videobook 0.0.0-stage → 0.2.0

package/dist/jobs/extract-frame.js

@@ -0,0 +1,58 @@
+import { readFile, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { queue, registerJobHandler } from "../queue.js";
+import { runFfmpeg } from "../ffmpeg.js";
+import { withLockedLocalLease } from "./_lease.js";
+const LOCK_DURATION_MS = 60_000;
+export function registerExtractFrameJob(engine) {
+    registerJobHandler("extract_frame", async (payload, ctx) => {
+        const { inputPath, timestamp, imageAssetId, imageAssetDir, sourceVideoId, bookId, width, height, mode, } = payload;
+        // ffmpeg has no API for "write to memory", so we stage the frame in a
+        // tempfile outside the asset directory and then route the bytes through
+        // the engine file API, which ingests it into CAS and versions the mapping.
+        const tempPath = join(tmpdir(), `videocity-extract-frame-${imageAssetId}-${Date.now()}.jpg`);
+        try {
+            const origin = await withLockedLocalLease(engine, imageAssetId, imageAssetDir, ctx, "extract", { durationMs: LOCK_DURATION_MS }, async () => {
+                await runFfmpeg([
+                    "-y",
+                    "-ss", String(timestamp),
+                    "-i", inputPath,
+                    "-frames:v", "1",
+                    "-q:v", "2",
+                    tempPath,
+                ]);
+                const outStat = await stat(tempPath).catch(() => null);
+                if (!outStat || outStat.size === 0) {
+                    throw new Error(`ffmpeg produced no output for ${inputPath} at t=${timestamp}s (mode=${mode})`);
+                }
+                const buffer = await readFile(tempPath);
+                const writeResult = await engine.files.write(imageAssetId, "original.jpg", buffer);
+                if (!writeResult.ok) {
+                    throw new Error(`failed to write original.jpg for ${imageAssetId}: ${writeResult.error.message}`);
+                }
+                const origin = {
+                    origin: `${mode}_frame`,
+                    source_asset: sourceVideoId,
+                    timestamp,
+                    width,
+                    height,
+                };
+                await engine.metadata.artifacts.write(imageAssetId, "original", origin);
+                return origin;
+            }, { durationMs: LOCK_DURATION_MS, waitForActiveMs: 30_000 });
+            const jobId = `process-image-${imageAssetId}-${Date.now()}`;
+            await queue.enqueue(jobId, {
+                type: "process_image",
+                assetId: imageAssetId,
+                bookId,
+                extension: ".jpg",
+                provenance: origin,
+            });
+            return { success: true };
+        }
+        finally {
+            await rm(tempPath, { force: true }).catch(() => { });
+        }
+    });
+}

package/dist/jobs/extract-notebook-audio.js

@@ -0,0 +1,82 @@
+import { registerJobHandler } from "../queue.js";
+import { extractSourceAudio } from "../notebook-media-ops.js";
+import { mutateNotebook } from "../notebook-mutations.js";
+import { notebookCellFingerprint } from "./run-notebook.js";
+async function writeAudioCellResult(engine, input, operation, result) {
+    const written = await mutateNotebook(engine, input.notebookId, operation, (notebook) => {
+        const cell = notebook.cells.find((candidate) => candidate.id === input.cellId);
+        if (!cell)
+            return notebook;
+        const updatedAt = new Date().toISOString();
+        const updatedCell = result.status === "completed"
+            ? {
+                ...cell,
+                outputArtifactId: result.artifactId,
+                inputs: {
+                    ...(cell.inputs ?? {}),
+                    durationSeconds: result.durationSeconds,
+                    sourceCellId: input.sourceCellId,
+                    state: "completed",
+                },
+            }
+            : {
+                ...cell,
+                inputs: {
+                    ...(cell.inputs ?? {}),
+                    state: "error",
+                },
+            };
+        return {
+            ...notebook,
+            cells: notebook.cells.map((candidate) => candidate.id === input.cellId ? updatedCell : candidate),
+            execution: {
+                ...(notebook.execution ?? {}),
+                [input.cellId]: {
+                    fingerprint: notebookCellFingerprint(notebook, updatedCell),
+                    status: result.status,
+                    runId: input.runId,
+                    ...(result.status === "completed"
+                        ? { outputArtifactId: result.artifactId, completedAt: updatedAt }
+                        : { error: result.error }),
+                    updatedAt,
+                    tool: "ffmpeg",
+                },
+            },
+        };
+    }, { cellId: input.cellId, runId: input.runId }, result.status === "completed" ? { artifactId: result.artifactId } : {});
+    if (!written.ok)
+        throw new Error(written.error.message);
+}
+export function registerExtractNotebookAudioJob(engine) {
+    registerJobHandler("extract_notebook_audio", async (payload) => {
+        const input = payload;
+        try {
+            const result = await extractSourceAudio(engine, input.sourceArtifactId, input.title, input.startSeconds === undefined && input.durationSeconds === undefined
+                ? undefined
+                : {
+                    startSeconds: input.startSeconds ?? 0,
+                    ...(input.durationSeconds === undefined
+                        ? {}
+                        : { durationSeconds: input.durationSeconds }),
+                });
+            await writeAudioCellResult(engine, input, "complete_extract_notebook_audio", {
+                status: "completed",
+                artifactId: result.artifactId,
+                durationSeconds: result.durationSeconds,
+            });
+            return {
+                success: true,
+                artifactId: result.artifactId,
+                durationSeconds: result.durationSeconds,
+            };
+        }
+        catch (cause) {
+            const message = cause instanceof Error ? cause.message : String(cause);
+            await writeAudioCellResult(engine, input, "fail_extract_notebook_audio", {
+                status: "error",
+                error: message,
+            }).catch(() => undefined);
+            throw cause;
+        }
+    });
+}

package/dist/jobs/extract-notebook-frame.js

@@ -0,0 +1,93 @@
+import { queue, registerJobHandler } from "../queue.js";
+import { captureFrame } from "../notebook-media-ops.js";
+import { mutateNotebook } from "../notebook-mutations.js";
+import { notebookCellFingerprint } from "./run-notebook.js";
+async function writeFrameCellResult(engine, input, operation, result) {
+    const written = await mutateNotebook(engine, input.notebookId, operation, (notebook) => {
+        const cell = notebook.cells.find((candidate) => candidate.id === input.cellId);
+        if (!cell)
+            return notebook;
+        const updatedAt = new Date().toISOString();
+        const updatedCell = result.status === "completed"
+            ? {
+                ...cell,
+                outputArtifactId: result.artifactId,
+                inputs: {
+                    ...(cell.inputs ?? {}),
+                    atSeconds: result.atSeconds,
+                    state: "completed",
+                },
+            }
+            : {
+                ...cell,
+                inputs: {
+                    ...(cell.inputs ?? {}),
+                    state: "error",
+                },
+            };
+        return {
+            ...notebook,
+            cells: notebook.cells.map((candidate) => candidate.id === input.cellId ? updatedCell : candidate),
+            execution: {
+                ...(notebook.execution ?? {}),
+                [input.cellId]: {
+                    fingerprint: notebookCellFingerprint(notebook, updatedCell),
+                    status: result.status,
+                    runId: input.runId,
+                    ...(result.status === "completed"
+                        ? { outputArtifactId: result.artifactId, completedAt: updatedAt }
+                        : { error: result.error }),
+                    updatedAt,
+                    tool: "ffmpeg",
+                },
+            },
+        };
+    }, { cellId: input.cellId, runId: input.runId }, result.status === "completed" ? { artifactId: result.artifactId } : {});
+    if (!written.ok)
+        throw new Error(written.error.message);
+}
+export function registerExtractNotebookFrameJob(engine) {
+    registerJobHandler("extract_notebook_frame", async (payload) => {
+        const input = payload;
+        try {
+            const result = await captureFrame(engine, input.sourceArtifactId, {
+                role: input.frameMode,
+                ...(input.frameMode === "time"
+                    && typeof input.timestampSeconds === "number"
+                    ? { timestampSeconds: input.timestampSeconds }
+                    : {}),
+                title: input.title,
+            });
+            await queue.enqueue(`process-image-${result.artifactId}-${Date.now()}`, {
+                type: "process_image",
+                assetId: result.artifactId,
+                bookId: input.bookId,
+                extension: ".jpg",
+                provenance: {
+                    origin: "extract_frame",
+                    sourceArtifactId: input.sourceArtifactId,
+                    frameMode: input.frameMode,
+                    atSeconds: result.atSeconds,
+                },
+            });
+            await writeFrameCellResult(engine, input, "complete_extract_notebook_frame", {
+                status: "completed",
+                artifactId: result.artifactId,
+                atSeconds: result.atSeconds,
+            });
+            return {
+                success: true,
+                artifactId: result.artifactId,
+                atSeconds: result.atSeconds,
+            };
+        }
+        catch (cause) {
+            const message = cause instanceof Error ? cause.message : String(cause);
+            await writeFrameCellResult(engine, input, "fail_extract_notebook_frame", {
+                status: "error",
+                error: message,
+            }).catch(() => undefined);
+            throw cause;
+        }
+    });
+}

package/dist/jobs/extract-video-clip.js

@@ -0,0 +1,8 @@
+import { splitSourceRange } from "../notebook-media-ops.js";
+import { registerJobHandler } from "../queue.js";
+export function registerExtractVideoClipJob(engine) {
+    registerJobHandler("extract_video_clip", async (payload) => {
+        const { sourceAssetId, startTime, endTime, title, } = payload;
+        return await splitSourceRange(engine, sourceAssetId, { startSeconds: startTime, endSeconds: endTime }, title);
+    });
+}

package/dist/jobs/extract-video-poster.js

@@ -0,0 +1,55 @@
+import { createHash } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, join } from "node:path";
+import { probeVideo } from "../ffmpeg.js";
+import { registerJobHandler } from "../queue.js";
+import { extractVideoPoster } from "../video-poster.js";
+export function registerExtractVideoPosterJob(engine) {
+    registerJobHandler("extract_video_poster", async (payload, { signal }) => {
+        const { posterArtifactId, sourceFilename, sourceHash } = payload;
+        const needsPoster = async () => {
+            const manifest = await engine.files.manifest(posterArtifactId);
+            if (!manifest.ok)
+                throw new Error(manifest.error.message);
+            return !manifest.value.files.some((file) => file.name === "original.jpg")
+                && manifest.value.files.some((file) => file.name === sourceFilename && file.objectHash === sourceHash);
+        };
+        if (!await needsPoster())
+            return { skipped: true };
+        const source = await engine.files.read(posterArtifactId, sourceFilename);
+        if (!source.ok)
+            throw new Error(source.error.message);
+        if (createHash("sha256").update(source.value).digest("hex") !== sourceHash) {
+            return { skipped: true };
+        }
+        const scratch = await mkdtemp(join(tmpdir(), "videobook-poster-source-"));
+        try {
+            const sourcePath = join(scratch, `source${extname(sourceFilename)}`);
+            await writeFile(sourcePath, source.value);
+            const probe = await probeVideo(sourcePath, { signal });
+            const poster = await extractVideoPoster(sourcePath, probe.videoDuration || probe.duration, signal);
+            signal?.throwIfAborted();
+            if (!await needsPoster())
+                return { skipped: true };
+            const written = await engine.files.write(posterArtifactId, "original.jpg", poster);
+            if (!written.ok)
+                throw new Error(written.error.message);
+            return { success: true };
+        }
+        catch (error) {
+            if (!signal?.aborted && await needsPoster()) {
+                const recorded = await engine.metadata.artifacts.write(posterArtifactId, "poster-recovery", {
+                    sourceHash,
+                    failed: true,
+                });
+                if (!recorded.ok)
+                    throw new Error(recorded.error.message);
+            }
+            throw error;
+        }
+        finally {
+            await rm(scratch, { recursive: true, force: true });
+        }
+    });
+}

