@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/slices/revisions/mutation-prepare.js

@@ -0,0 +1,182 @@
+import { z } from "zod";
+import { plainText } from "../article/plain.js";
+import { splitEndMatter } from "../article/split.js";
+import { normalizeArticleIntent } from "../rebuild/recipe-save.js";
+import { discardPreparedAssets } from "../storage/assets.js";
+import { prepareStagedFile, prepareText } from "../storage/prepare.js";
+import { outputSchema } from "../storage/schema.js";
+import { bindUpload, measureAudio, providedAssetSelected, } from "./mutation-assets.js";
+export async function prepareEditAssets(deps, base, edit) {
+    const prepared = [];
+    const allocated = [];
+    try {
+        const projectId = base.revision.projectId;
+        let content = normalizeArticleIntent(base, edit);
+        for (const upload of edit.uploads ?? []) {
+            const to = upload.destination;
+            const role = to.kind === "image"
+                ? "image"
+                : to.kind === "provided" && to.stage === "thumbnail"
+                    ? "thumbnail"
+                    : "audio_body";
+            const result = prepareStagedFile(deps, {
+                projectId,
+                stagedFileId: upload.stagedFileId,
+                role,
+                index: to.kind === "image" ? content.imageOrder.indexOf(to.imageKey) + 1 : 1,
+            });
+            if (!result.ok)
+                throw new Error("A validated upload became unavailable.");
+            const workKey = to.kind === "image"
+                ? `image:${to.imageKey}`
+                : to.kind === "narration"
+                    ? to.key
+                    : to.stage === "audio"
+                        ? "audio:provided"
+                        : "thumbnail:image";
+            const item = {
+                ...result,
+                upload,
+                workKey,
+                slot: to.kind === "image"
+                    ? workKey
+                    : to.kind === "narration"
+                        ? workKey
+                        : `${result.output.stageKind}:${role}`,
+            };
+            allocated.push(result.asset);
+            const durationMs = result.output.stageKind === "audio"
+                ? await measureAudio(deps, projectId, result.asset.path)
+                : item.output.durationMs;
+            prepared.push({ ...item, output: { ...item.output, durationMs } });
+            content = bindUpload(content, upload, result.asset.id);
+        }
+        for (const [index, key] of content.imageOrder.entries()) {
+            const definition = content.imageDefinitions[key];
+            const assetId = definition?.assetId;
+            const workKey = `image:${key}`;
+            if (definition?.source !== "provide" ||
+                assetId == null ||
+                prepared.some((row) => row.workKey === workKey) ||
+                base.outputs.some((row) => row.selected &&
+                    row.workKey === workKey &&
+                    row.assetId === assetId &&
+                    row.output.role === "image"))
+                continue;
+            const asset = retainedAsset(deps, projectId, assetId);
+            const existing = deps.db
+                .prepare("SELECT descriptor FROM revision_outputs WHERE project_id=? AND asset_id=? AND json_extract(descriptor,'$.stageKind')='images' AND json_extract(descriptor,'$.role')='image' LIMIT 1")
+                .get(projectId, assetId);
+            const descriptor = existing === undefined
+                ? {
+                    projectId,
+                    stageKind: "images",
+                    role: "image",
+                    path: asset.path,
+                    originalFilename: null,
+                    bytes: asset.bytes,
+                    durationMs: null,
+                    meta: {},
+                    createdAt: asset.createdAt,
+                }
+                : outputSchema.parse(JSON.parse(z.string().parse(existing.descriptor)));
+            prepared.push({
+                asset,
+                output: {
+                    ...descriptor,
+                    id: deps.ids.next(),
+                    meta: { ...descriptor.meta, index: index + 1 },
+                },
+                workKey,
+                slot: workKey,
+            });
+        }
+        for (const kind of ["audio", "thumbnail"]) {
+            const assetId = content.provided[kind];
+            if (edit.config.sources[kind] !== "provide" ||
+                assetId === undefined ||
+                providedAssetSelected(base, kind, assetId) ||
+                prepared.some((row) => row.asset.id === assetId))
+                continue;
+            const existing = deps.db
+                .prepare("SELECT descriptor FROM revision_outputs WHERE project_id=? AND asset_id=? AND json_extract(descriptor,'$.stageKind')=? LIMIT 1")
+                .get(projectId, assetId, kind);
+            if (existing === undefined)
+                throw new Error("Validated replacement asset has no descriptor.");
+            const descriptor = outputSchema.parse(JSON.parse(z.string().parse(existing.descriptor)));
+            const asset = retainedAsset(deps, projectId, assetId);
+            const role = kind === "audio" ? "audio_body" : "thumbnail";
+            const item = {
+                asset,
+                output: {
+                    ...descriptor,
+                    id: deps.ids.next(),
+                    role,
+                    durationMs: kind === "audio"
+                        ? await measureAudio(deps, projectId, asset.path)
+                        : descriptor.durationMs,
+                },
+                workKey: kind === "audio" ? "audio:provided" : "thumbnail:image",
+                slot: `${kind}:${role}`,
+            };
+            prepared.push(item);
+        }
+        const article = edit.config.sources.article === "provide" || content.articleEdited === true
+            ? (content.articleMarkdown ?? edit.config.provided.article)
+            : undefined;
+        if (article !== undefined &&
+            (article !== base.articleMarkdown ||
+                !base.outputs.some((row) => row.selected && row.available && row.output.role === "article_md"))) {
+            const end = splitEndMatter(article);
+            const texts = [
+                ["article_md", article],
+                ["article_txt", plainText(end.body)],
+                ["sources", end.sources],
+                ["glossary", end.glossary],
+            ];
+            for (const [role, text] of texts)
+                if (text.trim() !== "" || role === "article_md" || role === "article_txt") {
+                    const row = prepareText(deps, { projectId, stageKind: "article", role, text });
+                    allocated.push(row.asset);
+                    prepared.push({ ...row, workKey: "article:body", slot: `article:${role}` });
+                }
+        }
+        if (edit.config.sources.research === "provide" &&
+            (edit.config.provided.research !== base.revision.config.provided.research ||
+                !base.outputs.some((row) => row.selected && row.output.role === "notes"))) {
+            const row = prepareText(deps, {
+                projectId,
+                stageKind: "research",
+                role: "notes",
+                text: edit.config.provided.research ?? "",
+            });
+            allocated.push(row.asset);
+            prepared.push({ ...row, workKey: "research:notes", slot: "research:notes" });
+        }
+        return { edit: { ...edit, content }, assets: prepared };
+    }
+    catch (error) {
+        discardPreparedAssets(deps, allocated);
+        throw error;
+    }
+}
+function retainedAsset(deps, projectId, assetId) {
+    const row = z
+        .object({
+        id: z.string(),
+        project_id: z.string(),
+        path: z.string(),
+        bytes: z.number(),
+        created_at: z.string(),
+    })
+        .parse(deps.db
+        .prepare("SELECT * FROM project_assets WHERE project_id=? AND id=?")
+        .get(projectId, assetId));
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        path: row.path,
+        bytes: row.bytes,
+        createdAt: row.created_at,
+    };
+}

