@gentbajko/slopify 0.4.3 → 0.5.1

package/dist/edge/events/hub.js

@@ -60,6 +60,10 @@ export function createHub(deps) {
             for (const subscriber of projects.get(projectId) ?? []) {
                 send(subscriber, event);
             }
+            if (event.type === "project.state" || event.type === "project.updated") {
+                for (const subscriber of globals)
+                    send(subscriber, event);
+            }
         },
         emitGlobal: (event) => {
             if (event.type === "running.count") {

package/dist/edge/http/actions.js

@@ -3,9 +3,13 @@ import { Hono } from "hono";
 import { z } from "zod";
 import { stageKinds } from "../../kernel/pipeline.js";
 import { derive } from "../../kernel/runner/graph.js";
-import { projectById, stagesOf } from "../../slices/admission/repo.js";
+import { projectById, projectPaused, stagesOf } from "../../slices/admission/repo.js";
 import { cancelProject } from "../../slices/cancel/index.js";
+import { changeProviders, pauseProject, resumeProject } from "../../slices/control/index.js";
+import { withProjectControl } from "../../slices/control/lock.js";
+import { providerChangesSchema } from "../../slices/control/providers.js";
 import { deleteImage, editArticle, regenerateImage, rerunStage, retryStage, } from "../../slices/reruns/index.js";
+import { providerStatuses } from "../../slices/settings/readiness.js";
 import { outputsOf } from "../../slices/storage/repo.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 // The actions on the project header and on each stage: Cancel, Retry, Re-run, Save &
@@ -70,10 +74,20 @@ export function actionRoutes(deps) {
             deps.hub.emit(projectId, event);
         },
     };
+    const control = {
+        ...reruns,
+        runner: deps.runner,
+        emit: (projectId, event) => deps.hub.emit(projectId, event),
+        providers: () => providerStatuses({ db: deps.db, probe: deps.probe }),
+        modelsFor: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
+    };
     const view = (projectId) => {
         const stages = stagesOf(deps.db, projectId);
         return {
-            project: { ...projectById(deps.db, projectId), status: derive(stages) },
+            project: {
+                ...projectById(deps.db, projectId),
+                status: derive(stages, projectPaused(deps.db, projectId)),
+            },
             stages,
             outputs: outputsOf(deps.db, projectId),
         };
@@ -88,37 +102,77 @@ export function actionRoutes(deps) {
                 detail: details[result.reason],
             });
         }
-        deps.runner.tick(projectId);
+        deps.hub.emit(projectId, { type: "project.updated", projectId });
+        if (!projectPaused(deps.db, projectId))
+            deps.runner.tick(projectId);
         return c.json({ ...view(projectId), redone: result.redone });
     };
+    const controlled = (c, id, result) => {
+        if (result.ok)
+            return c.json(view(id));
+        const codes = {
+            "no-project": 404,
+            running: 409,
+            "not-editable": 409,
+            "invalid-providers": 400,
+            "catalog-unavailable": 503,
+        };
+        const messages = {
+            "no-project": "No project has that id.",
+            running: "Pause the run and wait for its active calls to stop before changing providers.",
+            "not-editable": "Providers can be changed only while a project is paused or failed.",
+            "invalid-providers": "The provider choices need attention.",
+            "catalog-unavailable": "The provider model catalog could not be loaded. Try again.",
+        };
+        return problem(c, {
+            status: codes[result.reason],
+            title: titleOf(codes[result.reason]),
+            detail: messages[result.reason],
+            ...(result.fields === undefined ? {} : { extensions: { fields: result.fields } }),
+        });
+    };
     return new Hono()
