@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/slices/rebuild/preview-plan.js

@@ -0,0 +1,223 @@
+import { z } from "zod";
+import { catalogueSchema } from "../../catalog/schema.js";
+import { stageKinds } from "../../kernel/pipeline.js";
+import { estimateRequests } from "../estimate/index.js";
+import { requestHash } from "../revisions/mutation-request.js";
+import { previewDetails } from "./preview-details.js";
+import { hasSubmittedRequest, requiresNewSubmission, retainedPreviewPlan, } from "./preview-retained.js";
+import { providedDependencyFingerprint } from "./provided-review.js";
+import { recipeInputSchema } from "./recipe-input-schema.js";
+import { recipeProviderChoice } from "./recipe-provider-choice.js";
+import { priceRecipe } from "./recipe-work.js";
+import { narrationOrdinal } from "./runtime-narration-reuse.js";
+import { executionCatalogue } from "./runtime-plan.js";
+export const executionSnapshotSchema = z.object({
+    version: z.literal(1),
+    submissions: z
+        .array(z.object({ key: z.string(), submit: z.boolean(), uncertain: z.boolean() }))
+        .default([]),
+    catalogue: catalogueSchema,
+    recipes: z.array(z.object({
+        key: z.string(),
+        stage: z.enum(stageKinds),
+        kind: z.enum(["provider", "local", "provided"]),
+        requestFingerprint: z.string(),
+        fingerprint: z.string(),
+        logicalFingerprint: z.string(),
+        dependsOn: z.array(z.string()),
+        unresolved: z.boolean(),
+        deferred: z.boolean(),
+        input: recipeInputSchema,
+    })),
+    dispositions: z.array(z.object({ key: z.string(), disposition: z.string() })),
+    assets: z.array(z.object({ id: z.string(), path: z.string(), available: z.boolean() })),
+    reviews: z.array(z.object({ key: z.string(), fingerprint: z.string() })),
+    anchors: z.record(z.string(), z.string()),
+    ordinals: z.record(z.string(), z.number().int()),
+});
+export function planPreview(deps, view, catalogue, selection, id) {
+    const plan = retainedPreviewPlan(deps, view, catalogue);
+    const requested = selection.kind === "allAffected"
+        ? plan.work.filter((row) => row.disposition !== "reuse").map((row) => row.key)
+        : selection.workKeys;
+    if (new Set(requested).size !== requested.length)
+        return invalid("Choose each work item only once.");
+    const selected = new Set();
+    const visiting = new Set();
+    const visit = (key) => {
+        if (selected.has(key))
+            return true;
+        if (visiting.has(key))
+            return false;
+        const work = plan.work.find((row) => row.key === key);
+        const recipe = plan.recipes.find((row) => row.key === key);
+        if (work === undefined || recipe === undefined)
+            return false;
+        if (recipe.input.kind === "provided" && recipe.unresolved)
+            return false;
+        if (recipe.unresolved && recipe.dependsOn.length === 0 && !recipe.deferred)
+            return false;
+        visiting.add(key);
+        if (work.disposition !== "reuse")
+            for (const dependency of recipe.dependsOn)
+                if (!visit(dependency))
+                    return false;
+        visiting.delete(key);
+        selected.add(key);
+        return true;
+    };
+    for (const key of requested)
+        if (!visit(key))
+            return invalid(`Work ${key} is disabled, unknown, or has an unavailable prerequisite.`);
+    const recipes = plan.recipes.filter((row) => selected.has(row.key));
+    const reservations = deps.db
+        .prepare(`SELECT r.work_key,r.fingerprint,w.state,w.recipe_context,r.piece_id FROM revision_work_reservations r JOIN revision_work w ON w.id=r.work_id WHERE r.revision_id=?`)
+        .all(view.revision.id);
+    const work = plan.work
+        .filter((row) => selected.has(row.key))
+        .map((row) => {
+        const old = reservations.find((one) => one.work_key === row.key &&
+            one.fingerprint === row.fingerprint &&
+            one.state !== "done" &&
+            typeof one.recipe_context === "string");
+        return old === undefined
+            ? row
+            : {
+                ...row,
+                inflight: old.state === "running",
+                pieceIds: typeof old.piece_id === "string" ? [old.piece_id] : [],
+            };
+    });
+    const relevantAssets = new Map();
+    for (const row of view.outputs)
+        if (row.selected && selected.has(row.workKey))
+            relevantAssets.set(row.assetId, {
+                id: row.assetId,
+                path: row.output.path,
+                available: row.available,
+            });
+    for (const row of view.pieces)
+        if (row.selected && selected.has(row.key) && row.assetId !== null) {
+            const asset = deps.db
+                .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
+                .get(row.assetId, view.revision.projectId);
+            relevantAssets.set(row.assetId, {
+                id: row.assetId,
+                path: String(asset?.path ?? ""),
+                available: row.available,
+            });
+        }
+    for (const recipe of recipes)
+        if (recipe.input.kind === "provided" && recipe.input.assetId !== null) {
+            const asset = deps.db
+                .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
+                .get(recipe.input.assetId, view.revision.projectId);
+            relevantAssets.set(recipe.input.assetId, {
+                id: recipe.input.assetId,
+                path: String(asset?.path ?? ""),
+                available: !recipe.unresolved,
+            });
+        }
+    const snapshot = selectedCatalogue(executionCatalogue(catalogue, view.revision.config), recipes, view);
+    const submissions = work
+        .filter((row) => row.kind === "provider")
+        .map((row) => {
+        const submit = row.disposition !== "reuse" &&
+            !row.inflight &&
+            requiresNewSubmission(deps, view.revision.id, row.key, row.fingerprint);
+        return {
+            key: row.key,
+            submit,
+            uncertain: submit && hasSubmittedRequest(deps, view.revision.id, row.key, row.fingerprint),
+        };
+    });
+    const execution = {
+        version: 1,
+        submissions,
+        catalogue: snapshot,
+        recipes: recipes.map((row) => ({ ...row, dependsOn: [...row.dependsOn] })),
+        dispositions: work.map((row) => ({ key: row.key, disposition: row.disposition })),
+        assets: [...relevantAssets.values()].sort((a, b) => a.id.localeCompare(b.id)),
+        reviews: plan.providedReuseRequired
+            .filter((key) => selected.has(key))
+            .map((key) => ({ key, fingerprint: providedDependencyFingerprint(plan, key) })),
+        ordinals: Object.fromEntries(recipes.map((row) => [row.key, narrationOrdinal(plan.recipes, row.key)])),
+        anchors: Object.fromEntries(recipes.map((recipe) => {
+            const key = recipe.input.kind === "tts" ? `${recipe.input.logicalKey}:1` : recipe.key;
+            return [key, view.revision.fingerprints[key] ?? recipe.logicalFingerprint];
+        })),
+    };
+    const preview = {
+        id,
+        projectId: view.revision.projectId,
+        baseRevisionId: view.revision.id,
+        selection,
+        planFingerprint: executionFingerprint(view.revision.id, execution),
+        work,
+        review: previewDetails(deps, view, plan.recipes, selected),
+        changedInputs: plan.changedInputs.filter((row) => selected.has(row.path)),
+        retained: view.outputs
+            .filter((row) => row.selected)
+            .map((row) => ({
+            slot: row.slot,
+            outputId: row.output.id,
+            assetId: row.assetId,
+            state: row.state,
+        })),
+        providedReuseRequired: execution.reviews.map((row) => row.key),
+        costs: estimateRequests(work.map((row) => priceRecipe(row.inflight || !requiresNewSubmission(deps, view.revision.id, row.key, row.fingerprint)
+            ? { ...row, disposition: "reuse" }
+            : row, recipes.find((recipe) => recipe.key === row.key))), snapshot),
+        wholeRequestNotice: plan.wholeRequestNotice,
+        warnings: submissions.some((row) => row.uncertain)
+            ? [
+                "A previous request was submitted without a saved result or resumable job. Retrying may charge you again.",
+            ]
+            : [],
+    };
+    return { ok: true, value: { preview, execution } };
+}
+function invalid(message) {
+    return {
+        ok: false,
+        reason: "invalid-selection",
+        fields: [{ field: "request.workKeys", message }],
+    };
+}
+function selectedCatalogue(catalogue, recipes, view) {
+    const uses = new Set(recipes.flatMap((row) => {
+        const choice = recipeProviderChoice(row, view.revision.config);
+        return choice === undefined ? [] : [`${choice.family}:${choice.provider}:${choice.model}`];
+    }));
+    const selected = {
+        llm: catalogue.llm.filter((row) => uses.has(`llm:${row.provider}:${row.id}`)),
+        tts: catalogue.tts.filter((row) => uses.has(`tts:${row.provider}:${row.id}`)),
+        image: catalogue.image.filter((row) => uses.has(`image:${row.provider}:${row.id}`)),
+    };
+    const providers = new Set([...selected.llm, ...selected.tts, ...selected.image].map((row) => row.provider));
+    return {
+        ...catalogue,
+        ...selected,
+        providers: Object.fromEntries(Object.entries(catalogue.providers).filter(([id]) => providers.has(id))),
+    };
+}
+function executionFingerprint(revisionId, execution) {
+    return requestHash("rebuild-plan-v1", revisionId, {
+        ...execution,
+        catalogue: { ...execution.catalogue, updatedAt: "1970-01-01" },
+    });
+}
+export function reviewStillCovers(reviewed, snapshot, fresh) {
+    if (reviewed.planFingerprint === fresh.preview.planFingerprint)
+        return true;
+    const escalated = fresh.execution.submissions.some((current) => {
+        const old = snapshot.submissions.find((row) => row.key === current.key);
+        return current.submit && (old?.submit !== true || (current.uncertain && !old.uncertain));
+    });
+    // A paid request may become a free join while readiness loads, never the reverse.
+    return (!escalated &&
+        executionFingerprint(reviewed.baseRevisionId, {
+            ...fresh.execution,
+            submissions: snapshot.submissions,
+        }) === reviewed.planFingerprint);
+}

