videobook-engine 2.0.1 → 5.0.1

package/dist/history.js

@@ -1,23 +1,21 @@
 import { rm } from "node:fs/promises";
 import { ok } from "./engine-types.js";
-import { resultOf, syncResultOf, } from "./context.js";
-import { artifactSlug } from "./artifacts.js";
+import { resultOf } from "./context.js";
 import { materializeArtifact } from "./files.js";
 import { assertUuidV7, isUuidV7, newUuidV7 } from "./ids.js";
-import { canonicalJson, EngineFault, parseJson, } from "./store.js";
+import { SCHEMA_VERSION, SEMANTIC_TABLES } from "./schema.js";
+import { canonicalJson, commitDateIso, EngineFault, parseCommitMessage, } from "./store.js";
 export function createHistoryApi(context) {
     return {
         revisions: (limit = 20) => revisionHistory(context, limit),
         artifact: (artifact, limit = 20) => artifactHistory(context, artifact, limit),
         resolveRevision: (revision) => resolveRevision(context, revision),
+        diff: (fromRevision, toRevision, table) => context.store.db.doltDiff(fromRevision, toRevision, table),
         recordOperation: (operation, artifact, details) => recordOperation(context, operation, artifact, details),
-        restoreArtifact: (artifactId, revision, slug) => restoreArtifact(context, artifactId, revision, slug),
+        restoreArtifact: (artifactId, revision) => restoreArtifact(context, artifactId, revision),
         restore: (revision) => restoreBook(context, revision),
         logAction: (action, payload) => logAction(context, action, payload),
         actionLog: (options) => actionLog(context, options),
-        actions: (options) => actions(context, options),
-        action: (actionId) => action(context, actionId),
-        recordAction: (input) => recordAction(context, input),
     };
 }
 function revisionForHash(context, hash) {
@@ -30,94 +28,74 @@ function revisionForHash(context, hash) {
             message: `Revision not found: ${hash}`,
         });
     }
+    const parsed = parseCommitMessage(commit.message);
+    if (parsed)
+        return revisionFromCommit(context, commit, parsed);
     return {
         hash,
         message: commit.message,
-        date: commit.date,
+        date: commitDateIso(commit.date),
         author: commit.committer,
     };
 }
 function revisionHistory(context, limit) {
-    return allRevisions(context).slice(0, Math.max(0, limit));
+    return commitRevisions(context).slice(0, Math.max(0, limit));
 }
 function artifactHistory(context, artifactReference, limit) {
-    const revisions = allRevisions(context);
-    let artifactId;
-    if (isUuidV7(artifactReference)) {
-        artifactId = artifactReference;
-    }
-    else {
-        try {
-            artifactId = context.artifactRow(artifactReference).artifact_id;
-        }
-        catch {
-            const historical = revisions.find((revision) => revision.artifactSlug === artifactReference ||
-                revision.details?.slug === artifactReference ||
-                revision.details?.oldSlug === artifactReference);
-            if (!historical?.artifactId)
-                return [];
-            artifactId = historical.artifactId;
-        }
-    }
+    const revisions = commitRevisions(context);
+    if (!isUuidV7(artifactReference))
+        return [];
+    const artifactId = artifactReference;
     return revisions
         .filter((revision) => revision.artifactId === artifactId)
         .slice(0, Math.max(0, limit));
 }
