@gentbajko/slopify 1.5.0 → 2.0.0

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

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

@@ -83,12 +83,14 @@ export function bindNarrationReuse(deps, view, recipe, ordinal) {
     }
     if (recipe.input.kind !== "tts")
         return;
+    const input = recipe.input;
     if (view.pieces.some((one) => one.selected &&
         one.available &&
         one.key === recipe.key &&
         one.fingerprint === recipe.fingerprint &&
         one.piece.state === "done" &&
-        one.piece.idx === ordinal))
+        one.piece.idx === ordinal &&
+        narrationMetadataMatches(one.piece.payload, input)))
         return;
     const history = [...view.pieces, ...retainedNarrationPieces(deps, view.revision.projectId)];
     const available = new Set(history
@@ -97,7 +99,6 @@ export function bindNarrationReuse(deps, view, recipe, ordinal) {
     const old = matchingNarrationPiece(recipe, history, available);
     if (old === undefined)
         return;
-    const input = recipe.input;
     const recordId = deps.ids.next();
     const payload = JSON.parse(old.piece.payload ?? "{}");
     insertManifestPiece(deps.db, view.revision, {
@@ -125,6 +126,23 @@ export function bindNarrationReuse(deps, view, recipe, ordinal) {
     }, recordId);
     selectPieceRecord(deps.db, view.revision.id, recipe.key, recordId);
 }
+function narrationMetadataMatches(payload, input) {
+    const parsed = z
+        .object({
+        text: z.string().optional(),
+        spokenText: z.string().optional(),
+        logicalKey: z.string().optional(),
+        logicalText: z.string().optional(),
+        segment: z.string().optional(),
+    })
+        .safeParse(JSON.parse(payload ?? "{}"));
+    return (parsed.success &&
+        parsed.data.text === input.text &&
+        parsed.data.spokenText === input.spokenText &&
+        parsed.data.logicalKey === input.logicalKey &&
+        parsed.data.logicalText === input.logicalText &&
+        parsed.data.segment === input.segment);
+}
 export function narrationOrdinal(recipes, key) {
     const entry = /^audio:(intro|outro):([0-9]+)$/.exec(key);
     if (entry !== null)

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

@@ -24,14 +24,20 @@ export function savedCatalogue(value) {
 }
 export function executionPlan(deps, view, catalogue) {
     const textOutput = (role) => {
-        const row = view.outputs.find((output) => output.selected && output.available && output.output.role === role);
+        const row = view.outputs.find((output) => output.selected &&
+            output.available &&
+            output.state === "ready" &&
+            output.output.role === role);
         return row === undefined
             ? null
             : readFileSync(outputPath(deps.paths, view.revision.projectId, row.output.path), "utf8");
     };
     const payloads = view.pieces.filter((piece) => piece.selected && piece.piece.state === "done" && piece.piece.payload !== null);
     const resolved = {
-        articleMarkdown: view.articleMarkdown ?? textOutput("article_md"),
+        articleMarkdown: view.revision.content.articleEdited === true ||
+            view.revision.config.sources.article === "provide"
+            ? view.articleMarkdown
+            : textOutput("article_md"),
         researchNotes: textOutput("notes"),
     };
     const research = matchingResearch({

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

@@ -4,6 +4,7 @@ import { publicationAuthority } from "../revisions/publication-rules.js";
 import { commitRevisionOutputs } from "../revisions/publish.js";
 import { insertAsset, insertManifestOutput, revisionById } from "../revisions/repo.js";
 import { discardPreparedAssets, writeAsset } from "../storage/assets.js";
+import { rebindPublishedNarration } from "./runtime-narration-publication.js";
 import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
 export function preparedResult(deps, context, piece, role, asset, durationMs = null, meta = {}) {
     return {
@@ -65,10 +66,14 @@ export async function publishResult(deps, context, piece, outputs, payload, asse
                 }),
             },
         };
-        const result = await commitRevisionOutputs(deps, { work: context.work, pieceId: piece.id, publicationId: piece.id }, outputs, [record]);
-        deps.db
-            .prepare("UPDATE revision_work_pieces SET state='done' WHERE id=? AND work_id=?")
-            .run(piece.id, context.work.workId);
+        const result = transact(deps.db, () => {
+            const committed = commitRevisionOutputs(deps, { work: context.work, pieceId: piece.id, publicationId: piece.id }, outputs, [record]);
+            rebindPublishedNarration(deps, context.work, piece);
+            deps.db
+                .prepare("UPDATE revision_work_pieces SET state='done' WHERE id=? AND work_id=?")
+                .run(piece.id, context.work.workId);
+            return committed;
+        });
         if (result.currentAttached)
             context.emit({ type: "project.updated", projectId: context.work.projectId });
     }

package/dist/slices/rebuild/service.js

@@ -3,7 +3,7 @@ import { requestHash } from "../revisions/mutation-request.js";
 import { currentRevisionId } from "../revisions/repo.js";
 import { getRevisionView } from "../revisions/view.js";
 import { previewRebuildSchema, startRebuildSchema, } from "./model.js";
-import { executionSnapshotSchema, planPreview, reviewStillCovers } from "./preview-plan.js";
+import { executionSnapshotSchema, planPreview, reviewStillCovers, } from "./preview-plan.js";
 import { admissionReceipt, admitPreview, previewById, storePreview } from "./repo.js";
 import { checkReadiness, localReadiness } from "./service-readiness.js";
 export function rebuildConfirmations(required, confirmed, unknownCosts, acknowledged) {
@@ -60,7 +60,7 @@ export async function startRebuild(deps, input) {
     const replay = admissionReceipt(deps.db, projectId, input.idempotencyKey, hash);
     if (replay !== undefined) {
         if (replay.ok)
-            wake(deps, projectId, replay.value);
+            wakeRebuild(deps, projectId, replay.value);
         return replay;
     }
     const preview = previewById(deps.db, projectId, input.previewId);
@@ -100,34 +100,56 @@ export async function startRebuild(deps, input) {
         const again = admissionReceipt(deps.db, projectId, input.idempotencyKey, hash);
         if (again !== undefined) {
             if (again.ok)
-                wake(deps, projectId, again.value);
+                wakeRebuild(deps, projectId, again.value);
             return again;
         }
-        if (currentRevisionId(deps.db, projectId) !== input.baseRevisionId)
-            return { ok: false, reason: "conflict" };
-        const current = getRevisionView(deps, projectId, input.baseRevisionId);
-        if (current === undefined)
-            return { ok: false, reason: "no-project" };
-        const catalogue = deps.catalogue.read();
-        const fresh = planPreview(deps, current, catalogue, preview.selection, preview.id);
-        if (!fresh.ok || !reviewStillCovers(preview, snapshot, fresh.value))
-            return { ok: false, reason: "stale-preview" };
-        const fields = localReadiness(deps, snapshot, current, ready.providers, catalogue);
-        if (fields.length > 0)
-            return { ok: false, reason: "readiness", fields };
-        const admitted = admitPreview(deps, {
-            preview,
-            idempotencyKey: input.idempotencyKey,
-            requestHash: hash,
-        });
+        const admitted = admitCheckedPreview(deps, preview, snapshot, ready.providers, input.idempotencyKey, hash);
         if (admitted.ok) {
             deps.emit(projectId, { type: "project.updated", projectId });
-            wake(deps, projectId, admitted.value);
+            wakeRebuild(deps, projectId, admitted.value);
         }
         return admitted;
     });
 }
-function wake(deps, projectId, admission) {
+export function admitCheckedPreview(deps, preview, snapshot, providers, idempotencyKey, hash) {
+    const replay = admissionReceipt(deps.db, preview.projectId, idempotencyKey, hash);
+    if (replay !== undefined)
+        return replay;
+    if (currentRevisionId(deps.db, preview.projectId) !== preview.baseRevisionId)
+        return { ok: false, reason: "conflict" };
+    const current = getRevisionView(deps, preview.projectId, preview.baseRevisionId);
+    if (current === undefined)
+        return { ok: false, reason: "no-project" };
+    const catalogue = deps.catalogue.read();
+    const fresh = planPreview(deps, current, catalogue, preview.selection, preview.id);
+    if (!fresh.ok || !reviewStillCovers(preview, snapshot, fresh.value))
+        return { ok: false, reason: "stale-preview" };
+    const fields = localReadiness(deps, snapshot, current, providers, catalogue);
+    if (fields.length > 0)
+        return { ok: false, reason: "readiness", fields };
+    for (const recipe of snapshot.recipes) {
+        const running = deps.db
+            .prepare("SELECT r.fingerprint FROM revision_work_reservations r " +
+            "JOIN revision_work w ON w.id=r.work_id WHERE r.revision_id=? " +
+            "AND r.work_key=? AND w.state='running'")
+            .get(preview.baseRevisionId, recipe.key);
+        if (running !== undefined && running.fingerprint !== recipe.fingerprint)
+            return {
+                ok: false,
+                reason: "conflict",
+                fields: [
+                    { field: recipe.key, message: "Wait for this work to finish, or Pause before retrying." },
+                ],
+            };
+    }
+    return admitPreview(deps, {
+        preview,
+        planningCatalogue: catalogue,
+        idempotencyKey,
+        requestHash: hash,
+    });
+}
+export function wakeRebuild(deps, projectId, admission) {
     const owned = deps.db
         .prepare("SELECT 1 FROM revision_work WHERE project_id=? AND admission_id=? AND state!='done' AND dispatch_state='allowed' LIMIT 1")
         .get(projectId, admission.admissionId) !== undefined;

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

@@ -96,7 +96,7 @@ function stageForKey(key) {
         return "research";
     if (prefix === "article" || prefix === "entry")
         return "article";
-    if (prefix === "audio")
+    if (prefix === "audio" || prefix === "narration")
         return "audio";
     if (prefix === "image")
         return "images";

package/dist/slices/revisions/mutation-assets.js

@@ -89,7 +89,12 @@ export function validateAssetReferences(deps, projectId, content, prepared) {
             (!allowPiece ||
                 deps.db
                     .prepare("SELECT 1 FROM revision_pieces WHERE project_id=? AND asset_id=? AND stage_kind=? AND json_extract(descriptor,'$.kind') IN (SELECT value FROM json_each(?))")
-                    .get(projectId, id, kind, JSON.stringify(kind === "audio" ? ["chunk", "segment"] : ["image"])) === undefined))
+                    .get(projectId, id, kind, JSON.stringify(kind === "audio" ? ["chunk", "segment"] : ["image"])) === undefined) &&
+            !(kind === "audio" &&
+                allowPiece &&
+                deps.db
+                    .prepare("SELECT 1 FROM project_revisions r, json_each(r.content, '$.narrationOverrides') o WHERE r.project_id=? AND json_extract(o.value,'$.kind')='asset' AND json_extract(o.value,'$.assetId')=? LIMIT 1")
+                    .get(projectId, id) !== undefined))
             fields.push({ field, message: "Choose an asset for this content stage." });
     }
     return fields;

package/dist/slices/revisions/mutation-request.js

@@ -39,6 +39,10 @@ export function checkMutation(deps, input) {
         .prepare("SELECT 1 FROM project_control_receipts WHERE project_id=? AND idempotency_key=?")
         .get(input.projectId, input.idempotencyKey) !== undefined)
         return refusal(deps, input.projectId, "idempotency-conflict");
+    if (db
+        .prepare("SELECT 1 FROM project_recovery_requests WHERE project_id=? AND idempotency_key=?")
+        .get(input.projectId, input.idempotencyKey) !== undefined)
+        return refusal(deps, input.projectId, "idempotency-conflict");
     if (db.prepare("SELECT 1 FROM projects WHERE id=?").get(input.projectId) === undefined)
         return refusal(deps, input.projectId, "no-project");
     if (currentRevisionId(db, input.projectId) !== input.baseRevisionId)

package/dist/slices/revisions/mutations.js

@@ -16,7 +16,7 @@ import { checkMutation, insertReceipt, requestHash, requiredView } from "./mutat
 import { preserveDeferredIntent } from "./mutation-work.js";
 import { cloneManifest, ensureRevisionStages, projectSelected } from "./projection.js";
 import { insertAsset, insertRevision } from "./repo.js";
-import { validateNarrationIntent, validateTemplateIntent } from "./rules.js";
+import { bindNarrationSources, validateNarrationIntent, validateTemplateIntent } from "./rules.js";
 import { revisionEditSchema } from "./schema.js";
 export { bindUpload } from "./mutation-assets.js";
 export { restoreRevision } from "./restore.js";
@@ -32,16 +32,18 @@ export async function saveRevision(deps, input) {
                 message: row.message,
             })),
         };
-    const edit = parsed.data;
+    const { narrationSources: _submitted, ...content } = parsed.data.content;
+    const submitted = { ...parsed.data, content };
     const identity = {
         ...input,
         operation: "save",
-        hash: requestHash("save", input.baseRevisionId, edit),
+        hash: requestHash("save", input.baseRevisionId, submitted),
     };
     const checked = checkMutation(deps, identity);
     if (checked !== undefined)
         return checked;
     const base = requiredView(deps, input.projectId, input.baseRevisionId);
+    const edit = bindNarrationSources(base, submitted);
     const fields = [
         ...validateUploads(deps, edit),
         ...validateTemplateIntent(base, edit),
@@ -65,14 +67,17 @@ export async function saveRevision(deps, input) {
             const checked = checkMutation(deps, identity);
             if (checked !== undefined)
                 return checked;
+            const blocked = input.beforeCommit?.();
+            if (blocked !== undefined)
+                return blocked;
             const fresh = requiredView(deps, input.projectId, input.baseRevisionId);
             const tokens = { ...fresh.revision.content.regenerationTokens };
             for (const key of new Set((edit.regenerate ?? []).map(narrationRegenerationKey)))
                 tokens[key] = deps.ids.next();
-            const finalEdit = {
+            const finalEdit = bindNarrationSources(fresh, {
                 ...supplied,
                 content: { ...supplied.content, regenerationTokens: tokens },
-            };
+            });
             const outputAssets = prepared.filter((row) => row.upload?.destination.kind !== "narration");
             const inspected = measuredOutputs(deps, fresh, durations);
             const preparedManifest = {

package/dist/slices/revisions/rules.js

@@ -1,6 +1,49 @@
 import { isDeepStrictEqual } from "node:util";
+import { narrationRegenerationKey } from "../narration/plan.js";
+import { bodyNarrationGroups } from "../rebuild/recipe-audio.js";
 import { buildRecipes } from "../rebuild/recipe-build.js";
 import { normalizeArticleIntent, validateRevisionEdit } from "../rebuild/recipe-save.js";
+import { textRecipes } from "../rebuild/recipe-text.js";
+export function bindNarrationSources(base, edit) {
+    const { narrationSources: _submitted, ...content } = normalizeArticleIntent(base, edit);
+    const keys = new Set([
+        ...Object.keys(content.narrationOverrides),
+        ...Object.keys(base.revision.content.regenerationTokens),
+        ...(edit.regenerate ?? []).map(narrationRegenerationKey),
+        ...(edit.uploads ?? []).flatMap((upload) => upload.destination.kind === "narration" ? [upload.destination.key] : []),
+    ]);
+    if (keys.size === 0)
+        return { ...edit, content };
+    const previous = {
+        config: base.revision.config,
+        content: base.revision.content,
+        manifest: base,
+        resolved: {
+            articleMarkdown: base.articleMarkdown,
+            researchNotes: base.revision.config.provided.research ?? null,
+        },
+    };
+    const sources = {
+        ...base.revision.content.narrationSources,
+        ...Object.fromEntries(bodyNarrationGroups(previous, textRecipes(previous)).flatMap((group) => group.source === undefined ? [] : [[group.key, group.source]])),
+    };
+    const proposed = {
+        ...previous,
+        config: edit.config,
+        content: {
+            ...content,
+            narrationSources: Object.fromEntries(Object.entries(sources).filter(([key]) => keys.has(key))),
+        },
+    };
+    const bindings = Object.fromEntries(bodyNarrationGroups(proposed, textRecipes(proposed)).flatMap((group) => group.source !== undefined && keys.has(group.key) ? [[group.key, group.source]] : []));
+    return {
+        ...edit,
+        content: {
+            ...content,
+            ...(Object.keys(bindings).length > 0 ? { narrationSources: bindings } : {}),
+        },
+    };
+}
 export function validateCues(cues, duration) {
     const fields = [];
     const seen = new Set();

package/dist/slices/revisions/schema.js

@@ -47,6 +47,18 @@ export const revisionContentSchema = z
         z.object({ kind: z.literal("asset"), assetId: id }).strict(),
         z.object({ kind: z.literal("text"), text: z.string().trim().min(1).max(500000) }).strict(),
     ])),
+    narrationSources: z
+        .record(workKey, z
+        .object({
+        text: z.string().min(1).max(500000),
+        start: z.number().int().nonnegative().max(500000),
+        bodyFingerprint: z.string().regex(/^[0-9a-f]{64}$/u),
+        chunkingFingerprint: z.string().regex(/^[0-9a-f]{64}$/u),
+    })
+        .strict())
+        .refine((rows) => Object.keys(rows).length <= 10000 &&
+        Object.values(rows).reduce((length, row) => length + row.text.length, 0) <= 500000, "Narration source bindings exceed the article limit.")
+        .optional(),
     subtitleCues: z
         .object({
         audioFingerprint: z.string().min(1),