videobook-engine 4.2.0 → 5.3.2

package/dist/domain.js

@@ -2,8 +2,9 @@ import { ok } from "./engine-types.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 { LEGACY_NOTEBOOK_CELL_TYPE_ALIASES, NOTEBOOK_CELL_TYPES, } from "./schema.js";
+import { firstEmptyNotebookGridSlots, isNotebookGridSlot, NOTEBOOK_GRID_ADDRESS_RANGE, } 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) {
@@ -28,7 +29,9 @@ 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),
@@ -149,13 +152,13 @@ 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",
+            operation: options?.operation ?? "write_notebook",
             tables: [
                 "notebooks",
                 "notebook_fields",
@@ -163,13 +166,12 @@ async function writeNotebook(context, notebook) {
                 "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 },
+            details: { notebookId: notebook.id, ...options?.details },
+            ...(options?.artifactId ? { artifactId: options.artifactId } : {}),
             writeSet: [
                 `notebook:${notebook.id}`,
                 ...notebook.cells.map((cell) => `cell:${notebook.id}:${cell.id}`),
@@ -185,6 +187,98 @@ async function writeNotebook(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");
@@ -194,7 +288,6 @@ async function insertNotebookCell(context, notebookId, cell) {
         }
         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",
@@ -223,7 +316,6 @@ async function updateNotebookCell(context, notebookId, cell) {
             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",
@@ -270,6 +362,7 @@ async function removeNotebookCell(context, notebookId, cellId) {
             operation: "remove_cell",
             tables: [
                 "cells",
+                "generations",
                 "notebook_cell_executions",
                 "notebook_generation_plans",
                 "edges",
@@ -287,15 +380,6 @@ async function removeNotebookCell(context, notebookId, cellId) {
         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
@@ -305,13 +389,6 @@ function assertCellSlotFree(context, notebookId, cell) {
         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
@@ -319,67 +396,46 @@ function repairCellSlots(context, notebookId, protectedCellId) {
        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 });
+        group.push(row);
         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=?");
+    const occupied = [];
+    const losers = [];
     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;
-        }
+        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));
     }
-}
-/**
- * `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);
+    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, slug, grid_row, grid_column,
+        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,
-        slug=excluded.slug,
+        label=excluded.label,
         grid_row=excluded.grid_row,
         grid_column=excluded.grid_column,
         output_entity_id=excluded.output_entity_id,
@@ -390,7 +446,7 @@ function upsertNotebookCell(context, notebookId, cell) {
         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);
+        .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);
 }
@@ -404,11 +460,10 @@ async function deleteNotebook(context, notebookId) {
                 "notebooks",
                 "notebook_fields",
                 "cells",
+                "generations",
                 "notebook_cell_executions",
                 "notebook_generation_plans",
                 "notebook_run_plans",
-                "notebook_transcript_edits",
-                "notebook_transcript_attachments",
                 "edges",
                 "runs",
                 "cell_references",
@@ -485,7 +540,7 @@ function notebookFromRows(context, row) {
        ORDER BY field`)
         .all(row.notebook_id);
     const cells = context.store.db
-        .prepare(`SELECT cell_id, type, slug, grid_row, grid_column, output_entity_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=?
@@ -529,16 +584,6 @@ function notebookFromRows(context, row) {
        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),
@@ -558,16 +603,6 @@ function notebookFromRows(context, row) {
         ...(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") }
             : {}),
@@ -577,8 +612,6 @@ function notebookFromRows(context, row) {
         ])),
         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(),
@@ -586,16 +619,11 @@ function notebookFromRows(context, row) {
 }
 function validateNotebook(context, notebook) {
     const cellIds = new Set();
-    const cellSlugs = new Set();
     const occupiedSlots = new Set();
     for (const cell of notebook.cells) {
         if (cellIds.has(cell.id))
             throw new Error(`Duplicate cell ID: ${cell.id}`);
         cellIds.add(cell.id);
-        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}`);
@@ -625,14 +653,8 @@ function validateCellFields(context, notebook, cell) {
     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 (!isNotebookGridSlot(cell.slot)) {
+        throw new Error(`Cell slot must be within ${NOTEBOOK_GRID_ADDRESS_RANGE}: ${cell.id}`);
     }
     if (cell.outputEntityId) {
         assertUuidV7(cell.outputEntityId, "Cell output entity ID");
@@ -648,7 +670,6 @@ function validateCellFields(context, notebook, 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));
-    evacuateChangedCellSlugs(context, notebook);
     for (const cell of notebook.cells) {
         upsertNotebookCell(context, notebook.id, cell);
     }
@@ -669,8 +690,6 @@ function synchronizeNotebookState(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();
@@ -689,12 +708,6 @@ function synchronizeNotebookFields(context, notebook) {
     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);
     }
@@ -785,34 +798,6 @@ function synchronizeRunPlans(context, notebook) {
         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
@@ -1015,7 +1000,7 @@ function rowToCell(row, references, pinnedResults) {
     return {
         id: row.cell_id,
         type: notebookCellType(row.type),
-        slug: row.slug,
+        ...(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 } : {}),
@@ -1032,10 +1017,11 @@ function rowToCell(row, references, pinnedResults) {
     };
 }
 function notebookCellType(type) {
-    if (!NOTEBOOK_CELL_TYPE_SET.has(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 type;
+    return resolved;
 }
 function normalizeCellForWrite(cell) {
     const inputs = { ...(cell.inputs ?? {}) };
@@ -1158,22 +1144,6 @@ function runPlanFromRow(row) {
         ...(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) {