@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/slices/rebuild/runtime-article.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { continuationLimit, continuationMessages } from "../article/continuation.js";
+import { currentRevisionId, revisionById } from "../revisions/repo.js";
+import { recipe } from "./recipe-model.js";
+import { retainPartialArticle } from "./runtime-publication.js";
+import { insertWorkPiece, workPieces } from "./work-records.js";
+const answerSchema = z.object({
+    text: z.string(),
+    finishReason: z.string().nullable(),
+    usage: z.object({ inputTokens: z.number(), outputTokens: z.number() }).nullable(),
+});
+export async function executeArticleRequests(deps, context, providers, initial) {
+    if (initial.input.kind !== "llm")
+        throw new Error("Article generation needs a pinned LLM request.");
+    let piece = initial;
+    let text = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    for (let part = 0; part <= continuationLimit; part += 1) {
+        if (piece.input.kind !== "llm")
+            throw new Error("An article continuation must contain an exact LLM request.");
+        const saved = deps.db
+            .prepare("SELECT result_json FROM revision_work_pieces WHERE id=? AND work_id=?")
+            .get(piece.id, context.work.workId);
+        let answer;
+        if (typeof saved?.result_json === "string")
+            answer = answerSchema.parse(JSON.parse(saved.result_json));
+        else {
+            const input = piece.input;
+            const result = await providers.forPiece(piece.id).llm({
+                provider: input.provider,
+                model: input.model,
+                messages: input.messages,
+                thinkingConfig: input.thinkingConfig,
+                ...(input.thinking === null ? {} : { thinking: input.thinking }),
+                webSearch: input.webSearch,
+                previewLabel: part === 0 ? "Article" : `Continuation ${part}`,
+                check: (value) => value.text.trim() === ""
+                    ? "The article answered with nothing."
+                    : part === continuationLimit && value.finishReason === "length"
+                        ? `The article was still unfinished after ${continuationLimit} continuations.`
+                        : undefined,
+            }, (event) => {
+                if (event.type === "delta")
+                    context.emit({
+                        type: "article.delta",
+                        projectId: context.work.projectId,
+                        workPieceId: piece.id,
+                        text: event.text,
+                    });
+            });
+            if (!result.ok)
+                return result;
+            answer = result.value;
+            deps.db
+                .prepare("UPDATE revision_work_pieces SET result_json=? WHERE id=? AND work_id=? AND result_json IS NULL")
+                .run(JSON.stringify(answer), piece.id, context.work.workId);
+        }
+        text += answer.text;
+        inputTokens += answer.usage?.inputTokens ?? 0;
+        outputTokens += answer.usage?.outputTokens ?? 0;
+        if (answer.finishReason !== "length")
+            return {
+                ok: true,
+                value: { text, finishReason: answer.finishReason, usage: { inputTokens, outputTokens } },
+            };
+        retainPartialArticle(deps, context, piece, text);
+        const next = continuationPiece(deps, context, initial, part + 1, text);
+        if (next === undefined)
+            return { ok: false, reason: "held" };
+        piece = next;
+    }
+    throw new Error("The article exceeded its continuation limit.");
+}
+function continuationPiece(deps, context, initial, part, text) {
+    return transact(deps.db, () => {
+        const key = `article:continuation:${part}`;
+        const existing = workPieces(deps.db, context.work.workId).find((piece) => piece.key === key);
+        if (existing !== undefined)
+            return existing;
+        if (!context.maySubmit(initial.id) || initial.input.kind !== "llm")
+            return undefined;
+        const revision = revisionById(deps.db, context.work.projectId, context.work.revisionId);
+        const head = currentRevisionId(deps.db, context.work.projectId);
+        if (revision === undefined || head === undefined)
+            return undefined;
+        const anchor = deps.db
+            .prepare("SELECT logical_key,desired_fingerprint,work_key,fingerprint FROM revision_work_reservations WHERE revision_id=? AND work_id=? AND piece_id=?")
+            .get(head, context.work.workId, initial.id);
+        if (anchor === undefined)
+            return undefined;
+        const value = recipe({ content: revision.content }, key, "article", {
+            ...initial.input,
+            messages: continuationMessages(initial.input.messages, text),
+        }, [initial.key], { tokenKey: initial.key });
+        const piece = {
+            id: deps.ids.next(),
+            workId: context.work.workId,
+            key,
+            fingerprint: value.fingerprint,
+            requestFingerprint: value.requestFingerprint,
+            logicalFingerprint: value.logicalFingerprint,
+            input: value.input,
+            continuation: null,
+            generationToken: initial.generationToken,
+            state: "pending",
+            dispatchState: "allowed",
+            submittedAt: null,
+        };
+        insertWorkPiece(deps.db, piece);
+        deps.db
+            .prepare("INSERT INTO revision_work_reservations(project_id,revision_id,work_key,work_id,piece_id,fingerprint,logical_key,desired_fingerprint) VALUES (?,?,?,?,?,?,?,?)")
+            .run(context.work.projectId, head, key, context.work.workId, piece.id, piece.fingerprint, z.string().parse(anchor.logical_key ?? anchor.work_key), z.string().parse(anchor.desired_fingerprint ?? anchor.fingerprint));
+        return piece;
+    });
+}

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

