@gentbajko/slopify 0.8.4 → 1.0.1

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),
+            },
+        },
+    };
+}

package/dist/slices/rebuild/admission-repo.js

@@ -0,0 +1,120 @@
+import { transact } from "../../kernel/db/tx.js";
+import { setProjectPaused } from "../admission/repo.js";
+import { requestHash as hash } from "../revisions/mutation-request.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { rebuildAdmissionSchema, } from "./model.js";
+import { executionSnapshotSchema, planPreview, reviewStillCovers } from "./preview-plan.js";
+import { previewById } from "./repo.js";
+import { insertInvocation } from "./runtime-admission.js";
+import { bindNarrationReuse } from "./runtime-narration-reuse.js";
+import { projectStandings } from "./runtime-store.js";
+export function admissionReceipt(db, projectId, idempotencyKey, requestHash) {
+    const row = db
+        .prepare("SELECT request_hash,response_json FROM rebuild_admissions WHERE project_id=? AND idempotency_key=?")
+        .get(projectId, idempotencyKey);
+    if (row !== undefined)
+        return row.request_hash !== requestHash
+            ? { ok: false, reason: "conflict" }
+            : {
+                ok: true,
+                value: {
+                    ...rebuildAdmissionSchema.parse(JSON.parse(String(row.response_json))),
+                    replayed: true,
+                },
+            };
+    if (db
+        .prepare("SELECT 1 FROM revision_mutations WHERE project_id=? AND idempotency_key=? UNION ALL SELECT 1 FROM project_control_receipts WHERE project_id=? AND idempotency_key=?")
+        .get(projectId, idempotencyKey, projectId, idempotencyKey) !== undefined)
+        return { ok: false, reason: "conflict" };
+    return undefined;
+}
+export function admitPreview(deps, input) {
+    return transact(deps.db, () => {
+        const { preview } = input;
+        const replay = admissionReceipt(deps.db, preview.projectId, input.idempotencyKey, input.requestHash);
+        if (replay !== undefined)
+            return replay;
+        if (currentRevisionId(deps.db, preview.projectId) !== preview.baseRevisionId)
+            return { ok: false, reason: "conflict" };
+        const persisted = previewById(deps.db, preview.projectId, preview.id);
+        const row = deps.db
+            .prepare("SELECT execution_json FROM rebuild_previews WHERE id=? AND project_id=?")
+            .get(preview.id, preview.projectId);
+        if (persisted === undefined ||
+            typeof row?.execution_json !== "string" ||
+            hash("body", "", persisted) !== hash("body", "", preview))
+            return { ok: false, reason: "stale-preview" };
+        const snapshot = executionSnapshotSchema.parse(JSON.parse(row.execution_json));
+        const view = getRevisionView(deps, preview.projectId, preview.baseRevisionId);
+        if (view === undefined)
+            return { ok: false, reason: "no-project" };
+        const fresh = planPreview(deps, view, snapshot.catalogue, preview.selection, preview.id);
+        if (!fresh.ok || !reviewStillCovers(preview, snapshot, fresh.value))
+            return { ok: false, reason: "stale-preview" };
+        const admissionId = deps.ids.next();
+        const workIds = [];
+        for (const recipe of snapshot.recipes) {
+            const disposition = snapshot.dispositions.find((row) => row.key === recipe.key)?.disposition;
+            const existing = deps.db
+                .prepare(`SELECT w.id,w.state,w.recipe_context,r.piece_id,r.fingerprint FROM revision_work_reservations r JOIN revision_work w ON w.id=r.work_id WHERE r.revision_id=? AND r.work_key=?`)
+                .get(view.revision.id, recipe.key);
+            if (disposition === "reuse") {
+                bindNarrationReuse(deps, view, recipe, snapshot.ordinals[recipe.key] ?? 0);
+                continue;
+            }
+            if (existing?.fingerprint === recipe.fingerprint &&
+                typeof existing.recipe_context === "string" &&
+                existing.state !== "done") {
+                workIds.push(String(existing.id));
+                if (existing.state !== "running") {
+                    deps.db
+                        .prepare("UPDATE revision_work SET state='pending',dispatch_state='allowed',failure_reason=NULL WHERE id=?")
+                        .run(String(existing.id));
+                    deps.db
+                        .prepare(`UPDATE revision_work_pieces SET state='pending',dispatch_state='allowed'
+              WHERE work_id=? AND state!='done' AND id IN (
+                SELECT p.id FROM revision_work_pieces p
+                JOIN revision_work_reservations r ON r.piece_id=p.id AND r.work_id=p.work_id
+                  AND r.work_key=p.work_key AND r.fingerprint=p.fingerprint
+                JOIN project_revisions v ON v.id=r.revision_id
+                JOIN json_each(v.fingerprints) f ON f.key=COALESCE(r.logical_key,r.work_key)
+                  AND f.value=COALESCE(r.desired_fingerprint,r.fingerprint)
+                WHERE r.revision_id=? AND (p.id=? OR
+                  (?='article:body' AND p.work_key LIKE 'article:continuation:%'
+                   AND COALESCE(r.logical_key,r.work_key)='article:body'))
+              )`)
+                        .run(String(existing.id), view.revision.id, String(existing.piece_id), recipe.key);
+                }
+                continue;
+            }
+            if (existing?.state === "running")
+                throw new Error("Selected work has a mismatched running reservation.");
+            deps.db
+                .prepare("DELETE FROM revision_work_reservations WHERE revision_id=? AND work_key=?")
+                .run(view.revision.id, recipe.key);
+            const key = recipe.input.kind === "tts" ? `${recipe.input.logicalKey}:1` : recipe.key;
+            const fingerprint = snapshot.anchors[key];
+            if (fingerprint === undefined)
+                throw new Error("Selected work has no reviewed desired anchor.");
+            const work = insertInvocation(deps, view, recipe, snapshot.catalogue, { key, fingerprint }, false, view.revision.id, admissionId);
+            workIds.push(work.workId);
+        }
+        const receipt = {
+            revisionId: view.revision.id,
+            admissionId,
+            workIds: [...new Set(workIds)],
+            replayed: false,
+        };
+        deps.db
+            .prepare("INSERT INTO rebuild_admissions(id,project_id,revision_id,idempotency_key,request_hash,preview_id,response_json,created_at) VALUES (?,?,?,?,?,?,?,?)")
+            .run(admissionId, preview.projectId, view.revision.id, input.idempotencyKey, input.requestHash, preview.id, JSON.stringify(receipt), deps.clock.now().toISOString());
+        for (const review of snapshot.reviews)
+            deps.db
+                .prepare("INSERT INTO revision_provided_reviews(project_id,revision_id,work_key,dependency_fingerprint,admission_id) VALUES (?,?,?,?,?) ON CONFLICT(revision_id,work_key) DO UPDATE SET dependency_fingerprint=excluded.dependency_fingerprint,admission_id=excluded.admission_id")
+                .run(preview.projectId, view.revision.id, review.key, review.fingerprint, admissionId);
+        setProjectPaused(deps.db, preview.projectId, false, deps.clock.now().toISOString());
+        projectStandings(deps, preview.projectId);
+        return { ok: true, value: receipt };
+    });
+}

package/dist/slices/rebuild/dependencies.js

@@ -0,0 +1,33 @@
+export function planDependencies(desired, retained) {
+    return desired.map((recipe) => {
+        const old = retained.find((one) => one.key === recipe.key &&
+            one.fingerprint === recipe.fingerprint &&
+            (one.available || one.inflight));
+        const changedProvided = recipe.kind === "provided" &&
+            retained.some((one) => one.key === recipe.key && one.fingerprint !== recipe.fingerprint);
+        const disposition = recipe.unresolved
+            ? "blocked"
+            : old
+                ? "reuse"
+                : changedProvided
+                    ? "review"
+                    : recipe.kind === "provided"
+                        ? "blocked"
+                        : recipe.kind === "local"
+                            ? "local"
+                            : "generate";
+        return {
+            ...recipe,
+            disposition,
+            inflight: old?.inflight ?? false,
+            pieceIds: old?.pieceIds ?? [],
+            reason: disposition === "reuse"
+                ? "Inputs match retained work."
+                : disposition === "review"
+                    ? "Confirm the provided content against changed inputs."
+                    : disposition === "blocked"
+                        ? "An input is unavailable or needs a fresh preview."
+                        : "Inputs changed or a required output is missing.",
+        };
+    });
+}