@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/slices/play-drafts/start.js

@@ -0,0 +1,148 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { startRun } from "../admission/start.js";
+import { enqueueBatch, pumpQueue } from "../batch/index.js";
+import { admitReviewedCheckpoints } from "../rebuild/runtime-checkpoints.js";
+import { releaseStagedFile } from "../storage/staging-refs.js";
+import { checkDraftReadiness, localDraftReadiness } from "./readiness.js";
+import { attachmentRows, draftRow } from "./repo.js";
+import { readDraft } from "./service.js";
+import { executionSchema, insertStartReceipt, markDraftStartedAndReleaseRefs, readStartReceipt, releaseStartClaim, replayResult, requireStartingIdentity, } from "./start-repo.js";
+const inputSchema = z
+    .object({ draftId: z.uuid(), baseVersion: z.number().int().positive(), reviewId: z.uuid() })
+    .strict();
+export async function startPlayDraft(deps, input) {
+    const parsed = inputSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-edit", currentVersion: null, fields: [] };
+    input = parsed.data;
+    const claimed = transact(deps.db, () => {
+        const receipt = readStartReceipt(deps.db, input.reviewId);
+        if (receipt)
+            return replayResult(receipt, input);
+        const row = draftRow(deps.db, input.draftId);
+        if (!row)
+            return { ok: false, reason: "not-found", currentVersion: null, fields: [] };
+        const view = readDraft(deps, input.draftId);
+        if (!view.ok)
+            return view;
+        if (row.state === "started")
+            return {
+                ok: false,
+                reason: "already-started",
+                currentVersion: row.version,
+                fields: [],
+            };
+        if (row.state === "starting" && row.start_id !== input.reviewId)
+            return {
+                ok: false,
+                reason: "pending-start",
+                currentVersion: row.version,
+                reviewId: row.start_id ?? input.reviewId,
+                fields: [],
+            };
+        if (row.version !== input.baseVersion || view.value.review?.id !== input.reviewId)
+            return {
+                ok: false,
+                reason: "stale-review",
+                currentVersion: row.version,
+                fields: [],
+            };
+        if (row.state === "active") {
+            deps.db
+                .prepare("UPDATE play_drafts SET state='starting',start_id=? WHERE id=? AND version=? AND state='active'")
+                .run(input.reviewId, input.draftId, input.baseVersion);
+        }
+        return { ok: true, value: view.value.review };
+    });
+    if (!claimed.ok) {
+        releaseStartClaim(deps, input, claimed.reason === "stale-review");
+        return claimed;
+    }
+    if ("requestId" in claimed.value)
+        return { ok: true, value: claimed.value };
+    const identity = requireStartingIdentity(deps, input);
+    if (!identity.ok) {
+        releaseStartClaim(deps, input, identity.reason === "stale-review");
+        return identity;
+    }
+    const row = draftRow(deps.db, input.draftId);
+    if (row?.review_json == null)
+        throw new Error("Pending Start lost its review");
+    const { catalogue } = executionSchema.parse(JSON.parse(row.review_json)).execution;
+    const captured = {
+        ...deps,
+        catalogue: {
+            ...deps.catalogue,
+            read: () => catalogue,
+            models: (provider, family) => catalogue[family].filter((m) => m.provider === provider && m.enabled && !m.deprecated),
+        },
+    };
+    const checked = await checkDraftReadiness(captured, claimed.value.runs);
+    const oldFiles = attachmentRows(deps.db, input.draftId).flatMap((a) => a.staged_file_id === null ? [] : [a.staged_file_id]);
+    const result = transact(deps.db, () => {
+        const receipt = readStartReceipt(deps.db, input.reviewId);
+        if (receipt)
+            return replayResult(receipt, input);
+        const starting = requireStartingIdentity(deps, input);
+        if (!starting.ok)
+            return starting;
+        const fields = [
+            ...checked.fields,
+            ...localDraftReadiness(captured, starting.value.runs, checked.providers),
+        ];
+        if (fields.length)
+            return { ok: false, reason: "readiness", currentVersion: input.baseVersion, fields };
+        const runs = starting.value.runs;
+        const first = runs[0];
+        if (!first)
+            throw new Error("Reviewed run list was empty");
+        const queue = runs.length === 1 ? [] : enqueueBatch(captured, input.reviewId, runs, true);
+        const projectIds = runs.length === 1
+            ? [startRun(captured, first.draft, first.rendered, true, first.templates).project.id]
+            : queue.map((e) => e.projectId);
+        const checkpointSet = admitReviewedCheckpoints(captured, projectIds, starting.value.checkpointSet ?? [], catalogue);
+        const value = {
+            requestId: input.reviewId,
+            projectIds,
+            queue,
+            replayed: false,
+            ...(checkpointSet.length ? { checkpointSet } : {}),
+        };
+        insertStartReceipt(deps, input, value);
+        markDraftStartedAndReleaseRefs(deps.db, input);
+        return { ok: true, value };
+    });
+    if (!result.ok) {
+        releaseStartClaim(deps, input, result.reason === "stale-review");
+        return result;
+    }
+    if (!result.value.replayed) {
+        afterCommit(deps, () => deps.recordStarted(result.value.projectIds));
+        for (const id of oldFiles)
+            afterCommit(deps, () => releaseStagedFile(deps, id));
+        afterCommit(deps, () => {
+            if (result.value.queue.length)
+                pumpQueue(deps.db, deps.runner);
+            else
+                for (const id of result.value.projectIds)
+                    deps.runner.tick(id);
+        });
+    }
+    return result;
+}
+function afterCommit(deps, run) {
+    try {
+        run();
+    }
+    catch {
+        try {
+            deps.log.write("warn", "play.start.after-commit", {
+                detail: "Start committed; a post-commit action failed.",
+            });
+        }
+        catch {
+            /* The durable receipt remains authoritative even if logging fails. */
+        }
+    }
+}