@@ -0,0 +1,45 @@
+import { checkpointClosure, checkpointFingerprint } from "../checkpoints/fingerprint.js";
+import { saveCheckpointSet } from "../checkpoints/repo.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { executionCatalogue, executionPlan } from "./runtime-plan.js";
+export function admitReviewedCheckpoints(deps, projectIds, reviewed, catalogue) {
+    return projectIds.flatMap((projectId, runIndex) => {
+        const gates = reviewed.filter((gate) => gate.runIndex === runIndex);
+        if (!gates.length)
+            return [];
+        const revisionId = currentRevisionId(deps.db, projectId);
+        const view = revisionId === undefined ? undefined : getRevisionView(deps, projectId, revisionId);
+        if (!view)
+            throw new Error("Checkpoint admission has no retained revision");
+        const plan = executionPlan(deps, view, executionCatalogue(catalogue, view.revision.config));
+        const checkpoints = gates.map((gate) => {
+            const work = deps.db
+                .prepare("SELECT id FROM revision_work WHERE project_id=? AND revision_id=? AND kind=? ORDER BY id LIMIT 1")
+                .get(projectId, view.revision.id, gate.stage);
+            if (typeof work?.id !== "string")
+                throw new Error("Checkpoint admission has no stage work");
+            return {
+                checkpointId: gate.checkpointId,
+                stage: gate.stage,
+                workId: work.id,
+                fingerprint: checkpointFingerprint(view.revision, checkpointClosure(gate.stage, plan.recipes)),
+                state: "held",
+            };
+        });
+        const saved = saveCheckpointSet(deps.db, {
+            projectId,
+            revisionId: view.revision.id,
+            checkpoints,
+            createdAt: deps.clock.now().toISOString(),
+        });
+        if (!saved.ok)
+            throw new Error("Checkpoint admission could not persist reviewed gates");
+        return saved.value.map((row) => {
+            const gate = gates.find((gate) => gate.checkpointId === row.checkpointId);
+            if (!gate)
+                throw new Error("Checkpoint admission lost its reviewed identity");
+            return { ...row, reviewedFingerprint: gate.fingerprint };
+        });
+    });
+}

package/dist/slices/rebuild/runtime-export-inputs.js

