@gentbajko/slopify 2.4.0 → 3.0.0

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

@@ -0,0 +1,45 @@
+import { pieceLufs, pieceTruePeak, truePeakOf, usesLoudness, } from "../loudness/model.js";
+import { recipe, resourceIdentity, } from "./recipe-model.js";
+// Level the volume (`loudness/model.ts`): beside each narration join, a step that joins the
+// same pieces again, each brought to one loudness first. The plain join stays what it was, and
+// the word timing keeps reading it, so turning the setting on never makes the timing, or the
+// description, shorts and reviews written from it, again: only these steps and the exports that
+// play their files. The keys are outside `audio:` on purpose, where the narration's own pieces
+// and joins are recognised by their keys.
+export const levelOperation = "level-narration-v1";
+export function levelKey(segment) {
+    return `level:${segment}`;
+}
+export function levelRecipe(context, join, segment) {
+    if (!usesLoudness(context.config) || join.input.kind !== "local")
+        return undefined;
+    return recipe(context, levelKey(segment), "audio", {
+        kind: "local",
+        version: 1,
+        operation: levelOperation,
+        // The join it repeats, as that join's own recipe has it: the pieces and their layout.
+        values: [
+            join.input.operation,
+            join.input.values,
+            ["piece-level-v1", pieceLufs, pieceTruePeak],
+        ],
+    }, join.dependsOn, { unresolved: join.unresolved });
+}
+export const noMaster = { values: [], keys: [] };
+export function masterPlan(context, levels, target) {
+    const settings = context.config.loudness;
+    if (!usesLoudness(context.config) || settings === undefined)
+        return noMaster;
+    const lufs = target === "video" ? settings.videoLufs : settings.audioFilesLufs;
+    return {
+        values: [
+            [
+                "loudness-v1",
+                levels.map((level) => resourceIdentity(context, level)),
+                lufs,
+                truePeakOf(target),
+            ],
+        ],
+        keys: levels.map((level) => level.key),
+    };
+}

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

