videobook-engine 2.0.1

package/dist/history.js

@@ -0,0 +1,921 @@
+import { rm } from "node:fs/promises";
+import { ok } from "./engine-types.js";
+import { resultOf, syncResultOf, } from "./context.js";
+import { artifactSlug } from "./artifacts.js";
+import { materializeArtifact } from "./files.js";
+import { assertUuidV7, isUuidV7, newUuidV7 } from "./ids.js";
+import { canonicalJson, EngineFault, parseJson, } 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),
+        recordOperation: (operation, artifact, details) => recordOperation(context, operation, artifact, details),
+        restoreArtifact: (artifactId, revision, slug) => restoreArtifact(context, artifactId, revision, slug),
+        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) {
+    const commit = context.store.db
+        .doltLog()
+        .find((item) => item.commit_hash === hash);
+    if (!commit) {
+        throw new EngineFault({
+            code: "NOT_FOUND",
+            message: `Revision not found: ${hash}`,
+        });
+    }
+    return {
+        hash,
+        message: commit.message,
+        date: commit.date,
+        author: commit.committer,
+    };
+}
+function revisionHistory(context, limit) {
+    return allRevisions(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;
+        }
+    }
+    return revisions
+        .filter((revision) => revision.artifactId === artifactId)
+        .slice(0, Math.max(0, limit));
+}
+function allRevisions(context) {
+    const commits = context.store.db.doltLog();
+    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,
+            });
+        }
+    }
+    return revisions;
+}
+function resolveRevision(context, reference) {
+    const historical = allRevisions(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));
+    return commit
+        ? {
+            hash: commit.commit_hash,
+            message: commit.message,
+            date: commit.date,
+            author: commit.committer,
+        }
+        : null;
+}
+function requiredRevision(context, reference) {
+    const revision = resolveRevision(context, reference);
+    if (!revision) {
+        throw new EngineFault({
+            code: "NOT_FOUND",
+            message: `Revision not found: ${reference}`,
+        });
+    }
+    return revision;
+}
+async function recordOperation(context, operation, artifactReference, details) {
+    return resultOf(async () => {
+        const artifact = artifactReference
+            ? context.artifactRow(artifactReference)
+            : null;
+        const mutation = await context.store.semantic({
+            operation,
+            ...(artifact ? { artifactId: artifact.artifact_id } : {}),
+            details: {
+                ...(details ?? {}),
+                ...(artifact ? { artifactSlug: artifact.slug } : {}),
+            },
+            writeSet: artifact
+                ? [`artifact:${artifact.artifact_id}`]
+                : ["book"],
+        }, [], () => undefined);
+        return ok(revisionForHash(context, mutation.revision), mutation.revision);
+    });
+}
+async function restoreArtifact(context, artifactId, revisionReference, replacementSlug) {
+    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
+         FROM dolt_at_artifacts(?)
+         WHERE artifact_id=?`)
+            .get(revision.hash, artifactId);
+        if (!target) {
+            throw new EngineFault({
+                code: "NOT_FOUND",
+                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
+         FROM dolt_at_artifact_metadata(?) WHERE artifact_id=?`)
+            .all(revision.hash, artifactId);
+        const waveform = context.store.db
+            .prepare(`SELECT peaks_json
+         FROM dolt_at_audio_waveforms(?) WHERE artifact_id=?`)
+            .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}`,
+            ],
+        }, [
+            "artifacts",
+            "artifact_files",
+            "artifact_metadata",
+            "audio_waveforms",
+        ], (_operationId, now) => {
+            context.store.db
+                .prepare(`INSERT INTO artifacts(
+              artifact_id, slug, kind, created_at
+            ) VALUES (?, ?, ?, ?)
+            ON CONFLICT(artifact_id) DO UPDATE SET
+              slug=excluded.slug,
+              kind=excluded.kind`)
+                .run(target.artifact_id, desiredSlug, target.kind, target.created_at);
+            context.store.db
+                .prepare("DELETE FROM artifact_files WHERE artifact_id=?")
+                .run(artifactId);
+            context.store.db
+                .prepare("DELETE FROM artifact_metadata WHERE artifact_id=?")
+                .run(artifactId);
+            context.store.db
+                .prepare("DELETE FROM audio_waveforms WHERE artifact_id=?")
+                .run(artifactId);
+            insertFiles(context, files);
+            const insertMetadata = context.store.db.prepare(`INSERT INTO artifact_metadata(
+            artifact_id, key, value_json
+          ) VALUES (?, ?, ?)`);
+            for (const row of metadata) {
+                insertMetadata.run(artifactId, row.key, row.value_json);
+            }
+            if (waveform) {
+                context.store.db
+                    .prepare(`INSERT INTO audio_waveforms(artifact_id, peaks_json)
+               VALUES (?, ?)`)
+                    .run(artifactId, waveform.peaks_json);
+            }
+            resetArtifactRuntime(context, artifactId, now);
+        });
+        await rm(context.artifactPath(artifactId), { recursive: true, force: true });
+        await materializeArtifact(context, artifactId);
+        return ok(revisionForHash(context, mutation.revision), mutation.revision);
+    });
+}
+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(?)")
+            .get(revision.hash);
+        if (!targetBook) {
+            throw new EngineFault({
+                code: "NOT_FOUND",
+                message: `Book did not exist at ${revision.hash}`,
+            });
+        }
+        const currentBook = context.bookRow();
+        if (targetBook.book_id !== currentBook.book_id) {
+            throw new EngineFault({
+                code: "SCHEMA_INCOMPATIBLE",
+                message: "A restore cannot replace the catalog's stable book ID",
+            });
+        }
+        const targetArtifacts = context.store.db
+            .prepare(`SELECT artifact_id, slug, 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",
+            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);
+            }
+            abortActiveJobs(context, now, "Book restored");
+            context.store.db
+                .prepare(`UPDATE runtime_resource_leases
+             SET revoked_at=?, fence=fence+1 WHERE revoked_at IS NULL`)
+                .run(now);
+            context.store.db
+                .prepare("UPDATE runtime_workspace_entries SET invalidated_at=?")
+                .run(now);
+            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_text_similarity_documents")
+                .run();
+            for (const row of targetArtifacts) {
+                resetArtifactRuntime(context, row.artifact_id, now);
+            }
+        });
+        for (const artifactId of new Set([...currentArtifactIds, ...targetIds])) {
+            await rm(context.artifactPath(artifactId), { recursive: true, force: true });
+        }
+        for (const artifact of targetArtifacts) {
+            await materializeArtifact(context, artifact.artifact_id);
+        }
+        return ok(revisionForHash(context, mutation.revision), mutation.revision);
+    });
+}
+async function logAction(context, actionName, payload) {
+    return resultOf(async () => {
+        const result = await recordOperation(context, `action:${actionName}`, undefined, {
+            payload,
+        });
+        if (!result.ok)
+            throw new EngineFault(result.error);
+        return {
+            hash: result.value.hash,
+            action: actionName,
+            payload,
+            date: result.value.date,
+        };
+    });
+}
+function actionLog(context, options = {}) {
+    return revisionHistory(context, Math.max(options.limit ?? 100, 100))
+        .filter((revision) => revision.operation?.startsWith("action:") &&
+        (!options.action || revision.operation === `action:${options.action}`))
+        .slice(0, options.limit ?? 100)
+        .map((revision) => ({
+        hash: revision.hash,
+        action: revision.operation.slice("action:".length),
+        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(
+        artifact_id, status, meta_json, updated_at
+      ) VALUES (?, 'ready', '{}', ?)
+      ON CONFLICT(artifact_id) DO UPDATE SET
+        status='ready', meta_json='{}', owner_id=NULL,
+        owner_kind=NULL, pid=NULL, deadline_at=NULL,
+        updated_at=excluded.updated_at, fence=fence+1`)
+        .run(artifactId, now);
+    context.store.db
+        .prepare(`INSERT INTO runtime_workspace_entries(
+        artifact_id, path, invalidated_at, last_accessed_at
+      ) VALUES (?, ?, ?, ?)
+      ON CONFLICT(artifact_id) DO UPDATE SET
+        invalidated_at=excluded.invalidated_at,
+        hydrated_at=NULL,
+        last_accessed_at=excluded.last_accessed_at`)
+        .run(artifactId, context.artifactPath(artifactId), now, now);
+    context.store.db
+        .prepare("DELETE FROM runtime_pending_tasks WHERE artifact_id=?")
+        .run(artifactId);
+    context.store.db
+        .prepare("DELETE FROM runtime_generation_errors WHERE artifact_id=?")
+        .run(artifactId);
+    context.store.db
+        .prepare(`UPDATE runtime_resource_leases
+       SET revoked_at=?, fence=fence+1
+       WHERE artifact_id=? AND revoked_at IS NULL`)
+        .run(now, artifactId);
+}
+function abortActiveJobs(context, now, message) {
+    const jobs = context.store.db
+        .prepare(`SELECT id, artifact_id, type, payload_json, result_json, started_at
+       FROM runtime_jobs
+       WHERE state IN ('queued','running','completing')`)
+        .all();
+    const update = context.store.db.prepare(`UPDATE runtime_jobs
+     SET state='aborted', error_json=?, finished_at=?,
+         lease_expires_at=NULL, pid=NULL, fence=fence+1
+     WHERE id=?`);
+    const insertRun = context.store.db.prepare(`INSERT INTO job_runs(
+      run_id, artifact_id, job_type, state,
+      payload_json, result_json, error_json, started_at, finished_at
+    ) VALUES (?, ?, ?, 'aborted', ?, ?, ?, ?, ?)`);
+    for (const job of jobs) {
+        const errorJson = canonicalJson({ message });
+        update.run(errorJson, now, job.id);
+        insertRun.run(newUuidV7(), job.artifact_id, job.type, job.payload_json, job.result_json, errorJson, job.started_at, now);
+    }
+}
+function filesAt(context, revision, artifactId) {
+    return context.store.db
+        .prepare(`SELECT artifact_id, path, object_hash, mtime_ms, 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 (?, ?, ?, ?, ?)`);
+    for (const row of files) {
+        insert.run(row.artifact_id, row.path, row.object_hash, row.mtime_ms, 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) {
+    const row = context.store.db
+        .prepare(`SELECT slug 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("-", " ");
+}
+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