Merge pull request #51 from kris7t/color-identifiers

Color identifiers

21 files changed, 495 insertions, 107 deletions

diff --git a/subprojects/frontend/src/editor/EditorArea.tsx b/subprojects/frontend/src/editor/EditorArea.tsx
index 905fa2ec..aafaad40 100644
--- a/subprojects/frontend/src/editor/EditorArea.tsx
+++ b/subprojects/frontend/src/editor/EditorArea.tsx
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -38,6 +38,7 @@ export default observer(function EditorArea({
       <EditorTheme
         showLineNumbers={editorStore.showLineNumbers}
         showActiveLine={!editorStore.hasSelection}
+        colorIdentifiers={editorStore.colorIdentifiers}
         ref={editorParentRef}
       />
     </Box>
diff --git a/subprojects/frontend/src/editor/EditorButtons.tsx b/subprojects/frontend/src/editor/EditorButtons.tsx
index ca51f975..f4513909 100644
--- a/subprojects/frontend/src/editor/EditorButtons.tsx
+++ b/subprojects/frontend/src/editor/EditorButtons.tsx
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -8,8 +8,9 @@ import type { Diagnostic } from '@codemirror/lint';
 import CancelIcon from '@mui/icons-material/Cancel';
 import CheckIcon from '@mui/icons-material/Check';
 import FormatListNumberedIcon from '@mui/icons-material/FormatListNumbered';
-import FormatPaint from '@mui/icons-material/FormatPaint';
+import FormatPaintIcon from '@mui/icons-material/FormatPaint';
 import InfoOutlinedIcon from '@mui/icons-material/InfoOutlined';
+import LooksIcon from '@mui/icons-material/Looks';
 import RedoIcon from '@mui/icons-material/Redo';
 import SearchIcon from '@mui/icons-material/Search';
 import UndoIcon from '@mui/icons-material/Undo';
@@ -72,6 +73,15 @@ export default observer(function EditorButtons({
           <FormatListNumberedIcon fontSize="small" />
         </ToggleButton>
         <ToggleButton
+          selected={editorStore?.colorIdentifiers ?? false}
+          disabled={editorStore === undefined}
+          onClick={() => editorStore?.toggleColorIdentifiers()}
+          aria-label="Color identifiers"
+          value="color-identifiers"
+        >
+          <LooksIcon fontSize="small" />
+        </ToggleButton>
+        <ToggleButton
           selected={editorStore?.searchPanel?.state ?? false}
           disabled={editorStore === undefined}
           onClick={() => editorStore?.searchPanel?.toggle()}
@@ -104,7 +114,7 @@ export default observer(function EditorButtons({
         aria-label="Automatic format"
         color="inherit"
       >
-        <FormatPaint fontSize="small" />
+        <FormatPaintIcon fontSize="small" />
       </IconButton>
       <ConnectButton editorStore={editorStore} />
     </Stack>
diff --git a/subprojects/frontend/src/editor/EditorStore.ts b/subprojects/frontend/src/editor/EditorStore.ts
index 87c4040e..5e7d05e1 100644
--- a/subprojects/frontend/src/editor/EditorStore.ts
+++ b/subprojects/frontend/src/editor/EditorStore.ts
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -62,6 +62,8 @@ export default class EditorStore {
 
   showLineNumbers = false;
 
+  colorIdentifiers = true;
+
   disposed = false;
 
   analyzing = false;
@@ -96,7 +98,7 @@ export default class EditorStore {
     })().catch((error) => {
       log.error('Failed to load XtextClient', error);
     });
-    this.graph = new GraphStore();
+    this.graph = new GraphStore(this);
     makeAutoObservable<EditorStore, 'client'>(this, {
       id: false,
       state: observable.ref,
@@ -279,6 +281,11 @@ export default class EditorStore {
     log.debug('Show line numbers', this.showLineNumbers);
   }
 
+  toggleColorIdentifiers(): void {
+    this.colorIdentifiers = !this.colorIdentifiers;
+    log.debug('Color identifiers', this.colorIdentifiers);
+  }
+
   get hasSelection(): boolean {
     return this.state.selection.ranges.some(({ from, to }) => from !== to);
   }
@@ -324,7 +331,7 @@ export default class EditorStore {
   }
 
   addGeneratedModel(uuid: string, randomSeed: number): void {
-    this.generatedModels.set(uuid, new GeneratedModelStore(randomSeed));
+    this.generatedModels.set(uuid, new GeneratedModelStore(randomSeed, this));
     this.selectGeneratedModel(uuid);
   }
 
diff --git a/subprojects/frontend/src/editor/EditorTheme.ts b/subprojects/frontend/src/editor/EditorTheme.ts
index 9f560dfb..1cad4a36 100644
--- a/subprojects/frontend/src/editor/EditorTheme.ts
+++ b/subprojects/frontend/src/editor/EditorTheme.ts
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -8,10 +8,35 @@ import cancelSVG from '@material-icons/svg/svg/cancel/baseline.svg?raw';
 import expandMoreSVG from '@material-icons/svg/svg/expand_more/baseline.svg?raw';
 import infoSVG from '@material-icons/svg/svg/info/baseline.svg?raw';
 import warningSVG from '@material-icons/svg/svg/warning/baseline.svg?raw';
-import { alpha, styled, type CSSObject } from '@mui/material/styles';
+import {
+  alpha,
+  styled,
+  type CSSObject,
+  type Theme,
+} from '@mui/material/styles';
+import { range } from 'lodash-es';
 
 import svgURL from '../utils/svgURL';
 
+function createTypeHashStyles(
+  theme: Theme,
+  colorIdentifiers: boolean,
+): CSSObject {
+  if (!colorIdentifiers) {
+    return {};
+  }
+  const result: CSSObject = {};
+  range(theme.palette.highlight.typeHash.length).forEach((i) => {
+    result[`.tok-problem-typeHash-${i}`] = {
+      '&, .tok-typeName': {
+        color: theme.palette.highlight.typeHash[i]?.text,
+        fontWeight: theme.typography.fontWeightEditorTypeHash,
+      },
+    };
+  });
+  return result;
+}
+
 export default styled('div', {
   name: 'EditorTheme',
   shouldForwardProp: (propName) =>
@@ -19,7 +44,8 @@ export default styled('div', {
 })<{
   showLineNumbers: boolean;
   showActiveLine: boolean;
-}>(({ theme, showLineNumbers, showActiveLine }) => {
+  colorIdentifiers: boolean;
+}>(({ theme, showLineNumbers, showActiveLine, colorIdentifiers }) => {
   const editorFontStyle: CSSObject = {
     ...theme.typography.editor,
     fontWeight: theme.typography.fontWeightEditorNormal,
@@ -114,6 +140,11 @@ export default styled('div', {
     },
     '.tok-problem-error': {
       '&, & .tok-typeName': {
+        color: theme.palette.highlight.comment,
+      },
+    },
+    '.tok-invalid': {
+      '&, & .tok-typeName': {
         color: theme.palette.error.main,
       },
     },
@@ -124,6 +155,7 @@ export default styled('div', {
         fontStyle: 'normal',
       },
     },
+    ...createTypeHashStyles(theme, colorIdentifiers),
   };
 
   const matchingStyle: CSSObject = {
diff --git a/subprojects/frontend/src/editor/GeneratedModelStore.ts b/subprojects/frontend/src/editor/GeneratedModelStore.ts
index 5088d603..f2695d9a 100644
--- a/subprojects/frontend/src/editor/GeneratedModelStore.ts
+++ b/subprojects/frontend/src/editor/GeneratedModelStore.ts
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -9,6 +9,8 @@ import { makeAutoObservable } from 'mobx';
 import GraphStore from '../graph/GraphStore';
 import type { SemanticsSuccessResult } from '../xtext/xtextServiceResults';
 
+import type EditorStore from './EditorStore';
+
 export default class GeneratedModelStore {
   title: string;
 
@@ -18,10 +20,15 @@ export default class GeneratedModelStore {
 
   graph: GraphStore | undefined;
 
-  constructor(randomSeed: number) {
+  constructor(
+    randomSeed: number,
+    private readonly editorStore: EditorStore,
+  ) {
     const time = new Date().toLocaleTimeString(undefined, { hour12: false });
     this.title = `Generated at ${time} (${randomSeed})`;
-    makeAutoObservable(this);
+    makeAutoObservable<GeneratedModelStore, 'editorStore'>(this, {
+      editorStore: false,
+    });
   }
 
   get running(): boolean {
@@ -43,7 +50,7 @@ export default class GeneratedModelStore {
 
   setSemantics(semantics: SemanticsSuccessResult): void {
     if (this.running) {
-      this.graph = new GraphStore();
+      this.graph = new GraphStore(this.editorStore);
       this.graph.setSemantics(semantics);
     }
   }
diff --git a/subprojects/frontend/src/graph/DotGraphVisualizer.tsx b/subprojects/frontend/src/graph/DotGraphVisualizer.tsx
index eec72a7d..72ac58fa 100644
--- a/subprojects/frontend/src/graph/DotGraphVisualizer.tsx
+++ b/subprojects/frontend/src/graph/DotGraphVisualizer.tsx
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -150,7 +150,7 @@ function DotGraphVisualizer({
     ],
   );
 
-  return <GraphTheme ref={setElement} />;
+  return <GraphTheme ref={setElement} colorNodes={graph.colorNodes} />;
 }
 
 DotGraphVisualizer.defaultProps = {
diff --git a/subprojects/frontend/src/graph/GraphStore.ts b/subprojects/frontend/src/graph/GraphStore.ts
index ecb016b5..58c4422d 100644
--- a/subprojects/frontend/src/graph/GraphStore.ts
+++ b/subprojects/frontend/src/graph/GraphStore.ts
@@ -1,11 +1,12 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 
 import { makeAutoObservable, observable } from 'mobx';
 
+import type EditorStore from '../editor/EditorStore';
 import type {
   RelationMetadata,
   SemanticsSuccessResult,
@@ -65,8 +66,9 @@ export default class GraphStore {
 
   selectedSymbol: RelationMetadata | undefined;
 
-  constructor() {
-    makeAutoObservable(this, {
+  constructor(private readonly editorStore: EditorStore) {
+    makeAutoObservable<GraphStore, 'editorStore'>(this, {
+      editorStore: false,
       semantics: observable.ref,
     });
   }
@@ -184,4 +186,8 @@ export default class GraphStore {
     });
     this.setSelectedSymbol(this.selectedSymbol);
   }
+
+  get colorNodes(): boolean {
+    return this.editorStore.colorIdentifiers;
+  }
 }
diff --git a/subprojects/frontend/src/graph/GraphTheme.tsx b/subprojects/frontend/src/graph/GraphTheme.tsx
index 14d58b96..7334f559 100644
--- a/subprojects/frontend/src/graph/GraphTheme.tsx
+++ b/subprojects/frontend/src/graph/GraphTheme.tsx
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -7,7 +7,13 @@
 import cancelSVG from '@material-icons/svg/svg/cancel/baseline.svg?raw';
 import labelSVG from '@material-icons/svg/svg/label/baseline.svg?raw';
 import labelOutlinedSVG from '@material-icons/svg/svg/label/outline.svg?raw';
-import { alpha, styled, type CSSObject } from '@mui/material/styles';
+import {
+  alpha,
+  styled,
+  type CSSObject,
+  type Theme,
+} from '@mui/material/styles';
+import { range } from 'lodash-es';
 
 import svgURL from '../utils/svgURL';
 
@@ -31,9 +37,24 @@ function createEdgeColor(
   };
 }
 
+function createTypeHashStyles(theme: Theme, colorNodes: boolean): CSSObject {
+  if (!colorNodes) {
+    return {};
+  }
+  const result: CSSObject = {};
+  range(theme.palette.highlight.typeHash.length).forEach((i) => {
+    result[`.node-typeHash-${i}`] = {
+      '& [fill="green"]': {
+        fill: theme.palette.highlight.typeHash[i]?.box,
+      },
+    };
+  });
+  return result;
+}
+
 export default styled('div', {
   name: 'GraphTheme',
-})(({ theme }) => ({
+})<{ colorNodes: boolean }>(({ theme, colorNodes }) => ({
   '& svg': {
     userSelect: 'none',
     '.node': {
@@ -68,6 +89,7 @@ export default styled('div', {
     '.node-exists-UNKNOWN [stroke="black"]': {
       strokeDasharray: '5 2',
     },
+    ...createTypeHashStyles(theme, colorNodes),
     '.edge': {
       '& text': {
         fontFamily: theme.typography.fontFamily,
diff --git a/subprojects/frontend/src/graph/dotSource.ts b/subprojects/frontend/src/graph/dotSource.ts
index bd358dfa..3ac5eb1c 100644
--- a/subprojects/frontend/src/graph/dotSource.ts
+++ b/subprojects/frontend/src/graph/dotSource.ts
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -142,6 +142,9 @@ function createNodes(
     if (data.unaryPredicates.size === 0) {
       classList.push('node-empty');
     }
+    if (node.typeHash !== undefined) {
+      classList.push(`node-typeHash-${node.typeHash}`);
+    }
     const classes = classList.join(' ');
     const name = nodeName(graph, node);
     const border = node.kind === 'INDIVIDUAL' ? 2 : 1;
diff --git a/subprojects/frontend/src/theme/ThemeProvider.tsx b/subprojects/frontend/src/theme/ThemeProvider.tsx
index 18310147..a996cde8 100644
--- a/subprojects/frontend/src/theme/ThemeProvider.tsx
+++ b/subprojects/frontend/src/theme/ThemeProvider.tsx
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -24,6 +24,11 @@ interface OuterPalette {
   border: string;
 }
 
+interface TypeHashPalette {
+  text: string;
+  box: string;
+}
+
 interface HighlightPalette {
   number: string;
   parameter: string;
@@ -41,17 +46,20 @@ interface HighlightPalette {
     selected: string;
     contrastText: string;
   };
+  typeHash: TypeHashPalette[];
 }
 
 declare module '@mui/material/styles' {
   interface TypographyVariants {
     fontWeightEditorNormal: number;
+    fontWeightEditorTypeHash: number;
     fontWeightEditorBold: number;
     editor: TypographyStyle;
   }
 
   interface TypographyVariantsOptions {
     fontWeightEditorNormal?: number;
+    fontWeightEditorTypeHash?: number;
     fontWeightEditorBold?: number;
     editor?: TypographyStyle;
   }
@@ -78,6 +86,7 @@ function createResponsiveTheme(
         '"Open Sans Variable", "Open Sans", "Roboto", "Helvetica", "Arial", sans-serif',
       fontWeightMedium: 500,
       fontWeightEditorNormal: 400,
+      fontWeightEditorTypeHash: 500,
       fontWeightEditorBold: 700,
       button: {
         fontWeight: 600,
@@ -220,7 +229,7 @@ const lightTheme = (() => {
     palette: {
       mode: 'light',
       primary: { main: '#038a99' },
-      secondary: { main: '#e45649' },
+      secondary: { main: '#61afef' },
       error: { main: '#ca1243' },
       warning: { main: '#c18401' },
       success: { main: '#50a14f' },
@@ -256,6 +265,18 @@ const lightTheme = (() => {
           selected: '#d500f9',
           contrastText: '#fff',
         },
+        typeHash: [
+          { text: '#986801', box: '#e5c07b' },
+          { text: '#d6493e', box: '#e06c75' },
+          { text: '#50a14f', box: '#98c379' },
+          { text: '#a626a4', box: '#c678dd' },
+          { text: '#4078f2', box: '#80a7f4' },
+          { text: '#827662', box: '#e3d1b2' },
+          { text: '#904f53', box: '#e78b8f' },
+          { text: '#637855', box: '#abcc94' },
+          { text: '#805f89', box: '#dbb2e8' },
+          { text: '#5987ae', box: '#92c0e9' },
+        ],
       },
     },
   });
@@ -270,6 +291,7 @@ const darkTheme = (() => {
     {
       typography: {
         fontWeightEditorNormal: 350,
+        fontWeightEditorTypeHash: 350,
         fontWeightEditorBold: 650,
       },
       palette: {
@@ -277,7 +299,7 @@ const darkTheme = (() => {
         primary: { main: '#56b6c2' },
         secondary: { main: '#be5046' },
         error: { main: '#e06c75' },
-        warning: { main: '#e5c07b' },
+        warning: { main: '#d19a66' },
         success: { main: '#98c379' },
         info: { main: '#61afef' },
         background: {
@@ -311,6 +333,18 @@ const darkTheme = (() => {
             selected: '#dd33fa',
             contrastText: darkBackground,
           },
+          typeHash: [
+            { text: '#e5c07b', box: '#ae8003' },
+            { text: '#e06c75', box: '#a23b47' },
+            { text: '#98c379', box: '#428141' },
+            { text: '#c678dd', box: '#854797' },
+            { text: '#61afef', box: '#3982bb' },
+            { text: '#e3d1b2', box: '#827662' },
+            { text: '#e78b8f', box: '#904f53' },
+            { text: '#abcc94', box: '#647e63' },
+            { text: '#dbb2e8', box: '#805f89' },
+            { text: '#92c0e9', box: '#4f7799' },
+          ],
         },
       },
     },
diff --git a/subprojects/frontend/src/xtext/xtextServiceResults.ts b/subprojects/frontend/src/xtext/xtextServiceResults.ts
index e473bd48..792c7de3 100644
--- a/subprojects/frontend/src/xtext/xtextServiceResults.ts
+++ b/subprojects/frontend/src/xtext/xtextServiceResults.ts
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -137,6 +137,7 @@ export type ModelGenerationStartedResult = z.infer<
 export const NodeMetadata = z.object({
   name: z.string(),
   simpleName: z.string(),
+  typeHash: z.string().optional(),
   kind: z.enum(['IMPLICIT', 'INDIVIDUAL', 'NEW']),
 });
 
@@ -182,15 +183,15 @@ export type SemanticsResult = z.infer<typeof SemanticsResult>;
 
 export const ModelGenerationResult = z.union([
   z.object({
-    uuid: z.string().nonempty(),
+    uuid: z.string().min(1),
     status: z.string(),
   }),
   z.object({
-    uuid: z.string().nonempty(),
+    uuid: z.string().min(1),
     error: z.string(),
   }),
   SemanticsSuccessResult.extend({
-    uuid: z.string().nonempty(),
+    uuid: z.string().min(1),
   }),
 ]);
 
diff --git a/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/ProblemSemanticHighlightingCalculator.java b/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/ProblemSemanticHighlightingCalculator.java
index ae8c70e0..f64d4066 100644
--- a/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/ProblemSemanticHighlightingCalculator.java
+++ b/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/ProblemSemanticHighlightingCalculator.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -38,9 +38,12 @@ public class ProblemSemanticHighlightingCalculator extends DefaultSemanticHighli
         @Inject
         private ProblemDesugarer desugarer;
 
+        @Inject
+        private TypeHashProvider typeHashProvider;
+
         @Override
         protected boolean highlightElement(EObject object, IHighlightedPositionAcceptor acceptor,
-                        CancelIndicator cancelIndicator) {
+                                                                           CancelIndicator cancelIndicator) {
                 highlightName(object, acceptor);
                 highlightCrossReferences(object, acceptor, cancelIndicator);
                 return false;
@@ -57,7 +60,7 @@ public class ProblemSemanticHighlightingCalculator extends DefaultSemanticHighli
         }
 
         protected void highlightCrossReferences(EObject object, IHighlightedPositionAcceptor acceptor,
-                        CancelIndicator cancelIndicator) {
+                                                                                        CancelIndicator cancelIndicator) {
                 for (EReference reference : object.eClass().getEAllReferences()) {
                         if (reference.isContainment()) {
                                 continue;
@@ -98,7 +101,7 @@ public class ProblemSemanticHighlightingCalculator extends DefaultSemanticHighli
                 boolean isError = ProblemUtil.isError(eObject);
                 if (ProblemUtil.isBuiltIn(eObject)) {
                         var className = isError ? ERROR_CLASS : BUILTIN_CLASS;
-                        return new String[] { className };
+                        return new String[]{className};
                 }
                 return getUserDefinedElementHighlightClass(eObject, reference, isError);
         }
@@ -113,21 +116,32 @@ public class ProblemSemanticHighlightingCalculator extends DefaultSemanticHighli
                                 && desugarer.isContainmentReference(referenceDeclaration)) {
                         classesBuilder.add(CONTAINMENT_CLASS);
                 }
-                if (isError) {
+                if (isError && reference != null) {
+                        // References to error patterns should be highlighted as errors, but error pattern definitions shouldn't.
                         classesBuilder.add(ERROR_CLASS);
                 }
                 if (eObject instanceof Node node) {
-                        if (reference == ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE) {
-                                classesBuilder.add(NODE_CLASS);
-                        }
-                        if (ProblemUtil.isIndividualNode(node)) {
-                                classesBuilder.add(INDIVIDUAL_NODE_CLASS);
-                        }
-                        if (ProblemUtil.isNewNode(node)) {
-                                classesBuilder.add(NEW_NODE_CLASS);
+                        highlightNode(node, reference, classesBuilder);
+                }
+                if (eObject instanceof Relation relation) {
+                        var typeHash = typeHashProvider.getTypeHash(relation);
+                        if (typeHash != null) {
+                                classesBuilder.add("typeHash-" + typeHash);
                         }
                 }
                 List<String> classes = classesBuilder.build();
                 return classes.toArray(new String[0]);
         }
+
+        private static void highlightNode(Node node, EReference reference, ImmutableList.Builder<String> classesBuilder) {
+                if (reference == ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE) {
+                        classesBuilder.add(NODE_CLASS);
+                }
+                if (ProblemUtil.isIndividualNode(node)) {
+                        classesBuilder.add(INDIVIDUAL_NODE_CLASS);
+                }
+                if (ProblemUtil.isNewNode(node)) {
+                        classesBuilder.add(NEW_NODE_CLASS);
+                }
+        }
 }
diff --git a/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/TypeHashProvider.java b/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/TypeHashProvider.java
new file mode 100644
index 00000000..f75ecdb2
--- /dev/null
+++ b/subprojects/language-ide/src/main/java/tools/refinery/language/ide/syntaxcoloring/TypeHashProvider.java
@@ -0,0 +1,93 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.ide.syntaxcoloring;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import org.eclipse.xtext.EcoreUtil2;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.IQualifiedNameProvider;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import org.eclipse.xtext.util.IResourceScopeCache;
+import tools.refinery.language.model.problem.*;
+import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
+import tools.refinery.language.utils.ProblemUtil;
+
+import java.util.*;
+
+@Singleton
+public class TypeHashProvider {
+        private static final String CACHE_KEY = "tools.refinery.language.ide.syntaxcoloring.TypeHashProvider";
+        private static final int COLOR_COUNT = 10;
+
+        @Inject
+        private IResourceScopeCache resourceScopeCache;
+
+        @Inject
+        private IScopeProvider scopeProvider;
+
+        @Inject
+        private IQualifiedNameProvider qualifiedNameProvider;
+
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        public String getTypeHash(Relation relation) {
+                if (!(relation instanceof ClassDeclaration || relation instanceof EnumDeclaration) ||
+                                ProblemUtil.isBuiltIn(relation)) {
+                        return null;
+                }
+                var qualifiedName = qualifiedNameProvider.getFullyQualifiedName(relation);
+                if (qualifiedName == null) {
+                        return null;
+                }
+                var qualifiedNameString = qualifiedNameConverter.toString(qualifiedName);
+                var problem = EcoreUtil2.getContainerOfType(relation, Problem.class);
+                if (problem == null) {
+                        return null;
+                }
+                var cache = resourceScopeCache.get(CACHE_KEY, problem.eResource(), () -> computeHashes(problem));
+                return cache.get(qualifiedNameString);
+        }
+
+        private Map<String, String> computeHashes(Problem problem) {
+                var qualifiedNameStrings = new TreeSet<String>();
+                var scope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__RELATION);
+                for (var description : scope.getAllElements()) {
+                        if (ProblemResourceDescriptionStrategy.COLOR_RELATION_TRUE.equals(
+                                        description.getUserData(ProblemResourceDescriptionStrategy.COLOR_RELATION))) {
+                                var qualifiedNameString = qualifiedNameConverter.toString(description.getQualifiedName());
+                                qualifiedNameStrings.add(qualifiedNameString);
+                        }
+                }
+                var stringList = new ArrayList<>(qualifiedNameStrings);
+                int size = stringList.size();
+                if (size == 0) {
+                        return Map.of();
+                }
+                // The use of a non-cryptographic random generator is safe here, because we only use it to shuffle the color
+                // IDs in a pseudo-random way. The shuffle depends on the size of the list of identifiers before padding to
+                // make sure that adding a new class randomizes all color IDs.
+                @SuppressWarnings("squid:S2245")
+                var random = new Random(size);
+                int padding = COLOR_COUNT - (size % COLOR_COUNT);
+                for (int i = 0; i < padding; i++) {
+                        stringList.add(null);
+                }
+                size += padding;
+                Collections.shuffle(stringList, random);
+                var mapBuilder = ImmutableMap.<String, String>builder();
+                for (int i = 0; i < size; i++) {
+                        var key = stringList.get(i);
+                        if (key != null) {
+                                int colorId = i % COLOR_COUNT;
+                                mapBuilder.put(key, Integer.toString(colorId));
+                        }
+                }
+                return mapBuilder.build();
+        }
+}
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/NodeNameProvider.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/NodeNameProvider.java
new file mode 100644
index 00000000..517b8604
--- /dev/null
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/NodeNameProvider.java
@@ -0,0 +1,62 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.semantics;
+
+import com.google.inject.Inject;
+import org.eclipse.collections.api.factory.primitive.ObjectIntMaps;
+import org.eclipse.collections.api.map.primitive.MutableObjectIntMap;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import tools.refinery.language.model.problem.Node;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.model.problem.ProblemPackage;
+
+import java.util.Locale;
+
+public class NodeNameProvider {
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        @Inject
+        private SemanticsUtils semanticsUtils;
+
+        @Inject
+        private IScopeProvider scopeProvider;
+
+        private Problem problem;
+        private final MutableObjectIntMap<String> indexMap = ObjectIntMaps.mutable.empty();
+
+        public void setProblem(Problem problem) {
+                if (this.problem != null) {
+                        throw new IllegalStateException("Problem was already set");
+                }
+                this.problem = problem;
+        }
+
+        public String getNextName(String typeName) {
+                if (problem == null) {
+                        throw new IllegalStateException("Problem was not set");
+                }
+                String namePrefix;
+                if (typeName == null || typeName.isEmpty()) {
+                        namePrefix = "node";
+                } else {
+                        namePrefix = typeName.substring(0, 1).toLowerCase(Locale.ROOT) + typeName.substring(1);
+                }
+                int index = indexMap.getIfAbsent(namePrefix, 0);
+                String nodeName;
+                QualifiedName qualifiedName;
+                var scope = scopeProvider.getScope(problem, ProblemPackage.Literals.NODE_ASSERTION_ARGUMENT__NODE);
+                do {
+                        index++;
+                        nodeName = namePrefix + index;
+                        qualifiedName = qualifiedNameConverter.toQualifiedName(nodeName);
+                } while (semanticsUtils.maybeGetElement(problem, scope, qualifiedName, Node.class) != null);
+                indexMap.put(namePrefix, index);
+                return nodeName;
+        }
+}
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java
index 57af599e..09ba34fc 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/SolutionSerializer.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -8,12 +8,9 @@ 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;
@@ -37,7 +34,6 @@ 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;
@@ -57,9 +53,6 @@ public class SolutionSerializer {
         private IQualifiedNameProvider qualifiedNameProvider;
 
         @Inject
-        private IQualifiedNameConverter qualifiedNameConverter;
-
-        @Inject
         private SemanticsUtils semanticsUtils;
 
         @Inject
@@ -68,6 +61,9 @@ public class SolutionSerializer {
         @Inject
         private ProblemDesugarer desugarer;
 
+        @Inject
+        private NodeNameProvider nameProvider;
+
         private ProblemTrace trace;
         private Model model;
         private ReasoningAdapter reasoningAdapter;
@@ -95,6 +91,7 @@ public class SolutionSerializer {
                 problem = copyProblem(originalProblem, uri);
                 problem.getStatements().removeIf(SolutionSerializer::shouldRemoveStatement);
                 problem.getNodes().removeIf(this::shouldRemoveNode);
+                nameProvider.setProblem(problem);
                 addExistsAssertions();
                 addClassAssertions();
                 addReferenceAssertions();
@@ -172,11 +169,6 @@ public class SolutionSerializer {
                 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);
@@ -222,19 +214,17 @@ public class SolutionSerializer {
         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);
+                                createNodeAndAssertType(nodeId, cursor.getValue(), types);
                         }
                 }
         }
 
-        private void createNodeAndAssertType(int nodeId, InferredType inferredType, Map<PartialRelation, Relation> types,
-                                                                                 MutableObjectIntMap<Object> indexMap) {
+        private void createNodeAndAssertType(int nodeId, InferredType inferredType, Map<PartialRelation, Relation> types) {
                 var candidateTypeSymbol = inferredType.candidateType();
                 var candidateRelation = types.get(candidateTypeSymbol);
                 if (candidateRelation instanceof EnumDeclaration) {
@@ -243,18 +233,8 @@ public class SolutionSerializer {
                 }
                 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);
+                        var typeName = candidateRelation.getName();
+                        var nodeName = nameProvider.getNextName(typeName);
                         node = ProblemFactory.eINSTANCE.createNode();
                         node.setName(nodeName);
                         problem.getNodes().add(node);
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java
index a3b6ca82..7febce7d 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -17,6 +17,7 @@ import tools.refinery.generator.ValidationErrorsException;
 import tools.refinery.language.web.semantics.PartialInterpretation2Json;
 import tools.refinery.language.web.xtext.server.ThreadPoolExecutorServiceProvider;
 import tools.refinery.language.web.xtext.server.push.PushWebDocument;
+import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.util.CancellationToken;
 
 import java.io.IOException;
@@ -142,7 +143,7 @@ public class ModelGenerationWorker implements Runnable {
                 } catch (ValidationErrorsException e) {
                         var errors = e.getErrors();
                         if (errors != null && !errors.isEmpty()) {
-                                return new ModelGenerationErrorResult(uuid, "Validation error: " + errors.get(0).getMessage());
+                                return new ModelGenerationErrorResult(uuid, "Validation error: " + errors.getFirst().getMessage());
                         }
                         throw e;
                 }
@@ -154,7 +155,7 @@ public class ModelGenerationWorker implements Runnable {
                 notifyResult(new ModelGenerationStatusResult(uuid, "Saving generated model"));
                 cancellationToken.checkCancelled();
                 metadataCreator.setProblemTrace(generator.getProblemTrace());
-                var nodesMetadata = metadataCreator.getNodesMetadata(generator.getModel(), false);
+                var nodesMetadata = metadataCreator.getNodesMetadata(generator.getModel(), Concreteness.CANDIDATE);
                 cancellationToken.checkCancelled();
                 var relationsMetadata = metadataCreator.getRelationsMetadata();
                 cancellationToken.checkCancelled();
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java
index 44974869..fed3c8a3 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -20,6 +20,7 @@ import tools.refinery.generator.ModelSemanticsFactory;
 import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.web.semantics.metadata.MetadataCreator;
 import tools.refinery.language.semantics.TracedException;
+import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.util.CancellationToken;
 
@@ -73,7 +74,7 @@ class SemanticsWorker implements Callable<SemanticsResult> {
                 }
                 cancellationToken.checkCancelled();
                 metadataCreator.setProblemTrace(semantics.getProblemTrace());
-                var nodesMetadata = metadataCreator.getNodesMetadata(semantics.getModel(), true);
+                var nodesMetadata = metadataCreator.getNodesMetadata(semantics.getModel(), Concreteness.PARTIAL);
                 cancellationToken.checkCancelled();
                 var relationsMetadata = metadataCreator.getRelationsMetadata();
                 cancellationToken.checkCancelled();
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/MetadataCreator.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/MetadataCreator.java
index 3fbc5d2d..f05abc45 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/MetadataCreator.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/MetadataCreator.java
@@ -1,11 +1,12 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.language.web.semantics.metadata;
 
 import com.google.inject.Inject;
+import com.google.inject.Provider;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
 import org.eclipse.xtext.naming.IQualifiedNameProvider;
@@ -18,6 +19,7 @@ import tools.refinery.language.semantics.TracedException;
 import tools.refinery.language.utils.ProblemUtil;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 
 import java.util.ArrayList;
@@ -35,10 +37,11 @@ public class MetadataCreator {
         @Inject
         private IQualifiedNameConverter qualifiedNameConverter;
 
-        private ProblemTrace problemTrace;
+        @Inject
+        private Provider<NodeMetadataFactory> nodeMetadataFactoryProvider;
 
+        private ProblemTrace problemTrace;
         private IScope nodeScope;
-
         private IScope relationScope;
 
         public void setProblemTrace(ProblemTrace problemTrace) {
@@ -51,37 +54,35 @@ public class MetadataCreator {
                 relationScope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__RELATION);
         }
 
-        public static String unnamedNode(int nodeId) {
-                return "::" + nodeId;
-        }
-
-        public List<NodeMetadata> getNodesMetadata(Model model, boolean preserveNewNodes) {
+        public List<NodeMetadata> getNodesMetadata(Model model, Concreteness concreteness) {
                 int nodeCount = model.getAdapter(ReasoningAdapter.class).getNodeCount();
                 var nodeTrace = problemTrace.getNodeTrace();
                 var nodes = new NodeMetadata[Math.max(nodeTrace.size(), nodeCount)];
+                var nodeMetadataFactory = nodeMetadataFactoryProvider.get();
+                nodeMetadataFactory.initialize(problemTrace, concreteness, model);
+                boolean preserveNewNodes = concreteness == Concreteness.PARTIAL;
                 for (var entry : nodeTrace.keyValuesView()) {
                         var node = entry.getOne();
                         var id = entry.getTwo();
-                        nodes[id] = getNodeMetadata(id, node, preserveNewNodes);
+                        nodes[id] = getNodeMetadata(id, node, preserveNewNodes, nodeMetadataFactory);
                 }
                 for (int i = 0; i < nodes.length; i++) {
                         if (nodes[i] == null) {
-                                var nodeName = unnamedNode(i);
-                                nodes[i] = new NodeMetadata(nodeName, nodeName, NodeKind.IMPLICIT);
+                                nodes[i] = nodeMetadataFactory.createFreshlyNamedMetadata(i);
                         }
                 }
                 return List.of(nodes);
         }
 
-        private NodeMetadata getNodeMetadata(int nodeId, Node node, boolean preserveNewNodes) {
+        private NodeMetadata getNodeMetadata(int nodeId, Node node, boolean preserveNewNodes,
+                                                                                 NodeMetadataFactory nodeMetadataFactory) {
                 var kind = getNodeKind(node);
                 if (!preserveNewNodes && kind == NodeKind.NEW) {
-                        var nodeName = unnamedNode(nodeId);
-                        return new NodeMetadata(nodeName, nodeName, NodeKind.IMPLICIT);
+                        return nodeMetadataFactory.createFreshlyNamedMetadata(nodeId);
                 }
                 var qualifiedName = getQualifiedName(node);
                 var simpleName = getSimpleName(node, qualifiedName, nodeScope);
-                return new NodeMetadata(qualifiedNameConverter.toString(qualifiedName),
+                return nodeMetadataFactory.doCreateMetadata(nodeId, qualifiedNameConverter.toString(qualifiedName),
                                 qualifiedNameConverter.toString(simpleName), getNodeKind(node));
         }
 
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/NodeMetadata.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/NodeMetadata.java
index 5da28acf..f3347eac 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/NodeMetadata.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/NodeMetadata.java
@@ -1,9 +1,9 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2023 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.language.web.semantics.metadata;
 
-public record NodeMetadata(String name, String simpleName, NodeKind kind) implements Metadata {
+public record NodeMetadata(String name, String simpleName, String typeHash, NodeKind kind) implements Metadata {
 }
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/NodeMetadataFactory.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/NodeMetadataFactory.java
new file mode 100644
index 00000000..ce0e50c1
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/metadata/NodeMetadataFactory.java
@@ -0,0 +1,89 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.web.semantics.metadata;
+
+import com.google.inject.Inject;
+import tools.refinery.language.ide.syntaxcoloring.TypeHashProvider;
+import tools.refinery.language.semantics.NodeNameProvider;
+import tools.refinery.language.semantics.ProblemTrace;
+import tools.refinery.store.model.Interpretation;
+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;
+
+public class NodeMetadataFactory {
+        @Inject
+        private NodeNameProvider nodeNameProvider;
+
+        @Inject
+        private TypeHashProvider typeHashProvider;
+
+        private ProblemTrace problemTrace;
+        private Concreteness concreteness;
+        private Interpretation<InferredType> typeInterpretation;
+        private PartialInterpretation<TruthValue, Boolean> existsInterpretation;
+
+        public void initialize(ProblemTrace problemTrace, Concreteness concreteness, Model model) {
+                this.problemTrace = problemTrace;
+                this.concreteness = concreteness;
+                typeInterpretation = model.getInterpretation(TypeHierarchyTranslator.TYPE_SYMBOL);
+                existsInterpretation = model.getAdapter(ReasoningAdapter.class).getPartialInterpretation(concreteness,
+                                ReasoningAdapter.EXISTS_SYMBOL);
+                nodeNameProvider.setProblem(problemTrace.getProblem());
+        }
+
+        public NodeMetadata doCreateMetadata(int nodeId, String name, String simpleName, NodeKind kind) {
+                var type = getType(nodeId);
+                return doCreateMetadata(name, simpleName, type, kind);
+        }
+
+        public NodeMetadata createFreshlyNamedMetadata(int nodeId) {
+                var type = getType(nodeId);
+                var name = getName(type, nodeId);
+                return doCreateMetadata(name, name, type, NodeKind.IMPLICIT);
+        }
+
+        private PartialRelation getType(int nodeId) {
+                var inferredType = typeInterpretation.get(Tuple.of(nodeId));
+                if (inferredType == null) {
+                        return null;
+                }
+                return inferredType.candidateType();
+        }
+
+        private String getName(PartialRelation type, int nodeId) {
+                if (concreteness == Concreteness.CANDIDATE && !existsInterpretation.get(Tuple.of(nodeId)).may()) {
+                        // Do not increment the node name counter for non-existent nodes in the candidate interpretation.
+                        // While non-existent nodes may appear in the partial interpretation, they are never displayed in the
+                        // candidate interpretation.
+                        return "::" + nodeId;
+                }
+                if (type == null) {
+                        return nodeNameProvider.getNextName(null);
+                }
+                var relation = problemTrace.getRelation(type);
+                return nodeNameProvider.getNextName(relation.getName());
+        }
+
+        private NodeMetadata doCreateMetadata(String name, String simpleName, PartialRelation type, NodeKind kind) {
+                var typeHash = getTypeHash(type);
+                return new NodeMetadata(name, simpleName, typeHash, kind);
+        }
+
+        private String getTypeHash(PartialRelation type) {
+                if (type == null) {
+                        return null;
+                }
+                var relation = problemTrace.getRelation(type);
+                return typeHashProvider.getTypeHash(relation);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
index cac1f265..c04c7d09 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -28,6 +28,8 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
         public static final String ARITY = DATA_PREFIX + "ARITY";
         public static final String ERROR_PREDICATE = DATA_PREFIX + "ERROR_PREDICATE";
         public static final String ERROR_PREDICATE_TRUE = "true";
+        public static final String COLOR_RELATION = DATA_PREFIX + "COLOR_RELATION";
+        public static final String COLOR_RELATION_TRUE = "true";
 
         @Inject
         private IQualifiedNameConverter qualifiedNameConverter;
@@ -44,12 +46,9 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
                 var problem = EcoreUtil2.getContainerOfType(eObject, Problem.class);
                 var problemQualifiedName = getNameAsQualifiedName(problem);
                 var userData = getUserData(eObject);
-                boolean nameExported;
+                QualifiedName lastQualifiedNameToExport = null;
                 if (shouldExportSimpleName(eObject)) {
-                        acceptEObjectDescription(eObject, problemQualifiedName, qualifiedName, userData, acceptor);
-                        nameExported = true;
-                } else {
-                        nameExported = false;
+                        lastQualifiedNameToExport = qualifiedName;
                 }
                 var parent = eObject.eContainer();
                 while (parent != null && parent != problem) {
@@ -60,16 +59,18 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
                         }
                         qualifiedName = parentQualifiedName.append(qualifiedName);
                         if (shouldExportSimpleName(parent)) {
-                                acceptEObjectDescription(eObject, problemQualifiedName, qualifiedName, userData, acceptor);
-                                nameExported = true;
-                        } else {
-                                nameExported = false;
+                                if (lastQualifiedNameToExport != null) {
+                                        acceptEObjectDescription(eObject, problemQualifiedName, lastQualifiedNameToExport, userData,
+                                                        acceptor);
+                                }
+                                lastQualifiedNameToExport = qualifiedName;
                         }
                         parent = parent.eContainer();
                 }
-                if (!nameExported) {
-                        acceptEObjectDescription(eObject, problemQualifiedName, qualifiedName, userData, acceptor);
+                if (lastQualifiedNameToExport == null) {
+                        lastQualifiedNameToExport = qualifiedName;
                 }
+                acceptEObjectDescription(eObject, problemQualifiedName, lastQualifiedNameToExport, userData, true, acceptor);
                 return true;
         }
 
@@ -120,8 +121,31 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
 
         private void acceptEObjectDescription(EObject eObject, QualifiedName prefix, QualifiedName qualifiedName,
                                                                                   Map<String, String> userData, IAcceptor<IEObjectDescription> acceptor) {
+                acceptEObjectDescription(eObject, prefix, qualifiedName, userData, false, acceptor);
+        }
+
+        private void acceptEObjectDescription(EObject eObject, QualifiedName prefix, QualifiedName qualifiedName,
+                                                                                  Map<String, String> userData, boolean fullyQualified,
+                                                                                  IAcceptor<IEObjectDescription> acceptor) {
                 var qualifiedNameWithPrefix = prefix == null ? qualifiedName : prefix.append(qualifiedName);
-                var description = EObjectDescription.create(qualifiedNameWithPrefix, eObject, userData);
+                Map<String, String> userDataWithFullyQualified;
+                if (fullyQualified && shouldColorRelation(eObject)) {
+                        userDataWithFullyQualified = ImmutableMap.<String, String>builder()
+                                        .putAll(userData)
+                                        .put(COLOR_RELATION, COLOR_RELATION_TRUE)
+                                        .build();
+                } else {
+                        userDataWithFullyQualified = userData;
+                }
+                var description = EObjectDescription.create(qualifiedNameWithPrefix, eObject, userDataWithFullyQualified);
                 acceptor.accept(description);
         }
+
+        private boolean shouldColorRelation(EObject eObject) {
+                if (ProblemUtil.isBuiltIn(eObject)) {
+                        return false;
+                }
+                return eObject instanceof ClassDeclaration || eObject instanceof EnumDeclaration;
+
+        }
 }