@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/main.js

@@ -1,4 +1,4 @@
-import { randomBytes } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { serve } from "@hono/node-server";
@@ -10,37 +10,45 @@ import { nodeRunCli } from "./adapters/llm/run-cli.js";
 import { curateRegistry } from "./catalog/registry.js";
 import { createCatalogueStore } from "./catalog/store.js";
 import { createHub } from "./edge/events/hub.js";
+import { currentProjectEvent } from "./edge/events/visibility.js";
 import { createApp } from "./edge/http/app.js";
+import { createMutationLifecycle, drainMutationsWithDeadline } from "./edge/http/mutations.js";
 import { openFolder } from "./edge/open-folder.js";
 import { createAudioPreviewStore } from "./kernel/audio-preview.js";
 import { systemClock } from "./kernel/clock.js";
 import { openDb } from "./kernel/db/index.js";
 import { migrate } from "./kernel/db/migrate.js";
+import { transact } from "./kernel/db/tx.js";
 import { ulidIds } from "./kernel/ids.js";
 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 { createCheckpointAuthority, } from "./kernel/runner/checkpoint-authority.js";
 import { createRunner } from "./kernel/runner/index.js";
 import { stageProviders } from "./kernel/runner/providers.js";
 import { createProviderQueue } from "./kernel/runner/queue.js";
 import { readVersion } from "./kernel/version.js";
 import { modelSources } from "./model-catalog.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 { projectPaused } from "./slices/admission/repo.js";
 import { pumpQueue, queueWaiting } from "./slices/batch/index.js";
-import { runImages } from "./slices/images/run.js";
-import { runNarration } from "./slices/narration/run.js";
-import { runResearch } from "./slices/research/run.js";
+import { approveCheckpoint } from "./slices/checkpoints/index.js";
+import { checkpointDecisionForWork, recoverCheckpointWork, settleReleasedCheckpoints, } from "./slices/checkpoints/recovery.js";
+import { resolveFont } from "./slices/fonts/index.js";
+import { templateById } from "./slices/project-templates/repo.js";
+import { claimWork, finishWork, maySubmit } from "./slices/rebuild/repo.js";
+import { materializeAdmittedWork } from "./slices/rebuild/runtime-materialize.js";
+import { runRevisionInvocation } from "./slices/rebuild/runtime-run.js";
+import { executionStages, executionStandings, invocationReady, projectStandings, recordWorkProgress, } from "./slices/rebuild/runtime-store.js";
+import { settleTerminalScheduleRuns } from "./slices/schedules/repo.js";
+import { createScheduleRunner } from "./slices/schedules/scheduler.js";
 import { nodeCliProbe } from "./slices/settings/cli-status.js";
+import { providerStatuses } from "./slices/settings/readiness.js";
 import { reconcileStorage } from "./slices/storage/reconcile.js";
 import { collectorEndpoint, httpPostEvents } from "./slices/telemetry/collector-client.js";
 import { createFlusher } from "./slices/telemetry/flush.js";
 import { record } from "./slices/telemetry/record.js";
-import { runThumbnail } from "./slices/thumbnail/run.js";
-import { renderVideo } from "./slices/video/run.js";
+import { probeDurationMs } from "./slices/video/ffmpeg.js";
 import { watchActivation } from "./updater/candidate.js";
 import { launchUpdate } from "./updater/install.js";
 import { isUpdateToken } from "./updater/model.js";
@@ -52,10 +60,58 @@ import { createUpdater } from "./updater/service.js";
 // stay queued.
 const flushDelayMs = 1000;
 const collectorTimeoutMs = 10_000;