@@ -0,0 +1,109 @@
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import { plainText } from "../article/plain.js";
+import { splitEndMatter } from "../article/split.js";
+import { outputPath } from "../storage/layout.js";
+import { probeDurationMs } from "../video/ffmpeg.js";
+import { audioTimeline } from "../video/plan.js";
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+export function exportSnapshot(deps, context, piece) {
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(context.work.workId);
+    if (view === undefined || row === undefined)
+        throw new Error("The export revision no longer exists.");
+    const plan = executionPlan(deps, view, savedCatalogue(row.recipe_context));
+    const recipe = plan.recipes.find((one) => one.key === piece.key && one.fingerprint === piece.fingerprint);
+    if (recipe === undefined || recipe.deferred || recipe.unresolved)
+        throw new Error("The export inputs do not match the admitted recipe.");
+    return { view, plan };
+}
+export async function revisionAudio(deps, context, view) {
+    const config = view.revision.config;
+    if (config.sources.audio === "off")
+        return [];
+    const input = async (role) => {
+        const row = view.outputs.find((one) => one.selected && one.available && one.state === "ready" && one.output.role === role);
+        if (row === undefined)
+            return undefined;
+        const path = outputPath(deps.paths, context.work.projectId, row.output.path);
+        const duration = row.output.durationMs ??
+            (await (deps.measureAudio?.(path, context.signal) ??
+                probeDurationMs(deps.ffmpeg, path, context.signal, deps.log)));
+        if (!Number.isFinite(duration) || duration <= 0)
+            throw new Error("The narration duration could not be measured.");
+        return { path, seconds: duration / 1000 };
+    };
+    const body = await input("audio_body");
+    if (body === undefined)
+        throw new Error("The revision has no complete narration.");
+    return audioTimeline({
+        body,
+        intro: config.sources.audio === "generate" && config.intro !== undefined
+            ? await input("audio_intro")
+            : undefined,
+        outro: config.sources.audio === "generate" && config.outro !== undefined
+            ? await input("audio_outro")
+            : undefined,
+        gapSeconds: config.silenceGapSeconds,
+    }, config.sources.video === "off" ? 1 / 48000 : 1 / 30);
+}
+export function revisionTranscript(deps, snapshot, kind) {
+    const { view, plan } = snapshot;
+    const concat = plan.recipes.find((one) => one.key === (kind === "body" ? "audio:body:concat" : `audio:${kind}`));
+    if (concat !== undefined) {
+        const texts = concat.dependsOn.map((key) => {
+            const row = view.pieces.find((one) => one.key === key && one.selected && one.available && one.piece.state === "done");
+            const payload = row?.piece.payload === null || row?.piece.payload === undefined
+                ? undefined
+                : z.object({ text: z.string().optional() }).parse(JSON.parse(row.piece.payload));
+            if (payload?.text !== undefined)
+                return payload.text;
+            const recipe = plan.recipes.find((one) => one.key === key);
+            if (recipe?.input.kind === "tts")
+                return recipe.input.text;
+            if (recipe?.input.kind === "provided" &&
+                Array.isArray(recipe.input.semantic) &&
+                typeof recipe.input.semantic[0] === "string")
+                return recipe.input.semantic[0];
+            throw new Error("The saved narration transcript is incomplete.");
+        });
+        if (texts.length > 0)
+            return texts.join("\n");
+    }
+    if (kind === "body") {
+        const row = view.outputs.find((one) => one.selected && one.available && one.state === "ready" && one.output.role === "article_txt");
+        if (row !== undefined)
+            return readFileSync(outputPath(deps.paths, view.revision.projectId, row.output.path), "utf8");
+        if (view.articleMarkdown !== null)
+            return plainText(splitEndMatter(view.articleMarkdown).body);
+    }
+    throw new Error(`The saved ${kind} narration transcript is missing.`);
+}
+export function retainedOutput(deps, view, row) {
+    const asset = z
+        .object({
+        id: z.string(),
+        project_id: z.string(),
+        path: z.string(),
+        bytes: z.number(),
+        created_at: z.string(),
+    })
+        .parse(deps.db
+        .prepare("SELECT * FROM project_assets WHERE id=? AND project_id=?")
+        .get(row.assetId, view.revision.projectId));
+    return {
+        slot: row.slot,
+        workKey: row.workKey,
+        fingerprint: row.fingerprint,
+        asset: {
+            id: asset.id,
+            projectId: asset.project_id,
+            path: asset.path,
+            bytes: asset.bytes,
+            createdAt: asset.created_at,
+        },
+        output: { ...row.output, id: deps.ids.next(), createdAt: deps.clock.now().toISOString() },
+    };
+}

package/dist/slices/rebuild/runtime-export.js

