diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index d53d47ac9..3a6699865 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -12,6 +12,7 @@ jobs:
   build_dev_docs:
     name: Build developer docs
     runs-on: ubuntu-latest
+    needs: build_instances_mockup
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -58,6 +59,12 @@ jobs:
             echo "🔨 Dev docs built and cached"
           fi
 
+      - name: Include instances mockup in developer docs
+        uses: actions/download-artifact@v4
+        with:
+          name: instances-mockup
+          path: dev-docs/output/instances-mockup
+
       - name: Upload developer docs
         uses: actions/upload-artifact@v4
         with:
@@ -168,6 +175,70 @@ jobs:
           name: frontend_docs
           path: packages/frontend/docs
 
+  build_instances_mockup:
+    name: Build instances mockup
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          # Need full history for `git log` for cache key
+          fetch-depth: 0
+
+      - name: Compute cache key
+        id: cache-key
+        run: |
+          hash=$(git log -1 --format="%H" -- packages/document-methods packages/catlog-wasm packages/document-types packages/ui-components tools/vite-plugin-monorepo-dedupe pnpm-lock.yaml pnpm-workspace.yaml)
+          echo "git-hash=${hash}" >> $GITHUB_OUTPUT
+          echo "Instances mockup hash: ${hash}"
+
+      - name: Cache instances mockup build
+        id: cache-instances-mockup
+        uses: actions/cache@v4
+        with:
+          path: packages/document-methods/demo/dist
+          key: instances-mockup-${{ steps.cache-key.outputs.git-hash }}
+
+      - name: Setup pnpm
+        if: steps.cache-instances-mockup.outputs.cache-hit != 'true'
+        uses: pnpm/action-setup@v4
+
+      - name: Setup NodeJS
+        if: steps.cache-instances-mockup.outputs.cache-hit != 'true'
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: "pnpm"
+
+      - name: Install Rust toolchain from file
+        if: steps.cache-instances-mockup.outputs.cache-hit != 'true'
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          # Don't override flags in cargo config files.
+          rustflags: ""
+
+      - name: Build instances mockup
+        if: steps.cache-instances-mockup.outputs.cache-hit != 'true'
+        run: |
+          pnpm install
+          pnpm --filter ./packages/document-methods run build:wasm
+          pnpm --filter ./packages/document-methods exec wasm-pack build ../catlog-wasm --target browser -d ./dist/pkg-browser --debug
+          pnpm --filter ./packages/document-methods run demo:build
+
+      - name: Report cache status
+        run: |
+          if [ "${{ steps.cache-instances-mockup.outputs.cache-hit }}" = "true" ]; then
+            echo "✅ Instances mockup restored from cache"
+          else
+            echo "🔨 Instances mockup built and cached"
+          fi
+
+      - name: Upload instances mockup
+        uses: actions/upload-artifact@v4
+        with:
+          name: instances-mockup
+          path: packages/document-methods/demo/dist
+
   build_rust_docs:
     name: Build Rust docs
     runs-on: ubuntu-latest
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 89c28aef4..7408bddba 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -86,6 +86,7 @@ jobs:
           mv rust_docs site/dev/rust
           mv frontend_docs site/dev/frontend
           mv ui-components site/dev/ui-components
+          mv instances-mockup site/dev/instances-mockup
           mv math-docs site/math
           mv rfc site/rfc
           echo '/dev/rust /dev/rust/catlog' >> site/_redirects
diff --git a/packages/document-methods/.agents/skills/catcolab-demo/SKILL.md b/packages/document-methods/.agents/skills/catcolab-demo/SKILL.md
new file mode 100644
index 000000000..b959a7002
--- /dev/null
+++ b/packages/document-methods/.agents/skills/catcolab-demo/SKILL.md
@@ -0,0 +1,216 @@
+---
+name: catcolab-instances-demo-script
+description: Drive the CatColab instances demo by running its script via the WebMCP `run_script` tool over Chrome DevTools. Use when you need to programmatically build or edit the demo's schema and instance (entities, mappings, attributes, and rows) in a running browser.
+---
+
+# CatColab instances demo: scripting via WebMCP + Chrome DevTools
+
+The instances demo (`pnpm demo` in `packages/document-methods`) exposes a single
+WebMCP tool, `run_script`, on `document.modelContext`. It writes JavaScript into
+the demo's script editor, opens the script pane, and **runs it**, returning the
+script's return value (or thrown error). This skill covers driving that tool
+through the Chrome DevTools MCP and what the script may contain.
+
+## Prerequisites
+
+- The demo dev server is running (default `http://localhost:5173/`). It is
+  usually already running; check first.
+- A Chrome DevTools MCP connection to that page.
+
+The page installs the WebMCP polyfill at startup, so `document.modelContext`
+exists app-wide and `run_script` is registered even when the script pane is
+closed.
+
+## Using `run_script` over Chrome DevTools
+
+Chrome DevTools MCP has no direct WebMCP bridge, so call the tool through
+`evaluate_script`, which runs in the page and can reach `document.modelContext`.
+
+1. Navigate to the demo (only if not already there):
+
+    `navigate_page` -> `http://localhost:5173/`
+
+2. (Optional) List tools to confirm registration:
+
+    ```js
+    () =>
+        document.modelContext
+            .getTools()
+            .then((ts) => ts.map((t) => ({ name: t.name, inputSchema: t.inputSchema })));
+    ```
+
+    Expect a `run_script` tool whose `inputSchema` (returned as a JSON string)
+    describes a single required `script` string property.
+
+3. Execute it. `executeTool` takes a tool descriptor from `getTools()` and a
+   **JSON string** of arguments, and returns a JSON string:
+
+    ```js
+    async () => {
+        const mc = document.modelContext;
+        const tool = (await mc.getTools()).find((t) => t.name === "run_script");
+        return mc.executeTool(
+            tool,
+            JSON.stringify({
+                script:
+                    `const p = schema.add(Entity, { label: "Person" });\n` +
+                    `schema.add(Attr, { label: "name", from: p, to: attrTypes.String });\n`,
+            }),
+        );
+    };
+    ```
+
+    On success it returns
+    `{"content":[{"type":"text","text":"Script ran successfully."}]}` (with the
+    returned value appended, if the script returned one), and the script pane
+    opens with the source shown. If the script throws, the result is an error
+    with the message `Script threw: …`.
+
+4. Verify (optional). There are two `<textarea>`s on the page (one belongs to
+   the instance grid); the script editor is the one holding your source:
+
+    ```js
+    () => [...document.querySelectorAll("textarea")].map((t) => t.value);
+    ```
+
+    The source is also persisted to `localStorage["catcolab-instances-demo:script"]`.
+
+Notes:
+
+- `run_script` executes the script immediately: the schema and instance update
+  as soon as the tool returns. No human Run press is needed.
+- Calling it again replaces the editor contents and runs the new script.
+
+## What can go in the script
+
+The script body runs inside an `async` function (so you may use top-level
+`await`) with these names in scope:
+
+| Name        | What it is                                                        |
+| ----------- | ----------------------------------------------------------------- |
+| `schema`    | The schema notebook (a `Notebook` over `SimpleSchema`).           |
+| `instance`  | The instance (a database of `schema`).                            |
+| `doc`       | The demo document wrapper (`{ schema, instance, attrTypes, … }`). |
+| `attrTypes` | `{ String, Number }` — the two fixed attribute-type cells.        |
+| `Entity`    | Object def: an entity (a table).                                  |
+| `Mapping`   | Morphism def: a foreign key `Entity -> Entity`.                   |
+| `Attr`      | Morphism def: an attribute `Entity -> AttrType`.                  |
+| `AttrType`  | Object def for attribute types (only `String`/`Number` are used). |
+
+Every mutation goes through the same document API the UI uses, so the notebook,
+instance tables, history, and persistence all update as with point-and-click
+edits. The script has full access to the page (it is a demo affordance, not a
+sandbox).
+
+> **Always reset first.** Scripts are additive and the schema/instance persist
+> across runs (via `localStorage`), so building on top of whatever is already
+> there produces duplicate cells and rows. Unless the human explicitly asks to
+> extend the current state, begin every schema-building script with the reset
+> block from [Resetting the schema](#resetting-the-schema), which deletes every
+> cell except the two fixed `AttrType` cells.
+
+### Schema API (`schema`)
+
+```js
+// Add cells. Each returns a live cell handle.
+const person = schema.add(Entity, { label: "Person" });
+const company = schema.add(Entity, { label: "Company" });
+const name = schema.add(Attr, { label: "name", from: person, to: attrTypes.String });
+const age = schema.add(Attr, { label: "age", from: person, to: attrTypes.Number });
+const employer = schema.add(Mapping, { label: "employer", from: person, to: company });
+
+// List cells of a kind.
+schema.cellsOf(Entity); // -> entity cells
+schema.cellsOf(Attr); // -> attribute cells
+schema.cellsOf(Mapping); // -> mapping cells
+
+// Edit / remove a cell.
+person.update({ label: "Human" });
+employer.update({ to: company }); // change a mapping's codomain
+age.delete(); // remove a cell
+```
+
+Attribute codomains must be `attrTypes.String` or `attrTypes.Number`. A
+`Mapping`'s `from`/`to` are `Entity` cells; an `Attr`'s `from` is an `Entity`
+cell and `to` is an `attrTypes` cell.
+
+#### Resetting the schema
+
+To start from a clean schema, delete every cell **except** the `AttrType` cells.
+The fixed `String`/`Number` attribute types are ordinary `AttrType` cells, so
+skipping them keeps `doc.attrTypes` pointing at the live cells the UI, instance
+editor, and later scripts already reference:
+
+```js
+const attrTypeIds = new Set(schema.cellsOf(AttrType).map((c) => c.id));
+for (const c of schema.cells()) {
+    if (!attrTypeIds.has(c.id)) c.delete();
+}
+```
+
+After this, `attrTypes.String` / `attrTypes.Number` still point at the surviving
+attribute-type cells, so schema-building continues as normal.
+
+### Instance API (`instance`)
+
+```js
+// Add rows. Inline args name the entity's outgoing attributes and mappings.
+const acme = instance.add(company, {});
+const fred = instance.add(person, { name: "Fred", employer: acme });
+
+// List rows.
+instance.rows(); // all rows
+instance.rowsOf(person); // rows of one entity
+
+// Validate against the schema (async).
+const result = await instance.validate(); // { tag: "Valid" | "Invalid" | "Illformed", ... }
+```
+
+### Row API (a `Row` from `add` / `rows()`)
+
+```js
+fred.id; // stable row id (use as a mapping target)
+fred.entity; // the schema entity this row is a record of
+fred.get(name); // value for a morphism, keyed by its UUID (collision-free)
+fred.set(name, "Freddy"); // set an attribute literal, or a mapping's target Row
+fred.set(employer, acme); // point a foreign key at another row
+fred.set(name, undefined); // clear a value
+fred.values; // { [morphismName]: value }  (names may collide; last wins)
+fred.valuesById; // { [morphismUUID]: value }  (collision-free)
+fred.delete(); // delete this row
+```
+
+- A mapping value is the **target `Row`**; an attribute value is a **literal**
+  (`string` for `String`, `number` for `Number`).
+- Prefer `get(morphism)` / `valuesById` over `values` when a schema may have
+  two morphisms sharing a name.
+- Deleting a row leaves foreign keys pointing at it dangling; they show as
+  invalid on the next `validate()`.
+
+### Complete example
+
+Build a small schema and populate an instance in one script. Note the reset at
+the top — always start from a clean slate unless asked to extend existing state:
+
+```js
+// Reset: delete every cell except the two fixed attribute types.
+const attrTypeIds = new Set(schema.cellsOf(AttrType).map((c) => c.id));
+for (const c of schema.cells()) {
+    if (!attrTypeIds.has(c.id)) c.delete();
+}
+
+const person = schema.add(Entity, { label: "Person" });
+const company = schema.add(Entity, { label: "Company" });
+schema.add(Attr, { label: "name", from: person, to: attrTypes.String });
+schema.add(Mapping, { label: "employer", from: person, to: company });
+
+const acme = instance.add(company, {});
+instance.add(person, { name: "Fred", employer: acme });
+instance.add(person, { name: "Wilma", employer: acme });
+
+const result = await instance.validate();
+result.tag; // the async function's return value is shown in the status line
+```
+
+The script's return value (or a thrown error) is returned by `run_script` and
+also displayed under the editor.
diff --git a/packages/document-methods/.gitignore b/packages/document-methods/.gitignore
new file mode 100644
index 000000000..c73939bcf
--- /dev/null
+++ b/packages/document-methods/.gitignore
@@ -0,0 +1,2 @@
+.lts/
+demo/dist
diff --git a/packages/document-methods/demo/index.html b/packages/document-methods/demo/index.html
new file mode 100644
index 000000000..12877be39
--- /dev/null
+++ b/packages/document-methods/demo/index.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>CatColab Instances Demo</title>
+    </head>
+    <body>
+        <div id="root"></div>
+        <script type="module" src="/src/main.tsx"></script>
+    </body>
+</html>
diff --git a/packages/document-methods/demo/src/App.module.css b/packages/document-methods/demo/src/App.module.css
new file mode 100644
index 000000000..87bfcb263
--- /dev/null
+++ b/packages/document-methods/demo/src/App.module.css
@@ -0,0 +1,73 @@
+.app {
+    display: flex;
+    flex-direction: column;
+    height: 100vh;
+    overflow: hidden;
+}
+
+/* Floating, always-on-top controls in the bottom-right corner of the app:
+   the app-wide script toggle and the "Clear all data" reset. */
+.floatingControls {
+    position: fixed;
+    right: 1rem;
+    bottom: 1rem;
+    z-index: 20;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.4rem;
+    border: 1px solid var(--color-gray-300);
+    border-radius: 8px;
+    background: var(--color-background);
+}
+
+.resetButton {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 4px 10px;
+    font-size: 0.8rem;
+    border: 1px solid var(--color-button-utility-border);
+    border-radius: 6px;
+    background: var(--color-button-utility-bg);
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.resetButton:hover {
+    background: var(--color-icon-button-danger-hover);
+    border-color: var(--color-icon-button-danger-hover);
+    color: var(--color-icon-button-danger-text);
+}
+
+.split {
+    display: grid;
+    grid-template-columns: minmax(320px, 40%) 1fr;
+    flex: 1;
+    min-height: 0;
+}
+
+.storageProblemDialog {
+    max-width: 32rem;
+    padding-top: 0.5rem;
+}
+
+.storageProblemDetail {
+    padding: 0.75rem;
+    border: 1px solid var(--color-warning-border, #b7791f);
+    border-radius: 6px;
+    background: var(--color-warning-bg, #fffaf0);
+    color: var(--color-warning-text, #744210);
+}
+
+.storageProblemActions {
+    display: flex;
+    justify-content: flex-end;
+    gap: 0.5rem;
+    margin-top: 1rem;
+}
+
+.loading {
+    padding: 2rem;
+    color: var(--muted);
+}
diff --git a/packages/document-methods/demo/src/App.tsx b/packages/document-methods/demo/src/App.tsx
new file mode 100644
index 000000000..2ef230271
--- /dev/null
+++ b/packages/document-methods/demo/src/App.tsx
@@ -0,0 +1,241 @@
+import {
+    createEffect,
+    createMemo,
+    createResource,
+    createSignal,
+    onCleanup,
+    onMount,
+    Show,
+} from "solid-js";
+
+import { Button, Dialog } from "catcolab-ui-components";
+import { createDemoDocument, type DemoDocument } from "./document";
+import { InstanceEditor } from "./InstanceEditor";
+import { SchemaEditor } from "./SchemaEditor";
+import { demoScript, formatRunValue, runScript } from "./script-scopes";
+import { ScriptSidebar } from "./ScriptSidebar";
+import { ScriptToggle } from "./ScriptToggle";
+
+import styles from "./App.module.css";
+
+/** Which panel currently owns keyboard focus, so only its shortcuts fire. */
+export type ActivePanel = "schema" | "instance";
+
+/**
+ * The instances demo: a schema editor on the left and a live, editable
+ * spreadsheet instance of that schema on the right, with a single script pane
+ * (toggled from the top bar) docked along the bottom that can edit both sides.
+ */
+export function App() {
+    const [doc] = createResource(createDemoDocument);
+
+    // Exactly one panel is "active" at a time: the last one the user focused or
+    // clicked into. Its undo/redo shortcuts fire; the other's do not, matching
+    // the frontend's per-pane behaviour. Starts on the schema panel.
+    const [activePanel, setActivePanel] = createSignal<ActivePanel>("schema");
+
+    // The single script pane spans the whole app and edits both sides, so its
+    // open state lives here rather than in either editor.
+    const [scriptOpen, setScriptOpen] = createSignal(false);
+
+    return (
+        <div class={styles.app}>
+            <Show when={doc()} fallback={<div class={styles.loading}>Loading…</div>}>
+                {(loaded) => (
+                    <Loaded
+                        doc={loaded()}
+                        activePanel={activePanel}
+                        setActivePanel={setActivePanel}
+                        scriptOpen={scriptOpen}
+                        setScriptOpen={setScriptOpen}
+                    />
+                )}
+            </Show>
+        </div>
+    );
+}
+
+/**
+ * The demo once its document has loaded. The script source lives here — above
+ * both the (toggleable) {@link ScriptSidebar} and the always-mounted WebMCP tool
+ * — so the tool can author a script whether or not the pane is currently open,
+ * and the editor renders that same state when opened.
+ */
+function Loaded(props: {
+    doc: DemoDocument;
+    activePanel: () => ActivePanel;
+    setActivePanel: (panel: ActivePanel) => void;
+    scriptOpen: () => boolean;
+    setScriptOpen: (open: boolean) => void;
+}) {
+    // The demo's single script config: the merged scope, starter script, and the
+    // localStorage key its source is persisted under.
+    const script = createMemo(() => demoScript(props.doc));
+    const [scriptStorageProblem, setScriptStorageProblem] = createSignal<string>();
+    const storageProblem = createMemo(() =>
+        [props.doc.storageProblem(), scriptStorageProblem()].filter(Boolean).join(" "),
+    );
+    const [storageDialogOpen, setStorageDialogOpen] = createSignal(false);
+    createEffect(() => {
+        if (storageProblem()) {
+            setStorageDialogOpen(true);
+        }
+    });
+
+    // The editor source, owned here and persisted on every change, so both the
+    // editor and the `set_script` WebMCP tool write to the same state.
+    const [source, setSource] = createSignal(
+        loadScriptSource(script().storageKey, script().defaultScript),
+    );
+    const setScript = (value: string) => {
+        setSource(value);
+        try {
+            localStorage.setItem(script().storageKey, value);
+        } catch (error) {
+            setScriptStorageProblem(storageProblemMessage("save the script to", error));
+        }
+    };
+
+    function loadScriptSource(storageKey: string, defaultScript: string) {
+        try {
+            return localStorage.getItem(storageKey) ?? defaultScript;
+        } catch (error) {
+            setScriptStorageProblem(storageProblemMessage("read the script from", error));
+            return defaultScript;
+        }
+    }
+
+    // Register the "run the script" WebMCP tool. It is mounted for the whole
+    // session (not tied to the pane's open state), so an agent driving
+    // `document.modelContext` can author and run a script at any time; running
+    // one also opens the pane so the result is visible. The script is placed in
+    // the editor *and* executed, and its return value (or thrown error) is
+    // reported back to the caller.
+    onMount(() => {
+        const modelContext = document.modelContext;
+        if (!modelContext) {
+            return;
+        }
+        const controller = new AbortController();
+        modelContext.registerTool(
+            {
+                name: "run_script",
+                description:
+                    "Replace the contents of the demo's script editor with the given " +
+                    "JavaScript source, open the script pane, and run it. The script's " +
+                    "scope exposes `schema`, `instance`, `doc`, `attrTypes`, and the " +
+                    "simple-schema generator defs `Entity`, `Mapping`, `Attr`, and " +
+                    "`AttrType`, so it can read and mutate both the schema and its " +
+                    "instance. The script's return value (or thrown error) is returned.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        script: {
+                            type: "string",
+                            description: "The JavaScript source to place in the editor and run.",
+                        },
+                    },
+                    required: ["script"],
+                    additionalProperties: false,
+                },
+                annotations: { title: "Run script" },
+                async execute(args) {
+                    const value = args.script;
+                    if (typeof value !== "string") {
+                        throw new TypeError('"script" must be a string.');
+                    }
+                    setScript(value);
+                    props.setScriptOpen(true);
+                    const result = await runScript(script().scope, value);
+                    if (result.tag === "error") {
+                        return {
+                            isError: true,
+                            content: [
+                                { type: "text", text: `Script threw: ${String(result.error)}` },
+                            ],
+                        };
+                    }
+                    const text =
+                        result.value === undefined
+                            ? "Script ran successfully."
+                            : `Script ran successfully. Returned: ${formatRunValue(result.value)}`;
+                    return { content: [{ type: "text", text }] };
+                },
+            },
+            { signal: controller.signal },
+        );
+        onCleanup(() => controller.abort());
+    });
+
+    const reset = () => {
+        if (confirm("Clear the schema, instance, and scripts? This cannot be undone.")) {
+            props.doc.clear();
+        }
+    };
+    const clearStorageProblem = () => props.doc.clear();
+
+    return (
+        <>
+            <Show when={storageProblem()}>
+                {(problem) => (
+                    <Dialog
+                        open={storageDialogOpen()}
+                        onOpenChange={setStorageDialogOpen}
+                        title="Storage problem"
+                    >
+                        <div class={styles.storageProblemDialog}>
+                            <p>
+                                The demo could not load or save browser storage. You can keep
+                                working in the current session, but changes may not survive a
+                                reload.
+                            </p>
+                            <p class={styles.storageProblemDetail}>{problem()}</p>
+                            <div class={styles.storageProblemActions}>
+                                <Button variant="danger" onClick={clearStorageProblem}>
+                                    Clear all data
+                                </Button>
+                                <Button
+                                    variant="utility"
+                                    onClick={() => setStorageDialogOpen(false)}
+                                >
+                                    Keep working
+                                </Button>
+                            </div>
+                        </div>
+                    </Dialog>
+                )}
+            </Show>
+            <div class={styles.split}>
+                <SchemaEditor
+                    doc={props.doc}
+                    active={() => props.activePanel() === "schema"}
+                    onActivate={() => props.setActivePanel("schema")}
+                />
+                <InstanceEditor
+                    doc={props.doc}
+                    active={() => props.activePanel() === "instance"}
+                    onActivate={() => props.setActivePanel("instance")}
+                />
+            </div>
+            <Show when={props.scriptOpen()}>
+                <ScriptSidebar
+                    scope={script().scope}
+                    source={source()}
+                    onSourceChange={setScript}
+                />
+            </Show>
+            <div class={styles.floatingControls}>
+                <Button onClick={reset}>Clear all data</Button>
+                <ScriptToggle
+                    open={props.scriptOpen()}
+                    onToggle={() => props.setScriptOpen(!props.scriptOpen())}
+                />
+            </div>
+        </>
+    );
+}
+
+function storageProblemMessage(action: string, error?: unknown) {
+    const detail = error instanceof Error ? ` ${error.message}` : "";
+    return `Could not ${action} local storage.${detail}`;
+}
diff --git a/packages/document-methods/demo/src/HistorySidebar.module.css b/packages/document-methods/demo/src/HistorySidebar.module.css
new file mode 100644
index 000000000..86c5addb3
--- /dev/null
+++ b/packages/document-methods/demo/src/HistorySidebar.module.css
@@ -0,0 +1,9 @@
+/* The docked history panel, mirroring the frontend's `.history-sidebar`. */
+.historySidebar {
+    width: 260px;
+    flex-shrink: 0;
+    border-left: 1px solid var(--color-gray-400);
+    height: 100%;
+    min-height: 0;
+    overflow: hidden;
+}
diff --git a/packages/document-methods/demo/src/HistorySidebar.tsx b/packages/document-methods/demo/src/HistorySidebar.tsx
new file mode 100644
index 000000000..b7c945f1d
--- /dev/null
+++ b/packages/document-methods/demo/src/HistorySidebar.tsx
@@ -0,0 +1,66 @@
+import { onCleanup, onMount } from "solid-js";
+
+import {
+    formatShortcut,
+    HistoryNavigator,
+    keyEventHasModifier,
+    primaryModifier,
+} from "catcolab-ui-components";
+import type { LocalHistory } from "./history";
+
+import styles from "./HistorySidebar.module.css";
+
+/**
+ * The history sidebar shown docked to a panel. It maps a {@link LocalHistory}
+ * onto the shared `HistoryNavigator` — the exact component the CatColab frontend
+ * uses — so it looks and behaves like the frontend's, and installs the same
+ * undo/redo keyboard shortcuts (scoped to when this sidebar's panel is active).
+ *
+ * @param active  Whether this sidebar's panel currently owns keyboard focus, so
+ *                only the focused panel's shortcuts fire (matching the frontend's
+ *                per-pane behaviour).
+ */
+export function HistorySidebar(props: { history: LocalHistory; active?: () => boolean }) {
+    onMount(() => {
+        const onKeyDown = (evt: KeyboardEvent) => {
+            if (props.active && !props.active()) {
+                return;
+            }
+            const key = evt.key.toUpperCase();
+            const hasPrimary = keyEventHasModifier(evt, primaryModifier);
+            if (!hasPrimary || evt.altKey) {
+                return;
+            }
+            if (key === "Z" && !evt.shiftKey && props.history.canUndo()) {
+                props.history.onUndo();
+                evt.preventDefault();
+                return;
+            }
+            if (
+                ((key === "Z" && evt.shiftKey) || (key === "Y" && !evt.shiftKey)) &&
+                props.history.canRedo()
+            ) {
+                props.history.onRedo();
+                evt.preventDefault();
+                return;
+            }
+        };
+        window.addEventListener("keydown", onKeyDown);
+        onCleanup(() => window.removeEventListener("keydown", onKeyDown));
+    });
+
+    return (
+        <div class={styles.historySidebar}>
+            <HistoryNavigator
+                items={props.history.items()}
+                canUndo={props.history.canUndo()}
+                canRedo={props.history.canRedo()}
+                onUndo={props.history.onUndo}
+                onRedo={props.history.onRedo}
+                onSelect={props.history.navigate}
+                undoTooltip={`Undo (${formatShortcut([primaryModifier, "Z"])})`}
+                redoTooltip={`Redo (${formatShortcut([primaryModifier, "Shift", "Z"])} or ${formatShortcut([primaryModifier, "Y"])})`}
+            />
+        </div>
+    );
+}
diff --git a/packages/document-methods/demo/src/HistoryToggle.tsx b/packages/document-methods/demo/src/HistoryToggle.tsx
new file mode 100644
index 000000000..3c26a1bff
--- /dev/null
+++ b/packages/document-methods/demo/src/HistoryToggle.tsx
@@ -0,0 +1,40 @@
+import { IconButton } from "catcolab-ui-components";
+
+/**
+ * A toolbar button that toggles a panel's history sidebar, mirroring the
+ * frontend's History toggle (the same lucide "history" glyph, drawn inline to
+ * avoid pulling `lucide-solid` into the demo directly).
+ */
+export function HistoryToggle(props: { open: boolean; onToggle: () => void }) {
+    return (
+        <IconButton
+            onClick={() => props.onToggle()}
+            tooltip={props.open ? "Hide history" : "Show history"}
+            aria-pressed={props.open}
+        >
+            <HistoryIcon />
+        </IconButton>
+    );
+}
+
+/** The lucide `history` icon, inlined. */
+function HistoryIcon() {
+    return (
+        <svg
+            xmlns="http://www.w3.org/2000/svg"
+            width="20"
+            height="20"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="2"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+            aria-hidden="true"
+        >
+            <path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8" />
+            <path d="M3 3v5h5" />
+            <path d="M12 7v5l4 2" />
+        </svg>
+    );
+}
diff --git a/packages/document-methods/demo/src/InstanceEditor.module.css b/packages/document-methods/demo/src/InstanceEditor.module.css
new file mode 100644
index 000000000..3ffce6835
--- /dev/null
+++ b/packages/document-methods/demo/src/InstanceEditor.module.css
@@ -0,0 +1,99 @@
+/* The whole right half: the instance panel (with its optional script pane
+   stacked below) plus its (optional) history sidebar, laid side by side. */
+.panelLayout {
+    display: flex;
+    flex-direction: row;
+    height: 100%;
+    min-height: 0;
+}
+
+/* The panel and its bottom script pane, stacked vertically. */
+.panelColumn {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    min-width: 0;
+    height: 100%;
+    min-height: 0;
+}
+
+.panel {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    min-width: 0;
+    min-height: 0;
+    overflow: hidden;
+    background: var(--background);
+}
+
+.header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 0.75rem;
+    min-height: 3.25rem;
+    padding: 0.75rem 1rem;
+    border-bottom: 2px solid var(--color-gray-150);
+}
+
+.headerLeft {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.headerRight {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.header h2 {
+    margin: 0;
+    font-size: 1rem;
+    font-weight: 450;
+}
+
+.badge {
+    font-size: 0.75rem;
+    font-weight: 500;
+    padding: 0.2rem 0.6rem;
+    border-radius: 999px;
+    border: 1px solid transparent;
+}
+
+.badge[data-tag="Valid"] {
+    background: var(--color-icon-button-positive-hover);
+    color: var(--color-topos-primary-hover);
+    border-color: var(--color-icon-button-positive-active);
+}
+
+.badge[data-tag="Invalid"],
+.badge[data-tag="Illformed"] {
+    background: var(--color-form-invalid-bg);
+    color: var(--color-alert-danger);
+}
+
+/* A masonry-style tiling: each table takes its natural width and wraps,
+   packing left-to-right with no gaps and no inner scrolling. */
+.tables {
+    flex: 1;
+    overflow-y: auto;
+    overflow-x: hidden;
+    padding: 0;
+    display: flex;
+    flex-wrap: wrap;
+    align-content: flex-start;
+}
+
+/* Each table sizes to its content and carries shared dividing borders. */
+.tables > * {
+    border-right: 1px solid var(--color-gray-400);
+    border-bottom: 1px solid var(--color-gray-400);
+}
+
+.empty {
+    color: var(--muted);
+    font-style: italic;
+}
diff --git a/packages/document-methods/demo/src/InstanceEditor.tsx b/packages/document-methods/demo/src/InstanceEditor.tsx
new file mode 100644
index 000000000..db57440a0
--- /dev/null
+++ b/packages/document-methods/demo/src/InstanceEditor.tsx
@@ -0,0 +1,99 @@
+import type { DiagramValidationResult } from "catcolab-documents";
+import { createMemo, createSignal, For, onCleanup, Show } from "solid-js";
+
+import type { DemoDocument } from "./document";
+import { HistorySidebar } from "./HistorySidebar";
+import { HistoryToggle } from "./HistoryToggle";
+import { tableSpecs } from "./instance-model";
+import { InstanceTable } from "./InstanceTable";
+
+import styles from "./InstanceEditor.module.css";
+
+/**
+ * The right-hand instance editor. It renders one spreadsheet table per schema
+ * entity, following the demo's structural rules:
+ *
+ *  - entity added / deleted  -> a table appears / disappears;
+ *  - morphism added / deleted, or its domain changed -> a column appears /
+ *    disappears in the appropriate table;
+ *  - a mapping's codomain changed -> foreign-key cells pointing at rows of the
+ *    old codomain are shown as invalid.
+ *
+ * The `<For>` is keyed on entity id so a table's DOM (and its jspreadsheet
+ * instance) survives column changes; `InstanceTable` reacts to those.
+ */
+export function InstanceEditor(props: {
+    doc: DemoDocument;
+    active: () => boolean;
+    onActivate: () => void;
+}) {
+    const doc = () => props.doc;
+
+    const specs = createMemo(() => {
+        doc().trackSchema();
+        doc().trackInstance();
+        return tableSpecs(doc());
+    });
+
+    const [historyOpen, setHistoryOpen] = createSignal(false);
+
+    return (
+        <div
+            class={styles.panelLayout}
+            onFocusIn={() => props.onActivate()}
+            onPointerDown={() => props.onActivate()}
+        >
+            <div class={styles.panelColumn}>
+                <div class={styles.panel}>
+                    <div class={styles.header}>
+                        <div class={styles.headerLeft}>
+                            <h2>Instance</h2>
+                            <ValidationBadge doc={doc()} />
+                        </div>
+                        <div class={styles.headerRight}>
+                            <HistoryToggle
+                                open={historyOpen()}
+                                onToggle={() => setHistoryOpen((v) => !v)}
+                            />
+                        </div>
+                    </div>
+                    <div class={styles.tables}>
+                        <Show
+                            when={specs().length > 0}
+                            fallback={
+                                <div class={styles.empty}>
+                                    Add an entity on the left to create a table here.
+                                </div>
+                            }
+                        >
+                            <For each={specs()}>
+                                {(spec) => <InstanceTable doc={doc()} entity={spec.entity} />}
+                            </For>
+                        </Show>
+                    </div>
+                </div>
+            </div>
+            <Show when={historyOpen()}>
+                <HistorySidebar history={doc().instanceHistory} active={props.active} />
+            </Show>
+        </div>
+    );
+}
+
+/** A live validity badge from `instance.onValidate()`. */
+function ValidationBadge(props: { doc: DemoDocument }) {
+    // The observer follows the instance's own rows *and* the schema's whole
+    // model tree through the elaboration cache, so no manual subscription to
+    // the schema is needed, and equivalent results are never re-delivered.
+    const [validation, setValidation] = createSignal<DiagramValidationResult>();
+    const unsubscribe = props.doc.instance.onValidate(setValidation);
+    onCleanup(unsubscribe);
+
+    const displayTag = () => validation()?.tag ?? "Checking";
+
+    return (
+        <span class={styles.badge} data-tag={displayTag()}>
+            {displayTag()}
+        </span>
+    );
+}
diff --git a/packages/document-methods/demo/src/InstanceTable.module.css b/packages/document-methods/demo/src/InstanceTable.module.css
new file mode 100644
index 000000000..c02b1d77f
--- /dev/null
+++ b/packages/document-methods/demo/src/InstanceTable.module.css
@@ -0,0 +1,105 @@
+.table {
+    display: flex;
+    flex-direction: column;
+    /* Size the frame to the jspreadsheet table's exact width so the header and
+       footer align flush with the grid rather than overhanging it. */
+    width: fit-content;
+    max-width: 100%;
+    background: var(--color-background);
+}
+
+.tableHeader {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.4rem 0.75rem;
+    border-bottom: 1px solid var(--color-gray-300);
+    background: var(--color-gray-50);
+    flex: none;
+}
+
+.entityName {
+    font-weight: 500;
+    font-size: 1.05rem;
+}
+
+/* Match the schema editor's de-emphasized "Unnamed" placeholder styling. */
+.unnamed {
+    color: var(--color-text-placeholder);
+}
+
+/* The grid area sizes to the jspreadsheet table's full content, no inner scroll. */
+.grid {
+    flex: none;
+    width: fit-content;
+}
+
+.noRows {
+    min-width: 12rem;
+    padding: 1rem 1.25rem;
+    color: var(--color-text-secondary);
+    font-size: 0.85rem;
+    font-style: italic;
+}
+
+/* jspreadsheet sets an inline pixel width on its wrapper divs that is a few
+   pixels wider than the actual table (it reserves space for a scrollbar),
+   leaving the header/footer overhanging the grid on the right. Override those
+   inline widths (hence `!important`) so every wrapper shrinks to the table's
+   real width and the frame fits flush. It also pads the wrappers a few pixels
+   on the right/bottom for the same reason, so drop that too. */
+.grid :global(.jss_spreadsheet),
+.grid :global(.jtabs-content),
+.grid :global(.jss_container),
+.grid :global(.jss_content) {
+    width: fit-content !important;
+    padding: 0 !important;
+}
+
+/* `.jss_content` is inline-block, whose baseline leaves a few pixels of gap
+   below the table; make it block so the frame ends flush at the bottom. */
+.grid :global(.jss_content) {
+    display: block !important;
+}
+
+/* jspreadsheet's table uses `border-collapse: separate`, so its own 1px outer
+   border sits *outside* the cell borders, reading as a thin gap all around the
+   grid. Collapse the borders so the outer edge and the cells' borders merge and
+   the grid meets the frame flush on every side. */
+.grid :global(table.jss_worksheet) {
+    border-collapse: collapse !important;
+}
+
+/* The "+ Row" footer, sitting directly under the table. */
+.tableFooter {
+    display: flex;
+    flex: none;
+    border-top: 1px solid var(--color-gray-300);
+    background: var(--color-gray-50);
+}
+
+.addRow {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.25rem;
+    width: 100%;
+    padding: 6px 10px;
+    font-size: 0.8rem;
+    border: none;
+    background: transparent;
+    color: var(--color-text-secondary);
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.addRow:hover {
+    background: var(--color-button-utility-hover-bg);
+    color: var(--color-foreground);
+}
+
+.invalidCell {
+    background: var(--danger-bg) !important;
+    color: var(--danger) !important;
+    font-style: italic;
+}
diff --git a/packages/document-methods/demo/src/InstanceTable.tsx b/packages/document-methods/demo/src/InstanceTable.tsx
new file mode 100644
index 000000000..09d3dbc9f
--- /dev/null
+++ b/packages/document-methods/demo/src/InstanceTable.tsx
@@ -0,0 +1,386 @@
+import type { MorphismCell, ObjectCell, Row } from "catcolab-documents";
+import { Attr, Mapping } from "catcolab-logics/simple-schema";
+import jspreadsheet from "jspreadsheet-ce";
+import { createEffect, on, onCleanup, Show } from "solid-js";
+
+import type { DemoDocument } from "./document";
+import { type Column, columnsFor, schemaShapeSignature } from "./instance-model";
+
+import "jspreadsheet-ce/dist/jspreadsheet.css";
+import "jspreadsheet-ce/dist/jspreadsheet.themes.css";
+import "jsuites/dist/jsuites.css";
+import styles from "./InstanceTable.module.css";
+
+/**
+ * jspreadsheet hardcodes a native `confirm("Are you sure to delete the selected
+ * rows?")` before deleting rows (on Delete/Backspace or via its context menu),
+ * with no option to disable it. Deleting a row here is cheap and undoable
+ * through the history sidebar, so the prompt is just friction. Patch `confirm`
+ * once to auto-accept exactly jspreadsheet's row/column delete prompts, leaving
+ * every other `confirm()` (e.g. "Reset all data") untouched.
+ */
+function suppressJspreadsheetDeleteConfirm() {
+    const w = window as Window & { __jssDeleteConfirmPatched?: boolean };
+    if (w.__jssDeleteConfirmPatched) {
+        return;
+    }
+    w.__jssDeleteConfirmPatched = true;
+    const original = window.confirm.bind(window);
+    window.confirm = (message?: string) => {
+        if (
+            typeof message === "string" &&
+            /Are you sure to delete the selected (rows|columns)\?/.test(message)
+        ) {
+            return true;
+        }
+        return original(message);
+    };
+}
+
+suppressJspreadsheetDeleteConfirm();
+
+/**
+ * The special dropdown value used for a foreign-key cell whose target row no
+ * longer belongs to the mapping's current codomain (e.g. after the codomain was
+ * changed). It is not among the dropdown's sources, so jspreadsheet renders it
+ * verbatim and we style it as invalid.
+ */
+const INVALID = "invalid";
+
+/**
+ * The label for a codomain row in a foreign-key dropdown: the compact form shown
+ * both in the option and in the *closed* cell once selected. It is the entity
+ * name followed by the row's first column value in quotes, e.g. `Person "Fred"`.
+ * It falls back to the entity name and the row's 1-based index, e.g. `Person 1`,
+ * when the first column is not a literal attribute (e.g. it is a mapping) or its
+ * value is empty — including when the entity has no columns at all.
+ */
+function rowLabel(rows: Row[], row: Row, columns: Column[], entityName: string): string {
+    const index = rows.findIndex((r) => r.id === row.id) + 1;
+    const firstColumn = columns[0];
+    // Read by the morphism's UUID rather than its (non-unique) name.
+    const firstValue =
+        firstColumn?.kind === "attr" ? row.get({ id: firstColumn.morphismId }) : undefined;
+    return typeof firstValue === "string" && firstValue !== ""
+        ? `${entityName} "${firstValue}"`
+        : `${entityName} ${index}`;
+}
+
+/**
+ * One entity's instance table, backed by a jspreadsheet worksheet.
+ *
+ * The instance is the source of truth: jspreadsheet is a view over it. Because
+ * a schema *shape* change (columns added/removed, a mapping's codomain changed)
+ * requires rebuilding the grid's columns, the whole jspreadsheet instance is
+ * destroyed and recreated whenever the shape signature changes. Row edits made
+ * in the grid are written straight back to the instance; those instance
+ * mutations bump the document signals, but we guard against rebuilding on our
+ * own edits by only rebuilding when the shape signature or row set changes.
+ */
+export function InstanceTable(props: { doc: DemoDocument; entity: ObjectCell }) {
+    const doc = () => props.doc;
+    // jspreadsheet mutates the host element (adding a `.spreadsheet` property),
+    // so it is typed as its own element type; a div satisfies it at runtime.
+    let container!: HTMLDivElement;
+    const host = () => container as unknown as Parameters<typeof jspreadsheet.destroy>[0];
+    // The current jspreadsheet worksheet instance, and the row ids backing it
+    // (row index -> instance Row id), kept so grid callbacks can find the row.
+    let worksheet: jspreadsheet.WorksheetInstance | undefined;
+    let rowIds: string[] = [];
+
+    /** This entity's instance row with the given id, if it still exists. */
+    const rowById = (id: string | undefined): Row | undefined =>
+        id
+            ? doc()
+                  .instance.rowsOf(props.entity)
+                  .find((r) => r.id === id)
+            : undefined;
+
+    /** The schema morphism cell (Attr or Mapping) a column stands for. */
+    const morphismCellFor = (column: Column): MorphismCell => {
+        const all = [...doc().schema.cellsOf(Mapping), ...doc().schema.cellsOf(Attr)];
+        const cell = all.find((c) => c.id === column.morphismId);
+        if (!cell) {
+            throw new Error(`No schema morphism cell for column "${column.title}".`);
+        }
+        return cell;
+    };
+
+    /** The grid cell value shown for one row/column. */
+    const cellValue = (row: Row, column: Column): string => {
+        // Look up by the column's morphism UUID, not its name: two morphisms can
+        // share a name, so a name-keyed lookup would read the wrong column.
+        const value = row.get({ id: column.morphismId });
+        if (value === undefined) {
+            return "";
+        }
+        if (column.kind === "attr") {
+            return typeof value === "string" ? value : "";
+        }
+        // A mapping: the value is the target Row. If that row is no longer a row
+        // of the mapping's current codomain, it is invalid (e.g. the codomain
+        // was changed out from under it).
+        const target = value as Row;
+        const codomainRows = doc().instance.rowsOf(column.codomain);
+        return codomainRows.some((r) => r.id === target.id) ? target.id : INVALID;
+    };
+
+    /** Build the jspreadsheet column configs for the current columns. */
+    const buildColumns = (columns: Column[]): jspreadsheet.Column[] => {
+        if (columns.length === 0) {
+            // An entity with no attributes/mappings has nothing to show per row;
+            // render a single blank, read-only column (jspreadsheet needs at
+            // least one) with no title, rather than a hint or its default "A".
+            return [
+                {
+                    type: "text",
+                    title: " ",
+                    width: 120,
+                    readOnly: true,
+                },
+            ];
+        }
+        return columns.map((column) => {
+            if (column.kind === "attr") {
+                return {
+                    type: column.attrType === "Number" ? "numeric" : "text",
+                    title: column.title,
+                    width: 180,
+                };
+            }
+            const codomainRows = doc().instance.rowsOf(column.codomain);
+            const codomainColumns = columnsFor(doc(), column.codomain);
+            const codomainName = column.codomain.label || "(unnamed entity)";
+            return {
+                type: "dropdown",
+                title: column.title,
+                width: 220,
+                autocomplete: true,
+                source: codomainRows.map((r) => ({
+                    id: r.id,
+                    name: rowLabel(codomainRows, r, codomainColumns, codomainName),
+                })),
+                render: markInvalid,
+            };
+        });
+    };
+
+    const rows = () => (doc().trackInstance(), doc().instance.rowsOf(props.entity));
+    const hasRows = () => rows().length > 0;
+
+    /** Build the 2-D data array (and refresh `rowIds`) from the instance. */
+    const buildData = (columns: Column[]): string[][] => {
+        const entityRows = rows();
+        rowIds = entityRows.map((r) => r.id);
+        if (columns.length === 0) {
+            // One empty cell per row, matching the single hint column above.
+            return entityRows.map(() => [""]);
+        }
+        return entityRows.map((row) => columns.map((column) => cellValue(row, column)));
+    };
+
+    /** Push a single grid edit back into the instance. */
+    const applyEdit = (columns: Column[], x: number, y: number, value: string) => {
+        const column = columns[x];
+        if (!column) {
+            return;
+        }
+        const row = rowById(rowIds[y]);
+        if (!row) {
+            return;
+        }
+        const morphism = morphismCellFor(column);
+        if (column.kind === "attr") {
+            if (value === "") {
+                row.set(morphism, undefined);
+            } else {
+                row.set(morphism, column.attrType === "Number" ? Number(value) : value);
+            }
+        } else {
+            const target = doc()
+                .instance.rowsOf(column.codomain)
+                .find((r) => r.id === value);
+            row.set(morphism, target);
+        }
+    };
+
+    /** Colour foreign-key cells whose value is the INVALID sentinel. */
+    const markInvalid = (cell: HTMLTableCellElement, value: jspreadsheet.CellValue | undefined) => {
+        if (value === INVALID) {
+            cell.classList.add(styles.invalidCell ?? "");
+            cell.textContent = "⚠ invalid ref";
+        }
+    };
+
+    // Whether a deferred rebuild is already queued (see `rebuild`), so a burst
+    // of signal bumps coalesces into a single rebuild.
+    let rebuildScheduled = false;
+    // Set on cleanup so a queued rebuild becomes a no-op after disposal.
+    let disposed = false;
+
+    /**
+     * Schedule a rebuild for the next microtask rather than running it inline.
+     *
+     * The reactive effect that calls this can fire *synchronously from inside a
+     * jspreadsheet callback*: a cell edit runs `onchange` -> `applyEdit` ->
+     * `row.set`, which mutates the instance and (through the plain store's
+     * synchronous change notification) bumps the document signals, re-running
+     * the effect while jspreadsheet is still mid-edit. Destroying and recreating
+     * the worksheet at that moment corrupts jspreadsheet's internal edit state
+     * (`edition`), throwing "Cannot read properties of undefined". Deferring to a
+     * microtask lets jspreadsheet finish the current operation first, and
+     * coalesces the burst of signal bumps a single edit produces into one
+     * rebuild.
+     */
+    const rebuild = () => {
+        if (rebuildScheduled) {
+            return;
+        }
+        rebuildScheduled = true;
+        queueMicrotask(() => {
+            rebuildScheduled = false;
+            // The component may have been disposed while the rebuild was pending.
+            if (disposed) {
+                return;
+            }
+            rebuildNow();
+        });
+    };
+
+    const rebuildNow = () => {
+        if (worksheet) {
+            // A rebuild can be triggered by a schema change (e.g. adding an
+            // attribute) *while a cell edit is still open*. jspreadsheet only
+            // commits an in-progress edit on blur/close, so destroying the
+            // worksheet now would discard the typed-but-uncommitted value. Close
+            // any open editor with save=true first so its `onchange` fires and
+            // `applyEdit` writes the value back into the instance before we tear
+            // the grid down.
+            const editing = worksheet.edition;
+            if (editing) {
+                worksheet.closeEditor(editing[0], true);
+            }
+            jspreadsheet.destroy(host(), true);
+            worksheet = undefined;
+        }
+        const columns = columnsFor(doc(), props.entity);
+        const data = buildData(columns);
+        if (data.length === 0) {
+            rowIds = [];
+            return;
+        }
+
+        const options: jspreadsheet.SpreadsheetOptions = {
+            worksheets: [
+                {
+                    data,
+                    columns: buildColumns(columns),
+                    minDimensions: [Math.max(columns.length, 1), 0],
+                    allowInsertColumn: false,
+                    allowDeleteColumn: false,
+                    allowRenameColumn: false,
+                },
+            ],
+            onchange: (_ws, _cell, cx, cy, newValue) => {
+                applyEdit(columns, Number(cx), Number(cy), String(newValue ?? ""));
+            },
+            onselection: (ws, x1, y1, x2, y2, origin) => {
+                // Open the reference-completion dropdown on a *single* click:
+                // when exactly one mapping (dropdown) cell is selected by the
+                // user (an `origin` event, not a programmatic selection), open
+                // its editor immediately instead of requiring a double click.
+                if (origin === undefined || x1 !== x2 || y1 !== y2) {
+                    return;
+                }
+                if (columns[x1]?.kind !== "mapping") {
+                    return;
+                }
+                // Defer so this fires after jspreadsheet finishes its own
+                // selection handling (which would otherwise close the editor).
+                queueMicrotask(() => {
+                    if (disposed || worksheet !== ws || ws.edition) {
+                        return;
+                    }
+                    ws.openEditor(ws.getCellFromCoords(x1, y1), false);
+                });
+            },
+            oninsertrow: () => {
+                // A new grid row corresponds to a fresh, empty instance row.
+                // Rows are valid even for a column-less entity: they are simply
+                // empty records with no attribute/mapping values yet.
+                const row = doc().instance.add(props.entity, {});
+                rowIds.push(row.id);
+            },
+            ondeleterow: (_ws, removed) => {
+                for (const y of [...removed].toSorted((a, b) => b - a)) {
+                    rowById(rowIds[y])?.delete();
+                    rowIds.splice(y, 1);
+                }
+            },
+        };
+        const built = jspreadsheet(host(), options);
+        worksheet = Array.isArray(built) ? built[0] : built;
+    };
+
+    // Rebuild whenever this entity's table *shape* changes: its column set, a
+    // mapping codomain, or the number of rows (rows added/removed from outside
+    // this grid). Cell-value edits reconcile through `applyEdit` without a
+    // rebuild, so typing is not interrupted.
+    createEffect(
+        on(
+            () => {
+                doc().trackSchema();
+                doc().trackInstance();
+                const columnSig = columnsFor(doc(), props.entity)
+                    .map((c) =>
+                        c.kind === "attr"
+                            ? `a:${c.morphismId}:${c.title}:${c.attrType}`
+                            : `m:${c.morphismId}:${c.title}:${c.codomain.id}`,
+                    )
+                    .join(",");
+                const rowCount = doc().instance.rowsOf(props.entity).length;
+                // Include the global shape signature so codomain-row relabels in
+                // other tables (used as this table's FK sources) refresh too.
+                return `${schemaShapeSignature(doc())}#${columnSig}#${rowCount}`;
+            },
+            () => rebuild(),
+        ),
+    );
+
+    onCleanup(() => {
+        disposed = true;
+        if (worksheet) {
+            jspreadsheet.destroy(host(), true);
+        }
+    });
+
+    return (
+        <div class={styles.table}>
+            <div class={styles.tableHeader}>
+                <span
+                    classList={{
+                        [styles.entityName ?? ""]: true,
+                        [styles.unnamed ?? ""]: !props.entity.label,
+                    }}
+                >
+                    {props.entity.label || "Unnamed"}
+                </span>
+            </div>
+            <div class={styles.grid}>
+                <Show when={!hasRows()}>
+                    <div class={styles.noRows}>No rows</div>
+                </Show>
+                <div ref={container} />
+            </div>
+            <div class={styles.tableFooter}>
+                <button
+                    class={styles.addRow}
+                    type="button"
+                    onClick={() => doc().instance.add(props.entity, {})}
+                >
+                    + Row
+                </button>
+            </div>
+        </div>
+    );
+}
diff --git a/packages/document-methods/demo/src/SchemaEditor.module.css b/packages/document-methods/demo/src/SchemaEditor.module.css
new file mode 100644
index 000000000..7e9fa59ff
--- /dev/null
+++ b/packages/document-methods/demo/src/SchemaEditor.module.css
@@ -0,0 +1,354 @@
+/* The whole left half: the schema panel (with its optional script pane stacked
+   below) plus its (optional) history sidebar, laid side by side. The divider to
+   the instance sits on this layout. */
+.panelLayout {
+    display: flex;
+    flex-direction: row;
+    height: 100%;
+    min-height: 0;
+    border-right: 2px solid var(--color-gray-150);
+}
+
+/* The panel and its bottom script pane, stacked vertically. */
+.panelColumn {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    min-width: 0;
+    height: 100%;
+    min-height: 0;
+}
+
+.panel {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    min-width: 0;
+    min-height: 0;
+    overflow-y: auto;
+    background: var(--color-background);
+}
+
+/* A sticky header, mirroring the instance editor's. */
+.header {
+    position: sticky;
+    top: 0;
+    z-index: 5;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 0.75rem;
+    min-height: 3.25rem;
+    padding: 0.75rem 1rem;
+    border-bottom: 2px solid var(--color-gray-150);
+    background: var(--color-background);
+}
+
+.header h2 {
+    margin: 0;
+    font-size: 1rem;
+    font-weight: 450;
+}
+
+.headerRight {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+/* The notebook, mirroring CatColab's `.notebook-container` gutter layout. */
+.notebookContainer {
+    --gutter-width: 50px;
+    width: 100%;
+    max-width: calc(80ex + var(--gutter-width));
+    margin: 0 auto;
+    padding-left: var(--gutter-width);
+    padding-right: 5px;
+}
+
+.notebookCells {
+    list-style: none;
+    margin: 1rem 0;
+    padding: 0;
+}
+
+/* One cell row: gutter (left, in the negative space), content, and a type tag. */
+.cell {
+    position: relative;
+    margin: 0.25em 0;
+    display: flex;
+    flex-direction: row;
+    align-items: baseline;
+    justify-content: space-between;
+}
+
+.cellGutter {
+    position: absolute;
+    top: 50%;
+    left: 0;
+    transform: translate(-100%, -50%);
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 0.15rem;
+    visibility: hidden;
+}
+
+.cell:hover .cellGutter {
+    visibility: visible;
+}
+
+.cellContent {
+    flex-grow: 1;
+    max-width: 100%;
+}
+
+.cellTag {
+    color: var(--color-gray-600);
+    font-size: 11pt;
+    align-self: flex-start;
+    padding-left: 1ex;
+    white-space: nowrap;
+}
+
+/* Formal-judgment sizing, exactly as CatColab. */
+.formalJudgment {
+    --formal-judgment-font-size: 1.3em;
+    font-size: var(--formal-judgment-font-size);
+    line-height: 1.1;
+}
+
+.code {
+    font-family: var(--mono-font);
+}
+
+/* An entity declaration: a monospace name in a 1px box that hugs its content. */
+.objectDecl {
+    width: fit-content;
+}
+
+.box {
+    border: 1px solid var(--color-foreground);
+    padding: 2px;
+}
+
+/* Inline name inputs that size to their content, like the frontend's
+   `InlineInput`: a hidden filler span sets the width and the real input is
+   stretched over it, so the field hugs the text with no default fixed width
+   (which otherwise leaves empty space to the right of the name in the box). */
+.inlineInput {
+    display: inline-block;
+    position: relative;
+}
+
+.inlineInputFiller {
+    display: inline-block;
+    visibility: hidden;
+    white-space-collapse: preserve;
+    padding: 0 5px;
+    min-width: 1ex;
+}
+
+/* The real input, stretched over the filler that sizes the container. Its metrics
+   (font, padding) come from the caller's `.nameInput` / `.arrowName` class, which
+   must match the filler's so the two align exactly. */
+.inlineInputField {
+    position: absolute;
+    inset: 0;
+}
+
+/* Inline, borderless name inputs that blend into the text (like InlineInput). */
+.nameInput,
+.arrowName {
+    font: inherit;
+    color: inherit;
+    border: none;
+    background: transparent;
+    outline: none;
+    padding: 0 5px;
+    min-width: 1ex;
+}
+
+.nameInput::placeholder,
+.arrowName::placeholder {
+    color: var(--color-text-placeholder);
+}
+
+/* A morphism declaration: dom  ──name──▶  cod. */
+.morphismDecl {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 1ex;
+}
+
+.arrowWithName {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    min-width: 2.5ex;
+}
+
+.arrowName {
+    text-align: center;
+    width: 100%;
+}
+
+/* The arrow sits *below* the name, in its own container. The container carries a
+   top margin (a gap under the name) and a large bottom margin so the diagonal
+   arrowhead pieces — positioned relative to the container — have room and never
+   overlap the name above. Mirrors the frontend's `.arrowContainer`. */
+.arrowContainer {
+    position: relative;
+    width: 100%;
+    margin-top: 0.3em;
+    margin-bottom: calc(var(--formal-judgment-font-size) + 0.3em);
+}
+
+/* The 2px arrow bar. */
+.arrow {
+    width: 100%;
+    min-width: 3ex;
+    height: 2px;
+    background: var(--color-foreground);
+    border-radius: 3px;
+}
+
+/* The diagonal arrowhead pieces at the bar's right end. They are absolutely
+   positioned against the `.arrowContainer` (the nearest positioned ancestor),
+   which carries the margins keeping the whole arrow below the name. */
+.arrow::before,
+.arrow::after {
+    content: "";
+    position: absolute;
+    right: -1px;
+    height: 2px;
+    width: 10px;
+    background: var(--color-foreground);
+    border-radius: 3px;
+}
+
+.arrow::before {
+    bottom: -3px;
+    transform: rotate(-45deg);
+}
+
+.arrow::after {
+    top: -3px;
+    transform: rotate(45deg);
+}
+
+/* Endpoint pickers: kept inline and unobtrusive over the mono name. */
+.endpoint {
+    font: inherit;
+    color: inherit;
+    padding: 0 2px;
+    border: 1px solid transparent;
+    border-radius: 4px;
+    background: transparent;
+    cursor: pointer;
+}
+
+.endpoint:hover,
+.endpoint:focus {
+    border-color: var(--color-gray-450);
+    background: var(--color-gray-100);
+}
+
+/* The gutter delete affordance. */
+.gutterDelete {
+    width: 1.4rem;
+    height: 1.4rem;
+    line-height: 1;
+    font-size: 1rem;
+    border: none;
+    border-radius: 5px;
+    background: transparent;
+    color: var(--color-gray-600);
+    cursor: pointer;
+    transition: all 0.15s ease;
+}
+
+.gutterDelete:hover {
+    background: var(--color-icon-button-danger-hover);
+    color: var(--color-icon-button-danger-text);
+}
+
+/* End-of-notebook placeholder, matching `.notebook-cell-placeholder`. */
+.notebookCellPlaceholder {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    column-gap: 0.5ex;
+    margin: 1rem 0;
+    color: var(--color-gray-600);
+}
+
+/* New-cell button + popover menu. */
+.addCell {
+    position: relative;
+    display: inline-flex;
+}
+
+.addCellButton {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 1.4rem;
+    height: 1.4rem;
+    font-size: 1.1rem;
+    line-height: 1;
+    border: none;
+    border-radius: 5px;
+    background: transparent;
+    color: var(--color-gray-600);
+    cursor: pointer;
+}
+
+.addCellButton:hover {
+    background: var(--color-icon-button-utility-hover-bg);
+}
+
+.addCellBackdrop {
+    position: fixed;
+    inset: 0;
+    z-index: 10;
+}
+
+.addCellMenu {
+    position: absolute;
+    top: calc(100% + 4px);
+    left: 0;
+    z-index: 11;
+    min-width: 16rem;
+    margin: 0;
+    padding: 0.25rem;
+    list-style: none;
+    background: var(--color-background);
+    border: 1px solid var(--color-gray-450);
+    border-radius: 6px;
+    box-shadow:
+        var(--color-shadow-base) 0px 0px 0px 1px,
+        var(--color-shadow-medium) 0px 3px 6px,
+        var(--color-shadow-strong) 0px 9px 24px;
+}
+
+.addCellOption {
+    padding: 5px;
+    border-radius: 4px;
+    cursor: pointer;
+}
+
+.addCellOption:hover {
+    background: var(--color-highlight-bg);
+}
+
+.addCellName {
+    font-weight: 500;
+    color: var(--color-foreground);
+}
+
+.addCellDescription {
+    font-size: 0.75em;
+    color: var(--color-text-muted);
+}
diff --git a/packages/document-methods/demo/src/SchemaEditor.tsx b/packages/document-methods/demo/src/SchemaEditor.tsx
new file mode 100644
index 000000000..8e7c4b391
--- /dev/null
+++ b/packages/document-methods/demo/src/SchemaEditor.tsx
@@ -0,0 +1,390 @@
+import { CellKind, type ObjectCell } from "catcolab-documents";
+import { Attr, Entity, Mapping } from "catcolab-logics/simple-schema";
+import { createEffect, createSignal, For, on, Show } from "solid-js";
+
+import {
+    type AttrTypeName,
+    type DemoDocument,
+    entityCells,
+    SCHEMA_CELL_LABEL,
+    type SchemaCell,
+    schemaCellKind,
+    schemaCells,
+} from "./document";
+import { HistorySidebar } from "./HistorySidebar";
+import { HistoryToggle } from "./HistoryToggle";
+
+import styles from "./SchemaEditor.module.css";
+
+/** A morphism cell as it appears in the schema notebook (Mapping or Attr). */
+type SchemaMorphismCell = Extract<SchemaCell, { kind: typeof CellKind.Morphism }>;
+
+/** The single object endpoint of a schema morphism (never a list, here). */
+function endpoint(
+    end: SchemaMorphismCell["from"] | SchemaMorphismCell["to"],
+): { readonly id: string; readonly label: string } | undefined {
+    return Array.isArray(end) ? end[0] : end;
+}
+
+/**
+ * An inline, borderless name field that owns its text locally so a schema
+ * re-render (triggered by *its own* edits) never clobbers what the user is
+ * typing. It writes through to `setValue` on every input and only pulls the
+ * external `value` back in when the field is not focused (e.g. an edit from
+ * elsewhere), mirroring CatColab's `InlineInput`.
+ */
+function NameField(props: {
+    value: string;
+    setValue: (name: string) => void;
+    placeholder?: string;
+    class?: string;
+}) {
+    const [text, setText] = createSignal(props.value);
+    let el!: HTMLInputElement;
+
+    createEffect(
+        on(
+            () => props.value,
+            (value) => {
+                if (document.activeElement !== el) {
+                    setText(value);
+                }
+            },
+        ),
+    );
+
+    // Size the input to its content with the frontend's `InlineInput` trick: a
+    // hidden filler span (same text metrics) sets the width, and the input is
+    // stretched over it. Without this the input keeps its default fixed width,
+    // leaving empty space to the right of the name inside the entity box.
+    return (
+        <span class={styles.inlineInput}>
+            <span class={`${styles.inlineInputFiller} ${props.class ?? ""}`}>
+                {text() || props.placeholder}
+            </span>
+            <input
+                ref={el}
+                class={`${styles.inlineInputField} ${props.class ?? ""}`}
+                placeholder={props.placeholder}
+                value={text()}
+                onInput={(e) => {
+                    setText(e.currentTarget.value);
+                    props.setValue(e.currentTarget.value);
+                }}
+            />
+        </span>
+    );
+}
+
+/**
+ * The left panel: a faithful simple-schema notebook. It edits a single
+ * SimpleSchema laid out exactly like a CatColab model notebook — one formal cell
+ * per line, each with a hover gutter ("+") on the left and its type tag on the
+ * right. Entities are boxed monospace names; mappings and attributes are drawn
+ * `dom ──name──▶ cod`.
+ *
+ * The two attribute types (String, Number) are seeded and shown as ordinary
+ * "Attribute type" cells, but they are pinned to the top and cannot be deleted,
+ * and the new-cell menu never offers to add another attribute type — so the only
+ * attribute codomains are ever String and Number.
+ */
+export function SchemaEditor(props: {
+    doc: DemoDocument;
+    active: () => boolean;
+    onActivate: () => void;
+}) {
+    const doc = () => props.doc;
+
+    // Iterate over stable cell ids so a row's DOM (and its focused input) is not
+    // torn down every time the schema signal bumps; each row resolves its live
+    // handle by id reactively.
+    const cellIds = () => (doc().trackSchema(), schemaCells(doc()).map((c) => c.id));
+
+    const [historyOpen, setHistoryOpen] = createSignal(false);
+
+    return (
+        <div
+            class={styles.panelLayout}
+            onFocusIn={() => props.onActivate()}
+            onPointerDown={() => props.onActivate()}
+        >
+            <div class={styles.panelColumn}>
+                <div class={styles.panel}>
+                    <div class={styles.header}>
+                        <h2>Schema</h2>
+                        <div class={styles.headerRight}>
+                            <HistoryToggle
+                                open={historyOpen()}
+                                onToggle={() => setHistoryOpen((v) => !v)}
+                            />
+                        </div>
+                    </div>
+                    <div class={styles.notebookContainer}>
+                        <ul class={styles.notebookCells}>
+                            <For each={cellIds()}>
+                                {(id) => <SchemaCellRow doc={doc()} cellId={id} />}
+                            </For>
+                        </ul>
+                        <AddCellPlaceholder doc={doc()} />
+                    </div>
+                </div>
+            </div>
+            <Show when={historyOpen()}>
+                <HistorySidebar history={doc().schemaHistory} active={props.active} />
+            </Show>
+        </div>
+    );
+}
+
+/** Dispatch one notebook cell to the right formal-cell editor, plus gutter + tag. */
+function SchemaCellRow(props: { doc: DemoDocument; cellId: string }) {
+    const cell = () => {
+        props.doc.trackSchema();
+        return schemaCells(props.doc).find((c) => c.id === props.cellId);
+    };
+    const kind = () => {
+        const c = cell();
+        return c ? schemaCellKind(props.doc, c) : undefined;
+    };
+    // The seeded attribute types are pinned and cannot be deleted.
+    const deletable = () => kind() !== "attrType";
+
+    return (
+        <Show when={cell()}>
+            {(c) => (
+                <li class={styles.cell}>
+                    <div class={styles.cellGutter}>
+                        <AddCellButton doc={props.doc} icon="+" />
+                        <Show when={deletable()}>
+                            <button
+                                class={styles.gutterDelete}
+                                type="button"
+                                title="Delete cell"
+                                onClick={() => c().delete()}
+                            >
+                                ×
+                            </button>
+                        </Show>
+                    </div>
+                    <div class={styles.cellContent}>
+                        <Show
+                            when={c().kind === CellKind.Object}
+                            fallback={
+                                <MorphismCellEditor
+                                    doc={props.doc}
+                                    cell={c() as SchemaMorphismCell}
+                                    kind={kind() === "mapping" ? "mapping" : "attr"}
+                                />
+                            }
+                        >
+                            <ObjectCellEditor
+                                object={c() as ObjectCell}
+                                boxed={kind() === "entity"}
+                                readonly={kind() === "attrType"}
+                            />
+                        </Show>
+                    </div>
+                    <Show when={kind()}>
+                        {(k) => <div class={styles.cellTag}>{SCHEMA_CELL_LABEL[k()]}</div>}
+                    </Show>
+                </li>
+            )}
+        </Show>
+    );
+}
+
+/**
+ * An object cell: a single monospace name. Entities are wrapped in a 1px box
+ * (like a CatColab Entity declaration); attribute types are shown read-only.
+ */
+function ObjectCellEditor(props: { object: ObjectCell; boxed: boolean; readonly?: boolean }) {
+    return (
+        <div
+            classList={{
+                [styles.formalJudgment ?? ""]: true,
+                [styles.objectDecl ?? ""]: true,
+                [styles.box ?? ""]: props.boxed,
+            }}
+        >
+            <Show
+                when={!props.readonly}
+                fallback={<span class={styles.code}>{props.object.label}</span>}
+            >
+                <NameField
+                    class={`${styles.nameInput} ${styles.code}`}
+                    placeholder="Unnamed"
+                    value={props.object.label}
+                    setValue={(name) => props.object.update({ label: name })}
+                />
+            </Show>
+        </div>
+    );
+}
+
+/** A morphism cell rendered `dom ──name──▶ cod`, matching CatColab's layout. */
+function MorphismCellEditor(props: {
+    doc: DemoDocument;
+    cell: SchemaMorphismCell;
+    kind: "mapping" | "attr";
+}) {
+    const doc = () => props.doc;
+    const entities = () => (doc().trackSchema(), entityCells(doc()));
+
+    const setDomain = (id: string) => {
+        const entity = entities().find((e) => e.id === id);
+        if (entity) {
+            props.cell.update({ from: entity });
+        }
+    };
+    const setMappingCodomain = (id: string) => {
+        const entity = entities().find((e) => e.id === id);
+        if (entity) {
+            props.cell.update({ to: entity });
+        }
+    };
+
+    // Reactive endpoint ids: read `trackSchema` so, after the option list
+    // re-renders on a schema change, the select re-applies the right selection
+    // (a `<select>` otherwise snaps back to its first option).
+    const fromId = () => (doc().trackSchema(), endpoint(props.cell.from)?.id ?? "");
+    const toId = () => (doc().trackSchema(), endpoint(props.cell.to)?.id ?? "");
+    const toName = () => (doc().trackSchema(), endpoint(props.cell.to)?.label ?? "String");
+    const setAttrCodomain = (name: AttrTypeName) => {
+        props.cell.update({ to: doc().attrTypes[name] });
+    };
+
+    return (
+        <div class={`${styles.formalJudgment} ${styles.morphismDecl}`}>
+            <select
+                class={`${styles.endpoint} ${styles.code}`}
+                onChange={(e) => setDomain(e.currentTarget.value)}
+            >
+                <For each={entities()}>
+                    {(entity) => (
+                        <option value={entity.id} selected={entity.id === fromId()}>
+                            {entity.label || "•"}
+                        </option>
+                    )}
+                </For>
+            </select>
+
+            <div class={styles.arrowWithName}>
+                <NameField
+                    class={`${styles.arrowName} ${styles.code}`}
+                    placeholder="Unnamed"
+                    value={props.cell.label}
+                    setValue={(name) => props.cell.update({ label: name })}
+                />
+                <div class={styles.arrowContainer}>
+                    <div class={styles.arrow} />
+                </div>
+            </div>
+
+            <Show
+                when={props.kind === "mapping"}
+                fallback={
+                    <select
+                        class={`${styles.endpoint} ${styles.code}`}
+                        onChange={(e) => setAttrCodomain(e.currentTarget.value as AttrTypeName)}
+                    >
+                        <option value="String" selected={toName() === "String"}>
+                            String
+                        </option>
+                        <option value="Number" selected={toName() === "Number"}>
+                            Number
+                        </option>
+                    </select>
+                }
+            >
+                <select
+                    class={`${styles.endpoint} ${styles.code}`}
+                    onChange={(e) => setMappingCodomain(e.currentTarget.value)}
+                >
+                    <For each={entities()}>
+                        {(entity) => (
+                            <option value={entity.id} selected={entity.id === toId()}>
+                                {entity.label || "•"}
+                            </option>
+                        )}
+                    </For>
+                </select>
+            </Show>
+        </div>
+    );
+}
+
+/** The list of cell types offered by the new-cell menu (never "Attribute type"). */
+const CELL_TYPES: { kind: "entity" | "mapping" | "attr"; name: string; description: string }[] = [
+    { kind: "entity", name: "Entity", description: "A type of thing, i.e. a database table." },
+    {
+        kind: "mapping",
+        name: "Mapping",
+        description: "A foreign key from one entity to another entity.",
+    },
+    { kind: "attr", name: "Attribute", description: "A String- or Number-valued column." },
+];
+
+/** Insert a new cell of the given kind, adding an entity first if one is needed. */
+function addCell(doc: DemoDocument, kind: "entity" | "mapping" | "attr") {
+    if (kind === "entity") {
+        doc.schema.add(Entity, { label: "" });
+        return;
+    }
+    // A mapping/attribute needs a domain entity; create one if none exists yet.
+    const entity = entityCells(doc)[0] ?? doc.schema.add(Entity, { label: "" });
+    if (kind === "mapping") {
+        // A mapping is a foreign key between entities: entity -> entity.
+        doc.schema.add(Mapping, { label: "", from: entity, to: entity });
+    } else {
+        doc.schema.add(Attr, { label: "", from: entity, to: doc.attrTypes.String });
+    }
+}
+
+/** A popover-style new-cell button (the "+" gutter affordance and the footer). */
+function AddCellButton(props: { doc: DemoDocument; icon: string }) {
+    const [open, setOpen] = createSignal(false);
+
+    return (
+        <div class={styles.addCell}>
+            <button
+                class={styles.addCellButton}
+                type="button"
+                title="Add a cell"
+                onClick={() => setOpen((v) => !v)}
+            >
+                {props.icon}
+            </button>
+            <Show when={open()}>
+                <>
+                    <div class={styles.addCellBackdrop} onClick={() => setOpen(false)} />
+                    <ul class={styles.addCellMenu}>
+                        <For each={CELL_TYPES}>
+                            {(type) => (
+                                <li
+                                    class={styles.addCellOption}
+                                    onClick={() => {
+                                        addCell(props.doc, type.kind);
+                                        setOpen(false);
+                                    }}
+                                >
+                                    <div class={styles.addCellName}>{type.name}</div>
+                                    <div class={styles.addCellDescription}>{type.description}</div>
+                                </li>
+                            )}
+                        </For>
+                    </ul>
+                </>
+            </Show>
+        </div>
+    );
+}
+
+/** The end-of-notebook add-cell placeholder. */
+function AddCellPlaceholder(props: { doc: DemoDocument }) {
+    return (
+        <div class={styles.notebookCellPlaceholder}>
+            <AddCellButton doc={props.doc} icon="+" />
+            <span>Add a cell</span>
+        </div>
+    );
+}
diff --git a/packages/document-methods/demo/src/ScriptSidebar.module.css b/packages/document-methods/demo/src/ScriptSidebar.module.css
new file mode 100644
index 000000000..edde25e50
--- /dev/null
+++ b/packages/document-methods/demo/src/ScriptSidebar.module.css
@@ -0,0 +1,163 @@
+/* The single script panel, docked along the bottom of the whole app and taking
+   up a fixed slice of its height (it edits both the schema and the instance). */
+.scriptSidebar {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    height: 40vh;
+    flex: none;
+    border-top: 2px solid var(--color-gray-150);
+    min-height: 0;
+    overflow: hidden;
+    background: var(--color-background);
+}
+
+.header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.5rem 0.75rem;
+    border-bottom: 1px solid var(--color-gray-300);
+    font-size: 0.85rem;
+    font-weight: 500;
+    color: var(--color-text-secondary);
+}
+
+/* The editing area: a highlighted layer and the transparent textarea stacked on
+   top of one another. Both must share identical text metrics so the caret and
+   the highlighted glyphs line up exactly. This box is the single scroll
+   container: both layers grow to their content height inside it and scroll
+   together as one, so wheel/trackpad scrolling works in every browser (Firefox
+   in particular does not reliably wheel-scroll an absolutely-positioned,
+   content-clipping textarea). */
+.editorArea {
+    position: relative;
+    flex: 1;
+    min-height: 0;
+    overflow-x: hidden;
+    overflow-y: auto;
+}
+
+/* Shared text metrics for both the textarea and the highlight layer. Any change
+   here must apply to both, or the two will drift out of alignment. */
+.editorArea,
+.editor,
+.highlight :global(pre),
+.highlight :global(code) {
+    font-family: var(--mono-font);
+    font-size: 1.15rem;
+    line-height: 1.6;
+    tab-size: 2;
+}
+
+/* The highlighted code, drawn underneath the textarea. `CodeView` emits its own
+   <pre>; strip its background and padding so it aligns with the textarea and
+   shows this panel's background instead. It is pinned to the top of the scroll
+   container and drawn at its full content height, so it scrolls together with
+   the textarea overlaid on it. */
+.highlight {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    min-height: 100%;
+    padding: 0.75rem;
+    pointer-events: none;
+    white-space: pre-wrap;
+    word-break: break-word;
+    overflow: visible;
+}
+
+.highlight :global(pre),
+.highlight :global(code) {
+    margin: 0;
+    padding: 0;
+    background: transparent !important;
+    white-space: pre-wrap;
+    word-break: break-word;
+}
+
+/* The textarea sits on top, its text transparent so only its caret and
+   selection show; the highlight layer beneath supplies the visible glyphs. It
+   lives in the flow of the scrolling `.editorArea` and is grown by JS to its
+   content height (never scrolling internally — `overflow: hidden`), so the
+   container scrolls it and the highlight layer together as one. `min-height:
+   100%` keeps it filling the pane (and clickable) when the code is short. */
+.editor {
+    position: relative;
+    z-index: 1;
+    display: block;
+    width: 100%;
+    min-height: 100%;
+    height: auto;
+    resize: none;
+    border: none;
+    outline: none;
+    margin: 0;
+    padding: 0.75rem;
+    background: transparent;
+    color: transparent;
+    caret-color: var(--color-foreground);
+    white-space: pre-wrap;
+    word-break: break-word;
+    overflow: hidden;
+}
+
+.editor::placeholder {
+    color: var(--color-text-placeholder);
+}
+
+/* The textarea's text is transparent, so its selection highlight would paint an
+   opaque band over the highlighted code beneath. Use a translucent selection so
+   the highlighted glyphs stay legible through the selection. */
+.editor::selection {
+    background: color-mix(in srgb, var(--color-topos-primary) 30%, transparent);
+}
+
+.footer {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.5rem 0.75rem;
+    border-top: 1px solid var(--color-gray-300);
+}
+
+.runButton {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 5px 12px;
+    font-size: 0.8rem;
+    font-weight: 500;
+    border: 1px solid var(--color-topos-primary);
+    border-radius: 6px;
+    background: var(--color-topos-primary);
+    color: var(--color-background);
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.runButton:hover {
+    background: var(--color-topos-primary-hover);
+    border-color: var(--color-topos-primary-hover);
+}
+
+/* The result/error line shown after running. */
+.status {
+    flex: 1;
+    min-width: 0;
+    font-size: 0.75rem;
+    white-space: pre-wrap;
+    word-break: break-word;
+    max-height: 6rem;
+    overflow-y: auto;
+    font-family: var(--mono-font);
+}
+
+.status[data-tag="ok"] {
+    color: var(--color-topos-primary-hover);
+}
+
+.status[data-tag="error"] {
+    color: var(--color-alert-danger);
+}
diff --git a/packages/document-methods/demo/src/ScriptSidebar.tsx b/packages/document-methods/demo/src/ScriptSidebar.tsx
new file mode 100644
index 000000000..274cbca10
--- /dev/null
+++ b/packages/document-methods/demo/src/ScriptSidebar.tsx
@@ -0,0 +1,139 @@
+import { createEffect, createSignal, on, onMount, Show } from "solid-js";
+
+import { CodeView } from "catcolab-ui-components";
+import { formatRunValue, runScript } from "./script-scopes";
+
+import styles from "./ScriptSidebar.module.css";
+
+/** The last-run outcome shown under the editor. */
+type RunStatus = { tag: "ok" | "error"; message: string } | undefined;
+
+/**
+ * A docked sidebar holding a JavaScript editor that mutates a demo document.
+ *
+ * The sidebar is neutral about *what* it edits: the caller supplies the named
+ * values exposed to the script body via {@link ScriptSidebar.scope}, a starter
+ * script, and the localStorage key under which the source is persisted. The demo
+ * hands it a single merged scope — the schema notebook, the instance, and the
+ * simple-schema generator defs — so one script can edit both sides. Because the
+ * script calls the same document API the rest of the editor uses, every mutation
+ * flows through the document's change notification and the notebook UI, the
+ * instance, history, and persistence all update exactly as they do for
+ * point-and-click edits.
+ *
+ * The script body is `eval`ed in an async function so it may `await`, and its
+ * return value (or thrown error) is surfaced in the status line. This is a demo
+ * affordance, not a sandbox: the script has full access to the page.
+ */
+export function ScriptSidebar(props: {
+    /** The named values exposed to the script body. */
+    scope: Record<string, unknown>;
+    /**
+     * The current editor source. It is owned by the caller (so the WebMCP
+     * `set_script` tool and this editor write to the same state), making this a
+     * controlled editor.
+     */
+    source: string;
+    /** Called with the new source on every edit; the caller persists it. */
+    onSourceChange: (value: string) => void;
+}) {
+    const source = () => props.source;
+    const [status, setStatus] = createSignal<RunStatus>();
+
+    // The `.editorArea` is the single scroll container; the textarea and the
+    // highlight layer both live inside it and scroll together. A textarea does
+    // not size to its content on its own, so grow it to fit: match its height to
+    // its scroll height so it never scrolls internally (which Firefox handles
+    // inconsistently for a transparent overlay) and instead the surrounding
+    // container scrolls both layers as one.
+    let textareaEl: HTMLTextAreaElement | undefined;
+    const autoGrow = () => {
+        if (!textareaEl) {
+            return;
+        }
+        // Reset first so shrinking the text also shrinks the box.
+        textareaEl.style.height = "0px";
+        textareaEl.style.height = `${textareaEl.scrollHeight}px`;
+    };
+
+    const update = (value: string) => {
+        props.onSourceChange(value);
+        autoGrow();
+    };
+
+    onMount(autoGrow);
+
+    // Re-fit the textarea whenever the source changes from *outside* the editor
+    // (e.g. the WebMCP `set_script` tool), so a set script is fully visible
+    // without the user having to type into the box.
+    createEffect(on(source, autoGrow));
+
+    const run = async () => {
+        setStatus(undefined);
+        const result = await runScript(props.scope, source());
+        if (result.tag === "ok") {
+            setStatus({
+                tag: "ok",
+                message:
+                    result.value === undefined
+                        ? "Ran successfully."
+                        : `→ ${formatRunValue(result.value)}`,
+            });
+        } else {
+            setStatus({ tag: "error", message: String(result.error) });
+        }
+    };
+
+    // Ctrl/Cmd+Enter runs the script from within the editor.
+    const onKeyDown = (evt: KeyboardEvent) => {
+        if ((evt.metaKey || evt.ctrlKey) && evt.key === "Enter") {
+            evt.preventDefault();
+            void run();
+        }
+    };
+
+    return (
+        <div class={styles.scriptSidebar}>
+            <div class={styles.header}>
+                <span>Script</span>
+            </div>
+            <div class={styles.editorArea}>
+                {/* A syntax-highlighted layer (shiki, via ui-components'
+                    `CodeView`) sits underneath a transparent textarea, so the
+                    user types into the textarea while seeing highlighted code.
+                    A trailing newline keeps the highlight layer's height in
+                    sync with the textarea's when the source ends in a newline.
+
+                    Both layers grow to their content height and are scrolled
+                    together by the enclosing `.editorArea`, so scrolling works
+                    the same in every browser. */}
+                <div class={styles.highlight} aria-hidden="true">
+                    <CodeView text={`${source()}\n`} lang="javascript" />
+                </div>
+                <textarea
+                    ref={textareaEl}
+                    class={styles.editor}
+                    spellcheck={false}
+                    autocomplete="off"
+                    autocapitalize="off"
+                    value={source()}
+                    onInput={(e) => update(e.currentTarget.value)}
+                    onKeyDown={onKeyDown}
+                    placeholder="// JavaScript…"
+                />
+            </div>
+            <div class={styles.footer}>
+                <button class={styles.runButton} type="button" onClick={() => void run()}>
+                    Run
+                </button>
+                <Show when={status()}>
+                    {(s) => (
+                        <div class={styles.status} data-tag={s().tag}>
+                            {s().message}
+                        </div>
+                    )}
+                </Show>
+            </div>
+        </div>
+    );
+}
diff --git a/packages/document-methods/demo/src/ScriptToggle.tsx b/packages/document-methods/demo/src/ScriptToggle.tsx
new file mode 100644
index 000000000..c2999a774
--- /dev/null
+++ b/packages/document-methods/demo/src/ScriptToggle.tsx
@@ -0,0 +1,10 @@
+import { Button } from "catcolab-ui-components";
+
+/** A toolbar button that toggles the demo's single (app-wide) script pane. */
+export function ScriptToggle(props: { open: boolean; onToggle: () => void }) {
+    return (
+        <Button onClick={() => props.onToggle()} aria-pressed={props.open}>
+            Script
+        </Button>
+    );
+}
diff --git a/packages/document-methods/demo/src/css.d.ts b/packages/document-methods/demo/src/css.d.ts
new file mode 100644
index 000000000..8984e63ec
--- /dev/null
+++ b/packages/document-methods/demo/src/css.d.ts
@@ -0,0 +1,6 @@
+declare module "*.module.css" {
+    const classes: Record<string, string>;
+    export default classes;
+}
+
+declare module "*.css";
diff --git a/packages/document-methods/demo/src/document.ts b/packages/document-methods/demo/src/document.ts
new file mode 100644
index 000000000..2fe45dbbd
--- /dev/null
+++ b/packages/document-methods/demo/src/document.ts
@@ -0,0 +1,449 @@
+import {
+    type NotebookCell,
+    CellKind,
+    createBinder,
+    type DocumentRef,
+    type DocumentStore,
+    type InstanceDocument,
+    type Instance,
+    type ModelDocument,
+    type Notebook,
+    type ObjectCell,
+    type Row,
+} from "catcolab-documents";
+import { Attr, AttrType, Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { createSignal } from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { v7 } from "uuid";
+
+import type { Document } from "catcolab-document-types";
+import { createLocalHistory, type LocalHistory, type PersistedHistory } from "./history";
+
+/**
+ * The demo's document layer. It owns one schema notebook and one instance drawn
+ * over it, backed by a Solid store projection so notebook/instance reads are
+ * tracked with fine-grained reactivity.
+ */
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+    ref: DocumentRef;
+};
+
+const handleById = new Map<string, SolidStoreHandle>();
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const id = v7();
+        const draftDoc = structuredClone(initialDoc);
+        const [docView, setDocView] = createStore<Document>(initialDoc);
+        const handle: SolidStoreHandle = {
+            draftDoc,
+            docView,
+            setDocView,
+            listeners: new Set(),
+            ref: { id, version: null, server: "" },
+        };
+        handleById.set(id, handle);
+        return handle;
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    getDocumentRef: (handle) => handle.ref,
+    getHandle: async (ref) => {
+        const handle = handleById.get(ref.id);
+        return handle
+            ? { tag: "Ok", content: handle }
+            : {
+                  tag: "Err",
+                  content: [{ message: `Cannot resolve reference "${ref.id}".`, path: ["id"] }],
+              };
+    },
+};
+
+const solidBinder = createBinder(solidStore);
+
+/** The two hard-coded attribute types this demo offers: Number and String. */
+export type AttrTypeName = "Number" | "String";
+
+export type DemoDocument = {
+    schema: Notebook<typeof SimpleSchema, SolidStoreHandle>;
+    instance: Instance<(typeof SimpleSchema)["Diagram"], SolidStoreHandle>;
+    /** The two fixed attribute-type cells, keyed by name. */
+    attrTypes: Record<AttrTypeName, NotebookCell<typeof AttrType>>;
+    /** Read in a reactive scope to re-run when the schema changes. */
+    trackSchema: () => number;
+    /** Read in a reactive scope to re-run when the instance changes. */
+    trackInstance: () => number;
+    /** Snapshot history for the schema document, driving its sidebar. */
+    schemaHistory: LocalHistory;
+    /** Snapshot history for the instance document, driving its sidebar. */
+    instanceHistory: LocalHistory;
+    /** Wipe the persisted schema + instance and reload the page from scratch. */
+    clear: () => void;
+    /** Persistence failure that needs user recovery, if any. */
+    storageProblem: () => string | undefined;
+};
+
+/** The localStorage key under which the demo's schema + instance are persisted. */
+const STORAGE_KEY = "catcolab-instances-demo";
+
+/** The persisted shape: a dumped schema model document and instance document. */
+type PersistedState = {
+    schema: ModelDocument;
+    instance: InstanceDocument;
+    /** The schema document's snapshot history, so undo/redo survive a reload. */
+    schemaHistory?: PersistedHistory<ModelDocument>;
+    /** The instance document's snapshot history, so undo/redo survive a reload. */
+    instanceHistory?: PersistedHistory<InstanceDocument>;
+};
+
+type LoadedPersistedState = {
+    state?: PersistedState;
+    problem?: string;
+};
+
+function storageProblem(action: string, error?: unknown) {
+    const detail = error instanceof Error ? ` ${error.message}` : "";
+    return `Could not ${action} local storage.${detail}`;
+}
+
+/** Read persisted state from localStorage, or `undefined` if none/invalid. */
+function loadPersisted(): LoadedPersistedState {
+    let raw: string | null;
+    try {
+        raw = localStorage.getItem(STORAGE_KEY);
+    } catch (error) {
+        return { problem: storageProblem("read", error) };
+    }
+    if (!raw) {
+        return {};
+    }
+    try {
+        return { state: JSON.parse(raw) as PersistedState };
+    } catch (error) {
+        return { problem: storageProblem("load", error) };
+    }
+}
+
+/**
+ * Look up the two fixed attribute-type cells by name in a schema, adding any
+ * that are missing. A freshly created schema has none; a reloaded one already
+ * carries them (they are ordinary AttrType objects), so we reuse those.
+ */
+function ensureAttrTypes(
+    schema: Notebook<typeof SimpleSchema>,
+): Record<AttrTypeName, NotebookCell<typeof AttrType>> {
+    const existing = schema.cellsOf(AttrType);
+    const find = (name: AttrTypeName) => existing.find((c) => c.label === name);
+    return {
+        Number: find("Number") ?? schema.add(AttrType, { label: "Number" }),
+        String: find("String") ?? schema.add(AttrType, { label: "String" }),
+    };
+}
+
+/** Build the schema + instance and wire their change signals. */
+export async function createDemoDocument(): Promise<DemoDocument> {
+    const loadedPersisted = loadPersisted();
+    const [storageProblemMessage, setStorageProblemMessage] = createSignal(loadedPersisted.problem);
+    const persisted = loadedPersisted.state;
+    let persistenceBlocked = Boolean(loadedPersisted.problem);
+
+    let schema: Notebook<typeof SimpleSchema>;
+    let instance: Instance;
+    if (persisted) {
+        try {
+            const loaded = await solidBinder.loadNotebook(SimpleSchema, persisted.schema);
+            if (loaded.tag === "Ok") {
+                schema = loaded.content;
+                instance = await solidBinder.loadInstance(schema, persisted.instance);
+            } else {
+                throw new Error("Stored schema no longer matches the expected shape.");
+            }
+        } catch (error) {
+            setStorageProblemMessage(storageProblem("load", error));
+            persistenceBlocked = true;
+            schema = await solidBinder.createNotebook(SimpleSchema, { name: "Schema" });
+            instance = await solidBinder.createInstance(schema, { name: "Instance" });
+        }
+    } else {
+        schema = await solidBinder.createNotebook(SimpleSchema, { name: "Schema" });
+        instance = await solidBinder.createInstance(schema, { name: "Instance" });
+    }
+
+    // The two hard-coded attribute types. They are ordinary AttrType objects in
+    // the schema; the demo just never lets the user add or remove them, so the
+    // only attribute codomains ever offered are Number and String.
+    const attrTypes = ensureAttrTypes(schema);
+
+    const [schemaVersion, setSchemaVersion] = createSignal(0);
+    const [instanceVersion, setInstanceVersion] = createSignal(0);
+
+    // The latest persisted history states, kept here so the single `persist()`
+    // below writes them alongside the document dumps. They are updated by each
+    // history's `onChange`, and seeded from any persisted state so a reload
+    // resumes the existing chain rather than starting a fresh one.
+    let schemaHistoryState: PersistedHistory<ModelDocument> | undefined = persisted?.schemaHistory;
+    let instanceHistoryState: PersistedHistory<InstanceDocument> | undefined =
+        persisted?.instanceHistory;
+
+    /** Persist the current schema + instance dumps (and histories) to localStorage. */
+    const persist = () => {
+        if (persistenceBlocked) {
+            return;
+        }
+        try {
+            const state: PersistedState = {
+                schema: schema.dump(),
+                instance: instance.dump(),
+                schemaHistory: schemaHistoryState,
+                instanceHistory: instanceHistoryState,
+            };
+            localStorage.setItem(STORAGE_KEY, JSON.stringify(state));
+        } catch (error) {
+            setStorageProblemMessage(storageProblem("save to", error));
+        }
+    };
+
+    // Coalesce the expensive per-change side effects. A single scripted run can
+    // fire `onChange` hundreds of times synchronously (one per added cell/row and
+    // per attribute set); doing a full `persist()` (dump + stringify + write) and
+    // bumping the reactive signals on *every* one is O(N²) and thrashes the UI.
+    // Instead each change only marks what is dirty and schedules one flush on the
+    // next microtask, so a burst collapses into a single persist and a single UI
+    // update once the burst settles. Individual interactive edits (which are not
+    // in a burst) still flush on the very next tick, so they feel immediate.
+    //
+    let schemaDirty = false;
+    let instanceDirty = false;
+    let flushScheduled = false;
+    // Set around a history restore so the change it provokes is persisted and
+    // reflected in the UI, but not recorded as a *new* snapshot (which would
+    // branch history on every undo/redo). The history's own `record` guard runs
+    // synchronously inside `restore`; because we defer `record` to the flush,
+    // which runs after `restore` returns, we must suppress recording here too.
+    let restoring = false;
+
+    const flush = () => {
+        flushScheduled = false;
+        const schemaChanged = schemaDirty;
+        const instanceChanged = instanceDirty;
+        schemaDirty = false;
+        instanceDirty = false;
+        if (!schemaChanged && !instanceChanged) {
+            return;
+        }
+        // One persist for the whole burst, then bump each dirty signal once so
+        // reactive consumers re-read exactly once.
+        persist();
+        if (schemaChanged) {
+            setSchemaVersion((v) => v + 1);
+        }
+        if (instanceChanged) {
+            setInstanceVersion((v) => v + 1);
+        }
+        // History recording is itself debounced, so a burst of changes still
+        // records a single snapshot once edits pause. Skip it entirely while a
+        // restore is in flight, so navigating history does not branch it.
+        if (!restoring) {
+            if (schemaChanged) {
+                schemaHistory.record();
+            }
+            if (instanceChanged) {
+                instanceHistory.record();
+            }
+        }
+    };
+
+    const scheduleFlush = () => {
+        if (flushScheduled) {
+            return;
+        }
+        flushScheduled = true;
+        queueMicrotask(flush);
+    };
+
+    // Snapshot history for each document. A snapshot is a detached dump; a
+    // restore writes it back onto the live draft through the Solid store, so every
+    // reactive consumer (and the other document, for the schema) re-renders
+    // exactly as it does on an ordinary edit.
+    // Each history is seeded from, and persisted back into, localStorage so the
+    // undo/redo chain survives a reload.
+    //
+    // A restore flushes synchronously (with `restoring` set, so no new snapshot is
+    // recorded) rather than through the deferred microtask, so the UI reflects the
+    // restored state immediately on undo/redo.
+    const runRestore = (mutate: () => void) => {
+        restoring = true;
+        try {
+            mutate();
+            flush();
+        } finally {
+            restoring = false;
+        }
+    };
+    const schemaHistory = createLocalHistory<ModelDocument>({
+        capture: () => schema.dump(),
+        restore: (snapshot) => {
+            runRestore(() => {
+                solidStore.changeDocument(schema.handle, (doc) => {
+                    Object.assign(doc, structuredClone(snapshot));
+                });
+            });
+        },
+        equal: (a, b) => JSON.stringify(a) === JSON.stringify(b),
+        initial: persisted?.schemaHistory,
+        onChange: (state) => {
+            schemaHistoryState = state;
+            persist();
+        },
+    });
+    const instanceHistory = createLocalHistory<InstanceDocument>({
+        capture: () => instance.dump(),
+        restore: (snapshot) => {
+            runRestore(() => {
+                solidStore.changeDocument(instance.handle, (doc) => {
+                    Object.assign(doc, structuredClone(snapshot));
+                });
+            });
+        },
+        equal: (a, b) => JSON.stringify(a) === JSON.stringify(b),
+        initial: persisted?.instanceHistory,
+        onChange: (state) => {
+            instanceHistoryState = state;
+            persist();
+        },
+    });
+
+    // A schema edit can invalidate the instance (e.g. a mapping's codomain
+    // changing), so mark the instance dirty too when the schema changes.
+    schema.onChange(() => {
+        schemaDirty = true;
+        instanceDirty = true;
+        scheduleFlush();
+    });
+    instance.onChange(() => {
+        instanceDirty = true;
+        scheduleFlush();
+    });
+
+    // Persist the initial state so a first-run demo is saved even before an edit.
+    persist();
+    // Seed each history with the initial state so there is always a snapshot to
+    // return to. Immediate (not debounced): the seed must exist right away. On a
+    // reload this is a no-op — the resumed chain's current entry already equals
+    // the loaded document state, so `recordNow` records nothing.
+    schemaHistory.recordNow();
+    instanceHistory.recordNow();
+
+    return {
+        schema,
+        instance,
+        attrTypes,
+        trackSchema: schemaVersion,
+        trackInstance: instanceVersion,
+        schemaHistory,
+        instanceHistory,
+        storageProblem: storageProblemMessage,
+        clear: () => {
+            // Remove the persisted schema + instance and every key derived from
+            // the demo's prefix (the schema/instance script sources), so resetting
+            // clears the scripts too.
+            try {
+                for (const key of Object.keys(localStorage)) {
+                    if (key === STORAGE_KEY || key.startsWith(`${STORAGE_KEY}:`)) {
+                        localStorage.removeItem(key);
+                    }
+                }
+                location.reload();
+            } catch (error) {
+                setStorageProblemMessage(storageProblem("clear", error));
+            }
+        },
+    };
+}
+
+/** The formal cell kinds this simple-schema notebook shows. */
+export type SchemaCellKind = "entity" | "mapping" | "attr" | "attrType";
+
+/** A formal cell of the schema notebook, as returned by {@link schemaCells}. */
+export type SchemaCell = ReturnType<Notebook<typeof SimpleSchema>["formalCells"]>[number];
+
+/** The human tag shown at the right of a schema cell, matching CatColab. */
+export const SCHEMA_CELL_LABEL: Record<SchemaCellKind, string> = {
+    entity: "Entity",
+    mapping: "Mapping",
+    attr: "Attribute",
+    attrType: "Attribute type",
+};
+
+/**
+ * Classify a schema notebook cell by its definition.
+ *
+ * A cell's stored `type` is reconstructed from storage and is *not* referentially
+ * equal to the `Entity`/`Mapping`/… defs, so we classify by structural membership
+ * via `cellsOf` (the same matching the rest of the demo relies on), comparing by
+ * cell id.
+ */
+export function schemaCellKind(doc: DemoDocument, cell: SchemaCell): SchemaCellKind | undefined {
+    if (cell.kind === CellKind.Object) {
+        if (doc.schema.cellsOf(Entity).some((c) => c.id === cell.id)) {
+            return "entity";
+        }
+        if (doc.schema.cellsOf(AttrType).some((c) => c.id === cell.id)) {
+            return "attrType";
+        }
+    }
+    if (cell.kind === CellKind.Morphism) {
+        if (doc.schema.cellsOf(Mapping).some((c) => c.id === cell.id)) {
+            return "mapping";
+        }
+        if (doc.schema.cellsOf(Attr).some((c) => c.id === cell.id)) {
+            return "attr";
+        }
+    }
+    return undefined;
+}
+
+/** Every formal cell of the schema, in notebook (insertion) order. */
+export function schemaCells(doc: DemoDocument): SchemaCell[] {
+    return doc.schema.formalCells();
+}
+
+/** Every entity (user-defined object) cell in the schema, in notebook order. */
+export function entityCells(doc: DemoDocument): NotebookCell<typeof Entity>[] {
+    return doc.schema.cellsOf(Entity);
+}
+
+/** Every mapping (entity -> entity) cell in the schema. */
+export function mappingCells(doc: DemoDocument) {
+    return doc.schema.cellsOf(Mapping);
+}
+
+/** Every attribute (entity -> AttrType) cell in the schema. */
+export function attrCells(doc: DemoDocument) {
+    return doc.schema.cellsOf(Attr);
+}
+
+/** All rows of an entity in the instance. */
+export function rowsOf(doc: DemoDocument, entity: ObjectCell): Row[] {
+    return doc.instance.rowsOf(entity);
+}
+
+export { CellKind };
diff --git a/packages/document-methods/demo/src/history.ts b/packages/document-methods/demo/src/history.ts
new file mode 100644
index 000000000..4633d5027
--- /dev/null
+++ b/packages/document-methods/demo/src/history.ts
@@ -0,0 +1,195 @@
+import { createSignal } from "solid-js";
+import { v7 } from "uuid";
+
+import type { HistoryItem } from "catcolab-ui-components";
+
+/**
+ * A local, in-memory snapshot history for a single document, modelled to drive
+ * the shared `HistoryNavigator` exactly as the frontend's server-backed snapshot
+ * history does — but without a server.
+ *
+ * The frontend records a snapshot per synced change and navigates by asking the
+ * backend to repoint the live document at a chosen snapshot. Here the document
+ * lives entirely in memory (the plain store's handle *is* the document object),
+ * so a "snapshot" is a deep copy of the document's dump and navigating is
+ * restoring that copy back onto the live document in place — which fires the
+ * document's own change notification and so re-renders every reactive consumer.
+ *
+ * The chain is linear: recording a new snapshot while not at the tip drops the
+ * (now diverged) forward entries, matching ordinary undo/redo. Entries are held
+ * oldest-first internally and surfaced newest-first as `HistoryItem[]`, as the
+ * navigator expects.
+ */
+export type LocalHistory = {
+    /** History entries newest-first, for the `HistoryNavigator`. */
+    items: () => HistoryItem[];
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    onUndo: () => void;
+    onRedo: () => void;
+    /** Navigate to the snapshot with the given id (restores it in place). */
+    navigate: (id: string) => void;
+    /**
+     * Record the current document state as a new snapshot at the tip, *debounced*
+     * so a rapid burst of edits (e.g. typing a name) coalesces into one entry
+     * taken once edits pause. A no-op while a restore is in flight (so restoring
+     * does not itself branch history) and when the state is identical to the
+     * current snapshot.
+     */
+    record: () => void;
+    /**
+     * Record the current state immediately, bypassing the debounce — for the
+     * initial seed, so there is always a snapshot to return to right away.
+     */
+    recordNow: () => void;
+};
+
+type Entry<S> = {
+    id: string;
+    createdAt: number;
+    snapshot: S;
+};
+
+/**
+ * The serializable form of a {@link LocalHistory}: its full snapshot chain
+ * (oldest-first) and the index currently navigated to. This is exactly what is
+ * persisted to (and restored from) storage so history survives a reload.
+ */
+export type PersistedHistory<Snapshot> = {
+    entries: Entry<Snapshot>[];
+    currentIndex: number;
+};
+
+/**
+ * Build a {@link LocalHistory} over a document.
+ *
+ * @param capture  Take a deep, detached snapshot of the current document state.
+ * @param restore  Write a snapshot back onto the live document in place.
+ * @param equal    Whether two snapshots are equal, so identical consecutive
+ *                 states are not recorded as separate entries.
+ * @param initial  A previously {@link PersistedHistory} to resume from, so the
+ *                 snapshot chain (and where in it we are) survives a reload.
+ * @param onChange Called with the full {@link PersistedHistory} whenever the
+ *                 chain or the current index changes, so the host can persist it.
+ */
+export function createLocalHistory<Snapshot>(opts: {
+    capture: () => Snapshot;
+    restore: (snapshot: Snapshot) => void;
+    equal: (a: Snapshot, b: Snapshot) => boolean;
+    initial?: PersistedHistory<Snapshot>;
+    onChange?: (state: PersistedHistory<Snapshot>) => void;
+}): LocalHistory {
+    const [entries, setEntries] = createSignal<Entry<Snapshot>[]>(opts.initial?.entries ?? []);
+    const [currentIndex, setCurrentIndex] = createSignal(
+        opts.initial ? opts.initial.currentIndex : -1,
+    );
+
+    /** Persist the current chain + index through the host's `onChange`, if any. */
+    const persist = () => {
+        opts.onChange?.({ entries: entries(), currentIndex: currentIndex() });
+    };
+    // Set while a restore is applying, so the change it provokes is not recorded
+    // as a fresh snapshot (which would branch history on every navigation).
+    let restoring = false;
+
+    /** How long a burst of edits is coalesced into one snapshot, in ms. */
+    const DEBOUNCE_MS = 500;
+    // Pending debounced snapshot, if any: a rapid run of edits (e.g. typing a
+    // name character by character) is collapsed into a single entry taken once
+    // edits pause for `DEBOUNCE_MS`.
+    let debounceTimer: ReturnType<typeof setTimeout> | undefined;
+
+    const recordNow = () => {
+        if (restoring) {
+            return;
+        }
+        const snapshot = opts.capture();
+        const idx = currentIndex();
+        const chain = entries();
+        const current = chain[idx];
+        if (current && opts.equal(current.snapshot, snapshot)) {
+            return;
+        }
+        // Drop any forward (redo) entries: a new edit diverges from them.
+        const kept = chain.slice(0, idx + 1);
+        const entry: Entry<Snapshot> = { id: v7(), createdAt: Date.now(), snapshot };
+        setEntries([...kept, entry]);
+        setCurrentIndex(kept.length);
+        persist();
+    };
+
+    const record = () => {
+        // Never record while restoring — and drop any timer a prior edit armed,
+        // so a restore mid-burst does not later snapshot the restored state.
+        if (restoring) {
+            if (debounceTimer !== undefined) {
+                clearTimeout(debounceTimer);
+                debounceTimer = undefined;
+            }
+            return;
+        }
+        if (debounceTimer !== undefined) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(() => {
+            debounceTimer = undefined;
+            recordNow();
+        }, DEBOUNCE_MS);
+    };
+
+    const navigate = (id: string) => {
+        const chain = entries();
+        const idx = chain.findIndex((e) => e.id === id);
+        if (idx < 0 || idx === currentIndex()) {
+            return;
+        }
+        const entry = chain[idx];
+        if (!entry) {
+            return;
+        }
+        restoring = true;
+        try {
+            opts.restore(entry.snapshot);
+        } finally {
+            restoring = false;
+        }
+        setCurrentIndex(idx);
+        persist();
+    };
+
+    const items = (): HistoryItem[] => {
+        const chain = entries();
+        const idx = currentIndex();
+        // Newest-first, as the navigator expects.
+        return chain
+            .map((entry, i) => ({
+                id: entry.id,
+                createdAt: entry.createdAt,
+                active: i === idx,
+            }))
+            .toReversed();
+    };
+
+    const canUndo = () => currentIndex() > 0;
+    const canRedo = () => currentIndex() < entries().length - 1;
+
+    const onUndo = () => {
+        const idx = currentIndex();
+        if (idx > 0) {
+            const prev = entries()[idx - 1];
+            if (prev) {
+                navigate(prev.id);
+            }
+        }
+    };
+
+    const onRedo = () => {
+        const idx = currentIndex();
+        const next = entries()[idx + 1];
+        if (next) {
+            navigate(next.id);
+        }
+    };
+
+    return { items, canUndo, canRedo, onUndo, onRedo, navigate, record, recordNow };
+}
diff --git a/packages/document-methods/demo/src/instance-model.ts b/packages/document-methods/demo/src/instance-model.ts
new file mode 100644
index 000000000..57f1195cd
--- /dev/null
+++ b/packages/document-methods/demo/src/instance-model.ts
@@ -0,0 +1,90 @@
+import type { ObjectCell, Row } from "catcolab-documents";
+import { Entity } from "catcolab-logics/simple-schema";
+
+import { attrCells, type DemoDocument, mappingCells, rowsOf } from "./document";
+
+/**
+ * A column in an entity's instance table. Every column corresponds to one
+ * schema morphism whose *domain* is this entity: an attribute (a literal value)
+ * or a mapping / foreign key (a reference to a row of another entity).
+ */
+export type Column =
+    | {
+          kind: "attr";
+          /** The schema attribute cell id (stable key for this column). */
+          morphismId: string;
+          title: string;
+          /** Number or String — the fixed attribute type. */
+          attrType: "Number" | "String";
+      }
+    | {
+          kind: "mapping";
+          morphismId: string;
+          title: string;
+          /** The entity this foreign key points at. */
+          codomain: ObjectCell;
+      };
+
+/** The full spec of one entity's table: its identity, columns, and rows. */
+export type TableSpec = {
+    entity: ObjectCell;
+    columns: Column[];
+    rows: Row[];
+};
+
+/**
+ * A signature string that changes exactly when a table must be *rebuilt* (as
+ * opposed to merely re-filled with data): the entity set, and each table's
+ * columns with their kinds, titles, and mapping codomains. Row edits do not
+ * change it. Comparing signatures lets the view rebuild jspreadsheet only when
+ * the schema shape changes, per the demo's structural requirements.
+ */
+export function schemaShapeSignature(doc: DemoDocument): string {
+    return tableSpecs(doc)
+        .map((spec) => {
+            const cols = spec.columns
+                .map((c) =>
+                    c.kind === "attr"
+                        ? `a:${c.morphismId}:${c.title}:${c.attrType}`
+                        : `m:${c.morphismId}:${c.title}:${c.codomain.id}`,
+                )
+                .join(",");
+            return `${spec.entity.id}[${cols}]`;
+        })
+        .join("|");
+}
+
+/** Build the table spec for every entity in the schema. */
+export function tableSpecs(doc: DemoDocument): TableSpec[] {
+    const entities = doc.schema.cellsOf(Entity);
+    return entities.map((entity) => ({
+        entity,
+        columns: columnsFor(doc, entity),
+        rows: rowsOf(doc, entity),
+    }));
+}
+
+/** The columns for one entity: its outgoing attributes then its outgoing mappings. */
+export function columnsFor(doc: DemoDocument, entity: ObjectCell): Column[] {
+    const attrColumns: Column[] = attrCells(doc)
+        .filter((cell) => cell.from?.id === entity.id)
+        .map((cell) => ({
+            kind: "attr",
+            morphismId: cell.id,
+            title: cell.label || "(unnamed)",
+            attrType: cell.to?.label === "Number" ? "Number" : "String",
+        }));
+
+    const mappingColumns: Column[] = mappingCells(doc)
+        .filter((cell) => cell.from?.id === entity.id && cell.to !== undefined)
+        .map((cell) => ({
+            kind: "mapping",
+            morphismId: cell.id,
+            title: cell.label || "(unnamed)",
+            // The codomain is a live entity cell; if the codomain entity was
+            // deleted this filters out above (cell.to === undefined).
+            codomain: cell.to as ObjectCell,
+        }));
+
+    return [...attrColumns, ...mappingColumns];
+}
diff --git a/packages/document-methods/demo/src/main.tsx b/packages/document-methods/demo/src/main.tsx
new file mode 100644
index 000000000..b09b229a5
--- /dev/null
+++ b/packages/document-methods/demo/src/main.tsx
@@ -0,0 +1,20 @@
+/* @refresh reload */
+import { initializeWebMCPPolyfill } from "@mcp-b/webmcp-polyfill";
+import { render } from "solid-js/web";
+
+import { App } from "./App";
+
+import "catcolab-ui-components/global.css";
+import "./styles.css";
+
+// Install `document.modelContext` (the WebMCP standard surface) before the app
+// mounts, so components can register WebMCP tools during render. The polyfill is
+// a no-op when a native implementation already exists.
+initializeWebMCPPolyfill();
+
+const root = document.getElementById("root");
+if (!root) {
+    throw new Error("No #root element found in the demo page.");
+}
+
+render(() => <App />, root);
diff --git a/packages/document-methods/demo/src/script-scopes.ts b/packages/document-methods/demo/src/script-scopes.ts
new file mode 100644
index 000000000..d77f3a54b
--- /dev/null
+++ b/packages/document-methods/demo/src/script-scopes.ts
@@ -0,0 +1,99 @@
+import { Attr, AttrType, Entity, Mapping } from "catcolab-logics/simple-schema";
+
+import type { DemoDocument } from "./document";
+
+/**
+ * The demo has a single {@link ScriptSidebar}; this module supplies its
+ * particulars: the named values exposed to the script body, a starter script,
+ * and the localStorage key under which the source is persisted.
+ */
+export type ScriptConfig = {
+    scope: Record<string, unknown>;
+    defaultScript: string;
+    storageKey: string;
+};
+
+/**
+ * The unified script config. A single pane edits *both* sides, so its scope
+ * merges everything either side used to offer: the schema notebook, the
+ * instance, the demo document, the fixed `attrTypes`, and the simple-schema
+ * generator defs. One script can therefore build a schema and then populate an
+ * instance of it in the same run, calling the same document API the notebook UI
+ * and the tables use, so every mutation flows through the document's change
+ * notification and updates the UI, history, and persistence exactly as
+ * point-and-click edits do.
+ */
+export function demoScript(doc: DemoDocument): ScriptConfig {
+    return {
+        storageKey: "catcolab-instances-demo:script",
+        defaultScript: `// Edit the schema and instance with JavaScript.
+// Available: schema, instance, doc, attrTypes,
+//            Entity, Mapping, Attr, AttrType.
+//
+//   schema.add(Entity, { label })            — add an entity
+//   schema.add(Attr, { label, from, to })    — add an attribute
+//   schema.add(Mapping, { label, from, to }) — add a mapping
+//   schema.cellsOf(Entity | Attr | Mapping) — the schema cells
+//   instance.add(entity, {})                — add a row
+//   instance.rowsOf(entity) / instance.rows()
+//   row.set(morphism, value)                — set a mapping/attribute
+//
+// Example: build a tiny schema, then an instance of it.
+const person = schema.add(Entity, { label: "Person" });
+const name = schema.add(Attr, { label: "name", from: person, to: attrTypes.String });
+const fred = instance.add(person, {name: "Fred"});
+`,
+        scope: {
+            schema: doc.schema,
+            instance: doc.instance,
+            doc,
+            attrTypes: doc.attrTypes,
+            Entity,
+            Mapping,
+            Attr,
+            AttrType,
+        },
+    };
+}
+
+/** The outcome of running a script: its return value, or the error it threw. */
+export type RunResult = { tag: "ok"; value: unknown } | { tag: "error"; error: unknown };
+
+/**
+ * Run a script body against a scope. The body is wrapped in an async function
+ * (so it may `await`) with the scope's named values passed in as parameters
+ * rather than leaking globals. Because the script calls the same document API
+ * the rest of the demo uses, every mutation flows through the document's change
+ * notification, so the UI, history, and persistence all update as with
+ * point-and-click edits. This is a demo affordance, not a sandbox: the script
+ * has full access to the page.
+ */
+export async function runScript(
+    scope: Record<string, unknown>,
+    source: string,
+): Promise<RunResult> {
+    const names = Object.keys(scope);
+    const values = Object.values(scope);
+    try {
+        const AsyncFunction = async function () {}.constructor as new (
+            ...args: string[]
+        ) => (...args: unknown[]) => Promise<unknown>;
+        const fn = new AsyncFunction(...names, source);
+        const value = await fn(...values);
+        return { tag: "ok", value };
+    } catch (error) {
+        return { tag: "error", error };
+    }
+}
+
+/** A compact string for a script's return value, shown in status lines. */
+export function formatRunValue(value: unknown): string {
+    if (typeof value === "string") {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    } catch {
+        return String(value);
+    }
+}
diff --git a/packages/document-methods/demo/src/styles.css b/packages/document-methods/demo/src/styles.css
new file mode 100644
index 000000000..de3f4a8f0
--- /dev/null
+++ b/packages/document-methods/demo/src/styles.css
@@ -0,0 +1,112 @@
+/**
+ * Demo-local styling. The CatColab design tokens (colors, fonts, radii) come
+ * from `catcolab-ui-components/global.css`, imported in `main.tsx`. Here we map
+ * the demo's own variable names onto those tokens so the component CSS modules
+ * pick up the real CatColab palette and typography.
+ */
+
+:root {
+    /* Surfaces */
+    --background: var(--color-background);
+    --panel-bg: var(--color-background);
+    --header-bg: var(--color-gray-50);
+
+    /* Text */
+    --foreground: var(--color-foreground);
+    --muted: var(--color-text-muted);
+
+    /* Lines & hover */
+    --border: var(--color-gray-400);
+    --row-hover: var(--color-hover-bg);
+
+    /* Buttons (utility variant) */
+    --button-bg: var(--color-button-utility-bg);
+    --button-hover: var(--color-button-utility-hover-bg);
+
+    /* Accent = Topos teal */
+    --accent: var(--color-topos-primary);
+
+    /* Status */
+    --ok: var(--color-topos-primary-hover);
+    --ok-bg: var(--color-icon-button-positive-hover);
+    --danger: var(--color-alert-danger);
+    --danger-bg: var(--color-form-invalid-bg);
+
+    /* Tokens the shared `HistoryNavigator` reads but that the ui-components
+       palette leaves for the host app to supply. */
+    --color-border: var(--color-gray-300);
+    --color-foreground-secondary: var(--color-text-secondary);
+}
+
+* {
+    box-sizing: border-box;
+}
+
+html,
+body {
+    margin: 0;
+    height: 100%;
+}
+
+button {
+    font-family: inherit;
+    color: inherit;
+}
+
+/**
+ * jspreadsheet-ce overrides: retheme its default grid to CatColab's palette and
+ * typography. The library ships plain (non-variable) CSS, so we match its
+ * selectors closely enough to win on specificity/order.
+ */
+.jss_worksheet {
+    font-family: var(--main-font);
+    font-size: 1.05rem;
+    border-right: 1px solid var(--color-gray-400);
+    border-bottom: 1px solid var(--color-gray-400);
+}
+
+/* Roomier cells so rows are taller and easier to read. */
+.jss_worksheet > tbody > tr > td {
+    height: 2.4rem;
+    padding: 6px 10px;
+}
+
+/* The in-cell editor jspreadsheet renders on edit is a bare <input>/<textarea>
+   that does not inherit the cell's font, so it falls back to the browser default
+   and the text visibly changes font while editing. Force it to match the cell. */
+.jss_worksheet > tbody > tr > td > input,
+.jss_worksheet > tbody > tr > td > textarea,
+.jss_worksheet .editor > input,
+.jss_worksheet .editor > textarea {
+    font-family: var(--main-font);
+    font-size: 1.05rem;
+}
+
+.jss_worksheet > thead > tr > td,
+.jss_worksheet > tbody > tr > td:first-child {
+    background-color: var(--color-gray-50);
+    color: var(--color-text-secondary);
+    font-weight: 500;
+    border-color: var(--color-gray-300);
+    padding: 6px 10px;
+}
+
+.jss_worksheet > thead > tr > td.selected {
+    background-color: var(--color-gray-200);
+}
+
+.jss_worksheet > tbody > tr > td {
+    border-color: var(--color-gray-300);
+    color: var(--color-foreground);
+}
+
+.jss_worksheet .selection {
+    background-color: var(--color-icon-button-positive-hover);
+}
+
+.jss_worksheet .selection-left,
+.jss_worksheet .selection-right,
+.jss_worksheet .selection-top,
+.jss_worksheet .selection-bottom {
+    border-color: var(--color-topos-primary);
+}
diff --git a/packages/document-methods/demo/tsconfig.json b/packages/document-methods/demo/tsconfig.json
new file mode 100644
index 000000000..610fc5c25
--- /dev/null
+++ b/packages/document-methods/demo/tsconfig.json
@@ -0,0 +1,15 @@
+{
+    "extends": "../tsconfig.json",
+    "compilerOptions": {
+        "noEmit": true,
+        "jsx": "preserve",
+        "jsxImportSource": "solid-js",
+        "lib": ["ES2023", "DOM", "DOM.Iterable"],
+        "types": ["node"],
+        "paths": {
+            "catcolab-logics/*": ["../test/literate-ts/catcolab-logics/*.ts"],
+            "catcolab-documents": ["../src/future/index.ts"]
+        }
+    },
+    "include": ["src", "vite.config.ts"]
+}
diff --git a/packages/document-methods/demo/vite.config.ts b/packages/document-methods/demo/vite.config.ts
new file mode 100644
index 000000000..d12bb77a3
--- /dev/null
+++ b/packages/document-methods/demo/vite.config.ts
@@ -0,0 +1,28 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+import solid from "vite-plugin-solid";
+import wasm from "vite-plugin-wasm";
+
+const pkgRoot = fileURLToPath(new URL("..", import.meta.url));
+
+// A standalone Vite app for the instances demo. It reuses the package's "future"
+// API (`catcolab-documents`) and the simple-schema logic (`catcolab-logics/*`)
+// through the same aliases the package's vitest config uses, so the demo speaks
+// exactly the API the tests speak.
+export default defineConfig({
+    root: fileURLToPath(new URL(".", import.meta.url)),
+    base: "./",
+    plugins: [wasm(), solid()],
+    resolve: {
+        alias: [
+            {
+                find: "catcolab-documents",
+                replacement: `${pkgRoot}src/future/index.ts`,
+            },
+            {
+                find: /^catcolab-logics\/(.*)$/,
+                replacement: `${pkgRoot}test/literate-ts/catcolab-logics/$1.ts`,
+            },
+        ],
+    },
+});
diff --git a/packages/document-methods/package.json b/packages/document-methods/package.json
index a796f16ca..c8e1eb386 100644
--- a/packages/document-methods/package.json
+++ b/packages/document-methods/package.json
@@ -9,20 +9,52 @@
         "./*": "./src/*"
     },
     "scripts": {
-        "build:wasm": "wasm-pack build ../document-types",
+        "build:wasm": "wasm-pack build ../document-types && pnpm --prefix ../catlog-wasm run build:browser",
+        "demo": "vite --config demo/vite.config.ts",
+        "demo:build": "vite build --config demo/vite.config.ts",
         "format": "oxfmt .",
         "lint": "oxlint --fix && oxfmt .",
-        "check": "pnpm run build:wasm && tsc && pnpm run lint",
-        "ci": "tsc && oxlint --deny-warnings && oxfmt --check ."
+        "test:lts": "literate-typescript test/*.lts.md",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "check": "pnpm run build:wasm && tsc && tsc -p tsconfig.test.json && pnpm run lint",
+        "ci": "tsc && tsc -p tsconfig.test.json && oxlint --deny-warnings && oxfmt --check ."
     },
     "dependencies": {
+        "@mcp-b/webmcp-polyfill": "^3.0.0",
+        "@standard-schema/spec": "^1.1.0",
+        "arktype": "^2.2.1",
         "catcolab-document-types": "link:../document-types/pkg",
+        "catlog-wasm": "link:../catlog-wasm/dist/pkg-browser",
         "tiny-invariant": "^1.3.3",
         "uuid": "^13.0.0"
     },
     "devDependencies": {
+        "@automerge/automerge": "^3.2.5",
+        "@automerge/automerge-repo": "^2.5.5",
+        "@automerge/automerge-repo-solid-primitives": "^2.0.0",
+        "@automerge/prosemirror": "^0.2.0",
+        "@catcolab-dev-tools/literate-typescript": "workspace:*",
+        "@catcolab-dev-tools/vite-plugin-monorepo-dedupe": "link:../../tools/vite-plugin-monorepo-dedupe",
+        "@tsconfig/strictest": "^2.0.8",
+        "@types/node": "^24.0.0",
         "@types/uuid": "^10.0.0",
+        "@types/vhtml": "^2.2.9",
+        "@viz-js/viz": "^3.15.0",
+        "catcolab-ui-components": "link:../ui-components",
+        "happy-dom": "^20.0.0",
+        "jspreadsheet-ce": "^5.0.4",
+        "jsuites": "^6.4.2",
+        "prosemirror-model": "^1.25.9",
+        "prosemirror-state": "^1.4.4",
+        "prosemirror-view": "^1.41.9",
+        "solid-js": "^1.9.10",
         "typescript": "^6.0.3",
+        "vhtml": "^2.2.0",
+        "vite": "^7.2.2",
+        "vite-plugin-solid": "^2.11.10",
+        "vite-plugin-wasm": "^3.5.0",
+        "vitest": "^4.0.8",
         "wasm-pack": "^0.15.0"
     }
 }
diff --git a/packages/document-methods/pnpm-lock.yaml b/packages/document-methods/pnpm-lock.yaml
index 8ed08b845..a98473954 100644
--- a/packages/document-methods/pnpm-lock.yaml
+++ b/packages/document-methods/pnpm-lock.yaml
@@ -8,9 +8,21 @@ importers:
 
   .:
     dependencies:
+      '@mcp-b/webmcp-polyfill':
+        specifier: ^3.0.0
+        version: 3.0.0
+      '@standard-schema/spec':
+        specifier: ^1.1.0
+        version: 1.1.0
+      arktype:
+        specifier: ^2.2.1
+        version: 2.2.1
       catcolab-document-types:
         specifier: link:../document-types/pkg
         version: link:../document-types/pkg
+      catlog-wasm:
+        specifier: link:../catlog-wasm/dist/pkg-browser
+        version: link:../catlog-wasm/dist/pkg-browser
       tiny-invariant:
         specifier: ^1.3.3
         version: 1.3.3
@@ -18,78 +30,1985 @@ importers:
         specifier: ^13.0.0
         version: 13.0.0
     devDependencies:
+      '@automerge/automerge':
+        specifier: ^3.2.5
+        version: 3.2.6
+      '@automerge/automerge-repo':
+        specifier: ^2.5.5
+        version: 2.5.6
+      '@automerge/automerge-repo-solid-primitives':
+        specifier: ^2.0.0
+        version: 2.5.6(@automerge/automerge@3.2.6)(solid-js@1.9.13)
+      '@automerge/prosemirror':
+        specifier: ^0.2.0
+        version: 0.2.0
+      '@catcolab-dev-tools/literate-typescript':
+        specifier: workspace:*
+        version: link:../../tools/literate-typescript
+      '@catcolab-dev-tools/vite-plugin-monorepo-dedupe':
+        specifier: link:../../tools/vite-plugin-monorepo-dedupe
+        version: link:../../tools/vite-plugin-monorepo-dedupe
+      '@tsconfig/strictest':
+        specifier: ^2.0.8
+        version: 2.0.8
+      '@types/node':
+        specifier: ^24.0.0
+        version: 24.13.1
       '@types/uuid':
         specifier: ^10.0.0
         version: 10.0.0
+      '@types/vhtml':
+        specifier: ^2.2.9
+        version: 2.2.9
+      '@viz-js/viz':
+        specifier: ^3.15.0
+        version: 3.28.0
+      catcolab-ui-components:
+        specifier: link:../ui-components
+        version: link:../ui-components
+      happy-dom:
+        specifier: ^20.0.0
+        version: 20.10.2
+      jspreadsheet-ce:
+        specifier: ^5.0.4
+        version: 5.0.4
+      jsuites:
+        specifier: ^6.4.2
+        version: 6.4.2
+      prosemirror-model:
+        specifier: ^1.25.9
+        version: 1.25.9
+      prosemirror-state:
+        specifier: ^1.4.4
+        version: 1.4.4
+      prosemirror-view:
+        specifier: ^1.41.9
+        version: 1.41.9
+      solid-js:
+        specifier: ^1.9.10
+        version: 1.9.13
       typescript:
         specifier: ^6.0.3
         version: 6.0.3
+      vhtml:
+        specifier: ^2.2.0
+        version: 2.2.0
+      vite:
+        specifier: ^7.2.2
+        version: 7.3.5(@types/node@24.13.1)
+      vite-plugin-solid:
+        specifier: ^2.11.10
+        version: 2.11.12(solid-js@1.9.13)(vite@7.3.5(@types/node@24.13.1))
+      vite-plugin-wasm:
+        specifier: ^3.5.0
+        version: 3.6.0(vite@7.3.5(@types/node@24.13.1))
+      vitest:
+        specifier: ^4.0.8
+        version: 4.1.8(@types/node@24.13.1)(happy-dom@20.10.2)(vite@7.3.5(@types/node@24.13.1))
       wasm-pack:
         specifier: ^0.15.0
         version: 0.15.0
 
 packages:
 
+  '@ark/schema@0.56.0':
+    resolution: {integrity: sha512-ECg3hox/6Z/nLajxXqNhgPtNdHWC9zNsDyskwO28WinoFEnWow4IsERNz9AnXRhTZJnYIlAJ4uGn3nlLk65vZA==}
+
+  '@ark/util@0.56.0':
+    resolution: {integrity: sha512-BghfRC8b9pNs3vBoDJhcta0/c1J1rsoS1+HgVUreMFPdhz/CRAKReAu57YEllNaSy98rWAdY1gE+gFup7OXpgA==}
+
+  '@automerge/automerge-repo-solid-primitives@2.5.6':
+    resolution: {integrity: sha512-jwxktGP36AhxpPc9d3qi/k9WS7lIRqjfdWhn6i/Mzc6qe47COHe2QBvdDrDo6FTbFBoRz7+H5fyx3e2tfBIXfA==}
+    peerDependencies:
+      '@automerge/automerge': ^3.0.0
+      solid-js: ^1.9.4
+
+  '@automerge/automerge-repo@2.5.6':
+    resolution: {integrity: sha512-ZXM6TOAwm192g3+zIxYvlB+Z3O00NP+psErOwvbSype8fFO+dhc8tB/jPwfZJqmn1ULUz5w7gssKEynwcYFRSA==}
+
+  '@automerge/automerge@3.2.6':
+    resolution: {integrity: sha512-9/GXXfYYWNVGpnbRrGQzTNU4fWZ3XaEMeEg0OrpK4pvlQSpkmUBoirEb/4TMK6BwMysZGV5Yeneq3wwc7RNGfg==}
+
+  '@automerge/prosemirror@0.2.0':
+    resolution: {integrity: sha512-Mixxftvfs12tKi7DsStobrQxFayoLJXhEjbrnmNnaQbMzwHrUzuwac+OUvw6ujbtXaulWX+JE8hAuHFAGRDsvQ==}
+
+  '@babel/code-frame@7.29.7':
+    resolution: {integrity: sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/compat-data@7.29.7':
+    resolution: {integrity: sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/core@7.29.7':
+    resolution: {integrity: sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/generator@7.29.7':
+    resolution: {integrity: sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-compilation-targets@7.29.7':
+    resolution: {integrity: sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-globals@7.29.7':
+    resolution: {integrity: sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-module-imports@7.18.6':
+    resolution: {integrity: sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-module-imports@7.29.7':
+    resolution: {integrity: sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-module-transforms@7.29.7':
+    resolution: {integrity: sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/helper-plugin-utils@7.29.7':
+    resolution: {integrity: sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-string-parser@7.29.7':
+    resolution: {integrity: sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-identifier@7.29.7':
+    resolution: {integrity: sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-option@7.29.7':
+    resolution: {integrity: sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helpers@7.29.7':
+    resolution: {integrity: sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/parser@7.29.7':
+    resolution: {integrity: sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  '@babel/plugin-syntax-jsx@7.29.7':
+    resolution: {integrity: sha512-TSu8+mHCoEaaCDEZ0I3+6mvTBYR4PCxQwf2z9/r5Tbztv6NaLR3B9thGTTxX2WGuGHJqRiAbKPeGTJ5XWXVg6A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/template@7.29.7':
+    resolution: {integrity: sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/traverse@7.29.7':
+    resolution: {integrity: sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/types@7.29.7':
+    resolution: {integrity: sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==}
+    engines: {node: '>=6.9.0'}
+
+  '@cbor-extract/cbor-extract-darwin-arm64@2.2.2':
+    resolution: {integrity: sha512-ZKZ/F8US7JR92J4DMct6cLW/Y66o2K576+zjlEN/MevH70bFIsB10wkZEQPLzl2oNh2SMGy55xpJ9JoBRl5DOA==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@cbor-extract/cbor-extract-darwin-x64@2.2.2':
+    resolution: {integrity: sha512-32b1mgc+P61Js+KW9VZv/c+xRw5EfmOcPx990JbCBSkYJFY0l25VinvyyWfl+3KjibQmAcYwmyzKF9J4DyKP/Q==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@cbor-extract/cbor-extract-linux-arm64@2.2.2':
+    resolution: {integrity: sha512-wfqgzqCAy/Vn8i6WVIh7qZd0DdBFaWBjPdB6ma+Wihcjv0gHqD/mw3ouVv7kbbUNrab6dKEx/w3xQZEdeXIlzg==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@cbor-extract/cbor-extract-linux-arm@2.2.2':
+    resolution: {integrity: sha512-tNg0za41TpQfkhWjptD+0gSD2fggMiDCSacuIeELyb2xZhr7PrhPe5h66Jc67B/5dmpIhI2QOUtv4SBsricyYQ==}
+    cpu: [arm]
+    os: [linux]
+
+  '@cbor-extract/cbor-extract-linux-x64@2.2.2':
+    resolution: {integrity: sha512-rpiLnVEsqtPJ+mXTdx1rfz4RtUGYIUg2rUAZgd1KjiC1SehYUSkJN7Yh+aVfSjvCGtVP0/bfkQkXpPXKbmSUaA==}
+    cpu: [x64]
+    os: [linux]
+
+  '@cbor-extract/cbor-extract-win32-x64@2.2.2':
+    resolution: {integrity: sha512-dI+9P7cfWxkTQ+oE+7Aa6onEn92PHgfWXZivjNheCRmTBDBf2fx6RyTi0cmgpYLnD1KLZK9ZYrMxaPZ4oiXhGA==}
+    cpu: [x64]
+    os: [win32]
+
+  '@cfworker/json-schema@4.1.1':
+    resolution: {integrity: sha512-gAmrUZSGtKc3AiBL71iNWxDsyUC5uMaKKGdvzYsBoTW/xi42JQHl7eKV2OYzCUqvc+D2RCcf7EXY2iCyFIk6og==}
+
+  '@esbuild/aix-ppc64@0.27.7':
+    resolution: {integrity: sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.27.7':
+    resolution: {integrity: sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.27.7':
+    resolution: {integrity: sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.27.7':
+    resolution: {integrity: sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.27.7':
+    resolution: {integrity: sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.27.7':
+    resolution: {integrity: sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.27.7':
+    resolution: {integrity: sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.27.7':
+    resolution: {integrity: sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.27.7':
+    resolution: {integrity: sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.27.7':
+    resolution: {integrity: sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.27.7':
+    resolution: {integrity: sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.27.7':
+    resolution: {integrity: sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.27.7':
+    resolution: {integrity: sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.27.7':
+    resolution: {integrity: sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.27.7':
+    resolution: {integrity: sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.27.7':
+    resolution: {integrity: sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.27.7':
+    resolution: {integrity: sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.27.7':
+    resolution: {integrity: sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.27.7':
+    resolution: {integrity: sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.27.7':
+    resolution: {integrity: sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.27.7':
+    resolution: {integrity: sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openharmony-arm64@0.27.7':
+    resolution: {integrity: sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/sunos-x64@0.27.7':
+    resolution: {integrity: sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.27.7':
+    resolution: {integrity: sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.27.7':
+    resolution: {integrity: sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.27.7':
+    resolution: {integrity: sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
   '@isaacs/fs-minipass@4.0.1':
     resolution: {integrity: sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==}
     engines: {node: '>=18.0.0'}
 
-  '@types/uuid@10.0.0':
-    resolution: {integrity: sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ==}
+  '@jridgewell/gen-mapping@0.3.13':
+    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
+
+  '@jridgewell/remapping@2.3.5':
+    resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==}
+
+  '@jridgewell/resolve-uri@3.1.2':
+    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/sourcemap-codec@1.5.5':
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
+
+  '@jspreadsheet/formula@2.0.2':
+    resolution: {integrity: sha512-PDQYf9REQA53I7tVYkvkeyQxrd5jcjUeHgItYnRpjN2QiIQwawSqBDtGGEVQTSboTG+JwgGCuhvOpj7FxeKwew==}
+
+  '@jsuites/utils@6.0.6':
+    resolution: {integrity: sha512-KpiaJtC5wC2P8RIWmWNsuVQm9tvlmu2SW+/Iqr0alViuQqywIioGRYvv12l9zyI5gBBWQaMJ6jgac+wWeXPpRw==}
+
+  '@lemonadejs/calendar@5.9.3':
+    resolution: {integrity: sha512-kUK2WLuIVN9H1r79CEk0hQ0KG2tfe3zjcsVAoxZwGZJXHlmx9bF5jNh+G7aiT/gDmt2lehllt3Ng0Yv0JWF0Ig==}
+
+  '@lemonadejs/color@5.8.0':
+    resolution: {integrity: sha512-ep9yJAgRvRPrrx56p/3hGVctqcXgc5F3wJtefjvwKJv/CVMY19clZ3+vRoZm7Ndth6kN8h+Q6Pu5EkHkl/WLZQ==}
+
+  '@lemonadejs/contextmenu@5.8.5':
+    resolution: {integrity: sha512-v8bV5/xAC6enAgCoFoNLRmjEeFpUCsLm3w0U4t7j8cmkuOfc0iTifODJP02EFHhHSYof24QBeXwwh+JMpZcwSQ==}
+
+  '@lemonadejs/dropdown@5.8.4':
+    resolution: {integrity: sha512-pLJeu1EhbTI/mP9mfqxNVUaug2AKnK7RJu6mcPjhmlqeOtCN5NKlQ9L2ig1nxNvxJYIigM6EMn+J+dD/amegiw==}
+
+  '@lemonadejs/modal@5.8.3':
+    resolution: {integrity: sha512-iQJLCP5PT5y3ERSCobpifRKQT2q1PW2HZq5LvwACp+ECKtSJSy5ObJt6vEcmOq82WsFAIqdnA2BeRCvuxH4pIw==}
+
+  '@lemonadejs/rating@5.8.1':
+    resolution: {integrity: sha512-g/FJVJ/ay1BmcdqHDHX/2CHBQ1vBViJipWuEMdsqnwbnGGpkKf2q5Ml3xI2GMwCVw8ovvcy/++3UP1xs9GLyMQ==}
+
+  '@lemonadejs/switch@5.8.0':
+    resolution: {integrity: sha512-EpqK5iCpQj3o1bN8wW+jka6O4aMIKP5IbLXtD9iTv/ipasyQgxz2oZNkHD8yS6JrpGffSd87FNi37qm/XcJN3w==}
+
+  '@lemonadejs/tabs@5.8.0':
+    resolution: {integrity: sha512-nyqHOVwqKnFvqOxwidT5VFzKuFJ/Bzdfvqs7QY30LK9CXK3MrQBgLrijpQOTL3Als1Qp6qp3Q0HRQqUsLARhyA==}
+
+  '@lemonadejs/topmenu@5.8.0':
+    resolution: {integrity: sha512-mkWnaiE+0c/i+wv9cz88d2U4GOTxVIVj4aEOad4rQ2JCKkQfw02sP6PS/NaXWJMgDsF1cJOMnO3BThnP5/BqVw==}
+
+  '@mcp-b/webmcp-polyfill@3.0.0':
+    resolution: {integrity: sha512-TCrCOZCTfRWrTp8MpWU8EO4U7r7IvDDaIYW9Ej0aBD2KVR2hvwr4t3T7kPkSYssGhpIZJrq19owSzN1vZabW+A==}
+    engines: {node: '>=18'}
+
+  '@mcp-b/webmcp-types@3.0.0':
+    resolution: {integrity: sha512-MmKHNAtlyZoK5khz5GnmgEj/ehk5esoUbgOaFndrlZvpjq3ppmIY3BDrwCv6xaihuuIMOoLLDlf0E65wUd4q7A==}
+
+  '@noble/hashes@1.8.0':
+    resolution: {integrity: sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==}
+    engines: {node: ^14.21.3 || >=16}
+
+  '@rollup/rollup-android-arm-eabi@4.61.1':
+    resolution: {integrity: sha512-JnBB8MdXj45cajvTuO5FmPlvFVJRQgvrz1uSEl3NwqFnReAPGwb8EanbGi4z2nRaqLzjJSv5/JmycoTKlRZxHA==}
+    cpu: [arm]
+    os: [android]
+
+  '@rollup/rollup-android-arm64@4.61.1':
+    resolution: {integrity: sha512-Jx2g7iSjw4AOT0HDPHM9RV3GNjRXwybWtSFZiZAYUTjUwjVrYIwq3kBf+LnhqJlzXFAqTAh2F7IGI+O568exPw==}
+    cpu: [arm64]
+    os: [android]
+
+  '@rollup/rollup-darwin-arm64@4.61.1':
+    resolution: {integrity: sha512-0F1L/Z3Eqv8mT2n3dCpeO8GcTvHvVqkP5/t6DMsn0KzhYVcg+s7Ncl5DS8qjKYEeio6Az0Gt6nyBORay5qIlCA==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rollup/rollup-darwin-x64@4.61.1':
+    resolution: {integrity: sha512-qLttcH871ujY4YcVfUSShhOw+CsoTatYz8gRbHO7Bb92QH059/P0y5do1KMs41fY0BpD2x4AJH/gID0zFiqVKQ==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rollup/rollup-freebsd-arm64@4.61.1':
+    resolution: {integrity: sha512-fUI4RapGE0Oh3mb8mgfvC1O2nU1RpDZUKnDQm3xB1Ipg7C2wTs5Kstz7G2uWK99a8S2yTMq8/P4uycwNa0nJyw==}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@rollup/rollup-freebsd-x64@4.61.1':
+    resolution: {integrity: sha512-H5YrdvJaDtI/U9/emrD4b++xkvp3y/JvOe4rizHbxvkyMfRS/CiRYdji+Pl8D0brEaNFWUh1drQxgAGIl6Xudw==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.61.1':
+    resolution: {integrity: sha512-Q8CBCCQtDFrYtXoeUXSrnFXKOnyUhx6bz+SkL6A0E7V8kAiCJ5pamq1WtbfpVGhR5TSpXY6ak3avmDc5fHTyJA==}
+    cpu: [arm]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-arm-musleabihf@4.61.1':
+    resolution: {integrity: sha512-nwnhk1581l0FBVellGcVCAT0Oi06onEA3WB53sf01VO3I0UPBkMH9sXONYME2K0ovXcNayJfNtHfm6mpJElatQ==}
+    cpu: [arm]
+    os: [linux]
+    libc: [musl]
+
+  '@rollup/rollup-linux-arm64-gnu@4.61.1':
+    resolution: {integrity: sha512-x5Xr49hwt3hdW75UOZm3395YwwzPyauktslv29KpWL/T+vVAzoT3azLcTWv0eMciBNrx+DYjH4paehHoLpPvpg==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-arm64-musl@4.61.1':
+    resolution: {integrity: sha512-unMS3H73DpaoPyyEVPjGKleM/s0mkmsauTENpw4INQY8y4+IuLNjkueQ5QCtC0D3N38Y38yhAU8OoZ20S2Tm6w==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@rollup/rollup-linux-loong64-gnu@4.61.1':
+    resolution: {integrity: sha512-zNZzGRnAhwjFEYmvphJRV5XaQGjs62cCmeYYHUT//NbvEnHauw+I85nGG+SiVg5ld4GX8D1IbKIX+ozITQnhMQ==}
+    cpu: [loong64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-loong64-musl@4.61.1':
+    resolution: {integrity: sha512-LdpWGL8X209B2SIvWjqlc8VZgM6PKfontSerGepuldQmHYrAOtnMCXeJkxXGbC+PPZVOuu5czJo7fNV6aeW8rQ==}
+    cpu: [loong64]
+    os: [linux]
+    libc: [musl]
+
+  '@rollup/rollup-linux-ppc64-gnu@4.61.1':
+    resolution: {integrity: sha512-EC5kTtNaNGOmbMGqar8dvJy6y/hg99GAwjfBz++pxZhQATXGcRjd6c5en5wcbru0vkRmiMGsQKdMJOOf6sza4g==}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-ppc64-musl@4.61.1':
+    resolution: {integrity: sha512-8hiwp6D4acEcNK78I4rP0/XtS1sknWIAMJBPdR4l6zUtyTm5KiTDr5bXmWt4foY7nAN7AThDHgkLIEZOWKbzWw==}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [musl]
+
+  '@rollup/rollup-linux-riscv64-gnu@4.61.1':
+    resolution: {integrity: sha512-10dh/h/BqA7DuMPWSxkR8uks18FRwnwOEqr5zOTEl+NOwP/OMzKX8OFR/Of9xxDA7D5qef1Nzar5WDD2kCCr1g==}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-riscv64-musl@4.61.1':
+    resolution: {integrity: sha512-YKJ5lg35DP17gcAOggnihe+APw9HLyj1Xn7gsmGumBJAUDa6NGXNixJzmkWLhcK9TOuuyQjdamzvJefkO7qHZQ==}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [musl]
+
+  '@rollup/rollup-linux-s390x-gnu@4.61.1':
+    resolution: {integrity: sha512-Mlil5G2Jj6a7B3LWGctg+XPL9vdXYuzCtNXfxOQ0nPjc2m6ueUktocPGH9bnAM0bNRKb/bAWTujUU7IJQdQA+g==}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-x64-gnu@4.61.1':
+    resolution: {integrity: sha512-bVWIOIk6pV01p4CdUbPP7CJ/434z+OooYjDuFcR+44N35YvKUC66G8MGnvcWx5mWKW3g61J+t74l3Kj15Kwn2Q==}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rollup/rollup-linux-x64-musl@4.61.1':
+    resolution: {integrity: sha512-qy5pBvZbqNFheBz61R1rzsezjm0J7O2oNGoWtGoY89SZYLUfxAJTBAqDChqAIdB4rCiIbi9nF7yZ83GnNiLwSw==}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@rollup/rollup-openbsd-x64@4.61.1':
+    resolution: {integrity: sha512-E83TXjI4zm0+5f2qO+UOudaCYIhYwpJ5jq6YCZNIZ+6CbfhKrkAGezeiASBL9ElxAxFsRS9ZhESv8mfnj6TKeg==}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@rollup/rollup-openharmony-arm64@4.61.1':
+    resolution: {integrity: sha512-fbWnKqVkjrJN38vNe3ahkbk6iejS/3b0Nt7EEtPpE6RBacZcGXNKbzfHN3GUUlXOPghUg0j6XUGrtjX9z1sIvA==}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@rollup/rollup-win32-arm64-msvc@4.61.1':
+    resolution: {integrity: sha512-ArMl38iVAbk0New1ogihQNY6iphLi4ZaRsa037gUzv5yeKPY8TD3Dmy4x2RNC1VztU/uqm+G+/RwFrSka3Oy2g==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rollup/rollup-win32-ia32-msvc@4.61.1':
+    resolution: {integrity: sha512-0mYtjHS9ucAbcATycCNK9IGBk/cCe/ma7EmSLGZdsxnOA8cjRIyU04wDpVAD9NiOfLUR9KTxdiO53uOkherqjQ==}
+    cpu: [ia32]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-gnu@4.61.1':
+    resolution: {integrity: sha512-gK1iCEPfpoSG9wfBihXxvBMi8ZfcWffYkEsC/Eih+iFENTaewvNcrEQ69lIOWYO5pePHKLHHO7nq5AILGO/HQQ==}
+    cpu: [x64]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-msvc@4.61.1':
+    resolution: {integrity: sha512-X+zaP2x+j4RXGfbp/seSoRHWnPxzApilDszisZxbYH5C/jTxFhCtDNdPGZb9lJyYPs24wGxruPF7Y+sIXt9Gzw==}
+    cpu: [x64]
+    os: [win32]
+
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
+  '@tsconfig/strictest@2.0.8':
+    resolution: {integrity: sha512-XnQ7vNz5HRN0r88GYf1J9JJjqtZPiHt2woGJOo2dYqyHGGcd6OLGqSlBB6p1j9mpzja6Oe5BoPqWmeDx6X9rLw==}
+
+  '@types/babel__core@7.20.5':
+    resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
+
+  '@types/babel__generator@7.27.0':
+    resolution: {integrity: sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==}
+
+  '@types/babel__template@7.4.4':
+    resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==}
+
+  '@types/babel__traverse@7.28.0':
+    resolution: {integrity: sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==}
+
+  '@types/chai@5.2.3':
+    resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
+
+  '@types/deep-eql@4.0.2':
+    resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
+
+  '@types/estree@1.0.9':
+    resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==}
+
+  '@types/node@24.13.1':
+    resolution: {integrity: sha512-RSpUJGmvsJ1ZeBehQZFhIdpsz+bIpES0nIQXko4Ybq+N+kX6XvOq3Jo+iJ82FWLdblFq85AsMikd3m35jgezYg==}
+
+  '@types/uuid@10.0.0':
+    resolution: {integrity: sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ==}
+
+  '@types/vhtml@2.2.9':
+    resolution: {integrity: sha512-maEIRJb+PdK2FWDORl0a0aNUSGlniMl8pN+7WbanLzx1Gry4gLfsT0C9O/6JucPPBHCNrqDSImr2QcsUENLKUg==}
+
+  '@types/whatwg-mimetype@3.0.2':
+    resolution: {integrity: sha512-c2AKvDT8ToxLIOUlN51gTiHXflsfIFisS4pO7pDPoKouJCESkhZnEy623gwP9laCy5lnLDAw1vAzu2vM2YLOrA==}
+
+  '@types/ws@8.18.1':
+    resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
+
+  '@vitest/expect@4.1.8':
+    resolution: {integrity: sha512-h3nDO677RDLEGlBxyQ5CW8RlMThSKSRLUePLOx09gNIWRL40edgA1GCZSZgf1W55MFAG6/Sw14KeaAnqv0NKdQ==}
+
+  '@vitest/mocker@4.1.8':
+    resolution: {integrity: sha512-LEiN/xe4OSIbKe9HQIp5OC24agGD9J5CnmMgsLohVVoOPWL9a2sBoR6VBx43jQZb7Kr1l4RCuyCJzcAa0+dojw==}
+    peerDependencies:
+      msw: ^2.4.9
+      vite: ^6.0.0 || ^7.0.0 || ^8.0.0
+    peerDependenciesMeta:
+      msw:
+        optional: true
+      vite:
+        optional: true
+
+  '@vitest/pretty-format@4.1.8':
+    resolution: {integrity: sha512-9GasEBxpZ1VYIpqHf/0+YGg121uSNwCKOJqIrTwWP/TB7DmFCiaBpNl3aPZzoLWfWkuqhbH8vJIVobZkvdo2cA==}
+
+  '@vitest/runner@4.1.8':
+    resolution: {integrity: sha512-EmVxeBAfMJvycdjd6Hm+RbFBbA9fKvo0Kx37hNpBYoYeavH3RNsBXWDooR1mgD52dCrxIIuP7UotpfiwOikvcg==}
+
+  '@vitest/snapshot@4.1.8':
+    resolution: {integrity: sha512-acfZboRmAIf05DEKcBQy33VXojFJjtUdLyo7oOmV9kebb2xdU01UknNiPuPZoJZQyO7DF0gZdTGTpeAzET9QPQ==}
+
+  '@vitest/spy@4.1.8':
+    resolution: {integrity: sha512-6EevtBp6OZOPF7bmz36HrGMeP3txgVSrgebWxHOafDXGkhIzfXK14f8KF6MuFfgXXUeHxmpD3BQxkV00/3s5mA==}
+
+  '@vitest/utils@4.1.8':
+    resolution: {integrity: sha512-uOJamYALNhfJ6iolExyQM40yIQwDqYnkKtQ5VCiSe17E33H0aQ/u+1GlRuz4LZBk6Mm3sg90G9hEbmEt37C1Zg==}
+
+  '@viz-js/viz@3.28.0':
+    resolution: {integrity: sha512-nPt+jbGHGgd7lUQLBT79/4lChIzeW44I+hFrscx18AnpNyX9vdRFVNwVbKz9eq+ACeKSm4bFQns17WhCW11eWQ==}
+
+  arkregex@0.0.6:
+    resolution: {integrity: sha512-9mvuMKQuibfWhBrsNYhsKhNb6k9oEHoAJ/FvDiqe8h+E9Siwe0/cro1WVOGgpajXQ9ZHd24yCOf2k35Q/QqUQw==}
+
+  arktype@2.2.1:
+    resolution: {integrity: sha512-CWPJxNoSxrS+NYGB3ufwc/blFonESEW5vBQyYPVS0rf4STu8VWoAWfKJSl5vVVm56h4yxpwbODeYwy6XFKvojA==}
+
+  assertion-error@2.0.1:
+    resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
+    engines: {node: '>=12'}
+
+  babel-plugin-jsx-dom-expressions@0.40.7:
+    resolution: {integrity: sha512-/O6JWUmjv03OI9lL2ry9bUjpD5S3PclM55RRJEyCdcFZ5W2SEA/59d+l2hNsk3gI6kiWRdRPdOtqZmsQzFN1pQ==}
+    peerDependencies:
+      '@babel/core': ^7.20.12
+
+  babel-preset-solid@1.9.12:
+    resolution: {integrity: sha512-LLqnuKVDlKpyBlMPcH6qEvs/wmS9a+NczppxJ3ryS/c0O5IiSFOIBQi9GzyiGDSbcJpx4Gr87jyFTos1MyEuWg==}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+      solid-js: ^1.9.12
+    peerDependenciesMeta:
+      solid-js:
+        optional: true
+
+  base-x@4.0.1:
+    resolution: {integrity: sha512-uAZ8x6r6S3aUM9rbHGVOIsR15U/ZSc82b3ymnCPsT45Gk1DDvhDPdIgB5MrhirZWt+5K0EEPQH985kNqZgNPFw==}
+
+  baseline-browser-mapping@2.10.35:
+    resolution: {integrity: sha512-honAfLBde0HAFLdNyBEfuuENkF6zR+ozxqxa/2zJKHBe1qzLqyTSeRKpdPEHAP03rlDGyQOPnCSxnVpVqQo9Mg==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  browserslist@4.28.2:
+    resolution: {integrity: sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
+    hasBin: true
+
+  bs58@5.0.0:
+    resolution: {integrity: sha512-r+ihvQJvahgYT50JD05dyJNKlmmSlMoOGwn1lCcEzanPglg7TxYjioQUYehQ9mAR/+hOSd2jRc/Z2y5UxBymvQ==}
+
+  bs58check@3.0.1:
+    resolution: {integrity: sha512-hjuuJvoWEybo7Hn/0xOrczQKKEKD63WguEjlhLExYs2wUBcebDC1jDNK17eEAD2lYfw82d5ASC1d7K3SWszjaQ==}
+
+  buffer-image-size@0.6.4:
+    resolution: {integrity: sha512-nEh+kZOPY1w+gcCMobZ6ETUp9WfibndnosbpwB1iJk/8Gt5ZF2bhS6+B6bPYz424KtwsR6Rflc3tCz1/ghX2dQ==}
+    engines: {node: '>=4.0'}
+
+  caniuse-lite@1.0.30001797:
+    resolution: {integrity: sha512-l8xKG+gwAIExZGl9FrF7KUwuOmk6wbEPC9Xoy/RtnWv1XG0Q4LFlagaLpUv3Kiza3W/wm27zy0yWJEieYKAP6w==}
+
+  cbor-extract@2.2.2:
+    resolution: {integrity: sha512-hlSxxI9XO2yQfe9g6msd3g4xCfDqK5T5P0fRMLuaLHhxn4ViPrm+a+MUfhrvH2W962RGxcBwEGzLQyjbDG1gng==}
+    hasBin: true
+
+  cbor-x@1.6.4:
+    resolution: {integrity: sha512-UGKHjp6RHC6QuZ2yy5LCKm7MojM4716DwoSaqwQpaH4DvZvbBTGcoDNTiG9Y2lByXZYFEs9WRkS5tLl96IrF1Q==}
+
+  chai@6.2.2:
+    resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==}
+    engines: {node: '>=18'}
+
+  chownr@3.0.0:
+    resolution: {integrity: sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==}
+    engines: {node: '>=18'}
+
+  convert-source-map@2.0.0:
+    resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
+
+  csstype@3.2.3:
+    resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
+
+  debug@4.4.3:
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  detect-libc@2.1.2:
+    resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
+    engines: {node: '>=8'}
+
+  electron-to-chromium@1.5.370:
+    resolution: {integrity: sha512-D5tSHJReAb/Kf3Hu9F/GO4lJuSWzEWHwvQ/kKSUP7pimNgvxkSKj+gUQhHpKKACwrin7rS3byU7IxreF56rl5g==}
+
+  entities@6.0.1:
+    resolution: {integrity: sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==}
+    engines: {node: '>=0.12'}
+
+  entities@7.0.1:
+    resolution: {integrity: sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==}
+    engines: {node: '>=0.12'}
+
+  es-module-lexer@2.1.0:
+    resolution: {integrity: sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ==}
+
+  esbuild@0.27.7:
+    resolution: {integrity: sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  escalade@3.2.0:
+    resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
+    engines: {node: '>=6'}
+
+  estree-walker@3.0.3:
+    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
+
+  eventemitter3@5.0.4:
+    resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==}
+
+  expect-type@1.3.0:
+    resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==}
+    engines: {node: '>=12.0.0'}
+
+  fast-sha256@1.3.0:
+    resolution: {integrity: sha512-n11RGP/lrWEFI/bWdygLxhI+pVeo1ZYIVwvvPkW7azl/rOy+F3HYRZ2K5zeE9mmkhQppyv9sQFx0JM9UabnpPQ==}
+
+  fdir@6.5.0:
+    resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
+    engines: {node: '>=12.0.0'}
+    peerDependencies:
+      picomatch: ^3 || ^4
+    peerDependenciesMeta:
+      picomatch:
+        optional: true
+
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  gensync@1.0.0-beta.2:
+    resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
+    engines: {node: '>=6.9.0'}
+
+  happy-dom@20.10.2:
+    resolution: {integrity: sha512-5p9Sxis3eowDJKqx90QCsgbNA02XXqJ59NOHvD4V6cxp+rP4d/xOyVx7uY3hS8hiUbY1VeiFH8lbJ81AyuDVLQ==}
+    engines: {node: '>=20.0.0'}
+
+  html-entities@2.3.3:
+    resolution: {integrity: sha512-DV5Ln36z34NNTDgnz0EWGBLZENelNAtkiFA4kyNOG2tDI6Mz1uSWiq1wAKdyjnJwyDiDO7Fa2SO1CTxPXL8VxA==}
+
+  is-what@4.1.16:
+    resolution: {integrity: sha512-ZhMwEosbFJkA0YhFnNDgTM4ZxDRsS6HqTo7qsZM08fehyRYIYa0yHu5R6mgo1n/8MgaPBXiPimPD77baVFYg+A==}
+    engines: {node: '>=12.13'}
+
+  js-tokens@4.0.0:
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+
+  jsesc@3.1.0:
+    resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
+    engines: {node: '>=6'}
+    hasBin: true
+
+  json5@2.2.3:
+    resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==}
+    engines: {node: '>=6'}
+    hasBin: true
+
+  jspreadsheet-ce@5.0.4:
+    resolution: {integrity: sha512-ra1JI1n+tEGgRMzTzNkPZjG0HZz8W6bFGAiTiHl+eYarXdRmS5qDc/ua3l2ev7oZ6Og9kjfrXYHVLUWiVc308w==}
+
+  jsuites@5.13.5:
+    resolution: {integrity: sha512-cvkcpy/v5I3+IAcNPE4UP38PFCEfUQw9JI5NN61dlcXLwkD+2UTIOsRPvgMLeqI1eDWHL4AHfrbcE/+TFciUsw==}
+
+  jsuites@6.4.2:
+    resolution: {integrity: sha512-HgHy8hpJMW5kgaqZfe8QkxNi68BxbwL33w5fgfRRAuWUyBsvXaRDAnjqaBuzhYts3/464Ly9LUyyo3dzMiGsnw==}
+
+  lemonadejs@5.3.6:
+    resolution: {integrity: sha512-GfmoZvCcnesiRsU9oC3OJDZ2VU+U4TsOJKD3A+rEV7dwm2IBO0xaBkLYtpgY3kcoFQjm7u5k9KSQXEtIkanjHQ==}
+
+  lru-cache@5.1.1:
+    resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
+
+  magic-string@0.30.21:
+    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
+
+  merge-anything@5.1.7:
+    resolution: {integrity: sha512-eRtbOb1N5iyH0tkQDAoQ4Ipsp/5qSR79Dzrz8hEPxRX10RWWR/iQXdoKmBSRCThY1Fh5EhISDtpSc93fpxUniQ==}
+    engines: {node: '>=12.13'}
+
+  minipass@7.1.3:
+    resolution: {integrity: sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  minizlib@3.1.0:
+    resolution: {integrity: sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==}
+    engines: {node: '>= 18'}
+
+  ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  nanoid@3.3.12:
+    resolution: {integrity: sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  node-gyp-build-optional-packages@5.1.1:
+    resolution: {integrity: sha512-+P72GAjVAbTxjjwUmwjVrqrdZROD4nf8KgpBoDxqXXTiYZZt/ud60dE5yvCSr9lRO8e8yv6kgJIC0K0PfZFVQw==}
+    hasBin: true
+
+  node-releases@2.0.47:
+    resolution: {integrity: sha512-Uzmd6LXpouKo8EUK68IjH4+E01w/hXyV3R3g/geCJo+rXLNfh1xucB+LOzYEOQPSiUK3h/xZf0cQGcSsmyL2Og==}
+    engines: {node: '>=18'}
+
+  obug@2.1.2:
+    resolution: {integrity: sha512-AWGB9WFcRXOQs48Z/udjI5ZcZMHXwX8XPByNpOydgcGsDLIzjGizhoMWJyKAWze7AVW/2W1i+/gPX4YtKe5cyg==}
+    engines: {node: '>=12.20.0'}
+
+  ordered-map@0.1.0:
+    resolution: {integrity: sha512-ttpssyEqKXIeTapKeFTFG+oUCnrC+Fmyy1DPjys0vPJtccBE3baKDFTbJPDuKd9/XHbnKKe+KPQKTzBLri6Mtw==}
+
+  orderedmap@2.1.1:
+    resolution: {integrity: sha512-TvAWxi0nDe1j/rtMcWcIj94+Ffe6n7zhow33h40SKxmsmozs6dz/e+EajymfoFcHd7sxNn8yHM8839uixMOV6g==}
+
+  parse5@7.3.0:
+    resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==}
+
+  pathe@2.0.3:
+    resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  picomatch@4.0.4:
+    resolution: {integrity: sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==}
+    engines: {node: '>=12'}
+
+  postcss@8.5.15:
+    resolution: {integrity: sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  prosemirror-changeset@2.4.1:
+    resolution: {integrity: sha512-96WBLhOaYhJ+kPhLg3uW359Tz6I/MfcrQfL4EGv4SrcqKEMC1gmoGrXHecPE8eOwTVCJ4IwgfzM8fFad25wNfw==}
+
+  prosemirror-history@1.5.0:
+    resolution: {integrity: sha512-zlzTiH01eKA55UAf1MEjtssJeHnGxO0j4K4Dpx+gnmX9n+SHNlDqI2oO1Kv1iPN5B1dm5fsljCfqKF9nFL6HRg==}
+
+  prosemirror-model@1.25.9:
+    resolution: {integrity: sha512-pRTklkDDMMRopyoAcrr9wV/8g/RYgrLHBuJAb5hlEuYZRdm5yqmPjWId83fpBwPpSFqEdja0H7Dfd7z1X/npcA==}
+
+  prosemirror-schema-basic@1.2.4:
+    resolution: {integrity: sha512-ELxP4TlX3yr2v5rM7Sb70SqStq5NvI15c0j9j/gjsrO5vaw+fnnpovCLEGIcpeGfifkuqJwl4fon6b+KdrODYQ==}
+
+  prosemirror-schema-list@1.5.1:
+    resolution: {integrity: sha512-927lFx/uwyQaGwJxLWCZRkjXG0p48KpMj6ueoYiu4JX05GGuGcgzAy62dfiV8eFZftgyBUvLx76RsMe20fJl+Q==}
+
+  prosemirror-state@1.4.4:
+    resolution: {integrity: sha512-6jiYHH2CIGbCfnxdHbXZ12gySFY/fz/ulZE333G6bPqIZ4F+TXo9ifiR86nAHpWnfoNjOb3o5ESi7J8Uz1jXHw==}
+
+  prosemirror-transform@1.12.0:
+    resolution: {integrity: sha512-GxboyN4AMIsoHNtz5uf2r2Ru551i5hWeCMD6E2Ib4Eogqoub0NflniaBPVQ4MrGE5yZ8JV9tUHg9qcZTTrcN4w==}
+
+  prosemirror-view@1.41.9:
+    resolution: {integrity: sha512-clTunTX+eaLbr87L1V1QPheRlEQJyTlL3gXe9x3jQIk3rL0RVWxviDGz8tFaydwIVm+hKhYCyr+R/zBtWr9s6A==}
+
+  rollup@4.61.1:
+    resolution: {integrity: sha512-I4KW6iuRpuu2uHBLraZ1wNZe0DP7lnRha+VJ9tNaYVaVgKhW0aI3h4RYnoRPeql0flHm/Co55b7snEDcOfOJrA==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+
+  rope-sequence@1.3.4:
+    resolution: {integrity: sha512-UT5EDe2cu2E/6O4igUr5PSFs23nvvukicWHx6GnOPlHAiiYbzNuCRQCuiUdHJQcqKalLKlrYJnjY0ySGsXNQXQ==}
+
+  semver@6.3.1:
+    resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
+    hasBin: true
+
+  seroval-plugins@1.5.4:
+    resolution: {integrity: sha512-S0xQPhUTefAhNvNWFg0c1J8qJArHt5KdtJ/cFAofo06KD1MVSeFWyl4iiu+ApDIuw0WhjpOfCdgConOfAnLgkw==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      seroval: ^1.0
+
+  seroval@1.5.4:
+    resolution: {integrity: sha512-46uFvgrXTVxZcUorgSSRZ4y+ieqLLQRMlG4bnCZKW3qI6BZm7Rg4ntMW4p1mILEEBZWrFlcpp0AyIIlM6jD9iw==}
+    engines: {node: '>=10'}
+
+  siginfo@2.0.0:
+    resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
+
+  solid-js@1.9.13:
+    resolution: {integrity: sha512-6hJeJMOcEX8ktqjpDoJZEmld3ijvcvWBDtiXBm7f4332SiFN66QeAQI1REQshvyUoISsSeJ4PHDauKYbwao9JQ==}
+
+  solid-refresh@0.6.3:
+    resolution: {integrity: sha512-F3aPsX6hVw9ttm5LYlth8Q15x6MlI/J3Dn+o3EQyRTtTxidepSTwAYdozt01/YA+7ObcciagGEyXIopGZzQtbA==}
+    peerDependencies:
+      solid-js: ^1.3
+
+  source-map-js@1.2.1:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
+
+  stackback@0.0.2:
+    resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
+
+  std-env@4.1.0:
+    resolution: {integrity: sha512-Rq7ybcX2RuC55r9oaPVEW7/xu3tj8u4GeBYHBWCychFtzMIr86A7e3PPEBPT37sHStKX3+TiX/Fr/ACmJLVlLQ==}
+
+  tar@7.5.14:
+    resolution: {integrity: sha512-/7sHKgQO3JLP9ESlwTYUUftHUadOURUqq23xs1vjcnp8Vss6k0wCfzulyEtk5g91pjvnuriimGlyG7k6msrzRw==}
+    engines: {node: '>=18'}
+
+  tiny-invariant@1.3.3:
+    resolution: {integrity: sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==}
+
+  tinybench@2.9.0:
+    resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
+
+  tinyexec@1.2.4:
+    resolution: {integrity: sha512-SHf/r48b7vOrjve9PxJo3MN5v5yuyjHvdUcrQffT3WXMUfnGmHDVbC4k3sHJaJTgZCwpUplIaAo5ANtMyp3YHg==}
+    engines: {node: '>=18'}
+
+  tinyglobby@0.2.17:
+    resolution: {integrity: sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==}
+    engines: {node: '>=12.0.0'}
+
+  tinyrainbow@3.1.0:
+    resolution: {integrity: sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==}
+    engines: {node: '>=14.0.0'}
+
+  typescript@6.0.3:
+    resolution: {integrity: sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  undici-types@7.18.2:
+    resolution: {integrity: sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==}
+
+  update-browserslist-db@1.2.3:
+    resolution: {integrity: sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==}
+    hasBin: true
+    peerDependencies:
+      browserslist: '>= 4.21.0'
+
+  uuid@13.0.0:
+    resolution: {integrity: sha512-XQegIaBTVUjSHliKqcnFqYypAd4S+WCYt5NIeRs6w/UAry7z8Y9j5ZwRRL4kzq9U3sD6v+85er9FvkEaBpji2w==}
+    hasBin: true
+
+  uuid@9.0.1:
+    resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==}
+    deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
+    hasBin: true
+
+  vhtml@2.2.0:
+    resolution: {integrity: sha512-TPXrXrxBOslRUVnlVkiAqhoXneiertIg86bdvzionrUYhEuiROvyPZNiiP6GIIJ2Q7oPNVyEtIx8gMAZZE9lCQ==}
+
+  vite-plugin-solid@2.11.12:
+    resolution: {integrity: sha512-FgjPcx2OwX9h6f28jli7A4bG7PP3te8uyakE5iqsmpq3Jqi1TWLgSroC9N6cMfGRU2zXsl4Q6ISvTr2VL0QHpA==}
+    peerDependencies:
+      '@testing-library/jest-dom': ^5.16.6 || ^5.17.0 || ^6.*
+      solid-js: ^1.7.2
+      vite: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0
+    peerDependenciesMeta:
+      '@testing-library/jest-dom':
+        optional: true
+
+  vite-plugin-wasm@3.6.0:
+    resolution: {integrity: sha512-mL/QPziiIA4RAA6DkaZZzOstdwbW5jO4Vz7Zenj0wieKWBlNvIvX5L5ljum9lcUX0ShNfBgCNLKTjNkRVVqcsw==}
+    peerDependencies:
+      vite: ^2 || ^3 || ^4 || ^5 || ^6 || ^7 || ^8
+
+  vite@7.3.5:
+    resolution: {integrity: sha512-KuOaNhcnGFN2zIPGA7wRmzF+lJA1sea7rHq17aiJ++9lzY1WWG6Jpwqwe1KNbRVPIqHmr8GLYx7jbrQcN/7/ww==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^20.19.0 || >=22.12.0
+      jiti: '>=1.21.0'
+      less: ^4.0.0
+      lightningcss: ^1.21.0
+      sass: ^1.70.0
+      sass-embedded: ^1.70.0
+      stylus: '>=0.54.8'
+      sugarss: ^5.0.0
+      terser: ^5.16.0
+      tsx: ^4.8.1
+      yaml: ^2.4.2
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      jiti:
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+      tsx:
+        optional: true
+      yaml:
+        optional: true
+
+  vitefu@1.1.3:
+    resolution: {integrity: sha512-ub4okH7Z5KLjb6hDyjqrGXqWtWvoYdU3IGm/NorpgHncKoLTCfRIbvlhBm7r0YstIaQRYlp4yEbFqDcKSzXSSg==}
+    peerDependencies:
+      vite: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0
+    peerDependenciesMeta:
+      vite:
+        optional: true
+
+  vitest@4.1.8:
+    resolution: {integrity: sha512-flY6ScbCIt9HThs+C5HS7jvGOB560DJtk/Z15IQROTA6zEy49Nh8T/dofWTQL+n3vswqn87sbJNiuqw1SDp5Ig==}
+    engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
+    hasBin: true
+    peerDependencies:
+      '@edge-runtime/vm': '*'
+      '@opentelemetry/api': ^1.9.0
+      '@types/node': ^20.0.0 || ^22.0.0 || >=24.0.0
+      '@vitest/browser-playwright': 4.1.8
+      '@vitest/browser-preview': 4.1.8
+      '@vitest/browser-webdriverio': 4.1.8
+      '@vitest/coverage-istanbul': 4.1.8
+      '@vitest/coverage-v8': 4.1.8
+      '@vitest/ui': 4.1.8
+      happy-dom: '*'
+      jsdom: '*'
+      vite: ^6.0.0 || ^7.0.0 || ^8.0.0
+    peerDependenciesMeta:
+      '@edge-runtime/vm':
+        optional: true
+      '@opentelemetry/api':
+        optional: true
+      '@types/node':
+        optional: true
+      '@vitest/browser-playwright':
+        optional: true
+      '@vitest/browser-preview':
+        optional: true
+      '@vitest/browser-webdriverio':
+        optional: true
+      '@vitest/coverage-istanbul':
+        optional: true
+      '@vitest/coverage-v8':
+        optional: true
+      '@vitest/ui':
+        optional: true
+      happy-dom:
+        optional: true
+      jsdom:
+        optional: true
+
+  wasm-pack@0.15.0:
+    resolution: {integrity: sha512-DdqtGWc3+iFx+7lL7QU5LBWs7qMnwQSWxF0htSfE15sNa3roVwHjAkTm2JXgueU2GGfSwNqbq2EzyC2b/biKDA==}
+    engines: {node: '>=16'}
+    hasBin: true
+
+  whatwg-mimetype@3.0.0:
+    resolution: {integrity: sha512-nt+N2dzIutVRxARx1nghPKGv1xHikU7HKdfafKkLNLindmPU/ch3U31NOCGGA/dmPcmb1VlofO0vnKAcsm0o/Q==}
+    engines: {node: '>=12'}
+
+  why-is-node-running@2.3.0:
+    resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
+    engines: {node: '>=8'}
+    hasBin: true
+
+  ws@8.21.0:
+    resolution: {integrity: sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: '>=5.0.2'
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
+  xstate@5.32.0:
+    resolution: {integrity: sha512-zsk73aWGmxn9z34P0kbiod5JwTvdYRW3+IDxITq8sd9+VWwMyW7BUzpplnYy9mIEXa6V8IMDv7Hy4m0mhT5+2Q==}
+
+  yallist@3.1.1:
+    resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}
+
+  yallist@5.0.0:
+    resolution: {integrity: sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==}
+    engines: {node: '>=18'}
+
+snapshots:
+
+  '@ark/schema@0.56.0':
+    dependencies:
+      '@ark/util': 0.56.0
+
+  '@ark/util@0.56.0': {}
+
+  '@automerge/automerge-repo-solid-primitives@2.5.6(@automerge/automerge@3.2.6)(solid-js@1.9.13)':
+    dependencies:
+      '@automerge/automerge': 3.2.6
+      solid-js: 1.9.13
+
+  '@automerge/automerge-repo@2.5.6':
+    dependencies:
+      '@automerge/automerge': 3.2.6
+      bs58check: 3.0.1
+      cbor-x: 1.6.4
+      debug: 4.4.3
+      eventemitter3: 5.0.4
+      fast-sha256: 1.3.0
+      uuid: 9.0.1
+      xstate: 5.32.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@automerge/automerge@3.2.6': {}
+
+  '@automerge/prosemirror@0.2.0':
+    dependencies:
+      '@automerge/automerge': 3.2.6
+      ordered-map: 0.1.0
+      prosemirror-changeset: 2.4.1
+      prosemirror-history: 1.5.0
+      prosemirror-model: 1.25.9
+      prosemirror-schema-basic: 1.2.4
+      prosemirror-schema-list: 1.5.1
+      prosemirror-state: 1.4.4
+      prosemirror-transform: 1.12.0
+      prosemirror-view: 1.41.9
+
+  '@babel/code-frame@7.29.7':
+    dependencies:
+      '@babel/helper-validator-identifier': 7.29.7
+      js-tokens: 4.0.0
+      picocolors: 1.1.1
+
+  '@babel/compat-data@7.29.7': {}
+
+  '@babel/core@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-compilation-targets': 7.29.7
+      '@babel/helper-module-transforms': 7.29.7(@babel/core@7.29.7)
+      '@babel/helpers': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+      '@jridgewell/remapping': 2.3.5
+      convert-source-map: 2.0.0
+      debug: 4.4.3
+      gensync: 1.0.0-beta.2
+      json5: 2.2.3
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/generator@7.29.7':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+      jsesc: 3.1.0
+
+  '@babel/helper-compilation-targets@7.29.7':
+    dependencies:
+      '@babel/compat-data': 7.29.7
+      '@babel/helper-validator-option': 7.29.7
+      browserslist: 4.28.2
+      lru-cache: 5.1.1
+      semver: 6.3.1
+
+  '@babel/helper-globals@7.29.7': {}
+
+  '@babel/helper-module-imports@7.18.6':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@babel/helper-module-imports@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-module-transforms@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-module-imports': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
+      '@babel/traverse': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-plugin-utils@7.29.7': {}
+
+  '@babel/helper-string-parser@7.29.7': {}
+
+  '@babel/helper-validator-identifier@7.29.7': {}
+
+  '@babel/helper-validator-option@7.29.7': {}
+
+  '@babel/helpers@7.29.7':
+    dependencies:
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
+
+  '@babel/parser@7.29.7':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
+
+  '@babel/template@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+
+  '@babel/traverse@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-globals': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/types@7.29.7':
+    dependencies:
+      '@babel/helper-string-parser': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
+
+  '@cbor-extract/cbor-extract-darwin-arm64@2.2.2':
+    optional: true
+
+  '@cbor-extract/cbor-extract-darwin-x64@2.2.2':
+    optional: true
+
+  '@cbor-extract/cbor-extract-linux-arm64@2.2.2':
+    optional: true
+
+  '@cbor-extract/cbor-extract-linux-arm@2.2.2':
+    optional: true
+
+  '@cbor-extract/cbor-extract-linux-x64@2.2.2':
+    optional: true
+
+  '@cbor-extract/cbor-extract-win32-x64@2.2.2':
+    optional: true
+
+  '@cfworker/json-schema@4.1.1': {}
+
+  '@esbuild/aix-ppc64@0.27.7':
+    optional: true
+
+  '@esbuild/android-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/android-arm@0.27.7':
+    optional: true
+
+  '@esbuild/android-x64@0.27.7':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/darwin-x64@0.27.7':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-arm@0.27.7':
+    optional: true
+
+  '@esbuild/linux-ia32@0.27.7':
+    optional: true
+
+  '@esbuild/linux-loong64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.27.7':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.27.7':
+    optional: true
 
-  chownr@3.0.0:
-    resolution: {integrity: sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==}
-    engines: {node: '>=18'}
+  '@esbuild/linux-s390x@0.27.7':
+    optional: true
 
-  minipass@7.1.3:
-    resolution: {integrity: sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==}
-    engines: {node: '>=16 || 14 >=14.17'}
+  '@esbuild/linux-x64@0.27.7':
+    optional: true
 
-  minizlib@3.1.0:
-    resolution: {integrity: sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==}
-    engines: {node: '>= 18'}
+  '@esbuild/netbsd-arm64@0.27.7':
+    optional: true
 
-  tar@7.5.14:
-    resolution: {integrity: sha512-/7sHKgQO3JLP9ESlwTYUUftHUadOURUqq23xs1vjcnp8Vss6k0wCfzulyEtk5g91pjvnuriimGlyG7k6msrzRw==}
-    engines: {node: '>=18'}
+  '@esbuild/netbsd-x64@0.27.7':
+    optional: true
 
-  tiny-invariant@1.3.3:
-    resolution: {integrity: sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==}
+  '@esbuild/openbsd-arm64@0.27.7':
+    optional: true
 
-  typescript@6.0.3:
-    resolution: {integrity: sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==}
-    engines: {node: '>=14.17'}
-    hasBin: true
+  '@esbuild/openbsd-x64@0.27.7':
+    optional: true
 
-  uuid@13.0.0:
-    resolution: {integrity: sha512-XQegIaBTVUjSHliKqcnFqYypAd4S+WCYt5NIeRs6w/UAry7z8Y9j5ZwRRL4kzq9U3sD6v+85er9FvkEaBpji2w==}
-    hasBin: true
+  '@esbuild/openharmony-arm64@0.27.7':
+    optional: true
 
-  wasm-pack@0.15.0:
-    resolution: {integrity: sha512-DdqtGWc3+iFx+7lL7QU5LBWs7qMnwQSWxF0htSfE15sNa3roVwHjAkTm2JXgueU2GGfSwNqbq2EzyC2b/biKDA==}
-    engines: {node: '>=16'}
-    hasBin: true
+  '@esbuild/sunos-x64@0.27.7':
+    optional: true
 
-  yallist@5.0.0:
-    resolution: {integrity: sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==}
-    engines: {node: '>=18'}
+  '@esbuild/win32-arm64@0.27.7':
+    optional: true
 
-snapshots:
+  '@esbuild/win32-ia32@0.27.7':
+    optional: true
+
+  '@esbuild/win32-x64@0.27.7':
+    optional: true
 
   '@isaacs/fs-minipass@4.0.1':
     dependencies:
       minipass: 7.1.3
 
+  '@jridgewell/gen-mapping@0.3.13':
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/remapping@2.3.5':
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/resolve-uri@3.1.2': {}
+
+  '@jridgewell/sourcemap-codec@1.5.5': {}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  '@jspreadsheet/formula@2.0.2': {}
+
+  '@jsuites/utils@6.0.6': {}
+
+  '@lemonadejs/calendar@5.9.3':
+    dependencies:
+      '@jsuites/utils': 6.0.6
+      '@lemonadejs/modal': 5.8.3
+      lemonadejs: 5.3.6
+
+  '@lemonadejs/color@5.8.0':
+    dependencies:
+      '@lemonadejs/modal': 5.8.3
+      '@lemonadejs/tabs': 5.8.0
+      lemonadejs: 5.3.6
+
+  '@lemonadejs/contextmenu@5.8.5':
+    dependencies:
+      '@lemonadejs/modal': 5.8.3
+      lemonadejs: 5.3.6
+
+  '@lemonadejs/dropdown@5.8.4':
+    dependencies:
+      '@lemonadejs/modal': 5.8.3
+      lemonadejs: 5.3.6
+
+  '@lemonadejs/modal@5.8.3':
+    dependencies:
+      lemonadejs: 5.3.6
+
+  '@lemonadejs/rating@5.8.1':
+    dependencies:
+      lemonadejs: 5.3.6
+
+  '@lemonadejs/switch@5.8.0':
+    dependencies:
+      lemonadejs: 5.3.6
+
+  '@lemonadejs/tabs@5.8.0':
+    dependencies:
+      lemonadejs: 5.3.6
+
+  '@lemonadejs/topmenu@5.8.0':
+    dependencies:
+      '@lemonadejs/contextmenu': 5.8.5
+      lemonadejs: 5.3.6
+
+  '@mcp-b/webmcp-polyfill@3.0.0':
+    dependencies:
+      '@cfworker/json-schema': 4.1.1
+      '@mcp-b/webmcp-types': 3.0.0
+      '@standard-schema/spec': 1.1.0
+
+  '@mcp-b/webmcp-types@3.0.0': {}
+
+  '@noble/hashes@1.8.0': {}
+
+  '@rollup/rollup-android-arm-eabi@4.61.1':
+    optional: true
+
+  '@rollup/rollup-android-arm64@4.61.1':
+    optional: true
+
+  '@rollup/rollup-darwin-arm64@4.61.1':
+    optional: true
+
+  '@rollup/rollup-darwin-x64@4.61.1':
+    optional: true
+
+  '@rollup/rollup-freebsd-arm64@4.61.1':
+    optional: true
+
+  '@rollup/rollup-freebsd-x64@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-arm-musleabihf@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-gnu@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-musl@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-loong64-gnu@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-loong64-musl@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-ppc64-gnu@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-ppc64-musl@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-gnu@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-musl@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-s390x-gnu@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-x64-gnu@4.61.1':
+    optional: true
+
+  '@rollup/rollup-linux-x64-musl@4.61.1':
+    optional: true
+
+  '@rollup/rollup-openbsd-x64@4.61.1':
+    optional: true
+
+  '@rollup/rollup-openharmony-arm64@4.61.1':
+    optional: true
+
+  '@rollup/rollup-win32-arm64-msvc@4.61.1':
+    optional: true
+
+  '@rollup/rollup-win32-ia32-msvc@4.61.1':
+    optional: true
+
+  '@rollup/rollup-win32-x64-gnu@4.61.1':
+    optional: true
+
+  '@rollup/rollup-win32-x64-msvc@4.61.1':
+    optional: true
+
+  '@standard-schema/spec@1.1.0': {}
+
+  '@tsconfig/strictest@2.0.8': {}
+
+  '@types/babel__core@7.20.5':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+      '@types/babel__generator': 7.27.0
+      '@types/babel__template': 7.4.4
+      '@types/babel__traverse': 7.28.0
+
+  '@types/babel__generator@7.27.0':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@types/babel__template@7.4.4':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+
+  '@types/babel__traverse@7.28.0':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@types/chai@5.2.3':
+    dependencies:
+      '@types/deep-eql': 4.0.2
+      assertion-error: 2.0.1
+
+  '@types/deep-eql@4.0.2': {}
+
+  '@types/estree@1.0.9': {}
+
+  '@types/node@24.13.1':
+    dependencies:
+      undici-types: 7.18.2
+
   '@types/uuid@10.0.0': {}
 
+  '@types/vhtml@2.2.9': {}
+
+  '@types/whatwg-mimetype@3.0.2': {}
+
+  '@types/ws@8.18.1':
+    dependencies:
+      '@types/node': 24.13.1
+
+  '@vitest/expect@4.1.8':
+    dependencies:
+      '@standard-schema/spec': 1.1.0
+      '@types/chai': 5.2.3
+      '@vitest/spy': 4.1.8
+      '@vitest/utils': 4.1.8
+      chai: 6.2.2
+      tinyrainbow: 3.1.0
+
+  '@vitest/mocker@4.1.8(vite@7.3.5(@types/node@24.13.1))':
+    dependencies:
+      '@vitest/spy': 4.1.8
+      estree-walker: 3.0.3
+      magic-string: 0.30.21
+    optionalDependencies:
+      vite: 7.3.5(@types/node@24.13.1)
+
+  '@vitest/pretty-format@4.1.8':
+    dependencies:
+      tinyrainbow: 3.1.0
+
+  '@vitest/runner@4.1.8':
+    dependencies:
+      '@vitest/utils': 4.1.8
+      pathe: 2.0.3
+
+  '@vitest/snapshot@4.1.8':
+    dependencies:
+      '@vitest/pretty-format': 4.1.8
+      '@vitest/utils': 4.1.8
+      magic-string: 0.30.21
+      pathe: 2.0.3
+
+  '@vitest/spy@4.1.8': {}
+
+  '@vitest/utils@4.1.8':
+    dependencies:
+      '@vitest/pretty-format': 4.1.8
+      convert-source-map: 2.0.0
+      tinyrainbow: 3.1.0
+
+  '@viz-js/viz@3.28.0': {}
+
+  arkregex@0.0.6:
+    dependencies:
+      '@ark/util': 0.56.0
+
+  arktype@2.2.1:
+    dependencies:
+      '@ark/schema': 0.56.0
+      '@ark/util': 0.56.0
+      arkregex: 0.0.6
+
+  assertion-error@2.0.1: {}
+
+  babel-plugin-jsx-dom-expressions@0.40.7(@babel/core@7.29.7):
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-module-imports': 7.18.6
+      '@babel/plugin-syntax-jsx': 7.29.7(@babel/core@7.29.7)
+      '@babel/types': 7.29.7
+      html-entities: 2.3.3
+      parse5: 7.3.0
+
+  babel-preset-solid@1.9.12(@babel/core@7.29.7)(solid-js@1.9.13):
+    dependencies:
+      '@babel/core': 7.29.7
+      babel-plugin-jsx-dom-expressions: 0.40.7(@babel/core@7.29.7)
+    optionalDependencies:
+      solid-js: 1.9.13
+
+  base-x@4.0.1: {}
+
+  baseline-browser-mapping@2.10.35: {}
+
+  browserslist@4.28.2:
+    dependencies:
+      baseline-browser-mapping: 2.10.35
+      caniuse-lite: 1.0.30001797
+      electron-to-chromium: 1.5.370
+      node-releases: 2.0.47
+      update-browserslist-db: 1.2.3(browserslist@4.28.2)
+
+  bs58@5.0.0:
+    dependencies:
+      base-x: 4.0.1
+
+  bs58check@3.0.1:
+    dependencies:
+      '@noble/hashes': 1.8.0
+      bs58: 5.0.0
+
+  buffer-image-size@0.6.4:
+    dependencies:
+      '@types/node': 24.13.1
+
+  caniuse-lite@1.0.30001797: {}
+
+  cbor-extract@2.2.2:
+    dependencies:
+      node-gyp-build-optional-packages: 5.1.1
+    optionalDependencies:
+      '@cbor-extract/cbor-extract-darwin-arm64': 2.2.2
+      '@cbor-extract/cbor-extract-darwin-x64': 2.2.2
+      '@cbor-extract/cbor-extract-linux-arm': 2.2.2
+      '@cbor-extract/cbor-extract-linux-arm64': 2.2.2
+      '@cbor-extract/cbor-extract-linux-x64': 2.2.2
+      '@cbor-extract/cbor-extract-win32-x64': 2.2.2
+    optional: true
+
+  cbor-x@1.6.4:
+    optionalDependencies:
+      cbor-extract: 2.2.2
+
+  chai@6.2.2: {}
+
   chownr@3.0.0: {}
 
+  convert-source-map@2.0.0: {}
+
+  csstype@3.2.3: {}
+
+  debug@4.4.3:
+    dependencies:
+      ms: 2.1.3
+
+  detect-libc@2.1.2:
+    optional: true
+
+  electron-to-chromium@1.5.370: {}
+
+  entities@6.0.1: {}
+
+  entities@7.0.1: {}
+
+  es-module-lexer@2.1.0: {}
+
+  esbuild@0.27.7:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.27.7
+      '@esbuild/android-arm': 0.27.7
+      '@esbuild/android-arm64': 0.27.7
+      '@esbuild/android-x64': 0.27.7
+      '@esbuild/darwin-arm64': 0.27.7
+      '@esbuild/darwin-x64': 0.27.7
+      '@esbuild/freebsd-arm64': 0.27.7
+      '@esbuild/freebsd-x64': 0.27.7
+      '@esbuild/linux-arm': 0.27.7
+      '@esbuild/linux-arm64': 0.27.7
+      '@esbuild/linux-ia32': 0.27.7
+      '@esbuild/linux-loong64': 0.27.7
+      '@esbuild/linux-mips64el': 0.27.7
+      '@esbuild/linux-ppc64': 0.27.7
+      '@esbuild/linux-riscv64': 0.27.7
+      '@esbuild/linux-s390x': 0.27.7
+      '@esbuild/linux-x64': 0.27.7
+      '@esbuild/netbsd-arm64': 0.27.7
+      '@esbuild/netbsd-x64': 0.27.7
+      '@esbuild/openbsd-arm64': 0.27.7
+      '@esbuild/openbsd-x64': 0.27.7
+      '@esbuild/openharmony-arm64': 0.27.7
+      '@esbuild/sunos-x64': 0.27.7
+      '@esbuild/win32-arm64': 0.27.7
+      '@esbuild/win32-ia32': 0.27.7
+      '@esbuild/win32-x64': 0.27.7
+
+  escalade@3.2.0: {}
+
+  estree-walker@3.0.3:
+    dependencies:
+      '@types/estree': 1.0.9
+
+  eventemitter3@5.0.4: {}
+
+  expect-type@1.3.0: {}
+
+  fast-sha256@1.3.0: {}
+
+  fdir@6.5.0(picomatch@4.0.4):
+    optionalDependencies:
+      picomatch: 4.0.4
+
+  fsevents@2.3.3:
+    optional: true
+
+  gensync@1.0.0-beta.2: {}
+
+  happy-dom@20.10.2:
+    dependencies:
+      '@types/node': 24.13.1
+      '@types/whatwg-mimetype': 3.0.2
+      '@types/ws': 8.18.1
+      buffer-image-size: 0.6.4
+      entities: 7.0.1
+      whatwg-mimetype: 3.0.0
+      ws: 8.21.0
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  html-entities@2.3.3: {}
+
+  is-what@4.1.16: {}
+
+  js-tokens@4.0.0: {}
+
+  jsesc@3.1.0: {}
+
+  json5@2.2.3: {}
+
+  jspreadsheet-ce@5.0.4:
+    dependencies:
+      '@jspreadsheet/formula': 2.0.2
+      jsuites: 5.13.5
+
+  jsuites@5.13.5: {}
+
+  jsuites@6.4.2:
+    dependencies:
+      '@jsuites/utils': 6.0.6
+      '@lemonadejs/calendar': 5.9.3
+      '@lemonadejs/color': 5.8.0
+      '@lemonadejs/contextmenu': 5.8.5
+      '@lemonadejs/dropdown': 5.8.4
+      '@lemonadejs/modal': 5.8.3
+      '@lemonadejs/rating': 5.8.1
+      '@lemonadejs/switch': 5.8.0
+      '@lemonadejs/tabs': 5.8.0
+      '@lemonadejs/topmenu': 5.8.0
+
+  lemonadejs@5.3.6: {}
+
+  lru-cache@5.1.1:
+    dependencies:
+      yallist: 3.1.1
+
+  magic-string@0.30.21:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  merge-anything@5.1.7:
+    dependencies:
+      is-what: 4.1.16
+
   minipass@7.1.3: {}
 
   minizlib@3.1.0:
     dependencies:
       minipass: 7.1.3
 
+  ms@2.1.3: {}
+
+  nanoid@3.3.12: {}
+
+  node-gyp-build-optional-packages@5.1.1:
+    dependencies:
+      detect-libc: 2.1.2
+    optional: true
+
+  node-releases@2.0.47: {}
+
+  obug@2.1.2: {}
+
+  ordered-map@0.1.0: {}
+
+  orderedmap@2.1.1: {}
+
+  parse5@7.3.0:
+    dependencies:
+      entities: 6.0.1
+
+  pathe@2.0.3: {}
+
+  picocolors@1.1.1: {}
+
+  picomatch@4.0.4: {}
+
+  postcss@8.5.15:
+    dependencies:
+      nanoid: 3.3.12
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  prosemirror-changeset@2.4.1:
+    dependencies:
+      prosemirror-transform: 1.12.0
+
+  prosemirror-history@1.5.0:
+    dependencies:
+      prosemirror-state: 1.4.4
+      prosemirror-transform: 1.12.0
+      prosemirror-view: 1.41.9
+      rope-sequence: 1.3.4
+
+  prosemirror-model@1.25.9:
+    dependencies:
+      orderedmap: 2.1.1
+
+  prosemirror-schema-basic@1.2.4:
+    dependencies:
+      prosemirror-model: 1.25.9
+
+  prosemirror-schema-list@1.5.1:
+    dependencies:
+      prosemirror-model: 1.25.9
+      prosemirror-state: 1.4.4
+      prosemirror-transform: 1.12.0
+
+  prosemirror-state@1.4.4:
+    dependencies:
+      prosemirror-model: 1.25.9
+      prosemirror-transform: 1.12.0
+      prosemirror-view: 1.41.9
+
+  prosemirror-transform@1.12.0:
+    dependencies:
+      prosemirror-model: 1.25.9
+
+  prosemirror-view@1.41.9:
+    dependencies:
+      prosemirror-model: 1.25.9
+      prosemirror-state: 1.4.4
+      prosemirror-transform: 1.12.0
+
+  rollup@4.61.1:
+    dependencies:
+      '@types/estree': 1.0.9
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.61.1
+      '@rollup/rollup-android-arm64': 4.61.1
+      '@rollup/rollup-darwin-arm64': 4.61.1
+      '@rollup/rollup-darwin-x64': 4.61.1
+      '@rollup/rollup-freebsd-arm64': 4.61.1
+      '@rollup/rollup-freebsd-x64': 4.61.1
+      '@rollup/rollup-linux-arm-gnueabihf': 4.61.1
+      '@rollup/rollup-linux-arm-musleabihf': 4.61.1
+      '@rollup/rollup-linux-arm64-gnu': 4.61.1
+      '@rollup/rollup-linux-arm64-musl': 4.61.1
+      '@rollup/rollup-linux-loong64-gnu': 4.61.1
+      '@rollup/rollup-linux-loong64-musl': 4.61.1
+      '@rollup/rollup-linux-ppc64-gnu': 4.61.1
+      '@rollup/rollup-linux-ppc64-musl': 4.61.1
+      '@rollup/rollup-linux-riscv64-gnu': 4.61.1
+      '@rollup/rollup-linux-riscv64-musl': 4.61.1
+      '@rollup/rollup-linux-s390x-gnu': 4.61.1
+      '@rollup/rollup-linux-x64-gnu': 4.61.1
+      '@rollup/rollup-linux-x64-musl': 4.61.1
+      '@rollup/rollup-openbsd-x64': 4.61.1
+      '@rollup/rollup-openharmony-arm64': 4.61.1
+      '@rollup/rollup-win32-arm64-msvc': 4.61.1
+      '@rollup/rollup-win32-ia32-msvc': 4.61.1
+      '@rollup/rollup-win32-x64-gnu': 4.61.1
+      '@rollup/rollup-win32-x64-msvc': 4.61.1
+      fsevents: 2.3.3
+
+  rope-sequence@1.3.4: {}
+
+  semver@6.3.1: {}
+
+  seroval-plugins@1.5.4(seroval@1.5.4):
+    dependencies:
+      seroval: 1.5.4
+
+  seroval@1.5.4: {}
+
+  siginfo@2.0.0: {}
+
+  solid-js@1.9.13:
+    dependencies:
+      csstype: 3.2.3
+      seroval: 1.5.4
+      seroval-plugins: 1.5.4(seroval@1.5.4)
+
+  solid-refresh@0.6.3(solid-js@1.9.13):
+    dependencies:
+      '@babel/generator': 7.29.7
+      '@babel/helper-module-imports': 7.29.7
+      '@babel/types': 7.29.7
+      solid-js: 1.9.13
+    transitivePeerDependencies:
+      - supports-color
+
+  source-map-js@1.2.1: {}
+
+  stackback@0.0.2: {}
+
+  std-env@4.1.0: {}
+
   tar@7.5.14:
     dependencies:
       '@isaacs/fs-minipass': 4.0.1
@@ -100,12 +2019,109 @@ snapshots:
 
   tiny-invariant@1.3.3: {}
 
+  tinybench@2.9.0: {}
+
+  tinyexec@1.2.4: {}
+
+  tinyglobby@0.2.17:
+    dependencies:
+      fdir: 6.5.0(picomatch@4.0.4)
+      picomatch: 4.0.4
+
+  tinyrainbow@3.1.0: {}
+
   typescript@6.0.3: {}
 
+  undici-types@7.18.2: {}
+
+  update-browserslist-db@1.2.3(browserslist@4.28.2):
+    dependencies:
+      browserslist: 4.28.2
+      escalade: 3.2.0
+      picocolors: 1.1.1
+
   uuid@13.0.0: {}
 
+  uuid@9.0.1: {}
+
+  vhtml@2.2.0: {}
+
+  vite-plugin-solid@2.11.12(solid-js@1.9.13)(vite@7.3.5(@types/node@24.13.1)):
+    dependencies:
+      '@babel/core': 7.29.7
+      '@types/babel__core': 7.20.5
+      babel-preset-solid: 1.9.12(@babel/core@7.29.7)(solid-js@1.9.13)
+      merge-anything: 5.1.7
+      solid-js: 1.9.13
+      solid-refresh: 0.6.3(solid-js@1.9.13)
+      vite: 7.3.5(@types/node@24.13.1)
+      vitefu: 1.1.3(vite@7.3.5(@types/node@24.13.1))
+    transitivePeerDependencies:
+      - supports-color
+
+  vite-plugin-wasm@3.6.0(vite@7.3.5(@types/node@24.13.1)):
+    dependencies:
+      vite: 7.3.5(@types/node@24.13.1)
+
+  vite@7.3.5(@types/node@24.13.1):
+    dependencies:
+      esbuild: 0.27.7
+      fdir: 6.5.0(picomatch@4.0.4)
+      picomatch: 4.0.4
+      postcss: 8.5.15
+      rollup: 4.61.1
+      tinyglobby: 0.2.17
+    optionalDependencies:
+      '@types/node': 24.13.1
+      fsevents: 2.3.3
+
+  vitefu@1.1.3(vite@7.3.5(@types/node@24.13.1)):
+    optionalDependencies:
+      vite: 7.3.5(@types/node@24.13.1)
+
+  vitest@4.1.8(@types/node@24.13.1)(happy-dom@20.10.2)(vite@7.3.5(@types/node@24.13.1)):
+    dependencies:
+      '@vitest/expect': 4.1.8
+      '@vitest/mocker': 4.1.8(vite@7.3.5(@types/node@24.13.1))
+      '@vitest/pretty-format': 4.1.8
+      '@vitest/runner': 4.1.8
+      '@vitest/snapshot': 4.1.8
+      '@vitest/spy': 4.1.8
+      '@vitest/utils': 4.1.8
+      es-module-lexer: 2.1.0
+      expect-type: 1.3.0
+      magic-string: 0.30.21
+      obug: 2.1.2
+      pathe: 2.0.3
+      picomatch: 4.0.4
+      std-env: 4.1.0
+      tinybench: 2.9.0
+      tinyexec: 1.2.4
+      tinyglobby: 0.2.17
+      tinyrainbow: 3.1.0
+      vite: 7.3.5(@types/node@24.13.1)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/node': 24.13.1
+      happy-dom: 20.10.2
+    transitivePeerDependencies:
+      - msw
+
   wasm-pack@0.15.0:
     dependencies:
       tar: 7.5.14
 
+  whatwg-mimetype@3.0.0: {}
+
+  why-is-node-running@2.3.0:
+    dependencies:
+      siginfo: 2.0.0
+      stackback: 0.0.2
+
+  ws@8.21.0: {}
+
+  xstate@5.32.0: {}
+
+  yallist@3.1.1: {}
+
   yallist@5.0.0: {}
diff --git a/packages/document-methods/src/future/analysis.ts b/packages/document-methods/src/future/analysis.ts
new file mode 100644
index 000000000..f82b9e424
--- /dev/null
+++ b/packages/document-methods/src/future/analysis.ts
@@ -0,0 +1,26 @@
+import type { Analysis, AnalysisType, Document, Link } from "catcolab-document-types";
+import { currentVersion } from "catcolab-document-types";
+import { newNotebook } from "../notebook";
+
+/** A document defining an analysis notebook over another document. */
+export type AnalysisDocument = Document & { type: "analysis" };
+
+/** Create an empty analysis document. */
+export const newAnalysisDocument = (args: {
+    analysisType: AnalysisType;
+    analysisOf: Link;
+    name?: string;
+}): AnalysisDocument => ({
+    type: "analysis",
+    name: args.name ?? "",
+    analysisType: args.analysisType,
+    analysisOf: args.analysisOf,
+    notebook: newNotebook<Analysis>(),
+    version: currentVersion(),
+});
+
+/** Create a new analysis cell with the given id and initial content. */
+export const newAnalysisCell = (id: string, content: Record<string, unknown>): Analysis => ({
+    id,
+    content,
+});
diff --git a/packages/document-methods/src/future/definitions.ts b/packages/document-methods/src/future/definitions.ts
new file mode 100644
index 000000000..d09074842
--- /dev/null
+++ b/packages/document-methods/src/future/definitions.ts
@@ -0,0 +1,1418 @@
+import type {
+    AnalysisType,
+    Link,
+    Modality,
+    MorType,
+    Ob,
+    ObOp,
+    ObType,
+    SpecializeModel,
+} from "catcolab-document-types";
+import type {
+    DblModel,
+    DblModelDiagram,
+    DblTheory,
+    InvalidDiscreteDblModelDiagram,
+} from "catlog-wasm";
+import type { RichTextContent } from "../notebook";
+import type { Notebook } from "./notebook";
+import type { RichTextRef } from "./store";
+import type { Result } from "./validation";
+
+export type CoreTheoryLoader = () => Promise<DblTheory>;
+
+const coreTheoryCache = new WeakMap<CoreTheoryLoader, Promise<DblTheory>>();
+
+function lazyCoreTheory(load: CoreTheoryLoader): CoreTheoryLoader {
+    let cached: Promise<DblTheory> | undefined;
+
+    return () => {
+        cached ??= Promise.resolve().then(load);
+        return cached;
+    };
+}
+
+export function resolveCoreTheory(shape: {
+    readonly getCoreTheory?: CoreTheoryLoader | undefined;
+}): Promise<DblTheory | undefined> {
+    const load = shape.getCoreTheory;
+    if (!load) {
+        return Promise.resolve(undefined);
+    }
+    let cached = coreTheoryCache.get(load);
+    if (!cached) {
+        cached = Promise.resolve().then(load);
+        coreTheoryCache.set(load, cached);
+    }
+    return cached;
+}
+
+const richTextKind: unique symbol = Symbol("richText");
+const objectKind: unique symbol = Symbol("object");
+const morphismKind: unique symbol = Symbol("morphism");
+const instantiationKind: unique symbol = Symbol("instantiation");
+const analysisKind: unique symbol = Symbol("analysis");
+const pathEquationKind: unique symbol = Symbol("pathEquation");
+
+/** Precise discriminants for notebook cell handles. */
+export const CellKind = {
+    RichText: richTextKind,
+    Object: objectKind,
+    Morphism: morphismKind,
+    Instantiation: instantiationKind,
+    Analysis: analysisKind,
+    PathEquation: pathEquationKind,
+} as const;
+
+const richTextTypeBrand: unique symbol = Symbol("richTextType");
+const instantiationTypeBrand: unique symbol = Symbol("instantiationType");
+const pathEquationTypeBrand: unique symbol = Symbol("pathEquationType");
+
+/**
+ * The sentinel cell-type used to add rich-text cells to a notebook. Pass it
+ * as the first argument to {@link Notebook.add}; the second argument is
+ * `{ content: RichTextContent }`. Unlike object and morphism types,
+ * `RichText` is not an `ObType`/`MorType`; it lives at the top level.
+ */
+export type RichTextType = { readonly [richTextTypeBrand]: true };
+
+/** The singleton {@link RichTextType} value. */
+export const RichText: RichTextType = { [richTextTypeBrand]: true };
+
+export const isRichTextType = (value: unknown): value is RichTextType =>
+    typeof value === "object" &&
+    value !== null &&
+    (value as RichTextType)[richTextTypeBrand] === true;
+
+/** The sentinel cell-type used to add model instantiations to a notebook. */
+export type InstantiationType = { readonly [instantiationTypeBrand]: true };
+
+/** The singleton {@link InstantiationType} value. */
+export const Instantiation: InstantiationType = { [instantiationTypeBrand]: true };
+
+export const isInstantiationType = (value: unknown): value is InstantiationType =>
+    typeof value === "object" &&
+    value !== null &&
+    (value as InstantiationType)[instantiationTypeBrand] === true;
+
+/**
+ * The sentinel cell-type used to add *path equations* to a model notebook:
+ * equations between paths of the notebook's morphisms. Pass it as the first
+ * argument to {@link Notebook.add}; the second argument is a
+ * {@link PathEquationArgs}. A shape opts into path equations by declaring
+ * `supportsEquations: true` (see {@link Shape.supportsEquations}); a shape
+ * that does not cannot add them.
+ */
+export type PathEquationType = { readonly [pathEquationTypeBrand]: true };
+
+/** The singleton {@link PathEquationType} value. */
+export const PathEquation: PathEquationType = { [pathEquationTypeBrand]: true };
+
+export const isPathEquationType = (value: unknown): value is PathEquationType =>
+    typeof value === "object" &&
+    value !== null &&
+    (value as PathEquationType)[pathEquationTypeBrand] === true;
+
+/** Methods shared by all cell handles for editing a field. */
+export type Update<T> = {
+    /** Update one or more of the cell's fields. */
+    update(args: Partial<T>): void;
+};
+
+/** Methods shared by all cell handles for re-ordering and removal. Cells
+are identified by id at the moment the change applies, so operations stay
+valid even if the notebook was edited after the handle was obtained. */
+export type Reorder = {
+    /** Move this cell one position earlier; no-op if already first. */
+    moveUp(): void;
+    /** Move this cell one position later; no-op if already last. */
+    moveDown(): void;
+    /**
+     * Move this cell to the given index, interpreted after the cell is
+     * removed from its current position. Out-of-range targets clamp to the
+     * ends of the notebook.
+     */
+    moveTo(index: number): void;
+    /**
+     * Remove this cell from the notebook. After deletion, reads of the
+     * handle's fields (e.g. `label`, `content`) return `undefined`. Deleting a
+     * cell that is no longer in the notebook is a silent no-op.
+     */
+    delete(): void;
+};
+
+/**
+ * A tagged wrapper declaring an object type, built with {@link defineObject}.
+ * The `tag` discriminates it from a {@link MorphismDef}, so a `Basic` object
+ * and a `Basic` morphism — structurally identical as `ObType`/`MorType` — are
+ * told apart by their wrapper rather than by any structural heuristic.
+ */
+export type ObjectDef<O extends ObType = ObType> = {
+    readonly tag: "object";
+    readonly obType: O;
+};
+
+/** Wrap an `ObType` literal as an {@link ObjectDef}. Declare the result as a
+ * `const` and pass it both to a shape's `objects` list and to {@link
+ * Notebook.add}. */
+export function defineObject<const O extends ObType>(obType: O): ObjectDef<O> {
+    return { tag: "object", obType };
+}
+
+/**
+ * An object-cell handle, parametrized by its {@link ObjectDef}: two object
+ * defs with different `obType` values (e.g. a Petri-net `Place`, wrapping
+ * `{ tag: "Basic", content: "Object" }`, and a schema `Entity`, wrapping
+ * `{ tag: "Basic", content: "Entity" }`) yield distinct, non-interchangeable
+ * cell handles. The widest instantiation, `ObjectCell<ObjectDef>` (or the
+ * default `ObjectCell`), is the untyped form a generic notebook yields.
+ */
+export type ObjectCell<Def extends ObjectDef = ObjectDef> = Update<{ label: string }> &
+    Reorder & {
+        readonly kind: typeof CellKind.Object;
+        readonly id: string;
+        readonly type: Def;
+        readonly label: string;
+        duplicate(): ObjectCell<Def>;
+    };
+
+/** Modalities whose endpoints are lists of objects rather than a single one. */
+type ListModality = "List" | "SymmetricList" | "CocartesianList" | "CartesianList" | "AdditiveList";
+
+/**
+ * The endpoint type of a morphism cell, derived from the morphism's `MorType`:
+ *
+ * - a plain `Hom` over an object type (e.g. a schema `Mapping`,
+ *   `Hom(Entity)`) has a single object cell of that type;
+ * - any other morphism type does not record its endpoint object type, so its
+ *   endpoints stay untyped: a single object cell or a list of them.
+ *
+ * A morphism whose endpoints are *lists* (e.g. a Petri-net transition) declares
+ * a list `modality` instead; its array endpoints are given by {@link
+ * ListEndpointOf}. For the precise cases the `MorType` must be a literal, which
+ * {@link defineMorphism}'s `const` type parameter preserves automatically.
+ */
+export type EndpointOf<M extends MorType> = [M] extends [
+    { tag: "Hom"; content: infer O extends ObType },
+]
+    ? ObjectCell<ObjectDef<O>>
+    : ObjectCell | ObjectCell[];
+
+/**
+ * The array endpoint type of a list morphism (one declared with a `modality`,
+ * e.g. a Petri-net transition): an array of object cells of the `Hom`'s object
+ * type. The list counterpart of {@link EndpointOf}.
+ */
+type ListEndpointOf<M extends MorType> = [M] extends [
+    { tag: "Hom"; content: infer O extends ObType },
+]
+    ? ObjectCell<ObjectDef<O>>[]
+    : ObjectCell[];
+
+declare const domBrand: unique symbol;
+declare const codBrand: unique symbol;
+declare const modalityBrand: unique symbol;
+
+/**
+ * Phantom carrier of a morphism's endpoint object types. A `Hom` morphism reads
+ * its endpoints from its `MorType` structure, but a `Basic` morphism (e.g. a
+ * schema `Attr`) records nothing about its source/target in the literal, so
+ * {@link defineMorphism} brands it with these. They exist only in the type
+ * system; they are never written at runtime.
+ */
+export type Endpoints<D extends ObType, C extends ObType> = {
+    readonly [domBrand]: D;
+    readonly [codBrand]: C;
+};
+
+/**
+ * Phantom carrier of a morphism's list modality, present on *every* {@link
+ * MorphismDef}: `Mod` is the list modality for a list morphism (e.g. a
+ * Petri-net transition's `SymmetricList`) or `null` for an ordinary morphism.
+ * The morphism type itself stays the plain `Hom(Object)` the core theory
+ * understands; the list-ness lives here in the type system (driving {@link
+ * DomOf}/{@link CodOf} to array endpoints) and in the runtime
+ * `domain`/`codomain` endpoint metadata.
+ *
+ * Because the brand is carried by all morphisms with a *distinct* value per
+ * modality (and `null` for none), any two morphisms with different modalities
+ * are *mutually* non-assignable — a `List` is interchangeable with neither a
+ * `SymmetricList` nor a plain `Hom`. The shape-assignability bivariance (see the
+ * `__morphismShapeBound` phantom on {@link Notebook}) depends on this: now that
+ * a list morphism's type is structurally the plain `Hom(Object)` shared with
+ * e.g. an olog `Aspect`, the modality is the only thing keeping their notebooks
+ * from being wrongly interchangeable.
+ */
+export type ModalityBrand<Mod extends ListModality | null> = {
+    readonly [modalityBrand]: Mod;
+};
+
+/**
+ * A tagged wrapper declaring a morphism type, built with {@link defineMorphism}.
+/**
+ * Metadata controlling a morphism's domain or codomain, mirroring the
+ * frontend's theory `MorDomainMeta`. An `apply` operation (e.g. a Petri-net's
+ * `tensor`) turns a list of objects into the single object the endpoint
+ * actually is, so its presence is what makes an endpoint list-like; the
+ * `modality` is the kind of list that operation consumes. They belong together
+ * here, on the endpoint, because the modality is a property of the `apply`
+ * operation's domain (the frontend reads it back as `theory.dom(apply)`), not
+ * of the morphism as a whole — so the two endpoints may even differ.
+ */
+export type MorEndpointMeta = {
+    readonly apply?: ObOp | undefined;
+    readonly modality?: Modality | undefined;
+    /**
+     * The object type an endpoint cell must have, recorded so {@link
+     * Notebook.add} can reject an endpoint of the wrong type (or from another
+     * theory) at runtime — the check the phantom {@link Endpoints} brand makes
+     * at compile time. For a `Hom` morphism it is the `Hom`'s object type; for a
+     * list morphism it is the list element's object type; for a `Basic`
+     * morphism it is the explicitly declared endpoint `ObType`. Absent only for
+     * a morphism whose endpoint object type is genuinely unconstrained.
+     */
+    readonly obType?: ObType | undefined;
+};
+
+/**
+ * A tagged wrapper declaring a morphism type, built with {@link defineMorphism}.
+ * For a `Hom` morphism the endpoints are derived from its `MorType` structure;
+ * for a list morphism (whose `domain`/`codomain` each declare an `apply` op and
+ * a `modality`) they are arrays of the `Hom`'s object type, stored as
+ * `App(apply, List(modality, …))`: the `apply` operation is what turns a list
+ * of objects into the single object the morphism connects, and so is what makes
+ * the endpoint list-like. The endpoint operations and modalities live in the
+ * runtime `domain`/`codomain` fields; the modality is also carried in the
+ * phantom {@link ModalityBrand} for type-level distinctness. For any other
+ * morphism (e.g. a `Basic` morphism such as a schema `Attr`) the endpoint
+ * object types are carried in the phantom {@link Endpoints} brand.
+ */
+export type MorphismDef<M extends MorType = MorType> = {
+    readonly tag: "morphism";
+    readonly morType: M;
+    readonly domain?: MorEndpointMeta | undefined;
+    readonly codomain?: MorEndpointMeta | undefined;
+};
+
+/** The inner `MorType` of a {@link MorphismDef}. */
+type MorTypeOf<Def extends MorphismDef> = Def extends MorphismDef<infer M> ? M : never;
+
+/**
+ * Declare a morphism type as a {@link MorphismDef}.
+ *
+ * - For a plain `Hom` morphism, the endpoint object type is read from the
+ *   `MorType` structure, so only the morphism type is passed.
+ * - For a list morphism (e.g. a Petri-net transition), pass `{ domain, codomain
+ *   }` whose endpoints each declare an `apply` op and a `modality`, such as `{
+ *   domain: { apply: { tag: "Basic", content: "tensor" }, modality:
+ *   "SymmetricList" }, codomain: { … } }`. The morphism type stays the plain
+ *   `Hom(Object)` the core theory understands; each `apply` operation turns a
+ *   list into the single object the endpoint connects, so endpoints are stored
+ *   as `App(apply, List(modality, …))` (see {@link encodeEndpoint}) and read
+ *   back as arrays. The operations and modalities live in the runtime
+ *   `domain`/`codomain` fields; the modality is also carried in the phantom
+ *   {@link ModalityBrand}.
+ * - For any other morphism (e.g. a `Basic` morphism, such as a schema `Attr`),
+ *   the endpoint object types are not recorded in the literal, so each is
+ *   passed as the endpoint's `ObType` in the same `{ domain, codomain }`
+ *   options object, e.g. `{ domain: Entity.obType, codomain: AttrType.obType
+ *   }`; they are carried in the phantom {@link Endpoints} brand.
+ *
+ * The `{ domain, codomain }` options are thus unified across the `Basic` and
+ * list `Hom` cases: each endpoint is either an `ObType` (a single object of
+ * that type) or an `apply` definition `{ apply, modality }` (a list endpoint).
+ *
+ * Every result carries a {@link ModalityBrand} (`null` when no modality is
+ * declared) so list and non-list morphisms are mutually non-assignable.
+ */
+export function defineMorphism<const M extends MorType & { tag: "Hom" }>(
+    morType: M,
+): MorphismDef<M> & ModalityBrand<null>;
+export function defineMorphism<
+    const M extends MorType & { tag: "Hom" },
+    const DomMod extends ListModality,
+    const CodMod extends ListModality,
+>(
+    morType: M,
+    options: {
+        domain: { apply: ObOp; modality: DomMod };
+        codomain: { apply: ObOp; modality: CodMod };
+    },
+): MorphismDef<M> & ModalityBrand<DomMod | CodMod>;
+export function defineMorphism<
+    const M extends MorType,
+    const D extends ObType,
+    const C extends ObType,
+>(
+    morType: M,
+    options: { domain: D; codomain: C },
+): MorphismDef<M> & Endpoints<D, C> & ModalityBrand<null>;
+export function defineMorphism(
+    morType: MorType,
+    options?: {
+        domain?: ObType | MorEndpointMeta;
+        codomain?: ObType | MorEndpointMeta;
+    },
+): MorphismDef {
+    // The object type a `Hom` morphism's endpoints connect, read from the
+    // `MorType` literal (and shared by both endpoints). A list morphism's
+    // endpoints are lists of this same object type; a `Basic` morphism records
+    // nothing here, so its endpoint types come from `options` instead.
+    const homObType: ObType | undefined =
+        morType.tag === "Hom" ? (morType.content as ObType) : undefined;
+
+    // Build the runtime metadata for one endpoint. An endpoint is either an
+    // `ObType` (`{ tag, content }`) — a single object of that type — or an
+    // `apply` definition (`{ apply, modality }`) for a list endpoint. Either
+    // way the endpoint's expected object type is recorded so {@link
+    // Notebook.add} can validate it: a `Basic` endpoint supplies it directly,
+    // while a `Hom`/list endpoint takes it from the `MorType`.
+    const toMeta = (
+        endpoint: ObType | MorEndpointMeta | undefined,
+    ): MorEndpointMeta | undefined => {
+        const isApply = endpoint && ("apply" in endpoint || "modality" in endpoint);
+        if (isApply) {
+            const meta = endpoint as MorEndpointMeta;
+            return { ...meta, obType: meta.obType ?? homObType };
+        }
+        // A bare `ObType` endpoint (a `Basic` morphism's declared endpoint).
+        const obType = (endpoint as ObType | undefined) ?? homObType;
+        return obType ? { obType } : undefined;
+    };
+
+    return {
+        tag: "morphism",
+        morType,
+        domain: toMeta(options?.domain),
+        codomain: toMeta(options?.codomain),
+    };
+}
+
+/**
+ * The domain endpoint type of a morphism cell. A {@link defineMorphism}-branded
+ * morphism uses its declared domain; otherwise the endpoints are derived from
+ * the morphism type via {@link EndpointOf}.
+ */
+export type DomOf<Def extends MorphismDef> = [Def] extends [ModalityBrand<ListModality>]
+    ? ListEndpointOf<MorTypeOf<Def>>
+    : [Def] extends [Endpoints<infer D extends ObType, ObType>]
+      ? ObjectCell<ObjectDef<D>>
+      : EndpointOf<MorTypeOf<Def>>;
+
+/** The codomain endpoint type of a morphism cell; see {@link DomOf}. */
+export type CodOf<Def extends MorphismDef> = [Def] extends [ModalityBrand<ListModality>]
+    ? ListEndpointOf<MorTypeOf<Def>>
+    : [Def] extends [Endpoints<ObType, infer C extends ObType>]
+      ? ObjectCell<ObjectDef<C>>
+      : EndpointOf<MorTypeOf<Def>>;
+
+/**
+ * A morphism-cell handle, parametrized by its {@link MorphismDef}. The domain
+ * and codomain types are derived by {@link DomOf}/{@link CodOf}, so wiring an
+ * endpoint of the wrong object type, or a single object where a list is
+ * required, is a compile error. The widest instantiation,
+ * `MorphismCell<MorphismDef>` (or the default `MorphismCell`), is the untyped
+ * form a generic notebook yields; its endpoints are then the union of a single
+ * object cell or a list, so reading a single field like `cell.from.label` is a
+ * type error.
+ */
+export type MorphismCell<Def extends MorphismDef = MorphismDef> = Update<{
+    label: string;
+    from: DomOf<Def>;
+    to: CodOf<Def>;
+}> &
+    Reorder & {
+        readonly kind: typeof CellKind.Morphism;
+        readonly id: string;
+        readonly type: Def;
+        readonly label: string;
+        readonly from: DomOf<Def>;
+        readonly to: CodOf<Def>;
+        duplicate(): MorphismCell<Def>;
+    };
+
+export type RichTextCell = Update<{ content: RichTextContent }> &
+    Reorder & {
+        readonly kind: typeof CellKind.RichText;
+        readonly id: string;
+        readonly content: RichTextContent;
+        /**
+         * The store-native reference an incremental rich-text editor binds to
+         * (see {@link RichTextRef}), via {@link DocumentStore.getRichTextRef}.
+         * `undefined` when the store cannot bind an incremental editor; the
+         * cell's content is then replace-only, through {@link update}.
+         */
+        readonly editorRef: RichTextRef | undefined;
+    };
+
+/**
+ * The arguments to {@link Notebook.add} for a path equation cell. Each side is
+ * a *path*: an array of the notebook's morphism cells, composed left to right
+ * (`[f, g]` is "`f` then `g`"). Either side may be `null` to record an unset
+ * side, and `label` may be `null` for an unlabeled equation.
+ */
+export type PathEquationArgs = {
+    label: string | null;
+    lhs: readonly MorphismCell[] | null;
+    rhs: readonly MorphismCell[] | null;
+};
+
+/**
+ * A path-equation cell handle: an equation between two paths of the notebook's
+ * morphisms. Reading `lhs`/`rhs` yields the morphism cells the stored paths
+ * reference, in composition order; a reference to a morphism that has since
+ * been deleted is silently omitted, the same graceful degradation as a
+ * morphism cell's dangling endpoint. A single-step side is stored as the bare
+ * morphism and a longer side as a `Composite` sequence — the same convention
+ * the frontend equation editor persists — so `lhs`/`rhs` always read back as
+ * arrays regardless of the stored shape.
+ */
+export type PathEquationCell = Update<{
+    label: string;
+    lhs: readonly MorphismCell[] | null;
+    rhs: readonly MorphismCell[] | null;
+}> &
+    Reorder & {
+        readonly kind: typeof CellKind.PathEquation;
+        readonly id: string;
+        readonly label: string;
+        readonly lhs: MorphismCell[];
+        readonly rhs: MorphismCell[];
+        duplicate(): PathEquationCell;
+    };
+
+/**
+ * A tagged wrapper declaring an *individual* type in a diagram: an instance of a
+ * model object type, built with {@link defineIndividual}. It carries the {@link
+ * ObjectDef} of the model object type its individuals are drawn over (e.g. the
+ * olog `Object` type), so {@link Notebook.add} can record the diagram object's
+ * `obType` and check that the model object an individual is `over` has that
+ * type. Discriminated from {@link AspectDef} by its `tag`.
+ */
+export type IndividualDef<O extends ObjectDef = ObjectDef> = {
+    readonly tag: "individual";
+    readonly object: O;
+    /** The model object type an individual instantiates. */
+    readonly obType: O["obType"];
+};
+
+/** Wrap a model {@link ObjectDef} as an {@link IndividualDef}, the diagram-level
+ * type for instances of that model object type. */
+export function defineIndividual<const O extends ObjectDef>(object: O): IndividualDef<O> {
+    return { tag: "individual", object, obType: object.obType };
+}
+
+/**
+ * A tagged wrapper declaring an *aspect* type in a diagram: an instance of a
+ * model morphism type, built with {@link defineAspect}. It carries the {@link
+ * MorphismDef} of the model morphism type its aspects are drawn over (e.g. the
+ * olog `has` aspect). Discriminated from {@link IndividualDef} by its `tag`.
+ */
+export type AspectDef<M extends MorphismDef = MorphismDef> = {
+    readonly tag: "aspect";
+    readonly morphism: M;
+    readonly morType: M["morType"];
+};
+
+/** Wrap a model {@link MorphismDef} as an {@link AspectDef}, the diagram-level
+ * type for instances of that model morphism type. */
+export function defineAspect<const M extends MorphismDef>(morphism: M): AspectDef<M> {
+    return { tag: "aspect", morphism, morType: morphism.morType };
+}
+
+/**
+ * An individual-cell handle in a diagram notebook (see {@link Notebook.cells}).
+ * Like an {@link ObjectCell} it carries the {@link CellKind.Object} discriminant,
+ * but it additionally records the model object it is drawn `over` — an {@link
+ * ObjectCell} of the model the diagram is in. Reading `over` yields that model
+ * object cell, so `cell.over.label` is the model object's label.
+ */
+export type IndividualCell<Def extends IndividualDef = IndividualDef> = Update<{
+    label: string;
+    over: ObjectCell<Def["object"]>;
+}> &
+    Reorder & {
+        readonly kind: typeof CellKind.Object;
+        readonly id: string;
+        readonly type: Def;
+        readonly label: string;
+        /** The model object this individual is drawn over. */
+        readonly over: ObjectCell<Def["object"]>;
+        duplicate(): IndividualCell<Def>;
+    };
+
+/**
+ * An aspect-cell handle in a diagram notebook (see {@link Notebook.cells}). Like
+ * a {@link MorphismCell} it carries the {@link CellKind.Morphism} discriminant,
+ * but its `from`/`to` endpoints are diagram {@link IndividualCell}s (single
+ * cells, never arrays) and it additionally records the model morphism it is
+ * drawn `over` — a {@link MorphismCell} of the model the diagram is in.
+ */
+export type AspectCell<Def extends AspectDef = AspectDef> = Update<{
+    label: string;
+    from: IndividualCell;
+    to: IndividualCell;
+    over: MorphismCell<Def["morphism"]>;
+}> &
+    Reorder & {
+        readonly kind: typeof CellKind.Morphism;
+        readonly id: string;
+        readonly type: Def;
+        readonly label: string;
+        readonly from: IndividualCell;
+        readonly to: IndividualCell;
+        /** The model morphism this aspect is drawn over. */
+        readonly over: MorphismCell<Def["morphism"]>;
+        duplicate(): AspectCell<Def>;
+    };
+
+/**
+ * The union of cell handles that iterating a *diagram* notebook with {@link
+ * Notebook.cells} yields: rich-text cells plus the diagram's individual and
+ * aspect cells. `cell.kind` discriminates an {@link IndividualCell} as {@link
+ * CellKind.Object} and an {@link AspectCell} as {@link CellKind.Morphism}, so a
+ * `switch` on `kind` narrows to the precise diagram handle.
+ */
+export type DiagramCell = RichTextCell | IndividualCell | AspectCell;
+
+export type InstantiationSpecialization = {
+    readonly object: ObjectCell;
+    readonly as: ObjectCell;
+};
+
+/**
+ * A notebook that can be {@link Notebook.validate}d, i.e. whose shape declares a
+ * `getCoreTheory`. An instantiation resolves its referenced model by validating it,
+ * so only a validatable notebook may be an instantiation's `model`; a notebook
+ * over a shape without a `getCoreTheory` is rejected at compile time. A notebook
+ * over a richer shape stays assignable here, since `validate` is the structural
+ * marker {@link CoreTheoryMethods} adds exactly when the shape has a core theory.
+ *
+ * It declares the *whole* core-theory surface — `validate` **and** `migrateTo` —
+ * so it mirrors what `CoreTheoryMethods` contributes to a concrete core-theory
+ * notebook. That parity lets a `Notebook<PickerShape> & ValidatableNotebook`
+ * (a getCoreTheory-less picker shape re-annotated as validatable) stay assignable
+ * to a slot typed over a concrete core-theory shape, which also expects
+ * `migrateTo`; declaring only `validate` would leave `migrateTo` missing there.
+ */
+// oxlint-disable-next-line typescript/no-explicit-any
+export type ValidatableNotebook<Handle = any> = Notebook<AnyShape, Handle> & {
+    validate(): Promise<ModelValidationResult>;
+    onValidate(callback: (result: ModelValidationResult) => void): () => void;
+    migrateTo<TTarget extends CreatableShape>(
+        targetShape: TTarget,
+    ): Promise<Result<Notebook<TTarget, Handle>>>;
+};
+
+// oxlint-disable-next-line typescript/no-explicit-any
+export type InstantiationArgs<Handle = any> = {
+    label: string;
+    /**
+     * The referenced model: a {@link ValidatableNotebook} (its shape must
+     * declare a `getCoreTheory`, so it can be resolved by validation), or `null`
+     * for none. A reference is made by passing the notebook itself, not a
+     * {@link Link}; the cell records the corresponding link internally.
+     */
+    model: ValidatableNotebook<Handle> | null;
+    specializations?: readonly InstantiationSpecialization[];
+};
+
+// oxlint-disable-next-line typescript/no-explicit-any
+export type InstantiationCell<Handle = any> = Update<Partial<InstantiationArgs<Handle>>> &
+    Reorder & {
+        readonly kind: typeof CellKind.Instantiation;
+        readonly id: string;
+        readonly label: string;
+        readonly model: Link | null;
+        readonly specializations: readonly SpecializeModel[];
+        duplicate(): InstantiationCell<Handle>;
+    };
+
+/**
+ * The union of object-cell handles a shape declares, one member per object
+ * type listed in the shape. Distributing over the shape's listed types (rather
+ * than over the internal {@link ObType} union) keeps each declared type a
+ * distinct, discriminable member; for the default {@link AnyShape} it collapses
+ * to the widest {@link ObjectCell}.
+ */
+type ObjectCellsOf<TShape extends AnyShape> = TShape extends AnyShape
+    ? ObjectCellTuple<ShapeObjectList<TShape>>[number]
+    : never;
+
+/**
+ * Map a shape's object list to a parallel list of object-cell handles. Taking
+ * the list as an array type parameter makes this a homomorphic mapped type over
+ * the tuple, so distribution happens over the tuple's *positions* (one handle
+ * per listed def) rather than over the internal {@link ObjectDef} union — the
+ * base `Shape` (whose element is the whole `ObjectDef`) collapses to the single
+ * widest {@link ObjectCell}.
+ */
+type ObjectCellTuple<Os extends readonly ObjectDef[]> = {
+    [K in keyof Os]: ObjectCell<Os[K] & ObjectDef>;
+};
+
+/** The union of morphism-cell handles a shape declares; see {@link ObjectCellsOf}. */
+type MorphismCellsOf<TShape extends AnyShape> = TShape extends AnyShape
+    ? MorphismCellTuple<ShapeMorphismList<TShape>>[number]
+    : never;
+
+/** Morphism-side counterpart of {@link ObjectCellTuple}. */
+type MorphismCellTuple<Ms extends readonly MorphismDef[]> = {
+    [K in keyof Ms]: MorphismCell<Ms[K] & MorphismDef>;
+};
+
+/**
+ * The union of analysis-cell handles a shape declares; see {@link
+ * ObjectCellsOf}. Gated on {@link HasAnalyses} so only an analysis shape
+ * contributes analysis cells: an ordinary model shape (and the base {@link
+ * Shape}, whose `analyses` key is merely optional) contributes `never`, keeping
+ * `AnalysisCell` out of a model notebook's {@link NotebookCell} union.
+ */
+export type AnalysisCellsOf<TShape extends AnyShape> = TShape extends AnyShape
+    ? HasAnalyses<TShape> extends true
+        ? AnalysisCellTuple<ShapeAnalysisList<TShape>>[number]
+        : never
+    : never;
+
+/** Analysis-side counterpart of {@link ObjectCellTuple}. */
+type AnalysisCellTuple<As extends readonly AnalysisDef[]> = {
+    [K in keyof As]: AnalysisCell<As[K] & AnalysisDef>;
+};
+
+/**
+ * The union of cell handles that filtering a notebook with {@link
+ * Notebook.cellsOf} by a sub-shape yields. Unlike {@link NotebookCell} (which
+ * describes {@link Notebook.cells} and so always carries `RichTextCell` and
+ * `InstantiationCell`), this contains only the cell types the shape declares:
+ * each of its object/morphism/analysis types contributes its own precise
+ * handle, matching the runtime filter. {@link RichTextCell} is included exactly
+ * when the shape declares `informal: [RichText]` (see {@link HasRichText}), and
+ * {@link PathEquationCell} exactly when it declares `supportsEquations: true`
+ * (see {@link HasPathEquations}).
+ * Distributes over a union of shapes like the per-kind helpers it composes.
+ */
+export type ShapeCellsOf<TShape extends AnyShape> = TShape extends AnyShape
+    ?
+          | ObjectCellsOf<TShape>
+          | MorphismCellsOf<TShape>
+          | AnalysisCellsOf<TShape>
+          | (HasRichText<TShape> extends true ? RichTextCell : never)
+          | (HasPathEquations<TShape> extends true ? PathEquationCell : never)
+    : never;
+
+/**
+ * A pushforward migration from this shape to another. Mirrors the core: it
+ * transports an elaborated model along a theory morphism into the target
+ * theory. The resolved target core theory is supplied by the caller of
+ * `migrateTo`.
+ */
+export type ModelMigration = {
+    /** Identifier of the document theory migrated into. */
+    readonly target: string;
+    /**
+     * Transport an elaborated model along the morphism into `targetTheory`.
+     *
+     * The supplied `model` is shared: it comes from the per-store elaboration
+     * cache and other consumers (validation, analyses) may hold it too, so the
+     * migration must only *read* it — never mutate or free it.
+     */
+    readonly migrate: (model: DblModel, targetTheory: DblTheory) => Promise<DblModel>;
+};
+
+/**
+ * A shape describes the object and morphism types a notebook is built from.
+ *
+ * - With a `theory` (and usually a `getCoreTheory`) it is a full, *creatable*
+ *   shape: a notebook can be created, loaded, validated and migrated from it.
+ * - Without a `theory` it is a *sub-shape*: a structural contract a component
+ *   declares over a subset of cell types. It can type props, filter cells and
+ *   edit an existing notebook, but cannot originate a document.
+ *
+ * Object and morphism types are tagged wrappers built with {@link
+ * defineObject}/{@link defineMorphism}; declare each as a `const` so its
+ * structure (and a morphism's endpoint object type) survives type inference.
+ */
+export type Shape = {
+    /** Identifier of the document theory; omit for a sub-shape contract. */
+    readonly theory?: string;
+    /**
+     * Whether models of this shape support instances, i.e. diagrams drawn in
+     * them. Set `true` to opt into the `.Diagram` shape that {@link defineShape}
+     * derives (and that {@link Binder.createNotebook}/{@link
+     * Binder.createInstance} draw over a model). Requires a `theory` (a diagram
+     * carries its model's theory) and, to be validatable, a `getCoreTheory`.
+     *
+     * Left unset by default: not every theory admits diagrams. In the core,
+     * diagrams are only implemented for *discrete* double theories, so a shape
+     * over a modal theory (e.g. the symmetric-monoidal theory behind Petri nets)
+     * must omit this flag and gets no `.Diagram`.
+     */
+    readonly supportsInstances?: boolean;
+    /**
+     * Cached async loader for the double theory in the core that notebooks of
+     * this shape elaborate into. Optional: a sub-shape has none.
+     */
+    readonly getCoreTheory?: CoreTheoryLoader;
+    /**
+     * Object defs, as a list. Declare each as a standalone `const`
+     * (e.g. `const Place = defineObject({ tag: "Basic", content: "Object" })`)
+     * and pass it both here and to {@link Notebook.add}. Omit for a shape that
+     * declares no objects.
+     */
+    readonly objects?: readonly ObjectDef[];
+    /**
+     * Morphism defs, as a list; see {@link Shape.objects}. Omit for a shape
+     * that declares no morphisms.
+     */
+    readonly morphisms?: readonly MorphismDef[];
+    /** Theories this shape includes into (trivial migration target). */
+    readonly inclusions?: readonly string[];
+    /** Non-trivial migrations to other shapes, keyed by target theory. */
+    readonly migrations?: readonly ModelMigration[];
+    /**
+     * Informal cell types to include in shape-filtered {@link Notebook.cellsOf}
+     * alongside the shape's declared object/morphism cells. Defaults to none: a
+     * shape describes formal cell types, so rich text is opted into explicitly
+     * with `informal: [RichText]` by editors that render prose interleaved with
+     * typed cells.
+     */
+    readonly informal?: readonly RichTextType[];
+    /**
+     * Opt-in to *path equation* cells: equations between paths of the
+     * notebook's morphisms, declared with `supportsEquations: true`.
+     * Defaults to `false`: not every theory supports equations (in the core they
+     * are elaborated only for theories with discrete models, mirroring the
+     * frontend's per-theory `equationCellMeta` gate), so a shape opts in
+     * explicitly and {@link Notebook.add} of a {@link PathEquation} on a shape
+     * that has not is a compile error (and a runtime {@link ValidationError}).
+     */
+    readonly supportsEquations?: boolean;
+    /**
+     * Analyses that can be added to an analysis notebook for this shape.
+     * When present, `defineShape` attaches an `.Analysis` property — itself a
+     * {@link Shape} declaring these as its `analyses` — that can be passed to
+     * {@link Binder.createNotebook} to create an analysis notebook.
+     */
+    readonly modelAnalyses?: readonly AnalysisDef[];
+    /**
+     * The analyses an *analysis* shape declares. A notebook over a shape with
+     * `analyses` is an analysis notebook: its {@link Notebook.add} accepts these
+     * analysis defs, and its cells store analysis params rather than model
+     * judgments. Absent for an ordinary model shape; populated by the `.Analysis`
+     * shape that {@link defineShape} derives from `modelAnalyses`.
+     */
+    readonly analyses?: readonly AnalysisDef[];
+    /**
+     * Whether an analysis shape analyzes a model or a diagram. Present exactly
+     * when {@link Shape.analyses} is, and surfaced as {@link Notebook.analysisType}.
+     */
+    readonly analysisType?: AnalysisType;
+    /**
+     * The individual types a *diagram* shape declares. A notebook over a shape
+     * with `individuals` is a diagram notebook: its {@link Notebook.add} accepts
+     * these individual defs (and the {@link Shape.aspects} below), and its cells
+     * store diagram judgments — objects/morphisms drawn `over` a model's — rather
+     * than plain model judgments. Absent for an ordinary model shape; populated
+     * by the `.Diagram` shape that {@link defineShape} derives for a shape that
+     * declares `supportsInstances: true`.
+     */
+    readonly individuals?: readonly IndividualDef[];
+    /** The aspect types a *diagram* shape declares; see {@link Shape.individuals}. */
+    readonly aspects?: readonly AspectDef[];
+    /**
+     * The core theory the *model* a diagram is drawn in elaborates against,
+     * copied from the model logic's `getCoreTheory` by {@link defineShape}. A
+     * diagram is elaborated against this theory and validated in that model, so
+     * {@link Notebook.validate} on a diagram notebook needs it. Kept under a
+     * distinct key from {@link Shape.getCoreTheory} (which a diagram shape leaves
+     * absent) for that purpose.
+     */
+    readonly diagramInCoreTheory?: CoreTheoryLoader;
+};
+
+/** Any shape, used as the default and as a generic constraint. */
+export type AnyShape = Shape;
+
+/**
+ * A shape's object list, defaulting an omitted `objects` to the empty tuple so
+ * `[number]` indexing stays well-defined for shapes that declare none. Presence
+ * is tested by key (`"objects" extends keyof TShape`) rather than by the
+ * property's value type: a concrete shape that omits `objects` has no such key,
+ * whereas the base {@link Shape} (whose key is merely optional) still resolves
+ * to the widest `readonly ObType[]`.
+ */
+type ShapeObjectList<TShape extends AnyShape> = "objects" extends keyof TShape
+    ? NonNullable<TShape["objects"]>
+    : readonly [];
+/** A shape's morphism list; see {@link ShapeObjectList}. */
+type ShapeMorphismList<TShape extends AnyShape> = "morphisms" extends keyof TShape
+    ? NonNullable<TShape["morphisms"]>
+    : readonly [];
+
+/**
+ * Whether a shape *definitely* declares a `getCoreTheory`. Tested by requiredness
+ * rather than mere key presence: a concrete shape built with {@link
+ * defineShape} that provides `getCoreTheory` has it as a required property (so
+ * `true`), whereas one that omits it — and the base {@link Shape}, whose
+ * `getCoreTheory` key is only optional — resolves to `false`. This gates {@link
+ * Notebook.validate} and {@link Notebook.migrateTo}, both of which elaborate
+ * into the shape's core theory, so calling them on a shape that may lack one is
+ * a compile error rather than a runtime throw. The fully-generic `Notebook`
+ * (over the base {@link Shape}) therefore exposes neither, which is what keeps a
+ * concrete getCoreTheory-less notebook assignable to it.
+ */
+export type HasCoreTheory<TShape extends AnyShape> =
+    {} extends Pick<TShape, "getCoreTheory" & keyof TShape> ? false : true;
+
+/** The list element types, defaulted to the widest def for indexing safety. */
+type ObjectDefOf<TShape extends AnyShape> = ShapeObjectList<TShape>[number] & ObjectDef;
+type MorphismDefOf<TShape extends AnyShape> = ShapeMorphismList<TShape>[number] & MorphismDef;
+
+/** A shape's analysis list; see {@link ShapeObjectList}. */
+type ShapeAnalysisList<TShape extends AnyShape> = "analyses" extends keyof TShape
+    ? NonNullable<TShape["analyses"]>
+    : readonly [];
+
+/** The analysis def element type, defaulted to the widest def for indexing. */
+export type AnalysisDefOf<TShape extends AnyShape> = ShapeAnalysisList<TShape>[number] &
+    AnalysisDef;
+
+/**
+ * Whether a shape *definitely* declares `analyses`, i.e. is an analysis shape.
+ * Tested by requiredness like {@link HasCoreTheory}: a shape built with the
+ * `.Analysis` derivation has `analyses` as a required property (so `true`),
+ * whereas an ordinary model shape — and the base {@link Shape}, whose `analyses`
+ * key is only optional — resolves to `false`. Gates the analysis-only surface
+ * ({@link Notebook.analysisType} and the analysis {@link Notebook.add} overload).
+ */
+export type HasAnalyses<TShape extends AnyShape> =
+    {} extends Pick<TShape, "analyses" & keyof TShape> ? false : true;
+
+/**
+ * Whether a shape *definitely* declares `individuals`, i.e. is a diagram shape.
+ * Tested by requiredness like {@link HasAnalyses}: a shape built with the
+ * `.Diagram` derivation has `individuals` as a required property (so `true`),
+ * whereas an ordinary model shape — and the base {@link Shape}, whose
+ * `individuals` key is only optional — resolves to `false`.
+ */
+export type HasDiagram<TShape extends AnyShape> =
+    {} extends Pick<TShape, "individuals" & keyof TShape> ? false : true;
+
+/**
+ * Whether a shape opts into rich-text cells in {@link Notebook.cellsOf}. A
+ * concrete shape built with `informal: [RichText]` resolves to `true`; one that
+ * omits `informal`, and the base {@link Shape} (whose key is merely optional),
+ * resolve to `false`. Gates the {@link RichTextCell} member of {@link
+ * ShapeCellsOf}.
+ */
+export type HasRichText<TShape extends AnyShape> = "informal" extends keyof TShape
+    ? {} extends Pick<TShape, "informal" & keyof TShape>
+        ? false
+        : RichTextType extends NonNullable<TShape["informal"]>[number]
+          ? true
+          : false
+    : false;
+
+/**
+ * Whether a shape opts into path equation cells (see {@link
+ * Shape.supportsEquations}). A concrete shape built with `supportsEquations:
+ * true` resolves to `true`; one that omits the key or sets it to `false`, and
+ * the base {@link Shape} (whose key is merely optional), resolve to `false`.
+ * Gates the path-equation {@link Notebook.add} overload and the {@link
+ * PathEquationCell} member of {@link ShapeCellsOf}.
+ */
+export type HasPathEquations<TShape extends AnyShape> = "supportsEquations" extends keyof TShape
+    ? {} extends Pick<TShape, "supportsEquations" & keyof TShape>
+        ? false
+        : NonNullable<TShape["supportsEquations"]> extends true
+          ? true
+          : false
+    : false;
+
+/** A shape that can originate a document: it carries a document theory. */
+export type CreatableShape = Shape & { readonly theory: string };
+
+/**
+ * Whether the object def `T` is listed by *every* member of the (possibly
+ * union) shape `S`. For each member, `T` either appears in its object list
+ * (contributing `never`) or does not (contributing the member itself); the
+ * union of those collapses to `never` only when every member lists `T`.
+ */
+type ObjectInEveryMember<T extends ObjectDef, S extends AnyShape> = [
+    S extends AnyShape ? (T extends ShapeObjectList<S>[number] ? never : S) : never,
+] extends [never]
+    ? true
+    : false;
+/** Morphism-side counterpart of {@link ObjectInEveryMember}. */
+type MorphismInEveryMember<T extends MorphismDef, S extends AnyShape> = [
+    S extends AnyShape ? (T extends ShapeMorphismList<S>[number] ? never : S) : never,
+] extends [never]
+    ? true
+    : false;
+
+/**
+ * The union of a shape's object defs. Deliberately *not* distributive over a
+ * union of shapes: it yields only the object defs every member declares, so
+ * {@link Notebook.add} over a union shape accepts an object only when it is safe
+ * for whichever member the notebook turns out to be. Narrow first with {@link
+ * Notebook.supports}.
+ */
+export type ShapeObjects<TShape extends AnyShape> =
+    DeclaredObjects<TShape> extends infer O
+        ? O extends ObjectDef
+            ? ObjectInEveryMember<O, TShape> extends true
+                ? O
+                : never
+            : never
+        : never;
+/** The union of a shape's morphism defs; see {@link ShapeObjects} for the union-shape semantics. */
+export type ShapeMorphisms<TShape extends AnyShape> =
+    DeclaredMorphisms<TShape> extends infer M
+        ? M extends MorphismDef
+            ? MorphismInEveryMember<M, TShape> extends true
+                ? M
+                : never
+            : never
+        : never;
+
+/**
+ * Every object and morphism def a shape declares. Unlike {@link ShapeObjects}
+ * and {@link ShapeMorphisms}, this *distributes* over a union of shapes, so a
+ * union shape's declared defs are the union of all members' declared defs.
+ * Carried by the phantom {@link Notebook} member that drives shape assignability
+ * (see there): a notebook is assignable to another only when its declared defs
+ * relate to the target's, so a notebook whose morphisms are foreign to a union
+ * shape (e.g. a `SimpleOlog` against a union of list shapes) is rejected, while
+ * one declaring a subset (e.g. a `PetriNet`) is accepted.
+ */
+export type DeclaredTypes<TShape extends AnyShape> = TShape extends AnyShape
+    ? ObjectDefOf<TShape> | MorphismDefOf<TShape>
+    : never;
+
+/**
+ * The morphism defs a shape declares, distributing over a union of shapes like
+ * {@link DeclaredTypes} (and unlike {@link ShapeMorphisms}, which collapses to
+ * the morphisms shared by every member): the union of every member's morphism
+ * defs, or `never` for a shape that declares none.
+ */
+export type DeclaredMorphisms<TShape extends AnyShape> = TShape extends AnyShape
+    ? MorphismDefOf<TShape>
+    : never;
+
+/** Whether a shape declares at least one morphism type. */
+export type DeclaresMorphism<TShape extends AnyShape> = [DeclaredMorphisms<TShape>] extends [never]
+    ? false
+    : true;
+
+/** The object defs a shape declares, distributing over a union of shapes; the
+ * object-side dual of {@link DeclaredMorphisms}. */
+export type DeclaredObjects<TShape extends AnyShape> = TShape extends AnyShape
+    ? ObjectDefOf<TShape>
+    : never;
+
+/** Whether a shape declares at least one object type. */
+export type DeclaresObject<TShape extends AnyShape> = [DeclaredObjects<TShape>] extends [never]
+    ? false
+    : true;
+
+/**
+ * A function type whose parameter is compared *bivariantly* even under
+ * `strictFunctionTypes`: extracting a method's type from an object literal
+ * keeps the method-position bivariance at the extracted signature. Carried by
+ * the phantom shape-bound members of {@link Notebook}, where bivariance encodes
+ * "subset or superset" of declared cell types.
+ */
+type BivariantBound<T> = { bound(declared: T): void }["bound"];
+
+/**
+ * The phantom *object*-axis bound of a {@link Notebook}'s shape. For a single
+ * shape it is a bivariant function over the shape's object defs, so one
+ * notebook's bound is assignable to another's exactly when its declared object
+ * types are a subset or a superset of the target's. Distributes over a union of
+ * shapes into a *union of bounds* — one per member — so a notebook is assignable
+ * to a union-shape notebook when it matches *some* member, rather than being
+ * measured against the pooled object types of all members. That keeps
+ * assignability consistent with the member types: a notebook assignable to
+ * `Notebook<B>` is also assignable to `Notebook<A | B>`.
+ */
+export type ObjectShapeBound<TShape extends AnyShape> = TShape extends AnyShape
+    ? BivariantBound<ObjectDefOf<TShape>>
+    : never;
+
+/** The morphism-axis counterpart of {@link ObjectShapeBound}. */
+export type MorphismShapeBound<TShape extends AnyShape> = TShape extends AnyShape
+    ? BivariantBound<MorphismDefOf<TShape>>
+    : never;
+
+/**
+ * The {@link Notebook.add} capability gained once a notebook is known to
+ * support the cell type `T`. {@link Notebook.supports} narrows a notebook to its
+ * own type intersected with this, which adds an `add` overload accepting exactly
+ * `T` — so the guarded `add` type-checks even when `T` is not declared by every
+ * member of a union shape. An intersection is always a subtype of the original
+ * notebook, so this narrowing is immune to the method-bivariance that makes
+ * union- and member-shape notebooks otherwise mutually assignable.
+ *
+ * An object def and a morphism def carry distinct `tag`s, so `T extends
+ * MorphismDef` cleanly selects the morphism capability; everything else is an
+ * object def.
+ */
+export type AddCapability<T extends ObjectDef | MorphismDef> = T extends MorphismDef
+    ? {
+          add(type: T, args: { label: string; from: DomOf<T>; to: CodOf<T> }): MorphismCell<T>;
+      }
+    : T extends ObjectDef
+      ? { add(type: T, args: { label: string }): ObjectCell<T> }
+      : object;
+
+/**
+ * Turn a union into the intersection of its members. Used to combine the
+ * per-type {@link AddCapability}s of every type a shape declares into a single
+ * capability, so {@link Notebook.supportsShape} can grant them all at once.
+ */
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (
+    k: infer I,
+) => void
+    ? I
+    : never;
+
+/**
+ * The combined {@link Notebook.add} capability gained once a notebook is known
+ * to support *every* object and morphism type a sub-shape declares: the
+ * intersection of {@link AddCapability} over the shape's {@link DeclaredTypes}.
+ * Narrowing a notebook to its own type intersected with this lets a guarded
+ * block add any of the sub-shape's types without narrowing each individually.
+ */
+export type ShapeAddCapability<S extends AnyShape> = UnionToIntersection<
+    DeclaredTypes<S> extends infer T
+        ? T extends ObjectDef | MorphismDef
+            ? AddCapability<T>
+            : never
+        : never
+>;
+
+/**
+ * The result of elaborating and validating a model, as a {@link Result}: an
+ * `Ok` carries the elaborated {@link DblModel} as `content`; an `Err` carries
+ * an array of issues. Both a model that fails one or more validation checks
+ * and one that fails to even elaborate map to an `Err`, their errors surfaced
+ * as [Standard Schema](https://standardschema.dev) {@link Issue}s.
+ */
+export type ModelValidationResult = Result<DblModel>;
+
+/**
+ * An analysis that can be added to an analysis notebook. An analysis has a
+ * stable `id`, a `getInitialParams` factory for default parameters, and a
+ * `run` function that computes the analysis result from the analyzed model's
+ * elaborated {@link DblModel}. Define one with {@link defineAnalysis}.
+ */
+export type AnalysisDef<Params extends object = object, Output = unknown> = {
+    readonly id: string;
+    getInitialParams(): Params;
+    run(model: DblModel, params: Params): Promise<Output>;
+};
+
+/** Define an analysis from a compact spec. */
+export function defineAnalysis<Params extends object, Output>(spec: {
+    id: string;
+    getInitialParams(): Params;
+    run(model: DblModel, params: Params): Promise<Output>;
+}): AnalysisDef<Params, Output> {
+    return spec;
+}
+
+/** Extract the `Params` type from an `AnalysisDef`. */
+export type ParamsOf<Def extends AnalysisDef> =
+    Def extends AnalysisDef<infer P, unknown> ? P : Record<string, unknown>;
+
+/** Extract the `Output` type from an `AnalysisDef`. */
+export type OutputOf<Def extends AnalysisDef> =
+    Def extends AnalysisDef<object, infer O> ? O : unknown;
+
+/**
+ * A handle for an analysis cell in an analysis notebook (a {@link Notebook}
+ * over an {@link AnalysisShape}). The persisted `params` are seeded by
+ * `def.getInitialParams()` and updated with {@link AnalysisCell.update}; `run()`
+ * resolves the analyzed model's elaborated {@link DblModel} from the document's
+ * `analysis-of` link through the store (via {@link DocumentStore.getHandle},
+ * elaborating against the shape's `analysisOfCoreTheory`) and calls the def's
+ * `run` with that model and the current params.
+ */
+export type AnalysisCell<Def extends AnalysisDef = AnalysisDef> = Reorder & {
+    readonly kind: typeof CellKind.Analysis;
+    readonly id: string;
+    readonly type: Def;
+    /** The persisted parameters for this analysis cell. */
+    readonly params: ParamsOf<Def>;
+    /** Merge `partial` into the cell's params. */
+    update(partial: Partial<ParamsOf<Def>>): void;
+    /**
+     * Run the analysis, returning a {@link Result}: an `Ok` carries the
+     * analysis output as `content`; an `Err` carries an array of issues.
+     * Failures include an unresolvable or invalid analyzed model and any error
+     * thrown by the analysis def's `run`.
+     */
+    run(): Promise<Result<OutputOf<Def>>>;
+};
+
+/**
+ * The cell handle(s) for `T`, which may be either a *type definition* or a whole
+ * *shape*:
+ *
+ * - Given a **def**, it is the single precise handle for that def's kind: an
+ *   {@link ObjectDef} maps to an {@link ObjectCell}, a {@link MorphismDef} to a
+ *   {@link MorphismCell}, an {@link AnalysisDef} to an {@link AnalysisCell}, and
+ *   the diagram-level {@link IndividualDef}/{@link AspectDef} to an {@link
+ *   IndividualCell}/{@link AspectCell}. So `NotebookCell<typeof Place>` is the
+ *   precise object-cell handle for a Petri-net `Place`, replacing the longer
+ *   `ObjectCell<typeof Place>`.
+ * - Given a **shape**, it is the union of cell handles that iterating a notebook
+ *   of that shape with {@link Notebook.cells} yields: each of the shape's object
+ *   and morphism types contributes its own precise handle plus {@link
+ *   RichTextCell}/{@link InstantiationCell} (e.g. a Petri-net
+ *   `NotebookCell<typeof PetriNet>` is `RichTextCell | NotebookCell<typeof
+ *   Place> | NotebookCell<typeof Transition>`), so a single-type endpoint like
+ *   `cell.from.label` type-checks after discriminating on `cell.kind`. The
+ *   default {@link AnyShape} instantiation (the bare `NotebookCell`) widens the
+ *   object and morphism members to `ObjectCell`/`MorphismCell`; recover precise
+ *   handles with {@link Notebook.cellsOf}.
+ *
+ * The def kinds are matched *first*, before the shape fallback: because {@link
+ * Shape}'s keys are all optional, every def structurally satisfies `AnyShape`
+ * too, so peeling the defs off first is what keeps a def (e.g. an {@link
+ * AnalysisDef}) from being mis-dispatched into the shape union. Any `T` that is
+ * neither a recognized def nor a shape yields `never`.
+ */
+export type NotebookCell<T = AnyShape> = T extends IndividualDef
+    ? IndividualCell<T>
+    : T extends AspectDef
+      ? AspectCell<T>
+      : T extends ObjectDef
+        ? ObjectCell<T>
+        : T extends MorphismDef
+          ? MorphismCell<T>
+          : T extends AnalysisDef
+            ? AnalysisCell<T>
+            : T extends AnyShape
+              ?
+                    | RichTextCell
+                    | InstantiationCell
+                    | PathEquationCell
+                    | ObjectCellsOf<T>
+                    | MorphismCellsOf<T>
+                    | AnalysisCellsOf<T>
+              : never;
+
+/**
+ * Define a shape from a compact declaration of object and morphism defs.
+ * Object and morphism defs are built with {@link defineObject}/{@link
+ * defineMorphism} (declare each as a `const`). A `Hom` morphism's endpoint
+ * object type and arity are read from its `MorType` structure; any other
+ * morphism declares its endpoints when built with {@link defineMorphism}.
+ * `theory`/`getCoreTheory` are optional: include them for a creatable shape, omit
+ * them for a sub-shape contract. Set `supportsInstances: true` (requires a
+ * `theory`) to also derive a `.Diagram` shape for drawing diagrams in models of
+ * this shape.
+ */
+export function defineShape<const TSpec extends Shape>(
+    spec: TSpec,
+): TSpec &
+    ("modelAnalyses" extends keyof TSpec
+        ? { readonly Analysis: AnalysisShape<NonNullable<TSpec["modelAnalyses"]>> }
+        : object) &
+    (TSpec extends { supportsInstances: true }
+        ? { readonly Diagram: DiagramShapeOf<TSpec> }
+        : object) {
+    const getCoreTheory = spec.getCoreTheory ? lazyCoreTheory(spec.getCoreTheory) : undefined;
+    const derived: Shape & { Analysis?: AnalysisShape; Diagram?: DiagramShape } = {
+        ...spec,
+        ...(getCoreTheory ? { getCoreTheory } : {}),
+    };
+    if (spec.modelAnalyses) {
+        derived.Analysis = {
+            analyses: spec.modelAnalyses as NonNullable<TSpec["modelAnalyses"]>,
+            analysisType: "model",
+            ...(getCoreTheory ? { analysisOfCoreTheory: getCoreTheory } : {}),
+        } satisfies AnalysisShape<NonNullable<TSpec["modelAnalyses"]>>;
+    }
+    if (spec.supportsInstances === true) {
+        if (spec.theory === undefined) {
+            throw new Error(
+                "A shape with `supportsInstances: true` must declare a `theory`: a diagram " +
+                    "carries its model's theory.",
+            );
+        }
+        const individuals = (spec.objects ?? []).map((object) => defineIndividual(object));
+        const aspects = (spec.morphisms ?? []).map((morphism) => defineAspect(morphism));
+        // `Individual`/`Aspect` are the diagram-level cell types: a single
+        // `IndividualDef`/`AspectDef` accepting any of the model's object/morphism
+        // types. (A model object cell — not a morphism — for `over`.)
+        const Individual = defineIndividual(
+            spec.objects?.[0] ?? defineObject({ tag: "Basic", content: "Object" }),
+        );
+        const Aspect =
+            spec.morphisms?.[0] !== undefined ? defineAspect(spec.morphisms[0]) : undefined;
+        derived.Diagram = {
+            theory: spec.theory,
+            individuals,
+            aspects,
+            Individual,
+            ...(Aspect ? { Aspect } : {}),
+            ...(getCoreTheory ? { diagramInCoreTheory: getCoreTheory } : {}),
+        };
+    }
+    return derived as ReturnType<typeof defineShape<TSpec>>;
+}
+
+/**
+ * The diagram shape derived by {@link defineShape} from a model shape that
+ * declares `supportsInstances: true`, exposed as `shape.Diagram`. It declares an {@link IndividualDef} per model
+ * object type and an {@link AspectDef} per model morphism type, and surfaces the
+ * single diagram cell types {@link DiagramShape.Individual} / {@link
+ * DiagramShape.Aspect} to pass to {@link Notebook.add}.
+ */
+export type DiagramShapeOf<TSpec extends Shape> = DiagramShape & {
+    readonly theory: NonNullable<TSpec["theory"]>;
+    readonly Individual: IndividualDef<DeclaredObjects<TSpec> & ObjectDef>;
+    readonly Aspect: AspectDef<DeclaredMorphisms<TSpec> & MorphismDef>;
+};
+
+/**
+ * A {@link Shape} for diagram notebooks: a shape that declares `individuals` and
+ * `aspects` — the diagram-level types drawn over a model's objects and
+ * morphisms. Obtained via `shape.Diagram` on a model shape that declares
+ * `supportsInstances: true`. Pass it to
+ * {@link Binder.createNotebook} together with `{ name, in: validatableNotebook }`
+ * to create a diagram notebook. It carries the model's `theory` (surfaced as
+ * {@link Notebook.theory}) but no `getCoreTheory` of its own; the model's core
+ * theory is kept under {@link Shape.diagramInCoreTheory} for validation.
+ */
+export type DiagramShape = Shape & {
+    readonly individuals: readonly IndividualDef[];
+    readonly aspects: readonly AspectDef[];
+    /** The diagram-level individual cell type to pass to {@link Notebook.add}. */
+    readonly Individual: IndividualDef;
+    /** The diagram-level aspect cell type to pass to {@link Notebook.add}. */
+    readonly Aspect?: AspectDef;
+};
+
+/** Whether a shape value declares individuals, i.e. is a diagram shape. */
+export const isDiagramShape = (shape: AnyShape): shape is DiagramShape =>
+    Array.isArray((shape as { individuals?: unknown }).individuals);
+
+/** An elaborated diagram together with its validation status against its model. */
+export type DiagramValidationResult =
+    /** Successfully elaborated and validated in its model. */
+    | { tag: "Valid"; diagram: DblModelDiagram }
+    /** Elaborated, but failing one or more validation checks in its model. */
+    | { tag: "Invalid"; diagram: DblModelDiagram; errors: InvalidDiscreteDblModelDiagram[] }
+    /** Failed to even elaborate (e.g. its model is ill-formed). */
+    | { tag: "Illformed"; diagram: null; error: string };
+
+/**
+ * A {@link Shape} for analysis notebooks: an ordinary shape that declares
+ * `analyses` (and an `analysisType`). Obtained via `shape.Analysis` when the
+ * shape declares `modelAnalyses`. Pass it to {@link Binder.createNotebook}
+ * together with `{ name, of: validatableNotebook }` to create an analysis
+ * notebook, just like any other shape.
+ */
+export type AnalysisShape<Analyses extends readonly AnalysisDef[] = readonly AnalysisDef[]> =
+    Shape & {
+        readonly analyses: Analyses;
+        readonly analysisType: AnalysisType;
+        /**
+         * The core theory the *analyzed* model elaborates against, copied from
+         * the analyzed logic's `getCoreTheory` by {@link defineShape}. The analysis
+         * shape itself carries no `getCoreTheory` (so it exposes no `validate`),
+         * but `run()` needs the analyzed model's core theory to resolve it; this
+         * is kept under a distinct key for that purpose.
+         */
+        readonly analysisOfCoreTheory?: CoreTheoryLoader;
+    };
+
+/** Whether a shape value declares analyses, i.e. is an analysis shape. */
+export const isAnalysisShape = (shape: AnyShape): shape is AnalysisShape =>
+    Array.isArray((shape as { analyses?: unknown }).analyses);
+
+/** Structural equality of stored type expressions (plain JSON-like values). */
+export const sameTypeValue = (a: unknown, b: unknown): boolean => {
+    if (a === b) {
+        return true;
+    }
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+        return false;
+    }
+    const aRecord = a as Record<string, unknown>;
+    const bRecord = b as Record<string, unknown>;
+    const keys = Object.keys(aRecord);
+    if (keys.length !== Object.keys(bRecord).length) {
+        return false;
+    }
+    return keys.every((key) => sameTypeValue(aRecord[key], bRecord[key]));
+};
+
+const LIST_MODALITIES: ReadonlySet<Modality> = new Set<Modality>([
+    "List",
+    "SymmetricList",
+    "CocartesianList",
+    "CartesianList",
+    "AdditiveList",
+]);
+
+/** Whether a stored endpoint is a list, recognized by its `App(op, List(...))`
+shape: the `apply` operation (e.g. `tensor`) wrapping a `List` is what makes the
+endpoint list-like. Returns its modality, or `null` when not a list. Used to
+recover a list morphism's modality when reading a cell back from the document. */
+export const endpointListModality = (ob: Ob | null): Modality | null => {
+    if (ob?.tag === "App" && ob.content.ob.tag === "List") {
+        const modality = ob.content.ob.content.modality;
+        return LIST_MODALITIES.has(modality) ? modality : null;
+    }
+    return null;
+};
+
+/** The `apply` operation wrapping a stored list endpoint (the counterpart of
+{@link endpointListModality}), or `null` when the endpoint is not a list. Used
+to recover a list morphism's `domain`/`codomain` `apply` op on read. */
+export const endpointApplyOp = (ob: Ob | null): ObOp | null =>
+    ob?.tag === "App" && ob.content.ob.tag === "List" ? ob.content.op : null;
+
+/** Encode an object-cell endpoint reference as a model object. */
+export const encodeObjectRef = (cell: { readonly id: string }): Ob => ({
+    tag: "Basic",
+    content: cell.id,
+});
+
+const copyObOp = (op: ObOp): ObOp => ({ tag: op.tag, content: op.content });
+
+/**
+ * Encode a morphism endpoint into the document's object notation. The shape is
+ * chosen from the morphism's declared `modality` and endpoint `apply` op: a list
+ * endpoint (e.g. a Petri-net transition's, `modality: "SymmetricList"` with an
+ * `apply: tensor`) wraps an array of cells as `App(apply, List(modality, …))` —
+ * the operation turning the list into the single object the endpoint connects;
+ * an endpoint with no modality encodes a single object cell as a basic object.
+ * This is exactly what the frontend persists, so the morphism type stored in the
+ * document stays the plain `Hom(Object)` the core theory exposes as a generator.
+ */
+export const encodeEndpoint = (
+    apply: ObOp | null,
+    modality: Modality | null,
+    value: unknown,
+): Ob | null => {
+    if (modality !== null) {
+        const cells = Array.isArray(value) ? value : value == null ? [] : [value];
+        const list: Ob = {
+            tag: "List",
+            content: {
+                modality,
+                objects: cells.map((cell) => encodeObjectRef(cell as { readonly id: string })),
+            },
+        };
+        return apply ? { tag: "App", content: { op: copyObOp(apply), ob: list } } : list;
+    }
+    if (value == null) {
+        return null;
+    }
+    return encodeObjectRef(value as { readonly id: string });
+};
diff --git a/packages/document-methods/src/future/diagram.ts b/packages/document-methods/src/future/diagram.ts
new file mode 100644
index 000000000..f828eab13
--- /dev/null
+++ b/packages/document-methods/src/future/diagram.ts
@@ -0,0 +1,57 @@
+import { v7 } from "uuid";
+
+import type {
+    DiagramJudgment,
+    Document,
+    Link,
+    Mor,
+    MorType,
+    Ob,
+    ObType,
+} from "catcolab-document-types";
+import { currentVersion } from "catcolab-document-types";
+import { newNotebook } from "../notebook";
+
+/** A document defining a diagram in a model. */
+export type DiagramDocument = Document & { type: "diagram" };
+
+/** Create an empty diagram document referencing the model it is drawn in. */
+export const newDiagramDocument = (args: { diagramIn: Link; name?: string }): DiagramDocument => ({
+    type: "diagram",
+    name: args.name ?? "",
+    diagramIn: args.diagramIn,
+    notebook: newNotebook<DiagramJudgment>(),
+    version: currentVersion(),
+});
+
+/** Create a new diagram object declaration with the given object type. */
+export const newDiagramObjectDecl = (
+    obType: ObType,
+    over?: Ob | null,
+): DiagramJudgment & { tag: "object" } => ({
+    tag: "object",
+    id: v7(),
+    name: "",
+    obType,
+    over: over ?? null,
+});
+
+/** Create a new diagram morphism declaration with the given morphism type. */
+export const newDiagramMorphismDecl = (
+    morType: MorType,
+    over?: Mor | null,
+): DiagramJudgment & { tag: "morphism" } => ({
+    tag: "morphism",
+    id: v7(),
+    name: "",
+    morType,
+    over: over ?? null,
+    dom: null,
+    cod: null,
+});
+
+/** Duplicate a diagram judgment, creating a fresh UUID. */
+export const duplicateDiagramJudgment = (jgmt: DiagramJudgment): DiagramJudgment => ({
+    ...structuredClone(jgmt),
+    id: v7(),
+});
diff --git a/packages/document-methods/src/future/index.ts b/packages/document-methods/src/future/index.ts
new file mode 100644
index 000000000..9604bf68f
--- /dev/null
+++ b/packages/document-methods/src/future/index.ts
@@ -0,0 +1,78 @@
+export { type ModelDocument, newModelDocument } from "../model";
+export { type AnalysisDocument, newAnalysisDocument } from "./analysis";
+export { type DiagramDocument, newDiagramDocument } from "./diagram";
+export {
+    type InstanceDocument,
+    type InstanceEntry,
+    type InstanceProperty,
+    type InstanceValue,
+    newInstanceDocument,
+} from "./instance";
+
+export {
+    plainStore,
+    type DocumentRef,
+    type DocumentStore,
+    type RichTextRef,
+    resolveModelInStore,
+} from "./store";
+export {
+    binder,
+    createBinder,
+    type Binder,
+    type Instance,
+    type Row,
+    type RowValue,
+    type Notebook,
+} from "./notebook";
+export { type Issue, type Result } from "./validation";
+export {
+    CellKind,
+    RichText,
+    Instantiation,
+    PathEquation,
+    defineObject,
+    defineMorphism,
+    defineAnalysis,
+    defineIndividual,
+    defineAspect,
+    defineShape,
+    resolveCoreTheory,
+    type CoreTheoryLoader,
+    type RichTextType,
+    type InstantiationType,
+    type PathEquationType,
+    type PathEquationArgs,
+    type PathEquationCell,
+    type ObjectDef,
+    type ObjectCell,
+    type EndpointOf,
+    type Endpoints,
+    type ModalityBrand,
+    type MorEndpointMeta,
+    type MorphismDef,
+    type DomOf,
+    type CodOf,
+    type MorphismCell,
+    type NotebookCell,
+    type RichTextCell,
+    type InstantiationSpecialization,
+    type ValidatableNotebook,
+    type InstantiationArgs,
+    type InstantiationCell,
+    type ShapeCellsOf,
+    type ModelMigration,
+    type Shape,
+    type ModelValidationResult,
+    type AnalysisDef,
+    type AnalysisCell,
+    type AnalysisShape,
+    type IndividualDef,
+    type AspectDef,
+    type IndividualCell,
+    type AspectCell,
+    type DiagramCell,
+    type DiagramShape,
+    type DiagramShapeOf,
+    type DiagramValidationResult,
+} from "./definitions";
diff --git a/packages/document-methods/src/future/instance.ts b/packages/document-methods/src/future/instance.ts
new file mode 100644
index 000000000..4136790ff
--- /dev/null
+++ b/packages/document-methods/src/future/instance.ts
@@ -0,0 +1,77 @@
+import type { Link } from "catcolab-document-types";
+import { currentVersion } from "catcolab-document-types";
+
+/**
+ * An *instance* document: a database of a schema, stored as a single flat array
+ * of `(subject, property, value)` triples rather than as a graph of diagram
+ * judgments.
+ *
+ * The storage is deliberately keyed by the schema's *generator UUIDs* rather
+ * than by any elaborated identity. A schema is a model whose object and morphism
+ * generators each carry a stable UUID; those UUIDs can never be confused with
+ * one another. A *row* is not a stored record: it is the set of triples sharing
+ * a `subject` (a bare row UUID). Each row's membership is itself a triple — an
+ * {@link InstanceProperty} of `EntityOf` whose value references the schema object
+ * (by UUID) the row is a record of — and each mapping/attribute is a triple whose
+ * property is a `MorphismRef` naming the schema morphism (by UUID).
+ *
+ * This is what lets the interface hide, but not lose, data when the schema
+ * changes. When a morphism is deleted from the schema, the interface simply
+ * stops displaying the triples whose `MorphismRef` no longer resolves to a live
+ * schema morphism — but those triples remain untouched in the document. Because
+ * generators are identified by UUID, an undo/redo/rollback of the schema that
+ * restores the morphism automatically re-associates the retained triples with
+ * it, with no diffing of elaborated models required.
+ */
+export type InstanceDocument = {
+    readonly type: "instance";
+    name: string;
+    /** A stable reference to the schema (a model document) this is an instance of. */
+    instanceOf: Link;
+    /** The theory of the schema, mirrored here so the instance can be read standalone. */
+    theory: string;
+    /** Every fact, as a flat `(subject, property, value)` triple. */
+    entries: InstanceEntry[];
+    version: string;
+};
+
+/** A single `(subject, property, value)` triple. */
+export type InstanceEntry = {
+    /** The row UUID the fact is about. */
+    subject: string;
+    /** What this triple asserts about its subject. */
+    property: InstanceProperty;
+    /** The value of the assertion. */
+    value: InstanceValue;
+};
+
+/** The predicate of an {@link InstanceEntry}. */
+export type InstanceProperty =
+    /** Membership: the subject is a row of the schema object named by the value. */
+    | { tag: "EntityOf" }
+    /** A mapping or attribute: the generator UUID of the schema morphism. */
+    | { tag: "MorphismRef"; content: string };
+
+/** The value of an {@link InstanceEntry}. */
+export type InstanceValue =
+    /**
+     * A reference by UUID: for an `EntityOf` property, the schema object the row
+     * is a record of; for a `MorphismRef` mapping, the target row.
+     */
+    | { tag: "ObjectRef"; content: string }
+    /** An attribute literal. */
+    | { tag: "Literal"; content: string | number | boolean };
+
+/** Create an empty instance document referencing the schema it is an instance of. */
+export const newInstanceDocument = (args: {
+    instanceOf: Link;
+    theory: string;
+    name?: string;
+}): InstanceDocument => ({
+    type: "instance",
+    name: args.name ?? "",
+    instanceOf: args.instanceOf,
+    theory: args.theory,
+    entries: [],
+    version: currentVersion(),
+});
diff --git a/packages/document-methods/src/future/model-cache.ts b/packages/document-methods/src/future/model-cache.ts
new file mode 100644
index 000000000..9545217fc
--- /dev/null
+++ b/packages/document-methods/src/future/model-cache.ts
@@ -0,0 +1,458 @@
+import type { Document, Link, ModelJudgment } from "catcolab-document-types";
+import {
+    type DblModel,
+    DblModelMap,
+    type DblTheory,
+    elaborateModel,
+    type ModelNotebook as WasmModelNotebook,
+} from "catlog-wasm";
+import type { ModelDocument } from "../model";
+import type { DocumentStore } from "./store";
+
+/**
+ * A persistent, per-store cache of elaborated models, shared by every consumer
+ * of {@link resolveModelInStore}: `Notebook.validate`, `migrateTo`, diagram and
+ * instance validation, and analysis `run()`. Without it each call re-elaborates
+ * the whole instantiation tree — an analysis notebook with N cells does N full
+ * wasm elaborations of the same unchanged model.
+ *
+ * ## Invalidation
+ *
+ * Invalidation is a per-document *version counter* with a *signature re-check
+ * on dirty*. The cache subscribes (once per document, via
+ * {@link DocumentStore.subscribe}) and bumps the document's `version` on every
+ * change notification — including remote changes where the store has them, e.g.
+ * an Automerge `DocHandle`'s change event for a collaborator's edit. The
+ * counter is purely local ("has *this client's* view possibly changed?"), so it
+ * needs no synchronization between peers.
+ *
+ * Change notifications are noisy — a rich-text keystroke bumps the version but
+ * cannot affect elaboration — so a bump does not evict anything by itself. On
+ * the next read, a dirty document's {@link formalCellsSignature} is recomputed
+ * once and compared: only a *changed* signature advances the document's content
+ * `stamp`. Cache entries record the stamps of every document in their
+ * resolution subtree, captured *before* the documents are read, so freshness is
+ * integer comparison and an edit racing a resolution in flight leaves the entry
+ * stale (wasted work) rather than ever serving a model elaborated from content
+ * the stamps don't describe.
+ *
+ * ## Lifecycle
+ *
+ * The cache lives as long as its store (see {@link modelCacheFor}); document
+ * subscriptions are never dropped, so its footprint is bounded by the set of
+ * documents ever resolved through it. Errors — unresolvable links, elaboration
+ * failures, cycles — are never cached.
+ */
+
+/**
+ * Thrown when a notebook instantiates itself, directly or through a chain of
+ * other notebooks, so its model can never be resolved. Carries the cycle as a
+ * `A → B → A` chain of the notebooks' names for a message the user can act on.
+ */
+export class CyclicInstantiationError extends Error {
+    constructor(readonly cycle: string) {
+        super(
+            `Instantiation cycle detected: ${cycle}. ` +
+                `A notebook cannot instantiate itself, directly or indirectly. ` +
+                `To fix, remove one of the instantiations in this chain.`,
+        );
+        this.name = "CyclicInstantiationError";
+    }
+}
+
+/**
+ * A stable string capturing the document's *formal* cells — every cell except
+ * rich text — in notebook order, including each cell's id and serialized
+ * content. {@link Notebook.onChangeFormalContent} and the model cache compare
+ * this signature across changes and react only when it differs, so adding,
+ * removing, reordering, or editing a formal cell is reported, while a change
+ * confined to rich text (or any other non-formal field) leaves it unchanged.
+ * Content is included so a formal cell edited in place (e.g. renaming an
+ * object) still re-reports.
+ */
+export const formalCellsSignature = (document: Document): string => {
+    const parts: Array<string> = [];
+    for (const cellId of document.notebook.cellOrder) {
+        const cell = document.notebook.cellContents[cellId];
+        if (cell?.tag === "formal") {
+            parts.push(`${cellId}:${JSON.stringify(cell.content)}`);
+        }
+    }
+    return parts.join("\u0000");
+};
+
+/** The instantiation links a model document references in its own notebook. */
+const instantiationLinks = (doc: ModelDocument): Link[] => {
+    const links: Link[] = [];
+    for (const cellId of doc.notebook.cellOrder) {
+        const cell = doc.notebook.cellContents[cellId];
+        if (cell?.tag !== "formal") {
+            continue;
+        }
+        const judgment = cell.content as ModelJudgment;
+        if (judgment.tag === "instantiation" && judgment.model) {
+            links.push(judgment.model);
+        }
+    }
+    return links;
+};
+
+/** The persistent invalidation state of one document, keyed by its link id. */
+type DocState<Handle> = {
+    readonly handle: Handle;
+    /** Bumped by the store's change notifications (local and remote). */
+    version: number;
+    /** The version at which {@link signature} was last computed. */
+    verifiedVersion: number;
+    /** Formal-content signature as of {@link verifiedVersion}. */
+    signature: string;
+    /** Content generation: advances only when the signature actually changes,
+     * so a rich-text edit bumps the version but never the stamp. */
+    stamp: number;
+};
+
+/** An elaborated model together with the content stamps of every document in
+ * its resolution subtree (itself included), captured when elaboration began. */
+type Resolved = {
+    readonly model: DblModel;
+    readonly stamps: ReadonlyMap<string, number>;
+};
+
+type Entry = {
+    readonly promise: Promise<Resolved>;
+    /** Whether {@link promise} has settled. A *pending* entry must not be
+     * awaited by another call that is itself mid-production; see
+     * {@link createModelCache}'s `resolveLink`. */
+    settled: boolean;
+    /** The fulfilled value, recorded on settlement so {@link ModelCache.depsOf}
+     * can read the dependency set synchronously. */
+    resolved?: Resolved;
+};
+
+/** Per-top-level-call resolution state: the ids currently being produced (for
+ * cycle detection) and the chain of names (for a legible cycle message). These
+ * are never shared across calls. */
+type CallState = {
+    readonly resolving: Set<string>;
+    readonly path: { id: string; name: string }[];
+};
+
+export interface ModelCache {
+    /**
+     * Resolve a link to its elaborated {@link DblModel}, reusing a cached model
+     * whenever the document and every document in its instantiation subtree
+     * still have the formal content they were elaborated from. Concurrent
+     * resolutions of the same document share one elaboration. Rejects — without
+     * caching the failure — when a referenced document is unavailable, fails to
+     * elaborate, or participates in a cycle.
+     */
+    resolve(link: Link, coreTheory: DblTheory): Promise<DblModel>;
+    /**
+     * Subscribe to change notifications for one document, by link id. The
+     * callback fires on *every* reported change of that document — the same
+     * (deliberately noisy) granularity as {@link DocumentStore.subscribe}; it is
+     * not filtered by formal content, so consumers re-derive what they need
+     * (typically by re-running a cached, and therefore cheap, validation).
+     *
+     * Only documents the cache has resolved have change subscriptions, so this
+     * is meaningful only for ids obtained from {@link depsOf} (or the id of a
+     * document that has itself been resolved). Returns an unsubscribe function.
+     */
+    onDocChange(id: string, callback: () => void): () => void;
+    /**
+     * The ids of every document the given document's cached model was built
+     * from — itself and its transitive instantiations — or `undefined` when the
+     * cache holds no settled resolution for it (never resolved, resolution
+     * still in flight, or evicted). This is the dependency set a validation
+     * observer subscribes to via {@link onDocChange}.
+     */
+    depsOf(id: string): ReadonlySet<string> | undefined;
+}
+
+function createModelCache<Handle>(store: DocumentStore<Handle>): ModelCache {
+    const docs = new Map<string, DocState<Handle>>();
+    const entries = new Map<string, Entry>();
+    /** Per-document change listeners (see {@link ModelCache.onDocChange}),
+     * notified from the store subscription right after the version bump. */
+    const docListeners = new Map<string, Set<() => void>>();
+
+    /**
+     * Get-or-create the persistent state for a document. Creation subscribes to
+     * the document's changes (the subscription is kept for the cache's — i.e.
+     * the store's — lifetime) and takes the initial signature. `getHandle` is
+     * asynchronous, so a concurrent creation may have raced ahead; the map is
+     * re-checked after the await and the earlier state wins.
+     */
+    const docStateFor = async (link: Link): Promise<DocState<Handle> | undefined> => {
+        const existing = docs.get(link._id);
+        if (existing) {
+            return existing;
+        }
+        const resolved = await store.getHandle({
+            id: link._id,
+            version: link._version,
+            server: link._server,
+        });
+        if (resolved.tag === "Err") {
+            return undefined;
+        }
+        const handle = resolved.content;
+        const raced = docs.get(link._id);
+        if (raced) {
+            return raced;
+        }
+        const state: DocState<Handle> = {
+            handle,
+            version: 0,
+            verifiedVersion: 0,
+            signature: "",
+            stamp: 0,
+        };
+        // Subscribe before the initial signature read: both are synchronous, so
+        // no change can slip between them, and every later change is reported.
+        store.subscribe(handle, () => {
+            state.version += 1;
+            // Snapshot so a listener may unsubscribe during notification.
+            for (const listener of Array.from(docListeners.get(link._id) ?? [])) {
+                listener();
+            }
+        });
+        state.signature = formalCellsSignature(store.getDocumentView(state.handle));
+        docs.set(link._id, state);
+        return state;
+    };
+
+    /**
+     * Re-verify a document's signature if changes were reported since the last
+     * check, advancing its content stamp only when the formal content actually
+     * differs. The version is captured before the read so a change landing
+     * during it leaves the state dirty for the next check.
+     */
+    const refreshDocState = (state: DocState<Handle>): void => {
+        if (state.version === state.verifiedVersion) {
+            return;
+        }
+        const version = state.version;
+        const signature = formalCellsSignature(store.getDocumentView(state.handle));
+        if (signature !== state.signature) {
+            state.signature = signature;
+            state.stamp += 1;
+        }
+        state.verifiedVersion = version;
+    };
+
+    /** Whether every document a resolved model was built from still has the
+     * content stamp captured at its elaboration. */
+    const stampsFresh = (stamps: ReadonlyMap<string, number>): boolean => {
+        for (const [id, stamp] of stamps) {
+            const state = docs.get(id);
+            if (!state) {
+                return false;
+            }
+            refreshDocState(state);
+            if (state.stamp !== stamp) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    /** A document's display name, or a short id fallback for an unnamed
+     * document, for legible cycle messages. */
+    const nameFor = async (link: Link): Promise<string> => {
+        const state = await docStateFor(link);
+        const name = state && (store.getDocumentView(state.handle) as ModelDocument).name;
+        return name && name.length > 0 ? `"${name}"` : `model ${link._id}`;
+    };
+
+    /**
+     * Elaborate a document afresh: fetch its state, capture its content stamp
+     * *before* reading the document view, recursively resolve its own
+     * instantiations (so it elaborates against a populated map), and elaborate
+     * against `coreTheory`. `call.resolving` catches cycles. The returned
+     * stamps are the union of the document's own stamp and every stamp its
+     * children were built from, so an entry's freshness covers the whole
+     * subtree — a grandchild edit invalidates the root even when the
+     * intermediate documents are untouched.
+     */
+    const elaborate = async (
+        link: Link,
+        coreTheory: DblTheory,
+        call: CallState,
+    ): Promise<Resolved> => {
+        const id = link._id;
+        const state = await docStateFor(link);
+        if (!state) {
+            throw new Error(`unknown model ${id}`);
+        }
+        refreshDocState(state);
+        // Capture the stamp before the reads below: an edit racing this
+        // (asynchronous) elaboration then makes the entry immediately stale
+        // rather than stamping fresh content stamps onto a mixed elaboration.
+        const stamps = new Map<string, number>([[id, state.stamp]]);
+        const doc = store.getDocumentView(state.handle) as ModelDocument;
+        call.resolving.add(id);
+        call.path.push({ id, name: await nameFor(link) });
+        try {
+            const instantiated = new DblModelMap();
+            for (const childLink of instantiationLinks(doc)) {
+                if (instantiated.has(childLink._id)) {
+                    continue;
+                }
+                const child = await resolveLink(childLink, coreTheory, call);
+                instantiated.set(childLink._id, child.model);
+                for (const [depId, depStamp] of child.stamps) {
+                    if (!stamps.has(depId)) {
+                        stamps.set(depId, depStamp);
+                    }
+                }
+            }
+            const model = elaborateModel(
+                doc.notebook as unknown as WasmModelNotebook,
+                instantiated,
+                coreTheory,
+                id,
+            );
+            return { model, stamps };
+        } finally {
+            call.resolving.delete(id);
+            call.path.pop();
+        }
+    };
+
+    /**
+     * Resolve a link through the cache: report cycles, reuse a fresh cached
+     * entry, await an in-flight one, or elaborate afresh and install the entry.
+     *
+     * A call that is itself mid-production (`call.resolving` non-empty) must
+     * *not* await a pending entry: that entry belongs to another, concurrent
+     * call (within one call resolution is sequential, so an own pending entry's
+     * id is always in `call.resolving` and is caught by the cycle check first),
+     * and two calls concurrently producing mutually-instantiating documents
+     * would await each other forever instead of reporting the cycle. Such a
+     * call elaborates independently — its own cycle detection still applies —
+     * and leaves the shared entry to its producer. Top-level awaits (empty
+     * `resolving`) cannot deadlock, since producers never wait on them.
+     */
+    const resolveLink = async (
+        link: Link,
+        coreTheory: DblTheory,
+        call: CallState,
+    ): Promise<Resolved> => {
+        const id = link._id;
+        if (call.resolving.has(id)) {
+            // Report the cycle as the chain of instantiations that closes it,
+            // e.g. `"First" → "Second" → "First"`, so the user can see exactly
+            // which notebooks instantiate each other.
+            const start = call.path.findIndex((entry) => entry.id === id);
+            const loop = [
+                ...call.path.slice(start).map((entry) => entry.name),
+                await nameFor(link),
+            ];
+            throw new CyclicInstantiationError(loop.join(" → "));
+        }
+        const existing = entries.get(id);
+        if (existing) {
+            if (!existing.settled && call.resolving.size > 0) {
+                return elaborate(link, coreTheory, call);
+            }
+            let resolved: Resolved | undefined;
+            try {
+                resolved = await existing.promise;
+            } catch {
+                // A rejected resolution is never cached; the producer removes
+                // the entry (below), and this caller resolves afresh.
+                resolved = undefined;
+            }
+            if (resolved && stampsFresh(resolved.stamps)) {
+                return resolved;
+            }
+            if (entries.get(id) === existing) {
+                entries.delete(id);
+            }
+            // Re-enter: another caller may already have installed a fresh entry.
+            return resolveLink(link, coreTheory, call);
+        }
+        const entry: Entry = { promise: elaborate(link, coreTheory, call), settled: false };
+        entry.promise.then(
+            (resolved) => {
+                entry.settled = true;
+                entry.resolved = resolved;
+            },
+            () => {
+                entry.settled = true;
+            },
+        );
+        entries.set(id, entry);
+        try {
+            return await entry.promise;
+        } catch (e) {
+            if (entries.get(id) === entry) {
+                entries.delete(id);
+            }
+            throw e;
+        }
+    };
+
+    return {
+        async resolve(link: Link, coreTheory: DblTheory): Promise<DblModel> {
+            const call: CallState = { resolving: new Set(), path: [] };
+            const resolved = await resolveLink(link, coreTheory, call);
+            return resolved.model;
+        },
+        onDocChange(id: string, callback: () => void): () => void {
+            let listeners = docListeners.get(id);
+            if (!listeners) {
+                listeners = new Set();
+                docListeners.set(id, listeners);
+            }
+            listeners.add(callback);
+            return () => {
+                listeners.delete(callback);
+            };
+        },
+        depsOf(id: string): ReadonlySet<string> | undefined {
+            const resolved = entries.get(id)?.resolved;
+            return resolved && new Set(resolved.stamps.keys());
+        },
+    };
+}
+
+/**
+ * The per-store cache registry. A `WeakMap` key is only object identity, so the
+ * store object itself keys its cache; `Handle` is captured in the cache's
+ * closures at construction (see {@link createModelCache}), so the cache's
+ * public surface — and hence this map's value type — never mentions it. The
+ * per-key correlation "cache's handle type = store's handle type" is tied
+ * together at the single accessor {@link modelCacheFor}.
+ */
+const caches = new WeakMap<object, ModelCache>();
+
+/** The model cache for a store, created on first use and GC'd with the store. */
+export function modelCacheFor<Handle>(store: DocumentStore<Handle>): ModelCache {
+    let cache = caches.get(store);
+    if (!cache) {
+        cache = createModelCache(store);
+        caches.set(store, cache);
+    }
+    return cache;
+}
+
+/**
+ * The memoized outcomes of {@link DblModel.validate}, keyed by model identity.
+ * A cached model is stable while its cache entry is fresh, so its validation
+ * outcome is stable too; a re-elaborated model is a new object and validates
+ * anew. Weakly keyed, so outcomes are collected with their models.
+ */
+const validationOutcomes = new WeakMap<DblModel, ReturnType<DblModel["validate"]>>();
+
+/** Run {@link DblModel.validate}, memoized per model object; see
+ * {@link validationOutcomes}. */
+export function validateModelCached(model: DblModel): ReturnType<DblModel["validate"]> {
+    let outcome = validationOutcomes.get(model);
+    if (!outcome) {
+        outcome = model.validate();
+        validationOutcomes.set(model, outcome);
+    }
+    return outcome;
+}
diff --git a/packages/document-methods/src/future/notebook.ts b/packages/document-methods/src/future/notebook.ts
new file mode 100644
index 000000000..8634cc2ad
--- /dev/null
+++ b/packages/document-methods/src/future/notebook.ts
@@ -0,0 +1,3144 @@
+import { v7 } from "uuid";
+
+import type {
+    Analysis,
+    AnalysisType,
+    Cell,
+    DiagramJudgment,
+    Document,
+    Link,
+    Modality,
+    ModelJudgment,
+    Mor,
+    MorType,
+    Ob,
+    SpecializeModel,
+} from "catcolab-document-types";
+import {
+    type DblModel,
+    type DblModelDiagram,
+    type DblTheory,
+    elaborateDiagram,
+    type InvalidDblModel,
+} from "catlog-wasm";
+import {
+    duplicateModelJudgment,
+    type ModelDocument,
+    newEquationDecl,
+    newInstantiatedModel,
+    newModelDocument,
+    newMorphismDecl,
+    newObjectDecl,
+} from "../model";
+import { duplicateCell, newFormalCell, newRichTextCell, type RichTextContent } from "../notebook";
+import { type AnalysisDocument, newAnalysisCell, newAnalysisDocument } from "./analysis";
+import {
+    type AnalysisCell,
+    type AnalysisCellsOf,
+    type AnalysisDef,
+    type AnalysisDefOf,
+    type AnalysisShape,
+    type AddCapability,
+    type AnyShape,
+    type AspectCell,
+    type AspectDef,
+    CellKind,
+    type CodOf,
+    type CreatableShape,
+    type DeclaredTypes,
+    type DeclaresMorphism,
+    type DeclaresObject,
+    type DiagramCell,
+    type DiagramShape,
+    type DiagramValidationResult,
+    defineObject,
+    type DomOf,
+    encodeEndpoint,
+    encodeObjectRef,
+    endpointApplyOp,
+    endpointListModality,
+    type HasAnalyses,
+    type HasCoreTheory,
+    type HasDiagram,
+    type IndividualCell,
+    type IndividualDef,
+    type InstantiationArgs,
+    type InstantiationCell,
+    type InstantiationSpecialization,
+    type InstantiationType,
+    type HasPathEquations,
+    isAnalysisShape,
+    isDiagramShape,
+    isInstantiationType,
+    isPathEquationType,
+    isRichTextType,
+    type ModelValidationResult,
+    type PathEquationArgs,
+    type PathEquationCell,
+    type PathEquationType,
+    type MorEndpointMeta,
+    type MorphismCell,
+    type MorphismDef,
+    type MorphismShapeBound,
+    type NotebookCell,
+    type ObjectCell,
+    type ObjectDef,
+    type ObjectShapeBound,
+    type RichTextCell,
+    type RichTextType,
+    type Reorder,
+    type ParamsOf,
+    type OutputOf,
+    resolveCoreTheory,
+    sameTypeValue,
+    type ShapeAddCapability,
+    type ShapeCellsOf,
+    type ShapeMorphisms,
+    type ShapeObjects,
+    type Update,
+    type ValidatableNotebook,
+} from "./definitions";
+import {
+    type DiagramDocument,
+    duplicateDiagramJudgment,
+    newDiagramDocument,
+    newDiagramMorphismDecl,
+    newDiagramObjectDecl,
+} from "./diagram";
+import {
+    type InstanceDocument,
+    type InstanceEntry,
+    type InstanceValue,
+    newInstanceDocument,
+} from "./instance";
+import { formalCellsSignature, modelCacheFor, validateModelCached } from "./model-cache";
+import { createValidationObserver } from "./observe";
+import {
+    type DocumentRef,
+    type DocumentStore,
+    linkFromRef,
+    plainDocumentId,
+    plainStore,
+    refFromLink,
+    resolveModelInStore,
+} from "./store";
+import {
+    type Issue,
+    type Result,
+    validateAddArgs,
+    validatePathEquationAddArgs,
+    validatePathEquationUpdateArgs,
+    validateUpdateArgs,
+    ValidationError,
+} from "./validation";
+
+/**
+ * Internal marker under which every attached notebook records the {@link Shape}
+ * it was created from. {@link Binder.createInstance} reads it back off a schema
+ * notebook to obtain that notebook's derived `.Diagram` shape without the caller
+ * having to pass the shape again. It is a symbol so it never collides with a
+ * document field or widens the public {@link Notebook} surface.
+ */
+const shapeMarker: unique symbol = Symbol("originatingShape");
+
+/** Stamp the originating shape onto a notebook and return it. */
+const withShape = <N extends object>(notebook: N, shape: AnyShape): N => {
+    Object.defineProperty(notebook, shapeMarker, {
+        value: shape,
+        enumerable: false,
+        writable: false,
+        configurable: true,
+    });
+    return notebook;
+};
+
+/** Read back the originating shape stamped by {@link withShape}, if present. */
+const shapeOf = (notebook: object): AnyShape | undefined =>
+    (notebook as { [shapeMarker]?: AnyShape })[shapeMarker];
+
+/** A stable key over an issue list, for {@link Notebook.onValidate}'s
+ * equivalence check on `Err` results. */
+const issuesKey = (issues: ReadonlyArray<Issue>): string =>
+    issues.map((issue) => `${String(issue.path?.[0] ?? "")}\u0000${issue.message}`).join("\u0001");
+
+/**
+ * Whether two model validation results would render identically, for
+ * {@link Notebook.onValidate}'s delivery gate. `Ok` results compare by model
+ * *identity* — safe because the elaboration cache returns the same model object
+ * until the underlying content actually changes — and `Err` results by their
+ * issues' paths and messages.
+ */
+const sameModelValidation = (a: ModelValidationResult, b: ModelValidationResult): boolean =>
+    a.tag === "Ok"
+        ? b.tag === "Ok" && a.content === b.content
+        : b.tag === "Err" && issuesKey(a.content) === issuesKey(b.content);
+
+/**
+ * A diagram/instance validation outcome together with what it was computed
+ * from, so {@link sameDiagramValidation} can decide equivalence: the elaborated
+ * diagram is a fresh object every run, so the result alone cannot say whether
+ * anything changed — the host model's identity (stable via the elaboration
+ * cache) and the notebook's own formal-content signature stand in for it.
+ */
+type DiagramValidationSnapshot = {
+    result: DiagramValidationResult;
+    model: DblModel | undefined;
+    ownSignature: string;
+};
+
+/** A stable key over a diagram validation's failure content. */
+const diagramErrorsKey = (result: DiagramValidationResult): string => {
+    switch (result.tag) {
+        case "Illformed":
+            return result.error;
+        case "Invalid":
+            return JSON.stringify(result.errors);
+        default:
+            return "";
+    }
+};
+
+/** Whether two diagram/instance validation snapshots would render identically;
+ * see {@link DiagramValidationSnapshot}. */
+const sameDiagramValidation = (
+    a: DiagramValidationSnapshot,
+    b: DiagramValidationSnapshot,
+): boolean =>
+    a.result.tag === b.result.tag &&
+    a.model === b.model &&
+    a.ownSignature === b.ownSignature &&
+    diagramErrorsKey(a.result) === diagramErrorsKey(b.result);
+
+/**
+ * Convert an {@link InvalidDblModel} validation error into a
+ * [Standard Schema](https://standardschema.dev) {@link Issue}. The failing
+ * generator's qualified name (when the error carries one) becomes the issue's
+ * `path`, and a legible description of the error tag its `message`, so callers
+ * inspect model validation failures the same vendor-neutral way as `add`/`get`
+ * failures.
+ */
+const modelErrorToIssue = (error: InvalidDblModel): Issue => {
+    switch (error.tag) {
+        case "Dom":
+            return {
+                message: `Morphism "${error.content}" has an invalid domain`,
+                path: [error.content],
+            };
+        case "Cod":
+            return {
+                message: `Morphism "${error.content}" has an invalid codomain`,
+                path: [error.content],
+            };
+        case "ObType":
+            return {
+                message: `Object "${error.content}" has an invalid type`,
+                path: [error.content],
+            };
+        case "MorType":
+            return {
+                message: `Morphism "${error.content}" has an invalid type`,
+                path: [error.content],
+            };
+        case "DomType":
+            return {
+                message: `Morphism "${error.content}" has an invalid domain type`,
+                path: [error.content],
+            };
+        case "CodType":
+            return {
+                message: `Morphism "${error.content}" has an invalid codomain type`,
+                path: [error.content],
+            };
+        case "Eqn":
+            return { message: "An equation is invalid" };
+        case "UnsupportedFeature":
+            return { message: `Unsupported feature: ${error.content.tag}` };
+        case "InvalidLink":
+            return {
+                message: `Object "${error.content}" has an invalid link`,
+                path: [error.content],
+            };
+    }
+};
+
+/**
+ * Drop the endpoint `obType` metadata from a morphism def's `domain`/`codomain`.
+ * That field is only an *expectation* used to validate `add` (see
+ * `defineMorphism`); it is not part of what the document stores, so a def
+ * reconstructed from storage in `cells()` cannot recover it for a `Basic`
+ * morphism. {@link sameMorphismType} compares on the rest (the `morType` and
+ * each endpoint's `apply`/`modality`), which keeps `cellsOf`/`supports`
+ * selecting the right cells regardless of the recorded `obType`.
+ */
+const stripObTypeFromMeta = (meta: MorEndpointMeta | undefined): MorEndpointMeta | undefined => {
+    if (!meta) {
+        return undefined;
+    }
+    const { obType: _obType, ...rest } = meta;
+    return Object.keys(rest).length > 0 ? rest : undefined;
+};
+
+const stripEndpointObType = (def: MorphismDef): MorphismDef => ({
+    ...def,
+    domain: stripObTypeFromMeta(def.domain),
+    codomain: stripObTypeFromMeta(def.codomain),
+});
+
+/** Structural equality of two morphism defs ignoring endpoint `obType`. */
+const sameMorphismType = (a: MorphismDef, b: MorphismDef): boolean =>
+    sameTypeValue(stripEndpointObType(a), stripEndpointObType(b));
+
+/**
+ * The rich-text updater shared by every notebook flavor's rich-text cell
+ * handle. A content update replaces the cell's fields through the notebook's
+ * generic `change`. This is replace-only by design: incremental rich-text
+ * editing does not go through the notebook handle at all — an editor binds
+ * directly to the store via {@link DocumentStore.getRichTextRef}.
+ */
+const makeRichTextUpdater =
+    (
+        change: (
+            fn: (doc: { notebook: { cellContents: Record<string, unknown> } }) => void,
+        ) => void,
+    ) =>
+    (cellId: string, u: { content?: RichTextContent }) => {
+        change((d) => {
+            Object.assign(d.notebook.cellContents[cellId] as object, u);
+        });
+    };
+
+/**
+ * Attach an analysis notebook over a real {@link AnalysisDocument} held by the
+ * store. Cells are stored as {@link Analysis} formal cells (`{ id, content }`),
+ * coexisting with rich-text cells. Each {@link AnalysisCell.run} resolves the
+ * analyzed model from the document's `analysisOf` link through the store, then
+ * delegates to the analysis def's `run`.
+ */
+function attachAnalysisNotebook<TShape extends AnalysisShape, Handle>(
+    store: DocumentStore<Handle>,
+    handle: Handle,
+    shape: TShape,
+): Notebook<TShape, Handle> {
+    const doc = store.getDocumentView(handle) as AnalysisDocument;
+    const change = (fn: (doc: AnalysisDocument) => void) =>
+        store.changeDocument(handle, fn as (doc: Document) => void);
+
+    const changeRichText = makeRichTextUpdater(change);
+
+    /** The analysis def for a given id, looked up in the shape's `analyses`. */
+    const defForId = (id: string): AnalysisDef | undefined =>
+        (shape.analyses ?? []).find((def) => def.id === id);
+
+    const readCell = (cellId: string): Cell<Analysis> | undefined =>
+        doc.notebook.cellContents[cellId] as Cell<Analysis> | undefined;
+
+    /**
+     * Read an analysis cell's stored params, or `{}` if missing/non-formal.
+     *
+     * This is the single untyped boundary of the analysis notebook: the
+     * persisted `Analysis.content` is a bare `Record<string, Value>` that carries
+     * no link back to the `Def` whose `params` it holds, so recovering the
+     * `ParamsOf<Def>` view here is an unchecked cast. Every typed handle reads its
+     * params through this one function, so no other cast is needed downstream.
+     */
+    const readParams = <Def extends AnalysisDef>(cellId: string): ParamsOf<Def> => {
+        const cell = readCell(cellId);
+        if (cell?.tag !== "formal") {
+            return {} as ParamsOf<Def>;
+        }
+        return cell.content.content as ParamsOf<Def>;
+    };
+
+    const moveCell = (cellId: string, target: (from: number) => number) =>
+        change((d) => {
+            const order = d.notebook.cellOrder;
+            const from = order.indexOf(cellId);
+            if (from < 0) {
+                return;
+            }
+            const to = Math.max(0, Math.min(target(from), order.length - 1));
+            if (to === from) {
+                return;
+            }
+            order.splice(from, 1);
+            order.splice(to, 0, cellId);
+        });
+
+    const deleteCell = (cellId: string) =>
+        change((d) => {
+            const order = d.notebook.cellOrder;
+            const from = order.indexOf(cellId);
+            if (from < 0) {
+                return;
+            }
+            order.splice(from, 1);
+            delete d.notebook.cellContents[cellId];
+        });
+
+    const reorderMethods = (cellId: string): Reorder => ({
+        moveUp: () => moveCell(cellId, (from) => from - 1),
+        moveDown: () => moveCell(cellId, (from) => from + 1),
+        moveTo: (index: number) => moveCell(cellId, () => index),
+        delete: () => deleteCell(cellId),
+    });
+
+    const richTextHandle = (cellId: string): RichTextCell =>
+        ({
+            kind: CellKind.RichText,
+            id: cellId,
+            get content() {
+                return (readCell(cellId) as { content?: RichTextContent } | undefined)?.content;
+            },
+            get editorRef() {
+                return store.getRichTextRef?.(handle, cellId);
+            },
+            update(u: { content?: RichTextContent }) {
+                changeRichText(cellId, u);
+            },
+            ...reorderMethods(cellId),
+        }) as unknown as RichTextCell;
+
+    const analysisHandle = <Def extends AnalysisDef>(
+        cellId: string,
+        def: Def,
+    ): AnalysisCell<Def> => {
+        const handle: AnalysisCell<Def> = {
+            kind: CellKind.Analysis,
+            get id() {
+                return cellId;
+            },
+            type: def,
+            get params() {
+                return readParams<Def>(cellId);
+            },
+            update(partial: Partial<ParamsOf<Def>>) {
+                change((d) => {
+                    const cell = d.notebook.cellContents[cellId] as Cell<Analysis> | undefined;
+                    if (cell?.tag === "formal") {
+                        Object.assign(cell.content.content, partial);
+                    }
+                });
+            },
+            async run(): Promise<Result<OutputOf<Def>>> {
+                const params = readParams<Def>(cellId);
+                const coreTheory = await resolveCoreTheory({
+                    getCoreTheory: shape.analysisOfCoreTheory,
+                });
+                if (!coreTheory) {
+                    return {
+                        tag: "Err",
+                        content: [
+                            {
+                                message:
+                                    "run() needs the analyzed model's core theory: this " +
+                                    "analysis shape has no `analysisOfCoreTheory`.",
+                            },
+                        ],
+                    };
+                }
+                try {
+                    const model = await resolveModelInStore(
+                        store,
+                        refFromLink(doc.analysisOf),
+                        coreTheory,
+                    );
+                    // `def.run` is only known to return `Promise<Output>` up to the
+                    // `AnalysisDef` constraint, where `Output` defaults to `unknown`;
+                    // recover the precise `OutputOf<Def>` at this boundary so the
+                    // `Ok` content matches the handle's declared `Result<OutputOf<Def>>`.
+                    const content = (await def.run(model, params)) as OutputOf<Def>;
+                    return { tag: "Ok", content };
+                } catch (error) {
+                    return {
+                        tag: "Err",
+                        content: [
+                            { message: error instanceof Error ? error.message : String(error) },
+                        ],
+                    };
+                }
+            },
+            ...reorderMethods(cellId),
+        };
+        return handle;
+    };
+
+    const impl = {
+        get name() {
+            return doc.name;
+        },
+        handle,
+        get document() {
+            return doc;
+        },
+        get analysisType(): AnalysisType {
+            return doc.analysisType;
+        },
+        dump() {
+            return store.copyValue(handle, doc);
+        },
+        update(u: { name?: string }) {
+            change((d) => {
+                Object.assign(d, u);
+            });
+        },
+        onChange(callback: () => void): () => void {
+            return store.subscribe(handle, callback);
+        },
+        onChangeFormalContent(callback: () => void): () => void {
+            const signature = () => formalCellsSignature(doc);
+            let previous = signature();
+            return impl.onChange(() => {
+                const next = signature();
+                if (next !== previous) {
+                    previous = next;
+                    callback();
+                }
+            });
+        },
+        add(type: unknown, args?: { content?: RichTextContent }) {
+            if (isRichTextType(type)) {
+                const cell = newRichTextCell((args as { content?: RichTextContent })?.content);
+                change((d) => {
+                    d.notebook.cellContents[cell.id] = cell as unknown as Cell<Analysis>;
+                    d.notebook.cellOrder.push(cell.id);
+                });
+                return richTextHandle(cell.id);
+            }
+            const def = type as AnalysisDef;
+            const cell = newFormalCell(
+                newAnalysisCell(def.id, def.getInitialParams() as Record<string, unknown>),
+            );
+            change((d) => {
+                d.notebook.cellContents[cell.id] = cell;
+                d.notebook.cellOrder.push(cell.id);
+            });
+            return analysisHandle(cell.id, def);
+        },
+        cells(): Array<RichTextCell | AnalysisCell> {
+            return doc.notebook.cellOrder.map((cellId) => {
+                const cell = doc.notebook.cellContents[cellId];
+                if (!cell) {
+                    throw new Error(`Failed to find notebook cell contents for cell '${cellId}'`);
+                }
+                if (cell.tag === "rich-text") {
+                    return richTextHandle(cellId);
+                }
+                const content = cell.content;
+                const def = defForId(content.id);
+                if (!def) {
+                    throw new Error(`No analysis declared for id '${content.id}'.`);
+                }
+                return analysisHandle(cellId, def);
+            });
+        },
+        formalCells(): Array<AnalysisCell> {
+            return impl
+                .cells()
+                .filter((cell) => cell.kind !== CellKind.RichText) as Array<AnalysisCell>;
+        },
+        cellsOf(arg: RichTextType | AnalysisDef): Array<RichTextCell | AnalysisCell> {
+            if (isRichTextType(arg)) {
+                return impl.cells().filter((cell) => cell.kind === CellKind.RichText);
+            }
+            return impl
+                .cells()
+                .filter((cell) => cell.kind === CellKind.Analysis && cell.type.id === arg.id);
+        },
+    };
+
+    const notebook = impl as unknown as Notebook<TShape, Handle>;
+
+    if ((store as DocumentStore<unknown>) === plainStore) {
+        plainDocumentId(handle as Document);
+    }
+
+    return notebook;
+}
+
+/**
+ * Attach a diagram notebook over a real {@link DiagramDocument} held by the
+ * store. Cells are stored as {@link DiagramJudgment} formal cells — objects and
+ * morphisms drawn `over` the cells of the model the diagram is in — coexisting
+ * with rich-text cells. The model is referenced by the document's `diagramIn`
+ * link and read through the store, so endpoint and `over` handles resolve to the
+ * model's own object/morphism cells. {@link Notebook.validate} resolves and
+ * elaborates the model, elaborates the diagram against the model's core theory,
+ * and validates the diagram in the model.
+ */
+function attachDiagramNotebook<TShape extends DiagramShape, Handle>(
+    store: DocumentStore<Handle>,
+    handle: Handle,
+    shape: TShape,
+    modelHandle: Handle,
+): Notebook<TShape, Handle> {
+    const doc = store.getDocumentView(handle) as DiagramDocument;
+    const change = (fn: (doc: DiagramDocument) => void) =>
+        store.changeDocument(handle, fn as (doc: Document) => void);
+    const copy = <T>(value: T): T => store.copyValue(handle, value);
+    const isPlainStore = (store as DocumentStore<unknown>) === plainStore;
+
+    const changeRichText = makeRichTextUpdater(change);
+
+    /**
+     * The model document the diagram is drawn in. The model handle is threaded
+     * in from `createNotebook`'s `in` notebook (the diagram's only construction
+     * path), so the diagram reads the model directly and synchronously — no
+     * `getHandle` round-trip is needed for reactive reads, since the caller
+     * already holds the model it is drawing in.
+     */
+    const modelDocument = (): ModelDocument => store.getDocumentView(modelHandle) as ModelDocument;
+
+    /** Read a model judgment by its generator id from the model document. */
+    const modelJudgment = (id: string): ModelJudgment | undefined => {
+        const model = modelDocument();
+        for (const cellId of model.notebook.cellOrder) {
+            const cell = model.notebook.cellContents[cellId];
+            if (cell?.tag === "formal" && (cell.content as ModelJudgment).id === id) {
+                return cell.content as ModelJudgment;
+            }
+        }
+        return undefined;
+    };
+
+    /** A read-only handle for the model object a diagram individual is over. */
+    const modelObjectHandle = (id: string): ObjectCell => {
+        const judgment = modelJudgment(id);
+        const obType =
+            judgment?.tag === "object" ? judgment.obType : { tag: "Basic" as const, content: "" };
+        return {
+            kind: CellKind.Object,
+            id,
+            type: defineObject(obType),
+            get label() {
+                const current = modelJudgment(id);
+                return current?.tag === "object" ? current.name : undefined;
+            },
+        } as unknown as ObjectCell;
+    };
+
+    /** A read-only handle for the model morphism a diagram aspect is over. */
+    const modelMorphismHandle = (id: string): MorphismCell => {
+        return {
+            kind: CellKind.Morphism,
+            id,
+            get label() {
+                const current = modelJudgment(id);
+                return current?.tag === "morphism" ? current.name : undefined;
+            },
+        } as unknown as MorphismCell;
+    };
+
+    const readCellContent = <T>(cellId: string): T | undefined => {
+        const cell = doc.notebook.cellContents[cellId];
+        if (!cell) {
+            return undefined;
+        }
+        return (cell as unknown as { content: T }).content;
+    };
+
+    const moveCell = (cellId: string, target: (from: number) => number) =>
+        change((d) => {
+            const order = d.notebook.cellOrder;
+            const from = order.indexOf(cellId);
+            if (from < 0) {
+                return;
+            }
+            const to = Math.max(0, Math.min(target(from), order.length - 1));
+            if (to === from) {
+                return;
+            }
+            order.splice(from, 1);
+            order.splice(to, 0, cellId);
+        });
+
+    const deleteCell = (cellId: string) =>
+        change((d) => {
+            const order = d.notebook.cellOrder;
+            const from = order.indexOf(cellId);
+            if (from < 0) {
+                return;
+            }
+            order.splice(from, 1);
+            delete d.notebook.cellContents[cellId];
+        });
+
+    const reorderMethods = (cellId: string): Reorder => ({
+        moveUp: () => moveCell(cellId, (from) => from - 1),
+        moveDown: () => moveCell(cellId, (from) => from + 1),
+        moveTo: (index: number) => moveCell(cellId, () => index),
+        delete: () => deleteCell(cellId),
+    });
+
+    const appendDuplicate = (cellId: string): string => {
+        const cell = doc.notebook.cellContents[cellId];
+        if (!cell || cell.tag !== "formal") {
+            throw new Error(`Cannot duplicate cell '${cellId}'.`);
+        }
+        const duplicated = newFormalCell(
+            duplicateDiagramJudgment(copy(cell.content as DiagramJudgment)),
+        );
+        change((d) => {
+            d.notebook.cellContents[duplicated.id] = duplicated as unknown as Cell<DiagramJudgment>;
+            d.notebook.cellOrder.push(duplicated.id);
+        });
+        return duplicated.id;
+    };
+
+    /** Resolve a stored endpoint `Ob` to the diagram individual cell it names. */
+    const individualForId = (id: string): IndividualCell => {
+        for (const cellId of doc.notebook.cellOrder) {
+            const cell = doc.notebook.cellContents[cellId];
+            if (cell?.tag !== "formal") {
+                continue;
+            }
+            const judgment = cell.content as DiagramJudgment;
+            if (judgment.tag === "object" && judgment.id === id) {
+                return individualHandle(cellId, shape.Individual);
+            }
+        }
+        throw new Error(`No individual cell found for endpoint '${id}'.`);
+    };
+
+    const decodeIndividualEndpoint = (ob: Ob | null): IndividualCell | undefined =>
+        ob?.tag === "Basic" ? individualForId(ob.content) : undefined;
+
+    const individualHandle = <Def extends IndividualDef>(
+        cellId: string,
+        type: Def,
+    ): IndividualCell<Def> =>
+        ({
+            kind: CellKind.Object,
+            get id() {
+                return readCellContent<{ id: string }>(cellId)?.id;
+            },
+            type,
+            get label() {
+                return readCellContent<{ name: string }>(cellId)?.name;
+            },
+            get over() {
+                const over = readCellContent<{ over: Ob | null }>(cellId)?.over;
+                return over?.tag === "Basic" ? modelObjectHandle(over.content) : undefined;
+            },
+            update(u: { label?: string; over?: { id: string } }) {
+                change((d) => {
+                    const content = (
+                        d.notebook.cellContents[cellId] as {
+                            content: { name: string; over: Ob | null };
+                        }
+                    ).content;
+                    if (u.label !== undefined) {
+                        content.name = u.label;
+                    }
+                    if ("over" in u) {
+                        content.over = u.over ? encodeObjectRef(u.over) : null;
+                    }
+                });
+            },
+            duplicate() {
+                return individualHandle(appendDuplicate(cellId), type);
+            },
+            ...reorderMethods(cellId),
+        }) as unknown as IndividualCell<Def>;
+
+    const aspectHandle = <Def extends AspectDef>(cellId: string, type: Def): AspectCell<Def> =>
+        ({
+            kind: CellKind.Morphism,
+            get id() {
+                return readCellContent<{ id: string }>(cellId)?.id;
+            },
+            type,
+            get label() {
+                return readCellContent<{ name: string }>(cellId)?.name;
+            },
+            get from() {
+                return decodeIndividualEndpoint(
+                    readCellContent<{ dom: Ob | null }>(cellId)?.dom ?? null,
+                );
+            },
+            get to() {
+                return decodeIndividualEndpoint(
+                    readCellContent<{ cod: Ob | null }>(cellId)?.cod ?? null,
+                );
+            },
+            get over() {
+                const over = readCellContent<{ over: Mor | null }>(cellId)?.over;
+                return over?.tag === "Basic" ? modelMorphismHandle(over.content) : undefined;
+            },
+            update(u: {
+                label?: string;
+                from?: { id: string };
+                to?: { id: string };
+                over?: { id: string };
+            }) {
+                change((d) => {
+                    const content = (
+                        d.notebook.cellContents[cellId] as {
+                            content: {
+                                name: string;
+                                dom: Ob | null;
+                                cod: Ob | null;
+                                over: Mor | null;
+                            };
+                        }
+                    ).content;
+                    if (u.label !== undefined) {
+                        content.name = u.label;
+                    }
+                    if ("from" in u) {
+                        content.dom = u.from ? encodeObjectRef(u.from) : null;
+                    }
+                    if ("to" in u) {
+                        content.cod = u.to ? encodeObjectRef(u.to) : null;
+                    }
+                    if ("over" in u) {
+                        content.over = u.over ? { tag: "Basic", content: u.over.id } : null;
+                    }
+                });
+            },
+            duplicate() {
+                return aspectHandle(appendDuplicate(cellId), type);
+            },
+            ...reorderMethods(cellId),
+        }) as unknown as AspectCell<Def>;
+
+    const richTextHandle = (cellId: string): RichTextCell =>
+        ({
+            kind: CellKind.RichText,
+            id: cellId,
+            get content() {
+                return readCellContent<RichTextContent>(cellId);
+            },
+            get editorRef() {
+                return store.getRichTextRef?.(handle, cellId);
+            },
+            update(u: { content?: RichTextContent }) {
+                changeRichText(cellId, u);
+            },
+            ...reorderMethods(cellId),
+        }) as unknown as RichTextCell;
+
+    const impl = {
+        get name() {
+            return doc.name;
+        },
+        get theory() {
+            return shape.theory;
+        },
+        handle,
+        get document() {
+            return doc;
+        },
+        dump() {
+            return copy(doc);
+        },
+        update(u: { name?: string }) {
+            change((d) => {
+                Object.assign(d, u);
+            });
+        },
+        onChange(callback: () => void): () => void {
+            return store.subscribe(handle, callback);
+        },
+        onChangeFormalContent(callback: () => void): () => void {
+            const signature = () => formalCellsSignature(doc);
+            let previous = signature();
+            return impl.onChange(() => {
+                const next = signature();
+                if (next !== previous) {
+                    previous = next;
+                    callback();
+                }
+            });
+        },
+        add(
+            type: unknown,
+            args: {
+                content?: RichTextContent;
+                label?: string;
+                over?: { id: string };
+                from?: { id: string };
+                to?: { id: string };
+            },
+        ) {
+            if (isRichTextType(type)) {
+                const cell = newRichTextCell((args as { content?: RichTextContent })?.content);
+                change((d) => {
+                    d.notebook.cellContents[cell.id] = cell as unknown as Cell<DiagramJudgment>;
+                    d.notebook.cellOrder.push(cell.id);
+                });
+                return richTextHandle(cell.id);
+            }
+            const def = type as IndividualDef | AspectDef;
+            if (def.tag === "individual") {
+                const judgment = newDiagramObjectDecl(
+                    def.obType,
+                    args.over ? encodeObjectRef(args.over) : null,
+                );
+                judgment.name = args.label ?? "";
+                const formalCell = newFormalCell(judgment);
+                change((d) => {
+                    d.notebook.cellContents[formalCell.id] = formalCell;
+                    d.notebook.cellOrder.push(formalCell.id);
+                });
+                return individualHandle(formalCell.id, def);
+            }
+            const judgment = newDiagramMorphismDecl(
+                def.morType,
+                args.over ? { tag: "Basic", content: args.over.id } : null,
+            );
+            judgment.name = args.label ?? "";
+            judgment.dom = args.from ? encodeObjectRef(args.from) : null;
+            judgment.cod = args.to ? encodeObjectRef(args.to) : null;
+            const formalCell = newFormalCell(judgment);
+            change((d) => {
+                d.notebook.cellContents[formalCell.id] = formalCell;
+                d.notebook.cellOrder.push(formalCell.id);
+            });
+            return aspectHandle(formalCell.id, def);
+        },
+        cells(): Array<DiagramCell> {
+            return doc.notebook.cellOrder.map((cellId) => {
+                const cell = doc.notebook.cellContents[cellId];
+                if (!cell) {
+                    throw new Error(`Failed to find notebook cell contents for cell '${cellId}'`);
+                }
+                if (cell.tag === "rich-text") {
+                    return richTextHandle(cellId);
+                }
+                const judgment = cell.content as DiagramJudgment;
+                switch (judgment.tag) {
+                    case "object":
+                        return individualHandle(cellId, shape.Individual);
+                    case "morphism":
+                        return aspectHandle(
+                            cellId,
+                            shape.Aspect ??
+                                ({
+                                    tag: "aspect",
+                                    morphism: { tag: "morphism", morType: judgment.morType },
+                                    morType: judgment.morType,
+                                } satisfies AspectDef),
+                        );
+                    default:
+                        throw new Error(`Unsupported diagram judgment tag: ${judgment.tag}`);
+                }
+            });
+        },
+        formalCells(): Array<Exclude<DiagramCell, RichTextCell>> {
+            return impl.cells().filter((cell) => cell.kind !== CellKind.RichText) as Array<
+                Exclude<DiagramCell, RichTextCell>
+            >;
+        },
+        async validate(): Promise<DiagramValidationResult> {
+            return (await runValidation()).result;
+        },
+        onValidate(callback: (result: DiagramValidationResult) => void): () => void {
+            return createValidationObserver<DiagramValidationSnapshot>({
+                validate: async () => ({
+                    ...(await runValidation()),
+                    ownSignature: formalCellsSignature(doc),
+                }),
+                cache: modelCacheFor(store),
+                depRootId: doc.diagramIn._id,
+                subscribeOwn: (cb) => impl.onChangeFormalContent(cb),
+                equivalent: sameDiagramValidation,
+                deliver: (snapshot) => callback(snapshot.result),
+            });
+        },
+    };
+
+    /**
+     * One validation run, also reporting the host model it validated in (when
+     * resolution succeeded): {@link Notebook.onValidate} compares that model's
+     * identity across runs, which the {@link DiagramValidationResult} alone
+     * cannot provide.
+     */
+    const runValidation = async (): Promise<{
+        result: DiagramValidationResult;
+        model: DblModel | undefined;
+    }> => {
+        const coreTheory = await resolveCoreTheory({
+            getCoreTheory: shape.diagramInCoreTheory,
+        });
+        if (!coreTheory) {
+            throw new Error(
+                "validate() needs the model's core theory: this diagram shape has " +
+                    "no `diagramInCoreTheory`.",
+            );
+        }
+        let model: DblModel;
+        try {
+            model = await resolveModelInStore(store, refFromLink(doc.diagramIn), coreTheory);
+        } catch (e) {
+            return {
+                result: { tag: "Illformed", diagram: null, error: String(e) },
+                model: undefined,
+            };
+        }
+        let diagram: DblModelDiagram;
+        try {
+            const judgments = doc.notebook.cellOrder.flatMap((cellId) => {
+                const cell = doc.notebook.cellContents[cellId];
+                return cell?.tag === "formal" ? [cell.content as DiagramJudgment] : [];
+            });
+            diagram = elaborateDiagram(judgments, coreTheory);
+        } catch (e) {
+            return { result: { tag: "Illformed", diagram: null, error: String(e) }, model };
+        }
+        diagram.inferMissingFrom(model);
+        const result = diagram.validateIn(model);
+        if (result.tag === "Ok") {
+            return { result: { tag: "Valid", diagram }, model };
+        }
+        return { result: { tag: "Invalid", diagram, errors: result.content }, model };
+    };
+
+    const notebook = impl as unknown as Notebook<TShape, Handle>;
+
+    if (isPlainStore) {
+        plainDocumentId(handle as Document);
+    }
+
+    return notebook;
+}
+
+/** The generator id referenced by a `Basic` endpoint object, if any. */
+const obRefId = (ob: Ob | null): string | undefined =>
+    ob?.tag === "Basic" ? ob.content : undefined;
+
+/** Whether a value passed as an inline instance-`add` arg is an existing row. */
+const isRow = (value: unknown): value is { readonly id: string } =>
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as { id?: unknown }).id === "string";
+
+/**
+ * Attach an *instance* notebook: an ergonomic, row-oriented surface over an
+ * {@link InstanceDocument}, which stores its data as a single flat `entries`
+ * array of triples
+ * keyed by the schema's generator UUIDs (see {@link InstanceDocument}).
+ *
+ * An instance is a database of the schema it is of: `instance.add(person, { …
+ * })` inserts a *row* for the schema object `person` by adding an `EntityOf`
+ * triple, and the inline args name the schema's outgoing mappings and
+ * attributes — each adds a `MorphismRef` triple wiring the row to another row (a
+ * mapping) or a literal value (an attribute). Rows are never named: identity is
+ * the row's UUID and its triples.
+ *
+ * Because `EntityOf` triples reference schema objects, and `MorphismRef` triples
+ * reference schema morphisms, by UUID, the surface only ever *displays* the parts
+ * of the schema still live: a deleted schema morphism's triples remain in the
+ * document but resolve to no live column, so {@link Row.values} silently omits
+ * them. Restoring the morphism (undo/redo/rollback) re-associates the retained
+ * triples with no diffing. This is the whole point of the single flat,
+ * UUID-keyed triples representation.
+ *
+ * Validation still runs through the same catlog machinery a diagram uses: the
+ * triples are elaborated on the fly into the {@link DiagramJudgment}s a
+ * diagram-in-model would carry, then validated in the schema model.
+ */
+function attachInstanceNotebook<TShape extends DiagramShape, Handle>(
+    store: DocumentStore<Handle>,
+    handle: Handle,
+    shape: TShape,
+    modelHandle: Handle,
+): Instance<TShape, Handle> {
+    const doc = store.getDocumentView(handle) as unknown as InstanceDocument;
+    const change = (fn: (doc: InstanceDocument) => void) =>
+        store.changeDocument(handle, fn as unknown as (doc: Document) => void);
+    const copy = <T>(value: T): T => store.copyValue(handle, value);
+    const isPlainStore = (store as DocumentStore<unknown>) === plainStore;
+
+    const modelDocument = (): ModelDocument => store.getDocumentView(modelHandle) as ModelDocument;
+
+    /** Every morphism judgment declared in the schema this instance is of. */
+    const schemaMorphisms = (): Array<ModelJudgment & { tag: "morphism" }> => {
+        const model = modelDocument();
+        const out: Array<ModelJudgment & { tag: "morphism" }> = [];
+        for (const cellId of model.notebook.cellOrder) {
+            const cell = model.notebook.cellContents[cellId];
+            if (cell?.tag === "formal" && (cell.content as ModelJudgment).tag === "morphism") {
+                out.push(cell.content as ModelJudgment & { tag: "morphism" });
+            }
+        }
+        return out;
+    };
+
+    /** The schema object judgment for a generator id, if it is still live. */
+    const schemaObjectJudgment = (id: string): (ModelJudgment & { tag: "object" }) | undefined => {
+        const model = modelDocument();
+        for (const cellId of model.notebook.cellOrder) {
+            const cell = model.notebook.cellContents[cellId];
+            const content = cell?.tag === "formal" ? (cell.content as ModelJudgment) : undefined;
+            if (content?.tag === "object" && content.id === id) {
+                return content;
+            }
+        }
+        return undefined;
+    };
+
+    /** A read-only schema object cell handle for a schema object judgment id. */
+    const schemaObjectCell = (id: string): ObjectCell => {
+        const judgment = schemaObjectJudgment(id);
+        const obType = judgment?.obType ?? { tag: "Basic" as const, content: "" };
+        return {
+            kind: CellKind.Object,
+            id,
+            type: defineObject(obType),
+            get label() {
+                return schemaObjectJudgment(id)?.name;
+            },
+        } as unknown as ObjectCell;
+    };
+
+    /** The morphism named `key` whose domain is `objectId`, if any. */
+    const morphismByName = (
+        key: string,
+        objectId: string,
+    ): (ModelJudgment & { tag: "morphism" }) | undefined =>
+        schemaMorphisms().find((m) => m.name === key && obRefId(m.dom) === objectId);
+
+    /** The morphism with the given generator id, if it is still live. */
+    const morphismById = (id: string): (ModelJudgment & { tag: "morphism" }) | undefined =>
+        schemaMorphisms().find((m) => m.id === id);
+
+    /** The `EntityOf` triple for a row id, if the row exists. */
+    const entityTripleOf = (rowId: string): InstanceEntry | undefined =>
+        doc.entries.find((e) => e.subject === rowId && e.property.tag === "EntityOf");
+
+    /** The schema object id a row is a record of, if the row exists. */
+    const objectIdOfRow = (rowId: string): string | undefined => {
+        const value = entityTripleOf(rowId)?.value;
+        return value?.tag === "ObjectRef" ? value.content : undefined;
+    };
+
+    /** The mapping/attribute triples (`MorphismRef`) whose subject is the given row id. */
+    const morphismEntriesOf = (rowId: string): InstanceEntry[] =>
+        doc.entries.filter((e) => e.subject === rowId && e.property.tag === "MorphismRef");
+
+    /** Encode a `RowValue` as a stored triple value. */
+    const encodeCellValue = (value: Exclude<RowValue, undefined>): InstanceValue =>
+        isRow(value)
+            ? { tag: "ObjectRef", content: value.id }
+            : { tag: "Literal", content: value as string | number | boolean };
+
+    /**
+     * Insert a row for a schema object, then set the inline mapping/attribute
+     * values named by `args`. Returns the new row handle.
+     */
+    const insertRow = (objectId: string, args?: Record<string, RowValue>): Row => {
+        const rowId = v7();
+        change((d) => {
+            d.entries.push({
+                subject: rowId,
+                property: { tag: "EntityOf" },
+                value: { tag: "ObjectRef", content: objectId },
+            });
+        });
+        const handle = rowHandle(rowId);
+        for (const [key, value] of Object.entries(args ?? {})) {
+            if (value === undefined) {
+                continue;
+            }
+            const morphism = morphismByName(key, objectId);
+            if (!morphism) {
+                const name = schemaObjectJudgment(objectId)?.name ?? objectId;
+                throw new Error(
+                    `No mapping or attribute named "${key}" on schema object "${name}".`,
+                );
+            }
+            handle.set(morphism, value);
+        }
+        return handle;
+    };
+
+    /** Set (or clear) a row's value for one schema morphism, replacing any prior triple. */
+    const setValue = (rowId: string, morphismId: string, value?: RowValue): void => {
+        if (entityTripleOf(rowId) === undefined) {
+            throw new Error(`No instance row with id "${rowId}".`);
+        }
+        change((d) => {
+            // Replace: drop any existing triple for this row + morphism first.
+            d.entries = d.entries.filter(
+                (e) =>
+                    !(
+                        e.subject === rowId &&
+                        e.property.tag === "MorphismRef" &&
+                        e.property.content === morphismId
+                    ),
+            );
+            if (value !== undefined) {
+                d.entries.push({
+                    subject: rowId,
+                    property: { tag: "MorphismRef", content: morphismId },
+                    value: encodeCellValue(value),
+                });
+            }
+        });
+    };
+
+    /**
+     * Delete a row: remove every triple whose subject is it (its `EntityOf`
+     * membership and the mapping/attribute triples drawn out of it). Triples in
+     * *other* rows referencing it (foreign keys pointing at it) are left in place
+     * and become invalid on the next {@link Instance.validate}, mirroring a
+     * deleted mapping target.
+     */
+    const deleteRow = (rowId: string): void => {
+        change((d) => {
+            d.entries = d.entries.filter((e) => e.subject !== rowId);
+        });
+    };
+
+    /** Build a row handle over the row with the given id. */
+    const rowHandle = (id: string): Row => ({
+        id,
+        set(morphism: { readonly id: string }, value?: RowValue) {
+            setValue(id, morphism.id, value);
+        },
+        delete() {
+            deleteRow(id);
+        },
+        get entity() {
+            const objectId = objectIdOfRow(id);
+            if (objectId === undefined) {
+                throw new Error(`Row "${id}" is not in the instance.`);
+            }
+            return schemaObjectCell(objectId);
+        },
+        get(morphism: { readonly id: string }): Row | string | undefined {
+            if (entityTripleOf(id) === undefined) {
+                return undefined;
+            }
+            const entry = morphismEntriesOf(id).find(
+                (e) => e.property.tag === "MorphismRef" && e.property.content === morphism.id,
+            );
+            // Only surface the value if the morphism is still a live schema
+            // morphism (a deleted column's data is retained but hidden).
+            if (!entry || !morphismById(morphism.id)) {
+                return undefined;
+            }
+            return entry.value.tag === "ObjectRef"
+                ? rowHandle(entry.value.content)
+                : String(entry.value.content);
+        },
+        get valuesById() {
+            const out: Record<string, Row | string> = {};
+            if (entityTripleOf(id) === undefined) {
+                return out;
+            }
+            for (const entry of morphismEntriesOf(id)) {
+                if (entry.property.tag !== "MorphismRef") {
+                    continue;
+                }
+                // A triple whose morphism is no longer a live schema morphism is
+                // retained in the document but omitted from the view, so a
+                // deleted column drops out without losing its data.
+                if (!morphismById(entry.property.content)) {
+                    continue;
+                }
+                out[entry.property.content] =
+                    entry.value.tag === "ObjectRef"
+                        ? rowHandle(entry.value.content)
+                        : String(entry.value.content);
+            }
+            return out;
+        },
+        get values() {
+            const out: Record<string, Row | string> = {};
+            if (entityTripleOf(id) === undefined) {
+                return out;
+            }
+            for (const entry of morphismEntriesOf(id)) {
+                // A triple whose morphism is no longer a live schema morphism is
+                // retained in the document but omitted from the view, so a
+                // deleted column drops out without losing its data.
+                if (entry.property.tag !== "MorphismRef") {
+                    continue;
+                }
+                const morphism = morphismById(entry.property.content);
+                if (!morphism) {
+                    continue;
+                }
+                // NOTE: keyed by morphism *name*, so two morphisms sharing a name
+                // collide here (last wins). For a UUID-keyed, collision-free read
+                // use `get(morphism)` or `valuesById`; the stored triples are
+                // always UUID-keyed and unaffected by this convenience view.
+                if (entry.value.tag === "ObjectRef") {
+                    out[morphism.name] = rowHandle(entry.value.content);
+                } else {
+                    out[morphism.name] = String(entry.value.content);
+                }
+            }
+            return out;
+        },
+    });
+
+    /**
+     * Elaborate the triples into the {@link DiagramJudgment}s a diagram-in-model
+     * would carry, so the instance validates through exactly the same catlog path
+     * a diagram does. Each `EntityOf` triple becomes an object judgment over its
+     * schema object; each `MorphismRef` triple becomes a morphism judgment over
+     * its schema morphism, from the row to either the referenced row (a mapping)
+     * or a freshly synthesized value object carrying the literal (an attribute).
+     *
+     * Rows over a deleted schema object, and triples over a deleted schema
+     * morphism, are skipped: retained data, but not part of the current
+     * instance's meaning.
+     */
+    const toDiagramJudgments = (): DiagramJudgment[] => {
+        const judgments: DiagramJudgment[] = [];
+        // Only rows over a live schema object contribute; note which those are so
+        // a triple whose row was skipped is skipped too.
+        const liveRows = new Set<string>();
+        for (const entry of doc.entries) {
+            if (entry.property.tag !== "EntityOf" || entry.value.tag !== "ObjectRef") {
+                continue;
+            }
+            const objectId = entry.value.content;
+            const objectJudgment = schemaObjectJudgment(objectId);
+            if (!objectJudgment) {
+                // The schema object is gone: keep the data, but it has no meaning
+                // in the current schema, so it contributes nothing to validate.
+                continue;
+            }
+            liveRows.add(entry.subject);
+            judgments.push({
+                tag: "object",
+                id: entry.subject,
+                name: "",
+                obType: objectJudgment.obType,
+                over: { tag: "Basic", content: objectId },
+            });
+        }
+        for (const entry of doc.entries) {
+            if (entry.property.tag !== "MorphismRef" || !liveRows.has(entry.subject)) {
+                continue;
+            }
+            const morphism = morphismById(entry.property.content);
+            if (!morphism) {
+                continue;
+            }
+            let cod: Ob | null;
+            if (entry.value.tag === "ObjectRef") {
+                cod = { tag: "Basic", content: entry.value.content };
+            } else {
+                // Materialize a value object for the literal so the attribute has
+                // a codomain object to point at, exactly as the schema morphism's
+                // codomain expects.
+                const valueId = v7();
+                const codObjectId = obRefId(morphism.cod);
+                const codObject =
+                    codObjectId !== undefined ? schemaObjectJudgment(codObjectId) : undefined;
+                judgments.push({
+                    tag: "object",
+                    id: valueId,
+                    name: String(entry.value.content),
+                    obType: codObject?.obType ?? { tag: "Basic", content: "" },
+                    over: codObjectId ? { tag: "Basic", content: codObjectId } : null,
+                });
+                cod = { tag: "Basic", content: valueId };
+            }
+            judgments.push({
+                tag: "morphism",
+                id: v7(),
+                name: "",
+                morType: morphism.morType,
+                over: { tag: "Basic", content: morphism.id },
+                dom: { tag: "Basic", content: entry.subject },
+                cod,
+            });
+        }
+        return judgments;
+    };
+
+    const onChangeFormalContent = (callback: () => void): (() => void) => {
+        const signature = () => JSON.stringify(doc.entries);
+        let previous = signature();
+        return store.subscribe(handle, () => {
+            const next = signature();
+            if (next !== previous) {
+                previous = next;
+                callback();
+            }
+        });
+    };
+
+    const instance = {
+        get name() {
+            return doc.name;
+        },
+        get theory() {
+            return doc.theory;
+        },
+        handle,
+        get document() {
+            return doc;
+        },
+        dump() {
+            return copy(doc);
+        },
+        update(u: { name?: string }) {
+            change((d) => {
+                Object.assign(d, u);
+            });
+        },
+        onChange(callback: () => void): () => void {
+            return store.subscribe(handle, callback);
+        },
+        onChangeFormalContent,
+        add(object: ObjectCell, args?: Record<string, RowValue>): Row {
+            return insertRow(object.id, args);
+        },
+        rows(): Row[] {
+            return doc.entries
+                .filter((e) => e.property.tag === "EntityOf" && e.value.tag === "ObjectRef")
+                .map((e) => rowHandle(e.subject));
+        },
+        rowsOf(object: ObjectCell): Row[] {
+            return doc.entries
+                .filter(
+                    (e) =>
+                        e.property.tag === "EntityOf" &&
+                        e.value.tag === "ObjectRef" &&
+                        e.value.content === object.id,
+                )
+                .map((e) => rowHandle(e.subject));
+        },
+        async validate(): Promise<DiagramValidationResult> {
+            return (await runValidation()).result;
+        },
+        onValidate(callback: (result: DiagramValidationResult) => void): () => void {
+            return createValidationObserver<DiagramValidationSnapshot>({
+                validate: async () => ({
+                    ...(await runValidation()),
+                    // The instance's own formal content is its entries, the same
+                    // signature `onChangeFormalContent` dedupes on.
+                    ownSignature: JSON.stringify(doc.entries),
+                }),
+                cache: modelCacheFor(store),
+                depRootId: doc.instanceOf._id,
+                subscribeOwn: onChangeFormalContent,
+                equivalent: sameDiagramValidation,
+                deliver: (snapshot) => callback(snapshot.result),
+            });
+        },
+    };
+
+    /**
+     * One validation run, also reporting the schema model it validated in (when
+     * resolution succeeded): {@link Instance.onValidate} compares that model's
+     * identity across runs, which the {@link DiagramValidationResult} alone
+     * cannot provide.
+     */
+    const runValidation = async (): Promise<{
+        result: DiagramValidationResult;
+        model: DblModel | undefined;
+    }> => {
+        const coreTheory = await resolveCoreTheory({
+            getCoreTheory: shape.diagramInCoreTheory,
+        });
+        if (!coreTheory) {
+            throw new Error(
+                "validate() needs the schema's core theory: this instance shape has " +
+                    "no `diagramInCoreTheory`.",
+            );
+        }
+        let model: DblModel;
+        try {
+            model = await resolveModelInStore(store, refFromLink(doc.instanceOf), coreTheory);
+        } catch (e) {
+            return {
+                result: { tag: "Illformed", diagram: null, error: String(e) },
+                model: undefined,
+            };
+        }
+        let diagram: DblModelDiagram;
+        try {
+            diagram = elaborateDiagram(toDiagramJudgments(), coreTheory);
+        } catch (e) {
+            return { result: { tag: "Illformed", diagram: null, error: String(e) }, model };
+        }
+        // NB: unlike the diagram notebook's `validate`, we deliberately do NOT
+        // call `diagram.inferMissingFrom(model)` here. For an instance, every
+        // mapping's codomain object should already exist — it is another row,
+        // which gets its own object judgment from its `EntityOf` triple. The
+        // only time an endpoint object is missing is when a mapping's target
+        // row was deleted (a dangling foreign key): inference would silently
+        // fabricate the missing object and heal the dangling ref, so the
+        // instance would validate as `Valid` despite the invalid reference the
+        // UI flags. Skipping inference lets `validateIn` surface it instead.
+        const result = diagram.validateIn(model);
+        if (result.tag === "Ok") {
+            return { result: { tag: "Valid", diagram }, model };
+        }
+        return { result: { tag: "Invalid", diagram, errors: result.content }, model };
+    };
+
+    if (isPlainStore) {
+        plainDocumentId(handle as Document);
+    }
+
+    return instance as unknown as Instance<TShape, Handle>;
+}
+
+function attachNotebook<TShape extends AnyShape, Handle>(
+    store: DocumentStore<Handle>,
+    handle: Handle,
+    shape: TShape,
+    // The model handle a diagram is drawn in. Required for diagram shapes (whose
+    // sole construction path, `createNotebook` with `in`, always has it), unused
+    // for model and analysis shapes.
+    modelHandle?: Handle,
+): Notebook<TShape, Handle> {
+    if (isAnalysisShape(shape)) {
+        return withShape(attachAnalysisNotebook(store, handle, shape), shape) as Notebook<
+            TShape,
+            Handle
+        >;
+    }
+    if (isDiagramShape(shape)) {
+        if (modelHandle === undefined) {
+            throw new Error("Diagram notebook requires the model handle it is drawn in.");
+        }
+        return withShape(
+            attachDiagramNotebook(store, handle, shape, modelHandle),
+            shape,
+        ) as Notebook<TShape, Handle>;
+    }
+    const doc = store.getDocumentView(handle) as ModelDocument;
+    const change = (fn: (doc: ModelDocument) => void) =>
+        store.changeDocument(handle, fn as (doc: Document) => void);
+    const copy = <T>(value: T): T => store.copyValue(handle, value);
+    const isPlainStore = (store as DocumentStore<unknown>) === plainStore;
+
+    const changeRichText = makeRichTextUpdater(change);
+
+    /**
+     * Elaborate this notebook's own model by minting a link to its own handle
+     * and resolving it through the shared resolver against the store. Resolution
+     * is the recursive workhorse — it walks this notebook's instantiations
+     * (resolving each via {@link DocumentStore.getHandle}) and elaborates each,
+     * along with this notebook itself, against the given `coreTheory` — so
+     * `validate` and `migrateTo` delegate here rather than building the
+     * instantiated map and elaborating themselves. Every instantiation is
+     * validatable against the host's core theory, so that single theory is
+     * threaded through the whole resolution tree. Returns the elaborated
+     * {@link DblModel}, or an error string when resolution rejects.
+     */
+    const resolveSelf = async (coreTheory: DblTheory): Promise<DblModel | { error: string }> => {
+        const ref = store.getDocumentRef(handle);
+        try {
+            return await resolveModelInStore(store, ref, coreTheory);
+        } catch (e) {
+            // Surface the error's own message (e.g. a CyclicInstantiationError's
+            // named cycle) rather than `String(e)`, which prepends a noisy
+            // `Error:` and buries the actionable text.
+            return { error: e instanceof Error ? e.message : String(e) };
+        }
+    };
+
+    /** Read a cell's content, or `undefined` if the cell is no longer in the
+    notebook (e.g. it was deleted after the handle was obtained). Reads off a
+    stale handle thus yield `undefined` rather than throwing. */
+    const readCellContent = <T>(cellId: string): T | undefined => {
+        const cell = doc.notebook.cellContents[cellId];
+        if (!cell) {
+            return undefined;
+        }
+        return (cell as unknown as { content: T }).content;
+    };
+
+    const cloneJudgment = (judgment: ModelJudgment): ModelJudgment =>
+        duplicateModelJudgment(copy(judgment));
+
+    const linkForModel = (model: ValidatableNotebook<Handle> | null): Link | null => {
+        if (model === null) {
+            return null;
+        }
+        return linkFromRef(store.getDocumentRef(model.handle), "instantiation");
+    };
+
+    const encodeSpecializations = (
+        specializations: readonly InstantiationSpecialization[] | undefined,
+    ): SpecializeModel[] =>
+        (specializations ?? []).map((specialization) => ({
+            id: specialization.object.id,
+            ob: encodeObjectRef(specialization.as),
+        }));
+
+    const duplicateFormalCell = (cellId: string): Cell<ModelJudgment> => {
+        const cell = doc.notebook.cellContents[cellId];
+        if (!cell) {
+            throw new Error(`Failed to find notebook cell contents for cell '${cellId}'`);
+        }
+        return duplicateCell(cell, cloneJudgment);
+    };
+
+    const appendDuplicate = (cellId: string): string => {
+        const duplicatedCell = duplicateFormalCell(cellId);
+        change((d) => {
+            d.notebook.cellContents[duplicatedCell.id] = duplicatedCell;
+            d.notebook.cellOrder.push(duplicatedCell.id);
+        });
+        return duplicatedCell.id;
+    };
+
+    /** Move a cell, locating it by id inside the change so stale indices
+    cannot misplace it. The target index is interpreted after removal and
+    clamped to the valid range; impossible moves are silent no-ops. */
+    const moveCell = (cellId: string, target: (from: number) => number) =>
+        change((d) => {
+            const order = d.notebook.cellOrder;
+            const from = order.indexOf(cellId);
+            if (from < 0) {
+                return;
+            }
+            const to = Math.max(0, Math.min(target(from), order.length - 1));
+            if (to === from) {
+                return;
+            }
+            order.splice(from, 1);
+            order.splice(to, 0, cellId);
+        });
+
+    const deleteCell = (cellId: string) =>
+        change((d) => {
+            const order = d.notebook.cellOrder;
+            const from = order.indexOf(cellId);
+            if (from < 0) {
+                return;
+            }
+            order.splice(from, 1);
+            delete d.notebook.cellContents[cellId];
+        });
+
+    const reorderMethods = (cellId: string): Reorder => ({
+        moveUp: () => moveCell(cellId, (from) => from - 1),
+        moveDown: () => moveCell(cellId, (from) => from + 1),
+        moveTo: (index: number) => moveCell(cellId, () => index),
+        delete: () => deleteCell(cellId),
+    });
+
+    const objectHandle = <Def extends ObjectDef>(cellId: string, type: Def): ObjectCell<Def> =>
+        ({
+            kind: CellKind.Object,
+            get id() {
+                return readCellContent<{ id: string }>(cellId)?.id;
+            },
+            type,
+            get label() {
+                return readCellContent<{ name: string }>(cellId)?.name;
+            },
+            update(u: { label?: string }) {
+                // Re-check the partial update at runtime: the typed `update`
+                // rejects field mistakes at compile time, but an untyped
+                // (plain-JS) caller bypasses that, so validate here and throw a
+                // `ValidationError` rather than silently writing a corrupt cell.
+                validateUpdateArgs(type, u);
+                change((d) => {
+                    const content = (
+                        d.notebook.cellContents[cellId] as { content: { name: string } }
+                    ).content;
+                    // Map the public `label` field to the stored `name` key.
+                    if (u.label !== undefined) {
+                        content.name = u.label;
+                    }
+                });
+            },
+            duplicate() {
+                return objectHandle(appendDuplicate(cellId), type);
+            },
+            ...reorderMethods(cellId),
+        }) as unknown as ObjectCell<Def>;
+
+    /**
+     * The object cell for a generator id, or `undefined` if no live object cell
+     * has that id. An endpoint can dangle: a morphism keeps referencing an object
+     * that has since been deleted (e.g. a mapping whose codomain entity was
+     * removed). That is a valid transient schema state — reading the endpoint
+     * must degrade gracefully (the dangling reference is simply omitted) rather
+     * than throw and crash every consumer that reads `.from` / `.to`.
+     */
+    const objectHandleForId = (objectId: string): ObjectCell | undefined => {
+        for (const candidateCellId of doc.notebook.cellOrder) {
+            const cell = doc.notebook.cellContents[candidateCellId];
+            if (cell?.tag !== "formal" || cell.content.tag !== "object") {
+                continue;
+            }
+            if (cell.content.id === objectId) {
+                return objectHandle(candidateCellId, defineObject(cell.content.obType));
+            }
+        }
+        return undefined;
+    };
+
+    /** Flatten any stored endpoint object into the object-cell handles it
+    references, regardless of tensor/list wrapping. A dangling reference (an id
+    with no live object cell) is skipped. */
+    const decodeEndpointObjects = (value: Ob | null): ObjectCell[] => {
+        if (!value) {
+            return [];
+        }
+        switch (value.tag) {
+            case "Basic": {
+                const cell = objectHandleForId(value.content);
+                return cell ? [cell] : [];
+            }
+            case "App":
+                return decodeEndpointObjects(value.content.ob);
+            case "List":
+                return value.content.objects.flatMap((item) => decodeEndpointObjects(item));
+            case "Tabulated":
+                return [];
+        }
+    };
+
+    /** Decode a stored endpoint, choosing array vs single shape from the
+    morphism's declared modality rather than from the stored value's shape. */
+    const decodeEndpoint = (
+        modality: Modality | null,
+        value: Ob | null,
+    ): ObjectCell | ObjectCell[] => {
+        const objects = decodeEndpointObjects(value);
+        if (modality !== null) {
+            return objects;
+        }
+        return objects[0] as ObjectCell;
+    };
+
+    const morphismHandle = <Def extends MorphismDef>(
+        cellId: string,
+        type: Def,
+    ): MorphismCell<Def> =>
+        ({
+            kind: CellKind.Morphism,
+            get id() {
+                return readCellContent<{ id: string }>(cellId)?.id;
+            },
+            type,
+            get label() {
+                return readCellContent<{ name: string }>(cellId)?.name;
+            },
+            get from() {
+                const content = readCellContent<{ dom: Ob | null }>(cellId);
+                return content && decodeEndpoint(type.domain?.modality ?? null, content.dom);
+            },
+            get to() {
+                const content = readCellContent<{ cod: Ob | null }>(cellId);
+                return content && decodeEndpoint(type.codomain?.modality ?? null, content.cod);
+            },
+            update(u: { label?: string; from?: unknown; to?: unknown }) {
+                // Re-check the partial update at runtime: the typed `update`
+                // rejects endpoint mistakes at compile time, but an untyped
+                // (plain-JS) caller bypasses that, so validate here and throw a
+                // `ValidationError` rather than silently writing a corrupt cell.
+                validateUpdateArgs(type, u);
+                change((d) => {
+                    const content = (
+                        d.notebook.cellContents[cellId] as {
+                            content: { name: string; dom: Ob | null; cod: Ob | null };
+                        }
+                    ).content;
+                    if (u.label !== undefined) {
+                        content.name = u.label;
+                    }
+                    if ("from" in u) {
+                        content.dom = encodeEndpoint(
+                            type.domain?.apply ?? null,
+                            type.domain?.modality ?? null,
+                            u.from,
+                        );
+                    }
+                    if ("to" in u) {
+                        content.cod = encodeEndpoint(
+                            type.codomain?.apply ?? null,
+                            type.codomain?.modality ?? null,
+                            u.to,
+                        );
+                    }
+                });
+            },
+            duplicate() {
+                return morphismHandle(appendDuplicate(cellId), type);
+            },
+            ...reorderMethods(cellId),
+        }) as unknown as MorphismCell<Def>;
+
+    /**
+     * Reconstruct a stored morphism judgment's {@link MorphismDef}, recovering
+     * each list endpoint's `apply` op and modality from the stored
+     * `App(apply, List(modality, …))` — inverting the encoding in
+     * `encodeEndpoint` — so the reconstructed def matches the one its
+     * {@link MorphismDef} declares (see `cellsOf`).
+     */
+    const morphismDefForJudgment = (judgment: {
+        morType: MorType;
+        dom: Ob | null;
+        cod: Ob | null;
+    }): MorphismDef => {
+        const endpointMeta = (ob: Ob | null): MorEndpointMeta | undefined => {
+            const apply = endpointApplyOp(ob);
+            return apply ? { apply, modality: endpointListModality(ob) ?? undefined } : undefined;
+        };
+        return {
+            tag: "morphism",
+            morType: judgment.morType,
+            domain: endpointMeta(judgment.dom),
+            codomain: endpointMeta(judgment.cod),
+        };
+    };
+
+    /**
+     * The morphism cell for a generator id, or `undefined` if no live morphism
+     * cell has that id — the morphism-side counterpart of
+     * {@link objectHandleForId}. An equation's path can dangle: it keeps
+     * referencing a morphism that has since been deleted. That is a valid
+     * transient state — reading the path must degrade gracefully (the dangling
+     * reference is simply omitted) rather than throw.
+     */
+    const morphismHandleForId = (morphismId: string): MorphismCell | undefined => {
+        for (const candidateCellId of doc.notebook.cellOrder) {
+            const cell = doc.notebook.cellContents[candidateCellId];
+            if (cell?.tag !== "formal" || cell.content.tag !== "morphism") {
+                continue;
+            }
+            if (cell.content.id === morphismId) {
+                return morphismHandle(candidateCellId, morphismDefForJudgment(cell.content));
+            }
+        }
+        return undefined;
+    };
+
+    /**
+     * Decode a stored equation side into the morphism cells its path
+     * references, in composition order: a bare morphism is a one-step path and
+     * a `Composite` sequence contributes its steps. A dangling reference (an id
+     * with no live morphism cell) is skipped; an identity path (`Id`) or any
+     * other morphism expression contributes no steps.
+     */
+    const decodePath = (mor: Mor | null | undefined): MorphismCell[] => {
+        if (!mor) {
+            return [];
+        }
+        switch (mor.tag) {
+            case "Basic": {
+                const cell = morphismHandleForId(mor.content);
+                return cell ? [cell] : [];
+            }
+            case "Composite":
+                return mor.content.tag === "Seq"
+                    ? mor.content.content.flatMap((step) => decodePath(step))
+                    : [];
+            default:
+                return [];
+        }
+    };
+
+    /**
+     * Encode a path of morphism cells as a stored equation side: an empty (or
+     * `null`) path is `null` (an unset side), a single step is stored as the
+     * bare morphism, and a longer path as a `Composite` sequence — the same
+     * convention the frontend equation editor persists.
+     */
+    const encodePath = (
+        cells: readonly { readonly id: string }[] | null | undefined,
+    ): Mor | null => {
+        const steps = (cells ?? []).map((cell): Mor => ({ tag: "Basic", content: cell.id }));
+        if (steps.length === 0) {
+            return null;
+        }
+        const first = steps[0];
+        if (steps.length === 1 && first) {
+            return first;
+        }
+        return { tag: "Composite", content: { tag: "Seq", content: steps } };
+    };
+
+    const pathEquationHandle = (cellId: string): PathEquationCell =>
+        ({
+            kind: CellKind.PathEquation,
+            get id() {
+                return readCellContent<{ id: string }>(cellId)?.id;
+            },
+            get label() {
+                return readCellContent<{ name: string }>(cellId)?.name;
+            },
+            get lhs() {
+                return decodePath(readCellContent<{ lhs: Mor | null }>(cellId)?.lhs);
+            },
+            get rhs() {
+                return decodePath(readCellContent<{ rhs: Mor | null }>(cellId)?.rhs);
+            },
+            update(u: Partial<PathEquationArgs>) {
+                // Re-check the partial update at runtime: the typed `update`
+                // rejects path mistakes at compile time, but an untyped
+                // (plain-JS) caller bypasses that, so validate here and throw a
+                // `ValidationError` rather than silently writing a corrupt cell.
+                validatePathEquationUpdateArgs(u);
+                change((d) => {
+                    const content = (
+                        d.notebook.cellContents[cellId] as {
+                            content: { name: string; lhs: Mor | null; rhs: Mor | null };
+                        }
+                    ).content;
+                    if (u.label !== undefined) {
+                        content.name = u.label ?? "";
+                    }
+                    if ("lhs" in u) {
+                        content.lhs = encodePath(u.lhs);
+                    }
+                    if ("rhs" in u) {
+                        content.rhs = encodePath(u.rhs);
+                    }
+                });
+            },
+            duplicate() {
+                return pathEquationHandle(appendDuplicate(cellId));
+            },
+            ...reorderMethods(cellId),
+        }) as unknown as PathEquationCell;
+
+    const richTextHandle = (cellId: string): RichTextCell =>
+        ({
+            kind: CellKind.RichText,
+            id: cellId,
+            get content() {
+                return readCellContent<RichTextContent>(cellId);
+            },
+            get editorRef() {
+                return store.getRichTextRef?.(handle, cellId);
+            },
+            update(u: { content?: RichTextContent }) {
+                changeRichText(cellId, u);
+            },
+            ...reorderMethods(cellId),
+        }) as unknown as RichTextCell;
+
+    const instantiationHandle = (cellId: string): InstantiationCell<Handle> =>
+        ({
+            kind: CellKind.Instantiation,
+            get id() {
+                return readCellContent<{ id: string }>(cellId)?.id;
+            },
+            get label() {
+                return readCellContent<{ name: string }>(cellId)?.name;
+            },
+            get model() {
+                return readCellContent<{ model: Link | null }>(cellId)?.model;
+            },
+            get specializations() {
+                return readCellContent<{ specializations: SpecializeModel[] }>(cellId)
+                    ?.specializations;
+            },
+            update(u: Partial<InstantiationArgs<Handle>>) {
+                change((d) => {
+                    const content = (
+                        d.notebook.cellContents[cellId] as {
+                            content: {
+                                name: string;
+                                model: Link | null;
+                                specializations: SpecializeModel[];
+                            };
+                        }
+                    ).content;
+                    if (u.label !== undefined) {
+                        content.name = u.label;
+                    }
+                    if ("model" in u) {
+                        content.model = linkForModel(u.model ?? null);
+                    }
+                    if ("specializations" in u) {
+                        content.specializations = encodeSpecializations(u.specializations);
+                    }
+                });
+            },
+            duplicate() {
+                return instantiationHandle(appendDuplicate(cellId));
+            },
+            ...reorderMethods(cellId),
+        }) as unknown as InstantiationCell<Handle>;
+
+    const isShapeMorphism = (def: MorphismDef): boolean =>
+        (shape.morphisms ?? []).some((t) => sameMorphismType(t, def));
+
+    const isShapeObject = (def: ObjectDef): boolean =>
+        (shape.objects ?? []).some((t) => sameTypeValue(t, def));
+
+    const addObjectCell = (def: ObjectDef, label: string): ObjectCell => {
+        const judgment = newObjectDecl(def.obType);
+        judgment.name = label;
+        const formalCell = newFormalCell(judgment);
+        change((d) => {
+            d.notebook.cellContents[formalCell.id] = formalCell;
+            d.notebook.cellOrder.push(formalCell.id);
+        });
+        return objectHandle(formalCell.id, def);
+    };
+
+    const addMorphismCell = (
+        def: MorphismDef,
+        args: { label: string | null; from?: unknown; to?: unknown },
+    ): MorphismCell => {
+        const judgment = newMorphismDecl(def.morType);
+        judgment.name = args.label ?? "";
+        judgment.dom = encodeEndpoint(
+            def.domain?.apply ?? null,
+            def.domain?.modality ?? null,
+            args.from,
+        );
+        judgment.cod = encodeEndpoint(
+            def.codomain?.apply ?? null,
+            def.codomain?.modality ?? null,
+            args.to,
+        );
+        const formalCell = newFormalCell(judgment);
+        change((d) => {
+            d.notebook.cellContents[formalCell.id] = formalCell;
+            d.notebook.cellOrder.push(formalCell.id);
+        });
+        return morphismHandle(formalCell.id, def);
+    };
+
+    const addInstantiationCell = (args: InstantiationArgs<Handle>): InstantiationCell<Handle> => {
+        const judgment = newInstantiatedModel(linkForModel(args.model));
+        judgment.name = args.label;
+        judgment.specializations = encodeSpecializations(args.specializations);
+        const formalCell = newFormalCell(judgment);
+        change((d) => {
+            d.notebook.cellContents[formalCell.id] = formalCell;
+            d.notebook.cellOrder.push(formalCell.id);
+        });
+        return instantiationHandle(formalCell.id);
+    };
+
+    const addPathEquationCell = (args: PathEquationArgs): PathEquationCell => {
+        const judgment = newEquationDecl();
+        judgment.name = args.label ?? "";
+        judgment.lhs = encodePath(args.lhs);
+        judgment.rhs = encodePath(args.rhs);
+        const formalCell = newFormalCell(judgment);
+        change((d) => {
+            d.notebook.cellContents[formalCell.id] = formalCell;
+            d.notebook.cellOrder.push(formalCell.id);
+        });
+        return pathEquationHandle(formalCell.id);
+    };
+
+    const impl = {
+        get name() {
+            return doc.name;
+        },
+        handle,
+        get document() {
+            return doc;
+        },
+        dump() {
+            return copy(doc);
+        },
+        onChange(callback: () => void): () => void {
+            return store.subscribe(handle, callback);
+        },
+        onChangeFormalContent(callback: () => void): () => void {
+            const signature = () => formalCellsSignature(doc);
+            let previous = signature();
+            return impl.onChange(() => {
+                const next = signature();
+                if (next !== previous) {
+                    previous = next;
+                    callback();
+                }
+            });
+        },
+        async validate(): Promise<ModelValidationResult> {
+            const theory = await resolveCoreTheory(shape);
+            if (!theory) {
+                throw new Error(
+                    "validate() needs a core theory: this shape has no `getCoreTheory`.",
+                );
+            }
+            // Delegate elaboration to the store: mint a link to this notebook's
+            // own handle and resolve it. The store walks this notebook's
+            // instantiations (resolving each recursively) and elaborates against
+            // the registered core theory. A successfully elaborated and
+            // validated model is an `Ok`; a model that fails validation, or
+            // one that fails to even elaborate, is an `Err` carrying issues.
+            const resolved = await resolveSelf(theory);
+            if ("error" in resolved) {
+                return { tag: "Err", content: [{ message: resolved.error }] };
+            }
+            const model = resolved;
+            // Memoized per model object: a cached model keeps its outcome until
+            // an edit re-elaborates it into a new object.
+            const result = validateModelCached(model);
+            if (result.tag === "Ok") {
+                return { tag: "Ok", content: model };
+            }
+            return { tag: "Err", content: result.content.map(modelErrorToIssue) };
+        },
+        onValidate(callback: (result: ModelValidationResult) => void): () => void {
+            return createValidationObserver<ModelValidationResult>({
+                validate: () => impl.validate(),
+                cache: modelCacheFor(store),
+                depRootId: store.getDocumentRef(handle).id,
+                subscribeOwn: (cb) => impl.onChangeFormalContent(cb),
+                equivalent: sameModelValidation,
+                deliver: callback,
+            });
+        },
+        async migrateTo<TTarget extends CreatableShape>(targetShape: TTarget) {
+            // Trivial migration: an empty notebook or an inclusion target only
+            // needs its theory rewritten; cell types are left untouched.
+            const hasFormalCells = doc.notebook.cellOrder.some(
+                (cellId) => doc.notebook.cellContents[cellId]?.tag === "formal",
+            );
+            const isInclusion = (shape.inclusions ?? []).includes(targetShape.theory);
+            if (!hasFormalCells || isInclusion) {
+                change((d) => {
+                    d.theory = targetShape.theory;
+                    delete d.editorVariant;
+                });
+                return { tag: "Ok", content: attachNotebook(store, handle, targetShape) };
+            }
+
+            // Pushforward migration: transport the elaborated model along the
+            // theory morphism, then re-type each cell from the migrated model.
+            const migration = (shape.migrations ?? []).find((m) => m.target === targetShape.theory);
+            if (!migration) {
+                return {
+                    tag: "Err",
+                    content: [
+                        {
+                            message: `No migration defined from "${shape.theory}" to "${targetShape.theory}".`,
+                        },
+                    ],
+                };
+            }
+            const sourceCoreTheory = await resolveCoreTheory(shape);
+            const targetCoreTheory = await resolveCoreTheory(targetShape);
+            if (!sourceCoreTheory || !targetCoreTheory) {
+                return {
+                    tag: "Err",
+                    content: [
+                        {
+                            message:
+                                "Migration needs the source and target core theories; one shape has none.",
+                        },
+                    ],
+                };
+            }
+
+            // Obtain the source model through the store (same recursive
+            // resolution as `validate`), then transport it along the morphism.
+            const resolved = await resolveSelf(sourceCoreTheory);
+            if ("error" in resolved) {
+                return {
+                    tag: "Err",
+                    content: [
+                        {
+                            message:
+                                `Cannot migrate notebook from "${shape.theory}" to ` +
+                                `"${targetShape.theory}": ${resolved.error}`,
+                        },
+                    ],
+                };
+            }
+            const model = resolved;
+
+            const migrated = await migration.migrate(model, targetCoreTheory);
+            change((d) => {
+                d.theory = targetShape.theory;
+                delete d.editorVariant;
+                for (const cellId of d.notebook.cellOrder) {
+                    const cell = d.notebook.cellContents[cellId];
+                    if (!cell || cell.tag !== "formal") {
+                        continue;
+                    }
+                    const judgment = cell.content as ModelJudgment;
+                    if (judgment.tag === "object") {
+                        judgment.obType = migrated.obType({ tag: "Basic", content: judgment.id });
+                    } else if (judgment.tag === "morphism") {
+                        judgment.morType = migrated.morType({ tag: "Basic", content: judgment.id });
+                    }
+                }
+            });
+            return { tag: "Ok", content: attachNotebook(store, handle, targetShape) };
+        },
+        update(u: { name?: string }) {
+            change((d) => {
+                Object.assign(d, u);
+            });
+        },
+        supports(arg: ObjectDef | MorphismDef | AnyShape): boolean {
+            // A def carries an "object"/"morphism" `tag`; a shape does not.
+            if ("tag" in arg) {
+                return arg.tag === "object" ? isShapeObject(arg) : isShapeMorphism(arg);
+            }
+            return (
+                (arg.objects ?? []).every((t) => isShapeObject(t)) &&
+                (arg.morphisms ?? []).every((t) => isShapeMorphism(t))
+            );
+        },
+        cells(): Array<NotebookCell> {
+            return doc.notebook.cellOrder.map((cellId) => {
+                const cell = doc.notebook.cellContents[cellId];
+                if (!cell) {
+                    throw new Error(`Failed to find notebook cell contents for cell '${cellId}'`);
+                }
+                if (cell.tag === "rich-text") {
+                    return richTextHandle(cellId);
+                }
+                const judgment = cell.content as ModelJudgment;
+                switch (judgment.tag) {
+                    case "object":
+                        return objectHandle(cellId, defineObject(judgment.obType));
+                    case "morphism":
+                        return morphismHandle(cellId, morphismDefForJudgment(judgment));
+                    case "instantiation":
+                        return instantiationHandle(cellId);
+                    case "equation":
+                        return pathEquationHandle(cellId);
+                    default:
+                        // Every judgment tag is handled above; guard against a
+                        // document written by a newer version at runtime.
+                        throw new Error(
+                            `Unsupported judgment tag: ${(judgment as { tag: string }).tag}`,
+                        );
+                }
+            });
+        },
+        formalCells(): Array<Exclude<NotebookCell, RichTextCell>> {
+            return impl.cells().filter((cell) => cell.kind !== CellKind.RichText) as Array<
+                Exclude<NotebookCell, RichTextCell>
+            >;
+        },
+        cellsOf(
+            arg:
+                | RichTextType
+                | InstantiationType
+                | PathEquationType
+                | ObjectDef
+                | MorphismDef
+                | AnyShape,
+        ): Array<NotebookCell> {
+            // `RichText` selects just the rich-text cells.
+            if (isRichTextType(arg)) {
+                return impl.cells().filter((cell) => cell.kind === CellKind.RichText);
+            }
+            if (isInstantiationType(arg)) {
+                return impl.cells().filter((cell) => cell.kind === CellKind.Instantiation);
+            }
+            if (isPathEquationType(arg)) {
+                return impl.cells().filter((cell) => cell.kind === CellKind.PathEquation);
+            }
+            // A def carries an "object"/"morphism" `tag`; a shape does not. A
+            // single def selects only its own cells (rich-text excluded); a
+            // shape includes rich-text cells only when it opts in with
+            // `informal: [RichText]`, and path-equation cells only when it
+            // opts in with `supportsEquations: true`.
+            const isDef = "tag" in arg;
+            const shape: AnyShape = isDef
+                ? arg.tag === "object"
+                    ? { objects: [arg] }
+                    : { morphisms: [arg] }
+                : arg;
+            const objectDefs = shape.objects ?? [];
+            const morphismDefs = shape.morphisms ?? [];
+            const includeRichText = !isDef && shape.informal?.some(isRichTextType) === true;
+            const includePathEquations = !isDef && shape.supportsEquations === true;
+            return impl.cells().filter((cell) => {
+                if (cell.kind === CellKind.RichText) {
+                    return includeRichText;
+                }
+                if (cell.kind === CellKind.PathEquation) {
+                    return includePathEquations;
+                }
+                if (cell.kind === CellKind.Object) {
+                    const type = (cell as { type?: unknown }).type;
+                    return objectDefs.some((def) => sameTypeValue(type, def));
+                }
+                if (cell.kind === CellKind.Morphism) {
+                    const type = (cell as { type?: MorphismDef }).type;
+                    return (
+                        type !== undefined &&
+                        morphismDefs.some((def) => sameMorphismType(type, def))
+                    );
+                }
+                return false;
+            });
+        },
+        get(
+            arg: RichTextType | InstantiationType | PathEquationType | ObjectDef | MorphismDef,
+            id: string,
+        ): Result<NotebookCell> {
+            const cell = impl.cellsOf(arg).find((cell) => cell.id === id);
+            if (cell !== undefined) {
+                return { tag: "Ok", content: cell };
+            }
+            const existsWithOtherType = impl
+                .cells()
+                .some((other) => (other as { id: string }).id === id);
+            return {
+                tag: "Err",
+                content: [
+                    existsWithOtherType
+                        ? {
+                              message: `Cell "${id}" is not of the expected type.`,
+                              path: ["id"],
+                          }
+                        : { message: `No cell with id "${id}".`, path: ["id"] },
+                ],
+            };
+        },
+        add(
+            type: unknown,
+            args: {
+                content?: RichTextContent;
+                label?: string;
+                from?: unknown;
+                to?: unknown;
+                lhs?: unknown;
+                rhs?: unknown;
+                model?: ValidatableNotebook<Handle> | null;
+                specializations?: readonly InstantiationSpecialization[];
+            },
+        ) {
+            if (isRichTextType(type)) {
+                const cell = newRichTextCell((args as { content?: RichTextContent })?.content);
+                change((d) => {
+                    d.notebook.cellContents[cell.id] = cell;
+                    d.notebook.cellOrder.push(cell.id);
+                });
+                return richTextHandle(cell.id);
+            }
+            if (isInstantiationType(type)) {
+                return addInstantiationCell(args as InstantiationArgs<Handle>);
+            }
+            if (isPathEquationType(type)) {
+                // The typed `add` already rejects this at compile time (see
+                // `HasPathEquations`); re-check at runtime for plain-JS callers.
+                if (shape.supportsEquations !== true) {
+                    throw new ValidationError([
+                        {
+                            message:
+                                "This notebook's shape does not declare path equations; " +
+                                "declare `supportsEquations: true` on the shape to add them.",
+                        },
+                    ]);
+                }
+                validatePathEquationAddArgs(args);
+                return addPathEquationCell(args as PathEquationArgs);
+            }
+            const def = type as ObjectDef | MorphismDef;
+            // Re-check the arguments at runtime: the typed `add` rejects endpoint
+            // mistakes at compile time, but an untyped (plain-JS) caller bypasses
+            // that, so validate here and throw a `ValidationError` rather than
+            // silently writing a corrupt cell.
+            validateAddArgs(def, args);
+            if (def.tag === "morphism") {
+                return addMorphismCell(def, args as { label: string | null });
+            }
+            return addObjectCell(def, (args as { label: string }).label);
+        },
+    };
+
+    const notebook = withShape(impl, shape) as unknown as Notebook<TShape, Handle>;
+
+    if (isPlainStore) {
+        // Ensure the document is reachable by id for the plain store's resolver.
+        plainDocumentId(handle as Document);
+    }
+
+    return notebook;
+}
+
+/**
+ * A notebook built over a {@link Shape}. The shape constrains the typed {@link
+ * Notebook.add} constructor to the shape's cell types; reading via {@link
+ * Notebook.cells} yields the shape-parametrized {@link NotebookCell} union,
+ * with each declared object/morphism type contributing its own precise handle.
+ *
+ * A notebook over a richer shape is assignable to a notebook over a sub-shape,
+ * so a fully-interactive component can be written against a sub-shape (e.g.
+ * `Notebook<typeof PlacesShape>`) and handed a notebook of the full theory.
+ */
+// oxlint-disable-next-line typescript/no-explicit-any
+export type Notebook<TShape extends AnyShape = AnyShape, Handle = any> = Update<{
+    name: string;
+}> &
+    NotebookMethods<TShape, Handle> &
+    CoreTheoryMethods<TShape, Handle> &
+    AnalysisMethods<TShape> &
+    DiagramMethods<TShape>;
+
+/**
+ * The object-literal surface of a {@link Notebook}, extracted into an interface
+ * so its type-guard methods (`supports`) can narrow via `this` rather than
+ * re-expanding `Notebook<TShape, Handle>`. Re-expanding the full notebook
+ * reintroduces the core-theory-gated `validate`/`migrateTo` (see {@link
+ * CoreTheoryMethods}) into the guard's narrowed type, which makes a
+ * getCoreTheory-less picker notebook's `supports` incompatible with a
+ * core-theory notebook's — breaking the "richer notebook into a sub-shape"
+ * assignability the phantom shape bounds otherwise grant. Narrowing to `this`
+ * instead keeps the guard tied to whatever the notebook actually is (including
+ * any `& ValidatableNotebook` intersection at the use site), so assignability is
+ * decided by the phantom bounds alone.
+ */
+// oxlint-disable-next-line typescript/no-explicit-any
+interface NotebookMethods<TShape extends AnyShape = AnyShape, Handle = any> {
+    /**
+     * Phantom carrier of the shape's declared *object* types, present only in
+     * the type: the runtime object never provides it. It exists so shape
+     * assignability is decided by the declared cell types rather than collapsing
+     * under the method-bivariance of the rest of the surface. Its type is a
+     * *bivariant* function over the declared object defs (see {@link
+     * ObjectShapeBound}): a notebook is assignable to another when its declared
+     * object types are a subset of, or a superset of, the target's. Over a
+     * union of shapes the bound distributes into one bound per member, so a
+     * notebook is accepted when it matches *some* member of the union — e.g. a
+     * schema notebook declaring `{Entity, AttrType}` matches a union member
+     * declaring just `{Entity}`. Objects and morphisms are carried on
+     * *separate* members (see {@link __morphismShapeBound}) so the two axes are
+     * related independently — a notebook that declares a superset of the
+     * target's objects (extra object types alongside the shared ones) and a
+     * subset of its morphisms is still accepted, rather than being rejected
+     * because the combined type set is neither subset nor superset.
+     */
+    readonly __objectShapeBound?: ObjectShapeBound<TShape>;
+    /**
+     * Phantom carrier of the shape's declared *morphism* types; the morphism-side
+     * counterpart of {@link __objectShapeBound}, compared bivariantly the same
+     * way. Relating morphisms independently of objects is what rejects a notebook
+     * whose morphisms are foreign to the target (e.g. `SimpleOlog`, whose
+     * `Hom`-over-`Basic` aspect is neither a subset nor a superset of a list
+     * shape's morphisms) while accepting one that merely adds extra object types.
+     */
+    readonly __morphismShapeBound?: MorphismShapeBound<TShape>;
+    /**
+     * Phantom carrier of whether the shape declares any morphism type, present
+     * only in the type. It complements {@link __morphismShapeBound}: bivariance
+     * relates declared morphisms by subset/superset, and the empty set is a
+     * subset of everything, so a notebook declaring *no* morphisms would slip
+     * through (its empty morphism set never produces the foreign type the
+     * bivariance check rejects). This member closes that gap: a target whose
+     * shape declares morphisms types it as the literal `true`, which a
+     * morphism-free shape (typed `boolean`) cannot satisfy, so handing an
+     * objects-only notebook to code that must add a morphism is rejected. A
+     * target with no morphisms types it as `boolean` and still accepts any
+     * notebook, preserving the "richer notebook into a sub-shape" assignability.
+     */
+    readonly __morphismBound?: DeclaresMorphism<TShape> extends true ? true : boolean;
+    /**
+     * Object-side dual of {@link __morphismBound}: requires that a notebook
+     * handed to code expecting objects actually declares some. A target whose
+     * shape declares object types types this as the literal `true`, which an
+     * object-free shape (typed `boolean`) cannot satisfy, so handing a
+     * morphisms-only notebook to code that must add an object is rejected. A
+     * target with no objects types it as `boolean` and accepts any notebook.
+     */
+    readonly __objectBound?: DeclaresObject<TShape> extends true ? true : boolean;
+    /** Reactive read of the notebook's name. */
+    readonly name: string;
+    /**
+     * The store handle this notebook is bound to, e.g. an Automerge
+     * `DocHandle`. With the plain in-memory store it is the document itself.
+     */
+    readonly handle: Handle;
+    /**
+     * The underlying document. With a reactive store (Solid, Automerge), this
+     * is the reactive proxy; with the plain in-memory store it is the raw
+     * object. Its type follows the shape: an analysis shape yields an {@link
+     * AnalysisDocument}, any other shape a {@link ModelDocument}.
+     */
+    readonly document: DocumentOf<TShape>;
+    /** Make a detached plain-JS snapshot of the underlying document. */
+    dump(): DocumentOf<TShape>;
+    /**
+     * Subscribe to changes to this notebook's document. The callback fires after
+     * each change — including remote changes from other collaborators where the
+     * store supports it (e.g. an Automerge `DocHandle`'s `change` event) — and
+     * takes no arguments, so re-read whatever notebook state you need inside it.
+     * Returns an unsubscribe function that removes the listener.
+     *
+     * This is the change source to drive a validation `createResource` off:
+     * reading `formalCells()` directly as a resource source re-validates on every
+     * tracked change because it rebuilds a fresh array each call (so it never
+     * compares equal). Instead, bump a signal from `onChange` and key the
+     * fetcher on a stable signature (e.g. the formal-cell ids), so unrelated
+     * edits — such as adding a rich-text comment — do not re-validate.
+     *
+     * Every store implements {@link DocumentStore.subscribe}, so this always
+     * fires for local mutations, and for remote changes where the store has a
+     * remote source.
+     */
+    onChange(callback: () => void): () => void;
+    /**
+     * Subscribe to changes to the notebook's *formal* content. The callback
+     * fires only when a formal cell is added, removed, reordered, or edited in
+     * place, and is skipped for changes that leave the formal cells intact, such
+     * as adding or editing a {@link RichText} comment.
+     *
+     * It is the ready-made source for a validation `createResource`: unlike
+     * {@link Notebook.onChange}, which fires on every change, this dedupes on a
+     * signature of the formal cells (their ids, order, and serialized content),
+     * so wiring it to bump a signal re-validates only when the formal content
+     * actually changes. It is built on `onChange` (and so also reacts to remote
+     * edits where the store supports them); a store with no change source leaves
+     * it a no-op subscription.
+     */
+    onChangeFormalContent(callback: () => void): () => void;
+    /**
+     * Whether this notebook's shape declares a cell type structurally equal to
+     * the given object or morphism type. A function written against a shape
+     * (e.g. `Notebook<typeof ListShape>`) can be handed a notebook of a
+     * narrower theory whose shape only covers some of those types; `supports`
+     * tests, at runtime, which of the shape's types this particular notebook
+     * actually provides before {@link Notebook.add}ing them.
+     *
+     * It is a type guard: for a notebook typed over a *union* of shapes, a true
+     * result narrows it to just those members that declare `type`, so the
+     * subsequent {@link Notebook.add} of that type type-checks. Adding a type
+     * not declared by every member without first narrowing is a compile error.
+     *
+     * `type` is constrained to the shape's {@link DeclaredTypes}: asking about a
+     * type no member of the shape could ever declare is itself a compile error,
+     * since the guard could never succeed.
+     */
+    supports<T extends DeclaredTypes<TShape>>(type: T): this is this & AddCapability<T>;
+    /**
+     * Given a sub-shape (a {@link defineShape} contract bundling several object
+     * and morphism types), whether this notebook's shape declares *every* type
+     * it declares — the many-types counterpart of the single-type overload.
+     *
+     * It is a type guard: a true result narrows the notebook to its own type
+     * intersected with the combined add-capability of all the sub-shape's
+     * declared types, so a single guarded block may {@link Notebook.add} any of
+     * them without narrowing each one individually.
+     */
+    supports<S extends AnyShape>(shape: S): this is this & ShapeAddCapability<S>;
+    /**
+     * Handles for all cells, in notebook order, as the widest {@link
+     * NotebookCell} union: object and morphism handles are the untyped
+     * `ObjectCell`/`MorphismCell`. It is deliberately *not* parametrized by the
+     * notebook's shape, so a notebook declaring extra cell types stays
+     * assignable where a narrower shape is expected (e.g. a notebook with an
+     * extra object type handed to a consumer over a union of list shapes); the
+     * tradeoff is that the result may include cell types beyond that shape.
+     * Recover precise handles with {@link Notebook.cellsOf}.
+     *
+     * For an analysis notebook the union additionally carries the shape's
+     * analysis-cell handles (see {@link AnalysisCellsOf}), so `cell.kind`
+     * discriminates a {@link CellKind.Analysis} cell to a precise {@link
+     * AnalysisCell}.
+     */
+    cells(): HasDiagram<TShape> extends true
+        ? Array<DiagramCell>
+        : Array<NotebookCell | AnalysisCellsOf<TShape>>;
+    /**
+     * Handles for the notebook's *formal* cells — every cell except rich-text —
+     * in notebook order. These are the cells backed by a formal judgment
+     * (object, morphism, instantiation, or analysis), i.e. the ones that
+     * contribute to {@link Notebook.validate}; rich-text cells are excluded.
+     *
+     * The element type is {@link Notebook.cells}' union with {@link
+     * RichTextCell} removed, so `cell.kind` never discriminates to {@link
+     * CellKind.RichText}.
+     */
+    formalCells(): HasDiagram<TShape> extends true
+        ? Array<Exclude<DiagramCell, RichTextCell>>
+        : Array<Exclude<NotebookCell | AnalysisCellsOf<TShape>, RichTextCell>>;
+    /**
+     * Handles for the cells whose object or morphism type is declared by the
+     * given sub-shape, precisely typed by that shape: each of its declared
+     * object/morphism types contributes its own handle, so `cell.kind`
+     * discriminates to a precise `ObjectCell`/`MorphismCell`. Matching is
+     * structural, so cells are selected by their stored type value regardless of
+     * which shape produced `shape`.
+     *
+     * A single object or morphism def may be passed directly instead of a
+     * shape, selecting just that type's cells as precise
+     * `ObjectCell`/`MorphismCell` handles (rich-text cells are excluded).
+     *
+     * Rich-text cells are included only when the sub-shape opts in with
+     * `informal: [RichText]`; otherwise the result carries just the shape's
+     * declared object/morphism (and analysis) cells. To select rich-text cells
+     * alone, pass {@link RichText}; to iterate every cell, use {@link
+     * Notebook.cells}.
+     */
+    cellsOf(type: RichTextType): Array<RichTextCell>;
+    cellsOf(type: InstantiationType): Array<InstantiationCell<Handle>>;
+    cellsOf(type: PathEquationType): Array<PathEquationCell>;
+    cellsOf<Def extends AnalysisDef>(type: Def): Array<AnalysisCell<Def>>;
+    cellsOf<Def extends ObjectDef>(type: Def): Array<ObjectCell<Def>>;
+    cellsOf<Def extends MorphismDef>(type: Def): Array<MorphismCell<Def>>;
+    cellsOf<S extends AnyShape>(shape: S): Array<ShapeCellsOf<S>>;
+    /**
+     * Look up the single cell of the given type with the given id. The type
+     * selects the precise handle just as {@link Notebook.cellsOf} does, so a
+     * cell whose id matches but whose type differs is not returned.
+     *
+     * Returns a {@link Result}: an `Ok` carrying the cell as `content`, or an
+     * `Err` carrying issues when no cell with that id exists or the cell has a
+     * different type.
+     */
+    get(type: RichTextType, id: string): Result<RichTextCell>;
+    get(type: InstantiationType, id: string): Result<InstantiationCell<Handle>>;
+    get(type: PathEquationType, id: string): Result<PathEquationCell>;
+    get<Def extends AnalysisDef>(type: Def, id: string): Result<AnalysisCell<Def>>;
+    get<Def extends ObjectDef>(type: Def, id: string): Result<ObjectCell<Def>>;
+    get<Def extends MorphismDef>(type: Def, id: string): Result<MorphismCell<Def>>;
+    /**
+     * Add a cell to the notebook. The kind of cell is selected by the first
+     * argument:
+     *
+     * - {@link RichText} adds a rich-text cell; `args` is `{ content }`.
+     * - {@link Instantiation} adds an instantiated model; `args` is
+     *   `{ label, model, specializations }`.
+     * - {@link PathEquation} adds a path equation (on a shape that declares
+     *   `supportsEquations: true`); `args` is `{ label, lhs, rhs }`, each
+     *   side an array of the notebook's morphism cells composed left to right.
+     *   Each field may be `null` to record an unset label or side.
+     * - A morphism type from the shape adds a morphism cell; `args` is
+     *   `{ label, from, to }`, with `from`/`to` constrained by the morphism type.
+     *   Each field may be `null` to record an unset label or endpoint.
+     * - An object type from the shape adds an object cell; `args` is `{ label }`.
+     */
+    add(type: RichTextType, args: { content: string }): RichTextCell;
+    add(type: InstantiationType, args: InstantiationArgs<Handle>): InstantiationCell<Handle>;
+    add(
+        type: HasPathEquations<TShape> extends true ? PathEquationType : never,
+        args: PathEquationArgs,
+    ): PathEquationCell;
+    add<A extends AnalysisDefOf<TShape>>(type: A): AnalysisCell<A>;
+    add<I extends IndividualDefOf<TShape>>(
+        type: I,
+        args: { label: string; over: ObjectCell<I["object"]> },
+    ): IndividualCell<I>;
+    add<P extends AspectDefOf<TShape>>(
+        type: P,
+        args: {
+            label?: string;
+            from: IndividualCell;
+            to: IndividualCell;
+            over: MorphismCell<P["morphism"]>;
+        },
+    ): AspectCell<P>;
+    add<M extends ShapeMorphisms<TShape>>(
+        type: M,
+        args: { label: string | null; from: DomOf<M> | null; to: CodOf<M> | null },
+    ): MorphismCell<M>;
+    add<O extends ShapeObjects<TShape>>(type: O, args: { label: string }): ObjectCell<O>;
+}
+
+/**
+ * The value of an inline instance-`add` argument: another {@link Row} (for a
+ * mapping) or a literal (for an attribute, auto-materialized as a value row).
+ * Loosely typed for now — the key set is not checked against the schema object's
+ * outgoing mappings/attributes at compile time; unknown keys throw at runtime.
+ */
+export type RowValue = Row | string | number | boolean;
+
+/**
+ * A row of an {@link Instance}: one record of a schema entity. Rows are never
+ * named — a row's identity is the row itself, exposed as {@link Row.id} — and its
+ * mapping/attribute values are read from {@link Row.values}. Returned by {@link
+ * Instance.add} and {@link Instance.rows}, and passed back as a mapping value to
+ * later `add` calls.
+ */
+export type Row = {
+    /** The row's stable id, used to reference it as a mapping target. */
+    readonly id: string;
+    /** The schema entity (object) this row is a record of. */
+    readonly entity: ObjectCell;
+    /**
+     * This row's value for one schema morphism, looked up by the morphism's
+     * *UUID* (the schema mapping / attribute cell): a mapping's value is the
+     * target {@link Row}, an attribute's is the literal it was given, and a
+     * cleared or unset morphism is `undefined`. This is the collision-free
+     * counterpart to {@link Row.values}: because it keys by UUID, two morphisms
+     * sharing a name are read independently.
+     */
+    get(morphism: { readonly id: string }): Row | string | undefined;
+    /**
+     * This row's mapping and attribute values keyed by the schema morphism's
+     * *UUID*, so morphisms sharing a name never collide (unlike {@link
+     * Row.values}). A mapping's value is the target {@link Row}, an attribute's
+     * is the literal it was given.
+     */
+    readonly valuesById: Record<string, Row | string>;
+    /**
+     * This row's mapping and attribute values, keyed by the schema mapping /
+     * attribute *name*: a mapping's value is the target {@link Row}, an
+     * attribute's value is the literal it was given.
+     *
+     * NOTE: names are not unique, so two morphisms sharing a name collide here
+     * (the last wins). Prefer {@link Row.get} or {@link Row.valuesById} — which
+     * key by the morphism's UUID — whenever a schema may have same-named
+     * morphisms. The underlying stored triples are always UUID-keyed, so this
+     * collision is only in this convenience view, never in the data.
+     */
+    readonly values: Record<string, Row | string>;
+    /**
+     * Set (or clear) this row's value for one schema morphism, replacing any
+     * previous value for it: a mapping takes a target {@link Row}, an attribute a
+     * literal; passing no value clears it. `morphism` is the schema's mapping /
+     * attribute cell (e.g. from `schema.cellsOf(Attr)`). Keyed by the morphism's
+     * UUID, so same-named morphisms are set independently.
+     */
+    set(morphism: { readonly id: string }, value?: RowValue): void;
+    /**
+     * Delete this row and the values drawn out of it. Foreign keys pointing *at*
+     * it from other rows are left dangling and become invalid on the next {@link
+     * Instance.validate}, mirroring a deleted mapping target.
+     */
+    delete(): void;
+};
+
+/**
+ * An *instance* notebook: a database that instantiates a schema, backed by an
+ * {@link InstanceDocument} storing a single flat `entries` array of triples keyed by the schema's
+ * generator UUIDs. Obtained from {@link Binder.createInstance}. It speaks in
+ * *rows*, not cells: {@link Instance.add} inserts a row for a schema entity and
+ * sets its mapping/attribute values inline, and {@link Instance.rows} lists
+ * them. It validates against its schema just as a diagram validates in its
+ * model.
+ */
+// oxlint-disable-next-line typescript/no-explicit-any
+export type Instance<_TShape extends DiagramShape = DiagramShape, Handle = any> = Update<{
+    name: string;
+}> & {
+    /** Reactive read of the instance's name. */
+    readonly name: string;
+    /** The document theory of the schema this instance is of. */
+    readonly theory: string;
+    /** The store handle this instance is bound to. */
+    readonly handle: Handle;
+    /** The underlying instance document (a single flat `entries` array keyed by schema UUIDs). */
+    readonly document: InstanceDocument;
+    /** Make a detached plain-JS snapshot of the underlying document. */
+    dump(): InstanceDocument;
+    /** Subscribe to changes to this instance's document; see {@link Notebook.onChange}. */
+    onChange(callback: () => void): () => void;
+    /** Subscribe to changes to formal content; see {@link Notebook.onChangeFormalContent}. */
+    onChangeFormalContent(callback: () => void): () => void;
+    /**
+     * Insert a row for the given schema entity. Inline args name the entity's
+     * outgoing mappings and attributes: each wires the new row to the arg's
+     * value — another {@link Row} for a mapping, or (for an attribute) the
+     * literal it points at. Rows are never named. Returns the new row.
+     */
+    add(entity: ObjectCell, args?: Record<string, RowValue>): Row;
+    /**
+     * All of the instance's rows. Value rows auto-created for attribute
+     * literals are not listed. Use {@link Instance.rowsOf} to filter to one
+     * schema entity.
+     */
+    rows(): Row[];
+    /**
+     * The instance's rows of one schema entity. Value rows auto-created for
+     * attribute literals are not listed.
+     */
+    rowsOf(entity: ObjectCell): Row[];
+    /**
+     * Elaborate the instance and validate it against its schema. Returns a
+     * tagged {@link DiagramValidationResult}, like a diagram notebook's.
+     */
+    validate(): Promise<DiagramValidationResult>;
+    /**
+     * Observe this instance's validation reactively; see
+     * {@link Notebook.onValidate}. Re-validation triggers on changes to the
+     * instance's own rows *and* to any document in its schema's instantiation
+     * tree — no manual subscription to the schema is needed. Returns an
+     * unsubscribe function.
+     */
+    onValidate(callback: (result: DiagramValidationResult) => void): () => void;
+};
+
+/** A diagram shape's individual-def list, defaulted to empty for indexing. */
+type IndividualDefOf<TShape extends AnyShape> = ("individuals" extends keyof TShape
+    ? NonNullable<TShape["individuals"]>
+    : readonly [])[number] &
+    IndividualDef;
+
+/** A diagram shape's aspect-def list; see {@link IndividualDefOf}. */
+type AspectDefOf<TShape extends AnyShape> = ("aspects" extends keyof TShape
+    ? NonNullable<TShape["aspects"]>
+    : readonly [])[number] &
+    AspectDef;
+
+/**
+ * The diagram-only notebook surface, present only when the shape declares
+ * `individuals` (see {@link HasDiagram}). A diagram notebook surfaces its model
+ * `theory`, iterates {@link DiagramCell}s, and validates against its model. A
+ * model or analysis notebook yields no such members.
+ */
+type DiagramMethods<TShape extends AnyShape> =
+    HasDiagram<TShape> extends true
+        ? {
+              /** The document theory of the model this diagram is drawn in. */
+              readonly theory: string;
+              /**
+               * Elaborate the diagram into its model and validate it there.
+               * Returns a tagged {@link DiagramValidationResult}: `Valid` with the
+               * elaborated diagram, `Invalid` with the diagram and its validation
+               * errors, or `Illformed` when elaboration (or resolving the model)
+               * failed.
+               */
+              validate(): Promise<DiagramValidationResult>;
+              /**
+               * Observe this diagram's validation reactively; see
+               * {@link Notebook.onValidate}. Re-validation triggers on changes
+               * to the diagram's own cells and to any document in its host
+               * model's instantiation tree. Returns an unsubscribe function.
+               */
+              onValidate(callback: (result: DiagramValidationResult) => void): () => void;
+          }
+        : object;
+
+/**
+ * The document type a shape's notebook is backed by: an {@link AnalysisDocument}
+ * for an analysis shape (one that declares `analyses`), a {@link ModelDocument}
+ * otherwise. The base {@link Shape} (optional `analyses`) yields the full
+ * {@link Document}, keeping a concrete notebook assignable to the generic one.
+ */
+type DocumentOf<TShape extends AnyShape> =
+    HasAnalyses<TShape> extends true
+        ? AnalysisDocument
+        : HasDiagram<TShape> extends true
+          ? DiagramDocument
+          : "analyses" extends keyof TShape
+            ? Document
+            : "individuals" extends keyof TShape
+              ? Document
+              : ModelDocument;
+
+/**
+ * The analysis-only notebook surface, present only when the shape declares
+ * `analyses` (see {@link HasAnalyses}). A model notebook yields no such members,
+ * so reading `analysisType` off one is a compile error.
+ */
+type AnalysisMethods<TShape extends AnyShape> =
+    HasAnalyses<TShape> extends true
+        ? {
+              /** Whether this notebook analyzes a model or a diagram. */
+              readonly analysisType: AnalysisType;
+          }
+        : object;
+
+/**
+ * The notebook methods that elaborate into the shape's `getCoreTheory`, present
+ * only when the shape declares one (see {@link HasCoreTheory}). A shape without
+ * a `getCoreTheory` (e.g. a sub-shape, or a creatable shape that omits it) yields
+ * no such methods, so calling them is a compile error rather than a runtime
+ * throw.
+ */
+type CoreTheoryMethods<TShape extends AnyShape, Handle> =
+    HasCoreTheory<TShape> extends true
+        ? {
+              /**
+               * Elaborate the notebook into a core model and validate it. Returns a
+               * {@link Result}: an `Ok` carrying the validated model as `content`,
+               * or an `Err` carrying issues if the model is invalid or elaboration
+               * itself failed.
+               *
+               * Elaborates into the shape's `getCoreTheory`; available only on a shape
+               * that declares one.
+               *
+               * Asynchronous because a notebook may contain instantiation cells,
+               * whose referenced models are resolved through the store (which
+               * fetches them via {@link DocumentStore.getHandle} and elaborates
+               * them against this notebook's core theory, handling any cycles).
+               * A notebook with instantiations whose resolution fails validates
+               * to an `Err`.
+               */
+              validate(): Promise<ModelValidationResult>;
+              /**
+               * Observe this notebook's validation reactively: the callback
+               * receives a first result asynchronously, then a new one whenever
+               * re-validation produces a *different* result — `Ok`s compare by
+               * model identity (stable through the elaboration cache), `Err`s
+               * by their issues. Re-validation triggers on changes to any
+               * document the validation depends on: this notebook *and* every
+               * transitively instantiated model, so an edit to an imported
+               * notebook is observed without the consumer knowing the
+               * dependency graph. Returns an unsubscribe function.
+               *
+               * This is the intended way to drive a reactive view (e.g. wire
+               * the callback to a signal); prefer it over hand-rolling
+               * {@link Notebook.onChangeFormalContent} + {@link Notebook.validate},
+               * which cannot see cross-document dependencies.
+               */
+              onValidate(callback: (result: ModelValidationResult) => void): () => void;
+              /**
+               * Migrate the notebook's document to another shape, **mutating it in
+               * place**: the underlying document is rewritten to the target theory
+               * rather than copied.
+               *
+               * Returns a {@link Result}: an `Ok` carrying a `Notebook` bound to
+               * the target shape (the original handle is now stale, so continue
+               * through the returned handle), or an `Err` carrying issues when no
+               * migration to the target is defined or the source model cannot be
+               * resolved.
+               *
+               * Available only on a shape that declares a `getCoreTheory`, since a
+               * pushforward migration elaborates the model. Asynchronous for the
+               * same reason as {@link Notebook.validate}: a notebook with
+               * instantiation cells resolves them through the store (via
+               * {@link DocumentStore.getHandle}).
+               */
+              migrateTo<TTarget extends CreatableShape>(
+                  targetShape: TTarget,
+              ): Promise<Result<Notebook<TTarget, Handle>>>;
+          }
+        : object;
+
+/**
+ * Entry points for notebooks over a fixed store. Obtain one with
+ * `createBinder`.
+ */
+export interface Binder<Handle> {
+    /**
+     * Build an analysis notebook from fresh data. The `of` model must be
+     * validatable (its shape must declare a `getCoreTheory`), so it can be
+     * resolved by calling `validate()` before each analysis run. The notebook
+     * is backed by a real {@link AnalysisDocument} whose `analysisOf` link
+     * references `of`.
+     */
+    createNotebook<S extends AnalysisShape>(
+        shape: S,
+        data: { name: string; of: ValidatableNotebook<Handle> },
+    ): Promise<Notebook<S, Handle>>;
+    /**
+     * Build a diagram notebook from fresh data. The `in` model must be
+     * validatable (its shape must declare a `getCoreTheory`), so the diagram can be
+     * elaborated and validated against it. The notebook is backed by a real
+     * {@link DiagramDocument} whose `diagramIn` link references `in`.
+     */
+    createNotebook<S extends DiagramShape>(
+        shape: S,
+        data: { name: string; in: ValidatableNotebook<Handle> },
+    ): Promise<Notebook<S, Handle>>;
+    /**
+     * Build an *instance* notebook of a schema. `schema` is the schema notebook
+     * itself (its shape must be a creatable, `.Diagram`-deriving shape); the
+     * instance's derived diagram shape and `diagram-in` link are taken from it,
+     * so the caller passes only the schema and a name. The result is an {@link
+     * Instance} whose ergonomic `add` takes schema object cells directly. See
+     * {@link Instance}.
+     */
+    createInstance<S extends CreatableShape & { readonly Diagram: DiagramShape }>(
+        schema: Notebook<S, Handle>,
+        data: { name: string },
+    ): Promise<Instance<S["Diagram"], Handle>>;
+    /**
+     * Rebuild an *instance* notebook from a previously {@link Instance.dump}ed
+     * {@link InstanceDocument}, re-attaching it over a live `schema` notebook.
+     * The dumped document's `instanceOf` link is rewritten to reference
+     * `schema`'s current handle, so the instance resolves against and validates
+     * in the schema it is reloaded over regardless of the id the schema held when
+     * the instance was dumped. Use it to persist and restore an instance (e.g. to
+     * `localStorage`) across sessions: dump the schema and instance, reload the
+     * schema with {@link Binder.loadNotebook}, then reload the instance here.
+     */
+    loadInstance<S extends CreatableShape & { readonly Diagram: DiagramShape }>(
+        schema: Notebook<S, Handle>,
+        document: InstanceDocument,
+    ): Promise<Instance<S["Diagram"], Handle>>;
+    /**
+     * Build a notebook from fresh data. The document seed is constructed
+     * internally from `data.name` and the shape's `theory`.
+     *
+     * Asynchronous because it initializes store storage through
+     * {@link DocumentStore.createHandle}, which a backend-backed store fulfils
+     * by registering the new document remotely.
+     */
+    createNotebook<TShape extends CreatableShape>(
+        shape: TShape,
+        data: { name: string },
+    ): Promise<Notebook<TShape, Handle>>;
+    /**
+     * Build a notebook around an existing plain document by initializing store
+     * storage from it. Returns a {@link Result}: an `Ok` carrying the
+     * `Notebook`, or an `Err` carrying issues when the document's theory does
+     * not match the shape's theory.
+     */
+    loadNotebook<TShape extends CreatableShape>(
+        shape: TShape,
+        document: ModelDocument,
+    ): Promise<Result<Notebook<TShape, Handle>>>;
+    /**
+     * Build a notebook around an existing document identified by a
+     * {@link DocumentRef}, resolving it through {@link DocumentStore.getHandle} —
+     * the abstraction over the frontend's `Api.getDocHandle` (resolve a reference
+     * over RPC, then `repo.find` the Automerge document). No store storage is
+     * created.
+     *
+     * Returns a {@link Result}: an `Ok` carrying the `Notebook`, or an `Err`
+     * carrying issues when the reference cannot be resolved (the store's
+     * `getHandle` returns `undefined`), or when the resolved document's theory
+     * does not match the shape's theory. Asynchronous because resolution can hit
+     * a remote backend.
+     */
+    loadNotebookFromRef<TShape extends CreatableShape>(
+        shape: TShape,
+        ref: DocumentRef,
+    ): Promise<Result<Notebook<TShape, Handle>>>;
+}
+
+/** Bind a store once, yielding the notebook entry points. */
+export function createBinder<Handle>(store: DocumentStore<Handle>): Binder<Handle> {
+    // `getDocumentView` is a plain, stable getter: a projecting store builds its
+    // projection once in `createHandle`/`getHandle` and returns it here, so the
+    // binder reads the store directly without caching projections itself.
+    const binder = {
+        async createNotebook(
+            shape: AnyShape,
+            data: {
+                name: string;
+                of?: ValidatableNotebook<Handle>;
+                in?: ValidatableNotebook<Handle>;
+            },
+        ) {
+            if (isAnalysisShape(shape)) {
+                const of = data.of;
+                if (!of) {
+                    throw new Error("Analysis notebook requires an `of` notebook.");
+                }
+                const ref = store.getDocumentRef(of.handle);
+                const seed = newAnalysisDocument({
+                    analysisType: shape.analysisType,
+                    analysisOf: linkFromRef(ref, "analysis-of"),
+                    name: data.name,
+                });
+                return attachNotebook(store, await store.createHandle(seed), shape);
+            }
+            if (isDiagramShape(shape)) {
+                const model = data.in;
+                if (!model) {
+                    throw new Error("Diagram notebook requires an `in` model notebook.");
+                }
+                const ref = store.getDocumentRef(model.handle);
+                const seed = newDiagramDocument({
+                    diagramIn: linkFromRef(ref, "diagram-in"),
+                    name: data.name,
+                });
+                return attachNotebook(store, await store.createHandle(seed), shape, model.handle);
+            }
+            const creatableShape = shape as CreatableShape;
+            const seed = newModelDocument({ theory: creatableShape.theory });
+            seed.name = data.name;
+            // The seed is constructed with the shape's own theory, so loading
+            // always succeeds.
+            return attachNotebook(store, await store.createHandle(seed), creatableShape);
+        },
+        async createInstance(schema: Notebook<AnyShape, Handle>, data: { name: string }) {
+            // The instance's diagram shape is the schema's own derived `.Diagram`,
+            // recovered from the shape stamped on the schema notebook at creation.
+            const schemaShape = shapeOf(schema);
+            const diagramShape = (schemaShape as { Diagram?: DiagramShape } | undefined)?.Diagram;
+            if (!diagramShape) {
+                throw new Error(
+                    "createInstance requires a schema notebook created from a creatable, " +
+                        "`.Diagram`-deriving shape.",
+                );
+            }
+            const ref = store.getDocumentRef(schema.handle);
+            const seed = newInstanceDocument({
+                instanceOf: linkFromRef(ref, "instantiation"),
+                theory: diagramShape.theory ?? "",
+                name: data.name,
+            });
+            return withShape(
+                attachInstanceNotebook(
+                    store,
+                    await store.createHandle(seed as unknown as Document),
+                    diagramShape,
+                    schema.handle,
+                ),
+                diagramShape,
+            );
+        },
+        async loadInstance(schema: Notebook<AnyShape, Handle>, document: InstanceDocument) {
+            const schemaShape = shapeOf(schema);
+            const diagramShape = (schemaShape as { Diagram?: DiagramShape } | undefined)?.Diagram;
+            if (!diagramShape) {
+                throw new Error(
+                    "loadInstance requires a schema notebook created from a creatable, " +
+                        "`.Diagram`-deriving shape.",
+                );
+            }
+            const ref = store.getDocumentRef(schema.handle);
+            // The dumped document's `instanceOf` link points at whatever id the
+            // schema held when it was dumped; rewrite it to the schema we are
+            // reloading over so validation resolves the current schema. A
+            // document persisted before the `entries` representation has no such
+            // field: default it to empty rather than crash on read.
+            const seed: InstanceDocument = {
+                ...document,
+                instanceOf: linkFromRef(ref, "instantiation"),
+                entries: document.entries ?? [],
+            };
+            return withShape(
+                attachInstanceNotebook(
+                    store,
+                    await store.createHandle(seed as unknown as Document),
+                    diagramShape,
+                    schema.handle,
+                ),
+                diagramShape,
+            );
+        },
+        async loadNotebook<TShape extends CreatableShape>(
+            shape: TShape,
+            document: ModelDocument,
+        ): Promise<Result<Notebook<TShape, Handle>>> {
+            if (document.theory !== shape.theory) {
+                return {
+                    tag: "Err",
+                    content: [
+                        {
+                            message:
+                                `Cannot load document with theory "${document.theory}" ` +
+                                `using a shape with theory "${shape.theory}".`,
+                            path: ["theory"],
+                        },
+                    ],
+                };
+            }
+            return {
+                tag: "Ok",
+                content: attachNotebook(store, await store.createHandle(document), shape),
+            };
+        },
+        async loadNotebookFromRef<TShape extends CreatableShape>(
+            shape: TShape,
+            ref: DocumentRef,
+        ): Promise<Result<Notebook<TShape, Handle>>> {
+            const resolved = await store.getHandle(ref);
+            if (resolved.tag === "Err") {
+                return resolved;
+            }
+            const handle = resolved.content;
+            const document = store.getDocumentView(handle);
+            const theory = document.type === "model" ? document.theory : undefined;
+            if (theory !== shape.theory) {
+                return {
+                    tag: "Err",
+                    content: [
+                        {
+                            message:
+                                `Cannot load document with theory "${theory}" ` +
+                                `using a shape with theory "${shape.theory}".`,
+                            path: ["theory"],
+                        },
+                    ],
+                };
+            }
+            return { tag: "Ok", content: attachNotebook(store, handle, shape) };
+        },
+    };
+    return binder as unknown as Binder<Handle>;
+}
+
+/** A ready-made binder over the plain in-memory store. */
+export const binder: Binder<Document> = createBinder(plainStore);
diff --git a/packages/document-methods/src/future/observe.ts b/packages/document-methods/src/future/observe.ts
new file mode 100644
index 000000000..0df66b6aa
--- /dev/null
+++ b/packages/document-methods/src/future/observe.ts
@@ -0,0 +1,143 @@
+import type { ModelCache } from "./model-cache";
+
+/**
+ * The machinery behind {@link Notebook.onValidate}: a validation observer
+ * re-validates a notebook when — and only when — something its validation
+ * actually depends on changes, and delivers the result to a callback when — and
+ * only when — it differs from the last delivered one.
+ *
+ * The dependency set comes from the model cache: after each validation the
+ * observer reads the ids of every document in the resolution subtree
+ * ({@link ModelCache.depsOf}) and keeps a change subscription
+ * ({@link ModelCache.onDocChange}) on exactly those, resubscribing as
+ * instantiations are added or removed. This is what per-component wiring built
+ * on `onChangeFormalContent` cannot do: it watches one document, while a
+ * validation depends on the whole subtree — an edit to an instantiated child
+ * (or, for an instance, to its schema) re-validates here without the consumer
+ * knowing the dependency graph exists.
+ *
+ * Re-validation is cheap by construction: the model cache serves an unchanged
+ * subtree from memory, so the observer can afford to run on every reported
+ * change (including noisy ones like rich-text keystrokes) and let the
+ * `equivalent` gate suppress deliveries that would re-render nothing.
+ */
+export type ValidationObserverOptions<T> = {
+    /** Run one validation, producing the value considered for delivery. */
+    validate(): Promise<T>;
+    /** The cache tracking the model dependency tree. */
+    cache: ModelCache;
+    /**
+     * The id of the document whose resolution roots the dependency tree: the
+     * notebook's own reference id for a model notebook, the host model's
+     * (`diagramIn`/`instanceOf`) for a diagram or instance. `undefined` when
+     * there is no such rooting document (e.g. an unlinked diagram/instance); the
+     * observer then only reacts to `subscribeOwn` triggers.
+     */
+    depRootId: string | undefined;
+    /**
+     * Subscribe to changes of the observed notebook's own (formal) content —
+     * the one dependency that is not a resolved model document, and the
+     * fallback trigger while no resolution has succeeded yet.
+     */
+    subscribeOwn(callback: () => void): () => void;
+    /** Whether two results are equivalent; an equivalent result is not
+     * re-delivered, so no-op re-validations cause no re-renders. */
+    equivalent(previous: T, next: T): boolean;
+    /** Deliver a changed result (and the first result). */
+    deliver(result: T): void;
+};
+
+/**
+ * Start observing: validate once (asynchronously) and deliver, then re-validate
+ * on relevant changes, delivering only results that are not `equivalent` to the
+ * last delivered one. Returns a dispose function that stops observation and
+ * releases every subscription.
+ *
+ * Changes are coalesced: a burst of synchronous edits triggers one validation
+ * (the loop yields a microtask before validating), and a change arriving while
+ * a validation is in flight queues exactly one more run. Exceptions from
+ * `validate` are not caught — a throw indicates shape misconfiguration (e.g. a
+ * missing core theory), not invalid content, and surfaces as an unhandled
+ * rejection; the observer stays subscribed and re-runs on the next change.
+ */
+export function createValidationObserver<T>(options: ValidationObserverOptions<T>): () => void {
+    /** Cache-side change subscriptions, one per dependency doc id. */
+    const depSubscriptions = new Map<string, () => void>();
+    let disposed = false;
+    let running = false;
+    let dirty = false;
+    /** Boxed so a legitimately-undefined first result still counts as delivered. */
+    let last: { value: T } | undefined;
+
+    /**
+     * Align the cache subscriptions with the dependency set of the latest
+     * resolution. When the resolution failed (no fresh entry, so no dep set),
+     * the current subscriptions are kept: the documents involved are the likely
+     * site of the fix, so their changes must keep re-triggering.
+     */
+    const resyncDeps = (): void => {
+        const deps = options.depRootId ? options.cache.depsOf(options.depRootId) : undefined;
+        if (!deps) {
+            return;
+        }
+        for (const [id, unsubscribe] of depSubscriptions) {
+            if (!deps.has(id)) {
+                unsubscribe();
+                depSubscriptions.delete(id);
+            }
+        }
+        for (const id of deps) {
+            if (!depSubscriptions.has(id)) {
+                depSubscriptions.set(id, options.cache.onDocChange(id, schedule));
+            }
+        }
+    };
+
+    const run = async (): Promise<void> => {
+        running = true;
+        try {
+            while (dirty) {
+                if (disposed) {
+                    return;
+                }
+                dirty = false;
+                // Yield one microtask so a synchronous burst of changes is
+                // batched into a single validation.
+                await Promise.resolve();
+                const value = await options.validate();
+                if (disposed) {
+                    return;
+                }
+                resyncDeps();
+                if (!last || !options.equivalent(last.value, value)) {
+                    last = { value };
+                    options.deliver(value);
+                }
+            }
+        } finally {
+            running = false;
+        }
+    };
+
+    const schedule = (): void => {
+        if (disposed) {
+            return;
+        }
+        dirty = true;
+        if (!running) {
+            void run();
+        }
+    };
+
+    const unsubscribeOwn = options.subscribeOwn(schedule);
+    schedule();
+
+    return () => {
+        disposed = true;
+        unsubscribeOwn();
+        for (const unsubscribe of depSubscriptions.values()) {
+            unsubscribe();
+        }
+        depSubscriptions.clear();
+    };
+}
diff --git a/packages/document-methods/src/future/store.ts b/packages/document-methods/src/future/store.ts
new file mode 100644
index 000000000..8f683cb00
--- /dev/null
+++ b/packages/document-methods/src/future/store.ts
@@ -0,0 +1,257 @@
+import { v7 } from "uuid";
+
+import type { Document, Link } from "catcolab-document-types";
+import type { DblModel, DblTheory } from "catlog-wasm";
+import { modelCacheFor } from "./model-cache";
+import type { Result } from "./validation";
+
+export { CyclicInstantiationError, formalCellsSignature } from "./model-cache";
+
+/**
+ * A plain reference to a document: the sole reference type of this package's
+ * public API. It identifies a document by `id`/`version`/`server`, without
+ * saying *how* the document is referenced — that is the concern of the internal,
+ * on-disk `Link` type (which additionally carries a link `type` and uses the
+ * database field convention `_id`/`_version`/`_server`). A `DocumentRef` is what
+ * {@link DocumentStore.getDocumentRef} returns and {@link DocumentStore.getHandle}
+ * consumes; {@link linkFromRef}/{@link refFromLink} bridge to the internal `Link`
+ * when building or reading document content.
+ */
+export interface DocumentRef {
+    /** Unique identifier of the referenced document. */
+    id: string;
+    /** Version of the document, or `null` to track the head commit. */
+    version: string | null;
+    /** Server containing the document. Omit for a local/serverless reference. */
+    server?: string;
+}
+
+/**
+ * Build an internal document-content {@link Link} of the given type from a
+ * {@link DocumentRef}, mapping the unprefixed fields onto the database-level
+ * `_id`/`_version`/`_server`. Internal: `Link` is not part of the public API.
+ */
+export const linkFromRef = (ref: DocumentRef, type: Link["type"]): Link => ({
+    _id: ref.id,
+    _version: ref.version,
+    _server: ref.server ?? "",
+    type,
+});
+
+/**
+ * Read an internal document-content {@link Link} as a public {@link DocumentRef},
+ * dropping the link `type`. Internal: used to hand a document-content link's
+ * target to {@link DocumentStore.getHandle}, which speaks `DocumentRef`.
+ */
+export const refFromLink = (link: Link): DocumentRef => ({
+    id: link._id,
+    version: link._version,
+    server: link._server,
+});
+
+/**
+ * A store-native reference to a rich-text cell's text, for binding an
+ * incremental editor. A collaborative rich-text editor does not mutate text
+ * through change functions: it binds directly to the store's underlying
+ * document (e.g. `@automerge/prosemirror` takes an Automerge `DocHandle` plus
+ * the path to the text object and emits per-keystroke splices). A ref carries
+ * exactly that pair.
+ *
+ * `docHandle` is deliberately `unknown`: this package does not depend on any
+ * particular store backend, and the consumer that constructed the store knows
+ * the concrete handle type and narrows it (e.g. to `DocHandle<unknown>` for an
+ * Automerge-backed store).
+ */
+export type RichTextRef = {
+    /** The store's underlying document handle, e.g. an Automerge `DocHandle`. */
+    readonly docHandle: unknown;
+    /** Path from the document root to the cell's text object, e.g.
+     * `["notebook", "cellContents", cellId, "content"]`. */
+    readonly path: ReadonlyArray<string | number>;
+};
+
+/**
+ * A document store abstracts the storage that notebooks operate over. A
+ * store is a stateless object working on handles of its own choosing: a
+ * plain document, a Solid store, an Automerge `DocHandle`, etc. Handles are
+ * produced by `createHandle` and passed back into the other methods.
+ */
+export interface DocumentStore<Handle> {
+    /**
+     * Initialize a store handle from an initial document. Asynchronous so a
+     * store backed by a remote backend can register the document as it is
+     * created — e.g. push the content over RPC and resolve the returned ref to
+     * a handle. In-memory stores simply resolve immediately.
+     */
+    createHandle(initialDoc: Document): Promise<Handle>;
+    /**
+     * Get the read view of the document for a handle (reactive where
+     * applicable). This is a plain getter: it must be cheap and return a stable
+     * object across calls, so a store that projects its handle (e.g. Automerge +
+     * `makeDocumentProjection`) builds the projection once in
+     * {@link createHandle} (and {@link getHandle}) and simply returns it here,
+     * rather than rebuilding it per read. The view is read-only: mutations go
+     * through {@link changeDocument}, not by writing to the returned document.
+     */
+    getDocumentView(handle: Handle): Readonly<Document>;
+    /** Apply a mutation by mutating a draft document. */
+    changeDocument(handle: Handle, fn: (doc: Document) => void): void;
+    /**
+     * The store-native reference an incremental rich-text editor binds to, when
+     * the store can provide one. An Automerge-backed store returns its
+     * `DocHandle` plus the path to the cell's text object, so an editor (e.g.
+     * `@automerge/prosemirror`) can emit per-keystroke splices that preserve
+     * text-object merge semantics. Stores that omit this (e.g. the plain
+     * in-memory store) cannot bind an incremental editor: rich text is then
+     * replace-only, through {@link changeDocument}.
+     */
+    getRichTextRef?(handle: Handle, cellId: string): RichTextRef | undefined;
+    /**
+     * Subscribe to changes of the document behind a handle, including remote
+     * changes — e.g. another collaborator editing a shared Automerge document.
+     * The callback takes no arguments: it is a pure notification, so a consumer
+     * re-reads whatever notebook state it cares about. Returns an unsubscribe
+     * function that removes the listener.
+     *
+     * A store with no asynchronous or remote change source (the plain in-memory
+     * store, a bare Solid store) still implements it to report local mutations
+     * made through {@link changeDocument}, typically by notifying a set of
+     * listeners after applying the mutation.
+     */
+    subscribe(handle: Handle, callback: () => void): () => void;
+    /** Make a detached plain-JS copy of a store-owned value before cloning it. */
+    copyValue<T>(handle: Handle, value: T): T;
+    /**
+     * Convert a store handle into the referenced document's {@link DocumentRef}.
+     * Every store must mint a stable reference for its handles — an in-memory
+     * store assigns one at {@link createHandle} time (see {@link plainStore}) —
+     * so `validate`, instantiation, and cross-document loading always have a
+     * reference to resolve. The inverse of {@link getHandle}.
+     */
+    getDocumentRef(handle: Handle): DocumentRef;
+    /**
+     * Fetch the handle a {@link DocumentRef} refers to as a {@link Result}: an
+     * `Ok` carrying the handle, or an `Err` carrying issues when the store cannot
+     * resolve the reference (e.g. it does not know the id, or a backend fetch
+     * failed). The referenced document is read off the handle with
+     * {@link getDocumentView}. The inverse of {@link getDocumentRef}.
+     *
+     * This is the store's contribution to resolution: validation's recursive
+     * elaborator (see {@link resolveModelInStore}) walks a model's
+     * instantiations by calling `getHandle` for each referenced document and
+     * viewing its document, then elaborates each against the host notebook's core
+     * theory (supplied by the caller, since every instantiation in a notebook is
+     * validatable against that one core theory). Because `validate` resolves a
+     * notebook's *own* model by taking a reference to its handle (via
+     * {@link getDocumentRef}), a store over validatable notebooks must be able to
+     * return the handle for that reference too.
+     *
+     * Asynchronous so a store backed by a remote backend can fetch the document
+     * — e.g. resolve a reference to an Automerge document over RPC, then load it
+     * from the repo. In-memory stores simply resolve immediately.
+     */
+    getHandle(ref: DocumentRef): Promise<Result<Handle>>;
+}
+
+/**
+ * The shared recursive elaborator behind validation. Given a store, a link, and
+ * the core theory to elaborate against, it fetches the handle (via
+ * {@link DocumentStore.getHandle}) and views its document, recursively resolves
+ * the document's own instantiations (so it elaborates against a populated map,
+ * not an empty one), elaborates against `coreTheory`, and detects cycles. Every
+ * instantiation in a notebook is validatable against the host's core theory, so
+ * the same `coreTheory` is threaded through the whole resolution tree rather
+ * than looked up per document. Stores differ only in how they fetch documents,
+ * so this is the single place resolution lives — `validate` delegates here
+ * rather than the reverse.
+ *
+ * It returns the elaborated {@link DblModel} without running `model.validate()`:
+ * the `Valid`/`Invalid` distinction is made by the top-level
+ * {@link Notebook.validate}, not by resolution. It rejects when a referenced
+ * document is unavailable, fails to elaborate, or participates in a cycle; the
+ * notebook whose `validate` triggered resolution then reports `Illformed`.
+ *
+ * Resolution is cached per store: an elaborated model is reused across calls —
+ * by `validate`, `migrateTo`, diagram and instance validation, and analysis
+ * `run()` alike — until the formal content of its document, or of any document
+ * in its instantiation subtree, actually changes. Failures are never cached.
+ * See {@link modelCacheFor} for the invalidation strategy.
+ */
+export function resolveModelInStore<Handle>(
+    store: DocumentStore<Handle>,
+    ref: DocumentRef,
+    coreTheory: DblTheory,
+): Promise<DblModel> {
+    // Resolution only ever follows a document reference as an instantiation, so
+    // the internal cache key is the corresponding instantiation link.
+    return modelCacheFor(store).resolve(linkFromRef(ref, "instantiation"), coreTheory);
+}
+
+const plainDocumentIds = new WeakMap<Document, string>();
+
+/** Reverse of {@link plainDocumentIds}: the document an id was minted for, so
+ * the plain store's resolver can fetch a referenced document by id. */
+const plainDocumentsById = new Map<string, Document>();
+
+export const plainDocumentId = (document: Document): string => {
+    let id = plainDocumentIds.get(document);
+    if (!id) {
+        id = v7();
+        plainDocumentIds.set(document, id);
+        plainDocumentsById.set(id, document);
+    }
+    return id;
+};
+
+/**
+ * Change listeners registered against plain-store documents. The plain store has
+ * no remote change source, so the only changes it can report are the local
+ * mutations made through {@link plainStore.changeDocument}, which notifies every
+ * listener registered for that document after applying the mutation.
+ */
+const plainChangeListeners = new WeakMap<Document, Set<() => void>>();
+
+/** A plain in-memory store whose handle is the document itself. */
+export const plainStore: DocumentStore<Document> = {
+    createHandle: async (initialDoc) => {
+        plainDocumentId(initialDoc);
+        return initialDoc;
+    },
+    getHandle: async (ref) => {
+        const handle = plainDocumentsById.get(ref.id);
+        return handle
+            ? { tag: "Ok", content: handle }
+            : {
+                  tag: "Err",
+                  content: [{ message: `Cannot resolve reference "${ref.id}".`, path: ["id"] }],
+              };
+    },
+    getDocumentView: (handle) => handle,
+    changeDocument: (handle, fn) => {
+        fn(handle);
+        const listeners = plainChangeListeners.get(handle);
+        if (listeners) {
+            // Snapshot so a listener may unsubscribe during notification.
+            for (const listener of Array.from(listeners)) {
+                listener();
+            }
+        }
+    },
+    subscribe: (handle, callback) => {
+        let listeners = plainChangeListeners.get(handle);
+        if (!listeners) {
+            listeners = new Set();
+            plainChangeListeners.set(handle, listeners);
+        }
+        listeners.add(callback);
+        return () => {
+            listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(value),
+    getDocumentRef: (handle) => ({
+        id: plainDocumentId(handle),
+        version: null,
+        server: "",
+    }),
+};
diff --git a/packages/document-methods/src/future/validation.ts b/packages/document-methods/src/future/validation.ts
new file mode 100644
index 000000000..e4a59ac77
--- /dev/null
+++ b/packages/document-methods/src/future/validation.ts
@@ -0,0 +1,363 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { type } from "arktype";
+
+import type { ObType } from "catcolab-document-types";
+import {
+    CellKind,
+    type MorEndpointMeta,
+    type MorphismDef,
+    type ObjectDef,
+    sameTypeValue,
+} from "./definitions";
+
+/**
+ * Runtime validation of {@link Notebook.add} arguments, built on ArkType
+ * (https://arktype.io). The typed `add` API rejects endpoint mistakes at
+ * *compile time*, but a plain-JavaScript caller gets no TypeScript checking, so
+ * the same mistakes would slip through and silently corrupt the document. These
+ * validators re-check the arguments at runtime and throw on the three classes of
+ * endpoint mistake — an endpoint of the wrong object type, a single object where
+ * a list is required (or vice versa), and a missing required field.
+ *
+ * Failures are reported through ArkType, whose error value is a Standard Schema
+ * (https://standardschema.dev) `FailureResult`: an `issues` array, each issue an
+ * `{ message, path? }`. {@link ValidationError} re-exposes that array on a thrown
+ * `Error` so callers inspect failures vendor-neutrally without importing
+ * anything validator-specific.
+ *
+ * TypeScript types are *derived from* the ArkType schemas with ArkType's
+ * `type.infer`, so the schema is the single source of truth for both the runtime
+ * check and the static shape.
+ */
+
+/**
+ * A [Standard Schema](https://standardschema.dev) issue: a human-readable
+ * `message` and an optional `path`. Aliased from the spec's own
+ * {@link StandardSchemaV1.Issue}.
+ */
+export type Issue = StandardSchemaV1.Issue;
+
+/**
+ * The result of a fallible operation: a tagged union structurally identical to
+ * the `JsResult` type in our Rust bindings (`catlog-wasm`), which serializes
+ * Rust's standard `Result` with `#[serde(tag = "tag", content = "content")]`.
+ * Results coming out of the Rust layer can therefore pass through untouched.
+ *
+ * When a failure is about validation of unknown or user generated input, the
+ * `Err` content defaults to an array of [Standard
+ * Schema](https://standardschema.dev) {@link Issue}s, so callers can inspect
+ * failures vendor-neutrally without importing anything validator-specific.
+ */
+export type Result<T, E = ReadonlyArray<Issue>> =
+    | { readonly tag: "Ok"; readonly content: T }
+    | { readonly tag: "Err"; readonly content: E };
+
+/**
+ * An error thrown when {@link Notebook.add} arguments fail validation. It is a
+ * real `Error` (so it propagates and prints normally) that additionally carries
+ * a Standard Schema `issues` array, mirroring ArkType's own failure result.
+ */
+export class ValidationError extends Error {
+    readonly issues: ReadonlyArray<Issue>;
+
+    constructor(issues: ReadonlyArray<Issue>) {
+        super(issues.map((issue) => issue.message).join("; "));
+        this.name = "ValidationError";
+        this.issues = issues;
+    }
+}
+
+/** A shape that looks like an object-cell handle: `kind` is
+ * {@link CellKind.Object} and it carries a `type.obType`. */
+type ObjectCellShape = { kind: unknown; type: { obType?: unknown } };
+
+/** Test the structural shape of an object-cell handle without leaking ArkType's
+ * internal per-field messages (e.g. the `kind` symbol). */
+const looksLikeObjectCell = (value: unknown): value is ObjectCellShape =>
+    typeof value === "object" &&
+    value !== null &&
+    (value as ObjectCellShape).kind === CellKind.Object &&
+    typeof (value as ObjectCellShape).type === "object" &&
+    (value as ObjectCellShape).type !== null;
+
+/** Test the structural shape of a morphism-cell handle: `kind` is
+ * {@link CellKind.Morphism} and it carries a string `id`; the morphism-side
+ * counterpart of {@link looksLikeObjectCell}. */
+const looksLikeMorphismCell = (value: unknown): boolean =>
+    typeof value === "object" &&
+    value !== null &&
+    (value as { kind?: unknown }).kind === CellKind.Morphism &&
+    typeof (value as { id?: unknown }).id === "string";
+
+/** Human-readable name of an object type, for legible messages: the `content`
+ * of a `Basic` obType (e.g. `Entity`), else its JSON form. */
+const obTypeName = (obType: unknown): string => {
+    if (
+        typeof obType === "object" &&
+        obType !== null &&
+        typeof (obType as { content?: unknown }).content === "string"
+    ) {
+        return (obType as { content: string }).content;
+    }
+    return JSON.stringify(obType);
+};
+
+/** Describe a runtime value for the `(was …)` half of a legible message,
+ * without dumping a whole object-cell handle (functions, ids) as JSON. */
+const describeValue = (value: unknown): string => {
+    if (value === undefined) {
+        return "missing";
+    }
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "an array";
+    }
+    if (looksLikeObjectCell(value)) {
+        return `an object cell of type ${obTypeName(value.type.obType)}`;
+    }
+    if (looksLikeMorphismCell(value)) {
+        return "a morphism cell";
+    }
+    return typeof value;
+};
+
+/** Check that `value` is an object cell, optionally of `expected` type,
+ * rejecting through `ctx` with a legible message otherwise. */
+const checkObjectCell = (
+    value: unknown,
+    expected: ObType | undefined,
+    ctx: { reject(spec: { expected: string; actual: string }): false },
+): boolean => {
+    if (!looksLikeObjectCell(value)) {
+        return ctx.reject({ expected: "an object cell", actual: describeValue(value) });
+    }
+    if (expected && !sameTypeValue(value.type.obType, expected)) {
+        return ctx.reject({
+            expected: `an object cell of type ${obTypeName(expected)}`,
+            actual: `an object cell of type ${obTypeName(value.type.obType)}`,
+        });
+    }
+    return true;
+};
+
+/**
+ * The schema for one morphism endpoint (`from`/`to`), shaped by the endpoint's
+ * declared metadata. It is a single `narrow` over `unknown` — deliberately *not*
+ * a `.or("null")`/`.array()` combination — so both halves of every failure
+ * message stay under our control and legible (an ArkType union re-serializes the
+ * rejected value, dumping a whole cell handle, functions and all):
+ *
+ * - `null` is always accepted (an unset endpoint);
+ * - a list endpoint (one with a `modality`) requires an *array* of object cells,
+ *   so a single cell is rejected (and vice versa);
+ * - the element/cell object type is checked against the declared `obType` when
+ *   one is recorded; an endpoint with no declared `obType` accepts any object
+ *   cell — including one from another theory, whose `obType` differs, which is
+ *   rejected when a type is declared.
+ */
+const endpointSchema = (meta: MorEndpointMeta | undefined) => {
+    const expected = meta?.obType;
+    const isList = meta?.modality !== undefined;
+    const shape = isList ? "an array or null" : "an object cell or null";
+    return type("unknown").narrow((value, ctx) => {
+        if (value === null) {
+            return true;
+        }
+        if (isList) {
+            if (!Array.isArray(value)) {
+                return ctx.reject({ expected: shape, actual: describeValue(value) });
+            }
+            return value.every((element) => checkObjectCell(element, expected, ctx));
+        }
+        if (Array.isArray(value)) {
+            return ctx.reject({ expected: shape, actual: "an array" });
+        }
+        return checkObjectCell(value, expected, ctx);
+    });
+};
+
+/**
+ * Build and run the validator for a {@link Notebook.add} call, throwing a
+ * {@link ValidationError} on failure. Object cells require a `label`; morphism
+ * cells require a `label` and `from`/`to` endpoints, each of which may be `null`
+ * to record an unset label or endpoint.
+ */
+export function validateAddArgs(def: ObjectDef | MorphismDef, args: unknown): void {
+    if (def.tag === "object") {
+        runSchema(type({ label: "string", "+": "ignore" }), args);
+        return;
+    }
+
+    // Endpoint keys are *optional* in the schema so an absent one reaches our
+    // own missing-field check below (which yields a legible "must be an object
+    // cell or null (was missing)") rather than ArkType's bare "must be present".
+    // A key that *is* present still runs the endpoint narrow.
+    const schema = type({
+        label: "string | null",
+        "from?": endpointSchema(def.domain),
+        "to?": endpointSchema(def.codomain),
+        "+": "ignore",
+    });
+
+    const supplied =
+        typeof args === "object" && args !== null ? (args as Record<string, unknown>) : {};
+    const missing: Issue[] = [];
+    for (const key of ["from", "to"] as const) {
+        if (!(key in supplied)) {
+            const meta = key === "from" ? def.domain : def.codomain;
+            const shape =
+                meta?.modality !== undefined ? "an array or null" : "an object cell or null";
+            missing.push({ message: `\`${key}\` must be ${shape} (was missing)`, path: [key] });
+        }
+    }
+
+    runSchema(schema, args, missing);
+}
+
+/**
+ * Build and run the validator for a {@link Update.update} call, throwing a
+ * {@link ValidationError} on failure. Unlike {@link validateAddArgs}, an update
+ * is *partial*: only the fields actually present in `args` are checked, so an
+ * omitted field is left untouched rather than rejected as missing. The same
+ * per-field endpoint rules as `add` apply to any field that *is* supplied.
+ */
+export function validateUpdateArgs(def: ObjectDef | MorphismDef, args: unknown): void {
+    const supplied =
+        typeof args === "object" && args !== null ? (args as Record<string, unknown>) : {};
+
+    const fields: Record<string, unknown> = {};
+    if ("label" in supplied) {
+        fields["label"] = def.tag === "object" ? "string" : "string | null";
+    }
+    if (def.tag === "morphism") {
+        if ("from" in supplied) {
+            fields["from"] = endpointSchema(def.domain);
+        }
+        if ("to" in supplied) {
+            fields["to"] = endpointSchema(def.codomain);
+        }
+    }
+
+    runSchema(type({ ...fields, "+": "ignore" }), args);
+}
+
+/**
+ * The schema for one side of a path equation (`lhs`/`rhs`): `null` (an unset
+ * side) or an array of morphism cells — the path's steps in composition order.
+ * A single `narrow` over `unknown`, like {@link endpointSchema}, so both halves
+ * of every failure message stay under our control and legible.
+ */
+const pathSchema = type("unknown").narrow((value, ctx) => {
+    if (value === null) {
+        return true;
+    }
+    if (!Array.isArray(value)) {
+        return ctx.reject({
+            expected: "an array of morphism cells or null",
+            actual: describeValue(value),
+        });
+    }
+    return value.every(
+        (element) =>
+            looksLikeMorphismCell(element) ||
+            ctx.reject({ expected: "a morphism cell", actual: describeValue(element) }),
+    );
+});
+
+/**
+ * Build and run the validator for a path-equation {@link Notebook.add} call,
+ * throwing a {@link ValidationError} on failure. An equation requires a `label`
+ * and `lhs`/`rhs` sides; each field may be `null` to record an unset label or
+ * side.
+ */
+export function validatePathEquationAddArgs(args: unknown): void {
+    // Side keys are *optional* in the schema so an absent one reaches our own
+    // missing-field check below (a legible "must be an array of morphism cells
+    // or null (was missing)") rather than ArkType's bare "must be present"; see
+    // `validateAddArgs`.
+    const schema = type({
+        label: "string | null",
+        "lhs?": pathSchema,
+        "rhs?": pathSchema,
+        "+": "ignore",
+    });
+
+    const supplied =
+        typeof args === "object" && args !== null ? (args as Record<string, unknown>) : {};
+    const missing: Issue[] = [];
+    for (const key of ["lhs", "rhs"] as const) {
+        if (!(key in supplied)) {
+            missing.push({
+                message: `\`${key}\` must be an array of morphism cells or null (was missing)`,
+                path: [key],
+            });
+        }
+    }
+
+    runSchema(schema, args, missing);
+}
+
+/**
+ * Build and run the validator for a path-equation {@link Update.update} call,
+ * throwing a {@link ValidationError} on failure. Like {@link
+ * validateUpdateArgs}, an update is *partial*: only the fields actually present
+ * in `args` are checked.
+ */
+export function validatePathEquationUpdateArgs(args: unknown): void {
+    const supplied =
+        typeof args === "object" && args !== null ? (args as Record<string, unknown>) : {};
+
+    const fields: Record<string, unknown> = {};
+    if ("label" in supplied) {
+        fields["label"] = "string";
+    }
+    for (const key of ["lhs", "rhs"] as const) {
+        if (key in supplied) {
+            fields[key] = pathSchema;
+        }
+    }
+
+    runSchema(type({ ...fields, "+": "ignore" }), args);
+}
+
+/** The leading path key of an issue, for stable message ordering. */
+const issueKey = (issue: Issue): string => String(issue.path?.[0] ?? "");
+
+/** Wrap the leading field name of an ArkType message in backticks. ArkType
+ * prefixes each field message with its bare path key (e.g. `from must be …`);
+ * delimiting that key keeps the field name legible and consistent with our
+ * other messages (e.g. those from {@link Notebook.get}). */
+const delimitFieldName = (message: string, path: readonly PropertyKey[]): string => {
+    const key = path[0];
+    if (typeof key !== "string") {
+        return message;
+    }
+    const prefix = `${key} `;
+    return message.startsWith(prefix) ? `\`${key}\` ${message.slice(prefix.length)}` : message;
+};
+
+/** Run an ArkType schema and, on failure (or if any `extra` issues were
+ * supplied), throw a {@link ValidationError} carrying all issues as a Standard
+ * Schema `FailureResult`. Issues are sorted by their leading path key so the
+ * message order is stable regardless of input key order. */
+function runSchema(
+    schema: { (data: unknown): unknown },
+    args: unknown,
+    extra: readonly Issue[] = [],
+): void {
+    const result = schema(args);
+    const fromSchema =
+        result instanceof type.errors
+            ? result.map((issue) => {
+                  const path = [...issue.path];
+                  return { message: delimitFieldName(issue.message, path), path };
+              })
+            : [];
+    const issues = [...fromSchema, ...extra];
+    if (issues.length > 0) {
+        issues.sort((a, b) => issueKey(a).localeCompare(issueKey(b)));
+        throw new ValidationError(issues);
+    }
+}
diff --git a/packages/document-methods/src/model.ts b/packages/document-methods/src/model.ts
index 2fe244d67..1c2618689 100644
--- a/packages/document-methods/src/model.ts
+++ b/packages/document-methods/src/model.ts
@@ -38,6 +38,15 @@ export const newMorphismDecl = (morType: MorType): ModelJudgment & { tag: "morph
     cod: null,
 });
 
+/** Create a new equation declaration. */
+export const newEquationDecl = (): ModelJudgment & { tag: "equation" } => ({
+    tag: "equation",
+    id: v7(),
+    name: "",
+    lhs: null,
+    rhs: null,
+});
+
 /** Create a new instantiation of an existing model. */
 export const newInstantiatedModel = (
     model?: Link | null,
diff --git a/packages/document-methods/src/notebook.ts b/packages/document-methods/src/notebook.ts
index 9cbe3aac5..dc3ba745d 100644
--- a/packages/document-methods/src/notebook.ts
+++ b/packages/document-methods/src/notebook.ts
@@ -6,8 +6,20 @@ import type { Cell, Notebook } from "catcolab-document-types";
 /** A cell containing custom data, usually a formal object. */
 export type FormalCell<T> = Cell<T> & { tag: "formal" };
 
-/** A cell containing rich text. */
-export type RichTextCell = Cell<unknown> & { tag: "rich-text" };
+/**
+ * Automerge-backed rich text edited by the frontend ProseMirror editor.
+ *
+ * At runtime this is the value at the rich-text cell's `content` path. The
+ * frontend passes that path to `@automerge/prosemirror`, which stores text,
+ * marks, and block metadata directly on the Automerge text object rather than
+ * as serialized ProseMirror JSON.
+ */
+export type RichTextContent = string;
+
+/** A cell containing frontend rich text. */
+export type RichTextCell = Omit<Cell<unknown> & { tag: "rich-text" }, "content"> & {
+    content: RichTextContent;
+};
 
 /** Creates an empty notebook. */
 export const newNotebook = <T>(): Notebook<T> => ({
@@ -15,8 +27,8 @@ export const newNotebook = <T>(): Notebook<T> => ({
     cellContents: {},
 });
 
-/** Creates a rich text cell with the given content. */
-export const newRichTextCell = (content?: string): RichTextCell => ({
+/** Creates a rich text cell with the given frontend rich-text content. */
+export const newRichTextCell = (content?: RichTextContent): RichTextCell => ({
     tag: "rich-text",
     id: v7(),
     content: content ?? "",
diff --git a/packages/document-methods/test/analysis_notebook.lts.md b/packages/document-methods/test/analysis_notebook.lts.md
new file mode 100644
index 000000000..42fadc3d1
--- /dev/null
+++ b/packages/document-methods/test/analysis_notebook.lts.md
@@ -0,0 +1,357 @@
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Visualization } from "catcolab-analyses";
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, RichText } from "catcolab-documents";
+
+const model = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const source = model.add(Type, { label: "A" });
+const target = model.add(Type, { label: "B" });
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const analysis = await binder.createNotebook(SimpleOlog.Analysis, {
+    name: "Olog analysis",
+    of: model,
+});
+```
+
+```ts
+console.log("name:", analysis.name);
+console.log("type:", analysis.analysisType);
+```
+
+```
+name: Olog analysis
+type: model
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+analysis.add(RichText, { content: "We visualize the olog." });
+
+const viz = analysis.add(Visualization);
+```
+
+```ts
+console.log("analysis id:", viz.type.id);
+console.log("layout:", viz.params.layout);
+```
+
+```
+analysis id: diagram
+layout: graphviz-directed
+```
+
+```ts
+viz.update({ direction: "horizontal" });
+
+console.log("layout:", viz.params.layout);
+console.log("direction:", viz.params.direction);
+```
+
+```
+layout: graphviz-directed
+direction: horizontal
+```
+
+The params are precisely typed from the analysis def, so `params`, `update`, and
+`run` are all checked against the analysis's own `Params` type. Unknown params
+and wrong value types are compile errors:
+
+```ts
+// @ts-expect-error `layout` is one of the known engines, not an arbitrary string.
+viz.update({ layout: "d3-force" });
+
+// @ts-expect-error `direction` is "horizontal" | "vertical", not any string.
+viz.update({ direction: "sideways" });
+
+// @ts-expect-error There is no `zoom` param on a visualization.
+viz.update({ zoom: 2 });
+
+// @ts-expect-error There is no `zoom` param to read either.
+console.log(viz.params.zoom);
+```
+
+The def's exported `Params` type is the single source of truth, so a handle's
+params are assignable to it:
+
+```ts
+import type { VisualizationParams } from "catcolab-analyses";
+
+const layout: VisualizationParams = viz.params;
+console.log("engine:", layout.layout);
+```
+
+```
+engine: graphviz-directed
+```
+
+## Running an analysis
+
+`run()` resolves to a `Result` whose `Ok` `content` is precisely the analysis's
+own output type. The visualization lays out the model with Graphviz and then
+renders that layout to a self-contained SVG string. The renderer reproduces the
+markup of the frontend's `GraphSVG` component (ported from
+`packages/frontend/src/visualization`), but builds it as a string with `vhtml`,
+so it runs headlessly. The `content.svg` string contains the frontend's markup: a
+`<svg class="graph">` with the graph stylesheet embedded, `<g class="node">`
+groups holding a `<rect>` and a label `<text>`, and `<g class="edge">` groups
+holding a `<path>`:
+
+```ts
+const result = await viz.run();
+if (result.tag === "Ok") {
+    const { svg } = result.content;
+    console.log("is svg:", svg.trimStart().startsWith("<?xml"));
+    console.log("graph class:", svg.includes('class="graph"'));
+    console.log("nodes:", svg.split('class="node"').length - 1);
+    console.log("has A:", svg.includes(">A<"));
+    console.log("has B:", svg.includes(">B<"));
+}
+```
+
+```
+is svg: true
+graph class: true
+nodes: 2
+has A: true
+has B: true
+```
+
+The output type is checked: unknown fields are compile errors, and the whole
+`content` is assignable to the def's exported output type.
+
+```ts
+import type { VisualizationResult } from "catcolab-analyses";
+
+const out = await viz.run();
+if (out.tag === "Ok") {
+    const rendered: VisualizationResult = out.content;
+
+    // @ts-expect-error The output has `svg`, not `nodes`.
+    void rendered.nodes;
+
+    // @ts-expect-error `svg` is a string, so it has no `.length` array access.
+    void rendered.svg[0]?.weight;
+
+    console.log("svg length > 0:", rendered.svg.length > 0);
+}
+```
+
+```
+svg length > 0: true
+```
+
+## Mass-action dynamics
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { MassActionDynamics } from "catcolab-analyses";
+import { PetriNet, Place, Transition } from "catcolab-logics/petri-net";
+import { binder } from "catcolab-documents";
+
+const petriNet = await binder.createNotebook(PetriNet, { name: "SIR" });
+
+const susceptible = petriNet.add(Place, { label: "S" });
+const infected = petriNet.add(Place, { label: "I" });
+
+petriNet.add(Transition, { label: "infection", from: [susceptible, infected], to: [infected] });
+
+const analysis = await binder.createNotebook(PetriNet.Analysis, {
+    name: "Petri net analysis",
+    of: petriNet,
+});
+
+const sim = analysis.add(MassActionDynamics);
+```
+
+```ts
+console.log("analysis id:", sim.type.id);
+console.log("duration:", sim.params.duration);
+```
+
+```
+analysis id: mass-action
+duration: 10
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+sim.update({ duration: 3, initialValues: { [susceptible.id]: 1 } });
+```
+
+```ts
+console.log("duration:", sim.params.duration);
+console.log("S initial:", sim.params.initialValues[susceptible.id]);
+```
+
+```
+duration: 3
+S initial: 1
+```
+
+The params are catlog-wasm's full `MassActionProblemData`, so `initialValues` and
+`rates` are `Record<string, number>` keyed by handle ids and `duration` is a
+plain number:
+
+```ts
+// @ts-expect-error `duration` is a number, not a string.
+sim.update({ duration: "long" });
+
+// @ts-expect-error `initialValues` maps ids to numbers, not strings.
+sim.update({ initialValues: { [susceptible.id]: "lots" } });
+
+// @ts-expect-error There is no `tolerance` param on `MassActionProblemData`.
+sim.update({ tolerance: 0.01 });
+```
+
+The params type is catlog-wasm's `MassActionProblemData`:
+
+```ts
+import type { MassActionProblemData } from "catlog-wasm";
+
+const params: MassActionProblemData = sim.params;
+console.log("duration:", params.duration);
+```
+
+```
+duration: 3
+```
+
+The analysis returns the raw `massAction` result — the ODE `solution` (itself a
+`JsResult` wrapping the solver's `time`/`states` trajectories) alongside the
+`latexEquations` for the system:
+
+```ts
+const result = await sim.run();
+if (result.tag === "Ok") {
+    const { solution, latexEquations } = result.content;
+    if (solution.tag === "Ok") {
+        console.log("has times:", solution.content.time.length > 0);
+        console.log("states:", [...solution.content.states.keys()].length);
+    }
+    console.log("equations:", latexEquations.length > 0);
+}
+```
+
+```
+has times: true
+states: 2
+equations: true
+```
+
+Like the params, the output is typed by the def and checked at the call site,
+and assignable to catlog-wasm's `ODEResultWithEquations`:
+
+```ts
+import type { ODEResultWithEquations } from "catlog-wasm";
+
+const out = await sim.run();
+if (out.tag === "Ok") {
+    const massResult: ODEResultWithEquations = out.content;
+
+    // @ts-expect-error `solution` is a `JsResult`, not a plain array.
+    const time: number[] = massResult.solution.time;
+    void time;
+
+    // @ts-expect-error The result exposes `solution`/`latexEquations`, not `states`.
+    void massResult.states;
+
+    if (massResult.solution.tag === "Ok") {
+        console.log("final time:", Math.round(massResult.solution.content.time.at(-1) ?? 0));
+    }
+}
+```
+
+```
+final time: 3
+```
+
+## Iterating through cells
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Visualization } from "catcolab-analyses";
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, RichText } from "catcolab-documents";
+
+const model = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+model.add(Type, { label: "A" });
+
+const analysis = await binder.createNotebook(SimpleOlog.Analysis, {
+    name: "Olog analysis",
+    of: model,
+});
+
+analysis.add(RichText, { content: "We visualize the olog." });
+analysis.add(Visualization);
+```
+
+```ts
+import { CellKind } from "catcolab-documents";
+
+for (const cell of analysis.cells()) {
+    switch (cell.kind) {
+        case CellKind.RichText:
+            console.log("text:", cell.content);
+            break;
+        case CellKind.Analysis:
+            console.log("analysis:", cell.type.id);
+            break;
+    }
+}
+```
+
+```
+text: We visualize the olog.
+analysis: diagram
+```
+
+## Type safety
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+import { binder, defineObject, defineShape } from "catcolab-documents";
+
+const model = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+// A creatable shape with a `theory` but no `getCoreTheory`: its notebooks cannot be
+// elaborated or validated, so they have no `validate()` method.
+const Sketch = defineShape({
+    theory: "sketch",
+    objects: [defineObject({ tag: "Basic", content: "Object" })],
+});
+
+const sketch = await binder.createNotebook(Sketch, { name: "A sketch" });
+```
+
+A validatable model is accepted as `of`:
+
+```ts
+await binder.createNotebook(SimpleOlog.Analysis, { name: "Olog analysis", of: model });
+```
+
+A non-validatable one is a type error:
+
+```ts
+// @ts-expect-error The `of` model must be validatable, but a notebook over a
+// shape without a `getCoreTheory` has no `validate()`.
+await binder.createNotebook(SimpleOlog.Analysis, { name: "bad", of: sketch });
+```
diff --git a/packages/document-methods/test/backend_document_store.test.tsx b/packages/document-methods/test/backend_document_store.test.tsx
new file mode 100644
index 000000000..69ffc4807
--- /dev/null
+++ b/packages/document-methods/test/backend_document_store.test.tsx
@@ -0,0 +1,460 @@
+// A full, production-shaped `DocumentStore` for the current frontend: Solid +
+// Automerge for reactivity and local state, and a real backend client for
+// creation, linking, and resolution. This mirrors what the frontend's `Api`
+// class (packages/frontend/src/api/types.ts) does today — create a document
+// through `rpc.new_ref`, resolve a ref id to an Automerge `DocumentId` over
+// `rpc.get_doc`, then `repo.find` it — but expressed as the
+// `DocumentStore<Handle>` abstraction from `catcolab-documents`.
+//
+// The store's `Handle` wraps an Automerge `DocHandle<Document>` together
+// with the Solid projection built from it once, at handle creation; `getDocumentView`
+// just returns that stable projection, exactly as
+// `notebook_with_automerge_solid_component.lts.md` sketches. What this example
+// adds over that sketch is the backend wiring:
+//
+//   * `createHandle` registers the new document with the backend as it is made
+//     (the analog of `Api.createDoc` -> `rpc.new_ref.mutate`), so every
+//     notebook created through this store is immediately backend-backed. This
+//     is why `createHandle` is asynchronous.
+//   * `getDocumentRef` mints a stable `{ id, version, server }` `DocumentRef`
+//     for a registered handle (the analog of `Api.makeUnversionedRef`).
+//   * `getHandle` walks a reference back to a handle by hitting the backend
+//     (the analog of `Api.getDocHandle` -> `rpc.get_doc.query` -> `repo.find`),
+//     so a notebook that instantiates another *backend* document can validate.
+//
+// Read `createBackendStore` top to bottom as the literal checklist of what
+// someone integrating a real backend must supply for each `DocumentStore`
+// method.
+/* oxlint-disable unicorn/consistent-function-scoping */
+import { getBackend, getObjectId } from "@automerge/automerge";
+import { type DocHandle, type DocumentId, Repo } from "@automerge/automerge-repo";
+import { makeDocumentProjection } from "@automerge/automerge-repo-solid-primitives";
+import { createBinder, type DocumentStore, Instantiation, type Notebook } from "catcolab-documents";
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { createRoot, For, getOwner, runWithOwner, type Owner } from "solid-js";
+import { render } from "solid-js/web";
+import { v7 } from "uuid";
+import { describe, expect, test } from "vitest";
+
+import type { Document } from "catcolab-document-types";
+import { DblModel } from "catlog-wasm";
+
+// ---------------------------------------------------------------------------
+// A stand-in for the CatColab backend, modelled on its real RPC surface.
+//
+// The production backend is reached through a Qubit RPC client (see
+// packages/frontend/src/api/rpc.ts and the generated `QubitServer` type in
+// packages/backend/pkg/src/index.ts). Every method returns an `RpcResult<T>`,
+// a tagged `Ok`/`Err` union, and document reads come back as a `RefDoc`, a
+// tagged `Live`/`Readonly` union. We reproduce those shapes here so the store
+// below has to unwrap them exactly like `Api.createDoc`/`Api.fetchDocCacheEntry`
+// do.
+//
+// The two methods the store uses:
+//
+//   * `new_ref(content)`: create a document from `content` under a fresh ref id,
+//     returning the ref id (the `_id` of a `StableRef`). Analog of
+//     `rpc.new_ref.mutate`, called by `Api.createDoc`.
+//   * `get_doc(refId)`: resolve a ref id to the Automerge document behind it.
+//     Analog of `rpc.get_doc.query`, whose `docId` the frontend then `find`s.
+//
+// The backend holds its own networked `Repo` in production; here the store and
+// backend share one in-memory `Repo`, and every document is served as `Live`
+// (the store `find`s it by `docId`). The `Readonly` arm — where the backend
+// ships document bytes to be imported into a local repo — is modelled too, so
+// the store's unwrapping logic is complete, even though this fake only ever
+// returns `Live`.
+// ---------------------------------------------------------------------------
+type RpcResult<T> = { tag: "Ok"; content: T } | { tag: "Err"; code: number; message: string };
+
+type RefDoc = { tag: "Live"; docId: string; isDeleted: boolean };
+
+class FakeBackend {
+    readonly serverHost = "test.catcolab.org";
+
+    /** The Automerge repo the backend serves documents out of. */
+    readonly repo = new Repo();
+
+    /** ref id -> Automerge document id, the mapping `get_doc` serves. */
+    private readonly refs = new Map<string, DocumentId>();
+
+    /**
+     * Analog of `rpc.new_ref.mutate`: take document *content*, create the repo
+     * document backend-side, and return a fresh ref id. This is what
+     * `Api.createDoc` calls, and what the store's `createHandle` calls below.
+     */
+    async new_ref(content: Document): Promise<RpcResult<string>> {
+        const handle = this.repo.create<Document>(content as Document);
+        const refId = v7();
+        this.refs.set(refId, handle.documentId);
+        return { tag: "Ok", content: refId };
+    }
+
+    /** Analog of `rpc.get_doc.query`: ref id -> `RefDoc` (always `Live` here). */
+    async get_doc(refId: string): Promise<RpcResult<RefDoc>> {
+        const docId = this.refs.get(refId);
+        if (!docId) {
+            return { tag: "Err", code: 404, message: `Unknown document ${refId}` };
+        }
+        return { tag: "Ok", content: { tag: "Live", docId, isDeleted: false } };
+    }
+}
+
+// ---------------------------------------------------------------------------
+// The store.
+//
+// This is the whole integration surface for a backend-backed store. It builds a
+// `DocumentStore<Handle>` where `Handle` wraps an Automerge `DocHandle` together
+// with the Solid projection built from it once, at handle creation; `getDocumentView`
+// returns that stable projection. The store keeps a bidirectional cache between
+// a handle's Automerge `DocumentId` and the backend ref id it was registered
+// under, so `getDocumentRef` can answer synchronously and `getHandle` can skip a
+// round-trip for handles already resolved.
+//
+// There is no separate "register" step: `createHandle` registers the document
+// with the backend as it creates it, so a notebook is referenceable the moment
+// it exists — matching `Api.createDoc`, which is how the frontend makes a new
+// document today.
+// ---------------------------------------------------------------------------
+// The store's handle wraps the Automerge `DocHandle` (local/remote state)
+// together with the Solid projection built from it once. Declaring the handle
+// shape is the one unavoidable step of any `DocumentStore` integration — every
+// store method takes or returns it.
+type StoreHandle = {
+    docHandle: DocHandle<Document>;
+    docView: Document;
+};
+
+function createBackendStore(backend: FakeBackend, owner?: Owner) {
+    const repo = backend.repo;
+
+    // Build a handle from a `DocHandle`, projecting it once. The projection is
+    // owned by `owner` (if given) so it stays reactive outside `render`.
+    const makeHandle = (docHandle: DocHandle<Document>): StoreHandle => ({
+        docHandle,
+        docView: owner
+            ? runWithOwner(owner, () => makeDocumentProjection(docHandle))!
+            : makeDocumentProjection(docHandle),
+    });
+
+    // handle document id <-> backend ref id, and ref id -> minted handle so a
+    // ref resolves to one stable handle (and one projection) per store.
+    const refByDocId = new Map<DocumentId, string>();
+    const handleByRefId = new Map<string, StoreHandle>();
+
+    // Annotated as `DocumentStore<StoreHandle>` so all methods share the one handle
+    // type and the store is checked against the interface as it is written.
+    const store: DocumentStore<StoreHandle> = {
+        // Creation is a backend round-trip: `new_ref` creates the document from
+        // its content and returns a ref id (analog of `Api.createDoc`), then
+        // `get_doc` + `repo.find` load the `DocHandle` for it (analog of
+        // `Api.getDocHandle`). The handle projects the `DocHandle` once, and both
+        // caches are primed so `getDocumentRef` answers immediately afterwards.
+        // Because this is asynchronous, `Binder.createNotebook` is asynchronous too.
+        createHandle: async (initialDoc: Document) => {
+            const created = await backend.new_ref(initialDoc);
+            if (created.tag !== "Ok") {
+                throw new Error(created.message);
+            }
+            const refId = created.content;
+
+            const fetched = await backend.get_doc(refId);
+            if (fetched.tag !== "Ok") {
+                throw new Error(fetched.message);
+            }
+            const docHandle = await repo.find<Document>(fetched.content.docId as DocumentId);
+            const handle = makeHandle(docHandle);
+
+            refByDocId.set(docHandle.documentId, refId);
+            handleByRefId.set(refId, handle);
+            return handle;
+        },
+
+        // Reactive read view: return the projection built once at handle
+        // creation, so notebook getters are tracked in Solid effects/JSX (see
+        // the render test below) without rebuilding it per read.
+        getDocumentView: (handle) => handle.docView,
+
+        changeDocument: (handle, fn) => handle.docHandle.change(fn),
+
+        // Remote changes flow through the Automerge change event, so a notebook
+        // built on this store reacts to collaborators editing the shared doc.
+        subscribe: (handle, callback) => {
+            handle.docHandle.on("change", callback);
+            return () => handle.docHandle.off("change", callback);
+        },
+
+        // Detach Solid/Automerge proxies before the caller clones a subtree:
+        // resolve the value's object id inside the current document and ask the
+        // Automerge backend to materialize a plain-JS copy of that subtree.
+        copyValue: (handle, value) => {
+            const doc = handle.docHandle.doc();
+            const objId = getObjectId(value as object);
+            return getBackend(doc).materialize(objId!) as typeof value;
+        },
+
+        // The backend analog of `Api.makeUnversionedRef`: a handle the store
+        // created (and so registered) has a stable, versionless reference on
+        // this server. Every handle this store hands out is registered, so a
+        // reference is always available; a handle unknown to this store (e.g.
+        // one minted by a different store instance) is a programming error.
+        getDocumentRef: (handle) => {
+            const refId = refByDocId.get(handle.docHandle.documentId);
+            if (!refId) {
+                throw new Error("handle is not registered with this store");
+            }
+            return { id: refId, version: null, server: backend.serverHost };
+        },
+
+        // The backend analog of `Api.getDocHandle`: call `get_doc` over RPC,
+        // unwrap the `RpcResult`, then turn the `RefDoc` into a handle and cache
+        // it so a resolved ref stays a single handle/projection.
+        getHandle: async (ref) => {
+            const refId = ref.id;
+            const cached = handleByRefId.get(refId);
+            if (cached) {
+                return { tag: "Ok", content: cached };
+            }
+
+            const result = await backend.get_doc(refId);
+            if (result.tag !== "Ok") {
+                return {
+                    tag: "Err",
+                    content: [{ message: `Cannot resolve reference "${refId}".`, path: ["id"] }],
+                };
+            }
+
+            const docHandle = await repo.find<Document>(result.content.docId as DocumentId);
+            const handle = makeHandle(docHandle);
+            handleByRefId.set(refId, handle);
+            refByDocId.set(docHandle.documentId, refId);
+            return { tag: "Ok", content: handle };
+        },
+    };
+
+    return store;
+}
+
+describe("backend-backed Solid + Automerge DocumentStore", () => {
+    test("reactive rendering: notebook getters track Automerge changes via Solid", async () => {
+        await createRoot(async (rootDispose) => {
+            const backend = new FakeBackend();
+            const store = createBackendStore(backend, getOwner()!);
+            const backendBinder = createBinder(store);
+            const notebook = await backendBinder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+            function Title(props: { title: string }) {
+                return <h1>{props.title}</h1>;
+            }
+
+            function Types(props: { notebook: Notebook<typeof SimpleOlog, StoreHandle> }) {
+                return (
+                    <ul>
+                        <For each={props.notebook.cellsOf(Type)}>
+                            {(cell) => <li>{cell.label}</li>}
+                        </For>
+                    </ul>
+                );
+            }
+
+            const container = document.createElement("div");
+            document.body.appendChild(container);
+
+            const dispose = render(
+                () => (
+                    <section>
+                        <Title title={notebook.name} />
+                        <Types notebook={notebook} />
+                    </section>
+                ),
+                container,
+            );
+
+            expect(container.querySelector("h1")?.textContent).toBe("An Olog");
+
+            // A local mutation through the store re-renders reactively.
+            notebook.update({ name: "A renamed Olog" });
+            expect(container.querySelector("h1")?.textContent).toBe("A renamed Olog");
+
+            // Adding a cell (an Automerge `change`) flows to the reactive list.
+            notebook.add(Type, { label: "Thing" });
+            expect([...container.querySelectorAll("li")].map((li) => li.textContent)).toEqual([
+                "Thing",
+            ]);
+
+            dispose();
+            container.remove();
+            rootDispose();
+        });
+    });
+
+    test("createNotebook registers with the backend, so getDocumentRef mints a ref", async () => {
+        await createRoot(async (dispose) => {
+            const backend = new FakeBackend();
+            const store = createBackendStore(backend, getOwner()!);
+            const backendBinder = createBinder(store);
+            // `createNotebook` registers through `new_ref` as it creates the
+            // document, so the handle has a stable reference right away.
+            const notebook = await backendBinder.createNotebook(SimpleOlog, { name: "Local" });
+
+            const ref = store.getDocumentRef(notebook.handle);
+            expect(ref).toEqual({
+                id: expect.any(String),
+                version: null,
+                server: backend.serverHost,
+            });
+            dispose();
+        });
+    });
+
+    test("getHandle resolves a backend ref to the same document (inverse of getDocumentRef)", async () => {
+        await createRoot(async (dispose) => {
+            const backend = new FakeBackend();
+            const owner = getOwner()!;
+            const store = createBackendStore(backend, owner);
+            const backendBinder = createBinder(store);
+            const notebook = await backendBinder.createNotebook(SimpleOlog, { name: "Shared" });
+            notebook.add(Type, { label: "Thing" });
+            const ref = store.getDocumentRef(notebook.handle);
+            const refId = ref.id;
+
+            // A fresh store over the same backend (e.g. a different browser tab)
+            // resolves the ref by fetching it, and sees the same document.
+            const otherStore = createBackendStore(backend, owner);
+            const resolved = await otherStore.getHandle(ref);
+
+            expect(resolved.tag).toBe("Ok");
+            if (resolved.tag !== "Ok") {
+                throw new Error("expected Ok");
+            }
+            const handle = resolved.content;
+            const doc = otherStore.getDocumentView(handle);
+            expect(doc.name).toBe("Shared");
+
+            // The ref round-trips back to the same id.
+            expect(otherStore.getDocumentRef(handle).id).toBe(refId);
+            dispose();
+        });
+    });
+
+    test("loadNotebookFromRef resolves a backend ref to a notebook (via getHandle)", async () => {
+        await createRoot(async (dispose) => {
+            const backend = new FakeBackend();
+            const owner = getOwner()!;
+            const store = createBackendStore(backend, owner);
+            const backendBinder = createBinder(store);
+
+            // Create a document and mint its stable reference — the analog of
+            // another tab (or a deep-link) landing on a document by its
+            // `{ id, server }` ref, the way the frontend opens a document through
+            // `Api.getDocHandle`.
+            const original = await backendBinder.createNotebook(SimpleOlog, { name: "Discovered" });
+            original.add(Type, { label: "Thing" });
+            const ref = store.getDocumentRef(original.handle);
+
+            // A fresh store over the same backend represents that other consumer.
+            // `loadNotebookFromRef` resolves the reference through the store's
+            // `getHandle` (the `get_doc` + `repo.find` round-trip) and wraps the
+            // resulting handle as a notebook.
+            const otherStore = createBackendStore(backend, owner);
+            const otherBinder = createBinder(otherStore);
+            const loaded = await otherBinder.loadNotebookFromRef(SimpleOlog, ref);
+
+            expect(loaded.tag).toBe("Ok");
+            if (loaded.tag !== "Ok") {
+                throw new Error("expected Ok");
+            }
+            const notebook = loaded.content;
+            // The loaded notebook views the same live document: it reads the
+            // existing name and cell, and edits propagate back to the original
+            // through the shared Automerge document.
+            expect(notebook.name).toBe("Discovered");
+            expect(notebook.cellsOf(Type).map((cell) => cell.label)).toEqual(["Thing"]);
+
+            notebook.update({ name: "Renamed via ref" });
+            expect(store.getDocumentView(original.handle).name).toBe("Renamed via ref");
+
+            dispose();
+        });
+    });
+
+    test("loadNotebookFromRef returns Err for a ref the store cannot resolve", async () => {
+        await createRoot(async (dispose) => {
+            const backend = new FakeBackend();
+            const store = createBackendStore(backend, getOwner()!);
+            const backendBinder = createBinder(store);
+
+            // No document was ever registered under this id, so `getHandle`
+            // returns `undefined` and the load reports an `Err`.
+            const loaded = await backendBinder.loadNotebookFromRef(SimpleOlog, {
+                id: v7(),
+                version: null,
+                server: backend.serverHost,
+            });
+            expect(loaded.tag).toBe("Err");
+            dispose();
+        });
+    });
+
+    test("loadNotebookFromRef rejects a ref whose document theory does not match the shape", async () => {
+        await createRoot(async (dispose) => {
+            const backend = new FakeBackend();
+            const store = createBackendStore(backend, getOwner()!);
+            const backendBinder = createBinder(store);
+
+            // A diagram document (created by an instance) is not a `model`
+            // document, so loading it with the model shape `SimpleOlog` fails.
+            const schema = await backendBinder.createNotebook(SimpleOlog, { name: "Schema" });
+            const instance = await backendBinder.createInstance(schema, { name: "Instance" });
+            const ref = store.getDocumentRef(instance.handle);
+
+            const loaded = await backendBinder.loadNotebookFromRef(SimpleOlog, ref);
+            expect(loaded.tag).toBe("Err");
+            dispose();
+        });
+    });
+
+    test("a notebook instantiating a backend document validates via getHandle resolution", async () => {
+        await createRoot(async (dispose) => {
+            const backend = new FakeBackend();
+            const store = createBackendStore(backend, getOwner()!);
+            const backendBinder = createBinder(store);
+            // The imported model lives on the backend the moment it is created.
+            const imported = await backendBinder.createNotebook(SimpleOlog, { name: "Imported" });
+            imported.add(Type, { label: "Thing" });
+
+            // The main notebook instantiates it. `Instantiation` mints a link via
+            // `store.getDocumentRef(imported.handle)`, and `validate` resolves it
+            // back through `store.getHandle` — the backend round-trip under test.
+            // `validate` also resolves the notebook's *own* model by minting a link
+            // to its handle (see `resolveSelf`), which requires a stable ref; since
+            // `createNotebook` registered it, that link is available too.
+            const notebook = await backendBinder.createNotebook(SimpleOlog, { name: "Main" });
+            notebook.add(Type, { label: "A" });
+            notebook.add(Instantiation, { label: "ImportedOlog", model: imported });
+
+            const result = await notebook.validate();
+            expect(result.tag).toBe("Ok");
+            expect(result.tag === "Ok" && result.content).toBeInstanceOf(DblModel);
+            dispose();
+        });
+    });
+});
+
+// Keep `createRoot` imported and exercised so the reactive-primitives path is
+// covered even outside `render` (e.g. a headless consumer of `getDocumentView`).
+describe("headless reactive read", () => {
+    test("getDocumentView is reactive under createRoot", async () => {
+        await createRoot(async (dispose) => {
+            const backend = new FakeBackend();
+            const store = createBackendStore(backend, getOwner()!);
+            const backendBinder = createBinder(store);
+            const notebook = await backendBinder.createNotebook(SimpleOlog, { name: "Headless" });
+
+            expect(notebook.name).toBe("Headless");
+            notebook.update({ name: "Renamed" });
+            expect(notebook.name).toBe("Renamed");
+            dispose();
+        });
+    });
+});
diff --git a/packages/document-methods/test/diagram_notebook.lts.md b/packages/document-methods/test/diagram_notebook.lts.md
new file mode 100644
index 000000000..0bd5203d9
--- /dev/null
+++ b/packages/document-methods/test/diagram_notebook.lts.md
@@ -0,0 +1,253 @@
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, RichText } from "catcolab-documents";
+
+const model = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const A = model.add(Type, { label: "A" });
+const B = model.add(Type, { label: "B" });
+const has = model.add(Aspect, { label: "has", from: A, to: B });
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const diagram = await binder.createNotebook(SimpleOlog.Diagram, {
+    name: "Olog diagram",
+    in: model,
+});
+```
+
+```ts
+console.log("name:", diagram.name);
+console.log("theory:", diagram.theory);
+```
+
+```
+name: Olog diagram
+theory: simple-olog
+```
+
+## Adding cells over the model
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+diagram.add(RichText, { content: "We picture two instances of the olog." });
+
+const x = diagram.add(SimpleOlog.Diagram.Individual, { label: "x", over: A });
+const y = diagram.add(SimpleOlog.Diagram.Individual, { label: "y", over: B });
+```
+
+```ts
+console.log("over:", x.over.label);
+console.log("type:", x.type.obType.content);
+```
+
+```
+over: A
+type: Object
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const f = diagram.add(SimpleOlog.Diagram.Aspect, { from: x, to: y, over: has });
+```
+
+```ts
+console.log("over:", f.over.label);
+console.log("from:", f.from.label);
+console.log("to:", f.to.label);
+```
+
+```
+over: has
+from: x
+to: y
+```
+
+## Validating a diagram
+
+```ts
+const result = await diagram.validate();
+console.log("tag:", result.tag);
+```
+
+```
+tag: Valid
+```
+
+```ts
+const result = await diagram.validate();
+if (result.tag === "Valid") {
+    console.log("objects:", result.diagram.obGenerators().length);
+    console.log("morphisms:", result.diagram.morGenerators().length);
+}
+```
+
+```
+objects: 2
+morphisms: 1
+```
+
+```ts
+import type { DiagramValidationResult } from "catcolab-documents";
+
+function describe(result: DiagramValidationResult): string {
+    switch (result.tag) {
+        case "Valid":
+            return `valid diagram with ${result.diagram.obGenerators().length} objects`;
+        case "Invalid":
+            return `invalid diagram with ${result.errors.length} errors`;
+        case "Illformed":
+            return `ill-formed: ${result.error}`;
+    }
+}
+
+console.log(describe(await diagram.validate()));
+```
+
+```
+valid diagram with 2 objects
+```
+
+## Iterating through cells
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, RichText } from "catcolab-documents";
+
+const model = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+const A = model.add(Type, { label: "A" });
+const B = model.add(Type, { label: "B" });
+const has = model.add(Aspect, { label: "has", from: A, to: B });
+
+const diagram = await binder.createNotebook(SimpleOlog.Diagram, {
+    name: "Olog diagram",
+    in: model,
+});
+
+diagram.add(RichText, { content: "We picture an instance." });
+const x = diagram.add(SimpleOlog.Diagram.Individual, { label: "x", over: A });
+const y = diagram.add(SimpleOlog.Diagram.Individual, { label: "y", over: B });
+diagram.add(SimpleOlog.Diagram.Aspect, { from: x, to: y, over: has });
+```
+
+```ts
+import { CellKind } from "catcolab-documents";
+
+for (const cell of diagram.cells()) {
+    switch (cell.kind) {
+        case CellKind.RichText:
+            console.log("text:", cell.content);
+            break;
+        case CellKind.Object:
+            console.log("individual:", cell.label, "over:", cell.over.label);
+            break;
+        case CellKind.Morphism:
+            console.log(
+                "aspect over:",
+                cell.over.label,
+                "from:",
+                cell.from.label,
+                "to:",
+                cell.to.label,
+            );
+            break;
+    }
+}
+```
+
+```
+text: We picture an instance.
+individual: x over: A
+individual: y over: B
+aspect over: has from: x to: y
+```
+
+## Type safety
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, defineObject, defineShape } from "catcolab-documents";
+
+const model = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+const A = model.add(Type, { label: "A" });
+const B = model.add(Type, { label: "B" });
+const has = model.add(Aspect, { label: "has", from: A, to: B });
+
+// A creatable shape with a `theory` but no `getCoreTheory`: its notebooks cannot be
+// elaborated or validated, so a diagram cannot be drawn in one.
+const Sketch = defineShape({
+    theory: "sketch",
+    objects: [defineObject({ tag: "Basic", content: "Object" })],
+});
+
+const sketch = await binder.createNotebook(Sketch, { name: "A sketch" });
+```
+
+```ts
+const diagram = await binder.createNotebook(SimpleOlog.Diagram, {
+    name: "Olog diagram",
+    in: model,
+});
+```
+
+```ts
+// @ts-expect-error The `in` model must be validatable, but a notebook over a
+// shape without a `getCoreTheory` has no `validate()`.
+await binder.createNotebook(SimpleOlog.Diagram, { name: "bad", in: sketch });
+```
+
+```ts
+const diagram = await binder.createNotebook(SimpleOlog.Diagram, {
+    name: "Olog diagram",
+    in: model,
+});
+
+// @ts-expect-error `over` for an Individual must be a model object, not a morphism.
+diagram.add(SimpleOlog.Diagram.Individual, { label: "bad", over: has });
+```
+
+```ts
+const diagram = await binder.createNotebook(SimpleOlog.Diagram, {
+    name: "Olog diagram",
+    in: model,
+});
+
+const x = diagram.add(SimpleOlog.Diagram.Individual, { label: "x", over: A });
+const y = diagram.add(SimpleOlog.Diagram.Individual, { label: "y", over: B });
+
+// @ts-expect-error Arrays are not valid endpoints in a simple olog diagram.
+diagram.add(SimpleOlog.Diagram.Aspect, { from: [x], to: y, over: has });
+```
+
+A shape only derives a `.Diagram` when it declares `supportsInstances: true`.
+`PetriNet` is over a modal (symmetric-monoidal) theory, for which diagrams are
+not implemented, so it omits the flag and has no `.Diagram`.
+
+```ts
+import { PetriNet } from "catcolab-logics/petri-net";
+
+// @ts-expect-error `PetriNet` does not support instances, so it has no `.Diagram`.
+PetriNet.Diagram;
+```
+
+Likewise `Sketch` declares a `theory` but not `supportsInstances`, so it too has
+no `.Diagram`.
+
+```ts
+// @ts-expect-error `Sketch` does not support instances, so it has no `.Diagram`.
+Sketch.Diagram;
+```
diff --git a/packages/document-methods/test/fake_backend.ts b/packages/document-methods/test/fake_backend.ts
new file mode 100644
index 000000000..c332bb0b9
--- /dev/null
+++ b/packages/document-methods/test/fake_backend.ts
@@ -0,0 +1,62 @@
+// A stand-in for the CatColab backend, modelled on its real RPC surface.
+//
+// The production backend is reached through a Qubit RPC client (see
+// packages/frontend/src/api/rpc.ts and the generated `QubitServer` type in
+// packages/backend/pkg/src/index.ts). Every method returns an `RpcResult<T>`,
+// a tagged `Ok`/`Err` union, and document reads come back as a `RefDoc`, a
+// tagged `Live`/`Readonly` union. We reproduce those shapes here so a store
+// backed by this backend has to unwrap them exactly like
+// `Api.createDoc`/`Api.fetchDocCacheEntry` do.
+//
+// The two methods a store uses:
+//
+//   * `new_ref(content)`: create a document from `content` under a fresh ref id,
+//     returning the ref id (the `_id` of a `StableRef`). Analog of
+//     `rpc.new_ref.mutate`, called by `Api.createDoc`.
+//   * `get_doc(refId)`: resolve a ref id to the Automerge document behind it.
+//     Analog of `rpc.get_doc.query`, whose `docId` the frontend then `find`s.
+//
+// The backend holds its own networked `Repo` in production; here the store and
+// backend share one in-memory `Repo`, and every document is served as `Live`
+// (the store `find`s it by `docId`).
+import { type DocumentId, Repo } from "@automerge/automerge-repo";
+import { v7 } from "uuid";
+
+import type { Document } from "catcolab-document-types";
+
+export type RpcResult<T> =
+    | { tag: "Ok"; content: T }
+    | { tag: "Err"; code: number; message: string };
+
+export type RefDoc = { tag: "Live"; docId: string; isDeleted: boolean };
+
+export class FakeBackend {
+    readonly serverHost = "test.catcolab.org";
+
+    /** The Automerge repo the backend serves documents out of. */
+    readonly repo = new Repo();
+
+    /** ref id -> Automerge document id, the mapping `get_doc` serves. */
+    private readonly refs = new Map<string, DocumentId>();
+
+    /**
+     * Analog of `rpc.new_ref.mutate`: take document *content*, create the repo
+     * document backend-side, and return a fresh ref id. This is what
+     * `Api.createDoc` calls, and what a store's `createHandle` calls.
+     */
+    async new_ref(content: Document): Promise<RpcResult<string>> {
+        const handle = this.repo.create<Document>(content as Document);
+        const refId = v7();
+        this.refs.set(refId, handle.documentId);
+        return { tag: "Ok", content: refId };
+    }
+
+    /** Analog of `rpc.get_doc.query`: ref id -> `RefDoc` (always `Live` here). */
+    async get_doc(refId: string): Promise<RpcResult<RefDoc>> {
+        const docId = this.refs.get(refId);
+        if (!docId) {
+            return { tag: "Err", code: 404, message: `Unknown document ${refId}` };
+        }
+        return { tag: "Ok", content: { tag: "Live", docId, isDeleted: false } };
+    }
+}
diff --git a/packages/document-methods/test/generating_logics.lts.md b/packages/document-methods/test/generating_logics.lts.md
new file mode 100644
index 000000000..fe97a4182
--- /dev/null
+++ b/packages/document-methods/test/generating_logics.lts.md
@@ -0,0 +1,143 @@
+# Defining shapes from a compact spec
+
+A shape is defined from a compact specification of object and morphism types,
+built with `defineObject`/`defineMorphism`. A `Hom` morphism's endpoint object
+type and arity are read from its `MorType` structure; a `Basic` morphism records
+no endpoints in its literal, so it declares them with `defineMorphism(morType, { domain, codomain })`, passing each endpoint's `ObType`.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { binder, defineMorphism, defineObject, defineShape } from "catcolab-documents";
+
+const Entity = defineObject({ tag: "Basic", content: "Entity" });
+const AttrType = defineObject({ tag: "Basic", content: "AttrType" });
+
+const Mapping = defineMorphism({ tag: "Hom", content: Entity.obType });
+const Attr = defineMorphism(
+    { tag: "Basic", content: "Attr" },
+    { domain: Entity.obType, codomain: AttrType.obType },
+);
+const Operation = defineMorphism({ tag: "Hom", content: AttrType.obType });
+
+const SimpleSchema = defineShape({
+    theory: "simple-schema",
+    getCoreTheory: async () => {
+        const { ThSchema } = await import("catlog-wasm");
+        return new ThSchema().theory();
+    },
+    objects: [Entity, AttrType],
+    morphisms: [Mapping, Attr, Operation],
+});
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const notebook = await binder.createNotebook(SimpleSchema, { name: "Company schema" });
+
+const person = notebook.add(Entity, { label: "Person" });
+const company = notebook.add(Entity, { label: "Company" });
+const str = notebook.add(AttrType, { label: "String" });
+const upper = notebook.add(AttrType, { label: "UpperString" });
+
+notebook.add(Mapping, { label: "employer", from: person, to: company });
+notebook.add(Attr, { label: "name", from: person, to: str });
+notebook.add(Operation, { label: "uppercase", from: str, to: upper });
+```
+
+```ts
+const entities = notebook.cellsOf(Entity);
+const operations = notebook.cellsOf(Operation);
+
+console.log("entities:", entities.map((cell) => cell.label).join(", "));
+console.log("operations:", operations.map((cell) => cell.label).join(", "));
+```
+
+```
+entities: Person, Company
+operations: uppercase
+```
+
+Object defs must be built with `defineObject`, not string shorthand.
+
+```ts
+defineShape({
+    theory: "bad-object-shorthand",
+    getCoreTheory: SimpleSchema.getCoreTheory,
+    // @ts-expect-error Object defs must be built with defineObject, not strings.
+    objects: ["Entity"],
+    morphisms: [],
+});
+```
+
+Endpoint types are inferred from each morphism's `MorType`. A `Mapping` is
+`Hom(Entity)`, so its endpoints are `Entity` cells; wiring its codomain to an
+attribute type is rejected.
+
+```ts
+const employer = notebook.add(Mapping, { label: "employer2", from: person, to: company });
+
+// @ts-expect-error A mapping's codomain must be an Entity cell, not an AttrType cell.
+employer.update({ to: str });
+```
+
+An `Operation` is `Hom(AttrType)`, so its domain must be an attribute type.
+
+```ts
+// @ts-expect-error An operation's domain must be an AttrType cell, not an Entity cell.
+notebook.add(Operation, { label: "op2", from: person, to: str });
+```
+
+Endpoint arity is taken from the declared list `modality`: a `Hom` morphism
+given a modality such as `SymmetricList` produces array-valued endpoints.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { binder, defineMorphism, defineObject, defineShape } from "catcolab-documents";
+
+const Place = defineObject({ tag: "Basic", content: "Object" });
+const Transition = defineMorphism(
+    { tag: "Hom", content: Place.obType },
+    {
+        domain: { apply: { tag: "Basic", content: "tensor" }, modality: "SymmetricList" },
+        codomain: { apply: { tag: "Basic", content: "tensor" }, modality: "SymmetricList" },
+    },
+);
+
+const PetriNet = defineShape({
+    theory: "petri-net",
+    getCoreTheory: async () => {
+        const { ThSymMonoidalCategory } = await import("catlog-wasm");
+        return new ThSymMonoidalCategory().theory();
+    },
+    objects: [Place],
+    morphisms: [Transition],
+});
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const notebook = await binder.createNotebook(PetriNet, { name: "Petri net" });
+const a = notebook.add(Place, { label: "A" });
+const b = notebook.add(Place, { label: "B" });
+
+notebook.add(Transition, {
+    label: "fires",
+    from: [a],
+    to: [b],
+});
+```
+
+A transition's endpoints are arrays of places, so a single place is rejected.
+
+```ts
+const fires = notebook.add(Transition, { label: "fires2", from: [a], to: [b] });
+
+// @ts-expect-error A transition endpoint is an array of places, not a single place.
+fires.update({ from: a });
+```
diff --git a/packages/document-methods/test/generic.lts.md b/packages/document-methods/test/generic.lts.md
new file mode 100644
index 000000000..d061e48ab
--- /dev/null
+++ b/packages/document-methods/test/generic.lts.md
@@ -0,0 +1,212 @@
+<!-- verifier:prepend-to-following -->
+
+```ts
+import {
+    binder,
+    CellKind,
+    defineMorphism,
+    defineObject,
+    defineShape,
+    type Notebook,
+} from "catcolab-documents";
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const Object = defineObject({ tag: "Basic", content: "Object" });
+const Aspect = defineMorphism({
+    tag: "Hom",
+    content: { tag: "Basic", content: "Object" },
+});
+
+const Olog = defineShape({
+    theory: "simple-olog",
+    getCoreTheory: async () => {
+        const { ThCategory } = await import("catlog-wasm");
+        return new ThCategory().theory();
+    },
+    objects: [Object],
+    morphisms: [Aspect],
+});
+
+const notebook = await binder.createNotebook(Olog, { name: "A generic notebook" });
+
+// A wide view whose `cells()` yields the untyped `NotebookCell` union.
+const generic: Notebook = notebook;
+```
+
+```ts
+console.log("name:", notebook.name);
+console.log("theory:", notebook.document.theory);
+```
+
+```
+name: A generic notebook
+theory: simple-olog
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const source = notebook.add(Object, { label: "A" });
+const target = notebook.add(Object, { label: "B" });
+
+const arrow = notebook.add(Aspect, {
+    label: "has",
+    from: source,
+    to: target,
+});
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+source.update({ label: "Source" });
+const sourceCopy = source.duplicate();
+sourceCopy.update({ label: "Source copy" });
+```
+
+```ts
+console.log("source:", source.label);
+console.log("source copy:", sourceCopy.label);
+```
+
+```
+source: Source
+source copy: Source copy
+```
+
+```ts
+for (const cell of generic.cells()) {
+    switch (cell.kind) {
+        case CellKind.Object:
+            console.log("object:", cell.label, "type:", cell.type.obType.content);
+            break;
+        case CellKind.Morphism:
+            console.log("morphism:", cell.label, "type tag:", cell.type.morType.tag);
+            break;
+    }
+}
+```
+
+```
+object: Source type: Object
+object: B type: Object
+morphism: has type tag: Hom
+object: Source copy type: Object
+```
+
+```ts
+console.log(generic.cells().length);
+
+sourceCopy.delete();
+arrow.moveTo(0);
+
+console.log(
+    "order:",
+    generic
+        .cells()
+        .map((cell) => (cell.kind === CellKind.RichText ? cell.content : cell.label))
+        .join(", "),
+);
+console.log(generic.cells().length);
+```
+
+```
+4
+order: has, Source, B
+3
+```
+
+```ts
+const result = await notebook.validate();
+console.log("valid:", result.tag === "Ok");
+if (result.tag === "Ok") {
+    console.log("objects:", result.content.obGenerators().length);
+    console.log("morphisms:", result.content.morGenerators().length);
+}
+```
+
+```
+valid: true
+objects: 3
+morphisms: 1
+```
+
+<!-- verifier:reset -->
+
+```ts
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, CellKind, type Notebook } from "catcolab-documents";
+
+const typed = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+typed.add(Type, { label: "A" });
+
+// A notebook over the full Olog shape is assignable to a notebook over the
+// widest shape, so code that does not need the static typing can take it.
+const generic: Notebook = typed;
+generic.update({ name: "Renamed via generic interface" });
+
+console.log("name:", generic.name);
+console.log("objects:", generic.cells().filter((cell) => cell.kind === CellKind.Object).length);
+```
+
+```
+name: Renamed via generic interface
+objects: 1
+```
+
+### Validation and migration require a core theory
+
+A shape elaborates into its `getCoreTheory`, so `validate()` and `migrateTo()` are
+only available on a notebook whose shape declares one. A shape with a `theory`
+but no `getCoreTheory` can still create and edit notebooks, but calling either is a
+compile error. The same requirement applies to an instantiation's `model`: an
+instantiation resolves its referenced model by validating it, so only a
+validatable notebook (one whose shape declares a `getCoreTheory`) may be used.
+
+<!-- verifier:reset -->
+
+```ts
+import {
+    binder,
+    defineMorphism,
+    defineObject,
+    defineShape,
+    Instantiation,
+} from "catcolab-documents";
+
+const Obj = defineObject({ tag: "Basic", content: "Object" });
+const Mor = defineMorphism({ tag: "Hom", content: Obj.obType });
+
+const NoCore = defineShape({ theory: "no-core", objects: [Obj], morphisms: [Mor] });
+const WithCore = defineShape({
+    theory: "with-core",
+    getCoreTheory: async () => {
+        const { ThCategory } = await import("catlog-wasm");
+        return new ThCategory().theory();
+    },
+    objects: [Obj],
+    morphisms: [Mor],
+});
+
+const noCore = await binder.createNotebook(NoCore, { name: "No core theory" });
+const host = await binder.createNotebook(WithCore, { name: "Host" });
+const core = await binder.createNotebook(WithCore, { name: "Core model" });
+
+// @ts-expect-error A shape without a `getCoreTheory` cannot be validated.
+await noCore.validate();
+
+// @ts-expect-error A shape without a `getCoreTheory` cannot be migrated.
+await noCore.migrateTo(NoCore);
+
+// A validatable notebook is accepted as an instantiation model.
+host.add(Instantiation, { label: "ok", model: core });
+
+// @ts-expect-error An instantiation model must be validatable (its shape needs a `getCoreTheory`).
+host.add(Instantiation, { label: "bad", model: noCore });
+
+// @ts-expect-error An instantiation model must be a notebook, not a link.
+host.add(Instantiation, { label: "linked", model: { _id: "x", _version: null, _server: "" } });
+```
diff --git a/packages/document-methods/test/generic_list.lts.md b/packages/document-methods/test/generic_list.lts.md
new file mode 100644
index 000000000..d2f1f2afc
--- /dev/null
+++ b/packages/document-methods/test/generic_list.lts.md
@@ -0,0 +1,293 @@
+# A function written against a list shape
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { defineMorphism, defineObject, defineShape, type Notebook } from "catcolab-documents";
+
+const BasicObj = defineObject({ tag: "Basic", content: "Object" });
+
+const tensor = { tag: "Basic", content: "tensor" } as const;
+
+const ListMor = defineMorphism(
+    { tag: "Hom", content: BasicObj.obType },
+    {
+        domain: { apply: tensor, modality: "List" },
+        codomain: { apply: tensor, modality: "List" },
+    },
+);
+
+const ListShape = defineShape({
+    objects: [BasicObj],
+    morphisms: [ListMor],
+});
+
+const SymmetricListMor = defineMorphism(
+    { tag: "Hom", content: BasicObj.obType },
+    {
+        domain: { apply: tensor, modality: "SymmetricList" },
+        codomain: { apply: tensor, modality: "SymmetricList" },
+    },
+);
+const SymmetricListShape = defineShape({
+    objects: [BasicObj],
+    morphisms: [SymmetricListMor],
+});
+
+const CocartesianListMor = defineMorphism(
+    { tag: "Hom", content: BasicObj.obType },
+    {
+        domain: { apply: tensor, modality: "CocartesianList" },
+        codomain: { apply: tensor, modality: "CocartesianList" },
+    },
+);
+
+const CocartesianListShape = defineShape({
+    objects: [BasicObj],
+    morphisms: [CocartesianListMor],
+});
+
+const CartesianListMor = defineMorphism(
+    { tag: "Hom", content: BasicObj.obType },
+    {
+        domain: { apply: tensor, modality: "CartesianList" },
+        codomain: { apply: tensor, modality: "CartesianList" },
+    },
+);
+
+const CartesianListShape = defineShape({
+    objects: [BasicObj],
+    morphisms: [CartesianListMor],
+});
+
+const AdditiveListMor = defineMorphism(
+    { tag: "Hom", content: BasicObj.obType },
+    {
+        domain: { apply: tensor, modality: "AdditiveList" },
+        codomain: { apply: tensor, modality: "AdditiveList" },
+    },
+);
+
+const AdditiveListShape = defineShape({
+    objects: [BasicObj],
+    morphisms: [AdditiveListMor],
+});
+```
+
+<!-- verifier:prepend-to-following -->
+
+`addListMorphism` works on any notebook that supports any of the morphisms our
+list shapes support. When implementing a generic consumer like this we need to
+narrow down what object and morphism types the notebook actually supports by
+using `notebook.supports`.
+
+```ts
+type NotebookOfLists = Notebook<
+    | typeof ListShape
+    | typeof SymmetricListShape
+    | typeof CocartesianListShape
+    | typeof CartesianListShape
+    | typeof AdditiveListShape,
+    unknown
+>;
+
+function addListMorphism(notebook: NotebookOfLists) {
+    const a = notebook.add(BasicObj, { label: "A" });
+    const b = notebook.add(BasicObj, { label: "B" });
+    const c = notebook.add(BasicObj, { label: "C" });
+
+    if (notebook.supports(ListMor)) {
+        notebook.add(ListMor, { label: "L", from: [a, b], to: [c] });
+    } else if (notebook.supports(SymmetricListMor)) {
+        console.log("Adding SymmetricListMor!");
+        notebook.add(SymmetricListMor, { label: "L", from: [a, b], to: [c] });
+    } else if (notebook.supports(CocartesianListMor)) {
+        notebook.add(CocartesianListMor, { label: "L", from: [a, b], to: [c] });
+    } else if (notebook.supports(CartesianListMor)) {
+        notebook.add(CartesianListMor, { label: "L", from: [a, b], to: [c] });
+    } else if (notebook.supports(AdditiveListMor)) {
+        notebook.add(AdditiveListMor, { label: "L", from: [a, b], to: [c] });
+    } else {
+        // If the code type checked this should be unreachable.
+        throw new Error("Did not find any supported List morphism in the notebook.");
+    }
+}
+```
+
+```ts
+function badAddListMorphism(notebook: NotebookOfLists) {
+    const a = notebook.add(BasicObj, { label: "A" });
+    const b = notebook.add(BasicObj, { label: "B" });
+    const c = notebook.add(BasicObj, { label: "C" });
+
+    //@ts-expect-error Not all variants support adding a `ListMor`. You need to narrow the type using the `supports` method.
+    notebook.add(ListMor, { label: "L", from: [a, b], to: [c] });
+}
+```
+
+## A structurally compatible notebook is accepted and the appropriate morphism is added.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { binder } from "catcolab-documents";
+import { PetriNet } from "catcolab-logics/petri-net";
+
+const petriNet = await binder.createNotebook(PetriNet, { name: "example" });
+
+addListMorphism(petriNet);
+```
+
+```
+Adding SymmetricListMor!
+```
+
+```ts
+const entityObType = defineObject({ tag: "Basic", content: "Entity" });
+const EntityObjectShape = defineShape({
+    theory: "entity-objects",
+    objects: [entityObType, BasicObj],
+    morphisms: [ListMor],
+});
+
+const entityObjects = await binder.createNotebook(EntityObjectShape, { name: "example" });
+
+addListMorphism(entityObjects);
+```
+
+## A structurally incompatible notebook should be rejected
+
+```ts
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+
+const simpleOlog = await binder.createNotebook(SimpleOlog, { name: "example" });
+
+// @ts-expect-error A SimpleOlog notebook lacks the list-valued morphisms ListShape requires.
+addListMorphism(simpleOlog);
+```
+
+```ts
+const JustObjectShape = defineShape({
+    theory: "just-objects",
+    objects: [BasicObj],
+});
+
+const justObjects = await binder.createNotebook(JustObjectShape, { name: "example" });
+
+// @ts-expect-error We have no morphisms in `JustObjectShape`.
+addListMorphism(justObjects);
+```
+
+```ts
+const JustMorphismShape = defineShape({
+    theory: "just-morphisms",
+    morphisms: [ListMor],
+});
+
+const justMorphisms = await binder.createNotebook(JustMorphismShape, { name: "example" });
+
+// @ts-expect-error We have no objects in `JustMorphismShape`.
+addListMorphism(justMorphisms);
+```
+
+```ts
+const EntityObj = defineObject({ tag: "Basic", content: "Entity" });
+
+const EntityListMor = defineMorphism(
+    { tag: "Hom", content: EntityObj.obType },
+    {
+        domain: { apply: tensor, modality: "List" },
+        codomain: { apply: tensor, modality: "List" },
+    },
+);
+
+const MultiObjectListShape = defineShape({
+    objects: [BasicObj, EntityObj],
+    morphisms: [ListMor, EntityListMor],
+});
+
+function badAddListMorphism2(notebook: Notebook<typeof MultiObjectListShape, unknown>) {
+    const a = notebook.add(BasicObj, { label: "A" });
+    const b = notebook.add(BasicObj, { label: "B" });
+    const e = notebook.add(EntityObj, { label: "E" });
+
+    notebook.add(ListMor, { label: "L1", from: [a, b], to: [b] });
+    //@ts-expect-error We can't use an EntityObj with a ListMor
+    notebook.add(ListMor, { label: "L2", from: [a, b], to: [e] });
+}
+```
+
+```ts
+const entityObType = defineObject({ tag: "Basic", content: "Entity" });
+
+const entityListMorType = defineMorphism(
+    { tag: "Hom", content: entityObType.obType },
+    {
+        domain: { apply: tensor, modality: "List" },
+        codomain: { apply: tensor, modality: "List" },
+    },
+);
+
+const EntityObjectListShape = defineShape({
+    objects: [entityObType],
+    morphisms: [entityListMorType],
+});
+
+type NotebookOfListsWithEntity = Notebook<
+    | typeof ListShape
+    | typeof SymmetricListShape
+    | typeof CocartesianListShape
+    | typeof CartesianListShape
+    | typeof AdditiveListShape
+    | typeof EntityObjectListShape,
+    unknown
+>;
+
+const EntityObj = entityObType;
+
+function goodAddObject(notebook: NotebookOfListsWithEntity) {
+    if (notebook.supports(BasicObj)) {
+        notebook.add(BasicObj, { label: "A" });
+    }
+
+    if (notebook.supports(EntityObj)) {
+        notebook.add(EntityObj, { label: "E" });
+    }
+}
+
+const BothObjectsShape = defineShape({
+    objects: [BasicObj, entityObType],
+});
+
+function goodAddObject2(notebook: NotebookOfListsWithEntity) {
+    if (notebook.supports(BothObjectsShape)) {
+        notebook.add(BasicObj, { label: "A" });
+        notebook.add(EntityObj, { label: "E" });
+    }
+}
+
+type JustEntityObjectListShape = Notebook<typeof EntityObjectListShape, unknown>;
+
+function goodAddObject3(notebook: JustEntityObjectListShape) {
+    notebook.add(EntityObj, { label: "E" });
+}
+
+function badAddObject(notebook: NotebookOfListsWithEntity) {
+    //@ts-expect-error We can't add a BasicObj without narrowing the notebook type because EntityObjectListShape does not support BasicObj.
+    notebook.add(BasicObj, { label: "A" });
+
+    //@ts-expect-error We can't add a EntityObj without narrowing the notebook type because not all notebooks support EntityObj.
+    notebook.add(EntityObj, { label: "E" });
+}
+
+function badAddObject2(notebook: Notebook<typeof BothObjectsShape, unknown>) {
+    const a = notebook.add(BasicObj, { label: "A" });
+    const b = notebook.add(BasicObj, { label: "B" });
+
+    //@ts-expect-error BothObjectsShape can never support CocartesianListMor.
+    if (notebook.supports(CocartesianListMor)) {
+        //@ts-expect-error BothObjectsShape does not support CocartesianListMor.
+        notebook.add(CocartesianListMor, { label: "L", from: [a, b], to: [b] });
+    }
+}
+```
diff --git a/packages/document-methods/test/instance.lts.md b/packages/document-methods/test/instance.lts.md
new file mode 100644
index 000000000..e876e1db2
--- /dev/null
+++ b/packages/document-methods/test/instance.lts.md
@@ -0,0 +1,90 @@
+# Instance documents
+
+An _instance_ is a database of a schema: where a schema declares entities,
+mappings, and attributes, an instance holds the actual _rows_. It is created
+from a schema notebook with `binder.createInstance`, and `add` inserts a row for
+a schema entity, wiring the schema's mappings and attributes inline.
+
+First we build a schema.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { binder } from "catcolab-documents";
+import { Attr, AttrType, Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+
+const schema = await binder.createNotebook(SimpleSchema, { name: "Company schema" });
+const person = schema.add(Entity, { label: "Person" });
+const company = schema.add(Entity, { label: "Company" });
+const str = schema.add(AttrType, { label: "String" });
+
+schema.add(Mapping, { label: "employer", from: person, to: company });
+schema.add(Attr, { label: "name", from: person, to: str });
+```
+
+An instance is created from the schema itself — it takes its shape and its
+reference to the schema from that notebook, so we pass only a name.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const instance = await binder.createInstance(schema, { name: "Company instance" });
+
+const acme = instance.add(company, {});
+const fred = instance.add(person, { name: "Fred", employer: acme });
+```
+
+`instance.add(company, {})` inserts a `Company` row. `instance.add(person, {
+name: "Fred", employer: acme })` inserts a `Person` row, then reads the schema's
+outgoing mappings and attributes by name: `employer` (a mapping) points the row
+at `acme`, while `name` (an attribute) records the literal `"Fred"`. Rows are
+never named.
+
+```ts
+console.log("theory:", instance.theory);
+console.log("fred entity:", fred.entity.label);
+console.log("acme entity:", acme.entity.label);
+```
+
+```
+theory: simple-schema
+fred entity: Person
+acme entity: Company
+```
+
+We can list the instance's rows with `rows()`, or just those of one entity with
+`rowsOf(entity)`, and read a row's mapping and attribute values.
+
+```ts
+import type { Row } from "catcolab-documents";
+
+console.log("row count:", instance.rows().length);
+console.log("person rows:", instance.rowsOf(person).length);
+
+const values = fred.values;
+const employer = values["employer"] as Row;
+console.log("name:", values["name"]);
+console.log("employer is acme:", employer.id === acme.id);
+console.log("employer entity:", employer.entity.label);
+```
+
+```
+row count: 2
+person rows: 1
+name: Fred
+employer is acme: true
+employer entity: Company
+```
+
+Finally, the instance validates against its schema.
+
+```ts
+const result = await instance.validate();
+console.log("valid:", result.tag);
+```
+
+```
+valid: Valid
+```
diff --git a/packages/document-methods/test/instance.test.ts b/packages/document-methods/test/instance.test.ts
new file mode 100644
index 000000000..e10acd8c8
--- /dev/null
+++ b/packages/document-methods/test/instance.test.ts
@@ -0,0 +1,153 @@
+import { binder } from "catcolab-documents";
+import { Attr, AttrType, Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { describe, expect, test } from "vitest";
+
+describe("instance notebooks", () => {
+    test("createInstance inserts rows with mapping and attribute values", async () => {
+        const schema = await binder.createNotebook(SimpleSchema, { name: "Company schema" });
+        const person = schema.add(Entity, { label: "Person" });
+        const company = schema.add(Entity, { label: "Company" });
+        const str = schema.add(AttrType, { label: "String" });
+
+        schema.add(Mapping, { label: "employer", from: person, to: company });
+        schema.add(Attr, { label: "name", from: person, to: str });
+
+        const instance = await binder.createInstance(schema, { name: "Company instance" });
+        const acme = instance.add(company, {});
+        const fred = instance.add(person, { name: "Fred", employer: acme });
+
+        expect(instance.theory).toBe("simple-schema");
+
+        // Rows are of their schema entity; value rows (the "Fred" attribute
+        // value) are not listed as rows.
+        expect(fred.entity?.label).toBe("Person");
+        expect(acme.entity?.label).toBe("Company");
+        expect(instance.rows().length).toBe(2);
+        expect(instance.rowsOf(person).length).toBe(1);
+        expect(instance.rowsOf(company).length).toBe(1);
+
+        // A mapping value is the target row; an attribute value is the literal.
+        const values = fred.values;
+        expect(values["name"]).toBe("Fred");
+        expect((values["employer"] as { id: string }).id).toBe(acme.id);
+
+        const result = await instance.validate();
+        expect(result.tag).toBe("Valid");
+    });
+
+    test("loadInstance restores a dumped instance over a reloaded schema", async () => {
+        const schema = await binder.createNotebook(SimpleSchema, { name: "Company schema" });
+        const person = schema.add(Entity, { label: "Person" });
+        const company = schema.add(Entity, { label: "Company" });
+        const str = schema.add(AttrType, { label: "String" });
+        schema.add(Mapping, { label: "employer", from: person, to: company });
+        schema.add(Attr, { label: "name", from: person, to: str });
+
+        const instance = await binder.createInstance(schema, { name: "Company instance" });
+        const acme = instance.add(company, {});
+        instance.add(person, { name: "Fred", employer: acme });
+
+        // Persist both documents (as the demo does through localStorage) and
+        // rebuild them from those detached dumps.
+        const schemaDump = JSON.parse(JSON.stringify(schema.dump()));
+        const instanceDump = JSON.parse(JSON.stringify(instance.dump()));
+
+        const loadedSchema = await binder.loadNotebook(SimpleSchema, schemaDump);
+        if (loadedSchema.tag !== "Ok") {
+            throw new Error("schema failed to reload");
+        }
+        const reloaded = await binder.loadInstance(loadedSchema.content, instanceDump);
+
+        const reloadedPerson = loadedSchema.content
+            .cellsOf(Entity)
+            .find((c) => c.label === "Person");
+        const reloadedCompany = loadedSchema.content
+            .cellsOf(Entity)
+            .find((c) => c.label === "Company");
+        if (!reloadedPerson || !reloadedCompany) {
+            throw new Error("reloaded schema missing entities");
+        }
+
+        expect(reloaded.rows().length).toBe(2);
+        expect(reloaded.rowsOf(reloadedPerson).length).toBe(1);
+        expect(reloaded.rowsOf(reloadedCompany).length).toBe(1);
+
+        const fredRow = reloaded.rowsOf(reloadedPerson)[0];
+        expect(fredRow?.values["name"]).toBe("Fred");
+
+        // The reloaded instance still validates against its reloaded schema.
+        const result = await reloaded.validate();
+        expect(result.tag).toBe("Valid");
+    });
+
+    test("deleting a schema morphism hides its column but retains the data", async () => {
+        const schema = await binder.createNotebook(SimpleSchema, { name: "Company schema" });
+        const person = schema.add(Entity, { label: "Person" });
+        const str = schema.add(AttrType, { label: "String" });
+        const nameAttr = schema.add(Attr, { label: "name", from: person, to: str });
+
+        const instance = await binder.createInstance(schema, { name: "Company instance" });
+        const fred = instance.add(person, { name: "Fred" });
+        expect(fred.values["name"]).toBe("Fred");
+
+        // Capture the generators' UUIDs now: a cell handle's `id` reads through
+        // to the live model, so it goes `undefined` once the cell is deleted.
+        const attrId = nameAttr.id;
+        const personId = person.id;
+        const strId = str.id;
+        const fredId = fred.id;
+
+        // The attribute is stored in the instance document as a triple, keyed by
+        // the schema morphism's generator UUID.
+        const findCell = () =>
+            instance.document.entries.find(
+                (e) =>
+                    e.subject === fredId &&
+                    e.property.tag === "MorphismRef" &&
+                    e.property.content === attrId,
+            );
+        const storedCell = structuredClone(findCell());
+        expect(storedCell).toBeDefined();
+        // The row's membership is itself a triple: an `EntityOf` predicate whose
+        // value references the schema object the row is a record of.
+        expect(
+            instance.document.entries.some(
+                (e) =>
+                    e.subject === fredId &&
+                    e.property.tag === "EntityOf" &&
+                    e.value.tag === "ObjectRef" &&
+                    e.value.content === personId,
+            ),
+        ).toBe(true);
+
+        // Delete the schema morphism. The morphism generator is gone, so the
+        // column is no longer displayed: `values` omits it.
+        const attrCell = schema.cellsOf(Attr).find((c) => c.id === attrId);
+        attrCell?.delete();
+        expect(schema.cellsOf(Attr).length).toBe(0);
+        expect(fred.values["name"]).toBeUndefined();
+
+        // But the triple itself is untouched in the instance document: it was
+        // hidden, not lost. It is identified by the morphism's UUID, which can
+        // never be confused with any other generator.
+        expect(findCell()).toEqual(storedCell);
+
+        // Restoring the morphism generator (as undo/redo/rollback would, keeping
+        // the same UUID) automatically re-associates the retained data — no
+        // diffing of elaborated models is required.
+        schema.document.notebook.cellContents[attrId] = {
+            tag: "formal",
+            id: attrId,
+            content: {
+                tag: "morphism",
+                id: attrId,
+                name: "name",
+                morType: { tag: "Basic", content: "Attr" },
+                dom: { tag: "Basic", content: personId },
+                cod: { tag: "Basic", content: strId },
+            },
+        };
+        schema.document.notebook.cellOrder.push(attrId);
+        expect(fred.values["name"]).toBe("Fred");
+    });
+});
diff --git a/packages/document-methods/test/instantiation_validation.test.ts b/packages/document-methods/test/instantiation_validation.test.ts
new file mode 100644
index 000000000..469315b10
--- /dev/null
+++ b/packages/document-methods/test/instantiation_validation.test.ts
@@ -0,0 +1,236 @@
+import { binder, createBinder, type DocumentStore, Instantiation } from "catcolab-documents";
+import { PetriNet, Place } from "catcolab-logics/petri-net";
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { Entity, SimpleSchema } from "catcolab-logics/simple-schema";
+import { v7 } from "uuid";
+import { describe, expect, test } from "vitest";
+
+import type { Document } from "catcolab-document-types";
+import { DblModel } from "catlog-wasm";
+
+// A bespoke store augmented with `getHandle`, so notebooks containing
+// instantiation cells can be validated. Handles are registered by a stable id;
+// the store contributes only how to fetch a handle by link (`getHandle`, whose
+// document the resolver reads with `getDocumentView`). The shared recursive
+// elaborator (the same one the plain store uses) walks the referenced model's
+// own instantiations, elaborates each against the host notebook's core theory
+// (supplied by `validate`), and detects cycles, so this store reimplements none
+// of that.
+//
+// `failOnResolve` makes `getHandle` return `undefined`, so resolution rejects
+// with "unknown model" and `validate` reports `Illformed` — modelling a store
+// that cannot fetch a referenced document.
+function createResolvingStore(): {
+    store: DocumentStore<Document>;
+    failOnResolve: { value: boolean };
+} {
+    // Each handle gets a stable id when `createHandle` registers it, so
+    // `getDocumentRef` is a plain lookup and `getHandle` its inverse.
+    const ids = new WeakMap<Document, string>();
+    const byId = new Map<string, Document>();
+    const listeners = new WeakMap<Document, Set<() => void>>();
+    const failOnResolve = { value: false };
+
+    const store: DocumentStore<Document> = {
+        createHandle: async (initialDoc) => {
+            const doc = initialDoc as Document;
+            const id = v7();
+            ids.set(doc, id);
+            byId.set(id, doc);
+            return doc;
+        },
+        getHandle: async (ref) => {
+            const handle = failOnResolve.value ? undefined : byId.get(ref.id);
+            return handle
+                ? { tag: "Ok", content: handle }
+                : {
+                      tag: "Err",
+                      content: [{ message: `Cannot resolve reference "${ref.id}".`, path: ["id"] }],
+                  };
+        },
+        getDocumentView: (handle) => handle,
+        changeDocument: (handle, fn) => {
+            fn(handle);
+            for (const listener of Array.from(listeners.get(handle) ?? [])) {
+                listener();
+            }
+        },
+        subscribe: (handle, callback) => {
+            let set = listeners.get(handle);
+            if (!set) {
+                set = new Set();
+                listeners.set(handle, set);
+            }
+            set.add(callback);
+            return () => {
+                set.delete(callback);
+            };
+        },
+        copyValue: (_handle, value) => structuredClone(value),
+        getDocumentRef: (handle) => {
+            let id = ids.get(handle);
+            if (!id) {
+                id = v7();
+                ids.set(handle, id);
+                byId.set(id, handle);
+            }
+            return { id, version: null, server: "" };
+        },
+    };
+
+    return { store, failOnResolve };
+}
+
+describe("instantiation validation", () => {
+    test("a notebook with an instantiation validates to Valid", async () => {
+        const { store } = createResolvingStore();
+        const resolvingBinder = createBinder(store);
+
+        const imported = await resolvingBinder.createNotebook(SimpleOlog, {
+            name: "Imported",
+        });
+        imported.add(Type, { label: "Thing" });
+
+        const notebook = await resolvingBinder.createNotebook(SimpleOlog, {
+            name: "Main",
+        });
+        notebook.add(Type, { label: "A" });
+        notebook.add(Instantiation, {
+            label: "ImportedOlog",
+            model: imported,
+        });
+
+        const result = await notebook.validate();
+        expect(result.tag).toBe("Ok");
+        expect(result.tag === "Ok" && result.content).toBeInstanceOf(DblModel);
+    });
+
+    test("the plain store resolves an instantiation of a locally-validated model", async () => {
+        const imported = await binder.createNotebook(SimpleOlog, { name: "Imported" });
+        imported.add(Type, { label: "Thing" });
+        // Validating the imported notebook elaborates it; the plain store caches
+        // the resulting model so the instantiation below can resolve it.
+        expect((await imported.validate()).tag).toBe("Ok");
+
+        const notebook = await binder.createNotebook(SimpleOlog, { name: "Main" });
+        notebook.add(Type, { label: "A" });
+        notebook.add(Instantiation, { label: "ImportedOlog", model: imported });
+
+        const result = await notebook.validate();
+        expect(result.tag).toBe("Ok");
+        expect(result.tag === "Ok" && result.content).toBeInstanceOf(DblModel);
+    });
+
+    test("a failed resolution is reported as Illformed", async () => {
+        const { store, failOnResolve } = createResolvingStore();
+        const resolvingBinder = createBinder(store);
+
+        const imported = await resolvingBinder.createNotebook(SimpleOlog, {
+            name: "Imported",
+        });
+        imported.add(Type, { label: "Thing" });
+
+        const notebook = await resolvingBinder.createNotebook(SimpleOlog, {
+            name: "Main",
+        });
+        notebook.add(Instantiation, { label: "ImportedOlog", model: imported });
+
+        failOnResolve.value = true;
+        const result = await notebook.validate();
+        expect(result.tag).toBe("Err");
+        expect(
+            result.tag === "Err" && result.content.map((issue) => issue.message).join("; "),
+        ).toContain("unknown model");
+    });
+
+    test("resolution elaborates instantiations against the host notebook's theory", async () => {
+        const { store } = createResolvingStore();
+        const resolvingBinder = createBinder(store);
+
+        // A Petri-net notebook instantiating another Petri-net model: every
+        // instantiation is validatable against the host's core theory
+        // (`ThSymMonoidalCategory`), which `validate` threads through resolution.
+        const imported = await resolvingBinder.createNotebook(PetriNet, {
+            name: "Imported",
+        });
+        imported.add(Place, { label: "S" });
+
+        const notebook = await resolvingBinder.createNotebook(PetriNet, { name: "Main" });
+        notebook.add(Place, { label: "A" });
+        notebook.add(Instantiation, { label: "ImportedNet", model: imported });
+
+        const result = await notebook.validate();
+        expect(result.tag).toBe("Ok");
+        expect(result.tag === "Ok" && result.content).toBeInstanceOf(DblModel);
+    });
+
+    test("a schema can instantiate an olog because their theories are compatible", async () => {
+        const { store } = createResolvingStore();
+        const resolvingBinder = createBinder(store);
+
+        // The olog's `ThCategory` embeds into the schema's `ThSchema`, so the
+        // instantiated olog is validatable against the host schema's core
+        // theory — the single theory `validate` threads through resolution.
+        const imported = await resolvingBinder.createNotebook(SimpleOlog, {
+            name: "Imported",
+        });
+        imported.add(Type, { label: "Thing" });
+
+        const notebook = await resolvingBinder.createNotebook(SimpleSchema, {
+            name: "Main",
+        });
+        notebook.add(Entity, { label: "A" });
+        notebook.add(Instantiation, { label: "ImportedOlog", model: imported });
+
+        const result = await notebook.validate();
+        expect(result.tag).toBe("Ok");
+        expect(result.tag === "Ok" && result.content).toBeInstanceOf(DblModel);
+    });
+
+    test("resolution recursively resolves the referenced model's own instantiations", async () => {
+        const { store } = createResolvingStore();
+        const resolvingBinder = createBinder(store);
+
+        // `inner` <- `imported` <- `main`: resolving `imported` must in turn
+        // resolve its instantiation of `inner`, so it elaborates against a
+        // populated map rather than an empty one.
+        const inner = await resolvingBinder.createNotebook(SimpleOlog, { name: "Inner" });
+        inner.add(Type, { label: "Thing" });
+
+        const imported = await resolvingBinder.createNotebook(SimpleOlog, {
+            name: "Imported",
+        });
+        imported.add(Type, { label: "B" });
+        imported.add(Instantiation, { label: "InnerOlog", model: inner });
+
+        const notebook = await resolvingBinder.createNotebook(SimpleOlog, {
+            name: "Main",
+        });
+        notebook.add(Type, { label: "A" });
+        notebook.add(Instantiation, { label: "ImportedOlog", model: imported });
+
+        const result = await notebook.validate();
+        expect(result.tag).toBe("Ok");
+        expect(result.tag === "Ok" && result.content).toBeInstanceOf(DblModel);
+    });
+
+    test("a cyclic instantiation is detected and reported as Illformed", async () => {
+        const { store } = createResolvingStore();
+        const resolvingBinder = createBinder(store);
+
+        // A instantiates C and C instantiates A: a cycle. The resolver tracks
+        // ids whose resolution is in progress and rejects when one recurs.
+        const a = await resolvingBinder.createNotebook(SimpleOlog, { name: "A" });
+        const c = await resolvingBinder.createNotebook(SimpleOlog, { name: "C" });
+        a.add(Type, { label: "TA" });
+        c.add(Type, { label: "TC" });
+        a.add(Instantiation, { label: "toC", model: c });
+        c.add(Instantiation, { label: "toA", model: a });
+
+        const result = await a.validate();
+        expect(result.tag).toBe("Err");
+        expect(
+            result.tag === "Err" && result.content.map((issue) => issue.message).join("; "),
+        ).toContain("Instantiation cycle detected");
+    });
+});
diff --git a/packages/document-methods/test/js_runtime_validation.test.js b/packages/document-methods/test/js_runtime_validation.test.js
new file mode 100644
index 000000000..326a71b14
--- /dev/null
+++ b/packages/document-methods/test/js_runtime_validation.test.js
@@ -0,0 +1,94 @@
+import { binder } from "catcolab-documents";
+import { PetriNet, Place, Transition } from "catcolab-logics/petri-net";
+import { AttrType, Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { describe, expect, test } from "vitest";
+
+// The typed `add` API catches endpoint mistakes at *compile time* (see
+// `typed_api_endpoint_safety.lts.md`). But a plain-JavaScript caller gets no
+// TypeScript checking, so those same mistakes would slip through and silently
+// corrupt the document. These tests call the documents API from untyped JS with
+// the three classes of endpoint mistake and assert that each is rejected at
+// runtime.
+//
+// Error contract: `add` throws on invalid input, and the thrown error carries a
+// Standard Schema (https://standardschema.dev) shaped `issues` array — each
+// issue an `{ message, path? }` — so callers inspect failures vendor-neutrally
+// without importing anything validator-specific.
+//
+// The runtime `add` (src/future/notebook.ts) validates its arguments with
+// ArkType (src/future/validation.ts) and throws a `ValidationError` carrying
+// that `issues` array, so each call below is rejected rather than silently
+// corrupting the document.
+
+/**
+ * Assert that `fn` throws an error carrying a Standard Schema `issues` array.
+ */
+function expectValidationError(fn) {
+    let thrown;
+    try {
+        fn();
+    } catch (error) {
+        thrown = error;
+    }
+    expect(thrown, "expected a validation error to be thrown").toBeDefined();
+    // The failure surfaces a Standard Schema `FailureResult.issues`: a non-empty
+    // array of issues, each with a string `message` (and an optional `path`).
+    expect(Array.isArray(thrown.issues), "thrown error should carry an `issues` array").toBe(true);
+    expect(thrown.issues.length).toBeGreaterThan(0);
+    for (const issue of thrown.issues) {
+        expect(typeof issue.message).toBe("string");
+        // `path` is optional; when present it must be an array. Asserted
+        // unconditionally (rather than inside an `if`) so the expectation always
+        // runs — the tests calling this are async, and a conditional `expect`
+        // there is flagged by `vitest/no-conditional-expect`.
+        expect(issue.path === undefined || Array.isArray(issue.path)).toBe(true);
+    }
+}
+
+describe("documents API runtime validation from JS", () => {
+    test("Bug 1: an endpoint of the wrong object type is rejected at runtime", async () => {
+        const notebook = await binder.createNotebook(SimpleSchema, { name: "Schema" });
+        const person = notebook.add(Entity, { label: "Person" });
+        const age = notebook.add(AttrType, { label: "Age" });
+
+        // A Mapping's codomain must be an Entity cell, not an AttrType cell.
+        expectValidationError(() => {
+            notebook.add(Mapping, { label: "broken", from: person, to: age });
+        });
+    });
+
+    test("Bug 2: a single object where an endpoint list is required is rejected at runtime", async () => {
+        const notebook = await binder.createNotebook(PetriNet, { name: "Net" });
+        const a = notebook.add(Place, { label: "A" });
+        const c = notebook.add(Place, { label: "C" });
+
+        // A transition endpoint is an array of Place cells, not a single Place.
+        expectValidationError(() => {
+            notebook.add(Transition, { label: "fires", from: a, to: [c] });
+        });
+    });
+
+    test("Bug 3: a cell from another theory is rejected at runtime", async () => {
+        const net = await binder.createNotebook(PetriNet, { name: "Net" });
+        const place = net.add(Place, { label: "A place" });
+
+        const schema = await binder.createNotebook(SimpleSchema, { name: "Schema" });
+        const person = schema.add(Entity, { label: "Person" });
+
+        // `place` is a Place cell from another theory; a Mapping endpoint needs
+        // an Entity cell.
+        expectValidationError(() => {
+            schema.add(Mapping, { label: "tangled", from: person, to: place });
+        });
+    });
+
+    test("a missing required field is rejected at runtime", async () => {
+        const notebook = await binder.createNotebook(SimpleSchema, { name: "Schema" });
+
+        // An object cell requires a `label`; omitting it should be a validation
+        // error rather than a cell with `label: undefined`.
+        expectValidationError(() => {
+            notebook.add(Entity, {});
+        });
+    });
+});
diff --git a/packages/document-methods/test/literate-ts/catcolab-analyses/index.ts b/packages/document-methods/test/literate-ts/catcolab-analyses/index.ts
new file mode 100644
index 000000000..520e500f5
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-analyses/index.ts
@@ -0,0 +1,4 @@
+export { Visualization } from "./visualization";
+export type { VisualizationParams, VisualizationResult } from "./visualization";
+
+export { MassActionDynamics } from "./mass-action";
diff --git a/packages/document-methods/test/literate-ts/catcolab-analyses/mass-action.ts b/packages/document-methods/test/literate-ts/catcolab-analyses/mass-action.ts
new file mode 100644
index 000000000..f02e3bb09
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-analyses/mass-action.ts
@@ -0,0 +1,37 @@
+import { defineAnalysis } from "catcolab-documents";
+
+import type {
+    DblModel,
+    ThSymMonoidalCategory,
+    MassActionProblemData,
+    ODEResultWithEquations,
+} from "catlog-wasm";
+
+let thSymMonoidalCategory: Promise<ThSymMonoidalCategory> | undefined;
+function getCachedTheory(): Promise<ThSymMonoidalCategory> {
+    thSymMonoidalCategory ??= import("catlog-wasm").then(
+        ({ ThSymMonoidalCategory }) => new ThSymMonoidalCategory(),
+    );
+    return thSymMonoidalCategory;
+}
+
+export const MassActionDynamics = defineAnalysis({
+    id: "mass-action",
+    getInitialParams: (): MassActionProblemData => ({
+        massConservationType: { type: "Balanced" },
+        rates: {},
+        transitionProductionRates: {},
+        transitionConsumptionRates: {},
+        placeProductionRates: {},
+        placeConsumptionRates: {},
+        initialValues: {},
+        duration: 10,
+    }),
+    run: async (
+        model: DblModel,
+        params: MassActionProblemData,
+    ): Promise<ODEResultWithEquations> => {
+        const th = await getCachedTheory();
+        return th.massAction(model, params);
+    },
+});
diff --git a/packages/document-methods/test/literate-ts/catcolab-analyses/visualization.ts b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization.ts
new file mode 100644
index 000000000..19f602509
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization.ts
@@ -0,0 +1,88 @@
+import { defineAnalysis } from "catcolab-documents";
+
+import type * as GraphSpec from "./visualization/graph_spec";
+import { renderGraphSVG } from "./visualization/graph_svg";
+import { graphToViz, loadViz, vizLayoutGraph } from "./visualization/graphviz";
+
+/** Visualize a model as a graph.
+
+Analyses live in their own package, separate from the logics they apply to. An
+analysis is attached to a logic by listing it in the logic's `modelAnalyses`
+(see `catcolab-logics/simple-olog`); the analysis itself declares its `id`
+(unique relative to the logic), the `getInitialParams` created when an analysis
+cell is added, and an async `run` that computes the analysis's output from the
+analyzed model's elaborated `DblModel`. The cell resolves and validates that
+model through the store (via `getHandle`, elaborating against the analysis
+shape's `analysisOfCoreTheory`) before invoking `run`, so `run` receives the
+elaborated model directly.
+
+`content` is the persisted, user-editable config stored on the cell. For a
+visualization it is a graph-layout config: a `layout` engine and an optional
+`direction`/`separation`. The config parametrizes *rendering*; it is not part of
+the run output.
+
+`run` reproduces the frontend's visualization pipeline (ported from
+`packages/frontend/src/visualization`): it derives an abstract graph — lists of
+nodes and edges — from the elaborated model, lays it out with Graphviz (compiled
+to WebAssembly via `@viz-js/viz`, using only Graphviz's `json0` layout output),
+and then renders the layout to a self-contained SVG string. The renderer
+reproduces the markup of the frontend's `GraphSVG` component, but builds it as a
+plain string with `vhtml` (no DOM or framework runtime) so it runs headlessly.
+The `layout` engine and `direction` from the config select the Graphviz engine
+(`dot`/`neato`) and rank direction (`TB`/`LR`). */
+export type VisualizationParams = {
+    /** The graph-layout engine. */
+    layout: "graphviz-directed" | "graphviz-undirected";
+    /** Optional layout direction. */
+    direction?: "horizontal" | "vertical";
+};
+
+/** The rendered visualization {@link Visualization} produces. */
+export type VisualizationResult = {
+    /** The visualization rendered as an SVG document. */
+    svg: string;
+};
+
+/** Convert a params engine to the corresponding Graphviz layout engine. */
+function graphvizEngine(layout: VisualizationParams["layout"]): "dot" | "neato" {
+    return layout === "graphviz-undirected" ? "neato" : "dot";
+}
+
+export const Visualization = defineAnalysis({
+    id: "diagram",
+    getInitialParams: (): VisualizationParams => ({ layout: "graphviz-directed" }),
+    run: async (elaborated, params: VisualizationParams): Promise<VisualizationResult> => {
+        // Derive the abstract graph from the elaborated model.
+        const spec: GraphSpec.Graph = {
+            nodes: elaborated.obGenerators().map((id) => ({
+                id,
+                label: elaborated.obPresentation(id).label?.join(".") ?? "",
+            })),
+            edges: elaborated.morGenerators().flatMap((id) => {
+                const mor = elaborated.morPresentation(id);
+                if (!(mor && mor.dom.tag === "Basic" && mor.cod.tag === "Basic")) {
+                    return [];
+                }
+                return [
+                    {
+                        id,
+                        source: mor.dom.content,
+                        target: mor.cod.content,
+                        label: mor.label?.join(".") ?? "",
+                    },
+                ];
+            }),
+        };
+
+        // Lay out the graph with Graphviz, then render the layout to SVG with a
+        // string renderer that mirrors the frontend's `GraphSVG` markup.
+        const viz = await loadViz();
+        const layout = vizLayoutGraph(viz, graphToViz(spec), {
+            engine: graphvizEngine(params.layout),
+            graphAttributes: {
+                rankdir: params.direction === "horizontal" ? "LR" : "TB",
+            },
+        });
+        return { svg: renderGraphSVG(layout) };
+    },
+});
diff --git a/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graph_layout.ts b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graph_layout.ts
new file mode 100644
index 000000000..a9fb4e46f
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graph_layout.ts
@@ -0,0 +1,76 @@
+import type { ArrowStyle } from "./types";
+
+/** A graph with a layout.
+
+The coordinate system is that of SVG and HTML canvas, meaning that the origin is
+in the top-left corner.
+ */
+export interface Graph {
+    /** Width of bounding box for graph. */
+    width?: number;
+
+    /** Height of bounding box for graph. */
+    height?: number;
+
+    /** Nodes of graph. */
+    nodes: Array<Node>;
+
+    /** Edges of graph. */
+    edges: Array<Edge>;
+}
+
+export interface Node extends GraphElement {
+    /** Identifier of node, unique within graph. */
+    id: string;
+
+    /** Position of node, with origin at center of node. */
+    pos: Point;
+
+    /** Width of bounding box for node. */
+    width: number;
+
+    /** Height of bounding box for node. */
+    height: number;
+
+    /** Node label, if any. */
+    label?: string;
+}
+
+export interface Edge extends GraphElement {
+    id?: string;
+
+    /** Source node of edge. */
+    source: string;
+
+    /**  Target node of edge. */
+    target: string;
+
+    /** Edge label, if any. */
+    label?: string;
+
+    /** Position of source of edge. */
+    sourcePos: Point;
+
+    /** Position of target of edge. */
+    targetPos: Point;
+
+    /** Position of center of label. */
+    labelPos?: Point;
+
+    /** Path for the edge in SVG path data format. */
+    path: string;
+
+    /** Style of edge. */
+    style?: ArrowStyle;
+}
+
+export interface GraphElement {
+    /** CSS class (or classes) to apply to element. */
+    cssClass?: string;
+}
+
+/** Point in a 2D cartesian coordinate system. */
+export type Point = {
+    x: number;
+    y: number;
+};
diff --git a/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graph_spec.ts b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graph_spec.ts
new file mode 100644
index 000000000..1ca7eb453
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graph_spec.ts
@@ -0,0 +1,58 @@
+import type { ArrowStyle } from "./types";
+
+/** A graph specified by lists of nodes and edges.
+
+This type exists only to define a tool-agnostic input format for our graph
+layout and rendering pipeline. It is not intended as a generic data format for
+graphs.
+ */
+export interface Graph {
+    /** Nodes of graph. */
+    nodes: Array<Node>;
+
+    /** Edges of graph. */
+    edges: Array<Edge>;
+}
+
+export interface Node extends GraphElement {
+    /** Identifier of node, unique within graph. */
+    id: string;
+
+    /** Node label, if any.
+
+    The label should provided if it will be rendered downstream, as graph layout
+    engines may take it into account when sizing the node.
+    */
+    label?: string;
+
+    /** Minimum width of node. */
+    minimumWidth?: number;
+
+    /** Minimum height of node. */
+    minimumHeight?: number;
+}
+
+export interface Edge extends GraphElement {
+    /** Identifier of edge, unique within graph. */
+    id: string;
+
+    /** Source node of edge. */
+    source: string;
+
+    /**  Target node of edge. */
+    target: string;
+
+    /** Edge label, if any. */
+    label?: string;
+
+    /** Style of edge. */
+    style?: ArrowStyle;
+}
+
+export interface GraphElement {
+    /** CSS class (or classes) to apply to element. */
+    cssClass?: string;
+
+    /** Whether the label is set in a monospace font. */
+    isMonospaced?: boolean;
+}
diff --git a/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graph_svg.ts b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graph_svg.ts
new file mode 100644
index 000000000..42e77107b
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graph_svg.ts
@@ -0,0 +1,314 @@
+import h from "vhtml";
+
+import type * as GraphLayout from "./graph_layout";
+import { perpendicularLabelPosition } from "./label_position";
+import type { ArrowStyle } from "./types";
+
+/** Styles for the rendered graph SVG.
+
+Ported from the frontend's `graph_svg.css`. The CSS variables used by the
+frontend (`--color-foreground`/`--color-background`) are resolved to concrete
+colors so the exported SVG is self-contained and renders identically outside the
+app's theming context.
+
+The frontend loads these rules from an external stylesheet; when exporting a
+standalone SVG we embed them in a `<style>` element instead (see
+{@link renderGraphSVG}). */
+export const GRAPH_SVG_CSS = `
+.graph {
+    display: block;
+    margin: auto;
+    overflow: visible;
+}
+
+.node rect {
+    fill: transparent;
+}
+
+.edge line,
+.edge path {
+    fill: none;
+    stroke: black;
+    stroke-width: 1.5;
+}
+
+.edge path.double-outer {
+    stroke-width: 6;
+    stroke-linecap: round;
+}
+.edge path.double-inner {
+    stroke: white;
+    stroke-width: 3.5;
+    stroke-linecap: round;
+}
+.edge path.double-marker {
+    stroke: white;
+    stroke-width: 1.5;
+}
+
+#arrowhead-vee,
+#arrowhead-flat,
+#arrowhead-double {
+    fill: none;
+    stroke: black;
+}
+
+#arrowhead-flat {
+    stroke-width: 2;
+}
+`;
+
+/** Render a laid-out graph to a self-contained SVG string.
+
+This reproduces the markup of the frontend's SolidJS `GraphSVG` component
+(`packages/frontend/src/visualization/graph_svg.tsx`), but as a plain string
+built with `vhtml`'s `h()` reviver — no DOM, no JSX, no framework runtime — so it
+works under any toolchain (esbuild, tsx, Vite). The graph's stylesheet is
+embedded so the export stands alone, and an XML prolog is prepended. */
+export function renderGraphSVG(graph: GraphLayout.Graph): string {
+    const defs = h("defs", null, ...edgeMarkers(graph).map((marker) => arrowMarkerSVG[marker]()));
+    const edges = graph.edges.map((edge, i) => edgeSVG(edge, i));
+    const nodes = graph.nodes.map((node) => nodeSVG(node));
+
+    const svg = h(
+        "svg",
+        {
+            xmlns: "http://www.w3.org/2000/svg",
+            class: "graph",
+            ...(graph.width !== undefined && { width: graph.width }),
+            ...(graph.height !== undefined && { height: graph.height }),
+        },
+        // Embed the stylesheet raw so its selectors (e.g. `.edge path`) are not
+        // HTML-escaped. `dangerouslySetInnerHTML` inserts the content verbatim.
+        h("style", { dangerouslySetInnerHTML: { __html: GRAPH_SVG_CSS } }),
+        defs,
+        ...edges,
+        ...nodes,
+    );
+
+    return `<?xml version="1.0" encoding="UTF-8"?>\n${svg}`;
+}
+
+/** The set of arrow markers actually used by the graph's edges. */
+function edgeMarkers(graph: GraphLayout.Graph): ArrowMarker[] {
+    const markers = new Set<ArrowMarker>();
+    for (const edge of graph.edges) {
+        const marker = styleToMarker[edge.style ?? "default"];
+        if (marker) {
+            markers.add(marker);
+        }
+    }
+    return Array.from(markers);
+}
+
+/** Draw a labeled rectangle, positioned by top-left corner.
+
+A reusable SVG primitive for rendering boxes with centered labels, matching the
+frontend's `LabeledRect`. */
+function labeledRect(props: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    label?: string | undefined;
+    class?: string | undefined;
+    labelClass?: string | undefined;
+}): string {
+    const children: string[] = [
+        h("rect", { x: props.x, y: props.y, width: props.width, height: props.height }),
+    ];
+    if (props.label !== undefined) {
+        children.push(
+            h(
+                "text",
+                {
+                    class: props.labelClass ?? "label",
+                    x: props.x + props.width / 2,
+                    y: props.y + props.height / 2,
+                    "dominant-baseline": "middle",
+                    "text-anchor": "middle",
+                },
+                props.label,
+            ),
+        );
+    }
+    return h("g", { class: props.class }, ...children);
+}
+
+/** Draw a node with a layout using SVG (matches the frontend's `NodeSVG`). */
+function nodeSVG(node: GraphLayout.Node): string {
+    const { x, y } = node.pos;
+    const { width, height } = node;
+    return labeledRect({
+        x: x - width / 2,
+        y: y - height / 2,
+        width,
+        height,
+        label: node.label,
+        class: node.cssClass ?? "node",
+    });
+}
+
+/** Draw an edge with a layout using SVG (matches the frontend's `EdgeSVG`).
+
+`index` provides a stable, unique id for the edge path so caesura `textPath`s can
+reference it. */
+function edgeSVG(edge: GraphLayout.Edge, index: number): string {
+    const path = edge.path;
+    const style = edge.style ?? "default";
+    const marker = styleToMarker[style];
+    const markerUrl = `url(#arrowhead-${marker})`;
+    const pathId = `edge-path-${index}`;
+
+    const defaultPath = () => h("path", { id: pathId, "marker-end": markerUrl, d: path });
+
+    const tgtLabel = (text: string) => {
+        // Place the target label offset from the target in the direction
+        // orthogonal to the vector from the source to the target.
+        const pos = perpendicularLabelPosition(edge.sourcePos, edge.targetPos);
+        return h(
+            "text",
+            {
+                class: "label",
+                x: pos.x,
+                y: pos.y,
+                "dominant-baseline": "middle",
+                "text-anchor": "middle",
+            },
+            text,
+        );
+    };
+
+    const caesura = () =>
+        h(
+            "text",
+            { style: "dominant-baseline: central" },
+            h("textPath", { href: `#${pathId}`, startOffset: "40%" }, "‖"),
+        );
+
+    let body: string;
+    switch (style) {
+        case "double":
+            body = [
+                h("path", { class: "double-outer", d: path }),
+                h("path", { class: "double-inner", d: path }),
+                h("path", { class: "double-marker", "marker-end": markerUrl, d: path }),
+            ].join("");
+            break;
+        case "plus":
+            body = defaultPath() + tgtLabel("+");
+            break;
+        case "minus":
+            body = defaultPath() + tgtLabel("-");
+            break;
+        case "indeterminate":
+            body = defaultPath() + tgtLabel("?");
+            break;
+        case "plusCaesura":
+            body = defaultPath() + tgtLabel("+") + caesura();
+            break;
+        case "minusCaesura":
+            body = defaultPath() + tgtLabel("-") + caesura();
+            break;
+        case "scalar":
+            body = defaultPath() + tgtLabel("∝");
+            break;
+        default:
+            body = defaultPath();
+            break;
+    }
+
+    const label =
+        edge.label !== undefined
+            ? h(
+                  "text",
+                  {
+                      class: "label",
+                      ...(edge.labelPos?.x !== undefined && { x: edge.labelPos.x }),
+                      ...(edge.labelPos?.y !== undefined && { y: edge.labelPos.y }),
+                      "dominant-baseline": "middle",
+                      "text-anchor": "middle",
+                  },
+                  edge.label,
+              )
+            : "";
+
+    return h("g", { class: edge.cssClass ?? "edge" }, body, label);
+}
+
+/** SVG marker for a standard V-shaped arrowhead. */
+function veeMarker(id: string, offset = 0): string {
+    return h(
+        "marker",
+        {
+            id,
+            viewBox: "0 0 5 10",
+            refX: 5 + offset,
+            refY: "5",
+            markerWidth: "10",
+            markerHeight: "10",
+            orient: "auto-start-reverse",
+        },
+        h("path", { d: "M 0 2 L 5 5 L 0 8" }),
+    );
+}
+
+/** SVG marker for a triangular arrow head.
+
+Source: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/marker */
+function triangleMarker(id: string): string {
+    return h(
+        "marker",
+        {
+            id,
+            viewBox: "0 0 10 10",
+            refX: "10",
+            refY: "5",
+            markerWidth: "6",
+            markerHeight: "6",
+            orient: "auto-start-reverse",
+        },
+        h("path", { d: "M 0 0 L 10 5 L 0 10 z" }),
+    );
+}
+
+/** SVG marker for a flat arrow head, giving a "T-shaped" arrow. */
+function flatMarker(id: string): string {
+    return h(
+        "marker",
+        {
+            id,
+            viewBox: "0 0 5 10",
+            refX: "5",
+            refY: "5",
+            markerWidth: "10",
+            markerHeight: "10",
+            orient: "auto-start-reverse",
+        },
+        h("path", { d: "M 5 0 L 5 10" }),
+    );
+}
+
+/** Supported markers serving as arrowheads. */
+export type ArrowMarker = "vee" | "double" | "triangle" | "flat";
+
+const styleToMarker: Record<ArrowStyle, ArrowMarker | null> = {
+    default: "vee",
+    double: "double",
+    flat: "flat",
+    unmarked: null,
+    plus: "triangle",
+    minus: "triangle",
+    indeterminate: "triangle",
+    plusCaesura: "triangle",
+    minusCaesura: "triangle",
+    scalar: "triangle",
+};
+
+/** SVG markers for arrow heads. */
+export const arrowMarkerSVG: Record<ArrowMarker, () => string> = {
+    vee: () => veeMarker("arrowhead-vee"),
+    double: () => veeMarker("arrowhead-double", -2),
+    triangle: () => triangleMarker("arrowhead-triangle"),
+    flat: () => flatMarker("arrowhead-flat"),
+};
diff --git a/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graphviz.ts b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graphviz.ts
new file mode 100644
index 000000000..cbb0c2469
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graphviz.ts
@@ -0,0 +1,244 @@
+import type * as Viz from "@viz-js/viz";
+import invariant from "tiny-invariant";
+
+import type * as GraphLayout from "./graph_layout";
+import type { Point } from "./graph_layout";
+import type * as GraphSpec from "./graph_spec";
+import type * as GraphvizJSON from "./graphviz_json";
+import type { ArrowStyle } from "./types";
+
+/** Top-level attributes of a Graphviz graph.
+
+Viz.js doesn't directly export this type, so for convenience we do so here.
+ */
+export type GraphvizAttributes = {
+    graph?: Viz.Graph["graphAttributes"];
+    node?: Viz.Graph["nodeAttributes"];
+    edge?: Viz.Graph["edgeAttributes"];
+};
+
+/** Convert a graph specification into a Viz.js graph. */
+export function graphToViz(graph: GraphSpec.Graph, attrs?: GraphvizAttributes): Viz.Graph {
+    const nodes: Viz.Graph["nodes"] = graph.nodes.map((node) => ({
+        name: node.id,
+        attributes: {
+            id: node.id,
+            label: node.label ?? "",
+            fontname: fontname(node.isMonospaced),
+            ...(node.minimumWidth !== undefined && { width: pointsToInches(node.minimumWidth) }),
+            ...(node.minimumHeight !== undefined && { height: pointsToInches(node.minimumHeight) }),
+            ...(node.cssClass !== undefined && { class: node.cssClass }),
+        },
+    }));
+
+    const edges: Viz.Graph["edges"] = graph.edges.map((edge) => ({
+        tail: edge.source,
+        head: edge.target,
+        attributes: {
+            id: edge.id,
+            label: edge.label ?? "",
+            fontname: fontname(edge.isMonospaced),
+            ...(edge.cssClass !== undefined && { class: edge.cssClass }),
+            arrowstyle: edge.style ?? "default",
+        },
+    }));
+
+    return {
+        directed: true,
+        ...(attrs?.graph !== undefined && { graphAttributes: attrs.graph }),
+        ...(attrs?.node !== undefined && { nodeAttributes: attrs.node }),
+        ...(attrs?.edge !== undefined && { edgeAttributes: attrs.edge }),
+        nodes,
+        edges,
+    };
+}
+
+/** Asynchronously import and load Viz.js. */
+export async function loadViz() {
+    const { instance } = await import("@viz-js/viz");
+    return await instance();
+}
+
+/** Lay out a graph using Graphviz. */
+export function vizLayoutGraph(viz: Viz.Viz, graph: Viz.Graph, options?: Viz.RenderOptions) {
+    return parseGraphvizJSON(vizRenderJSON0(viz, graph, options));
+}
+
+/** Render a Graphviz graph using the Graphviz `json0` format.
+
+Graphviz is invoked with "inverted y coordinates" for compatibility with the
+coordinate systems in SVG and HTML Canvas.
+ */
+export function vizRenderJSON0(viz: Viz.Viz, graph: Viz.Graph, options?: Viz.RenderOptions) {
+    // We use `renderString` rather than the convenience method `renderJSON`
+    // since we need only `json0` output, not the full `json` output.
+    const result = viz.renderString(graph, {
+        ...options,
+        format: "json0",
+        yInvert: true,
+    });
+    return JSON.parse(result) as GraphvizJSON.Graph;
+}
+
+/** Parse a graph layout from Graphviz `json0` output.
+
+The predecessor to this code is Evan's defunct package
+[`wiring-diagram-canvas`](https://github.com/epatters/wiring-diagram-canvas/blob/master/src/graphviz.ts).
+ */
+export function parseGraphvizJSON(graphviz: GraphvizJSON.Graph): GraphLayout.Graph {
+    // Parse bounding box and padding.
+    //
+    // Apparently one corner of the bounding box is always the origin (0,0),
+    // though that is not documented. Which of the y coordinates is zero depends
+    // on whether the Graphviz option to invert the y axis has been set.
+    const bb = parseFloatArray(graphviz.bb);
+    const pad: Point = { x: 0, y: 0 };
+    if (graphviz.pad) {
+        const gvPad = parsePoint(graphviz.pad);
+        [pad.x, pad.y] = [inchesToPoints(gvPad.x), inchesToPoints(gvPad.y)];
+    }
+    const width = (bb[2] ?? 0) + 2 * pad.x;
+    const height = Math.max(bb[1] ?? 0, bb[3] ?? 0) + 2 * pad.y;
+
+    // Parse nodes of graph, ignoring any subgraphs.
+    const nodes: GraphLayout.Node[] = [];
+    const offset = graphviz._subgraph_cnt;
+    const nodeByNumber = (i: number) => nodes[i - offset];
+    for (const node of (graphviz.objects?.slice(offset) as GraphvizJSON.Node[]) ?? []) {
+        const id = node.id || node.name;
+        nodes.push({
+            id,
+            pos: parsePoint(node.pos),
+            width: inchesToPoints(Number.parseFloat(node.width)),
+            height: inchesToPoints(Number.parseFloat(node.height)),
+            ...(node.label !== undefined && { label: node.label }),
+            ...(node.class !== undefined && { cssClass: node.class }),
+        });
+    }
+
+    // Parse edge of graph.
+    const edges: GraphLayout.Edge[] = [];
+    for (const edge of graphviz.edges ?? []) {
+        if (edge.style === "invis") {
+            // Omit invisible edges, used to tweak the layout in Graphviz.
+            continue;
+        }
+        const [sourceNode, targetNode] = [nodeByNumber(edge.tail), nodeByNumber(edge.head)];
+        invariant(sourceNode && targetNode, "Source and target nodes should be defined");
+
+        const spline = parseSpline(edge.pos);
+        const { points, startPoint, endPoint } = spline;
+        const sourcePos = startPoint ?? points[0];
+        const targetPos = endPoint ?? points[points.length - 1];
+        invariant(sourcePos && targetPos, "Source and target positions should be defined");
+
+        const label = edge.xlabel ?? edge.label;
+        const labelPos =
+            (edge.xlp && parsePoint(edge.xlp)) || (edge.lp && parsePoint(edge.lp)) || undefined;
+        edges.push({
+            source: sourceNode.id,
+            target: targetNode.id,
+            sourcePos,
+            targetPos,
+            path: splineToPath(spline),
+            style: edge.arrowstyle as ArrowStyle,
+            ...(edge.id !== undefined && { id: edge.id }),
+            ...(label !== undefined && { label }),
+            ...(labelPos !== undefined && { labelPos }),
+            ...(edge.class !== undefined && { cssClass: edge.class }),
+        });
+    }
+
+    return { width, height, nodes, edges };
+}
+
+/* Parse Graphviz spline.
+
+   In Graphviz, a "spline" is a cubic B-spline of overlapping cubic Bezier
+   curves. It consists of 3n+1 points, where n is the number of Bezier curves.
+
+   References:
+
+   - https://graphviz.org/docs/attr-types/splineType/
+   - https://cprimozic.net/notes/posts/graphviz-spline-drawing/
+ */
+function parseSpline(spline: string): GraphvizSpline {
+    const points: Point[] = [];
+    let startPoint: Point | undefined;
+    let endPoint: Point | undefined;
+
+    for (const s of spline.split(" ")) {
+        if (s.startsWith("s,")) {
+            startPoint = parsePoint(s.slice(2));
+        } else if (s.startsWith("e,")) {
+            endPoint = parsePoint(s.slice(2));
+        } else {
+            points.push(parsePoint(s));
+        }
+    }
+
+    return {
+        points,
+        ...(startPoint !== undefined && { startPoint }),
+        ...(endPoint !== undefined && { endPoint }),
+    };
+}
+
+/** Convert a spline parsed from Graphviz into SVG path data.
+ */
+function splineToPath(spline: GraphvizSpline): string {
+    const { points, startPoint, endPoint } = spline;
+
+    // Start path.
+    const stmts: Array<string | number> = ["M"];
+    if (startPoint) {
+        stmts.push(startPoint.x, startPoint.y, "L");
+    }
+    const p0 = points[0];
+    invariant(p0, "Spline should have at least one point");
+    stmts.push(p0.x, p0.y);
+
+    // Bezier curves for intermediate segments.
+    for (let i = 1; i < points.length; i += 3) {
+        const [p1, p2, p3] = [points[i], points[i + 1], points[i + 2]];
+        invariant(p1 && p2 && p3, "Expecting sequence of three points in spline");
+        stmts.push("C", p1.x, `${p1.y},`, p2.x, `${p2.y},`, p3.x, p3.y);
+    }
+
+    // End path;
+    if (endPoint) {
+        stmts.push("L", endPoint.x, endPoint.y);
+    }
+    return stmts.join(" ");
+}
+
+type GraphvizSpline = {
+    points: Point[];
+    startPoint?: Point;
+    endPoint?: Point;
+};
+
+/** Parse array of floats in Graphviz's comma-separated format.
+ */
+function parseFloatArray(s: string): number[] {
+    return s.split(",").map(Number.parseFloat);
+}
+
+/** Parse a Graphviz point.
+ */
+function parsePoint(s: string): Point {
+    const point = parseFloatArray(s);
+    invariant(
+        point[0] !== undefined && point[1] !== undefined,
+        "Point should be array of length 2",
+    );
+    return { x: point[0], y: point[1] };
+}
+
+// 72 points per inch in Graphviz.
+const inchesToPoints = (x: number) => 72 * x;
+const pointsToInches = (x: number) => x / 72;
+
+// XXX: Exact font matching is impossible with Graphviz, but we at least try to
+// give Graphviz a monospaced font if and only if we will render in monospace.
+const fontname = (monospace?: boolean): string => (monospace ? "Courier" : "Helvetica");
diff --git a/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graphviz_json.ts b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graphviz_json.ts
new file mode 100644
index 000000000..afdb89967
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/graphviz_json.ts
@@ -0,0 +1,117 @@
+/** Top-level interface for Graphviz JSON output (new in Graphviz 2.40).
+ *
+ * https://graphviz.org/docs/outputs/json/
+ *
+ * JSON is produced using the `json` (`xdot` equivalent) or `json0` (`dot`
+ * equivalent) Graphviz output formats. The xdot drawing instructions are not
+ * included in this interface.
+ */
+export interface Graph {
+    /** Name of the top-level graph. */
+    name: string;
+
+    /** Is the graph directed? */
+    directed: boolean;
+
+    /** Is the graph strict, meaning that no two nodes have multiple edges? */
+    strict: boolean;
+
+    /** Bounding box of graph as rectangle (units: points). */
+    bb: string;
+
+    /** Padding of graph as point (units: inches). */
+    pad?: string;
+
+    /** Number of subgraphs in the graph. */
+    _subgraph_cnt: number;
+
+    /** Nodes and subgraphs in the graph.
+     *
+     * The first `_subgraph_cnt` objects are subgraphs; the rest are nodes.
+     */
+    objects?: Array<Node | Subgraph>;
+
+    /** Edges in the graph. */
+    edges?: Array<Edge>;
+}
+
+export interface Node extends GraphObject {
+    /** Position of node as comma-separated pair, in points (72 points/inch). */
+    pos: string;
+
+    /** Width of node in inches. */
+    width: string;
+
+    /** Height of node in inches. */
+    height: string;
+}
+
+export interface Subgraph extends GraphObject {
+    /** Nodes (or subgraphs) in graph that are contained in this subgraph. */
+    nodes?: number[];
+
+    /** Edges in graph that are contained in this subgraph. */
+    edges?: number[];
+}
+
+export interface Edge extends GraphElement {
+    /** Index of edge in `edges` array. */
+    _gvid: number;
+
+    /** Head (target) of edge. */
+    head: number;
+
+    /** Tail (source) of edge. */
+    tail: number;
+
+    /** Head port (target port) of edge. */
+    headport?: string;
+
+    /** Tail port (source port) of edge. */
+    tailport?: string;
+
+    /** Positions of start, end, and control points of spline.
+     *
+     * https://graphviz.org/docs/attr-types/splineType/
+     */
+    pos: string;
+
+    /** Position of edge label. */
+    lp?: string;
+
+    /** Arrow style, our own custom attribute ignored by Graphviz. */
+    arrowstyle?: string;
+}
+
+/** Node or subgraph in Graphviz JSON output.
+ */
+export interface GraphObject extends GraphElement {
+    /** Index of node or subgraph in `objects` array. */
+    _gvid: number;
+
+    /** Name of node or subgraph in dot file. */
+    name: string;
+}
+
+export interface GraphElement {
+    /** User-defined ID, ignored by Graphviz. */
+    id?: string;
+
+    /** Text label for element. */
+    label?: string;
+
+    /** External label for node or edge.
+     *
+     * https://graphviz.org/docs/attrs/xlabel/
+     */
+    xlabel?: string;
+
+    /** Position of external label. */
+    xlp?: string;
+
+    /** Graphviz-specific style. */
+    style?: string;
+
+    /** CSS class passed to Graphviz. */
+    class?: string;
+}
diff --git a/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/label_position.ts b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/label_position.ts
new file mode 100644
index 000000000..e85cb6bee
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/label_position.ts
@@ -0,0 +1,17 @@
+import type { Point } from "./graph_layout";
+
+/** Calculate a position offset perpendicular to the vector from source to target.
+ *
+ * This is useful for placing labels near the target of an edge, offset to the side
+ * so they don't overlap with the edge itself.
+ *
+ * @param sourcePos - The source point
+ * @param targetPos - The target point
+ * @param offset - The perpendicular distance to offset from the target (default: 10)
+ * @returns A point offset from the target perpendicular to the source-target vector
+ */
+export function perpendicularLabelPosition(sourcePos: Point, targetPos: Point, offset = 10): Point {
+    const vec = { x: targetPos.x - sourcePos.x, y: targetPos.y - sourcePos.y };
+    const scale = offset / Math.sqrt(vec.x ** 2 + vec.y ** 2);
+    return { x: targetPos.x - scale * vec.y, y: targetPos.y + scale * vec.x };
+}
diff --git a/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/types.ts b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/types.ts
new file mode 100644
index 000000000..e87bde83f
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-analyses/visualization/types.ts
@@ -0,0 +1,15 @@
+/** Style of arrow.
+
+Each arrow style has support to be rendered in HTML/CSS and SVG.
+ */
+export type ArrowStyle =
+    | "default"
+    | "double"
+    | "flat"
+    | "unmarked"
+    | "plus"
+    | "minus"
+    | "indeterminate"
+    | "plusCaesura"
+    | "minusCaesura"
+    | "scalar";
diff --git a/packages/document-methods/test/literate-ts/catcolab-logics/petri-net.ts b/packages/document-methods/test/literate-ts/catcolab-logics/petri-net.ts
new file mode 100644
index 000000000..fb74264b2
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-logics/petri-net.ts
@@ -0,0 +1,22 @@
+import { MassActionDynamics, Visualization } from "catcolab-analyses";
+import { defineMorphism, defineObject, defineShape } from "catcolab-documents";
+
+export const Place = defineObject({ tag: "Basic", content: "Object" });
+export const Transition = defineMorphism(
+    { tag: "Hom", content: Place.obType },
+    {
+        domain: { apply: { tag: "Basic", content: "tensor" }, modality: "SymmetricList" },
+        codomain: { apply: { tag: "Basic", content: "tensor" }, modality: "SymmetricList" },
+    },
+);
+
+export const PetriNet = defineShape({
+    theory: "petri-net",
+    getCoreTheory: async () => {
+        const { ThSymMonoidalCategory } = await import("catlog-wasm");
+        return new ThSymMonoidalCategory().theory();
+    },
+    objects: [Place],
+    morphisms: [Transition],
+    modelAnalyses: [Visualization, MassActionDynamics],
+});
diff --git a/packages/document-methods/test/literate-ts/catcolab-logics/simple-olog.ts b/packages/document-methods/test/literate-ts/catcolab-logics/simple-olog.ts
new file mode 100644
index 000000000..6e34389f2
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-logics/simple-olog.ts
@@ -0,0 +1,31 @@
+import { Visualization } from "catcolab-analyses";
+import { defineMorphism, defineObject, defineShape, RichText } from "catcolab-documents";
+
+export const Type = defineObject({ tag: "Basic", content: "Object" });
+export const Aspect = defineMorphism({
+    tag: "Hom",
+    content: { tag: "Basic", content: "Object" },
+});
+
+export const SimpleOlog = defineShape({
+    theory: "simple-olog",
+    getCoreTheory: async () => {
+        const { ThCategory } = await import("catlog-wasm");
+        return new ThCategory().theory();
+    },
+    objects: [Type],
+    morphisms: [Aspect],
+    supportsEquations: true,
+    supportsInstances: true,
+    modelAnalyses: [Visualization],
+    informal: [RichText],
+    migrations: [
+        {
+            target: "simple-schema",
+            migrate: async (model, targetTheory) => {
+                const { ThCategory } = await import("catlog-wasm");
+                return ThCategory.toSchema(model, targetTheory);
+            },
+        },
+    ],
+});
diff --git a/packages/document-methods/test/literate-ts/catcolab-logics/simple-schema.ts b/packages/document-methods/test/literate-ts/catcolab-logics/simple-schema.ts
new file mode 100644
index 000000000..ab9288bb9
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/catcolab-logics/simple-schema.ts
@@ -0,0 +1,32 @@
+import { defineMorphism, defineObject, defineShape, RichText } from "catcolab-documents";
+
+export const Entity = defineObject({ tag: "Basic", content: "Entity" });
+export const AttrType = defineObject({ tag: "Basic", content: "AttrType" });
+
+export const Mapping = defineMorphism({ tag: "Hom", content: Entity.obType });
+export const Attr = defineMorphism(
+    { tag: "Basic", content: "Attr" },
+    { domain: Entity.obType, codomain: AttrType.obType },
+);
+
+export const SimpleSchema = defineShape({
+    theory: "simple-schema",
+    getCoreTheory: async () => {
+        const { ThSchema } = await import("catlog-wasm");
+        return new ThSchema().theory();
+    },
+    objects: [Entity, AttrType],
+    morphisms: [Mapping, Attr],
+    supportsEquations: true,
+    supportsInstances: true,
+    informal: [RichText],
+    migrations: [
+        {
+            target: "simple-olog",
+            migrate: async (model, targetTheory) => {
+                const { ThSchema } = await import("catlog-wasm");
+                return ThSchema.toCategory(model, targetTheory);
+            },
+        },
+    ],
+});
diff --git a/packages/document-methods/test/literate-ts/mock-model-context.ts b/packages/document-methods/test/literate-ts/mock-model-context.ts
new file mode 100644
index 000000000..141f39123
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/mock-model-context.ts
@@ -0,0 +1,45 @@
+/**
+ * A stand-in for the browser-supplied `document.modelContext`, used by the
+ * `notebook_webmcp` literate spec so its examples run outside a browser. It
+ * implements the slice of the WebMCP imperative API the examples exercise:
+ * `registerTool`, `getTools`, and `executeTool`.
+ */
+
+/** The minimal slice of a registered WebMCP tool the helper relies on. */
+export type RegisteredTool = {
+    name: string;
+    description: string;
+    inputSchema: object;
+    execute: (args: Record<string, unknown>) => Promise<string> | string;
+};
+
+/** A stand-in `document.modelContext` exposing the imperative-API surface. */
+export type MockModelContext = {
+    /** Register a tool, removing it when an optional `AbortSignal` fires. */
+    registerTool(tool: RegisteredTool, options?: { signal?: AbortSignal }): void;
+    /** All registered tools, ordered alphabetically by name (as the real API). */
+    getTools(): Promise<RegisteredTool[]>;
+    /** Run a tool by name with a JSON-string argument, as an agent would. */
+    executeTool(ref: { name: string }, args: string): Promise<string>;
+};
+
+/** Create a fresh, empty {@link MockModelContext}. */
+export function createMockModelContext(): MockModelContext {
+    const tools = new Map<string, RegisteredTool>();
+    return {
+        registerTool(tool, options) {
+            tools.set(tool.name, tool);
+            options?.signal?.addEventListener("abort", () => tools.delete(tool.name));
+        },
+        async getTools() {
+            return [...tools.values()].toSorted((a, b) => a.name.localeCompare(b.name));
+        },
+        async executeTool(ref, args) {
+            const tool = tools.get(ref.name);
+            if (!tool) {
+                throw new Error(`Unknown tool '${ref.name}'.`);
+            }
+            return tool.execute(JSON.parse(args));
+        },
+    };
+}
diff --git a/packages/document-methods/test/literate-ts/tsconfig.json b/packages/document-methods/test/literate-ts/tsconfig.json
new file mode 100644
index 000000000..82f5b7256
--- /dev/null
+++ b/packages/document-methods/test/literate-ts/tsconfig.json
@@ -0,0 +1,18 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "baseUrl": ".",
+        "ignoreDeprecations": "6.0",
+        "jsx": "preserve",
+        "jsxImportSource": "solid-js",
+        "lib": ["ES2023", "DOM"],
+        "paths": {
+            "catcolab-logics/*": ["./catcolab-logics/*.ts"],
+            "catcolab-analyses": ["./catcolab-analyses/index.ts"],
+            "catcolab-analyses/*": ["./catcolab-analyses/*.ts"],
+            "catcolab-documents": ["../../src/future/index.ts"]
+        },
+        "noUnusedLocals": false,
+        "noEmit": false
+    }
+}
diff --git a/packages/document-methods/test/model_cache.test.ts b/packages/document-methods/test/model_cache.test.ts
new file mode 100644
index 000000000..9d8647a0c
--- /dev/null
+++ b/packages/document-methods/test/model_cache.test.ts
@@ -0,0 +1,302 @@
+/**
+ * Tests for the per-store elaboration cache behind `resolveModelInStore`
+ * (`src/future/model-cache.ts`). Elaborations are counted by spying on
+ * `elaborateModel` from `catlog-wasm`: the cache's whole point is to avoid
+ * re-running it, so the spy's call count *is* the observable behavior.
+ */
+import { Visualization } from "catcolab-analyses";
+import {
+    CellKind,
+    createBinder,
+    type DocumentStore,
+    Instantiation,
+    RichText,
+} from "catcolab-documents";
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { v7 } from "uuid";
+import { describe, expect, test, vi } from "vitest";
+
+import type { Document } from "catcolab-document-types";
+
+vi.mock("catlog-wasm", async (importOriginal) => {
+    const original = await importOriginal<typeof import("catlog-wasm")>();
+    return {
+        ...original,
+        elaborateModel: vi.fn<typeof original.elaborateModel>(original.elaborateModel),
+    };
+});
+
+/** The spied `elaborateModel`, for counting calls per document id (its fourth
+ * argument). */
+const elaborations = async () => {
+    const { elaborateModel } = await import("catlog-wasm");
+    return elaborateModel as unknown as ReturnType<typeof vi.fn>;
+};
+
+/** Calls of the spied `elaborateModel` for a given document id. */
+const elaborationsOf = async (id: string): Promise<number> => {
+    const spy = await elaborations();
+    return spy.mock.calls.filter((call) => call[3] === id).length;
+};
+
+/** The reference id a store minted for a notebook's handle. */
+const idOf = (store: DocumentStore<Document>, notebook: { handle: Document }): string => {
+    const ref = store.getDocumentRef(notebook.handle);
+    if (!ref) {
+        throw new Error("store minted no reference");
+    }
+    return ref.id;
+};
+
+// A bespoke resolving store, as in `instantiation_validation.test.ts`. Each
+// test creates its own store object, so each gets its own cache (the cache
+// registry is keyed by store identity).
+function createResolvingStore(): {
+    store: DocumentStore<Document>;
+    failOnResolve: { value: boolean };
+} {
+    const ids = new WeakMap<Document, string>();
+    const byId = new Map<string, Document>();
+    const listeners = new WeakMap<Document, Set<() => void>>();
+    const failOnResolve = { value: false };
+
+    const store: DocumentStore<Document> = {
+        createHandle: async (initialDoc) => {
+            const doc = initialDoc as Document;
+            const id = v7();
+            ids.set(doc, id);
+            byId.set(id, doc);
+            return doc;
+        },
+        getHandle: async (ref) => {
+            const handle = failOnResolve.value ? undefined : byId.get(ref.id);
+            return handle
+                ? { tag: "Ok", content: handle }
+                : {
+                      tag: "Err",
+                      content: [{ message: `Cannot resolve reference "${ref.id}".`, path: ["id"] }],
+                  };
+        },
+        getDocumentView: (handle) => handle,
+        changeDocument: (handle, fn) => {
+            fn(handle);
+            for (const listener of Array.from(listeners.get(handle) ?? [])) {
+                listener();
+            }
+        },
+        subscribe: (handle, callback) => {
+            let set = listeners.get(handle);
+            if (!set) {
+                set = new Set();
+                listeners.set(handle, set);
+            }
+            set.add(callback);
+            return () => {
+                set.delete(callback);
+            };
+        },
+        copyValue: (_handle, value) => structuredClone(value),
+        getDocumentRef: (handle) => {
+            let id = ids.get(handle);
+            if (!id) {
+                id = v7();
+                ids.set(handle, id);
+                byId.set(id, handle);
+            }
+            return { id, version: null, server: "" };
+        },
+    };
+
+    return { store, failOnResolve };
+}
+
+describe("model cache", () => {
+    test("repeated validate() reuses one elaboration and one model", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+
+        const notebook = await binder.createNotebook(SimpleOlog, { name: "Main" });
+        notebook.add(Type, { label: "A" });
+        const id = idOf(store, notebook);
+
+        const first = await notebook.validate();
+        const second = await notebook.validate();
+        expect(first.tag).toBe("Ok");
+        expect(second.tag).toBe("Ok");
+        // Same cached model object, elaborated exactly once.
+        expect(first.tag === "Ok" && second.tag === "Ok" && first.content).toBe(
+            second.tag === "Ok" && second.content,
+        );
+        expect(await elaborationsOf(id)).toBe(1);
+    });
+
+    test("a formal edit re-elaborates; the models differ", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+
+        const notebook = await binder.createNotebook(SimpleOlog, { name: "Main" });
+        notebook.add(Type, { label: "A" });
+        const id = idOf(store, notebook);
+
+        const first = await notebook.validate();
+        notebook.add(Type, { label: "B" });
+        const second = await notebook.validate();
+
+        expect(await elaborationsOf(id)).toBe(2);
+        expect(first.tag === "Ok" && second.tag === "Ok" && first.content).not.toBe(
+            second.tag === "Ok" && second.content,
+        );
+    });
+
+    test("non-formal changes (rich text, rename) keep the cached model", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+
+        const notebook = await binder.createNotebook(SimpleOlog, { name: "Main" });
+        notebook.add(Type, { label: "A" });
+        const id = idOf(store, notebook);
+
+        await notebook.validate();
+        // Both changes bump the document's version but not its formal content.
+        notebook.add(RichText, { content: "A comment." });
+        notebook.update({ name: "Renamed" });
+        const again = await notebook.validate();
+
+        expect(again.tag).toBe("Ok");
+        expect(await elaborationsOf(id)).toBe(1);
+    });
+
+    test("instantiation resolution shares cached models across top-level calls", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+
+        const inner = await binder.createNotebook(SimpleOlog, { name: "Inner" });
+        inner.add(Type, { label: "Thing" });
+
+        const importedA = await binder.createNotebook(SimpleOlog, { name: "A" });
+        importedA.add(Instantiation, { label: "InnerA", model: inner });
+        const importedB = await binder.createNotebook(SimpleOlog, { name: "B" });
+        importedB.add(Instantiation, { label: "InnerB", model: inner });
+
+        const main = await binder.createNotebook(SimpleOlog, { name: "Main" });
+        main.add(Instantiation, { label: "ImportA", model: importedA });
+        main.add(Instantiation, { label: "ImportB", model: importedB });
+
+        // Validate every notebook separately: a diamond of instantiations, four
+        // top-level calls — yet each document elaborates exactly once.
+        expect((await inner.validate()).tag).toBe("Ok");
+        expect((await importedA.validate()).tag).toBe("Ok");
+        expect((await importedB.validate()).tag).toBe("Ok");
+        expect((await main.validate()).tag).toBe("Ok");
+
+        for (const notebook of [inner, importedA, importedB, main]) {
+            expect(await elaborationsOf(idOf(store, notebook))).toBe(1);
+        }
+    });
+
+    test("a grandchild edit invalidates the root; untouched siblings are reused", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+
+        const inner = await binder.createNotebook(SimpleOlog, { name: "Inner" });
+        inner.add(Type, { label: "Thing" });
+        const imported = await binder.createNotebook(SimpleOlog, { name: "Imported" });
+        imported.add(Instantiation, { label: "Inner", model: inner });
+        const sibling = await binder.createNotebook(SimpleOlog, { name: "Sibling" });
+        sibling.add(Type, { label: "S" });
+
+        const main = await binder.createNotebook(SimpleOlog, { name: "Main" });
+        main.add(Instantiation, { label: "Import", model: imported });
+        main.add(Instantiation, { label: "Sib", model: sibling });
+
+        expect((await main.validate()).tag).toBe("Ok");
+
+        // Edit the *grandchild*: `imported` is untouched, but its model embeds
+        // `inner`'s content, so both it and `main` must re-elaborate. The
+        // sibling is unaffected and must be reused.
+        inner.add(Type, { label: "Another" });
+        expect((await main.validate()).tag).toBe("Ok");
+
+        expect(await elaborationsOf(idOf(store, inner))).toBe(2);
+        expect(await elaborationsOf(idOf(store, imported))).toBe(2);
+        expect(await elaborationsOf(idOf(store, main))).toBe(2);
+        expect(await elaborationsOf(idOf(store, sibling))).toBe(1);
+    });
+
+    test("analysis cells share one elaboration, including concurrent runs", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+
+        const model = await binder.createNotebook(SimpleOlog, { name: "Model" });
+        model.add(Type, { label: "A" });
+        const id = idOf(store, model);
+
+        const analysis = await binder.createNotebook(SimpleOlog.Analysis, {
+            name: "Analysis",
+            of: model,
+        });
+        const first = analysis.add(Visualization);
+        const second = analysis.add(Visualization);
+
+        // Concurrent runs (as when all cells of a notebook run on mount)
+        // dedupe on the in-flight entry; the sequential re-run hits the cache.
+        const [a, b] = await Promise.all([first.run(), second.run()]);
+        expect(a.tag).toBe("Ok");
+        expect(b.tag).toBe("Ok");
+        expect((await first.run()).tag).toBe("Ok");
+        expect(await elaborationsOf(id)).toBe(1);
+
+        // An edit to the analyzed model is picked up by the next run.
+        model.add(Type, { label: "B" });
+        const after = await first.run();
+        expect(after.tag).toBe("Ok");
+        expect(after.tag === "Ok" && after.content.svg.includes(">B<")).toBe(true);
+        expect(await elaborationsOf(id)).toBe(2);
+    });
+
+    test("a cycle introduced by an edit after a cached validate is detected", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+
+        const a = await binder.createNotebook(SimpleOlog, { name: "A" });
+        const c = await binder.createNotebook(SimpleOlog, { name: "C" });
+        a.add(Type, { label: "TA" });
+        c.add(Type, { label: "TC" });
+        a.add(Instantiation, { label: "toC", model: c });
+
+        expect((await a.validate()).tag).toBe("Ok");
+
+        c.add(Instantiation, { label: "toA", model: a });
+        const result = await a.validate();
+        expect(result.tag).toBe("Err");
+        expect(
+            result.tag === "Err" && result.content.map((issue) => issue.message).join("; "),
+        ).toContain("Instantiation cycle detected");
+
+        // Breaking the cycle recovers: failures were never cached.
+        for (const cell of c.cells()) {
+            if (cell.kind === CellKind.Instantiation) {
+                cell.delete();
+            }
+        }
+        expect((await a.validate()).tag).toBe("Ok");
+    });
+
+    test("a failed resolution is not cached; a later resolution succeeds", async () => {
+        const { store, failOnResolve } = createResolvingStore();
+        const binder = createBinder(store);
+
+        const imported = await binder.createNotebook(SimpleOlog, { name: "Imported" });
+        imported.add(Type, { label: "Thing" });
+        const notebook = await binder.createNotebook(SimpleOlog, { name: "Main" });
+        notebook.add(Instantiation, { label: "Import", model: imported });
+
+        failOnResolve.value = true;
+        const failed = await notebook.validate();
+        expect(failed.tag).toBe("Err");
+
+        failOnResolve.value = false;
+        const recovered = await notebook.validate();
+        expect(recovered.tag).toBe("Ok");
+    });
+});
diff --git a/packages/document-methods/test/notebook.lts.md b/packages/document-methods/test/notebook.lts.md
new file mode 100644
index 000000000..117c5aa91
--- /dev/null
+++ b/packages/document-methods/test/notebook.lts.md
@@ -0,0 +1,731 @@
+Two new package for our built-in logics `catcolab-logics` and
+`catcolab-documents`. In the future people may create their own logics instead of
+using `catcolab-logics`. The logics need to play nice with `catcolab-documents`.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, RichText } from "catcolab-documents";
+```
+
+Notebooks are created through a binder, which ties the notebook API to a
+document store. The default `binder` uses the plain in-memory store.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const notebook = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+```
+
+All cells are added with a single `add` method. The first argument selects
+the kind of cell: `RichText` for prose, or an object/morphism type from the
+logic for formal cells.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const intro = notebook.add(RichText, { content: "We define a simple olog." });
+```
+
+We can create objects and morphisms in the notebook.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const source = notebook.add(Type, {
+    label: "A",
+});
+
+const target = notebook.add(Type, {
+    label: "B",
+});
+
+const arrow = notebook.add(Aspect, {
+    label: "has",
+    from: source,
+    to: target,
+});
+```
+
+We can update any item.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+notebook.update({ name: "A simple Olog example" });
+
+intro.update({
+    content: "We define a simple olog with two objects and one arrow.",
+});
+
+source.update({
+    label: "Source",
+});
+
+arrow.update({
+    label: "has as",
+    from: source,
+    to: target,
+});
+```
+
+We can also do partial updates.
+
+```ts
+arrow.update({
+    label: "has as example",
+});
+```
+
+We can duplicate formal cells. Copies keep the same logical shape but receive
+fresh identities, and their handles can be updated independently.
+
+```ts
+const sourceCopy = source.duplicate();
+sourceCopy.update({
+    label: "Source copy",
+});
+
+console.log("source:", source.label);
+console.log("source copy:", sourceCopy.label);
+```
+
+```
+source: Source
+source copy: Source copy
+```
+
+## Instantiation
+
+```ts
+import { Instantiation } from "catcolab-documents";
+
+const anotherOlog = await binder.createNotebook(SimpleOlog, { name: "Another Olog" });
+const thing = anotherOlog.add(Type, { label: "Thing" });
+
+const instantiation = notebook.add(Instantiation, {
+    label: "ImportedOlog",
+    model: anotherOlog,
+    // maps ImportedOlog.Thing <- B
+    specializations: [{ object: thing, as: target }],
+});
+
+console.log("instantiation:", instantiation.label);
+```
+
+```
+instantiation: ImportedOlog
+```
+
+## Iterating through cells
+
+We can iterate through cells: both informal cells and formal judgment cells.
+Each cell handle is discriminated by `CellKind`.
+
+```ts
+import { CellKind } from "catcolab-documents";
+
+for (const cell of notebook.cells()) {
+    switch (cell.kind) {
+        case CellKind.RichText:
+            console.log("text:", cell.content);
+            break;
+        case CellKind.Object:
+            console.log("object:", cell.label, "type:", cell.type.obType.content);
+            break;
+        case CellKind.Morphism:
+            console.log("morphism:", cell.label, "type tag:", cell.type.morType.tag);
+            break;
+    }
+}
+```
+
+```
+text: We define a simple olog with two objects and one arrow.
+object: Source type: Object
+object: B type: Object
+morphism: has as type tag: Hom
+```
+
+`formalCells` yields only the formal judgment cells, excluding rich text.
+
+```ts
+console.log("all:", notebook.cells().length);
+console.log("formal:", notebook.formalCells().length);
+for (const cell of notebook.formalCells()) {
+    console.log("formal kind:", cell.kind.toString());
+}
+```
+
+```
+all: 4
+formal: 3
+formal kind: Symbol(object)
+formal kind: Symbol(object)
+formal kind: Symbol(morphism)
+```
+
+We can filter cells by their type, not just their kind and we provide some utilities to do so.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Attr, AttrType, Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleSchema, { name: "Example schema" });
+
+const person = notebook.add(Entity, { label: "Person" });
+const company = notebook.add(Entity, { label: "Company" });
+
+const mapping = notebook.add(Mapping, { label: "employer", from: person, to: company });
+```
+
+```ts
+const entities = notebook.cellsOf(Entity);
+const mappings = notebook.cellsOf(Mapping);
+
+console.log("entities:", entities.map((cell) => cell.label).join(", "));
+console.log("mappings:", mappings.map((cell) => cell.label).join(", "));
+```
+
+```
+entities: Person, Company
+mappings: employer
+```
+
+`cells` and `cellsOf` do not recurse into instantiations.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Instantiation } from "catcolab-documents";
+
+const anotherSchema = await binder.createNotebook(SimpleSchema, { name: "Another schema" });
+const enterprise = anotherSchema.add(Entity, { label: "Enterprise" });
+const building = anotherSchema.add(Entity, { label: "Building" });
+const owner = anotherSchema.add(Mapping, { label: "owner", from: enterprise, to: building });
+
+const instantiation = notebook.add(Instantiation, {
+    label: "ImportedSchema",
+    model: anotherSchema,
+    specializations: [{ object: enterprise, as: company }],
+});
+```
+
+```ts
+const instantiations = notebook.cellsOf(Instantiation);
+const entities = notebook.cellsOf(Entity);
+const mappings = notebook.cellsOf(Mapping);
+
+console.log("instantiations:", instantiations.map((cell) => cell.label).join(", "));
+console.log("entities:", entities.map((cell) => cell.label).join(", "));
+console.log("mappings:", mappings.map((cell) => cell.label).join(", "));
+```
+
+```
+instantiations: ImportedSchema
+entities: Person, Company
+mappings: employer
+```
+
+## Getting a cell by id
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleSchema, { name: "Example schema" });
+
+const person = notebook.add(Entity, { label: "Person" });
+const company = notebook.add(Entity, { label: "Company" });
+
+const mapping = notebook.add(Mapping, { label: "employer", from: person, to: company });
+```
+
+`get` returns a `Result`: an `Ok` carrying the cell as `content`, or an `Err`
+carrying an array of issues.
+
+```ts
+const found = notebook.get(Entity, person.id);
+console.log("tag:", found.tag);
+if (found.tag === "Ok") {
+    console.log("found:", found.content.label);
+}
+```
+
+```
+tag: Ok
+found: Person
+```
+
+A missing id, or an id whose cell has a different type, yields an `Err` result
+whose issues describe the problem.
+
+```ts
+const missing = notebook.get(Entity, "00000000-0000-0000-0000-000000000000");
+if (missing.tag === "Err") {
+    console.log("missing:", missing.content.map((issue) => issue.message).join("; "));
+}
+
+// `employer` is a mapping, not an entity.
+const wrongType = notebook.get(Entity, mapping.id);
+if (wrongType.tag === "Err") {
+    console.log(
+        "wrong type:",
+        wrongType.content
+            .map((issue) => issue.message.replace(mapping.id, "<our-random-uuid>"))
+            .join("; "),
+    );
+}
+```
+
+```
+missing: No cell with id "00000000-0000-0000-0000-000000000000".
+wrong type: Cell "<our-random-uuid>" is not of the expected type.
+```
+
+## Type safety
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const source = notebook.add(Type, { label: "A" });
+const target = notebook.add(Type, { label: "B" });
+const arrow = notebook.add(Aspect, { label: "has", from: source, to: target });
+```
+
+Invalid shapes should be type errors:
+
+```ts
+// @ts-expect-error Arrays are not valid endpoints in a simple olog.
+arrow.update({ from: [source] });
+
+// @ts-expect-error Arrays are not valid endpoints in a simple olog.
+notebook.add(Aspect, { label: "bad", from: [source, target], to: target });
+```
+
+<!-- verifier:reset -->
+
+```ts
+import { AttrType, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { binder } from "catcolab-documents";
+
+const schema = await binder.createNotebook(SimpleSchema, { name: "Example schema" });
+
+const str = schema.add(AttrType, { label: "String" });
+
+// @ts-expect-error A mapping's endpoints must be entities, not attribute types.
+schema.add(Mapping, {
+    label: "bad",
+    from: str,
+    to: str,
+});
+```
+
+But adapt to the underlying logic:
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { PetriNet, Place, Transition } from "catcolab-logics/petri-net";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(PetriNet, { name: "Example Petri-net" });
+
+const a = notebook.add(Place, { label: "A" });
+
+const b = notebook.add(Place, { label: "B" });
+
+const c = notebook.add(Place, { label: "C" });
+
+notebook.add(Transition, {
+    label: "t1",
+    from: [a, b],
+    to: [c],
+});
+
+// @ts-expect-error Petri net transitions require arrays of places.
+notebook.add(Transition, {
+    label: "bad",
+    from: a,
+    to: [c],
+});
+```
+
+## Re-ordering cells
+
+Every cell handle can move itself within the notebook. Moves locate the cell
+by its id at the moment the change applies, so they remain valid even if the
+notebook was edited after the handle was obtained.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, RichText } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const a = notebook.add(Type, { label: "A" });
+const b = notebook.add(Type, { label: "B" });
+const c = notebook.add(Type, { label: "C" });
+
+function names() {
+    return notebook
+        .cellsOf(Type)
+        .map((cell) => cell.label)
+        .join(", ");
+}
+```
+
+`moveUp` and `moveDown` shift a cell one position; `moveTo` moves it to an
+index, interpreted after the cell is removed from its current position.
+
+```ts
+c.moveUp();
+console.log(names());
+
+a.moveDown();
+console.log(names());
+
+b.moveTo(0);
+console.log(names());
+```
+
+```
+A, C, B
+C, A, B
+B, C, A
+```
+
+Impossible moves are silent no-ops and out-of-range targets clamp to the ends
+of the notebook.
+
+```ts
+a.moveUp();
+c.moveDown();
+console.log(names());
+
+b.moveTo(99);
+console.log(names());
+```
+
+```
+A, B, C
+A, C, B
+```
+
+## Deleting cells
+
+Every cell handle can remove itself from the notebook with `delete`. Like the
+reorder methods, delete locates the cell by its id when the change applies, so
+it stays valid even if the notebook was edited after the handle was obtained.
+
+Deleting a cell removes it from the notebook's order and contents.
+
+```ts
+console.log(names());
+b.delete();
+console.log(names());
+```
+
+```
+A, B, C
+A, C
+```
+
+Rich-text cells can be deleted in the same way.
+
+```ts
+const note = notebook.add(RichText, { content: "A note." });
+console.log(notebook.cells().length);
+note.delete();
+console.log(notebook.cells().length);
+```
+
+```
+4
+3
+```
+
+After deletion, reading fields off the stale handle returns `undefined`.
+
+```ts
+b.delete();
+console.log(b.label);
+```
+
+```
+undefined
+```
+
+Deleting an already-deleted cell is a silent no-op.
+
+```ts
+b.delete();
+b.delete();
+console.log(names());
+```
+
+```
+A, C
+```
+
+## Validation
+
+A notebook is a document: a loosely structured collection of cells. To use it
+as a formal model we elaborate it into a core model and validate it. The
+`validate` method walks the formal cells, builds the core model, and runs the
+logic's validation in one step. It returns a `Result`: an `Ok` carrying the
+elaborated model as `content`, or an `Err` carrying an array of issues, so
+ill-formed and invalid notebooks can be handled without throwing.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const source = notebook.add(Type, { label: "A" });
+const target = notebook.add(Type, { label: "B" });
+notebook.add(Aspect, { label: "has", from: source, to: target });
+```
+
+A well-formed notebook validates to an `Ok` carrying the model as `content`.
+
+```ts
+const result = await notebook.validate();
+console.log("valid:", result.tag === "Ok");
+```
+
+```
+valid: true
+```
+
+The validated model is available on the result and can be queried.
+
+```ts
+const result = await notebook.validate();
+if (result.tag === "Ok") {
+    console.log("objects:", result.content.obGenerators().length);
+    console.log("morphisms:", result.content.morGenerators().length);
+}
+```
+
+```
+objects: 2
+morphisms: 1
+```
+
+```ts
+import type { ModelValidationResult } from "catcolab-documents";
+
+function describe(result: ModelValidationResult): string {
+    if (result.tag === "Ok") {
+        return `valid model with ${result.content.obGenerators().length} objects`;
+    }
+    return `invalid model: ${result.content.map((issue) => issue.message).join("; ")}`;
+}
+
+console.log(describe(await notebook.validate()));
+```
+
+```
+valid model with 2 objects
+```
+
+An ill-formed notebook validates to an `Err` carrying issues.
+
+<!-- verifier:reset -->
+
+```ts
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, Instantiation } from "catcolab-documents";
+
+const first = await binder.createNotebook(SimpleOlog, { name: "First" });
+const second = await binder.createNotebook(SimpleOlog, { name: "Second" });
+
+first.add(Type, { label: "A" });
+second.add(Type, { label: "B" });
+
+// A cycle: `first` instantiates `second`, which instantiates `first`.
+first.add(Instantiation, { label: "ImportedSecond", model: second });
+second.add(Instantiation, { label: "ImportedFirst", model: first });
+
+const result = await first.validate();
+console.log("valid:", result.tag === "Ok");
+if (result.tag === "Err") {
+    console.log("issues:", result.content.map((issue) => issue.message).join("; "));
+}
+```
+
+```
+valid: false
+issues: Instantiation cycle detected: "First" → "Second" → "First". A notebook cannot instantiate itself, directly or indirectly. To fix, remove one of the instantiations in this chain.
+```
+
+## Serialization
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { PetriNet } from "catcolab-logics/petri-net";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(PetriNet, { name: "Example Petri-net" });
+```
+
+We can dump a notebook.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const petriNetData = notebook.dump();
+```
+
+And load it. `loadNotebook` returns a `Result`: an `Ok` carrying the notebook
+as `content`, or an `Err` carrying an array of issues.
+
+```ts
+const loaded = await binder.loadNotebook(PetriNet, petriNetData);
+console.log("tag:", loaded.tag);
+if (loaded.tag === "Ok") {
+    console.log("loaded:", loaded.content.name);
+}
+```
+
+```
+tag: Ok
+loaded: Example Petri-net
+```
+
+Trying to load a document with the wrong shape yields an `Err` result whose
+issues describe the mismatch.
+
+```ts
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+
+const wrong = await binder.loadNotebook(SimpleOlog, petriNetData);
+if (wrong.tag === "Err") {
+    console.log("issues:", wrong.content.map((issue) => issue.message).join("; "));
+}
+```
+
+```
+issues: Cannot load document with theory "petri-net" using a shape with theory "simple-olog".
+```
+
+## Migrating between logics
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { binder } from "catcolab-documents";
+
+const olog = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const a = olog.add(Type, { label: "A" });
+const b = olog.add(Type, { label: "B" });
+olog.add(Aspect, { label: "has", from: a, to: b });
+```
+
+`migrateTo` returns a `Result`: an `Ok` carrying the migrated notebook as
+`content`, or an `Err` carrying an array of issues.
+
+```ts
+const migration = await olog.migrateTo(SimpleSchema);
+console.log("tag:", migration.tag);
+if (migration.tag === "Ok") {
+    const schema = migration.content;
+
+    // The original document was rewritten in place, not copied.
+    console.log("same document:", schema.document === olog.document);
+    console.log("theory:", schema.document.theory);
+    console.log(
+        "entities:",
+        schema
+            .cellsOf(Entity)
+            .map((cell) => cell.label)
+            .join(", "),
+    );
+    console.log(
+        "mappings:",
+        schema
+            .cellsOf(Mapping)
+            .map((cell) => cell.label)
+            .join(", "),
+    );
+    console.log("valid:", (await schema.validate()).tag === "Ok");
+}
+```
+
+```
+tag: Ok
+same document: true
+theory: simple-schema
+entities: A, B
+mappings: has
+valid: true
+```
+
+### When migration goes wrong
+
+Not every pair of logics is connected by a migration. Migrating to a logic
+with no defined path yields an `Err` result whose issues describe the
+problem, instead of throwing.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { PetriNet } from "catcolab-logics/petri-net";
+import { binder } from "catcolab-documents";
+
+const olog = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const a = olog.add(Type, { label: "A" });
+const b = olog.add(Type, { label: "B" });
+olog.add(Aspect, { label: "has", from: a, to: b });
+```
+
+```ts
+const result = await olog.migrateTo(PetriNet);
+if (result.tag === "Err") {
+    console.log("issues:", result.content.map((issue) => issue.message).join("; "));
+}
+```
+
+```
+issues: No migration defined from "simple-olog" to "petri-net".
+```
diff --git a/packages/document-methods/test/notebook_subshapes.lts.md b/packages/document-methods/test/notebook_subshapes.lts.md
new file mode 100644
index 000000000..e7e0870cd
--- /dev/null
+++ b/packages/document-methods/test/notebook_subshapes.lts.md
@@ -0,0 +1,127 @@
+# Interactive components over any notebook
+
+A shape declares the object and morphism types a notebook is built from, and
+`cells()` is typed precisely by that shape: a consumer that names a shape must
+handle every cell type the shape implies. A reusable component therefore does
+not pin itself to one theory's shape; it is written against the generic
+`Notebook` interface, whose `cells()` yields the widest `NotebookCell` union. It
+stays fully interactive — it reads cells with `cellsOf`, edits them with
+`update`, and adds new ones with `add` — and because a notebook over any shape
+is assignable to the generic `Notebook`, the component accepts a notebook of any
+theory.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { binder, defineObject, defineShape, type Notebook } from "catcolab-documents";
+import { PetriNet, Place, Transition } from "catcolab-logics/petri-net";
+```
+
+`renamePlaces` is written against the generic `Notebook`. It filters the
+notebook's places, renames each, and adds one — selecting the cells it handles
+with `cellsOf`, ignoring the rest.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+function renamePlaces(notebook: Notebook): string[] {
+    for (const place of notebook.cellsOf(Place)) {
+        place.update({ label: place.label.toUpperCase() });
+    }
+    notebook.add(Place, { label: "new" });
+    return notebook.cellsOf(Place).map((place) => place.label);
+}
+```
+
+A full Petri-net notebook — whose shape has both `Place` and `Transition` — is
+accepted wherever a generic `Notebook` is expected.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const net = await binder.createNotebook(PetriNet, { name: "Net" });
+const a = net.add(Place, { label: "a" });
+const c = net.add(Place, { label: "c" });
+const transition = net.add(Transition, { label: "fires", from: [a], to: [c] });
+```
+
+```ts
+console.log(renamePlaces(net).join(", "));
+```
+
+```
+A, C, new
+```
+
+## Mistakes caught at compile time
+
+Reading cells through `cells()` gives untyped handles, and the component
+boundaries above are typed, so the classic editor mistakes are compile errors.
+
+### A list endpoint read as a single cell
+
+A morphism cell's `from` is either a single cell or a list, so reading a field
+like `.label` off it directly is a type error.
+
+```ts
+import { CellKind } from "catcolab-documents";
+
+for (const cell of net.cells()) {
+    if (cell.kind === CellKind.Morphism) {
+        // @ts-expect-error `from` is a single cell or a list; a list has no `label`.
+        console.log(cell.from.label);
+    }
+}
+```
+
+### A sub-component prop of the wrong theory
+
+A list editor written for places types its prop as `NotebookCell<typeof Place>[]`. A schema
+`Entity` cell is `ObjectCell` of a different object type, so handing it over is
+rejected.
+
+```ts
+import type { NotebookCell } from "catcolab-documents";
+import { Entity, SimpleSchema } from "catcolab-logics/simple-schema";
+
+function renderPlaces(places: NotebookCell<typeof Place>[]): string {
+    return places.map((place) => place.label).join(", ");
+}
+
+const schema = await binder.createNotebook(SimpleSchema, { name: "Schema" });
+const person = schema.add(Entity, { label: "Person" });
+
+// @ts-expect-error A `NotebookCell<typeof Place>[]` prop rejects schema `Entity` cells.
+renderPlaces([person]);
+```
+
+### An update with a foreign cell
+
+A transition's `from` is `NotebookCell<typeof Place>[]`, and `update` constrains the new value the
+same way, so appending a cell of another object type is rejected.
+
+```ts
+import { Entity, SimpleSchema } from "catcolab-logics/simple-schema";
+
+const schema = await binder.createNotebook(SimpleSchema, { name: "Schema" });
+const entity = schema.add(Entity, { label: "Person" });
+
+// @ts-expect-error A transition's `from` is `NotebookCell<typeof Place>[]`; an `Entity` cell is rejected.
+transition.update({ from: [...transition.from, entity] });
+```
+
+### A theory-less shape cannot create a document
+
+A shape without a `theory` — for example one that names only a subset of cell
+types — is rejected by `createNotebook`: it can only describe notebooks, not
+originate them.
+
+```ts
+const PlacesShape = defineShape({
+    objects: [defineObject({ tag: "Basic", content: "Object" })],
+    morphisms: [],
+});
+
+// @ts-expect-error A shape without a `theory` cannot originate a document.
+await binder.createNotebook(PlacesShape, { name: "Nope" });
+```
diff --git a/packages/document-methods/test/notebook_with_automerge_solid_component.lts.md b/packages/document-methods/test/notebook_with_automerge_solid_component.lts.md
new file mode 100644
index 000000000..9e6c0e607
--- /dev/null
+++ b/packages/document-methods/test/notebook_with_automerge_solid_component.lts.md
@@ -0,0 +1,76 @@
+<!-- verifier:prepend-to-following -->
+
+```tsx
+import { type Doc, getBackend, getObjectId } from "@automerge/automerge";
+import { createEffect, createRoot } from "solid-js";
+import { type DocHandle, Repo } from "@automerge/automerge-repo";
+import { makeDocumentProjection } from "@automerge/automerge-repo-solid-primitives";
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+import { createBinder, type DocumentStore } from "catcolab-documents";
+import type { Document } from "catcolab-document-types";
+
+function materializeFromAutomerge<T>(doc: Doc<unknown>, subtree: T): T {
+    const objId = getObjectId(subtree as object);
+    return getBackend(doc).materialize(objId!) as T;
+}
+
+const repo = new Repo();
+
+// The handle wraps the Automerge `DocHandle` together with the Solid projection
+// built from it. `createHandle` builds the projection once with
+// `makeDocumentProjection`, and `getDocumentView` returns that stable projection.
+type SolidAutomergeHandle = {
+    docHandle: DocHandle<Document>;
+    docView: Document;
+};
+
+const makeHandle = (docHandle: DocHandle<Document>): SolidAutomergeHandle => ({
+    docHandle,
+    docView: makeDocumentProjection(docHandle),
+});
+
+const solidAutomergeStore: DocumentStore<SolidAutomergeHandle> = {
+    createHandle: async (initialDoc) => makeHandle(repo.create<Document>(initialDoc as Document)),
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => handle.docHandle.change(fn),
+    subscribe: (handle, callback) => {
+        const onChange = () => callback();
+        handle.docHandle.on("change", onChange);
+        return () => handle.docHandle.off("change", onChange);
+    },
+    copyValue: (handle, value) => materializeFromAutomerge(handle.docHandle.doc(), value),
+    getDocumentRef: (handle) => ({ id: handle.docHandle.documentId, version: null, server: "" }),
+    getHandle: async () => ({
+        tag: "Err" as const,
+        content: [{ message: "This store cannot resolve references." }],
+    }),
+};
+
+const automergeBinder = createBinder(solidAutomergeStore);
+```
+
+```tsx
+import { render } from "solid-js/web";
+
+const notebook = await automergeBinder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+function Title(props: { title: string }) {
+    return <h1>{props.title}</h1>;
+}
+
+const container = document.createElement("div");
+document.body.appendChild(container);
+
+const dispose = render(() => <Title title={notebook.name} />, container);
+console.log(container.innerHTML);
+
+notebook.update({ name: "A renamed Olog" });
+console.log(container.innerHTML);
+
+dispose();
+```
+
+```
+<h1>An Olog</h1>
+<h1>A renamed Olog</h1>
+```
diff --git a/packages/document-methods/test/notebook_with_solid.lts.md b/packages/document-methods/test/notebook_with_solid.lts.md
new file mode 100644
index 000000000..c5c54c9e0
--- /dev/null
+++ b/packages/document-methods/test/notebook_with_solid.lts.md
@@ -0,0 +1,395 @@
+A notebook's storage is abstracted to allow plugging in custom stores. This could be used with anything but our concrete plan is to use this with Solid and Automerge.
+
+A `DocumentStore` is a stateless object that works on handles of its own choosing. `createHandle` creates a handle from an initial document; the other methods receive that handle back: `getDocumentView` returns the read-only view, `changeDocument` applies a draft mutation, `subscribe` notifies of changes (returning an unsubscribe function), and `copyValue` makes detached plain-JS copies of values from the store's canonical document. A store also provides `getDocumentRef` (the handle's stable `DocumentRef`) and `getHandle` (fetches a handle by `DocumentRef`, the inverse of `getDocumentRef`). The shared recursive resolver uses `getHandle` to resolve an instantiation to an elaborated model, elaborating every node against the host notebook's core theory, and rejecting when it cannot.
+
+A store is bound once with `createBinder`, which yields the notebook entry points `createNotebook`, `loadNotebook`, and `loadNotebookFromRef`.
+
+We can plug in Solid's reactivity by itself using `createStore` and `reconcile`.
+The handle keeps a plain document as the source of truth and each change is
+reconciled into the Solid store projection.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { createEffect, createRoot } from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, createBinder, type DocumentStore } from "catcolab-documents";
+import type { Document } from "catcolab-document-types";
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+// Every store mints a stable reference for its handles; this one assigns an id
+// on demand and keeps it in a WeakMap.
+const solidStoreIds = new WeakMap<SolidStoreHandle, string>();
+const solidStoreIdFor = (handle: SolidStoreHandle): string => {
+    let id = solidStoreIds.get(handle);
+    if (!id) {
+        id = crypto.randomUUID();
+        solidStoreIds.set(handle, id);
+    }
+    return id;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    getDocumentView: (handle) => handle.docView,
+    getDocumentRef: (handle) => ({ id: solidStoreIdFor(handle), version: null, server: "" }),
+    getHandle: async () => ({
+        tag: "Err" as const,
+        content: [{ message: "This store cannot resolve references." }],
+    }),
+};
+
+const solidBinder = createBinder(solidStore);
+
+const notebook = await solidBinder.createNotebook(SimpleOlog, { name: "An Olog" });
+```
+
+A binder can also load an existing plain document instead of creating a fresh
+notebook. The store initializes its storage from the document.
+
+```ts
+const existingSolidDoc = (await binder.createNotebook(SimpleOlog, { name: "Loaded Olog" }))
+    .document;
+
+const loadedResult = await solidBinder.loadNotebook(SimpleOlog, existingSolidDoc);
+console.log("tag:", loadedResult.tag);
+if (loadedResult.tag === "Ok") {
+    const loadedSolidNotebook = loadedResult.content;
+
+    createRoot(async () => {
+        createEffect(() => {
+            console.log("loaded notebook name:", loadedSolidNotebook.name);
+        });
+
+        await Promise.resolve();
+        loadedSolidNotebook.update({ name: "Updated loaded Olog" });
+        await Promise.resolve();
+    });
+}
+```
+
+```
+tag: Ok
+loaded notebook name: Loaded Olog
+loaded notebook name: Updated loaded Olog
+```
+
+Reads of fields, e.g. `notebook.name` are reactive.
+
+```ts
+createRoot(async () => {
+    createEffect(() => {
+        console.log("notebook name:", notebook.name);
+    });
+    // Await a no-op to let the event loop get to running the effect.
+    await Promise.resolve();
+    notebook.update({ name: "An updated Olog" });
+    await Promise.resolve();
+});
+```
+
+```
+notebook name: An Olog
+notebook name: An updated Olog
+```
+
+Cell handles are reactive too. `source.label` reads from the same store, so it can be used directly inside an effect.
+
+```ts
+createRoot(async () => {
+    const obj = notebook.add(Type, { label: "A" });
+
+    createEffect(() => {
+        console.log("obj:", obj.label);
+    });
+
+    await Promise.resolve();
+    obj.update({ label: "Updated" });
+    await Promise.resolve();
+});
+```
+
+```
+obj: A
+obj: Updated
+```
+
+Reactivity is fine-grained. Because every change is diffed into the projection
+with `reconcile`, only signals for values that actually changed fire: an effect
+reading one cell does not re-run when a different cell — or the notebook's own
+metadata — changes, even though the notebook API rewrites whole cell objects on
+`update`.
+
+```ts
+createRoot(async () => {
+    const a = notebook.add(Type, { label: "A" });
+    const b = notebook.add(Type, { label: "B" });
+
+    createEffect(() => {
+        console.log("a effect:", a.label);
+    });
+    createEffect(() => {
+        console.log("b effect:", b.label);
+    });
+
+    await Promise.resolve();
+    // Only the effect reading `b` re-runs; `a`'s effect stays quiet.
+    b.update({ label: "B updated" });
+    await Promise.resolve();
+    // A notebook-level change doesn't re-run either cell effect.
+    notebook.update({ name: "Renamed Olog" });
+    await Promise.resolve();
+    console.log("notebook:", notebook.name);
+});
+```
+
+```
+a effect: A
+b effect: B
+b effect: B updated
+notebook: Renamed Olog
+```
+
+Copies materialize through the store before writing the duplicate, so Solid
+store proxies do not leak into the copied cell.
+
+```ts
+createRoot(async () => {
+    const obj = notebook.add(Type, { label: "A" });
+    const copiedObj = obj.duplicate();
+
+    createEffect(() => {
+        console.log("obj:", obj.label);
+        console.log("copied obj:", copiedObj.label);
+    });
+
+    await Promise.resolve();
+    obj.update({ label: "Updated" });
+    await Promise.resolve();
+    copiedObj.update({ label: "Updated copied" });
+    await Promise.resolve();
+});
+```
+
+```
+obj: A
+copied obj: A
+obj: Updated
+copied obj: A
+obj: Updated
+copied obj: Updated copied
+```
+
+<!-- verifier:reset -->
+
+To combine Solid reactivity with Automerge, we can plug in `makeDocumentProjection` from `@automerge/automerge-repo-solid-primitives`. The store's handle wraps the Automerge `DocHandle` alongside the Solid projection built from it: `createHandle` (and `getHandle`) create the document in the repo and build the projection once with `makeDocumentProjection`, and `getDocumentView` just returns that stable projection.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { type Doc, getBackend, getObjectId } from "@automerge/automerge";
+import { createEffect, createRoot } from "solid-js";
+import { type DocHandle, type DocumentId, Repo } from "@automerge/automerge-repo";
+import { makeDocumentProjection } from "@automerge/automerge-repo-solid-primitives";
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { createBinder, type DocumentStore } from "catcolab-documents";
+import type { Document } from "catcolab-document-types";
+
+function materializeFromAutomerge<T>(doc: Doc<unknown>, subtree: T): T {
+    const objId = getObjectId(subtree as object);
+    return getBackend(doc).materialize(objId!) as T;
+}
+
+const repo = new Repo();
+
+// The handle wraps the Automerge `DocHandle` together with the Solid projection
+// built from it. `createHandle` builds the projection once with
+// `makeDocumentProjection`, and `getDocumentView` returns that stable projection.
+type SolidAutomergeHandle = {
+    docHandle: DocHandle<Document>;
+    docView: Document;
+};
+
+const makeHandle = (docHandle: DocHandle<Document>): SolidAutomergeHandle => ({
+    docHandle,
+    docView: makeDocumentProjection(docHandle),
+});
+
+// A `DocumentRef` identifies a document by its Automerge `DocumentId`, so
+// `getHandle` resolves one by `repo.find`ing it (the analog of the frontend's
+// `Api.getDocHandle`), projecting it once into a handle.
+const handlesByDocId = new Map<string, SolidAutomergeHandle>();
+
+const solidAutomergeStore: DocumentStore<SolidAutomergeHandle> = {
+    createHandle: async (initialDoc) => {
+        const handle = makeHandle(repo.create<Document>(initialDoc as Document));
+        handlesByDocId.set(handle.docHandle.documentId, handle);
+        return handle;
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => handle.docHandle.change(fn),
+    subscribe: (handle, callback) => {
+        const onChange = () => callback();
+        handle.docHandle.on("change", onChange);
+        return () => handle.docHandle.off("change", onChange);
+    },
+    copyValue: (handle, value) => materializeFromAutomerge(handle.docHandle.doc(), value),
+    getDocumentRef: (handle) => ({
+        id: handle.docHandle.documentId,
+        version: null,
+        server: "",
+    }),
+    getHandle: async (ref) => {
+        const cached = handlesByDocId.get(ref.id);
+        if (cached) {
+            return { tag: "Ok" as const, content: cached };
+        }
+        const docHandle = await repo.find<Document>(ref.id as DocumentId);
+        const handle = makeHandle(docHandle);
+        handlesByDocId.set(ref.id, handle);
+        return { tag: "Ok" as const, content: handle };
+    },
+};
+
+const automergeBinder = createBinder(solidAutomergeStore);
+
+const notebook = await automergeBinder.createNotebook(SimpleOlog, { name: "An Olog" });
+```
+
+```ts
+createRoot(async () => {
+    createEffect(() => {
+        console.log("notebook name:", notebook.name);
+    });
+    await Promise.resolve();
+    notebook.update({ name: "An updated Olog" });
+    await Promise.resolve();
+});
+```
+
+```
+notebook name: An Olog
+notebook name: An updated Olog
+```
+
+Copies materialize from the Automerge document itself rather than from the Solid
+projection.
+
+```ts
+const copiedAutomergeObj = notebook.add(Type, { label: "Copied with Automerge" }).duplicate();
+copiedAutomergeObj.update({ label: "Updated Automerge copy" });
+console.log("automerge copy:", copiedAutomergeObj.label);
+```
+
+```
+automerge copy: Updated Automerge copy
+```
+
+The notebook exposes its store handle, so e.g. the Automerge URL is available
+as `notebook.handle.docHandle.url`. To work with an existing Automerge document,
+take a reference to it with `getDocumentRef` and load it using
+`loadNotebookFromRef`, which resolves the reference back to a handle through the
+store's `getHandle`.
+
+```ts
+const sourceNotebook = await automergeBinder.createNotebook(SimpleOlog, {
+    name: "Automerge Olog",
+});
+
+const ref = solidAutomergeStore.getDocumentRef(sourceNotebook.handle)!;
+const result = await automergeBinder.loadNotebookFromRef(SimpleOlog, ref);
+console.log("tag:", result.tag);
+if (result.tag === "Ok") {
+    const loadedNotebook = result.content;
+
+    loadedNotebook.update({ name: `Loaded ${loadedNotebook.name}` });
+    console.log("loaded automerge notebook:", loadedNotebook.name);
+}
+```
+
+```
+tag: Ok
+loaded automerge notebook: Loaded Automerge Olog
+```
+
+Migration mutates the document in place, so the store handle is preserved. The
+migrated notebook keeps the very same Automerge `DocHandle` and URL as before.
+
+```ts
+import { SimpleSchema } from "catcolab-logics/simple-schema";
+
+const migratable = await automergeBinder.createNotebook(SimpleOlog, { name: "To migrate" });
+const urlBefore = migratable.handle.docHandle.url;
+
+const migration = await migratable.migrateTo(SimpleSchema);
+console.log("tag:", migration.tag);
+if (migration.tag === "Ok") {
+    const migrated = migration.content;
+
+    console.log("same handle:", migrated.handle === migratable.handle);
+    console.log("same url:", migrated.handle.docHandle.url === urlBefore);
+    console.log("theory:", migrated.document.theory);
+}
+```
+
+```
+tag: Ok
+same handle: true
+same url: true
+theory: simple-schema
+```
+
+Because the store wires `subscribe` to the `DocHandle`'s `change` event,
+`notebook.onChange` fires for changes arriving from _any_ source — including
+remote edits made by another collaborator on the same Automerge document. Here
+we simulate a remote collaborator by editing through a second handle on the same
+document found in the repo.
+
+```ts
+const shared = await automergeBinder.createNotebook(SimpleOlog, { name: "Shared Olog" });
+
+let observedChanges = 0;
+const unsubscribe = shared.onChange(() => {
+    observedChanges += 1;
+});
+
+const remoteHandle = await repo.find<Document>(shared.handle.docHandle.url);
+remoteHandle.change((doc) => {
+    doc.name = "Edited by a collaborator";
+});
+
+await Promise.resolve();
+console.log("observed remote change:", observedChanges > 0);
+console.log("name after remote edit:", shared.name);
+unsubscribe();
+```
+
+```
+observed remote change: true
+name after remote edit: Edited by a collaborator
+```
diff --git a/packages/document-methods/test/notebook_with_solid_completions.lts.md b/packages/document-methods/test/notebook_with_solid_completions.lts.md
new file mode 100644
index 000000000..ccb1ec04d
--- /dev/null
+++ b/packages/document-methods/test/notebook_with_solid_completions.lts.md
@@ -0,0 +1,287 @@
+# SolidJS completion pickers
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+import {
+    type NotebookCell,
+    CellKind,
+    createBinder,
+    defineMorphism,
+    defineObject,
+    defineShape,
+    type DocumentStore,
+    type ModelValidationResult,
+    type Notebook,
+    RichText,
+    type ValidatableNotebook,
+} from "catcolab-documents";
+import {
+    createContext,
+    createSignal,
+    For,
+    onCleanup,
+    Show,
+    useContext,
+    type Accessor,
+} from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { render } from "solid-js/web";
+
+import type { Document } from "catcolab-document-types";
+import type { DblModel, ObType, QualifiedName } from "catlog-wasm";
+import { selfResolving } from "document-methods/test/self_resolving";
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    ...selfResolving<SolidStoreHandle>(),
+};
+
+const solidBinder = createBinder(solidStore);
+```
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+const MyEntity = defineObject({ tag: "Basic", content: "Entity" });
+const MyAttrType = defineObject({ tag: "Basic", content: "AttrType" });
+const MyAttr = defineMorphism(
+    { tag: "Basic", content: "Attr" },
+    { domain: MyEntity.obType, codomain: MyAttrType.obType },
+);
+
+const MyShape = defineShape({
+    objects: [MyEntity, MyAttrType],
+    morphisms: [MyAttr],
+    informal: [RichText],
+});
+
+type MyNotebook = Notebook<typeof MyShape>;
+```
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+function label(model: DblModel, id: QualifiedName): string {
+    return model.obGeneratorLabel(id)?.join(".") ?? "?";
+}
+
+function filteredCompletions(model: DblModel, obType: ObType, text: string): QualifiedName[] {
+    const needle = text.toLowerCase();
+    return model
+        .obGeneratorsWithType(obType)
+        .filter((id) => label(model, id).toLowerCase().includes(needle));
+}
+
+function codomainLabel(model: DblModel | undefined, morphism: NotebookCell<typeof MyAttr>): string {
+    if (!model) {
+        return "?";
+    }
+    const cod = model?.morPresentation(morphism.id)?.cod;
+    return cod?.tag === "Basic" ? label(model, cod.content) : "?";
+}
+```
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+type MyContextValue = {
+    notebook: MyNotebook;
+    model: Accessor<DblModel>;
+};
+
+const MyContext = createContext<MyContextValue>();
+
+function useMyContext() {
+    const context = useContext(MyContext);
+    if (!context) {
+        throw new Error("Schema editor context is missing.");
+    }
+    return context;
+}
+
+function selectCodomain(
+    notebook: MyNotebook,
+    attrCell: NotebookCell<typeof MyAttr>,
+    id: QualifiedName,
+) {
+    const result = notebook.get(MyAttrType, id);
+    if (result.tag === "Ok") {
+        attrCell.update({ to: result.content });
+    }
+}
+
+function CompletionPicker(props: {
+    obType: ObType;
+    selected: string;
+    text: Accessor<string>;
+    onSelect: (id: QualifiedName) => void;
+}) {
+    const context = useMyContext();
+    return (
+        <span class="picker">
+            <span class="selected">{props.selected}</span>
+            <ul class="completion-list">
+                <For each={filteredCompletions(context.model(), props.obType, props.text())}>
+                    {(id) => (
+                        <li onClick={() => props.onSelect(id)}>{label(context.model(), id)}</li>
+                    )}
+                </For>
+            </ul>
+        </span>
+    );
+}
+
+function MyAttrCellEditor(props: {
+    attrCell: NotebookCell<typeof MyAttr>;
+    text: Accessor<string>;
+}) {
+    const context = useMyContext();
+    return (
+        <li>
+            Attr: {props.attrCell.label}: {props.attrCell.from.label} -&gt;{" "}
+            <CompletionPicker
+                obType={MyAttrType.obType}
+                selected={codomainLabel(context.model(), props.attrCell)}
+                text={props.text}
+                onSelect={(id) => selectCodomain(context.notebook, props.attrCell, id)}
+            />
+        </li>
+    );
+}
+
+function MyCellEditor(props: { cell: NotebookCell<typeof MyShape>; text: Accessor<string> }) {
+    if (props.cell.kind === CellKind.Morphism) {
+        return <MyAttrCellEditor attrCell={props.cell} text={props.text} />;
+    }
+    if (props.cell.kind === CellKind.Object) {
+        const kind = props.cell.type === MyAttrType ? "MyAttrType" : "MyEntity";
+        return (
+            <li>
+                {kind}: {props.cell.label}
+            </li>
+        );
+    }
+    if (props.cell.kind === CellKind.RichText) {
+        return <li>Text: {props.cell.content}</li>;
+    }
+    return null;
+}
+
+// Globals for testing
+let testCurrentModel!: () => DblModel | undefined;
+
+function MyNotebookEditor(props: {
+    notebook: MyNotebook & ValidatableNotebook;
+    text: Accessor<string>;
+}) {
+    const [validation, setValidation] = createSignal<ModelValidationResult>();
+    const unsubscribe = props.notebook.onValidate(setValidation);
+    onCleanup(unsubscribe);
+
+    const model = () => {
+        const result = validation();
+        return result?.tag === "Ok" ? result.content : undefined;
+    };
+
+    testCurrentModel = model;
+
+    return (
+        <section>
+            <h1>{props.notebook.name}</h1>
+            <Show when={model()} fallback={<p>Validating...</p>}>
+                {(m) => (
+                    <MyContext.Provider value={{ notebook: props.notebook, model: m }}>
+                        <ul>
+                            <For each={props.notebook.cellsOf(MyShape)}>
+                                {(cell) => <MyCellEditor cell={cell} text={props.text} />}
+                            </For>
+                        </ul>
+                    </MyContext.Provider>
+                )}
+            </Show>
+        </section>
+    );
+}
+```
+
+```tsx
+import { Attr, AttrType, Entity, SimpleSchema } from "catcolab-logics/simple-schema";
+async function until(predicate: () => boolean) {
+    while (!predicate()) {
+        await new Promise((resolve) => setTimeout(resolve));
+    }
+}
+
+const notebook = await solidBinder.createNotebook(SimpleSchema, { name: "Company schema" });
+const person = notebook.add(Entity, { label: "Person" });
+const string = notebook.add(AttrType, { label: "String" });
+notebook.add(AttrType, { label: "Integer" });
+notebook.add(AttrType, { label: "Boolean" });
+const name = notebook.add(Attr, { label: "name", from: person, to: string });
+
+const [text, setText] = createSignal("");
+const container = document.createElement("div");
+document.body.appendChild(container);
+const dispose = render(() => <MyNotebookEditor notebook={notebook} text={text} />, container);
+
+await until(() => testCurrentModel() !== undefined);
+console.log(
+    "all:",
+    [...container.querySelectorAll(".completion-list li")].map((li) => li.textContent).join(", "),
+);
+console.log("codomain:", codomainLabel(testCurrentModel(), name));
+
+setText("in");
+console.log(
+    "filtered:",
+    [...container.querySelectorAll(".completion-list li")].map((li) => li.textContent).join(", "),
+);
+
+const model = testCurrentModel();
+if (!model) {
+    throw new Error("Expected a valid model.");
+}
+const integer = filteredCompletions(model, MyAttrType.obType, "in").find(
+    (id) => label(model, id) === "Integer",
+)!;
+selectCodomain(notebook, name, integer);
+await until(() => codomainLabel(testCurrentModel(), name) === "Integer");
+console.log("codomain:", codomainLabel(testCurrentModel(), name));
+
+dispose();
+container.remove();
+```
+
+```
+all: String, Integer, Boolean
+codomain: String
+filtered: String, Integer
+codomain: Integer
+```
diff --git a/packages/document-methods/test/notebook_with_solid_components.lts.md b/packages/document-methods/test/notebook_with_solid_components.lts.md
new file mode 100644
index 000000000..4335ea001
--- /dev/null
+++ b/packages/document-methods/test/notebook_with_solid_components.lts.md
@@ -0,0 +1,80 @@
+<!-- verifier:prepend-to-following -->
+
+```tsx
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { render } from "solid-js/web";
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+import { createBinder, type DocumentStore } from "catcolab-documents";
+import type { Document } from "catcolab-document-types";
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStoreIds = new WeakMap<SolidStoreHandle, string>();
+const solidStoreIdFor = (handle: SolidStoreHandle): string => {
+    let id = solidStoreIds.get(handle);
+    if (!id) {
+        id = crypto.randomUUID();
+        solidStoreIds.set(handle, id);
+    }
+    return id;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    getDocumentRef: (handle) => ({ id: solidStoreIdFor(handle), version: null, server: "" }),
+    getHandle: async () => ({
+        tag: "Err" as const,
+        content: [{ message: "This store cannot resolve references." }],
+    }),
+};
+
+const solidBinder = createBinder(solidStore);
+
+const notebook = await solidBinder.createNotebook(SimpleOlog, { name: "An Olog" });
+```
+
+```tsx
+function Title(props: { title: string }) {
+    return <h1>{props.title}</h1>;
+}
+
+const container = document.createElement("div");
+document.body.appendChild(container);
+
+const dispose = render(() => <Title title={notebook.name} />, container);
+console.log(container.innerHTML);
+
+notebook.update({ name: "A renamed Olog" });
+console.log(container.innerHTML);
+
+dispose();
+```
+
+```
+<h1>An Olog</h1>
+<h1>A renamed Olog</h1>
+```
diff --git a/packages/document-methods/test/notebook_with_solid_morphism_editor.lts.md b/packages/document-methods/test/notebook_with_solid_morphism_editor.lts.md
new file mode 100644
index 000000000..4d3521875
--- /dev/null
+++ b/packages/document-methods/test/notebook_with_solid_morphism_editor.lts.md
@@ -0,0 +1,224 @@
+# A simple morphism editor with completions
+
+This example is a smaller companion to the object editor and the completion
+pickers: one component that lists a notebook's morphisms and lets the user
+repoint each morphism's target from a completion list. The completions come
+from the _validated_ model, not from raw cells, following the same pipeline as
+the frontend:
+
+1. validate the notebook to get the elaborated `DblModel`,
+2. ask the model for object generators of the endpoint's type,
+3. filter their labels by the user's text,
+4. on selection, resolve the chosen id back to a typed cell and update the
+   morphism endpoint.
+
+The component is written against a minimal shape — one basic object type and
+the `Hom` morphism over it — so any structurally matching logic can use it. The
+notebook we render below is a `SimpleOlog`.
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+import {
+    type NotebookCell,
+    createBinder,
+    defineMorphism,
+    defineObject,
+    defineShape,
+    type DocumentStore,
+    type ModelValidationResult,
+    type Notebook,
+    type ValidatableNotebook,
+} from "catcolab-documents";
+import { createSignal, For, onCleanup, Show, type Accessor } from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { delegateEvents, render } from "solid-js/web";
+
+import type { Document } from "catcolab-document-types";
+import type { DblModel, QualifiedName } from "catlog-wasm";
+import { selfResolving } from "document-methods/test/self_resolving";
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    ...selfResolving<SolidStoreHandle>(),
+};
+
+const solidBinder = createBinder(solidStore);
+```
+
+The shape declares just what the editor touches: `Node` objects and `Arrow`
+morphisms between them. It has no theory, so validation is required from the
+concrete notebook passed in — hence the `ValidatableNotebook` intersection in
+the prop type.
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+const Node = defineObject({ tag: "Basic", content: "Object" });
+const Arrow = defineMorphism({ tag: "Hom", content: Node.obType });
+
+const ArrowEditorShape = defineShape({
+    objects: [Node],
+    morphisms: [Arrow],
+});
+
+type ArrowNotebook = Notebook<typeof ArrowEditorShape> & ValidatableNotebook;
+```
+
+The editor uses `onValidate` to re-validate whenever anything the validation
+depends on changes, delivering only actual result changes. While the model is
+available, each morphism row shows its endpoints and a completion list of every
+object generator whose label matches the filter text; clicking a completion
+resolves the id back to a typed `Node` cell and updates the morphism's `to`
+endpoint.
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+function label(model: DblModel, id: QualifiedName): string {
+    return model.obGeneratorLabel(id)?.join(".") ?? "?";
+}
+
+// Global for testing
+let testCurrentModel!: () => DblModel | undefined;
+
+function MorphismEditor(props: { notebook: ArrowNotebook; text: Accessor<string> }) {
+    const [validation, setValidation] = createSignal<ModelValidationResult>();
+    const unsubscribe = props.notebook.onValidate(setValidation);
+    onCleanup(unsubscribe);
+
+    const model = () => {
+        const result = validation();
+        return result?.tag === "Ok" ? result.content : undefined;
+    };
+    testCurrentModel = model;
+
+    const completions = (model: DblModel) => {
+        const needle = props.text().toLowerCase();
+        return model
+            .obGeneratorsWithType(Node.obType)
+            .filter((id) => label(model, id).toLowerCase().includes(needle));
+    };
+
+    const select = (arrow: NotebookCell<typeof Arrow>, id: QualifiedName) => {
+        const target = props.notebook.get(Node, id);
+        if (target.tag === "Ok") {
+            arrow.update({ to: target.content });
+        }
+    };
+
+    return (
+        <section>
+            <h1>{props.notebook.name}</h1>
+            <Show when={model()} fallback={<p>Validating...</p>}>
+                {(m) => (
+                    <ul>
+                        <For each={props.notebook.cellsOf(Arrow)}>
+                            {(arrow) => (
+                                <li>
+                                    {arrow.label}: {arrow.from.label} -&gt;{" "}
+                                    <span class="selected">{arrow.to.label}</span>
+                                    <ul class="completions">
+                                        <For each={completions(m())}>
+                                            {(id) => (
+                                                <li onClick={() => select(arrow, id)}>
+                                                    {label(m(), id)}
+                                                </li>
+                                            )}
+                                        </For>
+                                    </ul>
+                                </li>
+                            )}
+                        </For>
+                    </ul>
+                )}
+            </Show>
+        </section>
+    );
+}
+```
+
+Now render a `SimpleOlog` notebook with the generic component, filter the
+completions, and click one. The click goes through the delegated `onClick`
+handler, so the delegated event type is registered up front (top-level code
+here runs before the compiled module's own `delegateEvents` call). Reading the
+aspect back through its typed handle shows the repointed target.
+
+```tsx
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+
+delegateEvents(["click"]);
+
+async function until(predicate: () => boolean) {
+    while (!predicate()) {
+        await new Promise((resolve) => setTimeout(resolve));
+    }
+}
+
+function completionTexts(container: HTMLElement): string {
+    return [...container.querySelectorAll(".completions li")]
+        .map((li) => li.textContent)
+        .join(", ");
+}
+
+const olog = await solidBinder.createNotebook(SimpleOlog, { name: "An olog" });
+const person = olog.add(Type, { label: "person" });
+const city = olog.add(Type, { label: "city" });
+olog.add(Type, { label: "country" });
+const livesIn = olog.add(Aspect, { label: "lives in", from: person, to: city });
+
+const [text, setText] = createSignal("");
+const container = document.createElement("div");
+document.body.appendChild(container);
+const dispose = render(() => <MorphismEditor notebook={olog} text={text} />, container);
+
+await until(() => testCurrentModel() !== undefined);
+console.log("all:", completionTexts(container));
+
+setText("c");
+console.log("filtered:", completionTexts(container));
+
+const country = [...container.querySelectorAll<HTMLElement>(".completions li")].find(
+    (li) => li.textContent === "country",
+);
+country?.click();
+
+await until(() => livesIn.to.label === "country");
+console.log("selected:", container.querySelector(".selected")?.textContent);
+console.log("aspect:", livesIn.from.label, `-[${livesIn.label}]->`, livesIn.to.label);
+dispose();
+container.remove();
+```
+
+```
+all: person, city, country
+filtered: city, country
+selected: country
+aspect: person -[lives in]-> country
+```
diff --git a/packages/document-methods/test/notebook_with_solid_object_editor.lts.md b/packages/document-methods/test/notebook_with_solid_object_editor.lts.md
new file mode 100644
index 000000000..88cb45828
--- /dev/null
+++ b/packages/document-methods/test/notebook_with_solid_object_editor.lts.md
@@ -0,0 +1,279 @@
+# A basic object editor for ologs and Petri nets
+
+This example shows a small object editor written once and reused across logics.
+The component is not written against any particular logic: it defines the shapes
+it works with — one with a single object type `{ tag: "Basic", content:
+"Object" }`, one with `{ tag: "Basic", content: "Entity" }`, both with no
+morphisms — and types its notebook prop by their union. The shape match is
+structural, and a notebook matching _any_ member of the union is accepted:
+
+- `SimpleOlog`'s `Type` and `PetriNet`'s `Place` are both basic objects of type
+  `Object`, so olog and Petri-net notebooks match the `Object` member,
+- `SimpleSchema` declares `Entity` (alongside `AttrType`), a superset of the
+  `Entity` member's objects, so a schema notebook is assignable too.
+
+Cells the shapes do not declare — olog aspects, Petri-net transitions, schema
+attributes — are never selected by `cellsOf`, yet they share state with the
+edited objects: renaming a place through the editor is immediately visible
+through a typed transition handle.
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+import {
+    createBinder,
+    defineObject,
+    defineShape,
+    type DocumentStore,
+    type Notebook,
+} from "catcolab-documents";
+import { For } from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { delegateEvents, render } from "solid-js/web";
+
+import type { Document } from "catcolab-document-types";
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStoreIds = new WeakMap<SolidStoreHandle, string>();
+const solidStoreIdFor = (handle: SolidStoreHandle): string => {
+    let id = solidStoreIds.get(handle);
+    if (!id) {
+        id = crypto.randomUUID();
+        solidStoreIds.set(handle, id);
+    }
+    return id;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    getDocumentRef: (handle) => ({ id: solidStoreIdFor(handle), version: null, server: "" }),
+    getHandle: async () => ({
+        tag: "Err" as const,
+        content: [{ message: "This store cannot resolve references." }],
+    }),
+};
+
+const solidBinder = createBinder(solidStore);
+```
+
+The editor itself. The shape names the cell types the component may see, and
+the notebook prop is typed by it, so any notebook with a structurally matching
+object type — and only such a notebook — can be passed in. It renders one
+rename input per basic object and an add button. Nothing here mentions ologs or
+Petri nets. The shape has no `theory`, so it can describe notebooks but not
+originate them; creating the documents stays with the concrete logics below.
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+const BasicObject = defineObject({ tag: "Basic", content: "Object" });
+
+const BasicObjectShape = defineShape({
+    objects: [BasicObject],
+});
+
+const EntityObject = defineObject({ tag: "Basic", content: "Entity" });
+
+const EntityObjectShape = defineShape({
+    objects: [EntityObject],
+});
+
+function ObjectEditor(props: {
+    notebook: Notebook<typeof BasicObjectShape | typeof EntityObjectShape>;
+}) {
+    const addObject = () => {
+        if (props.notebook.supports(BasicObject)) {
+            props.notebook.add(BasicObject, { label: "new object" });
+        } else if (props.notebook.supports(EntityObject)) {
+            props.notebook.add(EntityObject, { label: "new entity" });
+        }
+    };
+
+    return (
+        <section>
+            <h1>{props.notebook.name}</h1>
+            <ul>
+                <For
+                    each={[
+                        ...props.notebook.cellsOf(BasicObject),
+                        ...props.notebook.cellsOf(EntityObject),
+                    ]}
+                >
+                    {(object) => (
+                        <li>
+                            <input
+                                aria-label={`rename ${object.label}`}
+                                value={object.label}
+                                onInput={(event) =>
+                                    object.update({ label: event.currentTarget.value })
+                                }
+                            />
+                        </li>
+                    )}
+                </For>
+            </ul>
+            <button onClick={addObject}>Add</button>
+        </section>
+    );
+}
+```
+
+A few helpers drive the rendered editor through the DOM, the way a user would:
+typing into a rename input and clicking the add button.
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+function names(container: HTMLElement): string {
+    return [...container.querySelectorAll("input")].map((input) => input.value).join(", ");
+}
+
+function renameThrough(container: HTMLElement, from: string, to: string) {
+    const input = container.querySelector<HTMLInputElement>(`[aria-label="rename ${from}"]`);
+    if (!input) {
+        throw new Error(`No rename input for ${from}.`);
+    }
+    input.value = to;
+    input.dispatchEvent(new Event("input", { bubbles: true }));
+}
+```
+
+## Editing an olog
+
+The editor lists the olog's types and renames one. The aspect between them is
+untouched by the editor, but reading its endpoints back through the typed
+handle shows the rename, because both views read the same cell.
+
+```tsx
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+
+const olog = await solidBinder.createNotebook(SimpleOlog, { name: "An olog" });
+const person = olog.add(Type, { label: "person" });
+const city = olog.add(Type, { label: "city" });
+const livesIn = olog.add(Aspect, { label: "lives in", from: person, to: city });
+
+const container = document.createElement("div");
+document.body.appendChild(container);
+const dispose = render(() => <ObjectEditor notebook={olog} />, container);
+
+console.log(names(container));
+
+renameThrough(container, "person", "inhabitant");
+container.querySelector("button")?.click();
+console.log(names(container));
+
+console.log("aspect:", livesIn.from.label, `-[${livesIn.label}]->`, livesIn.to.label);
+
+dispose();
+container.remove();
+```
+
+```
+person, city
+inhabitant, city, new object
+aspect: inhabitant -[lives in]-> city
+```
+
+## Editing a Petri net
+
+The same component, unchanged, edits the places of a Petri net. The transition
+is never rendered, but its endpoints resolve to the renamed place cells.
+
+```tsx
+import { PetriNet, Place, Transition } from "catcolab-logics/petri-net";
+
+const net = await solidBinder.createNotebook(PetriNet, { name: "Reaction network" });
+const substrate = net.add(Place, { label: "substrate" });
+const product = net.add(Place, { label: "product" });
+const converts = net.add(Transition, { label: "converts", from: [substrate], to: [product] });
+
+const container = document.createElement("div");
+document.body.appendChild(container);
+const dispose = render(() => <ObjectEditor notebook={net} />, container);
+
+console.log(names(container));
+
+renameThrough(container, "substrate", "reactant");
+console.log(names(container));
+
+console.log(
+    "transition:",
+    converts.from.map((place) => place.label).join(" + "),
+    `-[${converts.label}]->`,
+    converts.to.map((place) => place.label).join(" + "),
+);
+
+dispose();
+container.remove();
+```
+
+```
+substrate, product
+reactant, product
+transition: reactant -[converts]-> product
+```
+
+## Editing a schema notebook
+
+The same component edits a schema's entities through its `Entity` member shape.
+The editor renders only the cells its shapes declare: the `string` attribute
+type and the `full name` attribute are invisible to it, so the entity is the
+single rename input. Renaming the entity and clicking add go through the
+`EntityObject` branch — the notebook does not support `BasicObject`, which
+`supports` discovers at runtime — and the attribute's endpoints read back the
+rename.
+
+```tsx
+import { Attr, AttrType, Entity, SimpleSchema } from "catcolab-logics/simple-schema";
+
+const schema = await solidBinder.createNotebook(SimpleSchema, { name: "A schema" });
+const employee = schema.add(Entity, { label: "employee" });
+const str = schema.add(AttrType, { label: "string" });
+const fullName = schema.add(Attr, { label: "full name", from: employee, to: str });
+
+const container = document.createElement("div");
+document.body.appendChild(container);
+const dispose = render(() => <ObjectEditor notebook={schema} />, container);
+
+console.log(names(container));
+
+renameThrough(container, "employee", "person");
+container.querySelector("button")?.click();
+console.log(names(container));
+
+console.log("attr:", fullName.from.label, `-[${fullName.label}]->`, fullName.to.label);
+
+dispose();
+container.remove();
+```
+
+```
+employee
+person, new entity
+attr: person -[full name]-> string
+```
diff --git a/packages/document-methods/test/observe_validation.test.ts b/packages/document-methods/test/observe_validation.test.ts
new file mode 100644
index 000000000..6d7118993
--- /dev/null
+++ b/packages/document-methods/test/observe_validation.test.ts
@@ -0,0 +1,206 @@
+/**
+ * Tests for `onValidate`, the dependency-driven validation observer: it
+ * re-validates when — and only when — a document the validation depends on
+ * changes (the notebook itself *or* anything in its resolution subtree), and
+ * delivers only results that differ from the last delivered one.
+ */
+import {
+    createBinder,
+    type DiagramValidationResult,
+    Instantiation,
+    type ModelValidationResult,
+    RichText,
+} from "catcolab-documents";
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { Attr, AttrType, Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { describe, expect, test } from "vitest";
+
+import { createResolvingStore } from "./resolving_store";
+
+/** Poll until `predicate` holds (validation is asynchronous). */
+async function until(predicate: () => boolean): Promise<void> {
+    const deadline = Date.now() + 5000;
+    while (!predicate()) {
+        if (Date.now() > deadline) {
+            throw new Error("condition not met in time");
+        }
+        await new Promise((resolve) => setTimeout(resolve));
+    }
+}
+
+/** Let any in-flight observation settle, to assert that nothing more arrives. */
+async function flush(): Promise<void> {
+    for (let i = 0; i < 25; i++) {
+        await new Promise((resolve) => setTimeout(resolve));
+    }
+}
+
+describe("onValidate", () => {
+    test("delivers an initial result, then only actual changes", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+        const notebook = await binder.createNotebook(SimpleOlog, { name: "Main" });
+        notebook.add(Type, { label: "A" });
+
+        const results: ModelValidationResult[] = [];
+        const unsubscribe = notebook.onValidate((result) => results.push(result));
+
+        await until(() => results.length === 1);
+        expect(results[0]?.tag).toBe("Ok");
+
+        // Non-formal changes: a rich-text comment and a rename re-validate (the
+        // cache absorbs the cost) but deliver nothing — the model is identical.
+        notebook.add(RichText, { content: "A comment." });
+        notebook.update({ name: "Renamed" });
+        await flush();
+        expect(results.length).toBe(1);
+
+        // A formal edit delivers a new result with a new model.
+        notebook.add(Type, { label: "B" });
+        await until(() => results.length === 2);
+        expect(results[1]?.tag).toBe("Ok");
+        expect(results[1]?.tag === "Ok" && results[1].content).not.toBe(
+            results[0]?.tag === "Ok" && results[0].content,
+        );
+
+        unsubscribe();
+    });
+
+    test("a burst of synchronous edits is coalesced into one delivery", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+        const notebook = await binder.createNotebook(SimpleOlog, { name: "Main" });
+        notebook.add(Type, { label: "A" });
+
+        const results: ModelValidationResult[] = [];
+        const unsubscribe = notebook.onValidate((result) => results.push(result));
+        await until(() => results.length === 1);
+
+        notebook.add(Type, { label: "B" });
+        notebook.add(Type, { label: "C" });
+        notebook.add(Type, { label: "D" });
+        await until(() => results.length === 2);
+        await flush();
+        expect(results.length).toBe(2);
+
+        unsubscribe();
+    });
+
+    test("an edit to an instantiated child re-validates the parent", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+
+        const imported = await binder.createNotebook(SimpleOlog, { name: "Imported" });
+        imported.add(Type, { label: "Thing" });
+        const main = await binder.createNotebook(SimpleOlog, { name: "Main" });
+        main.add(Type, { label: "A" });
+        main.add(Instantiation, { label: "Import", model: imported });
+
+        const results: ModelValidationResult[] = [];
+        const unsubscribe = main.onValidate((result) => results.push(result));
+        await until(() => results.length === 1);
+        expect(results[0]?.tag).toBe("Ok");
+
+        // The consumer never told the observer about `imported`: the dependency
+        // was discovered from the resolution tree.
+        imported.add(Type, { label: "Another" });
+        await until(() => results.length === 2);
+        expect(results[1]?.tag).toBe("Ok");
+
+        // A rich-text edit to the child is a no-op for the parent, too.
+        imported.add(RichText, { content: "Note on the import." });
+        await flush();
+        expect(results.length).toBe(2);
+
+        unsubscribe();
+    });
+
+    test("errors are delivered and recovery is observed", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+
+        const a = await binder.createNotebook(SimpleOlog, { name: "A" });
+        const c = await binder.createNotebook(SimpleOlog, { name: "C" });
+        a.add(Type, { label: "TA" });
+        c.add(Type, { label: "TC" });
+        a.add(Instantiation, { label: "toC", model: c });
+
+        const results: ModelValidationResult[] = [];
+        const unsubscribe = a.onValidate((result) => results.push(result));
+        await until(() => results.length === 1);
+        expect(results[0]?.tag).toBe("Ok");
+
+        // Editing `c` to instantiate `a` closes a cycle: delivered as an `Err`.
+        const cycleCell = c.add(Instantiation, { label: "toA", model: a });
+        await until(() => results.length === 2);
+        expect(results[1]?.tag).toBe("Err");
+        expect(
+            results[1]?.tag === "Err" &&
+                results[1].content.map((issue) => issue.message).join("; "),
+        ).toContain("Instantiation cycle detected");
+
+        // The failed resolution kept the dependency subscriptions, so breaking
+        // the cycle in `c` is observed and recovery delivered.
+        cycleCell.delete();
+        await until(() => results.length === 3);
+        expect(results[2]?.tag).toBe("Ok");
+
+        unsubscribe();
+    });
+
+    test("unsubscribing stops delivery", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+        const notebook = await binder.createNotebook(SimpleOlog, { name: "Main" });
+        notebook.add(Type, { label: "A" });
+
+        const results: ModelValidationResult[] = [];
+        const unsubscribe = notebook.onValidate((result) => results.push(result));
+        await until(() => results.length === 1);
+
+        unsubscribe();
+        notebook.add(Type, { label: "B" });
+        await flush();
+        expect(results.length).toBe(1);
+    });
+
+    test("an instance observes its schema without manual wiring", async () => {
+        const { store } = createResolvingStore();
+        const binder = createBinder(store);
+
+        const schema = await binder.createNotebook(SimpleSchema, { name: "Company schema" });
+        const person = schema.add(Entity, { label: "Person" });
+        const company = schema.add(Entity, { label: "Company" });
+        const str = schema.add(AttrType, { label: "String" });
+        schema.add(Mapping, { label: "employer", from: person, to: company });
+        schema.add(Attr, { label: "name", from: person, to: str });
+
+        const instance = await binder.createInstance(schema, { name: "Company instance" });
+        const acme = instance.add(company, {});
+        instance.add(person, { name: "Fred", employer: acme });
+
+        const results: DiagramValidationResult[] = [];
+        const unsubscribe = instance.onValidate((result) => results.push(result));
+        await until(() => results.length === 1);
+        expect(results[0]?.tag).toBe("Valid");
+
+        // A schema edit re-validates the instance: the observer follows the
+        // schema through the cache's dependency tree, with no subscription to
+        // the schema notebook at the call site.
+        schema.add(Entity, { label: "Department" });
+        await until(() => results.length === 2);
+        expect(results[1]?.tag).toBe("Valid");
+
+        // A row edit delivers too — same tag, but new content.
+        instance.add(person, { name: "Barney", employer: acme });
+        await until(() => results.length === 3);
+        expect(results[2]?.tag).toBe("Valid");
+
+        // A rename of the instance is a no-op.
+        instance.update({ name: "Renamed instance" });
+        await flush();
+        expect(results.length).toBe(3);
+
+        unsubscribe();
+    });
+});
diff --git a/packages/document-methods/test/olog_editor_comparison.lts.md b/packages/document-methods/test/olog_editor_comparison.lts.md
new file mode 100644
index 000000000..168a3890c
--- /dev/null
+++ b/packages/document-methods/test/olog_editor_comparison.lts.md
@@ -0,0 +1,421 @@
+# Frontend olog editor comparison
+
+This compares the shape of a small olog notebook editor in the current
+frontend-style API with the `catcolab-documents` APIs. The current
+example is reduced from the real frontend path: a model document is edited
+through raw notebook cells, low-level model declarations, explicit endpoint
+encoding, and a document mutation callback.
+
+## Current frontend, reduced
+
+The frontend currently derives olog cell constructors from theory metadata and
+then mutates a raw `Document` notebook. In the sample body below, compare
+the same sequence of work against the document APIs: create a notebook, add two
+types and one aspect, render, then rename the first type.
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+import { For } from "solid-js";
+import { createStore, produce } from "solid-js/store";
+import { render } from "solid-js/web";
+
+import { Model, Nb, type ModelDocument } from "catcolab-document-methods";
+import type { Cell, ModelJudgment, MorType, Ob, ObType } from "catcolab-document-types";
+
+type CurrentOlogNotebook = {
+    doc: ModelDocument;
+    changeDoc(fn: (doc: ModelDocument) => void): void;
+};
+
+type CurrentObjectDecl = Extract<ModelJudgment, { tag: "object" }>;
+type CurrentMorphismDecl = Extract<ModelJudgment, { tag: "morphism" }>;
+
+type CurrentCellConstructor = {
+    name: string;
+    construct: () => Cell<ModelJudgment>;
+};
+
+const ologObjectType: ObType = { tag: "Basic", content: "Object" };
+const ologAspectType: MorType = { tag: "Hom", content: ologObjectType };
+
+const typeCellConstructor: CurrentCellConstructor = {
+    name: "Type",
+    construct: () => Nb.newFormalCell(Model.newObjectDecl(ologObjectType)),
+};
+
+const aspectCellConstructor: CurrentCellConstructor = {
+    name: "Aspect",
+    construct: () => Nb.newFormalCell(Model.newMorphismDecl(ologAspectType)),
+};
+
+function createCurrentOlogNotebook(data: { name: string }): CurrentOlogNotebook {
+    const initialDoc = Model.newModelDocument({ theory: "simple-olog" });
+    initialDoc.name = data.name;
+
+    const [doc, setDoc] = createStore<ModelDocument>(initialDoc);
+    return {
+        doc,
+        changeDoc: (fn) => setDoc(produce<ModelDocument>(fn)),
+    };
+}
+
+function appendConstructedCell(notebook: CurrentOlogNotebook, cell: Cell<ModelJudgment>) {
+    notebook.changeDoc((doc) => {
+        Nb.appendCell(doc.notebook, cell);
+    });
+}
+
+function encodeCurrentObjectRef(object: CurrentObjectDecl): Ob {
+    return { tag: "Basic", content: object.id };
+}
+
+function addCurrentType(notebook: CurrentOlogNotebook, args: { name: string }): CurrentObjectDecl {
+    const cell = typeCellConstructor.construct();
+    if (cell.tag !== "formal" || cell.content.tag !== "object") {
+        throw new Error("Type constructor produced the wrong cell shape");
+    }
+    cell.content.name = args.name;
+    appendConstructedCell(notebook, cell);
+    return cell.content;
+}
+
+function addCurrentAspect(
+    notebook: CurrentOlogNotebook,
+    args: {
+        name: string;
+        from: CurrentObjectDecl;
+        to: CurrentObjectDecl;
+    },
+): CurrentMorphismDecl {
+    const cell = aspectCellConstructor.construct();
+    if (cell.tag !== "formal" || cell.content.tag !== "morphism") {
+        throw new Error("Aspect constructor produced the wrong cell shape");
+    }
+    cell.content.name = args.name;
+    cell.content.dom = encodeCurrentObjectRef(args.from);
+    cell.content.cod = encodeCurrentObjectRef(args.to);
+    appendConstructedCell(notebook, cell);
+    return cell.content;
+}
+
+function updateCurrentType(
+    notebook: CurrentOlogNotebook,
+    object: CurrentObjectDecl,
+    args: { name: string },
+) {
+    notebook.changeDoc((doc) => {
+        for (const judgment of Nb.getFormalContent(doc.notebook)) {
+            if (judgment.id === object.id) {
+                judgment.name = args.name;
+                return;
+            }
+        }
+    });
+}
+
+function currentJudgmentLabel(judgment: ModelJudgment): string {
+    switch (judgment.tag) {
+        case "object":
+            return "Type";
+        case "morphism":
+            return "Aspect";
+        case "instantiation":
+            return "Instantiate";
+        case "equation":
+            return "Equation";
+    }
+}
+
+function CurrentOlogEditor(props: { notebook: CurrentOlogNotebook }) {
+    return (
+        <section>
+            <h1>{props.notebook.doc.name}</h1>
+            <ul>
+                <For each={Nb.getCells(props.notebook.doc.notebook)}>
+                    {(cell) => (
+                        <li>
+                            {cell.tag === "formal"
+                                ? `${currentJudgmentLabel(cell.content)}: ${cell.content.name}`
+                                : `Text: ${String(cell.content)}`}
+                        </li>
+                    )}
+                </For>
+            </ul>
+        </section>
+    );
+}
+```
+
+```tsx
+const notebook = createCurrentOlogNotebook({ name: "An Olog" });
+const person = addCurrentType(notebook, { name: "Person" });
+const company = addCurrentType(notebook, { name: "Company" });
+addCurrentAspect(notebook, { name: "works for", from: person, to: company });
+
+const container = document.createElement("div");
+document.body.appendChild(container);
+
+const dispose = render(() => <CurrentOlogEditor notebook={notebook} />, container);
+
+console.log(container.innerHTML);
+
+updateCurrentType(notebook, person, { name: "Employee" });
+console.log(container.innerHTML);
+
+dispose();
+```
+
+```
+<section><h1>An Olog</h1><ul><li>Type: Person</li><li>Type: Company</li><li>Aspect: works for</li></ul></section>
+<section><h1>An Olog</h1><ul><li>Type: Employee</li><li>Type: Company</li><li>Aspect: works for</li></ul></section>
+```
+
+## `catcolab-documents`, generic
+
+The generic API keeps the same store boundary and cell-handle operations as the
+typed API. A shape is defined inline from the cell types, so this is a close
+replacement for code that builds a shape from frontend theory metadata; the
+editor itself is written against the generic `Notebook` interface.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+import { For } from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { render } from "solid-js/web";
+
+import {
+    CellKind,
+    createBinder,
+    defineMorphism,
+    defineObject,
+    defineShape,
+    type DocumentStore,
+    type Notebook,
+    type Shape,
+} from "catcolab-documents";
+import type { Document } from "catcolab-document-types";
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStoreIds = new WeakMap<SolidStoreHandle, string>();
+const solidStoreIdFor = (handle: SolidStoreHandle): string => {
+    let id = solidStoreIds.get(handle);
+    if (!id) {
+        id = crypto.randomUUID();
+        solidStoreIds.set(handle, id);
+    }
+    return id;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    getDocumentRef: (handle) => ({ id: solidStoreIdFor(handle), version: null, server: "" }),
+    getHandle: async () => ({
+        tag: "Err" as const,
+        content: [{ message: "This store cannot resolve references." }],
+    }),
+};
+
+const solidBinder = createBinder(solidStore);
+
+const ologObjectType = defineObject({ tag: "Basic", content: "Object" });
+const ologAspectType = defineMorphism({
+    tag: "Hom",
+    content: ologObjectType.obType,
+});
+
+const Olog = defineShape({
+    objects: [ologObjectType],
+    morphisms: [ologAspectType],
+});
+
+function GenericOlogEditor(props: { notebook: Notebook<Shape, SolidStoreHandle> }) {
+    return (
+        <section>
+            <h1>{props.notebook.name}</h1>
+            <ul>
+                <For each={props.notebook.cells()}>
+                    {(cell) => (
+                        <li>
+                            {cell.kind === CellKind.RichText
+                                ? `Text: ${cell.content}`
+                                : cell.kind === CellKind.Object
+                                  ? `Type: ${cell.label}`
+                                  : `Aspect: ${cell.label}`}
+                        </li>
+                    )}
+                </For>
+            </ul>
+        </section>
+    );
+}
+```
+
+```tsx
+import { SimpleOlog, Aspect, Type } from "catcolab-logics/simple-olog";
+const notebook = await solidBinder.createNotebook(SimpleOlog, { name: "An Olog" });
+const person = notebook.add(Type, { label: "Person" });
+const company = notebook.add(Type, { label: "Company" });
+notebook.add(ologAspectType, { label: "works for", from: person, to: company });
+
+const container = document.createElement("div");
+document.body.appendChild(container);
+
+const dispose = render(() => <GenericOlogEditor notebook={notebook} />, container);
+
+console.log(container.innerHTML);
+
+person.update({ label: "Employee" });
+console.log(container.innerHTML);
+
+dispose();
+```
+
+```
+<section><h1>An Olog</h1><ul><li>Type: Person</li><li>Type: Company</li><li>Aspect: works for</li></ul></section>
+<section><h1>An Olog</h1><ul><li>Type: Employee</li><li>Type: Company</li><li>Aspect: works for</li></ul></section>
+```
+
+## `catcolab-documents`, typed logic
+
+With `catcolab-documents`, the store boundary is explicit and reusable. The
+editor receives a typed notebook handle instead of raw notebook data plus a
+separate mutation callback. The sample body follows the same sequence as above,
+but creating cells, wiring endpoints, and updating the first type all go through
+the logic's typed cell values.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+import { For } from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { render } from "solid-js/web";
+
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { CellKind, createBinder, type DocumentStore, type Notebook } from "catcolab-documents";
+import type { Document } from "catcolab-document-types";
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStoreIds = new WeakMap<SolidStoreHandle, string>();
+const solidStoreIdFor = (handle: SolidStoreHandle): string => {
+    let id = solidStoreIds.get(handle);
+    if (!id) {
+        id = crypto.randomUUID();
+        solidStoreIds.set(handle, id);
+    }
+    return id;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    getDocumentRef: (handle) => ({ id: solidStoreIdFor(handle), version: null, server: "" }),
+    getHandle: async () => ({
+        tag: "Err" as const,
+        content: [{ message: "This store cannot resolve references." }],
+    }),
+};
+
+const solidBinder = createBinder(solidStore);
+
+type TypedOlogNotebook = Notebook<typeof SimpleOlog, SolidStoreHandle>;
+
+function TypedOlogEditor(props: { notebook: TypedOlogNotebook }) {
+    return (
+        <section>
+            <h1>{props.notebook.name}</h1>
+            <ul>
+                <For each={props.notebook.cells()}>
+                    {(cell) => (
+                        <li>
+                            {cell.kind === CellKind.RichText
+                                ? `Text: ${cell.content}`
+                                : cell.kind === CellKind.Object
+                                  ? `Type: ${cell.label}`
+                                  : `Aspect: ${cell.label}`}
+                        </li>
+                    )}
+                </For>
+            </ul>
+        </section>
+    );
+}
+```
+
+```tsx
+const notebook = await solidBinder.createNotebook(SimpleOlog, { name: "An Olog" });
+const person = notebook.add(Type, { label: "Person" });
+const company = notebook.add(Type, { label: "Company" });
+notebook.add(Aspect, { label: "works for", from: person, to: company });
+
+const container = document.createElement("div");
+document.body.appendChild(container);
+
+const dispose = render(() => <TypedOlogEditor notebook={notebook} />, container);
+
+console.log(container.innerHTML);
+
+person.update({ label: "Employee" });
+console.log(container.innerHTML);
+
+dispose();
+```
+
+```
+<section><h1>An Olog</h1><ul><li>Type: Person</li><li>Type: Company</li><li>Aspect: works for</li></ul></section>
+<section><h1>An Olog</h1><ul><li>Type: Employee</li><li>Type: Company</li><li>Aspect: works for</li></ul></section>
+```
diff --git a/packages/document-methods/test/petri_net_editor_comparison.test.tsx b/packages/document-methods/test/petri_net_editor_comparison.test.tsx
new file mode 100644
index 000000000..3223b233d
--- /dev/null
+++ b/packages/document-methods/test/petri_net_editor_comparison.test.tsx
@@ -0,0 +1,710 @@
+// Each test case defines its editor components and helpers inside the `test()`
+// body so that the three scenarios stay fully self-contained and comparable.
+// Some of these are pure (don't capture parent-scope variables), which trips
+// `consistent-function-scoping`; hoisting them out would scatter each scenario.
+/* oxlint-disable unicorn/consistent-function-scoping */
+import {
+    type NotebookCell,
+    CellKind,
+    createBinder,
+    defineMorphism,
+    defineObject,
+    type DocumentStore,
+    type Notebook,
+    defineShape,
+    RichText,
+} from "catcolab-documents";
+import { PetriNet, Place, Transition } from "catcolab-logics/petri-net";
+import { For } from "solid-js";
+import { createStore, produce, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { render } from "solid-js/web";
+import { describe, expect, test } from "vitest";
+
+import { Model, Nb } from "catcolab-document-methods";
+import type { Document } from "catcolab-document-types";
+import type {
+    Cell as DocCell,
+    ModelJudgment,
+    MorType,
+    Notebook as DocumentNotebook,
+    Ob,
+    ObType,
+} from "catcolab-document-types";
+import { v7 } from "uuid";
+
+const EXPECTED_INITIAL =
+    "<section><h1>Petri net</h1><ul>" +
+    '<li><span class="cell-label">Place: A</span></li>' +
+    '<li><span class="cell-label">Place: B</span></li>' +
+    '<li><span class="cell-label">Place: C</span></li>' +
+    '<li><span class="cell-label">Transition: <span>[A<!---->]</span><span> -&gt; </span>' +
+    "<span>[C<!---->]</span><span>fires</span></span>" +
+    '<button aria-label="run test mutation"></button></li></ul></section>';
+
+const EXPECTED_AFTER_APPEND =
+    "<section><h1>Petri net</h1><ul>" +
+    '<li><span class="cell-label">Place: A</span></li>' +
+    '<li><span class="cell-label">Place: B</span></li>' +
+    '<li><span class="cell-label">Place: C</span></li>' +
+    '<li><span class="cell-label">Transition: <span>[A, B<!---->]</span><span> -&gt; </span>' +
+    "<span>[C<!---->]</span><span>fires</span></span>" +
+    '<button aria-label="run test mutation"></button></li></ul></section>';
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * Deep-clone a value, replacing every UUID with a stable label assigned by
+ * first encounter (`uuid:0`, `uuid:1`, ...). The mapping is shared across the
+ * whole value, so equal UUIDs collapse to equal labels: a morphism endpoint
+ * that references an object's id stays equal to that object's id, while the
+ * random values themselves are erased. UUID-valued object keys (the
+ * `cellContents` map keys) are normalized with the same map.
+ */
+function normalizeUuids(value: unknown): unknown {
+    const labels = new Map<string, string>();
+    const label = (s: string): string => {
+        let l = labels.get(s);
+        if (l === undefined) {
+            l = `uuid:${labels.size}`;
+            labels.set(s, l);
+        }
+        return l;
+    };
+    const walk = (v: unknown): unknown => {
+        if (typeof v === "string") {
+            return UUID_RE.test(v) ? label(v) : v;
+        }
+        if (Array.isArray(v)) {
+            return v.map(walk);
+        }
+        if (v && typeof v === "object") {
+            const out: Record<string, unknown> = {};
+            for (const k of Object.keys(v as Record<string, unknown>)) {
+                const nk = UUID_RE.test(k) ? label(k) : k;
+                out[nk] = walk((v as Record<string, unknown>)[k]);
+            }
+            return out;
+        }
+        return v;
+    };
+    return walk(value);
+}
+
+/**
+ * The notebook all three tests build (places A, B, C and a transition `fires`),
+ * after the editor's "run test mutation" button has wired place B into the
+ * transition's domain, so `dom: [A, B]` and `cod: [C]`. UUIDs are normalized by
+ * {@link normalizeUuids}; the labels `uuid:4`, `uuid:5`, `uuid:6` are the object
+ * *judgment* ids of A, B, C, so the transition's `dom`/`cod` references below
+ * verify the wiring produced by the component, not just the presence of some
+ * object.
+ */
+const EXPECTED_NOTEBOOK_JSON = {
+    name: "Petri net",
+    type: "model",
+    theory: "petri-net",
+    notebook: {
+        cellOrder: ["uuid:0", "uuid:1", "uuid:2", "uuid:3"],
+        cellContents: {
+            "uuid:0": {
+                tag: "formal",
+                id: "uuid:0",
+                content: {
+                    tag: "object",
+                    id: "uuid:4",
+                    name: "A",
+                    obType: { tag: "Basic", content: "Object" },
+                },
+            },
+            "uuid:1": {
+                tag: "formal",
+                id: "uuid:1",
+                content: {
+                    tag: "object",
+                    id: "uuid:5",
+                    name: "B",
+                    obType: { tag: "Basic", content: "Object" },
+                },
+            },
+            "uuid:2": {
+                tag: "formal",
+                id: "uuid:2",
+                content: {
+                    tag: "object",
+                    id: "uuid:6",
+                    name: "C",
+                    obType: { tag: "Basic", content: "Object" },
+                },
+            },
+            "uuid:3": {
+                tag: "formal",
+                id: "uuid:3",
+                content: {
+                    tag: "morphism",
+                    id: "uuid:7",
+                    name: "fires",
+                    morType: { tag: "Hom", content: { tag: "Basic", content: "Object" } },
+                    dom: {
+                        tag: "App",
+                        content: {
+                            op: { tag: "Basic", content: "tensor" },
+                            ob: {
+                                tag: "List",
+                                content: {
+                                    modality: "SymmetricList",
+                                    objects: [
+                                        { tag: "Basic", content: "uuid:4" },
+                                        { tag: "Basic", content: "uuid:5" },
+                                    ],
+                                },
+                            },
+                        },
+                    },
+                    cod: {
+                        tag: "App",
+                        content: {
+                            op: { tag: "Basic", content: "tensor" },
+                            ob: {
+                                tag: "List",
+                                content: {
+                                    modality: "SymmetricList",
+                                    objects: [{ tag: "Basic", content: "uuid:6" }],
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+    version: "2",
+};
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStoreIds = new WeakMap<SolidStoreHandle, string>();
+const solidStoreIdFor = (handle: SolidStoreHandle): string => {
+    let id = solidStoreIds.get(handle);
+    if (!id) {
+        id = v7();
+        solidStoreIds.set(handle, id);
+    }
+    return id;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    getDocumentRef: (handle) => ({ id: solidStoreIdFor(handle), version: null, server: "" }),
+    getHandle: async () => ({
+        tag: "Err",
+        content: [{ message: "This store cannot resolve references." }],
+    }),
+};
+
+const solidBinder = createBinder(solidStore);
+
+describe("Petri-net editor comparison", () => {
+    test("current frontend, reduced", () => {
+        type CurrentNotebook = {
+            doc: Document;
+            changeDoc(fn: (doc: Document) => void): void;
+        };
+
+        type CurrentPlaceDecl = Extract<ModelJudgment, { tag: "object" }>;
+        type CurrentTransitionDecl = Extract<ModelJudgment, { tag: "morphism" }>;
+        type CurrentModelNotebook = DocumentNotebook<ModelJudgment>;
+
+        function modelNotebook(doc: Document): CurrentModelNotebook {
+            return doc.notebook as CurrentModelNotebook;
+        }
+
+        type CurrentCellConstructor = {
+            name: string;
+            construct: () => DocCell<ModelJudgment>;
+        };
+
+        const placeObType: ObType = { tag: "Basic", content: "Object" };
+        // The core morphism type persisted by the frontend: a plain `Hom(Object)`
+        // whose list-ness lives in the tensor-product endpoints, not the type.
+        const transitionMorType: MorType = { tag: "Hom", content: placeObType };
+        const tensorOp = { tag: "Basic", content: "tensor" } as const;
+
+        const placeCellConstructor: CurrentCellConstructor = {
+            name: "Place",
+            construct: () => Nb.newFormalCell(Model.newObjectDecl(placeObType)),
+        };
+
+        const transitionCellConstructor: CurrentCellConstructor = {
+            name: "Transition",
+            construct: () => Nb.newFormalCell(Model.newMorphismDecl(transitionMorType)),
+        };
+
+        function createCurrentPetriNetNotebook(data: { name: string }): CurrentNotebook {
+            const initialDoc = Model.newModelDocument({ theory: "petri-net" });
+            initialDoc.name = data.name;
+
+            const [doc, setDoc] = createStore<Document>(initialDoc);
+            return {
+                doc,
+                changeDoc: (fn) => setDoc(produce<Document>(fn)),
+            };
+        }
+
+        function appendConstructedCell(notebook: CurrentNotebook, cell: DocCell<ModelJudgment>) {
+            notebook.changeDoc((doc) => {
+                Nb.appendCell(modelNotebook(doc), cell);
+            });
+        }
+
+        // Layer 1: the tensor `App` wrapper, mirroring `wrapApp`/`unwrapApp`.
+        function unwrapApp(ob: Ob | null, applyOp: typeof tensorOp): Ob | null {
+            if (ob?.tag === "App" && ob.content.op.content === applyOp.content) {
+                return ob.content.ob;
+            }
+            return null;
+        }
+
+        function wrapApp(ob: Ob, applyOp: typeof tensorOp): Ob {
+            return { tag: "App", content: { op: applyOp, ob } };
+        }
+
+        // Layer 2: the `List` modality, mirroring `extractObList`/`buildObList`.
+        function extractObList(ob: Ob | null): Array<Ob | null> {
+            return ob?.tag === "List" ? ob.content.objects : [];
+        }
+
+        function buildObList(modality: "SymmetricList", objects: Array<Ob | null>): Ob {
+            return { tag: "List", content: { modality, objects } };
+        }
+
+        function encodePlaceIds(placeIds: string[]): Ob {
+            const objects = placeIds.map((id): Ob => ({ tag: "Basic", content: id }));
+            return wrapApp(buildObList("SymmetricList", objects), tensorOp);
+        }
+
+        function placeIds(ob: Ob | null): string[] {
+            return extractObList(unwrapApp(ob, tensorOp)).flatMap((item) =>
+                item?.tag === "Basic" ? [item.content] : [],
+            );
+        }
+
+        function addCurrentPlace(
+            notebook: CurrentNotebook,
+            args: { name: string },
+        ): CurrentPlaceDecl {
+            const cell = placeCellConstructor.construct();
+            if (cell.tag !== "formal" || cell.content.tag !== "object") {
+                throw new Error("Place constructor produced the wrong cell shape");
+            }
+            cell.content.name = args.name;
+            appendConstructedCell(notebook, cell);
+            return cell.content;
+        }
+
+        function addCurrentTransition(
+            notebook: CurrentNotebook,
+            args: {
+                name: string;
+                from: CurrentPlaceDecl[];
+                to: CurrentPlaceDecl[];
+            },
+        ): CurrentTransitionDecl {
+            const cell = transitionCellConstructor.construct();
+            if (cell.tag !== "formal" || cell.content.tag !== "morphism") {
+                throw new Error("Transition constructor produced the wrong cell shape");
+            }
+            cell.content.name = args.name;
+            cell.content.dom = encodePlaceIds(args.from.map((place) => place.id));
+            cell.content.cod = encodePlaceIds(args.to.map((place) => place.id));
+            appendConstructedCell(notebook, cell);
+            return cell.content;
+        }
+
+        function updateCurrentTransition(
+            notebook: CurrentNotebook,
+            transition: CurrentTransitionDecl,
+            fn: (transition: CurrentTransitionDecl) => void,
+        ) {
+            notebook.changeDoc((doc) => {
+                for (const judgment of Nb.getFormalContent(modelNotebook(doc))) {
+                    if (judgment.tag === "morphism" && judgment.id === transition.id) {
+                        fn(judgment);
+                        return;
+                    }
+                }
+            });
+        }
+
+        function appendCurrentInput(
+            notebook: CurrentNotebook,
+            transition: CurrentTransitionDecl,
+            place: CurrentPlaceDecl,
+        ) {
+            updateCurrentTransition(notebook, transition, (transition) => {
+                transition.dom = encodePlaceIds([...placeIds(transition.dom), place.id]);
+            });
+        }
+
+        function placeName(notebook: CurrentNotebook, id: string): string {
+            for (const judgment of Nb.getFormalContent(modelNotebook(notebook.doc))) {
+                if (judgment.tag === "object" && judgment.id === id) {
+                    return judgment.name;
+                }
+            }
+            return "?";
+        }
+
+        function ObListEditor(props: { placeIds: string[]; placeName: (id: string) => string }) {
+            return <span>[{props.placeIds.map(props.placeName).join(", ")}]</span>;
+        }
+
+        function MorphismCellEditor(props: {
+            notebook: CurrentNotebook;
+            transition: CurrentTransitionDecl;
+        }) {
+            const name = (id: string) => placeName(props.notebook, id);
+            // Contrived test example: adding an arbitrary but valid input place
+            const runTestMutation = () => {
+                const referenced = new Set([
+                    ...placeIds(props.transition.dom),
+                    ...placeIds(props.transition.cod),
+                ]);
+                for (const judgment of Nb.getFormalContent(modelNotebook(props.notebook.doc))) {
+                    if (judgment.tag === "object" && !referenced.has(judgment.id)) {
+                        appendCurrentInput(props.notebook, props.transition, judgment);
+                        return;
+                    }
+                }
+            };
+            return (
+                <li>
+                    <span class="cell-label">
+                        Transition:{" "}
+                        <ObListEditor placeIds={placeIds(props.transition.dom)} placeName={name} />
+                        <span> -&gt; </span>
+                        <ObListEditor placeIds={placeIds(props.transition.cod)} placeName={name} />
+                        <span>{props.transition.name}</span>
+                    </span>
+                    <button aria-label="run test mutation" onClick={runTestMutation} />
+                </li>
+            );
+        }
+
+        function ModelCellEditor(props: {
+            notebook: CurrentNotebook;
+            cell: DocCell<ModelJudgment>;
+        }) {
+            if (props.cell.tag !== "formal") {
+                return (
+                    <li>
+                        <span class="cell-label">Text: {String(props.cell.content)}</span>
+                    </li>
+                );
+            }
+            switch (props.cell.content.tag) {
+                case "object":
+                    return (
+                        <li>
+                            <span class="cell-label">Place: {props.cell.content.name}</span>
+                        </li>
+                    );
+                case "morphism":
+                    return (
+                        <MorphismCellEditor
+                            notebook={props.notebook}
+                            transition={props.cell.content}
+                        />
+                    );
+                case "equation":
+                    return (
+                        <li>
+                            <span class="cell-label">Equation: {props.cell.content.name}</span>
+                        </li>
+                    );
+                case "instantiation":
+                    return (
+                        <li>
+                            <span class="cell-label">Instantiate: {props.cell.content.name}</span>
+                        </li>
+                    );
+            }
+        }
+
+        function ModelNotebookEditor(props: { notebook: CurrentNotebook }) {
+            return (
+                <section>
+                    <h1>{props.notebook.doc.name}</h1>
+                    <ul>
+                        <For each={Nb.getCells(modelNotebook(props.notebook.doc))}>
+                            {(cell) => <ModelCellEditor notebook={props.notebook} cell={cell} />}
+                        </For>
+                    </ul>
+                </section>
+            );
+        }
+
+        const notebook = createCurrentPetriNetNotebook({ name: "Petri net" });
+        const a = addCurrentPlace(notebook, { name: "A" });
+        addCurrentPlace(notebook, { name: "B" });
+        const c = addCurrentPlace(notebook, { name: "C" });
+        addCurrentTransition(notebook, { name: "fires", from: [a], to: [c] });
+
+        const container = document.createElement("div");
+        document.body.appendChild(container);
+
+        const dispose = render(() => <ModelNotebookEditor notebook={notebook} />, container);
+
+        expect(container.innerHTML).toBe(EXPECTED_INITIAL);
+
+        const appendButton = container.querySelector<HTMLButtonElement>(
+            '[aria-label="run test mutation"]',
+        )!;
+        appendButton.click();
+        expect(container.innerHTML).toBe(EXPECTED_AFTER_APPEND);
+
+        expect(normalizeUuids(structuredClone(unwrap(notebook.doc)))).toEqual(
+            EXPECTED_NOTEBOOK_JSON,
+        );
+
+        dispose();
+        container.remove();
+    });
+
+    test("catcolab-documents, typed logic", async () => {
+        function InlinePlaceListEditor(props: { places: NotebookCell<typeof Place>[] }) {
+            return <span>[{props.places.map((place) => place.label).join(", ")}]</span>;
+        }
+
+        function TransitionCell(props: {
+            notebook: Notebook<typeof PetriNet, SolidStoreHandle>;
+            transition: NotebookCell<typeof Transition>;
+        }) {
+            // Contrived test example: adding an arbitrary but valid input place
+            const runTestMutation = () => {
+                const referenced = new Set(
+                    [...props.transition.from, ...props.transition.to].map((place) => place.id),
+                );
+                const input = props.notebook
+                    .cellsOf(Place)
+                    .find((place) => !referenced.has(place.id));
+                if (input) {
+                    props.transition.update({ from: [...props.transition.from, input] });
+                }
+            };
+            return (
+                <li>
+                    <span class="cell-label">
+                        Transition: <InlinePlaceListEditor places={props.transition.from} />
+                        <span> -&gt; </span>
+                        <InlinePlaceListEditor places={props.transition.to} />
+                        <span>{props.transition.label}</span>
+                    </span>
+                    <button aria-label="run test mutation" onClick={runTestMutation} />
+                </li>
+            );
+        }
+
+        function PetriNetCell(props: {
+            notebook: Notebook<typeof PetriNet, SolidStoreHandle>;
+            cell: NotebookCell<typeof PetriNet>;
+        }) {
+            const cell = props.cell;
+            if (cell.kind === CellKind.Morphism) {
+                return <TransitionCell notebook={props.notebook} transition={cell} />;
+            }
+            if (cell.kind === CellKind.Object) {
+                return (
+                    <li>
+                        <span class="cell-label">Place: {cell.label}</span>
+                    </li>
+                );
+            }
+            if (cell.kind === CellKind.RichText) {
+                return (
+                    <li>
+                        <span class="cell-label">Text: {cell.content}</span>
+                    </li>
+                );
+            }
+            return null;
+        }
+
+        function PetriNetEditor(props: { notebook: Notebook<typeof PetriNet, SolidStoreHandle> }) {
+            return (
+                <section>
+                    <h1>{props.notebook.name}</h1>
+                    <ul>
+                        <For each={props.notebook.cellsOf(PetriNet)}>
+                            {(cell) => <PetriNetCell notebook={props.notebook} cell={cell} />}
+                        </For>
+                    </ul>
+                </section>
+            );
+        }
+
+        const notebook = await solidBinder.createNotebook(PetriNet, { name: "Petri net" });
+        const a = notebook.add(Place, { label: "A" });
+        notebook.add(Place, { label: "B" });
+        const c = notebook.add(Place, { label: "C" });
+        notebook.add(Transition, { label: "fires", from: [a], to: [c] });
+
+        const container = document.createElement("div");
+        document.body.appendChild(container);
+
+        const dispose = render(() => <PetriNetEditor notebook={notebook} />, container);
+
+        expect(container.innerHTML).toBe(EXPECTED_INITIAL);
+
+        const appendButton = container.querySelector<HTMLButtonElement>(
+            '[aria-label="run test mutation"]',
+        )!;
+        appendButton.click();
+        expect(container.innerHTML).toBe(EXPECTED_AFTER_APPEND);
+
+        expect(normalizeUuids(notebook.dump())).toEqual(EXPECTED_NOTEBOOK_JSON);
+
+        dispose();
+        container.remove();
+    });
+
+    test("catcolab-documents, generic consumer", async () => {
+        const basicObject = defineObject({ tag: "Basic", content: "Object" });
+        const symmetricListMorphism = defineMorphism(
+            { tag: "Hom", content: basicObject.obType },
+            {
+                domain: { apply: { tag: "Basic", content: "tensor" }, modality: "SymmetricList" },
+                codomain: { apply: { tag: "Basic", content: "tensor" }, modality: "SymmetricList" },
+            },
+        );
+
+        type BasicObCell = NotebookCell<typeof basicObject>;
+        type SymmetricListCell = NotebookCell<typeof symmetricListMorphism>;
+
+        const GenericShape = defineShape({
+            objects: [basicObject],
+            morphisms: [symmetricListMorphism],
+            informal: [RichText],
+        });
+
+        function ObListEditor(props: { objects: BasicObCell[] }) {
+            return <span>[{props.objects.map((place) => place.label).join(", ")}]</span>;
+        }
+
+        function MorphismCellEditor(props: {
+            notebook: Notebook<typeof GenericShape, SolidStoreHandle>;
+            morphism: SymmetricListCell;
+        }) {
+            // Contrived test example: adding an arbitrary but valid input place
+            const runTestMutation = () => {
+                const referenced = new Set(
+                    [...props.morphism.from, ...props.morphism.to].map((ob) => ob.id),
+                );
+                const input = props.notebook
+                    .cellsOf(basicObject)
+                    .find((ob) => !referenced.has(ob.id));
+                if (input) {
+                    props.morphism.update({ from: [...props.morphism.from, input] });
+                }
+            };
+            return (
+                <li>
+                    <span class="cell-label">
+                        Transition: <ObListEditor objects={props.morphism.from} />
+                        <span> -&gt; </span>
+                        <ObListEditor objects={props.morphism.to} />
+                        <span>{props.morphism.label}</span>
+                    </span>
+                    <button aria-label="run test mutation" onClick={runTestMutation} />
+                </li>
+            );
+        }
+
+        function ModelCellEditor(props: {
+            notebook: Notebook<typeof GenericShape, SolidStoreHandle>;
+            cell: NotebookCell<typeof GenericShape>;
+        }) {
+            const cell = props.cell;
+            if (cell.kind === CellKind.Morphism) {
+                return <MorphismCellEditor notebook={props.notebook} morphism={cell} />;
+            }
+            if (cell.kind === CellKind.Object) {
+                return (
+                    <li>
+                        <span class="cell-label">Place: {cell.label}</span>
+                    </li>
+                );
+            }
+            if (cell.kind === CellKind.RichText) {
+                return (
+                    <li>
+                        <span class="cell-label">Text: {cell.content}</span>
+                    </li>
+                );
+            }
+            return null;
+        }
+
+        function ModelNotebookEditor(props: {
+            notebook: Notebook<typeof GenericShape, SolidStoreHandle>;
+        }) {
+            return (
+                <section>
+                    <h1>{props.notebook.name}</h1>
+                    <ul>
+                        <For each={props.notebook.cellsOf(GenericShape)}>
+                            {(cell) => <ModelCellEditor notebook={props.notebook} cell={cell} />}
+                        </For>
+                    </ul>
+                </section>
+            );
+        }
+
+        const notebook = await solidBinder.createNotebook(PetriNet, { name: "Petri net" });
+        const a = notebook.add(Place, { label: "A" });
+        notebook.add(Place, { label: "B" });
+        const c = notebook.add(Place, { label: "C" });
+        notebook.add(Transition, { label: "fires", from: [a], to: [c] });
+
+        const container = document.createElement("div");
+        document.body.appendChild(container);
+
+        const dispose = render(() => <ModelNotebookEditor notebook={notebook} />, container);
+
+        expect(container.innerHTML).toBe(EXPECTED_INITIAL);
+
+        const appendButton = container.querySelector<HTMLButtonElement>(
+            '[aria-label="run test mutation"]',
+        )!;
+        appendButton.click();
+        expect(container.innerHTML).toBe(EXPECTED_AFTER_APPEND);
+
+        expect(normalizeUuids(notebook.dump())).toEqual(EXPECTED_NOTEBOOK_JSON);
+
+        dispose();
+        container.remove();
+    });
+});
diff --git a/packages/document-methods/test/petri_net_elaborated_consumer.test.tsx b/packages/document-methods/test/petri_net_elaborated_consumer.test.tsx
new file mode 100644
index 000000000..bb1fa250c
--- /dev/null
+++ b/packages/document-methods/test/petri_net_elaborated_consumer.test.tsx
@@ -0,0 +1,268 @@
+/*
+ * A fourth Petri-net scenario, companion to `petri_net_editor_comparison`.
+ *
+ * The comparison file renders three editors that all read the notebook's *cell
+ * handles* directly. This file instead renders a consumer that reads the
+ * *elaborated model* — the `DblModel` produced by `Notebook.validate()` — the
+ * way the frontend's analyses do (`petri_net_visualization.tsx`,
+ * `mass_action.tsx`, `object_list_editor.tsx`): it enumerates `obGenerators`/
+ * `morGenerators`, resolves display labels with `obGeneratorLabel`/
+ * `morGeneratorLabel`, and walks each transition's tensor-product `dom`/`cod`
+ * with `collectProduct`. The consumer never touches the Petri-net-specific
+ * `from`/`to` accessors; it works off the generic elaborated structure alone.
+ *
+ * Editing still goes through the document (the typed notebook), exactly as in
+ * the frontend, where the elaborated model is a derived, read-only artifact:
+ * the mutation button only edits a cell, and `Notebook.onValidate` — wired to
+ * a signal — re-validates reactively to obtain a fresh elaborated model, which
+ * the view re-renders.
+ */
+/* oxlint-disable unicorn/consistent-function-scoping */
+import { createBinder, type DocumentStore, type ModelValidationResult } from "catcolab-documents";
+import { Place, PetriNet, Transition } from "catcolab-logics/petri-net";
+import { type Accessor, createSignal, For, onCleanup, Show } from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { render } from "solid-js/web";
+import { describe, expect, test } from "vitest";
+
+import type { Document } from "catcolab-document-types";
+import { collectProduct, type DblModel, type Ob, type QualifiedName } from "catlog-wasm";
+import { selfResolving } from "./self_resolving";
+
+/** Test helper: poll until `predicate` holds (validation is asynchronous). */
+async function until(predicate: () => boolean): Promise<void> {
+    const deadline = Date.now() + 5000;
+    while (!predicate()) {
+        if (Date.now() > deadline) {
+            throw new Error("condition not met in time");
+        }
+        await new Promise((resolve) => setTimeout(resolve));
+    }
+}
+
+// Test hook: a real consumer keeps the validation signal component-local.
+// `Consumer` assigns this so the test can await re-validation from outside the
+// component.
+let globalValidation!: Accessor<ModelValidationResult | undefined>;
+
+const EXPECTED_INITIAL =
+    "<section><h1>Petri net</h1><ul>" +
+    '<li><span class="cell-label">Place: A</span></li>' +
+    '<li><span class="cell-label">Place: B</span></li>' +
+    '<li><span class="cell-label">Place: C</span></li>' +
+    '<li><span class="cell-label">Transition: <span>[A<!---->]</span><span> -&gt; </span>' +
+    "<span>[C<!---->]</span><span>fires</span></span>" +
+    '<button aria-label="run test mutation"></button></li></ul></section>';
+
+const EXPECTED_AFTER_APPEND =
+    "<section><h1>Petri net</h1><ul>" +
+    '<li><span class="cell-label">Place: A</span></li>' +
+    '<li><span class="cell-label">Place: B</span></li>' +
+    '<li><span class="cell-label">Place: C</span></li>' +
+    '<li><span class="cell-label">Transition: <span>[A, B<!---->]</span><span> -&gt; </span>' +
+    "<span>[C<!---->]</span><span>fires</span></span>" +
+    '<button aria-label="run test mutation"></button></li></ul></section>';
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    // Resolve a notebook's own model (validation now goes through the store).
+    ...selfResolving<SolidStoreHandle>(),
+};
+
+const solidBinder = createBinder(solidStore);
+
+describe("Petri-net elaborated-model consumer", () => {
+    test("catcolab-documents, elaborated-model consumer", async () => {
+        // Resolve a place's display label from the elaborated model, exactly as
+        // the frontend does (`ob.label?.join(".")`).
+
+        function placeLabel(model: DblModel, id: QualifiedName): string {
+            return model.obGeneratorLabel(id)?.join(".") ?? "?";
+        }
+
+        // Collect the place ids of a transition's input/output from the
+        // elaborated morphism's tensor-product endpoint, mirroring the
+        // `collectProduct(mor.dom)` usage in `petri_net_visualization.tsx`.
+        function placeIds(ob: Ob): QualifiedName[] {
+            return collectProduct(ob).flatMap((o) => (o.tag === "Basic" ? [o.content] : []));
+        }
+
+        function ObListView(props: { model: DblModel; ids: QualifiedName[] }) {
+            return <span>[{props.ids.map((id) => placeLabel(props.model, id)).join(", ")}]</span>;
+        }
+
+        function MorphismCellView(props: {
+            model: DblModel;
+            id: QualifiedName;
+            onMutate: () => void;
+        }) {
+            const mor = () => {
+                const m = props.model.morPresentation(props.id);
+                if (!m) {
+                    throw new Error(`missing morphism presentation for ${props.id}`);
+                }
+                return m;
+            };
+            return (
+                <li>
+                    <span class="cell-label">
+                        Transition: <ObListView model={props.model} ids={placeIds(mor().dom)} />
+                        <span> -&gt; </span>
+                        <ObListView model={props.model} ids={placeIds(mor().cod)} />
+                        <span>{props.model.morGeneratorLabel(props.id)?.join(".")}</span>
+                    </span>
+                    <button aria-label="run test mutation" onClick={props.onMutate} />
+                </li>
+            );
+        }
+
+        function ElaboratedModelView(props: {
+            name: string;
+            model: DblModel;
+            onMutate: () => void;
+        }) {
+            return (
+                <section>
+                    <h1>{props.name}</h1>
+                    <ul>
+                        <For each={props.model.obGenerators()}>
+                            {(id) => (
+                                <li>
+                                    <span class="cell-label">
+                                        Place: {placeLabel(props.model, id)}
+                                    </span>
+                                </li>
+                            )}
+                        </For>
+                        <For each={props.model.morGenerators()}>
+                            {(id) => (
+                                <MorphismCellView
+                                    model={props.model}
+                                    id={id}
+                                    onMutate={props.onMutate}
+                                />
+                            )}
+                        </For>
+                    </ul>
+                </section>
+            );
+        }
+
+        // Build and edit the notebook through the typed document API, just as
+        // the frontend does; the elaborated model below is derived from it.
+        const notebook = await solidBinder.createNotebook(PetriNet, { name: "Petri net" });
+        const a = notebook.add(Place, { label: "A" });
+        notebook.add(Place, { label: "B" });
+        const c = notebook.add(Place, { label: "C" });
+        notebook.add(Transition, { label: "fires", from: [a], to: [c] });
+
+        // The consumer component owns the reactive validation: `onValidate`
+        // re-validates on changes to anything the validation depends on and
+        // delivers only changed results, and the view re-renders from the fresh
+        // elaborated model. Re-elaboration is async (a notebook may resolve
+        // instantiations through the store).
+        function Consumer() {
+            const [validation, setValidation] = createSignal<ModelValidationResult>();
+            const unsubscribe = notebook.onValidate(setValidation);
+            onCleanup(unsubscribe);
+            const model = (): DblModel | undefined => {
+                const result = validation();
+                return result?.tag === "Ok" ? result.content : undefined;
+            };
+
+            // Test hook only: expose the resource so the test can await
+            // re-validation from outside the component.
+            globalValidation = validation;
+
+            // The button only edits the document; the reactive resource above
+            // re-validates on its own, yielding a fresh elaborated model that
+            // the view re-renders.
+            const runTestMutation = () => {
+                const m = model();
+                if (!m) {
+                    return;
+                }
+                // Generically find a place not yet wired into any transition,
+                // reading only the elaborated structure.
+                const referenced = new Set<QualifiedName>();
+                for (const morId of m.morGenerators()) {
+                    const mor = m.morPresentation(morId);
+                    if (!mor) {
+                        continue;
+                    }
+                    for (const id of [...placeIds(mor.dom), ...placeIds(mor.cod)]) {
+                        referenced.add(id);
+                    }
+                }
+                const inputId = m.obGenerators().find((id) => !referenced.has(id));
+                if (!inputId) {
+                    return;
+                }
+                // An object generator's id is its object cell's id, so the
+                // generic choice maps straight back to a document cell to edit.
+                const place = notebook.cellsOf(Place).find((p) => p.id === inputId);
+                const transition = notebook.cellsOf(Transition).at(0);
+                if (!place || !transition) {
+                    return;
+                }
+                transition.update({ from: [...transition.from, place] });
+            };
+
+            return (
+                <Show when={model()}>
+                    {(model) => (
+                        <ElaboratedModelView
+                            name={notebook.name}
+                            model={model()}
+                            onMutate={runTestMutation}
+                        />
+                    )}
+                </Show>
+            );
+        }
+
+        const container = document.createElement("div");
+        document.body.appendChild(container);
+        const dispose = render(() => <Consumer />, container);
+
+        await until(() => globalValidation() !== undefined);
+        expect(globalValidation()?.tag).toBe("Ok");
+        expect(container.innerHTML).toBe(EXPECTED_INITIAL);
+
+        const appendButton = container.querySelector<HTMLButtonElement>(
+            '[aria-label="run test mutation"]',
+        )!;
+        appendButton.click();
+        await until(() => container.innerHTML === EXPECTED_AFTER_APPEND);
+        expect(container.innerHTML).toBe(EXPECTED_AFTER_APPEND);
+
+        dispose();
+        container.remove();
+    });
+});
diff --git a/packages/document-methods/test/resolving_store.ts b/packages/document-methods/test/resolving_store.ts
new file mode 100644
index 000000000..abc27892e
--- /dev/null
+++ b/packages/document-methods/test/resolving_store.ts
@@ -0,0 +1,75 @@
+import type { DocumentStore } from "catcolab-documents";
+import { v7 } from "uuid";
+
+import type { Document } from "catcolab-document-types";
+
+/**
+ * A bespoke in-memory store whose handles are the documents themselves,
+ * augmented with `getHandle` so notebooks containing instantiation cells can be
+ * resolved. Handles are registered under a stable id by `createHandle`;
+ * `getDocumentRef` is a plain lookup and `getHandle` its inverse. Each call
+ * builds an independent store object, so each gets its own model cache (the
+ * cache registry is keyed by store identity).
+ *
+ * `failOnResolve` makes `getHandle` return `undefined`, so resolution rejects
+ * with "unknown model" — modelling a store that cannot fetch a referenced
+ * document.
+ */
+export function createResolvingStore(): {
+    store: DocumentStore<Document>;
+    failOnResolve: { value: boolean };
+} {
+    const ids = new WeakMap<Document, string>();
+    const byId = new Map<string, Document>();
+    const listeners = new WeakMap<Document, Set<() => void>>();
+    const failOnResolve = { value: false };
+
+    const store: DocumentStore<Document> = {
+        createHandle: async (initialDoc) => {
+            const doc = initialDoc as Document;
+            const id = v7();
+            ids.set(doc, id);
+            byId.set(id, doc);
+            return doc;
+        },
+        getHandle: async (ref) => {
+            const handle = failOnResolve.value ? undefined : byId.get(ref.id);
+            return handle
+                ? { tag: "Ok", content: handle }
+                : {
+                      tag: "Err",
+                      content: [{ message: `Cannot resolve reference "${ref.id}".`, path: ["id"] }],
+                  };
+        },
+        getDocumentView: (handle) => handle,
+        changeDocument: (handle, fn) => {
+            fn(handle);
+            for (const listener of Array.from(listeners.get(handle) ?? [])) {
+                listener();
+            }
+        },
+        subscribe: (handle, callback) => {
+            let set = listeners.get(handle);
+            if (!set) {
+                set = new Set();
+                listeners.set(handle, set);
+            }
+            set.add(callback);
+            return () => {
+                set.delete(callback);
+            };
+        },
+        copyValue: (_handle, value) => structuredClone(value),
+        getDocumentRef: (handle) => {
+            let id = ids.get(handle);
+            if (!id) {
+                id = v7();
+                ids.set(handle, id);
+                byId.set(id, handle);
+            }
+            return { id, version: null, server: "" };
+        },
+    };
+
+    return { store, failOnResolve };
+}
diff --git a/packages/document-methods/test/rfc-0006.lts.md b/packages/document-methods/test/rfc-0006.lts.md
new file mode 100644
index 000000000..67102f7af
--- /dev/null
+++ b/packages/document-methods/test/rfc-0006.lts.md
@@ -0,0 +1,3068 @@
+---
+title: |
+    `0006` Notebook Typescript API
+author: Kaspar Bumke
+date: 2026-07-08
+toc: true
+toc-depth: 3
+---
+
+::: {.callout-note}
+
+### RFC status
+
+This RFC is tracked in
+[#1334](https://github.com/ToposInstitute/CatColab/issues/1334).
+:::
+
+## Summary & Motivation
+
+Catlog and its WASM interface expose a rich and flexible API surface for formal
+modeling. The full flexibility of this is available to our frontend via
+Typescript, with types largely generated from Rust, but the ergonomics and
+type-safety of this API are sub-par.
+
+Colocation of the Typescript handling `catlog-wasm` and our
+`catcolab-document-types` with the frontend has led to entanglement of UI
+framework concerns with the modeling API.
+
+We want to improve this API surface with the aim of helping three main use-cases:
+
+1. Our use in the CatColab frontend
+2. Other programmatic use from Javascript and Typescript
+3. Users instructing LLMs
+
+We will focus on notebook documents, since that is the only document currently
+in use, but this API should be expandable to other types of documents in the
+future.
+
+## Technical approach
+
+We will replace our current `catcolab-document-methods` package with a package
+called `catcolab-documents` that makes use of `catcolab-document-types` and
+wraps notebook creation and editing in a more ergonomic interface.
+
+We will also add a package called `catcolab-logics` that defines the logics we
+currently make available to users on the frontend.
+
+In the future we may publish these packages on public registries such as NPM
+and JSR.
+
+### Creating notebooks
+
+`catcolab-documents` provides a default `binder` API instance and defines the
+`RichText` and `Instantiation` cells.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { binder, RichText, Instantiation } from "catcolab-documents";
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+```
+
+All documents are created through a binder instance. The default binder uses a
+plain in-memory store for documents and provides no reactivity on its document
+view. Creating custom binder instances is covered in [Use with SolidJS and
+Automerge](#use-with-solidjs-and-automerge).
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const notebook = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+```
+
+### Editing notebooks
+
+All cells are added with a single `add` method. The first argument selects
+the kind of cell: `RichText` for prose, or an object/morphism type from the
+logic for formal cells in the case of editing models.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const intro = notebook.add(RichText, { content: "We define a simple olog." });
+```
+
+We can create objects and morphisms in the notebook.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const source = notebook.add(Type, {
+    label: "A",
+});
+
+const target = notebook.add(Type, {
+    label: "B",
+});
+
+const arrow = notebook.add(Aspect, {
+    label: "has",
+    from: source,
+    to: target,
+});
+```
+
+We can update any item.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+notebook.update({ name: "A simple Olog example" });
+
+intro.update({
+    content: "We define a simple olog with two objects and one arrow.",
+});
+
+source.update({
+    label: "Source",
+});
+
+arrow.update({
+    label: "has as",
+    from: source,
+    to: target,
+});
+```
+
+We can also do partial updates.
+
+```ts
+arrow.update({
+    label: "has as example",
+});
+```
+
+### Instantiation
+
+Instantiation is just another cell type provided by `catcolab-documents`. In our
+initial implementation we only support instantiation of notebooks already defined
+in the local binder.
+
+```ts
+const anotherOlog = await binder.createNotebook(SimpleOlog, { name: "Another Olog" });
+const thing = anotherOlog.add(Type, { label: "Thing" });
+
+const instantiation = notebook.add(Instantiation, {
+    label: "ImportedOlog",
+    model: anotherOlog,
+    // maps ImportedOlog.Thing <- B
+    specializations: [{ object: thing, as: target }],
+});
+```
+
+### Iterating through cells
+
+A `cells` method is provided to iterate through all cells of the notebook.
+
+```ts
+import { CellKind } from "catcolab-documents";
+
+for (const cell of notebook.cells()) {
+    switch (cell.kind) {
+        case CellKind.RichText:
+            console.log("text:", cell.content);
+            break;
+        case CellKind.Object:
+            console.log("object:", cell.label, "type:", cell.type.obType.content);
+            break;
+        case CellKind.Morphism:
+            console.log("morphism:", cell.label, "type tag:", cell.type.morType.tag);
+            break;
+    }
+}
+```
+
+```
+text: We define a simple olog with two objects and one arrow.
+object: Source type: Object
+object: B type: Object
+morphism: has as type tag: Hom
+```
+
+Additionally we provide a `cellsOf` method where we can filter by cell type
+(and by `Shape`, see [Generic shapes of notebooks](#generic-shapes-of-notebooks)).
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Attr, AttrType, Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleSchema, { name: "Example schema" });
+
+const person = notebook.add(Entity, { label: "Person" });
+const company = notebook.add(Entity, { label: "Company" });
+
+const mapping = notebook.add(Mapping, { label: "employer", from: person, to: company });
+```
+
+```ts
+const entities = notebook.cellsOf(Entity);
+const mappings = notebook.cellsOf(Mapping);
+
+console.log("entities:", entities.map((cell) => cell.label).join(", "));
+console.log("mappings:", mappings.map((cell) => cell.label).join(", "));
+```
+
+```
+entities: Person, Company
+mappings: employer
+```
+
+`cells` and `cellsOf` do not recurse into instantiations.
+
+<details>
+
+<summary>Code example</summary>
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleSchema, { name: "Example schema" });
+
+const person = notebook.add(Entity, { label: "Person" });
+const company = notebook.add(Entity, { label: "Company" });
+
+const mapping = notebook.add(Mapping, { label: "employer", from: person, to: company });
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Instantiation } from "catcolab-documents";
+
+const anotherSchema = await binder.createNotebook(SimpleSchema, { name: "Another schema" });
+const enterprise = anotherSchema.add(Entity, { label: "Enterprise" });
+const building = anotherSchema.add(Entity, { label: "Building" });
+const owner = anotherSchema.add(Mapping, { label: "owner", from: enterprise, to: building });
+
+const instantiation = notebook.add(Instantiation, {
+    label: "ImportedSchema",
+    model: anotherSchema,
+    specializations: [{ object: enterprise, as: company }],
+});
+```
+
+```ts
+const instantiations = notebook.cellsOf(Instantiation);
+const entities = notebook.cellsOf(Entity);
+const mappings = notebook.cellsOf(Mapping);
+
+console.log("instantiations:", instantiations.map((cell) => cell.label).join(", "));
+console.log("entities:", entities.map((cell) => cell.label).join(", "));
+console.log("mappings:", mappings.map((cell) => cell.label).join(", "));
+```
+
+```
+instantiations: ImportedSchema
+entities: Person, Company
+mappings: employer
+```
+
+</details>
+
+### Further details on notebook editing
+
+#### Duplicating cells
+
+We can duplicate cells. Copies keep the same logical shape but receive
+fresh identities, and their handles can be updated independently.
+
+<details>
+
+<summary> Code example </summary>
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, RichText } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const a = notebook.add(Type, { label: "A" });
+const b = a.duplicate();
+b.update({
+    label: `B (copy of ${a.label})`,
+});
+
+console.log("a:", a.label);
+console.log("b:", b.label);
+```
+
+```
+a: A
+b: B (copy of A)
+```
+
+</details>
+
+#### Re-ordering cells
+
+Every cell handle can move itself within the notebook. Moves locate the cell
+by its id at the moment the change applies, so they remain valid even if the
+notebook was edited after the handle was obtained.
+
+<details>
+
+<summary> Code examples </summary>
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, RichText } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const a = notebook.add(Type, { label: "A" });
+const b = notebook.add(Type, { label: "B" });
+const c = notebook.add(Type, { label: "C" });
+
+function names() {
+    return notebook
+        .cellsOf(Type)
+        .map((cell) => cell.label)
+        .join(", ");
+}
+```
+
+`moveUp` and `moveDown` shift a cell one position; `moveTo` moves it to an
+index, interpreted after the cell is removed from its current position.
+
+```ts
+c.moveUp();
+console.log(names());
+
+a.moveDown();
+console.log(names());
+
+b.moveTo(0);
+console.log(names());
+```
+
+```
+A, C, B
+C, A, B
+B, C, A
+```
+
+Impossible moves are silent no-ops and out-of-range targets clamp to the ends
+of the notebook.
+
+```ts
+a.moveUp();
+c.moveDown();
+console.log(names());
+
+b.moveTo(99);
+console.log(names());
+```
+
+```
+A, B, C
+A, C, B
+```
+
+</details>
+
+#### Deleting cells
+
+Every cell handle can remove itself from the notebook with `delete`. Like the
+reorder methods, delete locates the cell by its id when the change applies, so
+it stays valid even if the notebook was edited after the handle was obtained.
+
+<details>
+
+<summary> Code examples </summary>
+
+Deleting a cell removes it from the notebook's order and contents.
+
+```ts
+console.log(names());
+b.delete();
+console.log(names());
+```
+
+```
+A, B, C
+A, C
+```
+
+Rich-text cells can be deleted in the same way.
+
+```ts
+const note = notebook.add(RichText, { content: "A note." });
+console.log(notebook.cells().length);
+note.delete();
+console.log(notebook.cells().length);
+```
+
+```
+4
+3
+```
+
+After deletion, reading fields off the stale handle returns `undefined`.
+
+```ts
+b.delete();
+console.log(b.label);
+```
+
+```
+undefined
+```
+
+Deleting an already-deleted cell is a silent no-op.
+
+```ts
+b.delete();
+b.delete();
+console.log(names());
+```
+
+```
+A, C
+```
+
+</details>
+
+#### Getting a cell by id
+
+We can retrieve a cell by its id, filtering by the type of cell we are looking
+for.
+
+<details>
+
+<summary> Code example </summary>
+
+```ts
+const retrievedA = notebook.get(Type, a.id);
+if (retrievedA.tag === "Ok") {
+    console.log("retrieved:", retrievedA.content.label);
+}
+```
+
+```
+retrieved: A
+```
+
+</details>
+
+#### Subscribing to changes.
+
+We can subscribe to notebook changes with `onChange`. This triggers on _any_
+change to the notebook. No arguments are passed to the callback.
+
+<details>
+
+<summary> Code example </summary>
+
+```ts
+const unsubscribe = notebook.onChange(() => {
+    console.log("changed");
+});
+```
+
+</details>
+
+### A `Result` type
+
+In cases where where functions take in unknown and user generated inputs we want a
+standardized way to return the result on success and diagnostics on failure.
+
+Our `Result` type is a tagged union structurally identical to the `JsResult`
+type in our Rust bindings (`catlog-wasm`). Results coming out of the Rust layer
+can therefore pass through untouched.
+
+When a failure is about validation of unknown or user generated input, the
+`Err` content is an array of issues following the [Standard
+Schema](https://standardschema.dev) definition. This allows for flexibility in
+validation libraries and implementation while sticking to a standard format,
+and lets us design and make use of general purpose libraries that follow this
+standard.
+
+```ts
+/** The result of a fallible operation. */
+type Result<T, E = ReadonlyArray<Issue>> =
+    | { readonly tag: "Ok"; readonly content: T }
+    | { readonly tag: "Err"; readonly content: E };
+
+/** The issue interface of the failure output. */
+interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+}
+
+/** The path segment interface of the issue. */
+interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+}
+```
+
+Since it is general enough, in the case of e.g. validation failure of a model,
+we can use the path field to point at specific object or morphism. If we have
+the need we can extend this in the future e.g. adding a `uuid` field to the
+`PathSegment` interface, without breaking compatibility with the standard.
+
+### Model validation
+
+#### Validate method
+
+`validate` is an asynchronous method that returns a `Result`: an `Ok` carrying
+the elaborated model as `content`, or an `Err` carrying an array of issues.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import type { DblModel } from "catlog-wasm";
+import type { Result } from "catcolab-documents";
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const source = notebook.add(Type, { label: "A" });
+const target = notebook.add(Type, { label: "B" });
+notebook.add(Aspect, { label: "has", from: source, to: target });
+```
+
+A well-formed notebook validates to an `Ok` carrying the model as `content`.
+
+```ts
+const result: Result<DblModel> = await notebook.validate();
+console.log("valid:", result.tag === "Ok");
+```
+
+```
+valid: true
+```
+
+The validated model is available on the result and can be queried.
+
+```ts
+const result = await notebook.validate();
+if (result.tag === "Ok") {
+    console.log("objects:", result.content.obGenerators().length);
+    console.log("morphisms:", result.content.morGenerators().length);
+}
+```
+
+```
+objects: 2
+morphisms: 1
+```
+
+#### Subscribing to validation changes
+
+You can subscribe to validation changes with `onValidate` and get notified when
+any of the formal content of the notebook affected the validation result.
+
+`onValidate` will trigger a validation if the notebook has not been validated
+yet and should always call the callback at least once with the current
+validation.
+
+```ts
+const unsubscribe = notebook.onValidate((result: Result<DblModel>) => {
+    console.log("valid:", result.tag === "Ok");
+});
+```
+
+#### Validation result
+
+An ill-formed notebook results in an `Err` carrying issues.
+
+<!-- verifier:reset -->
+
+```ts
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, Instantiation } from "catcolab-documents";
+
+const first = await binder.createNotebook(SimpleOlog, { name: "First" });
+const second = await binder.createNotebook(SimpleOlog, { name: "Second" });
+
+first.add(Type, { label: "A" });
+second.add(Type, { label: "B" });
+
+// A cycle: `first` instantiates `second`, which instantiates `first`.
+first.add(Instantiation, { label: "ImportedSecond", model: second });
+second.add(Instantiation, { label: "ImportedFirst", model: first });
+
+const result = await first.validate();
+console.log("valid:", result.tag === "Ok");
+if (result.tag === "Err") {
+    console.log("issues:", result.content.map((issue) => issue.message).join("; "));
+}
+```
+
+```
+valid: false
+issues: Instantiation cycle detected: "First" → "Second" → "First". A notebook cannot instantiate itself, directly or indirectly. To fix, remove one of the instantiations in this chain.
+```
+
+### Serialization
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { PetriNet } from "catcolab-logics/petri-net";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(PetriNet, { name: "Example Petri-net" });
+```
+
+We can dump a notebook.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const petriNetData = notebook.dump();
+```
+
+And load it.
+
+```ts
+const loaded = await binder.loadNotebook(PetriNet, petriNetData);
+console.log("tag:", loaded.tag);
+if (loaded.tag === "Ok") {
+    console.log("loaded:", loaded.content.name);
+}
+```
+
+```
+tag: Ok
+loaded: Example Petri-net
+```
+
+Trying to load a document with the wrong shape yields an `Err` result whose
+issues describe the mismatch.
+
+```ts
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+
+const wrong = await binder.loadNotebook(SimpleOlog, petriNetData);
+if (wrong.tag === "Err") {
+    console.log("issues:", wrong.content.map((issue) => issue.message).join("; "));
+}
+```
+
+```
+issues: Cannot load document with theory "petri-net" using a shape with theory "simple-olog".
+```
+
+We can also load a notebook from a `DocumentRef`.
+
+```ts
+const loaded = await binder.loadNotebookFromRef(PetriNet, {
+    id: "some-document-id",
+    version: null,
+});
+```
+
+### Migrating between logics
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { binder } from "catcolab-documents";
+
+const olog = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const a = olog.add(Type, { label: "A" });
+const b = olog.add(Type, { label: "B" });
+olog.add(Aspect, { label: "has", from: a, to: b });
+```
+
+`migrateTo` returns a `Result`.
+
+```ts
+const migration = await olog.migrateTo(SimpleSchema);
+console.log("tag:", migration.tag);
+if (migration.tag === "Ok") {
+    const schema = migration.content;
+
+    // The original document was rewritten in place, not copied.
+    console.log("same document:", schema.document === olog.document);
+    console.log("theory:", schema.document.theory);
+    console.log(
+        "entities:",
+        schema
+            .cellsOf(Entity)
+            .map((cell) => cell.label)
+            .join(", "),
+    );
+    console.log(
+        "mappings:",
+        schema
+            .cellsOf(Mapping)
+            .map((cell) => cell.label)
+            .join(", "),
+    );
+    console.log("valid:", (await schema.validate()).tag === "Ok");
+}
+```
+
+```
+tag: Ok
+same document: true
+theory: simple-schema
+entities: A, B
+mappings: has
+valid: true
+```
+
+### Diagram notebooks
+
+Diagrams are another type of notebook and have a very similar editing interface.
+
+#### Diagram creation
+
+<details>
+
+<summary> `model` definition </summary>
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, RichText } from "catcolab-documents";
+
+const model = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const A = model.add(Type, { label: "A" });
+const B = model.add(Type, { label: "B" });
+const has = model.add(Aspect, { label: "has", from: A, to: B });
+```
+
+</details>
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const diagram = await binder.createNotebook(SimpleOlog.Diagram, {
+    name: "Olog diagram",
+    in: model,
+});
+```
+
+```ts
+console.log("name:", diagram.name);
+console.log("theory:", diagram.theory);
+```
+
+```
+name: Olog diagram
+theory: simple-olog
+```
+
+#### Adding cells over the model
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+diagram.add(RichText, { content: "We picture two instances of the olog." });
+
+const x = diagram.add(SimpleOlog.Diagram.Individual, { label: "x", over: A });
+const y = diagram.add(SimpleOlog.Diagram.Individual, { label: "y", over: B });
+```
+
+```ts
+console.log("over:", x.over.label);
+console.log("type:", x.type.obType.content);
+```
+
+```
+over: A
+type: Object
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const f = diagram.add(SimpleOlog.Diagram.Aspect, { from: x, to: y, over: has });
+```
+
+```ts
+console.log("over:", f.over.label);
+console.log("from:", f.from.label);
+console.log("to:", f.to.label);
+```
+
+```
+over: has
+from: x
+to: y
+```
+
+### Analysis notebooks
+
+Analyses are yet another type of notebook, again with a similar editing interface.
+Common analysis cell types will be packaged by us into `catcolab-analyses`.
+
+<details>
+
+<summary> `model` definition </summary>
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder, RichText } from "catcolab-documents";
+
+const model = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const source = model.add(Type, { label: "A" });
+const target = model.add(Type, { label: "B" });
+```
+
+</details>
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const analysis = await binder.createNotebook(SimpleOlog.Analysis, {
+    name: "Olog analysis",
+    of: model,
+});
+```
+
+```ts
+console.log("name:", analysis.name);
+console.log("type:", analysis.analysisType);
+```
+
+```
+name: Olog analysis
+type: model
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Visualization } from "catcolab-analyses";
+analysis.add(RichText, { content: "We visualize the olog." });
+
+const viz = analysis.add(Visualization);
+```
+
+```ts
+console.log("analysis id:", viz.type.id);
+console.log("layout:", viz.params.layout);
+```
+
+```
+analysis id: diagram
+layout: graphviz-directed
+```
+
+```ts
+viz.update({ direction: "horizontal" });
+
+console.log("layout:", viz.params.layout);
+console.log("direction:", viz.params.direction);
+```
+
+```
+layout: graphviz-directed
+direction: horizontal
+```
+
+#### Running an analysis
+
+Running an analysis is an asynchronous function that returns a `Result`: an
+`Ok` carrying the analysis output as `content`, or an `Err` carrying an array
+of issues.
+
+```ts
+const result = await viz.run();
+if (result.tag === "Ok") {
+    const { svg } = result.content;
+    console.log("is svg:", svg.includes("<svg"));
+    console.log("has A:", svg.includes(">A<"));
+    console.log("has B:", svg.includes(">B<"));
+}
+```
+
+```
+is svg: true
+has A: true
+has B: true
+```
+
+#### Mass-action dynamics example
+
+<details>
+
+<summary> Code example </summary>
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { MassActionDynamics } from "catcolab-analyses";
+import { PetriNet, Place, Transition } from "catcolab-logics/petri-net";
+import { binder } from "catcolab-documents";
+
+const petriNet = await binder.createNotebook(PetriNet, { name: "SIR" });
+
+const susceptible = petriNet.add(Place, { label: "S" });
+const infected = petriNet.add(Place, { label: "I" });
+
+petriNet.add(Transition, { label: "infection", from: [susceptible, infected], to: [infected] });
+
+const analysis = await binder.createNotebook(PetriNet.Analysis, {
+    name: "Petri net analysis",
+    of: petriNet,
+});
+
+const sim = analysis.add(MassActionDynamics);
+```
+
+```ts
+console.log("analysis id:", sim.type.id);
+console.log("duration:", sim.params.duration);
+```
+
+```
+analysis id: mass-action
+duration: 10
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+sim.update({ duration: 3, initialValues: { [susceptible.id]: 1 } });
+```
+
+```ts
+console.log("duration:", sim.params.duration);
+console.log("S initial:", sim.params.initialValues[susceptible.id]);
+```
+
+```
+duration: 3
+S initial: 1
+```
+
+```ts
+const result = await sim.run();
+if (result.tag === "Ok") {
+    const { solution, latexEquations } = result.content;
+    if (solution.tag === "Ok") {
+        console.log("has times:", solution.content.time.length > 0);
+        console.log("states:", [...solution.content.states.keys()].length);
+    }
+    console.log("equations:", latexEquations.length > 0);
+}
+```
+
+```
+has times: true
+states: 2
+equations: true
+```
+
+</details>
+
+### Type errors & runtime errors
+
+We make use of Typescript type checking to have confidence that our use of the
+Notebook API makes sense and is free of misspellings or other issues
+that would throw errors at runtime.
+
+Since the API can also be used from Javascript directly without type checking
+we want runtime validation that inputs match our expected schema.
+
+At runtime invalid inputs:
+
+- Should _throw_ an exception, ideally carrying a Standard Schema compatible `issues` array, _if_ it is something Typescript would have caught
+- Should return a `Result` type otherwise
+
+#### Type errors
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const source = notebook.add(Type, { label: "A" });
+const target = notebook.add(Type, { label: "B" });
+const arrow = notebook.add(Aspect, { label: "has", from: source, to: target });
+```
+
+Invalid shapes should be type errors.
+
+```ts
+// @ts-expect-error Arrays are not valid endpoints in a simple olog.
+arrow.update({ from: [source] });
+
+// @ts-expect-error Arrays are not valid endpoints in a simple olog.
+notebook.add(Aspect, { label: "bad", from: [source, target], to: target });
+// @ts-expect-error Missing required fields.
+notebook.add(Aspect, {});
+// null fields are allowed.
+notebook.add(Aspect, { label: null, from: null, to: null });
+```
+
+#### Further type errors
+
+<details>
+
+<summary>Further type errors</summary>
+
+A mapping's endpoints must be entities, not attribute types:
+
+<!-- verifier:reset -->
+
+```ts
+import { AttrType, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { binder } from "catcolab-documents";
+
+const schema = await binder.createNotebook(SimpleSchema, { name: "Example schema" });
+
+const str = schema.add(AttrType, { label: "String" });
+
+// @ts-expect-error A mapping's endpoints must be entities, not attribute types.
+schema.add(Mapping, {
+    label: "bad",
+    from: str,
+    to: str,
+});
+```
+
+But adapt to the underlying logic:
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { PetriNet, Place, Transition } from "catcolab-logics/petri-net";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(PetriNet, { name: "Example Petri-net" });
+
+const a = notebook.add(Place, { label: "A" });
+
+const b = notebook.add(Place, { label: "B" });
+
+const c = notebook.add(Place, { label: "C" });
+
+notebook.add(Transition, {
+    label: "t1",
+    from: [a, b],
+    to: [c],
+});
+
+// @ts-expect-error Petri net transitions require arrays of places.
+notebook.add(Transition, {
+    label: "bad",
+    from: a,
+    to: [c],
+});
+```
+
+</details>
+
+#### Runtime errors
+
+The same invalid inputs that Typescript catches are also rejected at runtime.
+Each one throws an error carrying a Standard Schema compatible `issues` array.
+
+<!-- verifier:reset -->
+
+<!-- verifier:skip-typecheck -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Aspect, SimpleOlog, Type } from "catcolab-logics/simple-olog";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleOlog, { name: "An Olog" });
+
+const source = notebook.add(Type, { label: "A" });
+const target = notebook.add(Type, { label: "B" });
+const arrow = notebook.add(Aspect, { label: "has", from: source, to: target });
+```
+
+Invalid shapes throw at runtime, with a Standard Schema compatible `issues` array:
+
+<!-- verifier:skip-typecheck -->
+
+```ts
+try {
+    // Arrays are not valid endpoints in a simple olog.
+    arrow.update({ from: [source] });
+} catch (error) {
+    console.log("update:", error.issues?.map((issue) => issue.message).join("; "));
+}
+
+try {
+    // Arrays are not valid endpoints in a simple olog.
+    notebook.add(Aspect, { label: "bad", from: [source, target], to: target });
+} catch (error) {
+    console.log("add:", error.issues?.map((issue) => issue.message).join("; "));
+}
+
+try {
+    // Missing required fields.
+    notebook.add(Aspect, {});
+} catch (error) {
+    console.log("missing:", error.issues?.map((issue) => issue.message).join("; "));
+}
+
+// null fields are allowed.
+notebook.add(Aspect, { label: null, from: null, to: null });
+```
+
+```
+update: `from` must be an object cell or null (was an array)
+add: `from` must be an object cell or null (was an array)
+missing: `from` must be an object cell or null (was missing); `label` must be a string or null (was missing); `to` must be an object cell or null (was missing)
+```
+
+#### Further runtime errors
+
+<details>
+
+<summary>Further runtime errors</summary>
+
+A mapping's endpoints must be entities, not attribute types:
+
+<!-- verifier:reset -->
+
+<!-- verifier:skip-typecheck -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { AttrType, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { binder } from "catcolab-documents";
+
+const schema = await binder.createNotebook(SimpleSchema, { name: "Example schema" });
+
+const str = schema.add(AttrType, { label: "String" });
+```
+
+<!-- verifier:skip-typecheck -->
+
+```ts
+try {
+    schema.add(Mapping, { label: "bad", from: str, to: str });
+} catch (error) {
+    console.log("mapping:", error.issues?.map((issue) => issue.message).join("; "));
+}
+```
+
+```
+mapping: `from` must be an object cell of type Entity (was an object cell of type AttrType); `to` must be an object cell of type Entity (was an object cell of type AttrType)
+```
+
+Validation also adapts to the underlying logic:
+
+<!-- verifier:reset -->
+
+<!-- verifier:skip-typecheck -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { PetriNet, Place, Transition } from "catcolab-logics/petri-net";
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(PetriNet, { name: "Example Petri-net" });
+
+const a = notebook.add(Place, { label: "A" });
+const c = notebook.add(Place, { label: "C" });
+```
+
+<!-- verifier:skip-typecheck -->
+
+```ts
+try {
+    // Petri net transitions require arrays of places.
+    notebook.add(Transition, { label: "bad", from: a, to: [c] });
+} catch (error) {
+    console.log("transition:", error.issues?.map((issue) => issue.message).join("; "));
+}
+```
+
+```
+transition: `from` must be an array or null (was an object cell of type Object)
+```
+
+</details>
+
+### Use with SolidJS and Automerge
+
+The `Binder` abstraction exsits to keep the API consistent while being able to
+plug in custom backends. We offer the `createBinder` method and the
+`DocumentStore` type to be able to do so.
+
+<!-- verifier:reset -->
+
+```ts
+import type { Document } from "catcolab-document-types";
+import type { Result } from "catcolab-documents";
+interface DocumentRef {
+    id: string;
+    version: string | null;
+    server?: string;
+}
+interface DocumentStore<Handle> {
+    // An async function to create a document handle from inital data
+    createHandle(initialDoc: Document): Promise<Handle>;
+    // An async function to get a document handle from a `DocumentRef`,
+    // as a `Result` (`Ok` with the handle, or `Err` with issues).
+    getHandle(ref: DocumentRef): Promise<Result<Handle>>;
+    // Apply modifications to a handle.
+    changeDocument(handle: Handle, fn: (doc: Document) => void): void;
+    // Subscribe change callbacks to our store for `onChange`. Returns a
+    // function to unsubscribe.
+    subscribe(handle: Handle, callback: () => void): () => void;
+    // Copy values (with any proxies removed)
+    copyValue<T>(handle: Handle, value: T): T;
+    // Get the reference for a handle
+    getDocumentRef(handle: Handle): DocumentRef;
+    // Get a document view from a handle
+    getDocumentView(handle: Handle): Readonly<Document>;
+}
+```
+
+#### SolidJS binder
+
+An example of a simple SolidJS binder:
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { createEffect, createRoot } from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { binder, createBinder, type DocumentStore } from "catcolab-documents";
+import { type Document } from "catcolab-document-types";
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+// Every store mints a stable reference for its handles; this one assigns an id
+// on demand and keeps it in a WeakMap.
+const solidStoreIds = new WeakMap<SolidStoreHandle, string>();
+const solidStoreIdFor = (handle: SolidStoreHandle): string => {
+    let id = solidStoreIds.get(handle);
+    if (!id) {
+        id = crypto.randomUUID();
+        solidStoreIds.set(handle, id);
+    }
+    return id;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    getDocumentView: (handle) => handle.docView,
+    getDocumentRef: (handle) => ({ id: solidStoreIdFor(handle), version: null, server: "" }),
+    // Link resolution omitted for brevity.
+    getHandle: async () => ({
+        tag: "Err",
+        content: [{ message: "This store cannot resolve references." }],
+    }),
+};
+
+const solidBinder = createBinder(solidStore);
+```
+
+Which can be used just as the default binder.
+
+```ts
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+const notebook = await solidBinder.createNotebook(SimpleOlog, { name: "An Olog" });
+```
+
+#### Automerge binder
+
+A simple Automerge binder:
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { type Doc, getBackend, getObjectId } from "@automerge/automerge";
+import { type DocHandle, Repo } from "@automerge/automerge-repo";
+import { createBinder, type DocumentStore } from "catcolab-documents";
+import { type Document } from "catcolab-document-types";
+
+const repo = new Repo();
+
+const automergeStore: DocumentStore<DocHandle<Document>> = {
+    createHandle: async (initialDoc) => {
+        return repo.create<Document>(initialDoc as Document);
+    },
+    changeDocument: (handle, fn) => handle.change(fn),
+    subscribe: (handle, callback) => {
+        const onChange = () => callback();
+        handle.on("change", onChange);
+        return () => handle.off("change", onChange);
+    },
+    copyValue: (handle, value) => {
+        const doc = handle.doc();
+        const objId = getObjectId(value as object);
+        return getBackend(doc).materialize(objId!) as typeof value;
+    },
+    getDocumentView: (handle) => handle.doc(),
+    getDocumentRef: (handle) => ({ id: handle.documentId, version: null, server: "" }),
+    // Link resolution omitted for brevity.
+    getHandle: async () => ({
+        tag: "Err",
+        content: [{ message: "This store cannot resolve references." }],
+    }),
+};
+
+const automergeBinder = createBinder(automergeStore);
+```
+
+```ts
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+const notebook = await automergeBinder.createNotebook(SimpleOlog, { name: "An Olog" });
+```
+
+#### An Automerge and SolidJS binder for our backend
+
+Here is an approximation of how we can define a binder to work with our backend
+and frontend using Automerge, SolidJS and our RPC client (mocked here as
+`FakeBackend`).
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { getBackend, getObjectId } from "@automerge/automerge";
+import { type DocHandle, type DocumentId } from "@automerge/automerge-repo";
+import { makeDocumentProjection } from "@automerge/automerge-repo-solid-primitives";
+import { createBinder, type DocumentStore, Instantiation } from "catcolab-documents";
+import { SimpleOlog, Type } from "catcolab-logics/simple-olog";
+
+import type { Document } from "catcolab-document-types";
+import { FakeBackend } from "document-methods/test/fake_backend";
+
+const backend = new FakeBackend();
+const repo = backend.repo;
+
+type StoreHandle = {
+    docHandle: DocHandle<Document>;
+    docView: Document;
+};
+
+const makeHandle = (docHandle: DocHandle<Document>): StoreHandle => ({
+    docHandle,
+    docView: makeDocumentProjection(docHandle),
+});
+
+const refByDocId = new Map<DocumentId, string>();
+const handleByRefId = new Map<string, StoreHandle>();
+
+const backendStore: DocumentStore<StoreHandle> = {
+    createHandle: async (initialDoc: Document) => {
+        const created = await backend.new_ref(initialDoc);
+        if (created.tag !== "Ok") {
+            throw new Error(created.message);
+        }
+        const refId = created.content;
+
+        const fetched = await backend.get_doc(refId);
+        if (fetched.tag !== "Ok") {
+            throw new Error(fetched.message);
+        }
+        const docHandle = await repo.find<Document>(fetched.content.docId as DocumentId);
+        const handle = makeHandle(docHandle);
+
+        refByDocId.set(docHandle.documentId, refId);
+        handleByRefId.set(refId, handle);
+        return handle;
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => handle.docHandle.change(fn),
+    subscribe: (handle, callback) => {
+        handle.docHandle.on("change", callback);
+        return () => handle.docHandle.off("change", callback);
+    },
+    copyValue: (handle, value) => {
+        const doc = handle.docHandle.doc();
+        const objId = getObjectId(value as object);
+        return getBackend(doc).materialize(objId!) as typeof value;
+    },
+    getDocumentRef: (handle) => {
+        const refId = refByDocId.get(handle.docHandle.documentId);
+        if (!refId) {
+            throw new Error("handle is not registered with this store");
+        }
+        return { id: refId, version: null, server: backend.serverHost };
+    },
+    getHandle: async (ref) => {
+        const refId = ref.id;
+        const cached = handleByRefId.get(refId);
+        if (cached) {
+            return { tag: "Ok", content: cached };
+        }
+
+        const result = await backend.get_doc(refId);
+        if (result.tag !== "Ok") {
+            return {
+                tag: "Err",
+                content: [{ message: `Cannot resolve reference "${refId}".`, path: ["id"] }],
+            };
+        }
+
+        const docHandle = await repo.find<Document>(result.content.docId as DocumentId);
+        const handle = makeHandle(docHandle);
+        handleByRefId.set(refId, handle);
+        refByDocId.set(docHandle.documentId, refId);
+        return { tag: "Ok", content: handle };
+    },
+};
+
+const backendBinder = createBinder(backendStore);
+```
+
+<details>
+
+<summary>Code verification</summary>
+
+```ts
+const imported = await backendBinder.createNotebook(SimpleOlog, { name: "Imported" });
+imported.add(Type, { label: "Thing" });
+
+const notebook = await backendBinder.createNotebook(SimpleOlog, { name: "Main" });
+notebook.add(Type, { label: "A" });
+notebook.add(Instantiation, { label: "ImportedOlog", model: imported });
+
+const result = await notebook.validate();
+console.log(result.tag);
+```
+
+```
+Ok
+```
+
+</details>
+
+### Defining notebook shapes
+
+#### A logic
+
+We provide some utilities for defining a logic: `defineMorphism`,
+`defineObject` and `defineShape`. Here is what the definition of the `PetriNet`
+logic looks like:
+
+<!-- verifier:reset -->
+
+```ts
+import { MassActionDynamics, Visualization } from "catcolab-analyses";
+import { defineMorphism, defineObject, defineShape } from "catcolab-documents";
+
+export const Place = defineObject({ tag: "Basic", content: "Object" });
+export const Transition = defineMorphism(
+    { tag: "Hom", content: Place.obType },
+    {
+        domain: { apply: { tag: "Basic", content: "tensor" }, modality: "SymmetricList" },
+        codomain: { apply: { tag: "Basic", content: "tensor" }, modality: "SymmetricList" },
+    },
+);
+
+export const PetriNet = defineShape({
+    theory: "petri-net",
+    getCoreTheory: async () => {
+        const { ThSymMonoidalCategory } = await import("catlog-wasm");
+        return new ThSymMonoidalCategory().theory();
+    },
+    objects: [Place],
+    morphisms: [Transition],
+    modelAnalyses: [Visualization, MassActionDynamics /*, ... */],
+});
+```
+
+To illustrate how migrations are defined here is the definition of `SimpleSchema`.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { defineMorphism, defineObject, defineShape, RichText } from "catcolab-documents";
+
+export const Entity = defineObject({ tag: "Basic", content: "Entity" });
+export const AttrType = defineObject({ tag: "Basic", content: "AttrType" });
+
+export const Mapping = defineMorphism({ tag: "Hom", content: Entity.obType });
+export const Attr = defineMorphism(
+    { tag: "Basic", content: "Attr" },
+    { domain: Entity.obType, codomain: AttrType.obType },
+);
+
+export const SimpleSchema = defineShape({
+    theory: "simple-schema",
+    getCoreTheory: async () => {
+        const { ThSchema } = await import("catlog-wasm");
+        return new ThSchema().theory();
+    },
+    objects: [Entity, AttrType],
+    morphisms: [Mapping, Attr],
+    supportsInstances: true,
+    informal: [RichText],
+    analyses: [
+        /* ... */
+    ],
+    migrations: [
+        {
+            target: "simple-olog",
+            migrate: async (model, targetTheory) => {
+                const { ThSchema } = await import("catlog-wasm");
+                return ThSchema.toCategory(model, targetTheory);
+            },
+        },
+    ],
+});
+```
+
+`supportsIntances` is a boolean flag that indicates whether the notebook
+supports diagrams. When included the `.Diagram` is generated for the logic. See
+[Diagram notebooks](#diagram-notebooks) for using the `.Diagram` shape.
+
+#### Analysis definitions
+
+For analysis cell definitions we can use the `defineAnalysis` helper. Here is
+an example for `MassActionDynamics`.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { defineAnalysis } from "catcolab-documents";
+import type {
+    MassActionProblemData,
+    ODEResultWithEquations,
+    ThSymMonoidalCategory,
+    DblModel,
+} from "catlog-wasm";
+
+let thSymMonoidalCategory: Promise<ThSymMonoidalCategory> | undefined;
+
+function getCachedTheory(): Promise<ThSymMonoidalCategory> {
+    if (thSymMonoidalCategory === undefined) {
+        thSymMonoidalCategory = import("catlog-wasm").then(
+            ({ ThSymMonoidalCategory }) => new ThSymMonoidalCategory(),
+        );
+    }
+    return thSymMonoidalCategory;
+}
+
+export const MassActionDynamics = defineAnalysis({
+    id: "mass-action",
+    getInitialParams: (): MassActionProblemData => ({
+        massConservationType: { type: "Balanced" },
+        rates: {},
+        transitionProductionRates: {},
+        transitionConsumptionRates: {},
+        placeProductionRates: {},
+        placeConsumptionRates: {},
+        initialValues: {},
+        duration: 10,
+    }),
+    run: async (
+        model: DblModel,
+        params: MassActionProblemData,
+    ): Promise<ODEResultWithEquations> => {
+        const th = await getCachedTheory();
+        return th.massAction(model, params);
+    },
+});
+```
+
+#### Generic shapes of notebooks
+
+Using `defineShape` we don't have to define a complete notebook. We can define
+shapes that are subsets of a notebook and/or span across different notebooks.
+
+Here is an example of a shape that only deals with basic objects:
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { defineObject, defineShape } from "catcolab-documents";
+
+const BasicObj = defineObject({ tag: "Basic", content: "Object" });
+
+const OnlyBasicObj = defineShape({
+    objects: [BasicObj],
+});
+```
+
+Because `OnlyBasicObj` is a subset of both the olog and petri-net logics (they
+share the basic `Object`), we can write a generic function against it that
+works with notebooks from either logic.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { binder, type Notebook } from "catcolab-documents";
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+import { PetriNet } from "catcolab-logics/petri-net";
+
+function addObjects(notebook: Notebook<typeof OnlyBasicObj>) {
+    notebook.add(BasicObj, { label: "A" });
+    notebook.add(BasicObj, { label: "B" });
+}
+```
+
+Both an olog and a petri-net notebook support `BasicObj`, so `addObjects` adds
+to them:
+
+```ts
+const olog = await binder.createNotebook(SimpleOlog, { name: "olog" });
+const petriNet = await binder.createNotebook(PetriNet, { name: "petri-net" });
+
+addObjects(olog);
+addObjects(petriNet);
+```
+
+A schema notebook has no basic `Object` so we get a type error.
+
+```ts
+import { SimpleSchema } from "catcolab-logics/simple-schema";
+
+const schema = await binder.createNotebook(SimpleSchema, { name: "schema" });
+
+// @ts-expect-error A SimpleSchema notebook lacks the basic `Object` that OnlyBasicObj requires.
+addObjects(schema);
+```
+
+We can pass a union of shapes to `Notebook` but we need to use `supports` to
+narrow the type to confirm it supports adding cells of a particular shape.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { defineObject, defineShape, defineMorphism } from "catcolab-documents";
+import type { Notebook } from "catcolab-documents";
+
+const BasicObj = defineObject({ tag: "Basic", content: "Object" });
+
+const OnlyBasicObj = defineShape({
+    objects: [BasicObj],
+});
+
+const EntityObj = defineObject({ tag: "Basic", content: "Entity" });
+const OnlyEntityObj = defineShape({
+    objects: [EntityObj],
+});
+```
+
+```ts
+function addBasicAndEntityObjects(notebook: Notebook<typeof OnlyBasicObj | typeof OnlyEntityObj>) {
+    // @ts-expect-error We can't add a BasicObj without narrowing the notebook
+    // type because EntityWithMor does not support BasicObj.
+    notebook.add(BasicObj, { label: "A" });
+
+    // This is ok because we narrowed the notebook type.
+    if (notebook.supports(BasicObj)) {
+        notebook.add(BasicObj, { label: "B" });
+    }
+
+    // @ts-expect-error We can't add a BasicObj without narrowing the notebook
+    // type because OnlyBasicObj does not suppor EntityObj.
+    notebook.add(EntityObj, { label: "C" });
+
+    // This is ok because we narrowed the notebook type.
+    if (notebook.supports(EntityObj)) {
+        notebook.add(EntityObj, { label: "D" });
+    }
+}
+```
+
+`supports` can also take a shape as an argument.
+
+```ts
+export const Morphism = defineMorphism({
+    tag: "Hom",
+    content: EntityObj.obType,
+});
+const EntityWithMor = defineShape({
+    objects: [EntityObj],
+    morphisms: [Morphism],
+});
+function addBasicEntityAndMor(notebook: Notebook<typeof OnlyBasicObj | typeof EntityWithMor>) {
+    // @ts-expect-error We can't add a BasicObj without narrowing the notebook
+    // type because EntityWithMor does not support BasicObj.
+    notebook.add(BasicObj, { label: "A" });
+
+    // This is ok because we narrowed the notebook type.
+    if (notebook.supports(OnlyBasicObj)) {
+        notebook.add(BasicObj, { label: "B" });
+    }
+
+    // @ts-expect-error We can't add a BasicObj without narrowing the notebook
+    // type because OnlyBasicObj does not support EntityObj.
+    notebook.add(EntityObj, { label: "C" });
+
+    // This is ok because we narrowed the notebook type to supporting both
+    // `EntiyObj` and `Morphism`.
+    if (notebook.supports(EntityWithMor)) {
+        const d = notebook.add(EntityObj, { label: "D" });
+        notebook.add(Morphism, { label: "f", from: d, to: d });
+    }
+}
+```
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+`cellsOf` takes `Shape` as an alternative to a cell definition as an argument
+to filter by. `cellsOf` narrows the cell shape type in a similar way to `supports`.
+
+```ts
+import { SimpleSchema, Entity, AttrType, Mapping, Attr } from "catcolab-logics/simple-schema";
+import { binder, defineShape } from "catcolab-documents";
+
+const EntityShape = defineShape({
+    objects: [Entity],
+    morphisms: [Mapping],
+});
+
+const schema = await binder.createNotebook(SimpleSchema, { name: "Example" });
+
+const a = schema.add(Entity, { label: "A" });
+const b = schema.add(AttrType, { label: "B" });
+const c = schema.add(Entity, { label: "C" });
+schema.add(Attr, { label: "f", from: a, to: b });
+schema.add(Mapping, { label: "g", from: a, to: c });
+
+for (const cell of schema.cellsOf(EntityShape)) {
+    console.log(cell.label);
+}
+```
+
+```
+A
+C
+g
+```
+
+#### Further shape examples
+
+##### Implementing a list shape
+
+Here is a complete example that accepts morphisms with lists as domain and
+codomain of all the variants we currently have defined.
+
+<details>
+
+<summary>Code example</summary>
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { defineMorphism, defineObject, defineShape, type Notebook } from "catcolab-documents";
+
+const BasicObj = defineObject({ tag: "Basic", content: "Object" });
+
+const tensor = { tag: "Basic", content: "tensor" } as const;
+
+const ListMor = defineMorphism(
+    { tag: "Hom", content: BasicObj.obType },
+    {
+        domain: { apply: tensor, modality: "List" },
+        codomain: { apply: tensor, modality: "List" },
+    },
+);
+
+const ListShape = defineShape({
+    objects: [BasicObj],
+    morphisms: [ListMor],
+});
+
+const SymmetricListMor = defineMorphism(
+    { tag: "Hom", content: BasicObj.obType },
+    {
+        domain: { apply: tensor, modality: "SymmetricList" },
+        codomain: { apply: tensor, modality: "SymmetricList" },
+    },
+);
+const SymmetricListShape = defineShape({
+    objects: [BasicObj],
+    morphisms: [SymmetricListMor],
+});
+
+const CocartesianListMor = defineMorphism(
+    { tag: "Hom", content: BasicObj.obType },
+    {
+        domain: { apply: tensor, modality: "CocartesianList" },
+        codomain: { apply: tensor, modality: "CocartesianList" },
+    },
+);
+
+const CocartesianListShape = defineShape({
+    objects: [BasicObj],
+    morphisms: [CocartesianListMor],
+});
+
+const CartesianListMor = defineMorphism(
+    { tag: "Hom", content: BasicObj.obType },
+    {
+        domain: { apply: tensor, modality: "CartesianList" },
+        codomain: { apply: tensor, modality: "CartesianList" },
+    },
+);
+
+const CartesianListShape = defineShape({
+    objects: [BasicObj],
+    morphisms: [CartesianListMor],
+});
+
+const AdditiveListMor = defineMorphism(
+    { tag: "Hom", content: BasicObj.obType },
+    {
+        domain: { apply: tensor, modality: "AdditiveList" },
+        codomain: { apply: tensor, modality: "AdditiveList" },
+    },
+);
+
+const AdditiveListShape = defineShape({
+    objects: [BasicObj],
+    morphisms: [AdditiveListMor],
+});
+```
+
+<!-- verifier:prepend-to-following -->
+
+`addListMorphism` works on any notebook that supports any of the morphisms our
+list shapes support. When implementing a generic consumer like this we need to
+narrow down what object and morphism types the notebook actually supports by
+using `notebook.supports`.
+
+```ts
+type NotebookOfLists = Notebook<
+    | typeof ListShape
+    | typeof SymmetricListShape
+    | typeof CocartesianListShape
+    | typeof CartesianListShape
+    | typeof AdditiveListShape
+>;
+
+function addListMorphism(notebook: NotebookOfLists) {
+    const a = notebook.add(BasicObj, { label: "A" });
+    const b = notebook.add(BasicObj, { label: "B" });
+    const c = notebook.add(BasicObj, { label: "C" });
+
+    if (notebook.supports(ListMor)) {
+        notebook.add(ListMor, { label: "L", from: [a, b], to: [c] });
+    } else if (notebook.supports(SymmetricListMor)) {
+        console.log("Adding SymmetricListMor!");
+        notebook.add(SymmetricListMor, { label: "L", from: [a, b], to: [c] });
+    } else if (notebook.supports(CocartesianListMor)) {
+        notebook.add(CocartesianListMor, { label: "L", from: [a, b], to: [c] });
+    } else if (notebook.supports(CartesianListMor)) {
+        notebook.add(CartesianListMor, { label: "L", from: [a, b], to: [c] });
+    } else if (notebook.supports(AdditiveListMor)) {
+        notebook.add(AdditiveListMor, { label: "L", from: [a, b], to: [c] });
+    } else {
+        // If the code type checked this should be unreachable.
+        throw new Error("Did not find any supported List morphism in the notebook.");
+    }
+}
+```
+
+```ts
+function badAddListMorphism(notebook: NotebookOfLists) {
+    const a = notebook.add(BasicObj, { label: "A" });
+    const b = notebook.add(BasicObj, { label: "B" });
+    const c = notebook.add(BasicObj, { label: "C" });
+
+    //@ts-expect-error Not all variants support adding a `ListMor`. You need to narrow the type using the `supports` method.
+    notebook.add(ListMor, { label: "L", from: [a, b], to: [c] });
+}
+```
+
+</details>
+
+##### A structurally compatible notebook is accepted and the appropriate morphism is added
+
+<details>
+
+<summary>Code example</summary>
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { binder } from "catcolab-documents";
+import { PetriNet } from "catcolab-logics/petri-net";
+
+const petriNet = await binder.createNotebook(PetriNet, { name: "example" });
+
+addListMorphism(petriNet);
+```
+
+```
+Adding SymmetricListMor!
+```
+
+```ts
+const entityObType = defineObject({ tag: "Basic", content: "Entity" });
+const EntityObjectShape = defineShape({
+    theory: "entity-objects",
+    objects: [entityObType, BasicObj],
+    morphisms: [ListMor],
+});
+
+const entityObjects = await binder.createNotebook(EntityObjectShape, { name: "example" });
+
+addListMorphism(entityObjects);
+```
+
+</details>
+
+##### A structurally incompatible notebook should be rejected
+
+<details>
+
+<summary>Code examples</summary>
+
+```ts
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+
+const simpleOlog = await binder.createNotebook(SimpleOlog, { name: "example" });
+
+// @ts-expect-error A SimpleOlog notebook lacks the list-valued morphisms ListShape requires.
+addListMorphism(simpleOlog);
+```
+
+```ts
+const JustObjectShape = defineShape({
+    theory: "just-objects",
+    objects: [BasicObj],
+});
+
+const justObjects = await binder.createNotebook(JustObjectShape, { name: "example" });
+
+// @ts-expect-error We have no morphisms in `JustObjectShape`.
+addListMorphism(justObjects);
+```
+
+```ts
+const JustMorphismShape = defineShape({
+    theory: "just-morphisms",
+    morphisms: [ListMor],
+});
+
+const justMorphisms = await binder.createNotebook(JustMorphismShape, { name: "example" });
+
+// @ts-expect-error We have no objects in `JustMorphismShape`.
+addListMorphism(justMorphisms);
+```
+
+```ts
+const EntityObj = defineObject({ tag: "Basic", content: "Entity" });
+
+const EntityListMor = defineMorphism(
+    { tag: "Hom", content: EntityObj.obType },
+    {
+        domain: { apply: tensor, modality: "List" },
+        codomain: { apply: tensor, modality: "List" },
+    },
+);
+
+const MultiObjectListShape = defineShape({
+    objects: [BasicObj, EntityObj],
+    morphisms: [ListMor, EntityListMor],
+});
+
+function badAddListMorphism2(notebook: Notebook<typeof MultiObjectListShape>) {
+    const a = notebook.add(BasicObj, { label: "A" });
+    const b = notebook.add(BasicObj, { label: "B" });
+    const e = notebook.add(EntityObj, { label: "E" });
+
+    notebook.add(ListMor, { label: "L1", from: [a, b], to: [b] });
+    //@ts-expect-error We can't use an EntityObj with a ListMor
+    notebook.add(ListMor, { label: "L2", from: [a, b], to: [e] });
+}
+```
+
+```ts
+const entityObType = defineObject({ tag: "Basic", content: "Entity" });
+
+const entityListMorType = defineMorphism(
+    { tag: "Hom", content: entityObType.obType },
+    {
+        domain: { apply: tensor, modality: "List" },
+        codomain: { apply: tensor, modality: "List" },
+    },
+);
+
+const EntityObjectListShape = defineShape({
+    objects: [entityObType],
+    morphisms: [entityListMorType],
+});
+
+type NotebookOfListsWithEntity = Notebook<
+    | typeof ListShape
+    | typeof SymmetricListShape
+    | typeof CocartesianListShape
+    | typeof CartesianListShape
+    | typeof AdditiveListShape
+    | typeof EntityObjectListShape
+>;
+
+const EntityObj = entityObType;
+
+function goodAddObject(notebook: NotebookOfListsWithEntity) {
+    if (notebook.supports(BasicObj)) {
+        notebook.add(BasicObj, { label: "A" });
+    }
+
+    if (notebook.supports(EntityObj)) {
+        notebook.add(EntityObj, { label: "E" });
+    }
+}
+
+const BothObjectsShape = defineShape({
+    objects: [BasicObj, entityObType],
+});
+
+function goodAddObject2(notebook: NotebookOfListsWithEntity) {
+    if (notebook.supports(BothObjectsShape)) {
+        notebook.add(BasicObj, { label: "A" });
+        notebook.add(EntityObj, { label: "E" });
+    }
+}
+
+type JustEntityObjectListShape = Notebook<typeof EntityObjectListShape>;
+
+function goodAddObject3(notebook: JustEntityObjectListShape) {
+    notebook.add(EntityObj, { label: "E" });
+}
+
+function badAddObject(notebook: NotebookOfListsWithEntity) {
+    //@ts-expect-error We can't add a BasicObj without narrowing the notebook type because EntityObjectListShape does not support BasicObj.
+    notebook.add(BasicObj, { label: "A" });
+
+    //@ts-expect-error We can't add a EntityObj without narrowing the notebook type because not all notebooks support EntityObj.
+    notebook.add(EntityObj, { label: "E" });
+}
+
+function badAddObject2(notebook: Notebook<typeof BothObjectsShape>) {
+    const a = notebook.add(BasicObj, { label: "A" });
+    const b = notebook.add(BasicObj, { label: "B" });
+
+    //@ts-expect-error BothObjectsShape can never support CocartesianListMor.
+    if (notebook.supports(CocartesianListMor)) {
+        //@ts-expect-error BothObjectsShape does not support CocartesianListMor.
+        notebook.add(CocartesianListMor, { label: "L", from: [a, b], to: [b] });
+    }
+}
+```
+
+</details>
+
+#### Use with SolidJS
+
+##### Shape consumer
+
+We can define the shape our components consume.
+
+<details>
+
+<summary>Code example</summary>
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+import {
+    type NotebookCell,
+    CellKind,
+    createBinder,
+    defineMorphism,
+    defineObject,
+    type DocumentStore,
+    type Notebook,
+    defineShape,
+    RichText,
+} from "catcolab-documents";
+import { PetriNet, Place, Transition } from "catcolab-logics/petri-net";
+import { For } from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { render } from "solid-js/web";
+
+import type { Document } from "catcolab-document-types";
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStoreIds = new WeakMap<SolidStoreHandle, string>();
+const solidStoreIdFor = (handle: SolidStoreHandle): string => {
+    let id = solidStoreIds.get(handle);
+    if (!id) {
+        id = crypto.randomUUID();
+        solidStoreIds.set(handle, id);
+    }
+    return id;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    getDocumentRef: (handle) => ({ id: solidStoreIdFor(handle), version: null, server: "" }),
+    // Link resolution omitted for brevity.
+    getHandle: async () => ({
+        tag: "Err",
+        content: [{ message: "This store cannot resolve references." }],
+    }),
+};
+
+const solidBinder = createBinder(solidStore);
+
+const basicObject = defineObject({ tag: "Basic", content: "Object" });
+const symmetricListMorphism = defineMorphism(
+    { tag: "Hom", content: basicObject.obType },
+    {
+        domain: { apply: { tag: "Basic", content: "tensor" }, modality: "SymmetricList" },
+        codomain: { apply: { tag: "Basic", content: "tensor" }, modality: "SymmetricList" },
+    },
+);
+
+type BasicObCell = NotebookCell<typeof basicObject>;
+type SymmetricListCell = NotebookCell<typeof symmetricListMorphism>;
+
+const GenericShape = defineShape({
+    objects: [basicObject],
+    morphisms: [symmetricListMorphism],
+    informal: [RichText],
+});
+
+function ObListEditor(props: { objects: BasicObCell[] }) {
+    return <span>[{props.objects.map((place) => place.label).join(", ")}]</span>;
+}
+
+function MorphismCellEditor(props: {
+    notebook: Notebook<typeof GenericShape>;
+    morphism: SymmetricListCell;
+}) {
+    // Contrived test example: adding an arbitrary but valid input place
+    const runTestMutation = () => {
+        const referenced = new Set(
+            [...props.morphism.from, ...props.morphism.to].map((ob) => ob.id),
+        );
+        const input = props.notebook.cellsOf(basicObject).find((ob) => !referenced.has(ob.id));
+        if (input) {
+            props.morphism.update({ from: [...props.morphism.from, input] });
+        }
+    };
+    return (
+        <li>
+            <span class="cell-label">
+                Transition: <ObListEditor objects={props.morphism.from} />
+                <span> -&gt; </span>
+                <ObListEditor objects={props.morphism.to} />
+                <span>{props.morphism.label}</span>
+            </span>
+            <button aria-label="run test mutation" onClick={runTestMutation} />
+        </li>
+    );
+}
+
+function ModelCellEditor(props: {
+    notebook: Notebook<typeof GenericShape>;
+    cell: NotebookCell<typeof GenericShape>;
+}) {
+    const cell = props.cell;
+    if (cell.kind === CellKind.Morphism) {
+        return <MorphismCellEditor notebook={props.notebook} morphism={cell} />;
+    }
+    if (cell.kind === CellKind.Object) {
+        return (
+            <li>
+                <span class="cell-label">Place: {cell.label}</span>
+            </li>
+        );
+    }
+    if (cell.kind === CellKind.RichText) {
+        return (
+            <li>
+                <span class="cell-label">Text: {cell.content}</span>
+            </li>
+        );
+    }
+    return null;
+}
+
+function ModelNotebookEditor(props: { notebook: Notebook<typeof GenericShape> }) {
+    return (
+        <section>
+            <h1>{props.notebook.name}</h1>
+            <ul>
+                <For each={props.notebook.cellsOf(GenericShape)}>
+                    {(cell) => <ModelCellEditor notebook={props.notebook} cell={cell} />}
+                </For>
+            </ul>
+        </section>
+    );
+}
+```
+
+```tsx
+const notebook = await solidBinder.createNotebook(PetriNet, { name: "Petri net" });
+const a = notebook.add(Place, { label: "A" });
+notebook.add(Place, { label: "B" });
+const c = notebook.add(Place, { label: "C" });
+notebook.add(Transition, { label: "fires", from: [a], to: [c] });
+
+const container = document.createElement("div");
+document.body.appendChild(container);
+
+const dispose = render(() => <ModelNotebookEditor notebook={notebook} />, container);
+
+console.log(container.innerHTML);
+
+const appendButton = container.querySelector<HTMLButtonElement>(
+    '[aria-label="run test mutation"]',
+)!;
+appendButton.click();
+console.log(container.innerHTML);
+
+dispose();
+```
+
+```
+<section><h1>Petri net</h1><ul><li><span class="cell-label">Place: A</span></li><li><span class="cell-label">Place: B</span></li><li><span class="cell-label">Place: C</span></li><li><span class="cell-label">Transition: <span>[A<!---->]</span><span> -&gt; </span><span>[C<!---->]</span><span>fires</span></span><button aria-label="run test mutation"></button></li></ul></section>
+<section><h1>Petri net</h1><ul><li><span class="cell-label">Place: A</span></li><li><span class="cell-label">Place: B</span></li><li><span class="cell-label">Place: C</span></li><li><span class="cell-label">Transition: <span>[A, B<!---->]</span><span> -&gt; </span><span>[C<!---->]</span><span>fires</span></span><button aria-label="run test mutation"></button></li></ul></section>
+```
+
+</details>
+
+##### SolidJS example with validation & completions
+
+Wiring in the validated model through the components for completions looks
+something like this, using `onValidate` to feed a signal with validation
+results. Future work could be to bring the validated model API closer to our
+notebook API.
+
+<details>
+
+<summary> Code example </summary>
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+import {
+    type NotebookCell,
+    CellKind,
+    createBinder,
+    defineMorphism,
+    defineObject,
+    defineShape,
+    type DocumentStore,
+    type ModelValidationResult,
+    type Notebook,
+    RichText,
+    type ValidatableNotebook,
+} from "catcolab-documents";
+import {
+    createContext,
+    createSignal,
+    For,
+    onCleanup,
+    Show,
+    useContext,
+    type Accessor,
+} from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { render } from "solid-js/web";
+
+import type { Document } from "catcolab-document-types";
+import type { DblModel, ObType, QualifiedName } from "catlog-wasm";
+import { selfResolving } from "document-methods/test/self_resolving";
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    ...selfResolving<SolidStoreHandle>(),
+};
+
+const solidBinder = createBinder(solidStore);
+```
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+const MyEntity = defineObject({ tag: "Basic", content: "Entity" });
+const MyAttrType = defineObject({ tag: "Basic", content: "AttrType" });
+const MyAttr = defineMorphism(
+    { tag: "Basic", content: "Attr" },
+    { domain: MyEntity.obType, codomain: MyAttrType.obType },
+);
+
+const MyShape = defineShape({
+    objects: [MyEntity, MyAttrType],
+    morphisms: [MyAttr],
+    informal: [RichText],
+});
+
+type MyNotebook = Notebook<typeof MyShape>;
+```
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+function label(model: DblModel, id: QualifiedName): string {
+    return model.obGeneratorLabel(id)?.join(".") ?? "?";
+}
+
+function filteredCompletions(model: DblModel, obType: ObType, text: string): QualifiedName[] {
+    const needle = text.toLowerCase();
+    return model
+        .obGeneratorsWithType(obType)
+        .filter((id) => label(model, id).toLowerCase().includes(needle));
+}
+
+function codomainLabel(model: DblModel | undefined, morphism: NotebookCell<typeof MyAttr>): string {
+    if (!model) {
+        return "?";
+    }
+    const cod = model?.morPresentation(morphism.id)?.cod;
+    return cod?.tag === "Basic" ? label(model, cod.content) : "?";
+}
+```
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+type MyContextValue = {
+    notebook: MyNotebook;
+    model: Accessor<DblModel>;
+};
+
+const MyContext = createContext<MyContextValue>();
+
+function useMyContext() {
+    const context = useContext(MyContext);
+    if (!context) {
+        throw new Error("Schema editor context is missing.");
+    }
+    return context;
+}
+
+function selectCodomain(
+    notebook: MyNotebook,
+    attrCell: NotebookCell<typeof MyAttr>,
+    id: QualifiedName,
+) {
+    const result = notebook.get(MyAttrType, id);
+    if (result.tag === "Ok") {
+        attrCell.update({ to: result.content });
+    }
+}
+
+function CompletionPicker(props: {
+    obType: ObType;
+    selected: string;
+    text: Accessor<string>;
+    onSelect: (id: QualifiedName) => void;
+}) {
+    const context = useMyContext();
+    return (
+        <span class="picker">
+            <span class="selected">{props.selected}</span>
+            <ul class="completion-list">
+                <For each={filteredCompletions(context.model(), props.obType, props.text())}>
+                    {(id) => (
+                        <li onClick={() => props.onSelect(id)}>{label(context.model(), id)}</li>
+                    )}
+                </For>
+            </ul>
+        </span>
+    );
+}
+
+function MyAttrCellEditor(props: {
+    attrCell: NotebookCell<typeof MyAttr>;
+    text: Accessor<string>;
+}) {
+    const context = useMyContext();
+    return (
+        <li>
+            Attr: {props.attrCell.label}: {props.attrCell.from.label} -&gt;{" "}
+            <CompletionPicker
+                obType={MyAttrType.obType}
+                selected={codomainLabel(context.model(), props.attrCell)}
+                text={props.text}
+                onSelect={(id) => selectCodomain(context.notebook, props.attrCell, id)}
+            />
+        </li>
+    );
+}
+
+function MyCellEditor(props: { cell: NotebookCell<typeof MyShape>; text: Accessor<string> }) {
+    if (props.cell.kind === CellKind.Morphism) {
+        return <MyAttrCellEditor attrCell={props.cell} text={props.text} />;
+    }
+    if (props.cell.kind === CellKind.Object) {
+        const kind = props.cell.type === MyAttrType ? "MyAttrType" : "MyEntity";
+        return (
+            <li>
+                {kind}: {props.cell.label}
+            </li>
+        );
+    }
+    if (props.cell.kind === CellKind.RichText) {
+        return <li>Text: {props.cell.content}</li>;
+    }
+    return null;
+}
+
+// Globals for testing
+let testCurrentModel!: () => DblModel | undefined;
+
+function MyNotebookEditor(props: {
+    notebook: MyNotebook & ValidatableNotebook;
+    text: Accessor<string>;
+}) {
+    // `onValidate` delivers an initial result and then re-validates whenever
+    // anything the validation depends on changes, notifying only when the
+    // result actually changed.
+    const [validation, setValidation] = createSignal<ModelValidationResult>();
+    const unsubscribe = props.notebook.onValidate(setValidation);
+    onCleanup(unsubscribe);
+
+    const model = () => {
+        const result = validation();
+        return result?.tag === "Ok" ? result.content : undefined;
+    };
+
+    testCurrentModel = model;
+
+    return (
+        <section>
+            <h1>{props.notebook.name}</h1>
+            <Show when={model()} fallback={<p>Validating...</p>}>
+                {(m) => (
+                    <MyContext.Provider value={{ notebook: props.notebook, model: m }}>
+                        <ul>
+                            <For each={props.notebook.cellsOf(MyShape)}>
+                                {(cell) => <MyCellEditor cell={cell} text={props.text} />}
+                            </For>
+                        </ul>
+                    </MyContext.Provider>
+                )}
+            </Show>
+        </section>
+    );
+}
+```
+
+```tsx
+import { Attr, AttrType, Entity, SimpleSchema } from "catcolab-logics/simple-schema";
+async function until(predicate: () => boolean) {
+    while (!predicate()) {
+        await new Promise((resolve) => setTimeout(resolve));
+    }
+}
+
+const notebook = await solidBinder.createNotebook(SimpleSchema, { name: "Company schema" });
+const person = notebook.add(Entity, { label: "Person" });
+const string = notebook.add(AttrType, { label: "String" });
+notebook.add(AttrType, { label: "Integer" });
+notebook.add(AttrType, { label: "Boolean" });
+const name = notebook.add(Attr, { label: "name", from: person, to: string });
+
+const [text, setText] = createSignal("");
+const container = document.createElement("div");
+document.body.appendChild(container);
+const dispose = render(() => <MyNotebookEditor notebook={notebook} text={text} />, container);
+
+await until(() => testCurrentModel() !== undefined);
+console.log(
+    "all:",
+    [...container.querySelectorAll(".completion-list li")].map((li) => li.textContent).join(", "),
+);
+console.log("codomain:", codomainLabel(testCurrentModel(), name));
+
+setText("in");
+console.log(
+    "filtered:",
+    [...container.querySelectorAll(".completion-list li")].map((li) => li.textContent).join(", "),
+);
+
+const model = testCurrentModel();
+if (!model) {
+    throw new Error("Expected a valid model.");
+}
+const integer = filteredCompletions(model, MyAttrType.obType, "in").find(
+    (id) => label(model, id) === "Integer",
+)!;
+selectCodomain(notebook, name, integer);
+await until(() => codomainLabel(testCurrentModel(), name) === "Integer");
+console.log("codomain:", codomainLabel(testCurrentModel(), name));
+
+dispose();
+container.remove();
+```
+
+```
+all: String, Integer, Boolean
+codomain: String
+filtered: String, Integer
+codomain: Integer
+```
+
+</details>
+
+### Rich text handling
+
+Rich text is a special case because our editor components will need to bypass
+our notebook interface to work with ProseMirror and the Automerge plugin for
+ProseMirror.
+
+We need to define a `getRichTextRef` method on our store for this to work. This
+will add a `editorRef` field to the RichText cell that our editor component can
+make use of.
+
+<details>
+
+<summary>Code example</summary>
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```tsx
+import * as Automerge from "@automerge/automerge";
+import { type Doc, getBackend, getObjectId, type Patch } from "@automerge/automerge";
+import {
+    type DocHandle,
+    type DocHandleChangePayload,
+    type Prop,
+    Repo,
+} from "@automerge/automerge-repo";
+import { makeDocumentProjection } from "@automerge/automerge-repo-solid-primitives";
+import { basicSchemaAdapter, init } from "@automerge/prosemirror";
+import {
+    createBinder,
+    defineShape,
+    type DocumentStore,
+    RichText,
+    type RichTextCell,
+} from "catcolab-documents";
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+import { EditorState } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import { createEffect, createSignal, onCleanup } from "solid-js";
+import { For, render } from "solid-js/web";
+import { expect } from "vitest";
+
+import type { Document } from "catcolab-document-types";
+
+type StoreHandle = {
+    readonly docHandle: DocHandle<Document>;
+    readonly docView: Document;
+};
+
+function makeAutomergeRichTextStore(): DocumentStore<StoreHandle> {
+    const repo = new Repo();
+    return {
+        createHandle: async (initialDoc) => {
+            const docHandle = repo.create<Document>(initialDoc as Document);
+            return { docHandle, docView: makeDocumentProjection(docHandle) };
+        },
+        getDocumentView: (handle) => handle.docView,
+        changeDocument: (handle, fn) => handle.docHandle.change(fn),
+        subscribe: (handle, callback) => {
+            handle.docHandle.on("change", callback);
+            return () => handle.docHandle.off("change", callback);
+        },
+        copyValue: (handle, value) => {
+            const objId = getObjectId(value as object);
+            return getBackend(handle.docHandle.doc()).materialize(objId!) as typeof value;
+        },
+        getDocumentRef: (handle) => ({
+            id: handle.docHandle.documentId,
+            version: null,
+            server: "",
+        }),
+        getHandle: async () => ({
+            tag: "Err",
+            content: [{ message: "This store cannot resolve references." }],
+        }),
+        // This is needed for the RichTextCellEditor to bypass the notebook interface.
+        getRichTextRef: (handle, cellId) => ({
+            docHandle: handle.docHandle,
+            path: ["notebook", "cellContents", cellId, "content"],
+        }),
+    };
+}
+
+function isPathPrefixOf(candidate: Prop[], target: readonly Prop[]) {
+    return (
+        candidate.length <= target.length &&
+        candidate.every((part, index) => part === target[index])
+    );
+}
+
+function hasStructuralReplacement(patches: Patch[], textPath: readonly Prop[]) {
+    return patches.some(
+        (patch) =>
+            (patch.action === "put" || patch.action === "del") &&
+            isPathPrefixOf(patch.path, textPath),
+    );
+}
+
+function RichTextCellEditor(props: { cell: RichTextCell; onView: (view: EditorView) => void }) {
+    let editorRoot!: HTMLDivElement;
+    const [reinitTrigger, setReinitTrigger] = createSignal(0);
+
+    createEffect(() => {
+        void reinitTrigger();
+
+        // The editorRef is exposed on the cell.
+        const ref = props.cell.editorRef;
+        if (!ref) {
+            throw new Error("RichTextCellEditor: cell has no editorRef");
+        }
+
+        const docHandle = ref.docHandle as DocHandle<unknown>;
+        const path = [...ref.path];
+        const { schema, pmDoc, plugin } = init(docHandle, path, {
+            schemaAdapter: basicSchemaAdapter,
+        });
+        const state = EditorState.create({ schema, plugins: [plugin], doc: pmDoc });
+        const view: EditorView = new EditorView(editorRoot, {
+            state,
+            dispatchTransaction: (tx) => {
+                if (!view.isDestroyed) {
+                    view.updateState(view.state.apply(tx));
+                }
+            },
+        });
+
+        const onRemoteChange = (payload: DocHandleChangePayload<unknown>) => {
+            if (hasStructuralReplacement(payload.patches, path)) {
+                setReinitTrigger((n) => n + 1);
+            }
+        };
+
+        docHandle.on("change", onRemoteChange);
+        props.onView(view);
+        onCleanup(() => {
+            docHandle.off("change", onRemoteChange);
+            view.destroy();
+        });
+    });
+
+    return <div class="rich-text-cell" ref={editorRoot} />;
+}
+```
+
+```tsx
+const InformalShape = defineShape({ informal: [RichText] });
+
+const store = makeAutomergeRichTextStore();
+const frontendBinder = createBinder(store);
+const notebook = await frontendBinder.createNotebook(SimpleOlog, { name: "Notes" });
+const note = notebook.add(RichText, { content: "" });
+
+let view: EditorView | undefined;
+const container = document.createElement("div");
+document.body.appendChild(container);
+const dispose = render(
+    () => (
+        <For each={notebook.cellsOf(InformalShape)}>
+            {(cell) => <RichTextCellEditor cell={cell} onView={(nextView) => (view = nextView)} />}
+        </For>
+    ),
+    container,
+);
+
+view!.dispatch(view!.state.tr.insertText("Hello from ProseMirror"));
+expect(note.content).toBe("Hello from ProseMirror");
+
+const ref = note.editorRef!;
+const docHandle = ref.docHandle as DocHandle<Document>;
+docHandle.change((doc) => {
+    Automerge.splice(doc as Doc<unknown>, [...ref.path], 0, 5, "Howdy");
+});
+expect(view!.state.doc.textContent).toBe("Howdy from ProseMirror");
+
+const staleView = view;
+note.update({ content: "Replaced programmatically" });
+expect(view).not.toBe(staleView);
+expect(staleView?.isDestroyed).toBe(true);
+expect(view!.state.doc.textContent).toBe("Replaced programmatically");
+
+dispose();
+container.remove();
+```
+
+</details>
+
+### Future extensions
+
+#### Path equations
+
+As this RFC is written, path equations are being added to the `simple-olog` and
+`simple-schema` theories in the frontend. `PathEquation` is another cell type,
+with a `CellKind.PathEquation` discriminant, and a shape opts into it via
+`supportsEquations: true`.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { binder, PathEquation } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleSchema, { name: "Example schema" });
+
+const person = notebook.add(Entity, { label: "Person" });
+const department = notebook.add(Entity, { label: "Department" });
+const company = notebook.add(Entity, { label: "Company" });
+
+const worksIn = notebook.add(Mapping, { label: "works in", from: person, to: department });
+const partOf = notebook.add(Mapping, { label: "part of", from: department, to: company });
+const employer = notebook.add(Mapping, { label: "employer", from: person, to: company });
+
+// An employee's employer is the company their department is part of.
+const equation = notebook.add(PathEquation, {
+    label: "employment",
+    lhs: [worksIn, partOf],
+    rhs: [employer],
+});
+```
+
+<details>
+
+<summary>Code verification</summary>
+
+```ts
+console.log("equation:", equation.label);
+console.log("lhs:", equation.lhs.map((step) => step.label).join(" ; "));
+console.log("rhs:", equation.rhs.map((step) => step.label).join(" ; "));
+console.log("equations:", notebook.cellsOf(PathEquation).length);
+
+const result = await notebook.validate();
+console.log("valid:", result.tag === "Ok");
+```
+
+```
+equation: employment
+lhs: works in ; part of
+rhs: employer
+equations: 1
+valid: true
+```
+
+</details>
+
+#### Tabular instances
+
+Tabular instances are being added to CatColab. We can envision an API for
+instances that mirrors our Notebook API.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { binder } from "catcolab-documents";
+import { SimpleSchema, Mapping, Attr, Entity, AttrType } from "catcolab-logics/simple-schema";
+
+const schema = await binder.createNotebook(SimpleSchema, { name: "Company schema" });
+const person = schema.add(Entity, { label: "Person" });
+const company = schema.add(Entity, { label: "Company" });
+const str = schema.add(AttrType, { label: "String" });
+
+const employer = schema.add(Mapping, { label: "employer", from: person, to: company });
+const name = schema.add(Attr, { label: "name", from: person, to: str });
+```
+
+An instance can have a very similar `add` method.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const instance = await binder.createInstance(schema, { name: "Company instance" });
+const acme = instance.add(company, {});
+instance.add(person, { name: "Alice", employer: acme });
+instance.add(person, { name: "Bob", employer: acme });
+```
+
+A "table" could be retrieved via a `rowsOf` that mirrors `cellsOf` though,
+unlike cells it may be better to keep a separate `values` field on rows, to
+keep them in their own namespace.
+
+```ts
+for (const row of instance.rowsOf(person)) {
+    console.log(row.values["name"]);
+}
+```
+
+```
+Alice
+Bob
+```
+
+Our API could in principle allow us to define logic shapes as notebooks of
+`SimpleSchema`. To illustrate this here is the `SimpleSchema` logic defined as
+a notebook of `SimpleSchema` by aliasing the real `SimpleSchema` to
+`SuperSchema` first.
+
+<!-- verifier:reset -->
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import {
+    Attr as SuperAttr,
+    AttrType as SuperAttrType,
+    Entity as SuperEntity,
+    Mapping as SuperMapping,
+    SimpleSchema as SuperSchema,
+} from "catcolab-logics/simple-schema";
+import { binder } from "catcolab-documents";
+const SimpleSchema = await binder.createNotebook(SuperSchema, { name: "simple-schema" });
+
+const Entity = SimpleSchema.add(SuperEntity, { label: "Entity" });
+const AttrType = SimpleSchema.add(SuperEntity, { label: "AttrType" });
+const String = SimpleSchema.add(SuperAttrType, { label: "String" });
+
+const Mapping = SimpleSchema.add(SuperEntity, { label: "Mapping" });
+SimpleSchema.add(SuperMapping, { label: "from", from: Mapping, to: Entity });
+SimpleSchema.add(SuperMapping, { label: "to", from: Mapping, to: Entity });
+SimpleSchema.add(SuperAttr, { label: "label", from: Mapping, to: String });
+
+const Attr = SimpleSchema.add(SuperEntity, { label: "Attr" });
+SimpleSchema.add(SuperMapping, { label: "from", from: Attr, to: Entity });
+SimpleSchema.add(SuperMapping, { label: "to", from: Attr, to: AttrType });
+SimpleSchema.add(SuperAttr, { label: "label", from: Entity, to: String });
+```
+
+Schemas can can then be defined as instances of the `SimpleSchema` notebook as
+follows.
+
+```ts
+const schema = await binder.createInstance(SimpleSchema, { name: "Company schema" });
+
+const person = schema.add(Entity, { label: "Person" });
+const company = schema.add(Entity, { label: "Company" });
+const str = schema.add(AttrType, { label: "String" });
+
+const employer = schema.add(Mapping, { label: "employer", from: person, to: company });
+const name = schema.add(Attr, { label: "name", from: person, to: str });
+```
+
+To use this flexibility for defining logics through notebooks in practice a lot
+of details would still need to be worked out of course.
+
+#### Validated models
+
+There is some awkwardness in the discrepancy between the validated model and
+the corresponding notebook. While we can clearly define the shape of the
+notebook we are working with, when it comes to querying the validated model we
+just have a `DblModel` and its associated methods that don't let us work with
+the same shapes and formal content types we have already defined.
+
+This can be seen in the [SolidJS example with validation &
+completions](#solidjs-example-with-validation-completions) in e.g. this
+extract:
+
+<!-- verifier:skip -->
+
+```ts
+function label(model: DblModel, id: QualifiedName): string {
+    return model.obGeneratorLabel(id)?.join(".") ?? "?";
+}
+
+function filteredCompletions(model: DblModel, obType: ObType, text: string): QualifiedName[] {
+    const needle = text.toLowerCase();
+    return model
+        .obGeneratorsWithType(obType)
+        .filter((id) => label(model, id).toLowerCase().includes(needle));
+}
+
+function codomainLabel(model: DblModel | undefined, morphism: NotebookCell<typeof MyAttr>): string {
+    if (!model) {
+        return "?";
+    }
+    const cod = model?.morPresentation(morphism.id)?.cod;
+    return cod?.tag === "Basic" ? label(model, cod.content) : "?";
+}
+```
+
+We can instead imagine passing around a validated model that is
+aware of the underlying shape of the formal content and could be queried
+similar to how our notebooks can be queried.
+
+<!-- verifier:skip -->
+
+```ts
+const model: ValidatedModel<typeof SimpleSchema> = await notebook.validate();
+
+for (const mapping of model.judgmentsOf(Mapping)) {
+    console.log(mapping.label);
+    console.log(mapping.from);
+    console.log(mapping.to);
+}
+```
+
+### Rollout
+
+Our implementation should loosely follow these steps.
+
+1. **Test suite for model notebooks**
+
+    We will implement the tests first. This very document forms part of a spec
+    we can test against. We should write some more tests covering further
+    feature details and edge cases. If possible we should implement property
+    based tests that show our new API will not cause document corruption.
+
+2. **Package for model notebooks**
+
+    A package that meets the spec outline in the test suite. We will not
+    implement diagram or analysis notebooks initially.
+
+3. **CatColab script execution**
+
+    Our initial feature will be a way, possibly through a secret "developer"
+    interface, a user can write Javascript that makes use of this API to create
+    and edit model notebooks.
+
+4. **LLM integration in CatColab**
+
+    Our LLM integration should make use of the CatColab scripting capability to
+    build out a way for users to use LLMs to write scripts.
+
+5. **Test suite & implement analyses and diagrams**
+
+    We will spec and implement a package for analyses and add diagram capability
+    to the relevant models. These will become available to the script execution
+    and LLM integration.
+
+6. **New features use the API & port existing features**
+
+    Once we have proven the stability and usefuleness of the new API we should
+    dictate that any new features need to be made using the new API. We will
+    also begin the process of porting existing features to the new API.
diff --git a/packages/document-methods/test/richtext.test.ts b/packages/document-methods/test/richtext.test.ts
new file mode 100644
index 000000000..9ae0b0ad6
--- /dev/null
+++ b/packages/document-methods/test/richtext.test.ts
@@ -0,0 +1,155 @@
+import * as Automerge from "@automerge/automerge";
+import { type Doc, getBackend, getObjectId } from "@automerge/automerge";
+import { type DocHandle, Repo } from "@automerge/automerge-repo";
+import { makeDocumentProjection } from "@automerge/automerge-repo-solid-primitives";
+import {
+    createBinder,
+    defineShape,
+    type DocumentStore,
+    plainStore,
+    RichText,
+    type RichTextRef,
+} from "catcolab-documents";
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+import { describe, expect, test } from "vitest";
+
+import type { Document } from "catcolab-document-types";
+
+function materializeFromAutomerge<T>(doc: Doc<unknown>, subtree: T): T {
+    const objId = getObjectId(subtree as object);
+    return getBackend(doc).materialize(objId!) as T;
+}
+
+type SolidAutomergeHandle = {
+    readonly docHandle: DocHandle<Document>;
+    readonly docView: Document;
+};
+
+type RichTextDocumentStore<Handle> = DocumentStore<Handle> & {
+    getRichTextRef(handle: Handle, cellId: string): RichTextRef | undefined;
+};
+
+/** An Automerge-backed store with the one rich-text capability: the
+ * editor-binding `getRichTextRef`. Programmatic replaces need no dedicated
+ * hook — Automerge stores strings assigned inside a change function as text
+ * objects, so the generic `changeDocument` path already preserves text-object
+ * semantics. */
+function makeAutomergeStore() {
+    const repo = new Repo();
+    const store: RichTextDocumentStore<SolidAutomergeHandle> = {
+        createHandle: async (initialDoc) => {
+            const docHandle = repo.create<Document>(initialDoc as Document);
+            return {
+                docHandle,
+                docView: makeDocumentProjection(docHandle),
+            };
+        },
+        getDocumentView: (handle) => handle.docView,
+        changeDocument: (handle, fn) => handle.docHandle.change(fn),
+        subscribe: (handle, callback) => {
+            handle.docHandle.on("change", callback);
+            return () => handle.docHandle.off("change", callback);
+        },
+        copyValue: (handle, value) => materializeFromAutomerge(handle.docHandle.doc(), value),
+        getDocumentRef: (handle) => ({
+            id: handle.docHandle.documentId,
+            version: null,
+            server: "",
+        }),
+        getHandle: async () => ({
+            tag: "Err",
+            content: [{ message: "This store cannot resolve references." }],
+        }),
+        getRichTextRef: (handle, cellId) => ({
+            docHandle: handle.docHandle,
+            path: ["notebook", "cellContents", cellId, "content"],
+        }),
+    };
+    return store;
+}
+
+const InformalShape = defineShape({ informal: [RichText] });
+
+describe("RichText", () => {
+    test("Automerge-backed rich-text replaces go through the generic change path", async () => {
+        const store = makeAutomergeStore();
+
+        const binder = createBinder(store);
+        const notebook = await binder.createNotebook(SimpleOlog, { name: "Rich text" });
+        const note = notebook.add(RichText, { content: "" });
+
+        const [cell] = notebook.cellsOf(InformalShape);
+        expect(cell).toBeDefined();
+        if (!cell) {
+            throw new Error("Expected informal shape to select the rich-text cell.");
+        }
+        expect(cell.id).toBe(note.id);
+
+        cell.update({ content: "Replaced through the generic change path" });
+        expect(note.content).toBe("Replaced through the generic change path");
+
+        const storedCell = notebook.handle.docHandle.doc().notebook.cellContents[note.id];
+        expect(storedCell?.tag).toBe("rich-text");
+        expect(storedCell?.content).toBe("Replaced through the generic change path");
+
+        // The replaced field is still an Automerge text object — a string
+        // assigned inside a change function is stored as text — so it stays
+        // spliceable at the editor ref's path after the replace.
+        const ref = note.editorRef;
+        expect(ref).toBeDefined();
+        const docHandle = ref!.docHandle as DocHandle<Document>;
+        docHandle.change((doc) => {
+            Automerge.splice(doc as Doc<unknown>, [...ref!.path], 0, 8, "Swapped");
+        });
+        expect(note.content).toBe("Swapped through the generic change path");
+    });
+
+    test("editorRef exposes the store-native binding for incremental edits", async () => {
+        const store = makeAutomergeStore();
+
+        const binder = createBinder(store);
+        const notebook = await binder.createNotebook(SimpleOlog, { name: "Rich text" });
+        const note = notebook.add(RichText, { content: "" });
+
+        const ref = note.editorRef;
+        expect(ref).toBeDefined();
+        if (!ref) {
+            throw new Error("Expected the Automerge store to provide an editor ref.");
+        }
+        expect(ref.docHandle).toBe(notebook.handle.docHandle);
+        expect(ref.path).toEqual(["notebook", "cellContents", note.id, "content"]);
+
+        // Simulate what `@automerge/prosemirror` does with the binding: emit
+        // incremental splices at the ref's path per keystroke, never routing
+        // through the notebook handle or replacing the text object.
+        let notifications = 0;
+        const unsubscribe = store.subscribe(notebook.handle, () => {
+            notifications += 1;
+        });
+        const docHandle = ref.docHandle as DocHandle<Document>;
+        docHandle.change((doc) => {
+            Automerge.splice(doc as Doc<unknown>, [...ref.path], 0, 0, "Hello");
+        });
+        docHandle.change((doc) => {
+            Automerge.splice(doc as Doc<unknown>, [...ref.path], 5, 0, ", world");
+        });
+        unsubscribe();
+
+        expect(note.content).toBe("Hello, world");
+        expect(notifications).toBeGreaterThanOrEqual(1);
+    });
+
+    test("plain store falls back to replace-only rich text without an editor ref", async () => {
+        const binder = createBinder(plainStore);
+        const notebook = await binder.createNotebook(SimpleOlog, { name: "Plain rich text" });
+        const note = notebook.add(RichText, { content: "start" });
+
+        // The plain store defines no rich-text capability.
+        expect(note.editorRef).toBeUndefined();
+
+        note.update({ content: "replaced" });
+        expect(note.content).toBe("replaced");
+        const [cell] = notebook.cellsOf(InformalShape);
+        expect(cell?.content).toBe("replaced");
+    });
+});
diff --git a/packages/document-methods/test/richtext_frontend_editor.test.tsx b/packages/document-methods/test/richtext_frontend_editor.test.tsx
new file mode 100644
index 000000000..1d59cc522
--- /dev/null
+++ b/packages/document-methods/test/richtext_frontend_editor.test.tsx
@@ -0,0 +1,260 @@
+// A realistic frontend integration for rich-text cells: the exact wiring of
+// the frontend's `RichTextEditor` (packages/frontend/src/components/
+// rich_text_editor/rich_text_editor.tsx), but sourcing the Automerge binding
+// from `cell.editorRef` instead of hand-threading `handle` + `path` props
+// through the notebook UI (as notebook_editor.tsx:382 / notebook_cell.tsx:308
+// do today).
+//
+// The frontend's rich-text data flow is *not* "mutate through a change
+// function": ProseMirror is bound directly to the Automerge document by
+// `@automerge/prosemirror`'s sync plugin, which emits per-keystroke splices on
+// the text object and applies remote patches back into the editor. The store
+// abstraction supports that with `getRichTextRef`, which hands the editor the
+// store's `DocHandle` plus the path to the cell's text object. This file shows
+// the three flows a frontend needs:
+//
+//   1. Typing in the editor lands in the document, readable reactively through
+//      the notebook handle (`cell.content`).
+//   2. A collaborator's incremental edit (a splice arriving on the same
+//      `DocHandle`) flows back into the live editor through the sync plugin.
+//   3. A coarse programmatic replace (`cell.update({ content })`, routed
+//      through the generic `changeDocument`) structurally replaces the text
+//      object; the editor detects that — the frontend's
+//      `hasStructuralReplacement` reinit path (rich_text_editor.tsx:283, 517)
+//      — and reinitializes.
+/* oxlint-disable unicorn/consistent-function-scoping */
+import * as Automerge from "@automerge/automerge";
+import { type Doc, getBackend, getObjectId, type Patch } from "@automerge/automerge";
+import {
+    type DocHandle,
+    type DocHandleChangePayload,
+    type Prop,
+    Repo,
+} from "@automerge/automerge-repo";
+import { makeDocumentProjection } from "@automerge/automerge-repo-solid-primitives";
+import { basicSchemaAdapter, init } from "@automerge/prosemirror";
+import {
+    createBinder,
+    defineShape,
+    type DocumentStore,
+    RichText,
+    type RichTextCell,
+} from "catcolab-documents";
+import { SimpleOlog } from "catcolab-logics/simple-olog";
+import { EditorState } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import { createEffect, createSignal, onCleanup } from "solid-js";
+import { For, render } from "solid-js/web";
+import { describe, expect, test } from "vitest";
+
+import type { Document } from "catcolab-document-types";
+
+function materializeFromAutomerge<T>(doc: Doc<unknown>, subtree: T): T {
+    const objId = getObjectId(subtree as object);
+    return getBackend(doc).materialize(objId!) as T;
+}
+
+// ---------------------------------------------------------------------------
+// The store: Solid + Automerge, as the frontend would implement it. The one
+// rich-text capability is the point of this file:
+//
+//   * `getRichTextRef` — the editor binding. It returns the `DocHandle` the
+//     handle wraps plus the path to the cell's text object, exactly the pair
+//     the frontend's `RichTextEditor` takes as props today.
+//
+// Programmatic replaces (`cell.update({ content })`, for non-editor writes
+// like imports or automation) need no dedicated hook: they route through the
+// generic `changeDocument`, and Automerge stores a string assigned inside a
+// change function as a text object, so the field stays a text object.
+// ---------------------------------------------------------------------------
+type StoreHandle = {
+    readonly docHandle: DocHandle<Document>;
+    readonly docView: Document;
+};
+
+function makeFrontendStore(): DocumentStore<StoreHandle> {
+    const repo = new Repo();
+    return {
+        createHandle: async (initialDoc) => {
+            const docHandle = repo.create<Document>(initialDoc as Document);
+            return { docHandle, docView: makeDocumentProjection(docHandle) };
+        },
+        getDocumentView: (handle) => handle.docView,
+        changeDocument: (handle, fn) => handle.docHandle.change(fn),
+        subscribe: (handle, callback) => {
+            handle.docHandle.on("change", callback);
+            return () => handle.docHandle.off("change", callback);
+        },
+        copyValue: (handle, value) => materializeFromAutomerge(handle.docHandle.doc(), value),
+        getDocumentRef: (handle) => ({
+            id: handle.docHandle.documentId,
+            version: null,
+            server: "",
+        }),
+        getHandle: async () => ({
+            tag: "Err",
+            content: [{ message: "This store cannot resolve references." }],
+        }),
+        getRichTextRef: (handle, cellId) => ({
+            docHandle: handle.docHandle,
+            path: ["notebook", "cellContents", cellId, "content"],
+        }),
+    };
+}
+
+// ---------------------------------------------------------------------------
+// The editor component: the frontend's `RichTextEditor` reduced to its
+// Automerge wiring (no menus, math, or keymaps). Line-for-line correspondence
+// with packages/frontend/src/components/rich_text_editor/rich_text_editor.tsx:
+//
+//   * `init(docHandle, path, { schemaAdapter })` — schema.ts:39. The frontend
+//     passes its custom `SchemaAdapter`; the stock `basicSchemaAdapter` is
+//     used here.
+//   * `EditorState.create` with the returned plugin + `new EditorView` —
+//     rich_text_editor.tsx:162-189. The sync plugin owns both directions:
+//     local transactions become Automerge splices, remote patches become
+//     editor transactions.
+//   * structural-replacement detection + reinit — rich_text_editor.tsx:283,
+//     500-521. `@automerge/prosemirror` skips `put`/`del` patches at the text
+//     path, so a whole-object replacement must reinitialize the editor.
+//
+// The one difference from today's frontend: the component takes the notebook's
+// `RichTextCell` handle and reads `cell.editorRef`, instead of receiving
+// `handle` and `path` threaded down as props.
+// ---------------------------------------------------------------------------
+
+/** True when `candidate` is a prefix of (or equal to) `target`. */
+function isPathPrefixOf(candidate: Prop[], target: readonly Prop[]): boolean {
+    if (candidate.length > target.length) {
+        return false;
+    }
+    for (let i = 0; i < candidate.length; i++) {
+        if (candidate[i] !== target[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/** Detect patches that replace the text object (or an ancestor) wholesale. */
+function hasStructuralReplacement(patches: Patch[], textPath: readonly Prop[]): boolean {
+    return patches.some(
+        (p) => (p.action === "put" || p.action === "del") && isPathPrefixOf(p.path, textPath),
+    );
+}
+
+function RichTextCellEditor(props: {
+    cell: RichTextCell;
+    /** Hands the live view out so the test can type into it. */
+    onView: (view: EditorView) => void;
+}) {
+    let editorRoot!: HTMLDivElement;
+    const [reinitTrigger, setReinitTrigger] = createSignal(0);
+
+    createEffect(() => {
+        void reinitTrigger();
+
+        // The whole point: the binding comes off the cell handle. A store that
+        // cannot bind an editor yields `undefined`, and a real component would
+        // fall back to a read-only rendering with replace-style updates.
+        const ref = props.cell.editorRef;
+        if (!ref) {
+            return;
+        }
+        const docHandle = ref.docHandle as DocHandle<unknown>;
+        const path = [...ref.path];
+
+        const { schema, pmDoc, plugin } = init(docHandle, path, {
+            schemaAdapter: basicSchemaAdapter,
+        });
+        const state = EditorState.create({ schema, plugins: [plugin], doc: pmDoc });
+        const view: EditorView = new EditorView(editorRoot, {
+            state,
+            dispatchTransaction: (tx) => {
+                if (view.isDestroyed) {
+                    return;
+                }
+                view.updateState(view.state.apply(tx));
+            },
+        });
+
+        const onRemoteChange = (payload: DocHandleChangePayload<unknown>) => {
+            if (hasStructuralReplacement(payload.patches, path)) {
+                setReinitTrigger((n) => n + 1);
+            }
+        };
+        docHandle.on("change", onRemoteChange);
+
+        props.onView(view);
+        onCleanup(() => {
+            docHandle.off("change", onRemoteChange);
+            view.destroy();
+        });
+    });
+
+    return <div class="rich-text-cell" ref={editorRoot} />;
+}
+
+const InformalShape = defineShape({ informal: [RichText] });
+
+describe("frontend rich-text editor over the future notebook API", () => {
+    test("typing, collaboration, and programmatic replace through cell.editorRef", async () => {
+        const store = makeFrontendStore();
+        const binder = createBinder(store);
+        const notebook = await binder.createNotebook(SimpleOlog, { name: "Notes" });
+        const note = notebook.add(RichText, { content: "" });
+
+        // Render the notebook's rich-text cells the way notebook_editor.tsx
+        // does, except each editor binds itself through `cell.editorRef`.
+        let view: EditorView | undefined;
+        const container = document.createElement("div");
+        document.body.appendChild(container);
+        const dispose = render(
+            () => (
+                <For each={notebook.cellsOf(InformalShape)}>
+                    {(cell) => <RichTextCellEditor cell={cell} onView={(v) => (view = v)} />}
+                </For>
+            ),
+            container,
+        );
+        expect(view).toBeDefined();
+
+        // 1. Typing: a ProseMirror transaction (what every keystroke becomes)
+        // is turned into Automerge splices by the sync plugin, and surfaces
+        // reactively on the notebook handle — no notebook-side code involved.
+        view!.dispatch(view!.state.tr.insertText("Hello from ProseMirror"));
+        expect(note.content).toBe("Hello from ProseMirror");
+        expect(container.textContent).toContain("Hello from ProseMirror");
+
+        // 2. Collaboration: a remote splice arrives on the same `DocHandle`
+        // (that is what sync delivers). The plugin patches the live editor.
+        const ref = note.editorRef;
+        expect(ref).toBeDefined();
+        const docHandle = ref!.docHandle as DocHandle<Document>;
+        docHandle.change((doc) => {
+            Automerge.splice(doc as Doc<unknown>, [...ref!.path], 0, 5, "Howdy");
+        });
+        expect(note.content).toBe("Howdy from ProseMirror");
+        expect(view!.state.doc.textContent).toBe("Howdy from ProseMirror");
+
+        // 3. Programmatic replace: `cell.update` routes through the generic
+        // `changeDocument`, and assigning a string inside an Automerge change
+        // function structurally replaces the text object (a `put` patch). The
+        // sync plugin skips such patches, so the component's reinit path (the
+        // frontend's `hasStructuralReplacement`) rebuilds the editor around
+        // the new text object.
+        const staleView = view;
+        note.update({ content: "Replaced programmatically" });
+        expect(note.content).toBe("Replaced programmatically");
+        expect(view).not.toBe(staleView); // the editor reinitialized
+        expect(staleView?.isDestroyed).toBe(true);
+        expect(view!.state.doc.textContent).toBe("Replaced programmatically");
+
+        // ...and the reinitialized editor is still live for further typing.
+        view!.dispatch(view!.state.tr.insertText(" and edited", view!.state.doc.content.size - 1));
+        expect(note.content).toBe("Replaced programmatically and edited");
+
+        dispose();
+        container.remove();
+    });
+});
diff --git a/packages/document-methods/test/row-edit.test.ts b/packages/document-methods/test/row-edit.test.ts
new file mode 100644
index 000000000..c5412519f
--- /dev/null
+++ b/packages/document-methods/test/row-edit.test.ts
@@ -0,0 +1,105 @@
+import { binder } from "catcolab-documents";
+import { Attr, AttrType, Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { describe, expect, test } from "vitest";
+
+describe("instance row editing", () => {
+    test("set and delete on rows", async () => {
+        const schema = await binder.createNotebook(SimpleSchema, { name: "S" });
+        const person = schema.add(Entity, { label: "Person" });
+        const company = schema.add(Entity, { label: "Company" });
+        const str = schema.add(AttrType, { label: "String" });
+        const employer = schema.add(Mapping, { label: "employer", from: person, to: company });
+        const nameAttr = schema.add(Attr, { label: "name", from: person, to: str });
+
+        const instance = await binder.createInstance(schema, { name: "I" });
+        const acme = instance.add(company, {});
+        const fred = instance.add(person, {});
+
+        // Setting an attribute records the literal; setting it again replaces it
+        // (rather than accumulating a second value row).
+        fred.set(nameAttr, "Fred");
+        expect(fred.values["name"]).toBe("Fred");
+        fred.set(nameAttr, "Freddy");
+        expect(fred.values["name"]).toBe("Freddy");
+        // The attribute's value rows are never listed as rows of the entity.
+        expect(instance.rowsOf(person).length).toBe(1);
+
+        // Setting a mapping points the row at the target row.
+        fred.set(employer, acme);
+        expect((fred.values["employer"] as { id: string }).id).toBe(acme.id);
+
+        // Clearing an attribute removes its value.
+        fred.set(nameAttr, undefined);
+        expect(fred.values["name"]).toBeUndefined();
+
+        // The instance still validates against its schema after edits.
+        const result = await instance.validate();
+        expect(result.tag).toBe("Valid");
+
+        // Deleting a row removes it (and the value rows its attributes owned).
+        fred.delete();
+        expect(instance.rowsOf(person).length).toBe(0);
+    });
+
+    test("two morphisms sharing a name are read independently by UUID", async () => {
+        const schema = await binder.createNotebook(SimpleSchema, { name: "S" });
+        const person = schema.add(Entity, { label: "Person" });
+        const str = schema.add(AttrType, { label: "String" });
+        // Two distinct attributes with the *same* name: they have distinct UUIDs
+        // but collide in the name-keyed `values` view.
+        const alias1 = schema.add(Attr, { label: "alias", from: person, to: str });
+        const alias2 = schema.add(Attr, { label: "alias", from: person, to: str });
+        expect(alias1.id).not.toBe(alias2.id);
+
+        const instance = await binder.createInstance(schema, { name: "I" });
+        const fred = instance.add(person, {});
+
+        fred.set(alias1, "Freddy");
+        fred.set(alias2, "Fred the Great");
+
+        // UUID-keyed reads keep the two apart.
+        expect(fred.get(alias1)).toBe("Freddy");
+        expect(fred.get(alias2)).toBe("Fred the Great");
+        expect(fred.valuesById[alias1.id]).toBe("Freddy");
+        expect(fred.valuesById[alias2.id]).toBe("Fred the Great");
+
+        // Setting one does not touch the other.
+        fred.set(alias1, "Freddo");
+        expect(fred.get(alias1)).toBe("Freddo");
+        expect(fred.get(alias2)).toBe("Fred the Great");
+
+        // The document stores two independent triples, one per morphism UUID.
+        const aliasTriples = instance.document.entries.filter(
+            (e) => e.subject === fred.id && e.property.tag === "MorphismRef",
+        );
+        expect(aliasTriples.length).toBe(2);
+
+        // Clearing one leaves the other intact.
+        fred.set(alias1, undefined);
+        expect(fred.get(alias1)).toBeUndefined();
+        expect(fred.get(alias2)).toBe("Fred the Great");
+    });
+
+    test("a dangling foreign key makes the instance invalid", async () => {
+        const schema = await binder.createNotebook(SimpleSchema, { name: "S" });
+        const person = schema.add(Entity, { label: "Person" });
+        const company = schema.add(Entity, { label: "Company" });
+        const employer = schema.add(Mapping, { label: "employer", from: person, to: company });
+
+        const instance = await binder.createInstance(schema, { name: "I" });
+        const acme = instance.add(company, {});
+        const fred = instance.add(person, { employer: acme });
+
+        // With the target present the instance validates.
+        expect((await instance.validate()).tag).toBe("Valid");
+
+        // Delete the target row: `fred`'s `employer` foreign key now dangles.
+        acme.delete();
+
+        // The foreign-key triple is retained (pointing at the gone row's id)...
+        expect((fred.get(employer) as { id: string }).id).toBe(acme.id);
+        // ...and validate() reports it rather than silently inferring the missing
+        // codomain object away (which `inferMissingFrom` used to do).
+        expect((await instance.validate()).tag).toBe("Invalid");
+    });
+});
diff --git a/packages/document-methods/test/self_resolving.ts b/packages/document-methods/test/self_resolving.ts
new file mode 100644
index 000000000..a5d227c70
--- /dev/null
+++ b/packages/document-methods/test/self_resolving.ts
@@ -0,0 +1,46 @@
+import type { DocumentStore } from "catcolab-documents";
+import { v7 } from "uuid";
+
+/**
+ * Build the `getDocumentRef`/`getHandle` pair a single-document store needs to
+ * resolve its *own* notebooks — the contract {@link DocumentStore} now requires,
+ * since `validate` resolves a notebook's own model by taking a reference to its
+ * handle. Each handle is assigned a stable id and registered so the shared
+ * recursive elaborator can fetch it back (via `getHandle`, then view its
+ * document with the store's own `getDocumentView`) and elaborate it against the
+ * host notebook's core theory (supplied by `validate`).
+ *
+ * Used by the test fixtures' stores so a no-instantiation notebook validates
+ * (the store can resolve its own handle) without each fixture reimplementing the
+ * recursive elaborator.
+ */
+export function selfResolving<Handle extends WeakKey>(): Pick<
+    DocumentStore<Handle>,
+    "getDocumentRef" | "getHandle"
+> {
+    const ids = new WeakMap<Handle, string>();
+    const byId = new Map<string, Handle>();
+
+    const idFor = (handle: Handle): string => {
+        let id = ids.get(handle);
+        if (!id) {
+            id = v7();
+            ids.set(handle, id);
+            byId.set(id, handle);
+        }
+        return id;
+    };
+
+    return {
+        getDocumentRef: (handle) => ({ id: idFor(handle), version: null, server: "" }),
+        getHandle: async (ref) => {
+            const handle = byId.get(ref.id);
+            return handle
+                ? { tag: "Ok", content: handle }
+                : {
+                      tag: "Err",
+                      content: [{ message: `Cannot resolve reference "${ref.id}".`, path: ["id"] }],
+                  };
+        },
+    };
+}
diff --git a/packages/document-methods/test/shape_completion_picker.test.tsx b/packages/document-methods/test/shape_completion_picker.test.tsx
new file mode 100644
index 000000000..76dac5315
--- /dev/null
+++ b/packages/document-methods/test/shape_completion_picker.test.tsx
@@ -0,0 +1,349 @@
+/* oxlint-disable unicorn/consistent-function-scoping */
+import {
+    type NotebookCell,
+    CellKind,
+    createBinder,
+    defineMorphism,
+    defineObject,
+    defineShape,
+    type DocumentStore,
+    type ModelValidationResult,
+    type Notebook,
+    RichText,
+    type ValidatableNotebook,
+} from "catcolab-documents";
+import { Attr, AttrType, Entity, SimpleSchema } from "catcolab-logics/simple-schema";
+import {
+    createContext,
+    createSignal,
+    For,
+    onCleanup,
+    Show,
+    useContext,
+    type Accessor,
+} from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { render } from "solid-js/web";
+import { describe, expect, test } from "vitest";
+
+import type { Document } from "catcolab-document-types";
+import type { DblModel, ObType, QualifiedName } from "catlog-wasm";
+import { selfResolving } from "./self_resolving";
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    ...selfResolving<SolidStoreHandle>(),
+};
+
+const solidBinder = createBinder(solidStore);
+
+const entity = defineObject({ tag: "Basic", content: "Entity" });
+const attrType = defineObject({ tag: "Basic", content: "AttrType" });
+const attr = defineMorphism(
+    { tag: "Basic", content: "Attr" },
+    { domain: entity.obType, codomain: attrType.obType },
+);
+
+const AttrPickerShape = defineShape({
+    objects: [entity, attrType],
+    morphisms: [attr],
+    informal: [RichText],
+});
+
+type AttrPickerNotebook = Notebook<typeof AttrPickerShape, SolidStoreHandle> &
+    ValidatableNotebook<SolidStoreHandle>;
+
+/** Poll until `predicate` holds (validation results arrive asynchronously). */
+async function until(predicate: () => boolean): Promise<void> {
+    const deadline = Date.now() + 5000;
+    while (!predicate()) {
+        if (Date.now() > deadline) {
+            throw new Error("condition not met in time");
+        }
+        await new Promise((resolve) => setTimeout(resolve));
+    }
+}
+
+function label(model: DblModel, id: QualifiedName): string {
+    return model.obGeneratorLabel(id)?.join(".") ?? "?";
+}
+
+function filteredCompletions(model: DblModel, obType: ObType, text: string): QualifiedName[] {
+    const needle = text.toLowerCase();
+    return model
+        .obGeneratorsWithType(obType)
+        .filter((id) => label(model, id).toLowerCase().includes(needle));
+}
+
+function codomainLabel(model: DblModel | undefined, morphism: NotebookCell<typeof attr>): string {
+    if (!model) {
+        return "?";
+    }
+    const cod = model?.morPresentation(morphism.id)?.cod;
+    return cod?.tag === "Basic" ? label(model, cod.content) : "?";
+}
+
+describe("shape-driven completion picker", () => {
+    test("uses a generic shape with elaborated-model completions", async () => {
+        let validation!: Accessor<ModelValidationResult | undefined>;
+        let model!: () => DblModel | undefined;
+
+        type EditorContextValue = {
+            notebook: AttrPickerNotebook;
+            model: Accessor<DblModel>;
+        };
+        const EditorContext = createContext<EditorContextValue>();
+        const useEditor = () => {
+            const context = useContext(EditorContext);
+            if (!context) {
+                throw new Error("Schema editor context is missing.");
+            }
+            return context;
+        };
+
+        function CompletionPicker(props: {
+            obType: ObType;
+            selected: string;
+            onSelect: (id: QualifiedName) => void;
+        }) {
+            const editor = useEditor();
+            const [text, setText] = createSignal("");
+            const [open, setOpen] = createSignal(true);
+            const [presumptive, setPresumptive] = createSignal(0);
+            const completions = () => filteredCompletions(editor.model(), props.obType, text());
+            const select = (id: QualifiedName) => {
+                props.onSelect(id);
+                setText(label(editor.model(), id));
+                setOpen(false);
+            };
+            const movePresumptive = (delta: number) => {
+                const options = completions();
+                if (options.length === 0) {
+                    return;
+                }
+                setPresumptive((index) => (index + delta + options.length) % options.length);
+            };
+            const selectPresumptive = () => {
+                const id = completions()[presumptive()];
+                if (id) {
+                    select(id);
+                }
+            };
+
+            return (
+                <span class="picker">
+                    <span class="selected">{props.selected}</span>
+                    <input
+                        aria-label="attribute type"
+                        value={text()}
+                        onFocus={() => setOpen(true)}
+                        onInput={(event) => {
+                            setText(event.currentTarget.value);
+                            setPresumptive(0);
+                            setOpen(true);
+                        }}
+                        onKeyDown={(event) => {
+                            if (event.key === "ArrowDown") {
+                                event.preventDefault();
+                                movePresumptive(1);
+                            } else if (event.key === "ArrowUp") {
+                                event.preventDefault();
+                                movePresumptive(-1);
+                            } else if (event.key === "Enter") {
+                                event.preventDefault();
+                                selectPresumptive();
+                            } else if (event.key === "Escape") {
+                                setOpen(false);
+                            }
+                        }}
+                    />
+                    <Show when={open()}>
+                        <ul class="completion-list">
+                            <For each={completions()}>
+                                {(id, index) => (
+                                    <li
+                                        classList={{ presumptive: index() === presumptive() }}
+                                        onMouseDown={() => select(id)}
+                                    >
+                                        {label(editor.model(), id)}
+                                    </li>
+                                )}
+                            </For>
+                        </ul>
+                    </Show>
+                </span>
+            );
+        }
+
+        function AttrCellEditor(props: { attribute: NotebookCell<typeof attr> }) {
+            const editor = useEditor();
+            const selectCodomain = (id: QualifiedName) => {
+                const result = editor.notebook.get(attrType, id);
+                if (result.tag === "Ok") {
+                    props.attribute.update({ to: result.content });
+                }
+            };
+
+            return (
+                <li>
+                    <span class="cell-label">
+                        Attr: {props.attribute.label}: {props.attribute.from.label} -&gt;{" "}
+                        <CompletionPicker
+                            obType={attrType.obType}
+                            selected={codomainLabel(editor.model(), props.attribute)}
+                            onSelect={selectCodomain}
+                        />
+                    </span>
+                </li>
+            );
+        }
+
+        function SchemaCellEditor(props: { cell: NotebookCell<typeof AttrPickerShape> }) {
+            if (props.cell.kind === CellKind.Morphism) {
+                return <AttrCellEditor attribute={props.cell} />;
+            }
+            if (props.cell.kind === CellKind.Object) {
+                const label = props.cell.type === attrType ? "AttrType" : "Entity";
+                return (
+                    <li>
+                        <span class="cell-label">
+                            {label}: {props.cell.label}
+                        </span>
+                    </li>
+                );
+            }
+            if (props.cell.kind === CellKind.RichText) {
+                return (
+                    <li>
+                        <span class="cell-label">Text: {props.cell.content}</span>
+                    </li>
+                );
+            }
+            return null;
+        }
+
+        function SchemaNotebookEditor(props: { notebook: AttrPickerNotebook }) {
+            // Reactive validation: `onValidate` re-validates on changes to any
+            // document the validation depends on (this notebook and anything it
+            // instantiates) and delivers only results that actually differ, so
+            // wiring it to a signal is all a component needs.
+            const [result, setResult] = createSignal<ModelValidationResult>();
+            const unsubscribe = props.notebook.onValidate(setResult);
+            onCleanup(unsubscribe);
+            const currentModel = () => {
+                const validated = result();
+                return validated?.tag === "Ok" ? validated.content : undefined;
+            };
+
+            validation = result;
+            model = currentModel;
+
+            return (
+                <section>
+                    <h1>{props.notebook.name}</h1>
+                    <Show when={currentModel()} fallback={<p>Validating...</p>}>
+                        {(m) => (
+                            <EditorContext.Provider value={{ notebook: props.notebook, model: m }}>
+                                <ul>
+                                    <For each={props.notebook.cellsOf(AttrPickerShape)}>
+                                        {(cell) => <SchemaCellEditor cell={cell} />}
+                                    </For>
+                                </ul>
+                            </EditorContext.Provider>
+                        )}
+                    </Show>
+                </section>
+            );
+        }
+
+        const notebook = await solidBinder.createNotebook(SimpleSchema, { name: "Company schema" });
+        const person = notebook.add(Entity, { label: "Person" });
+        const string = notebook.add(AttrType, { label: "String" });
+        notebook.add(AttrType, { label: "Integer" });
+        notebook.add(AttrType, { label: "Boolean" });
+        const name = notebook.add(Attr, { label: "name", from: person, to: string });
+
+        const container = document.createElement("div");
+        document.body.appendChild(container);
+        const dispose = render(() => <SchemaNotebookEditor notebook={notebook} />, container);
+
+        await until(() => validation() !== undefined);
+        expect(validation()?.tag).toBe("Ok");
+        expect(codomainLabel(model(), name)).toBe("String");
+        expect(
+            [...container.querySelectorAll(".completion-list li")].map((li) => li.textContent),
+        ).toEqual(["String", "Integer", "Boolean"]);
+        expect(container.textContent).toContain("Entity: Person");
+        expect(container.textContent).not.toContain("PersonString");
+
+        const input = container.querySelector<HTMLInputElement>(
+            'input[aria-label="attribute type"]',
+        )!;
+        input.value = "in";
+        input.dispatchEvent(new InputEvent("input", { bubbles: true }));
+        expect(
+            [...container.querySelectorAll(".completion-list li")].map((li) => li.textContent),
+        ).toEqual(["String", "Integer"]);
+
+        input.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowDown", bubbles: true }));
+        expect(container.querySelector(".completion-list li.presumptive")?.textContent).toBe(
+            "Integer",
+        );
+
+        input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+        await until(() => codomainLabel(model(), name) === "Integer");
+
+        const updatedInput = container.querySelector<HTMLInputElement>(
+            'input[aria-label="attribute type"]',
+        )!;
+        updatedInput.value = "";
+        updatedInput.dispatchEvent(new InputEvent("input", { bubbles: true }));
+        updatedInput.dispatchEvent(new FocusEvent("focus", { bubbles: true }));
+        const stringItem = [...container.querySelectorAll(".completion-list li")].find(
+            (li) => li.textContent === "String",
+        )!;
+        stringItem.dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));
+        await until(() => codomainLabel(model(), name) === "String");
+
+        notebook.add(AttrType, { label: "Date" });
+        await until(() => {
+            const m = model();
+            return !!m && filteredCompletions(m, attrType.obType, "").length === 4;
+        });
+        container
+            .querySelector<HTMLInputElement>('input[aria-label="attribute type"]')!
+            .dispatchEvent(new FocusEvent("focus", { bubbles: true }));
+        expect(
+            [...container.querySelectorAll(".completion-list li")].map((li) => li.textContent),
+        ).toEqual(["String", "Integer", "Boolean", "Date"]);
+
+        dispose();
+        container.remove();
+    });
+});
diff --git a/packages/document-methods/test/simple_schema_completions.test.tsx b/packages/document-methods/test/simple_schema_completions.test.tsx
new file mode 100644
index 000000000..f4dc84c1b
--- /dev/null
+++ b/packages/document-methods/test/simple_schema_completions.test.tsx
@@ -0,0 +1,210 @@
+/*
+ * A simple-schema scenario focused on *completions*, companion to
+ * `petri_net_elaborated_consumer`.
+ *
+ * It reads the *elaborated model* — the `DblModel` from `Notebook.validate()` —
+ * to reproduce how the frontend computes autocompletions for a morphism
+ * endpoint (`model/object_input.tsx` -> `components/id_input.tsx` ->
+ * `ui-components/completions.tsx`):
+ *
+ *   1. Candidate ids come from `obGeneratorsWithType(obType)`, filtered to the
+ *      endpoint's object type (`AttrType` for an `Attr`'s codomain).
+ *   2. Each id is labelled with `obGeneratorLabel(id)?.join(".")`.
+ *   3. Typed text filters the list to substring matches.
+ *   4. Selecting one edits the typed notebook; `Notebook.onValidate` — wired
+ *      to a signal — re-validates reactively into a fresh elaborated model.
+ */
+/* oxlint-disable unicorn/consistent-function-scoping */
+import { createBinder, type DocumentStore, type ModelValidationResult } from "catcolab-documents";
+import { Attr, AttrType, Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+import { type Accessor, createSignal, For, Show } from "solid-js";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { render } from "solid-js/web";
+import { describe, expect, test } from "vitest";
+
+import type { Document } from "catcolab-document-types";
+import type { DblModel, ObType, QualifiedName } from "catlog-wasm";
+import { selfResolving } from "./self_resolving";
+
+/** Test helper: poll until `predicate` holds (validation is asynchronous). */
+async function until(predicate: () => boolean): Promise<void> {
+    const deadline = Date.now() + 5000;
+    while (!predicate()) {
+        if (Date.now() > deadline) {
+            throw new Error("condition not met in time");
+        }
+        await new Promise((resolve) => setTimeout(resolve));
+    }
+}
+
+// Test hooks: a real consumer keeps the validation signal and the derived
+// model accessor component-local. `Consumer` assigns these so the test can
+// await re-validation (`globalValidation`) and read the elaborated model
+// (`globalModel`) from outside the component.
+let globalValidation!: Accessor<ModelValidationResult | undefined>;
+let globalModel!: () => DblModel | undefined;
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    // Resolve a notebook's own model (validation now goes through the store).
+    ...selfResolving<SolidStoreHandle>(),
+};
+
+const solidBinder = createBinder(solidStore);
+
+/**
+ * Build the completions for an object type and filter them by the typed text,
+ * exactly as the frontend does (`obGeneratorsWithType` + `obGeneratorLabel`):
+ * keep the generators whose label contains the text.
+ */
+function filteredCompletions(model: DblModel, obType: ObType, text: string): QualifiedName[] {
+    const label = (id: QualifiedName) => model.obGeneratorLabel(id)?.join(".") ?? "?";
+    const needle = text.toLowerCase();
+    return model
+        .obGeneratorsWithType(obType)
+        .filter((id) => label(id).toLowerCase().includes(needle));
+}
+
+describe("simple-schema completions consumer", () => {
+    test("catcolab-documents, elaborated-model completions", async () => {
+        // The endpoint completions list: candidate `AttrType` ids filtered by
+        // the typed text, each selectable to edit the morphism's codomain.
+        function Completions(props: {
+            model: DblModel;
+            obType: ObType;
+            text: string;
+            onSelect: (id: QualifiedName) => void;
+        }) {
+            return (
+                <ul class="completion-list">
+                    <For each={filteredCompletions(props.model, props.obType, props.text)}>
+                        {(id) => (
+                            <li onMouseDown={() => props.onSelect(id)}>
+                                {props.model.obGeneratorLabel(id)?.join(".")}
+                            </li>
+                        )}
+                    </For>
+                </ul>
+            );
+        }
+
+        // Build the schema through the typed document API; the elaborated model
+        // is derived from it. `Mapping` exists only so the morphism-type filter
+        // is meaningful: `obGeneratorsWithType(AttrType)` must exclude entities.
+        void Mapping;
+        const notebook = await solidBinder.createNotebook(SimpleSchema, { name: "Company schema" });
+        const person = notebook.add(Entity, { label: "Person" });
+        const str = notebook.add(AttrType, { label: "String" });
+        notebook.add(AttrType, { label: "Integer" });
+        notebook.add(AttrType, { label: "Boolean" });
+        const attr = notebook.add(Attr, { label: "name", from: person, to: str });
+
+        // The typed text is test-driven UI state, lifted so the test can
+        // simulate typing; the consumer component below reads it as a prop.
+        const [text, setText] = createSignal("");
+
+        // The consumer component owns the reactive validation: `onValidate`
+        // re-elaborates when anything the validation depends on changes (a
+        // formal-cell edit, but not, say, a rich-text comment — equivalent
+        // results are not re-delivered), and the derived `model` accessor
+        // exposes its elaborated `DblModel`.
+        function Consumer(props: { text: string }) {
+            const [validation, setValidation] = createSignal<ModelValidationResult>();
+            notebook.onValidate(setValidation);
+            const model = (): DblModel | undefined => {
+                const result = validation();
+                return result?.tag === "Ok" ? result.content : undefined;
+            };
+
+            // Selecting an id only edits the morphism cell (an object
+            // generator's id is its cell's id); the reactive observer above
+            // re-validates into a fresh elaborated model.
+            const onSelect = (id: QualifiedName) => {
+                const result = notebook.get(AttrType, id);
+                if (result.tag === "Ok") {
+                    attr.update({ to: result.content });
+                }
+            };
+
+            // Test hooks only: expose the signal and model so the test can
+            // await re-validation and inspect the codomain from outside.
+            globalValidation = validation;
+            globalModel = model;
+
+            return (
+                <Show when={model()}>
+                    {(model) => (
+                        <Completions
+                            model={model()}
+                            obType={AttrType.obType}
+                            text={props.text}
+                            onSelect={onSelect}
+                        />
+                    )}
+                </Show>
+            );
+        }
+
+        const container = document.createElement("div");
+        document.body.appendChild(container);
+        const dispose = render(() => <Consumer text={text()} />, container);
+
+        function codomain() {
+            const m = globalModel();
+            const cod = m?.morPresentation(attr.id)?.cod;
+            return cod?.tag === "Basic" ? m?.obGeneratorLabel(cod.content)?.join(".") : "?";
+        }
+
+        await until(() => globalValidation() !== undefined);
+        expect(globalValidation()?.tag).toBe("Ok");
+
+        // Empty text: every `AttrType` generator, in generator order.
+        expect(container.innerHTML).toBe(
+            '<ul class="completion-list"><li>String</li><li>Integer</li><li>Boolean</li></ul>',
+        );
+        expect(codomain()).toBe("String");
+
+        // "in" keeps the substring matches `String` and `Integer` (in
+        // generator order); `Boolean` drops out.
+        setText("in");
+        expect(container.innerHTML).toBe(
+            '<ul class="completion-list"><li>String</li><li>Integer</li></ul>',
+        );
+
+        // Selecting `Integer` edits the document and re-validates.
+        const integer = [...container.querySelectorAll("li")].find(
+            (li) => li.textContent === "Integer",
+        )!;
+        integer.dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));
+        await until(() => codomain() === "Integer");
+
+        dispose();
+        container.remove();
+    });
+});
diff --git a/packages/document-methods/test/simple_schema_formal_cells_resource.test.tsx b/packages/document-methods/test/simple_schema_formal_cells_resource.test.tsx
new file mode 100644
index 000000000..fd19445a6
--- /dev/null
+++ b/packages/document-methods/test/simple_schema_formal_cells_resource.test.tsx
@@ -0,0 +1,197 @@
+/*
+ * A companion to `simple_schema_completions`, this test shows why
+ * `notebook.formalCells()` is a poor `createResource` source — and how
+ * `notebook.onChange` fixes it.
+ *
+ * `formalCells()` rebuilds its result on every call: it maps over the
+ * notebook's reactive cell order into a brand new array of freshly-constructed
+ * cell handles (see `src/future/index.ts`, `formalCells` -> `cells`). So two
+ * consecutive reads are never referentially equal (`formalCells() !==
+ * formalCells()`), even with no edits in between. Used directly as a
+ * `createResource` source the value therefore *always* compares as changed, so
+ * the resource re-validates on every tracked change — including edits that
+ * leave the formal cells untouched, such as adding a `RichText` comment.
+ *
+ * The building blocks are `notebook.onChange` (a change notification sourced
+ * from the store, so it also fires for remote edits, e.g. another Automerge
+ * collaborator). For *validation*, components need neither directly:
+ * `notebook.onValidate` re-validates on changes to anything the validation
+ * depends on and delivers only results that actually differ, which the last
+ * test demonstrates.
+ */
+/* oxlint-disable unicorn/consistent-function-scoping */
+import {
+    createBinder,
+    type DocumentStore,
+    type ModelValidationResult,
+    RichText,
+} from "catcolab-documents";
+import { Attr, AttrType, Entity, SimpleSchema } from "catcolab-logics/simple-schema";
+import { createStore, reconcile, type SetStoreFunction, unwrap } from "solid-js/store";
+import { describe, expect, test } from "vitest";
+
+import type { Document } from "catcolab-document-types";
+import { selfResolving } from "./self_resolving";
+
+/** Test helper: poll until `predicate` holds (validation is asynchronous). */
+async function until(predicate: () => boolean): Promise<void> {
+    const deadline = Date.now() + 5000;
+    while (!predicate()) {
+        if (Date.now() > deadline) {
+            throw new Error("condition not met in time");
+        }
+        await new Promise((resolve) => setTimeout(resolve));
+    }
+}
+
+/** Test helper: let any in-flight observation settle. */
+async function flush(): Promise<void> {
+    for (let i = 0; i < 25; i++) {
+        await new Promise((resolve) => setTimeout(resolve));
+    }
+}
+
+type SolidStoreHandle = {
+    draftDoc: Document;
+    docView: Document;
+    setDocView: SetStoreFunction<Document>;
+    listeners: Set<() => void>;
+};
+
+const solidStore: DocumentStore<SolidStoreHandle> = {
+    async createHandle(initialDoc) {
+        const draftDoc = structuredClone(initialDoc as Document);
+        const [docView, setDocView] = createStore<Document>(initialDoc as Document);
+        return { draftDoc, docView, setDocView, listeners: new Set() };
+    },
+    getDocumentView: (handle) => handle.docView,
+    changeDocument: (handle, fn) => {
+        fn(handle.draftDoc);
+        handle.setDocView(reconcile(structuredClone(handle.draftDoc), { key: "id" }));
+        // Notify subscribers after the mutation. A real reactive store (Solid,
+        // Automerge) detects changes however they arrive; this fixture has only
+        // one mutation path — `changeDocument` — so notifying here is complete.
+        for (const listener of Array.from(handle.listeners)) {
+            listener();
+        }
+    },
+    subscribe: (handle, callback) => {
+        handle.listeners.add(callback);
+        return () => {
+            handle.listeners.delete(callback);
+        };
+    },
+    copyValue: (_handle, value) => structuredClone(unwrap(value)),
+    // Resolve a notebook's own model (validation now goes through the store).
+    ...selfResolving<SolidStoreHandle>(),
+};
+
+const solidBinder = createBinder(solidStore);
+
+describe("simple-schema formalCells() validation resource", () => {
+    test("formalCells() returns a fresh array each call", async () => {
+        const notebook = await solidBinder.createNotebook(SimpleSchema, { name: "Company schema" });
+        const person = notebook.add(Entity, { label: "Person" });
+        const str = notebook.add(AttrType, { label: "String" });
+        notebook.add(Attr, { label: "name", from: person, to: str });
+
+        const first = notebook.formalCells();
+        const second = notebook.formalCells();
+
+        // The arrays carry the same formal cells (same ids, same order)...
+        expect(first.map((cell) => cell.id)).toEqual(second.map((cell) => cell.id));
+        // ...yet they are distinct array instances built of fresh handles, so
+        // referential equality — what `createResource` relies on to dedupe —
+        // never holds. This is exactly why `formalCells()` cannot be a resource
+        // source on its own.
+        expect(first).not.toBe(second);
+        expect(first[0]).not.toBe(second[0]);
+    });
+
+    test("onChange fires for every change to the notebook", async () => {
+        const notebook = await solidBinder.createNotebook(SimpleSchema, { name: "Company schema" });
+
+        let changes = 0;
+        const unsubscribe = notebook.onChange(() => {
+            changes += 1;
+        });
+
+        const person = notebook.add(Entity, { label: "Person" });
+        expect(changes).toBe(1);
+
+        person.update({ label: "Human" });
+        expect(changes).toBe(2);
+
+        notebook.add(RichText, { content: "A note." });
+        expect(changes).toBe(3);
+
+        // After unsubscribing, further edits are not reported.
+        unsubscribe();
+        notebook.add(AttrType, { label: "String" });
+        expect(changes).toBe(3);
+    });
+
+    test("onChange fires when an entity's name is updated", async () => {
+        const notebook = await solidBinder.createNotebook(SimpleSchema, { name: "Company schema" });
+        const person = notebook.add(Entity, { label: "Person" });
+
+        let changes = 0;
+        const unsubscribe = notebook.onChange(() => {
+            changes += 1;
+        });
+
+        // Updating an entity's name mutates nested cell content
+        // (`cellContents[id].content.name`) rather than replacing the cell. The
+        // change still flows through `changeDocument`, so `onChange` fires and
+        // the new name is observable.
+        person.update({ label: "Human" });
+        expect(changes).toBe(1);
+        expect(person.label).toBe("Human");
+
+        // A second update to the same nested content fires `onChange` again.
+        person.update({ label: "Individual" });
+        expect(changes).toBe(2);
+        expect(person.label).toBe("Individual");
+
+        unsubscribe();
+    });
+
+    test("onValidate delivers only when the validation result changes", async () => {
+        const notebook = await solidBinder.createNotebook(SimpleSchema, { name: "Company schema" });
+        const person = notebook.add(Entity, { label: "Person" });
+        const str = notebook.add(AttrType, { label: "String" });
+        notebook.add(Attr, { label: "name", from: person, to: str });
+
+        // `onValidate` replaces the whole revision-signal + resource dance:
+        // it re-validates on changes to anything the validation depends on
+        // (cheap, through the elaboration cache) and delivers only results that
+        // differ from the last delivered one — so unrelated edits cause no
+        // deliveries, and hence no re-renders in a consumer wired to a signal.
+        const results: ModelValidationResult[] = [];
+        const unsubscribe = notebook.onValidate((result) => results.push(result));
+
+        await until(() => results.length === 1);
+        expect(results[0]?.tag).toBe("Ok");
+
+        // Add a rich-text comment. It is not a formal cell, so the elaborated
+        // model is unchanged: nothing is delivered.
+        notebook.add(RichText, { content: "An explanatory note." });
+        await flush();
+        expect(results.length).toBe(1);
+
+        // Editing a *formal* cell in place changes the elaborated model, so a
+        // fresh result is delivered.
+        person.update({ label: "Human" });
+        await until(() => results.length === 2);
+
+        // Adding a *formal* cell delivers again.
+        notebook.add(Entity, { label: "Company" });
+        await until(() => results.length === 3);
+
+        // After unsubscribing, further edits deliver nothing.
+        unsubscribe();
+        notebook.add(Entity, { label: "Office" });
+        await flush();
+        expect(results.length).toBe(3);
+    });
+});
diff --git a/packages/document-methods/test/simple_schema_logic.lts.md b/packages/document-methods/test/simple_schema_logic.lts.md
new file mode 100644
index 000000000..ae9057c49
--- /dev/null
+++ b/packages/document-methods/test/simple_schema_logic.lts.md
@@ -0,0 +1,131 @@
+# Defining a schema shape
+
+A shape declares a notebook's object and morphism types as tagged wrappers built
+with `defineObject`/`defineMorphism`. A `Hom` morphism's endpoint object type and
+arity are read from its `MorType` structure. A `Basic` morphism records no
+endpoints in its literal, so it must declare them with
+`defineMorphism(morType, { domain, codomain })`, passing each endpoint's
+`ObType`; a bare `Basic` literal is not a `MorphismDef` and is a compile error.
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { defineMorphism, defineObject, defineShape } from "catcolab-documents";
+
+const Entity = defineObject({ tag: "Basic", content: "Entity" });
+const AttrType = defineObject({ tag: "Basic", content: "AttrType" });
+
+// `Hom(Entity)`: a mapping between entities; endpoints are `Entity` cells.
+const Mapping = defineMorphism({ tag: "Hom", content: Entity.obType });
+// A `Basic` morphism records no endpoints, so they are declared here:
+// an `Attr` goes from an `Entity` to an `AttrType`.
+const Attr = defineMorphism(
+    { tag: "Basic", content: "Attr" },
+    { domain: Entity.obType, codomain: AttrType.obType },
+);
+// `Hom(AttrType)`: an operation between attribute types.
+const Operation = defineMorphism({ tag: "Hom", content: AttrType.obType });
+
+const SimpleSchema = defineShape({
+    theory: "simple-schema",
+    getCoreTheory: async () => {
+        const { ThSchema } = await import("catlog-wasm");
+        return new ThSchema().theory();
+    },
+    objects: [Entity, AttrType],
+    morphisms: [Mapping, Attr, Operation],
+});
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+import { binder } from "catcolab-documents";
+
+const notebook = await binder.createNotebook(SimpleSchema, { name: "Company schema" });
+```
+
+<!-- verifier:prepend-to-following -->
+
+```ts
+const person = notebook.add(Entity, { label: "Person" });
+const company = notebook.add(Entity, { label: "Company" });
+const str = notebook.add(AttrType, { label: "String" });
+const upper = notebook.add(AttrType, { label: "UpperString" });
+
+notebook.add(Mapping, { label: "employer", from: person, to: company });
+notebook.add(Attr, { label: "name", from: person, to: str });
+notebook.add(Operation, { label: "uppercase", from: str, to: upper });
+```
+
+```ts
+const entities = notebook.cellsOf(Entity);
+const mappings = notebook.cellsOf(Mapping);
+const attrs = notebook.cellsOf(Attr);
+const operations = notebook.cellsOf(Operation);
+
+console.log("entities:", entities.map((cell) => cell.label).join(", "));
+console.log("mappings:", mappings.map((cell) => cell.label).join(", "));
+console.log("attrs:", attrs.map((cell) => cell.label).join(", "));
+console.log("operations:", operations.map((cell) => cell.label).join(", "));
+```
+
+```
+entities: Person, Company
+mappings: employer
+attrs: name
+operations: uppercase
+```
+
+A `Mapping` ends on an `Entity` (`Hom(Entity)`), so pointing its codomain at an
+attribute type is a compile error.
+
+```ts
+// @ts-expect-error A mapping's codomain must be an Entity cell, not an AttrType cell.
+notebook.add(Mapping, {
+    label: "bad",
+    from: person,
+    to: str,
+});
+```
+
+Likewise an `Operation` goes between attribute types (`Hom(AttrType)`), so an
+entity domain is rejected.
+
+```ts
+// @ts-expect-error An operation's domain must be an AttrType cell, not an Entity cell.
+notebook.add(Operation, {
+    label: "bad",
+    from: person,
+    to: str,
+});
+```
+
+The `defineMorphism(...)` declaration types an `Attr`'s endpoints just like a
+`Hom`: its domain is an `Entity` and its codomain an `AttrType`, so swapping them
+is a compile error even though `Attr` is a `Basic` morphism.
+
+```ts
+// @ts-expect-error An attr's domain must be an Entity cell and its codomain an AttrType cell.
+notebook.add(Attr, {
+    label: "bad",
+    from: str,
+    to: person,
+});
+```
+
+A bare `Basic` morphism literal is not a `MorphismDef`, so passing one in a
+shape's `morphisms` list (instead of wrapping it with `defineMorphism`) is a
+compile error.
+
+```ts
+defineShape({
+    theory: "missing-endpoints",
+    getCoreTheory: SimpleSchema.getCoreTheory,
+    objects: [Entity],
+    morphisms: [
+        // @ts-expect-error A Basic morphism must be wrapped with defineMorphism(morType, { domain, codomain }).
+        { tag: "Basic", content: "Attr" },
+    ],
+});
+```
diff --git a/packages/document-methods/test/tsconfig.json b/packages/document-methods/test/tsconfig.json
new file mode 100644
index 000000000..b3bf0f0f3
--- /dev/null
+++ b/packages/document-methods/test/tsconfig.json
@@ -0,0 +1,8 @@
+{
+    // Editor-only config so tsserver (e.g. coc-tsserver) routes files under
+    // `test/` to the test compiler options. The canonical config used by
+    // `pnpm run check`/`ci` is `../tsconfig.test.json`; this just makes those
+    // same settings the nearest discoverable `tsconfig.json` for test files.
+    "extends": "../tsconfig.test.json",
+    "include": ["**/*.ts", "**/*.tsx"]
+}
diff --git a/packages/document-methods/test/typed_api_endpoint_safety.lts.md b/packages/document-methods/test/typed_api_endpoint_safety.lts.md
new file mode 100644
index 000000000..f926605df
--- /dev/null
+++ b/packages/document-methods/test/typed_api_endpoint_safety.lts.md
@@ -0,0 +1,87 @@
+# How a shape avoids endpoint bugs
+
+The olog and Petri-net editor comparisons
+([`olog_editor_comparison.lts.md`](./olog_editor_comparison.lts.md),
+[`petri_net_editor_comparison.lts.md`](./petri_net_editor_comparison.lts.md))
+build the same editor over the unified `Notebook` API. A notebook over a shape
+that declares its cell types constrains `add` to those types and derives each
+morphism's endpoints from its `MorType` (and, for a list morphism, its declared
+`modality`), so wiring an endpoint with the wrong cell is a compile error rather
+than a corrupt document.
+
+The examples below take three classes of endpoint mistake and show that a shaped
+notebook rejects each at compile time, before any document is written.
+
+## Bug 1: an endpoint of the wrong object type
+
+A schema `Mapping` goes between entities (`Entity -> Entity`); an `Attr` goes
+from an entity to an attribute type (`Entity -> AttrType`).
+
+Because `Mapping` is `Hom(Entity)`, its codomain is `ObjectCell` of the `Entity`
+type. Passing an attribute cell is a compile error, caught before any document
+is written.
+
+```ts
+import { binder } from "catcolab-documents";
+import { AttrType, Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+
+const notebook = await binder.createNotebook(SimpleSchema, { name: "Schema" });
+const person = notebook.add(Entity, { label: "Person" });
+const age = notebook.add(AttrType, { label: "Age" });
+
+// @ts-expect-error A Mapping's codomain must be an Entity cell, not an AttrType cell.
+notebook.add(Mapping, { label: "broken", from: person, to: age });
+```
+
+## Bug 2: a single object where an endpoint list is required
+
+A Petri-net transition's endpoints are _lists_ of places, declared with a
+`SymmetricList` modality on the morphism (its morphism type stays the plain
+`Hom(Object)` the core theory understands). A shaped `Transition` derives
+`ObjectCell[]` for each endpoint from that modality, so a single place where a
+list is required is rejected at compile time.
+
+```ts
+import { binder } from "catcolab-documents";
+import { PetriNet, Place, Transition } from "catcolab-logics/petri-net";
+
+const notebook = await binder.createNotebook(PetriNet, { name: "Net" });
+const a = notebook.add(Place, { label: "A" });
+const c = notebook.add(Place, { label: "C" });
+
+// @ts-expect-error A transition endpoint is an array of Place cells, not a single Place.
+notebook.add(Transition, { label: "fires", from: a, to: [c] });
+```
+
+## Bug 3: a cell from another theory or another notebook
+
+A place handle from one notebook should not be wirable into a mapping in a
+different schema notebook. With a shape the place handle is `ObjectCell` of the
+`Place` type (`{ tag: "Basic", content: "Object" }`), which is not assignable to
+the mapping's `Entity` endpoint (`{ tag: "Basic", content: "Entity" }`), so the
+cross-theory wiring is a compile error.
+
+```ts
+import { binder } from "catcolab-documents";
+import { PetriNet, Place } from "catcolab-logics/petri-net";
+import { Entity, Mapping, SimpleSchema } from "catcolab-logics/simple-schema";
+
+const net = await binder.createNotebook(PetriNet, { name: "Net" });
+const place = net.add(Place, { label: "A place" });
+
+const schema = await binder.createNotebook(SimpleSchema, { name: "Schema" });
+const person = schema.add(Entity, { label: "Person" });
+
+// @ts-expect-error `place` is a Place cell from another theory; a Mapping endpoint needs an Entity cell.
+schema.add(Mapping, { label: "tangled", from: person, to: place });
+```
+
+## Why this matters
+
+Declaring a shape moves the endpoint contract into the type system: `add` is
+constrained to the shape's cell types, and each morphism's endpoints are derived
+from its `MorType` and declared `modality` (`Hom(Entity)` wants an `Entity`
+cell; a `SymmetricList` `Hom` wants a list). Wrong-type, wrong-arity, and
+cross-theory endpoints become
+compile-time errors instead of runtime surprises, while reads recover precise
+handles with `cellsOf`.
diff --git a/packages/document-methods/tsconfig.lts.json b/packages/document-methods/tsconfig.lts.json
new file mode 100644
index 000000000..b047b8af5
--- /dev/null
+++ b/packages/document-methods/tsconfig.lts.json
@@ -0,0 +1,23 @@
+{
+    "extends": ["./tsconfig.json", "@tsconfig/strictest/tsconfig.json"],
+    "compilerOptions": {
+        "noEmit": true,
+        // Literate samples in markdown often declare bindings that are not
+        // referenced again in the same fence (the prose is the consumer), so
+        // the strictest preset's unused-locals/parameters checks would
+        // produce spurious diagnostics here.
+        "noUnusedLocals": false,
+        "noUnusedParameters": false,
+        "jsx": "preserve",
+        "jsxImportSource": "solid-js",
+        "lib": ["ES2023", "DOM"],
+        "paths": {
+            "catcolab-logics/*": ["./test/literate-ts/catcolab-logics/*.ts"],
+            "catcolab-analyses": ["./test/literate-ts/catcolab-analyses/index.ts"],
+            "catcolab-analyses/*": ["./test/literate-ts/catcolab-analyses/*.ts"],
+            "catcolab-documents": ["./src/future/index.ts"],
+            "document-methods/test/*": ["./test/*.ts"]
+        }
+    },
+    "include": [".lts/**/*.ts", ".lts/**/*.tsx"]
+}
diff --git a/packages/document-methods/tsconfig.test.json b/packages/document-methods/tsconfig.test.json
new file mode 100644
index 000000000..ca9ba375c
--- /dev/null
+++ b/packages/document-methods/tsconfig.test.json
@@ -0,0 +1,17 @@
+{
+    "extends": ["./tsconfig.json", "@tsconfig/strictest/tsconfig.json"],
+    "compilerOptions": {
+        "noEmit": true,
+        "types": ["node"],
+        "jsx": "preserve",
+        "jsxImportSource": "solid-js",
+        "lib": ["ES2023", "DOM", "DOM.Iterable"],
+        "paths": {
+            "catcolab-logics/*": ["./test/literate-ts/catcolab-logics/*.ts"],
+            "catcolab-analyses": ["./test/literate-ts/catcolab-analyses/index.ts"],
+            "catcolab-analyses/*": ["./test/literate-ts/catcolab-analyses/*.ts"],
+            "catcolab-documents": ["./src/future/index.ts"]
+        }
+    },
+    "include": ["vite.config.ts", "test/**/*.ts", "test/**/*.tsx"]
+}
diff --git a/packages/document-methods/vite.config.ts b/packages/document-methods/vite.config.ts
new file mode 100644
index 000000000..74184bd84
--- /dev/null
+++ b/packages/document-methods/vite.config.ts
@@ -0,0 +1,39 @@
+import { fileURLToPath } from "node:url";
+import { monorepoDedupe } from "@catcolab-dev-tools/vite-plugin-monorepo-dedupe";
+import solid from "vite-plugin-solid";
+import wasm from "vite-plugin-wasm";
+import { defineConfig } from "vitest/config";
+
+const root = fileURLToPath(new URL(".", import.meta.url));
+
+export default defineConfig({
+    plugins: [monorepoDedupe(), wasm(), solid()],
+    resolve: {
+        // Vitest does not read tsconfig `paths`, so the specifiers used by the
+        // example tests (mirroring the literate-typescript samples) are mapped
+        // here instead.
+        alias: [
+            {
+                find: "catcolab-documents",
+                replacement: fileURLToPath(new URL("./src/future/index.ts", import.meta.url)),
+            },
+            {
+                find: "catcolab-document-methods",
+                replacement: fileURLToPath(new URL("./src/index.ts", import.meta.url)),
+            },
+            {
+                find: "catcolab-analyses",
+                replacement: fileURLToPath(
+                    new URL("./test/literate-ts/catcolab-analyses/index.ts", import.meta.url),
+                ),
+            },
+            {
+                find: /^catcolab-logics\/(.*)$/,
+                replacement: `${root}test/literate-ts/catcolab-logics/$1.ts`,
+            },
+        ],
+    },
+    test: {
+        environment: "happy-dom",
+    },
+});
diff --git a/packages/document-types/src/v0/model.rs b/packages/document-types/src/v0/model.rs
index 6ad4ad26a..edb8c381e 100644
--- a/packages/document-types/src/v0/model.rs
+++ b/packages/document-types/src/v0/model.rs
@@ -33,7 +33,7 @@ pub enum Mor {
     Basic(String),
 
     /// Composite of morphisms.
-    Composite(Box<Path<Ob, Mor>>),
+    Composite(#[tsify(type = "Path<Ob, Mor>")] Box<Path<Ob, Mor>>),
 
     /// Morphism between tabulated morphisms, a commutative square.
     TabulatorSquare {
diff --git a/packages/frontend/default.nix b/packages/frontend/default.nix
index d898dffec..5a2f57b92 100644
--- a/packages/frontend/default.nix
+++ b/packages/frontend/default.nix
@@ -41,6 +41,7 @@ let
     "packages/document-methods" = ../document-methods/pnpm-lock.yaml;
     "packages/backend/pkg" = ../backend/pkg/pnpm-lock.yaml;
     "tools/vite-plugin-monorepo-dedupe" = ../../tools/vite-plugin-monorepo-dedupe/pnpm-lock.yaml;
+    "tools/literate-typescript" = ../../tools/literate-typescript/pnpm-lock.yaml;
   };
 
   processedLocks = lib.mapAttrs (_: processLock) lockfilesToProcess;
@@ -77,6 +78,7 @@ let
         ../../packages/frontend
         ../../packages/ui-components
         ../../tools/vite-plugin-monorepo-dedupe
+        ../../tools/literate-typescript
         ../../packages/document-methods
         ../../packages/backend/pkg
       ];
@@ -207,6 +209,7 @@ let
         cp -r packages/ui-components $out/packages/
         mkdir -p $out/tools
         cp -r tools/vite-plugin-monorepo-dedupe $out/tools/
+        cp -r tools/literate-typescript $out/tools/
         cp -r packages/document-methods $out/packages/
         mkdir -p $out/packages/document-types
         cp -r packages/document-types/pkg $out/packages/document-types/
diff --git a/packages/frontend/src/model/editors.ts b/packages/frontend/src/model/editors.ts
index 131d8595a..35fd40791 100644
--- a/packages/frontend/src/model/editors.ts
+++ b/packages/frontend/src/model/editors.ts
@@ -1,7 +1,7 @@
 import type { Component } from "solid-js";
 
 import type { FocusHandle } from "catcolab-ui-components";
-import type { MorDecl, ObDecl } from "catlog-wasm";
+import type { EqnDecl, MorDecl, ObDecl } from "catlog-wasm";
 import type { CellActions } from "../notebook";
 import type { Theory } from "../theory";
 import type { MorTypeMap, ObTypeMap } from "../theory/types";
@@ -33,3 +33,12 @@ export type MorphismEditorProps = {
     actions: CellActions;
     theory: Theory;
 };
+
+/** Props for an equation cell editor component in a model. */
+export type EquationEditorProps = {
+    equation: EqnDecl;
+    modifyEquation: (f: (decl: EqnDecl) => void) => void;
+    focus: FocusHandle;
+    actions: CellActions;
+    theory: Theory;
+};
diff --git a/packages/frontend/src/model/equation_cell_editor.module.css b/packages/frontend/src/model/equation_cell_editor.module.css
new file mode 100644
index 000000000..31e1d9972
--- /dev/null
+++ b/packages/frontend/src/model/equation_cell_editor.module.css
@@ -0,0 +1,53 @@
+.decl {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 0.125rem;
+    margin-top: 0.25rem;
+    margin-bottom: 0.25rem;
+}
+
+.name {
+    display: inline-flex;
+    align-items: baseline;
+}
+
+.nameSeparator {
+    color: var(--color-gray-800);
+    padding-left: 0.375rem;
+    padding-right: 0.625rem;
+}
+
+/* Lay the two sides out horizontally, but allow them to wrap onto separate
+   lines when there is not enough horizontal space. */
+.equation {
+    display: flex;
+    flex-direction: row;
+    flex-wrap: wrap;
+    align-items: center;
+    justify-content: flex-start;
+    gap: 0.125rem 0.5rem;
+    min-width: 0;
+}
+
+.equals {
+    font-size: 1.5em;
+    text-align: center;
+    line-height: 1;
+    color: var(--color-gray-950);
+    margin: 0 0.25rem;
+}
+
+.morList {
+    display: flex;
+    min-width: 0;
+
+    ul {
+        flex-wrap: wrap;
+    }
+}
+
+.separator {
+    color: var(--color-gray-800);
+    padding: 0 0.25em;
+}
diff --git a/packages/frontend/src/model/equation_cell_editor.tsx b/packages/frontend/src/model/equation_cell_editor.tsx
new file mode 100644
index 000000000..5769780bf
--- /dev/null
+++ b/packages/frontend/src/model/equation_cell_editor.tsx
@@ -0,0 +1,284 @@
+import { createEffect, createMemo, createSignal, useContext } from "solid-js";
+import invariant from "tiny-invariant";
+import { P, match } from "ts-pattern";
+
+import {
+    type FocusHandle,
+    InlineListEditor,
+    NameInput,
+    useChildFocus,
+} from "catcolab-ui-components";
+import type { DblModel, Mor, Ob, QualifiedName, Uuid } from "catlog-wasm";
+import { removeProxyAndCopy } from "../util/remove_proxy_and_copy";
+import { LiveModelContext } from "./context";
+import type { EquationEditorProps } from "./editors";
+import { PathMorInput } from "./path_mor_input";
+
+import styles from "./equation_cell_editor.module.css";
+
+type EquationCellInput = "name" | "lhs" | "rhs";
+
+/** Editor for an equation cell in a model. */
+export default function EquationCellEditor(props: EquationEditorProps) {
+    const liveModel = useContext(LiveModelContext);
+    invariant(liveModel, "Live model should be provided as context");
+
+    // oxlint-disable-next-line solid/reactivity -- Focus handles are stable for a mounted cell.
+    const focus = useChildFocus<EquationCellInput>(props.focus, { default: "name" });
+
+    const completions = (): QualifiedName[] | undefined =>
+        liveModel().elaboratedModel()?.morGenerators();
+
+    const lhs = createMemo(() => morToList(props.equation.lhs));
+    const rhs = createMemo(() => morToList(props.equation.rhs));
+
+    // The domain of the left-hand side, used to require that the right-hand side
+    // begins on the same object so the two sides remain parallel.
+    const lhsDom = createMemo((): Ob | null => {
+        const model = liveModel().elaboratedModel();
+        const first = lhs().find((mor): mor is Mor => mor != null);
+        if (!model || !first) {
+            return null;
+        }
+        return morDom(model, first);
+    });
+
+    const setLhs = (mors: Array<Mor | null>) =>
+        props.modifyEquation((eqn) => {
+            eqn.lhs = removeProxyAndCopy(listToMor(mors));
+        });
+
+    const setRhs = (mors: Array<Mor | null>) =>
+        props.modifyEquation((eqn) => {
+            eqn.rhs = removeProxyAndCopy(listToMor(mors));
+        });
+
+    const setName = (name: string) =>
+        props.modifyEquation((eqn) => {
+            eqn.name = name;
+        });
+
+    return (
+        <div class={`formal-judgment ${styles.decl}`}>
+            <div class={styles.name}>
+                <NameInput
+                    placeholder="Unnamed"
+                    name={props.equation.name}
+                    setName={setName}
+                    focus={focus.childFocus("name")}
+                    deleteBackward={props.actions.deleteBackward}
+                    deleteForward={props.actions.deleteForward}
+                    exitBackward={props.actions.activateAbove}
+                    exitForward={() => focus.setActiveChild("lhs")}
+                    exitUp={props.actions.activateAbove}
+                    exitDown={() => focus.setActiveChild("lhs")}
+                    exitRight={() => focus.setActiveChild("lhs")}
+                    createBelow={() => focus.setActiveChild("lhs")}
+                />
+            </div>
+            <div class={styles.nameSeparator}>:</div>
+            <div class={styles.equation}>
+                <MorListEditor
+                    mors={lhs()}
+                    setMors={setLhs}
+                    completions={completions()}
+                    focus={focus.childFocus("lhs")}
+                    exitBackward={() => focus.setActiveChild("name")}
+                    exitForward={() => focus.setActiveChild("rhs")}
+                    exitLeft={() => focus.setActiveChild("name")}
+                    exitRight={() => focus.setActiveChild("rhs")}
+                    deleteBackward={() => focus.setActiveChild("name")}
+                    deleteForward={() => focus.setActiveChild("rhs")}
+                />
+                <div class={styles.equals}>{"="}</div>
+                <MorListEditor
+                    mors={rhs()}
+                    setMors={setRhs}
+                    completions={completions()}
+                    baseDom={lhsDom()}
+                    focus={focus.childFocus("rhs")}
+                    exitBackward={() => focus.setActiveChild("lhs")}
+                    exitForward={props.actions.activateBelow}
+                    exitLeft={() => focus.setActiveChild("lhs")}
+                    exitRight={props.actions.activateBelow}
+                    deleteBackward={() => focus.setActiveChild("lhs")}
+                    deleteForward={props.actions.activateBelow}
+                />
+            </div>
+        </div>
+    );
+}
+
+function MorListEditor(props: {
+    mors: Array<Mor | null>;
+    setMors: (mors: Array<Mor | null>) => void;
+    completions: QualifiedName[] | undefined;
+    /** Required domain for the first morphism in the path, if constrained. */
+    baseDom?: Ob | null;
+    focus: FocusHandle;
+    exitBackward: () => void;
+    exitForward: () => void;
+    exitLeft: () => void;
+    exitRight: () => void;
+    deleteBackward: () => void;
+    deleteForward: () => void;
+}) {
+    const liveModel = useContext(LiveModelContext);
+    invariant(liveModel, "Live model should be provided as context");
+
+    const [editMors, setEditMors] = createSignal<Array<Mor | null> | null>(null);
+
+    const mors = () => editMors() ?? props.mors;
+
+    const setMors = (mors: Array<Mor | null>) => {
+        setEditMors(mors);
+        props.setMors(mors);
+    };
+
+    createEffect(() => {
+        if (!props.focus.hasFocus()) {
+            setEditMors(null);
+        }
+    });
+
+    // The object that a morphism at `index` must have as its domain in order to
+    // extend the path: the codomain of the preceding morphism, or `baseDom` for
+    // the first morphism. `null` means there is no constraint.
+    const requiredDom = (index: number): Ob | null => {
+        const model = liveModel().elaboratedModel();
+        if (!model) {
+            return null;
+        }
+        const items = mors();
+        for (let i = index - 1; i >= 0; i--) {
+            const prev = items[i];
+            if (prev != null) {
+                return morCod(model, prev);
+            }
+        }
+        return props.baseDom ?? null;
+    };
+
+    // Morphism generators whose domain matches the required domain at `index`.
+    const morCompletions = (index: number): Uuid[] | undefined => {
+        const all = props.completions;
+        if (!all) {
+            return all;
+        }
+        const dom = requiredDom(index);
+        if (dom === null) {
+            return all;
+        }
+        const model = liveModel().elaboratedModel();
+        return all.filter((id) => {
+            const gen = model?.morPresentation(id);
+            return gen != null && obsEqual(gen.dom, dom);
+        });
+    };
+
+    // Object generators on which the identity morphism composes at `index`, i.e.
+    // those equal to the required domain (since `id(X)` has domain and codomain X).
+    const obCompletions = (index: number): Uuid[] | undefined => {
+        const model = liveModel().elaboratedModel();
+        const all = model?.obGenerators();
+        if (!all) {
+            return all;
+        }
+        const dom = requiredDom(index);
+        if (dom === null) {
+            return all;
+        }
+        return all.filter((id) => obsEqual(basicOb(id), dom));
+    };
+
+    return (
+        <div class={styles.morList}>
+            <InlineListEditor<Mor>
+                items={mors()}
+                setItems={setMors}
+                insertKey=";"
+                startDelimiter={""}
+                endDelimiter={""}
+                separator={() => <div class={styles.separator}>{";"}</div>}
+                focus={props.focus}
+                exitBackward={props.exitBackward}
+                exitForward={props.exitForward}
+                exitLeft={props.exitLeft}
+                exitRight={props.exitRight}
+                deleteBackward={props.deleteBackward}
+                deleteForward={props.deleteForward}
+            >
+                {(mor, setMor, options, index) => (
+                    <PathMorInput
+                        mor={mor()}
+                        setMor={setMor}
+                        placeholder="..."
+                        morCompletions={morCompletions(index)}
+                        obCompletions={obCompletions(index)}
+                        {...options}
+                    />
+                )}
+            </InlineListEditor>
+        </div>
+    );
+}
+
+/** Build a basic object from its generator id. */
+function basicOb(id: Uuid): Ob {
+    return { tag: "Basic", content: id };
+}
+
+/** Domain of a morphism in the model, or `null` if it cannot be computed. */
+function morDom(model: DblModel, mor: Mor): Ob | null {
+    try {
+        return model.dom(mor);
+    } catch {
+        return null;
+    }
+}
+
+/** Codomain of a morphism in the model, or `null` if it cannot be computed. */
+function morCod(model: DblModel, mor: Mor): Ob | null {
+    try {
+        return model.cod(mor);
+    } catch {
+        return null;
+    }
+}
+
+/** Structural equality of objects, sufficient for comparing model objects. */
+function obsEqual(a: Ob | null, b: Ob | null): boolean {
+    if (a === null || b === null) {
+        return a === b;
+    }
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+
+/** Convert the stored morphism into the editable list shape. */
+function morToList(mor: Mor | null): Array<Mor | null> {
+    if (mor === null) {
+        return [];
+    }
+    const seq = match(mor)
+        .with({ tag: "Composite", content: { tag: "Seq", content: P.select() } }, (xs) => xs)
+        .otherwise(() => null);
+    return seq ?? [mor];
+}
+
+/** Convert the editable list into the stored equation side. */
+function listToMor(mors: Array<Mor | null>): Mor | null {
+    const present = mors.filter((mor): mor is Mor => mor !== null);
+    if (present.length === 0) {
+        return null;
+    }
+    if (present.length === 1) {
+        return present[0] ?? null;
+    }
+    return {
+        tag: "Composite",
+        content: {
+            tag: "Seq",
+            content: present,
+        },
+    };
+}
diff --git a/packages/frontend/src/model/model_editor.tsx b/packages/frontend/src/model/model_editor.tsx
index 8236b2e21..5673d4832 100644
--- a/packages/frontend/src/model/model_editor.tsx
+++ b/packages/frontend/src/model/model_editor.tsx
@@ -3,12 +3,19 @@ import { Dynamic } from "solid-js/web";
 import invariant from "tiny-invariant";
 
 import { Model, Nb } from "catcolab-document-methods";
-import type { InstantiatedModel, ModelJudgment, MorDecl, ObDecl } from "catcolab-document-types";
+import type {
+    EqnDecl,
+    InstantiatedModel,
+    ModelJudgment,
+    MorDecl,
+    ObDecl,
+} from "catcolab-document-types";
 import { type FocusHandle } from "catcolab-ui-components";
 import { type CellConstructor, type FormalCellEditorProps, NotebookEditor } from "../notebook";
 import { TheoryLibraryContext, type ModelTypeMeta, type Theory } from "../theory";
 import { LiveModelContext } from "./context";
 import type { LiveModelDoc } from "./document";
+import EquationCellEditor from "./equation_cell_editor";
 import { InstantiationCellEditor } from "./instantiation_cell_editor";
 
 /** Notebook editor for a model of a double theory.
@@ -104,6 +111,19 @@ export function ModelCellEditor(props: FormalCellEditorProps<ModelJudgment>) {
                     actions={props.actions}
                 />
             </Match>
+            <Match when={props.content.tag === "equation" && liveModel().theory()}>
+                {(theory) => (
+                    <EquationCellEditor
+                        equation={props.content as EqnDecl}
+                        modifyEquation={(f) =>
+                            props.changeContent((content) => f(content as EqnDecl))
+                        }
+                        focus={props.focus}
+                        actions={props.actions}
+                        theory={theory()}
+                    />
+                )}
+            </Match>
         </Switch>
     );
 }
@@ -121,6 +141,17 @@ function modelCellConstructors(theory: Theory): CellConstructor<ModelJudgment>[]
     for (const meta of theory.modelTypes ?? []) {
         constructors.push(modelCellConstructor(meta));
     }
+    const eqMeta = theory.equationCellMeta;
+    if (eqMeta) {
+        constructors.push({
+            name: eqMeta.name,
+            description: eqMeta.description,
+            shortcut: eqMeta.shortcut,
+            construct() {
+                return Nb.newFormalCell(Model.newEquationDecl());
+            },
+        });
+    }
     return constructors;
 }
 
@@ -156,7 +187,7 @@ function judgmentLabel(judgment: ModelJudgment): string | undefined {
         case "instantiation":
             return theory?.name;
         case "equation":
-            return "Equation";
+            return theory?.equationCellMeta?.name ?? "Equation";
         default:
             judgment satisfies never;
     }
diff --git a/packages/frontend/src/model/path_mor_input.tsx b/packages/frontend/src/model/path_mor_input.tsx
new file mode 100644
index 000000000..8e7a05806
--- /dev/null
+++ b/packages/frontend/src/model/path_mor_input.tsx
@@ -0,0 +1,207 @@
+import { createEffect, createSignal, splitProps, useContext } from "solid-js";
+import invariant from "tiny-invariant";
+import { P, match } from "ts-pattern";
+
+import {
+    type Completion,
+    InlineInput,
+    type InlineInputErrorStatus,
+    type InlineInputOptions,
+} from "catcolab-ui-components";
+import type { LabelSegment, Mor, QualifiedLabel, Uuid } from "catlog-wasm";
+import { LiveModelContext } from "./context";
+
+import "../components/id_input.css";
+
+/** Text wrapping the object name of an identity morphism, e.g. `id(X)`. */
+const ID_PREFIX = "id(";
+const ID_SUFFIX = ")";
+
+/** Optional props for `PathMorInput`. */
+export type PathMorInputOptions = {
+    /** Basic morphism generators offered as completions. */
+    morCompletions?: Uuid[];
+    /** Object generators offered as `id(...)` completions. */
+    obCompletions?: Uuid[];
+    /** Whether the current morphism is invalid in context. */
+    isInvalid?: boolean;
+} & Omit<InlineInputOptions, "completions" | "status">;
+
+/** Input a morphism in a path by its human-readable name.
+
+Unlike the generic `MorIdInput`, this input understands two kinds of morphisms,
+both relevant when building a path of composable morphisms:
+
+- basic morphism generators, entered and displayed by name;
+- identity morphisms, entered and displayed as `id(<object name>)`.
+
+Label lookups are read from the live model in context; the caller supplies the
+(usually domain-filtered) sets of generators to offer as completions.
+ */
+export function PathMorInput(
+    allProps: {
+        mor: Mor | null;
+        setMor: (mor: Mor | null) => void;
+    } & PathMorInputOptions,
+) {
+    const [props, inputProps] = splitProps(allProps, [
+        "mor",
+        "setMor",
+        "morCompletions",
+        "obCompletions",
+        "isInvalid",
+    ]);
+
+    const liveModel = useContext(LiveModelContext);
+    invariant(liveModel, "Live model should be provided as context");
+
+    const model = () => liveModel().elaboratedModel();
+
+    // Display text for a morphism: a basic generator's name, or `id(<object>)`
+    // for an identity morphism.
+    const morToText = (mor: Mor | null): string => {
+        if (mor === null) {
+            return "";
+        }
+        const obId = identityOb(mor);
+        if (obId !== null) {
+            const name = labelText(model()?.obGeneratorLabel(obId)) || "?";
+            return `${ID_PREFIX}${name}${ID_SUFFIX}`;
+        }
+        const id = basicMor(mor);
+        if (id !== null) {
+            return labelText(model()?.morGeneratorLabel(id));
+        }
+        return "";
+    };
+
+    // Resolve display text to a morphism, or `null` if it doesn't name one.
+    const textToMor = (text: string): Mor | null => {
+        const obName = parseIdentityName(text);
+        if (obName !== null) {
+            const lookup = model()?.obGeneratorWithLabel([parseSegment(obName)]);
+            return lookup && lookup.tag !== "None" ? identityMor(lookup.content) : null;
+        }
+        const lookup = model()?.morGeneratorWithLabel([parseSegment(text.trim())]);
+        return lookup && lookup.tag !== "None" ? { tag: "Basic", content: lookup.content } : null;
+    };
+
+    const [text, setText] = createSignal("");
+
+    createEffect(() => setText(morToText(props.mor)));
+
+    // Re-resolve the text against the model when it changes (e.g. a referenced
+    // generator gains a name), but only while the value is still incomplete.
+    createEffect(() => {
+        const currentText = text();
+        if (currentText !== "" && !isComplete()) {
+            const mor = textToMor(currentText);
+            if (mor !== null) {
+                props.setMor(mor);
+            }
+        }
+    });
+
+    const handleNewText = (newText: string) => {
+        const mor = textToMor(newText);
+        if (mor !== null) {
+            props.setMor(mor);
+        } else if (newText === "") {
+            // Avoid erasing partially-entered text: only clear the value when
+            // the text is empty too.
+            props.setMor(null);
+        }
+        setText(newText);
+    };
+
+    const setCompletion = (mor: Mor) => {
+        props.setMor(mor);
+        setText(morToText(mor));
+    };
+
+    const completions = (): Completion[] | undefined => {
+        if (props.morCompletions === undefined && props.obCompletions === undefined) {
+            return undefined;
+        }
+        const mors = (props.morCompletions ?? []).map((id): Completion => {
+            const mor: Mor = { tag: "Basic", content: id };
+            return { name: morToText(mor), onComplete: () => setCompletion(mor) };
+        });
+        const identities = (props.obCompletions ?? []).map((obId): Completion => {
+            const mor = identityMor(obId);
+            return { name: morToText(mor), onComplete: () => setCompletion(mor) };
+        });
+        return [...mors, ...identities];
+    };
+
+    const isComplete = () => text() === morToText(props.mor);
+
+    const status = (): InlineInputErrorStatus => {
+        if (!isComplete()) {
+            return "incomplete";
+        }
+        if (props.isInvalid) {
+            return "invalid";
+        }
+        return null;
+    };
+
+    return (
+        <div class="id-input">
+            <InlineInput
+                text={text()}
+                setText={handleNewText}
+                completions={completions()}
+                status={status()}
+                {...inputProps}
+            />
+        </div>
+    );
+}
+
+/** Render a qualified label as dotted display text. */
+function labelText(label: QualifiedLabel | undefined): string {
+    return label && label.length > 0 ? label.join(".") : "";
+}
+
+/** Parse a single label segment, treating all-digit text as an anonymous index. */
+function parseSegment(text: string): LabelSegment {
+    return /^\d+$/.test(text) ? Number.parseInt(text, 10) : text;
+}
+
+/** Extract the object generator of an identity morphism, if any. */
+function identityOb(mor: Mor): Uuid | null {
+    return match(mor)
+        .with(
+            {
+                tag: "Composite",
+                content: { tag: "Id", content: { tag: "Basic", content: P.select() } },
+            },
+            (id) => id,
+        )
+        .otherwise(() => null);
+}
+
+/** Extract the generator of a basic morphism, if any. */
+function basicMor(mor: Mor): Uuid | null {
+    return match(mor)
+        .with({ tag: "Basic", content: P.select() }, (id) => id)
+        .otherwise(() => null);
+}
+
+/** Build an identity morphism on a basic object generator. */
+function identityMor(obId: Uuid): Mor {
+    return {
+        tag: "Composite",
+        content: { tag: "Id", content: { tag: "Basic", content: obId } },
+    };
+}
+
+/** Parse the object name out of `id(<name>)` text, if it matches. */
+function parseIdentityName(text: string): string | null {
+    const trimmed = text.trim();
+    if (trimmed.startsWith(ID_PREFIX) && trimmed.endsWith(ID_SUFFIX)) {
+        return trimmed.slice(ID_PREFIX.length, trimmed.length - ID_SUFFIX.length).trim();
+    }
+    return null;
+}
diff --git a/packages/frontend/src/stdlib/theories/simple-olog.ts b/packages/frontend/src/stdlib/theories/simple-olog.ts
index e8eae2a28..83caacb54 100644
--- a/packages/frontend/src/stdlib/theories/simple-olog.ts
+++ b/packages/frontend/src/stdlib/theories/simple-olog.ts
@@ -16,6 +16,11 @@ export default function createOlogTheory(theoryMeta: TheoryMeta): Theory {
     return new Theory({
         ...theoryMeta,
         theory: thCategory.theory(),
+        equationCellMeta: {
+            name: "Fact",
+            description: "Add a fact relating aspects",
+            shortcut: ["F"],
+        },
         pushforwards: [
             {
                 target: "simple-schema",
diff --git a/packages/frontend/src/stdlib/theories/simple-schema.ts b/packages/frontend/src/stdlib/theories/simple-schema.ts
index 67b38a570..1184aef6e 100644
--- a/packages/frontend/src/stdlib/theories/simple-schema.ts
+++ b/packages/frontend/src/stdlib/theories/simple-schema.ts
@@ -30,6 +30,11 @@ export default function createSchemaTheory(theoryMeta: TheoryMeta): Theory {
     return new Theory({
         ...theoryMeta,
         theory: thSchema.theory(),
+        equationCellMeta: {
+            name: "Equation",
+            description: "Add an equation between morphisms",
+            shortcut: ["E"],
+        },
         pushforwards: [
             {
                 target: "simple-olog",
diff --git a/packages/frontend/src/theory/theory.ts b/packages/frontend/src/theory/theory.ts
index d46c29505..bafc47900 100644
--- a/packages/frontend/src/theory/theory.ts
+++ b/packages/frontend/src/theory/theory.ts
@@ -79,6 +79,16 @@ export class Theory {
     /** Whether models of the double theory are constrained to be free. */
     readonly onlyFreeModels!: boolean;
 
+    /** Metadata for equation cells in the model editor.
+
+    When defined, equation cells are supported in models of this theory and
+    these labels drive the cell-add menu and the cell label badge. Equation
+    cells build paths on demand from `morGenerators`/`morPresentation`, which
+    only work on discrete double models, so theories that opt in must have
+    discrete models.
+     */
+    readonly equationCellMeta?: EquationCellMeta;
+
     /** Human-readable name for instances of models of theory.
 
     Defaults to "Instance of".
@@ -130,6 +140,7 @@ export class Theory {
         modelTypes?: ModelTypeMeta[];
         modelAnalyses?: ModelAnalysisMeta[];
         onlyFreeModels?: boolean;
+        equationCellMeta?: EquationCellMeta;
         instanceOfName?: string;
         instanceTypes?: InstanceTypeMeta[];
         diagramAnalyses?: DiagramAnalysisMeta[];
@@ -162,6 +173,7 @@ export class Theory {
         }
         this.modelAnalysisMap = uniqueIndexArray(props.modelAnalyses ?? [], (meta) => meta.id);
         this.onlyFreeModels = props.onlyFreeModels ?? false;
+        this.equationCellMeta = props.equationCellMeta;
 
         // Instances.
         this.instanceOfName = props.instanceOfName ?? "Instance of";
@@ -184,6 +196,11 @@ export class Theory {
         return this.inclusions.concat(this.pushforwards.map((m) => m.target));
     }
 
+    /** Whether equation cells are supported in the model editor. */
+    get supportsEquations(): boolean {
+        return this.equationCellMeta !== undefined;
+    }
+
     /** Get metadata for an object type as used in models. */
     modelObTypeMeta(typ: ObType): ModelObTypeMeta | undefined {
         return this.modelObTypeMap.get(typ);
@@ -239,6 +256,18 @@ export class Theory {
     }
 }
 
+/** Metadata for equation cells in a model editor. */
+export type EquationCellMeta = {
+    /** Human-readable name shown in the cell-add menu and as the cell label. */
+    name: string;
+
+    /** Tooltip-length description for the cell-add menu. */
+    description: string;
+
+    /** Keyboard shortcut for the cell-add menu. */
+    shortcut: KbdKey[];
+};
+
 /** Frontend metadata applicable to any type in a double theory. */
 export type BaseTypeMeta = {
     /** Human-readable name of type. */
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index f9a2a19e9..d1c662bbb 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -10,4 +10,5 @@ packages:
   - "packages/document-methods"
   - "packages/ui-components"
   - "packages/gaios"
+  - "tools/literate-typescript"
   - "tools/vite-plugin-monorepo-dedupe"
diff --git a/tools/literate-typescript/README.md b/tools/literate-typescript/README.md
new file mode 100644
index 000000000..29db5cab6
--- /dev/null
+++ b/tools/literate-typescript/README.md
@@ -0,0 +1,72 @@
+# @catcolab-dev-tools/literate-typescript
+
+A minimal literate-TypeScript verifier for `.lts.md` Markdown documents.
+
+For each `.lts.md` file passed on the command line, it:
+
+1. Extracts fenced code blocks (`ts` and `tsx`), honouring these directives:
+    - `<!-- verifier:prepend-to-following -->` — the next code fence becomes a
+      prelude: it is concatenated above every subsequent code fence (in
+      addition to being a sample itself). Use this to share imports/setup
+      across samples without repeating them.
+    - `<!-- verifier:throws -->` — the next code fence is expected to throw at
+      runtime: it is executed and must exit non-zero. If it is followed by a
+      non-code fence, that fence is matched as a substring of the runtime
+      error output (stderr) instead of stdout. A red cross emoji (❌) in
+      expected output is stripped before comparison, so it can be used to
+      flag failure cases visually.
+    - `<!-- verifier:typescript-errors -->` — the next code fence is expected
+      to fail type-checking. If it is followed by a non-code fence, that fence
+      is exact-compared against the TypeScript diagnostics for that sample,
+      formatted as `error TS2322: ...` lines without generated `.lts` paths.
+    - `<!-- verifier:skip-typecheck -->` — the next code fence is still
+      materialised (and may still be run for expected-output/throws checks),
+      but any TypeScript diagnostics it produces are ignored rather than
+      reported as failures. Use this for illustrative snippets that are not
+      meant to type-check cleanly.
+    - `<!-- verifier:skip -->` — the next code fence is skipped entirely: it is
+      not materialised, type-checked, or run, and is not added to the prepend
+      stack. Use this for purely illustrative snippets that reference names not
+      available to the verifier.
+    - `<!-- verifier:reset -->` — clears the accumulated prepend stack so the
+      next code fence starts fresh.
+2. If a code fence is immediately followed by a non-code fence, the non-code
+   fence is treated as that sample's expected stdout.
+3. Writes each assembled sample to a package-local temporary directory as
+   `<sampleId>.{ts,tsx}`. A sample is `tsx` if its body or any active prepend is
+   a `tsx` fence. The temporary files are removed after that markdown file is
+   checked.
+4. Type-checks all materialised samples with the consuming package's TypeScript
+   config (`tsconfig.lts.json` if present, else `tsconfig.json`). Use
+   `@ts-expect-error` to assert that a particular line should fail to type-check.
+5. For each sample with an expected-output fence, executes it with `tsx` and
+   exact-compares stdout (after stripping ANSI escapes and trailing whitespace)
+   against the expected output.
+
+## Solid JSX (`tsx` fences)
+
+`tsx` samples are intended for full Solid component examples:
+
+- Before execution, the sample is compiled with Babel using
+  `babel-preset-solid` — the same transform `vite-plugin-solid` applies — so
+  Solid's fine-grained reactivity works exactly as in the browser. (The
+  esbuild-based `tsx` CLI alone cannot do this; it only knows React-style JSX
+  transforms.) The compiled output is written next to the sample as
+  `<sampleId>.compiled.mjs`.
+- happy-dom globals (`document`, `window`, ...) are registered automatically
+  before the sample runs, so `render` from `solid-js/web` can mount components
+  and examples can assert on `container.innerHTML`.
+- Type-checking uses the consuming package's tsconfig; for Solid set
+  `"jsx": "preserve"` and `"jsxImportSource": "solid-js"`. The generated
+  sample files are passed to TypeScript directly, so they do not need to be
+  listed in `include`.
+- `solid-js` is resolved from the consuming package (it must be a dependency
+  there); the Babel and happy-dom machinery is owned by this tool.
+
+## Usage
+
+```
+literate-typescript path/to/file.lts.md [more.lts.md ...]
+```
+
+No `.lts/` directory needs to be added to the consuming package's `.gitignore`.
diff --git a/tools/literate-typescript/bin/literate-typescript.mjs b/tools/literate-typescript/bin/literate-typescript.mjs
new file mode 100755
index 000000000..85bf2060a
--- /dev/null
+++ b/tools/literate-typescript/bin/literate-typescript.mjs
@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Bin shim: load the TypeScript CLI through tsx so the tool can be invoked
+ * directly via the package's `bin` entry without a build step.
+ */
+
+import { tsImport } from "tsx/esm/api";
+
+await tsImport("../src/cli.ts", import.meta.url);
diff --git a/tools/literate-typescript/package.json b/tools/literate-typescript/package.json
new file mode 100644
index 000000000..dbcd922ab
--- /dev/null
+++ b/tools/literate-typescript/package.json
@@ -0,0 +1,27 @@
+{
+    "name": "@catcolab-dev-tools/literate-typescript",
+    "version": "0.0.0",
+    "private": true,
+    "bin": {
+        "literate-typescript": "./bin/literate-typescript.mjs"
+    },
+    "type": "module",
+    "scripts": {
+        "format": "oxfmt .",
+        "lint": "oxlint --fix && oxfmt .",
+        "check": "tsc && pnpm run lint",
+        "ci": "tsc && oxlint --deny-warnings && oxfmt --check ."
+    },
+    "dependencies": {
+        "@babel/core": "^7.26.0",
+        "@babel/preset-typescript": "^7.26.0",
+        "@happy-dom/global-registrator": "^20.0.0",
+        "babel-preset-solid": "^1.9.3",
+        "tsx": "^4.19.0",
+        "typescript": "^6.0.3"
+    },
+    "devDependencies": {
+        "@types/babel__core": "^7.20.5",
+        "@types/node": "^24.0.0"
+    }
+}
diff --git a/tools/literate-typescript/pnpm-lock.yaml b/tools/literate-typescript/pnpm-lock.yaml
new file mode 100644
index 000000000..69142f89f
--- /dev/null
+++ b/tools/literate-typescript/pnpm-lock.yaml
@@ -0,0 +1,973 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      '@babel/core':
+        specifier: ^7.26.0
+        version: 7.29.7
+      '@babel/preset-typescript':
+        specifier: ^7.26.0
+        version: 7.29.7(@babel/core@7.29.7)
+      '@happy-dom/global-registrator':
+        specifier: ^20.0.0
+        version: 20.9.0
+      babel-preset-solid:
+        specifier: ^1.9.3
+        version: 1.9.12(@babel/core@7.29.7)
+      tsx:
+        specifier: ^4.19.0
+        version: 4.22.1
+      typescript:
+        specifier: ^6.0.3
+        version: 6.0.3
+    devDependencies:
+      '@types/babel__core':
+        specifier: ^7.20.5
+        version: 7.20.5
+      '@types/node':
+        specifier: ^24.0.0
+        version: 24.12.4
+
+packages:
+
+  '@babel/code-frame@7.29.7':
+    resolution: {integrity: sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/compat-data@7.29.7':
+    resolution: {integrity: sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/core@7.29.7':
+    resolution: {integrity: sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/generator@7.29.7':
+    resolution: {integrity: sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-annotate-as-pure@7.29.7':
+    resolution: {integrity: sha512-OoK6239jHPuSQOoS0kfTVKn0b/rVTk0seKq4Gd2UMLtmOVLjDC0ki3e+c90Trqv2gMfvJFqkiljrr568+qddiw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-compilation-targets@7.29.7':
+    resolution: {integrity: sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-create-class-features-plugin@7.29.7':
+    resolution: {integrity: sha512-IY3ZD9Tmooqr3TUhc3DUWxiuo8xx1DWLhd5M7hQ+ZWJamqM2BbalrBJb2MisSLoYorOj75U03qULCxQTY9r3hg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/helper-globals@7.29.7':
+    resolution: {integrity: sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-member-expression-to-functions@7.29.7':
+    resolution: {integrity: sha512-j+7JYmk1JYDtACIGj0QJqqWZjoUpMoEikQGADMaHgCMCSDqd2+P32rfcibUNrGOMWrlzK1WJBdxrB3JJQZwWtg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-module-imports@7.18.6':
+    resolution: {integrity: sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-module-imports@7.29.7':
+    resolution: {integrity: sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-module-transforms@7.29.7':
+    resolution: {integrity: sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/helper-optimise-call-expression@7.29.7':
+    resolution: {integrity: sha512-+kmGVjcT9RGYzoDwdwEqEvGgKe3BYq+O1iGzjFubaNgZHwYHP6lsF2Yghf4kEuv9BV7tYDZ913aBW9am6YKong==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-plugin-utils@7.29.7':
+    resolution: {integrity: sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-replace-supers@7.29.7':
+    resolution: {integrity: sha512-atfGXWSeCiF4DnKZIfmJfQRkSw9b9gNNXR1kqKjbhG4pGYCOnkp8OcTB8E3NXjBu8NpheSnOeNKz8KT7UNFTmQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/helper-skip-transparent-expression-wrappers@7.29.7':
+    resolution: {integrity: sha512-brcMGQaVzIeUb+6/bs1Av0f8YuNNjKY2JyvfRCsFuFsdKccEQ5Ges2y74D74NZ1Rz8lKJ9ksJkfqwQFJ/iNEyQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-string-parser@7.29.7':
+    resolution: {integrity: sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-identifier@7.29.7':
+    resolution: {integrity: sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-option@7.29.7':
+    resolution: {integrity: sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helpers@7.29.7':
+    resolution: {integrity: sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/parser@7.29.7':
+    resolution: {integrity: sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  '@babel/plugin-syntax-jsx@7.29.7':
+    resolution: {integrity: sha512-TSu8+mHCoEaaCDEZ0I3+6mvTBYR4PCxQwf2z9/r5Tbztv6NaLR3B9thGTTxX2WGuGHJqRiAbKPeGTJ5XWXVg6A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-syntax-typescript@7.29.7':
+    resolution: {integrity: sha512-ngr+82Sh0xMz25TPCZi+nC2iTzjfCdWS2ONXTp/PtSCHCgaCNBpdMqgvJ2ccdLlClVZ7sisIgB914j/JFe+RZA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-modules-commonjs@7.29.7':
+    resolution: {integrity: sha512-j0vCldybPC5b5dwCQOJ21uKtHzt7hxLygJTg9eF1ScfaikEDNfzn94XoW5Fi+seBR0nCyL23xaBFFkq7dTM8XQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-typescript@7.29.7':
+    resolution: {integrity: sha512-jK52h8LaLc7JarhQV2ofeFMts4H7vnOXnqZNA6fYglBTZewRBE51KWt3BUltW1P+KoPsYkHoJeXePuz4zo2LMw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/preset-typescript@7.29.7':
+    resolution: {integrity: sha512-/Foi8vKY2EVbed/1eZx0gJEEwHAIxogrySI7rULcRIvhZzbvoE/b5qG5Ghc0WKAFKOHA9SD1x7RsFlOYdutIiQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/template@7.29.7':
+    resolution: {integrity: sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/traverse@7.29.7':
+    resolution: {integrity: sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/types@7.29.7':
+    resolution: {integrity: sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==}
+    engines: {node: '>=6.9.0'}
+
+  '@esbuild/aix-ppc64@0.28.0':
+    resolution: {integrity: sha512-lhRUCeuOyJQURhTxl4WkpFTjIsbDayJHih5kZC1giwE+MhIzAb7mEsQMqMf18rHLsrb5qI1tafG20mLxEWcWlA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.28.0':
+    resolution: {integrity: sha512-+WzIXQOSaGs33tLEgYPYe/yQHf0WTU0X42Jca3y8NWMbUVhp7rUnw+vAsRC/QiDrdD31IszMrZy+qwPOPjd+rw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.28.0':
+    resolution: {integrity: sha512-wqh0ByljabXLKHeWXYLqoJ5jKC4XBaw6Hk08OfMrCRd2nP2ZQ5eleDZC41XHyCNgktBGYMbqnrJKq/K/lzPMSQ==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.28.0':
+    resolution: {integrity: sha512-+VJggoaKhk2VNNqVL7f6S189UzShHC/mR9EE8rDdSkdpN0KflSwWY/gWjDrNxxisg8Fp1ZCD9jLMo4m0OUfeUA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.28.0':
+    resolution: {integrity: sha512-0T+A9WZm+bZ84nZBtk1ckYsOvyA3x7e2Acj1KdVfV4/2tdG4fzUp91YHx+GArWLtwqp77pBXVCPn2We7Letr0Q==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.28.0':
+    resolution: {integrity: sha512-fyzLm/DLDl/84OCfp2f/XQ4flmORsjU7VKt8HLjvIXChJoFFOIL6pLJPH4Yhd1n1gGFF9mPwtlN5Wf82DZs+LQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.28.0':
+    resolution: {integrity: sha512-l9GeW5UZBT9k9brBYI+0WDffcRxgHQD8ShN2Ur4xWq/NFzUKm3k5lsH4PdaRgb2w7mI9u61nr2gI2mLI27Nh3Q==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.28.0':
+    resolution: {integrity: sha512-BXoQai/A0wPO6Es3yFJ7APCiKGc1tdAEOgeTNy3SsB491S3aHn4S4r3e976eUnPdU+NbdtmBuLncYir2tMU9Nw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.28.0':
+    resolution: {integrity: sha512-RVyzfb3FWsGA55n6WY0MEIEPURL1FcbhFE6BffZEMEekfCzCIMtB5yyDcFnVbTnwk+CLAgTujmV/Lgvih56W+A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.28.0':
+    resolution: {integrity: sha512-CjaaREJagqJp7iTaNQjjidaNbCKYcd4IDkzbwwxtSvjI7NZm79qiHc8HqciMddQ6CKvJT6aBd8lO9kN/ZudLlw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.28.0':
+    resolution: {integrity: sha512-KBnSTt1kxl9x70q+ydterVdl+Cn0H18ngRMRCEQfrbqdUuntQQ0LoMZv47uB97NljZFzY6HcfqEZ2SAyIUTQBQ==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.28.0':
+    resolution: {integrity: sha512-zpSlUce1mnxzgBADvxKXX5sl8aYQHo2ezvMNI8I0lbblJtp8V4odlm3Yzlj7gPyt3T8ReksE6bK+pT3WD+aJRg==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.28.0':
+    resolution: {integrity: sha512-2jIfP6mmjkdmeTlsX/9vmdmhBmKADrWqN7zcdtHIeNSCH1SqIoNI63cYsjQR8J+wGa4Y5izRcSHSm8K3QWmk3w==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.28.0':
+    resolution: {integrity: sha512-bc0FE9wWeC0WBm49IQMPSPILRocGTQt3j5KPCA8os6VprfuJ7KD+5PzESSrJ6GmPIPJK965ZJHTUlSA6GNYEhg==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.28.0':
+    resolution: {integrity: sha512-SQPZOwoTTT/HXFXQJG/vBX8sOFagGqvZyXcgLA3NhIqcBv1BJU1d46c0rGcrij2B56Z2rNiSLaZOYW5cUk7yLQ==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.28.0':
+    resolution: {integrity: sha512-SCfR0HN8CEEjnYnySJTd2cw0k9OHB/YFzt5zgJEwa+wL/T/raGWYMBqwDNAC6dqFKmJYZoQBRfHjgwLHGSrn3Q==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.28.0':
+    resolution: {integrity: sha512-us0dSb9iFxIi8srnpl931Nvs65it/Jd2a2K3qs7fz2WfGPHqzfzZTfec7oxZJRNPXPnNYZtanmRc4AL/JwVzHQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.28.0':
+    resolution: {integrity: sha512-CR/RYotgtCKwtftMwJlUU7xCVNg3lMYZ0RzTmAHSfLCXw3NtZtNpswLEj/Kkf6kEL3Gw+BpOekRX0BYCtklhUw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.28.0':
+    resolution: {integrity: sha512-nU1yhmYutL+fQ71Kxnhg8uEOdC0pwEW9entHykTgEbna2pw2dkbFSMeqjjyHZoCmt8SBkOSvV+yNmm94aUrrqw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.28.0':
+    resolution: {integrity: sha512-cXb5vApOsRsxsEl4mcZ1XY3D4DzcoMxR/nnc4IyqYs0rTI8ZKmW6kyyg+11Z8yvgMfAEldKzP7AdP64HnSC/6g==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.28.0':
+    resolution: {integrity: sha512-8wZM2qqtv9UP3mzy7HiGYNH/zjTA355mpeuA+859TyR+e+Tc08IHYpLJuMsfpDJwoLo1ikIJI8jC3GFjnRClzA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openharmony-arm64@0.28.0':
+    resolution: {integrity: sha512-FLGfyizszcef5C3YtoyQDACyg95+dndv79i2EekILBofh5wpCa1KuBqOWKrEHZg3zrL3t5ouE5jgr94vA+Wb2w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/sunos-x64@0.28.0':
+    resolution: {integrity: sha512-1ZgjUoEdHZZl/YlV76TSCz9Hqj9h9YmMGAgAPYd+q4SicWNX3G5GCyx9uhQWSLcbvPW8Ni7lj4gDa1T40akdlw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.28.0':
+    resolution: {integrity: sha512-Q9StnDmQ/enxnpxCCLSg0oo4+34B9TdXpuyPeTedN/6+iXBJ4J+zwfQI28u/Jl40nOYAxGoNi7mFP40RUtkmUA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.28.0':
+    resolution: {integrity: sha512-zF3ag/gfiCe6U2iczcRzSYJKH1DCI+ByzSENHlM2FcDbEeo5Zd2C86Aq0tKUYAJJ1obRP84ymxIAksZUcdztHA==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.28.0':
+    resolution: {integrity: sha512-pEl1bO9mfAmIC+tW5btTmrKaujg3zGtUmWNdCw/xs70FBjwAL3o9OEKNHvNmnyylD6ubxUERiEhdsL0xBQ9efw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@happy-dom/global-registrator@20.9.0':
+    resolution: {integrity: sha512-lBW6/m5BIFl3pMuWPNN0lIOYw9LMCmPfix53ExS3FBi4E+NELEljQ3xH6aAV9IYiQRfn9YIIgzzMrD0vIcD7tw==}
+    engines: {node: '>=20.0.0'}
+
+  '@jridgewell/gen-mapping@0.3.13':
+    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
+
+  '@jridgewell/remapping@2.3.5':
+    resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==}
+
+  '@jridgewell/resolve-uri@3.1.2':
+    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/sourcemap-codec@1.5.5':
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
+
+  '@types/babel__core@7.20.5':
+    resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
+
+  '@types/babel__generator@7.27.0':
+    resolution: {integrity: sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==}
+
+  '@types/babel__template@7.4.4':
+    resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==}
+
+  '@types/babel__traverse@7.28.0':
+    resolution: {integrity: sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==}
+
+  '@types/node@24.12.4':
+    resolution: {integrity: sha512-GUUEShf+PBCGW2KaXwcIt3Yk+e3pkKwWKb9GSyM9WQVE+ep2jzmHdGsHzu4wgcZy5fN9FBdVzjpBQsYlpfpgLA==}
+
+  '@types/whatwg-mimetype@3.0.2':
+    resolution: {integrity: sha512-c2AKvDT8ToxLIOUlN51gTiHXflsfIFisS4pO7pDPoKouJCESkhZnEy623gwP9laCy5lnLDAw1vAzu2vM2YLOrA==}
+
+  '@types/ws@8.18.1':
+    resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
+
+  babel-plugin-jsx-dom-expressions@0.40.7:
+    resolution: {integrity: sha512-/O6JWUmjv03OI9lL2ry9bUjpD5S3PclM55RRJEyCdcFZ5W2SEA/59d+l2hNsk3gI6kiWRdRPdOtqZmsQzFN1pQ==}
+    peerDependencies:
+      '@babel/core': ^7.20.12
+
+  babel-preset-solid@1.9.12:
+    resolution: {integrity: sha512-LLqnuKVDlKpyBlMPcH6qEvs/wmS9a+NczppxJ3ryS/c0O5IiSFOIBQi9GzyiGDSbcJpx4Gr87jyFTos1MyEuWg==}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+      solid-js: ^1.9.12
+    peerDependenciesMeta:
+      solid-js:
+        optional: true
+
+  baseline-browser-mapping@2.10.33:
+    resolution: {integrity: sha512-bA6+tcSLpz2tIEdDXZPpPTIuxBcC4+w6SieaYyfigIa4h8GlFxbA17v22Vx3JUtuZQj9SgOsnbK+aTBzyDyEuw==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  browserslist@4.28.2:
+    resolution: {integrity: sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
+    hasBin: true
+
+  caniuse-lite@1.0.30001793:
+    resolution: {integrity: sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA==}
+
+  convert-source-map@2.0.0:
+    resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
+
+  debug@4.4.3:
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  electron-to-chromium@1.5.364:
+    resolution: {integrity: sha512-G/dYE3+AYhyHwzTwg8UbnXf7zqMERYh7l2jJ3QujhFsH8agSYwtnGAR2aZ7f0AakIKJXd5En/Hre4igIUrdlYw==}
+
+  entities@6.0.1:
+    resolution: {integrity: sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==}
+    engines: {node: '>=0.12'}
+
+  entities@7.0.1:
+    resolution: {integrity: sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==}
+    engines: {node: '>=0.12'}
+
+  esbuild@0.28.0:
+    resolution: {integrity: sha512-sNR9MHpXSUV/XB4zmsFKN+QgVG82Cc7+/aaxJ8Adi8hyOac+EXptIp45QBPaVyX3N70664wRbTcLTOemCAnyqw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  escalade@3.2.0:
+    resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
+    engines: {node: '>=6'}
+
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  gensync@1.0.0-beta.2:
+    resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
+    engines: {node: '>=6.9.0'}
+
+  happy-dom@20.9.0:
+    resolution: {integrity: sha512-GZZ9mKe8r646NUAf/zemnGbjYh4Bt8/MqASJY+pSm5ZDtc3YQox+4gsLI7yi1hba6o+eCsGxpHn5+iEVn31/FQ==}
+    engines: {node: '>=20.0.0'}
+
+  html-entities@2.3.3:
+    resolution: {integrity: sha512-DV5Ln36z34NNTDgnz0EWGBLZENelNAtkiFA4kyNOG2tDI6Mz1uSWiq1wAKdyjnJwyDiDO7Fa2SO1CTxPXL8VxA==}
+
+  js-tokens@4.0.0:
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+
+  jsesc@3.1.0:
+    resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
+    engines: {node: '>=6'}
+    hasBin: true
+
+  json5@2.2.3:
+    resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==}
+    engines: {node: '>=6'}
+    hasBin: true
+
+  lru-cache@5.1.1:
+    resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
+
+  ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  node-releases@2.0.46:
+    resolution: {integrity: sha512-GYVXHE2KnrzAfsAjl4uP++evGFCrAU1jta4ubEjIG7YWt/64Gqv66a30yKwWczVjA6j3bM4nBwH7Pk1JmDHaxQ==}
+    engines: {node: '>=18'}
+
+  parse5@7.3.0:
+    resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  semver@6.3.1:
+    resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
+    hasBin: true
+
+  tsx@4.22.1:
+    resolution: {integrity: sha512-TvncJykhxAzFCk0VQZKBTClall4Pm7qXDSodb6uxi8QFa8X8mT6ABjxxsQ2opDRYxG7AzcRWXaFtruz5HJKuWg==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  typescript@6.0.3:
+    resolution: {integrity: sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  undici-types@7.16.0:
+    resolution: {integrity: sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==}
+
+  update-browserslist-db@1.2.3:
+    resolution: {integrity: sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==}
+    hasBin: true
+    peerDependencies:
+      browserslist: '>= 4.21.0'
+
+  whatwg-mimetype@3.0.0:
+    resolution: {integrity: sha512-nt+N2dzIutVRxARx1nghPKGv1xHikU7HKdfafKkLNLindmPU/ch3U31NOCGGA/dmPcmb1VlofO0vnKAcsm0o/Q==}
+    engines: {node: '>=12'}
+
+  ws@8.21.0:
+    resolution: {integrity: sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: '>=5.0.2'
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
+  yallist@3.1.1:
+    resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}
+
+snapshots:
+
+  '@babel/code-frame@7.29.7':
+    dependencies:
+      '@babel/helper-validator-identifier': 7.29.7
+      js-tokens: 4.0.0
+      picocolors: 1.1.1
+
+  '@babel/compat-data@7.29.7': {}
+
+  '@babel/core@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-compilation-targets': 7.29.7
+      '@babel/helper-module-transforms': 7.29.7(@babel/core@7.29.7)
+      '@babel/helpers': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+      '@jridgewell/remapping': 2.3.5
+      convert-source-map: 2.0.0
+      debug: 4.4.3
+      gensync: 1.0.0-beta.2
+      json5: 2.2.3
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/generator@7.29.7':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+      jsesc: 3.1.0
+
+  '@babel/helper-annotate-as-pure@7.29.7':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@babel/helper-compilation-targets@7.29.7':
+    dependencies:
+      '@babel/compat-data': 7.29.7
+      '@babel/helper-validator-option': 7.29.7
+      browserslist: 4.28.2
+      lru-cache: 5.1.1
+      semver: 6.3.1
+
+  '@babel/helper-create-class-features-plugin@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-annotate-as-pure': 7.29.7
+      '@babel/helper-member-expression-to-functions': 7.29.7
+      '@babel/helper-optimise-call-expression': 7.29.7
+      '@babel/helper-replace-supers': 7.29.7(@babel/core@7.29.7)
+      '@babel/helper-skip-transparent-expression-wrappers': 7.29.7
+      '@babel/traverse': 7.29.7
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-globals@7.29.7': {}
+
+  '@babel/helper-member-expression-to-functions@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-module-imports@7.18.6':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@babel/helper-module-imports@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-module-transforms@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-module-imports': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
+      '@babel/traverse': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-optimise-call-expression@7.29.7':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@babel/helper-plugin-utils@7.29.7': {}
+
+  '@babel/helper-replace-supers@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-member-expression-to-functions': 7.29.7
+      '@babel/helper-optimise-call-expression': 7.29.7
+      '@babel/traverse': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-skip-transparent-expression-wrappers@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-string-parser@7.29.7': {}
+
+  '@babel/helper-validator-identifier@7.29.7': {}
+
+  '@babel/helper-validator-option@7.29.7': {}
+
+  '@babel/helpers@7.29.7':
+    dependencies:
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
+
+  '@babel/parser@7.29.7':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
+
+  '@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
+
+  '@babel/plugin-transform-modules-commonjs@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-module-transforms': 7.29.7(@babel/core@7.29.7)
+      '@babel/helper-plugin-utils': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/plugin-transform-typescript@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-annotate-as-pure': 7.29.7
+      '@babel/helper-create-class-features-plugin': 7.29.7(@babel/core@7.29.7)
+      '@babel/helper-plugin-utils': 7.29.7
+      '@babel/helper-skip-transparent-expression-wrappers': 7.29.7
+      '@babel/plugin-syntax-typescript': 7.29.7(@babel/core@7.29.7)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/preset-typescript@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
+      '@babel/helper-validator-option': 7.29.7
+      '@babel/plugin-syntax-jsx': 7.29.7(@babel/core@7.29.7)
+      '@babel/plugin-transform-modules-commonjs': 7.29.7(@babel/core@7.29.7)
+      '@babel/plugin-transform-typescript': 7.29.7(@babel/core@7.29.7)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/template@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+
+  '@babel/traverse@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-globals': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/types@7.29.7':
+    dependencies:
+      '@babel/helper-string-parser': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
+
+  '@esbuild/aix-ppc64@0.28.0':
+    optional: true
+
+  '@esbuild/android-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/android-arm@0.28.0':
+    optional: true
+
+  '@esbuild/android-x64@0.28.0':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/darwin-x64@0.28.0':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-arm@0.28.0':
+    optional: true
+
+  '@esbuild/linux-ia32@0.28.0':
+    optional: true
+
+  '@esbuild/linux-loong64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.28.0':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-s390x@0.28.0':
+    optional: true
+
+  '@esbuild/linux-x64@0.28.0':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.28.0':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.28.0':
+    optional: true
+
+  '@esbuild/openharmony-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/sunos-x64@0.28.0':
+    optional: true
+
+  '@esbuild/win32-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/win32-ia32@0.28.0':
+    optional: true
+
+  '@esbuild/win32-x64@0.28.0':
+    optional: true
+
+  '@happy-dom/global-registrator@20.9.0':
+    dependencies:
+      '@types/node': 24.12.4
+      happy-dom: 20.9.0
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  '@jridgewell/gen-mapping@0.3.13':
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/remapping@2.3.5':
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/resolve-uri@3.1.2': {}
+
+  '@jridgewell/sourcemap-codec@1.5.5': {}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  '@types/babel__core@7.20.5':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+      '@types/babel__generator': 7.27.0
+      '@types/babel__template': 7.4.4
+      '@types/babel__traverse': 7.28.0
+
+  '@types/babel__generator@7.27.0':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@types/babel__template@7.4.4':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+
+  '@types/babel__traverse@7.28.0':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@types/node@24.12.4':
+    dependencies:
+      undici-types: 7.16.0
+
+  '@types/whatwg-mimetype@3.0.2': {}
+
+  '@types/ws@8.18.1':
+    dependencies:
+      '@types/node': 24.12.4
+
+  babel-plugin-jsx-dom-expressions@0.40.7(@babel/core@7.29.7):
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-module-imports': 7.18.6
+      '@babel/plugin-syntax-jsx': 7.29.7(@babel/core@7.29.7)
+      '@babel/types': 7.29.7
+      html-entities: 2.3.3
+      parse5: 7.3.0
+
+  babel-preset-solid@1.9.12(@babel/core@7.29.7):
+    dependencies:
+      '@babel/core': 7.29.7
+      babel-plugin-jsx-dom-expressions: 0.40.7(@babel/core@7.29.7)
+
+  baseline-browser-mapping@2.10.33: {}
+
+  browserslist@4.28.2:
+    dependencies:
+      baseline-browser-mapping: 2.10.33
+      caniuse-lite: 1.0.30001793
+      electron-to-chromium: 1.5.364
+      node-releases: 2.0.46
+      update-browserslist-db: 1.2.3(browserslist@4.28.2)
+
+  caniuse-lite@1.0.30001793: {}
+
+  convert-source-map@2.0.0: {}
+
+  debug@4.4.3:
+    dependencies:
+      ms: 2.1.3
+
+  electron-to-chromium@1.5.364: {}
+
+  entities@6.0.1: {}
+
+  entities@7.0.1: {}
+
+  esbuild@0.28.0:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.28.0
+      '@esbuild/android-arm': 0.28.0
+      '@esbuild/android-arm64': 0.28.0
+      '@esbuild/android-x64': 0.28.0
+      '@esbuild/darwin-arm64': 0.28.0
+      '@esbuild/darwin-x64': 0.28.0
+      '@esbuild/freebsd-arm64': 0.28.0
+      '@esbuild/freebsd-x64': 0.28.0
+      '@esbuild/linux-arm': 0.28.0
+      '@esbuild/linux-arm64': 0.28.0
+      '@esbuild/linux-ia32': 0.28.0
+      '@esbuild/linux-loong64': 0.28.0
+      '@esbuild/linux-mips64el': 0.28.0
+      '@esbuild/linux-ppc64': 0.28.0
+      '@esbuild/linux-riscv64': 0.28.0
+      '@esbuild/linux-s390x': 0.28.0
+      '@esbuild/linux-x64': 0.28.0
+      '@esbuild/netbsd-arm64': 0.28.0
+      '@esbuild/netbsd-x64': 0.28.0
+      '@esbuild/openbsd-arm64': 0.28.0
+      '@esbuild/openbsd-x64': 0.28.0
+      '@esbuild/openharmony-arm64': 0.28.0
+      '@esbuild/sunos-x64': 0.28.0
+      '@esbuild/win32-arm64': 0.28.0
+      '@esbuild/win32-ia32': 0.28.0
+      '@esbuild/win32-x64': 0.28.0
+
+  escalade@3.2.0: {}
+
+  fsevents@2.3.3:
+    optional: true
+
+  gensync@1.0.0-beta.2: {}
+
+  happy-dom@20.9.0:
+    dependencies:
+      '@types/node': 24.12.4
+      '@types/whatwg-mimetype': 3.0.2
+      '@types/ws': 8.18.1
+      entities: 7.0.1
+      whatwg-mimetype: 3.0.0
+      ws: 8.21.0
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  html-entities@2.3.3: {}
+
+  js-tokens@4.0.0: {}
+
+  jsesc@3.1.0: {}
+
+  json5@2.2.3: {}
+
+  lru-cache@5.1.1:
+    dependencies:
+      yallist: 3.1.1
+
+  ms@2.1.3: {}
+
+  node-releases@2.0.46: {}
+
+  parse5@7.3.0:
+    dependencies:
+      entities: 6.0.1
+
+  picocolors@1.1.1: {}
+
+  semver@6.3.1: {}
+
+  tsx@4.22.1:
+    dependencies:
+      esbuild: 0.28.0
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  typescript@6.0.3: {}
+
+  undici-types@7.16.0: {}
+
+  update-browserslist-db@1.2.3(browserslist@4.28.2):
+    dependencies:
+      browserslist: 4.28.2
+      escalade: 3.2.0
+      picocolors: 1.1.1
+
+  whatwg-mimetype@3.0.0: {}
+
+  ws@8.21.0: {}
+
+  yallist@3.1.1: {}
diff --git a/tools/literate-typescript/src/ansi.ts b/tools/literate-typescript/src/ansi.ts
new file mode 100644
index 000000000..1dbba645c
--- /dev/null
+++ b/tools/literate-typescript/src/ansi.ts
@@ -0,0 +1,18 @@
+/**
+ * Strip ANSI escape sequences from a string. Covers CSI (Control Sequence
+ * Introducer), OSC (Operating System Command), and a handful of other common
+ * escape forms emitted by terminal-aware programs.
+ *
+ * Borrowed from the chalk/ansi-regex pattern.
+ */
+
+const PATTERN = [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))",
+].join("|");
+
+const ANSI_RE = new RegExp(PATTERN, "g");
+
+export function stripAnsi(s: string): string {
+    return String(s).replace(ANSI_RE, "");
+}
diff --git a/tools/literate-typescript/src/assemble.ts b/tools/literate-typescript/src/assemble.ts
new file mode 100644
index 000000000..1b43eec47
--- /dev/null
+++ b/tools/literate-typescript/src/assemble.ts
@@ -0,0 +1,180 @@
+/**
+ * Walk the parsed item stream and produce the list of materialisable `ts`/`tsx`
+ * samples.
+ *
+ * Semantics:
+ *   - `<!-- verifier:prepend-to-following -->` marks the next code fence as a
+ *     prelude: it is added to the active prepend stack and concatenated above
+ *     every subsequent code fence (in addition to being a sample itself).
+ *   - Code fences without that directive are standalone samples (they still
+ *     see the existing prepend stack, but do not themselves get added to it).
+ *   - A non-code fence immediately following a code fence is treated as that
+ *     sample's expected stdout.
+ *   - `<!-- verifier:throws -->` marks the next code fence as expected to throw
+ *     at runtime: the sample must exit non-zero, and a following non-code fence
+ *     is matched as a substring of the runtime error output (stderr) instead of
+ *     stdout.
+ *   - `<!-- verifier:typescript-errors -->` marks the next code fence as
+ *     expected to fail type-checking: a following non-code fence is compared
+ *     against the exact TypeScript diagnostic text for that sample.
+ *   - `<!-- verifier:skip-typecheck -->` marks the next code fence so that any
+ *     TypeScript diagnostics it produces are ignored: the sample is still
+ *     materialised (and may still be run for expected-output/throws checks),
+ *     but its diagnostics never count as failures.
+ *   - `<!-- verifier:skip -->` marks the next code fence so that it is skipped
+ *     entirely: it is not materialised, type-checked, or run. Use this for
+ *     purely illustrative snippets that reference names not available to the
+ *     verifier.
+ *   - `<!-- verifier:reset -->` clears the prepend stack so the next code
+ *     fence starts fresh.
+ *   - A sample is `tsx` if its body or any active prepend is a `tsx` fence;
+ *     `tsx` samples are written with a `.tsx` extension and are compiled with
+ *     babel-preset-solid before execution.
+ *
+ * Each sample also carries the line-offset mapping needed to translate
+ * assembled-file line numbers back to the original markdown.
+ */
+
+import type { ParsedItem, SampleLanguage } from "./parse.ts";
+
+export type TsSample = {
+    id: string;
+    /** 'ts' or 'tsx'; tsx if the body or any prepend is tsx. */
+    language: SampleLanguage;
+    /** Assembled (prepends + body), each section separated by '\n'. */
+    content: string;
+    /** 1-based line of the body's first line in the markdown. */
+    mdLine: number;
+    /**
+     * Number of assembled lines that come BEFORE the body (i.e. lines contributed by
+     * prepends, plus their separator newlines). Used to map assembled-line → mdLine.
+     */
+    bodyOffset: number;
+    /** Expected stdout, if the sample is followed by a non-code fence. */
+    expectedOutput?: string;
+    /**
+     * Whether the sample is expected to throw at runtime. If set,
+     * `expectedOutput` is matched as a substring of stderr instead of stdout.
+     */
+    throws?: boolean;
+    /** Whether this sample is expected to fail TypeScript type-checking. */
+    typeErrors?: boolean;
+    /** Whether TypeScript diagnostics for this sample should be ignored. */
+    skipTypecheck?: boolean;
+    /** Whether this sample should be skipped entirely (not materialised or run). */
+    skip?: boolean;
+};
+
+export type Assembled = {
+    tsSamples: TsSample[];
+};
+
+type PrependPart = {
+    content: string;
+    language: SampleLanguage;
+};
+
+export function assemble(items: ParsedItem[], slug: string): Assembled {
+    const tsSamples: TsSample[] = [];
+
+    let prependStack: PrependPart[] = [];
+    let prependNext = false;
+    let throwsNext = false;
+    let typeErrorsNext = false;
+    let skipTypecheckNext = false;
+    let skipNext = false;
+    let lastTsSample: TsSample | null = null;
+
+    for (const item of items) {
+        if (item.kind === "directive") {
+            if (item.directive === "reset") {
+                prependStack = [];
+                prependNext = false;
+                throwsNext = false;
+                typeErrorsNext = false;
+                skipTypecheckNext = false;
+                skipNext = false;
+                lastTsSample = null;
+            } else if (item.directive === "prepend-to-following") {
+                prependNext = true;
+            } else if (item.directive === "throws") {
+                throwsNext = true;
+            } else if (item.directive === "typescript-errors") {
+                typeErrorsNext = true;
+            } else if (item.directive === "skip-typecheck") {
+                skipTypecheckNext = true;
+            } else if (item.directive === "skip") {
+                skipNext = true;
+            }
+            // Unknown directives are silently ignored so future additions
+            // remain non-fatal.
+            continue;
+        }
+
+        // item.kind === "fence"
+        if (item.language === null) {
+            // Non-code fence immediately after a code sample → expected output.
+            if (lastTsSample !== null) {
+                lastTsSample.expectedOutput = item.content;
+                lastTsSample = null;
+            }
+            continue;
+        }
+
+        if (skipNext) {
+            // Skipped fences are dropped entirely: not materialised, not
+            // type-checked, not run, and not added to the prepend stack. Reset
+            // the directive flags that would otherwise apply to this fence, and
+            // clear `lastTsSample` so a following non-code fence is not attached
+            // as expected output.
+            skipNext = false;
+            prependNext = false;
+            throwsNext = false;
+            typeErrorsNext = false;
+            skipTypecheckNext = false;
+            lastTsSample = null;
+            continue;
+        }
+
+        const prependParts = prependStack.slice();
+        const assembled =
+            prependParts.length === 0
+                ? item.content
+                : prependParts.map((p) => p.content).join("\n") + "\n" + item.content;
+        // Number of lines the prepend block contributes before the body begins.
+        let bodyOffset = 0;
+        for (const part of prependParts) {
+            bodyOffset += part.content.split("\n").length;
+        }
+
+        const language: SampleLanguage =
+            item.language === "tsx" || prependParts.some((p) => p.language === "tsx")
+                ? "tsx"
+                : "ts";
+
+        const sample: TsSample = {
+            id: `${slug}-${item.mdLine}`,
+            language,
+            content: assembled,
+            mdLine: item.mdLine,
+            bodyOffset,
+            ...(throwsNext ? { throws: true } : {}),
+            ...(typeErrorsNext ? { typeErrors: true } : {}),
+            ...(skipTypecheckNext ? { skipTypecheck: true } : {}),
+        };
+        throwsNext = false;
+        typeErrorsNext = false;
+        skipTypecheckNext = false;
+        tsSamples.push(sample);
+        lastTsSample = sample;
+
+        if (prependNext) {
+            prependStack = prependStack.concat([
+                { content: item.content, language: item.language },
+            ]);
+            prependNext = false;
+        }
+    }
+
+    return { tsSamples };
+}
diff --git a/tools/literate-typescript/src/babel-presets.d.ts b/tools/literate-typescript/src/babel-presets.d.ts
new file mode 100644
index 000000000..c986a0420
--- /dev/null
+++ b/tools/literate-typescript/src/babel-presets.d.ts
@@ -0,0 +1,17 @@
+/**
+ * Ambient declarations for Babel presets that ship no type definitions and
+ * have no @types/* package on DefinitelyTyped. Both are only ever passed to
+ * `@babel/core`'s `presets` option, so typing them as `PluginItem` suffices.
+ */
+
+declare module "babel-preset-solid" {
+    import type { PluginItem } from "@babel/core";
+    const preset: PluginItem;
+    export default preset;
+}
+
+declare module "@babel/preset-typescript" {
+    import type { PluginItem } from "@babel/core";
+    const preset: PluginItem;
+    export default preset;
+}
diff --git a/tools/literate-typescript/src/check.ts b/tools/literate-typescript/src/check.ts
new file mode 100644
index 000000000..9c0b2011f
--- /dev/null
+++ b/tools/literate-typescript/src/check.ts
@@ -0,0 +1,254 @@
+/**
+ * Type-check materialised samples using the consuming package's TypeScript
+ * configuration. Diagnostics are mapped back to original markdown line numbers
+ * via each sample's `bodyOffset`.
+ */
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import ts from "typescript";
+
+import { stripAnsi } from "./ansi.ts";
+import type { TsSample } from "./assemble.ts";
+
+export type MaterialisedSample = {
+    sample: TsSample;
+    /** Absolute path to the written .ts file. */
+    filePath: string;
+};
+
+export type CheckDiagnostic = {
+    sampleId: string;
+    mdPath: string;
+    /** 1-based line in the original markdown, or 0 when not attributable to a sample. */
+    mdLine: number;
+    /** 1-based column in the original line. */
+    column?: number;
+    code?: number;
+    category?: string;
+    message: string;
+};
+
+export type TypeErrorExpectationFailure = {
+    sampleId: string;
+    reason: string;
+    expected?: string;
+    actual?: string;
+};
+
+export type CheckResult = {
+    ok: boolean;
+    diagnostics: CheckDiagnostic[];
+    typeFailures: TypeErrorExpectationFailure[];
+};
+
+/**
+ * Write each assembled sample to disk under `outDir`.
+ */
+export function materialise(samples: TsSample[], outDir: string): MaterialisedSample[] {
+    const out: MaterialisedSample[] = [];
+    for (const sample of samples) {
+        const filePath = join(outDir, `${sample.id}.${sample.language}`);
+        // Append a trailing newline so TypeScript line counts match what editors show.
+        writeFileSync(filePath, sample.content + "\n", "utf8");
+        out.push({ sample, filePath });
+    }
+    return out;
+}
+
+/**
+ * Parse `tsconfig.json` into compiler options + base directory.
+ */
+function loadTsConfig(tsconfigPath: string): {
+    options: ts.CompilerOptions;
+    baseDir: string;
+} {
+    const text = readFileSync(tsconfigPath, "utf8");
+    const parsed = ts.parseConfigFileTextToJson(tsconfigPath, text);
+    if (parsed.error) {
+        throw new Error(
+            `Failed to parse ${tsconfigPath}: ${ts.flattenDiagnosticMessageText(parsed.error.messageText, "\n")}`,
+        );
+    }
+    const baseDir = dirname(tsconfigPath);
+    const result = ts.parseJsonConfigFileContent(
+        parsed.config,
+        ts.sys,
+        baseDir,
+        undefined,
+        tsconfigPath,
+    );
+    const errors = (result.errors ?? []).filter((e) => e.code !== 18003);
+    if (errors.length > 0) {
+        const msg = errors
+            .map((e) => ts.flattenDiagnosticMessageText(e.messageText, "\n"))
+            .join("\n");
+        throw new Error(`Errors loading ${tsconfigPath}:\n${msg}`);
+    }
+    return { options: result.options, baseDir };
+}
+
+/**
+ * Run a single ts.Program over the materialised files and return diagnostics
+ * mapped back to the original markdown.
+ */
+export function typeCheck(
+    files: MaterialisedSample[],
+    tsconfigPath: string,
+    mdPath: string,
+): CheckResult {
+    const { options } = loadTsConfig(tsconfigPath);
+
+    // Force noEmit, never write JS for samples.
+    options.noEmit = true;
+
+    // Build a lookup from absolute file path to sample for line mapping.
+    const byPath = new Map<string, TsSample>();
+    for (const m of files) {
+        byPath.set(m.filePath, m.sample);
+    }
+
+    const rootNames = files.map((f) => f.filePath);
+    const program = ts.createProgram({
+        rootNames,
+        options,
+    });
+
+    const allDiagnostics = ts.getPreEmitDiagnostics(program);
+    const diagnostics: CheckDiagnostic[] = [];
+    const expectedDiagnostics = new Map<string, CheckDiagnostic[]>();
+    const typeFailures: TypeErrorExpectationFailure[] = [];
+
+    for (const diag of allDiagnostics) {
+        const message = ts.flattenDiagnosticMessageText(diag.messageText, "\n");
+        if (!diag.file) {
+            diagnostics.push({
+                sampleId: "(global)",
+                mdPath,
+                mdLine: 0,
+                code: diag.code,
+                category: diagnosticCategory(diag),
+                message,
+            });
+            continue;
+        }
+        const sample = byPath.get(diag.file.fileName);
+        if (!sample) {
+            // Diagnostic about a library/node_modules file or something we didn't
+            // produce — surface it without md mapping.
+            const pos = diag.start ?? 0;
+            const { line, character } = diag.file.getLineAndCharacterOfPosition(pos);
+            diagnostics.push({
+                sampleId: "(external)",
+                mdPath: diag.file.fileName,
+                mdLine: line + 1,
+                column: character + 1,
+                code: diag.code,
+                category: diagnosticCategory(diag),
+                message,
+            });
+            continue;
+        }
+        const pos = diag.start ?? 0;
+        const { line, character } = diag.file.getLineAndCharacterOfPosition(pos);
+        // line is 0-based assembled-file line. Lines [0, sample.bodyOffset) belong
+        // to prepends. Lines >= bodyOffset are part of the body proper.
+        let mdLine: number;
+        if (line < sample.bodyOffset) {
+            // Diagnostic falls inside a prepend. Best-effort: report the body's
+            // first line (TS will repeat as user fixes the upstream sample).
+            mdLine = sample.mdLine;
+        } else {
+            const bodyLine = line - sample.bodyOffset; // 0-based within body
+            mdLine = sample.mdLine + bodyLine;
+        }
+        const mappedDiagnostic: CheckDiagnostic = {
+            sampleId: sample.id,
+            mdPath,
+            mdLine,
+            column: character + 1,
+            code: diag.code,
+            category: diagnosticCategory(diag),
+            message,
+        };
+        if (sample.skipTypecheck === true) {
+            // Diagnostics for this sample are ignored by request.
+            continue;
+        }
+        if (sample.typeErrors === true) {
+            const existing = expectedDiagnostics.get(sample.id) ?? [];
+            existing.push(mappedDiagnostic);
+            expectedDiagnostics.set(sample.id, existing);
+        } else {
+            diagnostics.push(mappedDiagnostic);
+        }
+    }
+
+    for (const file of files) {
+        const { sample } = file;
+        if (sample.typeErrors !== true) {
+            continue;
+        }
+        const actualDiagnostics = expectedDiagnostics.get(sample.id) ?? [];
+        const actual = formatTypeErrors(actualDiagnostics);
+        if (actualDiagnostics.length === 0) {
+            typeFailures.push({
+                sampleId: sample.id,
+                reason: "expected TypeScript errors, but the sample type-checked successfully",
+            });
+            continue;
+        }
+        if (sample.expectedOutput === undefined) {
+            continue;
+        }
+        const expected = normaliseTypeErrors(sample.expectedOutput);
+        if (actual !== expected) {
+            typeFailures.push({
+                sampleId: sample.id,
+                reason: "TypeScript diagnostics do not match expected output",
+                expected,
+                actual,
+            });
+        }
+    }
+
+    return {
+        ok: diagnostics.length === 0 && typeFailures.length === 0,
+        diagnostics,
+        typeFailures,
+    };
+}
+
+function diagnosticCategory(diag: ts.Diagnostic): string {
+    return ts.DiagnosticCategory[diag.category].toLowerCase();
+}
+
+function formatTypeErrors(diagnostics: CheckDiagnostic[]): string {
+    return normaliseTypeErrors(
+        diagnostics
+            .map(
+                (d) =>
+                    `${d.category ?? "error"} TS${d.code ?? 0}: ${formatTypeErrorMessage(d.message)}`,
+            )
+            .join("\n"),
+    );
+}
+
+function formatTypeErrorMessage(message: string): string {
+    const fieldError = message.match(/FieldError<"([^"]+)", "((?:\\.|[^"])*)">/);
+    if (fieldError) {
+        const [, field, reason] = fieldError;
+        return `Type error: ${field}: ${reason.replace(/\\"/g, '"')}`;
+    }
+    return message;
+}
+
+function normaliseTypeErrors(s: string): string {
+    const lines = stripAnsi(s)
+        .split("\n")
+        .map((line) => line.replace(/[ \t]+$/g, ""));
+    while (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    return lines.join("\n");
+}
diff --git a/tools/literate-typescript/src/cli.ts b/tools/literate-typescript/src/cli.ts
new file mode 100644
index 000000000..3eaaf068d
--- /dev/null
+++ b/tools/literate-typescript/src/cli.ts
@@ -0,0 +1,126 @@
+/**
+ * literate-typescript CLI.
+ *
+ * Usage:
+ *   literate-typescript <markdown-file>...
+ */
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { assemble } from "./assemble.ts";
+import { type MaterialisedSample, materialise, typeCheck } from "./check.ts";
+import { parse } from "./parse.ts";
+import {
+    cleanupAllOutDirs,
+    cleanupOutDir,
+    findPackageRoot,
+    findTsConfig,
+    markdownSlug,
+    prepareOutDir,
+} from "./paths.ts";
+import { type FileReport, printFileReport, totalFailures } from "./report.ts";
+import { type RunFailure, runPairs } from "./run.ts";
+
+/**
+ * Register process-level handlers that remove any leftover
+ * `.literate-typescript-*` output directories when the process is interrupted
+ * (Ctrl-C / SIGTERM) or exits. The per-file `finally` in {@link main} handles
+ * the normal and thrown-error paths; these handlers cover signals and abnormal
+ * exits, where `finally` never runs.
+ */
+function registerCleanupHandlers(): void {
+    // Synchronous best-effort sweep on any exit (including process.exit()).
+    process.on("exit", () => {
+        cleanupAllOutDirs();
+    });
+    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"] as const) {
+        process.on(signal, () => {
+            cleanupAllOutDirs();
+            // Re-raise with the conventional 128 + signal-number exit code so
+            // callers observe a normal interrupted-process exit.
+            const code = signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 129;
+            process.exit(code);
+        });
+    }
+}
+
+async function main(): Promise<void> {
+    const argv = process.argv.slice(2);
+    if (argv.length === 0) {
+        console.error("usage: literate-typescript <markdown-file>...");
+        process.exit(2);
+    }
+
+    const reports: FileReport[] = [];
+
+    for (const mdPathRaw of argv) {
+        const mdPath = resolve(mdPathRaw);
+        const text = readFileSync(mdPath, "utf8");
+        const slug = markdownSlug(mdPath);
+        const items = parse(text);
+        const { tsSamples } = assemble(items, slug);
+
+        const pkgRoot = findPackageRoot(mdPath);
+        const tsconfigPath = findTsConfig(pkgRoot);
+        const outDir = prepareOutDir(pkgRoot, slug);
+        try {
+            const materialised = materialise(tsSamples, outDir);
+            const { diagnostics, typeFailures } = typeCheck(materialised, tsconfigPath, mdPathRaw);
+
+            // Only attempt to run if type-checking passed; running broken samples
+            // produces noisier failures.
+            let runFailures: RunFailure[] = [];
+            if (diagnostics.length === 0 && typeFailures.length === 0) {
+                runFailures = await runPairs(materialised, pkgRoot, tsconfigPath);
+            }
+
+            const runCount = countRunnable(materialised);
+
+            const report: FileReport = {
+                mdPath: mdPathRaw,
+                sampleCount: tsSamples.length,
+                runCount,
+                diagnostics,
+                typeFailures,
+                runFailures,
+            };
+            reports.push(report);
+            printFileReport(report);
+        } finally {
+            cleanupOutDir(outDir);
+        }
+    }
+
+    const total = totalFailures(reports);
+    if (total > 0) {
+        process.exit(1);
+    }
+}
+
+function countRunnable(files: MaterialisedSample[]): number {
+    let n = 0;
+    for (const m of files) {
+        if (
+            m.sample.typeErrors !== true &&
+            (m.sample.expectedOutput !== undefined || m.sample.throws === true)
+        ) {
+            n += 1;
+        }
+    }
+    return n;
+}
+
+registerCleanupHandlers();
+
+main().catch((err: unknown) => {
+    // Ensure any output directory not yet removed by a per-file `finally` is
+    // cleaned before exiting on an unexpected error.
+    cleanupAllOutDirs();
+    if (err instanceof Error && err.stack) {
+        console.error(err.stack);
+    } else {
+        console.error(err);
+    }
+    process.exit(1);
+});
diff --git a/tools/literate-typescript/src/compile.ts b/tools/literate-typescript/src/compile.ts
new file mode 100644
index 000000000..6ba0969b3
--- /dev/null
+++ b/tools/literate-typescript/src/compile.ts
@@ -0,0 +1,115 @@
+/**
+ * Compile tsx samples with Babel using `babel-preset-solid`, the same
+ * transform `vite-plugin-solid` applies. This is required because esbuild
+ * (and hence the `tsx` CLI runner) only knows React-style JSX transforms,
+ * which evaluate reactive expressions eagerly and break Solid's fine-grained
+ * reactivity.
+ *
+ * The compiled output is written next to the materialised sample as
+ * `<id>.compiled.mjs`. The `.mjs` extension keeps it outside the consuming
+ * package's `.lts/**` TypeScript includes, so it is never type-checked; the
+ * original `.tsx` file remains the type-check target.
+ *
+ * A side-effect import of `dom-register.ts` (absolute path, resolved within
+ * this package) is prefixed so happy-dom globals are installed before any
+ * Solid code runs.
+ *
+ * babel-preset-solid appends the `delegateEvents([...])` registration call to
+ * the *end* of the module body. In a normal app that is fine: the module fully
+ * evaluates (registering delegated listeners on `document`) before any event is
+ * dispatched. Our samples, however, run as a flat top-level script that mounts
+ * a component and synthesises clicks inline — so a trailing `delegateEvents`
+ * call registers the listener *after* the sample already clicked, and delegated
+ * handlers (`onClick`) never fire. The {@link hoistDelegateEvents} plugin moves
+ * those calls up to just after the import declarations so delegation is active
+ * before the sample's imperative code runs, matching bundler/test behaviour.
+ */
+
+import { writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { type PluginObj, transformAsync, types as t } from "@babel/core";
+import presetTypescript from "@babel/preset-typescript";
+import presetSolid from "babel-preset-solid";
+
+import type { MaterialisedSample } from "./check.ts";
+
+const domRegisterPath = fileURLToPath(new URL("./dom-register.ts", import.meta.url));
+
+/**
+ * Babel plugin: hoist top-level `delegateEvents([...])` expression statements to
+ * immediately after the last import declaration in the module body. Only bare
+ * top-level statements are moved (calls emitted by babel-preset-solid); calls
+ * nested inside functions or other scopes are left untouched.
+ */
+function hoistDelegateEvents(): PluginObj {
+    const isDelegateEventsStatement = (node: t.Statement): boolean =>
+        t.isExpressionStatement(node) &&
+        t.isCallExpression(node.expression) &&
+        t.isIdentifier(node.expression.callee) &&
+        node.expression.callee.name.endsWith("delegateEvents");
+
+    return {
+        name: "hoist-delegate-events",
+        visitor: {
+            Program(path) {
+                const body = path.node.body;
+                const hoisted = body.filter(isDelegateEventsStatement);
+                if (hoisted.length === 0) {
+                    return;
+                }
+                const remaining = body.filter((node) => !isDelegateEventsStatement(node));
+                let lastImport = -1;
+                for (let i = 0; i < remaining.length; i++) {
+                    if (t.isImportDeclaration(remaining[i]!)) {
+                        lastImport = i;
+                    }
+                }
+                remaining.splice(lastImport + 1, 0, ...hoisted);
+                path.node.body = remaining;
+            },
+        },
+    };
+}
+
+/**
+ * Compile a materialised tsx sample to plain JS with Solid's JSX transform.
+ *
+ * @returns Absolute path to the written `.compiled.mjs` file.
+ */
+export async function compileTsxSample(m: MaterialisedSample): Promise<string> {
+    const result = await transformAsync(m.sample.content, {
+        filename: m.filePath,
+        babelrc: false,
+        configFile: false,
+        sourceMaps: false,
+        // Presets are passed as imported modules (not names) so Babel does not
+        // try to resolve them from the consuming package's directory.
+        presets: [
+            [presetSolid, { generate: "dom" }],
+            [presetTypescript, { isTSX: true, allExtensions: true }],
+        ],
+    });
+    if (result === null || result.code === null || result.code === undefined) {
+        throw new Error(`Babel produced no output for ${m.filePath}`);
+    }
+
+    // Second pass: run the hoist plugin over the JSX-transformed output. It must
+    // run *after* preset-solid (which appends the `delegateEvents` call to the
+    // module tail), so it cannot share the first pass — Babel runs plugins
+    // before presets, and the call does not exist yet at that point.
+    const hoisted = await transformAsync(result.code, {
+        filename: m.filePath,
+        babelrc: false,
+        configFile: false,
+        sourceMaps: false,
+        plugins: [hoistDelegateEvents],
+    });
+    if (hoisted === null || hoisted.code === null || hoisted.code === undefined) {
+        throw new Error(`Babel produced no output for ${m.filePath}`);
+    }
+
+    const compiled = `import ${JSON.stringify(domRegisterPath)};\n${hoisted.code}\n`;
+    const outPath = m.filePath.replace(/\.tsx$/, ".compiled.mjs");
+    writeFileSync(outPath, compiled, "utf8");
+    return outPath;
+}
diff --git a/tools/literate-typescript/src/dom-register.ts b/tools/literate-typescript/src/dom-register.ts
new file mode 100644
index 000000000..26c8fd6dd
--- /dev/null
+++ b/tools/literate-typescript/src/dom-register.ts
@@ -0,0 +1,12 @@
+/**
+ * Register happy-dom globals (document, window, HTMLElement, ...) so tsx
+ * samples can mount Solid components into a real-enough DOM.
+ *
+ * This module is injected (by absolute path) at the top of every compiled tsx
+ * sample, so it must resolve `@happy-dom/global-registrator` from this
+ * package, not from the consuming package.
+ */
+
+import { GlobalRegistrator } from "@happy-dom/global-registrator";
+
+GlobalRegistrator.register();
diff --git a/tools/literate-typescript/src/parse.ts b/tools/literate-typescript/src/parse.ts
new file mode 100644
index 000000000..f98a04605
--- /dev/null
+++ b/tools/literate-typescript/src/parse.ts
@@ -0,0 +1,80 @@
+/**
+ * Parse a `.lts.md` Markdown file into an ordered list of fenced code blocks
+ * and directives.
+ *
+ * Each fence carries:
+ *   - language: 'ts' or 'tsx' for type-checked/executed samples; null for
+ *     free-form fences (treated as expected output of the preceding sample, if
+ *     any).
+ *   - content: raw text of the fence body (no fence delimiters).
+ *   - mdLine: 1-based line number in the markdown of the first line of fence body.
+ *
+ * Directives are emitted as ordered events; the assembler walks fences and
+ * directives together.
+ *
+ * Recognised comment forms:
+ *   <!-- verifier:reset -->
+ *
+ * Anything else is treated as prose.
+ */
+
+const DIRECTIVE_RE = /^<!--\s*verifier:([a-z0-9-]+)\s*-->\s*$/;
+const FENCE_OPEN_RE = /^(```+)([a-zA-Z0-9_-]*)\s*$/;
+
+export type SampleLanguage = "ts" | "tsx";
+
+export type FenceItem = {
+    kind: "fence";
+    language: SampleLanguage | null;
+    content: string;
+    /** 1-based line of first content line. */
+    mdLine: number;
+};
+
+export type DirectiveItem = {
+    kind: "directive";
+    directive: string;
+};
+
+export type ParsedItem = FenceItem | DirectiveItem;
+
+export function parse(text: string): ParsedItem[] {
+    const lines = text.split("\n");
+    const items: ParsedItem[] = [];
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] as string;
+
+        const directiveMatch = DIRECTIVE_RE.exec(line);
+        if (directiveMatch) {
+            items.push({ kind: "directive", directive: directiveMatch[1] as string });
+            continue;
+        }
+
+        const fenceMatch = FENCE_OPEN_RE.exec(line);
+        if (fenceMatch) {
+            const fenceMarker = fenceMatch[1] as string;
+            const language = fenceMatch[2] || null;
+            const bodyStart = i + 1;
+            let j = bodyStart;
+            for (; j < lines.length; j++) {
+                const ln = lines[j] as string;
+                if (ln.startsWith(fenceMarker) && /^`+\s*$/.test(ln)) {
+                    break;
+                }
+            }
+            const content = lines.slice(bodyStart, j).join("\n");
+            const normalisedLanguage: SampleLanguage | null =
+                language === "ts" || language === "tsx" ? language : null;
+            items.push({
+                kind: "fence",
+                language: normalisedLanguage,
+                content,
+                mdLine: bodyStart + 1, // 1-based
+            });
+            i = j; // skip past closing fence
+        }
+    }
+
+    return items;
+}
diff --git a/tools/literate-typescript/src/paths.ts b/tools/literate-typescript/src/paths.ts
new file mode 100644
index 000000000..41cf535d9
--- /dev/null
+++ b/tools/literate-typescript/src/paths.ts
@@ -0,0 +1,105 @@
+/**
+ * Helpers for locating the consuming package root, its tsconfig, and the
+ * temporary sample output directory.
+ */
+
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { basename, dirname, join, parse as parsePath, resolve } from "node:path";
+
+/**
+ * Find the nearest ancestor directory of `start` that contains a `package.json`.
+ *
+ * @param start Absolute path of a file or directory.
+ * @returns Absolute path to the package root.
+ */
+export function findPackageRoot(start: string): string {
+    let dir = resolve(start);
+    if (existsSync(dir) && parsePath(dir).ext !== "") {
+        dir = dirname(dir);
+    }
+    while (true) {
+        if (existsSync(join(dir, "package.json"))) {
+            return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            throw new Error(
+                `Could not find package.json above ${start}; literate-typescript requires the markdown file to live inside a package.`,
+            );
+        }
+        dir = parent;
+    }
+}
+
+/**
+ * Pick the tsconfig to use for type-checking samples. Prefers `tsconfig.lts.json`
+ * in the package root over `tsconfig.json`.
+ */
+export function findTsConfig(pkgRoot: string): string {
+    const preferred = join(pkgRoot, "tsconfig.lts.json");
+    if (existsSync(preferred)) {
+        return preferred;
+    }
+    const fallback = join(pkgRoot, "tsconfig.json");
+    if (existsSync(fallback)) {
+        return fallback;
+    }
+    throw new Error(`Neither tsconfig.lts.json nor tsconfig.json found in ${pkgRoot}.`);
+}
+
+/**
+ * Compute the per-markdown slug: filename with `.lts.md` or `.md` stripped.
+ */
+export function markdownSlug(mdPath: string): string {
+    const base = basename(mdPath);
+    return base
+        .replace(/\.lts\.md$/i, "")
+        .replace(/\.md$/i, "")
+        .replace(/[^a-zA-Z0-9_-]+/g, "-");
+}
+
+/**
+ * Output directories created by {@link prepareOutDir} that have not yet been
+ * cleaned up. Tracked so that interruption/crash handlers (see
+ * {@link cleanupAllOutDirs}) can remove leftovers the normal `finally` path
+ * would otherwise miss.
+ */
+const activeOutDirs = new Set<string>();
+
+/**
+ * Create a per-markdown output directory in the package root.
+ *
+ * Keeping samples inside the package preserves package self-resolution and
+ * normal `node_modules` lookup without writing to the old `.lts` directory.
+ *
+ * @returns Absolute path to the output directory.
+ */
+export function prepareOutDir(pkgRoot: string, slug: string): string {
+    const dir = mkdtempSync(join(pkgRoot, `.literate-typescript-${slug}-`));
+    activeOutDirs.add(dir);
+    return dir;
+}
+
+/**
+ * Remove a temporary output directory created by `prepareOutDir`.
+ */
+export function cleanupOutDir(dir: string): void {
+    rmSync(dir, { recursive: true, force: true });
+    activeOutDirs.delete(dir);
+}
+
+/**
+ * Remove every output directory still tracked as active. Best-effort: used by
+ * the CLI's interruption/crash handlers so `.literate-typescript-*` folders do
+ * not leak when the process is killed (SIGINT/SIGTERM) or exits abnormally.
+ */
+export function cleanupAllOutDirs(): void {
+    for (const dir of activeOutDirs) {
+        try {
+            rmSync(dir, { recursive: true, force: true });
+        } catch {
+            // Best-effort during teardown; ignore failures.
+        }
+    }
+    activeOutDirs.clear();
+}
diff --git a/tools/literate-typescript/src/report.ts b/tools/literate-typescript/src/report.ts
new file mode 100644
index 000000000..c9363e65d
--- /dev/null
+++ b/tools/literate-typescript/src/report.ts
@@ -0,0 +1,85 @@
+/**
+ * Format check + run results for the console.
+ */
+
+/* eslint-disable no-console */
+
+import type { CheckDiagnostic, TypeErrorExpectationFailure } from "./check.ts";
+import type { RunFailure } from "./run.ts";
+
+export type FileReport = {
+    mdPath: string;
+    sampleCount: number;
+    runCount: number;
+    diagnostics: CheckDiagnostic[];
+    typeFailures: TypeErrorExpectationFailure[];
+    runFailures: RunFailure[];
+};
+
+export function printFileReport(report: FileReport): void {
+    const { mdPath, sampleCount, runCount, diagnostics, typeFailures, runFailures } = report;
+    const failed = diagnostics.length + typeFailures.length + runFailures.length;
+
+    if (failed === 0) {
+        console.log(
+            `\u2713 ${mdPath}  (${sampleCount} sample${sampleCount === 1 ? "" : "s"}` +
+                (runCount > 0 ? `, ${runCount} executed` : "") +
+                ")",
+        );
+        return;
+    }
+
+    console.log(
+        `\u2717 ${mdPath}  (${diagnostics.length} type error${diagnostics.length === 1 ? "" : "s"}, ` +
+            `${typeFailures.length} type expectation failure${typeFailures.length === 1 ? "" : "s"}, ` +
+            `${runFailures.length} run failure${runFailures.length === 1 ? "" : "s"})`,
+    );
+    for (const d of diagnostics) {
+        const loc =
+            d.mdLine > 0 ? `${d.mdPath}:${d.mdLine}${d.column ? `:${d.column}` : ""}` : d.mdPath;
+        console.log(`  [${d.sampleId}] ${loc}: ${d.message}`);
+    }
+    for (const f of typeFailures) {
+        printExpectedActual(f.sampleId, f.reason, f.expected, f.actual);
+    }
+    for (const f of runFailures) {
+        printExpectedActual(f.sampleId, f.reason, f.expected, f.actual);
+        if (f.stderr) {
+            console.log("    stderr:");
+            for (const line of f.stderr.split("\n")) {
+                console.log(`      ${line}`);
+            }
+        }
+    }
+}
+
+function printExpectedActual(
+    sampleId: string,
+    reason: string,
+    expected?: string,
+    actual?: string,
+): void {
+    console.log(`  [${sampleId}] ${reason}`);
+    if (expected === undefined || actual === undefined) {
+        return;
+    }
+    console.log("    expected:");
+    for (const line of expected.split("\n")) {
+        console.log(`      ${line}`);
+    }
+    console.log("    actual:");
+    for (const line of actual.split("\n")) {
+        console.log(`      ${line}`);
+    }
+}
+
+/**
+ * @returns Total failure count.
+ */
+export function totalFailures(reports: FileReport[]): number {
+    let n = 0;
+    for (const r of reports) {
+        n += r.diagnostics.length + r.typeFailures.length + r.runFailures.length;
+    }
+    return n;
+}
diff --git a/tools/literate-typescript/src/run.ts b/tools/literate-typescript/src/run.ts
new file mode 100644
index 000000000..913e25266
--- /dev/null
+++ b/tools/literate-typescript/src/run.ts
@@ -0,0 +1,197 @@
+/**
+ * Execute samples that carry an expected-output body via `tsx` and compare
+ * stdout against the expected text. Samples marked `throws` are expected to
+ * exit non-zero; their expected-output body (if any) is matched as a substring
+ * of stderr.
+ *
+ * `tsx`-language samples (Solid JSX) are first compiled with
+ * babel-preset-solid (see compile.ts); the compiled `.mjs` is what gets
+ * executed. The `tsx` CLI still drives execution either way, so transitive
+ * `.ts` imports and tsconfig path mappings keep resolving.
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
+
+import { stripAnsi } from "./ansi.ts";
+import type { MaterialisedSample } from "./check.ts";
+import { compileTsxSample } from "./compile.ts";
+
+export type RunFailure = {
+    sampleId: string;
+    /** Human-readable failure reason. */
+    reason: string;
+    expected?: string;
+    actual?: string;
+    stderr?: string;
+    exitCode?: number;
+};
+
+/**
+ * Normalise output for comparison: strip ANSI, remove red cross emoji
+ * decorations (`\u274c`, optionally followed by a space), then trim trailing
+ * whitespace on each line, then trim trailing blank lines. The emoji lets
+ * expected-output fences flag failure cases visually without affecting the
+ * comparison.
+ */
+export function normalise(s: string): string {
+    const stripped = stripAnsi(s).replace(/\u274c ?/g, "");
+    const lines = stripped.split("\n").map((line) => line.replace(/[ \t]+$/g, ""));
+    while (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    return lines.join("\n");
+}
+
+/**
+ * Resolve a `tsx` binary. Relies on tsx being a workspace dep of the consuming
+ * package (or hoisted by pnpm), so the spawn from `pkgRoot` finds it via
+ * `node_modules/.bin/tsx` on PATH.
+ */
+function resolveTsxBin(): string {
+    return "tsx";
+}
+
+/**
+ * Spawn tsx with the given file and capture stdio.
+ */
+function runOne(
+    filePath: string,
+    cwd: string,
+    tsconfigPath: string,
+): Promise<{ stdout: string; stderr: string; code: number }> {
+    return new Promise((resolve, reject) => {
+        // Ensure <cwd>/node_modules/.bin is on PATH so a tsx installed as a
+        // (dev-)dependency of the consuming package is found, regardless of how
+        // the CLI was invoked.
+        const localBin = join(cwd, "node_modules", ".bin");
+        const existingPath = process.env.PATH || "";
+        const augmentedPath = existsSync(localBin)
+            ? `${localBin}${delimiter}${existingPath}`
+            : existingPath;
+
+        // Pass `--conditions=browser --conditions=development` so packages
+        // exporting different builds for node vs browser (e.g. `solid-js`)
+        // resolve to their browser/dev build, where reactivity is active.
+        const proc = spawn(
+            resolveTsxBin(),
+            [
+                "--conditions=browser",
+                "--conditions=development",
+                "--tsconfig",
+                tsconfigPath,
+                filePath,
+            ],
+            {
+                cwd,
+                env: {
+                    ...process.env,
+                    PATH: augmentedPath,
+                    FORCE_COLOR: "0",
+                    NODE_DISABLE_COLORS: "1",
+                    NODE_OPTIONS: "",
+                },
+                stdio: ["ignore", "pipe", "pipe"],
+            },
+        );
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (chunk: Buffer) => {
+            stdout += chunk.toString();
+        });
+        proc.stderr.on("data", (chunk: Buffer) => {
+            stderr += chunk.toString();
+        });
+        proc.on("error", reject);
+        proc.on("close", (code) => {
+            resolve({ stdout, stderr, code: code ?? 1 });
+        });
+    });
+}
+
+/**
+ * For each materialised sample carrying an `expectedOutput` or marked
+ * `throws`, run the sample with tsx and check the outcome. Returns a list of
+ * failures (empty on success).
+ */
+export async function runPairs(
+    files: MaterialisedSample[],
+    pkgRoot: string,
+    tsconfigPath: string,
+): Promise<RunFailure[]> {
+    const failures: RunFailure[] = [];
+    for (const m of files) {
+        const expected = m.sample.expectedOutput;
+        const throws = m.sample.throws === true;
+        if (m.sample.typeErrors === true) {
+            continue;
+        }
+        if (expected === undefined && !throws) {
+            continue;
+        }
+
+        let entryPath = m.filePath;
+        if (m.sample.language === "tsx") {
+            try {
+                entryPath = await compileTsxSample(m);
+            } catch (err) {
+                failures.push({
+                    sampleId: m.sample.id,
+                    reason: `Solid JSX compilation failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+        }
+
+        const { stdout, stderr, code } = await runOne(entryPath, pkgRoot, tsconfigPath);
+        if (throws) {
+            if (code === 0) {
+                failures.push({
+                    sampleId: m.sample.id,
+                    reason: "expected the sample to throw, but it exited with code 0",
+                    exitCode: code,
+                });
+                continue;
+            }
+            if (expected !== undefined) {
+                const actualErr = normalise(stderr);
+                const expectedErr = normalise(expected);
+                if (!actualErr.includes(expectedErr)) {
+                    failures.push({
+                        sampleId: m.sample.id,
+                        reason: "runtime error output does not contain expected text",
+                        expected: expectedErr,
+                        actual: actualErr,
+                    });
+                }
+            }
+            continue;
+        }
+        if (expected === undefined) {
+            // Unreachable: non-throws samples without expected output are
+            // skipped above. Guard keeps the narrowing explicit.
+            continue;
+        }
+        if (code !== 0) {
+            failures.push({
+                sampleId: m.sample.id,
+                reason: `tsx exited with code ${code}`,
+                exitCode: code,
+                stderr,
+            });
+            continue;
+        }
+        const actual = normalise(stdout);
+        const expectedNorm = normalise(expected);
+        if (actual !== expectedNorm) {
+            failures.push({
+                sampleId: m.sample.id,
+                reason: "stdout does not match expected output",
+                expected: expectedNorm,
+                actual,
+            });
+        }
+    }
+    return failures;
+}
diff --git a/tools/literate-typescript/tsconfig.json b/tools/literate-typescript/tsconfig.json
new file mode 100644
index 000000000..50026b894
--- /dev/null
+++ b/tools/literate-typescript/tsconfig.json
@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "lib": ["ES2023"],
+        "types": ["node"],
+        "skipLibCheck": true,
+
+        "moduleResolution": "bundler",
+        "isolatedModules": true,
+        "noEmit": true,
+        "allowImportingTsExtensions": true,
+
+        "strict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noFallthroughCasesInSwitch": true
+    },
+    "include": ["src"]
+}