@@ -4,6 +4,8 @@ import { narrationRegenerationToken, narrationRequestFingerprint } from "../narr
 export const localOperations = [
     "export-wav",
     "wav2vec2-en-a19f851-v2-omissions",
+    "wav2vec2-xlsr56-2d48b01-v1",
+    "sentence-timing-v1",
     "automatic-cues-v1",
     "manual-cues-v1",
     "subtitle-files-v1",
@@ -19,9 +21,16 @@ export const localOperations = [
     "youtube-description-v1",
     "shorts-pick-v1",
     "short-render-v1",
+    "review-v1",
+    "concat-turns-v1",
+    "voice-captions-v1",
+    "audio-files-v1",
+    "level-narration-v1",
+    "figure-card-v1",
 ];
 export const deferredOperations = [
     "narration-preparation",
+    "narration-description",
     "research-synthesis",
     "article",
     "entry:intro:text",
@@ -34,14 +43,24 @@ export const deferredOperations = [
     "resolve-revision-recipe",
     "shorts",
     "animate",
+    "script-attribution",
 ];
 export function recipe(context, key, stage, input, dependsOn = [], options = {}) {
-    const requestFingerprint = input.kind === "tts"
-        ? narrationRequestFingerprint({
-            ...input,
-            wholeText: input.wholeRequest === true ? input.logicalText : null,
-        })
-        : fingerprint(JSON.parse(JSON.stringify(input, (_key, value) => typeof value === "number" ? z.number().finite().parse(value) : value)));
+    const requestFingerprint = input.kind === "tts" && input.dialogue !== undefined
+        ? // One request, several voices: every line's voice and words are what was sent.
+            fingerprint([
+                "narration-dialogue-v1",
+                input.provider,
+                input.model,
+                input.dialogue.map((line) => [line.voice, line.text]),
+                input.segment,
+            ])
+        : input.kind === "tts"
+            ? narrationRequestFingerprint({
+                ...input,
+                wholeText: input.wholeRequest === true ? input.logicalText : null,
+            })
+            : fingerprint(JSON.parse(JSON.stringify(input, (_key, value) => typeof value === "number" ? z.number().finite().parse(value) : value)));
     const token = input.kind === "tts"
         ? narrationRegenerationToken(context.content.regenerationTokens, input.logicalKey, input.segment)
         : options.token !== undefined

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

@@ -0,0 +1,7 @@
+import { pausesOf } from "../narration/pauses-model.js";
+export function pauseValues(config, next) {
+    const pauses = pausesOf(config);
+    if (pauses === undefined)
+        return [];
+    return [["pauses-v1", pauses.sentenceSeconds, pauses.paragraphSeconds, [...next]]];
+}

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

@@ -4,7 +4,7 @@ import { prepareRequests } from "../narration/steering.js";
 import { recipe, selectedReference, } from "./recipe-model.js";
 import { llmInput, renderedPrompt } from "./recipe-text.js";
 export function preparationTemplate(context) {
-    const input = llmInput(context, preparationMessages(renderedPrompt(context, "narration"), ""));
+    const input = llmInput(context, preparationMessages(renderedPrompt(context, "narration"), "", [], context.config.language));
     return [
         "inworld-tts-2",
         1,
@@ -25,9 +25,9 @@ export function preparationFuture(context, segment, dependency, additionalDepend
         ],
     }, [...new Set([dependency.key, ...additionalDependencies.map((row) => row.key)])]);
 }
-export function preparationForGroup(context, logicalKey, source, segment, dependsOn, maxCharacters, spans = []) {
+export function preparationForGroup(context, logicalKey, source, segment, dependsOn, maxCharacters, spans = [], aliases = [], speaker) {
     const preparation = recipe(context, `narration:prepare:${segment}:${logicalKey}`, "audio", {
-        ...llmInput(context, preparationMessages(renderedPrompt(context, "narration"), source)),
+        ...llmInput(context, preparationMessages(renderedPrompt(context, "narration"), source, aliases, context.config.language, speaker)),
         preparation: { format: "inworld-tts-2", version: 1, source, logicalKey, segment },
     }, dependsOn, { unresolved: source.trim() === "" });
     if (source.trim() === "")

package/dist/slices/rebuild/recipe-provider-choice.js

@@ -5,6 +5,16 @@ export function recipeProviderChoice(recipe, config) {
     // The YouTube description's request is built when it runs, from the project's LLM row.
     if (input.kind === "local" && input.operation === "youtube-description-v1")
         return config.llm === undefined ? undefined : { ...config.llm, family: "llm" };
+    // A review's request is built when it runs, from the reviewer the project chose.
+    if (input.kind === "local" && input.operation === "review-v1")
+        return config.reviews === undefined
+            ? undefined
+            : {
+                provider: config.reviews.provider,
+                model: config.reviews.model,
+                ...(config.reviews.thinking === undefined ? {} : { thinking: config.reviews.thinking }),
+                family: "llm",
+            };
     // So is the shorts' pick; what stands in for the rest of the step until it lands is
     // mostly images, which are its cost.
     if (input.kind === "local" && input.operation === "shorts-pick-v1")
@@ -22,7 +32,7 @@ export function recipeProviderChoice(recipe, config) {
             };
     if (input.kind !== "deferred")
         return undefined;
-    const family = input.operation === "narration-preparation"
+    const family = input.operation === "narration-preparation" || input.operation === "narration-description"
         ? "llm"
         : recipe.stage === "audio"
             ? "tts"

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

@@ -0,0 +1,58 @@
+import { referenceKey } from "../admission/model.js";
+import { usesReference } from "../admission/rules.js";
+import { castFor } from "./recipe-cast.js";
+import { recipe, selectedAsset, } from "./recipe-model.js";
+import { renderedPrompt } from "./recipe-text.js";
+// The establishing image (`RunDraft.reference`): one step of the Images stage, made before
+// every other image of the run and never part of the video. Made from its library prompt, whose
+// keywords are filled like every other image prompt's, or the file the user uploaded.
+export const referencePromptKey = "referencePrompt";
+// The image provider's choice as an image request carries it: the effort only when one is set,
+// so a request made without one keeps the fingerprint it always had.
+export function imageChoice(config) {
+    return {
+        provider: config.images?.provider ?? "",
+        model: config.images?.model ?? "",
+        ...(config.images?.thinking === undefined ? {} : { thinking: config.images.thinking }),
+    };
+}
+export function referenceRecipe(context) {
+    const { config, content } = context;
+    if (!usesReference(config) || config.reference === undefined)
+        return undefined;
+    if (config.reference.source === "provide")
+        return recipe(context, referenceKey, "images", {
+            kind: "provided",
+            version: 1,
+            assetId: content.provided.reference ?? null,
+            semantic: "reference",
+        }, [], { unresolved: content.provided.reference === undefined });
+    const prompt = renderedPrompt(context, referencePromptKey);
+    return recipe(context, referenceKey, "images", {
+        kind: "image",
+        version: 1,
+        ...imageChoice(config),
+        aspect: config.format,
+        prompt,
+        // The establishing image sets the look for the whole video, so it is drawn with every
+        // member the title mentions as well as the ones its own brief does.
+        ...castField(castFor(config, config.title, prompt)),
+    }, [], { unresolved: prompt.trim() === "" });
+}
+// Which image the others are drawn from: the step's fingerprint, so making it again or
+// changing it marks every image drawn from it outdated, and the asset it made.
+export function imageReference(context, reference) {
+    return reference === undefined
+        ? undefined
+        : {
+            key: reference.key,
+            input: {
+                fingerprint: reference.fingerprint,
+                assetId: selectedAsset(context, reference.key, reference.fingerprint),
+            },
+        };
+}
+// The request's `cast`, only when some member is mentioned.
+export function castField(cast) {
+    return cast === undefined ? {} : { cast };
+}

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

@@ -0,0 +1,117 @@
+import { narrationItemKey, reviewKey, reviewModeOf, reviewPromptKey, reviewRetriesOf, } from "../reviews/model.js";
+import { activeReviewStages } from "../reviews/rules.js";
+import { recipe, resourceIdentity, } from "./recipe-model.js";
+import { renderedPrompt } from "./recipe-text.js";
+// A review is a step of its own, `review:<item>`, planned like any other: it waits for the
+// item, its fingerprint follows the item's output, the reviewer and the prompt, and it is
+// kept and reused while those stay the same. What depends on a reviewed item waits for its
+// review too, so the run moves on only once the reviewer has answered - the automatic twin
+// of a review checkpoint. With every review Off nothing here is added and no step changes.
+export function withReviews(context, recipes) {
+    const settings = context.config.reviews;
+    const stages = activeReviewStages(context.config);
+    if (settings === undefined || stages.length === 0)
+        return recipes;
+    const byKey = new Map(recipes.map((row) => [row.key, row]));
+    const items = stages.flatMap((stage) => reviewedItems(stage, recipes, byKey));
+    const reviews = items.map((item) => recipe(context, reviewKey(item.itemKey), stageOf(item.stage), {
+        kind: "local",
+        version: 1,
+        operation: "review-v1",
+        values: [
+            item.stage,
+            item.itemKey,
+            item.inputs.map((input) => [input.key, resourceIdentity(context, input)]),
+            settings.provider,
+            settings.model,
+            settings.thinking ?? null,
+            // Blank means the stage's built-in prompt; the step fills it in, so a new built-in
+            // wording ships as a new operation version rather than a silent change here.
+            settings.stages[item.stage]?.prompt?.trim()
+                ? renderedPrompt(context, reviewPromptKey(item.stage))
+                : "",
+            reviewModeOf(settings, item.stage),
+            reviewRetriesOf(settings),
+        ],
+    }, item.inputs.map((input) => input.key), 
+    // A paid LLM call: readiness, the charge warning and the estimate treat it like one.
+    { kind: "provider" }));
+    const gated = recipes.map((row) => {
+        const waits = items.flatMap((item, index) => {
+            const review = reviews[index];
+            if (review === undefined || !row.dependsOn.some((key) => item.gates.includes(key)))
+                return [];
+            // A step the review itself reads (the word timing the narration review hears) must not
+            // wait for it.
+            return upstream(review, byKey).has(row.key) ? [] : [review.key];
+        });
+        return waits.length === 0 ? row : { ...row, dependsOn: [...row.dependsOn, ...waits] };
+    });
+    return [...gated, ...reviews];
+}
+function reviewedItems(stage, recipes, byKey) {
+    const one = (itemKey, inputs, gates) => ({ stage, itemKey, inputs, gates });
+    switch (stage) {
+        case "article": {
+            const article = byKey.get("article:body");
+            return article === undefined || article.kind !== "provider"
+                ? []
+                : [one(article.key, [article], [article.key])];
+        }
+        case "images": {
+            const reference = byKey.get("reference:image");
+            return recipes
+                .filter((row) => row.key.startsWith("image:") && row.input.kind === "image")
+                .map((row) => one(row.key, reference === undefined ? [row] : [row, reference], [row.key]));
+        }
+        // One thumbnail, or each of three when the project makes three to compare.
+        case "thumbnail":
+            return recipes
+                .filter((row) => /^thumbnail:image(?::\d+)?$/.test(row.key) && row.kind === "provider")
+                .map((row) => one(row.key, [row], [row.key]));
+        case "narration": {
+            const timing = byKey.get("subtitles:timing");
+            if (timing === undefined)
+                return [];
+            const article = byKey.get("article:body");
+            return [
+                one(narrationItemKey, article === undefined ? [timing] : [timing, article], [
+                    timing.key,
+                    ...timing.dependsOn,
+                ]),
+            ];
+        }
+        case "shorts":
+            return recipes.flatMap((row) => {
+                const match = /^(shorts:\d+):render$/.exec(row.key);
+                return match?.[1] === undefined ? [] : [one(match[1], [row], [row.key])];
+            });
+    }
+}
+// The Images stage runs the image reviews and the Video stage the shorts'; the others run in
+// the stage that made the item.
+function stageOf(stage) {
+    switch (stage) {
+        case "article":
+            return "article";
+        case "images":
+            return "images";
+        case "narration":
+            return "audio";
+        case "thumbnail":
+            return "thumbnail";
+        case "shorts":
+            return "video";
+    }
+}
+function upstream(review, byKey) {
+    const seen = new Set();
+    const queue = [...review.dependsOn];
+    for (let key = queue.pop(); key !== undefined; key = queue.pop()) {
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        queue.push(...(byKey.get(key)?.dependsOn ?? []));
+    }
+    return seen;
+}

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

@@ -1,6 +1,7 @@
 import { stageKinds } from "../../kernel/pipeline.js";
 import { sourceOf } from "../admission/model.js";
-import { allowedSources, edgeSilenceSecondsProblem, imageSecondsProblem, normaliseDraft, silenceGapSecondsMax, zoomPercentProblem, } from "../admission/rules.js";
+import { allowedSources, edgeSilenceSecondsProblem, imageSecondsProblem, normaliseDraft, silenceGapSecondsMax, voicesFields, zoomPercentProblem, } from "../admission/rules.js";
+import { shortModeFields } from "../admission/short-mode.js";
 import { render } from "../admission/substitute.js";
 import { effectiveClips, pickedShortsOf, rangeProblem } from "../shorts/clips.js";
 import { buildRecipes } from "./recipe-build.js";
@@ -44,6 +45,7 @@ export function planRevision(base, edit, prepared = { outputs: [], pieces: [] },
     const content = normalizeImages(normalizeArticleIntent(base, edit));
     const fields = [
         ...validateRevisionEdit(edit.config, content),
+        ...shortModeFields(edit.config),
         ...validateCues(content),
         ...validateRecipeInputs(edit.config, content),
         ...shortRangeFields(base, edit.config, content),
@@ -234,6 +236,7 @@ export function validateRevisionEdit(config, content) {
         config.subtitles !== undefined &&
         config.subtitles.mode !== "off")
         fields.push({ field: "subtitles.mode", message: "Subtitles need narration audio." });
+    fields.push(...voicesFields(config));
     return fields;
 }
 function validateCues(content) {

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

@@ -4,7 +4,10 @@ import { usesShorts } from "../admission/rules.js";
 import { effectiveClips, pickedShortsOf } from "../shorts/clips.js";
 import { defaultShortsImagePrompt, musicVolumeOf, shortImageCount, shortsSpeedOf, } from "../shorts/model.js";
 import { imagePromptMessages } from "../shorts/prompts.js";
+import { castFor } from "./recipe-cast.js";
+import { noMaster } from "./recipe-loudness.js";
 import { recipe, resourceIdentity, selectedReference, } from "./recipe-model.js";
+import { castField, imageChoice } from "./recipe-reference.js";
 import { llmInput, renderedPrompt } from "./recipe-text.js";
 // The Shorts step unfolds as its answers land, the way research's chapters unfold from the
 // plan. `shorts:pick` reads the word timing, so it waits for `subtitles:timing` and runs
@@ -19,7 +22,13 @@ import { llmInput, renderedPrompt } from "./recipe-text.js";
 // can be made again alone.
 export const shortsPickKey = "shorts:pick";
 export const shortsFutureKey = "shorts:future";
-export function shortsRecipes(context, exports) {
+export function shortsRecipes(context, exports, 
+// The establishing image the shorts' images are drawn from, when it is on.
+reference, 
+// "Show tables and figures on screen": the cards a short shows where it describes one.
+cards = [], 
+// Level the volume: the levelled narration and the master (`recipe-loudness.ts`).
+master = noMaster) {
     const { config } = context;
     const shorts = config.shorts;
     const timing = exports.find((value) => value.key === "subtitles:timing");
@@ -41,6 +50,8 @@ export function shortsRecipes(context, exports) {
             shorts.minSeconds,
             shorts.maxSeconds,
             config.title,
+            // The project language, only when it is not English, so English keeps its fingerprint.
+            ...(config.language === undefined || config.language === "en" ? [] : [config.language]),
         ],
     }, [timing.key], 
     // A paid LLM call: readiness, the charge warning and the estimate treat it like one.
@@ -67,6 +78,10 @@ export function shortsRecipes(context, exports) {
                     shorts.maxSeconds,
                     config.llm?.provider ?? "",
                     config.llm?.model ?? "",
+                    // Only what is in use, so shorts planned before these existed keep their
+                    // fingerprint; the estimate reads the fields above by position.
+                    ...(config.images?.thinking === undefined ? [] : [config.images.thinking]),
+                    ...(reference === undefined ? [] : [reference.input.fingerprint]),
                 ],
             }, [pick.key], { tokenKey: shortsPickKey }),
         ];
@@ -94,11 +109,12 @@ export function shortsRecipes(context, exports) {
         const stills = written.map((prompt, index) => recipe(context, `${prefix}:image:${String(index + 1)}`, "video", {
             kind: "image",
             version: 1,
-            provider: images.provider,
-            model: images.model,
+            ...imageChoice(config),
             prompt,
             aspect: "9:16",
-        }, [prompts.key], { token }));
+            ...(reference === undefined ? {} : { reference: reference.input }),
+            ...castField(castFor(config, prompt)),
+        }, [prompts.key, ...(reference === undefined ? [] : [reference.key])], { token }));
         recipes.push(...stills);
         const extras = renderExtras(context, clip);
         recipes.push(recipe(context, `${prefix}:render`, "video", {
@@ -118,8 +134,19 @@ export function shortsRecipes(context, exports) {
                 // Only when one of the later settings is in use, so a short rendered before
                 // they existed keeps its fingerprint.
                 ...(extras === undefined ? [] : [extras]),
+                // Only with cards, so a short rendered before them keeps its fingerprint.
+                ...(cards.length === 0
+                    ? []
+                    : [["figure-cards-v1", cards.map((card) => resourceIdentity(context, card))]]),
+                // Only while the volume is levelled, so every short without it keeps its fingerprint.
+                ...master.values,
             ],
-        }, [pick.key, ...stills.map((still) => still.key)], { token }));
+        }, [
+            pick.key,
+            ...stills.map((still) => still.key),
+            ...cards.map((card) => card.key),
+            ...master.keys,
+        ], { token }));
     }
     return recipes;
 }

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

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { withLanguage } from "../../kernel/ports/languages.js";
 import { documentIndex } from "../../kernel/ports/llm-documents.js";
 import { fingerprint } from "../../kernel/runner/work.js";
 import { usesPronunciationGlossary } from "../admission/rules.js";