@@ -0,0 +1,139 @@
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { extname, join, relative, sep } from "node:path";
+import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
+import { outputPath, projectDir } from "../storage/layout.js";
+import { audioExportArgs } from "../video/audio-export.js";
+import { renderArgs, runFfmpeg } from "../video/ffmpeg.js";
+import { planRender } from "../video/plan.js";
+import { exportSnapshot, retainedOutput, revisionAudio, } from "./runtime-export-inputs.js";
+import { preparedResult, preparedText, publishResult } from "./runtime-publication.js";
+export async function executeExportRecipe(deps, context, piece) {
+    if (deps.db
+        .prepare("SELECT state FROM revision_work_pieces WHERE id=? AND work_id=?")
+        .get(piece.id, context.work.workId)?.state === "done")
+        return "done";
+    if (!context.maySubmit(piece.id))
+        return "held";
+    context.signal.throwIfAborted();
+    const snapshot = exportSnapshot(deps, context, piece);
+    const { view } = snapshot;
+    const audio = await revisionAudio(deps, context, view);
+    const wav = piece.key === "export:wav";
+    if (!wav && piece.key !== "export:video")
+        throw new Error("Unknown media export recipe.");
+    if (wav && audio.length === 0)
+        throw new Error("Audio export needs complete narration.");
+    const filename = wav ? "audio.wav" : "video.mp4";
+    const pending = allocateAsset(deps, context.work.projectId, filename);
+    const prepared = [];
+    let directory;
+    try {
+        const captions = snapshot.view.outputs.filter((row) => row.selected && row.available && row.state === "ready" && row.workKey === "subtitles:files");
+        const burn = !wav && view.revision.config.subtitles?.mode === "burn-in";
+        if (burn)
+            directory = captionDirectory(deps, context, snapshot);
+        const mode = burn
+            ? "burn-in"
+            : captions.some((row) => row.output.role === "subtitles_srt") &&
+                captions.some((row) => row.output.role === "subtitles_vtt")
+                ? "files"
+                : "off";
+        const config = view.revision.config;
+        const segment = (kind) => {
+            const row = audio.find((one) => one.kind === kind);
+            return row?.path === null || row === undefined
+                ? undefined
+                : { path: row.path, seconds: row.seconds };
+        };
+        const images = (wav ? [] : view.revision.content.imageOrder).map((key) => {
+            const row = view.outputs.find((one) => one.workKey === `image:${key}` && one.selected && one.available && one.state === "ready");
+            if (row === undefined)
+                throw new Error("The revision is missing an image selected for its slideshow.");
+            return outputPath(deps.paths, context.work.projectId, row.output.path);
+        });
+        const plan = wav
+            ? undefined
+            : planRender({
+                format: config.format,
+                gapSeconds: config.silenceGapSeconds,
+                body: segment("body"),
+                intro: segment("intro"),
+                outro: segment("outro"),
+                images,
+                output: pending.absolutePath,
+            });
+        const totalSeconds = plan?.totalSeconds ?? audio.reduce((sum, row) => sum + row.seconds, 0);
+        const projectDirectory = projectDir(deps.paths, context.work.projectId);
+        const relativePath = (path) => relative(projectDirectory, path).split(sep).join("/");
+        const record = plan === undefined
+            ? {
+                sampleRate: 48000,
+                channels: 2,
+                codec: "pcm_s16le",
+                gapSeconds: config.silenceGapSeconds,
+                totalSeconds,
+                audio: audio.map((row) => ({
+                    ...row,
+                    path: row.path === null ? null : relativePath(row.path),
+                })),
+                output: pending.path,
+            }
+            : {
+                ...plan,
+                output: pending.path,
+                audio: plan.audio.map((row) => ({
+                    ...row,
+                    path: row.path === null ? null : relativePath(row.path),
+                })),
+                images: plan.images.map((row) => ({ ...row, path: relativePath(row.path) })),
+                subtitles: config.subtitles,
+            };
+        if (!context.maySubmit(piece.id))
+            return "held";
+        await runFfmpeg({
+            bin: deps.ffmpeg,
+            args: plan === undefined ? audioExportArgs(audio, pending.absolutePath) : renderArgs(plan, burn),
+            cwd: directory,
+            signal: context.signal,
+            log: deps.log,
+            onProgress: (elapsedMs) => context.emit({
+                type: "stage.progress",
+                projectId: context.work.projectId,
+                stage: "video",
+                current: Math.min(100, Math.round(elapsedMs / (totalSeconds * 10))),
+                total: 100,
+            }),
+        });
+        context.signal.throwIfAborted();
+        const asset = sealAsset(deps, pending);
+        prepared.push(preparedResult(deps, context, piece, wav ? "audio_export" : "video", asset, Math.round(totalSeconds * 1000), { subtitlesMode: mode }));
+        prepared.push(preparedText(deps, context, piece, "render_params", "render.json", JSON.stringify(record)));
+        prepared.push(...captions.map((row) => retainedOutput(deps, view, row)));
+        await publishResult(deps, context, piece, prepared, { totalSeconds }, asset);
+        deps.count?.("stage.completed", { stage: "video" });
+        return "done";
+    }
+    finally {
+        discardPreparedAssets(deps, [pending, ...prepared.map((one) => one.asset)]);
+        if (directory !== undefined)
+            rmSync(directory, { recursive: true, force: true });
+    }
+}
+function captionDirectory(deps, context, snapshot) {
+    const find = (role) => snapshot.view.outputs.find((row) => row.selected && row.available && row.state === "ready" && row.output.role === role);
+    const ass = find("subtitle_ass");
+    const font = find("subtitle_font");
+    if (ass === undefined || font === undefined)
+        throw new Error("Burned subtitles need prepared captions and their saved font.");
+    const directory = mkdtempSync(join(projectDir(deps.paths, context.work.projectId), "render-"));
+    try {
+        mkdirSync(join(directory, "fonts"), { mode: 0o700 });
+        copyFileSync(outputPath(deps.paths, context.work.projectId, ass.output.path), join(directory, "subtitles.ass"));
+        copyFileSync(outputPath(deps.paths, context.work.projectId, font.output.path), join(directory, "fonts", `selected${extname(font.output.path)}`));
+        return directory;
+    }
+    catch (error) {
+        rmSync(directory, { recursive: true, force: true });
+        throw error;
+    }
+}