+const mutationDrainTimeoutMs = 5_000;
+export function createScheduleTickLifecycle(deps) {
+    let stopping = false;
+    let inflight;
+    const tick = () => {
+        if (stopping)
+            return Promise.resolve();
+        if (inflight !== undefined)
+            return inflight;
+        const release = deps.beginMutation();
+        if (release === undefined)
+            return Promise.resolve();
+        const running = (async () => {
+            try {
+                await deps.tick();
+            }
+            catch {
+                try {
+                    deps.report();
+                }
+                catch {
+                    // A logging failure must not turn a timer callback into an unhandled rejection.
+                }
+            }
+            finally {
+                release();
+            }
+        })();
+        inflight = running;
+        void running.then(() => {
+            if (inflight === running)
+                inflight = undefined;
+        }, () => {
+            if (inflight === running)
+                inflight = undefined;
+        });
+        return running;
+    };
+    return {
+        tick,
+        stop: () => {
+            stopping = true;
+            return inflight ?? Promise.resolve();
+        },
+    };
+}
 export async function boot(config) {
     const clock = systemClock;
     const ids = ulidIds;
     const paths = layout(config.dataDir);
+    const candidateToken = process.env.SLOPIFY_UPDATE_TOKEN ?? "";
+    const pendingActivation = isUpdateToken(candidateToken) && process.env.SLOPIFY_UPDATE_PENDING === "1";
     ensureDirs(paths, { mode: 0o700 });
     const lock = acquireInstanceLock(paths.lock);
     let db;
@@ -68,13 +124,26 @@ export async function boot(config) {
         });
         db = openDb(paths.db);
         migrate(db, clock);
+        const runtimeDb = db;
         const interrupted = markInterruptedStages(db, clock);
-        const reconciled = reconcileStorage(db, paths);
+        recoverCheckpointWork(db);
+        const settledSchedules = settleTerminalScheduleRuns(db, clock.now().toISOString());
+        // The updater can restore the database after a failed candidate boot, but it cannot
+        // restore files deleted by reconciliation. Leave the filesystem untouched until the
+        // candidate's committed activation pointer has been verified.
+        const reconciled = pendingActivation ? undefined : reconcileStorage(db, paths);
         const log = openLog(paths.logs, clock);
         log.write("info", "boot", {
-            detail: `interrupted stages ${interrupted}, orphan files ${reconciled.orphanFiles}, staged files ${reconciled.stagedFiles}`,
+            detail: reconciled === undefined
+                ? `interrupted stages ${interrupted}, settled schedules ${settledSchedules}, storage reconciliation deferred during update activation`
+                : `interrupted stages ${interrupted}, settled schedules ${settledSchedules}, orphan files ${reconciled.orphanFiles}, staged files ${reconciled.stagedFiles}`,
+        });
+        const eventDb = db;
+        const hub = createHub({
+            ids,
+            log,
+            acceptEvent: (event) => currentProjectEvent(eventDb, event),
         });
-        const hub = createHub({ ids, log });
         const version = readVersion();
         const telemetry = { db, ids, clock, log, appVersion: version };
         const flusher = createFlusher({
@@ -92,7 +161,7 @@ export async function boot(config) {
             probe: nodeCliProbe,
         }), catalogue);
         const audioPreviews = createAudioPreviewStore();
