@gentbajko/slopify 0.5.0 → 0.6.1

package/dist/kernel/cli-command.js

@@ -0,0 +1,45 @@
+import { readFileSync, statSync } from "node:fs";
+import { extname, isAbsolute, join, resolve, win32 } from "node:path";
+// Keep prompts out of cmd.exe: npm launchers name a JavaScript entry point that
+// Node can execute directly with an argv array, including quotes and newlines.
+export function cliCommand(binary) {
+    const file = process.platform === "win32" ? windowsFile(binary) : binary;
+    if (/\.[cm]?js$/i.test(file))
+        return { file: process.execPath, args: [resolve(file)] };
+    if (process.platform !== "win32" || !/\.(cmd|bat)$/i.test(file))
+        return { file, args: [] };
+    const stat = statSync(file);
+    if (!stat.isFile() || stat.size > 64 * 1024)
+        throw unsupportedShim();
+    const target = windowsShimTarget(file, readFileSync(file, "utf8"));
+    if (target === undefined || !statSync(target, { throwIfNoEntry: false })?.isFile())
+        throw unsupportedShim();
+    return { file: process.execPath, args: [target] };
+}
+export function windowsShimTarget(file, source) {
+    if (!/(?:node|bun)(?:\.exe)?/i.test(source))
+        return undefined;
+    // npm's cmd-shim uses %dp0%, older launchers use %~dp0. The remainder must
+    // be a literal relative script path, followed by the original argument list.
+    const matched = /"(?:%dp0%|%~dp0)[\\/]?([^"%\r\n]+\.[cm]?js)"\s+%\*/i.exec(source);
+    if (matched?.[1] === undefined || win32.isAbsolute(matched[1]))
+        return undefined;
+    return win32.resolve(win32.dirname(file), matched[1]);
+}
+function windowsFile(binary) {
+    const path = Object.entries(process.env).find(([key]) => key.toLowerCase() === "path")?.[1] ?? "";
+    const directories = isAbsolute(binary) || /[\\/]/.test(binary) ? [""] : path.split(";");
+    const suffixes = extname(binary) === "" ? [".exe", ".com", ".cmd", ".bat", ""] : [""];
+    for (const directory of directories) {
+        for (const suffix of suffixes) {
+            const file = directory === "" ? binary + suffix : join(directory.replace(/^"|"$/g, ""), binary + suffix);
+            if (statSync(file, { throwIfNoEntry: false })?.isFile())
+                return resolve(file);
+        }
+    }
+    // Let spawn report its usual ENOENT when no executable exists.
+    return binary;
+}
+function unsupportedShim() {
+    return new Error("This batch launcher is not a supported Node CLI shim. Select the CLI's .exe or JavaScript entry file instead.");
+}

package/dist/kernel/db/migrations/0002-project-controls.sql

@@ -0,0 +1,4 @@
+CREATE TABLE project_controls (
+  project_id TEXT PRIMARY KEY REFERENCES projects(id) ON DELETE CASCADE,
+  paused INTEGER NOT NULL DEFAULT 0 CHECK(paused IN (0, 1))
+);

package/dist/kernel/pipeline.js

@@ -13,8 +13,13 @@ export const stageStates = [
     "provided",
     "skipped",
 ];
-// Four project states, derived in order: running if any stage is running, else canceled,
-// else failed, else done when video is done. A project whose stages are all pending matches
-// none of them - the real window between creating it and the runner starting the first
-// stage - so `pending` is the fallback. Nothing stores it.
-export const projectStates = ["running", "canceled", "failed", "done", "pending"];
+// A persisted pause overrides the stage-derived status. A completed run need not
+// include a video: all selected stages being satisfied is enough.
+export const projectStates = [
+    "running",
+    "paused",
+    "canceled",
+    "failed",
+    "done",
+    "pending",
+];

package/dist/kernel/ports/subtitles.js

@@ -0,0 +1 @@
+export {};

package/dist/kernel/runner/graph.js

