@gentbajko/slopify 2.5.0 → 3.0.1

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,125 @@
+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,
+    };
+}
+// The verdicts whose redo is being started right now. Overrule may call off a redo only while
+// it waits, not once Slopify has begun making the item again.
+const starting = new Set();
+export function redoStarting(verdictId) {
+    return starting.has(verdictId);
+}
+export async function startRedo(deps, verdict) {
+    starting.add(verdict.id);
+    try {
+        await makeAgain(deps, verdict);
+    }
+    finally {
+        starting.delete(verdict.id);
+    }
+}
+async function makeAgain(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

@@ -15,6 +15,11 @@ export async function revisionAction(deps, projectId, action) {
         ? 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" &&

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";

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

@@ -12,14 +12,14 @@ const answerSchema = z.object({
 });
 export async function executeArticleRequests(deps, context, providers, initial) {
     if (initial.input.kind !== "llm")
-        throw new Error("Slopify hit an internal error (the article step has no AI request). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the article step has no AI request). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     let piece = initial;
     let text = "";
     let inputTokens = 0;
     let outputTokens = 0;
     for (let part = 0; part <= continuationLimit; part += 1) {
         if (piece.input.kind !== "llm")
-            throw new Error("Slopify hit an internal error (an article continuation has no AI request). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (an article continuation has no AI request). Try again; if it happens again, use Download diagnostics in Settings and report it.");
         const saved = deps.db
             .prepare("SELECT result_json FROM revision_work_pieces WHERE id=? AND work_id=?")
             .get(piece.id, context.work.workId);
@@ -38,9 +38,9 @@ export async function executeArticleRequests(deps, context, providers, initial)
                 webSearch: input.webSearch,
                 previewLabel: part === 0 ? "Article" : `Continuation ${part}`,
                 check: (value) => value.text.trim() === ""
-                    ? "The AI model returned an empty article. Retry stage; if it keeps happening, choose a different model in Edit project → Providers."
+                    ? "The AI model returned an empty article. Try again; if it keeps happening, choose a different model in Edit project → Providers."
                     : part === continuationLimit && value.finishReason === "length"
-                        ? `The article was still unfinished after ${continuationLimit} continuations because the AI model kept stopping at its length limit. Ask for a shorter article in Edit project → Prompts, or choose a model with a larger output limit in Edit project → Providers, then Retry stage.`
+                        ? `The article was still unfinished after ${continuationLimit} continuations because the AI model kept stopping at its length limit. Ask for a shorter article in Edit project → Prompts, or choose a model with a larger output limit in Edit project → Providers, then Try again.`
                         : undefined,
             }, (event) => {
                 if (event.type === "delta")
@@ -72,7 +72,7 @@ export async function executeArticleRequests(deps, context, providers, initial)
             return { ok: false, reason: "held" };
         piece = next;
     }
-    throw new Error(`The article was still unfinished after ${continuationLimit} continuations because the AI model kept stopping at its length limit. Ask for a shorter article in Edit project → Prompts, or choose a model with a larger output limit in Edit project → Providers, then Retry stage.`);
+    throw new Error(`The article was still unfinished after ${continuationLimit} continuations because the AI model kept stopping at its length limit. Ask for a shorter article in Edit project → Prompts, or choose a model with a larger output limit in Edit project → Providers, then Try again.`);
 }
 function continuationPiece(deps, context, initial, part, text) {
     return transact(deps.db, () => {

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

@@ -28,7 +28,7 @@ export async function executeDocumentRecipe(deps, context, piece) {
         ? view.articleMarkdown
         : text("article_md", "article:body");
     if (article === null)
-        throw new Error("The article isn't finished yet, so there's nothing to make the document from. Let the Article stage finish (Resume, or Retry stage on Article), then use Retry stage on Document.");
+        throw new Error("The article isn't finished yet, so there's nothing to make the document from. Let the Article stage finish (Resume, or Try again on Article), then use Try again on Document.");
     const thumbnail = ready(view, "thumbnail", "thumbnail:image");
     let cover = null;
     if (config.sources.thumbnail !== "off" && thumbnail !== undefined) {
@@ -36,7 +36,7 @@ export async function executeDocumentRecipe(deps, context, piece) {
             cover = new Uint8Array(readFileSync(outputPath(deps.paths, projectId, thumbnail.output.path)));
         }
         catch (error) {
-            throw new Error(`The document's cover is the project's thumbnail, and its file can't be read (${error instanceof Error ? error.message : String(error)}). Regenerate or upload the thumbnail again (Re-run section on Thumbnail, or Edit project → Thumbnail), then use Retry stage on Document.`, { cause: error });
+            throw new Error(`The document's cover is the project's thumbnail, and its file can't be read (${error instanceof Error ? error.message : String(error)}). Regenerate or upload the thumbnail again (More → make it again in its section on Thumbnail, or Edit project → Thumbnail), then use Try again on Document.`, { cause: error });
         }
     }
     const rendered = renderDocument({
@@ -69,10 +69,10 @@ function documentView(deps, context, piece) {
         .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
         .get(context.work.workId);
     if (view === undefined || row === undefined)
-        throw new Error("Slopify hit an internal error (the project version the document belongs to is missing). Use Retry stage on Document; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the project version the document belongs to is missing). Use Try again on Document; if it happens again, use Download diagnostics in Settings and report it.");
     const recipe = executionPlan(deps, view, savedCatalogue(row.recipe_context)).recipes.find((one) => one.key === piece.key && one.fingerprint === piece.fingerprint);
     if (recipe === undefined || recipe.unresolved)
-        throw new Error("The project changed after this document was queued, so it no longer matches the saved article. Use Rebuild affected outputs (or Retry stage on Document) to make it from the current version.");
+        throw new Error("The project changed after this document was queued, so it no longer matches the saved article. Use Choose what to remake (in the project's More menu) (or Try again on Document) to make it from the current version.");
     return view;
 }
 function ready(view, role, workKey) {

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

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { outputPath } from "../storage/layout.js";
+import { usesAmbientBed } from "../video/ambient-bed.js";
+import { probeDurationMs } from "../video/ffmpeg.js";
+// The long video's ambient bed as the plan takes it (`video/ambient-bed.ts`), or undefined for
+// none. The user's own file is checked readable before the render, so a bad file is named as
+// the ambient sound rather than as a failed render.
+export async function exportBed(deps, context, view) {
+    const config = view.revision.config;
+    const bed = config.ambientBed;
+    if (bed === undefined || !usesAmbientBed(config))
+        return undefined;
+    const settings = {
+        levelDb: bed.levelDb,
+        fadeInSeconds: bed.fadeInSeconds,
+        tailSeconds: bed.tailSeconds,
+    };
+    if (bed.source !== "upload")
+        return { source: { kind: "noise", preset: bed.source }, ...settings };
+    const fix = "Make the video again from Play with another file under Video and style → Ambient sound, or pick Rain, Fireplace or Wind there instead.";
+    const assetId = view.revision.content.ambientBed;
+    const row = z
+        .object({ path: z.string() })
+        .safeParse(assetId === undefined
+        ? undefined
+        : deps.db
+            .prepare("SELECT path FROM project_assets WHERE project_id=? AND id=?")
+            .get(context.work.projectId, assetId));
+    if (!row.success)
+        throw new Error(`The ambient sound's audio file is no longer in the project. ${fix}`);
+    const path = outputPath(deps.paths, context.work.projectId, row.data.path);
+    let durationMs;
+    try {
+        durationMs = await probeDurationMs(deps.ffmpeg, path, context.signal, deps.log);
+    }
+    catch (error) {
+        context.signal.throwIfAborted();
+        throw new Error(`The ambient sound's audio file couldn't be read as audio (${error instanceof Error ? error.message : String(error)}). ${fix}`);
+    }
+    if (durationMs <= 0)
+        throw new Error(`The ambient sound's audio file holds no sound. ${fix}`);
+    return { source: { kind: "file", path }, ...settings };
+}