41 files changed, 1824 insertions, 144 deletions

diff --git a/subprojects/language/src/main/java/tools/refinery/language/GenerateProblem.mwe2 b/subprojects/language/src/main/java/tools/refinery/language/GenerateProblem.mwe2
index 59eba8f7..46ac18fe 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/GenerateProblem.mwe2
+++ b/subprojects/language/src/main/java/tools/refinery/language/GenerateProblem.mwe2
@@ -51,7 +51,7 @@ Workflow {
 
                 language = StandardLanguage {
                         name = 'tools.refinery.language.Problem'
-                        fileExtensions = 'problem'
+                        fileExtensions = 'problem,refinery'
                         referencedResource = 'platform:/resource/tools.refinery.refinery-language-model/model/problem.genmodel'
                         serializer = {
                                 generateStub = false
diff --git a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
index 0fb96954..f0d6c38c 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
+++ b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
@@ -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
  */
@@ -9,13 +9,19 @@ import "http://www.eclipse.org/emf/2002/Ecore" as ecore
 import "https://refinery.tools/emf/2021/Problem"
 
 Problem:
-        ("problem" name=Identifier ".")?
+        (kind=ModuleKind name=QualifiedName? ".")?
         statements+=Statement*;
 
+enum ModuleKind:
+        PROBLEM="problem" | MODULE="module";
+
 Statement:
-        Assertion | ClassDeclaration | EnumDeclaration |
+        ImportStatement | Assertion | ClassDeclaration | EnumDeclaration |
         PredicateDefinition | /* FunctionDefinition | RuleDefinition | */
-        ScopeDeclaration | IndividualDeclaration;
+        ScopeDeclaration | NodeDeclaration;
+
+ImportStatement:
+        "import" importedModule=[Problem|QualifiedName] ("as" alias=ID)? ".";
 
 ClassDeclaration:
         abstract?="abstract"? "class"
@@ -252,23 +258,28 @@ RangeMultiplicity:
 ExactMultiplicity:
         exactValue=INT;
 
-IndividualDeclaration:
-        "indiv" nodes+=EnumLiteral ("," nodes+=EnumLiteral)* ".";
+NodeDeclaration:
+        ("declare" | "declare"? kind=NodeKind)
+        nodes+=EnumLiteral ("," nodes+=EnumLiteral)* ".";
+
+enum NodeKind:
+        ATOM="atom" | MULTI="multi";
 
 UpperBound returns ecore::EInt:
         INT | "*";
 
 QualifiedName hidden():
-        Identifier ("::" Identifier)*;
+        "::"? Identifier (QUALIFIED_NAME_SEPARATOR Identifier)*;
 
 NonContainmentQualifiedName hidden():
-        NonContainmentIdentifier ("::" Identifier)*;
+        (NonContainmentIdentifier | "::" Identifier) (QUALIFIED_NAME_SEPARATOR Identifier)*;
 
 Identifier:
         NonContainmentIdentifier | "contains" | "container";
 
 NonContainmentIdentifier:
-        ID | "contained" | "sum" | "prod" | "min" | "max";
+        ID | "atom" | "multi" | "contained" |
+        "sum" | "prod" | "min" | "max" | "problem" | "module";
 
 Real returns ecore::EDouble:
         EXPONENTIAL | INT "." (INT | EXPONENTIAL);
@@ -276,6 +287,9 @@ Real returns ecore::EDouble:
 terminal TRANSITIVE_CLOSURE:
         "synthetic:TRANSITIVE_CLOSURE";
 
+terminal QUALIFIED_NAME_SEPARATOR:
+        "synthetic::QUALIFIED_NAME_SEPARATOR";
+
 @Override
 terminal ID:
         ('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '_' | '0'..'9')*;
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 00dd3de3..f9a564b0 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.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
  */
@@ -14,7 +14,10 @@ import com.google.inject.name.Names;
 import org.eclipse.xtext.conversion.IValueConverterService;
 import org.eclipse.xtext.linking.ILinkingService;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.IQualifiedNameProvider;
+import org.eclipse.xtext.parser.IAstFactory;
 import org.eclipse.xtext.parser.IParser;
+import org.eclipse.xtext.parsetree.reconstr.ITransientValueService;
 import org.eclipse.xtext.resource.*;
 import org.eclipse.xtext.scoping.IGlobalScopeProvider;
 import org.eclipse.xtext.scoping.IScopeProvider;
@@ -26,16 +29,21 @@ import org.eclipse.xtext.validation.IResourceValidator;
 import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator;
 import tools.refinery.language.conversion.ProblemValueConverterService;
 import tools.refinery.language.linking.ProblemLinkingService;
+import tools.refinery.language.naming.ProblemDelegateQualifiedNameProvider;
 import tools.refinery.language.naming.ProblemQualifiedNameConverter;
+import tools.refinery.language.naming.ProblemQualifiedNameProvider;
+import tools.refinery.language.parser.ProblemEcoreElementFactory;
 import tools.refinery.language.parser.antlr.TokenSourceInjectingProblemParser;
-import tools.refinery.language.resource.ProblemDerivedStateComputer;
 import tools.refinery.language.resource.ProblemLocationInFileProvider;
 import tools.refinery.language.resource.ProblemResource;
+import tools.refinery.language.resource.ProblemResourceDescriptionManager;
 import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
+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;
 import tools.refinery.language.serializer.ProblemCrossReferenceSerializer;
+import tools.refinery.language.serializer.ProblemTransientValueService;
 import tools.refinery.language.validation.ProblemDiagnosticConverter;
 
 /**
@@ -50,10 +58,26 @@ public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
                 return TokenSourceInjectingProblemParser.class;
         }
 
+        @Override
+        public Class<? extends IAstFactory> bindIAstFactory() {
+                return ProblemEcoreElementFactory.class;
+        }
+
         public Class<? extends IQualifiedNameConverter> bindIQualifiedNameConverter() {
                 return ProblemQualifiedNameConverter.class;
         }
 
+        public void configureIQualifiedNameProviderDelegate(Binder binder) {
+                binder.bind(IQualifiedNameProvider.class)
+                                .annotatedWith(Names.named(ProblemQualifiedNameProvider.NAMED_DELEGATE))
+                                .to(ProblemDelegateQualifiedNameProvider.class);
+        }
+
+        @Override
+        public Class<? extends IQualifiedNameProvider> bindIQualifiedNameProvider() {
+                return ProblemQualifiedNameProvider.class;
+        }
+
         public Class<? extends IDefaultResourceDescriptionStrategy> bindIDefaultResourceDescriptionStrategy() {
                 return ProblemResourceDescriptionStrategy.class;
         }
@@ -87,7 +111,7 @@ public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
         // Method name follows Xtext convention.
         @SuppressWarnings("squid:S100")
         public Class<? extends IResourceDescription.Manager> bindIResourceDescription$Manager() {
-                return DerivedStateAwareResourceDescriptionManager.class;
+                return ProblemResourceDescriptionManager.class;
         }
 
         public Class<? extends IResourceValidator> bindIResourceValidator() {
@@ -104,6 +128,11 @@ public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
         }
 
         @Override
+        public Class<? extends ITransientValueService> bindITransientValueService() {
+                return ProblemTransientValueService.class;
+        }
+
+        @Override
         public Class<? extends ISemanticSequencer> bindISemanticSequencer() {
                 return PreferShortAssertionsProblemSemanticSequencer.class;
         }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java b/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java
index 0f3bd3ee..d6ece1ea 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java
@@ -23,7 +23,7 @@ public class ProblemFormatter extends AbstractJavaFormatter {
         protected void format(Problem problem, IFormattableDocument doc) {
                 doc.prepend(problem, this::noSpace);
                 var region = regionFor(problem);
-                doc.append(region.keyword("problem"), this::oneSpace);
+                doc.prepend(region.feature(ProblemPackage.Literals.NAMED_ELEMENT__NAME), this::oneSpace);
                 doc.prepend(region.keyword("."), this::noSpace);
                 appendNewLines(doc, region.keyword("."), this::twoNewLines);
                 for (var statement : problem.getStatements()) {
@@ -132,10 +132,11 @@ public class ProblemFormatter extends AbstractJavaFormatter {
                 }
         }
 
-        protected void format(IndividualDeclaration individualDeclaration, IFormattableDocument doc) {
-                surroundNewLines(doc, individualDeclaration, this::singleNewLine);
-                var region = regionFor(individualDeclaration);
-                doc.append(region.keyword("indiv"), this::oneSpace);
+        protected void format(NodeDeclaration nodeDeclaration, IFormattableDocument doc) {
+                surroundNewLines(doc, nodeDeclaration, this::singleNewLine);
+                var region = regionFor(nodeDeclaration);
+                doc.append(region.keyword("declare"), this::oneSpace);
+                doc.append(region.feature(ProblemPackage.Literals.NODE_DECLARATION__KIND), this::oneSpace);
                 formatList(region, ",", doc);
                 doc.prepend(region.keyword("."), this::noSpace);
         }
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..ce80504e
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/BuiltinLibrary.java
@@ -0,0 +1,27 @@
+/*
+ * 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;
+
+public class BuiltinLibrary extends ClasspathBasedLibrary {
+        public static final QualifiedName BUILTIN_LIBRARY_NAME = QualifiedName.create("builtin");
+        public static final URI BUILTIN_LIBRARY_URI = ClasspathBasedLibrary.getLibraryUri(
+                        BuiltinLibrary.class, BUILTIN_LIBRARY_NAME).orElseThrow(
+                        () -> new IllegalStateException("Builtin library was not found"));
+
+        public BuiltinLibrary() {
+                super(BUILTIN_LIBRARY_NAME);
+        }
+
+        @Override
+        public List<QualifiedName> getAutomaticImports() {
+                return List.of(BUILTIN_LIBRARY_NAME);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/library/ClasspathBasedLibrary.java b/subprojects/language/src/main/java/tools/refinery/language/library/ClasspathBasedLibrary.java
new file mode 100644
index 00000000..56bb8b96
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/ClasspathBasedLibrary.java
@@ -0,0 +1,92 @@
+/*
+ * 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.nio.file.Path;
+import java.util.*;
+
+public abstract class ClasspathBasedLibrary implements RefineryLibrary {
+        private final Class<?> context;
+        private final QualifiedName prefix;
+        private final URI rootUri;
+
+        protected ClasspathBasedLibrary(Class<?> context, QualifiedName prefix) {
+        this.context = context == null ? getClass() : context;
+        this.prefix = prefix;
+                var contextPath = this.context.getCanonicalName().replace('.', '/') + ".class";
+                var contextResource = this.context.getClassLoader().getResource(contextPath);
+                if (contextResource == null) {
+                        throw new IllegalStateException("Failed to find library context");
+                }
+                var contextUri = URI.createURI(contextResource.toString());
+                var segments = Arrays.copyOf(contextUri.segments(), contextUri.segmentCount() - 1);
+                rootUri = URI.createHierarchicalURI(contextUri.scheme(), contextUri.authority(), contextUri.device(),
+                                segments, null, null);
+        }
+
+        protected ClasspathBasedLibrary(QualifiedName prefix) {
+                this(null, prefix);
+        }
+
+        @Override
+        public Optional<URI> resolveQualifiedName(QualifiedName qualifiedName, List<Path> libraryPaths) {
+                if (qualifiedName.startsWith(prefix)) {
+                        return getLibraryUri(context, qualifiedName);
+                }
+                return Optional.empty();
+        }
+
+        @Override
+        public Optional<QualifiedName> getQualifiedName(URI uri, List<Path> libraryPaths) {
+                if (!uri.isHierarchical() ||
+                                !Objects.equals(rootUri.scheme(), uri.scheme()) ||
+                                !Objects.equals(rootUri.authority(), uri.authority()) ||
+                                !Objects.equals(rootUri.device(), uri.device()) ||
+                                rootUri.segmentCount() >= uri.segmentCount()) {
+                        return Optional.empty();
+                }
+                int rootSegmentCount = rootUri.segmentCount();
+                int uriSegmentCount = uri.segmentCount();
+                if (!uri.segment(uriSegmentCount - 1).endsWith(RefineryLibrary.FILE_NAME_SUFFIX)) {
+                        return Optional.empty();
+                }
+                var segments = new ArrayList<String>();
+                int i = 0;
+                while (i < rootSegmentCount) {
+                        if (!rootUri.segment(i).equals(uri.segment(i))) {
+                                return Optional.empty();
+                        }
+                        i++;
+                }
+                while (i < uriSegmentCount) {
+                        var segment = uri.segment(i);
+                        if (i == uriSegmentCount - 1) {
+                                segment = segment.substring(0, segment.length() - RefineryLibrary.FILE_NAME_SUFFIX.length());
+                        }
+                        segments.add(segment);
+                        i++;
+                }
+                var qualifiedName = QualifiedName.create(segments);
+                if (!qualifiedName.startsWith(prefix)) {
+                        return Optional.empty();
+                }
+                return Optional.of(qualifiedName);
+        }
+
+        public static Optional<URI> getLibraryUri(Class<?> context, QualifiedName qualifiedName) {
+                var packagePath = context.getPackageName().replace('.', '/');
+                var libraryPath = String.join("/", qualifiedName.getSegments());
+                var resourceName = "%s/%s%s".formatted(packagePath, libraryPath, RefineryLibrary.FILE_NAME_SUFFIX);
+                var resource = context.getClassLoader().getResource(resourceName);
+                if (resource == null) {
+                        return Optional.empty();
+                }
+                return Optional.of(URI.createURI(resource.toString()));
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/library/PathLibrary.java b/subprojects/language/src/main/java/tools/refinery/language/library/PathLibrary.java
new file mode 100644
index 00000000..8eaf8458
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/PathLibrary.java
@@ -0,0 +1,90 @@
+/*
+ * 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.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+public final class PathLibrary implements RefineryLibrary {
+        @Override
+        public Optional<URI> resolveQualifiedName(QualifiedName qualifiedName, List<Path> libraryPaths) {
+                if (libraryPaths.isEmpty()) {
+                        return Optional.empty();
+                }
+                if (qualifiedName.getSegmentCount() == 0) {
+                        return Optional.empty();
+                }
+                var relativePath = qualifiedNameToRelativePath(qualifiedName);
+                for (var library : libraryPaths) {
+                        var absoluteResolvedPath = library.resolve(relativePath).toAbsolutePath().normalize();
+                        if (absoluteResolvedPath.startsWith(library) && Files.exists(absoluteResolvedPath)) {
+                                var uri = URI.createFileURI(absoluteResolvedPath.toString());
+                                return Optional.of(uri);
+                        }
+                }
+                return Optional.empty();
+        }
+
+        private static Path qualifiedNameToRelativePath(QualifiedName qualifiedName) {
+                int segmentCount = qualifiedName.getSegmentCount();
+                String first = null;
+                var rest = new String[segmentCount - 1];
+                for (var i = 0; i < segmentCount; i++) {
+                        var segment = qualifiedName.getSegment(i);
+                        if (i == segmentCount - 1) {
+                                segment = segment + RefineryLibrary.FILE_NAME_SUFFIX;
+                        }
+                        if (i == 0) {
+                                first = segment;
+                        } else {
+                                rest[i - 1] = segment;
+                        }
+                }
+                if (first == null) {
+                        throw new AssertionError("Expected qualified name to have non-null segments");
+                }
+        return Path.of(first, rest);
+        }
+
+        @Override
+        public Optional<QualifiedName> getQualifiedName(URI uri, List<Path> libraryPaths) {
+                if (libraryPaths.isEmpty()) {
+                        return Optional.empty();
+                }
+                if (!uri.isFile() || !uri.hasAbsolutePath()) {
+                        return Optional.empty();
+                }
+                var path = Path.of(uri.toFileString());
+                for (var library : libraryPaths) {
+                        if (path.startsWith(library)) {
+                                return getRelativeQualifiedName(library, path);
+                        }
+                }
+                return Optional.empty();
+        }
+
+        private static Optional<QualifiedName> getRelativeQualifiedName(Path library, Path path) {
+                var relativePath = path.relativize(library);
+                var segments = new ArrayList<String>();
+                for (Path value : relativePath) {
+                        segments.add(value.toString());
+                }
+                int lastIndex = segments.size() - 1;
+                var lastSegment = segments.get(lastIndex);
+                if (!lastSegment.endsWith(FILE_NAME_SUFFIX)) {
+                        return Optional.empty();
+                }
+                lastSegment = lastSegment.substring(0, lastSegment.length() - RefineryLibrary.FILE_NAME_SUFFIX.length());
+                segments.set(lastIndex, lastSegment);
+                return Optional.of(QualifiedName.create(segments));
+        }
+}
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..2559749a
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibrary.java
@@ -0,0 +1,26 @@
+/*
+ * 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.utils.ProblemUtil;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Optional;
+
+public interface RefineryLibrary {
+        String FILE_NAME_SUFFIX = "." + ProblemUtil.MODULE_EXTENSION;
+
+        default List<QualifiedName> getAutomaticImports() {
+                return List.of();
+        }
+
+        Optional<URI> resolveQualifiedName(QualifiedName qualifiedName, List<Path> libraryPaths);
+
+        Optional<QualifiedName> getQualifiedName(URI uri, List<Path> libraryPaths);
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/naming/NamingUtil.java b/subprojects/language/src/main/java/tools/refinery/language/naming/NamingUtil.java
index 1647d4e7..feae5ebb 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/naming/NamingUtil.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/naming/NamingUtil.java
@@ -1,21 +1,24 @@
 /*
- * 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
  */
 package tools.refinery.language.naming;
 
+import org.eclipse.xtext.naming.QualifiedName;
+
 import java.util.regex.Pattern;
 
 public final class NamingUtil {
         private static final String SINGLETON_VARIABLE_PREFIX = "_";
-        
-        private static final Pattern ID_REGEX = Pattern.compile("[_a-zA-Z][_0-9a-zA-Z]*");
+        public static final QualifiedName ROOT_NAME = QualifiedName.create("");
+
+        private static final Pattern ID_REGEX = Pattern.compile("[_a-zA-Z]\\w*");
 
         private NamingUtil() {
                 throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
         }
-        
+
         public static boolean isNullOrEmpty(String name) {
                 return name == null || name.isEmpty();
         }
@@ -23,8 +26,28 @@ public final class NamingUtil {
         public static boolean isSingletonVariableName(String name) {
                 return name != null && name.startsWith(SINGLETON_VARIABLE_PREFIX);
         }
-        
+
+        // This method name only makes sense if it checks for the positive case.
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
         public static boolean isValidId(String name) {
                 return name != null && ID_REGEX.matcher(name).matches();
         }
+
+        public static boolean isFullyQualified(QualifiedName name) {
+                return name.startsWith(ROOT_NAME);
+        }
+
+        public static QualifiedName stripRootPrefix(QualifiedName name) {
+                if (name == null) {
+                        return null;
+                }
+                return isFullyQualified(name) ? name.skipFirst(ROOT_NAME.getSegmentCount()) : name;
+        }
+
+        public static QualifiedName addRootPrefix(QualifiedName name) {
+                if (name == null) {
+                        return null;
+                }
+                return isFullyQualified(name) ? name : ROOT_NAME.append(name);
+        }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemDelegateQualifiedNameProvider.java b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemDelegateQualifiedNameProvider.java
new file mode 100644
index 00000000..b3931401
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemDelegateQualifiedNameProvider.java
@@ -0,0 +1,44 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.naming;
+
+import com.google.inject.Inject;
+import org.eclipse.xtext.naming.DefaultDeclarativeQualifiedNameProvider;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.QualifiedName;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.scoping.imports.ImportAdapter;
+import tools.refinery.language.utils.ProblemUtil;
+
+public class ProblemDelegateQualifiedNameProvider extends DefaultDeclarativeQualifiedNameProvider {
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        protected QualifiedName qualifiedName(Problem problem) {
+                var qualifiedNameString = problem.getName();
+                if (qualifiedNameString != null) {
+                        return NamingUtil.stripRootPrefix(qualifiedNameConverter.toQualifiedName(qualifiedNameString));
+                }
+                if (!ProblemUtil.isModule(problem)) {
+                        return null;
+                }
+                var resource = problem.eResource();
+                if (resource == null) {
+                        return null;
+                }
+                var resourceUri = resource.getURI();
+                if (resourceUri == null) {
+                        return null;
+                }
+                var resourceSet = resource.getResourceSet();
+                if (resourceSet == null) {
+                        return null;
+                }
+                var adapter = ImportAdapter.getOrInstall(resourceSet);
+                // If a module has no explicitly specified name, return the qualified name it was resolved under.
+                return adapter.getQualifiedName(resourceUri);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameConverter.java b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameConverter.java
index 74b4e208..88a0fe9a 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameConverter.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameConverter.java
@@ -12,7 +12,7 @@ import com.google.inject.Singleton;
 @Singleton
 public class ProblemQualifiedNameConverter extends IQualifiedNameConverter.DefaultImpl {
         public static final String DELIMITER = "::";
-        
+
         @Override
         public String getDelimiter() {
                 return DELIMITER;
diff --git a/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameProvider.java b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameProvider.java
new file mode 100644
index 00000000..5b682058
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemQualifiedNameProvider.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.naming;
+
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.naming.IQualifiedNameProvider;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.util.IResourceScopeCache;
+import org.eclipse.xtext.util.Tuples;
+import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
+
+public class ProblemQualifiedNameProvider extends IQualifiedNameProvider.AbstractImpl {
+        private static final String PREFIX = "tools.refinery.language.naming.ProblemQualifiedNameProvider.";
+        public static final String NAMED_DELEGATE = PREFIX + "NAMED_DELEGATE";
+        public static final String CACHE_KEY = PREFIX + "CACHE_KEY";
+
+        @Inject
+        @Named(NAMED_DELEGATE)
+        private IQualifiedNameProvider delegate;
+
+        @Inject
+        private IResourceScopeCache cache = IResourceScopeCache.NullImpl.INSTANCE;
+
+        @Override
+        public QualifiedName getFullyQualifiedName(EObject obj) {
+                return cache.get(Tuples.pair(obj, CACHE_KEY), obj.eResource(), () -> computeFullyQualifiedName(obj));
+        }
+
+        public QualifiedName computeFullyQualifiedName(EObject obj) {
+                var qualifiedName = delegate.getFullyQualifiedName(obj);
+                if (qualifiedName != null && ProblemResourceDescriptionStrategy.shouldExport(obj)) {
+                        return NamingUtil.addRootPrefix(qualifiedName);
+                }
+                return qualifiedName;
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/parser/ProblemEcoreElementFactory.java b/subprojects/language/src/main/java/tools/refinery/language/parser/ProblemEcoreElementFactory.java
new file mode 100644
index 00000000..7d246117
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/parser/ProblemEcoreElementFactory.java
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.parser;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.conversion.ValueConverterException;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.parser.DefaultEcoreElementFactory;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.model.problem.ProblemPackage;
+
+public class ProblemEcoreElementFactory extends DefaultEcoreElementFactory {
+        @Override
+        public void set(
+                        EObject object, String feature, Object value, String ruleName, INode node) throws ValueConverterException {
+                super.set(object, feature, value, ruleName, node);
+                if (object instanceof Problem problem && ProblemPackage.Literals.PROBLEM__KIND.getName().equals(feature)) {
+                        problem.setExplicitKind(true);
+                }
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/IdentifierTokenProvider.java b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/IdentifierTokenProvider.java
index 306a86fc..0e19357f 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/IdentifierTokenProvider.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/IdentifierTokenProvider.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
  */
@@ -59,7 +59,7 @@ public class IdentifierTokenProvider {
 
                 private void createValueToTokenIdMap() {
                         var tokenIdToValueMap = tokenDefProvider.getTokenDefMap();
-                        valueToTokenIdMap = new HashMap<>(tokenIdToValueMap.size());
+                        valueToTokenIdMap = HashMap.newHashMap(tokenIdToValueMap.size());
                         for (var entry : tokenIdToValueMap.entrySet()) {
                                 valueToTokenIdMap.put(entry.getValue(), entry.getKey());
                         }
@@ -74,17 +74,16 @@ public class IdentifierTokenProvider {
                 }
 
                 private void collectIdentifierTokensFromElement(AbstractElement element) {
-                        if (element instanceof Alternatives alternatives) {
-                                for (var alternative : alternatives.getElements()) {
-                                        collectIdentifierTokensFromElement(alternative);
-                                }
-                        } else if (element instanceof RuleCall ruleCall) {
-                                collectIdentifierTokensFromRule(ruleCall.getRule());
-                        } else if (element instanceof Keyword keyword) {
-                                collectToken("'" + keyword.getValue() + "'");
-                        } else {
-                                throw new IllegalArgumentException("Unknown Xtext grammar element: " + element);
-                        }
+            switch (element) {
+                case Alternatives alternatives -> {
+                    for (var alternative : alternatives.getElements()) {
+                        collectIdentifierTokensFromElement(alternative);
+                    }
+                }
+                case RuleCall ruleCall -> collectIdentifierTokensFromRule(ruleCall.getRule());
+                case Keyword keyword -> collectToken("'" + keyword.getValue() + "'");
+                default -> throw new IllegalArgumentException("Unknown Xtext grammar element: " + element);
+            }
                 }
 
                 private void collectToken(String value) {
diff --git a/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/ProblemTokenSource.java b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/ProblemTokenSource.java
index 5b91a6cc..487e4ceb 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/ProblemTokenSource.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/parser/antlr/ProblemTokenSource.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
  */
@@ -28,6 +28,8 @@ public class ProblemTokenSource implements TokenSource {
 
         private boolean seenId;
 
+        private boolean lastVisible;
+
         public ProblemTokenSource(TokenSource delegate) {
                 this.delegate = delegate;
         }
@@ -47,18 +49,18 @@ public class ProblemTokenSource implements TokenSource {
 
         @Override
         public Token nextToken() {
-                if (!buffer.isEmpty()) {
-                        return buffer.removeFirst();
-                }
-                var token = delegate.nextToken();
-                if (isIdentifier(token)) {
-                        seenId = true;
-                } else if (seenId && isPlusOrTransitiveClosure(token)) {
-                        if (peekForTransitiveClosure()) {
+                boolean fromStream = buffer.isEmpty();
+                var token = fromStream ? delegate.nextToken() : buffer.removeFirst();
+                if (seenId) {
+                        if (fromStream && isPlusOrTransitiveClosure(token) && peekForTransitiveClosure()) {
                                 token.setType(InternalProblemParser.RULE_TRANSITIVE_CLOSURE);
+                        } else if (lastVisible && isQualifiedNameSeparator(token)) {
+                                token.setType(InternalProblemParser.RULE_QUALIFIED_NAME_SEPARATOR);
                         }
-                } else if (isVisibleToken(token)) {
-                        seenId = false;
+                }
+                lastVisible = isVisibleToken(token);
+                if (lastVisible) {
+                        seenId = isIdentifier(token);
                 }
                 return token;
         }
@@ -76,6 +78,10 @@ public class ProblemTokenSource implements TokenSource {
                 return token.getType() == InternalProblemParser.PlusSign;
         }
 
+        protected boolean isQualifiedNameSeparator(Token token) {
+                return token.getType() == InternalProblemParser.ColonColon;
+        }
+
         protected boolean isVisibleToken(Token token) {
                 int tokenId = token.getType();
                 return tokenId != InternalProblemParser.RULE_WS && tokenId != InternalProblemParser.RULE_SL_COMMENT &&
@@ -87,11 +93,16 @@ public class ProblemTokenSource implements TokenSource {
                 if (token.getType() != InternalProblemParser.LeftParenthesis) {
                         return false;
                 }
+                boolean allowFullyQualifiedName = true;
                 while (true) {
                         token = peekWithSkipWhitespace();
+                        if (allowFullyQualifiedName && token.getType() == InternalProblemParser.ColonColon) {
+                                token = peekWithSkipWhitespace();
+                        }
                         if (!isIdentifier(token)) {
                                 return false;
                         }
+                        allowFullyQualifiedName = false;
                         token = peekWithSkipWhitespace();
                         switch (token.getType()) {
                         case InternalProblemParser.Comma:
@@ -112,11 +123,6 @@ public class ProblemTokenSource implements TokenSource {
 
         protected Token peekToken() {
                 var token = delegate.nextToken();
-                if (isIdentifier(token)) {
-                        seenId = true;
-                } else if (isVisibleToken(token)) {
-                        seenId = false;
-                }
                 buffer.addLast(token);
                 return token;
         }
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..ccadb42d
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/LoadOnDemandResourceDescriptionProvider.java
@@ -0,0 +1,52 @@
+/*
+ * 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.emf.ecore.util.EcoreUtil;
+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;
+                }
+                // Force the {@code importedResource} to have all of its derived resource state installed.
+                EcoreUtil.resolveAll(importedResource);
+                return globalResourceDescriptionProvider.getResourceDescription(importedResource);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemLocationInFileProvider.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemLocationInFileProvider.java
index 29eaad84..c81431e5 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemLocationInFileProvider.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemLocationInFileProvider.java
@@ -25,10 +25,10 @@ public class ProblemLocationInFileProvider extends DefaultLocationInFileProvider
         }
 
         protected ITextRegion getNodeTextRegion(Node node, RegionDescription query) {
-                if (ProblemUtil.isIndividualNode(node)) {
+                if (ProblemUtil.isDeclaredNode(node)) {
                         return super.doGetTextRegion(node, query);
                 }
-                if (ProblemUtil.isNewNode(node)) {
+                if (ProblemUtil.isMultiNode(node)) {
                         EObject container = node.eContainer();
                         return doGetTextRegion(container, query);
                 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResource.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResource.java
index 43239ffe..440a238e 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResource.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResource.java
@@ -20,9 +20,12 @@ import org.eclipse.xtext.linking.impl.IllegalNodeException;
 import org.eclipse.xtext.linking.impl.XtextLinkingDiagnostic;
 import org.eclipse.xtext.linking.lazy.LazyLinkingResource;
 import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.parser.IParseResult;
 import org.eclipse.xtext.resource.DerivedStateAwareResource;
 import org.eclipse.xtext.util.Triple;
 import org.jetbrains.annotations.Nullable;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.utils.ProblemUtil;
 
 import java.util.Arrays;
 import java.util.List;
@@ -40,6 +43,30 @@ public class ProblemResource extends DerivedStateAwareResource {
          */
         private int cyclicLinkingDetectionCounter = 0;
 
+        @Override
+        protected void updateInternalState(IParseResult oldParseResult, IParseResult newParseResult) {
+                if (isNewRootElement(oldParseResult, newParseResult) &&
+                                newParseResult.getRootASTElement() instanceof Problem newRootProblem &&
+                                !newRootProblem.isExplicitKind()) {
+                        // Post-process the parsed model to set its URI-dependent module kind.
+                        // We can't set the default module kind in {@link tools.refinery.language.serializer
+                        // .ProblemTransientValueService}, because the {@link Problem} does not get added into the EMF resource
+                        // before parsing is fully completed.
+                        var defaultModuleKind = ProblemUtil.getDefaultModuleKind(getURI());
+                        newRootProblem.setKind(defaultModuleKind);
+                }
+                super.updateInternalState(oldParseResult, newParseResult);
+        }
+
+        private boolean isNewRootElement(IParseResult oldParseResult, IParseResult newParseResult) {
+                if (oldParseResult == null) {
+                        return true;
+                }
+                var oldRootAstElement = oldParseResult.getRootASTElement();
+                var newRootAstElement = newParseResult.getRootASTElement();
+                return oldRootAstElement != newRootAstElement;
+        }
+
         /**
          * Tries to resolve a reference and emits a diagnostic if the reference is unresolvable or ambiguous.
          * <p>
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescription.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescription.java
new file mode 100644
index 00000000..498a7c57
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescription.java
@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2011 itemis AG (http://www.itemis.eu) and others.
+ * Copyright (c) 2024 The Refinery Authors <https://refinery.tools/>
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.language.resource;
+
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.util.TreeIterator;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.xtext.resource.IDefaultResourceDescriptionStrategy;
+import org.eclipse.xtext.resource.IEObjectDescription;
+import org.eclipse.xtext.resource.impl.DefaultResourceDescription;
+import org.eclipse.xtext.resource.impl.EObjectDescriptionLookUp;
+import org.eclipse.xtext.util.IAcceptor;
+import tools.refinery.language.naming.NamingUtil;
+
+import java.io.IOException;
+import java.util.*;
+
+/**
+ * A resource description that takes {@link ProblemResourceDescriptionStrategy#SHADOWING_KEY} into account when
+ * describing EObjects.
+ * <p>
+ * Based on {@link DefaultResourceDescription}.
+ */
+public class ProblemResourceDescription extends DefaultResourceDescription {
+        private static final Logger log = Logger.getLogger(ProblemResourceDescription.class);
+
+        private final IDefaultResourceDescriptionStrategy strategy;
+
+        public ProblemResourceDescription(Resource resource, IDefaultResourceDescriptionStrategy strategy) {
+                super(resource, strategy);
+                this.strategy = strategy;
+        }
+
+        /**
+         * Based on {@link DefaultResourceDescription#computeExportedObjects()}.
+         *
+         * @return The computed exported objects, taking shadowing into account.
+         */
+        @Override
+        protected List<IEObjectDescription> computeExportedObjects() {
+                if (!getResource().isLoaded()) {
+                        try {
+                                getResource().load(null);
+                        } catch (IOException e) {
+                                log.error(e.getMessage(), e);
+                                return Collections.emptyList();
+                        }
+                }
+                final Map<ProblemResourceDescriptionStrategy.ShadowingKey, List<IEObjectDescription>> nameToDescriptionsMap =
+                                new LinkedHashMap<>();
+                IAcceptor<IEObjectDescription> acceptor = eObjectDescription -> {
+                        var key = ProblemResourceDescriptionStrategy.getShadowingKey(eObjectDescription);
+                        var descriptions = nameToDescriptionsMap.computeIfAbsent(key, ignored -> new ArrayList<>());
+                        descriptions.add(eObjectDescription);
+                };
+                TreeIterator<EObject> allProperContents = EcoreUtil.getAllProperContents(getResource(), false);
+                while (allProperContents.hasNext()) {
+                        EObject content = allProperContents.next();
+                        if (!strategy.createEObjectDescriptions(content, acceptor)) {
+                                allProperContents.prune();
+                        }
+                }
+                return omitShadowedNames(nameToDescriptionsMap);
+        }
+
+        private static List<IEObjectDescription> omitShadowedNames(
+                        Map<ProblemResourceDescriptionStrategy.ShadowingKey, List<IEObjectDescription>> nameToDescriptionsMap) {
+                final List<IEObjectDescription> exportedEObjects = new ArrayList<>();
+                for (var entry : nameToDescriptionsMap.entrySet()) {
+                        var descriptions = entry.getValue();
+                        if (NamingUtil.isFullyQualified(entry.getKey().name())) {
+                                exportedEObjects.addAll(descriptions);
+                        } else {
+                                boolean foundPreferred = false;
+                                for (var description : descriptions) {
+                                        if (ProblemResourceDescriptionStrategy.PREFERRED_NAME_TRUE.equals(
+                                                        description.getUserData(ProblemResourceDescriptionStrategy.PREFERRED_NAME))) {
+                                                exportedEObjects.add(description);
+                                                foundPreferred = true;
+                                        }
+                                }
+                                if (!foundPreferred) {
+                                        exportedEObjects.addAll(descriptions);
+                                }
+                        }
+                }
+                return exportedEObjects;
+        }
+
+        // Based on {@code DerivedStateAwareResourceDescriptionManager#createResourceDescription}.
+        @Override
+        protected EObjectDescriptionLookUp getLookUp() {
+                if (lookup == null) {
+                        lookup = new EObjectDescriptionLookUp(computeExportedObjects());
+                }
+                return lookup;
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionManager.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionManager.java
new file mode 100644
index 00000000..23ca139a
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionManager.java
@@ -0,0 +1,19 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.resource;
+
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.resource.DerivedStateAwareResourceDescriptionManager;
+import org.eclipse.xtext.resource.IDefaultResourceDescriptionStrategy;
+import org.eclipse.xtext.resource.IResourceDescription;
+
+public class ProblemResourceDescriptionManager extends DerivedStateAwareResourceDescriptionManager {
+        @Override
+        protected IResourceDescription createResourceDescription(Resource resource,
+                                                                                                                         IDefaultResourceDescriptionStrategy strategy) {
+                return new ProblemResourceDescription(resource, strategy);
+        }
+}
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 c04c7d09..3080a78e 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
@@ -8,44 +8,70 @@ package tools.refinery.language.resource;
 import com.google.common.collect.ImmutableMap;
 import com.google.inject.Inject;
 import com.google.inject.Singleton;
+import com.google.inject.name.Named;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.xtext.EcoreUtil2;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.IQualifiedNameProvider;
 import org.eclipse.xtext.naming.QualifiedName;
 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.naming.ProblemQualifiedNameProvider;
+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 {
         private static final String DATA_PREFIX = "tools.refinery.language.resource.ProblemResourceDescriptionStrategy.";
+
         public static final String ARITY = DATA_PREFIX + "ARITY";
         public static final String ERROR_PREDICATE = DATA_PREFIX + "ERROR_PREDICATE";
         public static final String ERROR_PREDICATE_TRUE = "true";
+        public static final String SHADOWING_KEY = DATA_PREFIX + "SHADOWING_KEY";
+        public static final String SHADOWING_KEY_PROBLEM = "problem";
+        public static final String SHADOWING_KEY_NODE = "node";
+        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 MODULE_KIND = DATA_PREFIX + "MODULE_KIND";
         public static final String COLOR_RELATION = DATA_PREFIX + "COLOR_RELATION";
         public static final String COLOR_RELATION_TRUE = "true";
 
         @Inject
         private IQualifiedNameConverter qualifiedNameConverter;
 
+        @Inject
+        @Named(ProblemQualifiedNameProvider.NAMED_DELEGATE)
+        private IQualifiedNameProvider delegateQualifiedNameProvider;
+
+        @Inject
+        private ImportCollector importCollector;
+
         @Override
         public boolean createEObjectDescriptions(EObject eObject, IAcceptor<IEObjectDescription> acceptor) {
                 if (!shouldExport(eObject)) {
                         return false;
                 }
+                var problem = EcoreUtil2.getContainerOfType(eObject, Problem.class);
+                var problemQualifiedName = getProblemQualifiedName(problem);
+                var userData = getUserData(eObject);
+                if (eObject.equals(problem)) {
+                        acceptEObjectDescription(eObject, problemQualifiedName, QualifiedName.EMPTY, userData, true, acceptor);
+                        return true;
+                }
                 var qualifiedName = getNameAsQualifiedName(eObject);
                 if (qualifiedName == null) {
                         return true;
                 }
-                var problem = EcoreUtil2.getContainerOfType(eObject, Problem.class);
-                var problemQualifiedName = getNameAsQualifiedName(problem);
-                var userData = getUserData(eObject);
                 QualifiedName lastQualifiedNameToExport = null;
                 if (shouldExportSimpleName(eObject)) {
                         lastQualifiedNameToExport = qualifiedName;
@@ -82,24 +108,46 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
                 if (NamingUtil.isNullOrEmpty(name)) {
                         return null;
                 }
-                return qualifiedNameConverter.toQualifiedName(name);
+                var qualifiedName = qualifiedNameConverter.toQualifiedName(name);
+                if (eObject instanceof Problem) {
+                        return NamingUtil.stripRootPrefix(qualifiedName);
+                }
+                return qualifiedName;
         }
 
-        protected boolean shouldExport(EObject eObject) {
+        protected QualifiedName getProblemQualifiedName(Problem problem) {
+                if (problem == null) {
+                        return QualifiedName.EMPTY;
+                }
+                var qualifiedName = delegateQualifiedNameProvider.getFullyQualifiedName(problem);
+        return qualifiedName == null ? QualifiedName.EMPTY : qualifiedName;
+    }
+
+        public static boolean shouldExport(EObject eObject) {
                 if (eObject instanceof Variable) {
                         // Variables are always private to the containing predicate definition.
                         return false;
                 }
                 if (eObject instanceof Node node) {
-                        // Only enum literals and new nodes are visible across problem files.
-                        return ProblemUtil.isIndividualNode(node) || ProblemUtil.isNewNode(node);
+                        return !ProblemUtil.isImplicitNode(node);
                 }
                 return true;
         }
 
         protected Map<String, String> getUserData(EObject eObject) {
                 var builder = ImmutableMap.<String, String>builder();
-                if (eObject instanceof Relation relation) {
+                if (eObject instanceof Problem 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);
+                        builder.put(MODULE_KIND, problem.getKind().getName());
+                } else if (eObject instanceof Node) {
+                        builder.put(SHADOWING_KEY, SHADOWING_KEY_NODE);
+                } else if (eObject instanceof Relation relation) {
+                        builder.put(SHADOWING_KEY, SHADOWING_KEY_RELATION);
                         int arity = ProblemUtil.getArity(relation);
                         builder.put(ARITY, Integer.toString(arity));
                 }
@@ -111,7 +159,7 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
 
         protected boolean shouldExportSimpleName(EObject eObject) {
                 if (eObject instanceof Node node) {
-                        return !ProblemUtil.isNewNode(node);
+                        return !ProblemUtil.isMultiNode(node);
                 }
                 if (eObject instanceof PredicateDefinition predicateDefinition) {
                         return !ProblemUtil.isInvalidMultiplicityConstraint(predicateDefinition);
@@ -125,20 +173,31 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
         }
 
         private void acceptEObjectDescription(EObject eObject, QualifiedName prefix, QualifiedName qualifiedName,
-                                                                                  Map<String, String> userData, boolean fullyQualified,
+                                                                                  Map<String, String> userData, boolean preferredName,
                                                                                   IAcceptor<IEObjectDescription> acceptor) {
                 var qualifiedNameWithPrefix = prefix == null ? qualifiedName : prefix.append(qualifiedName);
-                Map<String, String> userDataWithFullyQualified;
-                if (fullyQualified && shouldColorRelation(eObject)) {
-                        userDataWithFullyQualified = ImmutableMap.<String, String>builder()
+                var userDataWithPreference = userData;
+                if (preferredName) {
+                        userDataWithPreference = ImmutableMap.<String, String>builder()
                                         .putAll(userData)
-                                        .put(COLOR_RELATION, COLOR_RELATION_TRUE)
+                                        .put(PREFERRED_NAME, PREFERRED_NAME_TRUE)
                                         .build();
-                } else {
-                        userDataWithFullyQualified = userData;
                 }
-                var description = EObjectDescription.create(qualifiedNameWithPrefix, eObject, userDataWithFullyQualified);
+                var description = EObjectDescription.create(qualifiedNameWithPrefix, eObject, userDataWithPreference);
                 acceptor.accept(description);
+                if (!preferredName) {
+                        return;
+                }
+                var userDataWithFullyQualified = userDataWithPreference;
+                if (shouldColorRelation(eObject)) {
+                        userDataWithFullyQualified = ImmutableMap.<String, String>builder()
+                                        .putAll(userDataWithPreference)
+                                        .put(COLOR_RELATION, COLOR_RELATION_TRUE)
+                                        .build();
+                }
+                var rootQualifiedName = NamingUtil.addRootPrefix(qualifiedNameWithPrefix);
+                var rootDescription = EObjectDescription.create(rootQualifiedName, eObject, userDataWithFullyQualified);
+                acceptor.accept(rootDescription);
         }
 
         private boolean shouldColorRelation(EObject eObject) {
@@ -146,6 +205,12 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
                         return false;
                 }
                 return eObject instanceof ClassDeclaration || eObject instanceof EnumDeclaration;
+        }
+
+        public static ShadowingKey getShadowingKey(IEObjectDescription description) {
+                return new ShadowingKey(description.getName(), description.getUserData(SHADOWING_KEY));
+        }
 
+        public record ShadowingKey(QualifiedName name, String shadowingKey) {
         }
 }
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/NoFullyQualifiedNamesSelectable.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/NoFullyQualifiedNamesSelectable.java
new file mode 100644
index 00000000..f9405fc1
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/NoFullyQualifiedNamesSelectable.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.base.Predicate;
+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 tools.refinery.language.naming.NamingUtil;
+
+import java.util.List;
+
+public class NoFullyQualifiedNamesSelectable implements ISelectable {
+        private final ISelectable delegateSelectable;
+
+        // {@link com.google.common.base.Predicate} required by Xtext API.
+        @SuppressWarnings("squid:S4738")
+        private final Predicate<IEObjectDescription> filter =
+                        eObjectDescription -> !NamingUtil.isFullyQualified(eObjectDescription.getName());
+
+    public NoFullyQualifiedNamesSelectable(ISelectable delegateSelectable) {
+        this.delegateSelectable = delegateSelectable;
+    }
+
+    @Override
+        public boolean isEmpty() {
+                return delegateSelectable.isEmpty();
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjects() {
+                return filter(delegateSelectable.getExportedObjects());
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjects(EClass type, QualifiedName name, boolean ignoreCase) {
+                if (NamingUtil.isFullyQualified(name)) {
+                        return List.of();
+                }
+                return delegateSelectable.getExportedObjects(type, name, ignoreCase);
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjectsByType(EClass type) {
+                return filter(delegateSelectable.getExportedObjectsByType(type));
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjectsByObject(EObject object) {
+                return filter(delegateSelectable.getExportedObjectsByObject(object));
+        }
+
+        private Iterable<IEObjectDescription> filter(Iterable<IEObjectDescription> eObjectDescriptions) {
+                return Iterables.filter(eObjectDescriptions, filter);
+        }
+}
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
new file mode 100644
index 00000000..09fe4716
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/NormalizedSelectable.java
@@ -0,0 +1,109 @@
+/*
+ * 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 org.eclipse.xtext.resource.impl.AliasedEObjectDescription;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+class NormalizedSelectable implements ISelectable {
+        private final ISelectable delegateSelectable;
+        private final QualifiedName originalPrefix;
+        private final 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;
+        }
+
+        @Override
+        public boolean isEmpty() {
+                return delegateSelectable.isEmpty();
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjects() {
+                var delegateIterable = delegateSelectable.getExportedObjects();
+                return getAliasedElements(delegateIterable);
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjects(EClass type, QualifiedName name, boolean ignoreCase) {
+                boolean startsWith = ignoreCase ? name.startsWithIgnoreCase(normalizedPrefix) :
+                                name.startsWith(normalizedPrefix);
+                if (startsWith && name.getSegmentCount() > normalizedPrefix.getSegmentCount()) {
+                        var originalName = originalPrefix.append(name.skipFirst(normalizedPrefix.getSegmentCount()));
+                        return Iterables.transform(
+                                        delegateSelectable.getExportedObjects(type, originalName, ignoreCase),
+                                        description -> {
+                                                var normalizedName = normalizedPrefix.append(
+                                                                description.getName().skipFirst(originalPrefix.getSegmentCount()));
+                                                return new AliasedEObjectDescription(normalizedName, description);
+                                        });
+                }
+                return List.of();
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjectsByType(EClass type) {
+                var delegateIterable = delegateSelectable.getExportedObjectsByType(type);
+                return getAliasedElements(delegateIterable);
+        }
+
+        @Override
+        public Iterable<IEObjectDescription> getExportedObjectsByObject(EObject object) {
+                var delegateIterable = delegateSelectable.getExportedObjectsByObject(object);
+                return getAliasedElements(delegateIterable);
+        }
+
+        private Iterable<IEObjectDescription> getAliasedElements(Iterable<IEObjectDescription> delegateIterable) {
+                return () -> new Iterator<>() {
+                        private final Iterator<IEObjectDescription> delegateIterator = delegateIterable.iterator();
+                        private IEObjectDescription next = computeNext();
+
+                        @Override
+                        public boolean hasNext() {
+                                return next != null;
+                        }
+
+                        @Override
+                        public IEObjectDescription next() {
+                                if (!hasNext()) {
+                                        throw new NoSuchElementException();
+                                }
+                                var current = next;
+                                next = computeNext();
+                                return current;
+                        }
+
+                        private IEObjectDescription computeNext() {
+                                while (delegateIterator.hasNext()) {
+                                        var description = delegateIterator.next();
+                                        var qualifiedName = description.getName();
+                                        if (qualifiedName.startsWith(originalPrefix) &&
+                                                        qualifiedName.getSegmentCount() > originalPrefix.getSegmentCount()) {
+                                                var alias = normalizedPrefix.append(qualifiedName.skipFirst(originalPrefix.getSegmentCount()));
+                                                return new AliasedEObjectDescription(alias, description);
+                                        }
+                                }
+                                return null;
+                        }
+                };
+        }
+}
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 4d2dd772..65e80a7e 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
@@ -5,19 +5,85 @@
  */
 package tools.refinery.language.scoping;
 
-import java.util.LinkedHashSet;
-
-import org.eclipse.emf.common.util.URI;
+import com.google.common.base.Predicate;
+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.scoping.impl.ImportUriGlobalScopeProvider;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.resource.IEObjectDescription;
+import org.eclipse.xtext.resource.ISelectable;
+import org.eclipse.xtext.scoping.IScope;
+import org.eclipse.xtext.scoping.impl.AbstractGlobalScopeProvider;
+import org.eclipse.xtext.util.IResourceScopeCache;
+import tools.refinery.language.resource.LoadOnDemandResourceDescriptionProvider;
+import tools.refinery.language.scoping.imports.ImportCollector;
+import tools.refinery.language.scoping.imports.NamedImport;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class ProblemGlobalScopeProvider extends AbstractGlobalScopeProvider {
+        private static final String CACHE_KEY = "tools.refinery.language.scoping.ProblemGlobalScopeProvider.CACHE_KEY";
 
-import tools.refinery.language.utils.ProblemUtil;
+        @Inject
+        private ImportCollector importCollector;
 
-public class ProblemGlobalScopeProvider extends ImportUriGlobalScopeProvider {
+        @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);
+        }
+
+        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 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 ShadowingKeyAwareSelectableBasedScope.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 229960a0..0067bf94 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
@@ -1,47 +1,68 @@
 /*
- * 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
  */
 package tools.refinery.language.scoping;
 
-import java.util.List;
-
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
 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.IResourceDescriptions;
 import org.eclipse.xtext.resource.IResourceDescriptionsProvider;
 import org.eclipse.xtext.resource.ISelectable;
-import org.eclipse.xtext.scoping.impl.ImportNormalizer;
-import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider;
+import org.eclipse.xtext.scoping.IScope;
+import org.eclipse.xtext.scoping.impl.AbstractGlobalScopeDelegatingScopeProvider;
+import org.eclipse.xtext.util.IResourceScopeCache;
+import tools.refinery.language.naming.ProblemQualifiedNameProvider;
 
-import com.google.inject.Inject;
+public class ProblemLocalScopeProvider extends AbstractGlobalScopeDelegatingScopeProvider {
+        private static final String CACHE_KEY = "tools.refinery.language.scoping.ProblemLocalScopeProvider.CACHE_KEY";
 
-import tools.refinery.language.utils.ProblemUtil;
-
-public class ProblemLocalScopeProvider extends ImportedNamespaceAwareLocalScopeProvider {
-        private static final QualifiedName BUILTIN_LIBRARY_QUALIFIED_NAME = QualifiedName
-                        .create(ProblemUtil.BUILTIN_LIBRARY_NAME);
+        @Inject
+        @Named(ProblemQualifiedNameProvider.NAMED_DELEGATE)
+        private IQualifiedNameProvider delegateQualifiedNameProvider;
 
         @Inject
         private IResourceDescriptionsProvider resourceDescriptionsProvider;
 
-        @Override
-        protected List<ImportNormalizer> getImplicitImports(boolean ignoreCase) {
-                return List.of(doCreateImportNormalizer(BUILTIN_LIBRARY_QUALIFIED_NAME, true, ignoreCase));
-        }
+        @Inject
+        private IResourceScopeCache cache;
 
         @Override
-        protected List<ImportNormalizer> getImportedNamespaceResolvers(EObject context, boolean ignoreCase) {
-                return List.of();
+        public IScope getScope(EObject context, EReference reference) {
+                var resource = context.eResource();
+                if (resource == null) {
+                        return IScope.NULLSCOPE;
+                }
+                var globalScope = getGlobalScope(resource, reference);
+                var localImports = cache.get(CACHE_KEY, resource, () -> computeLocalImports(resource));
+                if (localImports == null) {
+                        return globalScope;
+                }
+                var type = reference.getEReferenceType();
+                boolean ignoreCase = isIgnoreCase(reference);
+                return ShadowingKeyAwareSelectableBasedScope.createScope(globalScope, localImports, type, ignoreCase);
         }
 
-        @Override
-        protected ISelectable internalGetAllDescriptions(Resource resource) {
+        protected ISelectable computeLocalImports(Resource resource) {
                 // Force the use of ProblemResourceDescriptionStrategy to include all QualifiedNames of objects.
-                IResourceDescriptions resourceDescriptions = resourceDescriptionsProvider
-                                .getResourceDescriptions(resource.getResourceSet());
-                return resourceDescriptions.getResourceDescription(resource.getURI());
+                var resourceDescriptions = resourceDescriptionsProvider.getResourceDescriptions(resource.getResourceSet());
+                var resourceDescription = resourceDescriptions.getResourceDescription(resource.getURI());
+                if (resourceDescription == null) {
+                        return null;
+                }
+                var rootElement = resource.getContents().getFirst();
+                if (rootElement == null) {
+                        return new NoFullyQualifiedNamesSelectable(resourceDescription);
+                }
+                var rootName = delegateQualifiedNameProvider.getFullyQualifiedName(rootElement);
+                if (rootName == null) {
+                        return new NoFullyQualifiedNamesSelectable(resourceDescription);
+                }
+                return new NormalizedSelectable(resourceDescription, rootName, QualifiedName.EMPTY);
         }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/ShadowingKeyAwareSelectableBasedScope.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/ShadowingKeyAwareSelectableBasedScope.java
new file mode 100644
index 00000000..cdef13ad
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/ShadowingKeyAwareSelectableBasedScope.java
@@ -0,0 +1,52 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.scoping;
+
+import com.google.common.base.Predicate;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.xtext.resource.IEObjectDescription;
+import org.eclipse.xtext.resource.ISelectable;
+import org.eclipse.xtext.scoping.IScope;
+import org.eclipse.xtext.scoping.impl.SelectableBasedScope;
+import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
+
+import java.util.Objects;
+
+public class ShadowingKeyAwareSelectableBasedScope extends SelectableBasedScope {
+        public static IScope createScope(IScope outer, ISelectable selectable, EClass type, boolean ignoreCase) {
+                return createScope(outer, selectable, null, type, ignoreCase);
+        }
+
+        // {@link com.google.common.base.Predicate} required by Xtext API.
+        @SuppressWarnings("squid:S4738")
+        public static IScope createScope(IScope outer, ISelectable selectable, Predicate<IEObjectDescription> filter,
+                                                                         EClass type, boolean ignoreCase) {
+                if (selectable == null || selectable.isEmpty())
+                        return outer;
+                return new ShadowingKeyAwareSelectableBasedScope(outer, selectable, filter, type, ignoreCase);
+        }
+
+        // {@link com.google.common.base.Predicate} required by Xtext API.
+        @SuppressWarnings("squid:S4738")
+        protected ShadowingKeyAwareSelectableBasedScope(IScope outer, ISelectable selectable,
+                                                                                                        Predicate<IEObjectDescription> filter,
+                                                                                                        EClass type, boolean ignoreCase) {
+                super(outer, selectable, filter, type, ignoreCase);
+        }
+
+        @Override
+        protected boolean isShadowed(IEObjectDescription input) {
+                var shadowingKey = input.getUserData(ProblemResourceDescriptionStrategy.SHADOWING_KEY);
+                var localElements = getLocalElementsByName(input.getName());
+                for (var localElement : localElements) {
+                        var localElementKey = localElement.getUserData(ProblemResourceDescriptionStrategy.SHADOWING_KEY);
+                        if (Objects.equals(shadowingKey, localElementKey)) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+}
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/ImportAdapter.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportAdapter.java
new file mode 100644
index 00000000..d7a5304f
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportAdapter.java
@@ -0,0 +1,205 @@
+/*
+ * 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.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.impl.AdapterImpl;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.xtext.naming.QualifiedName;
+import tools.refinery.language.library.RefineryLibrary;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.*;
+
+public class ImportAdapter extends AdapterImpl {
+        private static final Logger LOG = Logger.getLogger(ImportAdapter.class);
+        private static final List<RefineryLibrary> DEFAULT_LIBRARIES;
+        private static final List<Path> DEFAULT_PATHS;
+
+        static {
+                var serviceLoader = ServiceLoader.load(RefineryLibrary.class);
+                var defaultLibraries = new ArrayList<RefineryLibrary>();
+                for (var service : serviceLoader) {
+                        defaultLibraries.add(service);
+                }
+                DEFAULT_LIBRARIES = List.copyOf(defaultLibraries);
+                var pathEnv = System.getenv("REFINERY_LIBRARY_PATH");
+                if (pathEnv == null) {
+                        DEFAULT_PATHS = List.of();
+                } else {
+                        DEFAULT_PATHS = Splitter.on(File.pathSeparatorChar)
+                                        .splitToStream(pathEnv)
+                                        .map(pathString -> Path.of(pathString).toAbsolutePath().normalize())
+                                        .toList();
+                }
+        }
+
+        private final List<RefineryLibrary> libraries;
+        private final List<Path> libraryPaths;
+        private final Cache<QualifiedName, QualifiedName> failedResolutions =
+                        CacheBuilder.newBuilder().maximumSize(100).build();
+        private final Map<QualifiedName, URI> qualifiedNameToUriMap = new LinkedHashMap<>();
+        private final Map<URI, QualifiedName> uriToQualifiedNameMap = new LinkedHashMap<>();
+
+        private ImportAdapter(ResourceSet resourceSet) {
+                libraries = new ArrayList<>(DEFAULT_LIBRARIES);
+                libraryPaths = new ArrayList<>(DEFAULT_PATHS);
+                for (var resource : resourceSet.getResources()) {
+                        resourceAdded(resource);
+                }
+        }
+
+        @Override
+        public boolean isAdapterForType(Object type) {
+                return type == ImportAdapter.class;
+        }
+
+        public List<RefineryLibrary> getLibraries() {
+                return libraries;
+        }
+
+        public List<Path> getLibraryPaths() {
+                return libraryPaths;
+        }
+
+        public URI resolveQualifiedName(QualifiedName qualifiedName) {
+                var uri = getResolvedUri(qualifiedName);
+                if (uri != null) {
+                        return uri;
+                }
+                if (isFailed(qualifiedName)) {
+                        return null;
+                }
+                for (var library : libraries) {
+                        var result = library.resolveQualifiedName(qualifiedName, libraryPaths);
+                        if (result.isPresent()) {
+                                uri = result.get();
+                                markAsResolved(qualifiedName, uri);
+                                return uri;
+                        }
+                }
+                markAsUnresolved(qualifiedName);
+                return null;
+        }
+
+        private URI getResolvedUri(QualifiedName qualifiedName) {
+                return qualifiedNameToUriMap.get(qualifiedName);
+        }
+
+        private boolean isFailed(QualifiedName qualifiedName) {
+                return failedResolutions.getIfPresent(qualifiedName) != null;
+        }
+
+        private void markAsResolved(QualifiedName qualifiedName, URI uri) {
+                if (qualifiedNameToUriMap.put(qualifiedName, uri) != null) {
+                        throw new IllegalArgumentException("Already resolved " + qualifiedName);
+                }
+                // We don't need to signal an error here, because modules with multiple qualified names will lead to
+                // validation errors later.
+                uriToQualifiedNameMap.putIfAbsent(uri, qualifiedName);
+                failedResolutions.invalidate(qualifiedName);
+        }
+
+        private void markAsUnresolved(QualifiedName qualifiedName) {
+                failedResolutions.put(qualifiedName, qualifiedName);
+        }
+
+        public QualifiedName getQualifiedName(URI uri) {
+                return uriToQualifiedNameMap.get(uri);
+        }
+
+        @Override
+        public void notifyChanged(Notification msg) {
+                switch (msg.getEventType()) {
+                case Notification.ADD -> {
+                        if (msg.getNewValue() instanceof Resource resource) {
+                                resourceAdded(resource);
+                        }
+                }
+                case Notification.ADD_MANY -> {
+                        if (msg.getNewValue() instanceof List<?> list) {
+                                manyResourcesAdded(list);
+                        }
+                }
+                case Notification.REMOVE -> {
+                        if (msg.getOldValue() instanceof Resource resource) {
+                                resourceRemoved(resource);
+                        }
+                }
+                case Notification.REMOVE_MANY -> {
+                        if (msg.getOldValue() instanceof List<?> list) {
+                                manyResourcesRemoved(list);
+                        }
+                }
+                default -> {
+                        // Nothing to update.
+                }
+                }
+        }
+
+        private void manyResourcesAdded(List<?> list) {
+                for (var element : list) {
+                        if (element instanceof Resource resource) {
+                                resourceAdded(resource);
+                        }
+                }
+        }
+
+        private void manyResourcesRemoved(List<?> list) {
+                for (var element : list) {
+                        if (element instanceof Resource resource) {
+                                resourceRemoved(resource);
+                        }
+                }
+        }
+
+        private void resourceAdded(Resource resource) {
+                var uri = resource.getURI();
+                for (var library : libraries) {
+                        var result = library.getQualifiedName(uri, libraryPaths);
+                        if (result.isPresent()) {
+                                var qualifiedName = result.get();
+                                var previousQualifiedName = uriToQualifiedNameMap.putIfAbsent(uri, qualifiedName);
+                                if (previousQualifiedName == null) {
+                                        if (qualifiedNameToUriMap.put(qualifiedName, uri) != null) {
+                                                throw new IllegalArgumentException("Duplicate resource for" + qualifiedName);
+                                        }
+                                } else if (!previousQualifiedName.equals(qualifiedName)) {
+                                        LOG.warn("Expected %s to have qualified name %s, got %s instead".formatted(
+                                                        uri, previousQualifiedName, qualifiedName));
+                                }
+                        }
+                }
+        }
+
+        private void resourceRemoved(Resource resource) {
+                var qualifiedName = uriToQualifiedNameMap.remove(resource.getURI());
+                if (qualifiedName != null) {
+                        qualifiedNameToUriMap.remove(qualifiedName);
+                }
+        }
+
+        public static ImportAdapter getOrInstall(ResourceSet resourceSet) {
+                var adapter = getAdapter(resourceSet);
+                if (adapter == null) {
+                        adapter = new ImportAdapter(resourceSet);
+                        resourceSet.eAdapters().add(adapter);
+                }
+                return adapter;
+        }
+
+        private static ImportAdapter getAdapter(ResourceSet resourceSet) {
+        return (ImportAdapter) EcoreUtil.getAdapter(resourceSet.eAdapters(), ImportAdapter.class);
+        }
+}
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..ac5a92ba
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportCollector.java
@@ -0,0 +1,160 @@
+/*
+ * 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.EObject;
+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.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;
+                }
+                var resourceSet = resource.getResourceSet();
+                if (resourceSet == null) {
+                        return ImportCollection.EMPTY;
+                }
+                var adapter = ImportAdapter.getOrInstall(resourceSet);
+                var collection = new ImportCollection();
+                collectAutomaticImports(collection, adapter);
+                collectExplicitImports(problem, collection, adapter);
+                collection.remove(resource.getURI());
+                return collection;
+        }
+
+        private void collectAutomaticImports(ImportCollection importCollection, ImportAdapter adapter) {
+                for (var library : adapter.getLibraries()) {
+                        for (var qualifiedName : library.getAutomaticImports()) {
+                                var uri = adapter.resolveQualifiedName(qualifiedName);
+                                if (uri != null) {
+                                        importCollection.add(NamedImport.implicit(uri, qualifiedName));
+                                }
+                        }
+                }
+        }
+
+        private void collectExplicitImports(Problem problem, ImportCollection collection, ImportAdapter adapter) {
+                for (var statement : problem.getStatements()) {
+                        if (statement instanceof ImportStatement importStatement) {
+                                collectImportStatement(importStatement, collection, adapter);
+                        }
+                }
+        }
+
+        private void collectImportStatement(ImportStatement importStatement, ImportCollection collection,
+                                                                                ImportAdapter adapter) {
+                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));
+                var referredProblem = (EObject) importStatement.eGet(ProblemPackage.Literals.IMPORT_STATEMENT__IMPORTED_MODULE,
+                                false);
+                URI referencedUri = null;
+                if (referredProblem != null && !referredProblem.eIsProxy()) {
+                        var resource = referredProblem.eResource();
+                        if (resource != null) {
+                                referencedUri = resource.getURI();
+                        }
+                }
+                for (var node : nodes) {
+                        var qualifiedNameString = linkingHelper.getCrossRefNodeAsString(node, true);
+                        if (Strings.isNullOrEmpty(qualifiedNameString)) {
+                                continue;
+                        }
+                        var qualifiedName = NamingUtil.stripRootPrefix(
+                                        qualifiedNameConverter.toQualifiedName(qualifiedNameString));
+                        var uri = referencedUri == null ? adapter.resolveQualifiedName(qualifiedName) : referencedUri;
+                        if (uri != null) {
+                                collection.add(NamedImport.explicit(uri, qualifiedName, List.of(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 || importString.isEmpty()) {
+                        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/serializer/ProblemTransientValueService.java b/subprojects/language/src/main/java/tools/refinery/language/serializer/ProblemTransientValueService.java
new file mode 100644
index 00000000..269e1243
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/serializer/ProblemTransientValueService.java
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.serializer;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.xtext.parsetree.reconstr.impl.DefaultTransientValueService;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.model.problem.ProblemPackage;
+import tools.refinery.language.utils.ProblemUtil;
+
+public class ProblemTransientValueService extends DefaultTransientValueService {
+        @Override
+        public boolean isTransient(EObject owner, EStructuralFeature feature, int index) {
+                if (owner instanceof Problem problem && feature == ProblemPackage.Literals.PROBLEM__KIND) {
+                        return problem.getName() == null && problem.getKind() == ProblemUtil.getDefaultModuleKind(problem) &&
+                                        !problem.isExplicitKind();
+                }
+                return super.isTransient(owner, feature, index);
+        }
+}
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 7b6407e1..f70893e0 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
@@ -8,11 +8,12 @@ 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();
+        public static final String MODULE_EXTENSION = "refinery";
 
         private ProblemUtil() {
                 throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
@@ -22,7 +23,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;
@@ -54,14 +55,24 @@ public final class ProblemUtil {
                 return eObject instanceof PredicateDefinition predicateDefinition && predicateDefinition.isError();
         }
 
-        public static boolean isIndividualNode(Node node) {
+        public static boolean isAtomNode(Node node) {
                 var containingFeature = node.eContainingFeature();
-                return containingFeature == ProblemPackage.Literals.INDIVIDUAL_DECLARATION__NODES
-                                || containingFeature == ProblemPackage.Literals.ENUM_DECLARATION__LITERALS;
+                if (containingFeature == ProblemPackage.Literals.NODE_DECLARATION__NODES) {
+                        return ((NodeDeclaration) node.eContainer()).getKind() == NodeKind.ATOM;
+                }
+                return containingFeature == ProblemPackage.Literals.ENUM_DECLARATION__LITERALS;
+        }
+
+        public static boolean isMultiNode(Node node) {
+                var containingFeature = node.eContainingFeature();
+                if (containingFeature == ProblemPackage.Literals.NODE_DECLARATION__NODES) {
+                        return ((NodeDeclaration) node.eContainer()).getKind() == NodeKind.MULTI;
+                }
+                return containingFeature == ProblemPackage.Literals.CLASS_DECLARATION__NEW_NODE;
         }
 
-        public static boolean isNewNode(Node node) {
-                return node.eContainingFeature() == ProblemPackage.Literals.CLASS_DECLARATION__NEW_NODE;
+        public static boolean isDeclaredNode(Node node) {
+                return node.eContainingFeature() == ProblemPackage.Literals.NODE_DECLARATION__NODES;
         }
 
         public static boolean isInvalidMultiplicityConstraint(PredicateDefinition predicateDefinition) {
@@ -116,12 +127,24 @@ public final class ProblemUtil {
                 };
         }
 
-        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));
+        public static ModuleKind getDefaultModuleKind(Problem problem) {
+                var resource = problem.eResource();
+                if (resource == null) {
+                        return ModuleKind.PROBLEM;
                 }
-                return URI.createURI(libraryResource.toString());
+                return getDefaultModuleKind(resource.getURI());
+        }
+
+        public static ModuleKind getDefaultModuleKind(URI uri) {
+                return MODULE_EXTENSION.equals(uri.fileExtension()) ? ModuleKind.MODULE : ModuleKind.PROBLEM;
+        }
+
+        public static boolean isModule(Problem problem) {
+                return problem.getKind() == ModuleKind.MODULE;
+        }
+
+        public static boolean isInModule(EObject eObject) {
+                var problem = EcoreUtil2.getContainerOfType(eObject, Problem.class);
+                return problem != null && isModule(problem);
         }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java b/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java
index 8bda4b95..d9eb5fd3 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemValidator.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
  */
@@ -13,16 +13,16 @@ import com.google.inject.Inject;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EReference;
 import org.eclipse.xtext.EcoreUtil2;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
 import org.eclipse.xtext.validation.Check;
 import org.jetbrains.annotations.Nullable;
 import tools.refinery.language.model.problem.*;
+import tools.refinery.language.naming.NamingUtil;
+import tools.refinery.language.scoping.imports.ImportAdapter;
 import tools.refinery.language.utils.ProblemDesugarer;
 import tools.refinery.language.utils.ProblemUtil;
 
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.Set;
+import java.util.*;
 
 /**
  * This class contains custom validation rules.
@@ -33,6 +33,10 @@ import java.util.Set;
 public class ProblemValidator extends AbstractProblemValidator {
         private static final String ISSUE_PREFIX = "tools.refinery.language.validation.ProblemValidator.";
 
+        public static final String UNEXPECTED_MODULE_NAME_ISSUE = ISSUE_PREFIX + "UNEXPECTED_MODULE_NAME";
+
+        public static final String INVALID_IMPORT_ISSUE = ISSUE_PREFIX + "INVALID_IMPORT";
+
         public static final String SINGLETON_VARIABLE_ISSUE = ISSUE_PREFIX + "SINGLETON_VARIABLE";
 
         public static final String NODE_CONSTANT_ISSUE = ISSUE_PREFIX + "NODE_CONSTANT_ISSUE";
@@ -65,6 +69,61 @@ public class ProblemValidator extends AbstractProblemValidator {
         @Inject
         private ProblemDesugarer desugarer;
 
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        @Check
+        public void checkModuleName(Problem problem) {
+                var nameString = problem.getName();
+                if (nameString == null) {
+                        return;
+                }
+                var resource = problem.eResource();
+                if (resource == null) {
+                        return;
+                }
+                var resourceSet = resource.getResourceSet();
+                if (resourceSet == null) {
+                        return;
+                }
+                var adapter = ImportAdapter.getOrInstall(resourceSet);
+                var expectedName = adapter.getQualifiedName(resource.getURI());
+                if (expectedName == null) {
+                        return;
+                }
+                var name = NamingUtil.stripRootPrefix(qualifiedNameConverter.toQualifiedName(nameString));
+                if (!expectedName.equals(name)) {
+                        var moduleKindName = switch (problem.getKind()) {
+                                case PROBLEM -> "problem";
+                                case MODULE -> "module";
+                        };
+                        var message = "Expected %s to have name '%s', got '%s' instead.".formatted(
+                                        moduleKindName, qualifiedNameConverter.toString(expectedName),
+                                        qualifiedNameConverter.toString(name));
+                        error(message, problem, ProblemPackage.Literals.NAMED_ELEMENT__NAME, INSIGNIFICANT_INDEX,
+                                        UNEXPECTED_MODULE_NAME_ISSUE);
+                }
+        }
+
+        @Check
+        public void checkImportStatement(ImportStatement importStatement) {
+                var importedModule = importStatement.getImportedModule();
+                if (importedModule == null || importedModule.eIsProxy()) {
+                        return;
+                }
+                String message = null;
+                var problem = EcoreUtil2.getContainerOfType(importStatement, Problem.class);
+                if (importedModule == problem) {
+                        message = "A module cannot import itself.";
+                } else if (importedModule.getKind() != ModuleKind.MODULE) {
+                        message = "Only modules can be imported.";
+                }
+                if (message != null) {
+                        error(message, importStatement, ProblemPackage.Literals.IMPORT_STATEMENT__IMPORTED_MODULE,
+                                        INSIGNIFICANT_INDEX, INVALID_IMPORT_ISSUE);
+                }
+        }
+
         @Check
         public void checkSingletonVariable(VariableOrNodeExpr expr) {
                 var variableOrNode = expr.getVariableOrNode();
@@ -84,10 +143,10 @@ public class ProblemValidator extends AbstractProblemValidator {
         @Check
         public void checkNodeConstants(VariableOrNodeExpr expr) {
                 var variableOrNode = expr.getVariableOrNode();
-                if (variableOrNode instanceof Node node && !ProblemUtil.isIndividualNode(node)) {
+                if (variableOrNode instanceof Node node && !ProblemUtil.isAtomNode(node)) {
                         var name = node.getName();
-                        var message = ("Only individuals can be referenced in predicates. " +
-                                        "Mark '%s' as individual with the declaration 'indiv %s.'").formatted(name, name);
+                        var message = ("Only atoms can be referenced in predicates. " +
+                                        "Mark '%s' as an atom with the declaration 'atom %s.'").formatted(name, name);
                         error(message, expr, ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE,
                                         INSIGNIFICANT_INDEX, NODE_CONSTANT_ISSUE);
                 }
@@ -96,16 +155,16 @@ public class ProblemValidator extends AbstractProblemValidator {
         @Check
         public void checkUniqueDeclarations(Problem problem) {
                 var relations = new ArrayList<Relation>();
-                var individuals = new ArrayList<Node>();
+                var nodes = new ArrayList<Node>();
                 for (var statement : problem.getStatements()) {
                         if (statement instanceof Relation relation) {
                                 relations.add(relation);
-                        } else if (statement instanceof IndividualDeclaration individualDeclaration) {
-                                individuals.addAll(individualDeclaration.getNodes());
+                        } else if (statement instanceof NodeDeclaration nodeDeclaration) {
+                                nodes.addAll(nodeDeclaration.getNodes());
                         }
                 }
                 checkUniqueSimpleNames(relations);
-                checkUniqueSimpleNames(individuals);
+                checkUniqueSimpleNames(nodes);
         }
 
         @Check
@@ -302,6 +361,10 @@ public class ProblemValidator extends AbstractProblemValidator {
         @Check
         public void checkTypeScope(TypeScope typeScope) {
                 checkArity(typeScope, ProblemPackage.Literals.TYPE_SCOPE__TARGET_TYPE, 1);
+                if (typeScope.isIncrement() && ProblemUtil.isInModule(typeScope)) {
+                        acceptError("Incremental type scopes are not supported in modules", typeScope, null, 0,
+                                        INVALID_MULTIPLICITY_ISSUE);
+                }
         }
 
         private void checkArity(EObject eObject, EReference reference, int expectedArity) {
@@ -351,9 +414,9 @@ public class ProblemValidator extends AbstractProblemValidator {
         }
 
         private void checkExistsAssertion(Assertion assertion, LogicValue value) {
-                if (value == LogicValue.TRUE || value == LogicValue.UNKNOWN) {
-                        // {@code true} is always a valid value for {@code exists}, while {@code unknown} values may always be
-                        // refined to {@code true} if necessary (e.g., for individual nodes).
+                if (value == LogicValue.UNKNOWN) {
+                        // {@code unknown} values may always be refined to {@code true} of {@code false} if necessary (e.g., for
+                        // atom nodes or removed multi-objects).
                         return;
                 }
                 var arguments = assertion.getArguments();
@@ -361,9 +424,16 @@ public class ProblemValidator extends AbstractProblemValidator {
                         // We already report an error on invalid arity.
                         return;
                 }
-                var node = getNodeArgumentForMultiObjectAssertion(arguments.get(0));
-                if (node != null && !node.eIsProxy() && ProblemUtil.isIndividualNode(node)) {
-                        acceptError("Individual nodes must exist.", assertion, null, 0, UNSUPPORTED_ASSERTION_ISSUE);
+                var node = getNodeArgumentForMultiObjectAssertion(arguments.getFirst());
+                if (node == null || node.eIsProxy()) {
+                        return;
+                }
+                if (ProblemUtil.isAtomNode(node) && value != LogicValue.TRUE) {
+                        acceptError("Atom nodes must exist.", assertion, null, 0, UNSUPPORTED_ASSERTION_ISSUE);
+                }
+                if (ProblemUtil.isMultiNode(node) && value != LogicValue.FALSE && ProblemUtil.isInModule(node)) {
+                        acceptError("Multi-objects in modules cannot be required to exist.", assertion, null, 0,
+                                        UNSUPPORTED_ASSERTION_ISSUE);
                 }
         }
 
@@ -403,4 +473,23 @@ public class ProblemValidator extends AbstractProblemValidator {
                 }
                 throw new IllegalArgumentException("Unknown assertion argument: " + argument);
         }
+
+        @Check
+        private void checkImplicitNodeInModule(Assertion assertion) {
+                if (!ProblemUtil.isInModule(assertion)) {
+                        return;
+                }
+                for (var argument : assertion.getArguments()) {
+                        if (argument instanceof NodeAssertionArgument nodeAssertionArgument) {
+                                var node = nodeAssertionArgument.getNode();
+                                if (node != null && !node.eIsProxy() && ProblemUtil.isImplicitNode(node)) {
+                                        var name = node.getName();
+                                        var message = ("Implicit nodes are not allowed in modules. Explicitly declare '%s' as a node " +
+                                                        "with the declaration 'declare %s.'").formatted(name, name);
+                                        acceptError(message, nodeAssertionArgument, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE,
+                                                        0, UNSUPPORTED_ASSERTION_ISSUE);
+                                }
+                        }
+                }
+        }
 }