package/dist/jobs/extract-waveform.js

@@ -0,0 +1,25 @@
+import { join } from "node:path";
+import { registerJobHandler } from "../queue.js";
+import { extractWaveform } from "../ffmpeg.js";
+export function registerExtractWaveformJob(engine) {
+    registerJobHandler("extract_waveform", async (payload) => {
+        const { bookId: _bookId, waveformAssetId, videoFilename } = payload;
+        // Idempotent: a concurrent poll may have already cached this waveform.
+        const existing = await engine.metadata.waveforms.read(waveformAssetId);
+        if (existing.ok)
+            return { cached: true };
+        const dir = await engine.workspaces.resolveArtifact(waveformAssetId);
+        if (!dir.ok) {
+            throw new Error(`extract_waveform: resolveAssetDir failed for ${waveformAssetId}: ${dir.error.message}`);
+        }
+        const peaks = await extractWaveform(join(dir.value, videoFilename));
+        // Persist even when empty. A silent track — or one ffmpeg can't decode —
+        // caches as "no waveform" so we don't re-decode the same file on every
+        // sync. extractWaveform already logs the underlying ffmpeg failure.
+        const write = await engine.metadata.waveforms.write(waveformAssetId, peaks);
+        if (!write.ok) {
+            throw new Error(`extract_waveform: writeAudioWaveform failed for ${waveformAssetId}: ${write.error.message}`);
+        }
+        return { peaks: peaks.length };
+    });
+}