@@ -1,18 +1,22 @@
-// Research → article → {audio ∥ images ∥ thumbnail} → video.
+// Images use saved prompts and can run immediately. A thumbnail's source and an
+// audio-only export narrow these dependencies through dependenciesOf().
 export const deps = {
     research: [],
     article: ["research"],
     audio: ["article"],
-    images: ["article"],
+    images: [],
     thumbnail: ["article"],
-    video: ["audio", "images", "thumbnail"],
+    video: ["article", "audio", "images", "thumbnail"],
 };
 // `provided` and `skipped` release a dependency exactly as `done` does.
 export function satisfied(state) {
     return state === "done" || state === "provided" || state === "skipped";
 }
-// The four states, in their order. Derived on every read, never stored.
-export function derive(stages) {
+// Stage state is derived; an explicit persisted pause takes precedence while calls
+// drain. Completed independent images do not imply that a run was canceled.
+export function derive(stages, paused = false) {
+    if (paused)
+        return "paused";
     if (stages.some((stage) => stage.state === "running")) {
         return "running";
     }
@@ -22,23 +26,19 @@ export function derive(stages) {
     if (stages.some((stage) => stage.state === "failed")) {
         return "failed";
     }
-    if (stages.some((stage) => stage.kind === "video" && stage.state === "done")) {
+    if (stages.length > 0 && stages.every((stage) => satisfied(stage.state))) {
         return "done";
     }
-    // Extended rule, beyond the four above. `pending` covers the window between creating a
-    // project and the runner claiming its first stage. A second case is reachable: a stage
-    // that stores its output in the same instant as the cancel stays `done`, so nothing is
-    // `canceled` and a stopped run would read as about to start. A stage in a terminal state
-    // tells the two apart - at creation none is `done`.
-    //
-    // ceiling: a process killed between a stage finishing and its dependent being claimed
-    // reads `canceled` too. Separating those needs the cancel stored on the project, and
-    // nothing about the status is stored.
-    if (stages.some((stage) => stage.state === "done")) {
-        return "canceled";
-    }
+    // Includes a run created but not yet claimed and unfinished work after restart.
     return "pending";
 }
+export function dependenciesOf(kind, sources) {
+    if (kind === "thumbnail" && sources.thumbnail === "from_prompt")
+        return [];
+    if (kind === "video" && sources.video === "off")
+        return ["article", "audio"];
+    return deps[kind];
+}
 // The thin meter under a running row on Projects, averaging stage progress. Every stage
 // the run asks for counts once: a finished one whole, a running one by its own progress, a
 // waiting, failed or canceled one not at all. `provided` and `skipped` are left out rather

package/dist/kernel/runner/index.js

@@ -1,4 +1,5 @@
 import { derive, deps as graph, satisfied } from "./graph.js";
+const pauseReason = new Error("paused by user");
 export function createRunner(deps) {
     const inflight = new Map();
     // ceiling: one entry per project ticked since boot, never evicted - a few dozen bytes
@@ -34,7 +35,7 @@ export function createRunner(deps) {
         }
     };
     const announce = (projectId) => {
-        const state = derive(deps.stages.stagesOf(projectId));
+        const state = derive(deps.stages.stagesOf(projectId), deps.stages.paused?.(projectId));
         if (announced.get(projectId) === state) {
             return;
         }
@@ -75,7 +76,8 @@ export function createRunner(deps) {
             if (controller.signal.aborted) {
                 // A late rejection from the aborted call is how a stage learns it was canceled, so
                 // it is not logged as a fault.
-                conclude(stage, "canceled", "canceled by user");
+                const paused = controller.signal.reason === pauseReason;
+                conclude(stage, paused ? "pending" : "canceled", paused ? null : "canceled by user");
                 return;
             }
             deps.log.write("error", "stage.failed", {
@@ -127,7 +129,7 @@ export function createRunner(deps) {
         // A stage finishing in the same instant as a shutdown or cancel would otherwise release
         // its dependent, leaving the abort waiting on a render nobody asked for - or one running
         // under a controller nobody aborted. The state still goes out, so an open page sees it.
-        if (!shuttingDown && !stopped.has(projectId)) {
+        if (!shuttingDown && !stopped.has(projectId) && !deps.stages.paused?.(projectId)) {
             startEligible(projectId);
         }
         announce(projectId);
@@ -139,7 +141,8 @@ export function createRunner(deps) {
             if (stage.state !== "pending" || inflight.has(stage.id)) {
                 continue;
             }
-            if (!graph[stage.kind].every((kind) => satisfied(stateOf(kind)))) {
+            const dependencies = deps.stages.dependenciesOf?.(projectId, stage.kind) ?? graph[stage.kind];
+            if (!dependencies.every((kind) => satisfied(stateOf(kind)))) {
                 continue;
             }
             // Nothing is awaited here: the fan-out starts audio, images and thumbnail together.
@@ -165,14 +168,15 @@ export function createRunner(deps) {
     return {
         tick,
         settled,
-        abortProject: async (projectId) => {
+        hasInflight: (projectId) => [...inflight.values()].some((entry) => entry.projectId === projectId),
+        abortProject: async (projectId, mode = "cancel") => {
             // Up before the first abort, down only once every stage has stopped. In between, the
             // tick each finishing stage fires starts nothing.
             stopped.add(projectId);
             try {
                 for (const entry of inflight.values()) {
                     if (entry.projectId === projectId) {
-                        entry.controller.abort();
+                        entry.controller.abort(mode === "pause" ? pauseReason : undefined);
                     }
                 }
                 // No provider call continues after cancel returns. The wait makes it true.

package/dist/kernel/runner/piece-repo.js

@@ -3,7 +3,14 @@ import { z } from "zod";
 // chunk, an image index. It sits beside the attempt store because the wrapper stamps
 // `piece_id` on every row it writes. The payload stays the JSON text it was stored as - its
 // shape belongs to whichever stage owns the kind, and nothing here reads inside it.
-export const pieceKinds = ["chapter", "chunk", "segment", "image", "prompt_written"];
+export const pieceKinds = [
+    "chapter",
+    "chunk",
+    "segment",
+    "image",
+    "prompt_written",
+    "article_written",
+];
 export const pieceStates = ["pending", "running", "done", "failed"];
 const pieceRow = z.object({
     id: z.string(),

package/dist/kernel/runner/providers.js

@@ -30,11 +30,12 @@ export function stageProviders(deps, context, pieceId) {
                     if (event.type === "delta") {
                         text += event.text;
                     }
-                    else {
+                    else if (event.type === "done") {
                         usage = event.usage;
                         finishReason = event.finishReason;
                     }
-                    onEvent?.(event);
+                    if (event.type !== "activity")
+                        onEvent?.(event);
                 }
                 const answer = { text, usage, finishReason };
                 const unusable = call.check?.(answer);

package/dist/main.js

@@ -2,8 +2,12 @@ import { fileURLToPath } from "node:url";
 import { serve } from "@hono/node-server";
 import ffmpegStatic from "ffmpeg-static";
 import { buildRegistry } from "./adapter-registry.js";
+import { alignSubtitles } from "./adapters/alignment/index.js";
 import { prepareFfmpeg } from "./adapters/ffmpeg.js";
 import { nodeRunCli } from "./adapters/llm/run-cli.js";
+import { cartesiaModel } from "./adapters/tts/cartesia.js";
+import { elevenLabsModel } from "./adapters/tts/elevenlabs.js";
+import { openAiTtsModel } from "./adapters/tts/openai.js";
 import { createHub } from "./edge/events/hub.js";
 import { createApp } from "./edge/http/app.js";
 import { systemClock } from "./kernel/clock.js";
@@ -14,10 +18,12 @@ import { acquireInstanceLock } from "./kernel/lock.js";
 import { openLog } from "./kernel/log.js";
 import { ensureDirs, layout } from "./kernel/paths.js";
 import { sqliteAttempts } from "./kernel/runner/attempt-repo.js";
+import { dependenciesOf } from "./kernel/runner/graph.js";
 import { createRunner } from "./kernel/runner/index.js";
 import { stageProviders } from "./kernel/runner/providers.js";
 import { readVersion } from "./kernel/version.js";
-import { claimStage, finishStage, stagesOf } from "./slices/admission/repo.js";
+import { claimStage, finishStage, projectById, projectPaused, stagesOf, } from "./slices/admission/repo.js";
+import { prepareProvidedArticleSegments } from "./slices/article/provided-entries.js";
 import { runArticle } from "./slices/article/run.js";
 import { runImages } from "./slices/images/run.js";
 import { runNarration } from "./slices/narration/run.js";
@@ -78,6 +84,19 @@ export async function boot(config) {
             paths,
             hub,
             runner,
+            modelsFor: (provider, family) => {
+                if (family === "llm")
+                    return registry.llm(provider).models();
+                if (family === "image")
+                    return registry.image(provider).models();
+                const models = {
+                    elevenlabs: elevenLabsModel,
+                    "openai-tts": openAiTtsModel,
+                    cartesia: cartesiaModel,
+                };
+                const id = models[provider];
+                return Promise.resolve(id === undefined ? [] : [{ id, name: id }]);
+            },
             clock,
             ids,
             log,
@@ -132,7 +151,7 @@ function wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry, f
     };
     // The audio stage joins its chunks with the same binary the render uses, so it takes
     // the same seven dependencies.
-    const video = { db, paths, ids, clock, log, ffmpeg, count };
+    const video = { db, paths, ids, clock, log, ffmpeg, count, alignSubtitles };
     // Research, the article, the images and the thumbnail all write into the same project
     // folder from the same database handle, so they take the same six dependencies.
     const writing = { db, paths, ids, clock, log, count };
@@ -142,6 +161,11 @@ function wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry, f
     return createRunner({
         stages: {
             stagesOf: (projectId) => stagesOf(db, projectId),
+            paused: (projectId) => projectPaused(db, projectId),
+            dependenciesOf: (projectId, kind) => {
+                const project = projectById(db, projectId);
+                return project === undefined ? [] : dependenciesOf(kind, project.config.sources);
+            },
             claim: (stageId) => claimStage(db, stageId, clock.now().toISOString()),
             finish: (stageId, state, failureReason) => finishStage(db, stageId, state, failureReason, clock.now().toISOString()),
         },
@@ -150,7 +174,11 @@ function wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry, f
         runs: {
             research: (context) => runResearch(writing, context, stageProviders(providers, context)),
             article: (context) => runArticle(writing, context, stageProviders(providers, context)),
-            audio: (context) => runNarration(video, context, stageProviders(providers, context)),
+            audio: async (context) => {
+                const wrapped = stageProviders(providers, context);
+                await prepareProvidedArticleSegments(writing, context, wrapped);
+                await runNarration(video, context, wrapped);
+            },
             images: (context) => runImages(writing, context, stageProviders(providers, context)),
             thumbnail: (context) => runThumbnail(writing, context, stageProviders(providers, context)),
             video: (context) => renderVideo(video, context),
@@ -208,7 +236,7 @@ export function urlOf(host, port) {
 // nothing auto-resumes, the user retries by hand.
 export function markInterruptedStages(db, clock) {
     const result = db
-        .prepare("UPDATE stages SET state = 'failed', failure_reason = 'interrupted', finished_at = ? WHERE state = 'running'")
+        .prepare("UPDATE stages SET state = CASE WHEN EXISTS (SELECT 1 FROM project_controls WHERE project_id = stages.project_id AND paused = 1) THEN 'pending' ELSE 'failed' END, failure_reason = CASE WHEN EXISTS (SELECT 1 FROM project_controls WHERE project_id = stages.project_id AND paused = 1) THEN NULL ELSE 'interrupted' END, finished_at = CASE WHEN EXISTS (SELECT 1 FROM project_controls WHERE project_id = stages.project_id AND paused = 1) THEN NULL ELSE ? END WHERE state = 'running'")
         .run(clock.now().toISOString());
     return Number(result.changes);
 }

package/dist/slices/admission/model.js

@@ -1,6 +1,6 @@
 // The format is the kernel's: the image port asks for the same two aspects.
 export { formats } from "../../kernel/pipeline.js";
-// Generate, Provide or Off for most stages, plus the thumbnail's two Generate modes. Video
-// is always `generate`.
+// Generate, Provide or Off for most stages, plus the thumbnail's two Generate modes.
+// Article stays Generate or Provide; Video can be Generate or Off.
 export const stageSources = ["generate", "provide", "off", "from_prompt", "prompt_by_llm"];
 export const entryModes = ["text", "llm"];

package/dist/slices/admission/repo.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { stageKinds, stageStates } from "../../kernel/pipeline.js";
 import { chunkModes } from "../narration/chunk.js";
+import { subtitleConfigSchema } from "../subtitles/model.js";
 import { entryModes, formats, stageSources } from "./model.js";
 const providerChoice = z.object({ provider: z.string(), model: z.string() });
 const entryChoice = z.object({ name: z.string(), mode: z.enum(entryModes) });
@@ -39,6 +40,7 @@ export const runDraftSchema = z.object({
     // a mode not listed here would never reach the audio stage.
     chunking: z.object({ mode: z.enum(chunkModes), words: z.number().optional() }).optional(),
     silenceGapSeconds: z.number(),
+    subtitles: subtitleConfigSchema.optional(),
 });
 export const runConfigSchema = runDraftSchema.extend({
     rendered: z.record(z.string(), z.string()),
@@ -50,6 +52,7 @@ const projectRow = z.object({
     config: z.string(),
     created_at: z.string(),
     updated_at: z.string(),
+    paused: z.number().default(0),
 });
 const standingRow = z.object({
     project_id: z.string(),
@@ -73,12 +76,14 @@ const stageRow = z.object({
 });
 export function insertProject(db, project) {
     db.prepare("INSERT INTO projects (id, title, format, config, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(project.id, project.title, project.format, JSON.stringify(project.config), project.createdAt, project.updatedAt);
+    if (project.paused === true)
+        setProjectPaused(db, project.id, true, project.updatedAt);
 }
 export function insertStage(db, stage) {
     db.prepare("INSERT INTO stages (id, project_id, kind, source, state, attempt_count) VALUES (?, ?, ?, ?, ?, ?)").run(stage.id, stage.projectId, stage.kind, stage.source, stage.state, stage.attemptCount);
 }
 export function projectById(db, id) {
-    const row = db.prepare("SELECT * FROM projects WHERE id = ?").get(id);
+    const row = db.prepare(`${projectSelect} WHERE projects.id = ?`).get(id);
     return row === undefined ? undefined : toProject(projectRow.parse(row));
 }
 // Existence alone, for a caller that needs no run configuration: `slices/cancel` only
@@ -90,7 +95,7 @@ export function projectExists(db, id) {
 // Newest first.
 export function listProjects(db) {
     return db
-        .prepare("SELECT * FROM projects ORDER BY created_at DESC, id DESC")
+        .prepare(`${projectSelect} ORDER BY created_at DESC, id DESC`)
         .all()
         .map((row) => toProject(projectRow.parse(row)));
 }
@@ -130,12 +135,12 @@ export function stagesOf(db, projectId) {
 // The runner's claim: one statement, so two callers cannot both find the stage pending.
 export function claimStage(db, stageId, at) {
     const result = db
-        .prepare("UPDATE stages SET state = 'running', started_at = ?, finished_at = NULL, failure_reason = NULL WHERE id = ? AND state = 'pending'")
+        .prepare("UPDATE stages SET state = 'running', started_at = ?, finished_at = NULL, failure_reason = NULL WHERE id = ? AND state = 'pending' AND NOT EXISTS (SELECT 1 FROM project_controls WHERE project_id = stages.project_id AND paused = 1)")
         .run(at, stageId);
     return Number(result.changes) === 1;
 }
 export function finishStage(db, stageId, state, failureReason, at) {
-    db.prepare("UPDATE stages SET state = ?, failure_reason = ?, finished_at = ? WHERE id = ?").run(state, failureReason, at, stageId);
+    db.prepare("UPDATE stages SET state = ?, failure_reason = ?, finished_at = ? WHERE id = ?").run(state, failureReason, state === "pending" ? null : at, stageId);
 }
 // A stage put back to `pending` by a re-run, a cascade or a retry starts again from a clean row
 // - no error text, no progress from the run before it, and a fresh attempt budget.
@@ -153,8 +158,21 @@ function toProject(row) {
         config: parseConfig(row.config),
         createdAt: row.created_at,
         updatedAt: row.updated_at,
+        paused: row.paused === 1,
     };
 }
+const projectSelect = "SELECT projects.*, COALESCE(project_controls.paused, 0) AS paused FROM projects LEFT JOIN project_controls ON project_controls.project_id = projects.id";
+export function projectPaused(db, projectId) {
+    return (db.prepare("SELECT paused FROM project_controls WHERE project_id = ?").get(projectId)
+        ?.paused === 1);
+}
+export function setProjectPaused(db, projectId, paused, at) {
+    db.prepare("INSERT INTO project_controls (project_id, paused) VALUES (?, ?) ON CONFLICT(project_id) DO UPDATE SET paused = excluded.paused").run(projectId, paused ? 1 : 0);
+    db.prepare("UPDATE projects SET updated_at = ? WHERE id = ?").run(at, projectId);
+}
+export function updateProjectConfig(db, projectId, config, at) {
+    db.prepare("UPDATE projects SET config = ?, updated_at = ? WHERE id = ?").run(JSON.stringify(config), at, projectId);
+}
 // A JSON column never reaches a caller as a string.
 function parseConfig(config) {
     const parsed = JSON.parse(config);

package/dist/slices/admission/rules.js

@@ -6,7 +6,7 @@ export const imagesPerRunMax = 60;
 // ceiling: the default gap is 3 s and nothing fixes an upper or lower bound, so the range
 // is this module's. A wider gap is a settings change, not a schema change.
 export const silenceGapSecondsMax = 30;
-// The legal source for each stage; video is always generated. Exported because Play's
+// The legal source for each stage. Exported because Play's
 // source switches offer exactly these and nothing else, so the segmented control and the
 // refusal below it are the same list and a stage whose legal set changes cannot leave a
 // switch offering something the server refuses. The order is the order the segments are
@@ -14,14 +14,14 @@ export const silenceGapSecondsMax = 30;
 export const allowedSources = {
     research: ["off", "generate", "provide"],
     article: ["generate", "provide"],
-    audio: ["generate", "provide"],
-    images: ["generate", "provide"],
+    audio: ["off", "generate", "provide"],
+    images: ["off", "generate", "provide"],
     thumbnail: ["off", "from_prompt", "prompt_by_llm", "provide"],
-    video: ["generate"],
+    video: ["off", "generate"],
 };
 export function admit(input) {
     const fields = [];
-    const draft = normalise(input.draft);
+    const draft = normaliseDraft(input.draft);
     const { sources } = draft;
     if (draft.title === "") {
         fields.push({ field: "title", message: "A title is required." });
@@ -60,14 +60,20 @@ export function admit(input) {
     }
     if (sources.images === "generate") {
         checkImagePrompts(draft, fields);
-        if (!chosen(draft.images)) {
-            fields.push({ field: "images", message: "Pick an image provider and model." });
-        }
+    }
+    if ((sources.images === "generate" ||
+        sources.thumbnail === "from_prompt" ||
+        sources.thumbnail === "prompt_by_llm") &&
+        !chosen(draft.images)) {
+        fields.push({ field: "images", message: "Pick an image provider and model." });
     }
     if ((sources.thumbnail === "from_prompt" || sources.thumbnail === "prompt_by_llm") &&
         blank(draft.thumbnailPrompt)) {
         fields.push({ field: "thumbnailPrompt", message: "Pick a thumbnail prompt." });
     }
+    if (sources.audio === "off" && draft.subtitles !== undefined && draft.subtitles.mode !== "off") {
+        fields.push({ field: "subtitles.mode", message: "Subtitles need narration audio." });
+    }
     checkProvided(draft, input.staged, fields);
     checkValues(draft, input.requiredSlots, fields);
     if (!Number.isFinite(draft.silenceGapSeconds) ||
@@ -81,12 +87,16 @@ export function admit(input) {
     return fields.length === 0 ? { ok: true, draft } : { ok: false, fields };
 }
 // Research only feeds article writing, so a provided article hides it.
-// Video is generated whatever the form said.
-function normalise(draft) {
-    const sources = { ...draft.sources, video: "generate" };
+// Disabling images chooses audio export. Uploaded narration is used as-is, and
+// only generated narration uses separately selected intro/outro entries.
+export function normaliseDraft(draft) {
+    const sources = { ...draft.sources };
     if (sources.article === "provide") {
         sources.research = "off";
     }
+    if (sources.images === "off" && sources.video === "generate") {
+        sources.video = "off";
+    }
     // Prototype-free, because a slot name is user-authored: `{{constructor}}` would
     // otherwise answer with Object rather than undefined and pass the "required" check, and
     // a value posted under `__proto__` would run a setter instead of being stored.
@@ -94,7 +104,17 @@ function normalise(draft) {
     for (const [name, value] of Object.entries(draft.values)) {
         values[name] = value.trim();
     }
-    return { ...draft, title: draft.title.trim(), sources, values };
+    return {
+        ...draft,
+        title: draft.title.trim(),
+        subtitles: sources.video === "off" && draft.subtitles?.mode === "burn-in"
+            ? { ...draft.subtitles, mode: "files" }
+            : draft.subtitles,
+        sources,
+        values,
+        intro: sources.audio === "generate" ? draft.intro : undefined,
+        outro: sources.audio === "generate" ? draft.outro : undefined,
+    };
 }
 function checkImagePrompts(draft, fields) {
     if (draft.imagePrompts.length === 0) {

package/dist/slices/admission/start.js

@@ -30,7 +30,9 @@ export function startRun(deps, draft, rendered) {
         projectId: id,
         kind,
         source: draft.sources[kind],
-        state: initialState(draft.sources[kind]),
+        state: kind === "video" && draft.sources.video === "off" && draft.sources.audio !== "off"
+            ? "pending"
+            : initialState(draft.sources[kind]),
         failureReason: null,
         attemptCount: 0,
         progressCurrent: null,

package/dist/slices/article/provided-entries.js

@@ -0,0 +1,62 @@
+import { readFileSync } from "node:fs";
+import { piecesOf } from "../../kernel/runner/piece-repo.js";
+import { projectById, stagesOf } from "../admission/repo.js";
+import { outputPath } from "../storage/layout.js";
+import { outputsOf } from "../storage/repo.js";
+import { storeText } from "../storage/staging.js";
+import { categories, instructionsText, keepSegment, writeSegment } from "./segments.js";
+// A provided Article never runs its writer. Prepare its selected entries as part
+// of Audio's cancellable work, retaining Article ownership of the resulting text.
+export async function prepareProvidedArticleSegments(deps, audioContext, providers) {
+    const { projectId } = audioContext.stage;
+    const project = projectById(deps.db, projectId);
+    if (!project)
+        throw new Error(`project ${projectId} has no row`);
+    const { config } = project;
+    if (config.sources.article !== "provide" || config.sources.audio !== "generate")
+        return;
+    if (!config.intro && !config.outro)
+        return;
+    audioContext.signal.throwIfAborted();
+    const article = stagesOf(deps.db, projectId).find((stage) => stage.kind === "article");
+    if (!article)
+        throw new Error(`project ${projectId} has no article stage`);
+    const outputs = outputsOf(deps.db, projectId);
+    const plain = outputs.find((output) => output.role === "article_txt");
+    if (!plain)
+        throw new Error("the run has no provided article text");
+    const narration = readFileSync(outputPath(deps.paths, projectId, plain.path), "utf8");
+    const saved = outputs.find((output) => output.stageKind === "article" && output.role === "instructions");
+    let instructions = saved
+        ? readFileSync(outputPath(deps.paths, projectId, saved.path), "utf8")
+        : "";
+    const completed = piecesOf(deps.db, article.id, "segment");
+    for (const [index, category] of categories.entries()) {
+        audioContext.signal.throwIfAborted();
+        if (completed.some((piece) => piece.idx === index + 1 && piece.state === "done"))
+            continue;
+        const sent = [];
+        const segment = await writeSegment(providers, config.llm, config, category, narration, sent);
+        audioContext.signal.throwIfAborted();
+        if (!segment)
+            continue;
+        if (sent.length > 0) {
+            instructions += `${instructions === "" ? "" : "\n"}${instructionsText(sent)}`;
+            storeText(deps, {
+                projectId,
+                stageKind: "article",
+                role: "instructions",
+                text: instructions,
+            });
+        }
+        keepSegment(deps, { stage: article }, segment, index + 1);
+        deps.count("stage.completed", {
+            stage: "article",
+            segment: category,
+            ...(segment.mode === "llm" && config.llm
+                ? { provider: config.llm.provider, model: config.llm.model }
+                : {}),
+            ...segment.tokens,
+        });
+    }
+}