Merge pull request #50 from kris7t/generator-roundtrip

Round-trip model serialization and command line application

50 files changed, 2055 insertions, 531 deletions

diff --git a/.yarnrc.yml b/.yarnrc.yml
index cf12e2d9..305b9b6a 100644
--- a/.yarnrc.yml
+++ b/.yarnrc.yml
@@ -4,7 +4,7 @@ enableTelemetry: false
 
 logFilters:
   - level: discard
-    text: "prettier is listed by your project with version 3.1.0, which doesn't satisfy what @xstate/cli (p708d6) and other dependencies request (^2.0.0)."
+    text: "prettier is listed by your project with version 3.1.1, which doesn't satisfy what @xstate/cli (p072c3) and other dependencies request (^2.0.0)."
 
 nodeLinker: pnp
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 06b76786..e65ffc03 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -4,7 +4,7 @@
 
 [versions]
 eclipseCollections = "12.0.0.M3"
-jetty = "12.0.3"
+jetty = "12.0.5"
 jmh = "1.37"
 junit = "5.10.1"
 mockito = "5.8.0"
@@ -23,6 +23,7 @@ gradlePlugin-shadow = { group = "com.github.johnrengelman", name = "shadow", ver
 gradlePlugin-sonarqube = { group = "org.sonarsource.scanner.gradle", name = "sonarqube-gradle-plugin", version = "4.4.1.3373" }
 gson = { group = "com.google.code.gson", name = "gson", version = "2.10.1" }
 hamcrest = { group = "org.hamcrest", name = "hamcrest", version = "2.2" }
+jcommander = { group = "org.jcommander", name = "jcommander", version = "1.83" }
 jetbrainsAnnotations = { group = "org.jetbrains", name = "annotations", version = "24.1.0" }
 jetty-server = { group = "org.eclipse.jetty", name = "jetty-server", version.ref = "jetty" }
 jetty-servlet = { group = "org.eclipse.jetty.ee10", name = "jetty-ee10-servlet", version.ref = "jetty" }
diff --git a/package.json b/package.json
index 6dbe66ad..a61c71d4 100644
--- a/package.json
+++ b/package.json
@@ -25,8 +25,8 @@
   },
   "packageManager": "yarn@4.0.2",
   "devDependencies": {
-    "eslint": "^8.55.0",
-    "typescript": "5.3.2"
+    "eslint": "^8.56.0",
+    "typescript": "5.3.3"
   },
   "resolutions": {
     "d3-zoom@npm:^3.0.0": "patch:d3-zoom@npm%3A3.0.0#~/.yarn/patches/d3-zoom-npm-3.0.0-18f706a421.patch",
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 40df30ff..6e5a72e9 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -9,6 +9,7 @@ rootProject.name = "refinery"
 include(
                 "frontend",
                 "generator",
+                "generator-cli",
                 "interpreter",
                 "interpreter-localsearch",
                 "interpreter-rete",
diff --git a/subprojects/frontend/config/graphvizUMDVitePlugin.ts b/subprojects/frontend/config/graphvizUMDVitePlugin.ts
index ab726e4f..0c3c9aa0 100644
--- a/subprojects/frontend/config/graphvizUMDVitePlugin.ts
+++ b/subprojects/frontend/config/graphvizUMDVitePlugin.ts
@@ -27,13 +27,15 @@ export default function graphvizUMDVitePlugin(): PluginOption {
     async buildStart() {
       const issuer =
         root === undefined ? issuerFileName : path.join(root, issuerFileName);
-      const resolvedPath = pnpapi.resolveRequest(
-        '@hpcc-js/wasm/graphviz',
-        issuer,
-      );
-      if (resolvedPath === null) {
+      // Since https://github.com/hpcc-systems/hpcc-js-wasm/commit/15e1ace5edae7f94714e547a3ac20e0e17cd6b0c,
+      // hpcc-js has both a `.cjs` and a `.umd.js` build. PnPAPI will find the former, but we need the latter.
+      const resolvedPath = pnpapi
+        .resolveRequest('@hpcc-js/wasm/graphviz', issuer)
+        ?.replace(/\.cjs$/, '.umd.js');
+      if (resolvedPath === undefined) {
         return;
       }
+      console.log(resolvedPath);
       if (command === 'serve') {
         url = `/@fs/${resolvedPath}`;
       } else {
diff --git a/subprojects/frontend/package.json b/subprojects/frontend/package.json
index f55093ce..9dec8b32 100644
--- a/subprojects/frontend/package.json
+++ b/subprojects/frontend/package.json
@@ -33,23 +33,23 @@
     "@codemirror/language": "^6.9.3",
     "@codemirror/lint": "^6.4.2",
     "@codemirror/search": "^6.5.5",
-    "@codemirror/state": "^6.3.2",
-    "@codemirror/view": "^6.22.1",
-    "@emotion/react": "^11.11.1",
+    "@codemirror/state": "^6.3.3",
+    "@codemirror/view": "^6.22.3",
+    "@emotion/react": "^11.11.3",
     "@emotion/styled": "^11.11.0",
-    "@fontsource-variable/jetbrains-mono": "^5.0.18",
-    "@fontsource-variable/open-sans": "^5.0.18",
-    "@hpcc-js/wasm": "^2.15.0",
-    "@lezer/common": "^1.1.1",
+    "@fontsource-variable/jetbrains-mono": "^5.0.19",
+    "@fontsource-variable/open-sans": "^5.0.21",
+    "@hpcc-js/wasm": "^2.15.3",
+    "@lezer/common": "^1.1.2",
     "@lezer/highlight": "^1.2.0",
     "@lezer/lr": "^1.3.14",
     "@material-icons/svg": "^1.0.33",
-    "@mui/icons-material": "5.14.19",
-    "@mui/material": "5.14.19",
-    "@mui/system": "^5.14.19",
-    "@mui/x-data-grid": "^6.18.2",
+    "@mui/icons-material": "^5.15.1",
+    "@mui/material": "^5.15.1",
+    "@mui/system": "^5.15.1",
+    "@mui/x-data-grid": "^6.18.6",
     "ansi-styles": "^6.2.1",
-    "csstype": "^3.1.2",
+    "csstype": "^3.1.3",
     "d3": "^7.8.5",
     "d3-graphviz": "patch:d3-graphviz@npm%3A5.2.0#~/.yarn/patches/d3-graphviz-npm-5.2.0-161b1fbad4.patch",
     "d3-selection": "^3.0.0",
@@ -65,7 +65,7 @@
     "notistack": "^3.0.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "react-resize-detector": "^9.1.0",
+    "react-resize-detector": "^9.1.1",
     "xstate": "^4.38.3",
     "zod": "^3.22.4"
   },
@@ -75,38 +75,38 @@
     "@types/d3-graphviz": "^2.6.10",
     "@types/d3-selection": "^3.0.10",
     "@types/d3-zoom": "^3.0.8",
-    "@types/eslint": "^8.44.8",
+    "@types/eslint": "^8.56.0",
     "@types/html-minifier-terser": "^7.0.2",
     "@types/lodash-es": "^4.17.12",
     "@types/micromatch": "^4.0.6",
     "@types/ms": "^0.7.34",
-    "@types/node": "^20.10.2",
+    "@types/node": "^20.10.5",
     "@types/pnpapi": "^0.0.5",
-    "@types/react": "^18.2.41",
-    "@types/react-dom": "^18.2.17",
-    "@typescript-eslint/eslint-plugin": "^6.13.1",
-    "@typescript-eslint/parser": "^6.13.1",
+    "@types/react": "^18.2.45",
+    "@types/react-dom": "^18.2.18",
+    "@typescript-eslint/eslint-plugin": "^6.15.0",
+    "@typescript-eslint/parser": "^6.15.0",
     "@vitejs/plugin-react-swc": "^3.5.0",
-    "@xstate/cli": "^0.5.11",
+    "@xstate/cli": "^0.5.15",
     "cross-env": "^7.0.3",
-    "eslint": "^8.55.0",
+    "eslint": "^8.56.0",
     "eslint-config-airbnb": "^19.0.4",
     "eslint-config-airbnb-typescript": "^17.1.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.29.0",
+    "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-jsx-a11y": "^6.8.0",
     "eslint-plugin-mobx": "^0.0.9",
-    "eslint-plugin-prettier": "^5.0.1",
+    "eslint-plugin-prettier": "^5.1.1",
     "eslint-plugin-react": "^7.33.2",
     "eslint-plugin-react-hooks": "^4.6.0",
     "html-minifier-terser": "^7.2.0",
     "micromatch": "^4.0.5",
     "pnpapi": "^0.0.0",
-    "prettier": "^3.1.0",
-    "typescript": "5.3.2",
-    "vite": "^5.0.4",
-    "vite-plugin-pwa": "^0.17.2",
+    "prettier": "^3.1.1",
+    "typescript": "5.3.3",
+    "vite": "^5.0.10",
+    "vite-plugin-pwa": "^0.17.4",
     "workbox-window": "^7.0.0"
   }
 }
diff --git a/subprojects/generator-cli/build.gradle.kts b/subprojects/generator-cli/build.gradle.kts
new file mode 100644
index 00000000..6c681222
--- /dev/null
+++ b/subprojects/generator-cli/build.gradle.kts
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+plugins {
+        id("tools.refinery.gradle.java-application")
+}
+
+dependencies {
+        implementation(project(":refinery-generator"))
+        implementation(libs.jcommander)
+        implementation(libs.slf4j.api)
+}
+
+application {
+        mainClass.set("tools.refinery.generator.cli.RefineryCli")
+}
+
+tasks.shadowJar {
+        // Silence Xtext warning.
+        append("plugin.properties")
+}
diff --git a/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/RefineryCli.java b/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/RefineryCli.java
new file mode 100644
index 00000000..5de579e6
--- /dev/null
+++ b/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/RefineryCli.java
@@ -0,0 +1,64 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.cli;
+
+import com.beust.jcommander.JCommander;
+import com.beust.jcommander.ParameterException;
+import com.google.inject.Inject;
+import tools.refinery.generator.cli.commands.GenerateCommand;
+import tools.refinery.generator.standalone.StandaloneRefinery;
+
+import java.io.IOException;
+
+public class RefineryCli {
+        private static final String GENERATE_COMMAND = "generate";
+
+        @Inject
+        private GenerateCommand generateCommand;
+
+        private JCommander jCommander;
+
+        public String parseArguments(String... args) {
+                var jc = getJCommander();
+                jc.parse(args);
+                return jc.getParsedCommand();
+        }
+
+        public void run(String command) throws IOException {
+                switch (command) {
+                case GENERATE_COMMAND -> generateCommand.run();
+                case null, default -> showUsageAndExit();
+                }
+        }
+
+        public void showUsageAndExit() {
+                getJCommander().usage();
+                System.exit(1);
+        }
+
+        private JCommander getJCommander() {
+                if (jCommander == null) {
+                        jCommander = JCommander.newBuilder()
+                                        .programName("refinery")
+                                        .addObject(this)
+                                        .addCommand(GENERATE_COMMAND, generateCommand)
+                                        .build();
+                }
+                return jCommander;
+        }
+
+        public static void main(String[] args) throws IOException {
+                var cli = StandaloneRefinery.getInjector().getInstance(RefineryCli.class);
+                String command = null;
+                try {
+                        command = cli.parseArguments(args);
+                } catch (ParameterException e) {
+                        System.err.println(e.getMessage());
+                        cli.showUsageAndExit();
+                }
+                cli.run(command);
+        }
+}
diff --git a/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java b/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java
new file mode 100644
index 00000000..b33fce23
--- /dev/null
+++ b/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java
@@ -0,0 +1,87 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator.cli.commands;
+
+import com.beust.jcommander.Parameter;
+import com.beust.jcommander.Parameters;
+import com.google.inject.Inject;
+import org.eclipse.emf.ecore.resource.Resource;
+import tools.refinery.generator.ModelGeneratorFactory;
+import tools.refinery.generator.ProblemLoader;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@Parameters(commandDescription = "Generate a model from a partial model")
+public class GenerateCommand {
+        @Inject
+        private ProblemLoader loader;
+
+        @Inject
+        private ModelGeneratorFactory generatorFactory;
+
+        private String inputPath;
+        private String outputPath = "-";
+        private List<String> scopes = new ArrayList<>();
+        private List<String> overrideScopes = new ArrayList<>();
+        private long randomSeed = 1;
+
+        @Parameter(description = "input path", required = true)
+        public void setInputPath(String inputPath) {
+                this.inputPath = inputPath;
+        }
+
+        @Parameter(names = {"-output", "-o"}, description = "Output path")
+        public void setOutputPath(String outputPath) {
+                this.outputPath = outputPath;
+        }
+
+        @Parameter(names = {"-scope", "-s"}, description = "Extra scope constraints")
+        public void setScopes(List<String> scopes) {
+                this.scopes = scopes;
+        }
+
+        @Parameter(names = {"-scope-override", "-S"}, description = "Override scope constraints")
+        public void setOverrideScopes(List<String> overrideScopes) {
+                this.overrideScopes = overrideScopes;
+        }
+
+        @Parameter(names = {"-random-seed", "-r"}, description = "Random seed")
+        public void setRandomSeed(long randomSeed) {
+                this.randomSeed = randomSeed;
+        }
+
+        public void run() throws IOException {
+                var problem = isStandardStream(inputPath) ? loader.loadStream(System.in) : loader.loadFile(inputPath);
+                problem = loader.loadScopeConstraints(problem, scopes, overrideScopes);
+                var generator = generatorFactory.createGenerator(problem);
+                generator.setRandomSeed(randomSeed);
+                generator.generate();
+                var solution = generator.serializeSolution();
+                var solutionResource = solution.eResource();
+                var saveOptions = Map.of();
+                if (isStandardStream(outputPath)) {
+                        printSolution(solutionResource, saveOptions);
+                } else {
+                        try (var outputStream = new FileOutputStream(outputPath)) {
+                                solutionResource.save(outputStream, saveOptions);
+                        }
+                }
+        }
+
+        private boolean isStandardStream(String path) {
+                return path == null || path.equals("-");
+        }
+
+        // We deliberately write to the standard output if no output path is specified.
+        @SuppressWarnings("squid:S106")
+        private void printSolution(Resource solutionResource, Map<?, ?> saveOptions) throws IOException {
+                solutionResource.save(System.out, saveOptions);
+        }
+}
diff --git a/subprojects/generator/build.gradle.kts b/subprojects/generator/build.gradle.kts
index d87ce6de..f78fee4d 100644
--- a/subprojects/generator/build.gradle.kts
+++ b/subprojects/generator/build.gradle.kts
@@ -12,4 +12,5 @@ dependencies {
         api(project(":refinery-language-semantics"))
         api(libs.eclipseCollections.api)
         implementation(project(":refinery-store-query-interpreter"))
+        testImplementation(testFixtures(project(":refinery-language")))
 }
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 5b44c10a..1515dceb 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
@@ -5,7 +5,10 @@
  */
 package tools.refinery.generator;
 
+import com.google.inject.Provider;
+import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.semantics.ProblemTrace;
+import tools.refinery.language.semantics.SolutionSerializer;
 import tools.refinery.store.dse.strategy.BestFirstStoreManager;
 import tools.refinery.store.map.Version;
 import tools.refinery.store.model.ModelStore;
@@ -16,21 +19,22 @@ import tools.refinery.store.reasoning.seed.ModelSeed;
 
 public class ModelGenerator extends ModelFacade {
         private final Version initialVersion;
-
-        private int randomSeed = 0;
-
+        private final Provider<SolutionSerializer> solutionSerializerProvider;
+        private long randomSeed = 1;
         private boolean lastGenerationSuccessful;
 
-        public ModelGenerator(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed) {
+        ModelGenerator(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed,
+                          Provider<SolutionSerializer> solutionSerializerProvider) {
                 super(problemTrace, store, modelSeed, Concreteness.CANDIDATE);
+                this.solutionSerializerProvider = solutionSerializerProvider;
                 initialVersion = getModel().commit();
         }
 
-        public int getRandomSeed() {
+        public long getRandomSeed() {
                 return randomSeed;
         }
 
-        public void setRandomSeed(int randomSeed) {
+        public void setRandomSeed(long randomSeed) {
                 this.randomSeed = randomSeed;
                 this.lastGenerationSuccessful = false;
         }
@@ -50,7 +54,7 @@ public class ModelGenerator extends ModelFacade {
                 if (solutions.isEmpty()) {
                         return false;
                 }
-                getModel().restore(solutions.get(0).version());
+                getModel().restore(solutions.getFirst().version());
                 lastGenerationSuccessful = true;
                 return true;
         }
@@ -63,9 +67,19 @@ public class ModelGenerator extends ModelFacade {
 
         @Override
         public <A, C> PartialInterpretation<A, C> getPartialInterpretation(PartialSymbol<A, C> partialSymbol) {
+                checkSuccessfulGeneration();
+                return super.getPartialInterpretation(partialSymbol);
+        }
+
+        public Problem serializeSolution() {
+                checkSuccessfulGeneration();
+                var serializer = solutionSerializerProvider.get();
+                return serializer.serializeSolution(getProblemTrace(), getModel());
+        }
+
+        private void checkSuccessfulGeneration() {
                 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
index 6642d591..587601f2 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java
@@ -9,6 +9,7 @@ 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.language.semantics.SolutionSerializer;
 import tools.refinery.store.dse.propagation.PropagationAdapter;
 import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
 import tools.refinery.store.model.ModelStore;
@@ -25,6 +26,9 @@ public final class ModelGeneratorFactory {
         @Inject
         private Provider<ModelInitializer> initializerProvider;
 
+        @Inject
+        private Provider<SolutionSerializer> solutionSerializerProvider;
+
         private CancellationToken cancellationToken = CancellationToken.NONE;
 
         private boolean debugPartialInterpretations;
@@ -53,7 +57,8 @@ public final class ModelGeneratorFactory {
                                                 .requiredInterpretations(getRequiredInterpretations()));
                 initializer.configureStoreBuilder(storeBuilder);
                 var store = storeBuilder.build();
-                return new ModelGenerator(initializer.getProblemTrace(), store, initializer.getModelSeed());
+                return new ModelGenerator(initializer.getProblemTrace(), store, initializer.getModelSeed(),
+                solutionSerializerProvider);
         }
 
         private Collection<Concreteness> getRequiredInterpretations() {
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 bc02c887..7207a509 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelSemantics.java
@@ -11,7 +11,7 @@ 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) {
+        ModelSemantics(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed) {
                 super(problemTrace, store, modelSeed, Concreteness.PARTIAL);
         }
 }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java b/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java
index 29f80714..20ea8132 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java
@@ -10,20 +10,30 @@ 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.FileExtensionProvider;
 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.language.model.problem.Relation;
+import tools.refinery.language.model.problem.ScopeDeclaration;
 import tools.refinery.store.util.CancellationToken;
 
+import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 
 public class ProblemLoader {
+        private String fileExtension;
+
         @Inject
         private Provider<XtextResourceSet> resourceSetProvider;
 
@@ -35,25 +45,39 @@ public class ProblemLoader {
 
         private CancellationToken cancellationToken = CancellationToken.NONE;
 
+        @Inject
+        public void setFileExtensionProvider(FileExtensionProvider fileExtensionProvider) {
+                this.fileExtension = fileExtensionProvider.getPrimaryFileExtension();
+        }
+
         public ProblemLoader cancellationToken(CancellationToken cancellationToken) {
                 this.cancellationToken = cancellationToken;
                 return this;
         }
 
-        public Problem loadString(String problemString) throws IOException {
+        public Problem loadString(String problemString, URI uri) throws IOException {
                 try (var stream = new LazyStringInputStream(problemString)) {
-                        return loadStream(stream);
+                        return loadStream(stream, uri);
                 }
         }
 
-        public Problem loadStream(InputStream inputStream) throws IOException {
+        public Problem loadString(String problemString) throws IOException {
+                return loadString(problemString, null);
+        }
+
+        public Problem loadStream(InputStream inputStream, URI uri) throws IOException {
                 var resourceSet = resourceSetProvider.get();
-                var resource = resourceFactory.createResource(URI.createFileURI("__synthetic.problem"));
+                var resourceUri = uri == null ? URI.createFileURI("__synthetic." + fileExtension) : uri;
+                var resource = resourceFactory.createResource(resourceUri);
                 resourceSet.getResources().add(resource);
                 resource.load(inputStream, Map.of());
                 return loadResource(resource);
         }
 
+        public Problem loadStream(InputStream inputStream) throws IOException {
+                return loadStream(inputStream, null);
+        }
+
         public Problem loadFile(File file) throws IOException {
                 return loadFile(file.getAbsolutePath());
         }
@@ -82,9 +106,63 @@ public class ProblemLoader {
                 if (!errors.isEmpty()) {
                         throw new ValidationErrorsException(resource.getURI(), errors);
                 }
-                if (resource.getContents().isEmpty() || !(resource.getContents().get(0) instanceof Problem problem)) {
+                if (resource.getContents().isEmpty() || !(resource.getContents().getFirst() instanceof Problem problem)) {
                         throw new IllegalArgumentException("Model generation problem not found in resource " + resource.getURI());
                 }
                 return problem;
         }
+
+        public Problem loadScopeConstraints(Problem problem, List<String> extraScopes,
+                                                                                List<String> overrideScopes) throws IOException {
+                var allScopes = new ArrayList<>(extraScopes);
+                allScopes.addAll(overrideScopes);
+                if (allScopes.isEmpty()) {
+                        return problem;
+                }
+                int originalStatementCount = problem.getStatements().size();
+                var builder = new StringBuilder();
+                var problemResource = problem.eResource();
+                try (var outputStream = new ByteArrayOutputStream()) {
+                        problemResource.save(outputStream, Map.of());
+                        builder.append(outputStream.toString(StandardCharsets.UTF_8));
+                }
+                builder.append('\n');
+                for (var scope : allScopes) {
+                        builder.append("scope ").append(scope).append(".\n");
+                }
+                var modifiedProblem = loadString(builder.toString(), problemResource.getURI());
+                var modifiedStatements = modifiedProblem.getStatements();
+                int modifiedStatementCount = modifiedStatements.size();
+                if (modifiedStatementCount != originalStatementCount + allScopes.size()) {
+                        throw new IllegalArgumentException("Failed to parse scope constraints");
+                }
+                // Override scopes remove any scope constraint from the original problem with the same target type.
+                var overriddenScopes = new HashSet<Relation>();
+                for (int i = modifiedStatementCount - overrideScopes.size(); i < modifiedStatementCount; i++) {
+                        var statement = modifiedStatements.get(i);
+                        if (!(statement instanceof ScopeDeclaration scopeDeclaration)) {
+                                throw new IllegalStateException("Invalid scope constraint: " + statement);
+                        }
+                        for (var typeScope : scopeDeclaration.getTypeScopes()) {
+                                overriddenScopes.add(typeScope.getTargetType());
+                        }
+                }
+                int statementIndex = 0;
+                var iterator = modifiedStatements.iterator();
+                // Scope overrides only affect type scopes from the original problem and leave type scopes added on the
+                // command line intact.
+                while (statementIndex < originalStatementCount && iterator.hasNext()) {
+                        var statement = iterator.next();
+                        if (statement instanceof ScopeDeclaration scopeDeclaration) {
+                                var typeScopes = scopeDeclaration.getTypeScopes();
+                                typeScopes.removeIf(typeScope -> overriddenScopes.contains(typeScope.getTargetType()));
+                                // Scope declarations with no type scopes are invalid, so we have to remove them.
+                                if (typeScopes.isEmpty()) {
+                                        iterator.remove();
+                                }
+                        }
+                        statementIndex++;
+                }
+                return modifiedProblem;
+        }
 }
diff --git a/subprojects/generator/src/test/java/tools/refinery/generator/ProblemLoaderTest.java b/subprojects/generator/src/test/java/tools/refinery/generator/ProblemLoaderTest.java
new file mode 100644
index 00000000..0c0db105
--- /dev/null
+++ b/subprojects/generator/src/test/java/tools/refinery/generator/ProblemLoaderTest.java
@@ -0,0 +1,129 @@
+/*
+ * 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 org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+class ProblemLoaderTest {
+        private static final String PREFIX = """
+                        class Foo.
+                        class Bar.
+                        """;
+
+        @Inject
+        private ProblemLoader loader;
+
+        @ParameterizedTest
+        @MethodSource
+        void loadScopeConstraintsTest(String originalScopes, List<String> scopes, List<String> overrideScopes,
+                                                                  String expectedScopes) throws IOException {
+                var problem = loader.loadString(PREFIX + originalScopes);
+                var modifiedProblem = loader.loadScopeConstraints(problem, scopes, overrideScopes);
+                String serializedProblem;
+                try (var outputStream = new ByteArrayOutputStream()) {
+                        modifiedProblem.eResource().save(outputStream, Map.of());
+                        serializedProblem = outputStream.toString(StandardCharsets.UTF_8);
+                }
+                assertThat(serializedProblem, is(PREFIX + expectedScopes));
+        }
+
+        static Stream<Arguments> loadScopeConstraintsTest() {
+                return Stream.of(Arguments.of("",
+                                List.of(),
+                                List.of(),
+                                ""), Arguments.of("",
+                                List.of("node=5..10"),
+                                List.of(), """
+
+                                                scope node=5..10.
+                                                """), Arguments.of("",
+                                List.of("Foo=2", "Bar=3"),
+                                List.of(), """
+
+                                                scope Foo=2.
+                                                scope Bar=3.
+                                                """), Arguments.of("""
+                                                scope Foo = 1, Bar = 1.
+                                                """,
+                                List.of("node=5..10"),
+                                List.of(), """
+                                                scope Foo = 1, Bar = 1.
+
+                                                scope node=5..10.
+                                                """), Arguments.of("""
+                                                scope Foo = 0..10, Bar = 1.
+                                                """,
+                                List.of("Foo = 5"),
+                                List.of(), """
+                                                scope Foo = 0..10, Bar = 1.
+
+                                                scope Foo = 5.
+                                                """), Arguments.of("""
+                                                scope Foo = 1, Bar = 1.
+                                                """,
+                                List.of(),
+                                List.of("node=5..10"), """
+                                                scope Foo = 1, Bar = 1.
+
+                                                scope node=5..10.
+                                                """), Arguments.of("""
+                                                scope Foo = 1, Bar = 1.
+                                                """,
+                                List.of(),
+                                List.of("Foo=3..4"), """
+                                                scope Bar = 1.
+
+                                                scope Foo=3..4.
+                                                """), Arguments.of("""
+                                                scope Foo = 1, Bar = 1.
+                                                """,
+                                List.of("Foo=2"),
+                                List.of("Foo=3..4"), """
+                                                scope Bar = 1.
+
+                                                scope Foo=2.
+                                                scope Foo=3..4.
+                                                """), Arguments.of("""
+                                                scope Foo = 1.
+                                                scope Bar = 1.
+                                                """,
+                                List.of(),
+                                List.of("Bar=3..4"), """
+                                                scope Foo = 1.
+
+
+                                                scope Bar=3..4.
+                                                """), Arguments.of("""
+                                                scope Foo = 1, Bar = 1.
+                                                """,
+                                List.of(),
+                                List.of("Foo=3..4", "Bar=4..5"), """
+
+                                                scope Foo=3..4.
+                                                scope Bar=4..5.
+                                                """));
+        }
+}
diff --git a/subprojects/language-model/src/main/resources/model/problem.ecore b/subprojects/language-model/src/main/resources/model/problem.ecore
index 204f922c..74229a89 100644
--- a/subprojects/language-model/src/main/resources/model/problem.ecore
+++ b/subprojects/language-model/src/main/resources/model/problem.ecore
@@ -23,7 +23,7 @@
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="kind" eType="#//ReferenceKind"/>
     <eStructuralFeatures xsi:type="ecore:EReference" name="referenceType" eType="#//Relation"/>
     <eStructuralFeatures xsi:type="ecore:EReference" name="invalidMultiplicity" eType="#//Relation"
-        containment="true"/>
+        transient="true" containment="true"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="NamedElement" abstract="true">
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
diff --git a/subprojects/language-semantics/build.gradle.kts b/subprojects/language-semantics/build.gradle.kts
index 689f621e..777ef993 100644
--- a/subprojects/language-semantics/build.gradle.kts
+++ b/subprojects/language-semantics/build.gradle.kts
@@ -16,6 +16,7 @@ dependencies {
         api(project(":refinery-store-reasoning"))
         implementation(project(":refinery-store-reasoning-scope"))
         runtimeOnly(libs.eclipseCollections)
+        testImplementation(project(":refinery-generator"))
         testImplementation(project(":refinery-store-dse-visualization"))
         testImplementation(project(":refinery-store-query-interpreter"))
         testImplementation(testFixtures(project(":refinery-language")))
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
index ecaa7e0d..38bf5a61 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
@@ -27,9 +27,7 @@ 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;
-import tools.refinery.store.reasoning.translator.metamodel.MetamodelTranslator;
+import tools.refinery.store.reasoning.translator.metamodel.*;
 import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
 import tools.refinery.store.reasoning.translator.multiplicity.ConstrainedMultiplicity;
 import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
@@ -73,6 +71,10 @@ public class ModelInitializer {
 
         private ScopePropagator scopePropagator;
 
+        private int nodeCount;
+
+        private ModelSeed.Builder modelSeedBuilder;
+
         private ModelSeed modelSeed;
 
         public void readProblem(Problem problem) {
@@ -101,13 +103,17 @@ public class ModelInitializer {
                                                         TruthValue.FALSE));
                         collectNodes();
                         collectPartialSymbols();
+                        nodeCount = problemTrace.getNodeTrace().size();
+                        modelSeedBuilder = ModelSeed.builder(nodeCount);
+                        collectAssertions();
                         collectMetamodel();
                         metamodel = metamodelBuilder.build();
                         problemTrace.setMetamodel(metamodel);
-                        collectAssertions();
-                        int nodeCount = problemTrace.getNodeTrace().size();
-                        var modelSeedBuilder = ModelSeed.builder(nodeCount);
+                        fixClassDeclarationAssertions();
                         for (var entry : relationInfoMap.entrySet()) {
+                                if (entry.getKey() instanceof ReferenceDeclaration) {
+                                        continue;
+                                }
                                 var info = entry.getValue();
                                 var partialRelation = info.partialRelation();
                                 modelSeedBuilder.seed(partialRelation, info.toSeed(nodeCount));
@@ -296,7 +302,20 @@ public class ModelInitializer {
                 }
                 var multiplicity = getMultiplicityConstraint(referenceDeclaration);
                 try {
-                        metamodelBuilder.reference(relation, source, containment, multiplicity, target, oppositeRelation);
+                        var seed = relationInfoMap.get(referenceDeclaration).toSeed(nodeCount);
+                        var defaultValue = seed.majorityValue();
+                        if (defaultValue.must()) {
+                                defaultValue = TruthValue.FALSE;
+                        }
+                        modelSeedBuilder.seed(relation, seed);
+                        metamodelBuilder.reference(relation, ReferenceInfo.builder()
+                                        .containment(containment)
+                                        .source(source)
+                                        .multiplicity(multiplicity)
+                                        .target(target)
+                                        .opposite(oppositeRelation)
+                                        .defaultValue(defaultValue)
+                                        .build());
                 } catch (RuntimeException e) {
                         throw TracedException.addTrace(classDeclaration, e);
                 }
@@ -355,10 +374,6 @@ public class ModelInitializer {
                 collectCardinalityAssertions(newNodeId, TruthValue.UNKNOWN);
                 var tuple = Tuple.of(newNodeId);
                 mergeValue(classDeclaration, tuple, TruthValue.TRUE);
-                var typeInfo = metamodel.typeHierarchy().getAnalysisResult(getPartialRelation(classDeclaration));
-                for (var subType : typeInfo.getDirectSubtypes()) {
-                        partialRelationInfoMap.get(subType).assertions().mergeValue(tuple, TruthValue.FALSE);
-                }
         }
 
         private void collectEnumAssertions(EnumDeclaration enumDeclaration) {
@@ -399,6 +414,27 @@ public class ModelInitializer {
                 }
         }
 
+        private void fixClassDeclarationAssertions() {
+                for (var statement : problem.getStatements()) {
+                        if (statement instanceof ClassDeclaration classDeclaration) {
+                                fixClassDeclarationAssertions(classDeclaration);
+                        }
+                }
+        }
+
+        private void fixClassDeclarationAssertions(ClassDeclaration classDeclaration) {
+                var newNode = classDeclaration.getNewNode();
+                if (newNode == null) {
+                        return;
+                }
+                var newNodeId = getNodeId(newNode);
+                var tuple = Tuple.of(newNodeId);
+                var typeInfo = metamodel.typeHierarchy().getAnalysisResult(getPartialRelation(classDeclaration));
+                for (var subType : typeInfo.getDirectSubtypes()) {
+                        partialRelationInfoMap.get(subType).assertions().mergeValue(tuple, TruthValue.FALSE);
+                }
+        }
+
         private void mergeValue(Relation relation, Tuple key, TruthValue value) {
                 getRelationInfo(relation).assertions().mergeValue(key, value);
         }
@@ -482,7 +518,7 @@ public class ModelInitializer {
                         defaultValue = TruthValue.FALSE;
                 } else {
                         var seed = modelSeed.getSeed(partialRelation);
-                        defaultValue = seed.reducedValue() == TruthValue.FALSE ? TruthValue.FALSE : TruthValue.UNKNOWN;
+                        defaultValue = seed.majorityValue() == TruthValue.FALSE ? TruthValue.FALSE : TruthValue.UNKNOWN;
                         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 = mutable || cursor.move();
@@ -495,7 +531,7 @@ public class ModelInitializer {
                 var problemParameters = predicateDefinition.getParameters();
                 int arity = problemParameters.size();
                 var parameters = new NodeVariable[arity];
-                var parameterMap = new HashMap<tools.refinery.language.model.problem.Variable, Variable>(arity);
+                var parameterMap = HashMap.<tools.refinery.language.model.problem.Variable, Variable>newHashMap(arity);
                 var commonLiterals = new ArrayList<Literal>();
                 for (int i = 0; i < arity; i++) {
                         var problemParameter = problemParameters.get(i);
@@ -532,7 +568,7 @@ public class ModelInitializer {
                         return existing;
                 }
                 int localScopeSize = existing.size() + newVariables.size();
-                var localScope = new HashMap<tools.refinery.language.model.problem.Variable, Variable>(localScopeSize);
+                var localScope = HashMap.<tools.refinery.language.model.problem.Variable, Variable>newHashMap(localScopeSize);
                 localScope.putAll(existing);
                 for (var newVariable : newVariables) {
                         localScope.put(newVariable, Variable.of(newVariable.getName()));
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
index cc634949..f686e980 100644
--- 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
@@ -9,7 +9,6 @@ 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;
@@ -28,7 +27,7 @@ import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
-public class ProblemTraceImpl implements ProblemTrace {
+class ProblemTraceImpl implements ProblemTrace {
         @Inject
         private IQualifiedNameConverter qualifiedNameConverter;
 
@@ -164,24 +163,6 @@ public class ProblemTraceImpl implements ProblemTrace {
         }
 
         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);
+                return semanticsUtils.getElement(problem, scope, qualifiedName, type);
         }
 }
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SemanticsUtils.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SemanticsUtils.java
index b195a8e7..b72ba697 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SemanticsUtils.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SemanticsUtils.java
@@ -8,8 +8,14 @@ package tools.refinery.language.semantics;
 import com.google.inject.Inject;
 import com.google.inject.Singleton;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
 import org.eclipse.xtext.naming.IQualifiedNameProvider;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.scoping.IScope;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.language.model.problem.Problem;
 
 import java.util.Optional;
 
@@ -28,4 +34,39 @@ public class SemanticsUtils {
                 }
                 return Optional.of(qualifiedNameConverter.toString(qualifiedName));
         }
+
+        @Nullable
+        public <T> T maybeGetElement(Problem problem, IScope scope, QualifiedName qualifiedName, Class<T> type) {
+                if (qualifiedName == null) {
+                        throw new IllegalArgumentException("Element name must not be null");
+                }
+                var iterator = scope.getElements(qualifiedName).iterator();
+                if (!iterator.hasNext()) {
+                        return null;
+                }
+                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(), problem);
+                if (!type.isInstance(eObject)) {
+                        var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
+                        throw new IllegalArgumentException("Not a %s: %s"
+                                        .formatted(type.getName(), qualifiedNameString));
+                }
+                return type.cast(eObject);
+        }
+
+        @NotNull
+        public <T> T getElement(Problem problem, IScope scope, QualifiedName qualifiedName, Class<T> type) {
+                var element = maybeGetElement(problem, scope, qualifiedName, type);
+                if (element == null) {
+                        var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
+                        throw new IllegalArgumentException("No such %s: %s"
+                                        .formatted(type.getName(), qualifiedNameString));
+                }
+                return element;
+        }
 }
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java
new file mode 100644
index 00000000..57af599e
--- /dev/null
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java
@@ -0,0 +1,335 @@
+/*
+ * 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 com.google.inject.Provider;
+import org.eclipse.collections.api.factory.primitive.IntObjectMaps;
+import org.eclipse.collections.api.factory.primitive.ObjectIntMaps;
+import org.eclipse.collections.api.map.primitive.MutableIntObjectMap;
+import org.eclipse.collections.api.map.primitive.MutableObjectIntMap;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.IQualifiedNameProvider;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.resource.FileExtensionProvider;
+import org.eclipse.xtext.resource.IResourceFactory;
+import org.eclipse.xtext.resource.XtextResource;
+import org.eclipse.xtext.resource.XtextResourceSet;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import tools.refinery.language.model.problem.*;
+import tools.refinery.language.utils.ProblemDesugarer;
+import tools.refinery.language.utils.ProblemUtil;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.typehierarchy.InferredType;
+import tools.refinery.store.reasoning.translator.typehierarchy.TypeHierarchyTranslator;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class SolutionSerializer {
+        private String fileExtension;
+
+        @Inject
+        private Provider<XtextResourceSet> resourceSetProvider;
+
+        @Inject
+        private IResourceFactory resourceFactory;
+
+        @Inject
+        private IQualifiedNameProvider qualifiedNameProvider;
+
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        @Inject
+        private SemanticsUtils semanticsUtils;
+
+        @Inject
+        private IScopeProvider scopeProvider;
+
+        @Inject
+        private ProblemDesugarer desugarer;
+
+        private ProblemTrace trace;
+        private Model model;
+        private ReasoningAdapter reasoningAdapter;
+        private PartialInterpretation<TruthValue, Boolean> existsInterpretation;
+        private Problem problem;
+        private final MutableIntObjectMap<Node> nodes = IntObjectMaps.mutable.empty();
+
+        @Inject
+        public void setFileExtensionProvider(FileExtensionProvider fileExtensionProvider) {
+                this.fileExtension = fileExtensionProvider.getPrimaryFileExtension();
+        }
+
+        public Problem serializeSolution(ProblemTrace trace, Model model) {
+                var uri = URI.createFileURI("__synthetic" + fileExtension);
+                return serializeSolution(trace, model, uri);
+        }
+
+        public Problem serializeSolution(ProblemTrace trace, Model model, URI uri) {
+                this.trace = trace;
+                this.model = model;
+                reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
+                existsInterpretation = reasoningAdapter.getPartialInterpretation(Concreteness.CANDIDATE,
+                                ReasoningAdapter.EXISTS_SYMBOL);
+                var originalProblem = trace.getProblem();
+                problem = copyProblem(originalProblem, uri);
+                problem.getStatements().removeIf(SolutionSerializer::shouldRemoveStatement);
+                problem.getNodes().removeIf(this::shouldRemoveNode);
+                addExistsAssertions();
+                addClassAssertions();
+                addReferenceAssertions();
+                return problem;
+        }
+
+        private static boolean shouldRemoveStatement(Statement statement) {
+                return statement instanceof Assertion || statement instanceof ScopeDeclaration;
+        }
+
+        private boolean shouldRemoveNode(Node newNode) {
+                var qualifiedName = qualifiedNameProvider.getFullyQualifiedName(newNode);
+                var scope = scopeProvider.getScope(trace.getProblem(), ProblemPackage.Literals.ASSERTION__RELATION);
+                var originalNode = semanticsUtils.maybeGetElement(problem, scope, qualifiedName, Node.class);
+                if (originalNode == null) {
+                        return false;
+                }
+                int nodeId = trace.getNodeId(originalNode);
+                return !isExistingNode(nodeId);
+        }
+
+        private boolean isExistingNode(int nodeId) {
+                var exists = existsInterpretation.get(Tuple.of(nodeId));
+                if (!exists.isConcrete()) {
+                        throw new IllegalStateException("Invalid EXISTS %s for node %d".formatted(exists, nodeId));
+                }
+                return exists.may();
+        }
+
+        private Problem copyProblem(Problem originalProblem, URI uri) {
+                var newResourceSet = resourceSetProvider.get();
+                if (!fileExtension.equals(uri.fileExtension())) {
+                        uri = uri.appendFileExtension(fileExtension);
+                }
+                var newResource = resourceFactory.createResource(uri);
+                newResourceSet.getResources().add(newResource);
+                var originalResource = originalProblem.eResource();
+                if (originalResource instanceof XtextResource) {
+                        byte[] bytes;
+                        try {
+                                try (var outputStream = new ByteArrayOutputStream()) {
+                                        originalResource.save(outputStream, Map.of());
+                                        bytes = outputStream.toByteArray();
+                                }
+                                try (var inputStream = new ByteArrayInputStream(bytes)) {
+                                        newResource.load(inputStream, Map.of());
+                                }
+                        } catch (IOException e) {
+                                throw new IllegalStateException("Failed to copy problem", e);
+                        }
+                        var contents = newResource.getContents();
+                        if (!contents.isEmpty() && contents.getFirst() instanceof Problem newProblem) {
+                                return newProblem;
+                        }
+                        throw new IllegalStateException("Invalid contents of copied problem");
+                } else {
+                        var newProblem = EcoreUtil.copy(originalProblem);
+                        newResource.getContents().add(newProblem);
+                        return newProblem;
+                }
+        }
+
+        private Relation findRelation(Relation originalRelation) {
+                var qualifiedName = qualifiedNameProvider.getFullyQualifiedName(originalRelation);
+                var scope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__RELATION);
+                return semanticsUtils.getElement(problem, scope, qualifiedName, Relation.class);
+        }
+
+        private Relation findPartialRelation(PartialRelation partialRelation) {
+                return findRelation(trace.getRelation(partialRelation));
+        }
+
+        private Node findNode(Node originalNode) {
+                var qualifiedName = qualifiedNameProvider.getFullyQualifiedName(originalNode);
+                return findNode(qualifiedName);
+        }
+
+        private Node findNode(String name) {
+                var qualifiedName = qualifiedNameConverter.toQualifiedName(name);
+                return findNode(qualifiedName);
+        }
+
+        private Node findNode(QualifiedName qualifiedName) {
+                var scope = scopeProvider.getScope(problem, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE);
+                return semanticsUtils.maybeGetElement(problem, scope, qualifiedName, Node.class);
+        }
+
+        private void addAssertion(Relation relation, LogicValue value, Node... arguments) {
+                var assertion = ProblemFactory.eINSTANCE.createAssertion();
+                assertion.setRelation(relation);
+                for (var node : arguments) {
+                        var argument = ProblemFactory.eINSTANCE.createNodeAssertionArgument();
+                        argument.setNode(node);
+                        assertion.getArguments().add(argument);
+                }
+                var logicConstant = ProblemFactory.eINSTANCE.createLogicConstant();
+                logicConstant.setLogicValue(value);
+                assertion.setValue(logicConstant);
+                problem.getStatements().add(assertion);
+        }
+
+        private void addExistsAssertions() {
+                var builtinSymbols = desugarer.getBuiltinSymbols(problem)
+                                .orElseThrow(() -> new IllegalStateException("No builtin library in copied problem"));
+                // Make sure to output exists assertions in a deterministic order.
+                var sortedNewNodes = new TreeMap<Integer, Node>();
+                for (var pair : trace.getNodeTrace().keyValuesView()) {
+                        var originalNode = pair.getOne();
+                        int nodeId = pair.getTwo();
+                        var newNode = findNode(originalNode);
+                        // Since all implicit nodes that do not exist has already been remove in serializeSolution,
+                        // we only need to add !exists assertions to ::new nodes (nodes marked as an individual must always exist).
+                        if (ProblemUtil.isNewNode(originalNode)) {
+                                sortedNewNodes.put(nodeId, newNode);
+                        } else {
+                                nodes.put(nodeId, newNode);
+                        }
+                }
+                for (var newNode : sortedNewNodes.values()) {
+                        // If a node is a new node of the class, we should replace it with a normal node.
+                        addAssertion(builtinSymbols.exists(), LogicValue.FALSE, newNode);
+                }
+        }
+
+        private void addClassAssertions() {
+                var types = trace.getMetamodel().typeHierarchy().getPreservedTypes().keySet().stream()
+                                .collect(Collectors.toMap(Function.identity(), this::findPartialRelation));
+                var indexMap = ObjectIntMaps.mutable.empty();
+                var cursor = model.getInterpretation(TypeHierarchyTranslator.TYPE_SYMBOL).getAll();
+                while (cursor.move()) {
+                        var key = cursor.getKey();
+                        var nodeId = key.get(0);
+                        if (isExistingNode(nodeId)) {
+                                createNodeAndAssertType(nodeId, cursor.getValue(), types, indexMap);
+                        }
+                }
+        }
+
+        private void createNodeAndAssertType(int nodeId, InferredType inferredType, Map<PartialRelation, Relation> types,
+                                                                                 MutableObjectIntMap<Object> indexMap) {
+                var candidateTypeSymbol = inferredType.candidateType();
+                var candidateRelation = types.get(candidateTypeSymbol);
+                if (candidateRelation instanceof EnumDeclaration) {
+                        // Type assertions for enum literals are added implicitly.
+                        return;
+                }
+                Node node = nodes.get(nodeId);
+                if (node == null) {
+                        String typeName = candidateRelation.getName();
+                        if (typeName == null || typeName.isEmpty()) {
+                                typeName = "node";
+                        } else {
+                                typeName = typeName.substring(0, 1).toLowerCase(Locale.ROOT) + typeName.substring(1);
+                        }
+                        int index = indexMap.getIfAbsent(typeName, 0);
+                        String nodeName;
+                        do {
+                                index++;
+                                nodeName = typeName + index;
+                        } while (findNode(nodeName) != null);
+                        node = ProblemFactory.eINSTANCE.createNode();
+                        node.setName(nodeName);
+                        problem.getNodes().add(node);
+                        nodes.put(nodeId, node);
+                }
+                addAssertion(candidateRelation, LogicValue.TRUE, node);
+                var typeAnalysisResult = trace.getMetamodel().typeHierarchy().getPreservedTypes().get(candidateTypeSymbol);
+                for (var subtype : typeAnalysisResult.getDirectSubtypes()) {
+                        var subtypeRelation = types.get(subtype);
+                        addAssertion(subtypeRelation, LogicValue.FALSE, node);
+                }
+        }
+
+        private void addReferenceAssertions() {
+                var metamodel = trace.getMetamodel();
+                for (var partialRelation : metamodel.containmentHierarchy().keySet()) {
+                        // No need to add a default value, because in a concrete model, each contained node has only a single
+                        // container.
+                        addAssertions(partialRelation);
+                }
+                for (var partialRelation : metamodel.directedCrossReferences().keySet()) {
+                        addDefaultAssertion(partialRelation);
+                        addAssertions(partialRelation);
+                }
+                // No need to add directed opposite references, because their default value is {@code unknown} and their
+                // actual value will always be computed from the value of the directed forward reference.
+                // However, undirected cross-references have to be serialized in both directions due to the default value of
+                // {@code false}.
+                for (var partialRelation : metamodel.undirectedCrossReferences().keySet()) {
+                        addDefaultAssertion(partialRelation);
+                        addAssertions(partialRelation);
+                }
+        }
+
+        private void addAssertions(PartialRelation partialRelation) {
+                var relation = findPartialRelation(partialRelation);
+                var cursor = reasoningAdapter.getPartialInterpretation(Concreteness.CANDIDATE, partialRelation).getAll();
+                // Make sure to output assertions in a deterministic order.
+                var sortedTuples = new TreeSet<Tuple>();
+                while (cursor.move()) {
+                        var tuple = cursor.getKey();
+                        var from = nodes.get(tuple.get(0));
+                        var to = nodes.get(tuple.get(1));
+                        if (from == null || to == null) {
+                                // One of the endpoints does not exist in the candidate model.
+                                continue;
+                        }
+                        var value = cursor.getValue();
+                        if (!value.isConcrete()) {
+                                throw new IllegalStateException("Invalid %s %s for tuple %s".formatted(partialRelation, value, tuple));
+                        }
+                        if (value.may()) {
+                                sortedTuples.add(tuple);
+                        }
+                }
+                for (var tuple : sortedTuples) {
+                        var from = nodes.get(tuple.get(0));
+                        var to = nodes.get(tuple.get(1));
+                        addAssertion(relation, LogicValue.TRUE, from, to);
+                }
+        }
+
+        private void addDefaultAssertion(PartialRelation partialRelation) {
+                var relation = findPartialRelation(partialRelation);
+                var assertion = ProblemFactory.eINSTANCE.createAssertion();
+                assertion.setDefault(true);
+                assertion.setRelation(relation);
+                int arity = ProblemUtil.getArity(relation);
+                for (int i = 0; i < arity; i++) {
+                        var argument = ProblemFactory.eINSTANCE.createWildcardAssertionArgument();
+                        assertion.getArguments().add(argument);
+                }
+                var logicConstant = ProblemFactory.eINSTANCE.createLogicConstant();
+                logicConstant.setLogicValue(LogicValue.FALSE);
+                assertion.setValue(logicConstant);
+                problem.getStatements().add(assertion);
+        }
+}
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTree.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTree.java
index c732f784..5d25f148 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTree.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTree.java
@@ -40,8 +40,8 @@ class DecisionTree implements MutableSeed<TruthValue> {
         }
 
         @Override
-        public TruthValue reducedValue() {
-                return root.getOtherwiseReducedValue().getTruthValue();
+        public TruthValue majorityValue() {
+                return root.getMajorityValue().getTruthValueOrElse(TruthValue.FALSE);
         }
 
         @Override
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTreeNode.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTreeNode.java
index ebca2634..31d6fc78 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTreeNode.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/DecisionTreeNode.java
@@ -100,6 +100,8 @@ abstract class DecisionTreeNode {
 
         protected abstract LazyIntIterable getChildKeys();
 
+        public abstract DecisionTreeValue getMajorityValue();
+
         protected abstract boolean moveNextSparse(int level, DecisionTreeCursor cursor, int startIndex,
                                                                                           int[] sortedChildren);
 
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/IntermediateNode.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/IntermediateNode.java
index 0e2f5d18..2ad216ce 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/IntermediateNode.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/IntermediateNode.java
@@ -130,6 +130,11 @@ final class IntermediateNode extends DecisionTreeNode {
                 return children.keysView();
         }
 
+        @Override
+        public DecisionTreeValue getMajorityValue() {
+                return otherwise.getMajorityValue();
+        }
+
         protected boolean moveNextSparse(int level, DecisionTreeCursor cursor, int startIndex, int[] sortedChildren) {
                 for (int i = startIndex; i < sortedChildren.length; i++) {
                         var key = sortedChildren[i];
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/NullaryMutableSeed.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/NullaryMutableSeed.java
index 7a72c656..f100c5a6 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/NullaryMutableSeed.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/NullaryMutableSeed.java
@@ -29,14 +29,14 @@ class NullaryMutableSeed implements MutableSeed<TruthValue> {
         }
 
         @Override
-        public TruthValue reducedValue() {
+        public TruthValue majorityValue() {
                 return value.getTruthValue();
         }
 
         @Override
         public TruthValue get(Tuple key) {
                 validateKey(key);
-                return reducedValue();
+                return majorityValue();
         }
 
         private static void validateKey(Tuple key) {
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/TerminalNode.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/TerminalNode.java
index d3dd757c..dc501479 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/TerminalNode.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/internal/TerminalNode.java
@@ -115,7 +115,7 @@ class TerminalNode extends DecisionTreeNode {
 
         @Override
         protected DecisionTreeValue getOtherwiseReducedValue() {
-                return otherwise;
+                return getMajorityValue();
         }
 
         @Override
@@ -124,6 +124,11 @@ class TerminalNode extends DecisionTreeNode {
         }
 
         @Override
+        public DecisionTreeValue getMajorityValue() {
+                return otherwise;
+        }
+
+        @Override
         protected boolean moveNextSparse(int level, DecisionTreeCursor cursor, int startIndex, int[] sortedChildren) {
                 if (startIndex >= sortedChildren.length) {
                         return false;
diff --git a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/SolutionSerializerTest.java b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/SolutionSerializerTest.java
new file mode 100644
index 00000000..2d759c86
--- /dev/null
+++ b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/SolutionSerializerTest.java
@@ -0,0 +1,164 @@
+/*
+ * 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.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import tools.refinery.generator.ModelGeneratorFactory;
+import tools.refinery.generator.ProblemLoader;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+class SolutionSerializerTest {
+        @Inject
+        ProblemLoader loader;
+
+        @Inject
+        ModelGeneratorFactory generatorFactory;
+
+        @Inject
+        SolutionSerializer serializer;
+
+        @ParameterizedTest
+        @MethodSource
+        void solutionSerializerTest(String prefix, String input, String expectedOutput) throws IOException {
+                var problem = loader.loadString(prefix + "\n" + input);
+                var generator = generatorFactory.createGenerator(problem);
+                generator.generate();
+                var solution = serializer.serializeSolution(generator.getProblemTrace(), generator.getModel());
+                String actualOutput;
+                try (var outputStream = new ByteArrayOutputStream()) {
+                        solution.eResource().save(outputStream, Map.of());
+                        actualOutput = outputStream.toString();
+                }
+                assertThat(actualOutput, is(prefix + "\n" + expectedOutput));
+        }
+
+        static Stream<Arguments> solutionSerializerTest() {
+                return Stream.of(Arguments.of("""
+                                class Foo.
+                                """, """
+                                scope Foo = 3.
+                                """, """
+                                !exists(Foo::new).
+                                Foo(foo1).
+                                Foo(foo2).
+                                Foo(foo3).
+                                """), Arguments.of("""
+                                class Foo {
+                                        contains Bar[2] bars
+                                }
+
+                                class Bar.
+                                """, """
+                                scope Foo = 1.
+                                """, """
+                                !exists(Foo::new).
+                                !exists(Bar::new).
+                                Foo(foo1).
+                                Bar(bar1).
+                                Bar(bar2).
+                                bars(foo1, bar1).
+                                bars(foo1, bar2).
+                                """), Arguments.of("""
+                                class Foo {
+                                        Bar[2] bars opposite foo
+                                }
+
+                                class Bar {
+                                        Foo[1] foo opposite bars
+                                }
+                                """, """
+                                scope Foo = 1, Bar = 2.
+                                """, """
+                                !exists(Foo::new).
+                                !exists(Bar::new).
+                                Foo(foo1).
+                                Bar(bar1).
+                                Bar(bar2).
+                                default !bars(*, *).
+                                bars(foo1, bar1).
+                                bars(foo1, bar2).
+                                """), Arguments.of("""
+                                class Person {
+                                        Person[2] friend opposite friend
+                                }
+                                """, """
+                                friend(a, b).
+                                friend(a, c).
+                                friend(b, c).
+
+                                scope Person += 0.
+                                """, """
+                                !exists(Person::new).
+                                Person(a).
+                                Person(b).
+                                Person(c).
+                                default !friend(*, *).
+                                friend(a, b).
+                                friend(a, c).
+                                friend(b, a).
+                                friend(b, c).
+                                friend(c, a).
+                                friend(c, b).
+                                """), Arguments.of("""
+                                class Foo {
+                                        Bar bar
+                                }
+
+                                enum Bar {
+                                        BAR_A,
+                                        BAR_B
+                                }
+                                """, """
+                                bar(foo, BAR_A).
+
+                                scope Foo += 0.
+                                """, """
+                                !exists(Foo::new).
+                                Foo(foo).
+                                default !bar(*, *).
+                                bar(foo, BAR_A).
+                                """), Arguments.of("""
+                                class Foo.
+                                class Bar extends Foo.
+                                """, """
+                                scope Foo = 1, Bar = 0.
+                                """, """
+                                !exists(Foo::new).
+                                !exists(Bar::new).
+                                Foo(foo1).
+                                !Bar(foo1).
+                                """), Arguments.of("""
+                                class Foo {
+                                        Foo[] ref
+                                }
+                                """, """
+                                ref(a, b).
+                                !exists(b).
+
+                                scope Foo += 0.
+                                """, """
+                                !exists(Foo::new).
+                                Foo(a).
+                                default !ref(*, *).
+                                """));
+        }
+}
diff --git a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/internal/DecisionTreeTests.java b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/internal/DecisionTreeTests.java
index 2320de2c..61ce850f 100644
--- a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/internal/DecisionTreeTests.java
+++ b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/internal/DecisionTreeTests.java
@@ -276,6 +276,16 @@ class DecisionTreeTests {
                 assertThat(sut.getReducedValue(), is(TruthValue.TRUE));
         }
 
+        @Test
+        void overwriteWildcardAllTest() {
+                var first = new DecisionTree(2, TruthValue.UNKNOWN);
+                first.mergeValue(Tuple.of(-1, -1), TruthValue.FALSE);
+                var second = new DecisionTree(2, null);
+                second.mergeValue(Tuple.of(1, -1), TruthValue.TRUE);
+                first.overwriteValues(second);
+                assertThat(first.majorityValue(), is(TruthValue.FALSE));
+        }
+
         private Map<Tuple, TruthValue> iterateAll(DecisionTree sut, TruthValue defaultValue, int nodeCount) {
                 var cursor = sut.getCursor(defaultValue, nodeCount);
                 var map = new LinkedHashMap<Tuple, TruthValue>();
diff --git a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
index 0a5cb3c2..00dd3de3 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
@@ -20,6 +20,7 @@ import org.eclipse.xtext.scoping.IGlobalScopeProvider;
 import org.eclipse.xtext.scoping.IScopeProvider;
 import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
 import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
+import org.eclipse.xtext.serializer.tokens.ICrossReferenceSerializer;
 import org.eclipse.xtext.validation.IDiagnosticConverter;
 import org.eclipse.xtext.validation.IResourceValidator;
 import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator;
@@ -34,12 +35,15 @@ import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
 import tools.refinery.language.scoping.ProblemGlobalScopeProvider;
 import tools.refinery.language.scoping.ProblemLocalScopeProvider;
 import tools.refinery.language.serializer.PreferShortAssertionsProblemSemanticSequencer;
+import tools.refinery.language.serializer.ProblemCrossReferenceSerializer;
 import tools.refinery.language.validation.ProblemDiagnosticConverter;
 
 /**
  * Use this class to register components to be used at runtime / without the
  * Equinox extension registry.
  */
+// Unused methods in this class are called by reflection to configure the Xtext Injector.
+@SuppressWarnings("unused")
 public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
         @Override
         public Class<? extends IParser> bindIParser() {
@@ -104,6 +108,10 @@ public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
                 return PreferShortAssertionsProblemSemanticSequencer.class;
         }
 
+        public Class<? extends ICrossReferenceSerializer> bindICrossReferenceSerializer() {
+                return ProblemCrossReferenceSerializer.class;
+        }
+
         public Class<? extends IDiagnosticConverter> bindIDiagnosticConverter() {
                 return ProblemDiagnosticConverter.class;
         }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java b/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java
index 55a5ac20..0f3bd3ee 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/formatting2/ProblemFormatter.java
@@ -69,12 +69,24 @@ public class ProblemFormatter extends AbstractJavaFormatter {
                 doc.prepend(region.keyword("{"), this::oneSpace);
                 doc.append(region.keyword("{"), it -> it.setNewLines(1, 1, 2));
                 doc.prepend(region.keyword("}"), it -> it.setNewLines(1, 1, 2));
+                doc.interior(region.keyword("{"), region.keyword("}"), IHiddenRegionFormatter::indent);
                 doc.prepend(region.keyword("."), this::noSpace);
                 for (var featureDeclaration : classDeclaration.getFeatureDeclarations()) {
                         doc.format(featureDeclaration);
                 }
         }
 
+        protected void format(EnumDeclaration enumDeclaration, IFormattableDocument doc) {
+                surroundNewLines(doc, enumDeclaration, this::twoNewLines);
+                var region = regionFor(enumDeclaration);
+                doc.append(region.keyword("enum"), this::oneSpace);
+                doc.prepend(region.keyword("{"), this::oneSpace);
+                doc.append(region.keyword("{"), it -> it.setNewLines(1, 1, 2));
+                doc.prepend(region.keyword("}"), it -> it.setNewLines(1, 1, 2));
+                doc.interior(region.keyword("{"), region.keyword("}"), IHiddenRegionFormatter::indent);
+                doc.prepend(region.keyword("."), this::noSpace);
+        }
+
         protected void format(PredicateDefinition predicateDefinition, IFormattableDocument doc) {
                 surroundNewLines(doc, predicateDefinition, this::twoNewLines);
                 var region = regionFor(predicateDefinition);
@@ -151,14 +163,14 @@ public class ProblemFormatter extends AbstractJavaFormatter {
         }
 
         protected void surroundNewLines(IFormattableDocument doc, EObject eObject,
-                        Procedure1<? super IHiddenRegionFormatter> init) {
+                                                                        Procedure1<? super IHiddenRegionFormatter> init) {
                 var region = doc.getRequest().getTextRegionAccess().regionForEObject(eObject);
                 preprendNewLines(doc, region, init);
                 appendNewLines(doc, region, init);
         }
 
         protected void preprendNewLines(IFormattableDocument doc, ISequentialRegion region,
-                        Procedure1<? super IHiddenRegionFormatter> init) {
+                                                                        Procedure1<? super IHiddenRegionFormatter> init) {
                 if (region == null) {
                         return;
                 }
@@ -174,7 +186,7 @@ public class ProblemFormatter extends AbstractJavaFormatter {
         }
 
         protected void appendNewLines(IFormattableDocument doc, ISequentialRegion region,
-                        Procedure1<? super IHiddenRegionFormatter> init) {
+                                                                  Procedure1<? super IHiddenRegionFormatter> init) {
                 if (region == null) {
                         return;
                 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/serializer/PreferShortAssertionsProblemSemanticSequencer.java b/subprojects/language/src/main/java/tools/refinery/language/serializer/PreferShortAssertionsProblemSemanticSequencer.java
index b9cafbc2..3432b2d8 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/serializer/PreferShortAssertionsProblemSemanticSequencer.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/serializer/PreferShortAssertionsProblemSemanticSequencer.java
@@ -21,8 +21,7 @@ public class PreferShortAssertionsProblemSemanticSequencer extends ProblemSemant
 
         @Override
         protected void sequence_Assertion(ISerializationContext context, Assertion semanticObject) {
-                if (semanticObject.isDefault() ||
-                                !(semanticObject.getValue() instanceof LogicConstant logicConstant) ||
+                if (!(semanticObject.getValue() instanceof LogicConstant logicConstant) ||
                                 logicConstant.getLogicValue() == LogicValue.ERROR) {
                         super.sequence_Assertion(context, semanticObject);
                         return;
@@ -39,6 +38,9 @@ public class PreferShortAssertionsProblemSemanticSequencer extends ProblemSemant
                 }
                 var feeder = createSequencerFeeder(context, semanticObject);
                 var access = grammarAccess.getAssertionAccess();
+                if (semanticObject.isDefault()) {
+                        feeder.accept(access.getDefaultDefaultKeyword_0_0());
+                }
                 feeder.accept(access.getValueShortLogicConstantParserRuleCall_1_1_0_0(), logicConstant);
                 feeder.accept(access.getRelationRelationQualifiedNameParserRuleCall_1_1_1_0_1(), semanticObject.getRelation());
                 var iterator = semanticObject.getArguments().iterator();
diff --git a/subprojects/language/src/main/java/tools/refinery/language/serializer/ProblemCrossReferenceSerializer.java b/subprojects/language/src/main/java/tools/refinery/language/serializer/ProblemCrossReferenceSerializer.java
new file mode 100644
index 00000000..42950e61
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/serializer/ProblemCrossReferenceSerializer.java
@@ -0,0 +1,167 @@
+/*******************************************************************************
+ * Copyright (c) 2008, 2018 itemis AG (http://www.itemis.eu) and others.
+ * Copyright (c) 2023 The Refinery Authors <https://refinery.tools/>
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.language.serializer;
+
+import com.google.common.collect.Lists;
+import com.google.inject.Inject;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.xtext.CrossReference;
+import org.eclipse.xtext.EcoreUtil2;
+import org.eclipse.xtext.GrammarUtil;
+import org.eclipse.xtext.IGrammarAccess;
+import org.eclipse.xtext.conversion.IValueConverterService;
+import org.eclipse.xtext.conversion.ValueConverterException;
+import org.eclipse.xtext.linking.impl.LinkingHelper;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.scoping.IScope;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic;
+import org.eclipse.xtext.serializer.diagnostic.SerializationDiagnostic;
+import org.eclipse.xtext.serializer.tokens.CrossReferenceSerializer;
+import org.eclipse.xtext.serializer.tokens.SerializerScopeProviderBinding;
+import org.eclipse.xtext.util.EmfFormatter;
+
+import java.util.List;
+
+public class ProblemCrossReferenceSerializer extends CrossReferenceSerializer {
+        public static final String AMBIGUOUS_REFERENCE_DIAGNOSTIC = "tools.refinery.language.serializer" +
+                        ".ProblemCrossReferenceSerializer.AMBIGUOUS_REFERENCE";
+
+        @Inject
+        private LinkingHelper linkingHelper;
+
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        @Inject
+        @SerializerScopeProviderBinding
+        private IScopeProvider scopeProvider;
+
+        @Inject
+        private IValueConverterService valueConverter;
+
+        @Inject
+        private IGrammarAccess grammarAccess;
+
+        @Override
+        public String serializeCrossRef(EObject semanticObject, CrossReference crossref, EObject target, INode node,
+                                                                        ISerializationDiagnostic.Acceptor errors) {
+                if ((target == null || target.eIsProxy()) && node != null) {
+                        return tokenUtil.serializeNode(node);
+                }
+
+                final EReference ref = GrammarUtil.getReference(crossref, semanticObject.eClass());
+                final IScope scope = scopeProvider.getScope(semanticObject, ref);
+                if (scope == null) {
+                        if (errors != null) {
+                                errors.accept(diagnostics.getNoScopeFoundDiagnostic(semanticObject, crossref, target));
+                        }
+                        return null;
+                }
+
+                if (target != null && target.eIsProxy()) {
+                        target = handleProxy(target, semanticObject, ref);
+                }
+
+                if (target != null && node != null) {
+                        String text = linkingHelper.getCrossRefNodeAsString(node, true);
+                        QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(text);
+                        URI targetUri = EcoreUtil2.getPlatformResourceOrNormalizedURI(target);
+                        if (isUniqueInScope(scope, qualifiedName, targetUri)) {
+                                return tokenUtil.serializeNode(node);
+                        }
+                }
+
+                return getCrossReferenceNameFromScope(semanticObject, crossref, target, scope, errors);
+        }
+
+        private boolean isUniqueInScope(IScope scope, QualifiedName qualifiedName, URI targetUri) {
+                var iterator = scope.getElements(qualifiedName).iterator();
+                if (!iterator.hasNext()) {
+                        return false;
+                }
+                var description = iterator.next();
+                return targetUri.equals(description.getEObjectURI()) && !iterator.hasNext();
+        }
+
+        @Override
+        protected String getCrossReferenceNameFromScope(EObject semanticObject, CrossReference crossref, EObject target,
+                                                                                                        IScope scope, ISerializationDiagnostic.Acceptor errors) {
+                var ruleName = linkingHelper.getRuleNameFrom(crossref);
+                var targetUri = EcoreUtil2.getPlatformResourceOrNormalizedURI(target);
+                FoundName foundName = FoundName.NONE;
+                int shortestNameLength = Integer.MAX_VALUE;
+                String shortestName = null;
+                List<ISerializationDiagnostic> recordedErrors = null;
+                for (var description : scope.getElements(target)) {
+                        var qualifiedName = description.getName();
+                        var segmentCount = qualifiedName.getSegmentCount();
+                        if (shortestName != null && segmentCount >= shortestNameLength) {
+                                continue;
+                        }
+                        if (isUniqueInScope(scope, qualifiedName, targetUri)) {
+                                var unconverted = qualifiedNameConverter.toString(qualifiedName);
+                                try {
+                                        shortestName = valueConverter.toString(unconverted, ruleName);
+                                        shortestNameLength = segmentCount;
+                                        foundName = FoundName.VALID;
+                                } catch (ValueConverterException e) {
+                                        if (recordedErrors == null) {
+                                                recordedErrors = Lists.newArrayList();
+                                        }
+                                        recordedErrors.add(diagnostics.getValueConversionExceptionDiagnostic(semanticObject, crossref,
+                                                        unconverted, e));
+                                }
+                        } else if (foundName == FoundName.NONE) {
+                                foundName = FoundName.AMBIGUOUS;
+                        }
+                }
+                handleErrors(semanticObject, crossref, target, scope, errors, recordedErrors, foundName);
+                return shortestName;
+        }
+
+        private void handleErrors(
+                        EObject semanticObject, CrossReference crossref, EObject target, IScope scope,
+                        ISerializationDiagnostic.Acceptor errors, List<ISerializationDiagnostic> recordedErrors,
+                        FoundName foundName) {
+                if (errors == null) {
+                        return;
+                }
+                if (recordedErrors != null) {
+                        recordedErrors.forEach(errors::accept);
+                }
+                if (foundName == FoundName.NONE) {
+                        errors.accept(diagnostics.getNoEObjectDescriptionFoundDiagnostic(semanticObject, crossref, target,
+                                        scope));
+                } else if (foundName == FoundName.AMBIGUOUS) {
+                        // Computation of reference name copied from
+                        // {@link org.eclipse.xtext.serializer.diagnostic.TokenDiagnosticProvider#getFullReferenceName}.
+                        var ref = GrammarUtil.getReference(crossref);
+                        var clazz = semanticObject.eClass().getName();
+                        if (ref.getEContainingClass() != semanticObject.eClass()) {
+                clazz = ref.getEContainingClass().getName() + "(" + clazz + ")";
+            }
+                        var message = "No unambiguous name could be found in scope %s.%s for %s"
+                                        .formatted(clazz, ref.getName(), EmfFormatter.objPath(target));
+                        var diagnostic = new SerializationDiagnostic(AMBIGUOUS_REFERENCE_DIAGNOSTIC, semanticObject, crossref,
+                                        grammarAccess.getGrammar(), message);
+                        errors.accept(diagnostic);
+                }
+        }
+
+        private enum FoundName {
+                NONE,
+                AMBIGUOUS,
+                VALID
+        }
+}
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
index 9f4f2bbf..65675b6b 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/serializer/ProblemSerializerTest.java
@@ -74,8 +74,8 @@ class ProblemSerializerTest {
         }
 
         @ParameterizedTest
-        @MethodSource
-        void defaultAssertionTest(LogicValue value, String valueAsString) {
+        @MethodSource("assertionTest")
+        void defaultAssertionTest(LogicValue value, String serializedAssertion) {
                 var pred = createPred();
                 var node = ProblemFactory.eINSTANCE.createNode();
                 node.setName("a");
@@ -88,12 +88,7 @@ class ProblemSerializerTest {
                                 pred foo(node p).
 
                                 indiv a.
-                                default foo(a):\040""" + valueAsString + ".\n");
-        }
-
-        static Stream<Arguments> defaultAssertionTest() {
-                return Stream.of(Arguments.of(LogicValue.TRUE, "true"), Arguments.of(LogicValue.FALSE, "false"),
-                                Arguments.of(LogicValue.UNKNOWN, "unknown"), Arguments.of(LogicValue.ERROR, "error"));
+                                default\040""" + serializedAssertion + "\n");
         }
 
         @Test
@@ -161,6 +156,7 @@ class ProblemSerializerTest {
                 problem.getStatements().add(assertion);
         }
 
+
         @Test
         void implicitVariableTest() {
                 var pred = ProblemFactory.eINSTANCE.createPredicateDefinition();
@@ -232,20 +228,77 @@ class ProblemSerializerTest {
                                 """);
         }
 
+        @Test
+        void unambiguousNameTest() {
+                createClassAndAssertion("Foo", "foo");
+
+                assertSerializedResult("""
+                                class Foo {
+                                        Foo ref
+                                }
+
+                                ref(foo, foo).
+                                """);
+        }
+
+        @Test
+        void ambiguousNameTest() {
+                createClassAndAssertion("Foo", "foo");
+                createClassAndAssertion("Bar", "bar");
+
+                assertSerializedResult("""
+                                class Foo {
+                                        Foo ref
+                                }
+
+                                Foo::ref(foo, foo).
+
+                                class Bar {
+                                        Bar ref
+                                }
+
+                                Bar::ref(bar, bar).
+                                """);
+        }
+
+        private void createClassAndAssertion(String className, String nodeName) {
+                var classDeclaration = ProblemFactory.eINSTANCE.createClassDeclaration();
+                classDeclaration.setName(className);
+                var referenceDeclaration = ProblemFactory.eINSTANCE.createReferenceDeclaration();
+                referenceDeclaration.setReferenceType(classDeclaration);
+                referenceDeclaration.setName("ref");
+                classDeclaration.getFeatureDeclarations().add(referenceDeclaration);
+                problem.getStatements().add(classDeclaration);
+                var node = ProblemFactory.eINSTANCE.createNode();
+                node.setName(nodeName);
+                problem.getNodes().add(node);
+                createBinaryAssertion(referenceDeclaration, node, node);
+        }
+
+        private void createBinaryAssertion(Relation relation, Node from, Node to) {
+                var assertion = ProblemFactory.eINSTANCE.createAssertion();
+                assertion.setRelation(relation);
+                var fromArgument = ProblemFactory.eINSTANCE.createNodeAssertionArgument();
+                fromArgument.setNode(from);
+                assertion.getArguments().add(fromArgument);
+                var toArgument = ProblemFactory.eINSTANCE.createNodeAssertionArgument();
+                toArgument.setNode(to);
+                assertion.getArguments().add(toArgument);
+                var value = ProblemFactory.eINSTANCE.createLogicConstant();
+                value.setLogicValue(LogicValue.TRUE);
+                assertion.setValue(value);
+                problem.getStatements().add(assertion);
+        }
+
         private void assertSerializedResult(String expected) {
-                var outputStream = new ByteArrayOutputStream();
-                try {
+                String problemString;
+                try (var outputStream = new ByteArrayOutputStream()) {
                         resource.save(outputStream, Map.of());
+                        problemString = outputStream.toString();
                 } catch (IOException e) {
                         throw new AssertionError("Failed to serialize problem", e);
-                } finally {
-                        try {
-                                outputStream.close();
-                        } catch (IOException e) {
-                                // Nothing to handle in a test.
-                        }
                 }
-                var problemString = outputStream.toString();
+                // Nothing to handle in a test.
 
                 assertThat(problemString.replace("\r\n", "\n"), equalTo(expected.replace("\r\n", "\n")));
         }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstExplorer.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstExplorer.java
index ce3efb21..22f38ca9 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstExplorer.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstExplorer.java
@@ -10,10 +10,10 @@ import tools.refinery.store.model.Model;
 import java.util.Random;
 
 public class BestFirstExplorer extends BestFirstWorker {
-        final int id;
+        final long id;
         Random random;
 
-        public BestFirstExplorer(BestFirstStoreManager storeManager, Model model, int id) {
+        public BestFirstExplorer(BestFirstStoreManager storeManager, Model model, long id) {
                 super(storeManager, model);
                 this.id = id;
                 // The use of a non-cryptographic random generator is safe here, because we only use it to direct the state
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStoreManager.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStoreManager.java
index 3d32f84c..c20ab9a0 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStoreManager.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStoreManager.java
@@ -79,7 +79,7 @@ public class BestFirstStoreManager {
                 startExploration(initial, 1);
         }
 
-        public void startExploration(Version initial, int randomSeed) {
+        public void startExploration(Version initial, long randomSeed) {
                 BestFirstExplorer bestFirstExplorer = new BestFirstExplorer(this, modelStore.createModelForState(initial),
                                 randomSeed);
                 bestFirstExplorer.explore();
diff --git a/subprojects/store-reasoning-scope/src/test/java/tools/refinery/store/reasoning/scope/PredicateScopeTest.java b/subprojects/store-reasoning-scope/src/test/java/tools/refinery/store/reasoning/scope/PredicateScopeTest.java
index a2c56a6b..5ee97ce1 100644
--- a/subprojects/store-reasoning-scope/src/test/java/tools/refinery/store/reasoning/scope/PredicateScopeTest.java
+++ b/subprojects/store-reasoning-scope/src/test/java/tools/refinery/store/reasoning/scope/PredicateScopeTest.java
@@ -27,7 +27,6 @@ import tools.refinery.store.reasoning.translator.containment.ContainmentHierarch
 import tools.refinery.store.reasoning.translator.metamodel.Metamodel;
 import tools.refinery.store.reasoning.translator.metamodel.MetamodelTranslator;
 import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
-import tools.refinery.store.reasoning.translator.multiplicity.ConstrainedMultiplicity;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.representation.cardinality.CardinalityIntervals;
 import tools.refinery.store.statecoding.StateCoderAdapter;
@@ -109,10 +108,16 @@ class PredicateScopeTest {
         private ModelStore createStore() {
                 var metamodel = Metamodel.builder()
                                 .type(index)
-                                .reference(next, index, false,
-                                                ConstrainedMultiplicity.of(CardinalityIntervals.LONE, nextInvalidMultiplicity), index, prev)
-                                .reference(prev, index, false,
-                                                ConstrainedMultiplicity.of(CardinalityIntervals.LONE, prevInvalidMultiplicity), index, next)
+                                .reference(next, builder -> builder
+                                                .source(index)
+                                                .target(index)
+                                                .multiplicity(CardinalityIntervals.LONE, nextInvalidMultiplicity)
+                                                .opposite(prev))
+                                .reference(prev, builder -> builder
+                                                .source(index)
+                                                .target(index)
+                                                .multiplicity(CardinalityIntervals.LONE, prevInvalidMultiplicity)
+                                                .opposite(next))
                                 .build();
                 return ModelStore.builder()
                                 .with(QueryInterpreterAdapter.builder())
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/MapBasedSeed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/MapBasedSeed.java
index 8b1c3bb3..3b78db02 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/MapBasedSeed.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/MapBasedSeed.java
@@ -12,19 +12,19 @@ import tools.refinery.store.tuple.Tuple;
 import java.util.Map;
 import java.util.Objects;
 
-record MapBasedSeed<T>(int arity, Class<T> valueType, T reducedValue, Map<Tuple, T> map) implements Seed<T> {
+record MapBasedSeed<T>(int arity, Class<T> valueType, T majorityValue, Map<Tuple, T> map) implements Seed<T> {
         @Override
         public T get(Tuple key) {
                 var value = map.get(key);
-                return value == null ? reducedValue : value;
+                return value == null ? majorityValue : value;
         }
 
         @Override
         public Cursor<Tuple, T> getCursor(T defaultValue, int nodeCount) {
-                if (Objects.equals(defaultValue, reducedValue)) {
+                if (Objects.equals(defaultValue, majorityValue)) {
                         return Cursors.of(map);
                 }
-                return new CartesianProductCursor<>(arity, nodeCount, reducedValue, defaultValue, map);
+                return new CartesianProductCursor<>(arity, nodeCount, majorityValue, defaultValue, map);
         }
 
         private static class CartesianProductCursor<T> implements Cursor<Tuple, T> {
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
index 732efbcc..d9bad866 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
@@ -19,7 +19,7 @@ public interface Seed<T> {
 
         Class<T> valueType();
 
-        T reducedValue();
+        T majorityValue();
 
         T get(Tuple key);
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceInfo.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceInfo.java
index d8c6a5ea..7241b032 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceInfo.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceInfo.java
@@ -7,9 +7,11 @@ package tools.refinery.store.reasoning.translator.crossreference;
 
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
+import tools.refinery.store.representation.TruthValue;
 
 public record DirectedCrossReferenceInfo(PartialRelation sourceType, Multiplicity sourceMultiplicity,
-                                                                                 PartialRelation targetType, Multiplicity targetMultiplicity) {
+                                                                                 PartialRelation targetType, Multiplicity targetMultiplicity,
+                                                                                 TruthValue defaultValue) {
         public boolean isConstrained() {
                 return sourceMultiplicity.isConstrained() || targetMultiplicity.isConstrained();
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceInitializer.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceInitializer.java
new file mode 100644
index 00000000..9347e91e
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceInitializer.java
@@ -0,0 +1,52 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.crossreference;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+class DirectedCrossReferenceInitializer implements PartialModelInitializer {
+        private final PartialRelation linkType;
+        private final PartialRelation sourceType;
+        private final PartialRelation targetType;
+        private final Symbol<TruthValue> symbol;
+
+        public DirectedCrossReferenceInitializer(PartialRelation linkType, PartialRelation sourceType,
+                                                                                         PartialRelation targetType, Symbol<TruthValue> symbol) {
+                this.linkType = linkType;
+                this.sourceType = sourceType;
+                this.targetType = targetType;
+                this.symbol = symbol;
+        }
+
+        @Override
+        public void initialize(Model model, ModelSeed modelSeed) {
+                var reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
+                var sourceRefiner = reasoningAdapter.getRefiner(sourceType);
+                var targetRefiner = reasoningAdapter.getRefiner(targetType);
+                var interpretation = model.getInterpretation(symbol);
+                var cursor = modelSeed.getCursor(linkType, symbol.defaultValue());
+                while (cursor.move()) {
+                        var key = cursor.getKey();
+                        var value = cursor.getValue();
+                        interpretation.put(key, value);
+                        if (value.must()) {
+                                boolean merged = sourceRefiner.merge(Tuple.of(key.get(0)), TruthValue.TRUE) &&
+                                                targetRefiner.merge(Tuple.of(key.get(1)), TruthValue.TRUE);
+                                if (!merged) {
+                                        throw new IllegalArgumentException("Failed to merge end types of reference %s for key %s"
+                                                        .formatted(linkType, key));
+                                }
+                        }
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceTranslator.java
index 9028337c..fc7477f1 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceTranslator.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.reasoning.translator.crossreference;
 
+import tools.refinery.store.dse.propagation.PropagationBuilder;
 import tools.refinery.store.dse.transition.Rule;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.model.ModelStoreConfiguration;
@@ -14,9 +15,9 @@ import tools.refinery.store.query.view.ForbiddenView;
 import tools.refinery.store.reasoning.lifting.DnfLifter;
 import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.literal.Modality;
-import tools.refinery.store.reasoning.refinement.RefinementBasedInitializer;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.reasoning.translator.multiplicity.InvalidMultiplicityErrorTranslator;
 import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
 import tools.refinery.store.representation.Symbol;
@@ -24,6 +25,7 @@ import tools.refinery.store.representation.TruthValue;
 
 import static tools.refinery.store.query.literal.Literals.not;
 import static tools.refinery.store.reasoning.actions.PartialActionLiterals.add;
+import static tools.refinery.store.reasoning.actions.PartialActionLiterals.merge;
 import static tools.refinery.store.reasoning.literal.PartialLiterals.*;
 import static tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator.MULTI_VIEW;
 
@@ -35,7 +37,7 @@ public class DirectedCrossReferenceTranslator implements ModelStoreConfiguration
         public DirectedCrossReferenceTranslator(PartialRelation linkType, DirectedCrossReferenceInfo info) {
                 this.linkType = linkType;
                 this.info = info;
-                symbol = Symbol.of(linkType.name(), 2, TruthValue.class, TruthValue.UNKNOWN);
+                symbol = Symbol.of(linkType.name(), 2, TruthValue.class, info.defaultValue());
         }
 
         @Override
@@ -45,41 +47,77 @@ public class DirectedCrossReferenceTranslator implements ModelStoreConfiguration
                 var targetType = info.targetType();
                 var mayNewSource = createMayHelper(sourceType, info.sourceMultiplicity(), false);
                 var mayNewTarget = createMayHelper(targetType, info.targetMultiplicity(), true);
-                var forbiddenView = new ForbiddenView(symbol);
                 var mayName = DnfLifter.decorateName(name, Modality.MAY, Concreteness.PARTIAL);
 
-                storeBuilder.with(PartialRelationTranslator.of(linkType)
-                                .symbol(symbol)
-                                .may(Query.of(mayName, (builder, source, target) -> {
+                var defaultValue = info.defaultValue();
+                if (defaultValue.must()) {
+                        throw new TranslationException(linkType, "Unsupported default value %s for directed cross references %s"
+                                        .formatted(defaultValue, linkType));
+                }
+
+                var translator = PartialRelationTranslator.of(linkType);
+                translator.symbol(symbol);
+                if (defaultValue.may()) {
+                        var forbiddenView = new ForbiddenView(symbol);
+                        translator.may(Query.of(mayName, (builder, source, target) -> {
+                                builder.clause(
+                                                mayNewSource.call(source),
+                                                mayNewTarget.call(target),
+                                                not(forbiddenView.call(source, target))
+                                );
+                                if (info.isConstrained()) {
+                                        // Violation of monotonicity:
+                                        // Edges violating upper multiplicity will not be marked as {@code ERROR}, but the
+                                        // corresponding error pattern will already mark the node as invalid.
+                                        builder.clause(
+                                                        must(linkType.call(source, target)),
+                                                        not(forbiddenView.call(source, target)),
+                                                        may(sourceType.call(source)),
+                                                        may(targetType.call(target))
+                                        );
+                                }
+                        }));
+                } else {
+                        var propagationBuilder = storeBuilder.getAdapter(PropagationBuilder.class);
+                        propagationBuilder.rule(Rule.of(name + "#invalidLink", (builder, p1, p2) -> {
+                                builder.clause(
+                                                may(linkType.call(p1, p2)),
+                                                not(may(sourceType.call(p1)))
+                                );
+                                builder.clause(
+                                                may(linkType.call(p1, p2)),
+                                                not(may(targetType.call(p2)))
+                                );
+                                if (info.isConstrained()) {
+                                        builder.clause(
+                                                        may(linkType.call(p1, p2)),
+                                                        not(must(linkType.call(p1, p2))),
+                                                        not(mayNewSource.call(p1))
+                                        );
                                         builder.clause(
-                                                        mayNewSource.call(source),
-                                                        mayNewTarget.call(target),
-                                                        not(forbiddenView.call(source, target))
+                                                        may(linkType.call(p1, p2)),
+                                                        not(must(linkType.call(p1, p2))),
+                                                        not(mayNewTarget.call(p2))
                                         );
-                                        if (info.isConstrained()) {
-                                                // Violation of monotonicity:
-                                                // Edges violating upper multiplicity will not be marked as {@code ERROR}, but the
-                                                // corresponding error pattern will already mark the node as invalid.
-                                                builder.clause(
-                                                                must(linkType.call(source, target)),
-                                                                not(forbiddenView.call(source, target)),
-                                                                may(sourceType.call(source)),
-                                                                may(targetType.call(target))
-                                                );
-                                        }
-                                }))
-                                .refiner(DirectedCrossReferenceRefiner.of(symbol, sourceType, targetType))
-                                .initializer(new RefinementBasedInitializer<>(linkType))
-                                .decision(Rule.of(linkType.name(), (builder, source, target) -> builder
-                                                .clause(
-                                                                may(linkType.call(source, target)),
-                                                                not(candidateMust(linkType.call(source, target))),
-                                                                not(MULTI_VIEW.call(source)),
-                                                                not(MULTI_VIEW.call(target))
-                                                )
-                                                .action(
-                                                                add(linkType, source, target)
-                                                ))));
+                                }
+                                builder.action(
+                                                merge(linkType, TruthValue.FALSE, p1, p2)
+                                );
+                        }));
+                }
+                translator.refiner(DirectedCrossReferenceRefiner.of(symbol, sourceType, targetType));
+                translator.initializer(new DirectedCrossReferenceInitializer(linkType, sourceType, targetType, symbol));
+                translator.decision(Rule.of(linkType.name(), (builder, source, target) -> builder
+                                .clause(
+                                                may(linkType.call(source, target)),
+                                                not(candidateMust(linkType.call(source, target))),
+                                                not(MULTI_VIEW.call(source)),
+                                                not(MULTI_VIEW.call(target))
+                                )
+                                .action(
+                                                add(linkType, source, target)
+                                )));
+                storeBuilder.with(translator);
 
                 storeBuilder.with(new InvalidMultiplicityErrorTranslator(sourceType, linkType, false,
                                 info.sourceMultiplicity()));
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInfo.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInfo.java
index fe99bc54..34e9032a 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInfo.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInfo.java
@@ -7,8 +7,9 @@ package tools.refinery.store.reasoning.translator.crossreference;
 
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
+import tools.refinery.store.representation.TruthValue;
 
-public record UndirectedCrossReferenceInfo(PartialRelation type, Multiplicity multiplicity) {
+public record UndirectedCrossReferenceInfo(PartialRelation type, Multiplicity multiplicity, TruthValue defaultValue) {
         public boolean isConstrained() {
                 return multiplicity.isConstrained();
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInitializer.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInitializer.java
new file mode 100644
index 00000000..77339aa0
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInitializer.java
@@ -0,0 +1,84 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.crossreference;
+
+import org.jetbrains.annotations.NotNull;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.reasoning.translator.TranslationException;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.LinkedHashMap;
+
+class UndirectedCrossReferenceInitializer implements PartialModelInitializer {
+        private final PartialRelation linkType;
+        private final PartialRelation sourceType;
+        private final Symbol<TruthValue> symbol;
+
+        UndirectedCrossReferenceInitializer(PartialRelation linkType, PartialRelation sourceType,
+                                                                                Symbol<TruthValue> symbol) {
+                this.linkType = linkType;
+                this.sourceType = sourceType;
+                this.symbol = symbol;
+        }
+
+        @Override
+        public void initialize(Model model, ModelSeed modelSeed) {
+                var reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
+                var mergedMap = getMergedMap(modelSeed);
+                var sourceRefiner = reasoningAdapter.getRefiner(sourceType);
+                var interpretation = model.getInterpretation(symbol);
+                for (var entry : mergedMap.entrySet()) {
+                        var key = entry.getKey();
+                        var value = entry.getValue();
+                        interpretation.put(key, value);
+                        if (value.must()) {
+                                boolean merged = sourceRefiner.merge(Tuple.of(key.get(0)), TruthValue.TRUE) &&
+                                                sourceRefiner.merge(Tuple.of(key.get(1)), TruthValue.TRUE);
+                                if (!merged) {
+                                        throw new IllegalArgumentException("Failed to merge end types of reference %s for key %s"
+                                                        .formatted(linkType, key));
+                                }
+                        }
+                }
+        }
+
+        @NotNull
+        private LinkedHashMap<Tuple, TruthValue> getMergedMap(ModelSeed modelSeed) {
+                var defaultValue = symbol.defaultValue();
+                var originalMap = new LinkedHashMap<Tuple, TruthValue>();
+                var cursor = modelSeed.getCursor(linkType, defaultValue);
+                while (cursor.move()) {
+                        if (originalMap.put(cursor.getKey(), cursor.getValue()) != null) {
+                                throw new TranslationException(linkType, "Duplicate value for key " + cursor.getKey());
+                        }
+                }
+                var mergedMap = LinkedHashMap.<Tuple, TruthValue>newLinkedHashMap(originalMap.size());
+                for (var entry : originalMap.entrySet()) {
+                        var key = entry.getKey();
+                        var value = entry.getValue();
+                        int first = key.get(0);
+                        int second = key.get(1);
+                        var oppositeKey = Tuple.of(second, first);
+                        var oppositeValue = originalMap.get(oppositeKey);
+                        if (oppositeValue != null && second < first) {
+                                // Already processed entry.
+                                continue;
+                        }
+                        var mergedValue = value.merge(oppositeValue == null ? defaultValue : oppositeValue);
+                        mergedMap.put(key, mergedValue);
+                        if (first != second) {
+                                mergedMap.put(oppositeKey, mergedValue);
+                        }
+                }
+                return mergedMap;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceTranslator.java
index c554e2a4..b76838b3 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceTranslator.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.reasoning.translator.crossreference;
 
+import tools.refinery.store.dse.propagation.PropagationBuilder;
 import tools.refinery.store.dse.transition.Rule;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.model.ModelStoreConfiguration;
@@ -13,15 +14,16 @@ import tools.refinery.store.query.view.ForbiddenView;
 import tools.refinery.store.reasoning.lifting.DnfLifter;
 import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.literal.Modality;
-import tools.refinery.store.reasoning.refinement.RefinementBasedInitializer;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.reasoning.translator.multiplicity.InvalidMultiplicityErrorTranslator;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.representation.TruthValue;
 
 import static tools.refinery.store.query.literal.Literals.not;
 import static tools.refinery.store.reasoning.actions.PartialActionLiterals.add;
+import static tools.refinery.store.reasoning.actions.PartialActionLiterals.merge;
 import static tools.refinery.store.reasoning.literal.PartialLiterals.*;
 import static tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator.MULTI_VIEW;
 
@@ -33,50 +35,77 @@ public class UndirectedCrossReferenceTranslator implements ModelStoreConfigurati
         public UndirectedCrossReferenceTranslator(PartialRelation linkType, UndirectedCrossReferenceInfo info) {
                 this.linkType = linkType;
                 this.info = info;
-                symbol = Symbol.of(linkType.name(), 2, TruthValue.class, TruthValue.UNKNOWN);
+                symbol = Symbol.of(linkType.name(), 2, TruthValue.class, info.defaultValue());
         }
 
         @Override
         public void apply(ModelStoreBuilder storeBuilder) {
                 var name = linkType.name();
                 var type = info.type();
-                var forbiddenView = new ForbiddenView(symbol);
                 var mayName = DnfLifter.decorateName(name, Modality.MAY, Concreteness.PARTIAL);
 
+                var defaultValue = info.defaultValue();
+                if (defaultValue.must()) {
+                        throw new TranslationException(linkType, "Unsupported default value %s for directed cross references %s"
+                                        .formatted(defaultValue, linkType));
+                }
+
                 var mayNewSource = CrossReferenceUtils.createMayHelper(linkType, type, info.multiplicity(), false);
 
-                storeBuilder.with(PartialRelationTranslator.of(linkType)
-                                .symbol(symbol)
-                                .may(Query.of(mayName, (builder, source, target) -> {
+                var translator = PartialRelationTranslator.of(linkType);
+                translator.symbol(symbol);
+                if (defaultValue.may()) {
+                        var forbiddenView = new ForbiddenView(symbol);
+                        translator.may(Query.of(mayName, (builder, source, target) -> {
+                                builder.clause(
+                                                mayNewSource.call(source),
+                                                mayNewSource.call(target),
+                                                not(forbiddenView.call(source, target))
+                                );
+                                if (info.isConstrained()) {
+                                        // Violation of monotonicity:
+                                        // Edges violating upper multiplicity will not be marked as {@code ERROR}, but the
+                                        // corresponding error pattern will already mark the node as invalid.
+                                        builder.clause(
+                                                        must(linkType.call(source, target)),
+                                                        not(forbiddenView.call(source, target)),
+                                                        may(type.call(source)),
+                                                        may(type.call(target))
+                                        );
+                                }
+                        }));
+                } else {
+                        var propagationBuilder = storeBuilder.getAdapter(PropagationBuilder.class);
+                        propagationBuilder.rule(Rule.of(name + "#invalidLink", (builder, p1, p2) -> {
+                                builder.clause(
+                                                may(linkType.call(p1, p2)),
+                                                not(may(type.call(p1)))
+                                );
+                                if (info.isConstrained()) {
                                         builder.clause(
-                                                        mayNewSource.call(source),
-                                                        mayNewSource.call(target),
-                                                        not(forbiddenView.call(source, target))
+                                                        may(linkType.call(p1, p2)),
+                                                        not(must(linkType.call(p1, p2))),
+                                                        not(mayNewSource.call(p1))
                                         );
-                                        if (info.isConstrained()) {
-                                                // Violation of monotonicity:
-                                                // Edges violating upper multiplicity will not be marked as {@code ERROR}, but the
-                                                // corresponding error pattern will already mark the node as invalid.
-                                                builder.clause(
-                                                                must(linkType.call(source, target)),
-                                                                not(forbiddenView.call(source, target)),
-                                                                may(type.call(source)),
-                                                                may(type.call(target))
-                                                );
-                                        }
-                                }))
-                                .refiner(UndirectedCrossReferenceRefiner.of(symbol, type))
-                                .initializer(new RefinementBasedInitializer<>(linkType))
-                                .decision(Rule.of(linkType.name(), (builder, source, target) -> builder
-                                                .clause(
-                                                                may(linkType.call(source, target)),
-                                                                not(candidateMust(linkType.call(source, target))),
-                                                                not(MULTI_VIEW.call(source)),
-                                                                not(MULTI_VIEW.call(target))
-                                                )
-                                                .action(
-                                                                add(linkType, source, target)
-                                                ))));
+                                }
+                                builder.action(
+                                                merge(linkType, TruthValue.FALSE, p1, p2)
+                                );
+                        }));
+                }
+                translator.refiner(UndirectedCrossReferenceRefiner.of(symbol, type));
+                translator.initializer(new UndirectedCrossReferenceInitializer(linkType, type, symbol));
+                translator.decision(Rule.of(linkType.name(), (builder, source, target) -> builder
+                                .clause(
+                                                may(linkType.call(source, target)),
+                                                not(candidateMust(linkType.call(source, target))),
+                                                not(MULTI_VIEW.call(source)),
+                                                not(MULTI_VIEW.call(target))
+                                )
+                                .action(
+                                                add(linkType, source, target)
+                                )));
+                storeBuilder.with(translator);
 
                 storeBuilder.with(new InvalidMultiplicityErrorTranslator(type, linkType, false, info.multiplicity()));
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
index 74022fc6..a5047768 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
@@ -16,6 +16,7 @@ import tools.refinery.store.reasoning.translator.multiplicity.UnconstrainedMulti
 import tools.refinery.store.reasoning.translator.typehierarchy.TypeInfo;
 
 import java.util.*;
+import java.util.function.Consumer;
 
 public class MetamodelBuilder {
         private final ContainedTypeHierarchyBuilder typeHierarchyBuilder = new ContainedTypeHierarchyBuilder();
@@ -68,6 +69,12 @@ public class MetamodelBuilder {
                 return this;
         }
 
+        public MetamodelBuilder reference(PartialRelation linkType, Consumer<ReferenceInfoBuilder> callback) {
+                var builder = ReferenceInfo.builder();
+                callback.accept(builder);
+                return reference(linkType, builder.build());
+        }
+
         public MetamodelBuilder reference(PartialRelation linkType, ReferenceInfo info) {
                 if (linkType.arity() != 2) {
                         throw new TranslationException(linkType,
@@ -81,47 +88,6 @@ public class MetamodelBuilder {
                 return this;
         }
 
-        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType, boolean containment,
-                                                                          Multiplicity multiplicity, PartialRelation targetType,
-                                                                          PartialRelation opposite) {
-                return reference(linkType, new ReferenceInfo(containment, sourceType, multiplicity, targetType, opposite));
-        }
-
-        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType, Multiplicity multiplicity,
-                                                                          PartialRelation targetType, PartialRelation opposite) {
-                return reference(linkType, sourceType, false, multiplicity, targetType, opposite);
-        }
-
-        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType,
-                                                                          boolean containment, PartialRelation targetType, PartialRelation opposite) {
-                return reference(linkType, sourceType, containment, UnconstrainedMultiplicity.INSTANCE, targetType, opposite);
-        }
-
-        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType, PartialRelation targetType,
-                                                                          PartialRelation opposite) {
-                return reference(linkType, sourceType, UnconstrainedMultiplicity.INSTANCE, targetType, opposite);
-        }
-
-        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType, boolean containment,
-                                                                          Multiplicity multiplicity, PartialRelation targetType) {
-                return reference(linkType, sourceType, containment, multiplicity, targetType, null);
-        }
-
-        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType, Multiplicity multiplicity,
-                                                                          PartialRelation targetType) {
-                return reference(linkType, sourceType, multiplicity, targetType, null);
-        }
-
-        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType, boolean containment,
-                                                                          PartialRelation targetType) {
-                return reference(linkType, sourceType, containment, targetType, null);
-        }
-
-        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType,
-                                                                          PartialRelation targetType) {
-                return reference(linkType, sourceType, targetType, null);
-        }
-
         public MetamodelBuilder references(Collection<Map.Entry<PartialRelation, ReferenceInfo>> entries) {
                 for (var entry : entries) {
                         reference(entry.getKey(), entry.getValue());
@@ -160,10 +126,12 @@ public class MetamodelBuilder {
                 var targetType = info.targetType();
                 var opposite = info.opposite();
                 Multiplicity targetMultiplicity = UnconstrainedMultiplicity.INSTANCE;
+                var defaultValue = info.defaultValue();
                 if (opposite != null) {
                         var oppositeInfo = referenceInfoMap.get(opposite);
                         validateOpposite(linkType, info, opposite, oppositeInfo);
                         targetMultiplicity = oppositeInfo.multiplicity();
+                        defaultValue = defaultValue.merge(oppositeInfo.defaultValue());
                         if (oppositeInfo.containment()) {
                                 // Skip processing this reference and process it once we encounter its containment opposite.
                                 return;
@@ -175,7 +143,7 @@ public class MetamodelBuilder {
                                                                         targetType, linkType, sourceType));
                                 }
                                 undirectedCrossReferences.put(linkType, new UndirectedCrossReferenceInfo(sourceType,
-                                                info.multiplicity()));
+                                                info.multiplicity(), defaultValue));
                                 return;
                         }
                         oppositeReferences.put(opposite, linkType);
@@ -185,7 +153,7 @@ public class MetamodelBuilder {
                         return;
                 }
                 directedCrossReferences.put(linkType, new DirectedCrossReferenceInfo(sourceType, info.multiplicity(),
-                                targetType, targetMultiplicity));
+                                targetType, targetMultiplicity, defaultValue));
         }
 
         private void processContainmentInfo(PartialRelation linkType, ReferenceInfo info,
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ReferenceInfo.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ReferenceInfo.java
index 9a6b4012..9d7fc9c3 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ReferenceInfo.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ReferenceInfo.java
@@ -7,7 +7,11 @@ package tools.refinery.store.reasoning.translator.metamodel;
 
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
+import tools.refinery.store.representation.TruthValue;
 
 public record ReferenceInfo(boolean containment, PartialRelation sourceType, Multiplicity multiplicity,
-                                                        PartialRelation targetType, PartialRelation opposite) {
+                                                        PartialRelation targetType, PartialRelation opposite, TruthValue defaultValue) {
+        public static ReferenceInfoBuilder builder() {
+                return new ReferenceInfoBuilder();
+        }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ReferenceInfoBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ReferenceInfoBuilder.java
new file mode 100644
index 00000000..43d01503
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ReferenceInfoBuilder.java
@@ -0,0 +1,84 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.metamodel;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.multiplicity.ConstrainedMultiplicity;
+import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
+import tools.refinery.store.reasoning.translator.multiplicity.UnconstrainedMultiplicity;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.representation.cardinality.CardinalityInterval;
+
+public final class ReferenceInfoBuilder {
+        private boolean containment;
+        private PartialRelation sourceType;
+        private Multiplicity multiplicity = UnconstrainedMultiplicity.INSTANCE;
+        private PartialRelation targetType;
+        private PartialRelation opposite;
+        private TruthValue defaultValue = TruthValue.UNKNOWN;
+
+        ReferenceInfoBuilder() {
+        }
+
+        public ReferenceInfoBuilder source(@NotNull PartialRelation sourceType) {
+                if (sourceType.arity() != 1) {
+                        throw new IllegalArgumentException("Source type %s must be of arity 1".formatted(sourceType));
+                }
+                this.sourceType = sourceType;
+                return this;
+        }
+
+        public ReferenceInfoBuilder target(@NotNull PartialRelation targetType) {
+                if (targetType.arity() != 1) {
+                        throw new IllegalArgumentException("Target type %s must be of arity 1".formatted(targetType));
+                }
+                this.targetType = targetType;
+                return this;
+        }
+
+        public ReferenceInfoBuilder containment(boolean containment) {
+                this.containment = containment;
+                return this;
+        }
+
+        public ReferenceInfoBuilder multiplicity(@NotNull Multiplicity multiplicity) {
+                this.multiplicity = multiplicity;
+                return this;
+        }
+
+        public ReferenceInfoBuilder multiplicity(@NotNull CardinalityInterval multiplicityInterval,
+                                                                                         @NotNull PartialRelation errorSymbol) {
+                return multiplicity(ConstrainedMultiplicity.of(multiplicityInterval, errorSymbol));
+        }
+
+        public ReferenceInfoBuilder opposite(@Nullable PartialRelation opposite) {
+                if (opposite != null && opposite.arity() != 2) {
+                        throw new IllegalArgumentException("Opposite %s must be of arity 2".formatted(targetType));
+                }
+                this.opposite = opposite;
+                return this;
+        }
+
+        public ReferenceInfoBuilder defaultValue(@NotNull TruthValue defaultValue) {
+                if (defaultValue.must()) {
+                        throw new IllegalArgumentException("Unsupported default value");
+                }
+                this.defaultValue = defaultValue;
+                return this;
+        }
+
+        public ReferenceInfo build() {
+                if (sourceType == null) {
+                        throw new IllegalStateException("Source type is required");
+                }
+                if (targetType == null) {
+                        throw new IllegalStateException("Target type is required");
+                }
+                return new ReferenceInfo(containment, sourceType, multiplicity, targetType, opposite, defaultValue);
+        }
+}
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilderTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilderTest.java
index 0f1a1006..ba6ba6da 100644
--- a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilderTest.java
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilderTest.java
@@ -8,7 +8,6 @@ package tools.refinery.store.reasoning.translator.metamodel;
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.TranslationException;
-import tools.refinery.store.reasoning.translator.multiplicity.ConstrainedMultiplicity;
 import tools.refinery.store.representation.cardinality.CardinalityIntervals;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -24,8 +23,13 @@ class MetamodelBuilderTest {
                 var builder = Metamodel.builder()
                                 .type(university)
                                 .type(course)
-                                .reference(courses, university, course, location)
-                                .reference(location, course, university);
+                                .reference(courses, referenceBuilder -> referenceBuilder
+                                                .source(university)
+                                                .target(course)
+                                                .opposite(location))
+                                .reference(location, referenceBuilder -> referenceBuilder
+                                                .source(course)
+                                                .target(university));
 
                 assertThrows(TranslationException.class, builder::build);
         }
@@ -35,8 +39,14 @@ class MetamodelBuilderTest {
                 var builder = Metamodel.builder()
                                 .type(university)
                                 .type(course)
-                                .reference(courses, university, course, location)
-                                .reference(location, course, course, courses);
+                                .reference(courses, referenceBuilder -> referenceBuilder
+                                                .source(university)
+                                                .target(course)
+                                                .opposite(location))
+                                .reference(location, referenceBuilder -> referenceBuilder
+                                                .source(course)
+                                                .target(course)
+                                                .opposite(courses));
 
                 assertThrows(TranslationException.class, builder::build);
         }
@@ -48,10 +58,16 @@ class MetamodelBuilderTest {
                 var builder = Metamodel.builder()
                                 .type(university)
                                 .type(course)
-                                .reference(courses, university, true, course, location)
-                                .reference(location, course,
-                                                ConstrainedMultiplicity.of(CardinalityIntervals.atLeast(2), invalidMultiplicity),
-                                                university,     courses);
+                                .reference(courses, referenceBuilder -> referenceBuilder
+                                                .containment(true)
+                                                .source(university)
+                                                .target(course)
+                                                .opposite(location))
+                                .reference(location, referenceBuilder -> referenceBuilder
+                                                .source(course)
+                                                .multiplicity(CardinalityIntervals.atLeast(2), invalidMultiplicity)
+                                                .target(university)
+                                                .opposite(courses));
 
                 assertThrows(TranslationException.class, builder::build);
         }
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTest.java
index 6c2f55af..88e6a4d7 100644
--- a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTest.java
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTest.java
@@ -16,7 +16,6 @@ import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.seed.ModelSeed;
 import tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator;
 import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
-import tools.refinery.store.reasoning.translator.multiplicity.ConstrainedMultiplicity;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.representation.cardinality.CardinalityIntervals;
 import tools.refinery.store.tuple.Tuple;
@@ -45,12 +44,23 @@ class MetamodelTest {
                                 .type(teacher, person)
                                 .type(university)
                                 .type(course)
-                                .reference(courses, university, true, course, location)
-                                .reference(location, course, university, courses)
-                                .reference(lecturer, course,
-                                                ConstrainedMultiplicity.of(CardinalityIntervals.ONE, invalidLecturerCount), teacher)
-                                .reference(enrolledStudents, course,
-                                                ConstrainedMultiplicity.of(CardinalityIntervals.SOME, invalidStudentCount), student)
+                                .reference(courses, builder -> builder
+                                                .containment(true)
+                                                .source(university)
+                                                .target(course)
+                                                .opposite(location))
+                                .reference(location, builder -> builder
+                                                .source(course)
+                                                .target(university)
+                                                .opposite(courses))
+                                .reference(lecturer, builder -> builder
+                                                .source(course)
+                                                .multiplicity(CardinalityIntervals.ONE, invalidLecturerCount)
+                                                .target(teacher))
+                                .reference(enrolledStudents, builder -> builder
+                                                .source(course)
+                                                .multiplicity(CardinalityIntervals.SOME, invalidStudentCount)
+                                                .target(student))
                                 .build();
 
                 var seed = ModelSeed.builder(5)
@@ -105,10 +115,12 @@ class MetamodelTest {
                 var metamodel = Metamodel.builder()
                                 .type(university)
                                 .type(course)
-                                .reference(courses, university, true, course)
+                                .reference(courses, builder -> builder
+                                                .containment(true)
+                                                .source(university)
+                                                .target(course))
                                 .build();
 
-
                 var seed = ModelSeed.builder(4)
                                 .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
                                                 .reducedValue(CardinalityIntervals.ONE)
diff --git a/yarn.lock b/yarn.lock
index 16ac69f0..a99aced7 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1234,12 +1234,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/runtime@npm:^7.11.2, @babel/runtime@npm:^7.12.5, @babel/runtime@npm:^7.18.3, @babel/runtime@npm:^7.23.2, @babel/runtime@npm:^7.23.4, @babel/runtime@npm:^7.5.5, @babel/runtime@npm:^7.8.4, @babel/runtime@npm:^7.8.7":
-  version: 7.23.5
-  resolution: "@babel/runtime@npm:7.23.5"
+"@babel/runtime@npm:^7.11.2, @babel/runtime@npm:^7.12.5, @babel/runtime@npm:^7.18.3, @babel/runtime@npm:^7.23.2, @babel/runtime@npm:^7.23.5, @babel/runtime@npm:^7.5.5, @babel/runtime@npm:^7.8.4, @babel/runtime@npm:^7.8.7":
+  version: 7.23.6
+  resolution: "@babel/runtime@npm:7.23.6"
   dependencies:
     regenerator-runtime: "npm:^0.14.0"
-  checksum: ca679cc91bb7e424bc2db87bb58cc3b06ade916b9adb21fbbdc43e54cdaacb3eea201ceba2a0464b11d2eb65b9fe6a6ffcf4d7521fa52994f19be96f1af14788
+  checksum: d886954e985ef8e421222f7a2848884d96a752e0020d3078b920dd104e672fdf23bcc6f51a44313a048796319f1ac9d09c2c88ec8cbb4e1f09174bcd3335b9ff
   languageName: node
   linkType: hard
 
@@ -1348,21 +1348,21 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@codemirror/state@npm:^6.0.0, @codemirror/state@npm:^6.1.4, @codemirror/state@npm:^6.2.0, @codemirror/state@npm:^6.3.2":
-  version: 6.3.2
-  resolution: "@codemirror/state@npm:6.3.2"
-  checksum: d0fa8c78bbccacc6bff5ac661a8e825c21c12fd45294d9a2e181d50af8294165b749094a3fbfc173a0aac72eabc3bf28aa48dfebc330239663680b2ded701ff5
+"@codemirror/state@npm:^6.0.0, @codemirror/state@npm:^6.1.4, @codemirror/state@npm:^6.2.0, @codemirror/state@npm:^6.3.3":
+  version: 6.3.3
+  resolution: "@codemirror/state@npm:6.3.3"
+  checksum: 97f0174dd6aa43d6293630b0024918ce1bb1f7833de8fa75006de8b7dbd963e2bb8b5e7a805f5a98492a0379d8b60faaee319d42583562b8ea6347ab8b63bf5f
   languageName: node
   linkType: hard
 
-"@codemirror/view@npm:^6.0.0, @codemirror/view@npm:^6.17.0, @codemirror/view@npm:^6.22.1":
-  version: 6.22.1
-  resolution: "@codemirror/view@npm:6.22.1"
+"@codemirror/view@npm:^6.0.0, @codemirror/view@npm:^6.17.0, @codemirror/view@npm:^6.22.3":
+  version: 6.22.3
+  resolution: "@codemirror/view@npm:6.22.3"
   dependencies:
     "@codemirror/state": "npm:^6.1.4"
     style-mod: "npm:^4.1.0"
     w3c-keyname: "npm:^2.2.4"
-  checksum: 142a861c2bf6d0ba2817eaffdf985c19b556cc98af1bd565b1e9286bfcaf17eb12837ce41633a2462fca1731d043781c21c778fb0d5ae928c03c6a6f42485c78
+  checksum: ed5e48923f0522d2c55c0bb48eadb06823afaa5fb037b09b53b8eb00acdd4c7cb90816ee023ba90d7c70f7612bb8ab749d232398a6ae8bc2dc4df8d653ba7386
   languageName: node
   linkType: hard
 
@@ -1421,14 +1421,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@emotion/react@npm:^11.11.1":
-  version: 11.11.1
-  resolution: "@emotion/react@npm:11.11.1"
+"@emotion/react@npm:^11.11.3":
+  version: 11.11.3
+  resolution: "@emotion/react@npm:11.11.3"
   dependencies:
     "@babel/runtime": "npm:^7.18.3"
     "@emotion/babel-plugin": "npm:^11.11.0"
     "@emotion/cache": "npm:^11.11.0"
-    "@emotion/serialize": "npm:^1.1.2"
+    "@emotion/serialize": "npm:^1.1.3"
     "@emotion/use-insertion-effect-with-fallbacks": "npm:^1.0.1"
     "@emotion/utils": "npm:^1.2.1"
     "@emotion/weak-memoize": "npm:^0.3.1"
@@ -1438,20 +1438,20 @@ __metadata:
   peerDependenciesMeta:
     "@types/react":
       optional: true
-  checksum: 1aea4d735b537fbfbeda828bbf929488a7e1b5b7d131f14aeede8737e92bb3b611e15fec353e97f85aed7a65a1c86a695a04ba6e9be905231beef6bd624cb705
+  checksum: ce995395b8714343715284beb8478afdfa72b89ed83981a15a170ca0f4a2f77d7a4a198fd50c1f9c6efcd0535768d168ff88c5921dc5f90bb33134c7a75f9455
   languageName: node
   linkType: hard
 
-"@emotion/serialize@npm:^1.1.2":
-  version: 1.1.2
-  resolution: "@emotion/serialize@npm:1.1.2"
+"@emotion/serialize@npm:^1.1.2, @emotion/serialize@npm:^1.1.3":
+  version: 1.1.3
+  resolution: "@emotion/serialize@npm:1.1.3"
   dependencies:
     "@emotion/hash": "npm:^0.9.1"
     "@emotion/memoize": "npm:^0.8.1"
     "@emotion/unitless": "npm:^0.8.1"
     "@emotion/utils": "npm:^1.2.1"
     csstype: "npm:^3.0.2"
-  checksum: d243e0e5abce8d2183d25a32ec89bf650ee741ebadb29e6405abde05d4e2ed446ba5b3f725a29833ad709d0d08f0a5c8d0532fdcd43f4b23d931d8b6d4f218c1
+  checksum: 875241eafaa30e7d3b7cf9b585d8c1f224cbf627a674e87eb1d7662dafa76a8c8d67f14a79dbf7d1eaa017e9f68389962990fbcc699d5ad65035a1a047432a3f
   languageName: node
   linkType: hard
 
@@ -1701,10 +1701,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@eslint/js@npm:8.55.0":
-  version: 8.55.0
-  resolution: "@eslint/js@npm:8.55.0"
-  checksum: 88ab9fc57a651becd2b32ec40a3958db27fae133b1ae77bebd733aa5bbd00a92f325bb02f20ad680d31c731fa49b22f060a4777dd52eb3e27da013d940bd978d
+"@eslint/js@npm:8.56.0":
+  version: 8.56.0
+  resolution: "@eslint/js@npm:8.56.0"
+  checksum: 60b3a1cf240e2479cec9742424224465dc50e46d781da1b7f5ef240501b2d1202c225bd456207faac4b34a64f4765833345bc4ddffd00395e1db40fa8c426f5a
   languageName: node
   linkType: hard
 
@@ -1746,28 +1746,28 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@fontsource-variable/jetbrains-mono@npm:^5.0.18":
-  version: 5.0.18
-  resolution: "@fontsource-variable/jetbrains-mono@npm:5.0.18"
-  checksum: c11926a1c55c1f9983a4d94cedad0b5d9b718cd58050c95e2cd14dab165bfba939e3cbecda8dd4652198e7f681e720490914f42b3dfabd1e11796002ba5a2e01
+"@fontsource-variable/jetbrains-mono@npm:^5.0.19":
+  version: 5.0.19
+  resolution: "@fontsource-variable/jetbrains-mono@npm:5.0.19"
+  checksum: 93622a6af324be162f028b974bd61f10530df30a1332dded4915509c0a21d80435ad623fb45325dd175afaa095ca6650f2de9da295b2bc9dea85474050d1a46b
   languageName: node
   linkType: hard
 
-"@fontsource-variable/open-sans@npm:^5.0.18":
-  version: 5.0.18
-  resolution: "@fontsource-variable/open-sans@npm:5.0.18"
-  checksum: ec5e33654d5abfed6d7788bd404f91bab749f69ede1730ab0b958265e1dcc82b77972d0f8e98d477e2f41d3334c73c86a8e7bd90107295b4c44bb17607977b78
+"@fontsource-variable/open-sans@npm:^5.0.21":
+  version: 5.0.21
+  resolution: "@fontsource-variable/open-sans@npm:5.0.21"
+  checksum: d7a5832751f24ca080355ac51259195dea1910cb4a7f74b5531e993e9892fadfb7784949d5d065d067403db1741bbedcbc96bb5cf1d988449ff647eeba0d4481
   languageName: node
   linkType: hard
 
-"@hpcc-js/wasm@npm:^2.14.1, @hpcc-js/wasm@npm:^2.15.0":
-  version: 2.15.0
-  resolution: "@hpcc-js/wasm@npm:2.15.0"
+"@hpcc-js/wasm@npm:^2.14.1, @hpcc-js/wasm@npm:^2.15.3":
+  version: 2.15.3
+  resolution: "@hpcc-js/wasm@npm:2.15.3"
   dependencies:
     yargs: "npm:17.7.2"
   bin:
     dot-wasm: bin/dot-wasm.js
-  checksum: aa3daac878a1c6135fd1eeafa0952e75d37c2664e5ccfb98075a5a901fc898852440a476ab54528cce8a6ae9abea44c810e39695c80149fc60c51f0389288c80
+  checksum: 9e4474329f191d93cd4029afe4a5e83732bec732a7c83a913fefe64e08a82deb59dbdc33d42c92e4c8eb4df5853c8cbe10d8d53d7db5204d8c9919af082f64b1
   languageName: node
   linkType: hard
 
@@ -1862,10 +1862,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@lezer/common@npm:^1.0.0, @lezer/common@npm:^1.0.2, @lezer/common@npm:^1.1.0, @lezer/common@npm:^1.1.1":
-  version: 1.1.1
-  resolution: "@lezer/common@npm:1.1.1"
-  checksum: 495b76f33164c732461097ee6f8d6f1250a63d21f5c01e58a24f1da49b8d4b392188bbbe972c0c2d7ec48db8e3fd550563bcdefba3b81b4d895e821c1f91fc8e
+"@lezer/common@npm:^1.0.0, @lezer/common@npm:^1.0.2, @lezer/common@npm:^1.1.0, @lezer/common@npm:^1.1.2":
+  version: 1.1.2
+  resolution: "@lezer/common@npm:1.1.2"
+  checksum: ed25e0b05ff073247266f2824d38159b93ab359be23c479ae0cf37131ec0d463a58dc2b78fb989ff9e29f87e0ef16291b2bd6243b082bb4116aed3e386cc069c
   languageName: node
   linkType: hard
 
@@ -1906,14 +1906,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@mui/base@npm:5.0.0-beta.25":
-  version: 5.0.0-beta.25
-  resolution: "@mui/base@npm:5.0.0-beta.25"
+"@mui/base@npm:5.0.0-beta.28":
+  version: 5.0.0-beta.28
+  resolution: "@mui/base@npm:5.0.0-beta.28"
   dependencies:
-    "@babel/runtime": "npm:^7.23.4"
+    "@babel/runtime": "npm:^7.23.5"
     "@floating-ui/react-dom": "npm:^2.0.4"
-    "@mui/types": "npm:^7.2.10"
-    "@mui/utils": "npm:^5.14.19"
+    "@mui/types": "npm:^7.2.11"
+    "@mui/utils": "npm:^5.15.1"
     "@popperjs/core": "npm:^2.11.8"
     clsx: "npm:^2.0.0"
     prop-types: "npm:^15.8.1"
@@ -1924,22 +1924,22 @@ __metadata:
   peerDependenciesMeta:
     "@types/react":
       optional: true
-  checksum: 9b1865655cb94b7a40ea31c698f1163d5521a7bb110ddcc1131f83a76428628d11d1582d2e96968734eed17d26e69c6c2b10eb5b9757639e7ddd48be0bd22dc6
+  checksum: 31479d9548e1b29150e3b94bcb88edce409339ac047e78a8a70173a0fa2c7730b38f28c6b366e2b3dda3964f28e883153cae0dc2957218b1711bb58004ddc2d1
   languageName: node
   linkType: hard
 
-"@mui/core-downloads-tracker@npm:^5.14.19":
-  version: 5.14.19
-  resolution: "@mui/core-downloads-tracker@npm:5.14.19"
-  checksum: a0851424a067e0e0c266752e34000bcc63121191b93077d6dc01834a71c5defe95e54495f98347e2f8c247cebfe38d142600c71b9a698cf30f114e90598ebb91
+"@mui/core-downloads-tracker@npm:^5.15.1":
+  version: 5.15.1
+  resolution: "@mui/core-downloads-tracker@npm:5.15.1"
+  checksum: 81e3afca19135336c1122aaa8bd69e411df95389c2654c03ce8a8787f4ee4b14403f58acfbf4eef1b9267685569ee9a0bee4b08cf15782d866e9277792d84657
   languageName: node
   linkType: hard
 
-"@mui/icons-material@npm:5.14.19":
-  version: 5.14.19
-  resolution: "@mui/icons-material@npm:5.14.19"
+"@mui/icons-material@npm:^5.15.1":
+  version: 5.15.1
+  resolution: "@mui/icons-material@npm:5.15.1"
   dependencies:
-    "@babel/runtime": "npm:^7.23.4"
+    "@babel/runtime": "npm:^7.23.5"
   peerDependencies:
     "@mui/material": ^5.0.0
     "@types/react": ^17.0.0 || ^18.0.0
@@ -1947,21 +1947,21 @@ __metadata:
   peerDependenciesMeta:
     "@types/react":
       optional: true
-  checksum: 1af1a14622795dae1b999b49dc27d8d9f32344ccd3bc73a3b9dbce3d8d7ad43e6aa93e100a58ae423c9404fcb91dbdeb7758bd94f5f4614a4843f649645a42a1
+  checksum: 9ae975f7534094f6e80ffeb3946338a22b9656bb02544fa76e427daeff050c7db0ce83b261bca73a1aab17789d87cc19cc92749d0dc40501f889a9dbfb35709d
   languageName: node
   linkType: hard
 
-"@mui/material@npm:5.14.19":
-  version: 5.14.19
-  resolution: "@mui/material@npm:5.14.19"
+"@mui/material@npm:^5.15.1":
+  version: 5.15.1
+  resolution: "@mui/material@npm:5.15.1"
   dependencies:
-    "@babel/runtime": "npm:^7.23.4"
-    "@mui/base": "npm:5.0.0-beta.25"
-    "@mui/core-downloads-tracker": "npm:^5.14.19"
-    "@mui/system": "npm:^5.14.19"
-    "@mui/types": "npm:^7.2.10"
-    "@mui/utils": "npm:^5.14.19"
-    "@types/react-transition-group": "npm:^4.4.9"
+    "@babel/runtime": "npm:^7.23.5"
+    "@mui/base": "npm:5.0.0-beta.28"
+    "@mui/core-downloads-tracker": "npm:^5.15.1"
+    "@mui/system": "npm:^5.15.1"
+    "@mui/types": "npm:^7.2.11"
+    "@mui/utils": "npm:^5.15.1"
+    "@types/react-transition-group": "npm:^4.4.10"
     clsx: "npm:^2.0.0"
     csstype: "npm:^3.1.2"
     prop-types: "npm:^15.8.1"
@@ -1980,16 +1980,16 @@ __metadata:
       optional: true
     "@types/react":
       optional: true
-  checksum: 5ffce28bc26fa5c7ea4409f816698c9f9cb27ae70bcf06bd21aab40ea5b979f17568032a9ec74a9209d11272ee1efc9f4dcbb19f8574e3eec63a622220f58a3f
+  checksum: d5fc5cba599a691d84424bfa8d8a3dc18ecbf85ea1bd4fc92292b716a4df9facf391d3c164743f83ae8c69905f92c0061cd311d2c6c3a051a277614940b87b1b
   languageName: node
   linkType: hard
 
-"@mui/private-theming@npm:^5.14.19":
-  version: 5.14.19
-  resolution: "@mui/private-theming@npm:5.14.19"
+"@mui/private-theming@npm:^5.15.1":
+  version: 5.15.1
+  resolution: "@mui/private-theming@npm:5.15.1"
   dependencies:
-    "@babel/runtime": "npm:^7.23.4"
-    "@mui/utils": "npm:^5.14.19"
+    "@babel/runtime": "npm:^7.23.5"
+    "@mui/utils": "npm:^5.15.1"
     prop-types: "npm:^15.8.1"
   peerDependencies:
     "@types/react": ^17.0.0 || ^18.0.0
@@ -1997,15 +1997,15 @@ __metadata:
   peerDependenciesMeta:
     "@types/react":
       optional: true
-  checksum: 06bb5c40f680c037c80fef67404d1181b5775ef38157e12d03c58d1b070e6bb89d82b028d0a544e5d78cbd7822f50d5596e1320cd822c9cfbf185cb3ab2f935c
+  checksum: 1d5e334601eac1e1f153c91094cd513e98ccb8fef2fcbcf8c048723d171ceda59b8231dcc3daa665e5e5ee7e39aae1b653040efb64320ef89d4ec1ad88eea4de
   languageName: node
   linkType: hard
 
-"@mui/styled-engine@npm:^5.14.19":
-  version: 5.14.19
-  resolution: "@mui/styled-engine@npm:5.14.19"
+"@mui/styled-engine@npm:^5.15.1":
+  version: 5.15.1
+  resolution: "@mui/styled-engine@npm:5.15.1"
   dependencies:
-    "@babel/runtime": "npm:^7.23.4"
+    "@babel/runtime": "npm:^7.23.5"
     "@emotion/cache": "npm:^11.11.0"
     csstype: "npm:^3.1.2"
     prop-types: "npm:^15.8.1"
@@ -2018,19 +2018,19 @@ __metadata:
       optional: true
     "@emotion/styled":
       optional: true
-  checksum: eaa539b76008d0dbc22cf6b479885f223ca2d71e7338d73f583529ad9b57fe80656cfb5f3779d1c84b7fa7f779b15f3a5df28eb1e1bf797609f78f295b6219f0
+  checksum: fcfa7cd3ba9ab24ad557ac9e980b46ff4d4dfddab41b1cdd57257a5ad57bf13e3891d771218dca1b1f405609c6e1e9895b80fcd90211a8877279f7774bb70e70
   languageName: node
   linkType: hard
 
-"@mui/system@npm:^5.14.19":
-  version: 5.14.19
-  resolution: "@mui/system@npm:5.14.19"
+"@mui/system@npm:^5.15.1":
+  version: 5.15.1
+  resolution: "@mui/system@npm:5.15.1"
   dependencies:
-    "@babel/runtime": "npm:^7.23.4"
-    "@mui/private-theming": "npm:^5.14.19"
-    "@mui/styled-engine": "npm:^5.14.19"
-    "@mui/types": "npm:^7.2.10"
-    "@mui/utils": "npm:^5.14.19"
+    "@babel/runtime": "npm:^7.23.5"
+    "@mui/private-theming": "npm:^5.15.1"
+    "@mui/styled-engine": "npm:^5.15.1"
+    "@mui/types": "npm:^7.2.11"
+    "@mui/utils": "npm:^5.15.1"
     clsx: "npm:^2.0.0"
     csstype: "npm:^3.1.2"
     prop-types: "npm:^15.8.1"
@@ -2046,27 +2046,27 @@ __metadata:
       optional: true
     "@types/react":
       optional: true
-  checksum: 8fb45a4bf6ca8736e029bcd42cd085eb3ade8d46c58f1ed2c1ab266cb89397855f1176a7d8dd4317d8ef08045d4e30a28c706b51415c37a8c8ae2589dc1a6d9a
+  checksum: c8abf92fde14031b0e6af6ef2d947bde9e98ce08bb81550bb08fa56793adf1da086066299a7c09d7f26c6e3a6a780679064ed8e54914ae5d775bb87c44632dc5
   languageName: node
   linkType: hard
 
-"@mui/types@npm:^7.2.10":
-  version: 7.2.10
-  resolution: "@mui/types@npm:7.2.10"
+"@mui/types@npm:^7.2.11":
+  version: 7.2.11
+  resolution: "@mui/types@npm:7.2.11"
   peerDependencies:
     "@types/react": ^17.0.0 || ^18.0.0
   peerDependenciesMeta:
     "@types/react":
       optional: true
-  checksum: 59c8162812581cd1021d319e8828f6220723ffceb13609a99b1ffee6943f81ab07291cc3837c28776ca919dbe74c6416b2014c10e16b19135ff94a80ad7d3270
+  checksum: 5aecdd9b02ca4537d05ec1809a31e64a3330dc104509bc470ec8e38a00259d36faf2dadee828987b385dff46fbec6fe112ef3a5c0c1b78e60c56755af04d38fa
   languageName: node
   linkType: hard
 
-"@mui/utils@npm:^5.14.16, @mui/utils@npm:^5.14.19":
-  version: 5.14.19
-  resolution: "@mui/utils@npm:5.14.19"
+"@mui/utils@npm:^5.14.16, @mui/utils@npm:^5.15.1":
+  version: 5.15.1
+  resolution: "@mui/utils@npm:5.15.1"
   dependencies:
-    "@babel/runtime": "npm:^7.23.4"
+    "@babel/runtime": "npm:^7.23.5"
     "@types/prop-types": "npm:^15.7.11"
     prop-types: "npm:^15.8.1"
     react-is: "npm:^18.2.0"
@@ -2076,13 +2076,13 @@ __metadata:
   peerDependenciesMeta:
     "@types/react":
       optional: true
-  checksum: fb049eed27249dabfba2b3bf3b6d6ebd0a31e837cde6651ab727482e24f3be700103ac04074c348cf8bdc5bed09d6e4c251e7ca46d7bbb66e2e5e9a062ea06cb
+  checksum: 46a66c488ece0d5be5f179316495220ff95d5276f452ea1cf48836ed6aade63ceb5dd3cd0d3970eb958272eb4455deb657effcf52b7eb2355d9b99bef9d61909
   languageName: node
   linkType: hard
 
-"@mui/x-data-grid@npm:^6.18.2":
-  version: 6.18.2
-  resolution: "@mui/x-data-grid@npm:6.18.2"
+"@mui/x-data-grid@npm:^6.18.6":
+  version: 6.18.6
+  resolution: "@mui/x-data-grid@npm:6.18.6"
   dependencies:
     "@babel/runtime": "npm:^7.23.2"
     "@mui/utils": "npm:^5.14.16"
@@ -2094,7 +2094,7 @@ __metadata:
     "@mui/system": ^5.4.1
     react: ^17.0.0 || ^18.0.0
     react-dom: ^17.0.0 || ^18.0.0
-  checksum: 441328df15f1d82651612229bee42c74eda893837bc08edc7c171a85bb755a612395f5abf8b4d09ddf4f70a74914faff221b6001ee8975c0ebe439ab7a1b4be1
+  checksum: a8931efe1cff8951331223defdf9b17cb501eef85d4b176f36f9b0fb8a9522d6c4d6f5b672ac4f9b710ab95faf98d7a405fb3a739cbe871123798ed82a71dee3
   languageName: node
   linkType: hard
 
@@ -2171,56 +2171,56 @@ __metadata:
     "@codemirror/language": "npm:^6.9.3"
     "@codemirror/lint": "npm:^6.4.2"
     "@codemirror/search": "npm:^6.5.5"
-    "@codemirror/state": "npm:^6.3.2"
-    "@codemirror/view": "npm:^6.22.1"
-    "@emotion/react": "npm:^11.11.1"
+    "@codemirror/state": "npm:^6.3.3"
+    "@codemirror/view": "npm:^6.22.3"
+    "@emotion/react": "npm:^11.11.3"
     "@emotion/styled": "npm:^11.11.0"
-    "@fontsource-variable/jetbrains-mono": "npm:^5.0.18"
-    "@fontsource-variable/open-sans": "npm:^5.0.18"
-    "@hpcc-js/wasm": "npm:^2.15.0"
-    "@lezer/common": "npm:^1.1.1"
+    "@fontsource-variable/jetbrains-mono": "npm:^5.0.19"
+    "@fontsource-variable/open-sans": "npm:^5.0.21"
+    "@hpcc-js/wasm": "npm:^2.15.3"
+    "@lezer/common": "npm:^1.1.2"
     "@lezer/generator": "npm:^1.5.1"
     "@lezer/highlight": "npm:^1.2.0"
     "@lezer/lr": "npm:^1.3.14"
     "@material-icons/svg": "npm:^1.0.33"
-    "@mui/icons-material": "npm:5.14.19"
-    "@mui/material": "npm:5.14.19"
-    "@mui/system": "npm:^5.14.19"
-    "@mui/x-data-grid": "npm:^6.18.2"
+    "@mui/icons-material": "npm:^5.15.1"
+    "@mui/material": "npm:^5.15.1"
+    "@mui/system": "npm:^5.15.1"
+    "@mui/x-data-grid": "npm:^6.18.6"
     "@types/d3": "npm:^7.4.3"
     "@types/d3-graphviz": "npm:^2.6.10"
     "@types/d3-selection": "npm:^3.0.10"
     "@types/d3-zoom": "npm:^3.0.8"
-    "@types/eslint": "npm:^8.44.8"
+    "@types/eslint": "npm:^8.56.0"
     "@types/html-minifier-terser": "npm:^7.0.2"
     "@types/lodash-es": "npm:^4.17.12"
     "@types/micromatch": "npm:^4.0.6"
     "@types/ms": "npm:^0.7.34"
-    "@types/node": "npm:^20.10.2"
+    "@types/node": "npm:^20.10.5"
     "@types/pnpapi": "npm:^0.0.5"
-    "@types/react": "npm:^18.2.41"
-    "@types/react-dom": "npm:^18.2.17"
-    "@typescript-eslint/eslint-plugin": "npm:^6.13.1"
-    "@typescript-eslint/parser": "npm:^6.13.1"
+    "@types/react": "npm:^18.2.45"
+    "@types/react-dom": "npm:^18.2.18"
+    "@typescript-eslint/eslint-plugin": "npm:^6.15.0"
+    "@typescript-eslint/parser": "npm:^6.15.0"
     "@vitejs/plugin-react-swc": "npm:^3.5.0"
-    "@xstate/cli": "npm:^0.5.11"
+    "@xstate/cli": "npm:^0.5.15"
     ansi-styles: "npm:^6.2.1"
     cross-env: "npm:^7.0.3"
-    csstype: "npm:^3.1.2"
+    csstype: "npm:^3.1.3"
     d3: "npm:^7.8.5"
     d3-graphviz: "patch:d3-graphviz@npm%3A5.2.0#~/.yarn/patches/d3-graphviz-npm-5.2.0-161b1fbad4.patch"
     d3-selection: "npm:^3.0.0"
     d3-zoom: "patch:d3-zoom@npm%3A3.0.0#~/.yarn/patches/d3-zoom-npm-3.0.0-18f706a421.patch"
     escape-string-regexp: "npm:^5.0.0"
-    eslint: "npm:^8.55.0"
+    eslint: "npm:^8.56.0"
     eslint-config-airbnb: "npm:^19.0.4"
     eslint-config-airbnb-typescript: "npm:^17.1.0"
     eslint-config-prettier: "npm:^9.1.0"
     eslint-import-resolver-typescript: "npm:^3.6.1"
-    eslint-plugin-import: "npm:^2.29.0"
+    eslint-plugin-import: "npm:^2.29.1"
     eslint-plugin-jsx-a11y: "npm:^6.8.0"
     eslint-plugin-mobx: "npm:^0.0.9"
-    eslint-plugin-prettier: "npm:^5.0.1"
+    eslint-plugin-prettier: "npm:^5.1.1"
     eslint-plugin-react: "npm:^7.33.2"
     eslint-plugin-react-hooks: "npm:^4.6.0"
     html-minifier-terser: "npm:^7.2.0"
@@ -2234,13 +2234,13 @@ __metadata:
     nanoid: "npm:^5.0.4"
     notistack: "npm:^3.0.1"
     pnpapi: "npm:^0.0.0"
-    prettier: "npm:^3.1.0"
+    prettier: "npm:^3.1.1"
     react: "npm:^18.2.0"
     react-dom: "npm:^18.2.0"
-    react-resize-detector: "npm:^9.1.0"
-    typescript: "npm:5.3.2"
-    vite: "npm:^5.0.4"
-    vite-plugin-pwa: "npm:^0.17.2"
+    react-resize-detector: "npm:^9.1.1"
+    typescript: "npm:5.3.3"
+    vite: "npm:^5.0.10"
+    vite-plugin-pwa: "npm:^0.17.4"
     workbox-window: "npm:^7.0.0"
     xstate: "npm:^4.38.3"
     zod: "npm:^3.22.4"
@@ -2251,8 +2251,8 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@refinery/root@workspace:."
   dependencies:
-    eslint: "npm:^8.55.0"
-    typescript: "npm:5.3.2"
+    eslint: "npm:^8.56.0"
+    typescript: "npm:5.3.3"
   languageName: unknown
   linkType: soft
 
@@ -2879,13 +2879,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/eslint@npm:^8.44.8":
-  version: 8.44.8
-  resolution: "@types/eslint@npm:8.44.8"
+"@types/eslint@npm:^8.56.0":
+  version: 8.56.0
+  resolution: "@types/eslint@npm:8.56.0"
   dependencies:
     "@types/estree": "npm:*"
     "@types/json-schema": "npm:*"
-  checksum: 610966753add984f6ac9f00eeb766691e141e66a7e20b724a45ad077f60e8cd8fd7874b7e655e93537e54873cc5711cd6f57728474e08b478407cd942f098263
+  checksum: afba97b10d02cb7c7e7658de38f626c65b81be0fe45bc479e058ab14bc089911193811dce681edd656fc6b59c91fd8d0c976972476fc98b5e782b2c3b08aaa6c
   languageName: node
   linkType: hard
 
@@ -2963,12 +2963,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/node@npm:*, @types/node@npm:^20.10.2":
-  version: 20.10.2
-  resolution: "@types/node@npm:20.10.2"
+"@types/node@npm:*, @types/node@npm:^20.10.5":
+  version: 20.10.5
+  resolution: "@types/node@npm:20.10.5"
   dependencies:
     undici-types: "npm:~5.26.4"
-  checksum: c24630d6bdd237f538d69886868fc29abba8c59f58996b6a6267c42e2253a84a18834c09408b3d887ec74f69e6828e25e3d23cf6fa0daac5902afccaf0568d7e
+  checksum: be30609aae0bfe492097815f166ccc07f465220cb604647fa4e5ec05a1d16c012a41b82b5f11ecfe2485cbb479d4d20384b95b809ca0bcff6d94d5bbafa645bb
   languageName: node
   linkType: hard
 
@@ -2993,32 +2993,32 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/react-dom@npm:^18.2.17":
-  version: 18.2.17
-  resolution: "@types/react-dom@npm:18.2.17"
+"@types/react-dom@npm:^18.2.18":
+  version: 18.2.18
+  resolution: "@types/react-dom@npm:18.2.18"
   dependencies:
     "@types/react": "npm:*"
-  checksum: 33b53078ed7e9e0cfc4dc691e938f7db1cc06353bc345947b41b581c3efe2b980c9e4eb6460dbf5ddc521dd91959194c970221a2bd4bfad9d23ebce338e12938
+  checksum: 74dba11a1b8156f3a763f3fca1fb4ec1dcd349153279b8bf79210024a69f994bf2cf0728198c047f8130c5318420ea56281b0a4ef84c8ae943cd9a0cac705220
   languageName: node
   linkType: hard
 
-"@types/react-transition-group@npm:^4.4.9":
-  version: 4.4.9
-  resolution: "@types/react-transition-group@npm:4.4.9"
+"@types/react-transition-group@npm:^4.4.10":
+  version: 4.4.10
+  resolution: "@types/react-transition-group@npm:4.4.10"
   dependencies:
     "@types/react": "npm:*"
-  checksum: 279cd319202f7ec24ecad174dffd19fd161250bc438bf3c62951f467093e5664a0c895b185976bf45f55b68ec901e520924216eb8abafe934b66f55337319ff5
+  checksum: 3eb9bca143abc21eb781aa5cb1bded0c9335689d515bf0513fb8e63217b7a8122c6a323ecd5644a06938727e1f467ee061d8df1c93b68825a80ff1b47ab777a2
   languageName: node
   linkType: hard
 
-"@types/react@npm:*, @types/react@npm:^18.2.41":
-  version: 18.2.41
-  resolution: "@types/react@npm:18.2.41"
+"@types/react@npm:*, @types/react@npm:^18.2.45":
+  version: 18.2.45
+  resolution: "@types/react@npm:18.2.45"
   dependencies:
     "@types/prop-types": "npm:*"
     "@types/scheduler": "npm:*"
     csstype: "npm:^3.0.2"
-  checksum: 5cc72491ce8be95e7bbedd8bf039ca971772ecd22d989feb045af7e73247c7e6cff25a2f1c2200be461fb2f6b5aacef739e1ba9fd83c744209dfd3ce8aa75afe
+  checksum: 4cc650c47ffb88baac29fb7a74e842e4af4a55f437086ef70250fdc75f0a5f2fcf8adc272d05ab2e00b1de6e14613296881271caee037dadf9130fdeb498c59e
   languageName: node
   linkType: hard
 
@@ -3052,15 +3052,15 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@typescript-eslint/eslint-plugin@npm:^6.13.1":
-  version: 6.13.1
-  resolution: "@typescript-eslint/eslint-plugin@npm:6.13.1"
+"@typescript-eslint/eslint-plugin@npm:^6.15.0":
+  version: 6.15.0
+  resolution: "@typescript-eslint/eslint-plugin@npm:6.15.0"
   dependencies:
     "@eslint-community/regexpp": "npm:^4.5.1"
-    "@typescript-eslint/scope-manager": "npm:6.13.1"
-    "@typescript-eslint/type-utils": "npm:6.13.1"
-    "@typescript-eslint/utils": "npm:6.13.1"
-    "@typescript-eslint/visitor-keys": "npm:6.13.1"
+    "@typescript-eslint/scope-manager": "npm:6.15.0"
+    "@typescript-eslint/type-utils": "npm:6.15.0"
+    "@typescript-eslint/utils": "npm:6.15.0"
+    "@typescript-eslint/visitor-keys": "npm:6.15.0"
     debug: "npm:^4.3.4"
     graphemer: "npm:^1.4.0"
     ignore: "npm:^5.2.4"
@@ -3073,44 +3073,44 @@ __metadata:
   peerDependenciesMeta:
     typescript:
       optional: true
-  checksum: ccbcbf2a16d985348f46f07c90db06d98878632e7e98eb2fe9275dc489e8a3406bbe002e6d5ff0da88f51a5fe44ea0e942ec35488a3f1939e009f0a43997d34a
+  checksum: 78054afb0d4ab12d82db7a9cb005dfa2be42962341728abf4a81802e1f4c0f5b23de4870287f4b7e32aa4a4bc900bbc218f2d4d0c02aa77452e8e8e0b71fe3de
   languageName: node
   linkType: hard
 
-"@typescript-eslint/parser@npm:^6.13.1":
-  version: 6.13.1
-  resolution: "@typescript-eslint/parser@npm:6.13.1"
+"@typescript-eslint/parser@npm:^6.15.0":
+  version: 6.15.0
+  resolution: "@typescript-eslint/parser@npm:6.15.0"
   dependencies:
-    "@typescript-eslint/scope-manager": "npm:6.13.1"
-    "@typescript-eslint/types": "npm:6.13.1"
-    "@typescript-eslint/typescript-estree": "npm:6.13.1"
-    "@typescript-eslint/visitor-keys": "npm:6.13.1"
+    "@typescript-eslint/scope-manager": "npm:6.15.0"
+    "@typescript-eslint/types": "npm:6.15.0"
+    "@typescript-eslint/typescript-estree": "npm:6.15.0"
+    "@typescript-eslint/visitor-keys": "npm:6.15.0"
     debug: "npm:^4.3.4"
   peerDependencies:
     eslint: ^7.0.0 || ^8.0.0
   peerDependenciesMeta:
     typescript:
       optional: true
-  checksum: 83f67374815f330ba96c2129f616ee1c8af3a7282c91e9645371ce4a9acfc2797df345cc65a34efa3ff0e574ac9422921cdac623a37be21e36e45c46d6de4731
+  checksum: e7f265fd4abd3bc49fa5b304cd4b9c22801ac5a9da4ee342bbab0c117d629ac4aad6998555b61a8c5a0b279c443a44ae99f16669e24e3ef17ccec20c8b7019e7
   languageName: node
   linkType: hard
 
-"@typescript-eslint/scope-manager@npm:6.13.1":
-  version: 6.13.1
-  resolution: "@typescript-eslint/scope-manager@npm:6.13.1"
+"@typescript-eslint/scope-manager@npm:6.15.0":
+  version: 6.15.0
+  resolution: "@typescript-eslint/scope-manager@npm:6.15.0"
   dependencies:
-    "@typescript-eslint/types": "npm:6.13.1"
-    "@typescript-eslint/visitor-keys": "npm:6.13.1"
-  checksum: 2b00f087ba9a9940df4cbc96335312737b3a7744b61528e4949ffd8034067d4c419a7b20beeb4c47d0ed5f52ad82490e89622a0de0e33c4bb6af3ede14c680b8
+    "@typescript-eslint/types": "npm:6.15.0"
+    "@typescript-eslint/visitor-keys": "npm:6.15.0"
+  checksum: 3428d99de440f227cbc2afb44cdcb25e44c4b49c5f490392f83e21d2048210a6ec2f2f68133376c842034f5b5ba4ec9721da7caa18e631e23b57e20927b5b6f0
   languageName: node
   linkType: hard
 
-"@typescript-eslint/type-utils@npm:6.13.1":
-  version: 6.13.1
-  resolution: "@typescript-eslint/type-utils@npm:6.13.1"
+"@typescript-eslint/type-utils@npm:6.15.0":
+  version: 6.15.0
+  resolution: "@typescript-eslint/type-utils@npm:6.15.0"
   dependencies:
-    "@typescript-eslint/typescript-estree": "npm:6.13.1"
-    "@typescript-eslint/utils": "npm:6.13.1"
+    "@typescript-eslint/typescript-estree": "npm:6.15.0"
+    "@typescript-eslint/utils": "npm:6.15.0"
     debug: "npm:^4.3.4"
     ts-api-utils: "npm:^1.0.1"
   peerDependencies:
@@ -3118,23 +3118,23 @@ __metadata:
   peerDependenciesMeta:
     typescript:
       optional: true
-  checksum: c958126cb9d28021ae8e3bb2c11d5f427ab09adff5deaf64927f9769b8ba1f7b561dfb30ac2e69f9ef923183566569500a27a188b534e6641a34e0a6fd144773
+  checksum: 32cb531a4b5e0ccd431cba553ec73b87d4453b48af288a33e359ba4f5278126390d82799b61d3f0fbf135cfde1ac6c2275c2cf37a676e8a2a2811e774e660f16
   languageName: node
   linkType: hard
 
-"@typescript-eslint/types@npm:6.13.1":
-  version: 6.13.1
-  resolution: "@typescript-eslint/types@npm:6.13.1"
-  checksum: 26ea37ec6943859415d683b280e135c20da73281d742aaf123763bf9e10ea0629950422934c4ec3cc77a390a8fa8f33cc4f3914869ffd5af4d1edbbbae834d60
+"@typescript-eslint/types@npm:6.15.0":
+  version: 6.15.0
+  resolution: "@typescript-eslint/types@npm:6.15.0"
+  checksum: 6e33529ea301c8c4b8c1f589dadd5d2a66c1b24ec87a577524fbc996d4c7b65d4f4fdfa4a3937b691efee6a10a6b16f7bfcabe98a15e0fc0c0c57aa0d80dcc25
   languageName: node
   linkType: hard
 
-"@typescript-eslint/typescript-estree@npm:6.13.1":
-  version: 6.13.1
-  resolution: "@typescript-eslint/typescript-estree@npm:6.13.1"
+"@typescript-eslint/typescript-estree@npm:6.15.0":
+  version: 6.15.0
+  resolution: "@typescript-eslint/typescript-estree@npm:6.15.0"
   dependencies:
-    "@typescript-eslint/types": "npm:6.13.1"
-    "@typescript-eslint/visitor-keys": "npm:6.13.1"
+    "@typescript-eslint/types": "npm:6.15.0"
+    "@typescript-eslint/visitor-keys": "npm:6.15.0"
     debug: "npm:^4.3.4"
     globby: "npm:^11.1.0"
     is-glob: "npm:^4.0.3"
@@ -3143,34 +3143,34 @@ __metadata:
   peerDependenciesMeta:
     typescript:
       optional: true
-  checksum: d8aa409464f860f12ddc67ad8d94dcc37dc4da272b1d9d1937b6ccbcf397daa8bb495f409ee5c263053f87a9a0cc7d5ba6926137e5724d4ac6a839d8a481a8c0
+  checksum: 08955f6e84b8edb855a6769671e85889e52b15b82e00a64f595da867b21ad060e5342787c436d77702b2a1f39d411ac79b81a8d2e2006e9b1886eadb08b626df
   languageName: node
   linkType: hard
 
-"@typescript-eslint/utils@npm:6.13.1":
-  version: 6.13.1
-  resolution: "@typescript-eslint/utils@npm:6.13.1"
+"@typescript-eslint/utils@npm:6.15.0":
+  version: 6.15.0
+  resolution: "@typescript-eslint/utils@npm:6.15.0"
   dependencies:
     "@eslint-community/eslint-utils": "npm:^4.4.0"
     "@types/json-schema": "npm:^7.0.12"
     "@types/semver": "npm:^7.5.0"
-    "@typescript-eslint/scope-manager": "npm:6.13.1"
-    "@typescript-eslint/types": "npm:6.13.1"
-    "@typescript-eslint/typescript-estree": "npm:6.13.1"
+    "@typescript-eslint/scope-manager": "npm:6.15.0"
+    "@typescript-eslint/types": "npm:6.15.0"
+    "@typescript-eslint/typescript-estree": "npm:6.15.0"
     semver: "npm:^7.5.4"
   peerDependencies:
     eslint: ^7.0.0 || ^8.0.0
-  checksum: 6706527c6d979ba0a9756394382e945a2de51f54b8193da03ec2f980d479ffca0f58216c90f510b39601d07b37781af4236384f49afc63713662cd309bd43a1f
+  checksum: 53519a2027681bdc8f028f9421c65f193f91b5bb1659465fedb8043376c693c2391211f1c01d8ba25bfaa7f7b3a102263d7123f9dfade12032159f4b4490f0fb
   languageName: node
   linkType: hard
 
-"@typescript-eslint/visitor-keys@npm:6.13.1":
-  version: 6.13.1
-  resolution: "@typescript-eslint/visitor-keys@npm:6.13.1"
+"@typescript-eslint/visitor-keys@npm:6.15.0":
+  version: 6.15.0
+  resolution: "@typescript-eslint/visitor-keys@npm:6.15.0"
   dependencies:
-    "@typescript-eslint/types": "npm:6.13.1"
+    "@typescript-eslint/types": "npm:6.15.0"
     eslint-visitor-keys: "npm:^3.4.1"
-  checksum: 68daf60941fc4824f90480787587c9cbb447eeceac5698dfef2b0c2caa6d3c715f604c2357cc20abb6899be3c3e3ae3b5bbee310faccaab9ea98c8bd9137ec1f
+  checksum: bf9f71af60bd63d1073900e75c5a0aa6eddd672f6c3ac6092c765d67deb7a0c32d2a5f6f3aee9e95f93a93d58563a76da209bd8487aadafd4d013100ffe38520
   languageName: node
   linkType: hard
 
@@ -3192,13 +3192,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@xstate/cli@npm:^0.5.11":
-  version: 0.5.11
-  resolution: "@xstate/cli@npm:0.5.11"
+"@xstate/cli@npm:^0.5.15":
+  version: 0.5.15
+  resolution: "@xstate/cli@npm:0.5.15"
   dependencies:
     "@babel/core": "npm:^7.21.4"
-    "@xstate/machine-extractor": "npm:^0.13.0"
-    "@xstate/tools-shared": "npm:^4.0.5"
+    "@xstate/machine-extractor": "npm:^0.14.1"
+    "@xstate/tools-shared": "npm:^4.0.8"
     chokidar: "npm:^3.5.3"
     commander: "npm:^8.0.0"
     dotenv: "npm:^16.0.3"
@@ -3208,13 +3208,13 @@ __metadata:
     xstate-beta: "npm:xstate@beta"
   bin:
     xstate: bin/bin.js
-  checksum: 02bf9f35661a2b8e93d3618ac1e44c07442e0453861800340c814caee03ce818d0a86e27d0682c6acbeca23d2e7c882713cfadc254c7f7e080c912dd81fe1373
+  checksum: 85dc3cfcc41328c694817d2aacfbae4fe3d93029fdf55a3fcc2b96e63b5c778abcaf9faf76fd6e2166612c393454b444ca3aa049c26bc9cdfb832b668c7eba2d
   languageName: node
   linkType: hard
 
-"@xstate/machine-extractor@npm:^0.13.0":
-  version: 0.13.0
-  resolution: "@xstate/machine-extractor@npm:0.13.0"
+"@xstate/machine-extractor@npm:^0.14.1":
+  version: 0.14.1
+  resolution: "@xstate/machine-extractor@npm:0.14.1"
   dependencies:
     "@babel/parser": "npm:^7.21.4"
     "@babel/traverse": "npm:^7.21.4"
@@ -3222,19 +3222,19 @@ __metadata:
     recast: "npm:^0.23.1"
   peerDependencies:
     xstate: ^4
-  checksum: 449cd18e42afccfd7e927683190757b61dd7a74b5ec2a51c786698203370a8348c7b497d6d3b4666ec1a949016792e124d22a65c398ff0a011e82c11b2890453
+  checksum: bc3ea496bb8974a9431acb318a11684fd7954253539d7d59bcea6af190621f82f6ea729d37bd487ec0e52e90f866401af79d7f1c0ccd396b3ee14916b8519ac9
   languageName: node
   linkType: hard
 
-"@xstate/tools-shared@npm:^4.0.5":
-  version: 4.0.5
-  resolution: "@xstate/tools-shared@npm:4.0.5"
+"@xstate/tools-shared@npm:^4.0.8":
+  version: 4.0.8
+  resolution: "@xstate/tools-shared@npm:4.0.8"
   dependencies:
-    "@xstate/machine-extractor": "npm:^0.13.0"
+    "@xstate/machine-extractor": "npm:^0.14.1"
   peerDependencies:
     prettier: ^2
     xstate: ^4
-  checksum: 9af83b255b586c4ee9e9131c41bcdb37377fbd9de2060d4782c0b8f96a89754e86d9101462d4b4dece6b2c82b8df9bb8d6f4c317fed5530d01ab1ceb593a36a1
+  checksum: 4f1b48b52f415505bb3186bf26cdc94f12630d1718ec4e6a003d5d95885590a6dafc2fbd8ed6c4ab0b7752b21e8357bf07bcd353b078429b55207f6d99217eb4
   languageName: node
   linkType: hard
 
@@ -3741,9 +3741,9 @@ __metadata:
   linkType: hard
 
 "caniuse-lite@npm:^1.0.30001517":
-  version: 1.0.30001565
-  resolution: "caniuse-lite@npm:1.0.30001565"
-  checksum: b400e0364651a700e39d59449ca6c65b26e2caceecc4b93ae54a01ed1f62d2a7e1333b1dc640d95fbe620ffa5be38fe4dbacd880cd7a1f42fc72bb8de9a2d0c9
+  version: 1.0.30001571
+  resolution: "caniuse-lite@npm:1.0.30001571"
+  checksum: 632f476e39febbfb5dc91c236981f3d518dc0cf55c42cc2bba431a6b6f4cceae3f9cd74d26312f30e9de65a3cc92ccf80d964ba8de061e25f37b7f0518303dad
   languageName: node
   linkType: hard
 
@@ -3998,10 +3998,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"csstype@npm:^3.0.2, csstype@npm:^3.1.2":
-  version: 3.1.2
-  resolution: "csstype@npm:3.1.2"
-  checksum: 32c038af259897c807ac738d9eab16b3d86747c72b09d5c740978e06f067f9b7b1737e1b75e407c7ab1fe1543dc95f20e202b4786aeb1b8d3bdf5d5ce655e6c6
+"csstype@npm:^3.0.2, csstype@npm:^3.1.2, csstype@npm:^3.1.3":
+  version: 3.1.3
+  resolution: "csstype@npm:3.1.3"
+  checksum: 80c089d6f7e0c5b2bd83cf0539ab41474198579584fa10d86d0cafe0642202343cbc119e076a0b1aece191989477081415d66c9fefbf3c957fc2fc4b7009f248
   languageName: node
   linkType: hard
 
@@ -4918,9 +4918,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"eslint-plugin-import@npm:^2.29.0":
-  version: 2.29.0
-  resolution: "eslint-plugin-import@npm:2.29.0"
+"eslint-plugin-import@npm:^2.29.1":
+  version: 2.29.1
+  resolution: "eslint-plugin-import@npm:2.29.1"
   dependencies:
     array-includes: "npm:^3.1.7"
     array.prototype.findlastindex: "npm:^1.2.3"
@@ -4938,10 +4938,10 @@ __metadata:
     object.groupby: "npm:^1.0.1"
     object.values: "npm:^1.1.7"
     semver: "npm:^6.3.1"
-    tsconfig-paths: "npm:^3.14.2"
+    tsconfig-paths: "npm:^3.15.0"
   peerDependencies:
     eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8
-  checksum: 761a4e1fbc2cd318e62350bed4c448f8b11ed83091d6bb7776f096556363a09debd9922b39fd2714c895edc9aaea82e08e684eb632283f880c58a91e4bae6733
+  checksum: 5f35dfbf4e8e67f741f396987de9504ad125c49f4144508a93282b4ea0127e052bde65ab6def1f31b6ace6d5d430be698333f75bdd7dca3bc14226c92a083196
   languageName: node
   linkType: hard
 
@@ -4980,22 +4980,23 @@ __metadata:
   languageName: node
   linkType: hard
 
-"eslint-plugin-prettier@npm:^5.0.1":
-  version: 5.0.1
-  resolution: "eslint-plugin-prettier@npm:5.0.1"
+"eslint-plugin-prettier@npm:^5.1.1":
+  version: 5.1.1
+  resolution: "eslint-plugin-prettier@npm:5.1.1"
   dependencies:
     prettier-linter-helpers: "npm:^1.0.0"
     synckit: "npm:^0.8.5"
   peerDependencies:
     "@types/eslint": ">=8.0.0"
     eslint: ">=8.0.0"
+    eslint-config-prettier: "*"
     prettier: ">=3.0.0"
   peerDependenciesMeta:
     "@types/eslint":
       optional: true
     eslint-config-prettier:
       optional: true
-  checksum: 08e2c7bed93d9f7c86e9aa0bd4f5cc51f65233a446ddfda11e821f12819e1e4be62cfbc2a4e17169c76fded1c4de7371e37e5f2525e81695decaf6c652a41fb0
+  checksum: cb9fb797e3b872864d9bd4a6154cc0aeccdd9b3d7add510b2077f6d5149fb4b681abd180dacb5dafda603defb6089824a7c6f97faf1f099dba4f4e77f86c46c3
   languageName: node
   linkType: hard
 
@@ -5051,14 +5052,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"eslint@npm:^8.55.0":
-  version: 8.55.0
-  resolution: "eslint@npm:8.55.0"
+"eslint@npm:^8.56.0":
+  version: 8.56.0
+  resolution: "eslint@npm:8.56.0"
   dependencies:
     "@eslint-community/eslint-utils": "npm:^4.2.0"
     "@eslint-community/regexpp": "npm:^4.6.1"
     "@eslint/eslintrc": "npm:^2.1.4"
-    "@eslint/js": "npm:8.55.0"
+    "@eslint/js": "npm:8.56.0"
     "@humanwhocodes/config-array": "npm:^0.11.13"
     "@humanwhocodes/module-importer": "npm:^1.0.1"
     "@nodelib/fs.walk": "npm:^1.2.8"
@@ -5095,7 +5096,7 @@ __metadata:
     text-table: "npm:^0.2.0"
   bin:
     eslint: bin/eslint.js
-  checksum: d28c0b60f19bb7d355cb8393e77b018c8f548dba3f820b799c89bb2e0c436ee26084e700c5e57e1e97e7972ec93065277849141b82e7b0c0d02c2dc1e553a2a1
+  checksum: 2be598f7da1339d045ad933ffd3d4742bee610515cd2b0d9a2b8b729395a01d4e913552fff555b559fccaefd89d7b37632825789d1b06470608737ae69ab43fb
   languageName: node
   linkType: hard
 
@@ -6687,12 +6688,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"nanoid@npm:^3.3.6":
-  version: 3.3.6
-  resolution: "nanoid@npm:3.3.6"
+"nanoid@npm:^3.3.7":
+  version: 3.3.7
+  resolution: "nanoid@npm:3.3.7"
   bin:
     nanoid: bin/nanoid.cjs
-  checksum: 606b355960d0fcbe3d27924c4c52ef7d47d3b57208808ece73279420d91469b01ec1dce10fae512b6d4a8c5a5432b352b228336a8b2202a6ea68e67fa348e2ee
+  checksum: e3fb661aa083454f40500473bb69eedb85dc160e763150b9a2c567c7e9ff560ce028a9f833123b618a6ea742e311138b591910e795614a629029e86e180660f3
   languageName: node
   linkType: hard
 
@@ -7080,14 +7081,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"postcss@npm:^8.4.31":
-  version: 8.4.31
-  resolution: "postcss@npm:8.4.31"
+"postcss@npm:^8.4.32":
+  version: 8.4.32
+  resolution: "postcss@npm:8.4.32"
   dependencies:
-    nanoid: "npm:^3.3.6"
+    nanoid: "npm:^3.3.7"
     picocolors: "npm:^1.0.0"
     source-map-js: "npm:^1.0.2"
-  checksum: 748b82e6e5fc34034dcf2ae88ea3d11fd09f69b6c50ecdd3b4a875cfc7cdca435c958b211e2cb52355422ab6fccb7d8f2f2923161d7a1b281029e4a913d59acf
+  checksum: 39308a9195fa34d4dbdd7b58a896cff0c7809f84f7a4ac1b95b68ca86c9138a395addff33075668ed3983d41b90aac05754c445237a9365eb1c3a5602ebd03ad
   languageName: node
   linkType: hard
 
@@ -7116,12 +7117,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"prettier@npm:^3.1.0":
-  version: 3.1.0
-  resolution: "prettier@npm:3.1.0"
+"prettier@npm:^3.1.1":
+  version: 3.1.1
+  resolution: "prettier@npm:3.1.1"
   bin:
     prettier: bin/prettier.cjs
-  checksum: a45ea70aa97fde162ea4c4aba3dfc7859aa6a732a1db34458d9535dc3c2c16d3bc3fb5689e6cd76aa835562555303b02d9449fd2e15af3b73c8053557e25c5b6
+  checksum: facc944ba20e194ff4db765e830ffbcb642803381f0d2033ed397e79904fa4ccc877dc25ad68f42d36985c01d051c990ca1b905fb83d2d7d65fe69e4386fa1a3
   languageName: node
   linkType: hard
 
@@ -7209,15 +7210,15 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-resize-detector@npm:^9.1.0":
-  version: 9.1.0
-  resolution: "react-resize-detector@npm:9.1.0"
+"react-resize-detector@npm:^9.1.1":
+  version: 9.1.1
+  resolution: "react-resize-detector@npm:9.1.1"
   dependencies:
     lodash: "npm:^4.17.21"
   peerDependencies:
     react: ^16.0.0 || ^17.0.0 || ^18.0.0
     react-dom: ^16.0.0 || ^17.0.0 || ^18.0.0
-  checksum: ebd45b54ce68368a8d8b6b32ff3b7949e8f56d5cce21fb18b5044612b16ae9adfdd2eefa6494a700aaf6c64b2cec4c3c33d86c464d1772042dbb4d87dd3dafc6
+  checksum: 6a85892fe46a12fc27b09b5bf5fcc1438f3196f70c75d4685b09eed2c68a2c853dd6eb792bf852038082505a3b4f05dba359055ee0baca3f8b59f022a85a368c
   languageName: node
   linkType: hard
 
@@ -8108,15 +8109,15 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tsconfig-paths@npm:^3.14.2":
-  version: 3.14.2
-  resolution: "tsconfig-paths@npm:3.14.2"
+"tsconfig-paths@npm:^3.15.0":
+  version: 3.15.0
+  resolution: "tsconfig-paths@npm:3.15.0"
   dependencies:
     "@types/json5": "npm:^0.0.29"
     json5: "npm:^1.0.2"
     minimist: "npm:^1.2.6"
     strip-bom: "npm:^3.0.0"
-  checksum: fdc92bb7b18b31c0e76f8ec4f98d07236b09590fd6578e587ad024792c8b2235d65125a8fd007fa47a84400f84ceccbf33f24e5198d953249e7204f4cef3517c
+  checksum: 5b4f301a2b7a3766a986baf8fc0e177eb80bdba6e396792ff92dc23b5bca8bb279fc96517dcaaef63a3b49bebc6c4c833653ec58155780bc906bdbcf7dda0ef5
   languageName: node
   linkType: hard
 
@@ -8197,23 +8198,23 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@npm:5.3.2":
-  version: 5.3.2
-  resolution: "typescript@npm:5.3.2"
+"typescript@npm:5.3.3":
+  version: 5.3.3
+  resolution: "typescript@npm:5.3.3"
   bin:
     tsc: bin/tsc
     tsserver: bin/tsserver
-  checksum: d7dbe1fbe19039e36a65468ea64b5d338c976550394ba576b7af9c68ed40c0bc5d12ecce390e4b94b287a09a71bd3229f19c2d5680611f35b7c53a3898791159
+  checksum: e33cef99d82573624fc0f854a2980322714986bc35b9cb4d1ce736ed182aeab78e2cb32b385efa493b2a976ef52c53e20d6c6918312353a91850e2b76f1ea44f
   languageName: node
   linkType: hard
 
-"typescript@patch:typescript@npm%3A5.3.2#optional!builtin<compat/typescript>":
-  version: 5.3.2
-  resolution: "typescript@patch:typescript@npm%3A5.3.2#optional!builtin<compat/typescript>::version=5.3.2&hash=e012d7"
+"typescript@patch:typescript@npm%3A5.3.3#optional!builtin<compat/typescript>":
+  version: 5.3.3
+  resolution: "typescript@patch:typescript@npm%3A5.3.3#optional!builtin<compat/typescript>::version=5.3.3&hash=e012d7"
   bin:
     tsc: bin/tsc
     tsserver: bin/tsserver
-  checksum: 73c8bad74e732d93211c9d77f28b03307e2f5fc6a0afc73f4b783261ab567686a16d6ae958bdaef383a00be1b0b8c8b6741dd6ca3d13af4963fa7e47456d49c7
+  checksum: 1d0a5f4ce496c42caa9a30e659c467c5686eae15d54b027ee7866744952547f1be1262f2d40de911618c242b510029d51d43ff605dba8fb740ec85ca2d3f9500
   languageName: node
   linkType: hard
 
@@ -8360,9 +8361,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"vite-plugin-pwa@npm:^0.17.2":
-  version: 0.17.2
-  resolution: "vite-plugin-pwa@npm:0.17.2"
+"vite-plugin-pwa@npm:^0.17.4":
+  version: 0.17.4
+  resolution: "vite-plugin-pwa@npm:0.17.4"
   dependencies:
     debug: "npm:^4.3.4"
     fast-glob: "npm:^3.3.2"
@@ -8373,17 +8374,17 @@ __metadata:
     vite: ^3.1.0 || ^4.0.0 || ^5.0.0
     workbox-build: ^7.0.0
     workbox-window: ^7.0.0
-  checksum: a51ce04ac51df72a26dc84162872b812f5c88bf9683b4a48d1331d9349aa67ebc4602e92e1012a0348777db160142ed921083beccfc9b14bcfe44c88b7f98fb8
+  checksum: 092da93c53fac8f90028c9412ee647944b59dcd2dbdfabd5c2c4a344dd2e09b1abde66bb8c2dd85022ba0fa68e77f7a8fb67e2659199b4effe549c0d7c46f681
   languageName: node
   linkType: hard
 
-"vite@npm:^5.0.4":
-  version: 5.0.4
-  resolution: "vite@npm:5.0.4"
+"vite@npm:^5.0.10":
+  version: 5.0.10
+  resolution: "vite@npm:5.0.10"
   dependencies:
     esbuild: "npm:^0.19.3"
     fsevents: "npm:~2.3.3"
-    postcss: "npm:^8.4.31"
+    postcss: "npm:^8.4.32"
     rollup: "npm:^4.2.0"
   peerDependencies:
     "@types/node": ^18.0.0 || >=20.0.0
@@ -8413,7 +8414,7 @@ __metadata:
       optional: true
   bin:
     vite: bin/vite.js
-  checksum: 67a0df248af042e75b1ecbf20098096df80a1068a832c5c964a20d7c06853e12b7310989c3c273cb88a9a3a37f4bada0a2115018b36df0fc09a6b6dba9a7d5b5
+  checksum: d666b2760d2a7ea1d0d35f67c042053e562144f80554be4e4dc58e607fd5f62193cd203d73ab2e315df66830d8b9d9a2e3509d0208bdef1b2e92e0a5c364df84
   languageName: node
   linkType: hard