package/dist/jobs/finish-goal.js

@@ -0,0 +1,255 @@
+import { join } from "node:path";
+import { v7 as uuidv7 } from "uuid";
+import { findPrimaryMediaFile } from "videobook-engine";
+import { coldOpenDestination, coldOpenSource } from "../cold-open.js";
+import { coldOpenRangeError } from "../cold-open-model.js";
+import { probeVideo } from "../ffmpeg.js";
+import { readGoal, saveGoal } from "../goal-store.js";
+import { goalAssemblyStale } from "../goal-state.js";
+import { finishingIdentityKey, watermarkProfileFor } from "../lightning-defaults.js";
+import { mutateNotebook } from "../notebook-mutations.js";
+import { registerMediaProbe } from "../notebook-media-ops.js";
+import { queue, registerJobHandler } from "../queue.js";
+import { applyWatermarkDef } from "../tools/apply-watermark.js";
+import { coldOpenDefs } from "../tools/cold-open.js";
+import { effectiveWatermarkProfile, readWatermarkConfig } from "../watermark-config.js";
+const FINISH_MESSAGE = "Only a reviewed scene and video goal can finish with a cold open.";
+const ASSEMBLY_MESSAGE = "The goal's timeline clips were edited. Keep those edits and place the revised videos manually.";
+function textOf(result) {
+    return result.content?.find(entry => entry.type === "text")?.text ?? "";
+}
+function currentFinish(engine, goalId, identity) {
+    const goal = readGoal(engine, goalId);
+    if (goal.finish?.identity !== identity || goal.finish.status === "cancelled")
+        return null;
+    return goal;
+}
+function finishSourceId(engine, goal) {
+    if (goal.assembly && goalAssemblyStale(engine, goal))
+        throw new Error(ASSEMBLY_MESSAGE);
+    if (goal.combined?.status === "completed" && goal.combined.artifactId && !goalAssemblyStale(engine, goal))
+        return goal.combined.artifactId;
+    const selected = goal.stages.videos?.outputs[0]?.artifactId ?? goal.finish?.sourceArtifactId;
+    if (!selected)
+        throw new Error("Approve a video before finishing it");
+    return selected;
+}
+async function waitForQueuedJob(engine, id, signal) {
+    const deadline = Date.now() + 180_000;
+    while (Date.now() < deadline) {
+        signal.throwIfAborted();
+        const job = engine.jobs.queue.get(id);
+        if (!job)
+            throw new Error("The finishing job disappeared");
+        if (job.state === "done")
+            return;
+        if (job.state === "failed" || job.state === "aborted")
+            throw new Error(job.error?.message ?? `Finishing ${job.state}`);
+        await new Promise(resolve => setTimeout(resolve, 50));
+    }
+    throw new Error("Finishing timed out");
+}
+async function renderColdOpen(engine, goal, signal) {
+    const finish = goal.finish;
+    if (!finish?.coldOpenRequestId || finish.startSeconds == null || finish.endSeconds == null || !finish.sourceObjectHash) {
+        throw new Error("The cold open is missing its reviewed range");
+    }
+    const existing = finish.coldOpenArtifactId;
+    if (existing && engine.artifacts.get(existing).ok) {
+        const manifest = await engine.files.manifest(existing);
+        if (manifest.ok && manifest.value.files.some(file => file.name === "original.mp4"))
+            return existing;
+    }
+    const edit = coldOpenDefs(engine).find(def => def.name === "edit_cold_open");
+    if (!edit)
+        throw new Error("Cold open editing is unavailable");
+    const result = await edit.handler({
+        book_id: goal.bookId,
+        notebook_id: goal.notebookId,
+        asset_id: finish.sourceArtifactId,
+        source_object_hash: finish.sourceObjectHash,
+        start_time: finish.startSeconds,
+        end_time: finish.endSeconds,
+        request_id: finish.coldOpenRequestId,
+    });
+    const text = textOf(result);
+    if (result.isError)
+        throw new Error(text || "Cold open failed");
+    const parsed = JSON.parse(text);
+    if (typeof parsed.job_id === "number" && parsed.status !== "completed")
+        await waitForQueuedJob(engine, parsed.job_id, signal);
+    if (!parsed.output_asset_id)
+        throw new Error("Cold open did not return a video");
+    const saved = currentFinish(engine, goal.goalId, finish.identity ?? "");
+    if (saved?.finish) {
+        saveGoal(engine, { ...saved, finish: { ...saved.finish, coldOpenArtifactId: parsed.output_asset_id } });
+    }
+    return parsed.output_asset_id;
+}
+async function duplicatePlayableVideo(engine, sourceArtifactId, label) {
+    const source = await coldOpenSource(engine, sourceArtifactId);
+    const created = await engine.artifacts.create({ kind: "video", label });
+    if (!created.ok)
+        throw new Error(created.error.message);
+    const artifactId = created.value.artifactId;
+    const copied = await engine.files.copy(sourceArtifactId, source.file.name, artifactId, "original.mp4");
+    if (!copied.ok)
+        throw new Error(copied.error.message);
+    const manifest = await engine.files.manifest(artifactId);
+    if (!manifest.ok)
+        throw new Error(manifest.error.message);
+    const probe = await probeVideo(join(manifest.value.path, "original.mp4"));
+    await registerMediaProbe(engine, artifactId, "original.mp4", probe);
+    return artifactId;
+}
+async function burnSavedWatermark(engine, artifactId) {
+    const apply = applyWatermarkDef(engine);
+    const result = await apply.handler({
+        book_id: engine.book.get().bookId,
+        asset_id: artifactId,
+        platform: "tiktok",
+        mode: "burn",
+        wait: true,
+    });
+    const text = textOf(result);
+    if (result.isError)
+        throw new Error(text || "Watermark failed");
+}
+async function placeFinishedCell(engine, goal, artifactId, sourceArtifactId) {
+    const placed = await mutateNotebook(engine, goal.notebookId, "goal_finish", notebook => {
+        if (notebook.cells.some(cell => cell.outputArtifactId === artifactId))
+            return notebook;
+        const cell = engine.notebooks.createCell({
+            type: "video",
+            label: "Finished",
+            slot: coldOpenDestination(notebook, sourceArtifactId),
+            outputArtifactId: artifactId,
+            inputs: { sourceOperation: "goal_finish", sourceArtifactId, state: "completed" },
+        });
+        return { ...notebook, cells: [...notebook.cells, cell] };
+    }, { goalId: goal.goalId, artifactId });
+    if (!placed.ok)
+        throw new Error(placed.error.message);
+}
+async function runFinish(engine, payload, signal) {
+    const goal = currentFinish(engine, payload.goalId, payload.identity);
+    if (!goal?.finish)
+        return { finalArtifactId: "", coldOpenArtifactId: "" };
+    const coldOpenArtifactId = await renderColdOpen(engine, goal, signal);
+    const running = currentFinish(engine, payload.goalId, payload.identity);
+    if (!running?.finish)
+        return { finalArtifactId: "", coldOpenArtifactId };
+    const finalArtifactId = await duplicatePlayableVideo(engine, coldOpenArtifactId, "Finished");
+    await burnSavedWatermark(engine, finalArtifactId);
+    const manifest = await engine.files.manifest(finalArtifactId);
+    if (!manifest.ok)
+        throw new Error(manifest.error.message);
+    const file = findPrimaryMediaFile(manifest.value.files, "video");
+    if (!file)
+        throw new Error("The finished video is missing");
+    const probe = await probeVideo(join(manifest.value.path, file.name));
+    if (!probe.videoStream || probe.videoDuration < 0.5)
+        throw new Error("The finished video is not playable");
+    await placeFinishedCell(engine, running, finalArtifactId, running.finish.sourceArtifactId);
+    const latest = currentFinish(engine, payload.goalId, payload.identity);
+    if (!latest?.finish)
+        return { finalArtifactId, coldOpenArtifactId };
+    saveGoal(engine, {
+        ...latest,
+        status: "completed",
+        error: null,
+        finish: { ...latest.finish, status: "completed", coldOpenArtifactId, finalArtifactId, error: null },
+    });
+    return { finalArtifactId, coldOpenArtifactId };
+}
+export function registerFinishGoalJob(engine) {
+    registerJobHandler("finish_goal", async (input, context) => {
+        const goalId = typeof input.goalId === "string" ? input.goalId : "";
+        const identity = typeof input.identity === "string" ? input.identity : "";
+        try {
+            return await runFinish(engine, { goalId, identity }, context.signal);
+        }
+        catch (error) {
+            const goal = readGoal(engine, goalId);
+            if (goal.finish?.identity === identity && goal.finish.status === "running") {
+                saveGoal(engine, {
+                    ...goal,
+                    status: "review",
+                    finish: { ...goal.finish, status: "failed", error: error instanceof Error ? error.message : String(error) },
+                });
+            }
+            throw error;
+        }
+    });
+}
+export async function queueGoalFinish(engine, goal, args) {
+    if (goal.planVersion !== 3)
+        throw new Error(FINISH_MESSAGE);
+    if (goal.status === "running")
+        throw new Error("Wait until the video is ready before finishing it");
+    if (!["review", "completed", "failed", "interrupted"].includes(goal.status))
+        throw new Error("Review the finished video before approving its cold open");
+    const source = await coldOpenSource(engine, finishSourceId(engine, goal));
+    const start = args.start_seconds;
+    const end = args.end_seconds;
+    if (start === undefined && end === undefined) {
+        if (goal.finish?.status === "completed" || goal.finish?.status === "running")
+            return goal;
+        const suggestion = {
+            status: "review",
+            sourceArtifactId: source.artifact.artifactId,
+            sourceObjectHash: source.file.objectHash,
+            finalArtifactId: null,
+            error: null,
+        };
+        return saveGoal(engine, { ...goal, status: "review", finish: suggestion });
+    }
+    if (typeof start !== "number" || typeof end !== "number")
+        throw new Error("Approve both the cold-open start and end");
+    const rangeError = coldOpenRangeError(start, end, source.durationSeconds);
+    if (rangeError)
+        throw new Error(rangeError);
+    const config = await readWatermarkConfig(engine, "tiktok");
+    const profile = effectiveWatermarkProfile(config, "tiktok");
+    const identity = finishingIdentityKey({
+        sourceObjectHash: source.file.objectHash,
+        startSeconds: start,
+        endSeconds: end,
+        profile: watermarkProfileFor(profile.platform, profile),
+        qrStartSeconds: config.profile?.qrStartSeconds,
+        qrEndSeconds: config.profile?.qrEndSeconds,
+    });
+    const same = goal.finish?.identity === identity;
+    if (same && goal.finish?.status === "completed" && goal.finish.finalArtifactId && engine.artifacts.get(goal.finish.finalArtifactId).ok) {
+        return saveGoal(engine, { ...goal, status: "completed", error: null });
+    }
+    if (same && goal.finish?.status === "running" && goal.finish.jobId) {
+        const active = engine.jobs.queue.get(goal.finish.jobId);
+        if (active && ["queued", "running", "completing"].includes(active.state))
+            return goal;
+    }
+    const finish = {
+        status: "running",
+        sourceArtifactId: source.artifact.artifactId,
+        sourceObjectHash: source.file.objectHash,
+        startSeconds: start,
+        endSeconds: end,
+        identity,
+        coldOpenArtifactId: same ? goal.finish?.coldOpenArtifactId ?? null : null,
+        coldOpenRequestId: same && goal.finish?.coldOpenRequestId ? goal.finish.coldOpenRequestId : uuidv7(),
+        finalArtifactId: null,
+        jobId: null,
+        error: null,
+    };
+    saveGoal(engine, { ...goal, status: "review", error: null, finish });
+    const job = await queue.enqueue(`goal-finish-${goal.goalId}-${uuidv7()}`, {
+        type: "finish_goal",
+        bookId: goal.bookId,
+        goalId: goal.goalId,
+        identity,
+    });
+    const queued = readGoal(engine, goal.goalId);
+    if (!queued.finish || queued.finish.identity !== identity || queued.finish.status !== "running")
+        return queued;
+    return saveGoal(engine, { ...queued, finish: { ...queued.finish, jobId: job.id } });
+}

package/dist/jobs/forget-asset.js

@@ -0,0 +1,11 @@
+import { forgetAsset } from "../forget-asset.js";
+import { registerJobHandler } from "../queue.js";
+export function registerForgetAssetJob(engine) {
+    registerJobHandler("forget_asset", async (payload) => {
+        const input = payload;
+        return await forgetAsset(engine, {
+            assetId: input.forgetArtifactId,
+            clearReferences: input.clearReferences === true,
+        });
+    });
+}