videobook-engine 2.0.1 → 5.0.1

package/dist/domain.js

@@ -1,8 +1,12 @@
 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 { canonicalJson, parseJson } from "./store.js";
+import { LEGACY_NOTEBOOK_CELL_TYPE_ALIASES, NOTEBOOK_CELL_TYPES, } from "./schema.js";
+import { firstEmptyNotebookGridSlots, isNotebookGridSlot, } from "./notebook-grid.js";
+import { canonicalJson, commitDateIso, parseCommitMessage, 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),
@@ -25,7 +29,13 @@ export function createNotebooksApi(context) {
         }),
         list: () => listNotebooks(context),
         read: (notebookId) => syncResultOf(() => requiredNotebook(context, notebookId)),
-        write: (notebook) => writeNotebook(context, notebook),
+        write: (notebook, options) => writeNotebook(context, notebook, options),
+        cellHistory: (notebookId, cellId, options) => cellHistory(context, notebookId, cellId, options),
+        executionHistory: (notebookId, cellId, options) => executionHistory(context, notebookId, cellId, options),
+        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 +47,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 +81,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 +100,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 +108,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 +116,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 +133,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);
@@ -138,38 +152,326 @@ function listNotebooks(context) {
         .all();
     return rows.map((row) => notebookFromRows(context, row));
 }
