@gentbajko/slopify 0.1.0

package/dist/kernel/version.js

@@ -0,0 +1,14 @@
+import { readFileSync } from "node:fs";
+// package.json sits two directories above this module both in src/ and in dist/,
+// because the build mirrors the source tree (src/kernel/version.ts -> dist/kernel/
+// version.js). Reading it through import.meta.url survives `npx slopify` from any cwd.
+export function readVersion() {
+    const parsed = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        !("version" in parsed) ||
+        typeof parsed.version !== "string") {
+        throw new Error("package.json has no version string");
+    }
+    return parsed.version;
+}

package/dist/main.js

@@ -0,0 +1,212 @@
+import { fileURLToPath } from "node:url";
+import { serve } from "@hono/node-server";
+import ffmpegStatic from "ffmpeg-static";
+import { buildRegistry } from "./adapter-registry.js";
+import { nodeRunCli } from "./adapters/llm/run-cli.js";
+import { createHub } from "./edge/events/hub.js";
+import { createApp } from "./edge/http/app.js";
+import { systemClock } from "./kernel/clock.js";
+import { openDb } from "./kernel/db/index.js";
+import { migrate } from "./kernel/db/migrate.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 { 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 { runArticle } from "./slices/article/run.js";
+import { runImages } from "./slices/images/run.js";
+import { runNarration } from "./slices/narration/run.js";
+import { runResearch } from "./slices/research/run.js";
+import { nodeCliProbe } from "./slices/settings/cli-status.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 { resolveFfmpeg } from "./slices/video/ffmpeg.js";
+import { renderVideo } from "./slices/video/run.js";
+// ceiling: a burst of finished stages coalesces into one delivery a second later, and the
+// collector gets ten seconds to answer before the attempt is abandoned and the events
+// stay queued.
+const flushDelayMs = 1000;
+const collectorTimeoutMs = 10_000;
+export async function boot(config) {
+    const clock = systemClock;
+    const ids = ulidIds;
+    const paths = layout(config.dataDir);
+    ensureDirs(paths, { mode: 0o700 });
+    const lock = acquireInstanceLock(paths.lock);
+    let db;
+    try {
+        db = openDb(paths.db);
+        migrate(db, clock);
+        const interrupted = markInterruptedStages(db, clock);
+        const reconciled = 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}`,
+        });
+        const hub = createHub({ ids, log });
+        const version = readVersion();
+        const telemetry = { db, ids, clock, log, appVersion: version };
+        const flusher = createFlusher({
+            db,
+            clock,
+            log,
+            post: httpPostEvents(collectorEndpoint(process.env), collectorTimeoutMs),
+        }, flushDelayMs);
+        const registry = buildRegistry({
+            db,
+            fetch: globalThis.fetch,
+            spawn: nodeRunCli,
+            clock,
+            probe: nodeCliProbe,
+        });
+        const runner = wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry });
+        const app = createApp({
+            db,
+            paths,
+            hub,
+            runner,
+            clock,
+            ids,
+            log,
+            version,
+            webDist: fileURLToPath(new URL("../dist/web", import.meta.url)),
+            flushSoon: flusher.soon,
+            probe: nodeCliProbe,
+        });
+        const server = await listen(app, config, log);
+        // logic/16 step 5: whatever last run left queued goes out at start. Nothing waits for
+        // it, and an unreachable collector costs one refused socket.
+        flusher.soon();
+        const open = db;
+        return {
+            paths,
+            url: urlOf(config.host, portOf(server) ?? config.port),
+            stop: async () => {
+                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);
+                    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 (logic/16 §Q134).
+                    flusher.stop();
+                    log.write("info", "shutdown");
+                    open.close();
+                    lock.release();
+                }
+            },
+        };
+    }
+    catch (error) {
+        db?.close();
+        lock.release();
+        throw error;
+    }
+}
+function wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry }) {
+    // Resolved once at boot rather than per render, so a machine with no usable binary
+    // fails at start with one message instead of on every project's last stage.
+    const ffmpeg = resolveFfmpeg(process.env, ffmpegStatic);
+    // logic/16 steps 2 and 5: 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.
+    const count = (type, counters) => {
+        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 };
+    // 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 };
+    // 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 = { registry, attempts: sqliteAttempts(db, ids), clock, log };
+    return createRunner({
+        stages: {
+            stagesOf: (projectId) => stagesOf(db, projectId),
+            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: (context) => runNarration(video, context, stageProviders(providers, context)),
+            images: (context) => runImages(writing, context, stageProviders(providers, context)),
+            thumbnail: (context) => runThumbnail(writing, context, stageProviders(providers, context)),
+            video: (context) => renderVideo(video, context),
+        },
+        // logic/16 step 2 counts finer than a stage reaching `done` - each intro and outro
+        // text, each narrated segment - and its counters are the provider names, the token
+        // usage and the durations only the stage slice ever sees. Each slice therefore
+        // records its own units through `count` above, and the runner is left counting
+        // nothing: the kernel may not import a slice (03-conventions).
+        emit: (projectId, event) => {
+            hub.emit(projectId, event);
+        },
+        emitRunningCount: (running) => {
+            hub.emitGlobal({ type: "running.count", count: running });
+        },
+        log,
+    });
+}
+function listen(app, config, log) {
+    return new Promise((resolve, reject) => {
+        const server = serve({ fetch: app.fetch, port: config.port, hostname: config.host }, () => {
+            server.off("error", reject);
+            server.on("error", (error) => {
+                log.write("error", "http.server", { detail: error.message });
+            });
+            resolve(server);
+        });
+        server.once("error", reject);
+    });
+}
+function close(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) => {
+        server.close((error) => {
+            if (error === undefined || error === null) {
+                resolve();
+                return;
+            }
+            reject(error);
+        });
+    });
+}
+function portOf(server) {
+    const address = server.address();
+    return address === null || typeof address === "string" ? undefined : address.port;
+}
+export function urlOf(host, port) {
+    // An IPv6 literal has to be bracketed before it is a URL authority.
+    return `http://${host.includes(":") ? `[${host}]` : host}:${port}`;
+}
+// A stage can only be `running` at boot if the previous process died mid-run;
+// nothing auto-resumes, the user retries by hand (logic/01 §Q7).
+export function markInterruptedStages(db, clock) {
+    const result = db
+        .prepare("UPDATE stages SET state = 'failed', failure_reason = 'interrupted', finished_at = ? WHERE state = 'running'")
+        .run(clock.now().toISOString());
+    return Number(result.changes);
+}