package/dist/slices/play-drafts/uploads.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { stageUpload } from "../storage/staging.js";
+import { releaseStagedFile } from "../storage/staging-refs.js";
+import { attachmentRow, draftRow } from "./repo.js";
+import { draftAttachmentSchema } from "./schema.js";
+export async function uploadDraftAttachment(deps, input) {
+    const row = z.uuid().safeParse(input.draftId).success
+        ? draftRow(deps.db, input.draftId)
+        : undefined;
+    const refuse = (reason) => ({
+        ok: false,
+        reason,
+        currentVersion: row?.version ?? null,
+        fields: [],
+        ...(row?.state === "starting" && row.review_id !== null ? { reviewId: row.review_id } : {}),
+    });
+    if (!z.uuid().safeParse(input.draftId).success || !z.uuid().safeParse(input.attachmentId).success)
+        return refuse("invalid-edit");
+    if (row === undefined)
+        return refuse("not-found");
+    if (row.state === "starting")
+        return refuse("pending-start");
+    if (row.state === "started")
+        return refuse("already-started");
+    const attachment = attachmentRow(deps.db, input.attachmentId);
+    if (attachment === undefined || attachment.draft_id !== input.draftId)
+        return refuse("not-found");
+    if (attachment.staged_file_id !== null || attachment.status !== "pending")
+        return refuse("conflict");
+    const storage = { ...deps, emit: () => undefined };
+    const result = await stageUpload(storage, {
+        stageKind: attachment.kind,
+        originalFilename: attachment.original_filename,
+        content: input.content,
+        onAllocated(file) {
+            const bound = deps.db
+                .prepare("UPDATE play_draft_attachments SET staged_file_id=?,error=NULL WHERE id=? AND draft_id=? AND staged_file_id IS NULL AND status='pending' AND EXISTS (SELECT 1 FROM play_drafts WHERE id=? AND state='active')")
+                .run(file.id, input.attachmentId, input.draftId, input.draftId);
+            if (Number(bound.changes) !== 1)
+                throw new Error("Upload attachment changed before allocation.");
+        },
+    });
+    if (!result.ok) {
+        deps.db
+            .prepare("UPDATE play_draft_attachments SET status='reattach',error=? WHERE id=? AND draft_id=? AND staged_file_id IS NULL")
+            .run("Upload failed. Reattach the file.", input.attachmentId, input.draftId);
+        return refuse("invalid-edit");
+    }
+    const updated = deps.db
+        .prepare("UPDATE play_draft_attachments SET status='ready',error=NULL WHERE id=? AND draft_id=? AND staged_file_id=?")
+        .run(input.attachmentId, input.draftId, result.file.id);
+    releaseStagedFile(storage, result.file.id);
+    if (Number(updated.changes) !== 1)
+        return refuse("not-found");
+    return {
+        ok: true,
+        value: draftAttachmentSchema.parse({
+            id: attachment.id,
+            kind: attachment.kind,
+            name: attachment.original_filename,
+            state: "ready",
+            stagedFileId: result.file.id,
+            bytes: result.file.bytes,
+            error: null,
+        }),
+    };
+}