package/dist/slices/revisions/mutation-request.js

@@ -0,0 +1,58 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { currentRevisionId } from "./repo.js";
+import { getRevisionView } from "./view.js";
+export function requestHash(operation, baseRevisionId, input) {
+    return createHash("sha256")
+        .update(JSON.stringify([operation, baseRevisionId, input], (_key, value) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return value;
+        return Object.fromEntries(Object.entries(value).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+    }))
+        .digest("hex");
+}
+export function refusal(deps, projectId, reason) {
+    return { ok: false, reason, currentRevisionId: currentRevisionId(deps.db, projectId) ?? null };
+}
+export function checkMutation(deps, input) {
+    const { db } = deps;
+    const row = db
+        .prepare("SELECT operation,request_hash,result_revision_id FROM revision_mutations WHERE project_id=? AND idempotency_key=?")
+        .get(input.projectId, input.idempotencyKey);
+    if (row !== undefined) {
+        const receipt = z
+            .object({ operation: z.string(), request_hash: z.string(), result_revision_id: z.string() })
+            .parse(row);
+        if (receipt.operation !== input.operation || receipt.request_hash !== input.hash)
+            return refusal(deps, input.projectId, "idempotency-conflict");
+        return {
+            ok: true,
+            view: requiredView(deps, input.projectId, receipt.result_revision_id),
+            duplicate: true,
+        };
+    }
+    if (db
+        .prepare("SELECT 1 FROM rebuild_admissions WHERE project_id=? AND idempotency_key=?")
+        .get(input.projectId, input.idempotencyKey) !== undefined)
+        return refusal(deps, input.projectId, "idempotency-conflict");
+    if (db
+        .prepare("SELECT 1 FROM project_control_receipts WHERE project_id=? AND idempotency_key=?")
+        .get(input.projectId, input.idempotencyKey) !== undefined)
+        return refusal(deps, input.projectId, "idempotency-conflict");
+    if (db.prepare("SELECT 1 FROM projects WHERE id=?").get(input.projectId) === undefined)
+        return refusal(deps, input.projectId, "no-project");
+    if (currentRevisionId(db, input.projectId) !== input.baseRevisionId)
+        return refusal(deps, input.projectId, "conflict");
+    return undefined;
+}
+export function requiredView(deps, projectId, revisionId) {
+    const view = getRevisionView(deps, projectId, revisionId);
+    if (view === undefined)
+        throw new Error("The retained revision was not found.");
+    return view;
+}
+export function insertReceipt(deps, input, revisionId) {
+    deps.db
+        .prepare("INSERT INTO revision_mutations(project_id,idempotency_key,operation,request_hash,base_revision_id,result_revision_id,created_at) VALUES (?,?,?,?,?,?,?)")
+        .run(input.projectId, input.idempotencyKey, input.operation, input.hash, input.baseRevisionId, revisionId, deps.clock.now().toISOString());
+}

