@gentbajko/slopify 3.0.0 → 3.0.1

package/dist/slices/notifications/rules.js

@@ -18,6 +18,23 @@ export function noticeOf(previous, next) {
             return undefined;
     }
 }
+const reviewItemNames = {
+    article: "the article",
+    images: "an image",
+    narration: "the narration",
+    thumbnail: "the thumbnail",
+    shorts: "a short",
+};
+export function reviewNoticeText(subject) {
+    const title = subject.title.trim() === "" ? "Untitled project" : subject.title.trim();
+    const reason = shortReason(subject.reason);
+    const item = reviewItemNames[subject.stage] ?? "an item";
+    const headline = `Review needs a decision: ${title}`;
+    return {
+        headline: reason === undefined ? headline : `${headline} — ${reason}`,
+        detail: `The automatic review flagged ${item} and kept it. Open the project and press Overrule to keep it or Redo to make it again.`,
+    };
+}
 const reasonMax = 140;
 // A provider's failure can run to paragraphs; a notification has a line.
 export function shortReason(reason) {
@@ -71,12 +88,19 @@ export function topicsNoticeText(subject) {
 }
 export const testNotice = {
     headline: "Slopify test notification",
-    detail: "Notifications work. You'll get one when a run finishes, fails or waits for you.",
+    detail: "Notifications work. You'll get one when a run finishes, fails or waits for you, and when a review needs your decision.",
 };
 // The body a Notification URL receives: plain text, which ntfy shows as the message. Nothing
 // but the project's title, what happened and the provider's own short reason goes in it.
 export function webhookBody(text) {
-    return `${text.headline}\n${text.detail}\n`;
+    return `${text.headline}\n${text.detail}\n${text.link === undefined ? "" : `${text.link}\n`}`;
+}
+// Where a project opens in the browser, from the address the server listens on. A wildcard
+// (0.0.0.0 in Docker) or loopback address is reached as localhost from the same machine.
+export function projectLink(host, port, projectId) {
+    const wildcard = host === "0.0.0.0" || host === "::" || host === "" || host === "127.0.0.1";
+    const authority = wildcard ? "localhost" : host.includes(":") ? `[${host}]` : host;
+    return `http://${authority}:${String(port)}/projects/${encodeURIComponent(projectId)}`;
 }
 export const notificationUrlMax = 2048;
 // Empty clears the setting. Otherwise one absolute http(s) URL with no user name or password:

package/dist/slices/onboarding/first-run.js

@@ -1,29 +1,55 @@
+import { readinessIsUsable } from "../../kernel/ports/model.js";
+import { templateById } from "../project-templates/repo.js";
 import { starterPacks } from "./packs.js";
 import { sampleProjectIds } from "./sample.js";
-import { dismissFirstRun, firstRunDismissed, readPackRecords } from "./state.js";
+import { firstRunDismissed, readPackRecords } from "./state.js";
 // The first-run screen shows on a fresh install and never again once it is skipped or a real
-// project (anything but the samples) exists. A real project also dismisses it for good, so
-// deleting every project later does not bring it back.
-export function firstRunView(db, statuses, at) {
+// project (anything but the samples) exists. Reading it writes nothing: a real project that
+// exists before the screen was recorded as done is reported as `settle`, and the client
+// records it with POST /dismiss, so deleting every project later does not bring it back.
+export function firstRunView(db, statuses) {
     const samples = sampleProjectIds(db);
     const real = db
         .prepare("SELECT 1 FROM projects WHERE id IS NOT ? AND id IS NOT ? AND id IS NOT ? LIMIT 1")
         .get(samples.library, samples.audiobook, samples.podcast) !== undefined;
-    if (real)
-        dismissFirstRun(db, at);
+    const dismissed = firstRunDismissed(db);
     const packs = readPackRecords(db);
     return {
-        show: !real && !firstRunDismissed(db),
+        show: !real && !dismissed,
+        settle: real && !dismissed,
+        voice: firstVoice(statuses),
         sampleProjectId: samples.library,
         samples,
         clis: detectedClis(statuses),
-        packs: starterPacks.map((pack) => ({
-            id: pack.id,
-            name: pack.name,
-            summary: pack.summary,
-            installed: packs[pack.id] !== undefined,
-            templateId: packs[pack.id]?.template ?? null,
-        })),
+        // A pack counts as added only with its template: the first short adds a pack's prompts and
+        // voice but no template, and Add pack must still be able to add that template later (or
+        // again, after it was deleted).
+        packs: starterPacks.map((pack) => {
+            const template = packs[pack.id]?.template;
+            const kept = template !== undefined && templateById(db, template) !== undefined;
+            return {
+                id: pack.id,
+                name: pack.name,
+                summary: pack.summary,
+                installed: kept,
+                templateId: kept ? template : null,
+            };
+        }),
+    };
+}
+// Who would narrate a first short: a keyed voice provider when one has a key, else the
+// computer's own voice when a speech program was found.
+export function firstVoice(statuses) {
+    const keyed = statuses.find((row) => row.family === "tts" && row.readiness.kind === "keyed" && readinessIsUsable(row.readiness));
+    const system = statuses.find((row) => row.readiness.kind === "local")?.readiness;
+    const local = system?.kind === "local" ? system : undefined;
+    return {
+        keyed: keyed?.displayName ?? null,
+        system: {
+            available: local?.available === true,
+            engine: local?.engine ?? null,
+            issue: local?.issue ?? null,
+        },
     };
 }
 // What this machine can make without a key: each agent CLI Slopify found, and whether it

package/dist/slices/onboarding/full-video.js

@@ -0,0 +1,81 @@
+import { projectById } from "../admission/repo.js";
+import { usesShortMode } from "../admission/short-mode.js";
+import { promptById } from "../library/repo.js";
+import { createDraft } from "../play-drafts/service.js";
+import { templateById } from "../project-templates/repo.js";
+import { freshTemplateDraft } from "../project-templates/setup.js";
+import { installPack } from "./install.js";
+import { starterPacks, starterSet } from "./packs.js";
+import { readPackRecords } from "./state.js";
+import { packTemplate } from "./template.js";
+// The pack whose short script the short was written from. A short made without a pack, or
+// whose pack's prompts were since renamed or removed, is the starter set's.
+export function shortPack(deps, articlePrompt) {
+    const records = readPackRecords(deps.db);
+    for (const pack of starterPacks) {
+        const id = records[pack.id]?.prompts.shortScript;
+        if (id !== undefined && promptById(deps.db, id)?.name === articlePrompt)
+            return pack;
+    }
+    return starterSet;
+}
+export function fullVideoDraft(deps, input) {
+    const project = projectById(deps.db, input.projectId);
+    if (project === undefined)
+        return { ok: false, reason: "not-found" };
+    const config = project.config;
+    if (!usesShortMode(config))
+        return { ok: false, reason: "not-short" };
+    const topic = config.values.topic?.trim() || project.title;
+    const pack = shortPack(deps, config.articlePrompt ?? "");
+    const document = packDocument(deps, pack);
+    if (document === undefined)
+        return { ok: false, reason: "not-found" };
+    const provider = (choice, fallback) => choice === undefined || fallback.provider !== ""
+        ? fallback
+        : {
+            provider: choice.provider,
+            model: choice.model,
+            ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
+        };
+    const form = document.form;
+    return createDraft(deps, {
+        id: input.draftId,
+        document: {
+            ...document,
+            form: {
+                ...form,
+                title: project.title,
+                values: { ...form.values, topic },
+                llm: provider(config.llm, form.llm),
+                images: provider(config.images, form.images),
+                audio: config.audio === undefined
+                    ? form.audio
+                    : {
+                        ...form.audio,
+                        provider: config.audio.provider,
+                        model: config.audio.model,
+                        voice: config.audio.voice,
+                    },
+            },
+        },
+    });
+}
+// A pack's own template, as Templates → Apply to Play opens it. The starter set has no long
+// video prompt of its own and no template, so it is its settings without one saved.
+function packDocument(deps, pack) {
+    const withTemplate = pack.id !== starterSet.id;
+    const installed = installPack(deps, pack.id, { template: withTemplate });
+    if (!installed.ok)
+        return undefined;
+    const { templateId } = installed.value;
+    if (!withTemplate || templateId === null)
+        return packTemplate(pack, installed.value.prompts, installed.value.voice ?? pack.voice.voiceId);
+    const template = templateById(deps.db, templateId);
+    if (template === undefined)
+        return undefined;
+    return freshTemplateDraft(deps, template.document, {
+        id: template.id,
+        version: template.version,
+    });
+}

package/dist/slices/onboarding/model.js

@@ -13,6 +13,22 @@ export const sampleProjectsSchema = z.object({
 export const firstRunViewSchema = z
     .object({
     show: z.boolean(),
+    // A real project exists but the screen was never recorded as done: the client records it
+    // with POST /dismiss, so deleting every project later does not bring the screen back.
+    // Reading this view writes nothing.
+    settle: z.boolean(),
+    // Who narrates a first short: a voice provider with a saved key, else the computer's own.
+    voice: z.object({
+        // The keyed voice provider that would be used, by name ("OpenAI"), or null.
+        keyed: z.string().nullable(),
+        system: z.object({
+            available: z.boolean(),
+            // The speech program found ("eSpeak NG", "macOS voices").
+            engine: z.string().nullable(),
+            // Why none can be used, with the fix.
+            issue: z.string().nullable(),
+        }),
+    }),
     // The Library of Alexandria's project, as before the demos; `samples` has all three.
     sampleProjectId: z.string().nullable(),
     samples: sampleProjectsSchema,
@@ -42,6 +58,11 @@ export const quickShortInputSchema = z
     requestId: z.uuid(),
 })
     .strict();
+// A finished short's "Make the full video on this topic": the draft id is the browser's, so a
+// repeated press opens the same Play draft instead of making another.
+export const fullVideoInputSchema = z
+    .object({ projectId: z.string().min(1).max(64), draftId: z.uuid() })
+    .strict();
 export const quickShortResultSchema = z.object({
     projectId: z.string(),
     replayed: z.boolean(),

package/dist/slices/onboarding/quick-short.js

@@ -1,5 +1,7 @@
+import { readinessIsUsable } from "../../kernel/ports/model.js";
 import { titleMax } from "../admission/rules.js";
 import { defaultSentencePauseSeconds } from "../narration/pauses-model.js";
+import { systemVoiceProvider } from "../settings/model.js";
 const textClis = ["claude-code", "codex", "gemini"];
 const keyedImages = ["openai-image", "google-image", "fal", "replicate"];
 const keyedVoices = ["openai-tts", "elevenlabs", "cartesia", "inworld"];
@@ -10,12 +12,7 @@ const preferred = {
     "openai-tts": /^gpt-4o-mini-tts$/,
 };
 function ready(status) {
-    if (status === undefined)
-        return false;
-    const readiness = status.readiness;
-    return readiness.kind === "cli"
-        ? readiness.installed && readiness.issue === undefined
-        : readiness.hasKey;
+    return status !== undefined && readinessIsUsable(status.readiness);
 }
 async function firstModel(modelsFor, provider, family) {
     let models;
@@ -62,8 +59,11 @@ export async function planShortProviders(input) {
             need: "images",
             message: "No image model is ready. Install Codex CLI and sign in to it, or add an OpenAI, Google, fal.ai or Replicate key in Settings → Providers.",
         });
+    // A keyed voice first (a saved one, else the pack's suggestion), then the computer's own: a
+    // saved system voice, else the one found. Keys are the better voice, never a requirement.
     let audio;
-    const saved = input.voices.find((voice) => ready(status(voice.provider)));
+    const keyed = (provider) => provider !== systemVoiceProvider;
+    const saved = input.voices.find((voice) => keyed(voice.provider) && ready(status(voice.provider)));
     const provider = saved?.provider ??
         (ready(status(input.suggested.provider)) ? input.suggested.provider : undefined);
     if (provider !== undefined) {
@@ -71,16 +71,31 @@ export async function planShortProviders(input) {
         if (model !== undefined)
             audio = { provider, model, voice: saved?.voiceId ?? input.suggested.voiceId };
     }
-    if (audio === undefined)
+    let systemVoice = false;
+    const system = status(systemVoiceProvider);
+    if (audio === undefined && ready(system) && input.systemVoice !== undefined) {
+        const savedSystem = input.voices.find((voice) => voice.provider === systemVoiceProvider);
+        audio = {
+            provider: systemVoiceProvider,
+            model: input.systemVoice.model,
+            voice: savedSystem?.voiceId ?? input.systemVoice.voiceId,
+        };
+        systemVoice = true;
+    }
+    if (audio === undefined) {
+        const systemIssue = system?.readiness.kind === "local" && system.readiness.issue !== undefined
+            ? ` ${system.readiness.issue}`
+            : "";
         gaps.push({
             need: "voice",
             message: keyedVoices.some((id) => ready(status(id)))
                 ? "Your voice provider has no saved voice yet. Add one in Settings → Voices, then try again."
-                : "No voice is ready to narrate the short: command-line tools can't speak. Add an OpenAI, ElevenLabs, Cartesia or Inworld key in Settings → Providers (with ElevenLabs, Cartesia or Inworld, also save a voice in Settings → Voices).",
+                : `No voice is ready to narrate the short: no voice key is saved and this computer's built-in voice can't be used.${systemIssue || " Install espeak-ng, or add an OpenAI, ElevenLabs, Cartesia or Inworld key in Settings → Providers (with ElevenLabs, Cartesia or Inworld, also save a voice in Settings → Voices)."}`,
         });
+    }
     return llm === undefined || images === undefined || audio === undefined
         ? { ok: false, gaps }
-        : { ok: true, providers: { llm, audio, images } };
+        : { ok: true, providers: { llm, audio, images }, systemVoice };
 }
 // The short-mode draft for a topic, using the pack's (or starter set's) script and scene
 // prompts under the names they have in the library.

package/dist/slices/play-drafts/convert.js

@@ -12,13 +12,13 @@ import { defaultSubtitles } from "../subtitles/model.js";
 import { ambientBedOfForm, ambientBedProblems } from "../video/ambient-bed.js";
 // Said where the control is, since the music sits in a closed disclosure on the Export rail.
 const musicMessages = {
-    uploading: "The shorts' background music is still uploading, so the run can't start yet. Wait for it to finish, or remove it under Outputs → Export → More shorts options → Background music.",
-    missing: "The shorts' background music file is no longer available (it was not uploaded again after the draft was copied, or the upload failed). Choose the file again under Outputs → Export → More shorts options → Background music, or remove it.",
+    uploading: "The shorts' background music is still uploading, so the run can't start yet. Wait for it to finish, or remove it under Outputs → More shorts options → Background music.",
+    missing: "The shorts' background music file is no longer available (it was not uploaded again after the draft was copied, or the upload failed). Choose the file again under Outputs → More shorts options → Background music, or remove it.",
 };
 function pickMusic(id) {
     return id === undefined ? {} : { shortsMusic: id };
 }
-const bedWhere = "under Outputs → Export → Ambient sound";
+const bedWhere = "under Video and style → Ambient sound";
 const bedMessages = {
     uploading: `The ambient sound's audio file is still uploading, so the run can't start yet. Wait for it to finish ${bedWhere}.`,
     missing: `The ambient sound's audio file is missing (it was never chosen, was not uploaded again after the draft was copied, or the upload failed). Choose the file ${bedWhere}, or pick Rain, Fireplace or Wind instead.`,

package/dist/slices/play-drafts/readiness.js

@@ -54,7 +54,7 @@ export async function checkDraftReadiness(deps, runs) {
         if (!provider || !readinessIsUsable(provider.readiness)) {
             fields.push({
                 field: c.field,
-                message: provider?.readiness.kind === "cli" && provider.readiness.issue
+                message: provider !== undefined && provider.readiness.kind !== "keyed" && provider.readiness.issue
                     ? provider.readiness.issue
                     : "Set up this provider in Settings → Providers before starting.",
             });

package/dist/slices/project-templates/from-project.js

@@ -13,11 +13,12 @@ import { currentRevisionId, revisionById } from "../revisions/repo.js";
 import { shortsExtrasForm } from "../shorts/model.js";
 import { ambientBedFormOf } from "../video/ambient-bed.js";
 import { usesScriptPrompt } from "../voices/model.js";
+import { templateNameMax } from "./schema.js";
 import { createTemplate, readTemplate } from "./service.js";
 export const projectTemplateCreateSchema = z
     .object({
     id: z.uuid(),
-    name: z.string().trim().min(1).max(200),
+    name: z.string().trim().min(1).max(templateNameMax),
     projectId: z.string().min(1).max(64),
     revisionId: z.string().min(1).max(64),
 })
@@ -65,7 +66,7 @@ export function createTemplateFromProject(deps, input) {
         return result;
     });
 }
-function documentFromProject(deps, revision) {
+export function documentFromProject(deps, revision) {
     const config = revision.config;
     const prompts = [];
     const entries = [];
@@ -211,7 +212,9 @@ function documentFromProject(deps, revision) {
             // it cuts every N seconds like the project did.
             ...(config.videoEdit === undefined ? {} : { videoEdit: config.videoEdit }),
             ...(config.reviews === undefined ? {} : { reviews: reviewSettingsForm(config.reviews) }),
-            ...(config.voices === undefined ? {} : { voices: config.voices }),
+            // Without the book: every run of a template would otherwise be the same chapter. "Make the
+            // next chapter" (`next-chapter.ts`) sets it itself.
+            ...(config.voices === undefined ? {} : { voices: withoutBook(config.voices) }),
             ...(config.ambientBed === undefined
                 ? {}
                 : { ambientBed: ambientBedFormOf(config.ambientBed) }),
@@ -265,3 +268,7 @@ function documentFromProject(deps, revision) {
         fontUpload: null,
     };
 }
+function withoutBook(voices) {
+    const { book: _book, ...rest } = voices;
+    return rest;
+}

package/dist/slices/project-templates/next-chapter.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { projectById } from "../admission/repo.js";
+import { projectChannelId } from "../channels/repo.js";
+import { draftRow } from "../play-drafts/repo.js";
+import { createDraft, readDraft } from "../play-drafts/service.js";
+import { currentRevisionId, revisionById } from "../revisions/repo.js";
+import { bookChapterMax, bookLabel, bookTitleMax } from "../voices/model.js";
+import { documentFromProject } from "./from-project.js";
+// Books: an audiobook is written chapter by chapter, one project each. "Make the next chapter"
+// on a chapter opens a new Play draft with everything the book shares - format, speakers and
+// their voices, channel (and so its cast), prompts and settings - and the chapter number one
+// higher. The chapter's own words are left empty: the new chapter is written or pasted fresh,
+// and files the last one was given are listed to attach again, as a template's are.
+export const nextChapterSchema = z
+    .object({ id: z.uuid(), projectId: z.string().min(1).max(64) })
+    .strict()
+    .readonly();
+// The book a project's next chapter belongs to: its own book one chapter on, or, for an
+// audiobook made on its own, a book named after it whose second chapter comes next.
+export function nextBook(title, book) {
+    return book === undefined
+        ? { title: title.trim().slice(0, bookTitleMax) || "Untitled book", chapter: 2 }
+        : { title: book.title, chapter: Math.min(bookChapterMax, book.chapter + 1) };
+}
+export function makeNextChapter(deps, input) {
+    const parsed = nextChapterSchema.safeParse(input);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "not-found",
+            message: "That project could not be found. Open it again from Projects, then try again.",
+        };
+    const { id, projectId } = parsed.data;
+    return transact(deps.db, () => {
+        // Pressed twice (a retry after a dropped answer): the draft it made the first time.
+        if (draftRow(deps.db, id) !== undefined) {
+            const made = readDraft(deps, id);
+            if (made.ok)
+                return { ok: true, value: made.value };
+        }
+        const project = projectById(deps.db, projectId);
+        const current = project === undefined ? undefined : currentRevisionId(deps.db, project.id);
+        const revision = project === undefined || current === undefined
+            ? undefined
+            : revisionById(deps.db, project.id, current);
+        if (project === undefined || revision === undefined)
+            return {
+                ok: false,
+                reason: "not-found",
+                message: "That project could not be found; it may have been deleted. Open Projects and pick another chapter.",
+            };
+        const voices = revision.config.voices;
+        if (voices?.format !== "audiobook")
+            return {
+                ok: false,
+                reason: "not-an-audiobook",
+                message: "Only an audiobook has chapters. Pick Audiobook under Speakers (Play → Narration) to start a book.",
+            };
+        const book = nextBook(revision.config.title, voices.book);
+        const document = documentFromProject(deps, revision);
+        const form = document.form;
+        const result = createDraft(deps, {
+            id,
+            document: {
+                ...document,
+                channelId: projectChannelId(deps.db, project.id),
+                form: {
+                    ...form,
+                    title: bookLabel(book),
+                    voices: { ...voices, book },
+                    provided: {
+                        ...form.provided,
+                        // The new chapter's own words, written or pasted fresh.
+                        research: "",
+                        article: "",
+                    },
+                },
+            },
+        });
+        if (!result.ok)
+            return {
+                ok: false,
+                reason: "conflict",
+                message: "The next chapter's draft could not be made. Press Make the next chapter again; if it keeps failing, use Download diagnostics in Settings and report it.",
+            };
+        // Files the last chapter was given are attached again on Play, as with a template.
+        deps.db.prepare("UPDATE play_draft_attachments SET status='reattach' WHERE draft_id=?").run(id);
+        const made = readDraft(deps, id);
+        if (!made.ok)
+            throw new Error("The next chapter's draft could not be read back");
+        return { ok: true, value: made.value };
+    });
+}

package/dist/slices/project-templates/one-off.js

@@ -1,6 +1,6 @@
 import { detectSlots } from "../admission/substitute.js";
 // A template keeps the settings, never what was typed for one video. A keyword the project
-// title names ({{Topic}} in "D&D Lore: {{Topic}}") is the video's topic: it changes with every
+// title names ({{Topic}} in "History: {{Topic}}") is the video's topic: it changes with every
 // video, so a template stores it empty. Every other keyword ({{minWords}}, {{style}}) is a
 // setting and keeps its value.
 export function topicKeywords(title) {

package/dist/slices/project-templates/schema.js

@@ -1,9 +1,14 @@
 import { z } from "zod";
 import { playDraftDocumentSchema } from "../play-drafts/schema.js";
+// The longest template name, in characters. Play's Save as template and Library → Templates
+// (save and rename) cap their name fields at it, and a new template is refused past it.
+export const templateNameMax = 120;
+// A template named before the cap (Play once allowed 200) can still be saved under its name.
+const templateNameStoredMax = 200;
 export const templateCreateSchema = z
     .object({
     id: z.uuid(),
-    name: z.string().trim().min(1).max(200),
+    name: z.string().trim().min(1).max(templateNameMax),
     document: playDraftDocumentSchema,
 })
     .strict()
@@ -11,6 +16,7 @@ export const templateCreateSchema = z
 export const templateUpdateSchema = templateCreateSchema
     .unwrap()
     .extend({
+    name: z.string().trim().min(1).max(templateNameStoredMax),
     baseVersion: z.number().int().positive(),
     mutationId: z.uuid(),
 })

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

@@ -67,6 +67,11 @@ export function exportRecipes(context, audio) {
                 (audio.sections ?? []).map((section) => [section.title, section.firstTurn]),
                 config.title,
                 ...master.values,
+                // The book's title and chapter become the files' album and track tags; a project
+                // that is no chapter of a book keeps the values it always had.
+                ...(voices.book === undefined
+                    ? []
+                    : [["book-v1", voices.book.title, voices.book.chapter]]),
             ],
         }, [...audio.keys, timing.key, ...master.keys], { unresolved: audio.sections === undefined }));
     if (config.subtitles === undefined || config.subtitles.mode === "off")

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

@@ -249,7 +249,7 @@ function speakerGlossary(context, speaker, glossary) {
     if (!own.ok)
         return {
             ok: false,
-            reason: `${speaker.name.trim()}'s pronunciations can't be used: ${own.reason.replace("Edit the glossary or turn off Use Pronunciation Glossary.", "Fix them under Speakers (Play → Audio, or Edit project → Providers).")}`,
+            reason: `${speaker.name.trim()}'s pronunciations can't be used: ${own.reason.replace("Edit the glossary or turn off Use Pronunciation Glossary.", "Fix them under Speakers (Play → Narration, or Edit project → Providers).")}`,
         };
     const run = context.config.audio?.usePronunciationGlossary === true && glossary?.ok === true
         ? glossary.entries

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

@@ -71,7 +71,22 @@ export function createReviewRedos() {
         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.");

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

@@ -17,7 +17,7 @@ export async function exportBed(deps, context, view) {
     };
     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 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() })

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

@@ -8,7 +8,7 @@ import { latestVerdict, saveVerdict } from "../reviews/repo.js";
 import { parseVerdict, reviewMessages } from "../reviews/verdict.js";
 import { pickedShortsOf } from "../shorts/clips.js";
 import { outputPath } from "../storage/layout.js";
-import { exportSnapshot } from "./runtime-export-inputs.js";
+import { exportSnapshot, revisionTranscript, } from "./runtime-export-inputs.js";
 import { savedCatalogue } from "./runtime-plan.js";
 import { publishResult } from "./runtime-publication.js";
 import { wordsSchema } from "./runtime-subtitles.js";
@@ -46,8 +46,8 @@ export async function executeReviewRecipe(deps, context, providers, piece) {
     if (values === undefined || !values.success)
         throw new Error("Slopify hit an internal error (a review step was set up wrongly). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     const [stage, itemKey, , provider, model, thinking, prompt, mode, retries] = values.data;
-    const { view, plan } = exportSnapshot(deps, context, piece);
-    const material = reviewMaterial(deps, context, view, plan.recipes, stage, itemKey, prompt);
+    const snapshot = exportSnapshot(deps, context, piece);
+    const material = reviewMaterial(deps, context, snapshot, stage, itemKey, prompt);
     const previous = latestVerdict(deps.db, context.work.projectId, itemKey);
     const attempt = nextAttempt(previous, material.itemFingerprint);
     const row = deps.db
@@ -102,6 +102,16 @@ export async function executeReviewRecipe(deps, context, providers, piece) {
         outcome: saved.outcome,
         attempt: saved.attempt,
     });
+    // Kept and flagged: nothing more happens to the item until someone decides.
+    if (saved.outcome === "flagged")
+        context.emit({
+            type: "review.flagged",
+            projectId: context.work.projectId,
+            verdictId: saved.id,
+            stage: saved.stage,
+            itemKey: saved.itemKey,
+            ...(saved.reasons[0] === undefined ? {} : { reason: saved.reasons[0] }),
+        });
     deps.count?.("stage.completed", {
         provider,
         model,
@@ -110,7 +120,27 @@ export async function executeReviewRecipe(deps, context, providers, piece) {
     });
     return "done";
 }
-function reviewMaterial(deps, context, view, recipes, stage, itemKey, prompt) {
+// What the voice was asked to say, segment by segment, as the word timing matched it: the intro
+// and outro, and the prepared or hand-edited spoken text rather than the article as written.
+// Falls back to the article when those texts can't be read.
+function spokenText(deps, snapshot) {
+    const present = ["intro", "body", "outro"].filter((kind) => snapshot.view.outputs.some((one) => one.selected &&
+        one.available &&
+        one.state === "ready" &&
+        one.output.role === `audio_${kind}`));
+    try {
+        const text = present.map((kind) => revisionTranscript(deps, snapshot, kind)).join("\n\n");
+        if (text.trim() !== "")
+            return text;
+    }
+    catch {
+        // The article below is still a fair reference.
+    }
+    return plainText(snapshot.view.articleMarkdown ?? "");
+}
+function reviewMaterial(deps, context, snapshot, stage, itemKey, prompt) {
+    const { view } = snapshot;
+    const recipes = snapshot.plan.recipes;
     const config = view.revision.config;
     const output = (workKey, role) => view.outputs.find((row) => row.workKey === workKey &&
         row.selected &&
@@ -186,7 +216,7 @@ function reviewMaterial(deps, context, view, recipes, stage, itemKey, prompt) {
                 request: request([
                     {
                         label: "Text the narration was read from",
-                        text: clip(plainText(view.articleMarkdown ?? "")),
+                        text: clip(spokenText(deps, snapshot)),
                     },
                     { label: "What the timing heard", text: clip(words.map((word) => word.text).join(" ")) },
                     {