videobook-engine 2.0.1 → 4.2.0

package/dist/domain.js

@@ -1,8 +1,11 @@
 import { ok } from "./engine-types.js";
-import { resultOf, syncResultOf, } from "./context.js";
+import { normalizeSearchLocation } from "./mvp-time.js";
+import { resultOf, syncResultOf } from "./context.js";
 import { assertUuidV7, newUuidV7 } from "./ids.js";
+import { isValidNotebookCellSlug, NOTEBOOK_CELL_TYPES } from "./schema.js";
 import { canonicalJson, parseJson } from "./store.js";
 import { EngineFault } from "./store.js";
+const NOTEBOOK_CELL_TYPE_SET = new Set(NOTEBOOK_CELL_TYPES);
 export function createEntitiesApi(context) {
     return {
         create: (type, name, input = {}) => createEntity(context, type, name, input),
@@ -26,6 +29,10 @@ export function createNotebooksApi(context) {
         list: () => listNotebooks(context),
         read: (notebookId) => syncResultOf(() => requiredNotebook(context, notebookId)),
         write: (notebook) => writeNotebook(context, notebook),
+        insertCell: (notebookId, cell) => insertNotebookCell(context, notebookId, cell),
+        updateCell: (notebookId, cell) => updateNotebookCell(context, notebookId, cell),
+        moveCell: (notebookId, cellId, slot) => moveNotebookCell(context, notebookId, cellId, slot),
+        removeCell: (notebookId, cellId) => removeNotebookCell(context, notebookId, cellId),
         delete: (notebookId) => deleteNotebook(context, notebookId),
         recordRun: (run) => recordNotebookRun(context, run),
     };
@@ -37,9 +44,10 @@ async function createEntity(context, type, name, input) {
         const entityId = newUuidV7();
         const mutation = await context.store.semantic({
             operation: "create_entity",
+            tables: ["entities"],
             details: { entityId, type, name: normalizedName },
             writeSet: [`entity:${entityId}`],
-        }, ["entities"], (_operationId, now) => {
+        }, (_operationId, now) => {
             context.store.db
                 .prepare(`INSERT INTO entities(
               entity_id, type, name, description, prompt, data_json, created_at
@@ -70,9 +78,10 @@ async function writeEntity(context, entity) {
         const name = requiredText(entity.name, "Entity name");
         const mutation = await context.store.semantic({
             operation: "write_entity",
+            tables: ["entities"],
             details: { entityId: entity.id, type: entity.type },
             writeSet: [`entity:${entity.id}`],
-        }, ["entities"], () => {
+        }, () => {
             context.store.db
                 .prepare(`UPDATE entities
              SET type=?, name=?, description=?, prompt=?, data_json=?
@@ -88,7 +97,7 @@ async function deleteEntity(context, entityId) {
         requiredEntity(context, entityId);
         const cells = context.store.db
             .prepare(`SELECT notebook_id, cell_id FROM cells
-         WHERE entity_id=? ORDER BY notebook_id, cell_id`)
+         WHERE output_entity_id=? ORDER BY notebook_id, cell_id`)
             .all(entityId);
         if (cells.length > 0) {
             throw new EngineFault({
@@ -96,7 +105,7 @@ async function deleteEntity(context, entityId) {
                 message: `Entity is still referenced: ${entityId}`,
                 details: {
                     references: cells.map((cell) => ({
-                        kind: "cell.entity",
+                        kind: "cell.output_entity",
                         id: `${cell.notebook_id}/${cell.cell_id}`,
                     })),
                 },
@@ -104,9 +113,10 @@ async function deleteEntity(context, entityId) {
         }
         const mutation = await context.store.semantic({
             operation: "delete_entity",
+            tables: ["entities"],
             details: { entityId },
             writeSet: [`entity:${entityId}`],
-        }, ["entities"], () => {
+        }, () => {
             context.store.db
                 .prepare("DELETE FROM entities WHERE entity_id=?")
                 .run(entityId);
@@ -120,13 +130,14 @@ async function createNotebook(context, name) {
         const notebookId = newUuidV7();
         const mutation = await context.store.semantic({
             operation: "create_notebook",
+            tables: ["notebooks"],
             details: { notebookId, name: normalizedName },
             writeSet: [`notebook:${notebookId}`],
-        }, ["notebooks"], (_operationId, now) => {
+        }, (_operationId, now) => {
             context.store.db
                 .prepare(`INSERT INTO notebooks(
-              notebook_id, name, properties_json, created_at
-            ) VALUES (?, ?, '{}', ?)`)
+              notebook_id, name, created_at
+            ) VALUES (?, ?, ?)`)
                 .run(notebookId, normalizedName, now);
         });
         return ok(requiredNotebook(context, notebookId), mutation.revision);
@@ -145,31 +156,267 @@ async function writeNotebook(context, notebook) {
         validateNotebook(context, notebook);
         const mutation = await context.store.semantic({
             operation: "write_notebook",
+            tables: [
+                "notebooks",
+                "notebook_fields",
+                "cells",
+                "notebook_cell_executions",
+                "notebook_generation_plans",
+                "notebook_run_plans",
+                "notebook_transcript_edits",
+                "notebook_transcript_attachments",
+                "edges",
+                "cell_references",
+                "pinned_search_results",
+            ],
             details: { notebookId: notebook.id },
             writeSet: [
                 `notebook:${notebook.id}`,
                 ...notebook.cells.map((cell) => `cell:${notebook.id}:${cell.id}`),
                 ...notebook.edges.map((edge) => `edge:${notebook.id}:${edge.id}`),
             ],
-        }, ["notebooks", "cells", "edges"], () => {
+        }, () => {
             context.store.db
-                .prepare(`UPDATE notebooks SET name=?, properties_json=?
-             WHERE notebook_id=?`)
-                .run(requiredText(notebook.name, "Notebook name"), canonicalJson(notebook.properties ?? {}), notebook.id);
+                .prepare(`UPDATE notebooks SET name=? WHERE notebook_id=?`)
+                .run(requiredText(notebook.name, "Notebook name"), notebook.id);
             synchronizeNotebookChildren(context, notebook);
+            synchronizeNotebookState(context, notebook);
+        });
+        return ok(revisionFor(context, mutation.revision), mutation.revision);
+    });
+}
+async function insertNotebookCell(context, notebookId, cell) {
+    return resultOf(async () => {
+        assertUuidV7(notebookId, "Notebook ID");
+        const notebook = requiredNotebook(context, notebookId);
+        if (notebook.cells.some((existing) => existing.id === cell.id)) {
+            throw new Error(`Cell already exists: ${cell.id}`);
+        }
+        const prospective = { ...notebook, cells: [...notebook.cells, cell] };
+        validateCellFields(context, prospective, cell);
+        assertCellSlugFree(context, notebookId, cell);
+        assertCellSlotFree(context, notebookId, cell);
+        const mutation = await context.store.semantic({
+            operation: "insert_cell",
+            tables: ["cells", "cell_references", "pinned_search_results"],
+            details: { notebookId, cellId: cell.id },
+            writeSet: [`notebook:${notebookId}`, `cell:${notebookId}:${cell.id}`],
+        }, () => {
+            upsertNotebookCell(context, notebookId, cell);
+            repairCellSlots(context, notebookId, cell.id);
+        });
+        return ok(revisionFor(context, mutation.revision), mutation.revision);
+    });
+}
+async function updateNotebookCell(context, notebookId, cell) {
+    return resultOf(async () => {
+        assertUuidV7(notebookId, "Notebook ID");
+        const notebook = requiredNotebook(context, notebookId);
+        if (!notebook.cells.some((existing) => existing.id === cell.id)) {
+            throw new EngineFault({
+                code: "NOT_FOUND",
+                message: `Cell not found: ${cell.id}`,
+            });
+        }
+        const prospective = {
+            ...notebook,
+            cells: notebook.cells.map((existing) => existing.id === cell.id ? cell : existing),
+        };
+        validateCellFields(context, prospective, cell);
+        assertCellSlugFree(context, notebookId, cell);
+        assertCellSlotFree(context, notebookId, cell);
+        const mutation = await context.store.semantic({
+            operation: "update_cell",
+            tables: ["cells", "cell_references", "pinned_search_results"],
+            details: { notebookId, cellId: cell.id },
+            writeSet: [`notebook:${notebookId}`, `cell:${notebookId}:${cell.id}`],
+        }, () => {
+            upsertNotebookCell(context, notebookId, cell);
+            repairCellSlots(context, notebookId, cell.id);
+        });
+        return ok(revisionFor(context, mutation.revision), mutation.revision);
+    });
+}
+async function moveNotebookCell(context, notebookId, cellId, slot) {
+    return resultOf(async () => {
+        assertUuidV7(notebookId, "Notebook ID");
+        assertUuidV7(cellId, "Cell ID");
+        const notebook = requiredNotebook(context, notebookId);
+        const existing = notebook.cells.find((cell) => cell.id === cellId);
+        if (!existing) {
+            throw new EngineFault({
+                code: "NOT_FOUND",
+                message: `Cell not found: ${cellId}`,
+            });
+        }
+        return updateNotebookCell(context, notebookId, { ...existing, slot });
+    });
+}
+async function removeNotebookCell(context, notebookId, cellId) {
+    return resultOf(async () => {
+        assertUuidV7(notebookId, "Notebook ID");
+        assertUuidV7(cellId, "Cell ID");
+        requiredNotebook(context, notebookId);
+        const found = context.store.db
+            .prepare("SELECT 1 AS present FROM cells WHERE notebook_id=? AND cell_id=?")
+            .get(notebookId, cellId);
+        if (!found) {
+            throw new EngineFault({
+                code: "NOT_FOUND",
+                message: `Cell not found: ${cellId}`,
+            });
+        }
+        const mutation = await context.store.semantic({
+            operation: "remove_cell",
+            tables: [
+                "cells",
+                "notebook_cell_executions",
+                "notebook_generation_plans",
+                "edges",
+                "cell_references",
+                "pinned_search_results",
+            ],
+            details: { notebookId, cellId },
+            writeSet: [`notebook:${notebookId}`, `cell:${notebookId}:${cellId}`],
+        }, () => {
+            context.store.db
+                .prepare("DELETE FROM cells WHERE notebook_id=? AND cell_id=?")
+                .run(notebookId, cellId);
+            repairCellSlots(context, notebookId);
         });
         return ok(revisionFor(context, mutation.revision), mutation.revision);
     });
 }
+function assertCellSlugFree(context, notebookId, cell) {
+    const found = context.store.db
+        .prepare(`SELECT cell_id FROM cells
+       WHERE notebook_id=? AND slug=? AND cell_id<>?`)
+        .get(notebookId, cell.slug, cell.id);
+    if (found) {
+        throw new Error(`Duplicate cell slug: ${cell.slug}`);
+    }
+}
+function assertCellSlotFree(context, notebookId, cell) {
+    const found = context.store.db
+        .prepare(`SELECT cell_id FROM cells
+       WHERE notebook_id=? AND grid_row=? AND grid_column=? AND cell_id<>?`)
+        .get(notebookId, cell.slot.row, cell.slot.column, cell.id);
+    if (found) {
+        throw new Error(`Cell slot is occupied: ${cell.slot.row}:${cell.slot.column}`);
+    }
+}
+/**
+ * Repairs grid-slot collisions left behind by a merge (the schema no longer
+ * enforces slot uniqueness so two forks can land cells on the same slot).
+ * Within each colliding slot the protected cell wins when present, otherwise
+ * the lowest cell id; losers keep their column and move to fresh rows below
+ * the current grid, in cell-id order.
+ */
+function repairCellSlots(context, notebookId, protectedCellId) {
+    const rows = context.store.db
+        .prepare(`SELECT cell_id, grid_row, grid_column FROM cells
+       WHERE notebook_id=?
+       ORDER BY grid_row, grid_column, cell_id`)
+        .all(notebookId);
+    const slots = new Map();
+    let maxRow = -1;
+    for (const row of rows) {
+        maxRow = Math.max(maxRow, row.grid_row);
+        const key = `${row.grid_row}:${row.grid_column}`;
+        const group = slots.get(key) ?? [];
+        group.push({ cell_id: row.cell_id, grid_column: row.grid_column });
+        slots.set(key, group);
+    }
+    let nextRow = maxRow + 1;
+    const move = context.store.db.prepare("UPDATE cells SET grid_row=? WHERE notebook_id=? AND cell_id=?");
+    for (const group of slots.values()) {
+        if (group.length < 2)
+            continue;
+        const winner = protectedCellId && group.some((row) => row.cell_id === protectedCellId)
+            ? protectedCellId
+            : group[0].cell_id;
+        for (const row of group) {
+            if (row.cell_id === winner)
+                continue;
+            move.run(nextRow, notebookId, row.cell_id);
+            nextRow += 1;
+        }
+    }
+}
+/**
+ * `UNIQUE(notebook_id, slug)` is immediate and the upsert loop writes cells
+ * one at a time, so a document that validly swaps or rotates slugs between
+ * surviving cells would collide mid-loop. Every surviving cell whose slug is
+ * about to change is first parked on a unique temporary slug derived from
+ * its current one — same type prefix, so the slug/type CHECK holds — and
+ * the upsert pass then assigns the final slugs.
+ */
+function evacuateChangedCellSlugs(context, notebook) {
+    const existing = context.store.db
+        .prepare("SELECT cell_id, slug FROM cells WHERE notebook_id=?")
+        .all(notebook.id);
+    if (existing.length === 0)
+        return;
+    const incomingSlugs = new Map(notebook.cells.map((cell) => [
+        cell.id,
+        normalizeCellForWrite(cell).slug ?? "",
+    ]));
+    const evacuate = context.store.db.prepare("UPDATE cells SET slug=? WHERE notebook_id=? AND cell_id=?");
+    for (const row of existing) {
+        const nextSlug = incomingSlugs.get(row.cell_id);
+        if (nextSlug === undefined || nextSlug === row.slug)
+            continue;
+        evacuate.run(`${row.slug}-evac-${newUuidV7().replace(/-/g, "")}`, notebook.id, row.cell_id);
+    }
+}
+function upsertNotebookCell(context, notebookId, cell) {
+    const normalized = normalizeCellForWrite(cell);
+    context.store.db
+        .prepare(`INSERT INTO cells(
+        notebook_id, cell_id, type, slug, grid_row, grid_column,
+        output_entity_id, prompt, provider, model, operation, tool,
+        inputs_json, output_artifact_id
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(notebook_id, cell_id) DO UPDATE SET
+        type=excluded.type,
+        slug=excluded.slug,
+        grid_row=excluded.grid_row,
+        grid_column=excluded.grid_column,
+        output_entity_id=excluded.output_entity_id,
+        prompt=excluded.prompt,
+        provider=excluded.provider,
+        model=excluded.model,
+        operation=excluded.operation,
+        tool=excluded.tool,
+        inputs_json=excluded.inputs_json,
+        output_artifact_id=excluded.output_artifact_id`)
+        .run(notebookId, normalized.id, normalized.type, requiredText(normalized.slug, "Cell slug"), normalized.slot.row, normalized.slot.column, normalized.outputEntityId ?? null, normalized.prompt ?? null, normalized.provider ?? null, normalized.model ?? null, normalized.operation ?? null, normalized.tool ?? null, canonicalJson(normalized.inputs ?? {}), normalized.outputArtifactId ?? null);
+    synchronizeCellReferences(context, notebookId, normalized);
+    synchronizePinnedResults(context, notebookId, normalized);
+}
 async function deleteNotebook(context, notebookId) {
     return resultOf(async () => {
         assertUuidV7(notebookId, "Notebook ID");
         requiredNotebook(context, notebookId);
         const mutation = await context.store.semantic({
             operation: "delete_notebook",
+            tables: [
+                "notebooks",
+                "notebook_fields",
+                "cells",
+                "notebook_cell_executions",
+                "notebook_generation_plans",
+                "notebook_run_plans",
+                "notebook_transcript_edits",
+                "notebook_transcript_attachments",
+                "edges",
+                "runs",
+                "cell_references",
+                "pinned_search_results",
+            ],
             details: { notebookId },
             writeSet: [`notebook:${notebookId}`],
-        }, ["notebooks", "cells", "edges", "runs"], () => {
+        }, () => {
             context.store.db
                 .prepare("DELETE FROM notebooks WHERE notebook_id=?")
                 .run(notebookId);
@@ -190,9 +437,10 @@ async function recordNotebookRun(context, run) {
         }
         const mutation = await context.store.semantic({
             operation: "record_notebook_run",
+            tables: ["runs"],
             details: { notebookId: run.notebookId, runId: run.id },
             writeSet: [`run:${run.id}`],
-        }, ["runs"], () => {
+        }, () => {
             context.store.db
                 .prepare(`INSERT INTO runs(
               run_id, notebook_id, status, started_at,
@@ -231,47 +479,131 @@ function requiredNotebook(context, notebookId) {
     return notebookFromRows(context, row);
 }
 function notebookFromRows(context, row) {
+    const fields = context.store.db
+        .prepare(`SELECT field, value_json
+       FROM notebook_fields WHERE notebook_id=?
+       ORDER BY field`)
+        .all(row.notebook_id);
     const cells = context.store.db
-        .prepare(`SELECT cell_id, type, title, position_x, position_y, entity_id,
-              prompt, model, inputs_json, output_artifact_id
-       FROM cells WHERE notebook_id=? ORDER BY cell_id`)
+        .prepare(`SELECT cell_id, type, slug, grid_row, grid_column, output_entity_id,
+              prompt, provider, model, operation, tool,
+              inputs_json, output_artifact_id
+       FROM cells WHERE notebook_id=?
+       ORDER BY grid_row, grid_column, cell_id`)
         .all(row.notebook_id);
     const edges = context.store.db
         .prepare(`SELECT edge_id, source_cell_id, target_cell_id, target_input
        FROM edges WHERE notebook_id=? ORDER BY edge_id`)
         .all(row.notebook_id);
+    const references = context.store.db
+        .prepare(`SELECT cell_id, reference_id, kind, target_id, snapshot_json, ordinal
+       FROM cell_references
+       WHERE notebook_id=?
+       ORDER BY cell_id, ordinal, reference_id`)
+        .all(row.notebook_id);
+    const pinnedResults = context.store.db
+        .prepare(`SELECT cell_id, result_id, artifact_id, object_hash, location_json,
+              representative_json, query_json, signals_json,
+              selected_revision, ordinal, created_at
+       FROM pinned_search_results
+       WHERE notebook_id=?
+       ORDER BY cell_id, ordinal, result_id`)
+        .all(row.notebook_id);
+    const executions = context.store.db
+        .prepare(`SELECT cell_id, fingerprint, status, output_artifact_id,
+              provider_artifact_id, run_id, completed_at, started_at,
+              updated_at, tool, error, stale, fixture_baseline
+       FROM notebook_cell_executions
+       WHERE notebook_id=? ORDER BY cell_id`)
+        .all(row.notebook_id);
+    const generationPlans = context.store.db
+        .prepare(`SELECT plan_id, cell_id, status, plan_json, output_artifact_id,
+              error, created_at, updated_at
+       FROM notebook_generation_plans
+       WHERE notebook_id=? ORDER BY created_at, plan_id`)
+        .all(row.notebook_id);
+    const runPlans = context.store.db
+        .prepare(`SELECT plan_id, status, plan_json, paid_cell_ids_json,
+              cell_fingerprints_json, known_cost_usd, unknown_cost_count,
+              created_at, updated_at, run_id, outputs_json, error
+       FROM notebook_run_plans
+       WHERE notebook_id=? ORDER BY created_at, plan_id`)
+        .all(row.notebook_id);
+    const transcriptEdits = context.store.db
+        .prepare(`SELECT action_id, kind, restored, payload_json
+       FROM notebook_transcript_edits
+       WHERE notebook_id=? ORDER BY action_id`)
+        .all(row.notebook_id);
+    const transcriptAttachments = context.store.db
+        .prepare(`SELECT attachment_id, payload_json
+       FROM notebook_transcript_attachments
+       WHERE notebook_id=? ORDER BY attachment_id`)
+        .all(row.notebook_id);
+    const field = new Map(fields.map((item) => [
+        item.field,
+        parseJson(item.value_json, null),
+    ]));
     return {
         id: row.notebook_id,
         name: row.name,
-        properties: parseJson(row.properties_json, {}),
-        cells: cells.map(rowToCell),
+        ...(typeof field.get("description") === "string"
+            ? { description: field.get("description") }
+            : {}),
+        ...(typeof field.get("lifecycle_state") === "string"
+            ? { lifecycleState: field.get("lifecycle_state") }
+            : {}),
+        ...(typeof field.get("workflow_version") === "number"
+            ? { workflowVersion: field.get("workflow_version") }
+            : {}),
+        ...(typeof field.get("analysis_revision") === "string"
+            ? { analysisRevision: field.get("analysis_revision") }
+            : {}),
+        ...(isRecord(field.get("audio_spine"))
+            ? {
+                audioSpine: field.get("audio_spine"),
+            }
+            : {}),
+        ...(isRecord(field.get("current_selection"))
+            ? {
+                currentSelection: field.get("current_selection"),
+            }
+            : {}),
+        ...(isRecord(field.get("fixture"))
+            ? { fixture: field.get("fixture") }
+            : {}),
+        execution: Object.fromEntries(executions.map((execution) => [
+            execution.cell_id,
+            executionFromRow(execution),
+        ])),
+        generationPlans: generationPlans.map(generationPlanFromRow),
+        notebookRunPlans: runPlans.map(runPlanFromRow),
+        transcriptEdits: transcriptEdits.map(transcriptEditFromRow),
+        transcriptAttachments: transcriptAttachments.map(transcriptAttachmentFromRow),
+        cells: cells.map((cell) => rowToCell(cell, references.filter((reference) => reference.cell_id === cell.cell_id), pinnedResults.filter((result) => result.cell_id === cell.cell_id))),
         edges: edges.map(rowToEdge),
         createdAt: new Date(row.created_at).toISOString(),
     };
 }
 function validateNotebook(context, notebook) {
     const cellIds = new Set();
+    const cellSlugs = new Set();
+    const occupiedSlots = new Set();
     for (const cell of notebook.cells) {
-        assertUuidV7(cell.id, "Cell ID");
         if (cellIds.has(cell.id))
             throw new Error(`Duplicate cell ID: ${cell.id}`);
         cellIds.add(cell.id);
-        if (!["prompt", "character", "scene", "asset", "image", "video"].includes(cell.type)) {
-            throw new Error(`Invalid cell type: ${cell.type}`);
-        }
-        if (!Number.isFinite(cell.position.x) || !Number.isFinite(cell.position.y)) {
-            throw new Error(`Cell position must be finite: ${cell.id}`);
-        }
-        if (cell.entityId) {
-            assertUuidV7(cell.entityId, "Cell entity ID");
-            requiredEntity(context, cell.entityId);
-        }
-        if (cell.outputArtifactId) {
-            assertUuidV7(cell.outputArtifactId, "Cell output artifact ID");
-            context.artifactRowById(cell.outputArtifactId);
+        if (cellSlugs.has(cell.slug)) {
+            throw new Error(`Duplicate cell slug: ${cell.slug}`);
         }
+        cellSlugs.add(cell.slug);
+        const slot = `${cell.slot.row}:${cell.slot.column}`;
+        if (occupiedSlots.has(slot))
+            throw new Error(`Duplicate cell slot: ${slot}`);
+        occupiedSlots.add(slot);
+        validateCellFields(context, notebook, cell);
     }
     const edgeIds = new Set();
+    const occupiedInputs = new Set();
     for (const edge of notebook.edges) {
         assertUuidV7(edge.id, "Edge ID");
         if (edgeIds.has(edge.id))
@@ -280,29 +612,47 @@ function validateNotebook(context, notebook) {
         if (!cellIds.has(edge.source) || !cellIds.has(edge.target)) {
             throw new Error(`Edge ${edge.id} must reference cells in the notebook`);
         }
-        requiredText(edge.targetInput, "Edge targetInput");
+        const targetInput = requiredText(edge.targetInput, "Edge targetInput");
+        const inputKey = `${edge.target}:${targetInput}`;
+        if (occupiedInputs.has(inputKey)) {
+            throw new Error(`Duplicate target input: ${edge.target} ${targetInput}`);
+        }
+        occupiedInputs.add(inputKey);
+    }
+}
+function validateCellFields(context, notebook, cell) {
+    assertUuidV7(cell.id, "Cell ID");
+    if (!NOTEBOOK_CELL_TYPE_SET.has(cell.type)) {
+        throw new Error(`Invalid cell type: ${cell.type}`);
+    }
+    const slug = requiredText(cell.slug, "Cell slug");
+    if (slug !== cell.slug || !isValidNotebookCellSlug(cell.type, slug)) {
+        throw new Error(`Invalid ${cell.type} cell slug: ${cell.slug}`);
+    }
+    if (!Number.isInteger(cell.slot.row) ||
+        cell.slot.row < 0 ||
+        !Number.isInteger(cell.slot.column)) {
+        throw new Error(`Cell slot row must be nonnegative and column must be an integer: ${cell.id}`);
+    }
+    if (cell.outputEntityId) {
+        assertUuidV7(cell.outputEntityId, "Cell output entity ID");
+        requiredEntity(context, cell.outputEntityId);
     }
+    if (cell.outputArtifactId) {
+        assertUuidV7(cell.outputArtifactId, "Cell output artifact ID");
+        context.artifactRowById(cell.outputArtifactId);
+    }
+    validateCellReferences(context, notebook, cell);
+    validatePinnedResults(context, cell);
 }
 function synchronizeNotebookChildren(context, notebook) {
     deleteMissing(context, "edges", "edge_id", notebook.id, notebook.edges.map((edge) => edge.id));
     deleteMissing(context, "cells", "cell_id", notebook.id, notebook.cells.map((cell) => cell.id));
-    const upsertCell = context.store.db.prepare(`INSERT INTO cells(
-      notebook_id, cell_id, type, title, position_x, position_y,
-      entity_id, prompt, model, inputs_json, output_artifact_id
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(notebook_id, cell_id) DO UPDATE SET
-      type=excluded.type,
-      title=excluded.title,
-      position_x=excluded.position_x,
-      position_y=excluded.position_y,
-      entity_id=excluded.entity_id,
-      prompt=excluded.prompt,
-      model=excluded.model,
-      inputs_json=excluded.inputs_json,
-      output_artifact_id=excluded.output_artifact_id`);
+    evacuateChangedCellSlugs(context, notebook);
     for (const cell of notebook.cells) {
-        upsertCell.run(notebook.id, cell.id, cell.type, requiredText(cell.title, "Cell title"), cell.position.x, cell.position.y, cell.entityId ?? null, cell.prompt ?? null, cell.model ?? null, canonicalJson(cell.inputs ?? {}), cell.outputArtifactId ?? null);
+        upsertNotebookCell(context, notebook.id, cell);
     }
+    repairCellSlots(context, notebook.id);
     const upsertEdge = context.store.db.prepare(`INSERT INTO edges(
       notebook_id, edge_id, source_cell_id, target_cell_id, target_input
     ) VALUES (?, ?, ?, ?, ?)
@@ -314,6 +664,168 @@ function synchronizeNotebookChildren(context, notebook) {
         upsertEdge.run(notebook.id, edge.id, edge.source, edge.target, edge.targetInput);
     }
 }
+function synchronizeNotebookState(context, notebook) {
+    synchronizeNotebookFields(context, notebook);
+    synchronizeCellExecutions(context, notebook);
+    synchronizeGenerationPlans(context, notebook);
+    synchronizeRunPlans(context, notebook);
+    synchronizeTranscriptEdits(context, notebook);
+    synchronizeTranscriptAttachments(context, notebook);
+}
+function synchronizeNotebookFields(context, notebook) {
+    const values = new Map();
+    if (notebook.description !== undefined) {
+        values.set("description", notebook.description);
+    }
+    if (notebook.lifecycleState !== undefined) {
+        values.set("lifecycle_state", notebook.lifecycleState);
+    }
+    if (notebook.workflowVersion !== undefined) {
+        if (!Number.isSafeInteger(notebook.workflowVersion)) {
+            throw new Error("Notebook workflow version must be an integer");
+        }
+        values.set("workflow_version", notebook.workflowVersion);
+    }
+    if (notebook.analysisRevision !== undefined) {
+        values.set("analysis_revision", notebook.analysisRevision);
+    }
+    if (notebook.audioSpine !== undefined) {
+        values.set("audio_spine", notebook.audioSpine);
+    }
+    if (notebook.currentSelection !== undefined) {
+        values.set("current_selection", notebook.currentSelection);
+    }
+    if (notebook.fixture !== undefined) {
+        values.set("fixture", notebook.fixture);
+    }
+    deleteMissingNotebookRows(context, "notebook_fields", "field", notebook.id, [
+        ...values.keys(),
+    ]);
+    const upsert = context.store.db.prepare(`INSERT INTO notebook_fields(notebook_id, field, value_json)
+     VALUES (?, ?, ?)
+     ON CONFLICT(notebook_id, field) DO UPDATE SET
+       value_json=excluded.value_json`);
+    for (const [field, value] of values) {
+        upsert.run(notebook.id, field, canonicalJson(value));
+    }
+}
+function synchronizeCellExecutions(context, notebook) {
+    const entries = Object.entries(notebook.execution ?? {});
+    const cellIds = new Set(notebook.cells.map((cell) => cell.id));
+    for (const [cellId] of entries) {
+        if (!cellIds.has(cellId)) {
+            throw new Error(`Notebook execution references missing cell: ${cellId}`);
+        }
+    }
+    deleteMissingNotebookRows(context, "notebook_cell_executions", "cell_id", notebook.id, entries.map(([cellId]) => cellId));
+    const upsert = context.store.db.prepare(`INSERT INTO notebook_cell_executions(
+       notebook_id, cell_id, fingerprint, status, output_artifact_id,
+       provider_artifact_id, run_id, completed_at, started_at, updated_at,
+       tool, error, stale, fixture_baseline
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(notebook_id, cell_id) DO UPDATE SET
+       fingerprint=excluded.fingerprint,
+       status=excluded.status,
+       output_artifact_id=excluded.output_artifact_id,
+       provider_artifact_id=excluded.provider_artifact_id,
+       run_id=excluded.run_id,
+       completed_at=excluded.completed_at,
+       started_at=excluded.started_at,
+       updated_at=excluded.updated_at,
+       tool=excluded.tool,
+       error=excluded.error,
+       stale=excluded.stale,
+       fixture_baseline=excluded.fixture_baseline`);
+    for (const [cellId, execution] of entries) {
+        upsert.run(notebook.id, cellId, execution.fingerprint ?? null, execution.status ?? null, execution.outputArtifactId ?? null, execution.providerArtifactId ?? null, execution.runId ?? null, execution.completedAt ?? null, execution.startedAt ?? null, execution.updatedAt ?? null, execution.tool ?? null, execution.error ?? null, execution.stale === true ? 1 : 0, execution.fixtureBaseline === true ? 1 : 0);
+    }
+}
+function synchronizeGenerationPlans(context, notebook) {
+    const plans = notebook.generationPlans ?? [];
+    assertUnique(plans.map((plan) => plan.planId), "generation plan ID");
+    deleteMissingNotebookRows(context, "notebook_generation_plans", "plan_id", notebook.id, plans.map((plan) => plan.planId));
+    const upsert = context.store.db.prepare(`INSERT INTO notebook_generation_plans(
+       notebook_id, plan_id, cell_id, status, plan_json,
+       output_artifact_id, error, created_at, updated_at
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(notebook_id, plan_id) DO UPDATE SET
+       cell_id=excluded.cell_id,
+       status=excluded.status,
+       plan_json=excluded.plan_json,
+       output_artifact_id=excluded.output_artifact_id,
+       error=excluded.error,
+       created_at=excluded.created_at,
+       updated_at=excluded.updated_at`);
+    for (const plan of plans) {
+        upsert.run(notebook.id, requiredText(plan.planId, "Generation plan ID"), requiredText(plan.cellId, "Generation plan cell ID"), requiredText(plan.status, "Generation plan status"), canonicalJson(plan.plan), plan.outputArtifactId ?? null, plan.error ?? null, requiredText(plan.createdAt, "Generation plan created time"), requiredText(plan.updatedAt, "Generation plan updated time"));
+    }
+}
+function synchronizeRunPlans(context, notebook) {
+    const plans = notebook.notebookRunPlans ?? [];
+    assertUnique(plans.map((plan) => plan.planId), "notebook run plan ID");
+    deleteMissingNotebookRows(context, "notebook_run_plans", "plan_id", notebook.id, plans.map((plan) => plan.planId));
+    const upsert = context.store.db.prepare(`INSERT INTO notebook_run_plans(
+       notebook_id, plan_id, status, plan_json, paid_cell_ids_json,
+       cell_fingerprints_json, known_cost_usd, unknown_cost_count,
+       created_at, updated_at, run_id, outputs_json, error
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(notebook_id, plan_id) DO UPDATE SET
+       status=excluded.status,
+       plan_json=excluded.plan_json,
+       paid_cell_ids_json=excluded.paid_cell_ids_json,
+       cell_fingerprints_json=excluded.cell_fingerprints_json,
+       known_cost_usd=excluded.known_cost_usd,
+       unknown_cost_count=excluded.unknown_cost_count,
+       created_at=excluded.created_at,
+       updated_at=excluded.updated_at,
+       run_id=excluded.run_id,
+       outputs_json=excluded.outputs_json,
+       error=excluded.error`);
+    for (const plan of plans) {
+        upsert.run(notebook.id, requiredText(plan.planId, "Notebook run plan ID"), requiredText(plan.status, "Notebook run plan status"), canonicalJson(plan.plan), canonicalJson(plan.paidCellIds), canonicalJson(plan.cellDefinitionFingerprints), nonNegativeFinite(plan.knownCostUsd, "Notebook run plan known cost"), nonNegativeInteger(plan.unknownCostCount, "Notebook run plan unknown cost count"), requiredText(plan.createdAt, "Notebook run plan created time"), requiredText(plan.updatedAt, "Notebook run plan updated time"), plan.runId ?? null, plan.outputs === undefined ? null : canonicalJson(plan.outputs), plan.error ?? null);
+    }
+}
+function synchronizeTranscriptEdits(context, notebook) {
+    const edits = notebook.transcriptEdits ?? [];
+    assertUnique(edits.map((edit) => edit.actionId), "transcript edit action ID");
+    deleteMissingNotebookRows(context, "notebook_transcript_edits", "action_id", notebook.id, edits.map((edit) => edit.actionId));
+    const upsert = context.store.db.prepare(`INSERT INTO notebook_transcript_edits(
+       notebook_id, action_id, kind, restored, payload_json
+     ) VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(notebook_id, action_id) DO UPDATE SET
+       kind=excluded.kind,
+       restored=excluded.restored,
+       payload_json=excluded.payload_json`);
+    for (const edit of edits) {
+        upsert.run(notebook.id, requiredText(edit.actionId, "Transcript edit action ID"), requiredText(edit.kind, "Transcript edit kind"), edit.restored === true ? 1 : 0, canonicalJson(edit));
+    }
+}
+function synchronizeTranscriptAttachments(context, notebook) {
+    const attachments = notebook.transcriptAttachments ?? [];
+    assertUnique(attachments.map((attachment) => attachment.id), "transcript attachment ID");
+    deleteMissingNotebookRows(context, "notebook_transcript_attachments", "attachment_id", notebook.id, attachments.map((attachment) => attachment.id));
+    const upsert = context.store.db.prepare(`INSERT INTO notebook_transcript_attachments(
+       notebook_id, attachment_id, payload_json
+     ) VALUES (?, ?, ?)
+     ON CONFLICT(notebook_id, attachment_id) DO UPDATE SET
+       payload_json=excluded.payload_json`);
+    for (const attachment of attachments) {
+        upsert.run(notebook.id, requiredText(attachment.id, "Transcript attachment ID"), canonicalJson(attachment));
+    }
+}
+function deleteMissingNotebookRows(context, table, idColumn, notebookId, ids) {
+    if (ids.length === 0) {
+        context.store.db
+            .prepare(`DELETE FROM ${table} WHERE notebook_id=?`)
+            .run(notebookId);
+        return;
+    }
+    const placeholders = ids.map(() => "?").join(", ");
+    context.store.db
+        .prepare(`DELETE FROM ${table}
+       WHERE notebook_id=? AND ${idColumn} NOT IN (${placeholders})`)
+        .run(notebookId, ...ids);
+}
 function deleteMissing(context, table, idColumn, notebookId, ids) {
     if (ids.length === 0) {
         context.store.db
@@ -327,21 +839,230 @@ function deleteMissing(context, table, idColumn, notebookId, ids) {
        WHERE notebook_id=? AND ${idColumn} NOT IN (${placeholders})`)
         .run(notebookId, ...ids);
 }
-function rowToCell(row) {
+function validateCellReferences(context, notebook, cell) {
+    const ids = new Set();
+    const ordinals = new Set();
+    for (const reference of cell.references ?? []) {
+        assertUuidV7(reference.id, "Cell reference ID");
+        if (ids.has(reference.id)) {
+            throw new Error(`Duplicate cell reference ID: ${reference.id}`);
+        }
+        ids.add(reference.id);
+        validateOrdinal(reference.ordinal, "Cell reference ordinal");
+        if (ordinals.has(reference.ordinal)) {
+            throw new Error(`Duplicate cell reference ordinal: ${reference.ordinal}`);
+        }
+        ordinals.add(reference.ordinal);
+        requiredText(reference.targetId, "Cell reference target ID");
+        assertReferenceTarget(context, notebook, reference);
+    }
+}
+function assertReferenceTarget(context, notebook, reference) {
+    if (reference.kind === "artifact") {
+        context.artifactRowById(reference.targetId);
+        return;
+    }
+    if (reference.kind === "cell-output") {
+        if (!notebook.cells.some((cell) => cell.id === reference.targetId)) {
+            throw new Error(`Cell output target not found: ${reference.targetId}`);
+        }
+        return;
+    }
+    const table = reference.kind === "transcript"
+        ? "transcripts"
+        : reference.kind === "sequence"
+            ? "sequences"
+            : "artifact_streams";
+    const column = reference.kind === "transcript"
+        ? "transcript_id"
+        : reference.kind === "sequence"
+            ? "sequence_id"
+            : "stream_id";
+    const found = context.store.db
+        .prepare(`SELECT 1 AS present FROM ${table} WHERE ${column}=?`)
+        .get(reference.targetId);
+    if (!found) {
+        throw new Error(`${reference.kind} target not found: ${reference.targetId}`);
+    }
+}
+function validatePinnedResults(context, cell) {
+    const ids = new Set();
+    const ordinals = new Set();
+    for (const result of cell.pinnedResults ?? []) {
+        assertUuidV7(result.id, "Pinned search result ID");
+        if (ids.has(result.id)) {
+            throw new Error(`Duplicate pinned search result ID: ${result.id}`);
+        }
+        ids.add(result.id);
+        validateOrdinal(result.ordinal, "Pinned search result ordinal");
+        if (ordinals.has(result.ordinal)) {
+            throw new Error(`Duplicate pinned search result ordinal: ${result.ordinal}`);
+        }
+        ordinals.add(result.ordinal);
+        context.artifactRowById(result.artifactId);
+        requiredText(result.objectHash, "Pinned search result object hash");
+        normalizeSearchLocation(result.location);
+        requiredText(result.selectedRevision, "Pinned search result revision");
+        if (!Number.isSafeInteger(result.createdAt) || result.createdAt < 0) {
+            throw new Error("Pinned search result createdAt must be a positive integer");
+        }
+        const object = context.store.db
+            .prepare("SELECT 1 AS present FROM objects WHERE object_hash=?")
+            .get(result.objectHash);
+        if (!object) {
+            throw new Error(`Pinned search result object not found: ${result.objectHash}`);
+        }
+    }
+}
+function validateOrdinal(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative safe integer`);
+    }
+}
+function synchronizeCellReferences(context, notebookId, cell) {
+    const references = cell.references ?? [];
+    deleteMissingChildren(context, "cell_references", "reference_id", notebookId, cell.id, references.map((reference) => reference.id));
+    const upsert = context.store.db.prepare(`INSERT INTO cell_references(
+      notebook_id, cell_id, reference_id, kind,
+      target_id, snapshot_json, ordinal
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(notebook_id, cell_id, reference_id) DO UPDATE SET
+      kind=excluded.kind,
+      target_id=excluded.target_id,
+      snapshot_json=excluded.snapshot_json,
+      ordinal=excluded.ordinal`);
+    for (const reference of references) {
+        upsert.run(notebookId, cell.id, reference.id, reference.kind, reference.targetId, canonicalJson(reference.snapshot), reference.ordinal);
+    }
+}
+function synchronizePinnedResults(context, notebookId, cell) {
+    const pinnedResults = cell.pinnedResults ?? [];
+    deleteMissingChildren(context, "pinned_search_results", "result_id", notebookId, cell.id, pinnedResults.map((result) => result.id));
+    const upsert = context.store.db.prepare(`INSERT INTO pinned_search_results(
+      notebook_id, cell_id, result_id, artifact_id, object_hash,
+      location_json, representative_json, query_json, signals_json,
+      selected_revision, ordinal, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(notebook_id, cell_id, result_id) DO UPDATE SET
+      artifact_id=excluded.artifact_id,
+      object_hash=excluded.object_hash,
+      location_json=excluded.location_json,
+      representative_json=excluded.representative_json,
+      query_json=excluded.query_json,
+      signals_json=excluded.signals_json,
+      selected_revision=excluded.selected_revision,
+      ordinal=excluded.ordinal,
+      created_at=excluded.created_at`);
+    for (const result of pinnedResults) {
+        upsert.run(notebookId, cell.id, result.id, result.artifactId, result.objectHash, canonicalJson(normalizeSearchLocation(result.location)), result.representativeTick === undefined
+            ? null
+            : canonicalJson(result.representativeTick), canonicalJson(result.query), canonicalJson(result.signals), result.selectedRevision, result.ordinal, result.createdAt);
+    }
+}
+function deleteMissingChildren(context, table, idColumn, notebookId, cellId, ids) {
+    if (ids.length === 0) {
+        context.store.db
+            .prepare(`DELETE FROM ${table} WHERE notebook_id=? AND cell_id=?`)
+            .run(notebookId, cellId);
+        return;
+    }
+    const placeholders = ids.map(() => "?").join(", ");
+    context.store.db
+        .prepare(`DELETE FROM ${table}
+       WHERE notebook_id=? AND cell_id=? AND ${idColumn} NOT IN (${placeholders})`)
+        .run(notebookId, cellId, ...ids);
+}
+function rowToCellReference(row) {
+    return {
+        id: row.reference_id,
+        kind: row.kind,
+        targetId: row.target_id,
+        snapshot: parseJson(row.snapshot_json, {}),
+        ordinal: row.ordinal,
+    };
+}
+function rowToPinnedSearchResult(row) {
+    const representativeTick = row.representative_json === null
+        ? undefined
+        : parseJson(row.representative_json, undefined);
+    return {
+        id: row.result_id,
+        artifactId: row.artifact_id,
+        objectHash: row.object_hash,
+        location: normalizeSearchLocation(parseJson(row.location_json, {
+            kind: "still",
+            artifactId: row.artifact_id,
+            sourcePath: "unknown",
+            objectHash: row.object_hash,
+        })),
+        ...(representativeTick === undefined ? {} : { representativeTick }),
+        query: parseJson(row.query_json, {}),
+        signals: parseJson(row.signals_json, []),
+        selectedRevision: row.selected_revision,
+        ordinal: row.ordinal,
+        createdAt: row.created_at,
+    };
+}
+function rowToCell(row, references, pinnedResults) {
+    const inputs = parseJson(row.inputs_json, {});
+    const legacyProvider = optionalString(inputs.provider);
+    const legacyOperation = optionalString(inputs.operation);
+    const provider = optionalString(row.provider) ?? legacyProvider;
+    const operation = optionalString(row.operation) ?? legacyOperation;
+    const model = optionalString(row.model);
+    const tool = optionalString(row.tool) ??
+        (looksLikeGenerationTool(model) ? model : undefined);
     return {
         id: row.cell_id,
-        type: row.type,
-        title: row.title,
-        position: { x: row.position_x, y: row.position_y },
-        ...(row.entity_id ? { entityId: row.entity_id } : {}),
+        type: notebookCellType(row.type),
+        slug: row.slug,
+        slot: { row: row.grid_row, column: row.grid_column },
+        ...(row.output_entity_id ? { outputEntityId: row.output_entity_id } : {}),
         ...(row.prompt ? { prompt: row.prompt } : {}),
-        ...(row.model ? { model: row.model } : {}),
-        inputs: parseJson(row.inputs_json, {}),
+        ...(provider ? { provider } : {}),
+        ...(model ? { model } : {}),
+        ...(operation ? { operation } : {}),
+        ...(tool ? { tool } : {}),
+        inputs,
         ...(row.output_artifact_id
             ? { outputArtifactId: row.output_artifact_id }
             : {}),
+        references: references.map(rowToCellReference),
+        pinnedResults: pinnedResults.map(rowToPinnedSearchResult),
+    };
+}
+function notebookCellType(type) {
+    if (!NOTEBOOK_CELL_TYPE_SET.has(type)) {
+        throw new Error(`Invalid cell type: ${type}`);
+    }
+    return type;
+}
+function normalizeCellForWrite(cell) {
+    const inputs = { ...(cell.inputs ?? {}) };
+    const provider = optionalString(cell.provider) ?? optionalString(inputs.provider);
+    const operation = optionalString(cell.operation) ?? optionalString(inputs.operation);
+    const model = optionalString(cell.model);
+    const tool = optionalString(cell.tool) ??
+        (looksLikeGenerationTool(model) ? model : undefined);
+    return {
+        ...cell,
+        ...(provider ? { provider } : { provider: undefined }),
+        ...(operation ? { operation } : { operation: undefined }),
+        ...(tool ? { tool } : { tool: undefined }),
+        inputs,
     };
 }
+function optionalString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function looksLikeGenerationTool(value) {
+    if (!value)
+        return false;
+    return value.startsWith("generate_") || value.includes("/");
+}
 function rowToEdge(row) {
     return {
         id: row.edge_id,
@@ -383,6 +1104,97 @@ function validateRunStatus(status) {
         throw new Error(`Invalid notebook run status: ${status}`);
     }
 }
+function executionFromRow(row) {
+    return {
+        ...(row.fingerprint ? { fingerprint: row.fingerprint } : {}),
+        ...(row.status ? { status: row.status } : {}),
+        ...(row.output_artifact_id
+            ? { outputArtifactId: row.output_artifact_id }
+            : {}),
+        ...(row.provider_artifact_id
+            ? { providerArtifactId: row.provider_artifact_id }
+            : {}),
+        ...(row.run_id ? { runId: row.run_id } : {}),
+        ...(row.completed_at ? { completedAt: row.completed_at } : {}),
+        ...(row.started_at ? { startedAt: row.started_at } : {}),
+        ...(row.updated_at ? { updatedAt: row.updated_at } : {}),
+        ...(row.tool ? { tool: row.tool } : {}),
+        ...(row.error ? { error: row.error } : {}),
+        ...(row.stale === 1 ? { stale: true } : {}),
+        ...(row.fixture_baseline === 1 ? { fixtureBaseline: true } : {}),
+    };
+}
+function generationPlanFromRow(row) {
+    return {
+        planId: row.plan_id,
+        cellId: row.cell_id,
+        status: row.status,
+        plan: parseJson(row.plan_json, {}),
+        ...(row.output_artifact_id
+            ? { outputArtifactId: row.output_artifact_id }
+            : {}),
+        ...(row.error ? { error: row.error } : {}),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function runPlanFromRow(row) {
+    return {
+        planId: row.plan_id,
+        status: row.status,
+        plan: parseJson(row.plan_json, {}),
+        paidCellIds: parseJson(row.paid_cell_ids_json, []),
+        cellDefinitionFingerprints: parseJson(row.cell_fingerprints_json, {}),
+        knownCostUsd: row.known_cost_usd,
+        unknownCostCount: row.unknown_cost_count,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        ...(row.run_id ? { runId: row.run_id } : {}),
+        ...(row.outputs_json
+            ? {
+                outputs: parseJson(row.outputs_json, {}),
+            }
+            : {}),
+        ...(row.error ? { error: row.error } : {}),
+    };
+}
+function transcriptEditFromRow(row) {
+    const payload = parseJson(row.payload_json, {});
+    return {
+        ...payload,
+        actionId: row.action_id,
+        kind: row.kind,
+        ...(row.restored === 1 ? { restored: true } : {}),
+    };
+}
+function transcriptAttachmentFromRow(row) {
+    const payload = parseJson(row.payload_json, {});
+    return {
+        ...payload,
+        id: row.attachment_id,
+    };
+}
+function assertUnique(values, label) {
+    const unique = new Set(values);
+    if (unique.size !== values.length) {
+        throw new Error(`Duplicate ${label}`);
+    }
+}
+function nonNegativeFinite(value, label) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative finite number`);
+    }
+    return value;
+}
+function nonNegativeInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer`);
+    }
+    return value;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function callerOrNewId(id, label) {
     const resolved = id ?? newUuidV7();
     assertUuidV7(resolved, label);
@@ -393,7 +1205,7 @@ const ENTITY_SELECT = `
   FROM entities
 `;
 const NOTEBOOK_SELECT = `
-  SELECT notebook_id, name, properties_json, created_at
+  SELECT notebook_id, name, created_at
   FROM notebooks
 `;
 //# sourceMappingURL=domain.js.map