package/dist/slices/rebuild/preview-retained.js

@@ -0,0 +1,128 @@
+import { continuationLimit } from "../article/continuation.js";
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { workPieces } from "./work-records.js";
+export function retainedPreviewPlan(deps, view, catalogue) {
+    const current = executionPlan(deps, view, catalogue);
+    const replacements = new Map();
+    const groups = new Set();
+    const reservations = deps.db
+        .prepare(`SELECT r.*,w.revision_id AS origin_revision,w.recipe_context,w.state FROM revision_work_reservations r JOIN revision_work w ON w.id=r.work_id WHERE r.revision_id=? AND w.recipe_context IS NOT NULL AND w.state!='done'`)
+        .all(view.revision.id);
+    const origins = new Map();
+    for (const row of reservations) {
+        const anchor = String(row.logical_key ?? row.work_key);
+        if (view.revision.fingerprints[anchor] !== row.desired_fingerprint)
+            continue;
+        const piece = workPieces(deps.db, String(row.work_id)).find((one) => one.id === row.piece_id);
+        if (piece === undefined)
+            continue;
+        const originKey = `${row.origin_revision}:${row.recipe_context}`;
+        let original = origins.get(originKey);
+        if (original === undefined) {
+            const origin = executionView(deps, view.revision.projectId, String(row.origin_revision));
+            if (origin === undefined)
+                continue;
+            original = executionPlan(deps, origin, savedCatalogue(row.recipe_context));
+            origins.set(originKey, original);
+        }
+        const recipe = original.recipes.find((one) => one.key === piece.key);
+        if (recipe === undefined)
+            continue;
+        replacements.set(piece.key, {
+            ...recipe,
+            input: piece.input,
+            fingerprint: piece.fingerprint,
+            requestFingerprint: piece.requestFingerprint,
+            logicalFingerprint: piece.logicalFingerprint ?? recipe.logicalFingerprint,
+        });
+        if (piece.input.kind === "tts") {
+            const logicalKey = piece.input.logicalKey;
+            groups.add(logicalKey);
+            for (const sibling of original.recipes)
+                if (sibling.input.kind === "tts" &&
+                    sibling.input.logicalKey === logicalKey &&
+                    !replacements.has(sibling.key))
+                    replacements.set(sibling.key, sibling);
+        }
+    }
+    const recipes = current.recipes.flatMap((row) => {
+        const replacement = replacements.get(row.key);
+        if (replacement !== undefined)
+            return [replacement];
+        if (row.input.kind === "tts" && groups.has(row.input.logicalKey))
+            return [];
+        return [row];
+    });
+    for (const row of replacements.values())
+        if (!recipes.some((one) => one.key === row.key))
+            recipes.push(row);
+    const work = recipes.flatMap((recipe) => {
+        const row = current.work.find((one) => one.key === recipe.key);
+        if (row !== undefined)
+            return [
+                {
+                    ...row,
+                    requestFingerprint: recipe.requestFingerprint,
+                    fingerprint: recipe.fingerprint,
+                    dependsOn: recipe.dependsOn,
+                    kind: recipe.kind,
+                    stage: recipe.stage,
+                },
+            ];
+        if (!replacements.has(recipe.key))
+            return [];
+        return [
+            {
+                key: recipe.key,
+                stage: recipe.stage,
+                kind: recipe.kind,
+                requestFingerprint: recipe.requestFingerprint,
+                fingerprint: recipe.fingerprint,
+                dependsOn: recipe.dependsOn,
+                disposition: recipe.kind === "local" ? "local" : "generate",
+                reason: "Continue the exact admitted request.",
+                inflight: false,
+                pieceIds: [],
+            },
+        ];
+    });
+    return { ...current, recipes, work };
+}
+export function requiresNewSubmission(deps, revisionId, key, fingerprint) {
+    const row = deps.db
+        .prepare(`SELECT w.id,w.state,w.dispatch_state,p.continuation FROM revision_work_reservations r JOIN revision_work w ON w.id=r.work_id JOIN revision_work_pieces p ON p.id=r.piece_id WHERE r.revision_id=? AND r.work_key=? AND r.fingerprint=? AND w.recipe_context IS NOT NULL`)
+        .get(revisionId, key, fingerprint);
+    return (row === undefined ||
+        (row.state !== "running" &&
+            !(row.state === "pending" && row.dispatch_state === "allowed") &&
+            row.continuation === null &&
+            !(key === "article:body" && cachedArticleComplete(deps, revisionId, String(row.id)))));
+}
+function cachedArticleComplete(deps, revisionId, workId) {
+    const answers = deps.db
+        .prepare(`SELECT p.work_key,json_extract(p.result_json,'$.finishReason') AS finish_reason
+       FROM revision_work_pieces p
+       JOIN revision_work_reservations r ON r.piece_id=p.id AND r.work_id=p.work_id
+         AND r.work_key=p.work_key AND r.fingerprint=p.fingerprint
+       JOIN project_revisions v ON v.id=r.revision_id
+       JOIN json_each(v.fingerprints) f ON f.key=COALESCE(r.logical_key,r.work_key)
+         AND f.value=COALESCE(r.desired_fingerprint,r.fingerprint)
+       WHERE r.revision_id=? AND p.work_id=? AND p.result_json IS NOT NULL
+         AND json_extract(p.input_json,'$.kind')='llm'
+         AND COALESCE(r.logical_key,r.work_key)='article:body'`)
+        .all(revisionId, workId);
+    for (let part = 0; part <= continuationLimit; part += 1) {
+        const key = part === 0 ? "article:body" : `article:continuation:${part}`;
+        const answer = answers.find((row) => row.work_key === key);
+        if (answer === undefined)
+            return false;
+        if (answer.finish_reason !== "length")
+            return true;
+    }
+    return false;
+}
+export function hasSubmittedRequest(deps, revisionId, key, fingerprint) {
+    return (deps.db
+        .prepare(`SELECT 1 FROM revision_work_reservations r JOIN revision_work_pieces p ON p.id=r.piece_id WHERE r.revision_id=? AND r.work_key=? AND r.fingerprint=? AND p.submitted_at IS NOT NULL AND p.continuation IS NULL AND p.state!='done'`)
+        .get(revisionId, key, fingerprint) !== undefined);
+}

