@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/slices/control/index.js

@@ -1,12 +1,20 @@
+import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { derive, satisfied } from "../../kernel/runner/graph.js";
 import { finishStage, projectById, resetStage, setProjectPaused, stagesOf, updateProjectConfig, } from "../admission/repo.js";
+import { listCheckpoints } from "../checkpoints/repo.js";
 import { sameChunking } from "../narration/chunk.js";
+import { projectStandings } from "../rebuild/runtime-store.js";
 import { clearUnfinishedAudio } from "../reruns/index.js";
+import { adoptBaseline } from "../revisions/adopt.js";
+import { saveRevision } from "../revisions/mutations.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
 import { providers as providerCatalog } from "../settings/model.js";
 import { hasKey, listVoices } from "../settings/repo.js";
 import { withProjectControl } from "./lock.js";
 import { validateLocalProviderChanges, validateProviderChanges } from "./providers.js";
+import { checkRevisionControl, rememberRevisionControl, } from "./revision-control.js";
 export const providerCheckTimeoutMs = 15_000;
 async function providerFields(deps, changes) {
     let timeout;
@@ -38,33 +46,63 @@ function changed(deps, id, wake = false) {
             state: derive(stagesOf(deps.db, id), projectById(deps.db, id)?.paused),
         });
 }