package/dist/slices/project-templates/from-project.js

@@ -0,0 +1,159 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { projectById } from "../admission/repo.js";
+import { detectSlots } from "../admission/substitute.js";
+import { listCheckpoints } from "../checkpoints/repo.js";
+import { requestHash } from "../play-drafts/repo.js";
+import { currentRevisionId, revisionById } from "../revisions/repo.js";
+import { createTemplate, readTemplate } from "./service.js";
+export const projectTemplateCreateSchema = z
+    .object({
+    id: z.uuid(),
+    name: z.string().trim().min(1).max(200),
+    projectId: z.string().min(1).max(64),
+    revisionId: z.string().min(1).max(64),
+})
+    .strict()
+    .readonly();
+export const templateFromProjectSchema = projectTemplateCreateSchema;
+export function createTemplateFromProject(deps, input) {
+    const parsed = projectTemplateCreateSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    return transact(deps.db, () => {
+        const hash = requestHash({ operation: "template-from-project", ...parsed.data });
+        const old = deps.db
+            .prepare("SELECT creation_hash FROM project_templates WHERE id=?")
+            .get(parsed.data.id);
+        if (old)
+            return old.creation_hash === hash
+                ? readTemplate(deps, parsed.data.id, 1)
+                : { ok: false, reason: "conflict" };
+        const project = projectById(deps.db, parsed.data.projectId);
+        if (project === undefined)
+            return { ok: false, reason: "not-found" };
+        const current = currentRevisionId(deps.db, project.id);
+        if (current === undefined || current !== parsed.data.revisionId)
+            return { ok: false, reason: "conflict" };
+        const revision = revisionById(deps.db, project.id, current);
+        if (revision === undefined)
+            return { ok: false, reason: "conflict" };
+        if (revision.config.sources.images === "generate" &&
+            revision.content.imageOrder.some((key) => revision.content.imageDefinitions[key]?.source === "provide"))
+            return { ok: false, reason: "invalid-input" };
+        const result = createTemplate(deps, {
+            id: parsed.data.id,
+            name: parsed.data.name,
+            document: documentFromProject(deps, revision),
+        });
+        if (result.ok)
+            deps.db
+                .prepare("UPDATE project_templates SET creation_hash=? WHERE id=?")
+                .run(hash, parsed.data.id);
+        return result;
+    });
+}
+function documentFromProject(deps, revision) {
+    const config = revision.config;
+    const prompts = [];
+    const entries = [];
+    const addPrompt = (kind, name, key, literal) => {
+        if (!name)
+            return;
+        const body = literal ?? revision.content.promptTemplates[key] ?? config.rendered[key];
+        if (body === null || body === undefined)
+            return;
+        prompts.push({
+            id: deps.uuid(),
+            kind,
+            name,
+            body,
+            slots: [...detectSlots(body).names],
+            updatedAt: revision.createdAt,
+        });
+    };
+    addPrompt("article", config.articlePrompt, "article");
+    const definitions = revision.content.imageOrder.flatMap((key) => {
+        const definition = revision.content.imageDefinitions[key];
+        return definition === undefined ? [] : [definition];
+    });
+    const imagePrompts = config.sources.images === "generate" && definitions.length > 0
+        ? definitions.map((definition, index) => {
+            const key = definition.templateKey ?? "";
+            const original = revision.content.promptTemplates[key];
+            const body = original && definition.prompt === config.rendered[key]
+                ? original
+                : (definition.prompt ?? original ?? "");
+            const name = `Project image ${index + 1}`;
+            addPrompt("image", name, key, body);
+            return { name, number: "1" };
+        })
+        : config.imagePrompts.map((prompt, index) => {
+            addPrompt("image", prompt.name, `imagePrompts.${index}`);
+            return { name: prompt.name, number: String(prompt.number) };
+        });
+    addPrompt("thumbnail", config.thumbnailPrompt, "thumbnailPrompt");
+    for (const category of ["intro", "outro"]) {
+        const choice = config[category];
+        const body = revision.content.promptTemplates[category] ?? config.rendered[category];
+        if (choice !== undefined && body !== null && body !== undefined)
+            entries.push({
+                id: deps.uuid(),
+                category,
+                mode: choice.mode,
+                name: choice.name,
+                body,
+                slots: [...detectSlots(body).names],
+                updatedAt: revision.createdAt,
+            });
+    }
+    const attachment = (name) => ({ attachmentId: deps.uuid(), name });
+    const provided = {
+        research: config.sources.research === "provide" ? (config.provided.research ?? "") : "",
+        article: config.sources.article === "provide"
+            ? (revision.content.articleMarkdown ?? config.provided.article ?? "")
+            : "",
+        audio: config.sources.audio === "provide" ? attachment("Audio from project") : null,
+        thumbnail: config.sources.thumbnail === "provide" ? attachment("Thumbnail from project") : null,
+        images: config.sources.images === "provide"
+            ? (definitions.length ? definitions : (config.provided.images ?? [])).map((_, index) => attachment(`Image ${index + 1}`))
+            : [],
+    };
+    return {
+        schemaVersion: 1,
+        librarySnapshot: { prompts, entries },
+        form: {
+            title: config.title,
+            format: config.format,
+            sources: config.sources,
+            checkpoints: listCheckpoints(deps.db, revision.projectId, revision.id).map((gate) => gate.stage),
+            llm: config.llm ?? { provider: "", model: "" },
+            audio: config.audio ?? { provider: "", model: "", voice: "" },
+            images: config.images ?? { provider: "", model: "" },
+            articlePrompt: config.articlePrompt ?? "",
+            imagePrompts,
+            thumbnailPrompt: config.thumbnailPrompt ?? "",
+            intro: config.intro?.name ?? "",
+            outro: config.outro?.name ?? "",
+            chunking: {
+                mode: config.chunking?.mode ?? "whole",
+                words: config.chunking?.words === undefined ? "500" : String(config.chunking.words),
+                characters: config.chunking?.characters === undefined ? "3000" : String(config.chunking.characters),
+            },
+            subtitles: {
+                mode: config.subtitles?.mode ?? "off",
+                language: "en",
+                fontId: config.subtitles?.fontId ?? "default",
+                fontSize: config.subtitles?.fontSize === undefined ? "48" : String(config.subtitles.fontSize),
+                position: config.subtitles?.position ?? "bottom",
+            },
+            values: config.values,
+            provided,
+        },
+        section: "content",
+        variants: [],
+        expectedWords: "1500",
+        previewText: "Every story begins with a word.",
+        fontUpload: null,
+    };
+}