package/dist/slices/rebuild/provided-review.js

@@ -0,0 +1,32 @@
+import { requestHash } from "../revisions/mutation-request.js";
+export function providedDependencyFingerprint(plan, key) {
+    const recipe = plan.recipes.find((one) => one.key === key);
+    const timing = plan.recipes.find((one) => one.key === "subtitles:timing");
+    return requestHash("provided-review-v1", key, {
+        recipe,
+        dependencies: recipe?.dependsOn.map((dependency) => plan.recipes.find((one) => one.key === dependency)),
+        timing: key === "subtitles:cues"
+            ? timing?.input.kind === "local" && Array.isArray(timing.input.values)
+                ? timing.input.values.slice(1)
+                : null
+            : null,
+    });
+}
+export function applyProvidedReviews(db, revisionId, plan) {
+    const approved = new Set(db
+        .prepare("SELECT work_key,dependency_fingerprint FROM revision_provided_reviews WHERE revision_id=?")
+        .all(revisionId)
+        .filter((row) => row.dependency_fingerprint === providedDependencyFingerprint(plan, String(row.work_key)))
+        .map((row) => String(row.work_key)));
+    return {
+        ...plan,
+        work: plan.work.map((row) => approved.has(row.key) && row.disposition === "review"
+            ? {
+                ...row,
+                disposition: row.kind === "provided" ? "reuse" : "local",
+                reason: "Provided content was reviewed against these exact inputs.",
+            }
+            : row),
+        providedReuseRequired: plan.providedReuseRequired.filter((key) => !approved.has(key)),
+    };
+}

