@gentbajko/slopify 2.5.0 → 3.0.0

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

@@ -0,0 +1,286 @@
+import { aliasMatches, applyAliases } from "../../kernel/ports/narration-aliases.js";
+import { splitText } from "../../kernel/ports/text.js";
+import { narrationAliasesOf, usesNarrationPreparation } from "../admission/rules.js";
+import { aliasSpans, withAliasSpans } from "../narration/aliases.js";
+import { normalizeNarrationText } from "../narration/plan.js";
+import { parsePronunciationGlossary, pronunciationSpans, } from "../narration/pronunciation.js";
+import { withSharedGlossary } from "../narration/shared-glossary.js";
+import { prepareRequests } from "../narration/steering.js";
+import { groupTurns } from "../voices/grouping.js";
+import { speakerPace } from "../voices/model.js";
+import { parseScript } from "../voices/script.js";
+import { describedText, describeFuture, describing } from "./recipe-describe.js";
+import { recipe, resourceIdentity, } from "./recipe-model.js";
+import { pauseValues } from "./recipe-pauses.js";
+import { preparationForGroup, preparationFuture, preparationTemplate, } from "./recipe-preparation.js";
+export function voiceBodyRecipes(context, voices, script, glossary) {
+    const parts = [];
+    const preparations = [];
+    const layout = [];
+    // Which parts end a turn, for the pauses between sentences (a turn gap of 0 is still a turn).
+    const turnEnds = new Set();
+    let transcript = script.fingerprint ?? script.text ?? null;
+    const describe = describing(context);
+    const parsed = script.text === null ? undefined : parseScript(script.text, voices.speakers, describe);
+    const prepare = voices.speakers.some((speaker) => preparesTurns(context.config, speaker));
+    // The narration still to be worked out: the whole script's while it is being written, or
+    // every turn's while a turn's delivery cues are (as a single voice waits for all of its own).
+    const future = () => recipe(context, "audio:body:future", "audio", {
+        kind: "deferred",
+        version: 1,
+        operation: "body-narration",
+        template: [
+            script.fingerprint ?? script.text ?? null,
+            speakerValues(voices),
+            ...(prepare ? [preparationTemplate(context)] : []),
+            ...(described.length === 0
+                ? []
+                : [["described-v1", described.map((row) => row.fingerprint)]]),
+        ],
+    }, [
+        ...new Set([
+            ...script.dependsOn,
+            ...described.map((row) => row.key),
+            ...preparations.map((row) => row.key),
+        ]),
+    ]);
+    let pending = false;
+    // A table, figure, equation or code block inside a turn is described within that turn: the
+    // turn says the description where the block was, in the same voice.
+    const described = [];
+    const cards = [];
+    let turns = parsed?.ok === true ? parsed.script.turns : [];
+    if (describe && script.text === null) {
+        const from = script.dependsOn[0];
+        if (from !== undefined)
+            described.push(describeFuture(context, { key: from, fingerprint: script.fingerprint ?? from }));
+    }
+    else if (describe && parsed?.ok === true) {
+        let offset = 0;
+        turns = turns.map((turn) => {
+            if (turn.markdown === undefined)
+                return turn;
+            const said = describedText(context, turn.markdown, script.dependsOn, offset);
+            if (said.recipes.length === 0)
+                return turn;
+            offset += said.recipes.length;
+            described.push(...said.recipes);
+            cards.push(...said.cards);
+            if (said.spoken === null) {
+                pending = true;
+                return turn;
+            }
+            return { ...turn, text: said.spoken.trim().replace(/\s*\n\s*/g, " ") };
+        });
+    }
+    preparations.push(...described);
+    if (script.text === null) {
+        // Turns not yet known are prepared behind one future step, as a single voice's text is.
+        const from = script.dependsOn[0];
+        if (prepare && from !== undefined)
+            preparations.push(preparationFuture(context, "body", { key: from, fingerprint: script.fingerprint ?? from }));
+        parts.push(future());
+    }
+    else if (parsed !== undefined && !parsed.ok) {
+        parts.push(refused(context, "audio:body:turn:1", script.dependsOn, `The script can't be narrated: ${parsed.reason} Fix it in Edit project → Article, then Try again.`));
+    }
+    else if (pending) {
+        parts.push(future());
+    }
+    else if (parsed !== undefined) {
+        transcript = ["voices-transcript-v1", turns.map((turn) => [turn.speaker, turn.text])];
+        const aliases = narrationAliasesOf(context.config);
+        for (const group of groupTurns(turns, voices.speakers, voices.nativeDialogue, (text) => applyAliases(text, aliases).length)) {
+            const first = group.turns[0];
+            const speaker = voices.speakers.find((one) => one.id === first?.speaker);
+            if (first === undefined || speaker === undefined)
+                continue;
+            const made = groupParts(context, voices, group.native, group.turns, speaker, glossary, script, preparations);
+            if (made.length === 0)
+                pending = true;
+            made.forEach((part, index) => {
+                parts.push(part);
+                if (index === made.length - 1)
+                    turnEnds.add(layout.length);
+                layout.push([speakerPace(speaker), index === made.length - 1 ? voices.turnGapSeconds : 0]);
+            });
+        }
+        // No gap after the last turn: the timeline's own gap follows it.
+        const last = layout.at(-1);
+        if (last !== undefined)
+            last[1] = 0;
+        if (pending) {
+            parts.length = 0;
+            layout.length = 0;
+            turnEnds.clear();
+            parts.push(future());
+        }
+    }
+    const body = recipe(context, "audio:body:concat", "audio", {
+        kind: "local",
+        version: 1,
+        operation: "concat-turns-v1",
+        values: [
+            parts.map((part) => resourceIdentity(context, part)),
+            layout,
+            // Pauses between sentences inside a turn; the turn gap stays the layout's.
+            ...pauseValues(context.config, layout.map(([, gap], at) => at === layout.length - 1 ? "end" : gap > 0 || turnEnds.has(at) ? "turn" : "sentence")),
+        ],
+    }, parts.map((part) => part.key), { unresolved: parsed?.ok !== true || pending });
+    return {
+        preparations,
+        cards,
+        parts,
+        body,
+        transcript,
+        ...(parsed?.ok === true ? { sections: parsed.script.sections } : {}),
+    };
+}
+function groupParts(context, voices, native, turns, speaker, glossary, script, preparations) {
+    const first = turns[0];
+    if (first === undefined)
+        return [];
+    const logicalKey = `audio:body:turn:${String(first.index)}`;
+    const override = context.content.narrationOverrides[logicalKey];
+    if (override?.kind === "asset")
+        return [
+            recipe(context, `${logicalKey}:1`, "audio", {
+                kind: "provided",
+                version: 1,
+                assetId: override.assetId,
+                semantic: [turns.map((turn) => turn.text).join("\n"), speaker.id],
+            }, script.dependsOn, { tokenKey: logicalKey }),
+        ];
+    if (native) {
+        const byId = new Map(voices.speakers.map((one) => [one.id, one]));
+        // Narration aliases reach every line of the one request, each turn on its own so an alias
+        // never joins the end of one turn to the start of the next. The clean turns stay the
+        // transcript, as they do for a voice that gets one request per turn.
+        const aliases = narrationAliasesOf(context.config);
+        const spoken = turns.map((turn) => applyAliases(turn.text, aliases));
+        const logicalText = turns.map((turn) => turn.text).join("\n");
+        const text = spoken.join("\n");
+        return [
+            recipe(context, `${logicalKey}:1`, "audio", {
+                kind: "tts",
+                version: 1,
+                provider: speaker.voice.provider,
+                model: speaker.voice.model,
+                voice: speaker.voice.voice,
+                text,
+                ...(text === logicalText ? {} : { spokenText: logicalText }),
+                logicalKey,
+                logicalText,
+                segment: "body",
+                pronunciation: null,
+                dialogue: turns.map((turn, index) => ({
+                    speaker: turn.speaker,
+                    turn: turn.index,
+                    voice: byId.get(turn.speaker)?.voice.voice ?? "",
+                    text: spoken[index] ?? turn.text,
+                })),
+            }, script.dependsOn, { tokenKey: logicalKey }),
+        ];
+    }
+    const logicalText = normalizeNarrationText(override?.kind === "text" ? override.text : first.text);
+    const entries = speakerGlossary(context, speaker, glossary);
+    if (!entries.ok)
+        return [refused(context, logicalKey, script.dependsOn, entries.reason)];
+    const maxCharacters = context.catalogue?.tts.find((row) => row.provider === speaker.voice.provider &&
+        row.id === speaker.voice.model &&
+        row.enabled &&
+        !row.deprecated)?.tts.maxCharacters ?? Math.max(2, logicalText.length * 4);
+    // Narration aliases apply to every voice, the speaker's pronunciations to IPA voices only.
+    const spans = withAliasSpans(pronunciationSpans(logicalText, entries.entries), aliasSpans(logicalText, narrationAliasesOf(context.config)));
+    if (preparesTurns(context.config, speaker)) {
+        const prepared = preparationForGroup(context, logicalKey, logicalText, "body", script.dependsOn, maxCharacters, spans, aliasMatches(logicalText, narrationAliasesOf(context.config)), { name: speaker.name.trim(), role: speaker.role });
+        preparations.push(prepared.preparation);
+        if (prepared.refusal !== null)
+            return [refused(context, logicalKey, [prepared.preparation.key], prepared.refusal)];
+        return (prepared.requests ?? []).map((request, index) => recipe(context, `${logicalKey}:${String(index + 1)}`, "audio", {
+            kind: "tts",
+            version: 1,
+            provider: speaker.voice.provider,
+            model: speaker.voice.model,
+            voice: speaker.voice.voice,
+            text: request.text,
+            spokenText: request.spokenText,
+            logicalKey,
+            logicalText,
+            segment: "body",
+            pronunciation: null,
+            speaker: speaker.id,
+            turn: first.index,
+        }, [prepared.preparation.key], { tokenKey: logicalKey, unresolved: logicalText.length === 0 }));
+    }
+    let requests;
+    if (spans.length > 0) {
+        const prepared = prepareRequests(logicalText, [], maxCharacters, spans);
+        if (!prepared.ok)
+            return [refused(context, logicalKey, script.dependsOn, prepared.reason)];
+        requests = prepared.requests;
+    }
+    else
+        requests = splitText(logicalText, maxCharacters).map((text) => ({ text }));
+    return requests.map((request, index) => recipe(context, `${logicalKey}:${String(index + 1)}`, "audio", {
+        kind: "tts",
+        version: 1,
+        provider: speaker.voice.provider,
+        model: speaker.voice.model,
+        voice: speaker.voice.voice,
+        text: request.text,
+        ...(request.spokenText === undefined ? {} : { spokenText: request.spokenText }),
+        logicalKey,
+        logicalText,
+        segment: "body",
+        pronunciation: null,
+        speaker: speaker.id,
+        turn: first.index,
+    }, script.dependsOn, { tokenKey: logicalKey, unresolved: logicalText.length === 0 }));
+}
+// IPA pronunciations reach only the voices that read IPA: the speaker's own first, then the
+// run's glossary where Use Pronunciation Glossary is on.
+function speakerGlossary(context, speaker, glossary) {
+    if (!readsIpa(speaker))
+        return { ok: true, entries: [] };
+    const own = speaker.pronunciations?.trim()
+        ? parsePronunciationGlossary(speaker.pronunciations, context.config.language)
+        : { ok: true, entries: [] };
+    if (!own.ok)
+        return {
+            ok: false,
+            reason: `${speaker.name.trim()}'s pronunciations can't be used: ${own.reason.replace("Edit the glossary or turn off Use Pronunciation Glossary.", "Fix them under Speakers (Play → Audio, or Edit project → Providers).")}`,
+        };
+    const run = context.config.audio?.usePronunciationGlossary === true && glossary?.ok === true
+        ? glossary.entries
+        : [];
+    return { ok: true, entries: withSharedGlossary(own.entries, run) };
+}
+// A turn is prepared when the run has a Narration Preparation prompt and its speaker's voice
+// takes Inworld TTS-2's delivery tags; every other speaker's turns are spoken as written.
+export function preparesTurns(config, speaker) {
+    return (usesNarrationPreparation(config) &&
+        speaker.voice.provider === "inworld" &&
+        speaker.voice.model === "inworld-tts-2");
+}
+export function readsIpa(speaker) {
+    return (speaker.voice.provider === "inworld" &&
+        (speaker.voice.model === "inworld-tts-2" || speaker.voice.model === "inworld-tts-2-flash"));
+}
+function refused(context, logicalKey, dependsOn, reason) {
+    return recipe(context, `${logicalKey}:1`, "audio", { kind: "deferred", version: 1, operation: "resolve-revision-recipe", template: reason }, dependsOn, { unresolved: true, refusal: reason });
+}
+// What a pending script will be spoken with, so a voice change before the script lands is
+// still a change.
+export function speakerValues(voices) {
+    return [
+        voices.nativeDialogue,
+        voices.speakers.map((speaker) => [
+            speaker.id,
+            speaker.voice.provider,
+            speaker.voice.model,
+            speaker.voice.voice,
+            speaker.pronunciations ?? null,
+        ]),
+    ];
+}

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

