@gentbajko/slopify 1.5.1 → 2.0.1

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 };
+}

package/dist/slices/rebuild/recovery.js

@@ -0,0 +1,257 @@
+import { transact } from "../../kernel/db/tx.js";
+import { withProjectControl } from "../control/lock.js";
+import { requestHash } from "../revisions/mutation-request.js";
+import { saveRevision } from "../revisions/mutations.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { planPreview } from "./preview-plan.js";
+import { retainedPreviewPlan } from "./preview-retained.js";
+import { recipeProviderChoice } from "./recipe-provider-choice.js";
+import { acceptedJobMessage, activeConflict, conflictRefusal } from "./recovery-conflict.js";
+import { recoveryRequestSchema, } from "./recovery-model.js";
+import { readRecovery, recoveryAuthority, recoveryKey, rememberRecovery, reserveRecovery, } from "./recovery-repo.js";
+import { dependentClosure, recoverySelection, regenerationEdit, sectionRoots, } from "./recovery-selection.js";
+import { previewById, storePreview } from "./repo.js";
+import { admitCheckedPreview, wakeRebuild } from "./service.js";
+import { checkReadiness } from "./service-readiness.js";
+function credentialsStamp(deps, plan, view) {
+    const providers = new Set(plan.execution.recipes.flatMap((recipe) => {
+        if (!plan.execution.submissions.some((row) => row.key === recipe.key && row.submit))
+            return [];
+        const choice = recipeProviderChoice(recipe, view.revision.config);
+        return choice === undefined ? [] : [choice.provider];
+    }));
+    const metadata = deps.db
+        .prepare("SELECT provider,credential_generation FROM provider_keys ORDER BY provider")
+        .all()
+        .filter((row) => providers.has(String(row.provider)));
+    return requestHash("recovery-credentials", view.revision.id, metadata);
+}
+export async function recoverProject(deps, projectId, raw) {
+    const parsed = recoveryRequestSchema.safeParse(raw);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid-selection",
+            fields: parsed.error.issues.map((issue) => ({
+                field: issue.path.join("."),
+                message: issue.message,
+            })),
+        };
+    const input = parsed.data;
+    const prepared = await withProjectControl(deps.db, projectId, async () => {
+        const found = readRecovery(deps, projectId, input);
+        if (found !== undefined && "ok" in found)
+            return found;
+        const base = getRevisionView(deps, projectId, input.baseRevisionId);
+        if (base === undefined)
+            return {
+                ok: false,
+                reason: currentRevisionId(deps.db, projectId) === undefined ? "no-project" : "conflict",
+            };
+        let record = found;
+        if (record === undefined) {
+            if (!base.current)
+                return { ok: false, reason: "conflict" };
+            const plan = retainedPreviewPlan(deps, base, deps.catalogue.read());
+            const edit = input.action.kind === "rerun" ? regenerationEdit(base, plan, input.action.stage) : null;
+            if (edit === undefined)
+                return {
+                    ok: false,
+                    reason: "invalid-selection",
+                    fields: [
+                        {
+                            field: "stage",
+                            message: "This section has no generated work to rerun. Use Edit project to change its source.",
+                        },
+                    ],
+                };
+            record = reserveRecovery(deps, projectId, input, edit);
+        }
+        const authority = record.authority;
+        let intentRevisionId = record.intentRevisionId;
+        const finish = (result) => rememberRecovery(deps, projectId, input, !result.ok && intentRevisionId !== null ? { ...result, intentRevisionId } : result);
+        if (recoveryAuthority(deps, projectId) !== authority)
+            return finish({ ok: false, reason: "control-changed" });
+        let view = base;
+        if (record.edit !== null) {
+            const prior = retainedPreviewPlan(deps, base, deps.catalogue.read());
+            const action = input.action;
+            if (action.kind !== "rerun")
+                throw new Error("Recovery edit has no rerun action");
+            const affected = dependentClosure(prior.recipes, sectionRoots(base, prior, action.stage));
+            const savedIntent = deps.db
+                .prepare("SELECT result_revision_id FROM revision_mutations WHERE project_id=? AND idempotency_key=?")
+                .get(projectId, recoveryKey(input, "save"));
+            const conflict = savedIntent === undefined ? activeConflict(deps, projectId, affected) : undefined;
+            if (conflict !== undefined)
+                return finish(conflictRefusal(conflict));
+            const saved = await saveRevision(deps, {
+                projectId,
+                baseRevisionId: input.baseRevisionId,
+                idempotencyKey: recoveryKey(input, "save"),
+                edit: record.edit,
+                beforeCommit: () => {
+                    const late = activeConflict(deps, projectId, affected);
+                    return late === undefined
+                        ? undefined
+                        : {
+                            ok: false,
+                            reason: "invalid-edit",
+                            currentRevisionId: currentRevisionId(deps.db, projectId) ?? null,
+                            fields: [
+                                {
+                                    field: "stage",
+                                    message: late === "running"
+                                        ? "Wait for this section to finish, or Pause the project before rerunning it."
+                                        : acceptedJobMessage,
+                                },
+                            ],
+                        };
+                },
+            });
+            if (!saved.ok)
+                return finish(saved);
+            view = saved.view;
+            intentRevisionId = view.revision.id;
+            deps.db
+                .prepare("UPDATE project_recovery_requests SET intent_revision_id=? WHERE project_id=? AND idempotency_key=?")
+                .run(view.revision.id, projectId, input.idempotencyKey);
+        }
+        if (currentRevisionId(deps.db, projectId) !== view.revision.id)
+            return finish({ ok: false, reason: "conflict" });
+        const plan = retainedPreviewPlan(deps, view, deps.catalogue.read());
+        const rerunKeys = input.action.kind === "rerun"
+            ? dependentClosure(plan.recipes, sectionRoots(view, plan, input.action.stage))
+            : [];
+        const selection = input.action.kind === "rerun"
+            ? { kind: "selected", workKeys: rerunKeys }
+            : recoverySelection(plan, input.action.kind === "retry" ? input.action.stage : undefined);
+        if (selection.kind === "selected" && selection.workKeys.length === 0)
+            return finish({
+                ok: false,
+                reason: "invalid-selection",
+                fields: [
+                    {
+                        field: "stage",
+                        message: "This section has no enabled work. Use Edit project to change its source.",
+                    },
+                ],
+            });
+        const preview = planPreview(deps, view, deps.catalogue.read(), selection, deps.ids.next());
+        if (!preview.ok)
+            return finish(preview);
+        if (preview.value.preview.providedReuseRequired.length > 0)
+            return finish({
+                ok: false,
+                reason: "review-required",
+                fields: preview.value.preview.providedReuseRequired.map((key) => ({
+                    field: key,
+                    message: "Review changed supplied content or manual captions in Edit project or Advanced rebuild review.",
+                })),
+            });
+        const blocked = preview.value.preview.work.filter((row) => row.disposition === "blocked");
+        if (blocked.length > 0)
+            return finish({
+                ok: false,
+                reason: "readiness",
+                fields: blocked.map((row) => ({ field: row.key, message: row.reason })),
+            });
+        if (input.action.kind === "rerun" &&
+            input.action.stage === "video" &&
+            preview.value.preview.work.some((row) => row.kind === "provider" && row.disposition !== "reuse"))
+            return finish({
+                ok: false,
+                reason: "readiness",
+                fields: [
+                    {
+                        field: "video",
+                        message: "Source media is incomplete. Use Resume to recover it before rerunning the export.",
+                    },
+                ],
+            });
+        const conflict = rerunKeys.length > 0 ? activeConflict(deps, projectId, rerunKeys) : undefined;
+        if (conflict !== undefined)
+            return finish(conflictRefusal(conflict));
+        storePreview(deps, preview.value.preview, preview.value.execution);
+        const stored = previewById(deps.db, projectId, preview.value.preview.id);
+        if (stored === undefined)
+            throw new Error("Stored recovery preview is missing.");
+        return {
+            plan: { preview: stored, execution: preview.value.execution },
+            view,
+            authority,
+            rerunKeys,
+            credentials: credentialsStamp(deps, preview.value, view),
+        };
+    });
+    if ("ok" in prepared)
+        return prepared;
+    let ready;
+    try {
+        ready = await checkReadiness(deps, prepared.plan.execution, prepared.view);
+    }
+    catch {
+        deps.log.write("warn", "project.recovery", {
+            projectId,
+            ...(input.action.kind === "resume" ? {} : { stage: input.action.stage }),
+            detail: "Provider readiness could not be loaded.",
+        });
+        ready = {
+            fields: [{ field: "provider", message: "Check provider readiness and try Resume." }],
+            providers: [],
+        };
+    }
+    let admittedHere = false;
+    const result = await withProjectControl(deps.db, projectId, () => transact(deps.db, () => {
+        const receipt = readRecovery(deps, projectId, input);
+        if (receipt !== undefined && "ok" in receipt)
+            return receipt;
+        if (receipt === undefined)
+            return { ok: false, reason: "no-project" };
+        const finish = (value) => rememberRecovery(deps, projectId, input, !value.ok && receipt.intentRevisionId !== null
+            ? { ...value, intentRevisionId: receipt.intentRevisionId }
+            : value);
+        if (recoveryAuthority(deps, projectId) !== prepared.authority)
+            return finish({ ok: false, reason: "control-changed" });
+        if (currentRevisionId(deps.db, projectId) !== prepared.view.revision.id)
+            return finish({ ok: false, reason: "conflict" });
+        if (credentialsStamp(deps, prepared.plan, prepared.view) !== prepared.credentials)
+            return finish({
+                ok: false,
+                reason: "readiness",
+                fields: [
+                    { field: "provider", message: "Provider credentials changed. Try Resume again." },
+                ],
+            });
+        if (ready.fields.length > 0)
+            return finish({ ok: false, reason: "readiness", fields: [...ready.fields] });
+        const conflict = prepared.rerunKeys.length > 0
+            ? activeConflict(deps, projectId, prepared.rerunKeys)
+            : undefined;
+        if (conflict !== undefined)
+            return finish(conflictRefusal(conflict));
+        const admitted = admitCheckedPreview(deps, prepared.plan.preview, prepared.plan.execution, ready.providers, recoveryKey(input, "admit"), requestHash("direct-recovery", input.baseRevisionId, input.action));
+        if (!admitted.ok)
+            return finish(admitted);
+        admittedHere = true;
+        return finish({
+            ok: true,
+            value: {
+                ...admitted.value,
+                workIds: [...admitted.value.workIds],
+                warnings: [
+                    ...prepared.plan.preview.warnings,
+                    ...(prepared.plan.preview.costs.unknown > 0
+                        ? ["Some generation prices are unknown; actual usage is recorded."]
+                        : []),
+                ],
+            },
+        });
+    }));
+    if (result.ok && admittedHere) {
+        deps.emit(projectId, { type: "project.updated", projectId });
+        wakeRebuild(deps, projectId, result.value);
+    }
+    return result;
+}

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

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 import { z } from "zod";
-import { usesNarrationPreparation } from "../admission/rules.js";
+import { usesNarrationPreparation, usesPronunciationGlossary } from "../admission/rules.js";
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
 import { outputPath } from "../storage/layout.js";
