@gentbajko/slopify 2.5.0 → 3.0.0

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

@@ -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 Outputs → Export → 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 };
+}

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

@@ -1,13 +1,15 @@
 import { readFileSync } from "node:fs";
 import { extname } from "node:path";
 import { z } from "zod";
-import { usesYoutubeDescription } from "../admission/rules.js";
+import { usesFigureCards, usesYoutubeDescription } from "../admission/rules.js";
+import { captionFont, captionFontDeps } from "../fonts/coverage.js";
 import { resolveFont } from "../fonts/index.js";
 import { outputPath } from "../storage/layout.js";
 import { headingChapters } from "../video/chapters.js";
 import { sentenceCutPoints } from "../video/cuts.js";
 import { usesChapterCards, usesNarrationCuts, videoEditOf, } from "../video/edit-settings.js";
 import { probeDurationMs } from "../video/ffmpeg.js";
+import { passageSpans } from "../video/figure-spans.js";
 import { wordsSchema } from "./runtime-subtitles.js";
 // The containers an uploaded clip may come in; anything else in the images is a still.
 const clipExtensions = new Set([".mp4", ".mov", ".m4v", ".webm", ".mkv"]);
@@ -39,23 +41,31 @@ export async function exportEdit(deps, context, view, images) {
             .safeParse(JSON.parse(row.piece.payload ?? "null"));
         return parsed.success ? [parsed.data.fallback] : [];
     });
-    if (config.videoEdit === undefined)
+    const endScreen = config.endScreen?.text.trim() ?? "";
+    const figures = usesFigureCards(config) ? figureShots(deps, context, view) : [];
+    const withFigures = figures.length === 0 ? {} : { figures };
+    if (config.videoEdit === undefined) {
+        const titles = endScreen === "" ? undefined : await titleFont(deps, config);
         return {
-            edit: clips.some((clip) => clip !== undefined) ? { clips } : undefined,
+            edit: titles !== undefined
+                ? { clips, cards: { chapters: [], ...titles, endScreen }, ...withFigures }
+                : clips.some((clip) => clip !== undefined) || figures.length > 0
+                    ? { clips, ...withFigures }
+                    : undefined,
             warnings,
             settings: undefined,
         };
+    }
     const settings = videoEditOf(config);
     const cuts = usesNarrationCuts(config);
     const cards = usesChapterCards(config);
     const words = cuts || cards ? timingWords(deps, context, view) : [];
     const chapters = cuts || cards ? chaptersOf(view, config, words) : [];
-    const font = cards
-        ? await resolveFont(deps.paths, config.subtitles?.fontId ?? "default")
-        : undefined;
+    const titles = cards || endScreen !== "" ? await titleFont(deps, config) : undefined;
     return {
         edit: {
             clips,
+            ...withFigures,
             ...(cuts
                 ? {
                     narration: {
@@ -73,22 +83,40 @@ export async function exportEdit(deps, context, view, images) {
                 grade: settings.grade,
                 atmosphere: settings.atmosphere,
             },
-            ...(font === undefined
+            ...(titles === undefined
                 ? {}
-                : { cards: { chapters, font: { path: font.path, name: font.assName } } }),
+                : {
+                    cards: {
+                        chapters: cards ? chapters : [],
+                        ...titles,
+                        ...(endScreen === "" ? {} : { endScreen }),
+                    },
+                }),
         },
         warnings,
         settings,
     };
 }
-function timingWords(deps, context, view) {
+// The cards' font and colour: the brand kit's title style, else the caption font in white.
+async function titleFont(deps, config) {
+    const fontId = config.titleStyle?.fontId ?? config.subtitles?.fontId ?? "default";
+    // Chapter titles are in the project language too, so they need its letters.
+    const font = config.language === undefined || config.language === "en"
+        ? await resolveFont(deps.paths, fontId)
+        : await captionFont(captionFontDeps(deps.paths), fontId, config.language);
+    return {
+        font: { path: font.path, name: font.assName },
+        ...(config.titleStyle?.color === undefined ? {} : { color: config.titleStyle.color }),
+    };
+}
+export function timingWords(deps, context, view) {
     const timing = view.outputs.find((row) => row.selected &&
         row.available &&
         row.state === "ready" &&
         row.workKey === "subtitles:timing" &&
         row.output.role === "subtitle_words");
     if (timing === undefined)
-        throw new Error("The narration's word timing, which the video's cuts and chapter cards follow, is missing. Use Re-run section on Video, then Retry stage.");
+        throw new Error("The narration's word timing, which the video's cuts and chapter cards follow, is missing. Use More → Render the video again in the Video section, then Try again.");
     return wordsSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, context.work.projectId, timing.output.path), "utf8"))).words;
 }
 // The YouTube description's chapters when that step runs, the article's headings otherwise.
@@ -114,6 +142,37 @@ async function clipSeconds(deps, context, path, place) {
         ms = 0;
     }
     if (!(ms > 0))
-        throw new Error(`Image ${String(place)} is a video clip Slopify can't read, so the video can't show it. Replace it with another clip or an image in Edit project → Images, then Retry stage.`);
+        throw new Error(`Image ${String(place)} is a video clip Slopify can't read, so the video can't show it. Replace it with another clip or an image in Edit project → Images, then Try again.`);
     return ms / 1000;
 }
+// Each card in the video's frame, shown where its description is spoken: the description's
+// answer found in the word timing (`video/figure-spans.ts`). A card whose description can't be
+// found in the timing is left out rather than shown at the wrong moment.
+export function figureShots(deps, context, view, format = view.revision.config.format, words = timingWords(deps, context, view)) {
+    const cards = view.outputs
+        .filter((row) => row.selected &&
+        row.available &&
+        row.state === "ready" &&
+        row.output.role === "figure_card" &&
+        row.workKey.startsWith("figure:card:") &&
+        (row.output.meta.format ?? view.revision.config.format) === format)
+        .map((row) => ({
+        index: Number(row.workKey.slice("figure:card:".length)),
+        path: outputPath(deps.paths, context.work.projectId, row.output.path),
+    }))
+        .toSorted((a, b) => a.index - b.index);
+    const passages = cards.map((card) => {
+        const row = view.pieces.find((one) => one.key === `narration:describe:${String(card.index)}` &&
+            one.selected &&
+            one.piece.state === "done");
+        const parsed = z
+            .object({ text: z.string() })
+            .safeParse(JSON.parse(row?.piece.payload ?? "null"));
+        return parsed.success ? parsed.data.text : "";
+    });
+    const spans = passageSpans(words, passages);
+    return cards.flatMap((card, at) => {
+        const span = spans[at];
+        return span === undefined ? [] : [{ path: card.path, start: span.start, end: span.end }];
+    });
+}