@@ -1,11 +1,17 @@
 import { z } from "zod";
 import { estimateRequests } from "../estimate/index.js";
+import { skippedGlossaryNotice, skippedSpeakerPronunciations, skippedSpeakerPronunciationsNotice, } from "../narration/pronunciation.js";
+import { isLocalCliProvider } from "../settings/model.js";
 import { defaultShortsPrompt, shortsImageUpperBound } from "../shorts/model.js";
+import { usesVoices } from "../voices/model.js";
 import { planDependencies } from "./dependencies.js";
 import { matchingNarrationPiece } from "./narration-reuse.js";
 import { buildRecipes } from "./recipe-build.js";
 import { manualCuesNeedReview } from "./recipe-exports.js";
 import { selectedReference, } from "./recipe-model.js";
+import { recipeProviderChoice } from "./recipe-provider-choice.js";
+import { narrationGlossary } from "./recipe-text.js";
+import { readsIpa } from "./recipe-voices.js";
 export function planRevisionWork(revision, manifest, catalogue, availableAssetIds, resolved, retainedNarration = []) {
     const selected = {
         outputs: manifest.outputs.filter(selectedReference),
@@ -27,6 +33,7 @@ export function planRevisionWork(revision, manifest, catalogue, availableAssetId
         resolved: { ...resolved, articleMarkdown: usableArticle ? resolved.articleMarkdown : null },
     };
     const logical = buildRecipes(logicalContext);
+    const glossary = narrationGlossary(logicalContext);
     const context = { ...logicalContext, catalogue };
     const recipes = buildRecipes(context).map((row) => ({
         ...row,
@@ -64,7 +71,7 @@ export function planRevisionWork(revision, manifest, catalogue, availableAssetId
             null,
         after: row.fingerprint,
     }));
-    const priced = work.flatMap((row) => priceRecipes(row, recipes.find((one) => one.key === row.key)));
+    const priced = work.flatMap((row) => priceRecipes(row, recipes.find((one) => one.key === row.key), revision.config));
     return {
         recipes,
         work,
@@ -74,6 +81,13 @@ export function planRevisionWork(revision, manifest, catalogue, availableAssetId
             (revision.config.chunking?.mode ?? "whole") === "whole"
             ? "Whole-text narration is one logical request. Editing its text rebuilds every provider part of that request."
             : null,
+        glossaryNotice: glossary?.ok === true && glossary.skipped !== undefined
+            ? skippedGlossaryNotice(glossary.skipped)
+            : null,
+        // Only speakers whose voice reads IPA use their pronunciations at all.
+        speakerPronunciationNotice: usesVoices(revision.config) && revision.config.voices !== undefined
+            ? skippedSpeakerPronunciationsNotice(skippedSpeakerPronunciations(revision.config.voices.speakers.filter(readsIpa), revision.config.language))
+            : null,
         costs: estimateRequests(priced, catalogue),
     };
 }
@@ -187,14 +201,16 @@ const shortsTranscriptEstimate = 24000;
 // What a step is charged as. Most steps are one request; what stands in for the shorts
 // until they are picked is every clip's image prompts and, at the longest length allowed,
 // every image, which is the most the step can cost.
-export function priceRecipes(work, value) {
+export function priceRecipes(work, value, 
+// The revision's settings, which name the provider of a request built only when it runs.
+config) {
     const input = value?.input;
     const unfolds = value?.unfoldsImages;
     // A short's image prompts once the clips are picked: the call, and the images it leads to,
     // as many as the clip's length asks for.
     if (work.disposition === "generate" && unfolds !== undefined)
         return [
-            priceRecipe(work, value),
+            priceRecipe(work, value, config),
             ...Array.from({ length: unfolds.count }, () => ({
                 kind: "image",
                 stage: work.key,
@@ -223,7 +239,7 @@ export function priceRecipes(work, value) {
         input?.kind !== "deferred" ||
         input.operation !== "shorts" ||
         !Array.isArray(input.template))
-        return [priceRecipe(work, value)];
+        return [priceRecipe(work, value, config)];
     const [, style, provider, model, imageSeconds, count, maxSeconds, llmProvider, llmModel] = input.template;
     const clips = typeof count === "number" ? count : 0;
     const images = typeof imageSeconds === "number" && typeof maxSeconds === "number"
@@ -249,7 +265,7 @@ export function priceRecipes(work, value) {
         })),
     ];
 }
-export function priceRecipe(work, value) {
+export function priceRecipe(work, value, config) {
     if (value === undefined || work.disposition !== "generate")
         return {
             kind: "local",
@@ -259,12 +275,21 @@ export function priceRecipe(work, value) {
                 : "Local, provided, or blocked work; no admitted generation charge.",
         };
     const input = value.input;
+    const onPlan = config === undefined ? undefined : cliRequest(work, value, config);
+    if (onPlan !== undefined)
+        return onPlan;
     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 === "deferred" && input.operation === "narration-description")
+        return {
+            kind: "unknown",
+            stage: work.key,
+            detail: "Narration descriptions: one LLM call per table, figure, equation or code block in the article; how many is known once the article is written.",
+        };
     if (input.kind === "llm")
         return {
             kind: "llm",
@@ -273,7 +298,7 @@ export function priceRecipe(work, value) {
             model: input.model,
             inputCharacters: input.messages.reduce((sum, message) => sum + message.content.length, 0) +
                 (input.documents ?? []).reduce((sum, document) => sum + document.content.length, 0),
-            outputCharacters: work.key === "article:body" ? 9000 : 2400,
+            outputCharacters: work.key === "article:body" ? 9000 : input.describe !== undefined ? 600 : 2400,
             detail: "Actual saved request input; output length is estimated. Retries and tools are excluded.",
         };
     if (input.kind === "tts")
@@ -299,6 +324,21 @@ export function priceRecipe(work, value) {
             detail: "The numbered transcript is built when the step runs; its length is estimated. One more call is made when the first answer breaks the rules. Retries are excluded.",
         };
     }
+    // A review: the stage's prompt and the item (the article's text, or a short brief beside an
+    // image, which the provider prices as it does).
+    if (input.kind === "local" && input.operation === "review-v1") {
+        const [stage, , , provider, model, , prompt] = Array.isArray(input.values) ? input.values : [];
+        return {
+            kind: "llm",
+            stage: work.key,
+            provider: typeof provider === "string" ? provider : "",
+            model: typeof model === "string" ? model : "",
+            inputCharacters: (typeof prompt === "string" && prompt !== "" ? prompt.length : 600) +
+                (stage === "article" || stage === "narration" ? 20000 : 1500),
+            outputCharacters: 400,
+            detail: "The item is read when the step runs; its length is estimated. A failed item made again is reviewed again, which is not in this estimate.",
+        };
+    }
     if (input.kind === "local" && input.operation === "youtube-description-v1") {
         const [, provider, model, , prompt] = Array.isArray(input.values) ? input.values : [];
         return {
@@ -320,3 +360,34 @@ export function priceRecipe(work, value) {
         detail: "Future generated input is unknown. This group materializes under the same admitted revision; its final request count and charge are unknown.",
     };
 }
+// A request built only when its step runs, on a command-line provider: it runs on the user's
+// plan, so it is known at $0, as Play's review prices the same step. Its size is estimated
+// for the API figure beside it; Narration Preparation's number of calls is not known yet, so
+// it has none.
+function cliRequest(work, value, config) {
+    if (value.input.kind !== "deferred")
+        return undefined;
+    const choice = recipeProviderChoice(value, config);
+    if (choice === undefined || !isLocalCliProvider(choice.provider))
+        return undefined;
+    if (choice.family === "image")
+        return { kind: "image", stage: work.key, provider: choice.provider, model: choice.model };
+    if (choice.family !== "llm")
+        return undefined;
+    const preparation = value.input.operation === "narration-preparation" ||
+        value.input.operation === "narration-description";
+    return {
+        kind: "llm",
+        stage: work.key,
+        provider: choice.provider,
+        model: choice.model,
+        inputCharacters: 6000,
+        outputCharacters: work.key === "article:body" ? 9000 : 2400,
+        ...(preparation ? { apiUnknown: true } : {}),
+        detail: preparation
+            ? value.input.operation === "narration-description"
+                ? "Runs on your CLI plan, so it adds no charge. Narration descriptions make one call per table, figure, equation or code block; how many is known once the article is written, so no API figure is given."
+                : "Runs on your CLI plan, so it adds no charge. Narration Preparation makes one call per logical chunk or entry; how many is known when the step runs, so no API figure is given."
+            : "Runs on your CLI plan, so it adds no charge. The request is built when the step runs, so its API figure uses an estimated length.",
+    };
+}

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

@@ -25,6 +25,8 @@ export function youtubeRecipes(context, exports) {
                 // ships as a new operation version rather than a silent change here.
                 config.descriptionPrompt?.trim() ? renderedPrompt(context, "description") : "",
                 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.

package/dist/slices/rebuild/recovery-conflict.js

@@ -1,5 +1,9 @@
 import { projectPaused } from "../admission/repo.js";
-export function activeConflict(deps, projectId, keys) {
+//
+// An automatic redo (`pendingSuperseded`) runs while the rest of the run waits: admitted work
+// that has not started is replaced by the redo's own, so only running work and accepted jobs
+// stand in its way.
+export function activeConflict(deps, projectId, keys, pendingSuperseded = false) {
     const rows = deps.db
         .prepare("SELECT work_key,logical_key,live FROM (SELECT p.work_key,r.logical_key," +
         "(w.state='running' OR (? AND w.state='pending' AND w.dispatch_state='allowed' AND NOT EXISTS(" +
@@ -10,7 +14,7 @@ export function activeConflict(deps, projectId, keys) {
         "FROM revision_work w JOIN revision_work_pieces p ON p.work_id=w.id " +
         "LEFT JOIN revision_work_reservations r ON r.work_id=w.id AND r.piece_id=p.id " +
         "WHERE w.project_id=?) WHERE live OR accepted")
-        .all(projectPaused(deps.db, projectId) ? 0 : 1, projectId)
+        .all(pendingSuperseded || projectPaused(deps.db, projectId) ? 0 : 1, projectId)
         .filter((row) => keys.some((key) => row.work_key === key ||
         row.logical_key === key ||
         (key.endsWith(":future") && String(row.work_key).startsWith(key.slice(0, -6)))));
@@ -18,7 +22,7 @@ export function activeConflict(deps, projectId, keys) {
         return undefined;
     return rows.some((row) => Number(row.live) === 1) ? "running" : "accepted-job";
 }
-export const acceptedJobMessage = "An accepted provider job for this section is waiting to be collected. Use Retry stage or Resume, then rerun.";
+export const acceptedJobMessage = "An accepted provider job for this section is waiting to be collected. Use Try again or Continue the run, then rerun.";
 export function conflictRefusal(conflict) {
     return conflict === "running"
         ? { ok: false, reason: "running" }

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

@@ -6,6 +6,9 @@ export const recoveryActionSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("resume") }).strict(),
     z.object({ kind: z.literal("retry"), stage: z.enum(stageKinds) }).strict(),
     z.object({ kind: z.literal("rerun"), stage: z.enum(stageKinds) }).strict(),
+    // Make one reviewed item again (`slices/reviews`): an image, the thumbnail, the article, the
+    // narration or one short, and everything that depends on it, its review included.
+    z.object({ kind: z.literal("redo"), item: z.string().min(1).max(200) }).strict(),
 ]);
 export const recoveryRequestSchema = revisionControlSchema
     .extend({

package/dist/slices/rebuild/recovery-selection.js

@@ -9,19 +9,45 @@ export function sectionRoots(view, plan, stage) {
             return false;
         if (stage === "video")
             return (row.input.kind === "local" &&
-                (row.key.startsWith("export:") || row.key === "subtitles:files"));
+                (row.key.startsWith("export:") ||
+                    row.key === "subtitles:files" ||
+                    row.key === "voices:files"));
         if (stage === "audio")
             return (row.input.kind === "tts" ||
                 (row.input.kind === "deferred" &&
                     ["body-narration", "intro-narration", "outro-narration"].includes(row.input.operation)));
         if (stage === "article")
-            return row.key === "article:body" && row.kind === "provider";
+            return ((row.key === "article:body" || row.key === "script:attribute") && row.kind === "provider");
         if (stage === "document")
             return row.key === "document:pdf";
         return row.kind === "provider";
     })
         .map((row) => row.key);
 }
+// What making one reviewed item again regenerates and where its rebuild starts. The article
+// and the narration are redone like More → make it again in its section on their stage; an image or the thumbnail
+// by its own token, like Regenerate; a short by "Make this short again"'s token.
+export function redoTarget(view, plan, item) {
+    const section = (stage) => {
+        const edit = regenerationEdit(view, plan, stage);
+        return edit === undefined ? undefined : { roots: sectionRoots(view, plan, stage), edit };
+    };
+    if (item === "narration")
+        return section("audio");
+    if (item === "article:body")
+        return section("article");
+    const own = (roots) => ({
+        roots,
+        edit: { config: view.revision.config, content: view.revision.content, regenerate: [item] },
+    });
+    if (/^shorts:\d+$/.test(item))
+        return plan.recipes.some((row) => row.key === `${item}:prompts`)
+            ? own([`${item}:prompts`])
+            : undefined;
+    return plan.recipes.some((row) => row.key === item && row.kind === "provider")
+        ? own([item])
+        : undefined;
+}
 export function dependentClosure(recipes, roots) {
     const selected = new Set(roots);
     let changed = true;