@gentbajko/slopify 2.4.0 → 3.0.0

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

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

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

@@ -25,6 +25,8 @@ export function youtubeRecipes(context, exports) {
                 // ships as a new operation version rather than a silent change here.
                 config.descriptionPrompt?.trim() ? renderedPrompt(context, "description") : "",
                 config.title,
+                // The project language, only when it is not English, so English keeps its fingerprint.
+                ...(config.language === undefined || config.language === "en" ? [] : [config.language]),
             ],
         }, [timing.key], 
         // A paid LLM call: readiness, the charge warning and the estimate treat it like one.

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

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

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

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

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

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

package/dist/slices/rebuild/recovery.js

@@ -10,7 +10,7 @@ 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 { dependentClosure, recoverySelection, redoTarget, regenerationEdit, sectionRoots, } from "./recovery-selection.js";
 import { previewById, storePreview } from "./repo.js";
 import { admitCheckedPreview, wakeRebuild } from "./service.js";
 import { checkReadiness } from "./service-readiness.js";
@@ -27,7 +27,10 @@ function credentialsStamp(deps, plan, view) {
         .filter((row) => providers.has(String(row.provider)));
     return requestHash("recovery-credentials", view.revision.id, metadata);
 }
-export async function recoverProject(deps, projectId, raw) {
+export async function recoverProject(deps, projectId, raw, 
+// Set only by an automatic review redo (`review-redo.ts`): see `activeConflict`.
+options = {}) {
+    const superseded = options.pendingSuperseded === true;
     const parsed = recoveryRequestSchema.safeParse(raw);
     if (!parsed.success)
         return {
@@ -39,6 +42,12 @@ export async function recoverProject(deps, projectId, raw) {
             })),
         };
     const input = parsed.data;