-function allRevisions(context) {
-    const commits = context.store.db.doltLog();
+// History listings are direct commit-log reads: every engine commit carries
+// its operation, parameters, and write set in its structured message, so no
+// per-commit table diffs are needed to describe a revision.
+function commitRevisions(context) {
     const revisions = [];
-    for (let index = 0; index < commits.length - 1; index += 1) {
-        const commit = commits[index];
-        const parent = commits[index + 1];
-        const operations = context.store
-            .diff(parent.commit_hash, commit.commit_hash, "operations")
-            .filter((row) => row.diff_type === "added")
-            .map(operationFromDiff)
-            .filter((operation) => operation !== null);
-        for (const operation of operations) {
-            const details = parseJson(operation.details_json, {});
-            const writeSet = parseJson(operation.write_set_json, []);
-            const artifactSlugAtRevision = operation.artifact_id
-                ? artifactSlugAt(context, operation.artifact_id, commit.commit_hash)
-                : undefined;
-            const fileChanges = revisionFileChanges(context.store.diff(parent.commit_hash, commit.commit_hash, "artifact_files"), operation.artifact_id);
-            revisions.push({
-                hash: commit.commit_hash,
-                message: commit.message,
-                date: new Date(operation.created_at).toISOString(),
-                author: operation.author,
-                operationId: operation.operation_id,
-                operation: operation.operation,
-                ...(operation.artifact_id
-                    ? { artifactId: operation.artifact_id }
-                    : {}),
-                ...(artifactSlugAtRevision
-                    ? { artifactSlug: artifactSlugAtRevision }
-                    : {}),
-                details: {
-                    ...details,
-                    ...(writeSet.length > 0 ? { writeSet } : {}),
-                    ...(operation.base_revision
-                        ? { baseRevision: operation.base_revision }
-                        : {}),
-                },
-                files: fileChanges.map((change) => change.file),
-                fileChanges,
-            });
-        }
+    for (const commit of context.store.db.doltLog()) {
+        const parsed = parseCommitMessage(commit.message);
+        if (!parsed)
+            continue;
+        revisions.push(revisionFromCommit(context, commit, parsed));
     }
     return revisions;
 }
+function revisionFromCommit(context, commit, parsed) {
+    const artifactLabelAtRevision = parsed.artifactId
+        ? artifactLabelAt(context, parsed.artifactId, commit.commit_hash)
+        : undefined;
+    return {
+        hash: commit.commit_hash,
+        message: commit.message,
+        date: commitDateIso(commit.date),
+        author: parsed.actor ?? commit.committer,
+        operationId: parsed.operationId,
+        operation: parsed.operation,
+        ...(parsed.artifactId ? { artifactId: parsed.artifactId } : {}),
+        ...(artifactLabelAtRevision ? { artifactLabel: artifactLabelAtRevision } : {}),
+        details: {
+            ...parsed.details,
+            ...(parsed.writeSet.length > 0 ? { writeSet: parsed.writeSet } : {}),
+            ...(parsed.baseRevision ? { baseRevision: parsed.baseRevision } : {}),
+        },
+    };
+}
 function resolveRevision(context, reference) {
-    const historical = allRevisions(context).find((revision) => revision.hash === reference || revision.hash.startsWith(reference));
+    const historical = commitRevisions(context).find((revision) => revision.hash === reference || revision.hash.startsWith(reference));
     if (historical)
         return historical;
-    const commit = context.store.db.doltLog().find((item) => item.commit_hash === reference || item.commit_hash.startsWith(reference));
+    const commit = context.store.db
+        .doltLog()
+        .find((item) => item.commit_hash === reference ||
+        item.commit_hash.startsWith(reference));
     return commit
         ? {
             hash: commit.commit_hash,
             message: commit.message,
-            date: commit.date,
+            date: commitDateIso(commit.date),
             author: commit.committer,
         }
         : null;
@@ -139,24 +117,26 @@ async function recordOperation(context, operation, artifactReference, details) {
             : null;
         const mutation = await context.store.semantic({
             operation,
+            tables: [],
             ...(artifact ? { artifactId: artifact.artifact_id } : {}),
             details: {
                 ...(details ?? {}),
-                ...(artifact ? { artifactSlug: artifact.slug } : {}),
+                ...(artifact?.label ? { artifactLabel: artifact.label } : {}),
             },
-            writeSet: artifact
-                ? [`artifact:${artifact.artifact_id}`]
-                : ["book"],
-        }, [], () => undefined);
+            writeSet: artifact ? [`artifact:${artifact.artifact_id}`] : ["book"],
+            // Provenance-only operations change no semantic rows; the commit
+            // itself is their record, so it must be minted even when empty.
+            allowEmpty: true,
+        }, () => undefined);
         return ok(revisionForHash(context, mutation.revision), mutation.revision);
     });
 }
