@gentbajko/slopify 1.2.0 → 1.3.1

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

@@ -1,8 +1,12 @@
 import { fingerprint } from "../../kernel/runner/work.js";
+import { usesNarrationPreparation } from "../admission/rules.js";
 import { chunkNarration, defaultChunking } from "../narration/chunk.js";
 import { concatArgs } from "../narration/concat.js";
-import { narrationRegenerationToken, normalizeNarrationText, planNarration, } from "../narration/plan.js";
+import { normalizeNarrationText } from "../narration/plan.js";
+import { narrationParts, voiceValues } from "./recipe-audio-parts.js";
 import { recipe, resourceIdentity, selectedReference, } from "./recipe-model.js";
+import { narrationFileRecipe } from "./recipe-narration-text.js";
+import { preparationFuture, preparationTemplate } from "./recipe-preparation.js";
 export function audioRecipes(context, text) {
     const { config, content } = context;
     const recipes = [];
@@ -24,21 +28,37 @@ export function audioRecipes(context, text) {
             : chunkNarration(normalizeNarrationText(text.articleText), config.chunking ?? defaultChunking);
         const occurrences = new Map();
         const parts = [];
+        let pending = text.articleText === null;
         for (const logicalText of groups) {
             const hash = fingerprint(logicalText).slice(0, 20);
             const occurrence = (occurrences.get(hash) ?? 0) + 1;
             occurrences.set(hash, occurrence);
             const logicalKey = `audio:body:${hash}-${occurrence}`;
-            parts.push(...narrationParts(context, logicalKey, logicalText, "body", [text.article.key]));
+            const group = narrationParts(context, logicalKey, logicalText, "body", [text.article.key], recipes);
+            if (group.length === 0)
+                pending = true;
+            parts.push(...group);
         }
-        if (text.articleText === null)
+        if (text.articleText === null && usesNarrationPreparation(config))
+            recipes.push(preparationFuture(context, "body", text.article));
+        // Physical ordinals are stable only after every logical group's cue plan is known.
+        if (pending && usesNarrationPreparation(config))
+            parts.length = 0;
+        if (pending)
             parts.push(recipe(context, "audio:body:future", "audio", {
                 kind: "deferred",
                 version: 1,
                 operation: "body-narration",
-                template: [text.article.fingerprint, voiceValues(context), chunkingValues(context)],
-            }, [text.article.key]));
+                template: [
+                    text.article.fingerprint,
+                    voiceValues(context),
+                    chunkingValues(context),
+                    ...(usesNarrationPreparation(config) ? [preparationTemplate(context)] : []),
+                ],
+            }, [text.article.key, ...preparationKeys(recipes, "body")]));
         recipes.push(...parts);