-        const runner = wire({
+        const runner = wireRunner({
             db,
             paths,
             clock,
@@ -122,8 +191,6 @@ export async function boot(config) {
             throw new Error("The server is not ready.");
         };
         let listeningPort = config.port;
-        const candidateToken = process.env.SLOPIFY_UPDATE_TOKEN ?? "";
-        const pendingActivation = isUpdateToken(candidateToken) && process.env.SLOPIFY_UPDATE_PENDING === "1";
         const updater = createUpdater({
             ...(isUpdateToken(candidateToken)
                 ? {
@@ -131,6 +198,21 @@ export async function boot(config) {
                         token: candidateToken,
                         pending: pendingActivation,
                         committed: () => updateCommitted(paths.dataDir, version, candidateToken),
+                        settle: () => {
+                            try {
+                                const settled = reconcileStorage(updateDb, paths);
+                                log.write("info", "update", {
+                                    detail: `activation storage reconciliation removed ${settled.orphanFiles} orphan files and ${settled.stagedFiles} staged files`,
+                                });
+                            }
+                            catch {
+                                // The pointer is already committed, so storage maintenance can no longer
+                                // safely reject or roll back this candidate. A normal restart retries it.
+                                log.write("error", "update", {
+                                    detail: "Storage reconciliation failed after update activation.",
+                                });
+                            }
+                        },
                     },
                 }
                 : {}),
@@ -169,13 +251,64 @@ export async function boot(config) {
                 });
             },
         });
+        const rebuild = {
+            db,
+            paths,
+            ids,
+            clock,
+            log,
+            runner,
+            catalogue,
+            measureAudio: (path, signal) => probeDurationMs(ffmpeg, path, signal ?? AbortSignal.timeout(30_000), log),
+            providers: () => providerStatuses({ db: updateDb, probe: nodeCliProbe }),
+            modelsFor: modelSources(registry).modelsFor,
+            emit: (projectId, event) => hub.emit(projectId, event),
+        };
+        const draftDeps = {
+            db,
+            paths,
+            ids,
+            clock,
+            log,
+            runner,
+            catalogue,
+            uuid: randomUUID,
+            resolveFont: (fontId) => resolveFont(paths, fontId),
+            providers: rebuild.providers,
+            modelsFor: rebuild.modelsFor,
+            emit: (event) => hub.emitGlobal(event),
+            recordStarted: (projectIds) => {
+                for (const _projectId of projectIds)
+                    record(telemetry, "project.created", {});
+                flusher.soon();
+            },
+        };
+        const scheduleDeps = {
+            ...draftDeps,
+            template: (id, templateVersion) => templateById(runtimeDb, id, templateVersion),
+        };
+        const scheduleRunner = createScheduleRunner(scheduleDeps);
+        scheduleRunner.recover(clock.now());
+        const scheduleTicks = createScheduleTickLifecycle({
+            beginMutation: updater.beginMutation,
+            tick: scheduleRunner.tick,
+            report: () => log.write("error", "schedule.tick", {
+                detail: "Scheduled jobs could not be advanced.",
+            }),
+        });
+        const mutations = createMutationLifecycle();
         const app = createApp({
+            rebuild,
+            drafts: draftDeps,
+            schedules: scheduleDeps,
+            ...(rebuild.measureAudio === undefined ? {} : { measureAudio: rebuild.measureAudio }),
             openFolder,
             db,
             paths,
             hub,
             runner,
             updater,
+            mutations,
             audioPreviews,
             ...modelSources(registry),
             catalogue,
@@ -202,6 +335,10 @@ export async function boot(config) {
                 release();
             }
         }, 1000);
+        const scheduleTimer = setInterval(() => {
+            void scheduleTicks.tick();
+        }, 15_000);
+        void scheduleTicks.tick();
         listeningPort = portOf(server) ?? config.port;
         // Whatever last run left queued goes out at start. Nothing waits for
         // it, and an unreachable collector costs one refused socket.
@@ -212,25 +349,34 @@ export async function boot(config) {
         shutdown = () => {
             stopping ??= (async () => {
                 clearInterval(queueTimer);
+                clearInterval(scheduleTimer);
+                const mutationDrain = mutations.stop();
+                const scheduleDrain = scheduleTicks.stop();
+                const serverClose = beginServerClose(server);
                 stopActivation();
                 audioPreviews.close();
                 try {
-                    // The listener goes first. Aborting the runner while the socket still accepted
-                    // requests let a Play arriving during the await start a stage under a fresh
-                    // controller nobody had aborted, which abortAll would then have waited out.
-                    // Only once nothing new can arrive is the runner drained and the database shut.
-                    await close(server);
+                    // Admission closes before the listener. Requests already admitted keep the
+                    // database until their response settles; anything racing shutdown receives 503.
+                    await drainMutationsWithDeadline(mutationDrain, serverClose.terminate, mutationDrainTimeoutMs);
+                    await scheduleDrain;
                     await runner.abortAll();
                 }
                 finally {
-                    // The pending timer is cancelled rather than awaited: a shutdown must not wait
-                    // on the collector. A flush already in flight may land after the database
-                    // closes and fail to mark its batch delivered, which costs one re-send that
-                    // the collector deduplicates by event id.
-                    flusher.stop();
-                    log.write("info", "shutdown");
-                    open.close();
-                    lock.release();
+                    serverClose.terminate();
+                    try {
+                        await serverClose.closed;
+                    }
+                    finally {
+                        // The pending timer is cancelled rather than awaited: a shutdown must not wait
+                        // on the collector. A flush already in flight may land after the database
+                        // closes and fail to mark its batch delivered, which costs one re-send that
+                        // the collector deduplicates by event id.
+                        flusher.stop();
+                        log.write("info", "shutdown");
+                        open.close();
+                        lock.release();
+                    }
                 }
             })();
             return stopping;
@@ -245,7 +391,7 @@ export async function boot(config) {
         throw error;
     }
 }
-function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, catalogue, ffmpeg, }) {
+export function wireRunner({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, catalogue, ffmpeg, }) {
     // A stage counts what it did and the queue is flushed after each new event. `record`
     // swallows its own failures, so this can neither fail a stage nor widen what leaves the
     // machine - the payload allow-list is checked inside it.
@@ -253,12 +399,7 @@ function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flush
         record(telemetry, type, counters);
         flusher.soon();
     };
-    // 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, 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 };
+    const execution = { db, paths, ids, clock, log, ffmpeg, alignSubtitles, audioPreviews, count };
     // A stage slice is handed the wrapped calls, never the registry: every provider call
     // it makes is already inside the retry policy (kernel/runner/providers.ts).
     const providers = {
@@ -268,43 +409,55 @@ function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flush
         log,
         queue: createProviderQueue((provider) => catalogue.read().providers[provider]?.maxConcurrent ?? 1),
     };
-    return createRunner({
+    const checkpoints = createCheckpointAuthority({
+        decide: (work) => checkpointDecisionForWork(execution, work),
+        approve: (projectId, checkpointId, identity) => approveCheckpoint(db, {
+            ...identity,
+            projectId,
+            checkpointId,
+            approvedAt: clock.now().toISOString(),
+        }),
+        inTransaction: () => db.isTransaction,
+        wake: (projectId) => runner.tick(projectId),
+        log,
+    });
+    const runner = createRunner({
+        checkpoints,
         stages: {
-            stagesOf: (projectId) => stagesOf(db, projectId),
+            stagesOf: (projectId) => {
+                materializeAdmittedWork(execution, projectId);
+                projectStandings(execution, projectId);
+                return executionStages(execution, projectId);
+            },
+            standingsOf: (projectId) => executionStandings(execution, projectId),
+            ready: (work) => invocationReady(execution, work),
             paused: (projectId) => projectPaused(db, projectId) || queueWaiting(db, projectId),
-            dependenciesOf: (projectId, kind) => {
-                const project = projectById(db, projectId);
-                return project === undefined ? [] : dependenciesOf(kind, project.config.sources);
+            claim: (work) => {
+                const claimed = claimWork(db, work);
+                projectStandings(execution, work.projectId);
+                return claimed;
             },
-            claim: (stageId) => claimStage(db, stageId, clock.now().toISOString()),
-            finish: (stageId, state, failureReason) => finishStage(db, stageId, state, failureReason, clock.now().toISOString()),
-        },
-        // Only the stages that exist. A pending stage with no entry here fails loudly with
-        // that sentence rather than waiting for a runner that will never call it.
-        runs: {
-            research: (context) => runResearch(writing, context, stageProviders(providers, context)),
-            article: (context) => runArticle(writing, context, stageProviders(providers, context)),
-            audio: async (context) => {
-                const wrapped = stageProviders(providers, context);
-                await prepareProvidedArticleSegments(writing, context, wrapped);
-                await runNarration({
-                    ...video,
-                    audioPreviews,
-                    maxCharacters: (provider, model) => {
-                        const entry = catalogue.models(provider, "tts").find((m) => m.id === model);
-                        return entry && "tts" in entry ? entry.tts.maxCharacters : 4000;
-                    },
-                }, context, wrapped);
+            maySubmit: (work, pieceId) => maySubmit(db, work, pieceId),
+            finish: (work, state, reason) => {
+                transact(db, () => {
+                    finishWork(db, work, state, reason);
+                    materializeAdmittedWork(execution, work.projectId);
+                    projectStandings(execution, work.projectId);
+                    settleReleasedCheckpoints(execution, work.projectId);
+                });
             },
-            images: (context) => runImages(writing, context, stageProviders(providers, context)),
-            thumbnail: (context) => runThumbnail(writing, context, stageProviders(providers, context)),
-            video: (context) => renderVideo(video, context),
         },
+        runs: Object.fromEntries(["research", "article", "audio", "images", "thumbnail", "video"].map((kind) => [
+            kind,
+            (context) => runRevisionInvocation(execution, context, stageProviders(providers, context)),
+        ])),
         // Counting is finer than a stage reaching `done` - each intro and outro text, each
         // narrated segment - and the counters are provider names, token usage and durations
         // only the stage slice ever sees. Each slice records its own units through `count`
         // above, and the runner counts nothing: the kernel may not import a slice.
         emit: (projectId, event) => {
+            if (event.type === "stage.progress")
+                recordWorkProgress(execution, event);
             hub.emit(projectId, event);
         },
         emitRunningCount: (running) => {
@@ -312,6 +465,7 @@ function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flush
         },
         log,
     });
+    return { ...runner, checkpoints };
 }
 function listen(app, config, log) {
     return new Promise((resolve, reject) => {
@@ -325,13 +479,10 @@ function listen(app, config, log) {
         server.once("error", reject);
     });
 }
-function close(server) {
+function beginServerClose(server) {
     // An SSE response never ends by itself, and close() waits for every open connection,
-    // so a shutdown that only called close() would hang for as long as a page is open.
-    if ("closeAllConnections" in server) {
-        server.closeAllConnections();
-    }
-    return new Promise((resolve, reject) => {
+    // so admitted mutations drain first and then the remaining sockets are terminated.
+    const closed = new Promise((resolve, reject) => {
         server.close((error) => {
             if (error === undefined || error === null) {
                 resolve();
@@ -340,6 +491,13 @@ function close(server) {
             reject(error);
         });
     });
+    return {
+        closed,
+        terminate: () => {
+            if ("closeAllConnections" in server)
+                server.closeAllConnections();
+        },
+    };
 }
 function portOf(server) {
     const address = server.address();

package/dist/slices/admission/repo.js

@@ -1,61 +1,8 @@
 import { z } from "zod";
 import { stageKinds, stageStates } from "../../kernel/pipeline.js";
-import { thinkingModes } from "../../kernel/ports/llm.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(),
-    thinking: z.enum(thinkingModes).optional(),
-});
-const entryChoice = z.object({ name: z.string(), mode: z.enum(entryModes) });
-// The shape Play posts and the shape `projects.config` holds, in one place: the second
-// is the first plus the rendered prompt texts.
-export const runDraftSchema = z.object({
-    title: z.string(),
-    format: z.enum(formats),
-    // Spelled out rather than built from stageKinds, so the inferred type carries the six
-    // keys and this schema stays assignable to the domain type without a cast.
-    sources: z.object({
-        research: z.enum(stageSources),
-        article: z.enum(stageSources),
-        audio: z.enum(stageSources),
-        images: z.enum(stageSources),
-        thumbnail: z.enum(stageSources),
-        video: z.enum(stageSources),
-    }),
-    llm: providerChoice.optional(),
-    audio: providerChoice.extend({ voice: z.string() }).optional(),
-    images: providerChoice.optional(),
-    articlePrompt: z.string().optional(),
-    imagePrompts: z.array(z.object({ name: z.string(), number: z.number() })),
-    thumbnailPrompt: z.string().optional(),
-    intro: entryChoice.optional(),
-    outro: entryChoice.optional(),
-    values: z.record(z.string(), z.string()),
-    provided: z.object({
-        research: z.string().optional(),
-        article: z.string().optional(),
-        audio: z.string().optional(),
-        images: z.array(z.string()).optional(),
-        thumbnail: z.string().optional(),
-    }),
-    // Optional until Play carries the control; unknown keys are stripped by this schema, so
-    // a mode not listed here would never reach the audio stage.
-    chunking: z
-        .object({
-        mode: z.enum(chunkModes),
-        words: z.number().optional(),
-        characters: z.number().int().min(1).max(1000000).optional(),
-    })
-        .optional(),
-    silenceGapSeconds: z.number(),
-    subtitles: subtitleConfigSchema.optional(),
-});
-export const runConfigSchema = runDraftSchema.extend({
-    rendered: z.record(z.string(), z.string()),
-});
+import { formats, stageSources } from "./model.js";
+import { runConfigSchema } from "./schema.js";
+export { runConfigSchema, runDraftSchema } from "./schema.js";
 const projectRow = z.object({
     id: z.string(),
     title: z.string(),
@@ -182,6 +129,8 @@ export function setProjectPaused(db, projectId, paused, at) {
     db.prepare("UPDATE projects SET updated_at = ? WHERE id = ?").run(at, projectId);
 }
 export function updateProjectConfig(db, projectId, config, at) {
+    if (db.prepare("SELECT 1 FROM project_heads WHERE project_id=?").get(projectId) !== undefined)
+        throw new Error("Versioned project configuration must be saved through revisions.");
     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.

package/dist/slices/admission/schema.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { thinkingModes } from "../../kernel/ports/llm.js";
+import { checkpointStageSchema } from "../checkpoints/schema.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(),
+    thinking: z.enum(thinkingModes).optional(),
+});
+const entryChoice = z.object({ name: z.string(), mode: z.enum(entryModes) });
+// The shape Play posts and the shape `projects.config` holds, in one place: the second
+// is the first plus the rendered prompt texts.
+export const runDraftSchema = z.object({
+    checkpoints: z
+        .array(checkpointStageSchema)
+        .max(3)
+        .refine((stages) => new Set(stages).size === stages.length)
+        .readonly()
+        .optional(),
+    title: z.string(),
+    format: z.enum(formats),
+    // Spelled out rather than built from stageKinds, so the inferred type carries the six
+    // keys and this schema stays assignable to the domain type without a cast.
+    sources: z.object({
+        research: z.enum(stageSources),
+        article: z.enum(stageSources),
+        audio: z.enum(stageSources),
+        images: z.enum(stageSources),
+        thumbnail: z.enum(stageSources),
+        video: z.enum(stageSources),
+    }),
+    llm: providerChoice.optional(),
+    audio: providerChoice.extend({ voice: z.string() }).optional(),
+    images: providerChoice.optional(),
+    articlePrompt: z.string().optional(),
+    imagePrompts: z.array(z.object({ name: z.string(), number: z.number() })),
+    thumbnailPrompt: z.string().optional(),
+    intro: entryChoice.optional(),
+    outro: entryChoice.optional(),
+    values: z.record(z.string(), z.string()),
+    provided: z.object({
+        research: z.string().optional(),
+        article: z.string().optional(),
+        audio: z.string().optional(),
+        images: z.array(z.string()).optional(),
+        thumbnail: z.string().optional(),
+    }),
+    // Optional until Play carries the control; unknown keys are stripped by this schema, so
+    // a mode not listed here would never reach the audio stage.
+    chunking: z
+        .object({
+        mode: z.enum(chunkModes),
+        words: z.number().optional(),
+        characters: z.number().int().min(1).max(1000000).optional(),
+    })
+        .optional(),
+    silenceGapSeconds: z.number(),
+    subtitles: subtitleConfigSchema.optional(),
+});
+export const runConfigSchema = runDraftSchema.extend({
+    rendered: z.record(z.string(), z.string()),
+});

package/dist/slices/admission/start.js

@@ -1,7 +1,10 @@
 import { transact } from "../../kernel/db/tx.js";
 import { stageKinds } from "../../kernel/pipeline.js";
 import { storeArticleText } from "../article/store.js";
-import { attachStagedFile, dropStagedSource, storeText } from "../storage/staging.js";
+import { admitInitialRevision } from "../rebuild/runtime-admission.js";
+import { adoptBaseline } from "../revisions/adopt.js";
+import { attachStagedFile, storeText } from "../storage/staging.js";
+import { releaseStagedFile } from "../storage/staging-refs.js";
 import { insertProject, insertStage } from "./repo.js";
 // Provide → `provided` with its output attached; Off → `skipped`;
 // everything else → `pending`.
@@ -13,7 +16,7 @@ export function initialState(source) {
 }
 // The project row, its six stages and the provided content all land together or not at
 // all. The caller ticks the runner after this returns, never inside it.
-export function startRun(deps, draft, rendered, retainStaged = false) {
+export function startRun(deps, draft, rendered, retainStaged = false, templates) {
     const id = deps.ids.next();
     const at = deps.clock.now().toISOString();
     const config = { ...draft, rendered };
@@ -50,9 +53,15 @@ export function startRun(deps, draft, rendered, retainStaged = false) {
             insertStage(deps.db, stage);
         }
         attachProvided(deps, id, draft, moved, retainStaged);
+        if (deps.catalogue !== undefined) {
+            const baseline = adoptBaseline(deps, id, templates);
+            if (!baseline.ok)
+                throw new Error("The new project has no revision.");
+            admitInitialRevision(deps, baseline.view, deps.catalogue.read());
+        }
     });
     for (const source of retainStaged ? [] : moved) {
-        dropStagedSource(deps, source);
+        releaseStagedFile(deps, source);
     }
     return { project, stages };
 }
@@ -101,5 +110,5 @@ function attach(deps, projectId, kind, stagedFileId, role, collected, retainStag
         // the file went away between the check and the write.
         throw new Error(`the ${kind} stage's file could not be attached: ${result.reason}`);
     }
-    collected.push(result.stagedSource);
+    collected.push(stagedFileId);
 }