package/dist/slices/rebuild/recipe-audio.js

@@ -0,0 +1,172 @@
+import { fingerprint } from "../../kernel/runner/work.js";
+import { chunkNarration, defaultChunking } from "../narration/chunk.js";
+import { concatArgs } from "../narration/concat.js";
+import { narrationRegenerationToken, normalizeNarrationText, planNarration, } from "../narration/plan.js";
+import { recipe, resourceIdentity, selectedReference, } from "./recipe-model.js";
+export function audioRecipes(context, text) {
+    const { config, content } = context;
+    const recipes = [];
+    if (config.sources.audio === "off")
+        return { recipes, mediaFingerprint: null, timeline: [], keys: [] };
+    let body;
+    if (config.sources.audio === "provide") {
+        body = recipe(context, "audio:provided", "audio", {
+            kind: "provided",
+            version: 1,
+            assetId: content.provided.audio ?? null,
+            semantic: text.articleText ?? text.article.fingerprint,
+        }, [text.article.key], { unresolved: content.provided.audio === undefined });
+        recipes.push(body);
+    }
+    else {
+        const groups = text.articleText === null
+            ? []
+            : chunkNarration(normalizeNarrationText(text.articleText), config.chunking ?? defaultChunking);
+        const occurrences = new Map();
+        const parts = [];
+        for (const logicalText of groups) {
+            const hash = fingerprint(logicalText).slice(0, 20);
+            const occurrence = (occurrences.get(hash) ?? 0) + 1;
+            occurrences.set(hash, occurrence);
+            const logicalKey = `audio:body:${hash}-${occurrence}`;
+            parts.push(...narrationParts(context, logicalKey, logicalText, "body", [text.article.key]));
+        }
+        if (text.articleText === null)
+            parts.push(recipe(context, "audio:body:future", "audio", {
+                kind: "deferred",
+                version: 1,
+                operation: "body-narration",
+                template: [text.article.fingerprint, voiceValues(context), chunkingValues(context)],
+            }, [text.article.key]));
+        recipes.push(...parts);
+        body = recipe(context, "audio:body:concat", "audio", {
+            kind: "local",
+            version: 1,
+            operation: "concat-narration",
+            values: [
+                parts.map((part) => resourceIdentity(context, part)),
+                parts.length === 1 ? "copy-single-file" : concatArgs("$parts", "$output"),
+            ],
+        }, parts.map((part) => part.key), { unresolved: text.articleText !== null && groups.length === 0 });
+        recipes.push(body);
+    }
+    const ordered = [];
+    for (const category of ["intro", "body", "outro"]) {
+        if (category === "body") {
+            ordered.push({ value: body, transcript: text.articleText ?? text.article.fingerprint });
+            continue;
+        }
+        const entry = text.entries[category];
+        if (entry === undefined)
+            continue;
+        const parts = entry.text === null
+            ? [
+                recipe(context, `audio:${category}:future`, "audio", {
+                    kind: "deferred",
+                    version: 1,
+                    operation: `${category}-narration`,
+                    template: [entry.recipe.fingerprint, voiceValues(context)],
+                }, [entry.recipe.key]),
+            ]
+            : narrationParts(context, `audio:${category}`, entry.text, category, [entry.recipe.key]);
+        recipes.push(...parts);
+        const audio = recipe(context, `audio:${category}`, "audio", {
+            kind: "local",
+            version: 1,
+            operation: "concat-narration",
+            values: [
+                parts.map((part) => resourceIdentity(context, part)),
+                parts.length === 1 ? "copy-single-file" : concatArgs("$parts", "$output"),
+            ],
+        }, parts.map((part) => part.key));
+        recipes.push(audio);
+        ordered.push({ value: audio, transcript: entry.text ?? entry.recipe.fingerprint });
+    }
+    const timeline = ordered.map(({ value, transcript }) => {
+        const retained = context.manifest.outputs.find((row) => row.workKey === value.key && row.state === "ready" && selectedReference(row));
+        return {
+            audio: resourceIdentity(context, value),
+            transcript,
+            durationMs: retained?.output.durationMs ?? null,
+        };
+    });
+    return {
+        recipes,
+        mediaFingerprint: fingerprint([
+            "audio-media-v1",
+            ordered.map(({ value }) => resourceIdentity(context, value)),
+            config.silenceGapSeconds,
+        ]),
+        timeline,
+        keys: ordered.map(({ value }) => value.key),
+    };
+}
+function narrationParts(context, logicalKey, originalText, segment, dependsOn) {
+    const override = context.content.narrationOverrides[logicalKey];
+    if (override?.kind === "asset")
+        return [
+            recipe(context, `${logicalKey}:1`, "audio", {
+                kind: "provided",
+                version: 1,
+                assetId: override.assetId,
+                semantic: [normalizeNarrationText(originalText), voiceValues(context)],
+            }, dependsOn, { tokenKey: logicalKey }),
+        ];
+    const logicalText = normalizeNarrationText(override?.kind === "text" ? override.text : originalText);
+    const wholeRequest = segment !== "body" || (context.config.chunking?.mode ?? "whole") === "whole";
+    const choice = context.config.audio;
+    const model = context.catalogue?.tts.find((row) => row.provider === choice?.provider &&
+        row.id === choice.model &&
+        row.enabled &&
+        !row.deprecated);
+    const requests = planNarration({
+        groups: [
+            {
+                key: logicalKey,
+                text: logicalText,
+                segment,
+                wholeRequest,
+                regenerationToken: narrationRegenerationToken(context.content.regenerationTokens, logicalKey, segment),
+            },
+        ],
+        provider: choice?.provider ?? "",
+        model: choice?.model ?? "",
+        voice: choice?.voice ?? "",
+        maxCharacters: context.catalogue === undefined
+            ? Math.max(2, logicalText.length)
+            : (model?.tts.maxCharacters ?? Math.max(2, logicalText.length)),
+        retained: [],
+    });
+    return requests.map(({ text, key }) => recipe(context, key, "audio", {
+        kind: "tts",
+        version: 1,
+        provider: choice?.provider ?? "",
+        model: choice?.model ?? "",
+        voice: choice?.voice ?? "",
+        text,
+        logicalKey,
+        logicalText,
+        segment,
+        pronunciation: null,
+        wholeRequest,
+    }, dependsOn, { tokenKey: logicalKey, unresolved: logicalText.length === 0 }));
+}
+function voiceValues(context) {
+    return [
+        context.config.audio?.provider ?? null,
+        context.config.audio?.model ?? null,
+        context.config.audio?.voice ?? null,
+        null,
+    ];
+}
+function chunkingValues(context) {
+    const chunking = context.config.chunking ?? defaultChunking;
+    return [
+        chunking.mode,
+        chunking.mode === "words"
+            ? (chunking.words ?? 500)
+            : chunking.mode === "characters"
+                ? (chunking.characters ?? 3000)
+                : null,
+    ];
+}