package/dist/slices/revisions/mutation-work.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { buildRecipes } from "../rebuild/recipe-build.js";
+import { recipeInputSchema } from "../rebuild/recipe-input-schema.js";
+export function preserveDeferredIntent(deps, base, plan) {
+    const rows = deps.db
+        .prepare("SELECT p.input_json,r.work_key,r.fingerprint,r.logical_key,r.desired_fingerprint FROM revision_work_reservations r JOIN revision_work_pieces p ON p.id=r.piece_id JOIN revision_work w ON w.id=r.work_id WHERE r.project_id=? AND r.revision_id=? AND (w.dispatch_state='allowed' OR p.dispatch_state='allowed')")
+        .all(base.revision.projectId, base.revision.id);
+    const before = buildRecipes({
+        config: base.revision.config,
+        content: base.revision.content,
+        manifest: {
+            outputs: base.outputs.filter((row) => row.selected),
+            pieces: base.pieces.filter((row) => row.selected),
+        },
+        resolved: {
+            articleMarkdown: null,
+            researchNotes: base.revision.config.provided.research ?? null,
+        },
+    });
+    const after = buildRecipes({
+        config: plan.config,
+        content: plan.content,
+        manifest: plan.manifest,
+        resolved: { articleMarkdown: null, researchNotes: plan.config.provided.research ?? null },
+    });
+    const fingerprints = { ...plan.fingerprints };
+    const baseFingerprints = { ...plan.baseFingerprints };
+    const recipes = [...plan.recipes];
+    for (const row of rows) {
+        const input = recipeInputSchema.parse(JSON.parse(z.string().parse(row.input_json)));
+        const key = z.string().parse(row.logical_key ?? row.work_key);
+        if (input.kind !== "deferred" || fingerprints[key] !== undefined)
+            continue;
+        const old = before.find((one) => one.key === key);
+        const next = after.find((one) => one.key === key);
+        const desired = z.string().parse(row.desired_fingerprint ?? row.fingerprint);
+        if (old !== undefined &&
+            next !== undefined &&
+            old.fingerprint === next.fingerprint &&
+            old.fingerprint === desired) {
+            fingerprints[key] = desired;
+            baseFingerprints[key] = desired;
+            recipes.push(next);
+        }
+    }
+    return { ...plan, fingerprints, baseFingerprints, recipes };
+}

package/dist/slices/revisions/mutations.js

