@gentbajko/slopify 3.25.8 → 4.0.0

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

@@ -1,8 +1,10 @@
 import { copyFileSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { extname, join, relative, sep } from "node:path";
+import { internalError } from "../../kernel/errors.js";
 import { usesShortMode } from "../admission/short-mode.js";
 import { masterFile, masterReport } from "../loudness/loudnorm.js";
 import { masterGoal } from "../loudness/model.js";
+import { isReadyOutput, readyOutput } from "../revisions/view.js";
 import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
 import { outputPath, projectDir, renderCacheDir } from "../storage/layout.js";
 import { audioExportArgs } from "../video/audio-export.js";
@@ -18,10 +20,21 @@ import { exportSnapshot, retainedOutput, revisionAudio, } from "./runtime-export
 import { executeShortExport } from "./runtime-export-short.js";
 import { lineLevelledAudio } from "./runtime-lines.js";
 import { preparedResult, preparedText, publishResult } from "./runtime-publication.js";
+import { pieceAlreadyDone } from "./work-records.js";
+// The machine settings for one render, and the notices it gathers for the project page.
+export async function exportMachine(deps, projectId) {
+    const chosen = await deps.renderMachine?.(projectId);
+    const notices = chosen?.notice === undefined ? [] : [chosen.notice];
+    return {
+        machine: chosen?.machine,
+        notices,
+        notice: (sentence) => {
+            notices.push(sentence);
+        },
+    };
+}
 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")
+    if (pieceAlreadyDone(deps.db, context.work.workId, piece.id))
         return "done";
     if (!context.maySubmit(piece.id))
         return "held";
@@ -31,7 +44,7 @@ export async function executeExportRecipe(deps, context, piece) {
     const audio = await revisionAudio(deps, context, view, { levelled: true });
     const wav = piece.key === "export:wav";
     if (!wav && piece.key !== "export:video")
-        throw new Error("Slopify hit an internal error (unknown kind of export). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error(internalError("unknown kind of export"));
     if (wav && audio.length === 0)
         throw new Error("The audio export has nothing to export because narration is turned off for this project. Turn narration on in Edit project, then Try again.");
     if (!wav && usesShortMode(view.revision.config))
@@ -49,7 +62,7 @@ export async function executeExportRecipe(deps, context, piece) {
         const sound = linesDirectory === undefined
             ? audio
             : await lineLevelledAudio(deps, context, view, audio, linesDirectory);
-        const captions = snapshot.view.outputs.filter((row) => row.selected && row.available && row.state === "ready" && row.workKey === "subtitles:files");
+        const captions = snapshot.view.outputs.filter((row) => isReadyOutput(row) && row.workKey === "subtitles:files");
         const burn = !wav && view.revision.config.subtitles?.mode === "burn-in";
         if (burn)
             directory = captionDirectory(deps, context, snapshot);
@@ -119,6 +132,8 @@ export async function executeExportRecipe(deps, context, piece) {
             };
         if (!context.maySubmit(piece.id))
             return "held";
+        const machine = await exportMachine(deps, context.work.projectId);
+        const priority = machine.machine?.priority;
         const onProgress = (elapsedMs) => context.emit({
             type: "stage.progress",
             projectId: context.work.projectId,
@@ -139,10 +154,11 @@ export async function executeExportRecipe(deps, context, piece) {
                     args: audioExportArgs(sound, mixed),
                     signal: context.signal,
                     log: deps.log,
+                    priority,
                     onProgress,
                 });
                 if (goal !== undefined) {
-                    const run = { bin: deps.ffmpeg, log: deps.log, signal: context.signal };
+                    const run = { bin: deps.ffmpeg, log: deps.log, signal: context.signal, priority };
                     await masterFile(run, mixed, `${pending.absolutePath}.master.wav`, goal, {
                         sampleRate: 48000,
                         channels: 2,
@@ -167,6 +183,7 @@ export async function executeExportRecipe(deps, context, piece) {
                         ],
                         signal: context.signal,
                         log: deps.log,
+                        priority,
                         onProgress: () => { },
                     });
                     master = await masterReport(run, pending.absolutePath, goal);
@@ -193,20 +210,21 @@ export async function executeExportRecipe(deps, context, piece) {
                 log: deps.log,
                 onProgress,
                 ...(goal === undefined ? {} : { master: goal }),
+                machine: machine.machine,
+                notice: machine.notice,
             });
         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,
-            ...(edited === undefined || edited.warnings.length === 0
-                ? {}
-                : { warnings: edited.warnings }),
+            // An audio export encodes no picture, so the encoder's notice is not its to show.
+            ...warningsOf([...(edited?.warnings ?? []), ...(wav ? [] : machine.notices)]),
             ...(master === undefined ? {} : { master }),
         }));
         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" });
+        deps.count?.("stage.completed", { stage: "video" }, context.work.projectId);
         return "done";
     }
     finally {
@@ -220,14 +238,14 @@ export async function executeExportRecipe(deps, context, piece) {
 // The project's images in slideshow order, as files.
 export function slideshowImages(deps, context, view) {
     return view.revision.content.imageOrder.map((key) => {
-        const row = view.outputs.find((one) => one.workKey === `image:${key}` && one.selected && one.available && one.state === "ready");
+        const row = readyOutput(view, { workKey: `image:${key}` });
         if (row === undefined)
             throw new Error("The video export can't find one of the slideshow images. Use More → make it again in its section on Images (or regenerate that image in Edit project → Images), then Try again.");
         return outputPath(deps.paths, context.work.projectId, row.output.path);
     });
 }
 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 find = (role) => readyOutput(snapshot.view, { role });
     const ass = find("subtitle_ass");
     const font = find("subtitle_font");
     if (ass === undefined || font === undefined)
@@ -244,3 +262,7 @@ function captionDirectory(deps, context, snapshot) {
         throw error;
     }
 }
+// What the video could not do as asked, for the project page; nothing when it did it all.
+export function warningsOf(warnings) {
+    return warnings.length === 0 ? {} : { warnings };
+}

package/dist/slices/rebuild/runtime-figure-card.js

@@ -1,6 +1,7 @@
 import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
+import { internalError } from "../../kernel/errors.js";
 import { captionFont, captionFontDeps } from "../fonts/coverage.js";
 import { describedKinds } from "../narration/blocks.js";
 import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
@@ -25,7 +26,7 @@ const values = z.object({
 const frames = { "16:9": [1920, 1080], "9:16": [1080, 1920], "1:1": [1080, 1080] };
 export async function executeFigureCard(deps, context, piece) {
     if (piece.input.kind !== "local")
-        throw new Error("Slopify hit an internal error (a figure card step was set up wrongly). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error(internalError("a figure card step was set up wrongly"));
     const card = values.parse(piece.input.values);
     const view = executionView(deps, context.work.projectId, context.work.revisionId);
     // The article's own picture for a figure, when the project has it as an upload.

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

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
-import { z } from "zod";
 import { imageBlob } from "../channels/repo.js";
+import { assetPathOrUndefined } from "../revisions/mutation-assets.js";
 import { outputPath } from "../storage/layout.js";
 // The provider call an image step makes: its request, the effort when one is chosen and, while
 // the project's Establishing image is on, that image's bytes as the visual reference.
@@ -25,17 +25,12 @@ function referenceImage(deps, projectId, input) {
     const missing = "The establishing image this image is drawn from is missing. Use Regenerate on the establishing image in the Images section (or upload it again in Edit project → Images), then use Try again.";
     if (input.reference.assetId === null)
         throw new Error(missing);
-    const row = z
-        .object({ path: z.string() })
-        .optional()
-        .parse(deps.db
-        .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
-        .get(input.reference.assetId, projectId));
-    if (row === undefined)
+    const saved = assetPathOrUndefined(deps, projectId, input.reference.assetId);
+    if (saved === undefined)
         throw new Error(missing);
     let bytes;
     try {
-        bytes = new Uint8Array(readFileSync(outputPath(deps.paths, projectId, row.path)));
+        bytes = new Uint8Array(readFileSync(outputPath(deps.paths, projectId, saved)));
     }
     catch {
         throw new Error(missing);

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

@@ -49,5 +49,7 @@ function label(key) {
         return "Intro";
     if (key === "entry:outro:text")
         return "Outro";
+    if (key === "article:digest")
+        return "Keyword digest";
     return "Thumbnail instructions";
 }

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

@@ -0,0 +1,59 @@
+import { errorText } from "../../kernel/errors.js";
+import { fillLateKeywords, mentionsLateKeyword } from "../keywords/fill.js";
+import { durationText, releaseDateText } from "../keywords/values.js";
+import { releasesOf } from "../studio/releases.js";
+import { revisionAudio } from "./runtime-export-inputs.js";
+import { executionView } from "./runtime-plan.js";
+// The release date and the video's length are filled into a request only as it is sent: the
+// planned request keeps `{{Slopify_Release_Date}}` and `{{Slopify_Duration}}`, so moving the
+// date later, or a new length, never makes anything outdated. Every other call goes through as
+// it was.
+export function lateKeywordProviders(providers, values) {
+    let once;
+    const late = () => {
+        once ??= values();
+        return once;
+    };
+    const wrap = (inner) => ({
+        ...inner,
+        llm: async (call, onEvent) => {
+            if (!call.messages.some((message) => mentionsLateKeyword(message.content)))
+                return inner.llm(call, onEvent);
+            const filled = await late();
+            return inner.llm({
+                ...call,
+                messages: call.messages.map((message) => ({
+                    ...message,
+                    content: fillLateKeywords(message.content, filled),
+                })),
+            }, onEvent);
+        },
+        image: async (call) => mentionsLateKeyword(call.prompt)
+            ? inner.image({ ...call, prompt: fillLateKeywords(call.prompt, await late()) })
+            : inner.image(call),
+        forPiece: (pieceId) => wrap(inner.forPiece(pieceId)),
+    });
+    return wrap(providers);
+}
+// The long video's release time from the posting plan, and the narration's length once it is
+// there. A length that can't be read yet (an article review runs before the narration) is
+// blank, so its line is left out, and the reason is logged.
+export async function lateValuesOf(deps, context) {
+    const releaseDate = releaseDateText(releasesOf(deps.db, context.work.projectId).find((release) => release.short === 0)?.at);
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    let duration;
+    if (view !== undefined && view.revision.config.sources.audio !== "off")
+        try {
+            const audio = await revisionAudio(deps, context, view);
+            const seconds = audio.reduce((sum, segment) => sum + segment.seconds, 0);
+            duration = seconds > 0 ? durationText(seconds) : undefined;
+        }
+        catch (error) {
+            deps.log.write("warn", "keywords.duration", {
+                projectId: context.work.projectId,
+                stage: context.work.kind,
+                detail: errorText(error),
+            });
+        }
+    return { releaseDate, duration };
+}

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

@@ -1,9 +1,7 @@
-import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { levelLines } from "../loudness/line-level.js";
-import { outputPath } from "../storage/layout.js";
 import { linesLevelled } from "./recipe-lines.js";
-import { wordsSchema } from "./runtime-subtitles.js";
+import { readTimingWords } from "./runtime-subtitles.js";
 // The sound a multi-voice run plays, with its body narration levelled line by line
 // (`loudness/line-level.ts`) into `directory`, for the video, the audio export and the audio
 // files alike. The words are timed on the timeline these segments lay out, so the body starts
@@ -11,14 +9,7 @@ import { wordsSchema } from "./runtime-subtitles.js";
 export async function lineLevelledAudio(deps, context, view, audio, directory) {
     if (!linesLevelled(view.revision.config))
         return audio;
-    const timing = view.outputs.find((row) => row.selected &&
-        row.available &&
-        row.state === "ready" &&
-        row.workKey === "subtitles:timing" &&
-        row.output.role === "subtitle_words");
-    if (timing === undefined)
-        throw new Error("The narration's word timing, which evens out the speakers' volume, is missing. Use More → Render the video again in the Video section, then Try again.");
-    const { words } = wordsSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, context.work.projectId, timing.output.path), "utf8")));
+    const { words } = readTimingWords(deps, context, view, "evens out the speakers' volume");
     const run = { bin: deps.ffmpeg, log: deps.log, signal: context.signal };
     const levelled = [];
     let offset = 0;

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

@@ -1,6 +1,7 @@
 import { rmSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { z } from "zod";
+import { internalError } from "../../kernel/errors.js";
 import { referenceKey, thumbnailVariant } from "../admission/model.js";
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
@@ -9,6 +10,8 @@ import { levelSentences } from "../loudness/sentence-level.js";
 import { cleanPieces } from "../narration/clean-pieces.js";
 import { joinNarration } from "../narration/concat.js";
 import { applyPauses, planPieces } from "../narration/pauses.js";
+import { assetPath } from "../revisions/mutation-assets.js";
+import { isDonePiece } from "../revisions/view.js";
 import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
 import { outputPath } from "../storage/layout.js";
 import { probeDurationMs, runFfmpeg } from "../video/ffmpeg.js";
@@ -17,12 +20,11 @@ import { breathsAsked, deEssAsked } from "./recipe-breaths.js";
 import { levelOperation, sentencesAsked } from "./recipe-loudness.js";
 import { executeFigureCard } from "./runtime-figure-card.js";
 import { publishNarrationText } from "./runtime-narration-text.js";
-import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { executionPlan, executionView, workCatalogue } from "./runtime-plan.js";
 import { preparedResult, preparedText, preparedTexts, publishResult, } from "./runtime-publication.js";
+import { pieceAlreadyDone } from "./work-records.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")
+    if (pieceAlreadyDone(deps.db, context.work.workId, piece.id))
         return "done";
     if (!context.maySubmit(piece.id))
         return "held";
@@ -62,7 +64,7 @@ export async function executeLocalRecipe(deps, context, piece) {
         return "done";
     }
     if (input.kind !== "local")
-        throw new Error("Slopify hit an internal error (a local step was set up wrongly). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error(internalError("a local step was set up wrongly"));
     if (input.operation === "figure-card-v1")
         return executeFigureCard(deps, context, piece);
     if (input.operation === "narration-files-v1") {
@@ -98,31 +100,23 @@ export async function executeLocalRecipe(deps, context, piece) {
         });
         return "done";
     }
-    throw new Error(`Slopify hit an internal error (no handler for the step "${input.operation}"). Try again; if it happens again, use Download diagnostics in Settings and report it.`);
+    throw new Error(internalError(`no handler for the step "${input.operation}"`));
 }
 async function concatenate(deps, context, piece) {
     const view = executionView(deps, context.work.projectId, context.work.revisionId);
     if (view === undefined)
-        throw new Error("Slopify hit an internal error (the project version being built is missing). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    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));
+        throw new Error(internalError("the project version being built is missing"));
+    const plan = executionPlan(deps, view, workCatalogue(deps.db, context.work.workId));
     const recipe = plan.recipes.find((candidate) => candidate.key === piece.key && candidate.fingerprint === piece.fingerprint);
     if (recipe === undefined)
-        throw new Error("Slopify hit an internal error (the narration chunks to join no longer match the project's saved inputs). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error(internalError("the narration chunks to join no longer match the project's saved inputs"));
     const files = recipe.dependsOn.map((key) => {
         const input = view.pieces.find((candidate) => candidate.key === key &&
-            candidate.selected &&
-            candidate.available &&
-            candidate.piece.state === "done" &&
+            isDonePiece(candidate) &&
             candidate.fingerprint === plan.recipes.find((value) => value.key === key)?.fingerprint);
         if (input?.assetId === null || input === undefined)
             throw new Error("One narration chunk has no saved audio, so the narration can't be joined together. Regenerate the missing chunk in Edit project → Narration, then Try again.");
-        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));
+        return outputPath(deps.paths, context.work.projectId, assetPath(deps, context.work.projectId, input.assetId));
     });
     // Level the volume repeats the join its recipe names, from the same pieces, each levelled
     // first (`recipe-loudness.ts`).
@@ -295,7 +289,7 @@ export async function joinTurns(run, files, values, output) {
         .rest(z.unknown())
         .parse(values)[1];
     if (layout.length !== files.length || files.length === 0)
-        throw new Error("Slopify hit an internal error (the speaker turns to join don't match their audio). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error(internalError("the speaker turns to join don't match their audio"));
     await runFfmpeg({
         bin: run.bin,
         args: turnJoinArgs(files.map((path, index) => ({

package/dist/slices/rebuild/runtime-narration-publication.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { projectSelected } from "../revisions/projection.js";
 import { getRevisionView } from "../revisions/view.js";
 import { bindNarrationReuse, narrationOrdinal } from "./runtime-narration-reuse.js";
-import { executionPlan, savedCatalogue } from "./runtime-plan.js";
+import { executionPlan, workCatalogue } from "./runtime-plan.js";
 export function rebindPublishedNarration(deps, work, piece) {
     if (piece.input.kind !== "tts")
         return;
@@ -11,10 +11,7 @@ export function rebindPublishedNarration(deps, work, piece) {
         .all(work.projectId, piece.id, piece.key, work.revisionId);
     if (targets.length === 0)
         return;
-    const row = deps.db
-        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
-        .get(work.workId);
-    const catalogue = savedCatalogue(row?.recipe_context);
+    const catalogue = workCatalogue(deps.db, work.workId);
     for (const target of targets) {
         const view = getRevisionView(deps, work.projectId, z.string().parse(target.revision_id));
         if (view === undefined)

package/dist/slices/rebuild/runtime-narration-reuse.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import { insertManifestOutput, insertManifestPiece, selectOutputRecord, selectPieceRecord, } from "../revisions/manifest-repo.js";
+import { assetPathOrUndefined } from "../revisions/mutation-assets.js";
+import { isDonePiece } from "../revisions/view.js";
 import { retainedNarrationPieces } from "./narration-history.js";
 import { matchingNarrationPiece } from "./narration-reuse.js";
 export function bindNarrationReuse(deps, view, recipe, ordinal) {
@@ -30,17 +32,14 @@ export function bindNarrationReuse(deps, view, recipe, ordinal) {
         return;
     }
     if (recipe.input.kind === "provided" && /^audio:(body:.+|intro|outro):[0-9]+$/.test(recipe.key)) {
-        if (view.pieces.some((one) => one.selected &&
-            one.available &&
-            one.key === recipe.key &&
+        if (view.pieces.some((one) => isDonePiece(one, recipe.key) &&
             one.fingerprint === recipe.fingerprint &&
-            one.piece.state === "done" &&
             one.piece.idx === ordinal))
             return;
-        const asset = deps.db
-            .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
-            .get(recipe.input.assetId, view.revision.projectId);
-        if (asset === undefined)
+        const file = recipe.input.assetId === null
+            ? undefined
+            : assetPathOrUndefined(deps, view.revision.projectId, recipe.input.assetId);
+        if (file === undefined)
             return;
         const semantic = z
             .tuple([z.string(), z.array(z.string().nullable())])
@@ -67,7 +66,7 @@ export function bindNarrationReuse(deps, view, recipe, ordinal) {
                 state: "done",
                 payload: JSON.stringify({
                     provided: true,
-                    file: asset.path,
+                    file,
                     logicalKey: recipe.key.slice(0, recipe.key.lastIndexOf(":")),
                     logicalText: semantic[0],
                     text: semantic[0],
@@ -85,11 +84,8 @@ export function bindNarrationReuse(deps, view, recipe, ordinal) {
     if (recipe.input.kind !== "tts")
         return;
     const input = recipe.input;
-    if (view.pieces.some((one) => one.selected &&
-        one.available &&
-        one.key === recipe.key &&
+    if (view.pieces.some((one) => isDonePiece(one, recipe.key) &&
         one.fingerprint === recipe.fingerprint &&
-        one.piece.state === "done" &&
         one.piece.idx === ordinal &&
         narrationMetadataMatches(one.piece.payload, input)))
         return;

package/dist/slices/rebuild/runtime-narration-text.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
-import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { internalError } from "../../kernel/errors.js";
+import { isDonePiece } from "../revisions/view.js";
+import { executionPlan, executionView, savedCatalogue, workCatalogue } from "./runtime-plan.js";
 import { preparedTexts, publishResult } from "./runtime-publication.js";
 export function joinedNarration(parts) {
     return parts
@@ -9,14 +11,10 @@ export function joinedNarration(parts) {
 export function narrationTextParts(view, plan, segment) {
     const concat = plan.recipes.find((row) => row.key === (segment === "body" ? "audio:body:concat" : `audio:${segment}`));
     if (concat === undefined)
-        throw new Error(`Slopify hit an internal error (the ${segment} narration is missing from the project plan). Try again; if it happens again, use Download diagnostics in Settings and report it.`);
+        throw new Error(internalError(`the ${segment} narration is missing from the project plan`));
     return concat.dependsOn.map((key) => {
         const recipe = plan.recipes.find((row) => row.key === key);
-        const selected = view.pieces.find((row) => row.key === key &&
-            row.selected &&
-            row.available &&
-            row.piece.state === "done" &&
-            row.fingerprint === recipe?.fingerprint);
+        const selected = view.pieces.find((row) => row.key === key && isDonePiece(row) && row.fingerprint === recipe?.fingerprint);
         if (selected === undefined || recipe === undefined)
             throw new Error("Some narration chunks aren't finished, so the full narration text isn't available. Let the Narration stage finish (Resume, or Try again on it), or regenerate the missing chunk in Edit project → Narration.");
         const input = recipe.input;
@@ -29,7 +27,7 @@ export function narrationTextParts(view, plan, segment) {
                 requestText: null,
             };
         if (input.kind !== "tts")
-            throw new Error("Slopify hit an internal error (a narration chunk's text was never worked out). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error(internalError("a narration chunk's text was never worked out"));
         const payload = z
             .object({ text: z.string().optional(), spokenText: z.string().optional() })
             .parse(JSON.parse(selected.piece.payload ?? "{}"));
@@ -45,19 +43,16 @@ export function narrationTextParts(view, plan, segment) {
 }
 export async function publishNarrationText(deps, context, piece) {
     if (piece.input.kind !== "local")
-        throw new Error("Slopify hit an internal error (the narration text file step was set up wrongly). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error(internalError("the narration text file step was set up wrongly"));
     const { segment } = z
         .object({ segment: z.enum(["body", "intro", "outro"]) })
         .parse(piece.input.values);
     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)
-        throw new Error("Slopify hit an internal error (the project version being narrated is missing). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    const plan = executionPlan(deps, view, savedCatalogue(row?.recipe_context));
+        throw new Error(internalError("the project version being narrated is missing"));
+    const plan = executionPlan(deps, view, workCatalogue(deps.db, context.work.workId));
     if (!plan.recipes.some((recipe) => recipe.key === piece.key && recipe.fingerprint === piece.fingerprint))
-        throw new Error("Slopify hit an internal error (the narration text no longer matches the project's saved inputs). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error(internalError("the narration text no longer matches the project's saved inputs"));
     const parts = narrationTextParts(view, plan, segment);
     const outputs = preparedTexts(deps, context, piece, [
         ["narration_txt", `${segment}-narration.txt`, joinedNarration(parts)],

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

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
 import { basename } from "node:path";
+import { assetPathOrUndefined } from "../revisions/mutation-assets.js";
 import { outputPath } from "../storage/layout.js";
 // The file behind a picture the article names (`![alt](maps/relief.png)`): an image uploaded
 // to the project under that file name. An article's pictures are otherwise web addresses
@@ -14,10 +15,7 @@ export function articlePicture(deps, view, named) {
     for (const image of Object.values(view.revision.content.imageDefinitions)) {
         if (image.source !== "provide" || image.assetId === null)
             continue;
-        const row = deps.db
-            .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
-            .get(image.assetId, view.revision.projectId);
-        const path = typeof row?.path === "string" ? row.path : undefined;
+        const path = assetPathOrUndefined(deps, view.revision.projectId, image.assetId);
         if (path === undefined || basename(path).toLowerCase() !== name)
             continue;
         const file = outputPath(deps.paths, view.revision.projectId, path);

package/dist/slices/rebuild/runtime-piece-label.js

@@ -1,4 +1,5 @@
-import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { platformLabels, socialPlatforms } from "../social/model.js";
+import { executionPlan, executionView, workCatalogueIfSaved } from "./runtime-plan.js";
 // What a failed step is called on screen, so its error says which image, chunk or topic to
 // fix. Worked out only after a failure: numbering a narration chunk means building the plan.
 // Undefined for steps that name their own place (captions, export) or have no single one.
@@ -17,6 +18,9 @@ export function pieceLabel(deps, context, piece) {
         return "Document";
     if (key === "youtube:description")
         return "YouTube description";
+    const post = /^social:post:([a-z]+)$/.exec(key);
+    if (post !== null)
+        return `${platformLabels[socialPlatforms.find((one) => one === post[1]) ?? "x"]} post`;
     if (key.startsWith("review:")) {
         const item = key.slice("review:".length);
         const itemLabel = item === "narration"
@@ -47,6 +51,8 @@ export function pieceLabel(deps, context, piece) {
         return "Animated images";
     if (key === "images:scenes")
         return "Image scenes";
+    if (key === "article:digest")
+        return "Keyword digest";
     const short = /^shorts:(\d+):(prompts|image:(\d+)|render)$/.exec(key);
     if (short !== null)
         return short[2] === "prompts"
@@ -84,13 +90,11 @@ export function pieceLabel(deps, context, piece) {
     return narrationChunk(deps, context, segment, key, prefix) ?? prefix;
 }
 function narrationChunk(deps, context, segment, key, prefix) {
-    const row = deps.db
-        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
-        .get(context.work.workId);
+    const catalogue = workCatalogueIfSaved(deps.db, context.work.workId);
     const view = executionView(deps, context.work.projectId, context.work.revisionId);
-    if (row?.recipe_context === null || row === undefined || view === undefined)
+    if (catalogue === undefined || view === undefined)
         return undefined;
-    const plan = executionPlan(deps, view, savedCatalogue(row.recipe_context));
+    const plan = executionPlan(deps, view, catalogue);
     const concat = plan.recipes.find((recipe) => recipe.key === (segment === "body" ? "audio:body:concat" : `audio:${segment}`));
     if (concat === undefined)
         return undefined;

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

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { z } from "zod";
 import { catalogueSchema } from "../../catalog/schema.js";
-import { getRevisionView, withEarlierJoins } from "../revisions/view.js";
+import { getRevisionView, readyOutput, withEarlierJoins } from "../revisions/view.js";
 import { outputPath } from "../storage/layout.js";
 import { referencedAssetsAvailable, retainedNarrationPieces } from "./narration-history.js";
 import { applyProvidedReviews } from "./provided-review.js";
@@ -22,12 +22,38 @@ export function executionCatalogue(catalogue, config) {
 export function savedCatalogue(value) {
     return catalogueSchema.parse(JSON.parse(z.string().parse(value)));
 }
+function savedContext(db, workId) {
+    return db.prepare("SELECT recipe_context FROM revision_work WHERE id=?").get(workId)
+        ?.recipe_context;
+}
+// The catalogue a work was admitted with, saved beside it; a work without one is a bug.
+export function workCatalogue(db, workId) {
+    return savedCatalogue(savedContext(db, workId));
+}
+// The same, or undefined for a work (or a missing one) that has no catalogue saved.
+export function workCatalogueIfSaved(db, workId) {
+    const context = savedContext(db, workId);
+    return context === null || context === undefined ? undefined : savedCatalogue(context);
+}
+// A step's LLM call on its work's saved catalogue: the chosen model with the thinking settings
+// the catalogue holds for its level, no web search, labelled with the step. The catalogue is
+// read once, as the builder is made.
+export function workLlm(db, workId, choice, label) {
+    const catalogued = workCatalogue(db, workId).llm.find((one) => one.provider === choice.provider && one.id === choice.model);
+    const { thinking } = choice;
+    return (call) => ({
+        provider: choice.provider,
+        model: choice.model,
+        ...(thinking === undefined ? {} : { thinking }),
+        thinkingConfig: thinking === undefined ? null : (catalogued?.llm.thinking?.[thinking] ?? null),
+        webSearch: false,
+        previewLabel: label,
+        ...call,
+    });
+}
 export function executionPlan(deps, view, catalogue) {
     const textOutput = (role) => {
-        const row = view.outputs.find((output) => output.selected &&
-            output.available &&
-            output.state === "ready" &&
-            output.output.role === role);
+        const row = readyOutput(view, { role });
         return row === undefined
             ? null
             : readFileSync(outputPath(deps.paths, view.revision.projectId, row.output.path), "utf8");