-export function pauseProject(deps, id) {
+export function pauseProject(deps, id, input) {
     return withProjectControl(deps.db, id, async () => {
-        const project = projectById(deps.db, id);
-        if (project === undefined)
-            return { ok: false, reason: "no-project" };
-        const before = stagesOf(deps.db, id);
-        if (before.every((stage) => satisfied(stage.state)))
-            return { ok: true };
-        const running = before.filter((stage) => stage.state === "running").map((stage) => stage.id);
-        if (project.paused === true && running.length === 0 && !deps.runner.hasInflight?.(id))
-            return { ok: true };
-        transact(deps.db, () => setProjectPaused(deps.db, id, true, deps.clock.now().toISOString()));
-        deps.emit(id, { type: "project.updated", projectId: id });
-        await deps.runner.abortProject(id, "pause");
-        // Covers a failed final row write and runners that report interruption as canceled.
-        for (const stage of stagesOf(deps.db, id)) {
-            if (running.includes(stage.id) && (stage.state === "running" || stage.state === "canceled")) {
-                finishStage(deps.db, stage.id, "pending", null, deps.clock.now().toISOString());
-                deps.emit(id, { type: "stage.state", projectId: id, stage: stage.kind, state: "pending" });
-            }
-        }
-        changed(deps, id);
-        return { ok: true };
+        if (deps.catalogue !== undefined)
+            adoptBaseline(deps, id);
+        const checked = checkRevisionControl(deps, id, "pause", input, z.object({ ok: z.literal(true) }));
+        if (!checked.ok)
+            return checked;
+        if (checked.response !== undefined)
+            return checked.response;
+        const result = await pause(deps, id);
+        if (result.ok)
+            rememberRevisionControl(deps, checked.identity, result);
+        return result;
     });
 }
+async function pause(deps, id) {
+    const project = projectById(deps.db, id);
+    if (project === undefined)
+        return { ok: false, reason: "no-project" };
+    const before = stagesOf(deps.db, id);
+    if (before.every((stage) => satisfied(stage.state)))
+        return { ok: true };
+    const running = before.filter((stage) => stage.state === "running").map((stage) => stage.id);
+    if (project.paused === true && running.length === 0 && !deps.runner.hasInflight?.(id))
+        return { ok: true };
+    transact(deps.db, () => setProjectPaused(deps.db, id, true, deps.clock.now().toISOString()));
+    deps.emit(id, { type: "project.updated", projectId: id });
+    await deps.runner.abortProject(id, "pause");
+    // Covers a failed final row write and runners that report interruption as canceled.
+    for (const stage of stagesOf(deps.db, id)) {
+        if (running.includes(stage.id) && (stage.state === "running" || stage.state === "canceled")) {
+            finishStage(deps.db, stage.id, "pending", null, deps.clock.now().toISOString());
+            deps.emit(id, { type: "stage.state", projectId: id, stage: stage.kind, state: "pending" });
+        }
+    }
+    changed(deps, id);
+    return { ok: true };
+}
 export function resumeProject(deps, id) {
     return withProjectControl(deps.db, id, () => {
+        if (deps.catalogue !== undefined)
+            adoptBaseline(deps, id);
+        const revisionId = currentRevisionId(deps.db, id);
+        if (revisionId !== undefined) {
+            const admitted = projectById(deps.db, id)?.paused === true &&
+                deps.db
+                    .prepare(`SELECT 1 FROM revision_work w JOIN revision_work_reservations r ON r.work_id=w.id
+        WHERE r.project_id=? AND r.revision_id=? AND w.state='pending' AND w.dispatch_state='allowed' LIMIT 1`)
+                    .get(id, revisionId) !== undefined;
+            if (listCheckpoints(deps.db, id, revisionId).length === 0 && !admitted)
+                return { ok: false, reason: "rebuild-required" };
+            if (stagesOf(deps.db, id).some((stage) => stage.state === "canceled"))
+                return { ok: false, reason: "rebuild-required" };
+            setProjectPaused(deps.db, id, false, deps.clock.now().toISOString());
+            changed(deps, id, true);
+            return { ok: true };
+        }
         const project = projectById(deps.db, id);
         if (project === undefined)
             return { ok: false, reason: "no-project" };
@@ -134,6 +172,34 @@ export function changeProviders(deps, id, changes) {
         });
         if (localFields.length > 0)
             return { ok: false, reason: "invalid-providers", fields: localFields };
+        if (deps.catalogue !== undefined)
+            adoptBaseline(deps, id);
+        const revisionId = currentRevisionId(deps.db, id);
+        if (revisionId !== undefined) {
+            const view = getRevisionView(deps, id, revisionId);
+            if (view === undefined)
+                return { ok: false, reason: "no-project" };
+            const saved = await saveRevision(deps, {
+                projectId: id,
+                baseRevisionId: revisionId,
+                idempotencyKey: deps.ids.next(),
+                edit: {
+                    config: {
+                        ...view.revision.config,
+                        ...(changes.llm === undefined ? {} : { llm: changes.llm }),
+                        ...(changes.audio === undefined ? {} : { audio: changes.audio }),
+                        ...(changes.images === undefined ? {} : { images: changes.images }),
+                        ...(changes.chunking === undefined ? {} : { chunking: changes.chunking }),
+                    },
+                    content: view.revision.content,
+                },
+            });
+            if (!saved.ok)
+                return { ok: false, reason: "not-editable" };
+            projectStandings(deps, id);
+            deps.emit(id, { type: "project.updated", projectId: id });
+            return { ok: true };
+        }
         const audioChanged = changes.audio !== undefined &&
             (changes.audio.provider !== project.config.audio?.provider ||
                 changes.audio.model !== project.config.audio?.model ||

package/dist/slices/control/providers.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { thinkingModes } from "../../kernel/ports/llm.js";
+import { readinessIsUsable, } from "../../kernel/ports/model.js";
 import { chunkModes } from "../narration/chunk.js";
 const choice = z
     .object({
@@ -36,12 +37,12 @@ export function validateLocalProviderChanges(changes, current) {
             fields.push({ field: key, message: "Choose a provider for this kind of generation." });
             continue;
         }
-        const usable = provider.readiness.kind === "cli" ? provider.readiness.installed : provider.readiness.hasKey;
+        const usable = readinessIsUsable(provider.readiness);
         if (!usable) {
             fields.push({
                 field: key,
                 message: provider.readiness.kind === "cli"
-                    ? "Install and sign in to this CLI first."
+                    ? (provider.readiness.issue ?? "Install and sign in to this CLI first.")
                     : "Save this provider's API key in Settings first.",
             });
         }

package/dist/slices/control/revision-control-schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const revisionControlSchema = z
+    .object({
+    baseRevisionId: z.string().min(1).max(64),
+    idempotencyKey: z.uuid(),
+})
+    .strict();

package/dist/slices/control/revision-control.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { projectExists } from "../admission/repo.js";
+import { requestHash } from "../revisions/mutation-request.js";
+import { currentRevisionId } from "../revisions/repo.js";
+export { revisionControlSchema } from "./revision-control-schema.js";
+import { revisionControlSchema } from "./revision-control-schema.js";
+export function checkRevisionControl(deps, projectId, operation, input, responseSchema) {
+    const { db } = deps;
+    return transact(db, () => {
+        if (!projectExists(db, projectId))
+            return { ok: false, reason: "no-project" };
+        const head = currentRevisionId(db, projectId);
+        if (head === undefined)
+            return { ok: true, identity: null };
+        const parsed = revisionControlSchema.safeParse(input);
+        if (!parsed.success)
+            return { ok: false, reason: "revision-required" };
+        const identity = {
+            ...parsed.data,
+            projectId,
+            operation,
+            hash: requestHash(operation, parsed.data.baseRevisionId, parsed.data),
+        };
+        const row = db
+            .prepare("SELECT operation,request_hash,response_json FROM project_control_receipts WHERE project_id=? AND idempotency_key=?")
+            .get(projectId, identity.idempotencyKey);
+        if (row !== undefined) {
+            if (row.operation !== operation || row.request_hash !== identity.hash)
+                return { ok: false, reason: "idempotency-conflict" };
+            const response = JSON.parse(String(row.response_json));
+            if (z
+                .object({ pending: z.literal(true) })
+                .strict()
+                .safeParse(response).success)
+                return head === identity.baseRevisionId
+                    ? { ok: true, identity }
+                    : { ok: false, reason: "conflict" };
+            return { ok: true, identity: null, response: responseSchema.parse(response) };
+        }
+        if (db
+            .prepare("SELECT 1 FROM revision_mutations WHERE project_id=? AND idempotency_key=? UNION ALL SELECT 1 FROM rebuild_admissions WHERE project_id=? AND idempotency_key=?")
+            .get(projectId, identity.idempotencyKey, projectId, identity.idempotencyKey) !== undefined)
+            return { ok: false, reason: "idempotency-conflict" };
+        if (head !== identity.baseRevisionId)
+            return { ok: false, reason: "conflict" };
+        db.prepare("INSERT INTO project_control_receipts(project_id,idempotency_key,operation,request_hash,base_revision_id,response_json,created_at) VALUES (?,?,?,?,?,?,?)").run(identity.projectId, identity.idempotencyKey, identity.operation, identity.hash, identity.baseRevisionId, JSON.stringify({ pending: true }), deps.clock.now().toISOString());
+        return { ok: true, identity };
+    });
+}
+export function rememberRevisionControl(deps, identity, response) {
+    if (identity === null)
+        return;
+    const changed = deps.db
+        .prepare("UPDATE project_control_receipts SET response_json=? WHERE project_id=? AND idempotency_key=? AND operation=? AND request_hash=?")
+        .run(JSON.stringify(response), identity.projectId, identity.idempotencyKey, identity.operation, identity.hash);
+    if (changed.changes !== 1)
+        throw new Error("The control request lost its receipt.");
+}

package/dist/slices/estimate/index.js

@@ -1,81 +1,99 @@
+import { z } from "zod";
+import { estimateRequests, groupEstimateRows } from "./requests.js";
+export { estimateRequests } from "./requests.js";
 export function estimateRun(draft, rendered, expectedWords, catalogue) {
-    const rows = [];
-    const model = (family, choice) => choice
-        ? catalogue?.models(choice.provider, family).find((m) => m.id === choice.model)
-        : undefined;
-    const llm = model("llm", draft.llm);
-    const tts = model("tts", draft.audio);
-    const image = model("image", draft.images);
+    z.number().finite().nonnegative().parse(expectedWords);
+    const data = catalogue?.read() ?? {
+        schemaVersion: 1,
+        updatedAt: "",
+        providers: {},
+        llm: [],
+        tts: [],
+        image: [],
+    };
+    const requests = [];
+    const llm = draft.llm ?? { provider: "", model: "" };
+    const tts = draft.audio ?? { provider: "", model: "" };
+    const image = draft.images ?? { provider: "", model: "" };
+    const textNote = data.llm.find((model) => model.provider === llm.provider &&
+        model.id === llm.model &&
+        model.enabled &&
+        !model.deprecated)?.pricing.note ??
+        "CLI subscription or model pricing is unavailable; usage may be billed by your account.";
+    const imageNote = data.image.find((model) => model.provider === image.provider &&
+        model.id === image.model &&
+        model.enabled &&
+        !model.deprecated)?.pricing.note ?? "Model or account pricing is unknown.";
     const generatedArticle = draft.sources.article === "generate";
     const articleChars = generatedArticle ? expectedWords * 6 : (draft.provided.article?.length ?? 0);
     const promptChars = Object.values(rendered).reduce((sum, value) => sum + value.length, 0);
-    const row = (stage, amount, detail, variable = false) => {
-        rows.push({
+    const local = (stage, detail) => {
+        requests.push({ kind: "local", stage, detail });
+    };
+    const text = (stage, inputCharacters, outputCharacters, detail) => {
+        requests.push({
+            kind: "llm",
             stage,
-            low: amount === undefined ? null : amount * (variable ? 0.5 : 1),
-            high: amount === undefined ? null : amount * (variable ? 1.5 : 1),
-            detail,
+            provider: llm.provider,
+            model: llm.model,
+            inputCharacters,
+            outputCharacters,
+            detail: detail === undefined ? textNote : `${detail} ${textNote}`,
         });
     };
-    const textCost = (input, output) => {
-        const p = llm?.pricing;
-        return p?.inputPerMillionTokens === undefined || p.outputPerMillionTokens === undefined
-            ? undefined
-            : ((input / 4) * p.inputPerMillionTokens + (output / 4) * p.outputPerMillionTokens) / 1000000;
-    };
-    const textNote = llm?.pricing.note ??
-        "CLI subscription or model pricing is unavailable; usage may be billed by your account.";
     if (draft.sources.research === "generate")
-        row("Research", textCost(promptChars + 6000, 12000), `Assumes about 2,000 words of notes; web search fees are excluded. ${textNote}`, true);
+        text("Research", promptChars + 6000, 12000, "Assumes about 2,000 words of notes; web search fees are excluded.");
     else
-        row("Research", 0, "Provided or off; no generation charge.");
+        local("Research", "Provided or off; no generation charge.");
     if (generatedArticle)
-        row("Article", textCost(promptChars + (draft.sources.research === "generate" ? 12000 : 0), articleChars), `${expectedWords.toLocaleString()} expected words. ${textNote}`, true);
+        text("Article", promptChars + (draft.sources.research === "generate" ? 12000 : 0), articleChars, `${expectedWords.toLocaleString()} expected words.`);
     else
-        row("Article", 0, "Provided article; no generation charge.");
+        local("Article", "Provided article; no generation charge.");
     if (draft.intro?.mode === "llm" || draft.outro?.mode === "llm")
-        row("Intro / outro text", textCost(promptChars + articleChars, 2400), textNote, true);
+        text("Intro / outro text", promptChars + articleChars, 2400);
     if (draft.sources.audio === "generate") {
         const extras = ["intro", "outro"].reduce((n, key) => n + (rendered[key]?.length ?? 0), 0);
         const llmExtras = (draft.intro?.mode === "llm" ? 1200 : 0) + (draft.outro?.mode === "llm" ? 1200 : 0);
-        const chars = articleChars + extras + llmExtras;
-        const p = tts?.pricing;
-        const amount = p?.perMillionCharacters === undefined
-            ? p?.perMinute === undefined
-                ? undefined
-                : (chars / 6 / 150) * p.perMinute
-            : (chars / 1000000) * p.perMillionCharacters;
-        row("Narration", amount, `About ${chars.toLocaleString()} characters. ${p?.note ?? "Account pricing is unknown."}`, generatedArticle || llmExtras > 0 || p?.perMinute !== undefined);
+        const choice = { stage: "Narration", provider: tts.provider, model: tts.model };
+        requests.push(generatedArticle || llmExtras > 0
+            ? { ...choice, kind: "tts-estimate", characters: articleChars + extras + llmExtras }
+            : {
+                ...choice,
+                kind: "tts",
+                text: (draft.provided.article ?? "") + (rendered.intro ?? "") + (rendered.outro ?? ""),
+            });
     }
     else
-        row("Narration", 0, "Provided or off; no generation charge.");
-    const images = draft.sources.images === "generate" ? draft.imagePrompts.reduce((n, p) => n + p.number, 0) : 0;
-    row("Images", images === 0
-        ? 0
-        : image?.pricing.perImage === undefined
-            ? undefined
-            : images * image.pricing.perImage, images === 0
-        ? "Provided or off."
-        : `${images} images. ${image?.pricing.note ?? "Model or account pricing is unknown."}`);
-    const thumbnail = ["from_prompt", "prompt_by_llm"].includes(draft.sources.thumbnail);
-    row("Thumbnail", thumbnail ? image?.pricing.perImage : 0, thumbnail
-        ? (image?.pricing.note ?? "Model or account pricing is unknown.")
-        : "Provided or off.");
+        local("Narration", "Provided or off; no generation charge.");
+    const images = draft.sources.images === "generate"
+        ? draft.imagePrompts.reduce((n, prompt) => n + prompt.number, 0)
+        : 0;
+    z.number().int().nonnegative().parse(images);
+    for (let index = 0; index < images; index++)
+        requests.push({
+            kind: "image",
+            stage: "Images",
+            provider: image.provider,
+            model: image.model,
+            detail: `${images} images. ${imageNote}`,
+        });
+    if (images === 0)
+        local("Images", "Provided or off.");
+    if (["from_prompt", "prompt_by_llm"].includes(draft.sources.thumbnail))
+        requests.push({
+            kind: "image",
+            stage: "Thumbnail",
+            provider: image.provider,
+            model: image.model,
+        });
+    else
+        local("Thumbnail", "Provided or off.");
     if (draft.sources.thumbnail === "prompt_by_llm")
-        row("Thumbnail prompt", textCost(promptChars + articleChars, 1200), textNote, true);
-    row("Export / subtitles", 0, "Local processing; no API fee.");
+        text("Thumbnail prompt", promptChars + articleChars, 1200);
+    local("Export / subtitles", "Local processing; no API fee.");
     return {
-        currency: "USD",
-        rows,
+        ...groupEstimateRows(estimateRequests(requests, data)),
         expectedWords,
-        catalogueDate: catalogue?.status().updatedAt ?? null,
-        low: rows.reduce((n, r) => n + (r.low ?? 0), 0),
-        high: rows.reduce((n, r) => n + (r.high ?? 0), 0),
-        unknown: rows.filter((r) => r.low === null).length,
-        assumptions: [
-            "Planning estimate, not a spending limit. Generated lengths use a ±50% range; actual output can exceed it.",
-            "Assumes roughly 6 characters per word, 4 characters per token, and 150 spoken words per minute.",
-            "Retries, extra reasoning tokens, web tools, taxes, discounts and included credits are excluded. Unknown charges are not counted as zero.",
-        ],
+        catalogueDate: catalogue === undefined ? null : data.updatedAt,
     };
 }

package/dist/slices/estimate/requests.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+const quantity = z.number().finite().nonnegative();
+const common = z.object({
+    stage: z.string(),
+    detail: z.string().optional(),
+    variable: z.boolean().optional(),
+    expectedWords: quantity.optional(),
+});
+const provider = common.extend({ provider: z.string(), model: z.string() });
+const requestSchema = z.discriminatedUnion("kind", [
+    provider
+        .extend({ kind: z.literal("llm"), inputCharacters: quantity, outputCharacters: quantity })
+        .strict(),
+    provider.extend({ kind: z.literal("tts"), text: z.string() }).strict(),
+    provider.extend({ kind: z.literal("tts-estimate"), characters: quantity }).strict(),
+    provider.extend({ kind: z.literal("image") }).strict(),
+    common.extend({ kind: z.literal("local") }).strict(),
+]);
+export function estimateRequests(requests, catalogue) {
+    const parsed = z.array(requestSchema).parse(requests);
+    const rows = parsed.map((request) => price(request, catalogue));
+    return {
+        currency: "USD",
+        rows,
+        low: rows.reduce((total, row) => total + (row.low ?? 0), 0),
+        high: rows.reduce((total, row) => total + (row.high ?? 0), 0),
+        unknown: rows.filter((row) => row.low === null).length,
+        expectedWords: parsed.reduce((total, request) => total + (request.expectedWords ?? 0), 0),
+        catalogueDate: catalogue.updatedAt,
+        assumptions: [
+            "Planning estimate, not a spending limit. Generated lengths use a ±50% range; actual output can exceed it.",
+            "Assumes roughly 6 characters per word, 4 characters per token, and 150 spoken words per minute.",
+            "Retries, extra reasoning tokens, web tools, taxes, discounts and included credits are excluded. Unknown charges are not counted as zero.",
+        ],
+    };
+}
+export function groupEstimateRows(estimate) {
+    const grouped = new Map();
+    for (const row of estimate.rows) {
+        const previous = grouped.get(row.stage);
+        grouped.set(row.stage, previous === undefined
+            ? row
+            : {
+                ...previous,
+                low: previous.low === null || row.low === null ? null : previous.low + row.low,
+                high: previous.high === null || row.high === null ? null : previous.high + row.high,
+            });
+    }
+    const rows = [...grouped.values()];
+    return { ...estimate, rows, unknown: rows.filter((row) => row.low === null).length };
+}
+function price(request, catalogue) {
+    if (request.kind === "local")
+        return {
+            stage: request.stage,
+            low: 0,
+            high: 0,
+            detail: request.detail ?? "Local processing or retained output; no API fee.",
+        };
+    const family = request.kind === "tts-estimate" ? "tts" : request.kind;
+    const model = catalogue[family].find((entry) => entry.provider === request.provider &&
+        entry.id === request.model &&
+        entry.enabled &&
+        !entry.deprecated);
+    const rates = model?.pricing;
+    let amount;
+    let variable = request.variable === true;
+    let detail = rates?.note ?? "Model or account pricing is unknown.";
+    switch (request.kind) {
+        case "llm":
+            if (rates?.inputPerMillionTokens !== undefined && rates.outputPerMillionTokens !== undefined)
+                amount =
+                    ((request.inputCharacters / 4) * rates.inputPerMillionTokens +
+                        (request.outputCharacters / 4) * rates.outputPerMillionTokens) /
+                        1000000;
+            variable = true;
+            break;
+        case "tts":
+        case "tts-estimate": {
+            const characters = request.kind === "tts" ? request.text.length : request.characters;
+            const perMinute = rates?.perMillionCharacters === undefined && rates?.perMinute !== undefined;
+            if (rates?.perMillionCharacters !== undefined)
+                amount = (characters / 1000000) * rates.perMillionCharacters;
+            else if (rates?.perMinute !== undefined)
+                amount = (characters / 6 / 150) * rates.perMinute;
+            variable ||= request.kind === "tts-estimate" || perMinute;
+            detail = `About ${characters.toLocaleString()} characters. ${detail}`;
+            break;
+        }
+        case "image":
+            amount = rates?.perImage;
+            break;
+    }
+    if (amount !== undefined)
+        quantity.parse(amount);
+    return {
+        stage: request.stage,
+        low: amount === undefined ? null : amount * (variable ? 0.5 : 1),
+        high: amount === undefined ? null : amount * (variable ? 1.5 : 1),
+        detail: request.detail ?? detail,
+    };
+}

package/dist/slices/images/run.js

@@ -38,7 +38,10 @@ export async function runImages(deps, context, providers) {
     }
     // The run's own frame. The adapter turns it into whatever its provider spells the
     // closest supported size, and the render crops whatever is left over.
-    const made = await sendAll(deps, context, providers, choice, pieces, project.format);
+    const result = await sendAll(deps, context, providers, choice, pieces, project.format);
+    if (!result.ok)
+        return "held";
+    const made = result.value;
     // Images made means images stored, and only the ones this run stored: a resume does not
     // count an image the previous run made, and a regenerated image counts again.
     //
@@ -56,6 +59,7 @@ export async function runImages(deps, context, providers) {
         stage: "images",
         detail: `${String(pieces.length)} images from ${String(project.config.imagePrompts.length)} prompts`,
     });
+    return "done";
 }
 // For each ticked image prompt, its rendered text is sent Number times as independent
 // parallel calls. The plan is made once and kept, so a retry finds the rows the first run
@@ -117,12 +121,17 @@ async function sendAll(deps, context, providers, choice, pieces, format) {
         }
         setPiece(deps.db, piece.id, "running", piece.payload);
         try {
-            const made = await providers.forPiece(piece.id).image({
+            const result = await providers.forPiece(piece.id).image({
                 provider: choice.provider,
                 model: choice.model,
                 prompt: asked.prompt,
                 aspect: format,
             });
+            if (!result.ok) {
+                setPiece(deps.db, piece.id, "pending", piece.payload);
+                return result;
+            }
+            const made = result.value;
             const file = keep(deps, projectId, piece.idx, made);
             // The prompt text, the prompt name, the index within the prompt, the
             // provider and the model travel with the image.
@@ -146,11 +155,13 @@ async function sendAll(deps, context, providers, choice, pieces, format) {
     let made = 0;
     for (const outcome of outcomes) {
         if (!outcome.ok) {
+            if ("reason" in outcome)
+                return outcome;
             throw outcome.error;
         }
         made += outcome.made ? 1 : 0;
     }
-    return made;
+    return { ok: true, value: made };
 }
 // An image counts as landed only when its row and its file are both still there: they are
 // written one after the other, the boot reconcile can remove a file whose row survived,

package/dist/slices/library/slots.js

@@ -4,8 +4,8 @@
 // is the one that runs.
 import { normaliseDraft } from "../admission/rules.js";
 import { collectFields, render } from "../admission/substitute.js";
-import { entryByName, promptByName } from "./repo.js";
-export function pickTemplates(db, input) {
+import { snapshotEntry, snapshotPrompt } from "./snapshot.js";
+export function pickTemplates(db, input, snapshot) {
     const draft = normaliseDraft(input);
     const { sources } = draft;
     const missing = [];
@@ -14,22 +14,22 @@ export function pickTemplates(db, input) {
     const text = [];
     const image = [];
     if (sources.article === "generate") {
-        body(db, "article", draft.articlePrompt, "articlePrompt", missing, text, "article");
+        body(db, "article", draft.articlePrompt, "articlePrompt", missing, text, "article", snapshot);
     }
-    const intro = pickEntry(db, "intro", draft.intro, missing);
-    const outro = pickEntry(db, "outro", draft.outro, missing);
+    const intro = pickEntry(db, "intro", draft.intro, missing, snapshot);
+    const outro = pickEntry(db, "outro", draft.outro, missing, snapshot);
     push(text, "intro", intro);
     push(text, "outro", outro);
     if (sources.images === "generate") {
         for (const [index, picked] of draft.imagePrompts.entries()) {
             const field = `imagePrompts.${String(index)}.name`;
-            body(db, "image", picked.name, field, missing, image, `imagePrompts.${String(index)}`);
+            body(db, "image", picked.name, field, missing, image, `imagePrompts.${String(index)}`, snapshot);
         }
     }
     // Both Generate modes read the same thumbnail template; Prompt by LLM sends it as the
     // instruction rather than to the image provider.
     if (sources.thumbnail === "from_prompt" || sources.thumbnail === "prompt_by_llm") {
-        body(db, "thumbnail", draft.thumbnailPrompt, "thumbnailPrompt", missing, image, "thumbnailPrompt");
+        body(db, "thumbnail", draft.thumbnailPrompt, "thumbnailPrompt", missing, image, "thumbnailPrompt", snapshot);
     }
     const fields = collectFields(text.map((picked) => picked.body), image.map((picked) => picked.body));
     return {
@@ -48,24 +48,24 @@ export function renderPicked(picked, values) {
     }
     return rendered;
 }
-function body(db, kind, name, field, missing, into, key) {
+function body(db, kind, name, field, missing, into, key, snapshot) {
     // An unpicked prompt is admission's rule to state ("Pick an article prompt."), so this
     // says nothing about it and the form marks the field once.
     if (name === undefined || name.trim() === "") {
         return;
     }
-    const prompt = promptByName(db, kind, name);
+    const prompt = snapshotPrompt(db, snapshot, kind, name);
     if (prompt === undefined) {
         missing.push({ field, message: `That ${kind} prompt no longer exists; pick another.` });
         return;
     }
     into.push({ key, body: prompt.body });
 }
-function pickEntry(db, category, choice, missing) {
+function pickEntry(db, category, choice, missing, snapshot) {
     if (choice === undefined) {
         return undefined;
     }
-    const entry = entryByName(db, category, choice.name);
+    const entry = snapshotEntry(db, snapshot, category, choice.name);
     if (entry === undefined) {
         missing.push({
             field: category,

package/dist/slices/library/snapshot.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { entryCategories, entryModes, promptKinds } from "./model.js";
+import { entryByName, promptByName } from "./repo.js";
+const base = z.object({
+    id: z.string(),
+    name: z.string(),
+    body: z.string(),
+    slots: z.array(z.string()).readonly(),
+    updatedAt: z.string(),
+});
+export const librarySnapshotSchema = z
+    .object({
+    prompts: z
+        .array(base
+        .extend({ kind: z.enum(promptKinds) })
+        .strict()
+        .readonly())
+        .readonly(),
+    entries: z
+        .array(base
+        .extend({ category: z.enum(entryCategories), mode: z.enum(entryModes) })
+        .strict()
+        .readonly())
+        .readonly(),
+})
+    .strict()
+    .readonly();
+export function snapshotPrompt(db, snapshot, kind, name) {
+    return (snapshot?.prompts.find((row) => row.kind === kind && row.name.toLowerCase() === name.toLowerCase()) ?? promptByName(db, kind, name));
+}
+export function snapshotEntry(db, snapshot, category, name) {
+    return (snapshot?.entries.find((row) => row.category === category && row.name.toLowerCase() === name.toLowerCase()) ?? entryByName(db, category, name));
+}