refactor(langauge-web): use generator facades

11 files changed, 147 insertions, 127 deletions

diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefinery.java b/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefinery.java
index 81bf712a..56c7a23b 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefinery.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefinery.java
@@ -5,22 +5,31 @@
  */
 package tools.refinery.generator;
 
+import tools.refinery.generator.impl.ProblemTraceImpl;
+import tools.refinery.language.semantics.metadata.NodeMetadata;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.ReasoningStoreAdapter;
 import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.reasoning.translator.TranslationException;
 
-public class AbstractRefinery {
+import java.util.List;
+
+public abstract class AbstractRefinery {
         protected final ProblemTrace problemTrace;
         protected final ModelStore store;
         protected final Model model;
         protected final ReasoningAdapter reasoningAdapter;
 
-        public AbstractRefinery(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed) {
+        protected AbstractRefinery(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed) {
                 this.problemTrace = problemTrace;
                 this.store = store;
-                model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
+                try {
+                        model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
+                } catch (TranslationException e) {
+                        throw ProblemTraceImpl.wrapException(problemTrace, e);
+                }
                 reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
         }
 
@@ -35,4 +44,11 @@ public class AbstractRefinery {
         public Model getModel() {
                 return model;
         }
+
+        public List<NodeMetadata> getNodesMetadata() {
+                int nodeCount = reasoningAdapter.getNodeCount();
+                return problemTrace.getNodesMetadata(nodeCount, isPreserveNewNodes());
+        }
+
+        protected abstract boolean isPreserveNewNodes();
 }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefineryBuilder.java b/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefineryBuilder.java
index b60a3890..d4649051 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefineryBuilder.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/AbstractRefineryBuilder.java
@@ -21,6 +21,7 @@ import tools.refinery.language.semantics.model.ModelInitializer;
 import tools.refinery.store.query.ModelQueryBuilder;
 import tools.refinery.store.query.interpreter.QueryInterpreterAdapter;
 import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.util.CancellationToken;
 
 import java.io.File;
@@ -29,6 +30,8 @@ import java.io.InputStream;
 import java.util.Collection;
 import java.util.Map;
 
+// This class is used as a fluent builder.
+@SuppressWarnings("UnusedReturnValue")
 public abstract class AbstractRefineryBuilder<T> {
         @Inject
         private Provider<XtextResourceSet> resourceSetProvider;
@@ -113,8 +116,12 @@ public abstract class AbstractRefineryBuilder<T> {
                 if (problemLoaded) {
                         throw new IllegalStateException("Problem was already set");
                 }
-                initializer.readProblem(problem);
                 problemTrace.setInitializer(initializer);
+                try {
+                        initializer.readProblem(problem);
+                } catch (TranslationException e) {
+                        throw ProblemTraceImpl.wrapException(problemTrace, e);
+                }
                 problemLoaded = true;
                 return self();
         }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
index e5115352..78c807d1 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
@@ -29,6 +29,11 @@ public class ModelGenerator extends AbstractRefinery {
                 initialVersion = model.commit();
         }
 
+        @Override
+        protected boolean isPreserveNewNodes() {
+                return false;
+        }
+
         public int getRandomSeed() {
                 return randomSeed;
         }
@@ -50,6 +55,8 @@ public class ModelGenerator extends AbstractRefinery {
                                 .toList();
         }
 
+        // This method only makes sense if it returns {@code true} on success.
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
         public boolean tryRun() {
                 var iterator = run(1).iterator();
                 if (!iterator.hasNext()) {
@@ -59,6 +66,12 @@ public class ModelGenerator extends AbstractRefinery {
                 return true;
         }
 
+        public void run() {
+                if (!tryRun()) {
+                        throw new UnsatisfiableProblemException();
+                }
+        }
+
         public <A, C> PartialInterpretation<A, C> getCandidateInterpretation(PartialSymbol<A, C> partialSymbol) {
                 return reasoningAdapter.getPartialInterpretation(Concreteness.CANDIDATE, partialSymbol);
         }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java
index 8bac1910..661bc97c 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java
@@ -19,6 +19,11 @@ public class ModelSemantics extends AbstractRefinery {
                 super(problemTrace, store, modelSeed);
         }
 
+        @Override
+        protected boolean isPreserveNewNodes() {
+                return true;
+        }
+
         public <A, C> PartialInterpretation<A, C> getPartialInterpretation(PartialSymbol<A, C> partialSymbol) {
                 return reasoningAdapter.getPartialInterpretation(Concreteness.PARTIAL, partialSymbol);
         }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemTrace.java b/subprojects/generator/src/main/java/tools/refinery/generator/ProblemTrace.java
index 7be2dc00..f7963c58 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemTrace.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ProblemTrace.java
@@ -8,8 +8,12 @@ package tools.refinery.generator;
 import org.eclipse.xtext.naming.QualifiedName;
 import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.model.problem.Relation;
+import tools.refinery.language.semantics.metadata.NodeMetadata;
+import tools.refinery.language.semantics.metadata.RelationMetadata;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 
+import java.util.List;
 import java.util.Map;
 
 public interface ProblemTrace {
@@ -17,9 +21,15 @@ public interface ProblemTrace {
 
         Map<Relation, PartialRelation> getRelationTrace();
 
+        Relation getInverseTrace(AnyPartialSymbol partialSymbol);
+
         PartialRelation getPartialRelation(Relation relation);
 
         PartialRelation getPartialRelation(QualifiedName qualifiedName);
 
         PartialRelation getPartialRelation(String qualifiedName);
+
+        List<RelationMetadata> getRelationsMetadata();
+
+        List<NodeMetadata> getNodesMetadata(int nodeCount, boolean preserveNewNodes);
 }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/impl/ProblemTraceImpl.java b/subprojects/generator/src/main/java/tools/refinery/generator/impl/ProblemTraceImpl.java
index 109e34af..5671d3f8 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/impl/ProblemTraceImpl.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/impl/ProblemTraceImpl.java
@@ -6,6 +6,7 @@
 package tools.refinery.generator.impl;
 
 import com.google.inject.Inject;
+import com.google.inject.Provider;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
 import org.eclipse.xtext.naming.IQualifiedNameProvider;
@@ -15,10 +16,17 @@ import tools.refinery.generator.ProblemTrace;
 import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.model.problem.ProblemPackage;
 import tools.refinery.language.model.problem.Relation;
+import tools.refinery.language.semantics.metadata.MetadataCreator;
+import tools.refinery.language.semantics.metadata.NodeMetadata;
+import tools.refinery.language.semantics.metadata.RelationMetadata;
 import tools.refinery.language.semantics.model.ModelInitializer;
+import tools.refinery.language.semantics.model.TracedException;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
 
 import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 
 public final class ProblemTraceImpl implements ProblemTrace {
@@ -31,22 +39,31 @@ public final class ProblemTraceImpl implements ProblemTrace {
         @Inject
         private IScopeProvider scopeProvider;
 
-        private Problem problem;
+        @Inject
+        private Provider<MetadataCreator> metadataCreatorProvider;
+
+        private ModelInitializer initializer;
         private Map<Relation, PartialRelation> relationTrace;
+        private MetadataCreator metadataCreator;
 
         public void setInitializer(ModelInitializer initializer) {
-                problem = initializer.getProblem();
+                this.initializer = initializer;
                 relationTrace = Collections.unmodifiableMap(initializer.getRelationTrace());
         }
 
         public Problem getProblem() {
-                return problem;
+                return initializer.getProblem();
         }
 
         public Map<Relation, PartialRelation> getRelationTrace() {
                 return relationTrace;
         }
 
+        @Override
+        public Relation getInverseTrace(AnyPartialSymbol partialSymbol) {
+                return initializer.getInverseTrace(partialSymbol);
+        }
+
         public PartialRelation getPartialRelation(Relation relation) {
                 var partialRelation = relationTrace.get(relation);
                 if (partialRelation == null) {
@@ -58,7 +75,7 @@ public final class ProblemTraceImpl implements ProblemTrace {
         }
 
         public PartialRelation getPartialRelation(QualifiedName qualifiedName) {
-                var scope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__RELATION);
+                var scope = scopeProvider.getScope(getProblem(), ProblemPackage.Literals.ASSERTION__RELATION);
                 var iterator = scope.getElements(qualifiedName).iterator();
                 if (!iterator.hasNext()) {
                         var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
@@ -69,7 +86,7 @@ public final class ProblemTraceImpl implements ProblemTrace {
                         var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
                         throw new IllegalArgumentException("Ambiguous relation: " + qualifiedNameString);
                 }
-                var eObject = EcoreUtil.resolve(eObjectDescription.getEObjectOrProxy(), problem);
+                var eObject = EcoreUtil.resolve(eObjectDescription.getEObjectOrProxy(), getProblem());
                 if (!(eObject instanceof Relation relation)) {
                         var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
                         throw new IllegalArgumentException("Not a relation: " + qualifiedNameString);
@@ -81,4 +98,30 @@ public final class ProblemTraceImpl implements ProblemTrace {
                 var convertedName = qualifiedNameConverter.toQualifiedName(qualifiedName);
                 return getPartialRelation(convertedName);
         }
+
+        @Override
+        public List<RelationMetadata> getRelationsMetadata() {
+                return getMetadataCreator().getRelationsMetadata();
+        }
+
+        @Override
+        public List<NodeMetadata> getNodesMetadata(int nodeCount, boolean preserveNewNodes) {
+                return getMetadataCreator().getNodesMetadata(nodeCount, preserveNewNodes);
+        }
+
+        private MetadataCreator getMetadataCreator() {
+                if (metadataCreator == null) {
+                        metadataCreator = metadataCreatorProvider.get();
+                        metadataCreator.setInitializer(initializer);
+                }
+                return metadataCreator;
+        }
+
+        public static RuntimeException wrapException(ProblemTrace trace, TranslationException translationException) {
+                var source = trace.getInverseTrace(translationException.getPartialSymbol());
+                if (source == null) {
+                        return translationException;
+                }
+                return new TracedException(source, translationException);
+        }
 }
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
index a0081041..a05e647d 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/model/ModelInitializer.java
@@ -68,7 +68,7 @@ public class ModelInitializer {
 
         private final Map<AnyPartialSymbol, Relation> inverseTrace = new HashMap<>();
 
-        private Map<Relation, PartialRelation> relationTrace;
+        private final Map<Relation, PartialRelation> relationTrace = new LinkedHashMap<>();
 
         private final MetamodelBuilder metamodelBuilder = Metamodel.builder();
 
@@ -128,7 +128,6 @@ public class ModelInitializer {
                 collectMetamodel();
                 metamodel = metamodelBuilder.build();
                 collectAssertions();
-                relationTrace = new LinkedHashMap<>(relationInfoMap.size());
                 int nodeCount = getNodeCount();
                 var modelSeedBuilder = ModelSeed.builder(nodeCount);
                 for (var entry : relationInfoMap.entrySet()) {
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/ModelGenerationWorker.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java
index 1fce10a4..7b4f957c 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,18 @@
 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.ModelGeneratorBuilder;
+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,19 +38,7 @@ public class ModelGenerationWorker implements Runnable {
         private OperationCanceledManager operationCanceledManager;
 
         @Inject
-        private Provider<XtextResourceSet> resourceSetProvider;
-
-        @Inject
-        private IResourceFactory resourceFactory;
-
-        @Inject
-        private IResourceValidator resourceValidator;
-
-        @Inject
-        private ModelInitializer initializer;
-
-        @Inject
-        private MetadataCreator metadataCreator;
+        private ModelGeneratorBuilder generatorBuilder;
 
         @Inject
         private PartialInterpretation2Json partialInterpretation2Json;
@@ -157,56 +127,29 @@ 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());
+                try {
+                        generatorBuilder.cancellationToken(cancellationToken);
+                        generatorBuilder.fromString(text);
+                } 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();
+                var generator = generatorBuilder.build();
                 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.tryRun()) {
                         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);
+                var nodesMetadata = generator.getNodesMetadata();
                 cancellationToken.checkCancelled();
-                var relationsMetadata = metadataCreator.getRelationsMetadata();
+                var relationsMetadata = generator.getProblemTrace().getRelationsMetadata();
                 cancellationToken.checkCancelled();
-                var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(initializer, model,
+                var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(generator,
                                 Concreteness.CANDIDATE, 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..7afed5c0 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,7 +9,7 @@ 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.generator.AbstractRefinery;
 import tools.refinery.language.semantics.model.SemanticsUtils;
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.model.Model;
@@ -27,11 +27,12 @@ public class PartialInterpretation2Json {
         @Inject
         private SemanticsUtils semanticsUtils;
 
-        public JsonObject getPartialInterpretation(ModelInitializer initializer, Model model, Concreteness concreteness,
+        public JsonObject getPartialInterpretation(AbstractRefinery refinery, Concreteness concreteness,
                                                                                            CancellationToken cancellationToken) {
+                var model = refinery.getModel();
                 var adapter = model.getAdapter(ReasoningAdapter.class);
                 var json = new JsonObject();
-                for (var entry : initializer.getRelationTrace().entrySet()) {
+                for (var entry : refinery.getProblemTrace().getRelationTrace().entrySet()) {
                         var relation = entry.getKey();
                         var partialSymbol = entry.getValue();
                         var tuples = getTuplesJson(adapter, concreteness, partialSymbol);
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..a8f16c84 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,15 +15,10 @@ 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.ModelSemanticsBuilder;
 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.store.reasoning.translator.TranslationException;
 import tools.refinery.store.util.CancellationToken;
@@ -44,10 +39,7 @@ class SemanticsWorker implements Callable<SemanticsResult> {
         private IDiagnosticConverter diagnosticConverter;
 
         @Inject
-        private ModelInitializer initializer;
-
-        @Inject
-        private MetadataCreator metadataCreator;
+        private ModelSemanticsBuilder semanticsBuilder;
 
         private Problem problem;
 
@@ -64,36 +56,29 @@ 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));
+                semanticsBuilder.cancellationToken(cancellationToken);
                 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);
+                        semanticsBuilder.problem(problem);
                         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 = semanticsBuilder.build();
                 } 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();
+                var nodesMetadata = semantics.getNodesMetadata();
+                cancellationToken.checkCancelled();
+                var relationsMetadata = semantics.getProblemTrace().getRelationsMetadata();
+                cancellationToken.checkCancelled();
+                var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(semantics,
+                                Concreteness.PARTIAL, cancellationToken);
+                return new SemanticsSuccessResult(nodesMetadata, relationsMetadata, partialInterpretation);
         }
 
         private SemanticsResult getTracedErrorResult(EObject sourceElement, String message) {