@@ -0,0 +1,194 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { carryCheckpointGates } from "../checkpoints/recovery.js";
+import { narrationRegenerationKey } from "../narration/plan.js";
+import { recipeInputSchema } from "../rebuild/recipe-input-schema.js";
+import { planRevision } from "../rebuild/recipe-save.js";
+import { transitionRevisionWork } from "../rebuild/repo.js";
+import { projectStandings } from "../rebuild/runtime-store.js";
+import { discardPreparedAssets } from "../storage/assets.js";
+import { deleteStagedFile } from "../storage/repo.js";
+import { releaseStagedFile } from "../storage/staging-refs.js";
+import { validateAssetReferences, validateReplacementAvailability, validateUploads, } from "./mutation-assets.js";
+import { cuesChanged, inspectCueAudio, measuredOutputs, validateProposedCues, } from "./mutation-cues.js";
+import { prepareEditAssets } from "./mutation-prepare.js";
+import { checkMutation, insertReceipt, requestHash, requiredView } from "./mutation-request.js";
+import { preserveDeferredIntent } from "./mutation-work.js";
+import { cloneManifest, ensureRevisionStages, projectSelected } from "./projection.js";
+import { insertAsset, insertRevision } from "./repo.js";
+import { validateNarrationIntent, validateTemplateIntent } from "./rules.js";
+import { revisionEditSchema } from "./schema.js";
+export { bindUpload } from "./mutation-assets.js";
+export { restoreRevision } from "./restore.js";
+export async function saveRevision(deps, input) {
+    const parsed = revisionEditSchema.safeParse(input.edit);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid-edit",
+            currentRevisionId: input.baseRevisionId,
+            fields: parsed.error.issues.map((row) => ({
+                field: row.path.join("."),
+                message: row.message,
+            })),
+        };
+    const edit = parsed.data;
+    const identity = {
+        ...input,
+        operation: "save",
+        hash: requestHash("save", input.baseRevisionId, edit),
+    };
+    const checked = checkMutation(deps, identity);
+    if (checked !== undefined)
+        return checked;
+    const base = requiredView(deps, input.projectId, input.baseRevisionId);
+    const fields = [
+        ...validateUploads(deps, edit),
+        ...validateTemplateIntent(base, edit),
+        ...validateNarrationIntent(base, edit),
+        ...validateAssetReferences(deps, input.projectId, edit.content, []),
+    ];
+    if (fields.length > 0)
+        return { ok: false, reason: "invalid-edit", currentRevisionId: base.revision.id, fields };
+    const unavailable = validateReplacementAvailability(deps, base, edit);
+    if (unavailable.length > 0)
+        return {
+            ok: false,
+            reason: "invalid-edit",
+            currentRevisionId: base.revision.id,
+            fields: unavailable,
+        };
+    const { edit: supplied, assets: prepared } = await prepareEditAssets(deps, base, edit);
+    try {
+        const durations = await inspectCueAudio(deps, base, supplied, prepared);
+        const result = transact(deps.db, () => {
+            const checked = checkMutation(deps, identity);
+            if (checked !== undefined)
+                return checked;
+            const fresh = requiredView(deps, input.projectId, input.baseRevisionId);
+            const tokens = { ...fresh.revision.content.regenerationTokens };
+            for (const key of new Set((edit.regenerate ?? []).map(narrationRegenerationKey)))
+                tokens[key] = deps.ids.next();
+            const finalEdit = {
+                ...supplied,
+                content: { ...supplied.content, regenerationTokens: tokens },
+            };
+            const outputAssets = prepared.filter((row) => row.upload?.destination.kind !== "narration");
+            const inspected = measuredOutputs(deps, fresh, durations);
+            const preparedManifest = {
+                outputs: [
+                    ...outputAssets.map((row) => ({
+                        slot: row.slot,
+                        workKey: row.workKey,
+                        assetId: row.asset.id,
+                        output: row.output,
+                        fingerprint: "",
+                        state: "ready",
+                    })),
+                ],
+                pieces: [],
+            };
+            let plan = planRevision(fresh, finalEdit, preparedManifest, inspected);
+            if (!plan.ok)
+                return {
+                    ok: false,
+                    reason: "invalid-edit",
+                    currentRevisionId: fresh.revision.id,
+                    fields: plan.fields,
+                };
+            const fields = [
+                ...validateAssetReferences(deps, input.projectId, plan.content, prepared.map((row) => row.asset)),
+                ...validateProposedCues(fresh, finalEdit, plan, prepared, durations),
+            ];
+            if (fields.length > 0)
+                return { ok: false, reason: "invalid-edit", currentRevisionId: fresh.revision.id, fields };
+            if (cuesChanged(fresh, finalEdit) && plan.content.subtitleCues !== undefined) {
+                const timing = plan.recipes.find((row) => row.key === "subtitles:timing");
+                if (timing !== undefined) {
+                    plan = planRevision(fresh, {
+                        ...finalEdit,
+                        content: {
+                            ...plan.content,
+                            subtitleCues: {
+                                ...plan.content.subtitleCues,
+                                audioFingerprint: timing.logicalFingerprint,
+                            },
+                        },
+                    }, preparedManifest, inspected);
+                    if (!plan.ok)
+                        throw new Error("Validated captions could not bind to their narration timeline.");
+                }
+            }
+            plan = preserveDeferredIntent(deps, fresh, plan);
+            const revision = {
+                id: deps.ids.next(),
+                projectId: input.projectId,
+                parentId: fresh.revision.id,
+                restoredFromId: null,
+                config: plan.config,
+                content: plan.content,
+                fingerprints: plan.fingerprints,
+                createdAt: deps.clock.now().toISOString(),
+            };
+            insertRevision(deps.db, revision);
+            ensureRevisionStages(deps, revision);
+            for (const row of prepared)
+                insertAsset(deps.db, row.asset);
+            cloneManifest(deps, revision, plan.manifest);
+            if (!advanceHead(deps.db, input.projectId, input.baseRevisionId, revision))
+                throw new Error("Project head changed during the revision transaction.");
+            transitionRevisionWork(deps, {
+                projectId: input.projectId,
+                baseRevisionId: input.baseRevisionId,
+                revisionId: revision.id,
+                fingerprints: plan.fingerprints,
+                baseFingerprints: plan.baseFingerprints,
+                logicalKeys: logicalKeys(deps, input.projectId, input.baseRevisionId, plan.fingerprints),
+                recipes: plan.recipes,
+            });
+            carryCheckpointGates(deps, input.baseRevisionId, revision);
+            projectSelected(deps.db, revision);
+            projectStandings(deps, revision.projectId);
+            insertReceipt(deps, identity, revision.id);
+            for (const row of prepared)
+                if (row.upload !== undefined)
+                    deleteStagedFile(deps.db, row.upload.stagedFileId);
+            return { ok: true, view: requiredView(deps, input.projectId, revision.id), duplicate: false };
+        });
+        if (result.ok && !result.duplicate)
+            for (const row of prepared)
+                if (row.upload !== undefined)
+                    releaseStagedFile({ ...deps, emit: () => undefined }, row.upload.stagedFileId);
+        return result;
+    }
+    finally {
+        discardPreparedAssets(deps, prepared
+            .map((row) => row.asset)
+            .filter((asset) => deps.db.prepare("SELECT 1 FROM project_assets WHERE id=?").get(asset.id) === undefined));
+    }
+}
+export function advanceHead(db, projectId, baseRevisionId, revision) {
+    const result = db
+        .prepare("UPDATE project_heads SET revision_id = ? WHERE project_id = ? AND revision_id = ?")
+        .run(revision.id, projectId, baseRevisionId);
+    if (Number(result.changes) !== 1)
+        return false;
+    db.prepare("UPDATE projects SET title = ?, format = ?, config = ?, updated_at = ? WHERE id = ?").run(revision.config.title, revision.config.format, JSON.stringify(revision.config), revision.createdAt, projectId);
+    return true;
+}
+export function logicalKeys(deps, projectId, revisionId, fingerprints) {
+    const values = {};
+    const rows = deps.db
+        .prepare("SELECT p.work_key,p.input_json,r.logical_key FROM revision_work_reservations r JOIN revision_work_pieces p ON p.id=r.piece_id AND p.work_id=r.work_id WHERE r.project_id=? AND r.revision_id=?")
+        .all(projectId, revisionId);
+    for (const row of rows) {
+        const input = recipeInputSchema.parse(JSON.parse(z.string().parse(row.input_json)));
+        if (input.kind === "tts" && fingerprints[`${input.logicalKey}:1`] !== undefined)
+            values[z.string().parse(row.work_key)] = `${input.logicalKey}:1`;
+        else if (typeof row.logical_key === "string")
+            values[z.string().parse(row.work_key)] = row.logical_key;
+        else if (input.kind === "tts")
+            values[z.string().parse(row.work_key)] = `${input.logicalKey}:1`;
+    }
+    return values;
+}