@@ -53,7 +53,8 @@ export async function revisionAudio(deps, context, view) {
 }
 export function revisionTranscript(deps, snapshot, kind) {
     const { view, plan } = snapshot;
-    if (usesNarrationPreparation(view.revision.config))
+    if (usesNarrationPreparation(view.revision.config) ||
+        usesPronunciationGlossary(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) {

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { projectSelected } from "../revisions/projection.js";
+import { getRevisionView } from "../revisions/view.js";
+import { bindNarrationReuse, narrationOrdinal } from "./runtime-narration-reuse.js";
+import { executionPlan, savedCatalogue } from "./runtime-plan.js";
+export function rebindPublishedNarration(deps, work, piece) {
+    if (piece.input.kind !== "tts")
+        return;
+    const targets = deps.db
+        .prepare("SELECT revision_id FROM revision_pieces WHERE project_id=? AND publication_id=? AND piece_key=? AND selected=1 AND revision_id!=?")
+        .all(work.projectId, piece.id, piece.key, work.revisionId);
+    if (targets.length === 0)
+        return;
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(work.workId);
+    const catalogue = savedCatalogue(row?.recipe_context);
+    for (const target of targets) {
+        const view = getRevisionView(deps, work.projectId, z.string().parse(target.revision_id));
+        if (view === undefined)
+            continue;
+        const plan = executionPlan(deps, view, catalogue);
+        const recipe = plan.recipes.find((value) => value.key === piece.key && value.fingerprint === piece.fingerprint);
+        if (recipe === undefined || recipe.unresolved || recipe.deferred)
+            continue;
+        bindNarrationReuse(deps, view, recipe, narrationOrdinal(plan.recipes, recipe.key));
+        if (view.current)
+            projectSelected(deps.db, view.revision);
+    }
+}