@gentbajko/slopify 2.0.1 → 2.0.3

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

@@ -14,11 +14,11 @@ export function exportSnapshot(deps, context, piece) {
         .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
         .get(context.work.workId);
     if (view === undefined || row === undefined)
-        throw new Error("The export revision no longer exists.");
+        throw new Error("Slopify hit an internal error (the project version being exported is missing). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     const plan = executionPlan(deps, view, savedCatalogue(row.recipe_context));
     const recipe = plan.recipes.find((one) => one.key === piece.key && one.fingerprint === piece.fingerprint);
     if (recipe === undefined || recipe.deferred || recipe.unresolved)
-        throw new Error("The export inputs do not match the admitted recipe.");
+        throw new Error("Slopify hit an internal error (the export no longer matches the project's saved inputs). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     return { view, plan };
 }
 export async function revisionAudio(deps, context, view) {
@@ -34,12 +34,12 @@ export async function revisionAudio(deps, context, view) {
             (await (deps.measureAudio?.(path, context.signal) ??
                 probeDurationMs(deps.ffmpeg, path, context.signal, deps.log)));
         if (!Number.isFinite(duration) || duration <= 0)
-            throw new Error("The narration duration could not be measured.");
+            throw new Error("Slopify couldn't read the length of the narration audio, so the file may be damaged or empty. Regenerate the narration (or upload your audio file again in Edit project → Narration), then Retry stage.");
         return { path, seconds: duration / 1000 };
     };
     const body = await input("audio_body");
     if (body === undefined)
-        throw new Error("The revision has no complete narration.");
+        throw new Error("The narration audio isn't finished yet. Let the Narration stage finish (Resume, or Retry stage on it), then retry this stage.");
     return audioTimeline({
         body,
         intro: config.sources.audio === "generate" && config.intro !== undefined
@@ -72,7 +72,7 @@ export function revisionTranscript(deps, snapshot, kind) {
                 Array.isArray(recipe.input.semantic) &&
                 typeof recipe.input.semantic[0] === "string")
                 return recipe.input.semantic[0];
-            throw new Error("The saved narration transcript is incomplete.");
+            throw new Error("Some narration chunks aren't finished, so the full narration text isn't available. Let the Narration stage finish (Resume, or Retry stage on it), or regenerate the missing chunk in Edit project → Narration.");
         });
         if (texts.length > 0)
             return texts.join("\n");
@@ -84,7 +84,7 @@ export function revisionTranscript(deps, snapshot, kind) {
         if (view.articleMarkdown !== null)
             return plainText(splitEndMatter(view.articleMarkdown).body);
     }
-    throw new Error(`The saved ${kind} narration transcript is missing.`);
+    throw new Error(`The saved text of the ${kind === "body" ? "article" : kind} is missing, so it can't be matched to the narration. Use Re-run section on Article, then Retry stage.`);
 }
 export function retainedOutput(deps, view, row) {
     const asset = z

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

@@ -20,9 +20,9 @@ export async function executeExportRecipe(deps, context, piece) {
     const audio = await revisionAudio(deps, context, view);
     const wav = piece.key === "export:wav";
     if (!wav && piece.key !== "export:video")
-        throw new Error("Unknown media export recipe.");
+        throw new Error("Slopify hit an internal error (unknown kind of export). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     if (wav && audio.length === 0)
-        throw new Error("Audio export needs complete narration.");
+        throw new Error("The audio export has nothing to export because narration is turned off for this project. Turn narration on in Edit project, then Retry stage.");
     const filename = wav ? "audio.wav" : "video.mp4";
     const pending = allocateAsset(deps, context.work.projectId, filename);
     const prepared = [];
@@ -48,7 +48,7 @@ export async function executeExportRecipe(deps, context, piece) {
         const images = (wav ? [] : view.revision.content.imageOrder).map((key) => {
             const row = view.outputs.find((one) => one.workKey === `image:${key}` && one.selected && one.available && one.state === "ready");
             if (row === undefined)
-                throw new Error("The revision is missing an image selected for its slideshow.");
+                throw new Error("The video export can't find one of the slideshow images. Use Re-run section on Images (or regenerate that image in Edit project → Images), then Retry stage.");
             return outputPath(deps.paths, context.work.projectId, row.output.path);
         });
         const plan = wav
@@ -124,7 +124,7 @@ function captionDirectory(deps, context, snapshot) {
     const ass = find("subtitle_ass");
     const font = find("subtitle_font");
     if (ass === undefined || font === undefined)
-        throw new Error("Burned subtitles need prepared captions and their saved font.");
+        throw new Error("Burned-in captions are missing their caption file or font. Use Re-run section on Video (or choose the caption font again in Edit project → Subtitles), then Retry stage.");
     const directory = mkdtempSync(join(projectDir(deps.paths, context.work.projectId), "render-"));
     try {
         mkdirSync(join(directory, "fonts"), { mode: 0o700 });

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

@@ -19,7 +19,7 @@ export async function executeLocalRecipe(deps, context, piece) {
     const input = piece.input;
     if (input.kind === "provided") {
         if (input.assetId === null)
-            throw new Error("The provided recipe has no retained asset.");
+            throw new Error("A file you uploaded for this project is missing. Upload it again in Edit project, then Retry stage.");
         const row = z
             .object({ id: z.string(), project_id: z.string(), path: z.string(), created_at: z.string() })
             .parse(deps.db
@@ -43,7 +43,7 @@ export async function executeLocalRecipe(deps, context, piece) {
         return "done";
     }
     if (input.kind !== "local")
-        throw new Error("Expected an exact local recipe.");
+        throw new Error("Slopify hit an internal error (a local step was set up wrongly). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     if (input.operation === "narration-files-v1") {
         await publishNarrationText(deps, context, piece);
         return "done";
@@ -75,19 +75,19 @@ export async function executeLocalRecipe(deps, context, piece) {
         });
         return "done";
     }
-    throw new Error(`No local executor for ${input.operation}.`);
+    throw new Error(`Slopify hit an internal error (no handler for the step "${input.operation}"). Retry stage; if it happens again, use Download diagnostics in Settings and report it.`);
 }
 async function concatenate(deps, context, piece) {
     const view = executionView(deps, context.work.projectId, context.work.revisionId);
     if (view === undefined)
-        throw new Error("The pinned revision is missing.");
+        throw new Error("Slopify hit an internal error (the project version being built is missing). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     const row = deps.db
         .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
         .get(context.work.workId);
     const plan = executionPlan(deps, view, savedCatalogue(row?.recipe_context));
     const recipe = plan.recipes.find((candidate) => candidate.key === piece.key && candidate.fingerprint === piece.fingerprint);
     if (recipe === undefined)
-        throw new Error("The pinned concatenation no longer matches its inputs.");
+        throw new Error("Slopify hit an internal error (the narration chunks to join no longer match the project's saved inputs). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     const files = recipe.dependsOn.map((key) => {
         const input = view.pieces.find((candidate) => candidate.key === key &&
             candidate.selected &&
@@ -95,7 +95,7 @@ async function concatenate(deps, context, piece) {
             candidate.piece.state === "done" &&
             candidate.fingerprint === plan.recipes.find((value) => value.key === key)?.fingerprint);
         if (input?.assetId === null || input === undefined)
-            throw new Error("A narration part has no retained audio.");
+            throw new Error("One narration chunk has no saved audio, so the narration can't be joined together. Regenerate the missing chunk in Edit project → Narration, then Retry stage.");
         const asset = deps.db
             .prepare("SELECT path FROM project_assets WHERE id=? AND project_id=?")
             .get(input.assetId, context.work.projectId);

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

@@ -9,7 +9,7 @@ export function joinedNarration(parts) {
 export function narrationTextParts(view, plan, segment) {
     const concat = plan.recipes.find((row) => row.key === (segment === "body" ? "audio:body:concat" : `audio:${segment}`));
     if (concat === undefined)
-        throw new Error(`The saved ${segment} narration is missing.`);
+        throw new Error(`Slopify hit an internal error (the ${segment} narration is missing from the project plan). Retry stage; if it happens again, use Download diagnostics in Settings and report it.`);
     return concat.dependsOn.map((key) => {
         const recipe = plan.recipes.find((row) => row.key === key);
         const selected = view.pieces.find((row) => row.key === key &&
@@ -18,7 +18,7 @@ export function narrationTextParts(view, plan, segment) {
             row.piece.state === "done" &&
             row.fingerprint === recipe?.fingerprint);
         if (selected === undefined || recipe === undefined)
-            throw new Error("The saved narration transcript is incomplete.");
+            throw new Error("Some narration chunks aren't finished, so the full narration text isn't available. Let the Narration stage finish (Resume, or Retry stage on it), or regenerate the missing chunk in Edit project → Narration.");
         const input = recipe.input;
         if (input.kind === "provided" &&
             Array.isArray(input.semantic) &&
@@ -29,13 +29,13 @@ export function narrationTextParts(view, plan, segment) {
                 requestText: null,
             };
         if (input.kind !== "tts")
-            throw new Error("The narration source has not resolved.");
+            throw new Error("Slopify hit an internal error (a narration chunk's text was never worked out). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
         const payload = z
             .object({ text: z.string().optional(), spokenText: z.string().optional() })
             .parse(JSON.parse(selected.piece.payload ?? "{}"));
         if (input.spokenText !== undefined &&
             (payload.spokenText !== input.spokenText || payload.text !== input.text))
-            throw new Error("Prepared narration is missing its exact clean transcript.");
+            throw new Error("A narration chunk's audio no longer matches its prepared text. Regenerate that chunk in Edit project → Narration, then Retry stage.");
         return {
             logicalKey: input.logicalKey,
             spokenText: input.spokenText === undefined ? (payload.text ?? input.text) : (payload.spokenText ?? ""),
@@ -45,7 +45,7 @@ export function narrationTextParts(view, plan, segment) {
 }
 export async function publishNarrationText(deps, context, piece) {
     if (piece.input.kind !== "local")
-        throw new Error("Expected a narration-file recipe.");
+        throw new Error("Slopify hit an internal error (the narration text file step was set up wrongly). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     const { segment } = z
         .object({ segment: z.enum(["body", "intro", "outro"]) })
         .parse(piece.input.values);
@@ -54,10 +54,10 @@ export async function publishNarrationText(deps, context, piece) {
         .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
         .get(context.work.workId);
     if (view === undefined)
-        throw new Error("The pinned narration revision is missing.");
+        throw new Error("Slopify hit an internal error (the project version being narrated is missing). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     const plan = executionPlan(deps, view, savedCatalogue(row?.recipe_context));
     if (!plan.recipes.some((recipe) => recipe.key === piece.key && recipe.fingerprint === piece.fingerprint))
-        throw new Error("Narration text no longer matches the admitted inputs.");
+        throw new Error("Slopify hit an internal error (the narration text no longer matches the project's saved inputs). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     const parts = narrationTextParts(view, plan, segment);
     const outputs = preparedTexts(deps, context, piece, [
         ["narration_txt", `${segment}-narration.txt`, joinedNarration(parts)],
@@ -73,3 +73,42 @@ export async function publishNarrationText(deps, context, piece) {
     }));
     await publishResult(deps, context, piece, outputs, { segment });
 }
+// The narration's chunks in the order they are spoken, each with its clean text. A chunk is
+// sent as one or more parts; the Narration editor numbers these chunks, so anything that
+// names "chunk N" to a person counts from this list.
+export function narrationChunks(parts) {
+    const chunks = [];
+    for (const part of parts) {
+        const last = chunks.at(-1);
+        if (last?.key === part.logicalKey)
+            chunks[chunks.length - 1] = {
+                key: last.key,
+                spokenText: `${last.spokenText}${part.spokenText}`,
+            };
+        else
+            chunks.push({ key: part.logicalKey, spokenText: part.spokenText });
+    }
+    return chunks;
+}
+// The current chunk keys of each narration segment, in spoken order, for the Narration
+// editor. Undefined when the revision has no admitted work to read a plan from, or its
+// narration is not complete yet; the editor then keeps its own listing.
+export function narrationChunkOrder(deps, projectId, revisionId) {
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE project_id=? AND revision_id=? AND recipe_context IS NOT NULL LIMIT 1")
+        .get(projectId, revisionId);
+    const view = executionView(deps, projectId, revisionId);
+    if (row === undefined || view === undefined)
+        return undefined;
+    const plan = executionPlan(deps, view, savedCatalogue(row.recipe_context));
+    const order = {};
+    for (const segment of ["intro", "body", "outro"]) {
+        try {
+            order[segment] = narrationChunks(narrationTextParts(view, plan, segment)).map((chunk) => chunk.key);
+        }
+        catch {
+            // A segment that is off, or not narrated yet, has no chunks to order.
+        }
+    }
+    return order;
+}

package/dist/slices/rebuild/runtime-piece-label.js

@@ -0,0 +1,62 @@
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+// What a failed step is called on screen, so its error says which image, chunk or topic to
+// fix. Worked out only after a failure: numbering a narration chunk means building the plan.
+// Undefined for steps that name their own place (captions, export) or have no single one.
+export function pieceLabel(deps, context, piece) {
+    const { key } = piece;
+    if (key === "thumbnail:image" || key.startsWith("thumbnail:"))
+        return "Thumbnail";
+    if (key === "article:body")
+        return "Article";
+    if (key === "entry:intro:text")
+        return "Intro text";
+    if (key === "entry:outro:text")
+        return "Outro text";
+    if (key === "research:planner")
+        return "Research plan";
+    if (key === "research:notes")
+        return "Research notes";
+    const topic = /^research:chapter:(\d+)$/.exec(key);
+    if (topic !== null)
+        return `Research topic ${topic[1] ?? ""}`;
+    const view = () => executionView(deps, context.work.projectId, context.work.revisionId);
+    if (key.startsWith("image:")) {
+        const at = view()?.revision.content.imageOrder.indexOf(key.slice("image:".length)) ?? -1;
+        return at === -1 ? "An image" : `Image ${String(at + 1)}`;
+    }
+    const narration = /^(?:narration:prepare:(?:intro|body|outro):)?audio:(intro|body|outro)(?::(.+))?$/.exec(key);
+    if (narration === null)
+        return undefined;
+    const segment = narration[1] ?? "body";
+    const prefix = segment === "body" ? "Narration" : `${segment === "intro" ? "Intro" : "Outro"} narration`;
+    if (narration[2] === undefined || narration[2] === "concat" || narration[2] === "future")
+        return prefix;
+    return narrationChunk(deps, context, segment, key, prefix) ?? prefix;
+}
+function narrationChunk(deps, context, segment, key, prefix) {
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(context.work.workId);
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    if (row?.recipe_context === null || row === undefined || view === undefined)
+        return undefined;
+    const plan = executionPlan(deps, view, savedCatalogue(row.recipe_context));
+    const concat = plan.recipes.find((recipe) => recipe.key === (segment === "body" ? "audio:body:concat" : `audio:${segment}`));
+    if (concat === undefined)
+        return undefined;
+    // Parts are `<chunk>:<n>`; the chunk is everything before the last colon.
+    const chunkOf = (part) => part.slice(0, part.lastIndexOf(":"));
+    const chunks = [...new Set(concat.dependsOn.map(chunkOf))];
+    const preparing = key.startsWith("narration:prepare:");
+    const chunk = preparing ? key.slice(key.indexOf("audio:")) : chunkOf(key);
+    const at = chunks.indexOf(chunk);
+    if (at === -1)
+        return undefined;
+    const label = `${prefix} chunk ${String(at + 1)} of ${String(chunks.length)}`;
+    if (preparing)
+        return `${label} (preparing its text)`;
+    const parts = concat.dependsOn.filter((part) => chunkOf(part) === chunk);
+    return parts.length > 1
+        ? `${label}, part ${String(parts.indexOf(key) + 1)} of ${String(parts.length)}`
+        : label;
+}

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

@@ -117,13 +117,15 @@ export async function executeProviderRecipe(deps, context, providers, piece) {
         });
         return "done";
     }
-    throw new Error("Expected an exact provider recipe.");
+    throw new Error("Slopify hit an internal error (this step has no provider request to run). Use Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
 }
 function checkAnswer(piece, answer) {
     if (answer.text.trim() === "")
-        return "The provider answered with nothing.";
+        return "The AI model sent back an empty answer. Use Retry stage; if it keeps happening, choose another model in the Providers section of Edit project.";
     if (piece.key === "research:planner")
-        return chaptersFrom(answer.text).length === 0 ? "The planner named no chapters." : undefined;
+        return chaptersFrom(answer.text).length === 0
+            ? "The AI model's research plan listed no chapters, so research could not go on. Use Retry stage; if it keeps happening, choose another model in the Providers section of Edit project."
+            : undefined;
     if (piece.key === "research:notes" || piece.key.startsWith("research:chapter:"))
         return sourcedAnswer(piece.key, answer.text);
     return undefined;
@@ -175,7 +177,7 @@ async function publishText(deps, context, piece, answer) {
             : [];
         const title = titles[Number(piece.key.split(":").at(-1)) - 1];
         if (typeof title !== "string")
-            throw new Error("Research chapter has no pinned title.");
+            throw new Error("Slopify hit an internal error (a research chapter has no title in the research plan). Use Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
         const asset = writeAsset(deps, context.work.projectId, `research-${piece.key.split(":").at(-1)}.md`, Buffer.from(answer.text));
         await publishResult(deps, context, piece, [], { title, notes: answer.text }, asset);
         return;

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

@@ -29,7 +29,7 @@ export function preparedResult(deps, context, piece, role, asset, durationMs = n
 export function preparedText(deps, context, piece, role, filename, text) {
     const output = preparedTexts(deps, context, piece, [[role, filename, text]])[0];
     if (output === undefined)
-        throw new Error("The text output was not prepared.");
+        throw new Error("Slopify hit an internal error (a text file could not be prepared). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     return output;
 }
 export function preparedTexts(deps, context, piece, texts) {
@@ -168,10 +168,10 @@ export function retainPartialArticle(deps, context, piece, text) {
             if (authority === undefined)
                 return;
             if (authority.key !== piece.key || authority.fingerprint !== piece.fingerprint)
-                throw new Error("Partial article differs from its durable piece authority.");
+                throw new Error("Slopify hit an internal error (a partly written article doesn't match its saved step). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
             const revision = revisionById(deps.db, context.work.projectId, context.work.revisionId);
             if (revision === undefined)
-                throw new Error("Partial article origin disappeared.");
+                throw new Error("Slopify hit an internal error (the project version for a partly written article is missing). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
             insertAsset(deps.db, result.asset);
             insertManifestOutput(deps.db, revision, {
                 slot: `article:partial:${piece.id}`,

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

@@ -1,5 +1,6 @@
 import { executeExportRecipe } from "./runtime-export.js";
 import { executeLocalRecipe } from "./runtime-local.js";
+import { pieceLabel } from "./runtime-piece-label.js";
 import { executeProviderRecipe } from "./runtime-provider.js";
 import { executeSubtitleRecipe } from "./runtime-subtitles.js";
 import { workPieces } from "./work-records.js";
@@ -25,7 +26,16 @@ export async function runRevisionInvocation(deps, context, providers) {
             deps.db
                 .prepare("UPDATE revision_work_pieces SET state=? WHERE id=? AND work_id=? AND state!='done'")
                 .run(context.signal.aborted ? "pending" : "failed", piece.id, context.work.workId);
-            throw error;
+            if (context.signal.aborted || !(error instanceof Error))
+                throw error;
+            let label;
+            try {
+                label = pieceLabel(deps, context, piece);
+            }
+            catch {
+                // The error itself matters more than its label.
+            }
+            throw label === undefined ? error : new Error(`${label}: ${error.message}`, { cause: error });
         }
     }
     deps.db

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

@@ -94,12 +94,12 @@ export function invocationReady(deps, work) {
         });
     });
 }
-export function executionStandings(deps, projectId) {
+export function executionStandings(deps, projectId, derived) {
     const revisionId = currentRevisionId(deps.db, projectId);
     const view = revisionId === undefined ? undefined : getRevisionView(deps, projectId, revisionId);
     if (view === undefined)
         return [];
-    const work = executionStages(deps, projectId);
+    const work = derived ?? executionStages(deps, projectId);
     return stageKinds.map((kind) => {
         const source = view.revision.config.sources[kind];
         const group = work
@@ -136,20 +136,18 @@ export function executionStandings(deps, projectId) {
     });
 }
 export function projectStandings(deps, projectId) {
-    const standings = executionStandings(deps, projectId);
+    // One derivation serves every stage: each builds the whole execution plan.
+    const work = executionStages(deps, projectId);
+    const standings = executionStandings(deps, projectId, work);
     for (const stage of standings) {
-        const invocations = executionStages(deps, projectId).filter((work) => work.kind === stage.kind);
-        const current = invocations.reduce((total, work) => {
-            if (work.state === "done")
+        const invocations = work.filter((entry) => entry.kind === stage.kind);
+        const current = invocations.reduce((total, entry) => {
+            if (entry.state === "done")
                 return total + 1;
             const progress = deps.db
                 .prepare("SELECT progress_current,progress_total FROM revision_work WHERE id=?")
-                .get(work.work.workId);
-            if (typeof progress?.progress_current !== "number" ||
-                typeof progress.progress_total !== "number" ||
-                progress.progress_total <= 0)
-                return total;
-            return total + Math.max(0, Math.min(1, progress.progress_current / progress.progress_total));
+                .get(entry.work.workId);
+            return total + fraction(progress?.progress_current, progress?.progress_total);
         }, 0);
         const failed = invocations.find((work) => work.state === "failed");
         const failure = failed === undefined
@@ -163,6 +161,11 @@ export function projectStandings(deps, projectId) {
     }
     settleScheduleRunsForProject(deps.db, projectId, deps.clock.now().toISOString());
 }
+// Progress moves one number and nothing else. The stage row already counts this invocation's
+// last fraction, from the claim or the previous event, so it takes the difference instead
+// of re-deriving the project: that derivation rebuilds every stage's plan and ran to seconds
+// on a long article, which froze the process once per downloaded chunk. State changes still
+// go through projectStandings.
 export function recordWorkProgress(deps, event) {
     if (event.workId === undefined ||
         event.revisionId === undefined ||
@@ -170,8 +173,35 @@ export function recordWorkProgress(deps, event) {
         !Number.isFinite(event.total) ||
         event.total <= 0)
         return;
+    const before = deps.db
+        .prepare("SELECT progress_current,progress_total FROM revision_work WHERE id=? AND revision_id=? AND project_id=? AND kind=? AND state='running'")
+        .get(event.workId, event.revisionId, event.projectId, event.stage);
+    if (before === undefined)
+        return;
+    const current = Math.max(0, Math.min(event.current, event.total));
     deps.db
-        .prepare("UPDATE revision_work SET progress_current=?,progress_total=? WHERE id=? AND revision_id=? AND project_id=? AND kind=? AND state='running'")
-        .run(Math.max(0, Math.min(event.current, event.total)), event.total, event.workId, event.revisionId, event.projectId, event.stage);
-    projectStandings(deps, event.projectId);
+        .prepare("UPDATE revision_work SET progress_current=?,progress_total=? WHERE id=?")
+        .run(current, event.total, event.workId);
+    // Work an edit retired keeps running until it notices, but the stage row belongs to the
+    // current revision's work and must not move with it.
+    const head = currentRevisionId(deps.db, event.projectId);
+    if (head === undefined ||
+        deps.db
+            .prepare("SELECT 1 FROM revision_work_reservations WHERE work_id=? AND revision_id=? LIMIT 1")
+            .get(event.workId, head) === undefined)
+        return;
+    const delta = current / event.total - fraction(before.progress_current, before.progress_total);
+    if (delta === 0)
+        return;
+    const moved = deps.db
+        .prepare("UPDATE stages SET progress_current=MIN(progress_total,MAX(0,progress_current+?)) WHERE project_id=? AND kind=? AND progress_current IS NOT NULL AND progress_total IS NOT NULL")
+        .run(delta, event.projectId, event.stage);
+    // A row no derivation has counted yet has nothing to adjust: derive it once.
+    if (moved.changes === 0)
+        projectStandings(deps, event.projectId);
+}
+function fraction(current, total) {
+    if (typeof current !== "number" || typeof total !== "number" || total <= 0)
+        return 0;
+    return Math.max(0, Math.min(1, current / total));
 }

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

@@ -1,12 +1,14 @@
 import { readFileSync } from "node:fs";
-import { join } from "node:path";
 import { z } from "zod";
+import { subtitleModelDir } from "../../kernel/paths.js";
+import { SubtitleMismatch } from "../../kernel/ports/subtitles.js";
 import { resolveFont } from "../fonts/index.js";
 import { validateCues } from "../revisions/rules.js";
 import { discardPreparedAssets, writeAsset } from "../storage/assets.js";
 import { outputPath } from "../storage/layout.js";
 import { captionCues, serializeAss, serializeSrt, serializeVtt } from "../subtitles/captions.js";
 import { exportSnapshot, retainedOutput, revisionAudio, revisionTranscript, } from "./runtime-export-inputs.js";
+import { narrationChunks, narrationTextParts, } from "./runtime-narration-text.js";
 import { preparedResult, preparedText, publishResult } from "./runtime-publication.js";
 const wordsSchema = z.object({
     key: z.string(),
@@ -39,14 +41,15 @@ export async function executeSubtitleRecipe(deps, context, piece) {
         return cues(deps, context, piece, snapshot);
     if (piece.key === "subtitles:files")
         return files(deps, context, piece, snapshot);
-    throw new Error("Unknown subtitle recipe.");
+    throw new Error("Slopify hit an internal error (unknown kind of caption step). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
 }
 async function timing(deps, context, piece, snapshot) {
     const audio = await revisionAudio(deps, context, snapshot.view);
     if (audio.length === 0)
-        throw new Error("Subtitles need narration audio.");
-    if (deps.alignSubtitles === undefined)
-        throw new Error("Local subtitle alignment is unavailable in this build.");
+        throw new Error("Captions need narration audio, but this project has none. Turn captions off in Edit project → Subtitles, or turn narration on, then Retry stage.");
+    const alignSubtitles = deps.alignSubtitles;
+    if (alignSubtitles === undefined)
+        throw new Error("Slopify hit an internal error (the caption timing tool is missing from this build). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     if (!context.maySubmit(piece.id))
         return "held";
     const words = [];
@@ -55,11 +58,12 @@ async function timing(deps, context, piece, snapshot) {
     const total = audio.reduce((sum, segment) => sum + segment.seconds, 0);
     for (const segment of audio) {
         context.signal.throwIfAborted();
-        if (segment.path !== null && segment.kind !== "gap") {
-            const aligned = await deps.alignSubtitles({
-                audioPath: segment.path,
-                text: revisionTranscript(deps, snapshot, segment.kind),
-                cacheDir: join(deps.paths.dataDir, "models", "english-subtitles"),
+        const { path, kind } = segment;
+        if (path !== null && kind !== "gap") {
+            const aligned = await located(snapshot, kind, () => alignSubtitles({
+                audioPath: path,
+                text: revisionTranscript(deps, snapshot, kind),
+                cacheDir: subtitleModelDir(deps.paths.dataDir),
                 ffmpeg: deps.ffmpeg,
                 signal: context.signal,
                 onOmission: (value) => omissions.push({ ...value, start: value.start + offset }),
@@ -70,10 +74,10 @@ async function timing(deps, context, piece, snapshot) {
                     current: Math.round((100 * (offset + segment.seconds * (maximum > 0 ? current / maximum : 0))) / total),
                     total: 100,
                 }),
-            });
+            }));
             for (const word of aligned) {
                 if (word.end > segment.seconds + 0.1)
-                    throw new Error("Subtitle timing exceeds the narration duration.");
+                    throw new Error("Caption timing came out longer than the narration audio. Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
                 words.push({
                     ...word,
                     start: word.start + offset,
@@ -84,7 +88,7 @@ async function timing(deps, context, piece, snapshot) {
         offset += segment.seconds;
     }
     if (captionCues(words).length === 0)
-        throw new Error("No spoken words could be aligned. Check that the English article matches the audio.");
+        throw new Error("None of the narration could be matched to the article text, so captions can't be timed. Captions only work for English narration; if you uploaded your own audio, make sure it reads the article text, then Retry stage.");
     context.signal.throwIfAborted();
     const output = preparedText(deps, context, piece, "subtitle_words", "subtitles.json", JSON.stringify({ key: piece.logicalFingerprint ?? piece.fingerprint, words, omissions }));
     await publishResult(deps, context, piece, [output], { words, omissions }, output.asset);
@@ -96,7 +100,7 @@ async function cues(deps, context, piece, snapshot) {
     let value;
     if (manual !== undefined) {
         if (plan.work.find((one) => one.key === piece.key)?.disposition === "review")
-            throw new Error("Review the saved captions against the current narration before rebuilding.");
+            throw new Error("Your edited captions were written for an older version of the narration. Review them in Edit project → Captions and save, then Retry stage.");
         const audio = await revisionAudio(deps, context, view);
         const errors = validateCues(manual.cues, audio.reduce((sum, segment) => sum + segment.seconds, 0));
         if (errors.length > 0)
@@ -109,7 +113,7 @@ async function cues(deps, context, piece, snapshot) {
             one.state === "ready" &&
             one.workKey === "subtitles:timing");
         if (output === undefined)
-            throw new Error("The revision has no aligned subtitle timing.");
+            throw new Error("Caption timing is missing. Use Re-run section on Video, then Retry stage.");
         const timed = wordsSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, context.work.projectId, output.output.path), "utf8")));
         value = { cues: [...captionCues(timed.words)], omissions: timed.omissions };
     }
@@ -123,10 +127,10 @@ async function files(deps, context, piece, snapshot) {
     const { view } = snapshot;
     const config = view.revision.config.subtitles;
     if (config === undefined || config.mode === "off")
-        throw new Error("The admitted revision has no subtitles.");
+        throw new Error("Slopify hit an internal error (captions are off for this version of the project). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     const row = view.pieces.find((one) => one.key === "subtitles:cues" && one.selected && one.available && one.piece.state === "done");
     if (row?.piece.payload === null || row?.piece.payload === undefined)
-        throw new Error("The revision has no prepared captions.");
+        throw new Error("The captions haven't been prepared yet. Use Re-run section on Video, then Retry stage.");
     const value = cuesSchema.parse(JSON.parse(row.piece.payload));
     const previous = view.outputs.find((one) => one.output.role === "subtitle_font" && one.selected && one.available);
     const previousFiles = view.pieces.find((one) => one.key === "subtitles:files" &&
@@ -200,3 +204,62 @@ async function files(deps, context, piece, snapshot) {
         discardPreparedAssets(deps, prepared.map((one) => one.asset));
     }
 }
+// A mismatch names the place to fix: the time in the narration, the chunk that holds it (as
+// the Narration editor numbers them) and what was expected against what was heard. The
+// usual cause is a TTS request that skipped or reworded a sentence.
+async function located(snapshot, segment, align) {
+    try {
+        return await align();
+    }
+    catch (error) {
+        if (!(error instanceof SubtitleMismatch))
+            throw error;
+        throw new Error(mismatchMessage(snapshot, segment, error), { cause: error });
+    }
+}
+export function mismatchMessage(snapshot, segment, mismatch) {
+    let chunks = [];
+    try {
+        chunks = narrationChunks(narrationTextParts(snapshot.view, snapshot.plan, segment));
+    }
+    catch {
+        // Without a readable plan the message still gives the time and the words.
+    }
+    return describeMismatch(chunks, segment, mismatch);
+}
+export function describeMismatch(chunks, segment, mismatch) {
+    const probe = comparable(mismatch.expected).split(" ").slice(0, 6).join(" ");
+    const at = probe === ""
+        ? chunks.length - 1
+        : chunks.findIndex((chunk) => comparable(chunk.spokenText).includes(probe));
+    const chunk = at === -1 ? undefined : chunks[at];
+    const where = chunk === undefined
+        ? `${clock(mismatch.at)} into the ${segment} narration`
+        : `${clock(mismatch.at)} into the ${segment} narration, in narration chunk ${String(at + 1)} of ${String(chunks.length)} (it starts "${opening(chunk.spokenText)}")`;
+    const expected = mismatch.expected === "" ? "the end of the text" : `"${mismatch.expected}…"`;
+    const heard = mismatch.heard === "" ? "no more speech" : `"${mismatch.heard.toLowerCase()}…"`;
+    const fix = chunk === undefined
+        ? "Check that part of the narration, regenerate it in Edit project → Narration, then Resume."
+        : `In Edit project → Narration, regenerate narration chunk ${String(at + 1)}, then Resume.`;
+    return `Subtitles stopped matching the audio at ${where}. The text expected ${expected} but the audio has ${heard} The recording there probably skips or changes words. ${fix}`;
+}
+function comparable(text) {
+    return text
+        .toUpperCase()
+        .replace(/&/g, " AND ")
+        .replace(/[^A-Z0-9' ]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function opening(text) {
+    return text.trim().split(/\s+/).slice(0, 6).join(" ");
+}
+function clock(seconds) {
+    const whole = Math.floor(seconds);
+    const hours = Math.floor(whole / 3600);
+    const minutes = Math.floor((whole % 3600) / 60);
+    const rest = String(whole % 60).padStart(2, "0");
+    return hours > 0
+        ? `${String(hours)}:${String(minutes).padStart(2, "0")}:${rest}`
+        : `${String(minutes)}:${rest}`;
+}