+        .post("/:id/pause", zValidator("param", idParam, onInvalid), async (c) => {
+        const { id } = c.req.valid("param");
+        return controlled(c, id, await pauseProject(control, id));
+    })
+        .post("/:id/resume", zValidator("param", idParam, onInvalid), async (c) => {
+        const { id } = c.req.valid("param");
+        return controlled(c, id, await resumeProject(control, id));
+    })
+        .patch("/:id/providers", zValidator("param", idParam, onInvalid), zValidator("json", providerChangesSchema, onInvalid), async (c) => {
+        const { id } = c.req.valid("param");
+        return controlled(c, id, await changeProviders(control, id, c.req.valid("json")));
+    })
         .post("/:id/cancel", zValidator("param", idParam, onInvalid), async (c) => {
         const { id } = c.req.valid("param");
-        const result = await cancelProject(cancel, id);
-        if (!result.ok) {
-            return problem(c, { status: 404, title: titleOf(404), detail: details["no-project"] });
-        }
-        // No tick: a canceled project sits until the user retries a stage.
-        return c.json({ ...view(id), canceled: result.canceled });
+        return withProjectControl(deps.db, id, async () => {
+            const result = await cancelProject(cancel, id);
+            if (!result.ok) {
+                return problem(c, { status: 404, title: titleOf(404), detail: details["no-project"] });
+            }
+            // No tick: a canceled project sits until the user retries a stage.
+            return c.json({ ...view(id), canceled: result.canceled });
+        });
     })
         .post("/:id/stages/:kind/retry", zValidator("param", stageParam, onInvalid), (c) => {
         const { id, kind } = c.req.valid("param");
-        return started(c, id, retryStage(reruns, id, kind));
+        return withProjectControl(deps.db, id, () => started(c, id, retryStage(reruns, id, kind)));
     })
         .post("/:id/stages/:kind/rerun", zValidator("param", stageParam, onInvalid), (c) => {
         const { id, kind } = c.req.valid("param");
-        return started(c, id, rerunStage(reruns, id, kind));
+        return withProjectControl(deps.db, id, () => started(c, id, rerunStage(reruns, id, kind)));
     })
         .put("/:id/article", zValidator("param", idParam, onInvalid), zValidator("json", articleBody, onInvalid), (c) => {
         const { id } = c.req.valid("param");
-        return started(c, id, editArticle(reruns, id, c.req.valid("json").markdown));
+        return withProjectControl(deps.db, id, () => started(c, id, editArticle(reruns, id, c.req.valid("json").markdown)));
     })
         .delete("/:id/images/:outputId", zValidator("param", imageParam, onInvalid), (c) => {
         const { id, outputId } = c.req.valid("param");
-        return started(c, id, deleteImage(reruns, id, outputId));
+        return withProjectControl(deps.db, id, () => started(c, id, deleteImage(reruns, id, outputId)));
     })
         .post("/:id/images/:outputId/regenerate", zValidator("param", imageParam, onInvalid), (c) => {
         const { id, outputId } = c.req.valid("param");
-        return started(c, id, regenerateImage(reruns, id, outputId));
+        return withProjectControl(deps.db, id, () => started(c, id, regenerateImage(reruns, id, outputId)));
     });
 }

package/dist/edge/http/projects.js

@@ -5,6 +5,7 @@ import { derive, progressOf } from "../../kernel/runner/graph.js";
 import { listProjects, projectById, runDraftSchema, stageStandingsByProject, stagesOf, } from "../../slices/admission/repo.js";
 import { admit } from "../../slices/admission/rules.js";
 import { startRun } from "../../slices/admission/start.js";
+import { withProjectControl } from "../../slices/control/lock.js";
 import { pickTemplates, renderPicked } from "../../slices/library/slots.js";
 import { deleteProject } from "../../slices/storage/delete-project.js";
 import { outputsOf, stagedFiles } from "../../slices/storage/repo.js";
@@ -40,7 +41,7 @@ export function projectRoutes(deps) {
     const storageForDelete = { db: deps.db, paths: deps.paths, log: deps.log };
     const summarise = (project) => ({
         ...project,
-        status: derive(stagesOf(deps.db, project.id)),
+        status: derive(stagesOf(deps.db, project.id), project.paused),
     });
     return (new Hono()
         .post("/", zValidator("json", runDraftSchema, onInvalid), (c) => {
@@ -82,7 +83,11 @@ export function projectRoutes(deps) {
         const standings = stageStandingsByProject(deps.db);
         const projects = listProjects(deps.db).map((project) => {
             const stages = standings.get(project.id) ?? [];
-            return { ...project, status: derive(stages), progress: progressOf(stages) };
+            return {
+                ...project,
+                status: derive(stages, project.paused),
+                progress: progressOf(stages),
+            };
         });
         return c.json({ projects });
     })
@@ -104,14 +109,16 @@ export function projectRoutes(deps) {
         // Irreversible, and only from the app: the Projects screen puts a confirmation
         // dialog in front of it.
         .delete("/:id", zValidator("param", idParam, onInvalid), (c) => {
-        const result = deleteProject(storageForDelete, c.req.valid("param").id);
-        if (result.ok) {
-            return c.body(null, 204);
-        }
-        return problem(c, {
-            status: deleteStatus[result.reason],
-            title: titleOf(deleteStatus[result.reason]),
-            detail: result.detail ?? deleteDetails[result.reason],
+        const id = c.req.valid("param").id;
+        return withProjectControl(deps.db, id, () => {
+            const result = deleteProject(storageForDelete, id);
+            if (result.ok)
+                return c.body(null, 204);
+            return problem(c, {
+                status: deleteStatus[result.reason],
+                title: titleOf(deleteStatus[result.reason]),
+                detail: result.detail ?? deleteDetails[result.reason],
+            });
         });
     }));
 }

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/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/main.js

@@ -4,6 +4,9 @@ import ffmpegStatic from "ffmpeg-static";
 import { buildRegistry } from "./adapter-registry.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 +17,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 +83,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,
@@ -142,6 +160,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 +173,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 +235,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

@@ -50,6 +50,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 +74,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 +93,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 +133,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 +156,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,9 +60,12 @@ 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)) {
@@ -81,12 +84,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 +101,14 @@ 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(),
+        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,