@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/slices/estimate/index.js

@@ -1,81 +1,99 @@
+import { z } from "zod";
+import { estimateRequests, groupEstimateRows } from "./requests.js";
+export { estimateRequests } from "./requests.js";
 export function estimateRun(draft, rendered, expectedWords, catalogue) {
-    const rows = [];
-    const model = (family, choice) => choice
-        ? catalogue?.models(choice.provider, family).find((m) => m.id === choice.model)
-        : undefined;
-    const llm = model("llm", draft.llm);
-    const tts = model("tts", draft.audio);
-    const image = model("image", draft.images);
+    z.number().finite().nonnegative().parse(expectedWords);
+    const data = catalogue?.read() ?? {
+        schemaVersion: 1,
+        updatedAt: "",
+        providers: {},
+        llm: [],
+        tts: [],
+        image: [],
+    };
+    const requests = [];
+    const llm = draft.llm ?? { provider: "", model: "" };
+    const tts = draft.audio ?? { provider: "", model: "" };
+    const image = draft.images ?? { provider: "", model: "" };
+    const textNote = data.llm.find((model) => model.provider === llm.provider &&
+        model.id === llm.model &&
+        model.enabled &&
+        !model.deprecated)?.pricing.note ??
+        "CLI subscription or model pricing is unavailable; usage may be billed by your account.";
+    const imageNote = data.image.find((model) => model.provider === image.provider &&
+        model.id === image.model &&
+        model.enabled &&
+        !model.deprecated)?.pricing.note ?? "Model or account pricing is unknown.";
     const generatedArticle = draft.sources.article === "generate";
     const articleChars = generatedArticle ? expectedWords * 6 : (draft.provided.article?.length ?? 0);
     const promptChars = Object.values(rendered).reduce((sum, value) => sum + value.length, 0);
-    const row = (stage, amount, detail, variable = false) => {
-        rows.push({
+    const local = (stage, detail) => {
+        requests.push({ kind: "local", stage, detail });
+    };
+    const text = (stage, inputCharacters, outputCharacters, detail) => {
+        requests.push({
+            kind: "llm",
             stage,
-            low: amount === undefined ? null : amount * (variable ? 0.5 : 1),
-            high: amount === undefined ? null : amount * (variable ? 1.5 : 1),
-            detail,
+            provider: llm.provider,
+            model: llm.model,
+            inputCharacters,
+            outputCharacters,
+            detail: detail === undefined ? textNote : `${detail} ${textNote}`,
         });
     };
-    const textCost = (input, output) => {
-        const p = llm?.pricing;
-        return p?.inputPerMillionTokens === undefined || p.outputPerMillionTokens === undefined
-            ? undefined
-            : ((input / 4) * p.inputPerMillionTokens + (output / 4) * p.outputPerMillionTokens) / 1000000;
-    };
-    const textNote = llm?.pricing.note ??
-        "CLI subscription or model pricing is unavailable; usage may be billed by your account.";
     if (draft.sources.research === "generate")
-        row("Research", textCost(promptChars + 6000, 12000), `Assumes about 2,000 words of notes; web search fees are excluded. ${textNote}`, true);
+        text("Research", promptChars + 6000, 12000, "Assumes about 2,000 words of notes; web search fees are excluded.");
     else
-        row("Research", 0, "Provided or off; no generation charge.");
+        local("Research", "Provided or off; no generation charge.");
     if (generatedArticle)
-        row("Article", textCost(promptChars + (draft.sources.research === "generate" ? 12000 : 0), articleChars), `${expectedWords.toLocaleString()} expected words. ${textNote}`, true);
+        text("Article", promptChars + (draft.sources.research === "generate" ? 12000 : 0), articleChars, `${expectedWords.toLocaleString()} expected words.`);
     else
-        row("Article", 0, "Provided article; no generation charge.");
+        local("Article", "Provided article; no generation charge.");
     if (draft.intro?.mode === "llm" || draft.outro?.mode === "llm")
-        row("Intro / outro text", textCost(promptChars + articleChars, 2400), textNote, true);
+        text("Intro / outro text", promptChars + articleChars, 2400);
     if (draft.sources.audio === "generate") {
         const extras = ["intro", "outro"].reduce((n, key) => n + (rendered[key]?.length ?? 0), 0);
         const llmExtras = (draft.intro?.mode === "llm" ? 1200 : 0) + (draft.outro?.mode === "llm" ? 1200 : 0);
-        const chars = articleChars + extras + llmExtras;
-        const p = tts?.pricing;
-        const amount = p?.perMillionCharacters === undefined
-            ? p?.perMinute === undefined
-                ? undefined
-                : (chars / 6 / 150) * p.perMinute
-            : (chars / 1000000) * p.perMillionCharacters;
-        row("Narration", amount, `About ${chars.toLocaleString()} characters. ${p?.note ?? "Account pricing is unknown."}`, generatedArticle || llmExtras > 0 || p?.perMinute !== undefined);
+        const choice = { stage: "Narration", provider: tts.provider, model: tts.model };
+        requests.push(generatedArticle || llmExtras > 0
+            ? { ...choice, kind: "tts-estimate", characters: articleChars + extras + llmExtras }
+            : {
+                ...choice,
+                kind: "tts",
+                text: (draft.provided.article ?? "") + (rendered.intro ?? "") + (rendered.outro ?? ""),
+            });
     }
     else
-        row("Narration", 0, "Provided or off; no generation charge.");
-    const images = draft.sources.images === "generate" ? draft.imagePrompts.reduce((n, p) => n + p.number, 0) : 0;
-    row("Images", images === 0
-        ? 0
-        : image?.pricing.perImage === undefined
-            ? undefined
-            : images * image.pricing.perImage, images === 0
-        ? "Provided or off."
-        : `${images} images. ${image?.pricing.note ?? "Model or account pricing is unknown."}`);
-    const thumbnail = ["from_prompt", "prompt_by_llm"].includes(draft.sources.thumbnail);
-    row("Thumbnail", thumbnail ? image?.pricing.perImage : 0, thumbnail
-        ? (image?.pricing.note ?? "Model or account pricing is unknown.")
-        : "Provided or off.");
+        local("Narration", "Provided or off; no generation charge.");
+    const images = draft.sources.images === "generate"
+        ? draft.imagePrompts.reduce((n, prompt) => n + prompt.number, 0)
+        : 0;
+    z.number().int().nonnegative().parse(images);
+    for (let index = 0; index < images; index++)
+        requests.push({
+            kind: "image",
+            stage: "Images",
+            provider: image.provider,
+            model: image.model,
+            detail: `${images} images. ${imageNote}`,
+        });
+    if (images === 0)
+        local("Images", "Provided or off.");
+    if (["from_prompt", "prompt_by_llm"].includes(draft.sources.thumbnail))
+        requests.push({
+            kind: "image",
+            stage: "Thumbnail",
+            provider: image.provider,
+            model: image.model,
+        });
+    else
+        local("Thumbnail", "Provided or off.");
     if (draft.sources.thumbnail === "prompt_by_llm")
-        row("Thumbnail prompt", textCost(promptChars + articleChars, 1200), textNote, true);
-    row("Export / subtitles", 0, "Local processing; no API fee.");
+        text("Thumbnail prompt", promptChars + articleChars, 1200);
+    local("Export / subtitles", "Local processing; no API fee.");
     return {
-        currency: "USD",
-        rows,
+        ...groupEstimateRows(estimateRequests(requests, data)),
         expectedWords,
-        catalogueDate: catalogue?.status().updatedAt ?? null,
-        low: rows.reduce((n, r) => n + (r.low ?? 0), 0),
-        high: rows.reduce((n, r) => n + (r.high ?? 0), 0),
-        unknown: rows.filter((r) => r.low === null).length,
-        assumptions: [
-            "Planning estimate, not a spending limit. Generated lengths use a ±50% range; actual output can exceed it.",
-            "Assumes roughly 6 characters per word, 4 characters per token, and 150 spoken words per minute.",
-            "Retries, extra reasoning tokens, web tools, taxes, discounts and included credits are excluded. Unknown charges are not counted as zero.",
-        ],
+        catalogueDate: catalogue === undefined ? null : data.updatedAt,
     };
 }

package/dist/slices/estimate/requests.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+const quantity = z.number().finite().nonnegative();
+const common = z.object({
+    stage: z.string(),
+    detail: z.string().optional(),
+    variable: z.boolean().optional(),
+    expectedWords: quantity.optional(),
+});
+const provider = common.extend({ provider: z.string(), model: z.string() });
+const requestSchema = z.discriminatedUnion("kind", [
+    provider
+        .extend({ kind: z.literal("llm"), inputCharacters: quantity, outputCharacters: quantity })
+        .strict(),
+    provider.extend({ kind: z.literal("tts"), text: z.string() }).strict(),
+    provider.extend({ kind: z.literal("tts-estimate"), characters: quantity }).strict(),
+    provider.extend({ kind: z.literal("image") }).strict(),
+    common.extend({ kind: z.literal("local") }).strict(),
+]);
+export function estimateRequests(requests, catalogue) {
+    const parsed = z.array(requestSchema).parse(requests);
+    const rows = parsed.map((request) => price(request, catalogue));
+    return {
+        currency: "USD",
+        rows,
+        low: rows.reduce((total, row) => total + (row.low ?? 0), 0),
+        high: rows.reduce((total, row) => total + (row.high ?? 0), 0),
+        unknown: rows.filter((row) => row.low === null).length,
+        expectedWords: parsed.reduce((total, request) => total + (request.expectedWords ?? 0), 0),
+        catalogueDate: catalogue.updatedAt,
+        assumptions: [
+            "Planning estimate, not a spending limit. Generated lengths use a ±50% range; actual output can exceed it.",
+            "Assumes roughly 6 characters per word, 4 characters per token, and 150 spoken words per minute.",
+            "Retries, extra reasoning tokens, web tools, taxes, discounts and included credits are excluded. Unknown charges are not counted as zero.",
+        ],
+    };
+}
+export function groupEstimateRows(estimate) {
+    const grouped = new Map();
+    for (const row of estimate.rows) {
+        const previous = grouped.get(row.stage);
+        grouped.set(row.stage, previous === undefined
+            ? row
+            : {
+                ...previous,
+                low: previous.low === null || row.low === null ? null : previous.low + row.low,
+                high: previous.high === null || row.high === null ? null : previous.high + row.high,
+            });
+    }
+    const rows = [...grouped.values()];
+    return { ...estimate, rows, unknown: rows.filter((row) => row.low === null).length };
+}
+function price(request, catalogue) {
+    if (request.kind === "local")
+        return {
+            stage: request.stage,
+            low: 0,
+            high: 0,
+            detail: request.detail ?? "Local processing or retained output; no API fee.",
+        };
+    const family = request.kind === "tts-estimate" ? "tts" : request.kind;
+    const model = catalogue[family].find((entry) => entry.provider === request.provider &&
+        entry.id === request.model &&
+        entry.enabled &&
+        !entry.deprecated);
+    const rates = model?.pricing;
+    let amount;
+    let variable = request.variable === true;
+    let detail = rates?.note ?? "Model or account pricing is unknown.";
+    switch (request.kind) {
+        case "llm":
+            if (rates?.inputPerMillionTokens !== undefined && rates.outputPerMillionTokens !== undefined)
+                amount =
+                    ((request.inputCharacters / 4) * rates.inputPerMillionTokens +
+                        (request.outputCharacters / 4) * rates.outputPerMillionTokens) /
+                        1000000;
+            variable = true;
+            break;
+        case "tts":
+        case "tts-estimate": {
+            const characters = request.kind === "tts" ? request.text.length : request.characters;
+            const perMinute = rates?.perMillionCharacters === undefined && rates?.perMinute !== undefined;
+            if (rates?.perMillionCharacters !== undefined)
+                amount = (characters / 1000000) * rates.perMillionCharacters;
+            else if (rates?.perMinute !== undefined)
+                amount = (characters / 6 / 150) * rates.perMinute;
+            variable ||= request.kind === "tts-estimate" || perMinute;
+            detail = `About ${characters.toLocaleString()} characters. ${detail}`;
+            break;
+        }
+        case "image":
+            amount = rates?.perImage;
+            break;
+    }
+    if (amount !== undefined)
+        quantity.parse(amount);
+    return {
+        stage: request.stage,
+        low: amount === undefined ? null : amount * (variable ? 0.5 : 1),
+        high: amount === undefined ? null : amount * (variable ? 1.5 : 1),
+        detail: request.detail ?? detail,
+    };
+}

package/dist/slices/images/run.js

@@ -38,7 +38,10 @@ export async function runImages(deps, context, providers) {
     }
     // The run's own frame. The adapter turns it into whatever its provider spells the
     // closest supported size, and the render crops whatever is left over.
-    const made = await sendAll(deps, context, providers, choice, pieces, project.format);
+    const result = await sendAll(deps, context, providers, choice, pieces, project.format);
+    if (!result.ok)
+        return "held";
+    const made = result.value;
     // Images made means images stored, and only the ones this run stored: a resume does not
     // count an image the previous run made, and a regenerated image counts again.
     //
@@ -56,6 +59,7 @@ export async function runImages(deps, context, providers) {
         stage: "images",
         detail: `${String(pieces.length)} images from ${String(project.config.imagePrompts.length)} prompts`,
     });
+    return "done";
 }
 // For each ticked image prompt, its rendered text is sent Number times as independent
 // parallel calls. The plan is made once and kept, so a retry finds the rows the first run
@@ -117,12 +121,17 @@ async function sendAll(deps, context, providers, choice, pieces, format) {
         }
         setPiece(deps.db, piece.id, "running", piece.payload);
         try {
-            const made = await providers.forPiece(piece.id).image({
+            const result = await providers.forPiece(piece.id).image({
                 provider: choice.provider,
                 model: choice.model,
                 prompt: asked.prompt,
                 aspect: format,
             });
+            if (!result.ok) {
+                setPiece(deps.db, piece.id, "pending", piece.payload);
+                return result;
+            }
+            const made = result.value;
             const file = keep(deps, projectId, piece.idx, made);
             // The prompt text, the prompt name, the index within the prompt, the
             // provider and the model travel with the image.
@@ -146,11 +155,13 @@ async function sendAll(deps, context, providers, choice, pieces, format) {
     let made = 0;
     for (const outcome of outcomes) {
         if (!outcome.ok) {
+            if ("reason" in outcome)
+                return outcome;
             throw outcome.error;
         }
         made += outcome.made ? 1 : 0;
     }
-    return made;
+    return { ok: true, value: made };
 }
 // An image counts as landed only when its row and its file are both still there: they are
 // written one after the other, the boot reconcile can remove a file whose row survived,

package/dist/slices/library/slots.js

@@ -4,8 +4,8 @@
 // is the one that runs.
 import { normaliseDraft } from "../admission/rules.js";
 import { collectFields, render } from "../admission/substitute.js";
-import { entryByName, promptByName } from "./repo.js";
-export function pickTemplates(db, input) {
+import { snapshotEntry, snapshotPrompt } from "./snapshot.js";
+export function pickTemplates(db, input, snapshot) {
     const draft = normaliseDraft(input);
     const { sources } = draft;
     const missing = [];
@@ -14,22 +14,22 @@ export function pickTemplates(db, input) {
     const text = [];
     const image = [];
     if (sources.article === "generate") {
-        body(db, "article", draft.articlePrompt, "articlePrompt", missing, text, "article");
+        body(db, "article", draft.articlePrompt, "articlePrompt", missing, text, "article", snapshot);
     }
-    const intro = pickEntry(db, "intro", draft.intro, missing);
-    const outro = pickEntry(db, "outro", draft.outro, missing);
+    const intro = pickEntry(db, "intro", draft.intro, missing, snapshot);
+    const outro = pickEntry(db, "outro", draft.outro, missing, snapshot);
     push(text, "intro", intro);
     push(text, "outro", outro);
     if (sources.images === "generate") {
         for (const [index, picked] of draft.imagePrompts.entries()) {
             const field = `imagePrompts.${String(index)}.name`;
-            body(db, "image", picked.name, field, missing, image, `imagePrompts.${String(index)}`);
+            body(db, "image", picked.name, field, missing, image, `imagePrompts.${String(index)}`, snapshot);
         }
     }
     // Both Generate modes read the same thumbnail template; Prompt by LLM sends it as the
     // instruction rather than to the image provider.
     if (sources.thumbnail === "from_prompt" || sources.thumbnail === "prompt_by_llm") {
-        body(db, "thumbnail", draft.thumbnailPrompt, "thumbnailPrompt", missing, image, "thumbnailPrompt");
+        body(db, "thumbnail", draft.thumbnailPrompt, "thumbnailPrompt", missing, image, "thumbnailPrompt", snapshot);
     }
     const fields = collectFields(text.map((picked) => picked.body), image.map((picked) => picked.body));
     return {
@@ -48,24 +48,24 @@ export function renderPicked(picked, values) {
     }
     return rendered;
 }
-function body(db, kind, name, field, missing, into, key) {
+function body(db, kind, name, field, missing, into, key, snapshot) {
     // An unpicked prompt is admission's rule to state ("Pick an article prompt."), so this
     // says nothing about it and the form marks the field once.
     if (name === undefined || name.trim() === "") {
         return;
     }
-    const prompt = promptByName(db, kind, name);
+    const prompt = snapshotPrompt(db, snapshot, kind, name);
     if (prompt === undefined) {
         missing.push({ field, message: `That ${kind} prompt no longer exists; pick another.` });
         return;
     }
     into.push({ key, body: prompt.body });
 }
-function pickEntry(db, category, choice, missing) {
+function pickEntry(db, category, choice, missing, snapshot) {
     if (choice === undefined) {
         return undefined;
     }
-    const entry = entryByName(db, category, choice.name);
+    const entry = snapshotEntry(db, snapshot, category, choice.name);
     if (entry === undefined) {
         missing.push({
             field: category,

package/dist/slices/library/snapshot.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { entryCategories, entryModes, promptKinds } from "./model.js";
+import { entryByName, promptByName } from "./repo.js";
+const base = z.object({
+    id: z.string(),
+    name: z.string(),
+    body: z.string(),
+    slots: z.array(z.string()).readonly(),
+    updatedAt: z.string(),
+});
+export const librarySnapshotSchema = z
+    .object({
+    prompts: z
+        .array(base
+        .extend({ kind: z.enum(promptKinds) })
+        .strict()
+        .readonly())
+        .readonly(),
+    entries: z
+        .array(base
+        .extend({ category: z.enum(entryCategories), mode: z.enum(entryModes) })
+        .strict()
+        .readonly())
+        .readonly(),
+})
+    .strict()
+    .readonly();
+export function snapshotPrompt(db, snapshot, kind, name) {
+    return (snapshot?.prompts.find((row) => row.kind === kind && row.name.toLowerCase() === name.toLowerCase()) ?? promptByName(db, kind, name));
+}
+export function snapshotEntry(db, snapshot, category, name) {
+    return (snapshot?.entries.find((row) => row.category === category && row.name.toLowerCase() === name.toLowerCase()) ?? entryByName(db, category, name));
+}

package/dist/slices/narration/legacy-plan.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { splitText } from "../../kernel/ports/text.js";
+import { insertPiece, piecesOf } from "../../kernel/runner/piece-repo.js";
+const payload = z.object({ text: z.string(), file: z.string().optional() });
+// Old whole-text plans can exceed a newly known account limit. Preserve finished
+// pieces and their paths, and split only unfinished work before any request starts.
+export function planLegacyNarration(deps, stageId, texts, maxCharacters, finished) {
+    const old = piecesOf(deps.db, stageId, "chunk");
+    const source = old.length
+        ? old
+        : texts.map((text, idx) => ({
+            id: deps.ids.next(),
+            stageId,
+            kind: "chunk",
+            idx: idx + 1,
+            state: "pending",
+            payload: JSON.stringify({ text }),
+        }));
+    const planned = [];
+    for (const piece of source) {
+        const data = payload.parse(JSON.parse(piece.payload ?? "null"));
+        if (finished(piece)) {
+            planned.push({ ...piece, idx: planned.length + 1 });
+            continue;
+        }
+        for (const [part, text] of splitText(data.text, maxCharacters).entries())
+            planned.push({
+                ...piece,
+                id: part === 0 ? piece.id : deps.ids.next(),
+                idx: planned.length + 1,
+                state: "pending",
+                payload: JSON.stringify({ text }),
+            });
+    }
+    if (old.length &&
+        planned.length === old.length &&
+        planned.every((p, i) => p.id === old[i]?.id &&
+            payload.parse(JSON.parse(p.payload ?? "null")).text ===
+                payload.parse(JSON.parse(old[i]?.payload ?? "null")).text))
+        return old;
+    transact(deps.db, () => {
+        // Negative temporary indices avoid colliding with a retained completed piece.
+        deps.db
+            .prepare("UPDATE stage_pieces SET idx=-idx WHERE stage_id=? AND kind='chunk'")
+            .run(stageId);
+        const known = new Set(old.map((p) => p.id));
+        for (const piece of planned) {
+            if (known.has(piece.id))
+                deps.db
+                    .prepare("UPDATE stage_pieces SET idx=?,state=?,payload=? WHERE id=?")
+                    .run(piece.idx, piece.state, piece.payload, piece.id);
+            else
+                insertPiece(deps.db, piece);
+        }
+    });
+    return planned;
+}

package/dist/slices/narration/live.js

@@ -1,11 +1,11 @@
-export function observeNarration(store, projectId, key, label) {
+export function observeNarration(store, projectId, key, label, origin) {
     if (store === undefined)
         return undefined;
     let sink;
     return (event) => {
         switch (event.type) {
             case "start":
-                sink = store.begin(projectId, key, label);
+                sink = store.begin(projectId, key, label, origin);
                 break;
             case "chunk":
                 sink?.append(event.bytes);

package/dist/slices/narration/plan.js

@@ -1,58 +1,52 @@
-import { z } from "zod";
-import { transact } from "../../kernel/db/tx.js";
 import { splitText } from "../../kernel/ports/text.js";
-import { insertPiece, piecesOf } from "../../kernel/runner/piece-repo.js";
-const payload = z.object({ text: z.string(), file: z.string().optional() });
-// Old whole-text plans can exceed a newly known account limit. Preserve finished
-// pieces and their paths, and split only unfinished work before any request starts.
-export function planNarration(deps, stageId, texts, maxCharacters, finished) {
-    const old = piecesOf(deps.db, stageId, "chunk");
-    const source = old.length
-        ? old
-        : texts.map((text, idx) => ({
-            id: deps.ids.next(),
-            stageId,
-            kind: "chunk",
-            idx: idx + 1,
-            state: "pending",
-            payload: JSON.stringify({ text }),
-        }));
-    const planned = [];
-    for (const piece of source) {
-        const data = payload.parse(JSON.parse(piece.payload ?? "null"));
-        if (finished(piece)) {
-            planned.push({ ...piece, idx: planned.length + 1 });
-            continue;
-        }
-        for (const [part, text] of splitText(data.text, maxCharacters).entries())
-            planned.push({
-                ...piece,
-                id: part === 0 ? piece.id : deps.ids.next(),
-                idx: planned.length + 1,
-                state: "pending",
-                payload: JSON.stringify({ text }),
+import { fingerprint } from "../../kernel/runner/work.js";
+export function normalizeNarrationText(text) {
+    return text.replace(/\r\n?/g, "\n").trim();
+}
+export function narrationRequestFingerprint(input) {
+    return fingerprint([
+        "narration-request-v1",
+        input.provider,
+        input.model,
+        input.voice,
+        input.text,
+        null,
+        input.segment,
+        input.wholeText === null ? null : fingerprint(["whole-v1", input.wholeText]),
+    ]);
+}
+export function planNarration(input) {
+    return input.groups.flatMap((group) => {
+        const text = normalizeNarrationText(group.text);
+        return splitText(text, input.maxCharacters).map((part, index) => {
+            const requestFingerprint = narrationRequestFingerprint({
+                ...input,
+                text: part,
+                segment: group.segment,
+                wholeText: group.wholeRequest ? text : null,
             });
-    }
-    if (old.length &&
-        planned.length === old.length &&
-        planned.every((p, i) => p.id === old[i]?.id &&
-            payload.parse(JSON.parse(p.payload ?? "null")).text ===
-                payload.parse(JSON.parse(old[i]?.payload ?? "null")).text))
-        return old;
-    transact(deps.db, () => {
-        // Negative temporary indices avoid colliding with a retained completed piece.
-        deps.db
-            .prepare("UPDATE stage_pieces SET idx=-idx WHERE stage_id=? AND kind='chunk'")
-            .run(stageId);
-        const known = new Set(old.map((p) => p.id));
-        for (const piece of planned) {
-            if (known.has(piece.id))
-                deps.db
-                    .prepare("UPDATE stage_pieces SET idx=?,state=?,payload=? WHERE id=?")
-                    .run(piece.idx, piece.state, piece.payload, piece.id);
-            else
-                insertPiece(deps.db, piece);
-        }
+            const workFingerprint = fingerprint([requestFingerprint, group.regenerationToken]);
+            const retained = group.regenerationToken === null
+                ? input.retained.find((one) => one.available && one.requestFingerprint === requestFingerprint)
+                : input.retained.find((one) => one.available && one.fingerprint === workFingerprint);
+            return {
+                key: `${group.key}:${index + 1}`,
+                logicalKey: group.key,
+                logicalText: text,
+                segment: group.segment,
+                text: part,
+                requestFingerprint,
+                fingerprint: workFingerprint,
+                assetId: retained?.assetId ?? null,
+            };
+        });
     });
-    return planned;
+}
+export function narrationRegenerationToken(tokens, logicalKey, segment) {
+    return tokens[logicalKey] ?? tokens[`audio:${segment}:future`] ?? null;
+}
+export function narrationRegenerationKey(key) {
+    return /^audio:(body:.+|intro|outro):[0-9]+$/.test(key)
+        ? key.slice(0, key.lastIndexOf(":"))
+        : key;
 }