package/dist/slices/admission/model.js

@@ -0,0 +1,6 @@
+// The format is the kernel's: the image port asks for the same two aspects.
+export { formats } from "../../kernel/pipeline.js";
+// mockup §Q28 and logic/10 §Q78: Generate / Provide / Off for most stages, and the
+// thumbnail's two Generate modes. Video is always `generate` (logic/01 step 5).
+export const stageSources = ["generate", "provide", "off", "from_prompt", "prompt_by_llm"];
+export const entryModes = ["text", "llm"];

package/dist/slices/admission/repo.js

@@ -0,0 +1,178 @@
+import { z } from "zod";
+import { stageKinds, stageStates } from "../../kernel/pipeline.js";
+import { chunkModes } from "../narration/chunk.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) });
+// The shape Play posts and the shape `projects.config` holds, in one place: the second
+// is the first plus the rendered prompt texts (logic/03 §Q25).
+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(),
+    }),
+    // logic/08 §Q65. Optional until Play carries the control; unknown keys are stripped by
+    // this schema, so a mode that is not listed here would never reach the audio stage.
+    chunking: z.object({ mode: z.enum(chunkModes), words: z.number().optional() }).optional(),
+    silenceGapSeconds: z.number(),
+});
+export const runConfigSchema = runDraftSchema.extend({
+    rendered: z.record(z.string(), z.string()),
+});
+const projectRow = z.object({
+    id: z.string(),
+    title: z.string(),
+    format: z.enum(formats),
+    config: z.string(),
+    created_at: z.string(),
+    updated_at: z.string(),
+});
+const standingRow = z.object({
+    project_id: z.string(),
+    kind: z.enum(stageKinds),
+    state: z.enum(stageStates),
+    progress_current: z.number().nullable(),
+    progress_total: z.number().nullable(),
+});
+const stageRow = z.object({
+    id: z.string(),
+    project_id: z.string(),
+    kind: z.enum(stageKinds),
+    source: z.enum(stageSources),
+    state: z.enum(stageStates),
+    failure_reason: z.string().nullable(),
+    attempt_count: z.number(),
+    progress_current: z.number().nullable(),
+    progress_total: z.number().nullable(),
+    started_at: z.string().nullable(),
+    finished_at: z.string().nullable(),
+});
+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);
+}
+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);
+    return row === undefined ? undefined : toProject(projectRow.parse(row));
+}
+// Existence alone, for a caller that needs no run configuration: `slices/cancel` only
+// asks whether the id names a project, and parsing the config to answer that would tie
+// cancelling to a schema it never reads.
+export function projectExists(db, id) {
+    return db.prepare("SELECT 1 FROM projects WHERE id = ?").get(id) !== undefined;
+}
+// mockup/07: newest first.
+export function listProjects(db) {
+    return db
+        .prepare("SELECT * FROM projects ORDER BY created_at DESC, id DESC")
+        .all()
+        .map((row) => toProject(projectRow.parse(row)));
+}
+// What 07 Projects needs of every project's stages and no more: the state each one is in
+// and how far through itself a running one is. One statement for the whole list rather
+// than `stagesOf` per row, and five columns rather than the whole stage table, because
+// the screen shows a status word and a meter and reads nothing else from a stage.
+export function stageStandingsByProject(db) {
+    const grouped = new Map();
+    const rows = db
+        .prepare("SELECT project_id, kind, state, progress_current, progress_total FROM stages ORDER BY rowid")
+        .all();
+    for (const row of rows) {
+        const parsed = standingRow.parse(row);
+        const standing = {
+            kind: parsed.kind,
+            state: parsed.state,
+            progressCurrent: parsed.progress_current,
+            progressTotal: parsed.progress_total,
+        };
+        const seen = grouped.get(parsed.project_id);
+        if (seen === undefined) {
+            grouped.set(parsed.project_id, [standing]);
+        }
+        else {
+            seen.push(standing);
+        }
+    }
+    return grouped;
+}
+export function stagesOf(db, projectId) {
+    return db
+        .prepare("SELECT * FROM stages WHERE project_id = ? ORDER BY rowid")
+        .all(projectId)
+        .map((row) => toStage(stageRow.parse(row)));
+}
+// 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'")
+        .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);
+}
+// `logic/12` step 9 and `logic/13` step 5: 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 the fresh attempt budget of `logic/01` §Q5.
+export function resetStage(db, stageId) {
+    db.prepare("UPDATE stages SET state = 'pending', failure_reason = NULL, attempt_count = 0, progress_current = NULL, progress_total = NULL, started_at = NULL, finished_at = NULL WHERE id = ?").run(stageId);
+}
+export function setStageProgress(db, stageId, current, total) {
+    db.prepare("UPDATE stages SET progress_current = ?, progress_total = ? WHERE id = ?").run(current, total, stageId);
+}
+function toProject(row) {
+    return {
+        id: row.id,
+        title: row.title,
+        format: row.format,
+        config: parseConfig(row.config),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+// A JSON column never reaches a caller as a string.
+function parseConfig(config) {
+    const parsed = JSON.parse(config);
+    return runConfigSchema.parse(parsed);
+}
+function toStage(row) {
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        kind: row.kind,
+        source: row.source,
+        state: row.state,
+        failureReason: row.failure_reason,
+        attemptCount: row.attempt_count,
+        progressCurrent: row.progress_current,
+        progressTotal: row.progress_total,
+        startedAt: row.started_at,
+        finishedAt: row.finished_at,
+    };
+}

package/dist/slices/admission/rules.js

@@ -0,0 +1,201 @@
+import { stageKinds } from "../../kernel/pipeline.js";
+export const titleMax = 200;
+export const valueMax = 200;
+export const numberPerPromptMax = 20;
+export const imagesPerRunMax = 60;
+// ceiling: logic/11 §Q99 and logic/02 fix the default at 3 s but name no bounds, so the
+// range is this module's. A wider gap is a settings change, not a schema change.
+export const silenceGapSecondsMax = 30;
+// mockup §Q28, logic/04 §Q31, logic/10 §Q78. Video is always generated (logic/01 step 5).
+// Exported because Play's source switches offer exactly these and nothing else: the
+// segmented control and the refusal below it are then the same list, and a stage whose
+// legal set changes cannot leave a switch behind offering something the server refuses.
+// The order is the order the segments are drawn in on the reference sheet; the rule
+// itself only asks whether a source is on its stage's list.
+export const allowedSources = {
+    research: ["off", "generate", "provide"],
+    article: ["generate", "provide"],
+    audio: ["generate", "provide"],
+    images: ["generate", "provide"],
+    thumbnail: ["off", "from_prompt", "prompt_by_llm", "provide"],
+    video: ["generate"],
+};
+export function admit(input) {
+    const fields = [];
+    const draft = normalise(input.draft);
+    const { sources } = draft;
+    if (draft.title === "") {
+        fields.push({ field: "title", message: "A title is required." });
+    }
+    else if (draft.title.length > titleMax) {
+        fields.push({ field: "title", message: `A title is at most ${titleMax} characters.` });
+    }
+    for (const kind of stageKinds) {
+        if (!allowedSources[kind].includes(sources[kind])) {
+            fields.push({
+                field: `sources.${kind}`,
+                message: `The ${kind} stage cannot be set to ${sources[kind]}.`,
+            });
+        }
+    }
+    // logic/04 §Q28 with logic/10 §Q81 and §Q97: the LLM row is required only when
+    // something in the run actually asks an LLM for text.
+    const needsLlm = sources.research === "generate" ||
+        sources.article === "generate" ||
+        sources.thumbnail === "prompt_by_llm" ||
+        draft.intro?.mode === "llm" ||
+        draft.outro?.mode === "llm";
+    if (needsLlm && !chosen(draft.llm)) {
+        fields.push({ field: "llm", message: "Pick an LLM provider and model." });
+    }
+    if (sources.article === "generate" && blank(draft.articlePrompt)) {
+        fields.push({ field: "articlePrompt", message: "Pick an article prompt." });
+    }
+    const voiced = draft.audio;
+    if (sources.audio === "generate") {
+        if (voiced === undefined || !chosen(voiced)) {
+            fields.push({ field: "audio", message: "Pick a narration provider and model." });
+        }
+        else if (voiced.voice.trim() === "") {
+            fields.push({ field: "audio.voice", message: "Pick a voice." });
+        }
+    }
+    if (sources.images === "generate") {
+        checkImagePrompts(draft, fields);
+        if (!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." });
+    }
+    checkProvided(draft, input.staged, fields);
+    checkValues(draft, input.requiredSlots, fields);
+    if (!Number.isFinite(draft.silenceGapSeconds) ||
+        draft.silenceGapSeconds < 0 ||
+        draft.silenceGapSeconds > silenceGapSecondsMax) {
+        fields.push({
+            field: "silenceGapSeconds",
+            message: `The silence gap is between 0 and ${silenceGapSecondsMax} seconds.`,
+        });
+    }
+    return fields.length === 0 ? { ok: true, draft } : { ok: false, fields };
+}
+// logic/05 §Q41: research only feeds article writing, so a provided article hides it.
+// logic/01 step 5: video is generated whatever the form said.
+function normalise(draft) {
+    const sources = { ...draft.sources, video: "generate" };
+    if (sources.article === "provide") {
+        sources.research = "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.
+    const values = Object.create(null);
+    for (const [name, value] of Object.entries(draft.values)) {
+        values[name] = value.trim();
+    }
+    return { ...draft, title: draft.title.trim(), sources, values };
+}
+function checkImagePrompts(draft, fields) {
+    if (draft.imagePrompts.length === 0) {
+        // logic/04 §Q31: a run always has an image source.
+        fields.push({ field: "imagePrompts", message: "Tick at least one image prompt." });
+        return;
+    }
+    let total = 0;
+    for (const [index, prompt] of draft.imagePrompts.entries()) {
+        total += prompt.number;
+        if (blank(prompt.name)) {
+            fields.push({ field: `imagePrompts.${index}.name`, message: "Pick an image prompt." });
+        }
+        if (!Number.isInteger(prompt.number) ||
+            prompt.number < 1 ||
+            prompt.number > numberPerPromptMax) {
+            fields.push({
+                field: `imagePrompts.${index}.number`,
+                message: `Number is between 1 and ${numberPerPromptMax}.`,
+            });
+        }
+    }
+    if (total > imagesPerRunMax) {
+        fields.push({
+            field: "imagePrompts",
+            message: `A run makes at most ${imagesPerRunMax} images; this one asks for ${total}.`,
+        });
+    }
+}
+function checkProvided(draft, staged, fields) {
+    const { sources, provided } = draft;
+    if (sources.research === "provide" && blank(provided.research)) {
+        fields.push({ field: "provided.research", message: "Paste the research notes." });
+    }
+    if (sources.article === "provide" && blank(provided.article)) {
+        fields.push({ field: "provided.article", message: "Paste the article." });
+    }
+    if (sources.audio === "provide") {
+        checkFile(staged, provided.audio, "audio", "provided.audio", "Pick an audio file.", fields);
+    }
+    if (sources.thumbnail === "provide") {
+        checkFile(staged, provided.thumbnail, "thumbnail", "provided.thumbnail", "Pick a thumbnail image.", fields);
+    }
+    if (sources.images === "provide") {
+        const ids = provided.images ?? [];
+        if (ids.length === 0) {
+            fields.push({ field: "provided.images", message: "Pick at least one image." });
+        }
+        else if (ids.length > imagesPerRunMax) {
+            fields.push({
+                field: "provided.images",
+                message: `A run holds at most ${imagesPerRunMax} images.`,
+            });
+        }
+        if (new Set(ids).size !== ids.length) {
+            fields.push({ field: "provided.images", message: "The same image was picked twice." });
+        }
+        for (const [index, id] of ids.entries()) {
+            checkFile(staged, id, "images", `provided.images.${index}`, "Pick an image.", fields);
+        }
+    }
+}
+// logic/05 §Q44: a run never starts with provided content that is missing or still copying.
+function checkFile(staged, id, kind, field, missing, fields) {
+    if (id === undefined || id === "") {
+        fields.push({ field, message: missing });
+        return;
+    }
+    const file = staged.find((candidate) => candidate.id === id);
+    if (file === undefined || file.stageKind !== kind) {
+        fields.push({ field, message: "That upload is no longer available; pick the file again." });
+        return;
+    }
+    if (file.state !== "staged") {
+        fields.push({ field, message: "This upload is still copying." });
+    }
+}
+// logic/03 step 4 and §Q26.
+function checkValues(draft, requiredSlots, fields) {
+    for (const name of requiredSlots) {
+        const value = Object.hasOwn(draft.values, name) ? draft.values[name] : undefined;
+        if (value === undefined || value === "") {
+            fields.push({ field: `values.${name}`, message: "This field is required." });
+            continue;
+        }
+        if (value.length > valueMax) {
+            fields.push({
+                field: `values.${name}`,
+                message: `A value is at most ${valueMax} characters.`,
+            });
+        }
+        if (/[\n\r]/.test(value)) {
+            fields.push({ field: `values.${name}`, message: "A value is a single line." });
+        }
+    }
+}
+function blank(value) {
+    return value === undefined || value.trim() === "";
+}
+function chosen(choice) {
+    return choice !== undefined && choice.provider.trim() !== "" && choice.model.trim() !== "";
+}