feat: connect model generator to UI

36 files changed, 1278 insertions, 235 deletions

diff --git a/subprojects/frontend/src/ModelWorkArea.tsx b/subprojects/frontend/src/ModelWorkArea.tsx
new file mode 100644
index 00000000..3aba31e3
--- /dev/null
+++ b/subprojects/frontend/src/ModelWorkArea.tsx
@@ -0,0 +1,198 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+import CloseIcon from '@mui/icons-material/Close';
+import SentimentVeryDissatisfiedIcon from '@mui/icons-material/SentimentVeryDissatisfied';
+import CircularProgress from '@mui/material/CircularProgress';
+import IconButton from '@mui/material/IconButton';
+import Stack from '@mui/material/Stack';
+import Tab from '@mui/material/Tab';
+import Tabs from '@mui/material/Tabs';
+import { styled } from '@mui/material/styles';
+import { observer } from 'mobx-react-lite';
+
+import DirectionalSplitPane from './DirectionalSplitPane';
+import Loading from './Loading';
+import { useRootStore } from './RootStoreProvider';
+import type GeneratedModelStore from './editor/GeneratedModelStore';
+import GraphPane from './graph/GraphPane';
+import type GraphStore from './graph/GraphStore';
+import TablePane from './table/TablePane';
+import type ThemeStore from './theme/ThemeStore';
+
+const SplitGraphPane = observer(function SplitGraphPane({
+  graph,
+  themeStore,
+}: {
+  graph: GraphStore;
+  themeStore: ThemeStore;
+}): JSX.Element {
+  return (
+    <DirectionalSplitPane
+      primary={<GraphPane graph={graph} />}
+      secondary={<TablePane graph={graph} />}
+      primaryOnly={!themeStore.showTable}
+      secondaryOnly={!themeStore.showGraph}
+    />
+  );
+});
+
+const GenerationStatus = styled('div', {
+  name: 'ModelWorkArea-GenerationStatus',
+  shouldForwardProp: (prop) => prop !== 'error',
+})<{ error: boolean }>(({ error, theme }) => ({
+  color: error ? theme.palette.error.main : theme.palette.text.primary,
+  ...(error
+    ? {
+        fontWeight: theme.typography.fontWeightBold ?? 600,
+      }
+    : {}),
+}));
+
+const GeneratedModelPane = observer(function GeneratedModelPane({
+  generatedModel,
+  themeStore,
+}: {
+  generatedModel: GeneratedModelStore;
+  themeStore: ThemeStore;
+}): JSX.Element {
+  const { message, error, graph } = generatedModel;
+
+  if (graph !== undefined) {
+    return <SplitGraphPane graph={graph} themeStore={themeStore} />;
+  }
+
+  return (
+    <Stack
+      direction="column"
+      alignItems="center"
+      justifyContent="center"
+      height="100%"
+      width="100%"
+      overflow="hidden"
+      my={2}
+    >
+      <Stack
+        direction="column"
+        alignItems="center"
+        flexGrow={1}
+        flexShrink={1}
+        flexBasis={0}
+        sx={(theme) => ({
+          maxHeight: '6rem',
+          height: 'calc(100% - 8rem)',
+          marginBottom: theme.spacing(1),
+          padding: error ? 0 : theme.spacing(1),
+          color: theme.palette.text.secondary,
+          '.MuiCircularProgress-root, .MuiCircularProgress-svg, .MuiSvgIcon-root':
+            {
+              height: '100% !important',
+              width: '100% !important',
+            },
+        })}
+      >
+        {error ? (
+          <SentimentVeryDissatisfiedIcon
+            className="VisibilityDialog-emptyIcon"
+            fontSize="inherit"
+          />
+        ) : (
+          <CircularProgress color="inherit" />
+        )}
+      </Stack>
+      <GenerationStatus error={error}>{message}</GenerationStatus>
+    </Stack>
+  );
+});
+
+function ModelWorkArea(): JSX.Element {
+  const { editorStore, themeStore } = useRootStore();
+
+  if (editorStore === undefined) {
+    return <Loading />;
+  }
+
+  const { graph, generatedModels, selectedGeneratedModel } = editorStore;
+
+  const generatedModelNames: string[] = [];
+  const generatedModelTabs: JSX.Element[] = [];
+  generatedModels.forEach((value, key) => {
+    generatedModelNames.push(key);
+    /* eslint-disable react/no-array-index-key -- Key is a string here, not the array index. */
+    generatedModelTabs.push(
+      <Tab
+        label={value.title}
+        key={key}
+        onAuxClick={(event) => {
+          if (event.button === 1) {
+            editorStore.deleteGeneratedModel(key);
+            event.preventDefault();
+            event.stopPropagation();
+          }
+        }}
+      />,
+    );
+    /* eslint-enable react/no-array-index-key */
+  });
+  const generatedModel =
+    selectedGeneratedModel === undefined
+      ? undefined
+      : generatedModels.get(selectedGeneratedModel);
+  const selectedIndex =
+    selectedGeneratedModel === undefined
+      ? 0
+      : generatedModelNames.indexOf(selectedGeneratedModel) + 1;
+
+  return (
+    <Stack direction="column" height="100%" width="100%" overflow="hidden">
+      <Stack
+        direction="row"
+        sx={(theme) => ({
+          display: generatedModelNames.length === 0 ? 'none' : 'flex',
+          alignItems: 'center',
+          borderBottom: `1px solid ${theme.palette.outer.border}`,
+        })}
+      >
+        <Tabs
+          value={selectedIndex}
+          onChange={(_event, value) => {
+            if (value === 0) {
+              editorStore.selectGeneratedModel(undefined);
+            } else if (typeof value === 'number') {
+              editorStore.selectGeneratedModel(generatedModelNames[value - 1]);
+            }
+          }}
+          sx={{ flexGrow: 1 }}
+        >
+          <Tab label="Initial model" />
+          {generatedModelTabs}
+        </Tabs>
+        <IconButton
+          aria-label="Close generated model"
+          onClick={() =>
+            editorStore.deleteGeneratedModel(selectedGeneratedModel)
+          }
+          sx={{
+            display: selectedIndex === 0 ? 'none' : 'flex',
+            mx: 1,
+          }}
+        >
+          <CloseIcon fontSize="small" />
+        </IconButton>
+      </Stack>
+      {generatedModel === undefined ? (
+        <SplitGraphPane graph={graph} themeStore={themeStore} />
+      ) : (
+        <GeneratedModelPane
+          generatedModel={generatedModel}
+          themeStore={themeStore}
+        />
+      )}
+    </Stack>
+  );
+}
+
+export default observer(ModelWorkArea);
diff --git a/subprojects/frontend/src/WorkArea.tsx b/subprojects/frontend/src/WorkArea.tsx
index adb29a50..a1fbf7dc 100644
--- a/subprojects/frontend/src/WorkArea.tsx
+++ b/subprojects/frontend/src/WorkArea.tsx
@@ -7,10 +7,9 @@
 import { observer } from 'mobx-react-lite';
 
 import DirectionalSplitPane from './DirectionalSplitPane';
+import ModelWorkArea from './ModelWorkArea';
 import { useRootStore } from './RootStoreProvider';
 import EditorPane from './editor/EditorPane';
