24 files changed, 779 insertions, 170 deletions

diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
index 7c649232..c2bca2a5 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
@@ -6,7 +6,9 @@
 package tools.refinery.language.semantics;
 
 import com.google.inject.Inject;
+import tools.refinery.language.library.BuiltinLibrary;
 import tools.refinery.language.model.problem.*;
+import tools.refinery.language.scoping.imports.ImportCollector;
 import tools.refinery.language.semantics.internal.MutableSeed;
 import tools.refinery.language.utils.BuiltinSymbols;
 import tools.refinery.language.utils.ProblemDesugarer;
@@ -51,8 +53,13 @@ public class ModelInitializer {
         @Inject
         private ProblemTraceImpl problemTrace;
 
+        @Inject
+        private ImportCollector importCollector;
+
         private Problem problem;
 
+        private final Set<Problem> importedProblems = new HashSet<>();
+
         private BuiltinSymbols builtinSymbols;
 
         private PartialRelation nodeRelation;
@@ -82,6 +89,8 @@ public class ModelInitializer {
                         throw new IllegalArgumentException("Problem was already set");
                 }
                 this.problem = problem;
+                loadImportedProblems();
+                importedProblems.add(problem);
                 problemTrace.setProblem(problem);
                 try {
                         builtinSymbols = desugarer.getBuiltinSymbols(problem).orElseThrow(() -> new IllegalArgumentException(
@@ -128,6 +137,29 @@ public class ModelInitializer {
                 }
         }
 
+        private void loadImportedProblems() {
+                var resource = problem.eResource();
+                if (resource == null) {
+                        return;
+                }
+                var resourceSet = resource.getResourceSet();
+                if (resourceSet == null) {
+                        return;
+                }
+                var importedUris = importCollector.getAllImports(resource).toUriSet();
+                for (var uri : importedUris) {
+                        if (BuiltinLibrary.BUILTIN_LIBRARY_URI.equals(uri)) {
+                                // We hard-code the behavior of the builtin library.
+                                continue;
+                        }
+                        var importedResource = resourceSet.getResource(uri, false);
+                        if (importedResource != null && !importedResource.getContents().isEmpty() &&
+                                        importedResource.getContents().getFirst() instanceof Problem importedProblem) {
+                                importedProblems.add(importedProblem);
+                        }
+                }
+        }
+
         public void configureStoreBuilder(ModelStoreBuilder storeBuilder) {
                 checkProblem();
                 try {
@@ -168,19 +200,21 @@ public class ModelInitializer {
         }
 
         private void collectNodes() {
-                for (var statement : problem.getStatements()) {
-                        if (statement instanceof NodeDeclaration nodeDeclaration) {
-                                for (var node : nodeDeclaration.getNodes()) {
-                                        collectNode(node);
-                                }
-                        } else if (statement instanceof ClassDeclaration classDeclaration) {
-                                var newNode = classDeclaration.getNewNode();
-                                if (newNode != null) {
-                                        collectNode(newNode);
-                                }
-                        } else if (statement instanceof EnumDeclaration enumDeclaration) {
-                                for (var literal : enumDeclaration.getLiterals()) {
-                                        collectNode(literal);
+                for (var importedProblem : importedProblems) {
+                        for (var statement : importedProblem.getStatements()) {
+                                if (statement instanceof NodeDeclaration nodeDeclaration) {
+                                        for (var node : nodeDeclaration.getNodes()) {
+                                                collectNode(node);
+                                        }
+                                } else if (statement instanceof ClassDeclaration classDeclaration) {
+                                        var newNode = classDeclaration.getNewNode();
+                                        if (newNode != null) {
+                                                collectNode(newNode);
+                                        }
+                                } else if (statement instanceof EnumDeclaration enumDeclaration) {
+                                        for (var literal : enumDeclaration.getLiterals()) {
+                                                collectNode(literal);
+                                        }
                                 }
                         }
                 }
@@ -194,13 +228,15 @@ public class ModelInitializer {
         }
 
         private void collectPartialSymbols() {
-                for (var statement : problem.getStatements()) {
-                        if (statement instanceof ClassDeclaration classDeclaration) {
-                                collectClassDeclarationSymbols(classDeclaration);
-                        } else if (statement instanceof EnumDeclaration enumDeclaration) {
-                                collectPartialRelation(enumDeclaration, 1, TruthValue.FALSE, TruthValue.FALSE);
-                        } else if (statement instanceof PredicateDefinition predicateDefinition) {
-                                collectPredicateDefinitionSymbol(predicateDefinition);
+                for (var importedProblem : importedProblems) {
+                        for (var statement : importedProblem.getStatements()) {
+                                if (statement instanceof ClassDeclaration classDeclaration) {
+                                        collectClassDeclarationSymbols(classDeclaration);
+                                } else if (statement instanceof EnumDeclaration enumDeclaration) {
+                                        collectPartialRelation(enumDeclaration, 1, TruthValue.FALSE, TruthValue.FALSE);
+                                } else if (statement instanceof PredicateDefinition predicateDefinition) {
+                                        collectPredicateDefinitionSymbol(predicateDefinition);
+                                }
                         }
                 }
         }
@@ -251,11 +287,13 @@ public class ModelInitializer {
         }
 
         private void collectMetamodel() {
-                for (var statement : problem.getStatements()) {
-                        if (statement instanceof ClassDeclaration classDeclaration) {
-                                collectClassDeclarationMetamodel(classDeclaration);
-                        } else if (statement instanceof EnumDeclaration enumDeclaration) {
-                                collectEnumMetamodel(enumDeclaration);
+                for (var importedProblem : importedProblems) {
+                        for (var statement : importedProblem.getStatements()) {
+                                if (statement instanceof ClassDeclaration classDeclaration) {
+                                        collectClassDeclarationMetamodel(classDeclaration);
+                                } else if (statement instanceof EnumDeclaration enumDeclaration) {
+                                        collectEnumMetamodel(enumDeclaration);
+                                }
                         }
                 }
         }
@@ -350,15 +388,17 @@ public class ModelInitializer {
         }
 
         private void collectAssertions() {
-                for (var statement : problem.getStatements()) {
-                        if (statement instanceof ClassDeclaration classDeclaration) {
-                                collectClassDeclarationAssertions(classDeclaration);
-                        } else if (statement instanceof EnumDeclaration enumDeclaration) {
-                                collectEnumAssertions(enumDeclaration);
-                        } else if (statement instanceof NodeDeclaration nodeDeclaration) {
-                                collectNodeDeclarationAssertions(nodeDeclaration);
-                        } else if (statement instanceof Assertion assertion) {
-                                collectAssertion(assertion);
+                for (var importedProblem : importedProblems) {
+                        for (var statement : importedProblem.getStatements()) {
+                                if (statement instanceof ClassDeclaration classDeclaration) {
+                                        collectClassDeclarationAssertions(classDeclaration);
+                                } else if (statement instanceof EnumDeclaration enumDeclaration) {
+                                        collectEnumAssertions(enumDeclaration);
+                                } else if (statement instanceof NodeDeclaration nodeDeclaration) {
+                                        collectNodeDeclarationAssertions(nodeDeclaration);
+                                } else if (statement instanceof Assertion assertion) {
+                                        collectAssertion(assertion);
+                                }
                         }
                 }
         }
@@ -429,9 +469,11 @@ public class ModelInitializer {
         }
 
         private void fixClassDeclarationAssertions() {
-                for (var statement : problem.getStatements()) {
-                        if (statement instanceof ClassDeclaration classDeclaration) {
-                                fixClassDeclarationAssertions(classDeclaration);
+                for (var importedProblem : importedProblems) {
+                        for (var statement : importedProblem.getStatements()) {
+                                if (statement instanceof ClassDeclaration classDeclaration) {
+                                        fixClassDeclarationAssertions(classDeclaration);
+                                }
                         }
                 }
         }
@@ -499,9 +541,11 @@ public class ModelInitializer {
         }
 
         private void collectPredicates(ModelStoreBuilder storeBuilder) {
-                for (var statement : problem.getStatements()) {
-                        if (statement instanceof PredicateDefinition predicateDefinition) {
-                                collectPredicateDefinitionTraced(predicateDefinition, storeBuilder);
+                for (var importedProblem : importedProblems) {
+                        for (var statement : importedProblem.getStatements()) {
+                                if (statement instanceof PredicateDefinition predicateDefinition) {
+                                        collectPredicateDefinitionTraced(predicateDefinition, storeBuilder);
+                                }
                         }
                 }
         }
@@ -601,51 +645,51 @@ public class ModelInitializer {
 
         private void toLiterals(Expr expr, Map<tools.refinery.language.model.problem.Variable, Variable> localScope,
                                                         List<Literal> literals) {
-        switch (expr) {
-            case LogicConstant logicConstant -> {
-                switch (logicConstant.getLogicValue()) {
-                    case TRUE -> literals.add(BooleanLiteral.TRUE);
-                    case FALSE -> literals.add(BooleanLiteral.FALSE);
-                    default -> throw new TracedException(logicConstant, "Unsupported literal");
-                }
-            }
-            case Atom atom -> {
-                var target = getPartialRelation(atom.getRelation());
-                var polarity = atom.isTransitiveClosure() ? CallPolarity.TRANSITIVE : CallPolarity.POSITIVE;
-                var argumentList = toArgumentList(atom.getArguments(), localScope, literals);
-                literals.add(target.call(polarity, argumentList));
-            }
-            case NegationExpr negationExpr -> {
-                var body = negationExpr.getBody();
-                if (!(body instanceof Atom atom)) {
-                    throw new TracedException(body, "Cannot negate literal");
-                }
-                var target = getPartialRelation(atom.getRelation());
-                Constraint constraint;
-                if (atom.isTransitiveClosure()) {
-                    constraint = Query.of(target.name() + "#transitive", (builder, p1, p2) -> builder.clause(
-                            target.callTransitive(p1, p2)
-                    )).getDnf();
-                } else {
-                    constraint = target;
-                }
-                var negatedScope = extendScope(localScope, negationExpr.getImplicitVariables());
-                var argumentList = toArgumentList(atom.getArguments(), negatedScope, literals);
-                literals.add(constraint.call(CallPolarity.NEGATIVE, argumentList));
-            }
-            case ComparisonExpr comparisonExpr -> {
-                var argumentList = toArgumentList(List.of(comparisonExpr.getLeft(), comparisonExpr.getRight()),
-                        localScope, literals);
-                boolean positive = switch (comparisonExpr.getOp()) {
-                    case EQ -> true;
-                    case NOT_EQ -> false;
-                    default -> throw new TracedException(
-                            comparisonExpr, "Unsupported operator");
-                };
-                literals.add(new EquivalenceLiteral(positive, argumentList.get(0), argumentList.get(1)));
-            }
-            default -> throw new TracedException(expr, "Unsupported literal");
-        }
+                switch (expr) {
+                case LogicConstant logicConstant -> {
+                        switch (logicConstant.getLogicValue()) {
+                        case TRUE -> literals.add(BooleanLiteral.TRUE);
+                        case FALSE -> literals.add(BooleanLiteral.FALSE);
+                        default -> throw new TracedException(logicConstant, "Unsupported literal");
+                        }
+                }
+                case Atom atom -> {
+                        var target = getPartialRelation(atom.getRelation());
+                        var polarity = atom.isTransitiveClosure() ? CallPolarity.TRANSITIVE : CallPolarity.POSITIVE;
+                        var argumentList = toArgumentList(atom.getArguments(), localScope, literals);
+                        literals.add(target.call(polarity, argumentList));
+                }
+                case NegationExpr negationExpr -> {
+                        var body = negationExpr.getBody();
+                        if (!(body instanceof Atom atom)) {
+                                throw new TracedException(body, "Cannot negate literal");
+                        }
+                        var target = getPartialRelation(atom.getRelation());
+                        Constraint constraint;
+                        if (atom.isTransitiveClosure()) {
+                                constraint = Query.of(target.name() + "#transitive", (builder, p1, p2) -> builder.clause(
+                                                target.callTransitive(p1, p2)
+                                )).getDnf();
+                        } else {
+                                constraint = target;
+                        }
+                        var negatedScope = extendScope(localScope, negationExpr.getImplicitVariables());
+                        var argumentList = toArgumentList(atom.getArguments(), negatedScope, literals);
+                        literals.add(constraint.call(CallPolarity.NEGATIVE, argumentList));
+                }
+                case ComparisonExpr comparisonExpr -> {
+                        var argumentList = toArgumentList(List.of(comparisonExpr.getLeft(), comparisonExpr.getRight()),
+                                        localScope, literals);
+                        boolean positive = switch (comparisonExpr.getOp()) {
+                                case EQ -> true;
+                                case NOT_EQ -> false;
+                                default -> throw new TracedException(
+                                                comparisonExpr, "Unsupported operator");
+                        };
+                        literals.add(new EquivalenceLiteral(positive, argumentList.get(0), argumentList.get(1)));
+                }
+                default -> throw new TracedException(expr, "Unsupported literal");
+                }
         }
 
         private List<Variable> toArgumentList(
@@ -680,13 +724,15 @@ public class ModelInitializer {
         }
 
         private void collectScopes() {
-                for (var statement : problem.getStatements()) {
-                        if (statement instanceof ScopeDeclaration scopeDeclaration) {
-                                for (var typeScope : scopeDeclaration.getTypeScopes()) {
-                                        if (typeScope.isIncrement()) {
-                                                collectTypeScopeIncrement(typeScope);
-                                        } else {
-                                                collectTypeScope(typeScope);
+                for (var importedProblem : importedProblems) {
+                        for (var statement : importedProblem.getStatements()) {
+                                if (statement instanceof ScopeDeclaration scopeDeclaration) {
+                                        for (var typeScope : scopeDeclaration.getTypeScopes()) {
+                                                if (typeScope.isIncrement()) {
+                                                        collectTypeScopeIncrement(typeScope);
+                                                } else {
+                                                        collectTypeScope(typeScope);
+                                                }
                                         }
                                 }
                         }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
index 19816da4..a846e265 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
@@ -32,6 +32,7 @@ import tools.refinery.language.naming.ProblemQualifiedNameConverter;
 import tools.refinery.language.naming.ProblemQualifiedNameProvider;
 import tools.refinery.language.parser.antlr.TokenSourceInjectingProblemParser;
 import tools.refinery.language.resource.*;
+import tools.refinery.language.resource.state.ProblemDerivedStateComputer;
 import tools.refinery.language.scoping.ProblemGlobalScopeProvider;
 import tools.refinery.language.scoping.ProblemLocalScopeProvider;
 import tools.refinery.language.serializer.PreferShortAssertionsProblemSemanticSequencer;
diff --git a/subprojects/language/src/main/java/tools/refinery/language/library/BuiltinLibrary.java b/subprojects/language/src/main/java/tools/refinery/language/library/BuiltinLibrary.java
new file mode 100644
index 00000000..0fb4cd2c
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/BuiltinLibrary.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.library;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.naming.QualifiedName;
+
+import java.util.List;
+import java.util.Optional;
+
+public class BuiltinLibrary implements RefineryLibrary {
+        public static final QualifiedName BUILTIN_LIBRARY_NAME = QualifiedName.create("builtin");
+        public static final URI BUILTIN_LIBRARY_URI = getLibraryUri(BUILTIN_LIBRARY_NAME).orElseThrow(
+                        () -> new IllegalStateException("Builtin library was not found"));
+
+        @Override
+        public List<QualifiedName> getAutomaticImports() {
+                return List.of(BUILTIN_LIBRARY_NAME);
+        }
+
+        @Override
+        public Optional<URI> resolveQualifiedName(QualifiedName qualifiedName) {
+                if (qualifiedName.startsWith(BUILTIN_LIBRARY_NAME)) {
+                        return getLibraryUri(qualifiedName);
+                }
+                return Optional.empty();
+        }
+
+        private static Optional<URI> getLibraryUri(QualifiedName qualifiedName) {
+                var libraryPath = String.join("/", qualifiedName.getSegments());
+                var libraryResource = BuiltinLibrary.class.getClassLoader()
+                                .getResource("tools/refinery/language/library/%s.refinery".formatted(libraryPath));
+                if (libraryResource == null) {
+                        return Optional.empty();
+                }
+                return Optional.of(URI.createURI(libraryResource.toString()));
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibraries.java b/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibraries.java
new file mode 100644
index 00000000..0efca199
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibraries.java
@@ -0,0 +1,54 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.library;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.naming.QualifiedName;
+import tools.refinery.language.scoping.imports.NamedImport;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Optional;
+import java.util.ServiceLoader;
+
+public final class RefineryLibraries {
+        private static final ServiceLoader<RefineryLibrary> SERVICE_LOADER = ServiceLoader.load(RefineryLibrary.class);
+        private static final List<NamedImport> AUTOMATIC_IMPORTS;
+
+        static {
+                var imports = new LinkedHashMap<QualifiedName, URI>();
+                for (var service : SERVICE_LOADER) {
+                        for (var qualifiedName : service.getAutomaticImports()) {
+                                var uri = service.resolveQualifiedName(qualifiedName).orElseThrow(
+                                                () -> new IllegalStateException("Automatic import %s was not found".formatted(qualifiedName)));
+                                if (imports.put(qualifiedName, uri) != null) {
+                                        throw new IllegalStateException("Duplicate automatic import " + qualifiedName);
+                                }
+                        }
+                }
+                AUTOMATIC_IMPORTS = imports.entrySet().stream()
+                                .map(entry -> NamedImport.implicit(entry.getValue(), entry.getKey()))
+                                .toList();
+        }
+
+        private RefineryLibraries() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static List<NamedImport> getAutomaticImports() {
+                return AUTOMATIC_IMPORTS;
+        }
+
+        public static Optional<URI> resolveQualifiedName(QualifiedName qualifiedName) {
+                for (var service : SERVICE_LOADER) {
+                        var result = service.resolveQualifiedName(qualifiedName);
+                        if (result.isPresent()) {
+                                return result;
+                        }
+                }
+                return Optional.empty();
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibrary.java b/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibrary.java
new file mode 100644
index 00000000..9db2900e
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibrary.java
@@ -0,0 +1,20 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.library;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.naming.QualifiedName;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface RefineryLibrary {
+        default List<QualifiedName> getAutomaticImports() {
+                return List.of();
+        }
+
+        Optional<URI> resolveQualifiedName(QualifiedName qualifiedName);
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/LoadOnDemandResourceDescriptionProvider.java b/subprojects/language/src/main/java/tools/refinery/language/resource/LoadOnDemandResourceDescriptionProvider.java
new file mode 100644
index 00000000..373a32f2
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/LoadOnDemandResourceDescriptionProvider.java
@@ -0,0 +1,49 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.resource;
+
+import com.google.inject.Inject;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.EcoreUtil2;
+import org.eclipse.xtext.resource.IResourceDescription;
+import org.eclipse.xtext.resource.IResourceDescriptions;
+import org.eclipse.xtext.resource.IResourceDescriptionsProvider;
+import org.eclipse.xtext.scoping.impl.GlobalResourceDescriptionProvider;
+
+public class LoadOnDemandResourceDescriptionProvider {
+        @Inject
+        private IResourceDescriptionsProvider resourceDescriptionsProvider;
+
+        @Inject
+        private GlobalResourceDescriptionProvider globalResourceDescriptionProvider;
+
+        private Resource context;
+        private IResourceDescriptions resourceDescriptions;
+
+        public void setContext(Resource context) {
+                if (this.context != null) {
+                        throw new IllegalStateException("Context was already set");
+                }
+                this.context = context;
+                resourceDescriptions = resourceDescriptionsProvider.getResourceDescriptions(context.getResourceSet());
+        }
+
+        public IResourceDescription getResourceDescription(URI uri) {
+                if (this.context == null) {
+                        throw new IllegalStateException("Context was not set");
+                }
+                var resourceDescription = resourceDescriptions.getResourceDescription(uri);
+                if (resourceDescription != null) {
+                        return resourceDescription;
+                }
+                var importedResource = EcoreUtil2.getResource(context, uri.toString());
+                if (importedResource == null) {
+                        return null;
+                }
+                return globalResourceDescriptionProvider.getResourceDescription(importedResource);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
index 76fd5852..a2ec7ed0 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
@@ -16,11 +16,13 @@ import org.eclipse.xtext.resource.EObjectDescription;
 import org.eclipse.xtext.resource.IEObjectDescription;
 import org.eclipse.xtext.resource.impl.DefaultResourceDescriptionStrategy;
 import org.eclipse.xtext.util.IAcceptor;
+import tools.refinery.language.scoping.imports.ImportCollector;
 import tools.refinery.language.model.problem.*;
 import tools.refinery.language.naming.NamingUtil;
 import tools.refinery.language.utils.ProblemUtil;
 
 import java.util.Map;
+import java.util.stream.Collectors;
 
 @Singleton
 public class ProblemResourceDescriptionStrategy extends DefaultResourceDescriptionStrategy {
@@ -35,12 +37,17 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
         public static final String SHADOWING_KEY_RELATION = "relation";
         public static final String PREFERRED_NAME = DATA_PREFIX + "PREFERRED_NAME";
         public static final String PREFERRED_NAME_TRUE = "true";
+        public static final String IMPORTS = DATA_PREFIX + "IMPORTS";
+        public static final String IMPORTS_SEPARATOR = "|";
         public static final String COLOR_RELATION = DATA_PREFIX + "COLOR_RELATION";
         public static final String COLOR_RELATION_TRUE = "true";
 
         @Inject
         private IQualifiedNameConverter qualifiedNameConverter;
 
+        @Inject
+        private ImportCollector importCollector;
+
         @Override
         public boolean createEObjectDescriptions(EObject eObject, IAcceptor<IEObjectDescription> acceptor) {
                 if (!shouldExport(eObject)) {
@@ -115,6 +122,11 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
                 var builder = ImmutableMap.<String, String>builder();
                 if (eObject instanceof Problem) {
                         builder.put(SHADOWING_KEY, SHADOWING_KEY_PROBLEM);
+                        var explicitImports = importCollector.getDirectImports(eObject.eResource());
+                        var importsString = explicitImports.toList().stream()
+                                        .map(importEntry -> importEntry.uri().toString())
+                                        .collect(Collectors.joining(IMPORTS_SEPARATOR));
+                        builder.put(IMPORTS, importsString);
                 } else if (eObject instanceof Node) {
                         builder.put(SHADOWING_KEY, SHADOWING_KEY_NODE);
                 } else if (eObject instanceof Relation relation) {
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/DerivedVariableComputer.java b/subprojects/language/src/main/java/tools/refinery/language/resource/state/DerivedVariableComputer.java
index 07c5da41..f0baf35f 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/DerivedVariableComputer.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/state/DerivedVariableComputer.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.resource;
+package tools.refinery.language.resource.state;
 
 import com.google.inject.Inject;
 import com.google.inject.Singleton;
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ImplicitVariableScope.java b/subprojects/language/src/main/java/tools/refinery/language/resource/state/ImplicitVariableScope.java
index e97c8287..e25887ad 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/ImplicitVariableScope.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/state/ImplicitVariableScope.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.resource;
+package tools.refinery.language.resource.state;
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.xtext.linking.impl.LinkingHelper;
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/NodeNameCollector.java b/subprojects/language/src/main/java/tools/refinery/language/resource/state/NodeNameCollector.java
index e5deca4d..de4a607c 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/NodeNameCollector.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/state/NodeNameCollector.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.resource;
+package tools.refinery.language.resource.state;
 
 import com.google.common.collect.ImmutableSet;
 import com.google.inject.Inject;
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemDerivedStateComputer.java b/subprojects/language/src/main/java/tools/refinery/language/resource/state/ProblemDerivedStateComputer.java
index 31eb55a6..d905aa9a 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemDerivedStateComputer.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/state/ProblemDerivedStateComputer.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.resource;
+package tools.refinery.language.resource.state;
 
 import com.google.inject.Inject;
 import com.google.inject.Provider;
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/CompositeSelectable.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/CompositeSelectable.java
new file mode 100644
index 00000000..0fddcaf9
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/CompositeSelectable.java
@@ -0,0 +1,62 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.scoping;
+
+import com.google.common.collect.Iterables;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.resource.IEObjectDescription;
+import org.eclipse.xtext.resource.ISelectable;
+
+import java.util.Collection;
+import java.util.List;
+
+class CompositeSelectable implements ISelectable {
+        private static final CompositeSelectable EMPTY = new CompositeSelectable(List.of());
+
+        private final List<? extends ISelectable> children;
+
+        private CompositeSelectable(List<? extends ISelectable> children) {
+
+                this.children = children;
+        }
+
+        @Override
+        public boolean isEmpty() {
+                return children.isEmpty();
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjects() {
+                return Iterables.concat(Iterables.transform(children, ISelectable::getExportedObjects));
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjects(EClass type, QualifiedName name, boolean ignoreCase) {
+                return Iterables.concat(Iterables.transform(children, child -> child.getExportedObjects(type, name,
+                                ignoreCase)));
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjectsByType(EClass type) {
+                return Iterables.concat(Iterables.transform(children, child -> child.getExportedObjectsByType(type)));
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjectsByObject(EObject object) {
+                return Iterables.concat(Iterables.transform(children, child -> child.getExportedObjectsByObject(object)));
+        }
+
+        public static ISelectable of(Collection<? extends ISelectable> children) {
+                var filteredChildren = children.stream().filter(selectable -> !selectable.isEmpty()).toList();
+                return switch (filteredChildren.size()) {
+                        case 0 -> EMPTY;
+                        case 1 -> filteredChildren.getFirst();
+                        default -> new CompositeSelectable(filteredChildren);
+                };
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/NormalizedSelectable.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/NormalizedSelectable.java
index 0c7828d8..09fe4716 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/scoping/NormalizedSelectable.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/NormalizedSelectable.java
@@ -12,18 +12,21 @@ import org.eclipse.xtext.naming.QualifiedName;
 import org.eclipse.xtext.resource.IEObjectDescription;
 import org.eclipse.xtext.resource.ISelectable;
 import org.eclipse.xtext.resource.impl.AliasedEObjectDescription;
-import org.jetbrains.annotations.NotNull;
 
 import java.util.Iterator;
+import java.util.List;
 import java.util.NoSuchElementException;
 
-public class NormalizedSelectable implements ISelectable {
+class NormalizedSelectable implements ISelectable {
         private final ISelectable delegateSelectable;
         private final QualifiedName originalPrefix;
         private final QualifiedName normalizedPrefix;
 
-        private NormalizedSelectable(ISelectable delegateSelectable, QualifiedName originalPrefix,
-                                                                 QualifiedName normalizedPrefix) {
+        public NormalizedSelectable(ISelectable delegateSelectable, QualifiedName originalPrefix,
+                                                                QualifiedName normalizedPrefix) {
+                if (originalPrefix.equals(QualifiedName.EMPTY)) {
+                        throw new IllegalArgumentException("Cannot normalize empty qualified name prefix");
+                }
                 this.delegateSelectable = delegateSelectable;
                 this.originalPrefix = originalPrefix;
                 this.normalizedPrefix = normalizedPrefix;
@@ -37,41 +40,36 @@ public class NormalizedSelectable implements ISelectable {
         @Override
         public Iterable<IEObjectDescription> getExportedObjects() {
                 var delegateIterable = delegateSelectable.getExportedObjects();
-                var aliasedIterable = getAliasedElements(delegateIterable);
-                return Iterables.concat(delegateIterable, aliasedIterable);
+                return getAliasedElements(delegateIterable);
         }
 
         @Override
         public Iterable<IEObjectDescription> getExportedObjects(EClass type, QualifiedName name, boolean ignoreCase) {
-                var delegateIterable = delegateSelectable.getExportedObjects(type, name, ignoreCase);
                 boolean startsWith = ignoreCase ? name.startsWithIgnoreCase(normalizedPrefix) :
                                 name.startsWith(normalizedPrefix);
                 if (startsWith && name.getSegmentCount() > normalizedPrefix.getSegmentCount()) {
                         var originalName = originalPrefix.append(name.skipFirst(normalizedPrefix.getSegmentCount()));
-                        var originalIterable = Iterables.transform(
+                        return Iterables.transform(
                                         delegateSelectable.getExportedObjects(type, originalName, ignoreCase),
                                         description -> {
                                                 var normalizedName = normalizedPrefix.append(
                                                                 description.getName().skipFirst(originalPrefix.getSegmentCount()));
                                                 return new AliasedEObjectDescription(normalizedName, description);
                                         });
-                        return Iterables.concat(originalIterable, delegateIterable);
                 }
-                return delegateIterable;
+                return List.of();
         }
 
         @Override
         public Iterable<IEObjectDescription> getExportedObjectsByType(EClass type) {
                 var delegateIterable = delegateSelectable.getExportedObjectsByType(type);
-                var aliasedIterable = getAliasedElements(delegateIterable);
-                return Iterables.concat(delegateIterable, aliasedIterable);
+                return getAliasedElements(delegateIterable);
         }
 
         @Override
         public Iterable<IEObjectDescription> getExportedObjectsByObject(EObject object) {
                 var delegateIterable = delegateSelectable.getExportedObjectsByObject(object);
-                var aliasedIterable = getAliasedElements(delegateIterable);
-                return Iterables.concat(delegateIterable, aliasedIterable);
+                return getAliasedElements(delegateIterable);
         }
 
         private Iterable<IEObjectDescription> getAliasedElements(Iterable<IEObjectDescription> delegateIterable) {
@@ -108,15 +106,4 @@ public class NormalizedSelectable implements ISelectable {
                         }
                 };
         }
-
-        public static ISelectable of(@NotNull ISelectable delegateSelectable, @NotNull QualifiedName originalPrefix,
-                                                                 @NotNull QualifiedName normalizedPrefix) {
-                if (originalPrefix.equals(normalizedPrefix)) {
-                        return delegateSelectable;
-                }
-                if (originalPrefix.equals(QualifiedName.EMPTY)) {
-                        throw new IllegalArgumentException("Cannot normalize empty qualified name prefix");
-                }
-                return new NormalizedSelectable(delegateSelectable, originalPrefix, normalizedPrefix);
-        }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemGlobalScopeProvider.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemGlobalScopeProvider.java
index 37a67c0c..dad4e5d0 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemGlobalScopeProvider.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemGlobalScopeProvider.java
@@ -6,35 +6,85 @@
 package tools.refinery.language.scoping;
 
 import com.google.common.base.Predicate;
-import org.eclipse.emf.common.util.URI;
+import com.google.inject.Inject;
+import com.google.inject.Provider;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.xtext.naming.QualifiedName;
 import org.eclipse.xtext.resource.IEObjectDescription;
-import org.eclipse.xtext.resource.IResourceDescriptions;
 import org.eclipse.xtext.resource.ISelectable;
 import org.eclipse.xtext.scoping.IScope;
-import org.eclipse.xtext.scoping.impl.ImportUriGlobalScopeProvider;
+import org.eclipse.xtext.scoping.impl.AbstractGlobalScopeProvider;
 import org.eclipse.xtext.scoping.impl.SelectableBasedScope;
-import tools.refinery.language.utils.ProblemUtil;
+import org.eclipse.xtext.util.IResourceScopeCache;
+import tools.refinery.language.scoping.imports.ImportCollector;
+import tools.refinery.language.resource.LoadOnDemandResourceDescriptionProvider;
+import tools.refinery.language.scoping.imports.NamedImport;
 
-import java.util.LinkedHashSet;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
 
-public class ProblemGlobalScopeProvider extends ImportUriGlobalScopeProvider {
+public class ProblemGlobalScopeProvider extends AbstractGlobalScopeProvider {
+        private static final String CACHE_KEY = "tools.refinery.language.scoping.ProblemGlobalScopeProvider.CACHE_KEY";
+
+        @Inject
+        private ImportCollector importCollector;
+
+        @Inject
+        private Provider<LoadOnDemandResourceDescriptionProvider> loadOnDemandProvider;
+
+        @Inject
+        private IResourceScopeCache cache;
+
+        // {@link com.google.common.base.Predicate} required by Xtext API.
+        @SuppressWarnings("squid:S4738")
         @Override
-        protected LinkedHashSet<URI> getImportedUris(Resource resource) {
-                LinkedHashSet<URI> importedUris = new LinkedHashSet<>();
-                importedUris.add(ProblemUtil.BUILTIN_LIBRARY_URI);
-                return importedUris;
+        protected IScope getScope(Resource resource, boolean ignoreCase, EClass type,
+                                                          Predicate<IEObjectDescription> filter) {
+                var loadedImports = cache.get(CACHE_KEY, resource, () -> computeLoadedImports(resource));
+                var qualifiedScope = createScope(IScope.NULLSCOPE, loadedImports.qualifiedImports(), type, filter, ignoreCase);
+                var implicitScope = createScope(qualifiedScope, loadedImports.implicitImports(), type, filter, ignoreCase);
+                return createScope(implicitScope, loadedImports.explicitImports(), type, filter, ignoreCase);
         }
 
-        @Override
-        protected IScope createLazyResourceScope(IScope parent, URI uri, IResourceDescriptions descriptions, EClass type,
-                                                                                         Predicate<IEObjectDescription> filter, boolean ignoreCase) {
-                ISelectable description = descriptions.getResourceDescription(uri);
-                if (description != null && ProblemUtil.BUILTIN_LIBRARY_URI.equals(uri)) {
-                        description = NormalizedSelectable.of(description, QualifiedName.create("builtin"), QualifiedName.EMPTY);
+        protected LoadedImports computeLoadedImports(Resource resource) {
+                var imports = importCollector.getAllImports(resource);
+                var loadOnDemand = loadOnDemandProvider.get();
+                loadOnDemand.setContext(resource);
+                var qualifiedImports = new ArrayList<ISelectable>();
+                var implicitImports = new ArrayList<ISelectable>();
+                var explicitImports = new ArrayList<ISelectable>();
+                for (var importEntry : imports.toList()) {
+                        var uri = importEntry.uri();
+                        var resourceDescription = loadOnDemand.getResourceDescription(uri);
+                        if (resourceDescription == null) {
+                                continue;
+                        }
+                        qualifiedImports.add(resourceDescription);
+                        if (importEntry instanceof NamedImport namedImport) {
+                                var qualifiedName = namedImport.qualifiedName();
+                                if (namedImport.alsoImplicit()) {
+                                        implicitImports.add(new NormalizedSelectable(resourceDescription, qualifiedName,
+                                                        QualifiedName.EMPTY));
+                                }
+                                for (var alias : namedImport.aliases()) {
+                                        explicitImports.add(new NormalizedSelectable(resourceDescription, qualifiedName, alias));
+                                }
+                        }
                 }
-                return SelectableBasedScope.createScope(parent, description, filter, type, ignoreCase);
+                return new LoadedImports(qualifiedImports, implicitImports, explicitImports);
+        }
+
+        // {@link com.google.common.base.Predicate} required by Xtext API.
+        @SuppressWarnings("squid:S4738")
+        protected IScope createScope(IScope parent, Collection<? extends ISelectable> children, EClass type,
+                                                                 Predicate<IEObjectDescription> filter, boolean ignoreCase) {
+                var selectable = CompositeSelectable.of(children);
+                return SelectableBasedScope.createScope(parent, selectable, filter, type, ignoreCase);
+        }
+
+        protected record LoadedImports(List<ISelectable> qualifiedImports, List<ISelectable> implicitImports,
+                                                                   List<ISelectable> explicitImports) {
         }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemLocalScopeProvider.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemLocalScopeProvider.java
index 9be32636..3e00b87e 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemLocalScopeProvider.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemLocalScopeProvider.java
@@ -6,37 +6,72 @@
 package tools.refinery.language.scoping;
 
 import com.google.inject.Inject;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.xtext.naming.IQualifiedNameProvider;
 import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.resource.IResourceDescription;
 import org.eclipse.xtext.resource.IResourceDescriptionsProvider;
 import org.eclipse.xtext.resource.ISelectable;
-import org.eclipse.xtext.scoping.impl.SimpleLocalScopeProvider;
+import org.eclipse.xtext.scoping.IScope;
+import org.eclipse.xtext.scoping.impl.AbstractGlobalScopeDelegatingScopeProvider;
+import org.eclipse.xtext.scoping.impl.SelectableBasedScope;
+import org.eclipse.xtext.util.IResourceScopeCache;
 import tools.refinery.language.naming.NamingUtil;
 
-public class ProblemLocalScopeProvider extends SimpleLocalScopeProvider {
+public class ProblemLocalScopeProvider extends AbstractGlobalScopeDelegatingScopeProvider {
+        private static final String CACHE_KEY = "tools.refinery.language.scoping.ProblemLocalScopeProvider.CACHE_KEY";
+
         @Inject
         private IQualifiedNameProvider qualifiedNameProvider;
 
         @Inject
         private IResourceDescriptionsProvider resourceDescriptionsProvider;
 
+        @Inject
+        private IResourceScopeCache cache;
+
         @Override
-        protected ISelectable getAllDescriptions(Resource resource) {
+        public IScope getScope(EObject context, EReference reference) {
+                var resource = context.eResource();
+                if (resource == null) {
+                        return IScope.NULLSCOPE;
+                }
+                var localImports = cache.get(CACHE_KEY, resource, () -> computeLocalImports(resource));
+                if (localImports.resourceDescription() == null) {
+                        return IScope.NULLSCOPE;
+                }
+                var globalScope = getGlobalScope(resource, reference);
+                var type = reference.getEReferenceType();
+                boolean ignoreCase = isIgnoreCase(reference);
+                var scope = SelectableBasedScope.createScope(globalScope, localImports.resourceDescription(), type,
+                ignoreCase);
+                if (localImports.normalizedSelectable() == null) {
+                        return scope;
+                }
+                return SelectableBasedScope.createScope(scope, localImports.normalizedSelectable(), type, ignoreCase);
+        }
+
+        protected LocalImports computeLocalImports(Resource resource) {
                 // Force the use of ProblemResourceDescriptionStrategy to include all QualifiedNames of objects.
-                var resourceDescriptions = resourceDescriptionsProvider
-                                .getResourceDescriptions(resource.getResourceSet());
+                var resourceDescriptions = resourceDescriptionsProvider.getResourceDescriptions(resource.getResourceSet());
                 var resourceDescription = resourceDescriptions.getResourceDescription(resource.getURI());
-                if (resourceDescription != null && !resource.getContents().isEmpty()) {
-                        var rootElement = resource.getContents().getFirst();
-                        if (rootElement != null) {
-                                var rootName = NamingUtil.stripRootPrefix(qualifiedNameProvider.getFullyQualifiedName(rootElement));
-                                if (rootName == null) {
-                                        return resourceDescription;
-                                }
-                                return NormalizedSelectable.of(resourceDescription, rootName, QualifiedName.EMPTY);
-                        }
+                if (resourceDescription == null) {
+                        return new LocalImports(null, null);
+                }
+                var rootElement = resource.getContents().getFirst();
+                if (rootElement == null) {
+                        return new LocalImports(resourceDescription, null);
                 }
-                return resourceDescription;
+                var rootName = NamingUtil.stripRootPrefix(qualifiedNameProvider.getFullyQualifiedName(rootElement));
+                if (rootName == null) {
+                        return new LocalImports(resourceDescription, null);
+                }
+                var normalizedSelectable = new NormalizedSelectable(resourceDescription, rootName, QualifiedName.EMPTY);
+                return new LocalImports(resourceDescription, normalizedSelectable);
+        }
+
+        protected record LocalImports(IResourceDescription resourceDescription, ISelectable normalizedSelectable) {
         }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/Import.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/Import.java
new file mode 100644
index 00000000..e2f0d3d8
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/Import.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.scoping.imports;
+
+import org.eclipse.emf.common.util.URI;
+
+public sealed interface Import permits NamedImport, TransitiveImport {
+        URI uri();
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportCollection.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportCollection.java
new file mode 100644
index 00000000..63171138
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportCollection.java
@@ -0,0 +1,76 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.scoping.imports;
+
+import org.eclipse.emf.common.util.URI;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+
+public class ImportCollection {
+        public static ImportCollection EMPTY = new ImportCollection() {
+                @Override
+                public void add(Import importEntry) {
+                        throw new UnsupportedOperationException("Read-only collection");
+                }
+
+                @Override
+                public void remove(URI uri) {
+                        throw new UnsupportedOperationException("Read-only collection");
+                }
+        };
+
+        private final Map<URI, Import> importMap = new HashMap<>();
+
+        public void add(Import importEntry) {
+                importMap.compute(importEntry.uri(), (ignored, originalEntry) -> merge(originalEntry, importEntry));
+        }
+
+        public void addAll(Iterable<? extends Import> imports) {
+                imports.forEach(this::add);
+        }
+
+        public void remove(URI uri) {
+                importMap.remove(uri);
+        }
+
+        public List<Import> toList() {
+                return List.copyOf(importMap.values());
+        }
+
+        public Set<URI> toUriSet() {
+                return new LinkedHashSet<>(importMap.keySet());
+        }
+
+        @NotNull
+        private static Import merge(@Nullable Import left, @NotNull Import right) {
+                if (left == null) {
+                        return right;
+                }
+                if (!left.uri().equals(right.uri())) {
+                        throw new IllegalArgumentException("Expected URIs '%s' and '%s' to be equal".formatted(
+                                        left.uri(), right.uri()));
+                }
+                return switch (left) {
+                        case TransitiveImport transitiveLeft ->
+                                        right instanceof TransitiveImport ? left : merge(right, transitiveLeft);
+                        case NamedImport namedLeft -> switch (right) {
+                                case TransitiveImport ignored -> namedLeft;
+                                case NamedImport namedRight -> {
+                                        if (!namedLeft.qualifiedName().equals(namedRight.qualifiedName())) {
+                                                throw new IllegalArgumentException("Expected qualified names '%s' and '%s' to be equal"
+                                                                .formatted(namedLeft.qualifiedName(), namedRight.qualifiedName()));
+                                        }
+                                        var mergedAliases = new LinkedHashSet<>(namedLeft.aliases());
+                                        mergedAliases.addAll(namedRight.aliases());
+                                        yield new NamedImport(namedLeft.uri(), namedLeft.qualifiedName(),
+                                                        List.copyOf(mergedAliases), namedLeft.alsoImplicit() || namedRight.alsoImplicit());
+                                }
+                        };
+                };
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportCollector.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportCollector.java
new file mode 100644
index 00000000..cea99f0a
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportCollector.java
@@ -0,0 +1,138 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.scoping.imports;
+
+import com.google.common.base.Splitter;
+import com.google.common.base.Strings;
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import com.google.inject.Singleton;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.linking.impl.LinkingHelper;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
+import org.eclipse.xtext.resource.IEObjectDescription;
+import org.eclipse.xtext.util.IResourceScopeCache;
+import tools.refinery.language.library.RefineryLibraries;
+import tools.refinery.language.model.problem.ImportStatement;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.model.problem.ProblemPackage;
+import tools.refinery.language.naming.NamingUtil;
+import tools.refinery.language.resource.LoadOnDemandResourceDescriptionProvider;
+import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
+
+import java.util.*;
+
+@Singleton
+public class ImportCollector {
+        private static final String PREFIX = "tools.refinery.language.imports.";
+        private static final String DIRECT_IMPORTS_KEY = PREFIX + "DIRECT_IMPORTS";
+        private static final String ALL_IMPORTS_KEY = PREFIX + "ALL_IMPORTS";
+
+        @Inject
+        private IResourceScopeCache cache;
+
+        @Inject
+        private LinkingHelper linkingHelper;
+
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        @Inject
+        private Provider<LoadOnDemandResourceDescriptionProvider> loadOnDemandProvider;
+
+        public ImportCollection getDirectImports(Resource resource) {
+                return cache.get(DIRECT_IMPORTS_KEY, resource, () -> this.computeDirectImports(resource));
+        }
+
+        protected ImportCollection computeDirectImports(Resource resource) {
+                if (resource.getContents().isEmpty() || !(resource.getContents().getFirst() instanceof Problem problem)) {
+                        return ImportCollection.EMPTY;
+                }
+                Map<QualifiedName, Set<QualifiedName>> aliasesMap = new LinkedHashMap<>();
+                for (var statement : problem.getStatements()) {
+                        if (statement instanceof ImportStatement importStatement) {
+                                collectImportStatement(importStatement, aliasesMap);
+                        }
+                }
+                var collection = new ImportCollection();
+                collection.addAll(RefineryLibraries.getAutomaticImports());
+                for (var entry : aliasesMap.entrySet()) {
+                        var qualifiedName = entry.getKey();
+                        RefineryLibraries.resolveQualifiedName(qualifiedName).ifPresent(uri -> {
+                                if (!uri.equals(resource.getURI())) {
+                                        var aliases = entry.getValue();
+                                        collection.add(NamedImport.explicit(uri, qualifiedName, List.copyOf(aliases)));
+                                }
+                        });
+                }
+                collection.remove(resource.getURI());
+                return collection;
+        }
+
+        private void collectImportStatement(ImportStatement importStatement, Map<QualifiedName, Set<QualifiedName>> aliasesMap) {
+                var nodes = NodeModelUtils.findNodesForFeature(importStatement,
+                                ProblemPackage.Literals.IMPORT_STATEMENT__IMPORTED_MODULE);
+                var aliasString = importStatement.getAlias();
+                var alias = Strings.isNullOrEmpty(aliasString) ? QualifiedName.EMPTY :
+                                NamingUtil.stripRootPrefix(qualifiedNameConverter.toQualifiedName(aliasString));
+                for (var node : nodes) {
+                        var qualifiedNameString = linkingHelper.getCrossRefNodeAsString(node, true);
+                        if (Strings.isNullOrEmpty(qualifiedNameString)) {
+                                continue;
+                        }
+                        var qualifiedName = NamingUtil.stripRootPrefix(
+                                        qualifiedNameConverter.toQualifiedName(qualifiedNameString));
+                        var aliases = aliasesMap.computeIfAbsent(qualifiedName, ignored -> new LinkedHashSet<>());
+                        aliases.add(alias);
+                }
+        }
+
+        public ImportCollection getAllImports(Resource resource) {
+                return cache.get(ALL_IMPORTS_KEY, resource, () -> this.computeAllImports(resource));
+        }
+
+        protected ImportCollection computeAllImports(Resource resource) {
+                var collection = new ImportCollection();
+                collection.addAll(getDirectImports(resource).toList());
+                var loadOnDemand = loadOnDemandProvider.get();
+                loadOnDemand.setContext(resource);
+                var seen = new HashSet<URI>();
+                seen.add(resource.getURI());
+                var queue = new ArrayDeque<>(collection.toUriSet());
+                while (!queue.isEmpty()) {
+                        var uri = queue.removeFirst();
+                        seen.add(uri);
+                        collection.add(new TransitiveImport(uri));
+                        var resourceDescription = loadOnDemand.getResourceDescription(uri);
+                        if (resourceDescription == null) {
+                                continue;
+                        }
+                        var problemDescriptions = resourceDescription.getExportedObjectsByType(ProblemPackage.Literals.PROBLEM);
+                        for (var eObjectDescription : problemDescriptions) {
+                                for (var importedUri : getImports(eObjectDescription)) {
+                                        if (!seen.contains(importedUri)) {
+                                                queue.addLast(importedUri);
+                                        }
+                                }
+                        }
+                }
+                collection.remove(resource.getURI());
+                return collection;
+        }
+
+        protected List<URI> getImports(IEObjectDescription eObjectDescription) {
+                var importString = eObjectDescription.getUserData(ProblemResourceDescriptionStrategy.IMPORTS);
+                if (importString == null) {
+                        return List.of();
+                }
+                return Splitter.on(ProblemResourceDescriptionStrategy.IMPORTS_SEPARATOR).splitToStream(importString)
+                                .map(URI::createURI)
+                                .toList();
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/NamedImport.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/NamedImport.java
new file mode 100644
index 00000000..f5e89605
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/NamedImport.java
@@ -0,0 +1,22 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.scoping.imports;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.naming.QualifiedName;
+
+import java.util.List;
+
+public record NamedImport(URI uri, QualifiedName qualifiedName, List<QualifiedName> aliases,
+                                                  boolean alsoImplicit) implements Import {
+        public static NamedImport implicit(URI uri, QualifiedName qualifiedName) {
+                return new NamedImport(uri, qualifiedName, List.of(), true);
+        }
+
+        public static NamedImport explicit(URI uri, QualifiedName qualifiedName, List<QualifiedName> aliases) {
+                return new NamedImport(uri, qualifiedName, aliases, false);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/TransitiveImport.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/TransitiveImport.java
new file mode 100644
index 00000000..6f5ceaa6
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/TransitiveImport.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.scoping.imports;
+
+import org.eclipse.emf.common.util.URI;
+
+public record TransitiveImport(URI uri) implements Import {
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemDesugarer.java b/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemDesugarer.java
index 59e26561..0bd1e50b 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemDesugarer.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemDesugarer.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -11,6 +11,7 @@ import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.xtext.util.IResourceScopeCache;
 import org.eclipse.xtext.util.Tuples;
+import tools.refinery.language.library.BuiltinLibrary;
 import tools.refinery.language.model.problem.*;
 
 import java.util.*;
@@ -27,8 +28,8 @@ public class ProblemDesugarer {
 
         private Optional<Problem> doGetBuiltinProblem(Resource resource) {
                 return Optional.ofNullable(resource).map(Resource::getResourceSet)
-                                .map(resourceSet -> resourceSet.getResource(ProblemUtil.BUILTIN_LIBRARY_URI, true))
-                                .map(Resource::getContents).filter(contents -> !contents.isEmpty()).map(contents -> contents.get(0))
+                                .map(resourceSet -> resourceSet.getResource(BuiltinLibrary.BUILTIN_LIBRARY_URI, true))
+                                .map(Resource::getContents).filter(contents -> !contents.isEmpty()).map(List::getFirst)
                                 .filter(Problem.class::isInstance).map(Problem.class::cast);
         }
 
diff --git a/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemUtil.java b/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemUtil.java
index 0f87c04b..23ff55e7 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemUtil.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemUtil.java
@@ -5,16 +5,13 @@
  */
 package tools.refinery.language.utils;
 
-import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.xtext.EcoreUtil2;
+import tools.refinery.language.library.BuiltinLibrary;
 import tools.refinery.language.model.problem.*;
 
 public final class ProblemUtil {
-        public static final String BUILTIN_LIBRARY_NAME = "builtin";
-        public static final URI BUILTIN_LIBRARY_URI = getLibraryUri();
-
         private ProblemUtil() {
                 throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
         }
@@ -23,7 +20,7 @@ public final class ProblemUtil {
                 if (eObject != null) {
                         var eResource = eObject.eResource();
                         if (eResource != null) {
-                                return ProblemUtil.BUILTIN_LIBRARY_URI.equals(eResource.getURI());
+                                return BuiltinLibrary.BUILTIN_LIBRARY_URI.equals(eResource.getURI());
                         }
                 }
                 return false;
@@ -131,13 +128,4 @@ public final class ProblemUtil {
                 var problem = EcoreUtil2.getContainerOfType(eObject, Problem.class);
                 return problem != null && problem.getKind() == ModuleKind.MODULE;
         }
-
-        private static URI getLibraryUri() {
-                var libraryResource = ProblemUtil.class.getClassLoader()
-                                .getResource("tools/refinery/language/%s.problem".formatted(BUILTIN_LIBRARY_NAME));
-                if (libraryResource == null) {
-                        throw new AssertionError("Library '%s' was not found".formatted(BUILTIN_LIBRARY_NAME));
-                }
-                return URI.createURI(libraryResource.toString());
-        }
 }
diff --git a/subprojects/language/src/main/resources/META-INF/services/tools.refinery.language.library.RefineryLibrary b/subprojects/language/src/main/resources/META-INF/services/tools.refinery.language.library.RefineryLibrary
new file mode 100644
index 00000000..bb7e369d
--- /dev/null
+++ b/subprojects/language/src/main/resources/META-INF/services/tools.refinery.language.library.RefineryLibrary
@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+#
+# SPDX-License-Identifier: EPL-2.0
+tools.refinery.language.library.BuiltinLibrary
diff --git a/subprojects/language/src/main/resources/tools/refinery/language/builtin.problem b/subprojects/language/src/main/resources/tools/refinery/language/library/builtin.refinery
index 022c3167..022c3167 100644
--- a/subprojects/language/src/main/resources/tools/refinery/language/builtin.problem
+++ b/subprojects/language/src/main/resources/tools/refinery/language/library/builtin.refinery