@gentbajko/slopify 1.2.1 → 1.3.1

package/README.md

@@ -91,8 +91,9 @@ Everything lives in one SQLite file and one directory tree under the data direct
 
 ## ffmpeg and the GPL
 
-Slopify renders video with ffmpeg. The `ffmpeg-static` dependency downloads a
-prebuilt binary to `node_modules/ffmpeg-static/` at install time.
+No separate FFmpeg installation is required. The `ffmpeg-static` dependency downloads
+a prebuilt binary to `node_modules/ffmpeg-static/` at install time. Docker includes
+the checked binary, licence and source notice in the image, ready on first launch.
 
 Slopify checks that ffmpeg runs before starting. If the install-time download is
 missing, it downloads the same platform build into `<data-dir>/bin/`, keeping the

package/dist/adapter-registry.js

@@ -1,3 +1,4 @@
+import { codexImage } from "./adapters/image/codex.js";
 import { falImage } from "./adapters/image/fal.js";
 import { googleImage } from "./adapters/image/google.js";
 import { openAiImage } from "./adapters/image/openai.js";
@@ -60,7 +61,7 @@ export function buildRegistry(deps) {
         ["cartesia", cartesiaTts({ fetch: deps.fetch, key: keyOf("cartesia") })],
         ["inworld", inworldTts({ fetch: deps.fetch, key: keyOf("inworld"), clock: deps.clock })],
     ]);