@@ -7,12 +8,17 @@ import { articleMessages, continuationMessages } from "../article/continuation.j
 import { plainText } from "../article/plain.js";
 import { segmentMessages } from "../article/segments.js";
 import { splitEndMatter } from "../article/split.js";
+import { withEarlierEpisodes } from "../episodes/related.js";
 import { parsePronunciationGlossary } from "../narration/pronunciation.js";
 import { withSharedGlossary } from "../narration/shared-glossary.js";
 import { researchDocuments } from "../research/documents.js";
 import { plannerMessages, subAgentMessages } from "../research/planner.js";
 import { synthesisMessages } from "../research/synthesis.js";
 import { thumbnailMessages } from "../thumbnail/by-llm.js";
+import { attributionMessages } from "../voices/attribution.js";
+import { usesVoices } from "../voices/model.js";
+import { scriptMessages } from "../voices/script.js";
+import { describedText, describeFuture, describing } from "./recipe-describe.js";
 import { recipe, selectedReference, } from "./recipe-model.js";
 export function renderedPrompt(context, key) {
     const raw = context.content.promptTemplates[key];
@@ -41,7 +47,12 @@ export function llmInput(context, messages, webSearch = false, documents) {
 export function selectedText(context, key, field) {
     const piece = context.manifest.pieces.find((row) => row.key === key &&
         selectedReference(row) &&
-        row.stageKind === (key.startsWith("entry:") ? "article" : "thumbnail") &&
+        row.stageKind ===
+            (key.startsWith("entry:") || key.startsWith("script:")
+                ? "article"
+                : key.startsWith("narration:describe:")
+                    ? "audio"
+                    : "thumbnail") &&
         row.piece.state === "done");
     if (piece?.piece.payload === null || piece === undefined)
         return null;
@@ -81,9 +92,7 @@ export function textRecipes(context) {
         });
         recipes.push(research);
     }
-    const articleMarkdown = config.sources.article === "provide" || content.articleEdited === true
-        ? (content.articleMarkdown ?? config.provided.article ?? "")
-        : resolved.articleMarkdown;
+    const articleMarkdown = articleMarkdownOf(context);
     const notes = config.sources.research === "off"
         ? null
         : config.sources.research === "provide"
@@ -95,10 +104,26 @@ export function textRecipes(context) {
             { id: "editorial-notes", title: "Editorial notes", content: notes },
         ]
         : [];
-    const messages = articleMessages({
-        articlePrompt: brief.articlePrompt,
-        ...(documents.length ? { notes: documentIndex(documents) } : notes === null ? {} : { notes }),
-    });
+    const voices = usesVoices(config) ? config.voices : undefined;
+    const writesScript = voices?.source === "script";
+    const articleNotes = documents.length ? documentIndex(documents) : (notes ?? undefined);
+    // A script run writes speaker turns in place of the article, from the same prompt and notes.
+    // The related earlier episodes go under the prompt only when the run carries them, so a
+    // project made without them keeps its fingerprint. Either is written in the project's
+    // language (`withLanguage`; English adds nothing).
+    const writtenPrompt = withEarlierEpisodes(brief.articlePrompt, config.earlierEpisodes);
+    const messages = withLanguage(voices !== undefined && writesScript
+        ? scriptMessages(voices.format, voices.speakers, writtenPrompt, articleNotes)
+        : articleMessages({
+            articlePrompt: writtenPrompt,
+            ...(articleNotes === undefined ? {} : { notes: articleNotes }),
+        }), config.language);
+    const scriptCheck = voices === undefined
+        ? undefined
+        : {
+            speakers: voices.speakers.map((speaker) => ({ id: speaker.id, name: speaker.name })),
+            attribute: !writesScript,
+        };
     const article = config.sources.article === "provide" || content.articleEdited === true
         ? recipe(context, "article:body", "article", {
             kind: "local",
@@ -113,7 +138,10 @@ export function textRecipes(context) {
                 operation: "article",
                 template: [llmInputFingerprint(context, messages), research?.fingerprint ?? null],
             }
-            : llmInput(context, messages, false, documents), research === undefined ? [] : [research.key]);
+            : {
+                ...llmInput(context, messages, false, documents),
+                ...(writesScript && scriptCheck !== undefined ? { script: scriptCheck } : {}),
+            }, research === undefined ? [] : [research.key]);
     recipes.push(article);
     if (resolved.articleContinuation !== undefined &&
         config.sources.article === "generate" &&
@@ -121,11 +149,50 @@ export function textRecipes(context) {
         recipes.push(recipe(context, "article:continuation", "article", llmInput(context, continuationMessages(messages, resolved.articleContinuation), false, documents), [article.key]));
     const endMatter = articleMarkdown === null ? null : splitEndMatter(articleMarkdown);
     const articleText = endMatter === null ? null : plainText(endMatter.body);
-    const glossary = !usesPronunciationGlossary(config)
-        ? { ok: true, entries: [] }
-        : endMatter === null
-            ? null
-            : withShared(parsePronunciationGlossary(endMatter.glossary), config);
+    let script;
+    if (voices !== undefined && scriptCheck !== undefined) {
+        if (writesScript)
+            script = { text: endMatter?.body ?? null, dependsOn: [article.key] };
+        else {
+            // An audiobook from a text: the text model hands the article's passages to speakers.
+            const attribute = recipe(context, "script:attribute", "article", endMatter === null
+                ? {
+                    kind: "deferred",
+                    version: 1,
+                    operation: "script-attribution",
+                    template: [
+                        article.fingerprint,
+                        llmInputFingerprint(context, withLanguage(attributionMessages("", voices.speakers), config.language)),
+                    ],
+                }
+                : {
+                    ...llmInput(context, withLanguage(attributionMessages(endMatter.body, voices.speakers), config.language)),
+                    script: scriptCheck,
+                }, [article.key]);
+            recipes.push(attribute);
+            script = {
+                text: endMatter === null ? null : matchingText(context, attribute, "text"),
+                dependsOn: [attribute.key],
+                fingerprint: attribute.fingerprint,
+            };
+        }
+    }
+    let narrationText = articleText;
+    const descriptions = [];
+    const cards = [];
+    if (describing(context) && voices === undefined) {
+        if (endMatter === null) {
+            descriptions.push(describeFuture(context, article));
+            narrationText = null;
+        }
+        else {
+            const described = describedText(context, endMatter.body, [article.key]);
+            descriptions.push(...described.recipes);
+            cards.push(...described.cards);
+            narrationText = described.spoken;
+        }
+    }
+    const glossary = glossaryOf(context, endMatter);
     const entries = {};
     for (const category of ["intro", "outro"]) {
         const choice = config[category];
@@ -141,11 +208,11 @@ export function textRecipes(context) {
                     version: 1,
                     operation: key,
                     template: [
-                        llmInputFingerprint(context, segmentMessages(prompt, config, "")),
+                        llmInputFingerprint(context, withLanguage(segmentMessages(prompt, config, ""), config.language)),
                         article.fingerprint,
                     ],
                 }
-                : llmInput(context, segmentMessages(prompt, config, articleText));
+                : llmInput(context, withLanguage(segmentMessages(prompt, config, articleText), config.language));
         const value = recipe(context, key, "article", input, choice.mode === "llm" ? [article.key] : []);
         recipes.push(value);
         entries[category] = {
@@ -171,7 +238,17 @@ export function textRecipes(context) {
             }
             : llmInput(context, messages), [article.key]));
     }
-    return { recipes, articleText, glossary, article, entries };
+    return {
+        recipes,
+        articleText,
+        narrationText,
+        descriptions,
+        cards,
+        glossary,
+        article,
+        entries,
+        ...(script === undefined ? {} : { script }),
+    };
 }
 function llmInputFingerprint(context, messages) {
     return fingerprint(JSON.parse(JSON.stringify(llmInput(context, messages))));
@@ -186,10 +263,28 @@ export function matchingText(context, value, field) {
         return null;
     return selectedText(context, value.key, field);
 }
+function articleMarkdownOf(context) {
+    const { config, content, resolved } = context;
+    return config.sources.article === "provide" || content.articleEdited === true
+        ? (content.articleMarkdown ?? config.provided.article ?? "")
+        : resolved.articleMarkdown;
+}
+function glossaryOf(context, endMatter) {
+    if (!usesPronunciationGlossary(context.config))
+        return { ok: true, entries: [] };
+    if (endMatter === null)
+        return null;
+    return withShared(parsePronunciationGlossary(endMatter.glossary, context.config.language), context.config);
+}
+// The narration glossary this revision uses, or null while its article is still unwritten.
+export function narrationGlossary(context) {
+    const markdown = articleMarkdownOf(context);
+    return glossaryOf(context, markdown === null ? null : splitEndMatter(markdown));
+}
 // The project's own glossary, then the other projects' pronunciations it copied, when it
-// shares them. An own glossary that doesn't parse still refuses, as before.
+// shares them. Rows the own glossary had to skip are still reported.
 function withShared(own, config) {
     if (!own.ok || config.audio?.shareGlossary !== true)
         return own;
-    return { ok: true, entries: withSharedGlossary(own.entries, config.sharedGlossary) };
+    return { ...own, entries: withSharedGlossary(own.entries, config.sharedGlossary) };
 }