-import GraphPane from './graph/GraphPane';
-import TablePane from './table/TablePane';
 
 export default observer(function WorkArea(): JSX.Element {
   const { themeStore } = useRootStore();
@@ -18,14 +17,7 @@ export default observer(function WorkArea(): JSX.Element {
   return (
     <DirectionalSplitPane
       primary={<EditorPane />}
-      secondary={
-        <DirectionalSplitPane
-          primary={<GraphPane />}
-          secondary={<TablePane />}
-          primaryOnly={!themeStore.showTable}
-          secondaryOnly={!themeStore.showGraph}
-        />
-      }
+      secondary={<ModelWorkArea />}
       primaryOnly={!themeStore.showGraph && !themeStore.showTable}
       secondaryOnly={!themeStore.showCode}
     />
diff --git a/subprojects/frontend/src/editor/EditorStore.ts b/subprojects/frontend/src/editor/EditorStore.ts
index b5989ad1..f9a9a7da 100644
--- a/subprojects/frontend/src/editor/EditorStore.ts
+++ b/subprojects/frontend/src/editor/EditorStore.ts
@@ -32,6 +32,7 @@ import type XtextClient from '../xtext/XtextClient';
 import type { SemanticsSuccessResult } from '../xtext/xtextServiceResults';
 
 import EditorErrors from './EditorErrors';
+import GeneratedModelStore from './GeneratedModelStore';
 import LintPanelStore from './LintPanelStore';
 import SearchPanelStore from './SearchPanelStore';
 import createEditorState from './createEditorState';
@@ -69,6 +70,10 @@ export default class EditorStore {
 
   graph: GraphStore;
 
+  generatedModels = new Map<string, GeneratedModelStore>();
+
+  selectedGeneratedModel: string | undefined;
+
   constructor(initialValue: string, pwaStore: PWAStore) {
     this.id = nanoid();
     this.state = createEditorState(initialValue, this);
@@ -307,4 +312,84 @@ export default class EditorStore {
     this.delayedErrors.dispose();
     this.disposed = true;
   }
+
+  startModelGeneration(): void {
+    this.client
+      ?.startModelGeneration()
+      ?.catch((error) => log.error('Could not start model generation', error));
+  }
+
+  addGeneratedModel(uuid: string): void {
+    this.generatedModels.set(uuid, new GeneratedModelStore());
+    this.selectGeneratedModel(uuid);
+  }
+
+  cancelModelGeneration(): void {
+    this.client
+      ?.cancelModelGeneration()
+      ?.catch((error) => log.error('Could not start model generation', error));
+  }
+
+  selectGeneratedModel(uuid: string | undefined): void {
+    if (uuid === undefined) {
+      this.selectedGeneratedModel = uuid;
+      return;
+    }
+    if (this.generatedModels.has(uuid)) {
+      this.selectedGeneratedModel = uuid;
+      return;
+    }
+    this.selectedGeneratedModel = undefined;
+  }
+
+  deleteGeneratedModel(uuid: string | undefined): void {
+    if (uuid === undefined) {
+      return;
+    }
+    if (this.selectedGeneratedModel === uuid) {
+      let previous: string | undefined;
+      let found: string | undefined;
+      this.generatedModels.forEach((_value, key) => {
+        if (key === uuid) {
+          found = previous;
+        }
+        previous = key;
+      });
+      this.selectGeneratedModel(found);
+    }
+    const generatedModel = this.generatedModels.get(uuid);
+    if (generatedModel !== undefined && generatedModel.running) {
+      this.cancelModelGeneration();
+    }
+    this.generatedModels.delete(uuid);
+  }
+
+  modelGenerationCancelled(): void {
+    this.generatedModels.forEach((value) =>
+      value.setError('Model generation cancelled'),
+    );
+  }
+
+  setGeneratedModelMessage(uuid: string, message: string): void {
+    this.generatedModels.get(uuid)?.setMessage(message);
+  }
+
+  setGeneratedModelError(uuid: string, message: string): void {
+    this.generatedModels.get(uuid)?.setError(message);
+  }
+
+  setGeneratedModelSemantics(
+    uuid: string,
+    semantics: SemanticsSuccessResult,
+  ): void {
+    this.generatedModels.get(uuid)?.setSemantics(semantics);
+  }
+
+  get generating(): boolean {
+    let generating = false;
+    this.generatedModels.forEach((value) => {
+      generating = generating || value.running;
+    });
+    return generating;
+  }
 }
diff --git a/subprojects/frontend/src/editor/GenerateButton.tsx b/subprojects/frontend/src/editor/GenerateButton.tsx
index 5bac0464..b8dcd531 100644
--- a/subprojects/frontend/src/editor/GenerateButton.tsx
+++ b/subprojects/frontend/src/editor/GenerateButton.tsx
@@ -5,6 +5,7 @@
  */
 
 import CancelIcon from '@mui/icons-material/Cancel';
+import CloseIcon from '@mui/icons-material/Close';
 import PlayArrowIcon from '@mui/icons-material/PlayArrow';
 import { observer } from 'mobx-react-lite';
 
@@ -28,8 +29,10 @@ const GenerateButton = observer(function GenerateButton({
     );
   }
 
-  const { analyzing, errorCount, warningCount, semanticsError } =
-    editorStore.delayedErrors;
+  const {
+    delayedErrors: { analyzing, errorCount, warningCount, semanticsError },
+    generating,
+  } = editorStore;
 
   if (analyzing) {
     return (
@@ -39,6 +42,18 @@ const GenerateButton = observer(function GenerateButton({
     );
   }
 
+  if (generating) {
+    return (
+      <AnimatedButton
+        color="inherit"
+        onClick={() => editorStore.cancelModelGeneration()}
+        startIcon={<CloseIcon />}
+      >
+        Cancel
+      </AnimatedButton>
+    );
+  }
+
   if (semanticsError !== undefined && editorStore.opened) {
     return (
       <AnimatedButton
@@ -83,6 +98,7 @@ const GenerateButton = observer(function GenerateButton({
       disabled={!editorStore.opened}
       color={warningCount > 0 ? 'warning' : 'primary'}
       startIcon={<PlayArrowIcon />}
+      onClick={() => editorStore.startModelGeneration()}
     >
       {summary === '' ? GENERATE_LABEL : `${GENERATE_LABEL} (${summary})`}
     </AnimatedButton>
diff --git a/subprojects/frontend/src/editor/GeneratedModelStore.ts b/subprojects/frontend/src/editor/GeneratedModelStore.ts
new file mode 100644
index 00000000..d0181eed
--- /dev/null
+++ b/subprojects/frontend/src/editor/GeneratedModelStore.ts
@@ -0,0 +1,50 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+import { makeAutoObservable } from 'mobx';
+
+import GraphStore from '../graph/GraphStore';
+import type { SemanticsSuccessResult } from '../xtext/xtextServiceResults';
+
+export default class GeneratedModelStore {
+  title: string;
+
+  message = 'Waiting for server';
+
+  error = false;
+
+  graph: GraphStore | undefined;
+
+  constructor() {
+    const time = new Date().toLocaleTimeString(undefined, { hour12: false });
+    this.title = `Generated at ${time}`;
+    makeAutoObservable(this);
+  }
+
+  get running(): boolean {
+    return !this.error && this.graph === undefined;
+  }
+
+  setMessage(message: string): void {
+    if (this.running) {
+      this.message = message;
+    }
+  }
+
+  setError(message: string): void {
+    if (this.running) {
+      this.error = true;
+      this.message = message;
+    }
+  }
+
+  setSemantics(semantics: SemanticsSuccessResult): void {
+    if (this.running) {
+      this.graph = new GraphStore();
+      this.graph.setSemantics(semantics);
+    }
+  }
+}
diff --git a/subprojects/frontend/src/graph/GraphArea.tsx b/subprojects/frontend/src/graph/GraphArea.tsx
index f8f40d22..d5801b9a 100644
--- a/subprojects/frontend/src/graph/GraphArea.tsx
+++ b/subprojects/frontend/src/graph/GraphArea.tsx
@@ -9,25 +9,17 @@ import { useTheme } from '@mui/material/styles';
 import { observer } from 'mobx-react-lite';
 import { useResizeDetector } from 'react-resize-detector';
 
-import Loading from '../Loading';
-import { useRootStore } from '../RootStoreProvider';
-
 import DotGraphVisualizer from './DotGraphVisualizer';
+import type GraphStore from './GraphStore';
 import VisibilityPanel from './VisibilityPanel';
 import ZoomCanvas from './ZoomCanvas';
 
-function GraphArea(): JSX.Element {
-  const { editorStore } = useRootStore();
+function GraphArea({ graph }: { graph: GraphStore }): JSX.Element {
   const { breakpoints } = useTheme();
   const { ref, width, height } = useResizeDetector({
     refreshMode: 'debounce',
   });
 
-  if (editorStore === undefined) {
-    return <Loading />;
-  }
-
-  const { graph } = editorStore;
   const breakpoint = breakpoints.values.sm;
   const dialog =
     width === undefined ||
diff --git a/subprojects/frontend/src/graph/GraphPane.tsx b/subprojects/frontend/src/graph/GraphPane.tsx
index c2ef8927..67dbfcbd 100644
--- a/subprojects/frontend/src/graph/GraphPane.tsx
+++ b/subprojects/frontend/src/graph/GraphPane.tsx
@@ -9,9 +9,15 @@ import { Suspense, lazy } from 'react';
 
 import Loading from '../Loading';
 
+import type GraphStore from './GraphStore';
+
 const GraphArea = lazy(() => import('./GraphArea'));
 
-export default function GraphPane(): JSX.Element {
+export default function GraphPane({
+  graph,
+}: {
+  graph: GraphStore;
+}): JSX.Element {
   return (
     <Stack
       direction="column"
@@ -21,7 +27,7 @@ export default function GraphPane(): JSX.Element {
       justifyContent="center"
     >
       <Suspense fallback={<Loading />}>
-        <GraphArea />
+        <GraphArea graph={graph} />
       </Suspense>
     </Stack>
   );
diff --git a/subprojects/frontend/src/index.tsx b/subprojects/frontend/src/index.tsx
index e8a22e82..4b251a23 100644
--- a/subprojects/frontend/src/index.tsx
+++ b/subprojects/frontend/src/index.tsx
@@ -16,35 +16,101 @@ import RootStore from './RootStore';
 (window as unknown as { fixViteIssue: unknown }).fixViteIssue = styled;
 
 const initialValue = `% Metamodel
-class Person {
-    contains Post[] posts opposite author
-    Person[] friend opposite friend
+
+abstract class CompositeElement {
+    contains Region[] regions
+}
+
+class Region {
+    contains Vertex[] vertices opposite region
+}
+
+abstract class Vertex {
+    container Region region opposite vertices
+    contains Transition[] outgoingTransition opposite source
+    Transition[] incomingTransition opposite target
 }
 
-class Post {
-    container Person author opposite posts
-    Post replyTo
+class Transition {
+    container Vertex source opposite outgoingTransition
+    Vertex target opposite incomingTransition
 }
 
+abstract class Pseudostate extends Vertex.
+
+abstract class RegularState extends Vertex.
+
+class Entry extends Pseudostate.
+
+class Exit extends Pseudostate.
+
+class Choice extends Pseudostate.
+
+class FinalState extends RegularState.
+
+class State extends RegularState, CompositeElement.
+
+class Statechart extends CompositeElement.
+
 % Constraints
-error replyToNotFriend(Post x, Post y) <->
-    replyTo(x, y),
-    author(x, xAuthor),
-    author(y, yAuthor),
-    xAuthor != yAuthor,
-    !friend(xAuthor, yAuthor).
 
-error replyToCycle(Post x) <-> replyTo+(x, x).
+%% Entry
+
+pred entryInRegion(Region r, Entry e) <->
+    vertices(r, e).
+
+error noEntryInRegion(Region r) <->
+    !entryInRegion(r, _).
+
+error multipleEntryInRegion(Region r) <->
+    entryInRegion(r, e1),
+    entryInRegion(r, e2),
+    e1 != e2.
+
+error incomingToEntry(Transition t, Entry e) <->
+    target(t, e).
+
+error noOutgoingTransitionFromEntry(Entry e) <->
+    !source(_, e).
+
+error multipleTransitionFromEntry(Entry e, Transition t1, Transition t2) <->
+    outgoingTransition(e, t1),
+    outgoingTransition(e, t2),
+    t1 != t2.
+
+%% Exit
+
+error outgoingFromExit(Transition t, Exit e) <->
+    source(t, e).
+
+%% Final
+
+error outgoingFromFinal(Transition t, FinalState e) <->
+    source(t, e).
+
+%% State vs Region
+
+pred stateInRegion(Region r, State s) <->
+    vertices(r, s).
+
+error noStateInRegion(Region r) <->
+    !stateInRegion(r, _).
+
+%% Choice
+
+error choiceHasNoOutgoing(Choice c) <->
+    !source(_, c).
+
+error choiceHasNoIncoming(Choice c) <->
+    !target(_, c).
 
 % Instance model
-friend(a, b).
-author(p1, a).
-author(p2, b).
 
-!author(Post::new, a).
+Statechart(sct).
 
 % Scope
-scope Post = 10..15, Person += 0.
+
+scope node = 20..30, Region = 2..*, Choice = 1..*, Statechart += 0.
 `;
 
 configure({
diff --git a/subprojects/frontend/src/table/RelationGrid.tsx b/subprojects/frontend/src/table/RelationGrid.tsx
deleted file mode 100644
index 004982c9..00000000
--- a/subprojects/frontend/src/table/RelationGrid.tsx
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-
-import Box from '@mui/material/Box';
-import {
-  DataGrid,
-  type GridRenderCellParams,
-  type GridColDef,
-} from '@mui/x-data-grid';
-import { observer } from 'mobx-react-lite';
-import { useMemo } from 'react';
-
-import type GraphStore from '../graph/GraphStore';
-
-import TableToolbar from './TableToolbar';
-import ValueRenderer from './ValueRenderer';
-
-interface Row {
-  nodes: string[];
-  value: string;
-}
-
-function RelationGrid({ graph }: { graph: GraphStore }): JSX.Element {
-  const {
-    selectedSymbol,
-    semantics: { nodes, partialInterpretation },
-  } = graph;
-  const symbolName = selectedSymbol?.name;
-  const arity = selectedSymbol?.arity ?? 0;
-
-  const columns = useMemo<GridColDef<Row>[]>(() => {
-    const defs: GridColDef<Row>[] = [];
-    for (let i = 0; i < arity; i += 1) {
-      defs.push({
-        field: `n${i}`,
-        headerName: String(i + 1),
-        valueGetter: (row) => row.row.nodes[i] ?? '',
-        flex: 1,
-      });
-    }
-    defs.push({
-      field: 'value',
-      headerName: 'Value',
-      flex: 1,
-      renderCell: ({ value }: GridRenderCellParams<Row, string>) => (
-        <ValueRenderer value={value} />
-      ),
-    });
-    return defs;
-  }, [arity]);
-
-  const rows = useMemo<Row[]>(() => {
-    if (symbolName === undefined) {
-      return [];
-    }
-    const interpretation = partialInterpretation[symbolName] ?? [];
-    return interpretation.map((tuple) => {
-      const nodeNames: string[] = [];
-      for (let i = 0; i < arity; i += 1) {
-        const index = tuple[i];
-        if (typeof index === 'number') {
-          const node = nodes[index];
-          if (node !== undefined) {
-            nodeNames.push(node.name);
-          }
-        }
-      }
-      return {
-        nodes: nodeNames,
-        value: String(tuple[arity]),
-      };
-    });
-  }, [arity, nodes, partialInterpretation, symbolName]);
-
-  return (
-    <Box
-      width="100%"
-      height="100%"
-      p={1}
-      sx={(theme) => ({
-        '.MuiDataGrid-withBorderColor': {
-          borderColor:
-            theme.palette.mode === 'dark'
-              ? theme.palette.divider
-              : theme.palette.outer.border,
-        },
-      })}
-    >
-      <DataGrid
-        slots={{ toolbar: TableToolbar }}
-        slotProps={{
-          toolbar: {
-            graph,
-          },
-        }}
-        density="compact"
-        rowSelection={false}
-        columns={columns}
-        rows={rows}
-        getRowId={(row) => row.nodes.join(',')}
-      />
-    </Box>
-  );
-}
-
-export default observer(RelationGrid);
diff --git a/subprojects/frontend/src/table/TableArea.tsx b/subprojects/frontend/src/table/TableArea.tsx
index cf37b96a..166b8adf 100644
--- a/subprojects/frontend/src/table/TableArea.tsx
+++ b/subprojects/frontend/src/table/TableArea.tsx
@@ -4,21 +4,106 @@
  * SPDX-License-Identifier: EPL-2.0
  */
 
+import Box from '@mui/material/Box';
+import {
+  DataGrid,
+  type GridRenderCellParams,
+  type GridColDef,
+} from '@mui/x-data-grid';
 import { observer } from 'mobx-react-lite';
+import { useMemo } from 'react';
 
-import Loading from '../Loading';
-import { useRootStore } from '../RootStoreProvider';
+import type GraphStore from '../graph/GraphStore';
 
-import RelationGrid from './RelationGrid';
+import TableToolbar from './TableToolbar';
+import ValueRenderer from './ValueRenderer';
 
-function TablePane(): JSX.Element {
-  const { editorStore } = useRootStore();
+interface Row {
+  nodes: string[];
+  value: string;
+}
+
+function TableArea({ graph }: { graph: GraphStore }): JSX.Element {
+  const {
+    selectedSymbol,
+    semantics: { nodes, partialInterpretation },
+  } = graph;
+  const symbolName = selectedSymbol?.name;
+  const arity = selectedSymbol?.arity ?? 0;
+
+  const columns = useMemo<GridColDef<Row>[]>(() => {
+    const defs: GridColDef<Row>[] = [];
+    for (let i = 0; i < arity; i += 1) {
+      defs.push({
+        field: `n${i}`,
+        headerName: String(i + 1),
+        valueGetter: (row) => row.row.nodes[i] ?? '',
+        flex: 1,
+      });
+    }
+    defs.push({
+      field: 'value',
+      headerName: 'Value',
+      flex: 1,
+      renderCell: ({ value }: GridRenderCellParams<Row, string>) => (
+        <ValueRenderer value={value} />
+      ),
+    });
+    return defs;
+  }, [arity]);
 
-  if (editorStore === undefined) {
-    return <Loading />;
-  }
+  const rows = useMemo<Row[]>(() => {
+    if (symbolName === undefined) {
+      return [];
+    }
+    const interpretation = partialInterpretation[symbolName] ?? [];
+    return interpretation.map((tuple) => {
+      const nodeNames: string[] = [];
+      for (let i = 0; i < arity; i += 1) {
+        const index = tuple[i];
+        if (typeof index === 'number') {
+          const node = nodes[index];
+          if (node !== undefined) {
+            nodeNames.push(node.name);
+          }
+        }
+      }
+      return {
+        nodes: nodeNames,
+        value: String(tuple[arity]),
+      };
+    });
+  }, [arity, nodes, partialInterpretation, symbolName]);
 
-  return <RelationGrid graph={editorStore.graph} />;
+  return (
+    <Box
+      width="100%"
+      height="100%"
+      p={1}
+      sx={(theme) => ({
+        '.MuiDataGrid-withBorderColor': {
+          borderColor:
+            theme.palette.mode === 'dark'
+              ? theme.palette.divider
+              : theme.palette.outer.border,
+        },
+      })}
+    >
+      <DataGrid
+        slots={{ toolbar: TableToolbar }}
+        slotProps={{
+          toolbar: {
+            graph,
+          },
+        }}
+        density="compact"
+        rowSelection={false}
+        columns={columns}
+        rows={rows}
+        getRowId={(row) => row.nodes.join(',')}
+      />
+    </Box>
+  );
 }
 
-export default observer(TablePane);
+export default observer(TableArea);
diff --git a/subprojects/frontend/src/table/TablePane.tsx b/subprojects/frontend/src/table/TablePane.tsx
index 01442c3a..8b640217 100644
--- a/subprojects/frontend/src/table/TablePane.tsx
+++ b/subprojects/frontend/src/table/TablePane.tsx
@@ -8,14 +8,19 @@ import Stack from '@mui/material/Stack';
 import { Suspense, lazy } from 'react';
 
 import Loading from '../Loading';
+import type GraphStore from '../graph/GraphStore';
 
 const TableArea = lazy(() => import('./TableArea'));
 
-export default function TablePane(): JSX.Element {
+export default function TablePane({
+  graph,
+}: {
+  graph: GraphStore;
+}): JSX.Element {
   return (
     <Stack direction="column" height="100%" overflow="auto" alignItems="center">
       <Suspense fallback={<Loading />}>
-        <TableArea />
+        <TableArea graph={graph} />
       </Suspense>
     </Stack>
   );
diff --git a/subprojects/frontend/src/xtext/ModelGenerationService.ts b/subprojects/frontend/src/xtext/ModelGenerationService.ts
new file mode 100644
index 00000000..1e9f837a
--- /dev/null
+++ b/subprojects/frontend/src/xtext/ModelGenerationService.ts
@@ -0,0 +1,46 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+import type EditorStore from '../editor/EditorStore';
+
+import type UpdateService from './UpdateService';
+import { ModelGenerationResult } from './xtextServiceResults';
+
+export default class ModelGenerationService {
+  constructor(
+    private readonly store: EditorStore,
+    private readonly updateService: UpdateService,
+  ) {}
+
+  onPush(push: unknown): void {
+    const result = ModelGenerationResult.parse(push);
+    if ('status' in result) {
+      this.store.setGeneratedModelMessage(result.uuid, result.status);
+    } else if ('error' in result) {
+      this.store.setGeneratedModelError(result.uuid, result.error);
+    } else {
+      this.store.setGeneratedModelSemantics(result.uuid, result);
+    }
+  }
+
+  onDisconnect(): void {
+    this.store.modelGenerationCancelled();
+  }
+
+  async start(): Promise<void> {
+    const result = await this.updateService.startModelGeneration();
+    if (!result.cancelled) {
+      this.store.addGeneratedModel(result.data.uuid);
+    }
+  }
+
+  async cancel(): Promise<void> {
+    const result = await this.updateService.cancelModelGeneration();
+    if (!result.cancelled) {
+      this.store.modelGenerationCancelled();
+    }
+  }
+}
diff --git a/subprojects/frontend/src/xtext/UpdateService.ts b/subprojects/frontend/src/xtext/UpdateService.ts
index 1ac722e1..d1246d5e 100644
--- a/subprojects/frontend/src/xtext/UpdateService.ts
+++ b/subprojects/frontend/src/xtext/UpdateService.ts
@@ -22,6 +22,7 @@ import {
   FormattingResult,
   isConflictResult,
   OccurrencesResult,
+  ModelGenerationStartedResult,
 } from './xtextServiceResults';
 
 const UPDATE_TIMEOUT_MS = 500;
@@ -341,4 +342,42 @@ export default class UpdateService {
     }
     return { cancelled: false, data: parsedOccurrencesResult };
   }
+
+  async startModelGeneration(): Promise<
+    CancellableResult<ModelGenerationStartedResult>
+  > {
+    try {
+      await this.updateOrThrow();
+    } catch (error) {
+      if (error instanceof CancelledError || error instanceof TimeoutError) {
+        return { cancelled: true };
+      }
+      throw error;
+    }
+    log.debug('Starting model generation');
+    const data = await this.webSocketClient.send({
+      resource: this.resourceName,
+      serviceType: 'modelGeneration',
+      requiredStateId: this.xtextStateId,
+      start: true,
+    });
+    if (isConflictResult(data)) {
+      return { cancelled: true };
+    }
+    const parsedResult = ModelGenerationStartedResult.parse(data);
+    return { cancelled: false, data: parsedResult };
+  }
+
+  async cancelModelGeneration(): Promise<CancellableResult<unknown>> {
+    log.debug('Cancelling model generation');
+    const data = await this.webSocketClient.send({
+      resource: this.resourceName,
+      serviceType: 'modelGeneration',
+      cancel: true,
+    });
+    if (isConflictResult(data)) {
+      return { cancelled: true };
+    }
+    return { cancelled: false, data };
+  }
 }
diff --git a/subprojects/frontend/src/xtext/XtextClient.ts b/subprojects/frontend/src/xtext/XtextClient.ts
index 87778084..77980d35 100644
--- a/subprojects/frontend/src/xtext/XtextClient.ts
+++ b/subprojects/frontend/src/xtext/XtextClient.ts
@@ -16,6 +16,7 @@ import getLogger from '../utils/getLogger';
 
 import ContentAssistService from './ContentAssistService';
 import HighlightingService from './HighlightingService';
+import ModelGenerationService from './ModelGenerationService';
 import OccurrencesService from './OccurrencesService';
 import SemanticsService from './SemanticsService';
 import UpdateService from './UpdateService';
@@ -40,6 +41,8 @@ export default class XtextClient {
 
   private readonly semanticsService: SemanticsService;
 
+  private readonly modelGenerationService: ModelGenerationService;
+
   constructor(
     private readonly store: EditorStore,
     private readonly pwaStore: PWAStore,
@@ -58,6 +61,10 @@ export default class XtextClient {
     this.validationService = new ValidationService(store, this.updateService);
     this.occurrencesService = new OccurrencesService(store, this.updateService);
     this.semanticsService = new SemanticsService(store, this.validationService);
+    this.modelGenerationService = new ModelGenerationService(
+      store,
+      this.updateService,
+    );
   }
 
   start(): void {
@@ -75,6 +82,7 @@ export default class XtextClient {
     this.highlightingService.onDisconnect();
     this.validationService.onDisconnect();
     this.occurrencesService.onDisconnect();
+    this.modelGenerationService.onDisconnect();
   }
 
   onTransaction(transaction: Transaction): void {
@@ -101,7 +109,7 @@ export default class XtextClient {
       );
       return;
     }
-    if (stateId !== xtextStateId) {
+    if (stateId !== xtextStateId && service !== 'modelGeneration') {
       log.error(
         'Unexpected xtext state id: expected:',
         xtextStateId,
@@ -122,6 +130,9 @@ export default class XtextClient {
       case 'semantics':
         this.semanticsService.onPush(push);
         return;
+      case 'modelGeneration':
+        this.modelGenerationService.onPush(push);
+        return;
       default:
         throw new Error('Unknown service');
     }
@@ -131,6 +142,14 @@ export default class XtextClient {
     return this.contentAssistService.contentAssist(context);
   }
 
+  startModelGeneration(): Promise<void> {
+    return this.modelGenerationService.start();
+  }
+
+  cancelModelGeneration(): Promise<void> {
+    return this.modelGenerationService.cancel();
+  }
+
   formatText(): void {
     this.updateService.formatText().catch((e) => {
       log.error('Error while formatting text', e);
diff --git a/subprojects/frontend/src/xtext/xtextMessages.ts b/subprojects/frontend/src/xtext/xtextMessages.ts
index 971720e1..15831c5a 100644
--- a/subprojects/frontend/src/xtext/xtextMessages.ts
+++ b/subprojects/frontend/src/xtext/xtextMessages.ts
@@ -38,6 +38,7 @@ export const XtextWebPushService = z.enum([
   'highlight',
   'validate',
   'semantics',
+  'modelGeneration',
 ]);
 
 export type XtextWebPushService = z.infer<typeof XtextWebPushService>;
diff --git a/subprojects/frontend/src/xtext/xtextServiceResults.ts b/subprojects/frontend/src/xtext/xtextServiceResults.ts
index caf2cf0b..e473bd48 100644
--- a/subprojects/frontend/src/xtext/xtextServiceResults.ts
+++ b/subprojects/frontend/src/xtext/xtextServiceResults.ts
@@ -126,6 +126,14 @@ export const FormattingResult = DocumentStateResult.extend({
 
 export type FormattingResult = z.infer<typeof FormattingResult>;
 
+export const ModelGenerationStartedResult = z.object({
+  uuid: z.string().nonempty(),
+});
+
+export type ModelGenerationStartedResult = z.infer<
+  typeof ModelGenerationStartedResult
+>;
+
 export const NodeMetadata = z.object({
   name: z.string(),
   simpleName: z.string(),
@@ -171,3 +179,19 @@ export const SemanticsResult = z.union([
 ]);
 
 export type SemanticsResult = z.infer<typeof SemanticsResult>;
+
+export const ModelGenerationResult = z.union([
+  z.object({
+    uuid: z.string().nonempty(),
+    status: z.string(),
+  }),
+  z.object({
+    uuid: z.string().nonempty(),
+    error: z.string(),
+  }),
+  SemanticsSuccessResult.extend({
+    uuid: z.string().nonempty(),
+  }),
+]);
+
+export type ModelGenerationResult = z.infer<typeof ModelGenerationResult>;
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/MetadataCreator.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/MetadataCreator.java
index 0c18b1b3..d6115c5c 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/MetadataCreator.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/metadata/MetadataCreator.java
@@ -47,12 +47,22 @@ public class MetadataCreator {
         }
 
         public List<NodeMetadata> getNodesMetadata() {
-                var nodes = new NodeMetadata[initializer.getNodeCount()];
+                return getNodesMetadata(initializer.getNodeCount());
+        }
+
+        public List<NodeMetadata> getNodesMetadata(int nodeCount) {
+                var nodes = new NodeMetadata[Math.max(initializer.getNodeCount(), nodeCount)];
                 for (var entry : initializer.getNodeTrace().keyValuesView()) {
                         var node = entry.getOne();
                         var id = entry.getTwo();
                         nodes[id] = getNodeMetadata(node);
                 }
+                for (int i = 0; i < nodes.length; i++) {
+                        if (nodes[i] == null) {
+                                var nodeName = "#" + i;
+                                nodes[i] = new NodeMetadata(nodeName, nodeName, NodeKind.IMPLICIT);
+                        }
+                }
                 return List.of(nodes);
         }
 
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationCancelledResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationCancelledResult.java
new file mode 100644
index 00000000..fc06fd2e
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationCancelledResult.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.web.generator;
+
+import org.eclipse.xtext.web.server.IServiceResult;
+
+public record ModelGenerationCancelledResult() implements IServiceResult {
+}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationErrorResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationErrorResult.java
new file mode 100644
index 00000000..bedaeb35
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationErrorResult.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.web.generator;
+
+import java.util.UUID;
+
+public record ModelGenerationErrorResult(UUID uuid, String error) implements ModelGenerationResult {
+}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationManager.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationManager.java
new file mode 100644
index 00000000..b0a1912c
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationManager.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.web.generator;
+
+import org.eclipse.xtext.util.CancelIndicator;
+
+public class ModelGenerationManager {
+        private final Object lockObject = new Object();
+        private ModelGenerationWorker worker;
+        private boolean disposed;
+
+        boolean setActiveModelGenerationWorker(ModelGenerationWorker worker, CancelIndicator cancelIndicator) {
+                synchronized (lockObject) {
+                        cancel();
+                        if (disposed || cancelIndicator.isCanceled()) {
+                                return true;
+                        }
+                        this.worker = worker;
+                }
+                return false;
+        }
+
+        public void cancel() {
+                synchronized (lockObject) {
+                        if (worker != null) {
+                                worker.cancel();
+                                worker = null;
+                        }
+                }
+        }
+
+        public void dispose() {
+                synchronized (lockObject) {
+                        disposed = true;
+                        cancel();
+                }
+        }
+}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationResult.java
new file mode 100644
index 00000000..cf06f447
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationResult.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.web.generator;
+
+import org.eclipse.xtext.web.server.IServiceResult;
+
+import java.util.UUID;
+
+public sealed interface ModelGenerationResult extends IServiceResult permits ModelGenerationSuccessResult,
+                ModelGenerationErrorResult, ModelGenerationStatusResult {
+        UUID uuid();
+}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationService.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationService.java
new file mode 100644
index 00000000..5a60007f
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationService.java
@@ -0,0 +1,60 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.web.generator;
+
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import com.google.inject.Singleton;
+import org.eclipse.xtext.service.OperationCanceledManager;
+import org.eclipse.xtext.util.CancelIndicator;
+import org.eclipse.xtext.util.concurrent.CancelableUnitOfWork;
+import org.eclipse.xtext.web.server.model.IXtextWebDocument;
+import tools.refinery.language.web.semantics.SemanticsService;
+import tools.refinery.language.web.xtext.server.push.PushWebDocument;
+import tools.refinery.language.web.xtext.server.push.PushWebDocumentAccess;
+
+@Singleton
+public class ModelGenerationService {
+        public static final String SERVICE_NAME = "modelGeneration";
+        public static final String MODEL_GENERATION_EXECUTOR = "modelGeneration";
+        public static final String MODEL_GENERATION_TIMEOUT_EXECUTOR = "modelGenerationTimeout";
+
+        @Inject
+        private OperationCanceledManager operationCanceledManager;
+
+        @Inject
+        private Provider<ModelGenerationWorker> workerProvider;
+
+        private final long timeoutSec;
+
+        public ModelGenerationService() {
+                timeoutSec = SemanticsService.getTimeout("REFINERY_MODEL_GENERATION_TIMEOUT_SEC").orElse(600L);
+        }
+
+        public ModelGenerationStartedResult generateModel(PushWebDocumentAccess document){
+                return document.modify(new CancelableUnitOfWork<>() {
+                        @Override
+                        public ModelGenerationStartedResult exec(IXtextWebDocument state, CancelIndicator cancelIndicator) {
+                                var pushState = (PushWebDocument) state;
+                                var worker = workerProvider.get();
+                                worker.setState(pushState, timeoutSec);
+                                var manager = pushState.getModelGenerationManager();
+                                worker.start();
+                                boolean canceled = manager.setActiveModelGenerationWorker(worker, cancelIndicator);
+                                if (canceled) {
+                                        worker.cancel();
+                                        operationCanceledManager.throwOperationCanceledException();
+                                }
+                                return new ModelGenerationStartedResult(worker.getUuid());
+                        }
+                });
+        }
+
+        public ModelGenerationCancelledResult cancelModelGeneration(PushWebDocumentAccess document) {
+                document.cancelModelGeneration();
+                return new ModelGenerationCancelledResult();
+        }
+}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationStartedResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationStartedResult.java
new file mode 100644
index 00000000..8c0e73c7
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationStartedResult.java
@@ -0,0 +1,13 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.web.generator;
+
+import org.eclipse.xtext.web.server.IServiceResult;
+
+import java.util.UUID;
+
+public record ModelGenerationStartedResult(UUID uuid) implements IServiceResult {
+}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationStatusResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationStatusResult.java
new file mode 100644
index 00000000..a6589870
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationStatusResult.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.web.generator;
+
+import java.util.UUID;
+
+public record ModelGenerationStatusResult(UUID uuid, String status) implements ModelGenerationResult {
+}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationSuccessResult.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationSuccessResult.java
new file mode 100644
index 00000000..21be4e08
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationSuccessResult.java
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.web.generator;
+
+import com.google.gson.JsonObject;
+import tools.refinery.language.semantics.metadata.NodeMetadata;
+import tools.refinery.language.semantics.metadata.RelationMetadata;
+
+import java.util.List;
+import java.util.UUID;
+
+public record ModelGenerationSuccessResult(UUID uuid, List<NodeMetadata> nodes, List<RelationMetadata> relations,
+                                                                                   JsonObject partialInterpretation) implements ModelGenerationResult {
+}
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
new file mode 100644
index 00000000..1f430da6
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/generator/ModelGenerationWorker.java
@@ -0,0 +1,228 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.web.generator;
+
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.diagnostics.Severity;
+import org.eclipse.xtext.resource.IResourceFactory;
+import org.eclipse.xtext.resource.XtextResourceSet;
+import org.eclipse.xtext.service.OperationCanceledManager;
+import org.eclipse.xtext.util.LazyStringInputStream;
+import org.eclipse.xtext.validation.CheckMode;
+import org.eclipse.xtext.validation.IResourceValidator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.semantics.metadata.MetadataCreator;
+import tools.refinery.language.semantics.model.ModelInitializer;
+import tools.refinery.language.web.semantics.PartialInterpretation2Json;
+import tools.refinery.language.web.xtext.server.ThreadPoolExecutorServiceProvider;
+import tools.refinery.language.web.xtext.server.push.PushWebDocument;
+import tools.refinery.store.dse.propagation.PropagationAdapter;
+import tools.refinery.store.dse.strategy.BestFirstStoreManager;
+import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.ReasoningStoreAdapter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.statecoding.StateCoderAdapter;
+import tools.refinery.store.util.CancellationToken;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.*;
+
+public class ModelGenerationWorker implements Runnable {
+        private static final Logger LOG = LoggerFactory.getLogger(ModelGenerationWorker.class);
+
+        private final UUID uuid = UUID.randomUUID();
+
+        private PushWebDocument state;
+
+        private String text;
+
+        private volatile boolean timedOut;
+
+        private volatile boolean cancelled;
+
+        @Inject
+        private OperationCanceledManager operationCanceledManager;
+
+        @Inject
+        private Provider<XtextResourceSet> resourceSetProvider;
+
+        @Inject
+        private IResourceFactory resourceFactory;
+
+        @Inject
+        private IResourceValidator resourceValidator;
+
+        @Inject
+        private ModelInitializer initializer;
+
+        @Inject
+        private MetadataCreator metadataCreator;
+
+        @Inject
+        private PartialInterpretation2Json partialInterpretation2Json;
+
+        private final Object lockObject = new Object();
+
+        private ExecutorService executorService;
+
+        private ScheduledExecutorService scheduledExecutorService;
+
+        private long timeoutSec;
+
+        private Future<?> future;
+
+        private ScheduledFuture<?> timeoutFuture;
+
+        private final CancellationToken cancellationToken = () -> {
+                if (cancelled || Thread.interrupted()) {
+                        operationCanceledManager.throwOperationCanceledException();
+                }
+        };
+
+        @Inject
+        public void setExecutorServiceProvider(ThreadPoolExecutorServiceProvider provider) {
+                executorService = provider.get(ModelGenerationService.MODEL_GENERATION_EXECUTOR);
+                scheduledExecutorService = provider.getScheduled(ModelGenerationService.MODEL_GENERATION_TIMEOUT_EXECUTOR);
+        }
+
+        public void setState(PushWebDocument state, long timeoutSec) {
+                this.state = state;
+                this.timeoutSec = timeoutSec;
+                text = state.getText();
+        }
+
+        public UUID getUuid() {
+                return uuid;
+        }
+
+        public void start() {
+                synchronized (lockObject) {
+                        LOG.debug("Enqueueing model generation: {}", uuid);
+                        future = executorService.submit(this);
+                }
+        }
+
+        public void startTimeout() {
+                synchronized (lockObject) {
+                        LOG.debug("Starting model generation: {}", uuid);
+                        cancellationToken.checkCancelled();
+                        timeoutFuture = scheduledExecutorService.schedule(() -> cancel(true), timeoutSec, TimeUnit.SECONDS);
+                }
+        }
+
+        // We catch {@code Throwable} to handle {@code OperationCancelledError}, but we rethrow fatal JVM errors.
+        @SuppressWarnings("squid:S1181")
+        @Override
+        public void run() {
+                startTimeout();
+                notifyResult(new ModelGenerationStatusResult(uuid, "Initializing model generator"));
+                ModelGenerationResult result;
+                try {
+                        result = doRun();
+                } catch (Throwable e) {
+                        if (operationCanceledManager.isOperationCanceledException(e)) {
+                                var message = timedOut ? "Model generation timed out" : "Model generation cancelled";
+                                LOG.debug("{}: {}", message, uuid);
+                                notifyResult(new ModelGenerationErrorResult(uuid, message));
+                        } else if (e instanceof Error error) {
+                                // Make sure we don't try to recover from any fatal JVM errors.
+                                throw error;
+                        } else {
+                                LOG.debug("Model generation error", e);
+                                notifyResult(new ModelGenerationErrorResult(uuid, e.toString()));
+                        }
+                        return;
+                }
+                notifyResult(result);
+        }
+
+        private void notifyResult(ModelGenerationResult result) {
+                state.notifyPrecomputationListeners(ModelGenerationService.SERVICE_NAME, result);
+        }
+
+        public ModelGenerationResult doRun() throws IOException {
+                cancellationToken.checkCancelled();
+                var resourceSet = resourceSetProvider.get();
+                var uri = URI.createURI("__synthetic_" + uuid + ".problem");
+                var resource = resourceFactory.createResource(uri);
+                resourceSet.getResources().add(resource);
+                var inputStream = new LazyStringInputStream(text);
+                resource.load(inputStream, Map.of());
+                cancellationToken.checkCancelled();
+                var issues = resourceValidator.validate(resource, CheckMode.ALL, () -> cancelled || Thread.interrupted());
+                cancellationToken.checkCancelled();
+                for (var issue : issues) {
+                        if (issue.getSeverity() == Severity.ERROR) {
+                                return new ModelGenerationErrorResult(uuid, "Validation error: " + issue.getMessage());
+                        }
+                }
+                if (resource.getContents().isEmpty() || !(resource.getContents().get(0) instanceof Problem problem)) {
+                        return new ModelGenerationErrorResult(uuid, "Model generation problem not found");
+                }
+                cancellationToken.checkCancelled();
+                var storeBuilder = ModelStore.builder()
+                                .cancellationToken(cancellationToken)
+                                .with(ViatraModelQueryAdapter.builder())
+                                .with(PropagationAdapter.builder())
+                                .with(StateCoderAdapter.builder())
+                                .with(DesignSpaceExplorationAdapter.builder())
+                                .with(ReasoningAdapter.builder());
+                var modelSeed = initializer.createModel(problem, storeBuilder);
+                var store = storeBuilder.build();
+                cancellationToken.checkCancelled();
+                var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
+                var initialVersion = model.commit();
+                cancellationToken.checkCancelled();
+                notifyResult(new ModelGenerationStatusResult(uuid, "Generating model"));
+                var bestFirst = new BestFirstStoreManager(store, 1);
+                bestFirst.startExploration(initialVersion);
+                cancellationToken.checkCancelled();
+                var solutionStore = bestFirst.getSolutionStore();
+                if (solutionStore.getSolutions().isEmpty()) {
+                        return new ModelGenerationErrorResult(uuid, "Problem is unsatisfiable");
+                }
+                notifyResult(new ModelGenerationStatusResult(uuid, "Saving generated model"));
+                model.restore(solutionStore.getSolutions().get(0).version());
+                cancellationToken.checkCancelled();
+                metadataCreator.setInitializer(initializer);
+                var nodesMetadata = metadataCreator.getNodesMetadata(model.getAdapter(ReasoningAdapter.class).getNodeCount());
+                cancellationToken.checkCancelled();
+                var relationsMetadata = metadataCreator.getRelationsMetadata();
+                cancellationToken.checkCancelled();
+                var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(initializer, model,
+                                Concreteness.CANDIDATE, cancellationToken);
+                return new ModelGenerationSuccessResult(uuid, nodesMetadata, relationsMetadata, partialInterpretation);
+        }
+
+        public void cancel() {
+                cancel(false);
+        }
+
+        public void cancel(boolean timedOut) {
+                synchronized (lockObject) {
+                        LOG.trace("Cancelling model generation: {}", uuid);
+                        this.timedOut = timedOut;
+                        cancelled = true;
+                        if (future != null) {
+                                future.cancel(true);
+                                future = null;
+                        }
+                        if (timeoutFuture != null) {
+                                timeoutFuture.cancel(true);
+                                timeoutFuture = null;
+                        }
+                }
+        }
+}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/PartialInterpretation2Json.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/PartialInterpretation2Json.java
new file mode 100644
index 00000000..5d5da8fe
--- /dev/null
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/PartialInterpretation2Json.java
@@ -0,0 +1,81 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.web.semantics;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import tools.refinery.language.semantics.model.ModelInitializer;
+import tools.refinery.language.semantics.model.SemanticsUtils;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.util.CancellationToken;
+
+import java.util.TreeMap;
+
+@Singleton
+public class PartialInterpretation2Json {
+        @Inject
+        private SemanticsUtils semanticsUtils;
+
+        public JsonObject getPartialInterpretation(ModelInitializer initializer, Model model, Concreteness concreteness,
+                                                                                           CancellationToken cancellationToken) {
+                var adapter = model.getAdapter(ReasoningAdapter.class);
+                var json = new JsonObject();
+                for (var entry : initializer.getRelationTrace().entrySet()) {
+                        var relation = entry.getKey();
+                        var partialSymbol = entry.getValue();
+                        var tuples = getTuplesJson(adapter, concreteness, partialSymbol);
+                        var name = semanticsUtils.getName(relation).orElse(partialSymbol.name());
+                        json.add(name, tuples);
+                        cancellationToken.checkCancelled();
+                }
+                json.add("builtin::count", getCountJson(model));
+                return json;
+        }
+
+        private static JsonArray getTuplesJson(ReasoningAdapter adapter, Concreteness concreteness,
+                                                                                   PartialRelation partialSymbol) {
+                var interpretation = adapter.getPartialInterpretation(concreteness, partialSymbol);
+                var cursor = interpretation.getAll();
+                return getTuplesJson(cursor);
+        }
+
+        private static JsonArray getTuplesJson(Cursor<Tuple, ?> cursor) {
+                var map = new TreeMap<Tuple, Object>();
+                while (cursor.move()) {
+                        map.put(cursor.getKey(), cursor.getValue());
+                }
+                var tuples = new JsonArray();
+                for (var entry : map.entrySet()) {
+                        tuples.add(toArray(entry.getKey(), entry.getValue()));
+                }
+                return tuples;
+        }
+
+        private static JsonArray toArray(Tuple tuple, Object value) {
+                int arity = tuple.getSize();
+                var json = new JsonArray(arity + 1);
+                for (int i = 0; i < arity; i++) {
+                        json.add(tuple.get(i));
+                }
+                json.add(value.toString());
+                return json;
+        }
+
+        private static JsonArray getCountJson(Model model) {
+                var interpretation = model.getInterpretation(MultiObjectTranslator.COUNT_STORAGE);
+                var cursor = interpretation.getAll();
+                return getTuplesJson(cursor);
+
+        }
+}
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java
index 26924f0a..331ef84b 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java
@@ -54,7 +54,7 @@ public class SemanticsService extends AbstractCachedService<SemanticsResult> {
                 warmupTimeoutMs = getTimeout("REFINERY_SEMANTICS_WARMUP_TIMEOUT_MS").orElse(timeoutMs * 2);
         }
 
-        private static Optional<Long> getTimeout(String name) {
+        public static Optional<Long> getTimeout(String name) {
                 return Optional.ofNullable(System.getenv(name)).map(Long::parseUnsignedLong);
         }
 
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 33b1c4fb..512c2778 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
@@ -5,8 +5,6 @@
  */
 package tools.refinery.language.web.semantics;
 
-import com.google.gson.JsonArray;
-import com.google.gson.JsonObject;
 import com.google.inject.Inject;
 import org.eclipse.emf.common.util.Diagnostic;
 import org.eclipse.emf.ecore.EObject;
@@ -20,31 +18,24 @@ import org.eclipse.xtext.web.server.validation.ValidationResult;
 import tools.refinery.language.model.problem.Problem;
 import tools.refinery.language.semantics.metadata.MetadataCreator;
 import tools.refinery.language.semantics.model.ModelInitializer;
-import tools.refinery.language.semantics.model.SemanticsUtils;
 import tools.refinery.language.semantics.model.TracedException;
 import tools.refinery.store.dse.propagation.PropagationAdapter;
-import tools.refinery.store.map.Cursor;
-import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
 import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.ReasoningStoreAdapter;
 import tools.refinery.store.reasoning.literal.Concreteness;
-import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.TranslationException;
-import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
-import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.util.CancellationToken;
 
 import java.util.ArrayList;
-import java.util.TreeMap;
 import java.util.concurrent.Callable;
 
 class SemanticsWorker implements Callable<SemanticsResult> {
         private static final String DIAGNOSTIC_ID = "tools.refinery.language.semantics.SemanticError";
 
         @Inject
-        private SemanticsUtils semanticsUtils;
+        private PartialInterpretation2Json partialInterpretation2Json;
 
         @Inject
         private OperationCanceledManager operationCanceledManager;
@@ -93,7 +84,8 @@ class SemanticsWorker implements Callable<SemanticsResult> {
                         cancellationToken.checkCancelled();
                         var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
                         cancellationToken.checkCancelled();
-                        var partialInterpretation = getPartialInterpretation(initializer, model);
+                        var partialInterpretation = partialInterpretation2Json.getPartialInterpretation(initializer, model,
+                                        Concreteness.PARTIAL, cancellationToken);
 
                         return new SemanticsSuccessResult(nodesMetadata, relationsMetadata, partialInterpretation);
                 } catch (TracedException e) {
@@ -104,55 +96,6 @@ class SemanticsWorker implements Callable<SemanticsResult> {
                 }
         }
 
-        private JsonObject getPartialInterpretation(ModelInitializer initializer, Model model) {
-                var adapter = model.getAdapter(ReasoningAdapter.class);
-                var json = new JsonObject();
-                for (var entry : initializer.getRelationTrace().entrySet()) {
-                        var relation = entry.getKey();
-                        var partialSymbol = entry.getValue();
-                        var tuples = getTuplesJson(adapter, partialSymbol);
-                        var name = semanticsUtils.getName(relation).orElse(partialSymbol.name());
-                        json.add(name, tuples);
-                        cancellationToken.checkCancelled();
-                }
-                json.add("builtin::count", getCountJson(model));
-                return json;
-        }
-
-        private static JsonArray getTuplesJson(ReasoningAdapter adapter, PartialRelation partialSymbol) {
-                var interpretation = adapter.getPartialInterpretation(Concreteness.PARTIAL, partialSymbol);
-                var cursor = interpretation.getAll();
-                return getTuplesJson(cursor);
-        }
-
-        private static JsonArray getTuplesJson(Cursor<Tuple, ?> cursor) {
-                var map = new TreeMap<Tuple, Object>();
-                while (cursor.move()) {
-                        map.put(cursor.getKey(), cursor.getValue());
-                }
-                var tuples = new JsonArray();
-                for (var entry : map.entrySet()) {
-                        tuples.add(toArray(entry.getKey(), entry.getValue()));
-                }
-                return tuples;
-        }
-
-        private static JsonArray toArray(Tuple tuple, Object value) {
-                int arity = tuple.getSize();
-                var json = new JsonArray(arity + 1);
-                for (int i = 0; i < arity; i++) {
-                        json.add(tuple.get(i));
-                }
-                json.add(value.toString());
-                return json;
-        }
-
-        private static JsonArray getCountJson(Model model) {
-                var interpretation = model.getInterpretation(MultiObjectTranslator.COUNT_STORAGE);
-                var cursor = interpretation.getAll();
-                return getTuplesJson(cursor);
-        }
-
         private SemanticsResult getTracedErrorResult(EObject sourceElement, String message) {
                 if (sourceElement == null || !problem.eResource().equals(sourceElement.eResource())) {
                         return new SemanticsInternalErrorResult(message);
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/ThreadPoolExecutorServiceProvider.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/ThreadPoolExecutorServiceProvider.java
index ba26ff58..625909b9 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/ThreadPoolExecutorServiceProvider.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/ThreadPoolExecutorServiceProvider.java
@@ -13,9 +13,13 @@ import tools.refinery.language.web.semantics.SemanticsService;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -24,6 +28,8 @@ public class ThreadPoolExecutorServiceProvider extends ExecutorServiceProvider {
         private static final String DOCUMENT_LOCK_EXECUTOR;
         private static final AtomicInteger POOL_ID = new AtomicInteger(1);
 
+        private final Map<String, ScheduledExecutorService> scheduledInstanceCache =
+                        Collections.synchronizedMap(new HashMap<>());
         private final int executorThreadCount;
         private final int lockExecutorThreadCount;
         private final int semanticsExecutorThreadCount;
@@ -58,11 +64,15 @@ public class ThreadPoolExecutorServiceProvider extends ExecutorServiceProvider {
                 return Optional.ofNullable(System.getenv(name)).map(Integer::parseUnsignedInt);
         }
 
+        public ScheduledExecutorService getScheduled(String key) {
+                return scheduledInstanceCache.computeIfAbsent(key, this::createScheduledInstance);
+        }
+
         @Override
         protected ExecutorService createInstance(String key) {
                 String name = "xtext-" + POOL_ID.getAndIncrement();
                 if (key != null) {
-                        name = name + key + "-";
+                        name = name + "-" + key;
                 }
                 var threadFactory = new Factory(name, 5);
                 int size = getSize(key);
@@ -72,6 +82,15 @@ public class ThreadPoolExecutorServiceProvider extends ExecutorServiceProvider {
                 return Executors.newFixedThreadPool(size, threadFactory);
         }
 
+        protected ScheduledExecutorService createScheduledInstance(String key) {
+                String name = "xtext-scheduled-" + POOL_ID.getAndIncrement();
+                if (key != null) {
+                        name = name + "-" + key;
+                }
+                var threadFactory = new Factory(name, 5);
+                return Executors.newScheduledThreadPool(1, threadFactory);
+        }
+
         private int getSize(String key) {
                 if (SemanticsService.SEMANTICS_EXECUTOR.equals(key)) {
                         return semanticsExecutorThreadCount;
@@ -82,6 +101,17 @@ public class ThreadPoolExecutorServiceProvider extends ExecutorServiceProvider {
                 }
         }
 
+        @Override
+        public void dispose() {
+                super.dispose();
+                synchronized (scheduledInstanceCache) {
+                        for (var instance : scheduledInstanceCache.values()) {
+                                instance.shutdown();
+                        }
+                        scheduledInstanceCache.clear();
+                }
+        }
+
         private static class Factory implements ThreadFactory {
                 // We have to explicitly store the {@link ThreadGroup} to create a {@link ThreadFactory}.
                 @SuppressWarnings("squid:S3014")
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/TransactionExecutor.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/TransactionExecutor.java
index 74456604..a3792bac 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/TransactionExecutor.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/TransactionExecutor.java
@@ -187,7 +187,7 @@ public class TransactionExecutor implements IDisposable, PrecomputationListener
                         var document = subscription.get();
                         if (document != null) {
                                 document.removePrecomputationListener(this);
-                                document.cancelBackgroundWork();
+                                document.dispose();
                         }
                 }
         }
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushServiceDispatcher.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushServiceDispatcher.java
index d4a8c433..a04ee226 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushServiceDispatcher.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushServiceDispatcher.java
@@ -5,14 +5,17 @@
  */
 package tools.refinery.language.web.xtext.server.push;
 
+import com.google.common.base.Optional;
 import com.google.inject.Inject;
 import org.eclipse.xtext.web.server.IServiceContext;
+import org.eclipse.xtext.web.server.InvalidRequestException;
 import org.eclipse.xtext.web.server.XtextServiceDispatcher;
 import org.eclipse.xtext.web.server.model.PrecomputedServiceRegistry;
 import org.eclipse.xtext.web.server.model.XtextWebDocument;
 
 import com.google.inject.Singleton;
 
+import tools.refinery.language.web.generator.ModelGenerationService;
 import tools.refinery.language.web.semantics.SemanticsService;
 import tools.refinery.language.web.xtext.server.SubscribingServiceContext;
 
@@ -21,6 +24,9 @@ public class PushServiceDispatcher extends XtextServiceDispatcher {
         @Inject
         private SemanticsService semanticsService;
 
+        @Inject
+        private ModelGenerationService modelGenerationService;
+
         @Override
         @Inject
         protected void registerPreComputedServices(PrecomputedServiceRegistry registry) {
@@ -37,4 +43,37 @@ public class PushServiceDispatcher extends XtextServiceDispatcher {
                 }
                 return document;
         }
+
+        @Override
+        protected ServiceDescriptor createServiceDescriptor(String serviceType, IServiceContext context) {
+                if (ModelGenerationService.SERVICE_NAME.equals(serviceType)) {
+                        return getModelGenerationService(context);
+                }
+                return super.createServiceDescriptor(serviceType, context);
+        }
+
+        protected ServiceDescriptor getModelGenerationService(IServiceContext context) throws InvalidRequestException {
+                var document = (PushWebDocumentAccess) getDocumentAccess(context);
+                // Using legacy Guava methods because of the Xtext dependency.
+                @SuppressWarnings({"Guava", "squid:S4738"})
+                boolean start = getBoolean(context, "start", Optional.of(false));
+                @SuppressWarnings({"Guava", "squid:S4738"})
+                boolean cancel = getBoolean(context, "cancel", Optional.of(false));
+                if (!start && !cancel) {
+                        throw new InvalidRequestException("Either start of cancel must be specified");
+                }
+                var descriptor = new ServiceDescriptor();
+                descriptor.setService(() -> {
+                        try {
+                                if (start) {
+                                        return modelGenerationService.generateModel(document);
+                                } else {
+                                        return modelGenerationService.cancelModelGeneration(document);
+                                }
+                        } catch (RuntimeException e) {
+                                return handleError(descriptor, e);
+                        }
+                });
+                return descriptor;
+        }
 }
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocument.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocument.java
index 2d43fb26..ca97147a 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocument.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocument.java
@@ -13,19 +13,18 @@ import org.eclipse.xtext.web.server.model.DocumentSynchronizer;
 import org.eclipse.xtext.web.server.model.XtextWebDocument;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import tools.refinery.language.web.generator.ModelGenerationManager;
 import tools.refinery.language.web.xtext.server.ResponseHandlerException;
 
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 public class PushWebDocument extends XtextWebDocument {
         private static final Logger LOG = LoggerFactory.getLogger(PushWebDocument.class);
 
         private final List<PrecomputationListener> precomputationListeners = new ArrayList<>();
 
-        private final Map<Class<?>, IServiceResult> precomputedServices = new HashMap<>();
+        private final ModelGenerationManager modelGenerationManager = new ModelGenerationManager();
 
         private final DocumentSynchronizer synchronizer;
 
@@ -34,6 +33,10 @@ public class PushWebDocument extends XtextWebDocument {
                 this.synchronizer = synchronizer;
         }
 
+        public ModelGenerationManager getModelGenerationManager() {
+                return modelGenerationManager;
+        }
+
         public void addPrecomputationListener(PrecomputationListener listener) {
                 synchronized (precomputationListeners) {
                         if (precomputationListeners.contains(listener)) {
@@ -52,15 +55,13 @@ public class PushWebDocument extends XtextWebDocument {
 
         public <T extends IServiceResult> void precomputeServiceResult(AbstractCachedService<T> service, String serviceName,
                         CancelIndicator cancelIndicator, boolean logCacheMiss) {
-                var serviceClass = service.getClass();
                 var result = getCachedServiceResult(service, cancelIndicator, logCacheMiss);
-                precomputedServices.put(serviceClass, result);
                 if (result != null) {
                         notifyPrecomputationListeners(serviceName, result);
                 }
         }
 
-        private <T extends IServiceResult> void notifyPrecomputationListeners(String serviceName, T result) {
+        public <T extends IServiceResult> void notifyPrecomputationListeners(String serviceName, T result) {
                 var resourceId = getResourceId();
                 if (resourceId == null) {
                         return;
@@ -86,7 +87,12 @@ public class PushWebDocument extends XtextWebDocument {
                 }
         }
 
-        public void cancelBackgroundWork() {
+        public void cancelModelGeneration() {
+                modelGenerationManager.cancel();
+        }
+
+        public void dispose() {
                 synchronizer.setCanceled(true);
+                modelGenerationManager.dispose();
         }
 }
diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocumentAccess.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocumentAccess.java
index c72e8e67..1e68b244 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocumentAccess.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocumentAccess.java
@@ -74,4 +74,8 @@ public class PushWebDocumentAccess extends XtextWebDocumentAccess {
                 }
                 throw new IllegalArgumentException("Unknown precomputed service: " + service);
         }
+
+        public void cancelModelGeneration() {
+                pushDocument.cancelModelGeneration();
+        }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java
index 1dda7ac1..7f0ef8b4 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java
@@ -47,6 +47,8 @@ public interface ReasoningAdapter extends ModelAdapter {
 
         boolean cleanup(int nodeToDelete);
 
+        int getNodeCount();
+
         static ReasoningBuilder builder() {
                 return new ReasoningBuilderImpl();
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
index f91fdd07..bd16bdfa 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
@@ -204,4 +204,10 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
                 }
                 return true;
         }
+
+        @Override
+        public int getNodeCount() {
+                Integer nodeCount = nodeCountInterpretation.get(Tuple.of());
+                return nodeCount == null ? 0 : nodeCount;
+        }
 }