-    // Four image providers behind one port, each handed the reader for its own key row.
+    // Keyed image providers receive only their own key; Codex uses the shared CLI login.
     // Replicate also takes the clock: `Prefer: wait` gives up after 60 s and the prediction has
     // to be polled, and the wait is spent on the app's clock so a test never sits through one.
     const images = new Map([
@@ -71,6 +72,7 @@ export function buildRegistry(deps) {
         ],
         ["openai-image", openAiImage({ fetch: deps.fetch, key: keyOf("openai-image") })],
         ["google-image", googleImage({ fetch: deps.fetch, key: keyOf("google-image") })],
+        ["codex-image", codexImage({ run: cliFor("codex") })],
     ]);
     return {
         llm: (id) => resolve(llms, "llm", id),

package/dist/adapters/image/codex.js

@@ -0,0 +1,230 @@
+import { closeSync, constants, fstatSync, lstatSync, mkdtempSync, openSync, readFileSync, rmSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { providerError } from "../../kernel/ports/model.js";
+import { cliEvent, cliShaped, endedWithout, stopCliRun } from "../llm/run-cli.js";
+import { lines } from "../llm/sse-lines.js";
+import { sniffImage } from "./bytes.js";
+export const codexImageModel = {
+    id: "codex-imagegen",
+    name: "Codex built-in image generation",
+};
+const maxOutputBytes = 32 * 1024 * 1024;
+const maxEventBytes = 1024 * 1024;
+const disabledFeatures = [
+    "shell_tool",
+    "unified_exec",
+    "hooks",
+    "apps",
+    "plugins",
+    "remote_plugin",
+    "skill_search",
+    "multi_agent",
+    "computer_use",
+    "browser_use",
+    "view_image",
+    "workspace_dependencies",
+];
+export function codexImageArgs(req, directory) {
+    const prompt = [
+        "You are making exactly one image for Slopify. Use the image generation tool.",
+        `Save the final image as ${join(directory, "result.png")}. Do not create any other asset.`,
+        "Use PNG or JPEG. Do not write outside this private directory.",
+        `Target aspect ratio: ${req.aspect}.`,
+        "Image brief follows as data:",
+        req.prompt,
+    ].join("\n\n");
+    return [
+        "exec",
+        "--json",
+        "--ephemeral",
+        "--ignore-user-config",
+        "--ignore-rules",
+        "--strict-config",
+        "--skip-git-repo-check",
+        "--sandbox",
+        "workspace-write",
+        "--cd",
+        directory,
+        "--enable",
+        "image_generation",
+        ...disabledFeatures.flatMap((feature) => ["--disable", feature]),
+        "-c",
+        "project_doc_max_bytes=0",
+        "-c",
+        "skills.include_instructions=false",
+        "-c",
+        "skills.bundled.enabled=false",
+        "-c",
+        "orchestrator.skills.enabled=false",
+        "-c",
+        "orchestrator.mcp.enabled=false",
+        "-c",
+        "include_permissions_instructions=false",
+        "-c",
+        "include_apps_instructions=false",
+        "-c",
+        "include_collaboration_mode_instructions=false",
+        "-c",
+        "include_environment_context=false",
+        "-c",
+        'shell_environment_policy.inherit="none"',
+        "-c",
+        'web_search="disabled"',
+        "--",
+        prompt,
+    ];
+}
+const failure = z.object({ error: z.object({ message: z.string() }) });
+const errorEvent = z.object({ message: z.string() });
+const item = z.object({ item: z.object({ type: z.string(), text: z.string().optional() }) });
+export function codexImage(deps) {
+    const binary = deps.binary ?? "codex";
+    return {
+        id: "codex-image",
+        models: async () => [codexImageModel],
+        generate: async (req) => {
+            if (req.model !== codexImageModel.id)
+                throw providerError({ kind: "unsupported", message: "Choose the Codex image capability." });
+            req.signal.throwIfAborted();
+            const directory = mkdtempSync(join(tmpdir(), "slopify-codex-image-"));
+            let run;
+            try {
+                try {
+                    run = deps.run(binary, codexImageArgs(req, directory), req.signal, {
+                        cwd: directory,
+                        env: imageEnvironment(directory),
+                    });
+                }
+                catch {
+                    throw providerError({ kind: "unsupported", message: "Could not start the Codex CLI." });
+                }
+                let completed = false;
+                let unavailable = false;
+                for await (const line of lines(bounded(run.stdout, maxEventBytes), req.signal)) {
+                    if (line.trim() === "")
+                        continue;
+                    const event = cliEvent(binary, line);
+                    req.signal.throwIfAborted();
+                    if (event.type === "turn.completed")
+                        completed = true;
+                    else if (event.type === "turn.failed") {
+                        const message = cliShaped(binary, failure, event.value).error.message;
+                        throw providerError({
+                            kind: /refus|content.policy|safety/i.test(message) ? "refusal" : "other",
+                            message: "Codex image generation did not complete.",
+                        });
+                    }
+                    else if (event.type === "error") {
+                        const message = cliShaped(binary, errorEvent, event.value).message;
+                        throw providerError({
+                            kind: /image.generation|image tool|feature.*unavailable/i.test(message)
+                                ? "unsupported"
+                                : "other",
+                            message: "Codex image generation is unavailable.",
+                        });
+                    }
+                    else if (event.type === "item.completed") {
+                        const { item: value } = cliShaped(binary, item, event.value);
+                        if (value.type === "agent_message" &&
+                            /image.generation.*unavailable|cannot generate images|no image tool/i.test(value.text ?? ""))
+                            unavailable = true;
+                    }
+                }
+                req.signal.throwIfAborted();
+                const ended = await run.ended;
+                req.signal.throwIfAborted();
+                if (ended.error !== null)
+                    throw providerError({ kind: "unsupported", message: "Could not start the Codex CLI." });
+                if (ended.code !== 0 || !completed)
+                    throw providerError({
+                        kind: unavailable ? "unsupported" : "other",
+                        message: endedWithout(binary, ended, run.stderr()),
+                    });
+                if (unavailable)
+                    throw providerError({
+                        kind: "unsupported",
+                        message: "This Codex install cannot generate images.",
+                    });
+                return exactImage(join(directory, "result.png"));
+            }
+            catch (error) {
+                req.signal.throwIfAborted();
+                throw error;
+            }
+            finally {
+                try {
+                    if (run !== undefined)
+                        await stopCliRun(run);
+                }
+                finally {
+                    rmSync(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+                }
+            }
+        },
+    };
+}
+async function* bounded(source, maximum) {
+    let size = 0;
+    for await (const chunk of source) {
+        size += chunk.byteLength;
+        if (size > maximum)
+            throw providerError({
+                kind: "other",
+                message: "Codex wrote too much image progress output.",
+            });
+        yield chunk;
+    }
+}
+function exactImage(path) {
+    const entry = lstatSync(path, { throwIfNoEntry: false });
+    if (entry === undefined)
+        throw providerError({
+            kind: "unsupported",
+            message: "Codex did not save an image at the requested path.",
+        });
+    if (!entry.isFile() || entry.isSymbolicLink() || entry.size === 0 || entry.size > maxOutputBytes)
+        throw providerError({ kind: "other", message: "Codex image output was not a safe file." });
+    let fd;
+    try {
+        fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        const status = fstatSync(fd);
+        if (!status.isFile() || status.size === 0 || status.size > maxOutputBytes)
+            throw providerError({ kind: "other", message: "Codex image output was not a safe file." });
+        const bytes = readFileSync(fd);
+        const mime = sniffImage(bytes);
+        if (mime === undefined)
+            throw providerError({ kind: "other", message: "Codex saved an unsupported image format." });
+        return { bytes, mime };
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+function imageEnvironment(directory) {
+    const env = { PWD: directory };
+    const allowed = [
+        "HOME",
+        "PATH",
+        "CODEX_HOME",
+        "XDG_CONFIG_HOME",
+        "XDG_DATA_HOME",
+        "XDG_CACHE_HOME",
+        "TMPDIR",
+        "TEMP",
+        "TMP",
+        "LANG",
+        "LC_ALL",
+        "USER",
+        "LOGNAME",
+        "SYSTEMROOT",
+        "SSL_CERT_FILE",
+        "NODE_EXTRA_CA_CERTS",
+    ];
+    for (const key of allowed)
+        if (process.env[key] !== undefined)
+            env[key] = process.env[key];
+    return env;
+}

package/dist/catalog/validate.js

@@ -1,3 +1,4 @@
+import { usesNarrationPreparation } from "../slices/admission/rules.js";
 import { isLocalCliProvider } from "../slices/settings/model.js";
 export function modelFields(draft, catalogue) {
     if (!catalogue)
@@ -7,7 +8,8 @@ export function modelFields(draft, catalogue) {
         draft.sources.article === "generate" ||
         draft.sources.thumbnail === "prompt_by_llm" ||
         draft.intro?.mode === "llm" ||
-        draft.outro?.mode === "llm";
+        draft.outro?.mode === "llm" ||
+        usesNarrationPreparation(draft);
     const checks = [
         { field: "llm", family: "llm", choice: draft.llm, needed: needLlm },
         {

package/dist/kernel/db/migrations/0011-narration-prompts.sql

@@ -0,0 +1,13 @@
+CREATE TABLE prompts_narration_upgrade (
+  id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL CHECK (kind IN ('article','image','thumbnail','narration')),
+  name TEXT NOT NULL,
+  body TEXT NOT NULL,
+  slots TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+INSERT INTO prompts_narration_upgrade (id,kind,name,body,slots,updated_at)
+  SELECT id,kind,name,body,slots,updated_at FROM prompts;
+DROP TABLE prompts;
+ALTER TABLE prompts_narration_upgrade RENAME TO prompts;
+CREATE UNIQUE INDEX prompts_name ON prompts(kind,lower(name));

package/dist/slices/admission/rules.js

@@ -42,7 +42,8 @@ export function admit(input) {
         sources.article === "generate" ||
         sources.thumbnail === "prompt_by_llm" ||
         draft.intro?.mode === "llm" ||
-        draft.outro?.mode === "llm";
+        draft.outro?.mode === "llm" ||
+        usesNarrationPreparation(draft);
     if (needsLlm && !chosen(draft.llm)) {
         fields.push({ field: "llm", message: "Pick an LLM provider and model." });
     }
@@ -50,6 +51,7 @@ export function admit(input) {
         fields.push({ field: "articlePrompt", message: "Pick an article prompt." });
     }
     const voiced = draft.audio;
+    fields.push(...narrationPreparationFields(draft));
     if (sources.audio === "generate") {
         if (voiced === undefined || !chosen(voiced)) {
             fields.push({ field: "audio", message: "Pick a narration provider and model." });
@@ -213,6 +215,20 @@ function checkValues(draft, requiredSlots, fields) {
 function blank(value) {
     return value === undefined || value.trim() === "";
 }
+export function usesNarrationPreparation(draft) {
+    return draft.sources.audio === "generate" && !blank(draft.narrationPrompt);
+}
+export function narrationPreparationFields(draft) {
+    return usesNarrationPreparation(draft) &&
+        (draft.audio?.provider !== "inworld" || draft.audio.model !== "inworld-tts-2")
+        ? [
+            {
+                field: "narrationPrompt",
+                message: "Narration Preparation requires Inworld TTS-2. Choose that model or turn preparation Off.",
+            },
+        ]
+        : [];
+}
 function chosen(choice) {
     return choice !== undefined && choice.provider.trim() !== "" && choice.model.trim() !== "";
 }

package/dist/slices/admission/schema.js

@@ -35,6 +35,7 @@ export const runDraftSchema = z.object({
     audio: providerChoice.extend({ voice: z.string() }).optional(),
     images: providerChoice.optional(),
     articlePrompt: z.string().optional(),
+    narrationPrompt: z.string().optional(),
     imagePrompts: z.array(z.object({ name: z.string(), number: z.number() })),
     thumbnailPrompt: z.string().optional(),
     intro: entryChoice.optional(),

package/dist/slices/estimate/index.js

@@ -1,4 +1,10 @@
 import { z } from "zod";
+import { usesNarrationPreparation } from "../admission/rules.js";
+import { plainText } from "../article/plain.js";
+import { splitEndMatter } from "../article/split.js";
+import { chunkNarration, defaultChunking } from "../narration/chunk.js";
+import { normalizeNarrationText } from "../narration/plan.js";
+import { preparationMessages } from "../narration/preparation.js";
 import { estimateRequests, groupEstimateRows } from "./requests.js";
 export { estimateRequests } from "./requests.js";
 export function estimateRun(draft, rendered, expectedWords, catalogue) {
@@ -26,7 +32,7 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
         !model.deprecated)?.pricing.note ?? "Model or account pricing is unknown.";
     const generatedArticle = draft.sources.article === "generate";
     const articleChars = generatedArticle ? expectedWords * 6 : (draft.provided.article?.length ?? 0);
-    const promptChars = Object.values(rendered).reduce((sum, value) => sum + value.length, 0);
+    const promptChars = Object.entries(rendered).reduce((sum, [key, value]) => sum + (key === "narration" ? 0 : value.length), 0);
     const local = (stage, detail) => {
         requests.push({ kind: "local", stage, detail });
     };
@@ -52,6 +58,31 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
     if (draft.intro?.mode === "llm" || draft.outro?.mode === "llm")
         text("Intro / outro text", promptChars + articleChars, 2400);
     if (draft.sources.audio === "generate") {
+        if (usesNarrationPreparation(draft)) {
+            const known = generatedArticle
+                ? []
+                : [
+                    ...chunkNarration(normalizeNarrationText(plainText(splitEndMatter(draft.provided.article ?? "").body)), draft.chunking ?? defaultChunking),
+                ];
+            const unknown = generatedArticle || draft.intro?.mode === "llm" || draft.outro?.mode === "llm";
+            for (const category of ["intro", "outro"])
+                if (draft[category]?.mode === "text" && rendered[category]?.trim())
+                    known.push(rendered[category] ?? "");
+            if (unknown)
+                requests.push({
+                    kind: "unknown",
+                    stage: "Narration Preparation",
+                    detail: "One LLM call per future logical narration chunk and enabled entry; generated source length is not yet known.",
+                });
+            else
+                for (const source of known)
+                    text("Narration Preparation", preparationMessages(rendered.narration ?? "", source).reduce((n, message) => n + message.content.length, 0), 2400, `${known.length} LLM calls: one per logical narration chunk or entry.`);
+            requests.push({
+                kind: "unknown",
+                stage: "Delivery cue overhead",
+                detail: "TTS character charges include delivery tags; their length is known after preparation.",
+            });
+        }
         const extras = ["intro", "outro"].reduce((n, key) => n + (rendered[key]?.length ?? 0), 0);
         const llmExtras = (draft.intro?.mode === "llm" ? 1200 : 0) + (draft.outro?.mode === "llm" ? 1200 : 0);
         const choice = { stage: "Narration", provider: tts.provider, model: tts.model };

package/dist/slices/estimate/requests.js

@@ -15,6 +15,7 @@ const requestSchema = z.discriminatedUnion("kind", [
     provider.extend({ kind: z.literal("tts-estimate"), characters: quantity }).strict(),
     provider.extend({ kind: z.literal("image") }).strict(),
     common.extend({ kind: z.literal("local") }).strict(),
+    common.extend({ kind: z.literal("unknown") }).strict(),
 ]);
 export function estimateRequests(requests, catalogue) {
     const parsed = z.array(requestSchema).parse(requests);
@@ -50,6 +51,13 @@ export function groupEstimateRows(estimate) {
     return { ...estimate, rows, unknown: rows.filter((row) => row.low === null).length };
 }
 function price(request, catalogue) {
+    if (request.kind === "unknown")
+        return {
+            stage: request.stage,
+            low: null,
+            high: null,
+            detail: request.detail ?? "Request size is not available yet.",
+        };
     if (request.kind === "local")
         return {
             stage: request.stage,

package/dist/slices/library/model.js

@@ -1,9 +1,8 @@
-// The two template libraries: prompts of three kinds, and the intro/outro entries. One rule
+// The two template libraries: prompts and intro/outro entries. One rule
 // set covers both, which is why the drafts, the lint and the save path below are shared
 // rather than mirrored.
 export { entryModes } from "../admission/model.js";
-// The CHECK constraint on `prompts.kind` holds the same three.
-export const promptKinds = ["article", "image", "thumbnail"];
+export const promptKinds = ["article", "image", "thumbnail", "narration"];
 export const entryCategories = ["intro", "outro"];
 // The name is what the Play pickers show, so it shares admission's title bound.
 export const nameMax = 200;

package/dist/slices/library/slots.js

@@ -2,7 +2,7 @@
 // the picked templates, the slot names they ask for, and the rendered text stored on the
 // project. The bodies are read at the click, not at selection, so an edit made in between
 // is the one that runs.
-import { normaliseDraft } from "../admission/rules.js";
+import { normaliseDraft, usesNarrationPreparation } from "../admission/rules.js";
 import { collectFields, render } from "../admission/substitute.js";
 import { snapshotEntry, snapshotPrompt } from "./snapshot.js";
 export function pickTemplates(db, input, snapshot) {
@@ -17,6 +17,8 @@ export function pickTemplates(db, input, snapshot) {
         body(db, "article", draft.articlePrompt, "articlePrompt", missing, text, "article", snapshot);
     }
     const intro = pickEntry(db, "intro", draft.intro, missing, snapshot);
+    if (usesNarrationPreparation(draft))
+        body(db, "narration", draft.narrationPrompt, "narrationPrompt", missing, text, "narration", snapshot);
     const outro = pickEntry(db, "outro", draft.outro, missing, snapshot);
     push(text, "intro", intro);
     push(text, "outro", outro);

package/dist/slices/narration/preparation.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+const sentence = z.number().int().positive();
+const instruction = z
+    .string()
+    .min(1)
+    .max(240)
+    .refine((text) => text.trim().length > 0 && !/[[\]<>*_`~#\p{Cc}]/u.test(text));
+const cueSchema = z.discriminatedUnion("kind", [
+    z.object({ sentence, kind: z.literal("instruction"), text: instruction }).strict(),
+    z.object({ sentence, kind: z.literal("reset") }).strict(),
+    z
+        .object({
+        sentence,
+        kind: z.literal("sound"),
+        sound: z.enum(["laugh", "breathe", "clear throat", "sigh", "cough", "yawn"]),
+    })
+        .strict(),
+]);
+const answerSchema = z.object({ cues: z.array(cueSchema) }).strict();
+export function sourceSentences(source) {
+    return Array.from(new Intl.Segmenter("en", { granularity: "sentence" }).segment(source), (part, index) => ({ sentence: index + 1, text: part.segment }));
+}
+export function validatePreparation(answer, source) {
+    let raw;
+    try {
+        raw = JSON.parse(answer);
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+        return { ok: false, reason: "Return a JSON object containing only cues." };
+    }
+    const parsed = answerSchema.safeParse(raw);
+    if (!parsed.success)
+        return { ok: false, reason: "Use only the documented cue fields and values." };
+    const count = sourceSentences(source).length;
+    const persistent = new Set();
+    const sounds = new Set();
+    let previous = 0;
+    for (const cue of parsed.data.cues) {
+        if (cue.sentence > count || cue.sentence < previous)
+            return { ok: false, reason: "Cue sentence numbers must be in source order and in range." };
+        previous = cue.sentence;
+        if (cue.kind !== "sound") {
+            if (persistent.has(cue.sentence))
+                return { ok: false, reason: "Use at most one instruction or reset per sentence." };
+            persistent.add(cue.sentence);
+        }
+        else {
+            const key = `${cue.sentence}:${cue.sound}`;
+            if (sounds.has(key))
+                return { ok: false, reason: "Do not repeat a sound at the same sentence." };
+            sounds.add(key);
+        }
+    }
+    return { ok: true, cues: parsed.data.cues };
+}
+const contract = [
+    'Return JSON only: {"cues":[...]}.',
+    "Each cue has sentence (a supplied 1-based index) and kind.",
+    "instruction adds text: a short English delivery direction without brackets or markup.",
+    "reset has no other fields. sound adds sound: laugh, breathe, clear throat, sigh, cough or yawn.",
+    "Order cues by sentence. At most one instruction or reset per sentence.",
+    "Never return or rewrite narration. Do not translate, correct, abbreviate or add dialogue.",
+    "Use cues sparingly; an empty cues array is valid. Combine simultaneous directions.",
+].join("\n");
+export function preparationMessages(prompt, source) {
+    return [
+        { role: "system", content: contract },
+        {
+            role: "user",
+            content: JSON.stringify({ direction: prompt, sentences: sourceSentences(source) }),
+        },
+    ];
+}

package/dist/slices/narration/steering.js

@@ -0,0 +1,89 @@
+import { sourceSentences } from "./preparation.js";
+const cannotFit = {
+    ok: false,
+    reason: "Delivery cues or whitespace leave no room for narration at this model's character limit.",
+};
+export function prepareRequests(source, cues, maxCharacters) {
+    if (!Number.isInteger(maxCharacters) || maxCharacters < 2)
+        return {
+            ok: false,
+            reason: "The narration character limit must be a whole number of at least 2.",
+        };
+    if (source.trim() === "")
+        return { ok: true, requests: [] };
+    const requests = [];
+    const bySentence = new Map();
+    for (const cue of cues) {
+        const group = bySentence.get(cue.sentence) ?? [];
+        group.push(cue);
+        bySentence.set(cue.sentence, group);
+    }
+    let active = null;
+    let text = "";
+    let spokenText = "";
+    const flush = () => {
+        if (spokenText.trim() === "")
+            return false;
+        requests.push({ text, spokenText });
+        text = "";
+        spokenText = "";
+        return true;
+    };
+    for (const sentence of sourceSentences(source)) {
+        const events = bySentence.get(sentence.sentence) ?? [];
+        const direction = events.find((cue) => cue.kind !== "sound");
+        const tags = events.map(cueTag).join(" ");
+        const prefix = tags === "" ? "" : `${tags} `;
+        const first = Array.from(sentence.text)[0] ?? "";
+        const words = sentence.text.match(/\S+\s*|\s+/gu) ?? [];
+        const firstWord = words[0] ?? first;
+        const freshPrefix = direction === undefined ? carryTag(active) : "";
+        const minimum = firstWord.length + prefix.length + freshPrefix.length <= maxCharacters
+            ? firstWord.length
+            : first.length;
+        if (spokenText.trim() !== "" && text.length + prefix.length + minimum > maxCharacters) {
+            if (!flush())
+                return cannotFit;
+        }
+        if (text === "" && direction === undefined)
+            text = carryTag(active);
+        if (text.length + prefix.length + first.length > maxCharacters)
+            return cannotFit;
+        text += prefix;
+        if (direction !== undefined)
+            active = direction.kind === "instruction" ? direction.text : null;
+        for (const word of words) {
+            if (word.length + carryTag(active).length <= maxCharacters &&
+                text.length + word.length > maxCharacters &&
+                spokenText.trim() !== "") {
+                if (!flush())
+                    return cannotFit;
+                text = carryTag(active);
+            }
+            for (const point of word) {
+                if (text.length + point.length > maxCharacters) {
+                    if (!flush())
+                        return cannotFit;
+                    text = carryTag(active);
+                }
+                if (text.length + point.length > maxCharacters)
+                    return cannotFit;
+                text += point;
+                spokenText += point;
+            }
+        }
+    }
+    if (spokenText !== "" && !flush())
+        return cannotFit;
+    return { ok: true, requests };
+}
+function cueTag(cue) {
+    return cue.kind === "instruction"
+        ? `[${cue.text}]`
+        : cue.kind === "reset"
+            ? "[reset]"
+            : `[${cue.sound}]`;
+}
+function carryTag(active) {
+    return active === null ? "" : `[${active}] `;
+}

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

@@ -62,6 +62,9 @@ export function toAdmissionDraft(input) {
         audio: sources.audio === "generate" ? form.audio : undefined,
         images: form.images,
         articlePrompt: sources.article === "generate" ? form.articlePrompt : undefined,
+        ...(sources.audio === "generate" && form.narrationPrompt?.trim()
+            ? { narrationPrompt: form.narrationPrompt }
+            : {}),
         imagePrompts: sources.images === "generate"
             ? form.imagePrompts.map((prompt, index) => ({
                 name: prompt.name,

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

@@ -1,6 +1,7 @@
 import { checkRuntimeModel } from "../../catalog/runtime-models.js";
 import { modelFields } from "../../catalog/validate.js";
 import { readinessIsUsable } from "../../kernel/ports/model.js";
+import { usesNarrationPreparation } from "../admission/rules.js";
 import { cliPathStatus } from "../settings/cli-paths.js";
 import { hasKey, listVoices } from "../settings/repo.js";
 export function choices(runs) {
@@ -14,7 +15,8 @@ export function choices(runs) {
                 d.sources.article === "generate" ||
                 d.sources.thumbnail === "prompt_by_llm" ||
                 d.intro?.mode === "llm" ||
-                d.outro?.mode === "llm",
+                d.outro?.mode === "llm" ||
+                usesNarrationPreparation(d),
         },
         {
             field: "audio",

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

@@ -34,6 +34,7 @@ export const playDraftFormSchema = z
     audio: provider.extend({ voice: text }).readonly(),
     images: provider.readonly(),
     articlePrompt: text,
+    narrationPrompt: text.optional(),
     imagePrompts: z.array(z.object({ name: text, number: text }).strict().readonly()).readonly(),
     thumbnailPrompt: text,
     intro: text,