package/dist/slices/revisions/projection.js

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { stageKinds } from "../../kernel/pipeline.js";
+import { insertPiece } from "../../kernel/runner/piece-repo.js";
+import { recipeInputSchema } from "../rebuild/recipe-input-schema.js";
+import { insertOutput } from "../storage/repo.js";
+import { insertManifestOutput, insertManifestPiece, outputsForRevision, piecesForRevision, selectOutputRecord, selectPieceRecord, } from "./repo.js";
+export function ensureRevisionStages(deps, revision) {
+    for (const kind of stageKinds) {
+        const source = revision.config.sources[kind];
+        deps.db
+            .prepare("INSERT INTO stages(id,project_id,kind,source,state) VALUES (?,?,?,?,?) ON CONFLICT(project_id,kind) DO UPDATE SET source=excluded.source")
+            .run(deps.ids.next(), revision.projectId, kind, source, source === "off" ? "skipped" : "pending");
+    }
+}
+export function positionedOutput(revision, row) {
+    if (row.output.role !== "image")
+        return row;
+    const index = revision.content.imageOrder.indexOf(row.workKey.replace(/^image:/, ""));
+    return index < 0
+        ? row
+        : { ...row, output: { ...row.output, meta: { ...row.output.meta, index: index + 1 } } };
+}
+export function positionedPiece(revision, row) {
+    if (row.piece.kind !== "image")
+        return row;
+    const index = revision.content.imageOrder.indexOf(row.key.replace(/^image:/, ""));
+    return index < 0 ? row : { ...row, piece: { ...row.piece, idx: index + 1 } };
+}
+export function cloneManifest(deps, revision, manifest) {
+    for (const row of manifest.outputs) {
+        if (row.output.role === "image" &&
+            !revision.content.imageOrder.includes(row.workKey.replace(/^image:/, "")))
+            continue;
+        const recordId = deps.ids.next();
+        insertManifestOutput(deps.db, revision, positionedOutput(revision, row), recordId);
+        selectOutputRecord(deps.db, revision.id, row.slot, recordId);
+    }
+    for (const row of manifest.pieces) {
+        if (row.piece.kind === "image" &&
+            !revision.content.imageOrder.includes(row.key.replace(/^image:/, "")))
+            continue;
+        const recordId = deps.ids.next();
+        insertManifestPiece(deps.db, revision, positionedPiece(revision, row), recordId);
+        selectPieceRecord(deps.db, revision.id, row.key, recordId);
+    }
+}
+export function projectSelected(db, revision) {
+    const outputs = outputsForRevision(db, revision.projectId, revision.id).filter((row) => row.selected);
+    const pieces = piecesForRevision(db, revision.projectId, revision.id).filter((row) => row.selected &&
+        (revision.fingerprints[row.key] !== undefined ||
+            desiredPhysicalPiece(db, revision, row) ||
+            db
+                .prepare("SELECT 1 FROM revision_work_reservations WHERE revision_id=? AND work_key=?")
+                .get(revision.id, row.key) !== undefined));
+    db.prepare("DELETE FROM outputs WHERE project_id=?").run(revision.projectId);
+    for (const row of outputs)
+        insertOutput(db, row.output);
+    db.prepare("DELETE FROM stage_pieces WHERE stage_id IN (SELECT id FROM stages WHERE project_id=?)").run(revision.projectId);
+    for (const row of pieces) {
+        const stage = db
+            .prepare("SELECT id FROM stages WHERE project_id=? AND kind=?")
+            .get(revision.projectId, row.stageKind);
+        if (stage === undefined || z.string().parse(stage.id) !== row.piece.stageId)
+            throw new Error("Manifest piece stage does not belong to this project.");
+        insertPiece(db, row.piece);
+    }
+}
+function desiredPhysicalPiece(db, revision, row) {
+    const piece = db
+        .prepare("SELECT p.input_json FROM revision_work_pieces p JOIN revision_work w ON w.id=p.work_id WHERE p.id=? AND w.project_id=?")
+        .get(row.piece.id, revision.projectId);
+    if (piece === undefined) {
+        if (row.stageKind !== "audio" || (row.piece.kind !== "chunk" && row.piece.kind !== "segment"))
+            return false;
+        const payload = z
+            .object({ logicalKey: z.string() })
+            .safeParse(JSON.parse(row.piece.payload ?? "null"));
+        return payload.success && revision.fingerprints[`${payload.data.logicalKey}:1`] !== undefined;
+    }
+    const input = recipeInputSchema.parse(JSON.parse(z.string().parse(piece.input_json)));
+    return input.kind === "tts" && revision.fingerprints[`${input.logicalKey}:1`] !== undefined;
+}

package/dist/slices/revisions/publication-model.js

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