@gentbajko/slopify 1.5.0 → 2.0.0

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

@@ -1,18 +1,28 @@
 import { fingerprint } from "../../kernel/runner/work.js";
-import { usesNarrationPreparation } from "../admission/rules.js";
-import { chunkNarration, defaultChunking } from "../narration/chunk.js";
+import { usesNarrationPreparation, usesPronunciationGlossary } from "../admission/rules.js";
+import { defaultChunking } from "../narration/chunk.js";
 import { concatArgs } from "../narration/concat.js";
 import { normalizeNarrationText } from "../narration/plan.js";
-import { narrationParts, voiceValues } from "./recipe-audio-parts.js";
+import { pronunciationChunks } from "../narration/pronunciation-chunks.js";
+import { narrationParts, pronunciationFutureValues, 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 bodyNarrationGroups(context, text) {
+    return text.articleText === null
+        ? []
+        : pronunciationChunks(normalizeNarrationText(text.articleText), context.config.chunking ?? defaultChunking, usesPronunciationGlossary(context.config) && text.glossary?.ok ? text.glossary.entries : [], new Set(Object.keys(context.content.narrationOverrides)), context.content.narrationSources);
+}
 export function audioRecipes(context, text) {
     const { config, content } = context;
     const recipes = [];
     if (config.sources.audio === "off")
         return { recipes, mediaFingerprint: null, timeline: [], keys: [] };
+    const prepare = usesNarrationPreparation(config);
+    const pronounce = usesPronunciationGlossary(config);
+    const narrationFiles = prepare || pronounce;
     let body;
+    let bodyTranscript = text.articleText ?? text.article.fingerprint;
     if (config.sources.audio === "provide") {
         body = recipe(context, "audio:provided", "audio", {
             kind: "provided",
@@ -23,26 +33,30 @@ export function audioRecipes(context, text) {
         recipes.push(body);
     }
     else {
-        const groups = text.articleText === null
-            ? []
-            : chunkNarration(normalizeNarrationText(text.articleText), config.chunking ?? defaultChunking);
-        const occurrences = new Map();
+        const groups = bodyNarrationGroups(context, text);
         const parts = [];
+        const transcripts = [];
+        const futurePronunciation = [];
         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}`;
-            const group = narrationParts(context, logicalKey, logicalText, "body", [text.article.key], recipes);
+        for (const { key: logicalKey, text: logicalText } of groups) {
+            transcripts.push({
+                original: logicalText,
+                effective: effectiveText(context, logicalKey, logicalText),
+            });
+            futurePronunciation.push(...pronunciationFutureValues(context, text.glossary, text.article, logicalKey, logicalText));
+            const group = narrationParts(context, logicalKey, logicalText, "body", [text.article.key], recipes, text.glossary);
             if (group.length === 0)
                 pending = true;
             parts.push(...group);
         }
-        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))
+        if (transcripts.some((row) => row.effective !== row.original))
+            bodyTranscript = ["narration-transcript-v1", transcripts.map((row) => row.effective)];
+        if (text.articleText === null) {
+            futurePronunciation.push(...pronunciationFutureValues(context, text.glossary, text.article, "audio:body:future", null));
+            if (prepare)
+                recipes.push(preparationFuture(context, "body", text.article));
+        }
+        if (pending && prepare)
             parts.length = 0;
         if (pending)
             parts.push(recipe(context, "audio:body:future", "audio", {
@@ -53,11 +67,12 @@ export function audioRecipes(context, text) {
                     text.article.fingerprint,
                     voiceValues(context),
                     chunkingValues(context),
-                    ...(usesNarrationPreparation(config) ? [preparationTemplate(context)] : []),
+                    ...(prepare ? [preparationTemplate(context)] : []),
+                    ...futurePronunciation,
                 ],
             }, [text.article.key, ...preparationKeys(recipes, "body")]));
         recipes.push(...parts);
-        if (usesNarrationPreparation(config))
+        if (narrationFiles)
             recipes.push(narrationFileRecipe(context, "body", parts));
         body = recipe(context, "audio:body:concat", "audio", {
             kind: "local",
@@ -73,29 +88,25 @@ export function audioRecipes(context, text) {
     const ordered = [];
     for (const category of ["intro", "body", "outro"]) {
         if (category === "body") {
-            ordered.push({ value: body, transcript: text.articleText ?? text.article.fingerprint });
+            ordered.push({ value: body, transcript: bodyTranscript });
             continue;
         }
         const entry = text.entries[category];
         if (entry === undefined)
             continue;
-        if (entry.text === null && usesNarrationPreparation(config))
-            recipes.push(preparationFuture(context, category, entry.recipe));
+        const logicalKey = `audio:${category}`;
+        const supplied = content.narrationOverrides[logicalKey]?.kind === "asset";
+        const dependencies = [entry.recipe.key, ...(pronounce && !supplied ? [text.article.key] : [])];
+        const invalidGlossary = !supplied && text.glossary !== null && !text.glossary.ok ? text.glossary.reason : undefined;
+        if (prepare &&
+            !supplied &&
+            invalidGlossary === undefined &&
+            (entry.text === null || text.glossary === null))
+            recipes.push(preparationFuture(context, category, entry.recipe, pronounce ? [text.article] : []));
         const parts = entry.text === null
-            ? [
-                recipe(context, `audio:${category}:future`, "audio", {
-                    kind: "deferred",
-                    version: 1,
-                    operation: `${category}-narration`,
-                    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], recipes);
-        if (parts.length === 0 && usesNarrationPreparation(config))
+            ? []
+            : narrationParts(context, logicalKey, entry.text, category, dependencies, recipes, text.glossary);
+        if (parts.length === 0)
             parts.push(recipe(context, `audio:${category}:future`, "audio", {
                 kind: "deferred",
                 version: 1,
@@ -103,9 +114,10 @@ export function audioRecipes(context, text) {
                 template: [
                     entry.recipe.fingerprint,
                     voiceValues(context),
-                    preparationTemplate(context),
+                    ...(prepare ? [preparationTemplate(context)] : []),
+                    ...pronunciationFutureValues(context, text.glossary, text.article, logicalKey, entry.text),
                 ],
-            }, [entry.recipe.key, ...preparationKeys(recipes, category)]));
+            }, [...dependencies, ...preparationKeys(recipes, category)], invalidGlossary === undefined ? {} : { unresolved: true, refusal: invalidGlossary }));
         recipes.push(...parts);
         const audio = recipe(context, `audio:${category}`, "audio", {
             kind: "local",
@@ -117,9 +129,14 @@ export function audioRecipes(context, text) {
             ],
         }, parts.map((part) => part.key));
         recipes.push(audio);
-        if (usesNarrationPreparation(config))
+        if (narrationFiles)
             recipes.push(narrationFileRecipe(context, category, parts));
-        ordered.push({ value: audio, transcript: entry.text ?? entry.recipe.fingerprint });
+        ordered.push({
+            value: audio,
+            transcript: entry.text === null
+                ? entry.recipe.fingerprint
+                : effectiveText(context, logicalKey, entry.text),
+        });
     }
     const timeline = ordered.map(({ value, transcript }) => {
         const retained = context.manifest.outputs.find((row) => row.workKey === value.key && row.state === "ready" && selectedReference(row));
@@ -140,6 +157,10 @@ export function audioRecipes(context, text) {
         keys: ordered.map(({ value }) => value.key),
     };
 }
+function effectiveText(context, key, original) {
+    const override = context.content.narrationOverrides[key];
+    return override?.kind === "text" ? normalizeNarrationText(override.text) : original;
+}
 function chunkingValues(context) {
     const chunking = context.config.chunking ?? defaultChunking;
     return [

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

@@ -36,11 +36,13 @@ export function recipe(context, key, stage, input, dependsOn = [], options = {})
             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)
+        : (context.content.regenerationTokens[options.tokenKey ?? key] ?? null);
+    const researchToken = stage === "research" ? context.content.regenerationTokens["research:all"] : undefined;
     const workFingerprint = fingerprint([
         requestFingerprint,
-        input.kind === "tts"
-            ? narrationRegenerationToken(context.content.regenerationTokens, input.logicalKey, input.segment)
-            : (context.content.regenerationTokens[options.tokenKey ?? key] ?? null),
+        researchToken === undefined ? token : fingerprint([researchToken, token]),
     ]);
     return {
         key,

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

@@ -12,7 +12,7 @@ export function preparationTemplate(context) {
         JSON.parse(JSON.stringify(context.content.narrationOverrides)),
     ];
 }
-export function preparationFuture(context, segment, dependency) {
+export function preparationFuture(context, segment, dependency, additionalDependencies = []) {
     return recipe(context, `narration:prepare:${segment}:future`, "audio", {
         kind: "deferred",
         version: 1,
@@ -21,10 +21,11 @@ export function preparationFuture(context, segment, dependency) {
             dependency.fingerprint,
             preparationTemplate(context),
             JSON.parse(JSON.stringify(context.config.chunking ?? null)),
+            ...additionalDependencies.map((row) => row.fingerprint),
         ],
-    }, [dependency.key]);
+    }, [...new Set([dependency.key, ...additionalDependencies.map((row) => row.key)])]);
 }
-export function preparationForGroup(context, logicalKey, source, segment, dependsOn, maxCharacters) {
+export function preparationForGroup(context, logicalKey, source, segment, dependsOn, maxCharacters, spans = []) {
     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 },
@@ -58,8 +59,9 @@ export function preparationForGroup(context, logicalKey, source, segment, depend
         return { preparation, requests: null, refusal: validated.reason };
     const prepared = prepareRequests(source, validated.cues, context.catalogue === undefined
         ? Math.max(2, source.length +
+            spans.reduce((sum, span) => sum + Math.max(0, span.text.length - (span.end - span.start)), 0) +
             validated.cues.reduce((n, cue) => n + (cue.kind === "instruction" ? cue.text.length : 20) + 3, 0))
-        : maxCharacters);
+        : maxCharacters, spans);
     return prepared.ok
         ? { preparation, requests: prepared.requests, refusal: null }
         : { preparation, requests: null, refusal: prepared.reason };

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

@@ -1,11 +1,13 @@
 import { z } from "zod";
 import { documentIndex } from "../../kernel/ports/llm-documents.js";
 import { fingerprint } from "../../kernel/runner/work.js";
+import { usesPronunciationGlossary } from "../admission/rules.js";
 import { render } from "../admission/substitute.js";
 import { articleMessages, continuationMessages } from "../article/continuation.js";
 import { plainText } from "../article/plain.js";
 import { segmentMessages } from "../article/segments.js";
 import { splitEndMatter } from "../article/split.js";
+import { parsePronunciationGlossary } from "../narration/pronunciation.js";
 import { researchDocuments } from "../research/documents.js";
 import { plannerMessages, subAgentMessages } from "../research/planner.js";
 import { synthesisMessages } from "../research/synthesis.js";
@@ -55,7 +57,7 @@ export function textRecipes(context) {
     if (config.sources.research === "generate") {
         const planner = recipe(context, "research:planner", "research", llmInput(context, plannerMessages(brief)));
         recipes.push(planner);
-        const chapters = resolved.research?.outline.map((title, index) => recipe(context, `research:chapter:${index + 1}`, "research", llmInput(context, subAgentMessages(brief, title, resolved.research?.outline ?? []), true), [planner.key])) ?? [];
+        const chapters = (resolved.research?.outline ?? []).map((title, index) => recipe(context, `research:chapter:${index + 1}`, "research", llmInput(context, subAgentMessages(brief, title, resolved.research?.outline ?? []), true), [planner.key]));
         recipes.push(...chapters);
         const findings = resolved.research?.findings;
         research =
@@ -116,7 +118,13 @@ export function textRecipes(context) {
         config.sources.article === "generate" &&
         !content.articleEdited)
         recipes.push(recipe(context, "article:continuation", "article", llmInput(context, continuationMessages(messages, resolved.articleContinuation), false, documents), [article.key]));
-    const articleText = articleMarkdown === null ? null : plainText(splitEndMatter(articleMarkdown).body);
+    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
+            : parsePronunciationGlossary(endMatter.glossary);
     const entries = {};
     for (const category of ["intro", "outro"]) {
         const choice = config[category];
@@ -162,7 +170,7 @@ export function textRecipes(context) {
             }
             : llmInput(context, messages), [article.key]));
     }
-    return { recipes, articleText, article, entries };
+    return { recipes, articleText, glossary, article, entries };
 }
 function llmInputFingerprint(context, messages) {
     return fingerprint(JSON.parse(JSON.stringify(llmInput(context, messages))));

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

@@ -0,0 +1,30 @@
+import { projectPaused } from "../admission/repo.js";
+export function activeConflict(deps, projectId, keys) {
+    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(" +
+        "SELECT 1 FROM revision_work f WHERE f.admission_id=w.admission_id " +
+        "AND f.state IN ('failed','canceled')))) AS live," +
+        "(w.state='pending' AND p.state!='done' AND p.continuation IS NOT NULL AND " +
+        "r.revision_id=(SELECT revision_id FROM project_heads WHERE project_id=w.project_id)) AS accepted " +
+        "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)
+        .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)))));
+    if (rows.length === 0)
+        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 function conflictRefusal(conflict) {
+    return conflict === "running"
+        ? { ok: false, reason: "running" }
+        : {
+            ok: false,
+            reason: "accepted-job",
+            fields: [{ field: "stage", message: acceptedJobMessage }],
+        };
+}

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

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { stageKinds } from "../../kernel/pipeline.js";
+import { revisionControlSchema } from "../control/revision-control-schema.js";
+import { rebuildAdmissionSchema } from "./model.js";
+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(),
+]);
+export const recoveryRequestSchema = revisionControlSchema
+    .extend({
+    action: recoveryActionSchema,
+})
+    .strict();
+export const recoveryResultSchema = z.discriminatedUnion("ok", [
+    z.object({
+        ok: z.literal(true),
+        value: rebuildAdmissionSchema.and(z.object({ warnings: z.array(z.string()).readonly() })),
+    }),
+    z.object({
+        ok: z.literal(false),
+        reason: z.enum([
+            "no-project",
+            "no-revision",
+            "conflict",
+            "idempotency-conflict",
+            "invalid-edit",
+            "stale-preview",
+            "invalid-selection",
+            "review-required",
+            "cost-ack-required",
+            "readiness",
+            "running",
+            "accepted-job",
+            "control-changed",
+        ]),
+        fields: z
+            .array(z.object({ field: z.string(), message: z.string() }))
+            .readonly()
+            .optional(),
+        intentRevisionId: z.string().optional(),
+        currentRevisionId: z.string().nullable().optional(),
+    }),
+]);

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

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { requestHash } from "../revisions/mutation-request.js";
+import { revisionEditSchema } from "../revisions/schema.js";
+import { recoveryResultSchema, } from "./recovery-model.js";
+const rowSchema = z.object({
+    request_hash: z.string(),
+    base_revision_id: z.string(),
+    authority_stamp: z.string(),
+    edit_json: z.string().nullable(),
+    intent_revision_id: z.string().nullable(),
+    response_json: z.string().nullable(),
+});
+export function recoveryKey(input, phase) {
+    return `recovery:${input.idempotencyKey}:${phase}`;
+}
+export function recoveryAuthority(deps, projectId) {
+    const controls = deps.db
+        .prepare("SELECT idempotency_key FROM project_control_receipts WHERE project_id=? ORDER BY rowid")
+        .all(projectId);
+    const admissions = deps.db
+        .prepare("SELECT id FROM rebuild_admissions WHERE project_id=? ORDER BY rowid")
+        .all(projectId);
+    return requestHash("recovery-authority", projectId, { controls, admissions });
+}
+export function readRecovery(deps, projectId, input) {
+    const raw = deps.db
+        .prepare("SELECT * FROM project_recovery_requests WHERE project_id=? AND idempotency_key=?")
+        .get(projectId, input.idempotencyKey);
+    if (raw === undefined) {
+        const used = deps.db
+            .prepare("SELECT 1 FROM revision_mutations WHERE project_id=? AND idempotency_key=? " +
+            "UNION ALL SELECT 1 FROM rebuild_admissions WHERE project_id=? AND idempotency_key=? " +
+            "UNION ALL SELECT 1 FROM project_control_receipts WHERE project_id=? AND idempotency_key=?")
+            .get(projectId, input.idempotencyKey, projectId, input.idempotencyKey, projectId, input.idempotencyKey);
+        return used === undefined ? undefined : { ok: false, reason: "idempotency-conflict" };
+    }
+    const row = rowSchema.parse(raw);
+    if (row.request_hash !== requestHash("direct-recovery", input.baseRevisionId, input.action))
+        return { ok: false, reason: "idempotency-conflict" };
+    if (row.response_json !== null)
+        return recoveryResultSchema.parse(JSON.parse(row.response_json));
+    return {
+        pending: true,
+        authority: row.authority_stamp,
+        intentRevisionId: row.intent_revision_id,
+        edit: row.edit_json === null ? null : revisionEditSchema.parse(JSON.parse(row.edit_json)),
+    };
+}
+export function reserveRecovery(deps, projectId, input, edit) {
+    const authority = recoveryAuthority(deps, projectId);
+    deps.db
+        .prepare("INSERT INTO project_recovery_requests " +
+        "(project_id,idempotency_key,request_hash,base_revision_id,authority_stamp,edit_json) " +
+        "VALUES (?,?,?,?,?,?)")
+        .run(projectId, input.idempotencyKey, requestHash("direct-recovery", input.baseRevisionId, input.action), input.baseRevisionId, authority, edit === null ? null : JSON.stringify(edit));
+    return { pending: true, authority, edit, intentRevisionId: null };
+}
+export function rememberRecovery(deps, projectId, input, result) {
+    const response = recoveryResultSchema.parse(result);
+    deps.db
+        .prepare("UPDATE project_recovery_requests SET response_json=? WHERE project_id=? AND idempotency_key=?")
+        .run(JSON.stringify(response), projectId, input.idempotencyKey);
+    return response;
+}
+// The head has unfinished stages but nothing that will move them on its own: no call in
+// flight and no admitted, dispatchable work. A saved rerun or edit is admitted by no one
+// until Resume, and work held by a pause, a restart or a failed sibling of its admission
+// never starts, yet none of these shows as paused or failed. A queued batch item waits for
+// its turn instead.
+export function resumable(db, projectId) {
+    return (db
+        .prepare("SELECT 1 FROM project_heads h WHERE h.project_id=? " +
+        "AND EXISTS(SELECT 1 FROM stages s WHERE s.project_id=h.project_id " +
+        "AND s.state NOT IN ('done','provided','skipped')) " +
+        "AND NOT EXISTS(SELECT 1 FROM stages s WHERE s.project_id=h.project_id AND s.state='running') " +
+        "AND NOT EXISTS(SELECT 1 FROM project_queue q WHERE q.project_id=h.project_id AND q.state='queued') " +
+        "AND NOT EXISTS(SELECT 1 FROM revision_work w WHERE w.project_id=h.project_id AND w.state='running') " +
+        "AND NOT EXISTS(SELECT 1 FROM revision_work w " +
+        "JOIN revision_work_reservations r ON r.work_id=w.id AND r.revision_id=h.revision_id " +
+        "WHERE w.state='pending' AND w.dispatch_state='allowed' AND NOT EXISTS(" +
+        "SELECT 1 FROM revision_work f WHERE f.admission_id=w.admission_id " +
+        "AND f.state IN ('failed','canceled')))")
+        .get(projectId) !== undefined);
+}

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

@@ -0,0 +1,68 @@
+import { narrationRegenerationKey } from "../narration/plan.js";
+export function sectionRoots(view, plan, stage) {
+    if (stage === "article" &&
+        (view.revision.config.sources.article !== "generate" || view.revision.content.articleEdited))
+        return [];
+    return plan.recipes
+        .filter((row) => {
+        if (row.stage !== stage || row.kind === "provided")
+            return false;
+        if (stage === "video")
+            return (row.input.kind === "local" &&
+                (row.key.startsWith("export:") || row.key === "subtitles: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.kind === "provider";
+    })
+        .map((row) => row.key);
+}
+export function dependentClosure(recipes, roots) {
+    const selected = new Set(roots);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const row of recipes)
+            if (!selected.has(row.key) && row.dependsOn.some((key) => selected.has(key))) {
+                selected.add(row.key);
+                changed = true;
+            }
+    }
+    return recipes.filter((row) => selected.has(row.key)).map((row) => row.key);
+}
+export function recoverySelection(plan, stage) {
+    if (stage === undefined)
+        return { kind: "allAffected" };
+    const roots = plan.work
+        .filter((row) => row.stage === stage && row.disposition !== "reuse")
+        .map((row) => row.key);
+    const unfinished = roots.length === 0
+        ? plan.work.filter((row) => row.stage === stage).map((row) => row.key)
+        : roots;
+    return { kind: "selected", workKeys: unfinished };
+}
+export function regenerationEdit(view, plan, stage) {
+    const roots = sectionRoots(view, plan, stage);
+    if (roots.length === 0)
+        return undefined;
+    const regenerate = stage === "research"
+        ? ["research:all"]
+        : [
+            ...new Set(roots.map((key) => {
+                const row = plan.recipes.find((recipe) => recipe.key === key);
+                return row?.input.kind === "tts"
+                    ? row.input.logicalKey
+                    : narrationRegenerationKey(key);
+            })),
+        ];
+    for (const root of roots.filter((key) => key.startsWith("audio:") && key.endsWith(":future"))) {
+        const segment = root.slice(0, -7);
+        for (const key of Object.keys(view.revision.content.regenerationTokens))
+            if ((key === segment || key.startsWith(`${segment}:`)) && !regenerate.includes(key))
+                regenerate.push(key);
+    }
+    return { config: view.revision.config, content: view.revision.content, regenerate };
+}