+    // Where a rerun or a redo starts: the stage's generated work, or the reviewed item's.
+    const rootsOf = (view, plan) => input.action.kind === "rerun"
+        ? sectionRoots(view, plan, input.action.stage)
+        : input.action.kind === "redo"
+            ? (redoTarget(view, plan, input.action.item)?.roots ?? [])
+            : [];
     const prepared = await withProjectControl(deps.db, projectId, async () => {
         const found = readRecovery(deps, projectId, input);
         if (found !== undefined && "ok" in found)
@@ -54,7 +63,11 @@ export async function recoverProject(deps, projectId, raw) {
             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;
+            const edit = input.action.kind === "rerun"
+                ? regenerationEdit(base, plan, input.action.stage)
+                : input.action.kind === "redo"
+                    ? redoTarget(base, plan, input.action.item)?.edit
+                    : null;
             if (edit === undefined)
                 return {
                     ok: false,
@@ -62,7 +75,9 @@ export async function recoverProject(deps, projectId, raw) {
                     fields: [
                         {
                             field: "stage",
-                            message: "This section has no generated work to rerun. Use Edit project to change its source.",
+                            message: input.action.kind === "redo"
+                                ? "This item is no longer made by the project (it was removed, or its source changed), so it can't be made again. Reload the project page."
+                                : "This section has no generated work to rerun. Use Edit project to change its source.",
                         },
                     ],
                 };
@@ -76,14 +91,15 @@ export async function recoverProject(deps, projectId, raw) {
         let view = base;
         if (record.edit !== null) {
             const prior = retainedPreviewPlan(deps, base, deps.catalogue.read());
-            const action = input.action;
-            if (action.kind !== "rerun")
+            if (input.action.kind !== "rerun" && input.action.kind !== "redo")
                 throw new Error("Slopify hit an internal error (a recovery edit has nothing to re-run). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-            const affected = dependentClosure(prior.recipes, sectionRoots(base, prior, action.stage));
+            const affected = dependentClosure(prior.recipes, rootsOf(base, prior));
             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;
+            const conflict = savedIntent === undefined
+                ? activeConflict(deps, projectId, affected, superseded)
+                : undefined;
             if (conflict !== undefined)
                 return finish(conflictRefusal(conflict));
             const saved = await saveRevision(deps, {
@@ -92,7 +108,7 @@ export async function recoverProject(deps, projectId, raw) {
                 idempotencyKey: recoveryKey(input, "save"),
                 edit: record.edit,
                 beforeCommit: () => {
-                    const late = activeConflict(deps, projectId, affected);
+                    const late = activeConflict(deps, projectId, affected, superseded);
                     return late === undefined
                         ? undefined
                         : {
@@ -121,10 +137,10 @@ export async function recoverProject(deps, projectId, raw) {
         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 rerunKeys = input.action.kind === "rerun" || input.action.kind === "redo"
+            ? dependentClosure(plan.recipes, rootsOf(view, plan))
             : [];
-        const selection = input.action.kind === "rerun"
+        const selection = input.action.kind === "rerun" || input.action.kind === "redo"
             ? { kind: "selected", workKeys: rerunKeys }
             : recoverySelection(plan, input.action.kind === "retry" ? input.action.stage : undefined);
         if (selection.kind === "selected" && selection.workKeys.length === 0)
@@ -167,15 +183,15 @@ export async function recoverProject(deps, projectId, raw) {
                     input.action.stage === "video"
                         ? {
                             field: "video",
-                            message: "Source media is incomplete. Use Resume to recover it before rerunning the export.",
+                            message: "Source media is incomplete. Use Continue the run to recover it before rerunning the export.",
                         }
                         : {
                             field: "document",
-                            message: "The article or thumbnail the document is made from isn't finished. Use Resume to finish it, then Re-run section on Document.",
+                            message: "The article or thumbnail the document is made from isn't finished. Use Continue the run to finish it, then More → make it again in its section on Document.",
                         },
                 ],
             });
-        const conflict = rerunKeys.length > 0 ? activeConflict(deps, projectId, rerunKeys) : undefined;
+        const conflict = rerunKeys.length > 0 ? activeConflict(deps, projectId, rerunKeys, superseded) : undefined;
         if (conflict !== undefined)
             return finish(conflictRefusal(conflict));
         storePreview(deps, preview.value.preview, preview.value.execution);
@@ -199,7 +215,9 @@ export async function recoverProject(deps, projectId, raw) {
     catch {
         deps.log.write("warn", "project.recovery", {
             projectId,
-            ...(input.action.kind === "resume" ? {} : { stage: input.action.stage }),
+            ...(input.action.kind === "resume" || input.action.kind === "redo"
+                ? {}
+                : { stage: input.action.stage }),
             detail: "Provider readiness could not be loaded.",
         });
         ready = {
@@ -232,7 +250,7 @@ export async function recoverProject(deps, projectId, raw) {
         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)
+            ? activeConflict(deps, projectId, prepared.rerunKeys, superseded)
             : undefined;
         if (conflict !== undefined)
             return finish(conflictRefusal(conflict));

package/dist/slices/rebuild/repo.js

@@ -7,7 +7,7 @@ export { transitionRevisionWork } from "./transition-repo.js";
 export function publicationTargets(db, publication, workKey, workFingerprint) {
     const { work, pieceId, publicationId } = publication;
     if (publicationId !== (pieceId ?? work.workId))
-        throw new Error("Slopify hit an internal error (a finished result is filed under the wrong step). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (a finished result is filed under the wrong step). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     if (!workExists(db, work))
         return [];
     if (pieceId !== null) {
@@ -15,9 +15,9 @@ export function publicationTargets(db, publication, workKey, workFingerprint) {
             .prepare("SELECT work_key,fingerprint FROM revision_work_pieces WHERE id=? AND work_id=?")
             .get(pieceId, work.workId);
         if (piece === undefined)
-            throw new Error("Slopify hit an internal error (a finished result belongs to a different step). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (a finished result belongs to a different step). Try again; if it happens again, use Download diagnostics in Settings and report it.");
         if (piece.work_key !== workKey || piece.fingerprint !== workFingerprint)
-            throw new Error("Slopify hit an internal error (a finished result doesn't match its saved step). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (a finished result doesn't match its saved step). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     const currentId = currentRevisionId(db, work.projectId);
     const owns = (revisionId) => {

package/dist/slices/rebuild/retry.js

@@ -0,0 +1,18 @@
+import { autoRetryDelay } from "../../kernel/runner/retry-policy.js";
+import { autoRetriesOf, deferWork, dueRetries } from "../../kernel/runner/work-authority.js";
+// The runner's store for the second tier of the retry policy (`kernel/runner/retry-policy.ts`):
+// a failure time can fix puts the step back to wait, with the time it may run again.
+export function waitToRetry(deps, work, fault, reason, random) {
+    const delay = autoRetryDelay(fault, autoRetriesOf(deps.db, work), random);
+    if (delay === undefined || fault === undefined)
+        return undefined;
+    const at = new Date(deps.clock.now().getTime() + delay).toISOString();
+    return deferWork(deps.db, work, at, reason, fault.kind) ? at : undefined;
+}
+// Ticks every project with a wait that has run out. Returns them, for the log and tests.
+export function wakeRetries(db, clock, runner) {
+    const due = dueRetries(db, clock.now().toISOString());
+    for (const projectId of due)
+        runner.tick(projectId);
+    return due;
+}

package/dist/slices/rebuild/review-redo.js

@@ -0,0 +1,110 @@
+import { createHash } from "node:crypto";
+import { reviewKey } from "../reviews/model.js";
+import { pendingRedos, setRedoState } from "../reviews/repo.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { recoverProject } from "./recovery.js";
+import { dependentClosure } from "./recovery-selection.js";
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { workPieces } from "./work-records.js";
+// While a review's verdict waits to send its item back, what depends on the item waits too:
+// the automatic redo replaces that work, and starting it on the failed item would be wasted.
+// The same claim-time hold a review checkpoint uses, answered by the reviewer.
+export function reviewHold(deps, work) {
+    const waiting = pendingRedos(deps.db, work.projectId).filter((row) => row.revisionId === work.revisionId);
+    if (waiting.length === 0)
+        return { kind: "eligible" };
+    const view = executionView(deps, work.projectId, work.revisionId);
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(work.workId);
+    if (view === undefined || row === undefined)
+        return { kind: "eligible" };
+    const plan = executionPlan(deps, view, savedCatalogue(row.recipe_context));
+    const keys = new Set(workPieces(deps.db, work.workId).map((piece) => piece.key));
+    const held = waiting.filter((verdict) => {
+        const review = reviewKey(verdict.itemKey);
+        return dependentClosure(plan.recipes, [review]).some((key) => key !== review && keys.has(key));
+    });
+    return held.length === 0
+        ? { kind: "eligible" }
+        : { kind: "held", checkpointIds: held.map((verdict) => `review:${verdict.id}`) };
+}
+// Starts the redos reviews asked for, once their review step has finished: the item is made
+// again through Re-run's path (a new regeneration token saved as a new project version, then
+// its dependents rebuilt), so the redone item, its new review and everything after it are
+// ordinary recipe work. One at a time per verdict; a redo that cannot start leaves the item
+// flagged with the reason and releases what was waiting on it.
+export function createReviewRedos() {
+    let bound;
+    const running = new Set();
+    const kick = (projectId) => {
+        const deps = bound;
+        if (deps === undefined)
+            return;
+        for (const verdict of pendingRedos(deps.db, projectId)) {
+            if (running.has(verdict.id))
+                continue;
+            running.add(verdict.id);
+            void startRedo(deps, verdict)
+                .catch((error) => {
+                deps.log.write("error", "review.redo", {
+                    projectId: verdict.projectId,
+                    detail: error instanceof Error ? error.message : String(error),
+                });
+                setRedoState(deps.db, verdict.id, "failed", "Slopify hit an internal error while making this item again. Use Redo beside it; if it happens again, use Download diagnostics in Settings and report it.");
+            })
+                .finally(() => {
+                running.delete(verdict.id);
+                try {
+                    deps.runner.tick(verdict.projectId);
+                }
+                catch {
+                    // The next tick of this project picks the released work up.
+                }
+            });
+        }
+    };
+    return {
+        bind: (deps) => {
+            bound = deps;
+        },
+        kick,
+    };
+}
+export async function startRedo(deps, verdict) {
+    const base = currentRevisionId(deps.db, verdict.projectId);
+    if (base === undefined) {
+        setRedoState(deps.db, verdict.id, "failed", "The project no longer exists.");
+        return;
+    }
+    const result = await recoverProject(deps, verdict.projectId, {
+        baseRevisionId: base,
+        idempotencyKey: redoKey(verdict.id),
+        action: { kind: "redo", item: verdict.itemKey },
+    }, { pendingSuperseded: true });
+    if (result.ok)
+        setRedoState(deps.db, verdict.id, "started");
+    else
+        setRedoState(deps.db, verdict.id, "failed", redoRefusal(result));
+    deps.emit(verdict.projectId, { type: "project.updated", projectId: verdict.projectId });
+}
+// A stable request identity per verdict, so a restart that starts the same redo again gets
+// the first attempt's answer instead of a second redo.
+export function redoKey(verdictId) {
+    const hex = createHash("sha256").update(`review-redo:${verdictId}`).digest("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+export function redoRefusal(result) {
+    const detail = result.fields?.map((field) => field.message).join(" ");
+    switch (result.reason) {
+        case "running":
+            return "Slopify couldn't make this item again automatically because work that depends on it was already running. Use Redo beside it once the run has finished.";
+        case "readiness":
+            return `Slopify couldn't make this item again automatically: ${detail ?? "a provider isn't ready"}. Fix that in Settings → Providers, then use Redo beside it.`;
+        case "conflict":
+        case "control-changed":
+            return "Slopify couldn't make this item again automatically because the project changed at the same moment (an edit, Pause or Cancel). Use Redo beside it.";
+        default:
+            return `Slopify couldn't make this item again automatically${detail ? `: ${detail}` : "."} Use Redo beside it.`;
+    }
+}

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

@@ -12,7 +12,19 @@ export async function revisionAction(deps, projectId, action) {
     const config = view.revision.config;
     const content = view.revision.content;
     const image = action.kind === "delete-image" || action.kind === "regenerate-image"
-        ? view.outputs.find((row) => row.selected && row.output.id === action.outputId && row.output.role === "image")
+        ? view.outputs.find((row) => row.selected &&
+            row.output.id === action.outputId &&
+            (row.output.role === "image" ||
+                // One of the generated thumbnails is made again on its own, the others kept.
+                (action.kind === "regenerate-image" &&
+                    row.output.role === "thumbnail" &&
+                    (config.sources.thumbnail === "from_prompt" ||
+                        config.sources.thumbnail === "prompt_by_llm")) ||
+                // A generated establishing image is made again like any image; it is never deleted
+                // on its own (Edit project sets it Off), and an uploaded one has nothing to redo.
+                (action.kind === "regenerate-image" &&
+                    row.output.role === "reference" &&
+                    config.reference?.source === "prompt")))
         : undefined;
     if ((action.kind === "delete-image" || action.kind === "regenerate-image") && image === undefined)
         return { ok: false, reason: "unknown-image" };
@@ -64,7 +76,7 @@ function keyStage(key) {
     const prefix = key.split(":")[0];
     if (prefix === "entry" || prefix === "article")
         return "article";
-    if (prefix === "image")
+    if (prefix === "image" || prefix === "reference")
         return "images";
     if (prefix === "audio")
         return "audio";

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

@@ -12,7 +12,10 @@ export function reservationKey(recipe, view) {
         ? `audio:${recipe.input.segment}:future`
         : recipe.input.kind === "llm" && recipe.input.preparation
             ? `narration:prepare:${recipe.input.preparation.segment}:future`
-            : key;
+            : (recipe.input.kind === "llm" && recipe.input.describe) ||
+                recipe.key.startsWith("figure:card:")
+                ? "narration:describe:future"
+                : key;
     return view.revision.fingerprints[future] === undefined ? key : future;
 }
 export function admitInitialRevision(deps, view, catalogue) {

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

@@ -22,7 +22,7 @@ export async function executeAnimateRecipe(deps, context, providers, piece) {
         return "done";
     const input = piece.input;
     if (input.kind !== "image" || input.animate === undefined)
-        throw new Error("Slopify hit an internal error (an animated image was set up wrongly). Use Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (an animated image was set up wrongly). Use Try again; if it happens again, use Download diagnostics in Settings and report it.");
     const imageKey = piece.key.slice("animate:".length);
     const view = executionView(deps, context.work.projectId, context.work.revisionId);
     const index = (view?.revision.content.imageOrder.indexOf(imageKey) ?? -1) + 1;
@@ -35,10 +35,10 @@ export async function executeAnimateRecipe(deps, context, providers, piece) {
         return "done";
     };
     if (still === undefined)
-        return fallback("its image wasn't ready to animate. Use Re-run section on Video after the image is made.");
+        return fallback("its image wasn't ready to animate. Use More → Render the video again in the Video section after the image is made.");
     const animate = providers.forPiece(piece.id).animate;
     if (animate === undefined)
-        throw new Error("Slopify hit an internal error (animating images isn't wired up in this build). Use Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (animating images isn't wired up in this build). Use Try again; if it happens again, use Download diagnostics in Settings and report it.");
     if (!context.maySubmit(piece.id))
         return "held";
     let made;
@@ -55,7 +55,7 @@ export async function executeAnimateRecipe(deps, context, providers, piece) {
     catch (error) {
         if (context.signal.aborted)
             throw error;
-        return fallback(`${error instanceof Error ? error.message : String(error)} To try again, use Re-run section on Video.`);
+        return fallback(`${error instanceof Error ? error.message : String(error)} To try again, use More → Render the video again in the Video section.`);
     }
     if (!made.ok)
         return "held";