47 files changed, 719 insertions, 722 deletions

diff --git a/subprojects/generator/build.gradle.kts b/subprojects/generator/build.gradle.kts
index f1a4ed54..d87ce6de 100644
--- a/subprojects/generator/build.gradle.kts
+++ b/subprojects/generator/build.gradle.kts
@@ -10,6 +10,6 @@ plugins {
 
 dependencies {
         api(project(":refinery-language-semantics"))
+        api(libs.eclipseCollections.api)
         implementation(project(":refinery-store-query-interpreter"))
-        implementation(project(":refinery-store-reasoning-scope"))
 }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefinery.java b/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefinery.java
deleted file mode 100644
index 56c7a23b..00000000
--- a/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefinery.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.generator;
-
-import tools.refinery.generator.impl.ProblemTraceImpl;
-import tools.refinery.language.semantics.metadata.NodeMetadata;
-import tools.refinery.store.model.Model;
-import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.reasoning.ReasoningAdapter;
-import tools.refinery.store.reasoning.ReasoningStoreAdapter;
-import tools.refinery.store.reasoning.seed.ModelSeed;
-import tools.refinery.store.reasoning.translator.TranslationException;
-
-import java.util.List;
-
-public abstract class AbstractRefinery {
-        protected final ProblemTrace problemTrace;
-        protected final ModelStore store;
-        protected final Model model;
-        protected final ReasoningAdapter reasoningAdapter;
-
-        protected AbstractRefinery(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed) {
-                this.problemTrace = problemTrace;
-                this.store = store;
-                try {
-                        model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
-                } catch (TranslationException e) {
-                        throw ProblemTraceImpl.wrapException(problemTrace, e);
-                }
-                reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
-        }
-
-        public ProblemTrace getProblemTrace() {
-                return problemTrace;
-        }
-
-        public ModelStore getModelStore() {
-                return store;
-        }
-
-        public Model getModel() {
-                return model;
-        }
-
-        public List<NodeMetadata> getNodesMetadata() {
-                int nodeCount = reasoningAdapter.getNodeCount();
-                return problemTrace.getNodesMetadata(nodeCount, isPreserveNewNodes());
-        }
-
-        protected abstract boolean isPreserveNewNodes();
-}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefineryBuilder.java b/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefineryBuilder.java
deleted file mode 100644
index d4649051..00000000
--- a/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefineryBuilder.java
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.generator;
-
-import com.google.inject.Inject;
-import com.google.inject.Provider;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.xtext.diagnostics.Severity;
-import org.eclipse.xtext.resource.IResourceFactory;
-import org.eclipse.xtext.resource.XtextResourceSet;
-import org.eclipse.xtext.util.LazyStringInputStream;
-import org.eclipse.xtext.validation.CheckMode;
-import org.eclipse.xtext.validation.IResourceValidator;
-import tools.refinery.generator.impl.ProblemTraceImpl;
-import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.semantics.model.ModelInitializer;
-import tools.refinery.store.query.ModelQueryBuilder;
-import tools.refinery.store.query.interpreter.QueryInterpreterAdapter;
-import tools.refinery.store.reasoning.literal.Concreteness;
-import tools.refinery.store.reasoning.translator.TranslationException;
-import tools.refinery.store.util.CancellationToken;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Collection;
-import java.util.Map;
-
-// This class is used as a fluent builder.
-@SuppressWarnings("UnusedReturnValue")
-public abstract class AbstractRefineryBuilder<T> {
-        @Inject
-        private Provider<XtextResourceSet> resourceSetProvider;
-
-        @Inject
-        private IResourceFactory resourceFactory;
-
-        @Inject
-        private IResourceValidator resourceValidator;
-
-        @Inject
-        protected ModelInitializer initializer;
-
-        @Inject
-        private ProblemTraceImpl problemTrace;
-
-        protected CancellationToken cancellationToken = CancellationToken.NONE;
-        private boolean problemLoaded;
-        private ModelQueryBuilder queryEngineBuilder;
-        protected Collection<Concreteness> requiredInterpretations;
-
-        protected AbstractRefineryBuilder(Collection<Concreteness> defaultRequiredInterpretations) {
-                requiredInterpretations = defaultRequiredInterpretations;
-        }
-
-        protected abstract T self();
-
-        public T cancellationToken(CancellationToken cancellationToken) {
-                this.cancellationToken = cancellationToken;
-                return self();
-        }
-
-        public T fromString(String problemString) throws IOException {
-                try (var stream = new LazyStringInputStream(problemString)) {
-                        return fromStream(stream);
-                }
-        }
-
-        public T fromStream(InputStream inputStream) throws IOException {
-                var resourceSet = resourceSetProvider.get();
-                var resource = resourceFactory.createResource(URI.createFileURI("__synthetic.problem"));
-                resourceSet.getResources().add(resource);
-                resource.load(inputStream, Map.of());
-                return fromResource(resource);
-        }
-
-        public T fromFile(File file) throws IOException {
-                return fromFile(file.getAbsolutePath());
-        }
-
-        public T fromFile(String filePath) throws IOException {
-                return fromUri(URI.createFileURI(filePath));
-        }
-
-        public T fromUri(URI uri) throws IOException {
-                var resourceSet = resourceSetProvider.get();
-                var resource = resourceFactory.createResource(uri);
-                resourceSet.getResources().add(resource);
-                resource.load(Map.of());
-                return fromResource(resource);
-        }
-
-        public T fromResource(Resource resource) {
-                var issues = resourceValidator.validate(resource, CheckMode.ALL, () -> {
-                        cancellationToken.checkCancelled();
-                        return Thread.interrupted();
-                });
-                cancellationToken.checkCancelled();
-                var errors = issues.stream()
-                                .filter(issue -> issue.getSeverity() == Severity.ERROR)
-                                .toList();
-                if (!errors.isEmpty()) {
-                        throw new ValidationErrorsException(resource.getURI(), errors);
-                }
-                if (resource.getContents().isEmpty() || !(resource.getContents().get(0) instanceof Problem problem)) {
-                        throw new IllegalArgumentException("Model generation problem not found in resource " + resource.getURI());
-                }
-                return problem(problem);
-        }
-
-        public T problem(Problem problem) {
-                if (problemLoaded) {
-                        throw new IllegalStateException("Problem was already set");
-                }
-                problemTrace.setInitializer(initializer);
-                try {
-                        initializer.readProblem(problem);
-                } catch (TranslationException e) {
-                        throw ProblemTraceImpl.wrapException(problemTrace, e);
-                }
-                problemLoaded = true;
-                return self();
-        }
-
-        public ProblemTrace getProblemTrace() {
-                checkProblem();
-                return problemTrace;
-        }
-
-        public T queryEngine(ModelQueryBuilder queryEngineBuilder) {
-                if (this.queryEngineBuilder != null) {
-                        throw new IllegalStateException("Query engine was already set");
-                }
-                this.queryEngineBuilder = queryEngineBuilder;
-                return self();
-        }
-
-        public T requiredInterpretations(Collection<Concreteness> requiredInterpretations) {
-                this.requiredInterpretations = requiredInterpretations;
-                return self();
-        }
-
-        protected void checkProblem() {
-                if (!problemLoaded) {
-                        throw new IllegalStateException("Problem was not loaded");
-                }
-        }
-
-        protected ModelQueryBuilder getQueryEngineBuilder() {
-                if (queryEngineBuilder == null) {
-                        return QueryInterpreterAdapter.builder();
-                }
-                return queryEngineBuilder;
-        }
-}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelFacade.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelFacade.java
new file mode 100644
index 00000000..a00ddc46
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelFacade.java
@@ -0,0 +1,58 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+import tools.refinery.language.semantics.ProblemTrace;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.ReasoningStoreAdapter;
+import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.reasoning.translator.TranslationException;
+
+public abstract class ModelFacade {
+        private final ProblemTrace problemTrace;
+        private final ModelStore store;
+        private final Model model;
+        private final ReasoningAdapter reasoningAdapter;
+        private final Concreteness concreteness;
+
+        protected ModelFacade(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed,
+                          Concreteness concreteness) {
+                this.problemTrace = problemTrace;
+                this.store = store;
+                try {
+                        model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
+                } catch (TranslationException e) {
+                        throw problemTrace.wrapException(e);
+                }
+                reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
+                this.concreteness = concreteness;
+        }
+
+        public ProblemTrace getProblemTrace() {
+                return problemTrace;
+        }
+
+        public ModelStore getModelStore() {
+                return store;
+        }
+
+        public Model getModel() {
+                return model;
+        }
+
+        public Concreteness getConcreteness() {
+                return concreteness;
+        }
+
+        public <A, C> PartialInterpretation<A, C> getPartialInterpretation(PartialSymbol<A, C> partialSymbol) {
+                return reasoningAdapter.getPartialInterpretation(concreteness, partialSymbol);
+        }
+}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
index 78c807d1..5b44c10a 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
@@ -5,33 +5,25 @@
  */
 package tools.refinery.generator;
 
-import org.eclipse.xtext.naming.QualifiedName;
-import tools.refinery.language.model.problem.Relation;
+import tools.refinery.language.semantics.ProblemTrace;
 import tools.refinery.store.dse.strategy.BestFirstStoreManager;
-import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
 import tools.refinery.store.map.Version;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
 import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.representation.PartialSymbol;
 import tools.refinery.store.reasoning.seed.ModelSeed;
-import tools.refinery.store.representation.TruthValue;
 
-import java.util.Collection;
-
-public class ModelGenerator extends AbstractRefinery {
+public class ModelGenerator extends ModelFacade {
         private final Version initialVersion;
 
-        private int randomSeed = 1;
+        private int randomSeed = 0;
 
-        public ModelGenerator(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed) {
-                super(problemTrace, store, modelSeed);
-                initialVersion = model.commit();
-        }
+        private boolean lastGenerationSuccessful;
 
-        @Override
-        protected boolean isPreserveNewNodes() {
-                return false;
+        public ModelGenerator(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed) {
+                super(problemTrace, store, modelSeed, Concreteness.CANDIDATE);
+                initialVersion = getModel().commit();
         }
 
         public int getRandomSeed() {
@@ -40,56 +32,40 @@ public class ModelGenerator extends AbstractRefinery {
 
         public void setRandomSeed(int randomSeed) {
                 this.randomSeed = randomSeed;
+                this.lastGenerationSuccessful = false;
         }
 
-        public Collection<Version> run(int maxNumberOfSolutions) {
-                var bestFirst = new BestFirstStoreManager(store, maxNumberOfSolutions);
-                int currentRandomSeed = randomSeed;
-                // Increment random seed even if generation is unsuccessful.
-                randomSeed++;
-                bestFirst.startExploration(initialVersion, currentRandomSeed);
-                return bestFirst.getSolutionStore()
-                                .getSolutions()
-                                .stream()
-                                .map(VersionWithObjectiveValue::version)
-                                .toList();
+        public boolean isLastGenerationSuccessful() {
+                return lastGenerationSuccessful;
         }
 
         // This method only makes sense if it returns {@code true} on success.
         @SuppressWarnings("BooleanMethodIsAlwaysInverted")
-        public boolean tryRun() {
-                var iterator = run(1).iterator();
-                if (!iterator.hasNext()) {
+        public boolean tryGenerate() {
+                lastGenerationSuccessful = false;
+                randomSeed++;
+                var bestFirst = new BestFirstStoreManager(getModelStore(), 1);
+                bestFirst.startExploration(initialVersion, randomSeed);
+                var solutions = bestFirst.getSolutionStore().getSolutions();
+                if (solutions.isEmpty()) {
                         return false;
                 }
-                model.restore(iterator.next());
+                getModel().restore(solutions.get(0).version());
+                lastGenerationSuccessful = true;
                 return true;
         }
 
-        public void run() {
-                if (!tryRun()) {
+        public void generate() {
+                if (!tryGenerate()) {
                         throw new UnsatisfiableProblemException();
                 }
         }
 
-        public <A, C> PartialInterpretation<A, C> getCandidateInterpretation(PartialSymbol<A, C> partialSymbol) {
-                return reasoningAdapter.getPartialInterpretation(Concreteness.CANDIDATE, partialSymbol);
-        }
-
-        public PartialInterpretation<TruthValue, Boolean> getCandidateInterpretation(Relation relation) {
-                return getCandidateInterpretation(problemTrace.getPartialRelation(relation));
-        }
-
-        public PartialInterpretation<TruthValue, Boolean> getCandidateInterpretation(QualifiedName qualifiedName) {
-                return getCandidateInterpretation(problemTrace.getPartialRelation(qualifiedName));
-        }
-
-        public PartialInterpretation<TruthValue, Boolean> getCandidateInterpretation(String qualifiedName) {
-                return getCandidateInterpretation(problemTrace.getPartialRelation(qualifiedName));
-        }
-
-        public static ModelGeneratorBuilder standaloneBuilder() {
-                var injector = StandaloneInjectorHolder.getInjector();
-                return injector.getInstance(ModelGeneratorBuilder.class);
+        @Override
+        public <A, C> PartialInterpretation<A, C> getPartialInterpretation(PartialSymbol<A, C> partialSymbol) {
+                if (!lastGenerationSuccessful) {
+                        throw new IllegalStateException("No generated model is available");
+                }
+                return super.getPartialInterpretation(partialSymbol);
         }
 }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorBuilder.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorBuilder.java
deleted file mode 100644
index d14cbe3a..00000000
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorBuilder.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.generator;
-
-import tools.refinery.store.dse.propagation.PropagationAdapter;
-import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
-import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.reasoning.ReasoningAdapter;
-import tools.refinery.store.reasoning.literal.Concreteness;
-import tools.refinery.store.statecoding.StateCoderAdapter;
-
-import java.util.Set;
-
-public final class ModelGeneratorBuilder extends AbstractRefineryBuilder<ModelGeneratorBuilder> {
-        public ModelGeneratorBuilder() {
-                super(Set.of(Concreteness.CANDIDATE));
-        }
-
-        @Override
-        protected ModelGeneratorBuilder self() {
-                return this;
-        }
-
-        public ModelGenerator build() {
-                checkProblem();
-                var storeBuilder = ModelStore.builder()
-                                .cancellationToken(cancellationToken)
-                                .with(getQueryEngineBuilder())
-                                .with(PropagationAdapter.builder())
-                                .with(StateCoderAdapter.builder())
-                                .with(DesignSpaceExplorationAdapter.builder())
-                                .with(ReasoningAdapter.builder()
-                                                .requiredInterpretations(requiredInterpretations));
-                initializer.configureStoreBuilder(storeBuilder);
-                var store = storeBuilder.build();
-                return new ModelGenerator(getProblemTrace(), store, initializer.getModelSeed());
-        }
-}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java
new file mode 100644
index 00000000..6642d591
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java
@@ -0,0 +1,63 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.semantics.ModelInitializer;
+import tools.refinery.store.dse.propagation.PropagationAdapter;
+import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.interpreter.QueryInterpreterAdapter;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.statecoding.StateCoderAdapter;
+import tools.refinery.store.util.CancellationToken;
+
+import java.util.Collection;
+import java.util.Set;
+
+public final class ModelGeneratorFactory {
+        @Inject
+        private Provider<ModelInitializer> initializerProvider;
+
+        private CancellationToken cancellationToken = CancellationToken.NONE;
+
+        private boolean debugPartialInterpretations;
+
+        public ModelGeneratorFactory cancellationToken(CancellationToken cancellationToken) {
+                this.cancellationToken = cancellationToken;
+                return this;
+        }
+
+        public ModelGeneratorFactory debugPartialInterpretations(boolean debugPartialInterpretations) {
+                this.debugPartialInterpretations = debugPartialInterpretations;
+                return this;
+        }
+
+        public ModelGenerator createGenerator(Problem problem) {
+                var initializer = initializerProvider.get();
+                initializer.readProblem(problem);
+                cancellationToken.checkCancelled();
+                var storeBuilder = ModelStore.builder()
+                                .cancellationToken(cancellationToken)
+                                .with(QueryInterpreterAdapter.builder())
+                                .with(PropagationAdapter.builder())
+                                .with(StateCoderAdapter.builder())
+                                .with(DesignSpaceExplorationAdapter.builder())
+                                .with(ReasoningAdapter.builder()
+                                                .requiredInterpretations(getRequiredInterpretations()));
+                initializer.configureStoreBuilder(storeBuilder);
+                var store = storeBuilder.build();
+                return new ModelGenerator(initializer.getProblemTrace(), store, initializer.getModelSeed());
+        }
+
+        private Collection<Concreteness> getRequiredInterpretations() {
+                return debugPartialInterpretations ? Set.of(Concreteness.PARTIAL, Concreteness.CANDIDATE) :
+                                Set.of(Concreteness.CANDIDATE);
+        }
+}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java
index 661bc97c..bc02c887 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java
@@ -5,43 +5,13 @@
  */
 package tools.refinery.generator;
 
-import org.eclipse.xtext.naming.QualifiedName;
-import tools.refinery.language.model.problem.Relation;
+import tools.refinery.language.semantics.ProblemTrace;
 import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
 import tools.refinery.store.reasoning.literal.Concreteness;
-import tools.refinery.store.reasoning.representation.PartialSymbol;
 import tools.refinery.store.reasoning.seed.ModelSeed;
-import tools.refinery.store.representation.TruthValue;
 
-public class ModelSemantics extends AbstractRefinery {
+public class ModelSemantics extends ModelFacade {
         public ModelSemantics(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed) {
-                super(problemTrace, store, modelSeed);
-        }
-
-        @Override
-        protected boolean isPreserveNewNodes() {
-                return true;
-        }
-
-        public <A, C> PartialInterpretation<A, C> getPartialInterpretation(PartialSymbol<A, C> partialSymbol) {
-                return reasoningAdapter.getPartialInterpretation(Concreteness.PARTIAL, partialSymbol);
-        }
-
-        public PartialInterpretation<TruthValue, Boolean> getPartialInterpretation(Relation relation) {
-                return getPartialInterpretation(problemTrace.getPartialRelation(relation));
-        }
-
-        public PartialInterpretation<TruthValue, Boolean> getPartialInterpretation(QualifiedName qualifiedName) {
-                return getPartialInterpretation(problemTrace.getPartialRelation(qualifiedName));
-        }
-
-        public PartialInterpretation<TruthValue, Boolean> getPartialInterpretation(String qualifiedName) {
-                return getPartialInterpretation(problemTrace.getPartialRelation(qualifiedName));
-        }
-
-        public static ModelSemanticsBuilder standaloneBuilder() {
-                var injector = StandaloneInjectorHolder.getInjector();
-                return injector.getInstance(ModelSemanticsBuilder.class);
+                super(problemTrace, store, modelSeed, Concreteness.PARTIAL);
         }
 }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsBuilder.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsBuilder.java
deleted file mode 100644
index a560ebe4..00000000
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsBuilder.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.generator;
-
-import tools.refinery.store.dse.propagation.PropagationAdapter;
-import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.reasoning.ReasoningAdapter;
-import tools.refinery.store.reasoning.literal.Concreteness;
-
-import java.util.Set;
-
-public final class ModelSemanticsBuilder extends AbstractRefineryBuilder<ModelSemanticsBuilder> {
-        public ModelSemanticsBuilder() {
-                super(Set.of(Concreteness.PARTIAL));
-        }
-
-        @Override
-        protected ModelSemanticsBuilder self() {
-                return this;
-        }
-
-        public ModelSemantics build() {
-                checkProblem();
-                var storeBuilder = ModelStore.builder()
-                                .cancellationToken(cancellationToken)
-                                .with(getQueryEngineBuilder())
-                                .with(PropagationAdapter.builder())
-                                .with(ReasoningAdapter.builder()
-                                                .requiredInterpretations(requiredInterpretations));
-                initializer.configureStoreBuilder(storeBuilder);
-                var store = storeBuilder.build();
-                return new ModelSemantics(getProblemTrace(), store, initializer.getModelSeed());
-        }
-}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java
new file mode 100644
index 00000000..b6263b37
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemanticsFactory.java
@@ -0,0 +1,45 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.semantics.ModelInitializer;
+import tools.refinery.store.dse.propagation.PropagationAdapter;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.interpreter.QueryInterpreterAdapter;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.util.CancellationToken;
+
+import java.util.Set;
+
+public final class ModelSemanticsFactory {
+        @Inject
+        private Provider<ModelInitializer> initializerProvider;
+
+        private CancellationToken cancellationToken = CancellationToken.NONE;
+
+        public ModelSemanticsFactory cancellationToken(CancellationToken cancellationToken) {
+                this.cancellationToken = cancellationToken;
+                return this;
+        }
+
+        public ModelSemantics createSemantics(Problem problem) {
+                var initializer = initializerProvider.get();
+                initializer.readProblem(problem);
+                var storeBuilder = ModelStore.builder()
+                                .cancellationToken(cancellationToken)
+                                .with(QueryInterpreterAdapter.builder())
+                                .with(PropagationAdapter.builder())
+                                .with(ReasoningAdapter.builder()
+                                                .requiredInterpretations(Set.of(Concreteness.PARTIAL)));
+                initializer.configureStoreBuilder(storeBuilder);
+                var store = storeBuilder.build();
+                return new ModelSemantics(initializer.getProblemTrace(), store, initializer.getModelSeed());
+        }
+}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java b/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java
new file mode 100644
index 00000000..29f80714
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java
@@ -0,0 +1,90 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.diagnostics.Severity;
+import org.eclipse.xtext.resource.IResourceFactory;
+import org.eclipse.xtext.resource.XtextResourceSet;
+import org.eclipse.xtext.util.LazyStringInputStream;
+import org.eclipse.xtext.validation.CheckMode;
+import org.eclipse.xtext.validation.IResourceValidator;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.store.util.CancellationToken;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+
+public class ProblemLoader {
+        @Inject
+        private Provider<XtextResourceSet> resourceSetProvider;
+
+        @Inject
+        private IResourceFactory resourceFactory;
+
+        @Inject
+        private IResourceValidator resourceValidator;
+
+        private CancellationToken cancellationToken = CancellationToken.NONE;
+
+        public ProblemLoader cancellationToken(CancellationToken cancellationToken) {
+                this.cancellationToken = cancellationToken;
+                return this;
+        }
+
+        public Problem loadString(String problemString) throws IOException {
+                try (var stream = new LazyStringInputStream(problemString)) {
+                        return loadStream(stream);
+                }
+        }
+
+        public Problem loadStream(InputStream inputStream) throws IOException {
+                var resourceSet = resourceSetProvider.get();
+                var resource = resourceFactory.createResource(URI.createFileURI("__synthetic.problem"));
+                resourceSet.getResources().add(resource);
+                resource.load(inputStream, Map.of());
+                return loadResource(resource);
+        }
+
+        public Problem loadFile(File file) throws IOException {
+                return loadFile(file.getAbsolutePath());
+        }
+
+        public Problem loadFile(String filePath) throws IOException {
+                return loadUri(URI.createFileURI(filePath));
+        }
+
+        public Problem loadUri(URI uri) throws IOException {
+                var resourceSet = resourceSetProvider.get();
+                var resource = resourceFactory.createResource(uri);
+                resourceSet.getResources().add(resource);
+                resource.load(Map.of());
+                return loadResource(resource);
+        }
+
+        public Problem loadResource(Resource resource) {
+                var issues = resourceValidator.validate(resource, CheckMode.ALL, () -> {
+                        cancellationToken.checkCancelled();
+                        return Thread.interrupted();
+                });
+                cancellationToken.checkCancelled();
+                var errors = issues.stream()
+                                .filter(issue -> issue.getSeverity() == Severity.ERROR)
+                                .toList();
+                if (!errors.isEmpty()) {
+                        throw new ValidationErrorsException(resource.getURI(), errors);
+                }
+                if (resource.getContents().isEmpty() || !(resource.getContents().get(0) instanceof Problem problem)) {
+                        throw new IllegalArgumentException("Model generation problem not found in resource " + resource.getURI());
+                }
+                return problem;
+        }
+}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/StandaloneInjectorHolder.java b/subprojects/generator/src/main/java/tools/refinery/generator/StandaloneInjectorHolder.java
deleted file mode 100644
index 7db96163..00000000
--- a/subprojects/generator/src/main/java/tools/refinery/generator/StandaloneInjectorHolder.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.generator;
-
-import com.google.inject.Injector;
-import tools.refinery.language.ProblemStandaloneSetup;
-
-public final class StandaloneInjectorHolder {
-        private StandaloneInjectorHolder() {
-                throw new IllegalArgumentException("This is a static utility class and should not be instantiated directly");
-        }
-
-        public static Injector getInjector() {
-                return LazyHolder.INJECTOR;
-        }
-
-        private static final class LazyHolder {
-                private static final Injector INJECTOR = createInjector();
-
-                private static Injector createInjector() {
-                        return new ProblemStandaloneSetup().createInjectorAndDoEMFRegistration();
-                }
-        }
-}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/impl/ProblemTraceImpl.java b/subprojects/generator/src/main/java/tools/refinery/generator/impl/ProblemTraceImpl.java
deleted file mode 100644
index 5671d3f8..00000000
--- a/subprojects/generator/src/main/java/tools/refinery/generator/impl/ProblemTraceImpl.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.generator.impl;
-
-import com.google.inject.Inject;
-import com.google.inject.Provider;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.xtext.naming.IQualifiedNameConverter;
-import org.eclipse.xtext.naming.IQualifiedNameProvider;
-import org.eclipse.xtext.naming.QualifiedName;
-import org.eclipse.xtext.scoping.IScopeProvider;
-import tools.refinery.generator.ProblemTrace;
-import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.model.problem.ProblemPackage;
-import tools.refinery.language.model.problem.Relation;
-import tools.refinery.language.semantics.metadata.MetadataCreator;
-import tools.refinery.language.semantics.metadata.NodeMetadata;
-import tools.refinery.language.semantics.metadata.RelationMetadata;
-import tools.refinery.language.semantics.model.ModelInitializer;
-import tools.refinery.language.semantics.model.TracedException;
-import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.reasoning.translator.TranslationException;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
-public final class ProblemTraceImpl implements ProblemTrace {
-        @Inject
-        private IQualifiedNameConverter qualifiedNameConverter;
-
-        @Inject
-        private IQualifiedNameProvider qualifiedNameProvider;
-
-        @Inject
-        private IScopeProvider scopeProvider;
-
-        @Inject
-        private Provider<MetadataCreator> metadataCreatorProvider;
-
-        private ModelInitializer initializer;
-        private Map<Relation, PartialRelation> relationTrace;
-        private MetadataCreator metadataCreator;
-
-        public void setInitializer(ModelInitializer initializer) {
-                this.initializer = initializer;
-                relationTrace = Collections.unmodifiableMap(initializer.getRelationTrace());
-        }
-
-        public Problem getProblem() {
-                return initializer.getProblem();
-        }
-
-        public Map<Relation, PartialRelation> getRelationTrace() {
-                return relationTrace;
-        }
-
-        @Override
-        public Relation getInverseTrace(AnyPartialSymbol partialSymbol) {
-                return initializer.getInverseTrace(partialSymbol);
-        }
-
-        public PartialRelation getPartialRelation(Relation relation) {
-                var partialRelation = relationTrace.get(relation);
-                if (partialRelation == null) {
-                        var qualifiedName = qualifiedNameProvider.getFullyQualifiedName(relation);
-                        var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
-                        throw new IllegalArgumentException("No partial relation for relation " + qualifiedNameString);
-                }
-                return partialRelation;
-        }
-
-        public PartialRelation getPartialRelation(QualifiedName qualifiedName) {
-                var scope = scopeProvider.getScope(getProblem(), ProblemPackage.Literals.ASSERTION__RELATION);
-                var iterator = scope.getElements(qualifiedName).iterator();
-                if (!iterator.hasNext()) {
-                        var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
-                        throw new IllegalArgumentException("No such relation: " + qualifiedNameString);
-                }
-                var eObjectDescription = iterator.next();
-                if (iterator.hasNext()) {
-                        var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
-                        throw new IllegalArgumentException("Ambiguous relation: " + qualifiedNameString);
-                }
-                var eObject = EcoreUtil.resolve(eObjectDescription.getEObjectOrProxy(), getProblem());
-                if (!(eObject instanceof Relation relation)) {
-                        var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
-                        throw new IllegalArgumentException("Not a relation: " + qualifiedNameString);
-                }
-                return getPartialRelation(relation);
-        }
-
-        public PartialRelation getPartialRelation(String qualifiedName) {
-                var convertedName = qualifiedNameConverter.toQualifiedName(qualifiedName);
-                return getPartialRelation(convertedName);
-        }
-
-        @Override
-        public List<RelationMetadata> getRelationsMetadata() {
-                return getMetadataCreator().getRelationsMetadata();
-        }
-
-        @Override
-        public List<NodeMetadata> getNodesMetadata(int nodeCount, boolean preserveNewNodes) {
-                return getMetadataCreator().getNodesMetadata(nodeCount, preserveNewNodes);
-        }
-
-        private MetadataCreator getMetadataCreator() {
-                if (metadataCreator == null) {
-                        metadataCreator = metadataCreatorProvider.get();
-                        metadataCreator.setInitializer(initializer);
-                }
-                return metadataCreator;
-        }
-
-        public static RuntimeException wrapException(ProblemTrace trace, TranslationException translationException) {
-                var source = trace.getInverseTrace(translationException.getPartialSymbol());
-                if (source == null) {
-                        return translationException;
-                }
-                return new TracedException(source, translationException);
-        }
-}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/standalone/StandaloneRefinery.java b/subprojects/generator/src/main/java/tools/refinery/generator/standalone/StandaloneRefinery.java
new file mode 100644
index 00000000..b444491b
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/standalone/StandaloneRefinery.java
@@ -0,0 +1,46 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.standalone;
+
+import com.google.inject.Injector;
+import tools.refinery.generator.ModelGeneratorFactory;
+import tools.refinery.generator.ModelSemanticsFactory;
+import tools.refinery.language.ProblemStandaloneSetup;
+import tools.refinery.generator.ProblemLoader;
+
+public final class StandaloneRefinery {
+        private StandaloneRefinery() {
+                throw new IllegalArgumentException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static Injector getInjector() {
+                return LazyHolder.INJECTOR;
+        }
+
+        public static <T> T getInstance(Class<T> type) {
+                return getInjector().getInstance(type);
+        }
+
+        public static ProblemLoader getProblemLoader() {
+                return getInstance(ProblemLoader.class);
+        }
+
+        public static ModelGeneratorFactory getGeneratorFactory() {
+                return getInstance(ModelGeneratorFactory.class);
+        }
+
+        public static ModelSemanticsFactory getSemanticsFactory() {
+                return getInstance(ModelSemanticsFactory.class);
+        }
+
+        private static final class LazyHolder {
+                private static final Injector INJECTOR = createInjector();
+
+                private static Injector createInjector() {
+                        return new ProblemStandaloneSetup().createInjectorAndDoEMFRegistration();
+                }
+        }
+}
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
index a05e647d..b3c58366 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
@@ -3,13 +3,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model;
+package tools.refinery.language.semantics;
 
 import com.google.inject.Inject;
-import org.eclipse.collections.api.factory.primitive.ObjectIntMaps;
-import org.eclipse.collections.api.map.primitive.MutableObjectIntMap;
 import tools.refinery.language.model.problem.*;
-import tools.refinery.language.semantics.model.internal.MutableSeed;
+import tools.refinery.language.semantics.internal.MutableSeed;
 import tools.refinery.language.utils.BuiltinSymbols;
 import tools.refinery.language.utils.ProblemDesugarer;
 import tools.refinery.language.utils.ProblemUtil;
@@ -23,11 +21,11 @@ import tools.refinery.store.query.literal.*;
 import tools.refinery.store.query.term.NodeVariable;
 import tools.refinery.store.query.term.Variable;
 import tools.refinery.store.reasoning.ReasoningAdapter;
-import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.scope.ScopePropagator;
 import tools.refinery.store.reasoning.seed.ModelSeed;
 import tools.refinery.store.reasoning.seed.Seed;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator;
 import tools.refinery.store.reasoning.translator.metamodel.Metamodel;
 import tools.refinery.store.reasoning.translator.metamodel.MetamodelBuilder;
@@ -52,24 +50,19 @@ public class ModelInitializer {
         @Inject
         private SemanticsUtils semanticsUtils;
 
-        private Problem problem;
+        @Inject
+        private ProblemTraceImpl problemTrace;
 
-        private ModelStoreBuilder storeBuilder;
+        private Problem problem;
 
         private BuiltinSymbols builtinSymbols;
 
         private PartialRelation nodeRelation;
 
-        private final MutableObjectIntMap<Node> nodeTrace = ObjectIntMaps.mutable.empty();
-
         private final Map<Relation, RelationInfo> relationInfoMap = new LinkedHashMap<>();
 
         private final Map<PartialRelation, RelationInfo> partialRelationInfoMap = new HashMap<>();
 
-        private final Map<AnyPartialSymbol, Relation> inverseTrace = new HashMap<>();
-
-        private final Map<Relation, PartialRelation> relationTrace = new LinkedHashMap<>();
-
         private final MetamodelBuilder metamodelBuilder = Metamodel.builder();
 
         private Metamodel metamodel;
@@ -80,81 +73,74 @@ public class ModelInitializer {
 
         private ModelSeed modelSeed;
 
-        public Problem getProblem() {
-                return problem;
-        }
-
-        public int getNodeCount() {
-                return nodeTrace.size();
-        }
-
-        public MutableObjectIntMap<Node> getNodeTrace() {
-                return nodeTrace;
-        }
-
-        public Map<Relation, PartialRelation> getRelationTrace() {
-                return relationTrace;
-        }
-
-        public Relation getInverseTrace(AnyPartialSymbol partialRelation) {
-                return inverseTrace.get(partialRelation);
-        }
-
-        public Metamodel getMetamodel() {
-                return metamodel;
-        }
-
         public void readProblem(Problem problem) {
+                if (this.problem != null) {
+                        throw new IllegalArgumentException("Problem was already set");
+                }
                 this.problem = problem;
-                builtinSymbols = desugarer.getBuiltinSymbols(problem).orElseThrow(() -> new IllegalArgumentException(
-                                "Problem has no builtin library"));
-                var nodeInfo = collectPartialRelation(builtinSymbols.node(), 1, TruthValue.TRUE, TruthValue.TRUE);
-                nodeRelation = nodeInfo.partialRelation();
-                metamodelBuilder.type(nodeRelation);
-                putRelationInfo(builtinSymbols.exists(), new RelationInfo(ReasoningAdapter.EXISTS_SYMBOL, null,
-                                TruthValue.TRUE));
-                putRelationInfo(builtinSymbols.equals(), new RelationInfo(ReasoningAdapter.EQUALS_SYMBOL,
-                                (TruthValue) null,
-                                null));
-                putRelationInfo(builtinSymbols.contained(), new RelationInfo(ContainmentHierarchyTranslator.CONTAINED_SYMBOL,
-                                null, TruthValue.UNKNOWN));
-                putRelationInfo(builtinSymbols.contains(), new RelationInfo(ContainmentHierarchyTranslator.CONTAINS_SYMBOL,
-                                null, TruthValue.UNKNOWN));
-                putRelationInfo(builtinSymbols.invalidContainer(),
-                                new RelationInfo(ContainmentHierarchyTranslator.INVALID_CONTAINER, TruthValue.FALSE,
-                                                TruthValue.FALSE));
-                collectNodes();
-                collectPartialSymbols();
-                collectMetamodel();
-                metamodel = metamodelBuilder.build();
-                collectAssertions();
-                int nodeCount = getNodeCount();
-                var modelSeedBuilder = ModelSeed.builder(nodeCount);
-                for (var entry : relationInfoMap.entrySet()) {
-                        var relation = entry.getKey();
-                        var info = entry.getValue();
-                        var partialRelation = info.partialRelation();
-                        relationTrace.put(relation, partialRelation);
-                        modelSeedBuilder.seed(partialRelation, info.toSeed(nodeCount));
-                }
-                collectScopes();
-                modelSeedBuilder.seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
-                                .reducedValue(CardinalityIntervals.SET)
-                                .putAll(countSeed));
-                modelSeed = modelSeedBuilder.build();
+                problemTrace.setProblem(problem);
+                try {
+                        builtinSymbols = desugarer.getBuiltinSymbols(problem).orElseThrow(() -> new IllegalArgumentException(
+                                        "Problem has no builtin library"));
+                        var nodeInfo = collectPartialRelation(builtinSymbols.node(), 1, TruthValue.TRUE, TruthValue.TRUE);
+                        nodeRelation = nodeInfo.partialRelation();
+                        metamodelBuilder.type(nodeRelation);
+                        putRelationInfo(builtinSymbols.exists(), new RelationInfo(ReasoningAdapter.EXISTS_SYMBOL, null,
+                                        TruthValue.TRUE));
+                        putRelationInfo(builtinSymbols.equals(), new RelationInfo(ReasoningAdapter.EQUALS_SYMBOL,
+                                        (TruthValue) null,
+                                        null));
+                        putRelationInfo(builtinSymbols.contained(),
+                                        new RelationInfo(ContainmentHierarchyTranslator.CONTAINED_SYMBOL, null, TruthValue.UNKNOWN));
+                        putRelationInfo(builtinSymbols.contains(), new RelationInfo(ContainmentHierarchyTranslator.CONTAINS_SYMBOL,
+                                        null, TruthValue.UNKNOWN));
+                        putRelationInfo(builtinSymbols.invalidContainer(),
+                                        new RelationInfo(ContainmentHierarchyTranslator.INVALID_CONTAINER, TruthValue.FALSE,
+                                                        TruthValue.FALSE));
+                        collectNodes();
+                        collectPartialSymbols();
+                        collectMetamodel();
+                        metamodel = metamodelBuilder.build();
+                        problemTrace.setMetamodel(metamodel);
+                        collectAssertions();
+                        int nodeCount = problemTrace.getNodeTrace().size();
+                        var modelSeedBuilder = ModelSeed.builder(nodeCount);
+                        for (var entry : relationInfoMap.entrySet()) {
+                                var info = entry.getValue();
+                                var partialRelation = info.partialRelation();
+                                modelSeedBuilder.seed(partialRelation, info.toSeed(nodeCount));
+                        }
+                        collectScopes();
+                        modelSeedBuilder.seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
+                                        .reducedValue(CardinalityIntervals.SET)
+                                        .putAll(countSeed));
+                        modelSeed = modelSeedBuilder.build();
+                } catch (TranslationException e) {
+                        throw problemTrace.wrapException(e);
+                }
         }
 
         public void configureStoreBuilder(ModelStoreBuilder storeBuilder) {
-                this.storeBuilder = storeBuilder;
-                storeBuilder.with(new MultiObjectTranslator());
-                storeBuilder.with(new MetamodelTranslator(metamodel));
-                if (scopePropagator != null) {
-                        if (storeBuilder.tryGetAdapter(PropagationBuilder.class).isEmpty()) {
-                                throw new TracedException(problem, "Type scopes require a PropagationBuilder");
+                checkProblem();
+                try {
+                        storeBuilder.with(new MultiObjectTranslator());
+                        storeBuilder.with(new MetamodelTranslator(metamodel));
+                        if (scopePropagator != null) {
+                                if (storeBuilder.tryGetAdapter(PropagationBuilder.class).isEmpty()) {
+                                        throw new TracedException(problem, "Type scopes require a PropagationBuilder");
+                                }
+                                storeBuilder.with(scopePropagator);
                         }
-                        storeBuilder.with(scopePropagator);
+                        collectPredicates(storeBuilder);
+                } catch (TranslationException e) {
+                        throw problemTrace.wrapException(e);
+                }
+        }
+
+        private void checkProblem() {
+                if (problem == null) {
+                        throw new IllegalStateException("Problem is not set");
                 }
-                collectPredicates();
         }
 
         public ModelSeed createModel(Problem problem, ModelStoreBuilder storeBuilder) {
@@ -163,7 +149,13 @@ public class ModelInitializer {
                 return getModelSeed();
         }
 
+        public ProblemTrace getProblemTrace() {
+                checkProblem();
+                return problemTrace;
+        }
+
         public ModelSeed getModelSeed() {
+                checkProblem();
                 return modelSeed;
         }
 
@@ -190,7 +182,7 @@ public class ModelInitializer {
         }
 
         private void collectNode(Node node) {
-                nodeTrace.getIfAbsentPut(node, this::getNodeCount);
+                problemTrace.collectNode(node);
         }
 
         private void collectPartialSymbols() {
@@ -232,7 +224,7 @@ public class ModelInitializer {
         private void putRelationInfo(Relation relation, RelationInfo info) {
                 relationInfoMap.put(relation, info);
                 partialRelationInfoMap.put(info.partialRelation(), info);
-                inverseTrace.put(info.partialRelation(), relation);
+                problemTrace.putRelation(relation, info.partialRelation());
         }
 
         private RelationInfo collectPartialRelation(Relation relation, int arity, TruthValue value,
@@ -241,7 +233,7 @@ public class ModelInitializer {
                         var name = getName(relation);
                         var info = new RelationInfo(name, arity, value, defaultValue);
                         partialRelationInfoMap.put(info.partialRelation(), info);
-                        inverseTrace.put(info.partialRelation(), relation);
+                        problemTrace.putRelation(relation, info.partialRelation());
                         return info;
                 });
         }
@@ -421,7 +413,7 @@ public class ModelInitializer {
         }
 
         private int getNodeId(Node node) {
-                return nodeTrace.getOrThrow(node);
+                return problemTrace.getNodeId(node);
         }
 
         private Tuple getTuple(Assertion assertion) {
@@ -453,17 +445,18 @@ public class ModelInitializer {
                 };
         }
 
-        private void collectPredicates() {
+        private void collectPredicates(ModelStoreBuilder storeBuilder) {
                 for (var statement : problem.getStatements()) {
                         if (statement instanceof PredicateDefinition predicateDefinition) {
-                                collectPredicateDefinitionTraced(predicateDefinition);
+                                collectPredicateDefinitionTraced(predicateDefinition, storeBuilder);
                         }
                 }
         }
 
-        private void collectPredicateDefinitionTraced(PredicateDefinition predicateDefinition) {
+        private void collectPredicateDefinitionTraced(PredicateDefinition predicateDefinition,
+                                                                                                  ModelStoreBuilder storeBuilder) {
                 try {
-                        collectPredicateDefinition(predicateDefinition);
+                        collectPredicateDefinition(predicateDefinition, storeBuilder);
                 } catch (InvalidClauseException e) {
                         int clauseIndex = e.getClauseIndex();
                         var bodies = predicateDefinition.getBodies();
@@ -477,7 +470,7 @@ public class ModelInitializer {
                 }
         }
 
-        private void collectPredicateDefinition(PredicateDefinition predicateDefinition) {
+        private void collectPredicateDefinition(PredicateDefinition predicateDefinition, ModelStoreBuilder storeBuilder) {
                 var partialRelation = getPartialRelation(predicateDefinition);
                 var query = toQuery(partialRelation.name(), predicateDefinition);
                 boolean mutable;
@@ -488,7 +481,7 @@ public class ModelInitializer {
                 } else {
                         var seed = modelSeed.getSeed(partialRelation);
                         defaultValue = seed.reducedValue() == TruthValue.FALSE ? TruthValue.FALSE : TruthValue.UNKNOWN;
-                        var cursor = seed.getCursor(defaultValue, getNodeCount());
+                        var cursor = seed.getCursor(defaultValue, problemTrace.getNodeTrace().size());
                         // The symbol should be mutable if there is at least one non-default entry in the seed.
                         mutable = cursor.move();
                 }
@@ -652,8 +645,8 @@ public class ModelInitializer {
                 if (newNode == null) {
                         throw new TracedException(typeScope, "Target of incremental type scope must be concrete class");
                 }
-                int newNodeId = nodeTrace.get(newNode);
-                var type = relationTrace.get(classDeclaration);
+                int newNodeId = getNodeId(newNode);
+                var type = problemTrace.getPartialRelation(classDeclaration);
                 var typeInfo = metamodel.typeHierarchy().getAnalysisResult(type);
                 if (!typeInfo.getDirectSubtypes().isEmpty()) {
                         throw new TracedException(typeScope, "Target of incremental type scope cannot have any subclasses");
@@ -664,10 +657,7 @@ public class ModelInitializer {
         }
 
         private void collectTypeScope(TypeScope typeScope) {
-                var type = relationTrace.get(typeScope.getTargetType());
-                if (type == null) {
-                        throw new TracedException(typeScope, "Unknown target type");
-                }
+                var type = problemTrace.getPartialRelation(typeScope.getTargetType());
                 var interval = getCardinalityInterval(typeScope.getMultiplicity());
                 if (scopePropagator == null) {
                         scopePropagator = new ScopePropagator();
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemTrace.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ProblemTrace.java
index f7963c58..b8d0b804 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemTrace.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ProblemTrace.java
@@ -3,33 +3,44 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.generator;
+package tools.refinery.language.semantics;
 
+import org.eclipse.collections.api.map.primitive.ObjectIntMap;
 import org.eclipse.xtext.naming.QualifiedName;
+import tools.refinery.language.model.problem.Node;
 import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.model.problem.Relation;
-import tools.refinery.language.semantics.metadata.NodeMetadata;
-import tools.refinery.language.semantics.metadata.RelationMetadata;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
+import tools.refinery.store.reasoning.translator.metamodel.Metamodel;
 
-import java.util.List;
 import java.util.Map;
 
 public interface ProblemTrace {
         Problem getProblem();
 
+        Metamodel getMetamodel();
+
+        ObjectIntMap<Node> getNodeTrace();
+
+        int getNodeId(Node node);
+
+        int getNodeId(QualifiedName qualifiedName);
+
+        int getNodeId(String qualifiedName);
+
         Map<Relation, PartialRelation> getRelationTrace();
 
-        Relation getInverseTrace(AnyPartialSymbol partialSymbol);
+        Map<AnyPartialSymbol, Relation> getInverseRelationTrace();
+
+        Relation getRelation(AnyPartialSymbol partialSymbol);
+
+        RuntimeException wrapException(TranslationException translationException);
 
         PartialRelation getPartialRelation(Relation relation);
 
         PartialRelation getPartialRelation(QualifiedName qualifiedName);
 
         PartialRelation getPartialRelation(String qualifiedName);
-
-        List<RelationMetadata> getRelationsMetadata();
-
-        List<NodeMetadata> getNodesMetadata(int nodeCount, boolean preserveNewNodes);
 }
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ProblemTraceImpl.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ProblemTraceImpl.java
new file mode 100644
index 00000000..cc634949
--- /dev/null
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ProblemTraceImpl.java
@@ -0,0 +1,187 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.semantics;
+
+import com.google.inject.Inject;
+import org.eclipse.collections.api.factory.primitive.ObjectIntMaps;
+import org.eclipse.collections.api.map.primitive.MutableObjectIntMap;
+import org.eclipse.collections.api.map.primitive.ObjectIntMap;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.scoping.IScope;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import tools.refinery.language.model.problem.Node;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.model.problem.ProblemPackage;
+import tools.refinery.language.model.problem.Relation;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
+import tools.refinery.store.reasoning.translator.metamodel.Metamodel;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class ProblemTraceImpl implements ProblemTrace {
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        @Inject
+        private SemanticsUtils semanticsUtils;
+
+        @Inject
+        private IScopeProvider scopeProvider;
+
+        private Problem problem;
+        private Metamodel metamodel;
+        private final MutableObjectIntMap<Node> mutableNodeTrace = ObjectIntMaps.mutable.empty();
+        private final ObjectIntMap<Node> nodeTrace = mutableNodeTrace.asUnmodifiable();
+        private final Map<Relation, PartialRelation> mutableRelationTrace = new LinkedHashMap<>();
+        private final Map<Relation, PartialRelation> relationTrace =
+                        Collections.unmodifiableMap(mutableRelationTrace);
+        private final Map<AnyPartialSymbol, Relation> mutableInverseTrace = new HashMap<>();
+        private final Map<AnyPartialSymbol, Relation> inverseTrace = Collections.unmodifiableMap(mutableInverseTrace);
+
+        @Override
+        public Problem getProblem() {
+                return problem;
+        }
+
+        void setProblem(Problem problem) {
+                this.problem = problem;
+        }
+
+        @Override
+        public Metamodel getMetamodel() {
+                return metamodel;
+        }
+
+        void setMetamodel(Metamodel metamodel) {
+                this.metamodel = metamodel;
+        }
+
+        @Override
+        public ObjectIntMap<Node> getNodeTrace() {
+                return nodeTrace;
+        }
+
+        void collectNode(Node node) {
+                mutableNodeTrace.getIfAbsentPut(node, mutableNodeTrace.size());
+        }
+
+        @Override
+        public int getNodeId(Node node) {
+                try {
+                        return nodeTrace.getOrThrow(node);
+                } catch (IllegalStateException e) {
+                        var qualifiedName = semanticsUtils.getName(node);
+                        throw new TracedException(node, "No node ID for " + qualifiedName, e);
+                }
+        }
+
+        @Override
+        public int getNodeId(QualifiedName qualifiedName) {
+                var nodeScope = scopeProvider.getScope(problem, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE);
+                return getNodeId(getElement(nodeScope, qualifiedName, Node.class));
+        }
+
+        @Override
+        public int getNodeId(String qualifiedName) {
+                var convertedName = qualifiedNameConverter.toQualifiedName(qualifiedName);
+                return getNodeId(convertedName);
+        }
+
+        @Override
+        public Map<Relation, PartialRelation> getRelationTrace() {
+                return relationTrace;
+        }
+
+        void putRelation(Relation relation, PartialRelation partialRelation) {
+                var oldPartialRelation = mutableRelationTrace.put(relation, partialRelation);
+                if (oldPartialRelation != null) {
+                        throw new TracedException(relation, "Relation already mapped to partial relation: " + oldPartialRelation);
+                }
+                var oldRelation = mutableInverseTrace.put(partialRelation, relation);
+                if (oldRelation != null) {
+                        throw new TracedException(oldRelation, "Partial relation %s was already mapped to relation"
+                                        .formatted(partialRelation));
+                }
+        }
+
+        @Override
+        public Map<AnyPartialSymbol, Relation> getInverseRelationTrace() {
+                return inverseTrace;
+        }
+
+        @Override
+        public Relation getRelation(AnyPartialSymbol partialSymbol) {
+                var relation = mutableInverseTrace.get(partialSymbol);
+                if (relation == null) {
+                        throw new IllegalArgumentException("No relation for partial symbol: " + partialSymbol);
+                }
+                return relation;
+        }
+
+        @Override
+        public RuntimeException wrapException(TranslationException translationException) {
+                var partialSymbol = translationException.getPartialSymbol();
+                if (partialSymbol == null) {
+                        return translationException;
+                }
+                var relation = mutableInverseTrace.get(partialSymbol);
+                if (relation == null) {
+                        return translationException;
+                }
+                return new TracedException(relation, translationException);
+        }
+
+        @Override
+        public PartialRelation getPartialRelation(Relation relation) {
+                var partialRelation = mutableRelationTrace.get(relation);
+                if (partialRelation == null) {
+                        var qualifiedName = semanticsUtils.getName(relation);
+                        throw new TracedException(relation, "No partial relation for " + qualifiedName);
+                }
+                return partialRelation;
+        }
+
+        @Override
+        public PartialRelation getPartialRelation(QualifiedName qualifiedName) {
+                var relationScope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__RELATION);
+                return getPartialRelation(getElement(relationScope, qualifiedName, Relation.class));
+        }
+
+        @Override
+        public PartialRelation getPartialRelation(String qualifiedName) {
+                var convertedName = qualifiedNameConverter.toQualifiedName(qualifiedName);
+                return getPartialRelation(convertedName);
+        }
+
+        private <T> T getElement(IScope scope, QualifiedName qualifiedName, Class<T> type) {
+                var iterator = scope.getElements(qualifiedName).iterator();
+                if (!iterator.hasNext()) {
+                        var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
+                        throw new IllegalArgumentException("No such %s: %s"
+                                        .formatted(type.getName(), qualifiedNameString));
+                }
+                var eObjectDescription = iterator.next();
+                if (iterator.hasNext()) {
+                        var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
+                        throw new IllegalArgumentException("Ambiguous %s: %s"
+                                        .formatted(type.getName(), qualifiedNameString));
+                }
+                var eObject = EcoreUtil.resolve(eObjectDescription.getEObjectOrProxy(), getProblem());
+                if (!type.isInstance(eObject)) {
+                        var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
+                        throw new IllegalArgumentException("Not a %s: %s"
+                                        .formatted(type.getName(), qualifiedNameString));
+                }
+                return type.cast(eObject);
+        }
+}
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/SemanticsUtils.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SemanticsUtils.java
index 47c89e9b..b195a8e7 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/SemanticsUtils.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SemanticsUtils.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model;
+package tools.refinery.language.semantics;
 
 import com.google.inject.Inject;
 import com.google.inject.Singleton;
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/TracedException.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/TracedException.java
index 38fd8a67..8636bdab 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/TracedException.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/TracedException.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model;
+package tools.refinery.language.semantics;
 
 import org.eclipse.emf.ecore.EObject;
 
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/DecisionTree.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTree.java
index 32112e61..c732f784 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/DecisionTree.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTree.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model.internal;
+package tools.refinery.language.semantics.internal;
 
 import org.eclipse.collections.api.factory.primitive.IntObjectMaps;
 import tools.refinery.store.map.Cursor;
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/DecisionTreeCursor.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTreeCursor.java
index a9fc644a..71b54cbd 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/DecisionTreeCursor.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTreeCursor.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model.internal;
+package tools.refinery.language.semantics.internal;
 
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.representation.TruthValue;
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/DecisionTreeNode.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTreeNode.java
index 3c54e3c5..ebca2634 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/DecisionTreeNode.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTreeNode.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model.internal;
+package tools.refinery.language.semantics.internal;
 
 import org.eclipse.collections.api.LazyIntIterable;
 import tools.refinery.store.tuple.Tuple;
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/DecisionTreeValue.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTreeValue.java
index 915ae2bf..5053e7ac 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/DecisionTreeValue.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTreeValue.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model.internal;
+package tools.refinery.language.semantics.internal;
 
 import tools.refinery.store.representation.TruthValue;
 
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/IntermediateNode.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/IntermediateNode.java
index e6f01d48..0e2f5d18 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/IntermediateNode.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/IntermediateNode.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model.internal;
+package tools.refinery.language.semantics.internal;
 
 import org.eclipse.collections.api.LazyIntIterable;
 import org.eclipse.collections.api.factory.primitive.IntObjectMaps;
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/MutableSeed.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/MutableSeed.java
index 99019e2a..693b9e1f 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/MutableSeed.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/MutableSeed.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model.internal;
+package tools.refinery.language.semantics.internal;
 
 import tools.refinery.store.reasoning.seed.Seed;
 import tools.refinery.store.representation.TruthValue;
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/NullaryMutableSeed.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/NullaryMutableSeed.java
index 80644b1f..7a72c656 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/NullaryMutableSeed.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/NullaryMutableSeed.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model.internal;
+package tools.refinery.language.semantics.internal;
 
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.map.Cursors;
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/TerminalNode.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/TerminalNode.java
index ce49aa62..d3dd757c 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/TerminalNode.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/TerminalNode.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model.internal;
+package tools.refinery.language.semantics.internal;
 
 import org.eclipse.collections.api.LazyIntIterable;
 import org.eclipse.collections.api.factory.primitive.IntObjectMaps;
diff --git a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/CountPropagationTest.java b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/CountPropagationTest.java
index 6beae93a..b679c1ef 100644
--- a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/CountPropagationTest.java
+++ b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/CountPropagationTest.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model;
+package tools.refinery.language.semantics;
 
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.dse.propagation.PropagationAdapter;
diff --git a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/ModelGenerationTest.java b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/ModelGenerationTest.java
index c8a79c37..899e3cb3 100644
--- a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/ModelGenerationTest.java
+++ b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/ModelGenerationTest.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model;
+package tools.refinery.language.semantics;
 
 import com.google.inject.Inject;
 import org.eclipse.xtext.testing.InjectWith;
diff --git a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/internal/DecisionTreeTests.java b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/internal/DecisionTreeTests.java
index 5d039308..2320de2c 100644
--- a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/internal/DecisionTreeTests.java
+++ b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/internal/DecisionTreeTests.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model.internal;
+package tools.refinery.language.semantics.internal;
 
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.representation.TruthValue;
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationSuccessResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationSuccessResult.java
index 21be4e08..0abe116e 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationSuccessResult.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationSuccessResult.java
@@ -6,8 +6,8 @@
 package tools.refinery.language.web.generator;
 
 import com.google.gson.JsonObject;
-import tools.refinery.language.semantics.metadata.NodeMetadata;
-import tools.refinery.language.semantics.metadata.RelationMetadata;
+import tools.refinery.language.web.semantics.metadata.NodeMetadata;
+import tools.refinery.language.web.semantics.metadata.RelationMetadata;
 
 import java.util.List;
 import java.util.UUID;
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java
index 7b4f957c..a3b6ca82 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java
@@ -9,12 +9,14 @@ import com.google.inject.Inject;
 import org.eclipse.xtext.service.OperationCanceledManager;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import tools.refinery.generator.ModelGeneratorBuilder;
+import tools.refinery.generator.ModelGenerator;
+import tools.refinery.generator.ModelGeneratorFactory;
+import tools.refinery.language.web.semantics.metadata.MetadataCreator;
+import tools.refinery.generator.ProblemLoader;
 import tools.refinery.generator.ValidationErrorsException;
 import tools.refinery.language.web.semantics.PartialInterpretation2Json;
 import tools.refinery.language.web.xtext.server.ThreadPoolExecutorServiceProvider;
 import tools.refinery.language.web.xtext.server.push.PushWebDocument;
-import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.util.CancellationToken;
 
 import java.io.IOException;
@@ -38,7 +40,13 @@ public class ModelGenerationWorker implements Runnable {
         private OperationCanceledManager operationCanceledManager;
 
         @Inject
-        private ModelGeneratorBuilder generatorBuilder;
+        private ProblemLoader problemLoader;
+
+        @Inject
+        private ModelGeneratorFactory generatorFactory;
+
+        @Inject
+        private MetadataCreator metadataCreator;
 
         @Inject
         private PartialInterpretation2Json partialInterpretation2Json;
@@ -127,9 +135,10 @@ public class ModelGenerationWorker implements Runnable {
 
         public ModelGenerationResult doRun() throws IOException {
                 cancellationToken.checkCancelled();
+                var problem = problemLoader.cancellationToken(cancellationToken).loadString(text);
+                ModelGenerator generator;
                 try {
-                        generatorBuilder.cancellationToken(cancellationToken);
-                        generatorBuilder.fromString(text);
+                        generator = generatorFactory.cancellationToken(cancellationToken).createGenerator(problem);
                 } catch (ValidationErrorsException e) {
                         var errors = e.getErrors();
                         if (errors != null && !errors.isEmpty()) {
@@ -137,20 +146,19 @@ public class ModelGenerationWorker implements Runnable {
                         }
                         throw e;
                 }
-                var generator = generatorBuilder.build();
                 notifyResult(new ModelGenerationStatusResult(uuid, "Generating model"));
                 generator.setRandomSeed(randomSeed);
-                if (!generator.tryRun()) {
+                if (!generator.tryGenerate()) {
                         return new ModelGenerationErrorResult(uuid, "Problem is unsatisfiable");
                 }
                 notifyResult(new ModelGenerationStatusResult(uuid, "Saving generated model"));
                 cancellationToken.checkCancelled();
-                var nodesMetadata = generator.getNodesMetadata();
+                metadataCreator.setProblemTrace(generator.getProblemTrace());
+                var nodesMetadata = metadataCreator.getNodesMetadata(generator.getModel(), false);
                 cancellationToken.checkCancelled();
-                var relationsMetadata = generator.getProblemTrace().getRelationsMetadata();
+                var relationsMetadata = metadataCreator.getRelationsMetadata();
                 cancellationToken.checkCancelled();
-                var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(generator,
-                                Concreteness.CANDIDATE, cancellationToken);
+                var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(generator, cancellationToken);
                 return new ModelGenerationSuccessResult(uuid, nodesMetadata, relationsMetadata, partialInterpretation);
         }
 
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/PartialInterpretation2Json.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/PartialInterpretation2Json.java
index 7afed5c0..efe04592 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/PartialInterpretation2Json.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/PartialInterpretation2Json.java
@@ -9,12 +9,10 @@ import com.google.gson.JsonArray;
 import com.google.gson.JsonObject;
 import com.google.inject.Inject;
 import com.google.inject.Singleton;
-import tools.refinery.generator.AbstractRefinery;
-import tools.refinery.language.semantics.model.SemanticsUtils;
+import tools.refinery.generator.ModelFacade;
+import tools.refinery.language.semantics.SemanticsUtils;
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.model.Model;
-import tools.refinery.store.reasoning.ReasoningAdapter;
-import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
 import tools.refinery.store.tuple.Tuple;
@@ -27,15 +25,13 @@ public class PartialInterpretation2Json {
         @Inject
         private SemanticsUtils semanticsUtils;
 
-        public JsonObject getPartialInterpretation(AbstractRefinery refinery, Concreteness concreteness,
-                                                                                           CancellationToken cancellationToken) {
-                var model = refinery.getModel();
-                var adapter = model.getAdapter(ReasoningAdapter.class);
+        public JsonObject getPartialInterpretation(ModelFacade facade, CancellationToken cancellationToken) {
+                var model = facade.getModel();
                 var json = new JsonObject();
-                for (var entry : refinery.getProblemTrace().getRelationTrace().entrySet()) {
+                for (var entry : facade.getProblemTrace().getRelationTrace().entrySet()) {
                         var relation = entry.getKey();
                         var partialSymbol = entry.getValue();
-                        var tuples = getTuplesJson(adapter, concreteness, partialSymbol);
+                        var tuples = getTuplesJson(facade, partialSymbol);
                         var name = semanticsUtils.getName(relation).orElse(partialSymbol.name());
                         json.add(name, tuples);
                         cancellationToken.checkCancelled();
@@ -44,9 +40,8 @@ public class PartialInterpretation2Json {
                 return json;
         }
 
-        private static JsonArray getTuplesJson(ReasoningAdapter adapter, Concreteness concreteness,
-                                                                                   PartialRelation partialSymbol) {
-                var interpretation = adapter.getPartialInterpretation(concreteness, partialSymbol);
+        private static JsonArray getTuplesJson(ModelFacade facade, PartialRelation partialSymbol) {
+                var interpretation = facade.getPartialInterpretation(partialSymbol);
                 var cursor = interpretation.getAll();
                 return getTuplesJson(cursor);
         }
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsSuccessResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsSuccessResult.java
index 350b0b2b..f26fa2b2 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsSuccessResult.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsSuccessResult.java
@@ -6,8 +6,8 @@
 package tools.refinery.language.web.semantics;
 
 import com.google.gson.JsonObject;
-import tools.refinery.language.semantics.metadata.NodeMetadata;
-import tools.refinery.language.semantics.metadata.RelationMetadata;
+import tools.refinery.language.web.semantics.metadata.NodeMetadata;
+import tools.refinery.language.web.semantics.metadata.RelationMetadata;
 
 import java.util.List;
 
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java
index a8f16c84..44974869 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java
@@ -16,10 +16,10 @@ import org.eclipse.xtext.validation.IDiagnosticConverter;
 import org.eclipse.xtext.validation.Issue;
 import org.eclipse.xtext.web.server.validation.ValidationResult;
 import tools.refinery.generator.ModelSemantics;
-import tools.refinery.generator.ModelSemanticsBuilder;
+import tools.refinery.generator.ModelSemanticsFactory;
 import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.semantics.model.TracedException;
-import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.language.web.semantics.metadata.MetadataCreator;
+import tools.refinery.language.semantics.TracedException;
 import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.util.CancellationToken;
 
@@ -30,16 +30,19 @@ class SemanticsWorker implements Callable<SemanticsResult> {
         private static final String DIAGNOSTIC_ID = "tools.refinery.language.semantics.SemanticError";
 
         @Inject
-        private PartialInterpretation2Json partialInterpretation2Json;
-
-        @Inject
         private OperationCanceledManager operationCanceledManager;
 
         @Inject
         private IDiagnosticConverter diagnosticConverter;
 
         @Inject
-        private ModelSemanticsBuilder semanticsBuilder;
+        private ModelSemanticsFactory semanticsFactory;
+
+        @Inject
+        private MetadataCreator metadataCreator;
+
+        @Inject
+        private PartialInterpretation2Json partialInterpretation2Json;
 
         private Problem problem;
 
@@ -56,13 +59,10 @@ class SemanticsWorker implements Callable<SemanticsResult> {
 
         @Override
         public SemanticsResult call() {
-                semanticsBuilder.cancellationToken(cancellationToken);
                 cancellationToken.checkCancelled();
                 ModelSemantics semantics;
                 try {
-                        semanticsBuilder.problem(problem);
-                        cancellationToken.checkCancelled();
-                        semantics = semanticsBuilder.build();
+                        semantics = semanticsFactory.cancellationToken(cancellationToken).createSemantics(problem);
                 } catch (TranslationException e) {
                         return new SemanticsInternalErrorResult(e.getMessage());
                 } catch (TracedException e) {
@@ -72,12 +72,12 @@ class SemanticsWorker implements Callable<SemanticsResult> {
                         return getTracedErrorResult(e.getSourceElement(), message);
                 }
                 cancellationToken.checkCancelled();
-                var nodesMetadata = semantics.getNodesMetadata();
+                metadataCreator.setProblemTrace(semantics.getProblemTrace());
+                var nodesMetadata = metadataCreator.getNodesMetadata(semantics.getModel(), true);
                 cancellationToken.checkCancelled();
-                var relationsMetadata = semantics.getProblemTrace().getRelationsMetadata();
+                var relationsMetadata = metadataCreator.getRelationsMetadata();
                 cancellationToken.checkCancelled();
-                var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(semantics,
-                                Concreteness.PARTIAL, cancellationToken);
+                var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(semantics, cancellationToken);
                 return new SemanticsSuccessResult(nodesMetadata, relationsMetadata, partialInterpretation);
         }
 
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/BuiltInDetail.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/BuiltInDetail.java
index 6f706069..27eb7ad7 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/BuiltInDetail.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/BuiltInDetail.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.metadata;
+package tools.refinery.language.web.semantics.metadata;
 
 public record BuiltInDetail() implements RelationDetail {
         public static final BuiltInDetail INSTANCE = new BuiltInDetail();
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/ClassDetail.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/ClassDetail.java
index 1d3190f5..42495950 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/ClassDetail.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/ClassDetail.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.metadata;
+package tools.refinery.language.web.semantics.metadata;
 
 public record ClassDetail(boolean abstractClass) implements RelationDetail {
         public static final ClassDetail CONCRETE_CLASS = new ClassDetail(false);
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/Metadata.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/Metadata.java
index d2dcb43a..5e1fac05 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/Metadata.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/Metadata.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.metadata;
+package tools.refinery.language.web.semantics.metadata;
 
 public sealed interface Metadata permits NodeMetadata, RelationMetadata {
         String name();
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/MetadataCreator.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/MetadataCreator.java
index 3694f5f4..3fbc5d2d 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/MetadataCreator.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/MetadataCreator.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.metadata;
+package tools.refinery.language.web.semantics.metadata;
 
 import com.google.inject.Inject;
 import org.eclipse.emf.ecore.EObject;
@@ -13,12 +13,17 @@ import org.eclipse.xtext.naming.QualifiedName;
 import org.eclipse.xtext.scoping.IScope;
 import org.eclipse.xtext.scoping.IScopeProvider;
 import tools.refinery.language.model.problem.*;
-import tools.refinery.language.semantics.model.ModelInitializer;
-import tools.refinery.language.semantics.model.TracedException;
+import tools.refinery.language.semantics.ProblemTrace;
+import tools.refinery.language.semantics.TracedException;
 import tools.refinery.language.utils.ProblemUtil;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
 
 public class MetadataCreator {
         @Inject
@@ -30,18 +35,18 @@ public class MetadataCreator {
         @Inject
         private IQualifiedNameConverter qualifiedNameConverter;
 
-        private ModelInitializer initializer;
+        private ProblemTrace problemTrace;
 
         private IScope nodeScope;
 
         private IScope relationScope;
 
-        public void setInitializer(ModelInitializer initializer) {
-                if (initializer == null) {
-                        throw new IllegalArgumentException("Initializer was already set");
+        public void setProblemTrace(ProblemTrace problemTrace) {
+                if (this.problemTrace != null) {
+                        throw new IllegalArgumentException("Problem trace was already set");
                 }
-                this.initializer = initializer;
-                var problem = initializer.getProblem();
+                this.problemTrace = problemTrace;
+                var problem = problemTrace.getProblem();
                 nodeScope = scopeProvider.getScope(problem, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE);
                 relationScope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__RELATION);
         }
@@ -50,13 +55,11 @@ public class MetadataCreator {
                 return "::" + nodeId;
         }
 
-        public List<NodeMetadata> getNodesMetadata() {
-                return getNodesMetadata(initializer.getNodeCount(), true);
-        }
-
-        public List<NodeMetadata> getNodesMetadata(int nodeCount, boolean preserveNewNodes) {
-                var nodes = new NodeMetadata[Math.max(initializer.getNodeCount(), nodeCount)];
-                for (var entry : initializer.getNodeTrace().keyValuesView()) {
+        public List<NodeMetadata> getNodesMetadata(Model model, boolean preserveNewNodes) {
+                int nodeCount = model.getAdapter(ReasoningAdapter.class).getNodeCount();
+                var nodeTrace = problemTrace.getNodeTrace();
+                var nodes = new NodeMetadata[Math.max(nodeTrace.size(), nodeCount)];
+                for (var entry : nodeTrace.keyValuesView()) {
                         var node = entry.getOne();
                         var id = entry.getTwo();
                         nodes[id] = getNodeMetadata(id, node, preserveNewNodes);
@@ -95,7 +98,7 @@ public class MetadataCreator {
         }
 
         public List<RelationMetadata> getRelationsMetadata() {
-                var relationTrace = initializer.getRelationTrace();
+                var relationTrace = problemTrace.getRelationTrace();
                 var relations = new ArrayList<RelationMetadata>(relationTrace.size());
                 for (var entry : relationTrace.entrySet()) {
                         var relation = entry.getKey();
@@ -142,7 +145,7 @@ public class MetadataCreator {
         }
 
         private RelationDetail getReferenceDetail(PartialRelation partialRelation) {
-                var metamodel = initializer.getMetamodel();
+                var metamodel = problemTrace.getMetamodel();
                 var opposite = metamodel.oppositeReferences().get(partialRelation);
                 if (opposite == null) {
                         boolean isContainment = metamodel.containmentHierarchy().containsKey(partialRelation);
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/NodeKind.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/NodeKind.java
index 01f0cd09..fa863bc2 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/NodeKind.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/NodeKind.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.metadata;
+package tools.refinery.language.web.semantics.metadata;
 
 public enum NodeKind {
         IMPLICIT,
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/NodeMetadata.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/NodeMetadata.java
index 812952c0..5da28acf 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/NodeMetadata.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/NodeMetadata.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.metadata;
+package tools.refinery.language.web.semantics.metadata;
 
 public record NodeMetadata(String name, String simpleName, NodeKind kind) implements Metadata {
 }
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/OppositeReferenceDetail.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/OppositeReferenceDetail.java
index 26d7461c..98e7fec8 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/OppositeReferenceDetail.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/OppositeReferenceDetail.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.metadata;
+package tools.refinery.language.web.semantics.metadata;
 
 public record OppositeReferenceDetail(boolean container, String opposite) implements RelationDetail {
 }
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/PredicateDetail.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/PredicateDetail.java
index ca397eca..d4ac4b65 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/PredicateDetail.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/PredicateDetail.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.metadata;
+package tools.refinery.language.web.semantics.metadata;
 
 public record PredicateDetail(boolean error) implements RelationDetail {
         public static final PredicateDetail PREDICATE = new PredicateDetail(false);
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/ReferenceDetail.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/ReferenceDetail.java
index 36771566..42799417 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/ReferenceDetail.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/ReferenceDetail.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.metadata;
+package tools.refinery.language.web.semantics.metadata;
 
 public record ReferenceDetail(boolean containment) implements RelationDetail {
         public static final ReferenceDetail CROSS_REFERENCE = new ReferenceDetail(false);
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/RelationDetail.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/RelationDetail.java
index 105179fd..bbe563cd 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/RelationDetail.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/RelationDetail.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.metadata;
+package tools.refinery.language.web.semantics.metadata;
 
 public sealed interface RelationDetail permits ClassDetail, ReferenceDetail, PredicateDetail, OppositeReferenceDetail,
                 BuiltInDetail {
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/RelationMetadata.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/RelationMetadata.java
index 5abcc253..e5d3a091 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/RelationMetadata.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/RelationMetadata.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.metadata;
+package tools.refinery.language.web.semantics.metadata;
 
 public record RelationMetadata(String name, String simpleName, int arity, RelationDetail detail) implements Metadata {
 }
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/servlet/XtextWebSocket.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/servlet/XtextWebSocket.java
index 1fde1be5..818bd80e 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/servlet/XtextWebSocket.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/servlet/XtextWebSocket.java
@@ -17,7 +17,7 @@ import org.eclipse.xtext.resource.IResourceServiceProvider;
 import org.eclipse.xtext.web.server.ISession;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import tools.refinery.language.semantics.metadata.*;
+import tools.refinery.language.web.semantics.metadata.*;
 import tools.refinery.language.web.xtext.server.ResponseHandler;
 import tools.refinery.language.web.xtext.server.ResponseHandlerException;
 import tools.refinery.language.web.xtext.server.TransactionExecutor;