feat: filesystem-level import resolution

Modules without an explicitly declared name get a name automatically inferred
from their path.

17 files changed, 556 insertions, 112 deletions

diff --git a/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java b/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java
index b33fce23..b1c28df0 100644
--- a/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java
+++ b/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java
@@ -58,6 +58,7 @@ public class GenerateCommand {
         }
 
         public void run() throws IOException {
+                loader.extraPath(System.getProperty("user.dir"));
                 var problem = isStandardStream(inputPath) ? loader.loadStream(System.in) : loader.loadFile(inputPath);
                 problem = loader.loadScopeConstraints(problem, scopes, overrideScopes);
                 var generator = generatorFactory.createGenerator(problem);
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java b/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java
index 20ea8132..e44dddc0 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -19,6 +19,7 @@ import org.eclipse.xtext.validation.IResourceValidator;
 import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.model.problem.Relation;
 import tools.refinery.language.model.problem.ScopeDeclaration;
+import tools.refinery.language.scoping.imports.ImportAdapter;
 import tools.refinery.store.util.CancellationToken;
 
 import java.io.ByteArrayOutputStream;
@@ -26,11 +27,14 @@ import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 
+// This class is used as a fluent builder.
+@SuppressWarnings("UnusedReturnValue")
 public class ProblemLoader {
         private String fileExtension;
 
@@ -45,6 +49,8 @@ public class ProblemLoader {
 
         private CancellationToken cancellationToken = CancellationToken.NONE;
 
+        private final List<Path> extraPaths = new ArrayList<>();
+
         @Inject
         public void setFileExtensionProvider(FileExtensionProvider fileExtensionProvider) {
                 this.fileExtension = fileExtensionProvider.getPrimaryFileExtension();
@@ -55,6 +61,15 @@ public class ProblemLoader {
                 return this;
         }
 
+        public ProblemLoader extraPath(String path) {
+                return extraPath(Path.of(path));
+        }
+
+        public ProblemLoader extraPath(Path path) {
+                extraPaths.add(path.toAbsolutePath().normalize());
+                return this;
+        }
+
         public Problem loadString(String problemString, URI uri) throws IOException {
                 try (var stream = new LazyStringInputStream(problemString)) {
                         return loadStream(stream, uri);
@@ -66,8 +81,8 @@ public class ProblemLoader {
         }
 
         public Problem loadStream(InputStream inputStream, URI uri) throws IOException {
-                var resourceSet = resourceSetProvider.get();
-                var resourceUri = uri == null ? URI.createFileURI("__synthetic." + fileExtension) : uri;
+                var resourceSet = createResourceSet();
+                var resourceUri = uri == null ? URI.createURI("__synthetic." + fileExtension) : uri;
                 var resource = resourceFactory.createResource(resourceUri);
                 resourceSet.getResources().add(resource);
                 resource.load(inputStream, Map.of());
@@ -87,13 +102,20 @@ public class ProblemLoader {
         }
 
         public Problem loadUri(URI uri) throws IOException {
-                var resourceSet = resourceSetProvider.get();
+                var resourceSet = createResourceSet();
                 var resource = resourceFactory.createResource(uri);
                 resourceSet.getResources().add(resource);
                 resource.load(Map.of());
                 return loadResource(resource);
         }
 
+        private XtextResourceSet createResourceSet() {
+                var resourceSet = resourceSetProvider.get();
+                var adapter = ImportAdapter.getOrInstall(resourceSet);
+                adapter.getLibraryPaths().addAll(0, extraPaths);
+                return resourceSet;
+        }
+
         public Problem loadResource(Resource resource) {
                 var issues = resourceValidator.validate(resource, CheckMode.ALL, () -> {
                         cancellationToken.checkCancelled();
diff --git a/subprojects/language-model/problem.aird b/subprojects/language-model/problem.aird
index 6583d364..ed3a4b58 100644
--- a/subprojects/language-model/problem.aird
+++ b/subprojects/language-model/problem.aird
@@ -7,7 +7,7 @@
     <semanticResources>build/resources/main/model/problem.genmodel</semanticResources>
     <ownedViews xmi:type="viewpoint:DView" uid="_CsAAYKA4EeuqkpDnuik1sg">
       <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']"/>
-      <ownedRepresentationDescriptors xmi:type="viewpoint:DRepresentationDescriptor" uid="_CsYa4KA4EeuqkpDnuik1sg" name="declarations" repPath="#_CsUwgKA4EeuqkpDnuik1sg" changeId="1706722245720">
+      <ownedRepresentationDescriptors xmi:type="viewpoint:DRepresentationDescriptor" uid="_CsYa4KA4EeuqkpDnuik1sg" name="declarations" repPath="#_CsUwgKA4EeuqkpDnuik1sg" changeId="1707054359028">
         <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
         <target xmi:type="ecore:EPackage" href="src/main/resources/model/problem.ecore#/"/>
       </ownedRepresentationDescriptors>
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java
index 1bd419d8..dad867b8 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java
@@ -19,6 +19,7 @@ import org.eclipse.xtext.resource.XtextResource;
 import org.eclipse.xtext.resource.XtextResourceSet;
 import org.eclipse.xtext.scoping.IScopeProvider;
 import tools.refinery.language.model.problem.*;
+import tools.refinery.language.scoping.imports.ImportAdapter;
 import tools.refinery.language.utils.ProblemDesugarer;
 import tools.refinery.language.utils.ProblemUtil;
 import tools.refinery.store.model.Model;
@@ -79,7 +80,7 @@ public class SolutionSerializer {
         }
 
         public Problem serializeSolution(ProblemTrace trace, Model model) {
-                var uri = URI.createFileURI("__synthetic" + fileExtension);
+                var uri = URI.createURI("__synthetic." + fileExtension);
                 return serializeSolution(trace, model, uri);
         }
 
@@ -133,6 +134,7 @@ public class SolutionSerializer {
 
         private Problem copyProblem(Problem originalProblem, URI uri) {
                 var newResourceSet = resourceSetProvider.get();
+                ImportAdapter.copySettings(originalProblem, newResourceSet);
                 if (!fileExtension.equals(uri.fileExtension())) {
                         uri = uri.appendFileExtension(fileExtension);
                 }
@@ -153,6 +155,7 @@ public class SolutionSerializer {
                                 throw new IllegalStateException("Failed to copy problem", e);
                         }
                         var contents = newResource.getContents();
+                        EcoreUtil.resolveAll(newResourceSet);
                         if (!contents.isEmpty() && contents.getFirst() instanceof Problem newProblem) {
                                 return newProblem;
                         }
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
index 0fb4cd2c..d88d0299 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/library/BuiltinLibrary.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/BuiltinLibrary.java
@@ -9,33 +9,14 @@ import org.eclipse.emf.common.util.URI;
 import org.eclipse.xtext.naming.QualifiedName;
 
 import java.util.List;
-import java.util.Optional;
 
-public class BuiltinLibrary implements RefineryLibrary {
+public class BuiltinLibrary extends ClasspathBasedLibrary {
         public static final QualifiedName BUILTIN_LIBRARY_NAME = QualifiedName.create("builtin");
-        public static final URI BUILTIN_LIBRARY_URI = getLibraryUri(BUILTIN_LIBRARY_NAME).orElseThrow(
+        public static final URI BUILTIN_LIBRARY_URI = ClasspathBasedLibrary.getLibraryUri(
+                        BuiltinLibrary.class, BUILTIN_LIBRARY_NAME).orElseThrow(
                         () -> new IllegalStateException("Builtin library was not found"));
 
-        @Override
-        public List<QualifiedName> getAutomaticImports() {
-                return List.of(BUILTIN_LIBRARY_NAME);
-        }
-
-        @Override
-        public Optional<URI> resolveQualifiedName(QualifiedName qualifiedName) {
-                if (qualifiedName.startsWith(BUILTIN_LIBRARY_NAME)) {
-                        return getLibraryUri(qualifiedName);
-                }
-                return Optional.empty();
-        }
-
-        private static Optional<URI> getLibraryUri(QualifiedName qualifiedName) {
-                var libraryPath = String.join("/", qualifiedName.getSegments());
-                var libraryResource = BuiltinLibrary.class.getClassLoader()
-                                .getResource("tools/refinery/language/library/%s.refinery".formatted(libraryPath));
-                if (libraryResource == null) {
-                        return Optional.empty();
-                }
-                return Optional.of(URI.createURI(libraryResource.toString()));
+        public BuiltinLibrary() {
+                super(BUILTIN_LIBRARY_NAME, 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..4b748c64
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/ClasspathBasedLibrary.java
@@ -0,0 +1,98 @@
+/*
+ * 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 QualifiedName prefix;
+        private final List<QualifiedName> automaticImports;
+        private final URI rootUri;
+
+        protected ClasspathBasedLibrary(QualifiedName prefix, List<QualifiedName> automaticImports) {
+                this.prefix = prefix;
+                this.automaticImports = List.copyOf(automaticImports);
+                var context = this.getClass();
+                var contextPath = context.getCanonicalName().replace('.', '/') + ".class";
+                var contextResource = 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(prefix, List.of());
+        }
+
+        @Override
+        public List<QualifiedName> getAutomaticImports() {
+                return automaticImports;
+        }
+
+        @Override
+        public Optional<URI> resolveQualifiedName(QualifiedName qualifiedName, List<Path> libraryPaths) {
+                if (qualifiedName.startsWith(prefix)) {
+                        return getLibraryUri(this.getClass(), 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.EXTENSION)) {
+                        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.EXTENSION.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.EXTENSION);
+                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..c6f994df
--- /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.EXTENSION;
+                        }
+                        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(EXTENSION)) {
+                        return Optional.empty();
+                }
+                lastSegment = lastSegment.substring(0, lastSegment.length() - RefineryLibrary.EXTENSION.length());
+                segments.set(lastIndex, lastSegment);
+                return Optional.of(QualifiedName.create(segments));
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibraries.java b/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibraries.java
deleted file mode 100644
index 0efca199..00000000
--- a/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibraries.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.language.library;
-
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.xtext.naming.QualifiedName;
-import tools.refinery.language.scoping.imports.NamedImport;
-
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Optional;
-import java.util.ServiceLoader;
-
-public final class RefineryLibraries {
-        private static final ServiceLoader<RefineryLibrary> SERVICE_LOADER = ServiceLoader.load(RefineryLibrary.class);
-        private static final List<NamedImport> AUTOMATIC_IMPORTS;
-
-        static {
-                var imports = new LinkedHashMap<QualifiedName, URI>();
-                for (var service : SERVICE_LOADER) {
-                        for (var qualifiedName : service.getAutomaticImports()) {
-                                var uri = service.resolveQualifiedName(qualifiedName).orElseThrow(
-                                                () -> new IllegalStateException("Automatic import %s was not found".formatted(qualifiedName)));
-                                if (imports.put(qualifiedName, uri) != null) {
-                                        throw new IllegalStateException("Duplicate automatic import " + qualifiedName);
-                                }
-                        }
-                }
-                AUTOMATIC_IMPORTS = imports.entrySet().stream()
-                                .map(entry -> NamedImport.implicit(entry.getValue(), entry.getKey()))
-                                .toList();
-        }
-
-        private RefineryLibraries() {
-                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
-        }
-
-        public static List<NamedImport> getAutomaticImports() {
-                return AUTOMATIC_IMPORTS;
-        }
-
-        public static Optional<URI> resolveQualifiedName(QualifiedName qualifiedName) {
-                for (var service : SERVICE_LOADER) {
-                        var result = service.resolveQualifiedName(qualifiedName);
-                        if (result.isPresent()) {
-                                return result;
-                        }
-                }
-                return Optional.empty();
-        }
-}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibrary.java b/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibrary.java
index 9db2900e..e1f8d7bc 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibrary.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibrary.java
@@ -8,13 +8,18 @@ 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.List;
 import java.util.Optional;
 
 public interface RefineryLibrary {
+        String EXTENSION = ".refinery";
+
         default List<QualifiedName> getAutomaticImports() {
                 return List.of();
         }
 
-        Optional<URI> resolveQualifiedName(QualifiedName qualifiedName);
+        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/ProblemDelegateQualifiedNameProvider.java b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemDelegateQualifiedNameProvider.java
index 1e78cee1..b3931401 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemDelegateQualifiedNameProvider.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/naming/ProblemDelegateQualifiedNameProvider.java
@@ -5,14 +5,40 @@
  */
 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 {
-        protected QualifiedName qualifiedName(Problem ele) {
-                var qualifiedName = computeFullyQualifiedNameFromNameAttribute(ele);
-                // Strip the root prefix even if explicitly provided.
-                return NamingUtil.stripRootPrefix(qualifiedName);
+        @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/resource/ProblemResourceDescriptionStrategy.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
index a2ec7ed0..7d90ea00 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,14 +8,17 @@ 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;
@@ -46,6 +49,10 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
         private IQualifiedNameConverter qualifiedNameConverter;
 
         @Inject
+        @Named(ProblemQualifiedNameProvider.NAMED_DELEGATE)
+        private IQualifiedNameProvider delegateQualifiedNameProvider;
+
+        @Inject
         private ImportCollector importCollector;
 
         @Override
@@ -53,17 +60,17 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
                 if (!shouldExport(eObject)) {
                         return false;
                 }
-                var qualifiedName = getNameAsQualifiedName(eObject);
-                if (qualifiedName == null) {
-                        return true;
-                }
                 var problem = EcoreUtil2.getContainerOfType(eObject, Problem.class);
+                var problemQualifiedName = getProblemQualifiedName(problem);
                 var userData = getUserData(eObject);
                 if (eObject.equals(problem)) {
-                        acceptEObjectDescription(eObject, qualifiedName, QualifiedName.EMPTY, userData, true, acceptor);
+                        acceptEObjectDescription(eObject, problemQualifiedName, QualifiedName.EMPTY, userData, true, acceptor);
+                        return true;
+                }
+                var qualifiedName = getNameAsQualifiedName(eObject);
+                if (qualifiedName == null) {
                         return true;
                 }
-                var problemQualifiedName = getNameAsQualifiedName(problem);
                 QualifiedName lastQualifiedNameToExport = null;
                 if (shouldExportSimpleName(eObject)) {
                         lastQualifiedNameToExport = qualifiedName;
@@ -107,6 +114,14 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
                 return qualifiedName;
         }
 
+        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.
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 3e00b87e..610efc03 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemLocalScopeProvider.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemLocalScopeProvider.java
@@ -6,6 +6,7 @@
 package tools.refinery.language.scoping;
 
 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;
@@ -18,13 +19,14 @@ import org.eclipse.xtext.scoping.IScope;
 import org.eclipse.xtext.scoping.impl.AbstractGlobalScopeDelegatingScopeProvider;
 import org.eclipse.xtext.scoping.impl.SelectableBasedScope;
 import org.eclipse.xtext.util.IResourceScopeCache;
-import tools.refinery.language.naming.NamingUtil;
+import tools.refinery.language.naming.ProblemQualifiedNameProvider;
 
 public class ProblemLocalScopeProvider extends AbstractGlobalScopeDelegatingScopeProvider {
         private static final String CACHE_KEY = "tools.refinery.language.scoping.ProblemLocalScopeProvider.CACHE_KEY";
 
         @Inject
-        private IQualifiedNameProvider qualifiedNameProvider;
+        @Named(ProblemQualifiedNameProvider.NAMED_DELEGATE)
+        private IQualifiedNameProvider delegateQualifiedNameProvider;
 
         @Inject
         private IResourceDescriptionsProvider resourceDescriptionsProvider;
@@ -64,7 +66,7 @@ public class ProblemLocalScopeProvider extends AbstractGlobalScopeDelegatingScop
                 if (rootElement == null) {
                         return new LocalImports(resourceDescription, null);
                 }
-                var rootName = NamingUtil.stripRootPrefix(qualifiedNameProvider.getFullyQualifiedName(rootElement));
+                var rootName = delegateQualifiedNameProvider.getFullyQualifiedName(rootElement);
                 if (rootName == null) {
                         return new LocalImports(resourceDescription, null);
                 }
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..5a8f7fd7
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/imports/ImportAdapter.java
@@ -0,0 +1,230 @@
+/*
+ * 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.EObject;
+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);
+        }
+
+        public static void copySettings(EObject context, ResourceSet newResourceSet) {
+                var resource = context.eResource();
+                if (resource == null) {
+                        return;
+                }
+                var originalResourceSet = resource.getResourceSet();
+                if (originalResourceSet == null) {
+                        return;
+                }
+                copySettings(originalResourceSet, newResourceSet);
+        }
+
+        public static void copySettings(ResourceSet originalResourceSet, ResourceSet newResourceSet) {
+                var originalAdapter = getAdapter(originalResourceSet);
+                if (originalAdapter == null) {
+                        return;
+                }
+                var newAdapter = getOrInstall(newResourceSet);
+                newAdapter.libraries.clear();
+                newAdapter.libraries.addAll(originalAdapter.libraries);
+                newAdapter.libraryPaths.clear();
+                newAdapter.libraryPaths.addAll(originalAdapter.libraryPaths);
+        }
+}
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
index cea99f0a..6cdfa63e 100644
--- 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
@@ -18,7 +18,6 @@ import org.eclipse.xtext.naming.QualifiedName;
 import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
 import org.eclipse.xtext.resource.IEObjectDescription;
 import org.eclipse.xtext.util.IResourceScopeCache;
-import tools.refinery.language.library.RefineryLibraries;
 import tools.refinery.language.model.problem.ImportStatement;
 import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.model.problem.ProblemPackage;
@@ -54,28 +53,49 @@ public class ImportCollector {
                 if (resource.getContents().isEmpty() || !(resource.getContents().getFirst() instanceof Problem problem)) {
                         return ImportCollection.EMPTY;
                 }
+                var resourceSet = resource.getResourceSet();
+                if (resourceSet == null) {
+                        return ImportCollection.EMPTY;
+                }
                 Map<QualifiedName, Set<QualifiedName>> aliasesMap = new LinkedHashMap<>();
                 for (var statement : problem.getStatements()) {
                         if (statement instanceof ImportStatement importStatement) {
                                 collectImportStatement(importStatement, aliasesMap);
                         }
                 }
+                var adapter = ImportAdapter.getOrInstall(resourceSet);
                 var collection = new ImportCollection();
-                collection.addAll(RefineryLibraries.getAutomaticImports());
+                collectAutomaticImports(collection, adapter);
+                collectExplicitImports(aliasesMap, 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(Map<QualifiedName, Set<QualifiedName>> aliasesMap,
+                                                                                ImportCollection collection, ImportAdapter adapter) {
                 for (var entry : aliasesMap.entrySet()) {
                         var qualifiedName = entry.getKey();
-                        RefineryLibraries.resolveQualifiedName(qualifiedName).ifPresent(uri -> {
-                                if (!uri.equals(resource.getURI())) {
-                                        var aliases = entry.getValue();
-                                        collection.add(NamedImport.explicit(uri, qualifiedName, List.copyOf(aliases)));
-                                }
-                        });
+                        var uri = adapter.resolveQualifiedName(qualifiedName);
+                        if (uri != null) {
+                                var aliases = entry.getValue();
+                                collection.add(NamedImport.explicit(uri, qualifiedName, List.copyOf(aliases)));
+                        }
                 }
-                collection.remove(resource.getURI());
-                return collection;
         }
 
-        private void collectImportStatement(ImportStatement importStatement, Map<QualifiedName, Set<QualifiedName>> aliasesMap) {
+        private void collectImportStatement(ImportStatement importStatement,
+                                                                                Map<QualifiedName, Set<QualifiedName>> aliasesMap) {
                 var nodes = NodeModelUtils.findNodesForFeature(importStatement,
                                 ProblemPackage.Literals.IMPORT_STATEMENT__IMPORTED_MODULE);
                 var aliasString = importStatement.getAlias();
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 23ff55e7..6b48cb5a 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
@@ -124,8 +124,12 @@ public final class ProblemUtil {
                 };
         }
 
+        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 && problem.getKind() == ModuleKind.MODULE;
+                return problem != null && isModule(problem);
         }
 }
diff --git a/subprojects/language/src/main/resources/META-INF/services/tools.refinery.language.library.RefineryLibrary b/subprojects/language/src/main/resources/META-INF/services/tools.refinery.language.library.RefineryLibrary
index bb7e369d..8e454ee5 100644
--- a/subprojects/language/src/main/resources/META-INF/services/tools.refinery.language.library.RefineryLibrary
+++ b/subprojects/language/src/main/resources/META-INF/services/tools.refinery.language.library.RefineryLibrary
@@ -2,3 +2,4 @@
 #
 # SPDX-License-Identifier: EPL-2.0
 tools.refinery.language.library.BuiltinLibrary
+tools.refinery.language.library.PathLibrary
diff --git a/subprojects/language/src/main/resources/tools/refinery/language/library/builtin.refinery b/subprojects/language/src/main/resources/tools/refinery/language/library/builtin.refinery
index 022c3167..f9ef959d 100644
--- a/subprojects/language/src/main/resources/tools/refinery/language/library/builtin.refinery
+++ b/subprojects/language/src/main/resources/tools/refinery/language/library/builtin.refinery
@@ -1,7 +1,7 @@
-% 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
-problem builtin.
+module builtin.
 
 abstract class node.