+        if (usesNarrationPreparation(config))
+            recipes.push(narrationFileRecipe(context, "body", parts));
         body = recipe(context, "audio:body:concat", "audio", {
             kind: "local",
             version: 1,
@@ -59,16 +79,33 @@ export function audioRecipes(context, text) {
         const entry = text.entries[category];
         if (entry === undefined)
             continue;
+        if (entry.text === null && usesNarrationPreparation(config))
+            recipes.push(preparationFuture(context, category, entry.recipe));
         const parts = entry.text === null
             ? [
                 recipe(context, `audio:${category}:future`, "audio", {
                     kind: "deferred",
                     version: 1,
                     operation: `${category}-narration`,
-                    template: [entry.recipe.fingerprint, voiceValues(context)],
-                }, [entry.recipe.key]),
+                    template: [
+                        entry.recipe.fingerprint,
+                        voiceValues(context),
+                        ...(usesNarrationPreparation(config) ? [preparationTemplate(context)] : []),
+                    ],
+                }, [entry.recipe.key, ...preparationKeys(recipes, category)]),
             ]
-            : narrationParts(context, `audio:${category}`, entry.text, category, [entry.recipe.key]);
+            : narrationParts(context, `audio:${category}`, entry.text, category, [entry.recipe.key], recipes);
+        if (parts.length === 0 && usesNarrationPreparation(config))
+            parts.push(recipe(context, `audio:${category}:future`, "audio", {
+                kind: "deferred",
+                version: 1,
+                operation: `${category}-narration`,
+                template: [
+                    entry.recipe.fingerprint,
+                    voiceValues(context),
+                    preparationTemplate(context),
+                ],
+            }, [entry.recipe.key, ...preparationKeys(recipes, category)]));
         recipes.push(...parts);
         const audio = recipe(context, `audio:${category}`, "audio", {
             kind: "local",
@@ -80,6 +117,8 @@ export function audioRecipes(context, text) {
             ],
         }, parts.map((part) => part.key));
         recipes.push(audio);
+        if (usesNarrationPreparation(config))
+            recipes.push(narrationFileRecipe(context, category, parts));
         ordered.push({ value: audio, transcript: entry.text ?? entry.recipe.fingerprint });
     }
     const timeline = ordered.map(({ value, transcript }) => {
@@ -101,64 +140,6 @@ export function audioRecipes(context, text) {
         keys: ordered.map(({ value }) => value.key),
     };
 }
-function narrationParts(context, logicalKey, originalText, segment, dependsOn) {
-    const override = context.content.narrationOverrides[logicalKey];
-    if (override?.kind === "asset")
-        return [
-            recipe(context, `${logicalKey}:1`, "audio", {
-                kind: "provided",
-                version: 1,
-                assetId: override.assetId,
-                semantic: [normalizeNarrationText(originalText), voiceValues(context)],
-            }, dependsOn, { tokenKey: logicalKey }),
-        ];
-    const logicalText = normalizeNarrationText(override?.kind === "text" ? override.text : originalText);
-    const wholeRequest = segment !== "body" || (context.config.chunking?.mode ?? "whole") === "whole";
-    const choice = context.config.audio;
-    const model = context.catalogue?.tts.find((row) => row.provider === choice?.provider &&
-        row.id === choice.model &&
-        row.enabled &&
-        !row.deprecated);
-    const requests = planNarration({
-        groups: [
-            {
-                key: logicalKey,
-                text: logicalText,
-                segment,
-                wholeRequest,
-                regenerationToken: narrationRegenerationToken(context.content.regenerationTokens, logicalKey, segment),
-            },
-        ],
-        provider: choice?.provider ?? "",
-        model: choice?.model ?? "",
-        voice: choice?.voice ?? "",
-        maxCharacters: context.catalogue === undefined
-            ? Math.max(2, logicalText.length)
-            : (model?.tts.maxCharacters ?? Math.max(2, logicalText.length)),
-        retained: [],
-    });
-    return requests.map(({ text, key }) => recipe(context, key, "audio", {
-        kind: "tts",
-        version: 1,
-        provider: choice?.provider ?? "",
-        model: choice?.model ?? "",
-        voice: choice?.voice ?? "",
-        text,
-        logicalKey,
-        logicalText,
-        segment,
-        pronunciation: null,
-        wholeRequest,
-    }, dependsOn, { tokenKey: logicalKey, unresolved: logicalText.length === 0 }));
-}
-function voiceValues(context) {
-    return [
-        context.config.audio?.provider ?? null,
-        context.config.audio?.model ?? null,
-        context.config.audio?.voice ?? null,
-        null,
-    ];
-}
 function chunkingValues(context) {
     const chunking = context.config.chunking ?? defaultChunking;
     return [
@@ -170,3 +151,8 @@ function chunkingValues(context) {
                 : null,
     ];
 }
+function preparationKeys(recipes, segment) {
+    return recipes
+        .filter((row) => row.key.startsWith(`narration:prepare:${segment}:`))
+        .map((row) => row.key);
+}

package/dist/slices/rebuild/recipe-input-schema.js

@@ -28,6 +28,16 @@ export const recipeInputSchema = z.discriminatedUnion("kind", [
             .nullable(),
         messages: z.array(z.object({ role: z.enum(messageRoles), content: z.string() }).strict()),
         webSearch: z.boolean(),
+        preparation: z
+            .object({
+            format: z.literal("inworld-tts-2"),
+            version,
+            source: z.string(),
+            logicalKey: z.string(),
+            segment: z.enum(["body", "intro", "outro"]),
+        })
+            .strict()
+            .optional(),
     })
         .strict(),
     z
@@ -38,6 +48,7 @@ export const recipeInputSchema = z.discriminatedUnion("kind", [
         model: z.string(),
         voice: z.string(),
         text: z.string(),
+        spokenText: z.string().optional(),
         logicalKey: z.string(),
         logicalText: z.string(),
         segment: z.enum(["body", "intro", "outro"]),

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

@@ -24,6 +24,8 @@ export function baselineFingerprints(project, outputs, pieces, content, stages =
     return fingerprints;
 }
 export function legacyOutputSlot(output) {
+    if (output.role === "narration_txt" || output.role === "tts_script")
+        return `narration:files:${output.meta.segment ?? "body"}:${output.role}`;
     return output.role === "image" ? `image:${output.id}` : `${output.stageKind}:${output.role}`;
 }
 export function legacyOutputWorkKey(output, config) {
@@ -39,6 +41,9 @@ export function legacyOutputWorkKey(output, config) {
         case "sources":
         case "glossary":
             return "article:body";
+        case "narration_txt":
+        case "tts_script":
+            return `narration:files:${output.meta.segment ?? "body"}`;
         case "audio_body":
             return config?.sources.audio === "provide" ? "audio:provided" : "audio:body:concat";
         case "audio_intro":

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

@@ -14,8 +14,10 @@ export const localOperations = [
     "manual-article",
     "entry-text",
     "concat-narration",
+    "narration-files-v1",
 ];
 export const deferredOperations = [
+    "narration-preparation",
     "research-synthesis",
     "article",
     "entry:intro:text",
@@ -57,6 +59,7 @@ export function recipe(context, key, stage, input, dependsOn = [], options = {})
         dependsOn,
         unresolved: options.unresolved ?? false,
         deferred: input.kind === "deferred",
+        ...(options.refusal === undefined ? {} : { refusal: options.refusal }),
     };
 }
 export function selectedAsset(context, key, desired) {

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

@@ -0,0 +1,33 @@
+import { recipe, resourceIdentity, } from "./recipe-model.js";
+export function narrationFileRecipe(context, segment, parts) {
+    const key = `narration:files:${segment}`;
+    const identities = parts.map((part) => resourceIdentity(context, part));
+    const dependencies = parts.map((part) => part.key);
+    if (parts.some((part) => part.deferred || part.unresolved))
+        return recipe(context, key, "audio", {
+            kind: "deferred",
+            version: 1,
+            operation: "resolve-revision-recipe",
+            template: [segment, identities],
+        }, dependencies);
+    return recipe(context, key, "audio", {
+        kind: "local",
+        version: 1,
+        operation: "narration-files-v1",
+        values: {
+            segment,
+            version: 1,
+            parts: parts.map((part) => {
+                if (part.input.kind === "tts")
+                    return [
+                        resourceIdentity(context, part),
+                        part.input.spokenText ?? part.input.text,
+                        part.input.text,
+                    ];
+                if (part.input.kind === "provided")
+                    return [resourceIdentity(context, part), part.input.semantic, null];
+                throw new Error("Narration files require exact audio parts.");
+            }),
+        },
+    }, dependencies, { unresolved: parts.length === 0 });
+}

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

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { preparationMessages, validatePreparation, } from "../narration/preparation.js";
+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"), ""));
+    return [
+        "inworld-tts-2",
+        1,
+        JSON.parse(JSON.stringify({ ...input, thinkingConfig: null })),
+        JSON.parse(JSON.stringify(context.content.narrationOverrides)),
+    ];
+}
+export function preparationFuture(context, segment, dependency) {
+    return recipe(context, `narration:prepare:${segment}:future`, "audio", {
+        kind: "deferred",
+        version: 1,
+        operation: "narration-preparation",
+        template: [
+            dependency.fingerprint,
+            preparationTemplate(context),
+            JSON.parse(JSON.stringify(context.config.chunking ?? null)),
+        ],
+    }, [dependency.key]);
+}
+export function preparationForGroup(context, logicalKey, source, segment, dependsOn, maxCharacters) {
+    const preparation = recipe(context, `narration:prepare:${segment}:${logicalKey}`, "audio", {
+        ...llmInput(context, preparationMessages(renderedPrompt(context, "narration"), source)),
+        preparation: { format: "inworld-tts-2", version: 1, source, logicalKey, segment },
+    }, dependsOn, { unresolved: source.trim() === "" });
+    if (source.trim() === "")
+        return {
+            preparation,
+            requests: null,
+            refusal: "Narration Preparation needs non-empty narration text.",
+        };
+    const logical = recipe(context, preparation.key, "audio", preparation.input.kind === "llm"
+        ? { ...preparation.input, thinkingConfig: null }
+        : preparation.input, dependsOn).fingerprint;
+    const saved = context.manifest.pieces.find((row) => row.key === preparation.key &&
+        row.stageKind === "audio" &&
+        selectedReference(row) &&
+        (!("available" in row) || row.available) &&
+        row.piece.state === "done" &&
+        (row.fingerprint === preparation.fingerprint ||
+            (context.catalogue === undefined &&
+                z
+                    .object({ logicalFingerprint: z.literal(logical) })
+                    .safeParse(JSON.parse(row.piece.payload ?? "null")).success)));
+    if (saved?.piece.payload === undefined || saved.piece.payload === null)
+        return { preparation, requests: null, refusal: null };
+    const payload = z.object({ text: z.string() }).safeParse(JSON.parse(saved.piece.payload));
+    if (!payload.success)
+        return { preparation, requests: null, refusal: "Saved narration preparation is incomplete." };
+    const validated = validatePreparation(payload.data.text, source);
+    if (!validated.ok)
+        return { preparation, requests: null, refusal: validated.reason };
+    const prepared = prepareRequests(source, validated.cues, context.catalogue === undefined
+        ? Math.max(2, source.length +
+            validated.cues.reduce((n, cue) => n + (cue.kind === "instruction" ? cue.text.length : 20) + 3, 0))
+        : maxCharacters);
+    return prepared.ok
+        ? { preparation, requests: prepared.requests, refusal: null }
+        : { preparation, requests: null, refusal: prepared.reason };
+}

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

@@ -4,11 +4,13 @@ export function recipeProviderChoice(recipe, config) {
         return { ...input, family: input.kind };
     if (input.kind !== "deferred")
         return undefined;
-    const family = recipe.stage === "audio"
-        ? "tts"
-        : recipe.stage === "images" || input.operation === "thumbnail-image"
-            ? "image"
-            : "llm";
+    const family = input.operation === "narration-preparation"
+        ? "llm"
+        : recipe.stage === "audio"
+            ? "tts"
+            : recipe.stage === "images" || input.operation === "thumbnail-image"
+                ? "image"
+                : "llm";
     const choice = family === "tts" ? config.audio : family === "image" ? config.images : config.llm;
     return choice === undefined ? undefined : { ...choice, family };
 }

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

@@ -1,9 +1,11 @@
+import { narrationPreparationFields, usesNarrationPreparation, } from "../admission/rules.js";
 import { detectSlots, render } from "../admission/substitute.js";
 export function validateRecipeInputs(config, content) {
-    const fields = [];
+    const fields = [...narrationPreparationFields(config)];
     const llm = (config.sources.research === "generate" && config.sources.article !== "provide") ||
         (config.sources.article === "generate" && !content.articleEdited) ||
         config.sources.thumbnail === "prompt_by_llm" ||
+        usesNarrationPreparation(config) ||
         (config.sources.audio === "generate" &&
             (config.intro?.mode === "llm" || config.outro?.mode === "llm"));
     if (llm && (!config.llm?.provider.trim() || !config.llm.model.trim()))
@@ -35,6 +37,12 @@ export function validateRecipeInputs(config, content) {
             message: "Use a whole number from 1 to 1,000,000.",
         });
     const prompts = [];
+    if (usesNarrationPreparation(config))
+        prompts.push({
+            field: "rendered.narration",
+            raw: content.promptTemplates.narration ?? null,
+            literal: config.rendered.narration,
+        });
     if ((config.sources.article === "generate" && !content.articleEdited) ||
         (config.sources.research === "generate" && config.sources.article !== "provide"))
         prompts.push({

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

@@ -47,7 +47,13 @@ export function planRevisionWork(revision, manifest, catalogue, availableAssetId
             disposition: "review",
             reason: "Narration or transcript changed. Review the saved manual cues before reusing them.",
         }
-        : row);
+        : recipes.find((recipe) => recipe.key === row.key)?.refusal !== undefined
+            ? {
+                ...row,
+                disposition: "blocked",
+                reason: recipes.find((recipe) => recipe.key === row.key)?.refusal ?? row.reason,
+            }
+            : row);
     const changedInputs = work
         .filter((row) => row.disposition !== "reuse")
         .map((row) => ({
@@ -181,6 +187,12 @@ export function priceRecipe(work, value) {
                 : "Local, provided, or blocked work; no admitted generation charge.",
         };
     const input = value.input;
+    if (input.kind === "deferred" && input.operation === "narration-preparation")
+        return {
+            kind: "unknown",
+            stage: work.key,
+            detail: "Narration Preparation: one LLM call per future logical chunk or entry; source length is not yet known.",
+        };
     if (input.kind === "llm")
         return {
             kind: "llm",

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

@@ -4,6 +4,17 @@ import { currentRevisionId } from "../revisions/repo.js";
 import { bindNarrationReuse, narrationOrdinal } from "./runtime-narration-reuse.js";
 import { executionCatalogue, executionPlan } from "./runtime-plan.js";
 import { insertWorkPiece } from "./work-records.js";
+export function reservationKey(recipe, view) {
+    const key = recipe.input.kind === "tts" ? `${recipe.input.logicalKey}:1` : recipe.key;
+    if (view.revision.fingerprints[key] !== undefined)
+        return key;
+    const future = recipe.input.kind === "tts"
+        ? `audio:${recipe.input.segment}:future`
+        : recipe.input.kind === "llm" && recipe.input.preparation
+            ? `narration:prepare:${recipe.input.preparation.segment}:future`
+            : key;
+    return view.revision.fingerprints[future] === undefined ? key : future;
+}
 export function admitInitialRevision(deps, view, catalogue) {
     transact(deps.db, () => {
         if (currentRevisionId(deps.db, view.revision.projectId) !== view.revision.id)

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

@@ -1,10 +1,12 @@
 import { readFileSync } from "node:fs";
 import { z } from "zod";
+import { usesNarrationPreparation } from "../admission/rules.js";
 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 { joinedNarration, narrationTextParts } from "./runtime-narration-text.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);
@@ -51,6 +53,8 @@ export async function revisionAudio(deps, context, view) {
 }
 export function revisionTranscript(deps, snapshot, kind) {
     const { view, plan } = snapshot;
+    if (usesNarrationPreparation(view.revision.config))
+        return joinedNarration(narrationTextParts(view, plan, kind));
     const concat = plan.recipes.find((one) => one.key === (kind === "body" ? "audio:body:concat" : `audio:${kind}`));
     if (concat !== undefined) {
         const texts = concat.dependsOn.map((key) => {

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

@@ -6,6 +6,7 @@ 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 { publishNarrationText } from "./runtime-narration-text.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) {
@@ -43,6 +44,10 @@ export async function executeLocalRecipe(deps, context, piece) {
     }
     if (input.kind !== "local")
         throw new Error("Expected an exact local recipe.");
+    if (input.operation === "narration-files-v1") {
+        await publishNarrationText(deps, context, piece);
+        return "done";
+    }
     if (input.operation === "concat-narration") {
         await concatenate(deps, context, piece);
         return "done";

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

@@ -95,6 +95,8 @@ function desiredAnchor(deps, projectId, head, row) {
         (row.desired_fingerprint ?? row.fingerprint));
 }
 function futureKey(recipe) {
+    if (recipe.input.kind === "llm" && recipe.input.preparation !== undefined)
+        return `narration:prepare:${recipe.input.preparation.segment}:future`;
     if (recipe.input.kind === "tts")
         return `audio:${recipe.input.segment}:future`;
     if (recipe.key.startsWith("research:chapter:"))

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

@@ -112,6 +112,7 @@ export function bindNarrationReuse(deps, view, recipe, ordinal) {
             payload: JSON.stringify({
                 ...(typeof payload === "object" && payload !== null ? payload : {}),
                 text: input.text,
+                spokenText: input.spokenText,
                 logicalKey: input.logicalKey,
                 logicalText: input.logicalText,
                 segment: input.segment,

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

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { preparedTexts, publishResult } from "./runtime-publication.js";
+export function joinedNarration(parts) {
+    return parts
+        .map((part, index) => `${index > 0 && parts[index - 1]?.logicalKey !== part.logicalKey ? "\n" : ""}${part.spokenText}`)
+        .join("");
+}
+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(`The saved ${segment} narration is missing.`);
+    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);
+        if (selected === undefined || recipe === undefined)
+            throw new Error("The saved narration transcript is incomplete.");
+        const input = recipe.input;
+        if (input.kind === "provided" &&
+            Array.isArray(input.semantic) &&
+            typeof input.semantic[0] === "string")
+            return {
+                logicalKey: key.slice(0, key.lastIndexOf(":")),
+                spokenText: input.semantic[0],
+                requestText: null,
+            };
+        if (input.kind !== "tts")
+            throw new Error("The narration source has not resolved.");
+        const payload = z
+            .object({ text: z.string().optional(), spokenText: z.string().optional() })
+            .parse(JSON.parse(selected.piece.payload ?? "{}"));
+        if (input.spokenText !== undefined &&
+            (payload.spokenText !== input.spokenText || payload.text !== input.text))
+            throw new Error("Prepared narration is missing its exact clean transcript.");
+        return {
+            logicalKey: input.logicalKey,
+            spokenText: input.spokenText === undefined ? (payload.text ?? input.text) : (payload.spokenText ?? ""),
+            requestText: input.text,
+        };
+    });
+}
+export async function publishNarrationText(deps, context, piece) {
+    if (piece.input.kind !== "local")
+        throw new Error("Expected a narration-file recipe.");
+    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("The pinned narration revision is missing.");
+    const plan = executionPlan(deps, view, savedCatalogue(row?.recipe_context));
+    if (!plan.recipes.some((recipe) => recipe.key === piece.key && recipe.fingerprint === piece.fingerprint))
+        throw new Error("Narration text no longer matches the admitted inputs.");
+    const parts = narrationTextParts(view, plan, segment);
+    const outputs = preparedTexts(deps, context, piece, [
+        ["narration_txt", `${segment}-narration.txt`, joinedNarration(parts)],
+        [
+            "tts_script",
+            `${segment}-tts-script.txt`,
+            parts.flatMap((part) => (part.requestText === null ? [] : [part.requestText])).join("\n\n"),
+        ],
+    ]).map((output) => ({
+        ...output,
+        slot: `${piece.key}:${output.output.role}`,
+        output: { ...output.output, meta: { ...output.output.meta, segment } },
+    }));
+    await publishResult(deps, context, piece, outputs, { segment });
+}

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

@@ -1,6 +1,8 @@
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
 import { observeNarration } from "../narration/live.js";
+import { validatePreparation } from "../narration/preparation.js";
+import { prepareRequests } from "../narration/steering.js";
 import { chaptersFrom } from "../research/planner.js";
 import { sourcedAnswer } from "../research/synthesis.js";
 import { discardPreparedAssets, writeAsset } from "../storage/assets.js";
@@ -28,7 +30,7 @@ export async function executeProviderRecipe(deps, context, providers, piece) {
                 messages: input.messages,
                 webSearch: input.webSearch,
                 previewLabel: piece.key,
-                check: (value) => checkAnswer(piece, value),
+                check: (value) => checkAnswer(piece, value) ?? checkPreparation(deps, context, piece, value),
             });
         if (!answer.ok)
             return "held";
@@ -63,6 +65,7 @@ export async function executeProviderRecipe(deps, context, providers, piece) {
                         : await probeDurationMs(deps.ffmpeg, outputPath(deps.paths, context.work.projectId, asset.path), context.signal, deps.log);
             await publishResult(deps, context, piece, [], {
                 text: input.text,
+                ...(input.spokenText === undefined ? {} : { spokenText: input.spokenText }),
                 logicalKey: input.logicalKey,
                 logicalText: input.logicalText,
                 segment: input.segment,
@@ -125,6 +128,18 @@ function checkAnswer(piece, answer) {
     return undefined;
 }
 async function publishText(deps, context, piece, answer) {
+    if (piece.input.kind === "llm" && piece.input.preparation !== undefined) {
+        const checked = validatePreparation(answer.text, piece.input.preparation.source);
+        if (!checked.ok)
+            throw new Error(checked.reason);
+        await publishResult(deps, context, piece, [], {
+            text: answer.text,
+            preparation: piece.input.preparation,
+            cues: checked.cues,
+            logicalFingerprint: piece.logicalFingerprint ?? piece.fingerprint,
+        });
+        return;
+    }
     if (piece.key === "article:body") {
         const parts = splitEndMatter(answer.text);
         await publishResult(deps, context, piece, preparedTexts(deps, context, piece, [
@@ -182,3 +197,17 @@ function narrationLabel(deps, context, piece) {
     const index = parts.findIndex((recipe) => recipe.key === piece.key);
     return parts.length > 1 && index >= 0 ? `${name} part ${index + 1} of ${parts.length}` : name;
 }
+function checkPreparation(deps, context, piece, answer) {
+    if (piece.input.kind !== "llm" || piece.input.preparation === undefined)
+        return undefined;
+    const source = piece.input.preparation.source;
+    const checked = validatePreparation(answer.text, source);
+    if (!checked.ok)
+        return checked.reason;
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(context.work.workId);
+    const model = savedCatalogue(row?.recipe_context).tts.find((model) => model.provider === "inworld" && model.id === "inworld-tts-2");
+    const prepared = prepareRequests(source, checked.cues, model?.tts.maxCharacters ?? 4000);
+    return prepared.ok ? undefined : prepared.reason;
+}