-async function writeNotebook(context, notebook) {
+async function writeNotebook(context, notebook, options) {
     return resultOf(async () => {
         assertUuidV7(notebook.id, "Notebook ID");
         requiredNotebook(context, notebook.id);
         validateNotebook(context, notebook);
         const mutation = await context.store.semantic({
-            operation: "write_notebook",
-            details: { notebookId: notebook.id },
+            operation: options?.operation ?? "write_notebook",
+            tables: [
+                "notebooks",
+                "notebook_fields",
+                "cells",
+                "notebook_cell_executions",
+                "notebook_generation_plans",
+                "notebook_run_plans",
+                "edges",
+                "cell_references",
+                "pinned_search_results",
+            ],
+            details: { notebookId: notebook.id, ...options?.details },
+            ...(options?.artifactId ? { artifactId: options.artifactId } : {}),
             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);
+    });
+}
+function cellHistory(context, notebookId, cellId, options) {
+    assertUuidV7(notebookId, "Notebook ID");
+    assertUuidV7(cellId, "Cell ID");
+    const limit = Math.max(1, Math.min(options?.limit ?? 50, 500));
+    const commitMeta = commitMetaByHash(context);
+    let rows;
+    try {
+        rows = context.store.db
+            .prepare(`SELECT notebook_id, cell_id, type, label, grid_row, grid_column,
+                output_entity_id, prompt, provider, model, operation, tool,
+                inputs_json, output_artifact_id, commit_hash, committer, commit_date
+         FROM dolt_history_cells
+         WHERE notebook_id=? AND cell_id=?
+         ORDER BY commit_date DESC
+         LIMIT ?`)
+            .all(notebookId, cellId, limit);
+    }
+    catch {
+        rows = context.store.db.doltHistoryOf("cells")
+            .filter((row) => row.notebook_id === notebookId && row.cell_id === cellId)
+            .sort((left, right) => right.commit_date.localeCompare(left.commit_date))
+            .slice(0, limit);
+    }
+    return rows.map((row) => {
+        const meta = commitMeta.get(row.commit_hash);
+        return {
+            commitHash: row.commit_hash,
+            commitDate: commitDateIso(row.commit_date),
+            committer: row.committer,
+            ...(meta?.operation ? { operation: meta.operation } : {}),
+            ...(meta?.operationId ? { operationId: meta.operationId } : {}),
+            ...(meta?.artifactId ? { artifactId: meta.artifactId } : {}),
+            ...(meta?.details ? { details: meta.details } : {}),
+            cell: rowToCell(row, [], []),
+        };
+    });
+}
+function executionHistory(context, notebookId, cellId, options) {
+    assertUuidV7(notebookId, "Notebook ID");
+    assertUuidV7(cellId, "Cell ID");
+    const limit = Math.max(1, Math.min(options?.limit ?? 50, 500));
+    const commitMeta = commitMetaByHash(context);
+    let rows;
+    try {
+        rows = context.store.db
+            .prepare(`SELECT 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,
+                commit_hash, committer, commit_date
+         FROM dolt_history_notebook_cell_executions
+         WHERE notebook_id=? AND cell_id=?
+         ORDER BY commit_date DESC
+         LIMIT ?`)
+            .all(notebookId, cellId, limit);
+    }
+    catch {
+        rows = context.store.db.doltHistoryOf("notebook_cell_executions")
+            .filter((row) => row.notebook_id === notebookId && row.cell_id === cellId)
+            .sort((left, right) => right.commit_date.localeCompare(left.commit_date))
+            .slice(0, limit);
+    }
+    return rows.map((row) => {
+        const meta = commitMeta.get(row.commit_hash);
+        return {
+            commitHash: row.commit_hash,
+            commitDate: commitDateIso(row.commit_date),
+            committer: row.committer,
+            notebookId: row.notebook_id,
+            cellId: row.cell_id,
+            ...(meta?.operation ? { operation: meta.operation } : {}),
+            ...(meta?.operationId ? { operationId: meta.operationId } : {}),
+            ...(meta?.artifactId ? { artifactId: meta.artifactId } : {}),
+            ...(meta?.details ? { details: meta.details } : {}),
+            execution: executionFromRow(row),
+        };
+    });
+}
+function commitMetaByHash(context) {
+    const map = new Map();
+    for (const commit of context.store.db.doltLog()) {
+        const parsed = parseCommitMessage(commit.message);
+        if (!parsed)
+            continue;
+        map.set(commit.commit_hash, {
+            operation: parsed.operation,
+            operationId: parsed.operationId,
+            ...(parsed.artifactId ? { artifactId: parsed.artifactId } : {}),
+            details: parsed.details,
+        });
+    }
+    return map;
+}
+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);
+        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);
+        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",
+                "generations",
+                "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 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}`);
+    }
+}
+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();
+    for (const row of rows) {
+        const key = `${row.grid_row}:${row.grid_column}`;
+        const group = slots.get(key) ?? [];
+        group.push(row);
+        slots.set(key, group);
+    }
+    const occupied = [];
+    const losers = [];
+    for (const group of slots.values()) {
+        const winner = protectedCellId && group.some((row) => row.cell_id === protectedCellId)
+            ? protectedCellId
+            : group[0].cell_id;
+        const winnerRow = group.find((row) => row.cell_id === winner);
+        occupied.push({
+            row: winnerRow.grid_row,
+            column: winnerRow.grid_column,
+        });
+        losers.push(...group
+            .filter((row) => row.cell_id !== winner)
+            .map((row) => row.cell_id));
+    }
+    const destinations = firstEmptyNotebookGridSlots(occupied, losers.length);
+    const move = context.store.db.prepare(`UPDATE cells SET grid_row=?, grid_column=?
+     WHERE notebook_id=? AND cell_id=?`);
+    for (const [index, cellId] of losers.entries()) {
+        const slot = destinations[index];
+        move.run(slot.row, slot.column, notebookId, cellId);
+    }
+}
+function upsertNotebookCell(context, notebookId, cell) {
+    const normalized = normalizeCellForWrite(cell);
+    context.store.db
+        .prepare(`INSERT INTO cells(
+        notebook_id, cell_id, type, label, 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,
+        label=excluded.label,
+        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, normalized.label?.trim() || null, 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",
+                "generations",
+                "notebook_cell_executions",
+                "notebook_generation_plans",
+                "notebook_run_plans",
+                "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 +492,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 +534,104 @@ 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, label, 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 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("fixture"))
+            ? { fixture: field.get("fixture") }
+            : {}),
+        execution: Object.fromEntries(executions.map((execution) => [
+            execution.cell_id,
+            executionFromRow(execution),
+        ])),
+        generationPlans: generationPlans.map(generationPlanFromRow),
+        notebookRunPlans: runPlans.map(runPlanFromRow),
+        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 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);
-        }
+        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 +640,40 @@ 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}`);
+    }
+    if (!isNotebookGridSlot(cell.slot)) {
+        throw new Error(`Cell slot must be within @a1-@z13: ${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`);
     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 +685,132 @@ 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);
+}
+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.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 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 +824,231 @@ 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),
+        ...(row.label ? { label: row.label } : {}),
+        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) {
+    const resolved = LEGACY_NOTEBOOK_CELL_TYPE_ALIASES[type] ?? type;
+    if (!NOTEBOOK_CELL_TYPE_SET.has(resolved)) {
+        throw new Error(`Invalid cell type: ${type}`);
+    }
+    return resolved;
+}
+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 +1090,81 @@ 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 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 +1175,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