-async function restoreArtifact(context, artifactId, revisionReference, replacementSlug) {
+async function restoreArtifact(context, artifactId, revisionReference) {
     return resultOf(async () => {
         assertUuidV7(artifactId, "Artifact ID");
         const revision = requiredRevision(context, revisionReference);
         const target = context.store.db
-            .prepare(`SELECT artifact_id, slug, kind, created_at
+            .prepare(`SELECT artifact_id, label, kind, created_at
          FROM dolt_at_artifacts(?)
          WHERE artifact_id=?`)
             .get(revision.hash, artifactId);
@@ -166,20 +146,6 @@ async function restoreArtifact(context, artifactId, revisionReference, replaceme
                 message: `Artifact ${artifactId} did not exist at ${revision.hash}`,
             });
         }
-        const desiredSlug = replacementSlug
-            ? artifactSlug(target.kind, replacementSlug)
-            : target.slug;
-        const owner = context.store.db
-            .prepare(`SELECT artifact_id FROM artifacts
-         WHERE slug=? AND artifact_id<>?`)
-            .get(desiredSlug, artifactId);
-        if (owner) {
-            throw new EngineFault({
-                code: "SLUG_CONFLICT",
-                message: `Slug ${desiredSlug} is owned by active artifact ${owner.artifact_id}`,
-                ownerId: owner.artifact_id,
-            });
-        }
         const files = filesAt(context, revision.hash, artifactId);
         const metadata = context.store.db
             .prepare(`SELECT key, value_json
@@ -191,26 +157,24 @@ async function restoreArtifact(context, artifactId, revisionReference, replaceme
             .get(revision.hash, artifactId);
         const mutation = await context.store.semantic({
             operation: "restore_artifact",
-            artifactId,
-            details: { fromRevision: revision.hash, slug: desiredSlug },
-            writeSet: [
-                `artifact:${artifactId}`,
-                `artifact-slug:${desiredSlug}`,
+            tables: [
+                "artifacts",
+                "artifact_files",
+                "artifact_metadata",
+                "audio_waveforms",
             ],
-        }, [
-            "artifacts",
-            "artifact_files",
-            "artifact_metadata",
-            "audio_waveforms",
-        ], (_operationId, now) => {
+            artifactId,
+            details: { fromRevision: revision.hash },
+            writeSet: [`artifact:${artifactId}`],
+        }, (_operationId, now) => {
             context.store.db
                 .prepare(`INSERT INTO artifacts(
-              artifact_id, slug, kind, created_at
+              artifact_id, label, kind, created_at
             ) VALUES (?, ?, ?, ?)
             ON CONFLICT(artifact_id) DO UPDATE SET
-              slug=excluded.slug,
+              label=excluded.label,
               kind=excluded.kind`)
-                .run(target.artifact_id, desiredSlug, target.kind, target.created_at);
+                .run(target.artifact_id, target.label, target.kind, target.created_at);
             context.store.db
                 .prepare("DELETE FROM artifact_files WHERE artifact_id=?")
                 .run(artifactId);
@@ -235,8 +199,11 @@ async function restoreArtifact(context, artifactId, revisionReference, replaceme
             }
             resetArtifactRuntime(context, artifactId, now);
         });
-        await rm(context.artifactPath(artifactId), { recursive: true, force: true });
-        await materializeArtifact(context, artifactId);
+        await rm(context.artifactPath(artifactId), {
+            recursive: true,
+            force: true,
+        });
+        await materializeIgnoringForgotten(context, artifactId);
         return ok(revisionForHash(context, mutation.revision), mutation.revision);
     });
 }
@@ -244,7 +211,7 @@ async function restoreBook(context, revisionReference) {
     return resultOf(async () => {
         const revision = requiredRevision(context, revisionReference);
         const targetBook = context.store.db
-            .prepare("SELECT book_id, slug, created_at FROM dolt_at_book(?)")
+            .prepare("SELECT book_id, name, created_at FROM dolt_at_book(?)")
             .get(revision.hash);
         if (!targetBook) {
             throw new EngineFault({
@@ -259,160 +226,33 @@ async function restoreBook(context, revisionReference) {
                 message: "A restore cannot replace the catalog's stable book ID",
             });
         }
+        const targetSchema = context.store.db
+            .prepare("SELECT version FROM dolt_at_engine_schema(?) WHERE singleton=1")
+            .get(revision.hash);
+        if (!targetSchema || targetSchema.version !== SCHEMA_VERSION) {
+            throw new EngineFault({
+                code: "SCHEMA_INCOMPATIBLE",
+                message: `Cannot restore ${revision.hash}: it records schema version ` +
+                    `${targetSchema?.version ?? "unknown"}, not the current ${SCHEMA_VERSION}`,
+            });
+        }
         const targetArtifacts = context.store.db
-            .prepare(`SELECT artifact_id, slug, kind, created_at
+            .prepare(`SELECT artifact_id, label, kind, created_at
          FROM dolt_at_artifacts(?)
          ORDER BY artifact_id`)
             .all(revision.hash);
         const targetIds = targetArtifacts.map((row) => row.artifact_id);
-        const targetFiles = rowsForArtifactIds(context, "artifact_files", "artifact_id, path, object_hash, mtime_ms, created_at", revision.hash, targetIds);
-        const bookMetadata = context.store.db
-            .prepare("SELECT key, value_json FROM dolt_at_book_metadata(?)")
-            .all(revision.hash);
-        const artifactMetadata = rowsForArtifactIds(context, "artifact_metadata", "artifact_id, key, value_json", revision.hash, targetIds);
-        const waveforms = rowsForArtifactIds(context, "audio_waveforms", "artifact_id, peaks_json", revision.hash, targetIds);
-        const entities = context.store.db
-            .prepare(`SELECT entity_id, type, name, description, prompt,
-                data_json, created_at
-         FROM dolt_at_entities(?)`)
-            .all(revision.hash);
-        const notebooks = context.store.db
-            .prepare(`SELECT notebook_id, name, properties_json, created_at
-         FROM dolt_at_notebooks(?)`)
-            .all(revision.hash);
-        const notebookIds = notebooks.map((row) => row.notebook_id);
-        const notebookCells = rowsForNotebookIds(context, "cells", `notebook_id, cell_id, type, title, position_x, position_y,
-       entity_id, prompt, model, inputs_json, output_artifact_id`, revision.hash, notebookIds);
-        const notebookEdges = rowsForNotebookIds(context, "edges", "notebook_id, edge_id, source_cell_id, target_cell_id, target_input", revision.hash, notebookIds);
-        const notebookRuns = rowsForNotebookIds(context, "runs", `run_id, notebook_id, status, started_at, completed_at,
-       cell_order_json, outputs_json, error`, revision.hash, notebookIds);
-        const timeline = context.store.db
-            .prepare("SELECT book_id, render FROM dolt_at_timeline(?)")
-            .get(revision.hash);
-        const timelineSlots = context.store.db
-            .prepare(`SELECT slot_id, artifact_id, ordinal, volume,
-                audio_fade_in, audio_fade_out
-         FROM dolt_at_timeline_slots(?)`)
-            .all(revision.hash);
-        const timelineAudio = context.store.db
-            .prepare(`SELECT audio_id, artifact_id, ordinal, start_frame, duration_frames,
-                volume, fade_in, fade_out
-         FROM dolt_at_timeline_audio(?)`)
-            .all(revision.hash);
-        const prompts = context.store.db
-            .prepare(`SELECT prompt_id, surface, prompt, context_json, created_at
-         FROM dolt_at_prompt_entries(?)`)
-            .all(revision.hash);
-        const messages = context.store.db
-            .prepare(`SELECT message_id, role, body_json, created_at
-         FROM dolt_at_messages(?)`)
-            .all(revision.hash);
         const currentArtifactIds = context.store.db
             .prepare("SELECT artifact_id FROM artifacts")
             .all()
             .map((row) => row.artifact_id);
         const mutation = await context.store.semantic({
             operation: "restore",
+            tables: SEMANTIC_TABLES,
             details: { fromRevision: revision.hash },
             writeSet: ["book"],
-        }, [
-            "book",
-            "artifacts",
-            "artifact_files",
-            "book_metadata",
-            "artifact_metadata",
-            "audio_waveforms",
-            "entities",
-            "notebooks",
-            "cells",
-            "edges",
-            "runs",
-            "timeline",
-            "timeline_slots",
-            "timeline_audio",
-            "prompt_entries",
-            "messages",
-            "job_runs",
-        ], (_operationId, now) => {
-            context.store.db.prepare("DELETE FROM timeline_slots").run();
-            context.store.db.prepare("DELETE FROM timeline_audio").run();
-            context.store.db.prepare("DELETE FROM edges").run();
-            context.store.db.prepare("DELETE FROM runs").run();
-            context.store.db.prepare("DELETE FROM cells").run();
-            context.store.db.prepare("DELETE FROM notebooks").run();
-            context.store.db.prepare("DELETE FROM artifact_metadata").run();
-            context.store.db.prepare("DELETE FROM audio_waveforms").run();
-            context.store.db.prepare("DELETE FROM artifact_files").run();
-            context.store.db.prepare("DELETE FROM entities").run();
-            context.store.db.prepare("DELETE FROM artifacts").run();
-            context.store.db
-                .prepare("UPDATE book SET slug=?, created_at=? WHERE book_id=?")
-                .run(targetBook.slug, targetBook.created_at, targetBook.book_id);
-            const insertArtifact = context.store.db.prepare(`INSERT INTO artifacts(artifact_id, slug, kind, created_at)
-           VALUES (?, ?, ?, ?)`);
-            for (const row of targetArtifacts) {
-                insertArtifact.run(row.artifact_id, row.slug, row.kind, row.created_at);
-            }
-            insertFiles(context, targetFiles);
-            const insertArtifactMetadata = context.store.db.prepare(`INSERT INTO artifact_metadata(artifact_id, key, value_json)
-           VALUES (?, ?, ?)`);
-            for (const row of artifactMetadata) {
-                insertArtifactMetadata.run(row.artifact_id, row.key, row.value_json);
-            }
-            const insertWaveform = context.store.db.prepare(`INSERT INTO audio_waveforms(artifact_id, peaks_json)
-           VALUES (?, ?)`);
-            for (const row of waveforms) {
-                if (!row.artifact_id)
-                    continue;
-                insertWaveform.run(row.artifact_id, row.peaks_json);
-            }
-            context.store.db.prepare("DELETE FROM book_metadata").run();
-            const insertBookMetadata = context.store.db.prepare("INSERT INTO book_metadata(key, value_json) VALUES (?, ?)");
-            for (const row of bookMetadata) {
-                insertBookMetadata.run(row.key, row.value_json);
-            }
-            const insertEntity = context.store.db.prepare(`INSERT INTO entities(
-            entity_id, type, name, description, prompt, data_json, created_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?)`);
-            for (const row of entities) {
-                insertEntity.run(row.entity_id, row.type, row.name, row.description, row.prompt, row.data_json, row.created_at);
-            }
-            const insertNotebook = context.store.db.prepare(`INSERT INTO notebooks(
-            notebook_id, name, properties_json, created_at
-          ) VALUES (?, ?, ?, ?)`);
-            for (const row of notebooks) {
-                insertNotebook.run(row.notebook_id, row.name, row.properties_json, row.created_at);
-            }
-            insertNotebookChildren(context, notebookCells, notebookEdges, notebookRuns);
-            context.store.db
-                .prepare("UPDATE timeline SET render=? WHERE book_id=?")
-                .run(timeline?.render ?? "landscape", targetBook.book_id);
-            const insertSlot = context.store.db.prepare(`INSERT INTO timeline_slots(
-            slot_id, artifact_id, ordinal, volume, audio_fade_in, audio_fade_out
-          ) VALUES (?, ?, ?, ?, ?, ?)`);
-            for (const row of timelineSlots) {
-                insertSlot.run(row.slot_id, row.artifact_id, row.ordinal, row.volume, row.audio_fade_in, row.audio_fade_out);
-            }
-            const insertAudio = context.store.db.prepare(`INSERT INTO timeline_audio(
-            audio_id, artifact_id, ordinal, start_frame, duration_frames,
-            volume, fade_in, fade_out
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
-            for (const row of timelineAudio) {
-                insertAudio.run(row.audio_id, row.artifact_id, row.ordinal, row.start_frame, row.duration_frames, row.volume, row.fade_in, row.fade_out);
-            }
-            context.store.db.prepare("DELETE FROM prompt_entries").run();
-            const insertPrompt = context.store.db.prepare(`INSERT INTO prompt_entries(
-            prompt_id, surface, prompt, context_json, created_at
-          ) VALUES (?, ?, ?, ?, ?)`);
-            for (const row of prompts) {
-                insertPrompt.run(row.prompt_id, row.surface, row.prompt, row.context_json, row.created_at);
-            }
-            context.store.db.prepare("DELETE FROM messages").run();
-            const insertMessage = context.store.db.prepare(`INSERT INTO messages(message_id, role, body_json, created_at)
-           VALUES (?, ?, ?, ?)`);
-            for (const row of messages) {
-                insertMessage.run(row.message_id, row.role, row.body_json, row.created_at);
-            }
+        }, (_operationId, now) => {
+            reloadSemanticTables(context, revision.hash);
             abortActiveJobs(context, now, "Book restored");
             context.store.db
                 .prepare(`UPDATE runtime_resource_leases
@@ -424,7 +264,9 @@ async function restoreBook(context, revisionReference) {
             context.store.db.prepare("DELETE FROM runtime_artifact_views").run();
             context.store.db.prepare("DELETE FROM runtime_pending_tasks").run();
             context.store.db.prepare("DELETE FROM runtime_generation_errors").run();
-            context.store.db.prepare("DELETE FROM runtime_similarity_embeddings").run();
+            context.store.db
+                .prepare("DELETE FROM runtime_similarity_embeddings")
+                .run();
             context.store.db
                 .prepare("DELETE FROM runtime_text_similarity_documents")
                 .run();
@@ -433,14 +275,94 @@ async function restoreBook(context, revisionReference) {
             }
         });
         for (const artifactId of new Set([...currentArtifactIds, ...targetIds])) {
-            await rm(context.artifactPath(artifactId), { recursive: true, force: true });
+            await rm(context.artifactPath(artifactId), {
+                recursive: true,
+                force: true,
+            });
         }
         for (const artifact of targetArtifacts) {
-            await materializeArtifact(context, artifact.artifact_id);
+            await materializeIgnoringForgotten(context, artifact.artifact_id);
         }
         return ok(revisionForHash(context, mutation.revision), mutation.revision);
     });
 }
+/**
+ * Workspace materialization after a restore tolerates forgotten objects:
+ * the restore commit is already durable, so a file whose bytes were
+ * deliberately deleted must not fail the whole restore — reads of that file
+ * surface OBJECT_UNAVAILABLE instead.
+ */
+async function materializeIgnoringForgotten(context, artifactId) {
+    try {
+        await materializeArtifact(context, artifactId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!/object unavailable/i.test(message))
+            throw error;
+    }
+}
+/**
+ * Restore is mechanical: every semantic table is reloaded from its
+ * `dolt_at_<table>` projection at the target revision, so the resulting
+ * state is exactly the state that revision recorded and no hand-maintained
+ * table list can drift. `SEMANTIC_TABLES` is ordered parent-before-child,
+ * so deleting in reverse order and reinserting in forward order satisfies
+ * foreign keys; columns come from `PRAGMA table_info`, not per-table code.
+ * Reinserted rows identical to HEAD produce no diff, so unchanged tables
+ * are never staged by the surrounding commit.
+ *
+ * The single deliberate exception is `objects`: its rows are permanent
+ * tombstone records, so restore merges instead of wiping — rows are never
+ * deleted and `forgotten_at` never rewinds (see `restoreObjectRows`).
+ */
+function reloadSemanticTables(context, revision) {
+    const db = context.store.db;
+    const snapshots = SEMANTIC_TABLES.map((table) => {
+        const columns = db.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name);
+        const rows = db
+            .prepare(`SELECT * FROM dolt_at_${table}(?)`)
+            .all(revision);
+        return { table, columns, rows };
+    });
+    for (const { table } of [...snapshots].reverse()) {
+        // `objects` is the one exception to the mechanical wipe: rows are never
+        // deleted (a row is the permanent tombstone for every historical
+        // reference) and `forgotten_at` never rewinds — see the upsert below.
+        if (table === "objects")
+            continue;
+        db.prepare(`DELETE FROM ${table}`).run();
+    }
+    for (const { table, columns, rows } of snapshots) {
+        if (rows.length === 0)
+            continue;
+        if (table === "objects") {
+            restoreObjectRows(db, columns, rows);
+            continue;
+        }
+        const insert = db.prepare(`INSERT INTO ${table}(${columns.join(", ")})
+       VALUES (${columns.map(() => "?").join(", ")})`);
+        for (const row of rows) {
+            insert.run(...columns.map((column) => row[column] ?? null));
+        }
+    }
+}
+/**
+ * Restores `objects` with merge semantics instead of wipe-and-reload:
+ * rows created after the target revision survive (object rows are never
+ * deleted), and an existing forget tombstone always wins over the target
+ * revision's live state (`forgotten_at` never rewinds — deleted bytes do
+ * not come back because history was restored).
+ */
+function restoreObjectRows(db, columns, rows) {
+    const upsert = db.prepare(`INSERT INTO objects(${columns.join(", ")})
+     VALUES (${columns.map(() => "?").join(", ")})
+     ON CONFLICT(object_hash) DO UPDATE SET
+       forgotten_at=COALESCE(objects.forgotten_at, excluded.forgotten_at)`);
+    for (const row of rows) {
+        upsert.run(...columns.map((column) => row[column] ?? null));
+    }
+}
 async function logAction(context, actionName, payload) {
     return resultOf(async () => {
         const result = await recordOperation(context, `action:${actionName}`, undefined, {
@@ -464,248 +386,10 @@ function actionLog(context, options = {}) {
         .map((revision) => ({
         hash: revision.hash,
         action: revision.operation.slice("action:".length),
-        payload: revision.details?.payload ??
-            {},
+        payload: revision.details?.payload ?? {},
         date: revision.date,
     }));
 }
-function actions(context, options = {}) {
-    return syncResultOf(() => {
-        const limit = Math.max(1, options.limit ?? 200);
-        const params = [];
-        let cursorClause = "";
-        if (options.cursor) {
-            const cursor = context.store.db
-                .prepare("SELECT created_at, action_id FROM actions WHERE action_id=?")
-                .get(options.cursor);
-            if (cursor) {
-                cursorClause = "WHERE (created_at < ? OR (created_at = ? AND action_id < ?))";
-                params.push(cursor.created_at, cursor.created_at, cursor.action_id);
-            }
-        }
-        params.push(limit + 1);
-        const rows = context.store.db
-            .prepare(`${ACTION_SELECT}
-         ${cursorClause}
-         ORDER BY created_at DESC, action_id DESC
-         LIMIT ?`)
-            .all(...params);
-        const page = rows.slice(0, limit);
-        return {
-            headRevision: context.store.head,
-            actions: page
-                .map((row) => actionFromRow(context, row))
-                .sort((left, right) => left.date.localeCompare(right.date)),
-            ...(rows.length > limit ? { nextCursor: page.at(-1)?.action_id } : {}),
-        };
-    });
-}
-function action(context, actionId) {
-    return syncResultOf(() => requiredAction(context, actionId));
-}
-async function recordAction(context, input) {
-    return resultOf(async () => {
-        assertWriteSet(context, input.baseRevision, input.writeSet ?? []);
-        const actionId = input.actionId ?? newUuidV7();
-        assertUuidV7(actionId, "Action ID");
-        const phase = input.phase ?? "completed";
-        const scope = input.scope ?? "book";
-        assertActionPhase(phase);
-        assertActionScope(scope);
-        for (const parentId of input.parentActionIds ?? []) {
-            assertUuidV7(parentId, "Parent action ID");
-            requiredAction(context, parentId);
-        }
-        if (input.targetActionId) {
-            assertUuidV7(input.targetActionId, "Target action ID");
-        }
-        const actor = input.actor ?? "videobook";
-        const inputArtifacts = resolveArtifactReferences(context, input.inputArtifactIds ?? []);
-        const outputArtifacts = resolveArtifactReferences(context, input.outputArtifactIds ?? []);
-        const targetArtifactId = input.targetArtifactId
-            ? context.artifactRow(input.targetArtifactId).artifact_id
-            : null;
-        const mutation = await context.store.semantic({
-            operation: `action:${input.operation}`,
-            ...(targetArtifactId ? { artifactId: targetArtifactId } : {}),
-            details: {
-                ...(input.details ?? {}),
-                actionId,
-                phase,
-                scope,
-                lane: input.lane ?? actor,
-            },
-            ...(input.baseRevision ? { baseRevision: input.baseRevision } : {}),
-            writeSet: input.writeSet ?? [],
-        }, [
-            "actions",
-            "action_events",
-            "action_parents",
-            "action_artifacts",
-            "action_write_set",
-        ], (operationId, now) => {
-            context.store.db
-                .prepare(`INSERT INTO actions(
-              action_id, operation, scope, actor, lane, phase,
-              base_revision, target_artifact_id, target_action_id,
-              layout_json, details_json, created_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(action_id) DO UPDATE SET
-              operation=excluded.operation,
-              scope=excluded.scope,
-              actor=excluded.actor,
-              lane=excluded.lane,
-              phase=excluded.phase,
-              base_revision=excluded.base_revision,
-              target_artifact_id=excluded.target_artifact_id,
-              target_action_id=excluded.target_action_id,
-              layout_json=excluded.layout_json,
-              details_json=excluded.details_json`)
-                .run(actionId, input.operation, scope, actor, input.lane ?? actor, phase, input.baseRevision ?? null, targetArtifactId, input.targetActionId ?? null, input.layout ? canonicalJson(input.layout) : null, canonicalJson(input.details ?? {}), now);
-            context.store.db
-                .prepare(`INSERT INTO action_events(
-              event_id, action_id, operation_id, phase,
-              details_json, created_at
-            ) VALUES (?, ?, ?, ?, ?, ?)`)
-                .run(newUuidV7(), actionId, operationId, phase, canonicalJson(input.details ?? {}), now);
-            replaceActionLinks(context, actionId, input.parentActionIds ?? [], inputArtifacts, outputArtifacts, input.writeSet ?? []);
-        });
-        return ok({
-            action: requiredAction(context, actionId),
-            revision: revisionForHash(context, mutation.revision),
-        }, mutation.revision);
-    });
-}
-function requiredAction(context, actionId) {
-    const row = context.store.db
-        .prepare(`${ACTION_SELECT} WHERE action_id=?`)
-        .get(actionId);
-    if (!row) {
-        throw new EngineFault({
-            code: "NOT_FOUND",
-            message: `History action not found: ${actionId}`,
-        });
-    }
-    return actionFromRow(context, row);
-}
-function actionFromRow(context, row) {
-    const parents = context.store.db
-        .prepare("SELECT parent_action_id FROM action_parents WHERE action_id=?")
-        .all(row.action_id).map((item) => item.parent_action_id);
-    const links = context.store.db
-        .prepare(`SELECT artifact_id, direction
-       FROM action_artifacts WHERE action_id=?`)
-        .all(row.action_id);
-    const events = context.store.db
-        .prepare(`SELECT event_id, action_id, operation_id, phase,
-              details_json, created_at
-       FROM action_events WHERE action_id=?
-       ORDER BY created_at, event_id`)
-        .all(row.action_id);
-    const revisionsByOperation = new Map(allRevisions(context).map((revision) => [revision.operationId, revision]));
-    return {
-        id: row.action_id,
-        operation: row.operation,
-        title: titleForOperation(row.operation),
-        scope: row.scope,
-        actor: row.actor,
-        lane: row.lane,
-        date: new Date(row.created_at).toISOString(),
-        phase: row.phase,
-        ...(row.base_revision ? { baseRevision: row.base_revision } : {}),
-        parentActionIds: parents,
-        inputArtifacts: links
-            .filter((link) => link.direction === "input")
-            .map((link) => artifactRef(context, link.artifact_id)),
-        outputArtifacts: links
-            .filter((link) => link.direction === "output")
-            .map((link) => artifactRef(context, link.artifact_id)),
-        ...(row.target_artifact_id
-            ? { targetArtifactId: row.target_artifact_id }
-            : {}),
-        ...(row.target_action_id ? { targetActionId: row.target_action_id } : {}),
-        ...(row.layout_json
-            ? {
-                layout: parseJson(row.layout_json, { stage: 0, column: 0 }),
-            }
-            : {}),
-        details: parseJson(row.details_json, {}),
-        events: events.map((event) => {
-            const revision = revisionsByOperation.get(event.operation_id);
-            return {
-                id: event.event_id,
-                revision: revision?.hash ?? context.store.head,
-                phase: event.phase,
-                date: new Date(event.created_at).toISOString(),
-                details: parseJson(event.details_json, {}),
-                files: revision?.files ?? [],
-                fileChanges: revision?.fileChanges ?? [],
-            };
-        }),
-    };
-}
-function replaceActionLinks(context, actionId, parents, inputs, outputs, writeSet) {
-    context.store.db
-        .prepare("DELETE FROM action_parents WHERE action_id=?")
-        .run(actionId);
-    context.store.db
-        .prepare("DELETE FROM action_artifacts WHERE action_id=?")
-        .run(actionId);
-    context.store.db
-        .prepare("DELETE FROM action_write_set WHERE action_id=?")
-        .run(actionId);
-    const insertParent = context.store.db.prepare("INSERT INTO action_parents(action_id, parent_action_id) VALUES (?, ?)");
-    for (const parent of new Set(parents))
-        insertParent.run(actionId, parent);
-    const insertArtifact = context.store.db.prepare(`INSERT INTO action_artifacts(action_id, artifact_id, direction)
-     VALUES (?, ?, ?)`);
-    for (const artifactId of new Set(inputs)) {
-        insertArtifact.run(actionId, artifactId, "input");
-    }
-    for (const artifactId of new Set(outputs)) {
-        insertArtifact.run(actionId, artifactId, "output");
-    }
-    const insertResource = context.store.db.prepare("INSERT INTO action_write_set(action_id, resource) VALUES (?, ?)");
-    for (const resource of new Set(writeSet))
-        insertResource.run(actionId, resource);
-}
-function assertWriteSet(context, baseRevision, writeSet) {
-    if (!baseRevision || baseRevision === context.store.head)
-        return;
-    const revisions = allRevisions(context);
-    let baseIndex = revisions.findIndex((revision) => revision.hash === baseRevision || revision.hash.startsWith(baseRevision));
-    if (baseIndex < 0) {
-        const commit = context.store.db.doltLog().find((item) => item.commit_hash === baseRevision || item.commit_hash.startsWith(baseRevision));
-        if (!commit) {
-            throw new EngineFault({
-                code: "STALE_REVISION",
-                message: `Base revision not found: ${baseRevision}`,
-            });
-        }
-        // Initialization has no operation record, so it is older than every
-        // operation-bearing revision we can inspect for a write-set conflict.
-        baseIndex = revisions.length;
-    }
-    const requested = new Set(writeSet);
-    const conflicts = new Set();
-    for (const revision of revisions.slice(0, baseIndex)) {
-        const changed = revision.details?.writeSet;
-        if (!Array.isArray(changed))
-            continue;
-        for (const resource of changed) {
-            if (typeof resource === "string" && requested.has(resource)) {
-                conflicts.add(resource);
-            }
-        }
-    }
-    if (conflicts.size > 0) {
-        throw new EngineFault({
-            code: "ACTION_CONFLICT",
-            message: `Action conflicts with newer changes: ${[...conflicts].join(", ")}`,
-            details: { resources: [...conflicts] },
-        });
-    }
-}
 function resetArtifactRuntime(context, artifactId, now) {
     context.store.db
         .prepare(`INSERT INTO runtime_artifact_views(
@@ -759,163 +443,22 @@ function abortActiveJobs(context, now, message) {
 }
 function filesAt(context, revision, artifactId) {
     return context.store.db
-        .prepare(`SELECT artifact_id, path, object_hash, mtime_ms, created_at
+        .prepare(`SELECT artifact_id, path, object_hash, created_at
        FROM dolt_at_artifact_files(?) WHERE artifact_id=? ORDER BY path`)
         .all(revision, artifactId);
 }
-function rowsForArtifactIds(context, table, columns, revision, artifactIds) {
-    if (artifactIds.length === 0)
-        return [];
-    const placeholders = artifactIds.map(() => "?").join(", ");
-    return context.store.db
-        .prepare(`SELECT ${columns} FROM dolt_at_${table}(?)
-       WHERE artifact_id IN (${placeholders})`)
-        .all(revision, ...artifactIds);
-}
-function rowsForNotebookIds(context, table, columns, revision, notebookIds) {
-    if (notebookIds.length === 0)
-        return [];
-    const placeholders = notebookIds.map(() => "?").join(", ");
-    return context.store.db
-        .prepare(`SELECT ${columns} FROM dolt_at_${table}(?)
-       WHERE notebook_id IN (${placeholders})`)
-        .all(revision, ...notebookIds);
-}
 function insertFiles(context, files) {
     const insert = context.store.db.prepare(`INSERT INTO artifact_files(
-      artifact_id, path, object_hash, mtime_ms, created_at
-    ) VALUES (?, ?, ?, ?, ?)`);
+      artifact_id, path, object_hash, created_at
+    ) VALUES (?, ?, ?, ?)`);
     for (const row of files) {
-        insert.run(row.artifact_id, row.path, row.object_hash, row.mtime_ms, row.created_at);
+        insert.run(row.artifact_id, row.path, row.object_hash, row.created_at);
     }
 }
-function insertNotebookChildren(context, cells, edges, runs) {
-    const insertCell = 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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-    for (const row of cells) {
-        insertCell.run(row.notebook_id, row.cell_id, row.type, row.title, row.position_x, row.position_y, row.entity_id, row.prompt, row.model, row.inputs_json, row.output_artifact_id);
-    }
-    const insertEdge = context.store.db.prepare(`INSERT INTO edges(
-      notebook_id, edge_id, source_cell_id, target_cell_id, target_input
-    ) VALUES (?, ?, ?, ?, ?)`);
-    for (const row of edges) {
-        insertEdge.run(row.notebook_id, row.edge_id, row.source_cell_id, row.target_cell_id, row.target_input);
-    }
-    const insertRun = context.store.db.prepare(`INSERT INTO runs(
-      run_id, notebook_id, status, started_at, completed_at,
-      cell_order_json, outputs_json, error
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
-    for (const row of runs) {
-        insertRun.run(row.run_id, row.notebook_id, row.status, row.started_at, row.completed_at, row.cell_order_json, row.outputs_json, row.error);
-    }
-}
-function operationFromDiff(row) {
-    const prefix = row.diff_type === "removed" ? "from_" : "to_";
-    const operationId = row[`${prefix}operation_id`];
-    const operation = row[`${prefix}operation`];
-    const detailsJson = row[`${prefix}details_json`];
-    const writeSetJson = row[`${prefix}write_set_json`];
-    const createdAt = row[`${prefix}created_at`];
-    const author = row[`${prefix}author`];
-    if (typeof operationId !== "string" ||
-        typeof operation !== "string" ||
-        typeof detailsJson !== "string" ||
-        typeof writeSetJson !== "string" ||
-        typeof createdAt !== "number" ||
-        typeof author !== "string") {
-        return null;
-    }
-    const artifactId = row[`${prefix}artifact_id`];
-    const baseRevision = row[`${prefix}base_revision`];
-    return {
-        operation_id: operationId,
-        operation,
-        artifact_id: typeof artifactId === "string" ? artifactId : null,
-        details_json: detailsJson,
-        write_set_json: writeSetJson,
-        base_revision: typeof baseRevision === "string" ? baseRevision : null,
-        created_at: createdAt,
-        author,
-    };
-}
-function revisionFileChanges(rows, artifactId) {
-    const changes = [];
-    for (const row of rows) {
-        const fromArtifact = row.from_artifact_id;
-        const toArtifact = row.to_artifact_id;
-        if (artifactId &&
-            fromArtifact !== artifactId &&
-            toArtifact !== artifactId) {
-            continue;
-        }
-        const fromPath = typeof row.from_path === "string" ? row.from_path : undefined;
-        const toPath = typeof row.to_path === "string" ? row.to_path : undefined;
-        const file = toPath ?? fromPath;
-        if (!file)
-            continue;
-        changes.push({
-            status: row.diff_type,
-            file,
-            ...(fromPath && toPath && fromPath !== toPath
-                ? { oldFile: fromPath }
-                : {}),
-        });
-    }
-    return changes;
-}
-function artifactSlugAt(context, artifactId, revision) {
+function artifactLabelAt(context, artifactId, revision) {
     const row = context.store.db
-        .prepare(`SELECT slug FROM dolt_at_artifacts(?) WHERE artifact_id=?`)
+        .prepare(`SELECT label FROM dolt_at_artifacts(?) WHERE artifact_id=?`)
         .get(revision, artifactId);
-    return row?.slug;
-}
-function resolveArtifactReferences(context, references) {
-    return [
-        ...new Set(references.map((reference) => context.artifactRow(reference).artifact_id)),
-    ];
-}
-function artifactRef(context, artifactId) {
-    try {
-        const artifact = context.artifactRowById(artifactId);
-        return {
-            id: artifact.artifact_id,
-            slug: artifact.slug,
-            kind: historyArtifactKind(artifact.kind),
-        };
-    }
-    catch {
-        return { id: artifactId, slug: artifactId, kind: "unknown" };
-    }
-}
-function historyArtifactKind(kind) {
-    return kind;
-}
-function assertActionPhase(value) {
-    if (![
-        "requested",
-        "started",
-        "completed",
-        "failed",
-        "cancelled",
-        "conflicted",
-    ].includes(value)) {
-        throw new Error(`Invalid action phase: ${value}`);
-    }
-}
-function assertActionScope(value) {
-    if (!["book", "artifact", "layout", "external", "system"].includes(value)) {
-        throw new Error(`Invalid action scope: ${value}`);
-    }
-}
-function titleForOperation(operation) {
-    return operation.replaceAll("_", " ").replaceAll("-", " ");
+    return row?.label ?? undefined;
 }
-const ACTION_SELECT = `
-  SELECT action_id, operation, scope, actor, lane, phase,
-         base_revision, target_artifact_id, target_action_id,
-         layout_json, details_json, created_at
-  FROM actions
-`;
 //# sourceMappingURL=history.js.map