package/dist/slices/project-templates/model.js

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

package/dist/slices/project-templates/repo.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { projectTemplateSchema } from "./schema.js";
+const select = `SELECT t.id,r.version,r.name,t.created_at AS createdAt,r.created_at AS updatedAt,r.document_json AS document FROM project_templates t JOIN project_template_revisions r ON r.template_id=t.id`;
+const templateSummarySchema = z
+    .object({
+    id: z.uuid(),
+    name: z.string(),
+    version: z.number().int().positive(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+})
+    .strict()
+    .readonly();
+export function templateById(db, id, version) {
+    const row = db
+        .prepare(`${select} WHERE t.id=? AND r.version=${version === undefined ? "t.head_version" : "?"}`)
+        .get(...(version === undefined ? [id] : [id, version]));
+    if (row === undefined)
+        return undefined;
+    if (typeof row.document !== "string")
+        throw new Error("Template document is missing");
+    return projectTemplateSchema.parse({ ...row, document: JSON.parse(row.document) });
+}
+export function templateSummaries(db) {
+    return db
+        .prepare(`${select} WHERE r.version=t.head_version ORDER BY lower(r.name),t.id`)
+        .all()
+        .map((row) => {
+        const parsed = templateSummarySchema.parse({
+            id: row.id,
+            name: row.name,
+            version: row.version,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        });
+        return parsed;
+    });
+}
+export function insertTemplateRevision(db, template) {
+    db.prepare("INSERT INTO project_template_revisions(template_id,version,name,document_json,created_at) VALUES (?,?,?,?,?)").run(template.id, template.version, template.name, JSON.stringify(template.document), template.updatedAt);
+}

package/dist/slices/project-templates/schema.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { playDraftDocumentSchema } from "../play-drafts/schema.js";
+export const templateCreateSchema = z
+    .object({
+    id: z.uuid(),
+    name: z.string().trim().min(1).max(200),
+    document: playDraftDocumentSchema,
+})
+    .strict()
+    .readonly();
+export const templateUpdateSchema = templateCreateSchema
+    .unwrap()
+    .extend({
+    baseVersion: z.number().int().positive(),
+    mutationId: z.uuid(),
+})
+    .strict()
+    .readonly();
+export const templateDeleteSchema = z
+    .object({ id: z.uuid(), baseVersion: z.number().int().positive() })
+    .strict()
+    .readonly();
+export const templateInstantiateSchema = z
+    .object({ templateId: z.uuid(), id: z.uuid(), version: z.number().int().positive() })
+    .strict()
+    .readonly();
+export const projectTemplateSchema = z
+    .object({
+    id: z.uuid(),
+    name: z.string(),
+    version: z.number().int().positive(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    document: playDraftDocumentSchema,
+})
+    .strict()
+    .readonly();

package/dist/slices/project-templates/service.js

@@ -0,0 +1,136 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { requestHash } from "../play-drafts/repo.js";
+import { createDraft, readDraft } from "../play-drafts/service.js";
+import { insertTemplateRevision, templateById, templateSummaries } from "./repo.js";
+import { templateCreateSchema, templateDeleteSchema, templateInstantiateSchema, templateUpdateSchema, } from "./schema.js";
+import { freshTemplateDraft, templateSetup } from "./setup.js";
+export function listTemplates(deps) {
+    return templateSummaries(deps.db);
+}
+export function readTemplate(deps, id, version) {
+    if (!z.uuid().safeParse(id).success ||
+        (version !== undefined && !z.number().int().positive().safeParse(version).success))
+        return { ok: false, reason: "invalid-input" };
+    const value = templateById(deps.db, id, version);
+    return value ? { ok: true, value } : { ok: false, reason: "not-found" };
+}
+export function createTemplate(deps, input) {
+    const parsed = templateCreateSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    return transact(deps.db, () => {
+        const { id, name, document } = parsed.data;
+        const hash = requestHash(parsed.data);
+        const old = deps.db.prepare("SELECT creation_hash FROM project_templates WHERE id=?").get(id);
+        if (old)
+            return old.creation_hash === hash
+                ? readTemplate(deps, id, 1)
+                : { ok: false, reason: "conflict" };
+        const setup = templateSetup(deps, document);
+        if (!setup.ok)
+            return setup;
+        const at = deps.clock.now().toISOString();
+        const value = {
+            id,
+            name,
+            document: setup.value,
+            version: 1,
+            createdAt: at,
+            updatedAt: at,
+        };
+        deps.db
+            .prepare("INSERT INTO project_templates(id,head_version,creation_hash,created_at) VALUES (?,1,?,?)")
+            .run(id, hash, at);
+        insertTemplateRevision(deps.db, value);
+        return { ok: true, value };
+    });
+}
+export function updateTemplate(deps, input) {
+    const parsed = templateUpdateSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    return transact(deps.db, () => {
+        const { id, baseVersion, mutationId, name, document } = parsed.data;
+        const previous = templateById(deps.db, id);
+        if (!previous)
+            return { ok: false, reason: "not-found" };
+        const row = deps.db
+            .prepare("SELECT mutation_id,mutation_hash FROM project_templates WHERE id=?")
+            .get(id);
+        const hash = requestHash(parsed.data);
+        if (row?.mutation_id === mutationId)
+            return row.mutation_hash === hash
+                ? { ok: true, value: previous }
+                : { ok: false, reason: "conflict" };
+        if (previous.version !== baseVersion)
+            return { ok: false, reason: "conflict" };
+        const setup = templateSetup(deps, document);
+        if (!setup.ok)
+            return setup;
+        const value = {
+            ...previous,
+            name,
+            document: setup.value,
+            version: baseVersion + 1,
+            updatedAt: deps.clock.now().toISOString(),
+        };
+        insertTemplateRevision(deps.db, value);
+        deps.db
+            .prepare("UPDATE project_templates SET head_version=?,mutation_id=?,mutation_hash=? WHERE id=? AND head_version=?")
+            .run(value.version, mutationId, hash, id, baseVersion);
+        return { ok: true, value };
+    });
+}
+export function deleteTemplate(deps, input) {
+    const parsed = templateDeleteSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    return transact(deps.db, () => {
+        const previous = templateById(deps.db, parsed.data.id);
+        if (!previous)
+            return { ok: false, reason: "not-found" };
+        if (previous.version !== parsed.data.baseVersion)
+            return { ok: false, reason: "conflict" };
+        if (deps.db
+            .prepare("SELECT 1 FROM schedules WHERE template_id=? AND deleted_at IS NULL LIMIT 1")
+            .get(parsed.data.id))
+            return { ok: false, reason: "referenced-by-schedule" };
+        deps.db.prepare("DELETE FROM project_templates WHERE id=?").run(parsed.data.id);
+        return { ok: true, value: { deleted: true } };
+    });
+}
+export function instantiateTemplate(deps, input) {
+    const parsed = templateInstantiateSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    return transact(deps.db, () => {
+        const { templateId, id, version } = parsed.data;
+        const receipt = deps.db
+            .prepare("SELECT template_id,template_version FROM project_template_instantiations WHERE draft_id=?")
+            .get(id);
+        if (receipt) {
+            if (receipt.template_id !== templateId || receipt.template_version !== version)
+                return { ok: false, reason: "conflict" };
+            const draft = readDraft(deps, id);
+            return draft.ok ? draft : { ok: false, reason: "conflict" };
+        }
+        const template = templateById(deps.db, templateId, version);
+        if (!template)
+            return { ok: false, reason: "not-found" };
+        const result = createDraft(deps, {
+            id,
+            document: freshTemplateDraft(deps, template.document, { id: templateId, version }),
+        });
+        if (!result.ok)
+            return { ok: false, reason: "conflict" };
+        deps.db.prepare("UPDATE play_draft_attachments SET status='reattach' WHERE draft_id=?").run(id);
+        deps.db
+            .prepare("INSERT INTO project_template_instantiations(draft_id,template_id,template_version) VALUES (?,?,?)")
+            .run(id, templateId, version);
+        const draft = readDraft(deps, id);
+        if (!draft.ok)
+            throw new Error("Created template draft could not be read");
+        return draft;
+    });
+}

package/dist/slices/project-templates/setup.js

@@ -0,0 +1,55 @@
+import { snapshotEntry, snapshotPrompt } from "../library/snapshot.js";
+export function templateSetup(deps, input) {
+    const prompts = [];
+    const entries = [];
+    const choices = [
+        { kind: "article", name: input.form.articlePrompt },
+        ...input.form.imagePrompts.map((row) => ({ kind: "image", name: row.name })),
+        { kind: "thumbnail", name: input.form.thumbnailPrompt },
+    ];
+    for (const choice of choices) {
+        if (choice.name === "")
+            continue;
+        const row = snapshotPrompt(deps.db, input.librarySnapshot, choice.kind, choice.name);
+        if (!row)
+            return { ok: false, reason: "missing-prompt" };
+        if (!prompts.some((saved) => saved.kind === row.kind && saved.name === row.name))
+            prompts.push(row);
+    }
+    for (const category of ["intro", "outro"]) {
+        if (input.form[category] === "")
+            continue;
+        const row = snapshotEntry(deps.db, input.librarySnapshot, category, input.form[category]);
+        if (!row)
+            return { ok: false, reason: "missing-prompt" };
+        entries.push(row);
+    }
+    const { templateSource: _source, ...document } = input;
+    return {
+        ok: true,
+        value: { ...document, fontUpload: null, librarySnapshot: { prompts, entries } },
+    };
+}
+export function freshTemplateDraft(deps, document, source) {
+    const provided = document.form.provided;
+    const fresh = (file) => ({
+        attachmentId: deps.uuid(),
+        name: file.name,
+    });
+    return {
+        ...document,
+        section: "content",
+        fontUpload: null,
+        templateSource: source,
+        variants: document.variants.map((variant) => ({ ...variant, id: deps.uuid() })),
+        form: {
+            ...document.form,
+            provided: {
+                ...provided,
+                audio: provided.audio === null ? null : fresh(provided.audio),
+                thumbnail: provided.thumbnail === null ? null : fresh(provided.thumbnail),
+                images: provided.images.map(fresh),
+            },
+        },
+    };
+}