Merge pull request #47 from kris7t/generator-facade

Generator facade

45 files changed, 912 insertions, 263 deletions

diff --git a/settings.gradle.kts b/settings.gradle.kts
index 0a9d4ca5..40df30ff 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -8,6 +8,7 @@ rootProject.name = "refinery"
 
 include(
                 "frontend",
+                "generator",
                 "interpreter",
                 "interpreter-localsearch",
                 "interpreter-rete",
diff --git a/subprojects/generator/build.gradle.kts b/subprojects/generator/build.gradle.kts
new file mode 100644
index 00000000..d87ce6de
--- /dev/null
+++ b/subprojects/generator/build.gradle.kts
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+plugins {
+        id("tools.refinery.gradle.java-library")
+}
+
+dependencies {
+        api(project(":refinery-language-semantics"))
+        api(libs.eclipseCollections.api)
+        implementation(project(":refinery-store-query-interpreter"))
+}
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
new file mode 100644
index 00000000..5b44c10a
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
@@ -0,0 +1,71 @@
+/*
+ * 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.dse.strategy.BestFirstStoreManager;
+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;
+
+public class ModelGenerator extends ModelFacade {
+        private final Version initialVersion;
+
+        private int randomSeed = 0;
+
+        private boolean lastGenerationSuccessful;
+
+        public ModelGenerator(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed) {
+                super(problemTrace, store, modelSeed, Concreteness.CANDIDATE);
+                initialVersion = getModel().commit();
+        }
+
+        public int getRandomSeed() {
+                return randomSeed;
+        }
+
+        public void setRandomSeed(int randomSeed) {
+                this.randomSeed = randomSeed;
+                this.lastGenerationSuccessful = false;
+        }
+
+        public boolean isLastGenerationSuccessful() {
+                return lastGenerationSuccessful;
+        }
+
+        // This method only makes sense if it returns {@code true} on success.
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+        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;
+                }
+                getModel().restore(solutions.get(0).version());
+                lastGenerationSuccessful = true;
+                return true;
+        }
+
+        public void generate() {
+                if (!tryGenerate()) {
+                        throw new UnsatisfiableProblemException();
+                }
+        }
+
+        @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/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
new file mode 100644
index 00000000..bc02c887
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java
@@ -0,0 +1,17 @@
+/*
+ * 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.ModelStore;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.seed.ModelSeed;
+
+public class ModelSemantics extends ModelFacade {
+        public ModelSemantics(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed) {
+                super(problemTrace, store, modelSeed, Concreteness.PARTIAL);
+        }
+}
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/UnsatisfiableProblemException.java b/subprojects/generator/src/main/java/tools/refinery/generator/UnsatisfiableProblemException.java
new file mode 100644
index 00000000..4fb18b90
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/UnsatisfiableProblemException.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+public class UnsatisfiableProblemException extends RuntimeException {
+        public UnsatisfiableProblemException() {
+                super("Model generation problem was unsatisfiable");
+        }
+}
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ValidationErrorsException.java b/subprojects/generator/src/main/java/tools/refinery/generator/ValidationErrorsException.java
new file mode 100644
index 00000000..d668e51d
--- /dev/null
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ValidationErrorsException.java
@@ -0,0 +1,64 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.validation.Issue;
+
+import java.util.List;
+
+public class ValidationErrorsException extends IllegalArgumentException {
+        private final transient URI resourceUri;
+
+        private final String resourceUriString;
+
+        private final transient List<Issue> errors;
+
+        private final List<String> errorStrings;
+
+        public ValidationErrorsException(URI resourceUri, List<Issue> errors) {
+                this.resourceUri = resourceUri;
+                resourceUriString = resourceUri.toString();
+                this.errors = errors;
+                errorStrings = errors.stream()
+                                .map(Issue::toString)
+                                .toList();
+        }
+
+        public URI getResourceUri() {
+                return resourceUri;
+        }
+
+        public String getResourceUriString() {
+                return resourceUriString;
+        }
+
+        public List<Issue> getErrors() {
+                return errors;
+        }
+
+        public List<String> getErrorStrings() {
+                return errorStrings;
+        }
+
+        @Override
+        public String getMessage() {
+                var builder = new StringBuilder();
+                builder.append("Validation errors in resource ");
+                builder.append(resourceUriString);
+                builder.append(": ");
+                var iterator = errorStrings.iterator();
+                if (!iterator.hasNext()) {
+                        return builder.toString();
+                }
+                builder.append(iterator.next());
+                while (iterator.hasNext()) {
+                        builder.append(",\n");
+                        builder.append(iterator.next());
+                }
+                return builder.toString();
+        }
+}
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 85c8d701..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 Map<Relation, PartialRelation> relationTrace;
-
         private final MetamodelBuilder metamodelBuilder = Metamodel.builder();
 
         private Metamodel metamodel;
@@ -80,79 +73,89 @@ public class ModelInitializer {
 
         private ModelSeed modelSeed;
 
-        public Problem getProblem() {
-                return problem;
-        }
-
-        public int getNodeCount() {
-                return nodeTrace.size();
+        public void readProblem(Problem problem) {
+                if (this.problem != null) {
+                        throw new IllegalArgumentException("Problem was already set");
+                }
+                this.problem = problem;
+                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 MutableObjectIntMap<Node> getNodeTrace() {
-                return nodeTrace;
+        public void configureStoreBuilder(ModelStoreBuilder storeBuilder) {
+                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);
+                        }
+                        collectPredicates(storeBuilder);
+                } catch (TranslationException e) {
+                        throw problemTrace.wrapException(e);
+                }
         }
 
-        public Map<Relation, PartialRelation> getRelationTrace() {
-                return relationTrace;
+        private void checkProblem() {
+                if (problem == null) {
+                        throw new IllegalStateException("Problem is not set");
+                }
         }
 
-        public Relation getInverseTrace(AnyPartialSymbol partialRelation) {
-                return inverseTrace.get(partialRelation);
+        public ModelSeed createModel(Problem problem, ModelStoreBuilder storeBuilder) {
+                readProblem(problem);
+                configureStoreBuilder(storeBuilder);
+                return getModelSeed();
         }
 
-        public Metamodel getMetamodel() {
-                return metamodel;
+        public ProblemTrace getProblemTrace() {
+                checkProblem();
+                return problemTrace;
         }
 
-        public ModelSeed createModel(Problem problem, ModelStoreBuilder storeBuilder) {
-                this.problem = problem;
-                this.storeBuilder = storeBuilder;
-                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();
-                storeBuilder.with(new MultiObjectTranslator());
-                storeBuilder.with(new MetamodelTranslator(metamodel));
-                relationTrace = new LinkedHashMap<>(relationInfoMap.size());
-                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();
-                if (scopePropagator != null) {
-                        if (storeBuilder.tryGetAdapter(PropagationBuilder.class).isEmpty()) {
-                                throw new TracedException(problem, "Type scopes require a PropagationBuilder");
-                        }
-                        storeBuilder.with(scopePropagator);
-                }
-                modelSeedBuilder.seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
-                                .reducedValue(CardinalityIntervals.SET)
-                                .putAll(countSeed));
-                modelSeed = modelSeedBuilder.build();
-                collectPredicates();
+        public ModelSeed getModelSeed() {
+                checkProblem();
                 return modelSeed;
         }
 
@@ -179,7 +182,7 @@ public class ModelInitializer {
         }
 
         private void collectNode(Node node) {
-                nodeTrace.getIfAbsentPut(node, this::getNodeCount);
+                problemTrace.collectNode(node);
         }
 
         private void collectPartialSymbols() {
@@ -221,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,
@@ -230,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;
                 });
         }
@@ -410,7 +413,7 @@ public class ModelInitializer {
         }
 
         private int getNodeId(Node node) {
-                return nodeTrace.getOrThrow(node);
+                return problemTrace.getNodeId(node);
         }
 
         private Tuple getTuple(Assertion assertion) {
@@ -442,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();
@@ -466,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;
@@ -477,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();
                 }
@@ -641,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");
@@ -653,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/language-semantics/src/main/java/tools/refinery/language/semantics/ProblemTrace.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ProblemTrace.java
new file mode 100644
index 00000000..b8d0b804
--- /dev/null
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ProblemTrace.java
@@ -0,0 +1,46 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+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.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.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();
+
+        Map<AnyPartialSymbol, Relation> getInverseRelationTrace();
+
+        Relation getRelation(AnyPartialSymbol partialSymbol);
+
+        RuntimeException wrapException(TranslationException translationException);
+
+        PartialRelation getPartialRelation(Relation relation);
+
+        PartialRelation getPartialRelation(QualifiedName qualifiedName);
+
+        PartialRelation getPartialRelation(String qualifiedName);
+}
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/build.gradle.kts b/subprojects/language-web/build.gradle.kts
index 2370794d..c3a0b7e9 100644
--- a/subprojects/language-web/build.gradle.kts
+++ b/subprojects/language-web/build.gradle.kts
@@ -15,11 +15,9 @@ val webapp: Configuration by configurations.creating {
 }
 
 dependencies {
+        implementation(project(":refinery-generator"))
         implementation(project(":refinery-language"))
         implementation(project(":refinery-language-ide"))
-        implementation(project(":refinery-language-semantics"))
-        implementation(project(":refinery-store-query-interpreter"))
-        implementation(project(":refinery-store-reasoning-scope"))
         implementation(libs.gson)
         implementation(libs.jetty.server)
         implementation(libs.jetty.servlet)
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 1fce10a4..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
@@ -6,36 +6,20 @@
 package tools.refinery.language.web.generator;
 
 import com.google.inject.Inject;
-import com.google.inject.Provider;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.xtext.diagnostics.Severity;
-import org.eclipse.xtext.resource.IResourceFactory;
-import org.eclipse.xtext.resource.XtextResourceSet;
 import org.eclipse.xtext.service.OperationCanceledManager;
-import org.eclipse.xtext.util.LazyStringInputStream;
-import org.eclipse.xtext.validation.CheckMode;
-import org.eclipse.xtext.validation.IResourceValidator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.semantics.metadata.MetadataCreator;
-import tools.refinery.language.semantics.model.ModelInitializer;
+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.dse.propagation.PropagationAdapter;
-import tools.refinery.store.dse.strategy.BestFirstStoreManager;
-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.ReasoningStoreAdapter;
-import tools.refinery.store.reasoning.literal.Concreteness;
-import tools.refinery.store.statecoding.StateCoderAdapter;
 import tools.refinery.store.util.CancellationToken;
 
 import java.io.IOException;
-import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.*;
 
@@ -56,16 +40,10 @@ public class ModelGenerationWorker implements Runnable {
         private OperationCanceledManager operationCanceledManager;
 
         @Inject
-        private Provider<XtextResourceSet> resourceSetProvider;
+        private ProblemLoader problemLoader;
 
         @Inject
-        private IResourceFactory resourceFactory;
-
-        @Inject
-        private IResourceValidator resourceValidator;
-
-        @Inject
-        private ModelInitializer initializer;
+        private ModelGeneratorFactory generatorFactory;
 
         @Inject
         private MetadataCreator metadataCreator;
@@ -157,57 +135,30 @@ public class ModelGenerationWorker implements Runnable {
 
         public ModelGenerationResult doRun() throws IOException {
                 cancellationToken.checkCancelled();
-                var resourceSet = resourceSetProvider.get();
-                var uri = URI.createURI("__synthetic_" + uuid + ".problem");
-                var resource = resourceFactory.createResource(uri);
-                resourceSet.getResources().add(resource);
-                var inputStream = new LazyStringInputStream(text);
-                resource.load(inputStream, Map.of());
-                cancellationToken.checkCancelled();
-                var issues = resourceValidator.validate(resource, CheckMode.ALL, () -> cancelled || Thread.interrupted());
-                cancellationToken.checkCancelled();
-                for (var issue : issues) {
-                        if (issue.getSeverity() == Severity.ERROR) {
-                                return new ModelGenerationErrorResult(uuid, "Validation error: " + issue.getMessage());
+                var problem = problemLoader.cancellationToken(cancellationToken).loadString(text);
+                ModelGenerator generator;
+                try {
+                        generator = generatorFactory.cancellationToken(cancellationToken).createGenerator(problem);
+                } catch (ValidationErrorsException e) {
+                        var errors = e.getErrors();
+                        if (errors != null && !errors.isEmpty()) {
+                                return new ModelGenerationErrorResult(uuid, "Validation error: " + errors.get(0).getMessage());
                         }
+                        throw e;
                 }
-                if (resource.getContents().isEmpty() || !(resource.getContents().get(0) instanceof Problem problem)) {
-                        return new ModelGenerationErrorResult(uuid, "Model generation problem not found");
-                }
-                cancellationToken.checkCancelled();
-                var storeBuilder = ModelStore.builder()
-                                .cancellationToken(cancellationToken)
-                                .with(QueryInterpreterAdapter.builder())
-                                .with(PropagationAdapter.builder())
-                                .with(StateCoderAdapter.builder())
-                                .with(DesignSpaceExplorationAdapter.builder())
-                                .with(ReasoningAdapter.builder()
-                                                .requiredInterpretations(Concreteness.CANDIDATE));
-                var modelSeed = initializer.createModel(problem, storeBuilder);
-                var store = storeBuilder.build();
-                cancellationToken.checkCancelled();
-                var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
-                var initialVersion = model.commit();
-                cancellationToken.checkCancelled();
                 notifyResult(new ModelGenerationStatusResult(uuid, "Generating model"));
-                var bestFirst = new BestFirstStoreManager(store, 1);
-                bestFirst.startExploration(initialVersion, randomSeed);
-                cancellationToken.checkCancelled();
-                var solutionStore = bestFirst.getSolutionStore();
-                if (solutionStore.getSolutions().isEmpty()) {
+                generator.setRandomSeed(randomSeed);
+                if (!generator.tryGenerate()) {
                         return new ModelGenerationErrorResult(uuid, "Problem is unsatisfiable");
                 }
                 notifyResult(new ModelGenerationStatusResult(uuid, "Saving generated model"));
-                model.restore(solutionStore.getSolutions().get(0).version());
                 cancellationToken.checkCancelled();
-                metadataCreator.setInitializer(initializer);
-                var nodesMetadata = metadataCreator.getNodesMetadata(model.getAdapter(ReasoningAdapter.class).getNodeCount(),
-                                false);
+                metadataCreator.setProblemTrace(generator.getProblemTrace());
+                var nodesMetadata = metadataCreator.getNodesMetadata(generator.getModel(), false);
                 cancellationToken.checkCancelled();
                 var relationsMetadata = metadataCreator.getRelationsMetadata();
                 cancellationToken.checkCancelled();
-                var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(initializer, model,
-                                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 5d5da8fe..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.language.semantics.model.ModelInitializer;
-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,14 +25,13 @@ public class PartialInterpretation2Json {
         @Inject
         private SemanticsUtils semanticsUtils;
 
-        public JsonObject getPartialInterpretation(ModelInitializer initializer, Model model, Concreteness concreteness,
-                                                                                           CancellationToken cancellationToken) {
-                var adapter = model.getAdapter(ReasoningAdapter.class);
+        public JsonObject getPartialInterpretation(ModelFacade facade, CancellationToken cancellationToken) {
+                var model = facade.getModel();
                 var json = new JsonObject();
-                for (var entry : initializer.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();
@@ -43,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 fb89bea6..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
@@ -15,16 +15,11 @@ import org.eclipse.xtext.validation.FeatureBasedDiagnostic;
 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.ModelSemanticsFactory;
 import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.semantics.metadata.MetadataCreator;
-import tools.refinery.language.semantics.model.ModelInitializer;
-import tools.refinery.language.semantics.model.TracedException;
-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.ReasoningStoreAdapter;
-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;
 
@@ -35,20 +30,20 @@ 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 ModelInitializer initializer;
+        private ModelSemanticsFactory semanticsFactory;
 
         @Inject
         private MetadataCreator metadataCreator;
 
+        @Inject
+        private PartialInterpretation2Json partialInterpretation2Json;
+
         private Problem problem;
 
         private CancellationToken cancellationToken;
@@ -64,36 +59,26 @@ class SemanticsWorker implements Callable<SemanticsResult> {
 
         @Override
         public SemanticsResult call() {
-                var builder = ModelStore.builder()
-                                .cancellationToken(cancellationToken)
-                                .with(QueryInterpreterAdapter.builder())
-                                .with(PropagationAdapter.builder())
-                                .with(ReasoningAdapter.builder()
-                                                .requiredInterpretations(Concreteness.PARTIAL));
                 cancellationToken.checkCancelled();
+                ModelSemantics semantics;
                 try {
-                        var modelSeed = initializer.createModel(problem, builder);
-                        cancellationToken.checkCancelled();
-                        metadataCreator.setInitializer(initializer);
-                        cancellationToken.checkCancelled();
-                        var nodesMetadata = metadataCreator.getNodesMetadata();
-                        cancellationToken.checkCancelled();
-                        var relationsMetadata = metadataCreator.getRelationsMetadata();
-                        cancellationToken.checkCancelled();
-                        var store = builder.build();
-                        cancellationToken.checkCancelled();
-                        var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
-                        cancellationToken.checkCancelled();
-                        var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(initializer, model,
-                                        Concreteness.PARTIAL, cancellationToken);
-
-                        return new SemanticsSuccessResult(nodesMetadata, relationsMetadata, partialInterpretation);
-                } catch (TracedException e) {
-                        return getTracedErrorResult(e.getSourceElement(), e.getMessage());
+                        semantics = semanticsFactory.cancellationToken(cancellationToken).createSemantics(problem);
                 } catch (TranslationException e) {
-                        var sourceElement = initializer.getInverseTrace(e.getPartialSymbol());
-                        return getTracedErrorResult(sourceElement, e.getMessage());
+                        return new SemanticsInternalErrorResult(e.getMessage());
+                } catch (TracedException e) {
+                        var cause = e.getCause();
+                        // Suppress the type of the cause exception.
+                        var message = cause == null ? e.getMessage() : cause.getMessage();
+                        return getTracedErrorResult(e.getSourceElement(), message);
                 }
+                cancellationToken.checkCancelled();
+                metadataCreator.setProblemTrace(semantics.getProblemTrace());
+                var nodesMetadata = metadataCreator.getNodesMetadata(semantics.getModel(), true);
+                cancellationToken.checkCancelled();
+                var relationsMetadata = metadataCreator.getRelationsMetadata();
+                cancellationToken.checkCancelled();
+                var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(semantics, cancellationToken);
+                return new SemanticsSuccessResult(nodesMetadata, relationsMetadata, partialInterpretation);
         }
 
         private SemanticsResult getTracedErrorResult(EObject sourceElement, String message) {
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;