package/dist/slices/rebuild/recipe-build.js

@@ -0,0 +1,17 @@
+import { audioRecipes } from "./recipe-audio.js";
+import { exportRecipes } from "./recipe-exports.js";
+import { textRecipes } from "./recipe-text.js";
+import { thumbnailRecipes, visualAssets, visualRecipes } from "./recipe-visual.js";
+export function buildRecipes(context) {
+    const text = textRecipes(context);
+    const audio = audioRecipes(context, text);
+    const exports = exportRecipes(context, audio);
+    const captions = exports.find((value) => value.key === "subtitles:files");
+    return [
+        ...text.recipes,
+        ...audio.recipes,
+        ...exports,
+        ...thumbnailRecipes(context, text.recipes),
+        ...visualAssets(context, visualRecipes(context.config, context.content, audio.mediaFingerprint, captions?.fingerprint ?? null)),
+    ];
+}

package/dist/slices/rebuild/recipe-checkpoints.js

@@ -0,0 +1,75 @@
+import { fingerprint } from "../../kernel/runner/work.js";
+import { checkpointClosure, checkpointFingerprint } from "../checkpoints/fingerprint.js";
+import { buildRecipes } from "./recipe-build.js";
+export function reviewCheckpointSet(runs, catalogue, attachments, fontHash) {
+    return runs.flatMap((run, runIndex) => {
+        if (!run.draft.checkpoints?.length)
+            return [];
+        const config = { ...run.draft, rendered: run.rendered };
+        const images = config.sources.images === "provide"
+            ? (config.provided.images ?? []).map((id) => [
+                id,
+                { source: "provide", assetId: id, prompt: null, templateKey: null },
+            ])
+            : config.imagePrompts.flatMap((prompt, index) => Array.from({ length: prompt.number }, (_, number) => [
+                `${index}:${number}`,
+                {
+                    source: "generate",
+                    assetId: null,
+                    prompt: run.rendered[`imagePrompts.${index}`] ?? null,
+                    templateKey: `imagePrompts.${index}`,
+                },
+            ]));
+        const content = {
+            articleMarkdown: config.sources.article === "provide" ? config.provided.article : undefined,
+            provided: { audio: config.provided.audio, thumbnail: config.provided.thumbnail },
+            imageOrder: images.map(([key]) => key),
+            imageDefinitions: Object.fromEntries(images),
+            narrationOverrides: {},
+            regenerationTokens: {},
+            promptTemplates: run.templates,
+        };
+        const recipes = buildRecipes({
+            config,
+            content,
+            catalogue,
+            manifest: { outputs: [], pieces: [] },
+            resolved: {
+                articleMarkdown: content.articleMarkdown ?? null,
+                researchNotes: config.provided.research ?? null,
+            },
+        });
+        // Project and retained asset IDs do not exist until Start; these are setup identities.
+        const revision = {
+            id: "review",
+            projectId: "review",
+            parentId: null,
+            restoredFromId: null,
+            config,
+            content,
+            fingerprints: Object.fromEntries(recipes.map((recipe) => [recipe.key, recipe.fingerprint])),
+            createdAt: "review",
+        };
+        return (config.checkpoints?.map((stage) => {
+            const closure = checkpointClosure(stage, recipes);
+            const video = closure.some((recipe) => recipe.stage === "video");
+            const audio = video || closure.some((recipe) => recipe.stage === "audio");
+            const inputs = new Set([
+                ...(audio && config.provided.audio ? [config.provided.audio] : []),
+                ...(video ? (config.provided.images ?? []) : []),
+            ]);
+            return {
+                runIndex,
+                checkpointId: stage,
+                stage,
+                fingerprint: fingerprint({
+                    recipes: checkpointFingerprint(revision, closure),
+                    attachments: attachments.filter((file) => inputs.has(file.stagedFileId)),
+                    font: video ? fontHash : null,
+                }),
+                workKeys: closure.map((recipe) => recipe.key),
+                dependents: [...new Set(closure.map((recipe) => recipe.stage))].filter((kind) => kind !== stage),
+            };
+        }) ?? []);
+    });
+}