package/dist/slices/rebuild/runtime-instructions.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { recipeInputSchema } from "./recipe-input-schema.js";
+import { executionView } from "./runtime-plan.js";
+export function frozenInstructions(deps, context, current) {
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    const selected = new Set(view?.pieces
+        .filter((row) => row.selected && row.piece.state === "done")
+        .map((row) => row.piece.id));
+    const rows = deps.db
+        .prepare(`SELECT p.id,p.work_id,p.work_key,p.input_json,p.result_json,p.state FROM revision_work_pieces p JOIN revision_work w ON w.id=p.work_id WHERE w.project_id=? AND w.kind=? ORDER BY w.rowid,p.rowid`)
+        .all(context.work.projectId, context.work.kind);
+    const sections = [];
+    for (const raw of rows) {
+        const row = z
+            .object({
+            id: z.string(),
+            work_id: z.string(),
+            work_key: z.string(),
+            input_json: z.string(),
+            result_json: z.string().nullable(),
+            state: z.string(),
+        })
+            .parse(raw);
+        if (row.id !== current.id &&
+            !selected.has(row.id) &&
+            !(row.work_id === current.workId && row.result_json !== null))
+            continue;
+        const input = recipeInputSchema.parse(JSON.parse(row.input_json));
+        if (input.kind !== "llm")
+            continue;
+        sections.push(`## ${label(row.work_key)}\n\n${input.messages.map((message) => `### ${message.role}\n\n${message.content}`).join("\n\n")}`);
+    }
+    return `${sections.join("\n\n")}\n`;
+}
+function label(key) {
+    if (key === "research:planner")
+        return "Research outline";
+    if (key === "research:notes")
+        return "Research synthesis";
+    if (key.startsWith("research:chapter:"))
+        return `Research chapter ${key.split(":").at(-1)}`;
+    if (key === "article:body")
+        return "Article";
+    if (key.startsWith("article:continuation:"))
+        return `Article continuation ${key.split(":").at(-1)}`;
+    if (key === "entry:intro:text")
+        return "Intro";
+    if (key === "entry:outro:text")
+        return "Outro";
+    return "Thumbnail instructions";
+}

package/dist/slices/rebuild/runtime-local.js

@@ -0,0 +1,137 @@
+import { statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import { plainText } from "../article/plain.js";
+import { splitEndMatter } from "../article/split.js";
+import { joinNarration } from "../narration/concat.js";
+import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
+import { outputPath } from "../storage/layout.js";
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { preparedResult, preparedText, preparedTexts, publishResult, } from "./runtime-publication.js";
+export async function executeLocalRecipe(deps, context, piece) {
+    if (deps.db
+        .prepare("SELECT state FROM revision_work_pieces WHERE id=? AND work_id=?")
+        .get(piece.id, context.work.workId)?.state === "done")
+        return "done";
+    if (!context.maySubmit(piece.id))
+        return "held";
+    const input = piece.input;
+    if (input.kind === "provided") {
+        if (input.assetId === null)
+            throw new Error("The provided recipe has no retained asset.");
+        const row = z
+            .object({ id: z.string(), project_id: z.string(), path: z.string(), created_at: z.string() })
+            .parse(deps.db
+            .prepare("SELECT * FROM project_assets WHERE id=? AND project_id=?")
+            .get(input.assetId, context.work.projectId));
+        const asset = {
+            id: row.id,
+            projectId: row.project_id,
+            path: row.path,
+            createdAt: row.created_at,
+            bytes: statSync(outputPath(deps.paths, row.project_id, row.path)).size,
+        };
+        const role = piece.key === "audio:provided"
+            ? "audio_body"
+            : piece.key === "thumbnail:image"
+                ? "thumbnail"
+                : piece.key.startsWith("image:")
+                    ? "image"
+                    : undefined;
+        await publishResult(deps, context, piece, role === undefined ? [] : [preparedResult(deps, context, piece, role, asset)], {}, asset);
+        return "done";
+    }
+    if (input.kind !== "local")
+        throw new Error("Expected an exact local recipe.");
+    if (input.operation === "concat-narration") {
+        await concatenate(deps, context, piece);
+        return "done";
+    }
+    if (input.operation === "provided-article" || input.operation === "manual-article") {
+        const text = z.string().parse(input.values);
+        const parts = splitEndMatter(text);
+        await publishResult(deps, context, piece, preparedTexts(deps, context, piece, [
+            ["article_md", "article.md", text],
+            ["article_txt", "article.txt", plainText(parts.body)],
+            ...(parts.sources ? [["sources", "sources.md", parts.sources]] : []),
+            ...(parts.glossary ? [["glossary", "glossary.md", parts.glossary]] : []),
+        ]), { text });
+        return "done";
+    }
+    if (input.operation === "provided-notes") {
+        const text = z.string().parse(input.values);
+        await publishResult(deps, context, piece, [preparedText(deps, context, piece, "notes", "notes.md", text)], { text });
+        return "done";
+    }
+    if (input.operation === "entry-text") {
+        await publishResult(deps, context, piece, [], {
+            text: z.string().parse(input.values),
+            category: piece.key.includes(":intro:") ? "intro" : "outro",
+        });
+        return "done";
+    }
+    throw new Error(`No local executor for ${input.operation}.`);
+}
+async function concatenate(deps, context, piece) {
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    if (view === undefined)
+        throw new Error("The pinned revision is missing.");
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(context.work.workId);
+    const plan = executionPlan(deps, view, savedCatalogue(row?.recipe_context));
+    const recipe = plan.recipes.find((candidate) => candidate.key === piece.key && candidate.fingerprint === piece.fingerprint);
+    if (recipe === undefined)
+        throw new Error("The pinned concatenation no longer matches its inputs.");
+    const files = recipe.dependsOn.map((key) => {
+        const input = view.pieces.find((candidate) => candidate.key === key &&
+            candidate.selected &&
+            candidate.available &&
+            candidate.piece.state === "done" &&
+            candidate.fingerprint === plan.recipes.find((value) => value.key === key)?.fingerprint);
+        if (input?.assetId === null || input === undefined)
+            throw new Error("A narration part has no retained audio.");
+        const asset = deps.db
+            .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
+            .get(input.assetId, context.work.projectId);
+        return outputPath(deps.paths, context.work.projectId, z.string().parse(asset?.path));
+    });
+    const pending = allocateAsset(deps, context.work.projectId, "narration.mp3");
+    try {
+        const durationMs = await joinNarration({ bin: deps.ffmpeg, log: deps.log }, {
+            files,
+            output: pending.absolutePath,
+            listPath: join(dirname(pending.absolutePath), "parts.txt"),
+            signal: context.signal,
+        });
+        context.signal.throwIfAborted();
+        const asset = sealAsset(deps, pending);
+        const role = piece.key === "audio:intro"
+            ? "audio_intro"
+            : piece.key === "audio:outro"
+                ? "audio_outro"
+                : "audio_body";
+        await publishResult(deps, context, piece, [
+            preparedResult(deps, context, piece, role, asset, durationMs, view.revision.config.audio === undefined
+                ? {}
+                : {
+                    provider: view.revision.config.audio.provider,
+                    model: view.revision.config.audio.model,
+                    voice: view.revision.config.audio.voice,
+                }),
+        ], { durationMs }, asset);
+        for (const key of recipe.dependsOn) {
+            const retained = view.pieces.find((candidate) => candidate.key === key && candidate.selected && candidate.available);
+            if (retained?.publicationId === null || retained === undefined)
+                continue;
+            const owner = deps.db
+                .prepare("SELECT work_id FROM revision_work_pieces WHERE id=?")
+                .get(retained.publicationId);
+            if (typeof owner?.work_id === "string")
+                deps.audioPreviews?.clear(context.work.projectId, owner.work_id);
+        }
+    }
+    finally {
+        discardPreparedAssets(deps, [pending]);
+    }
+}