@gentbajko/slopify 0.8.3 → 1.0.0

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 {};

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

@@ -0,0 +1,166 @@
+import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+import { workExists } from "../../kernel/runner/work-authority.js";
+import { pieceFile } from "../storage/reconcile.js";
+import { outputSchema } from "../storage/schema.js";
+import { outputsForRevision, piecesForRevision, revisionById } from "./repo.js";
+import { stagePieceSchema } from "./schema.js";
+export function publicationAuthority(db, publication) {
+    const { work, pieceId, publicationId } = publication;
+    if (publicationId !== (pieceId ?? work.workId))
+        throw new Error("Publication identity does not match its durable work.");
+    if (!workExists(db, work))
+        return undefined;
+    const row = pieceId === null
+        ? db
+            .prepare("SELECT work_key,fingerprint FROM revision_work_reservations WHERE work_id=? AND piece_id IS NULL")
+            .get(work.workId)
+        : db
+            .prepare("SELECT work_key,fingerprint FROM revision_work_pieces WHERE work_id=? AND id=?")
+            .get(work.workId, pieceId);
+    if (row === undefined && pieceId === null) {
+        const candidates = Object.entries(revisionById(db, work.projectId, work.revisionId)?.fingerprints ?? {}).filter(([, value]) => value === work.fingerprint);
+        const candidate = candidates.length === 1 ? candidates[0] : undefined;
+        if (candidate !== undefined)
+            return { key: candidate[0], fingerprint: candidate[1] };
+    }
+    if (row === undefined)
+        throw new Error("Publication has no unambiguous durable authority.");
+    const parsed = z.object({ work_key: z.string(), fingerprint: z.string() }).parse(row);
+    return { key: parsed.work_key, fingerprint: parsed.fingerprint };
+}
+export function validatePublication(db, publication, outputs, pieces) {
+    if (outputs.length + pieces.length === 0)
+        throw new Error("A publication must contain a result.");
+    if (new Set(outputs.map((row) => row.slot)).size !== outputs.length ||
+        new Set(pieces.map((row) => row.key)).size !== pieces.length)
+        throw new Error("Publication destinations must be unique.");
+    const authority = publicationAuthority(db, publication);
+    const durablePiece = publication.pieceId === null
+        ? undefined
+        : db
+            .prepare("SELECT logical_fingerprint FROM revision_work_pieces WHERE id=? AND work_id=?")
+            .get(publication.pieceId, publication.work.workId);
+    const revision = revisionById(db, publication.work.projectId, publication.work.revisionId);
+    for (const row of outputs) {
+        const retainedMember = ((authority?.key === "subtitles:files" &&
+            ((row.workKey === "export:wav" && row.output.role === "audio_export") ||
+                (row.workKey === "export:video" &&
+                    row.output.role === "video" &&
+                    row.output.meta.subtitlesMode !== "burn-in"))) ||
+            ((authority?.key === "export:wav" || authority?.key === "export:video") &&
+                row.workKey === "subtitles:files" &&
+                ["subtitles_srt", "subtitles_vtt", "subtitle_ass", "subtitle_font"].includes(row.output.role))) &&
+            outputsForRevision(db, publication.work.projectId, publication.work.revisionId).some((old) => old.selected &&
+                old.state === "ready" &&
+                old.workKey === row.workKey &&
+                old.output.role === row.output.role &&
+                old.assetId === row.asset.id &&
+                old.fingerprint === row.fingerprint);
+        if (!retainedMember &&
+            row.fingerprint !== revision?.fingerprints[row.workKey] &&
+            !(row.workKey === authority?.key &&
+                (row.fingerprint === authority.fingerprint ||
+                    row.fingerprint === durablePiece?.logical_fingerprint)))
+            throw new Error("Output fingerprint differs from its authorized recipe.");
+        outputSchema.parse(row.output);
+        if (row.output.projectId !== publication.work.projectId ||
+            row.asset.projectId !== publication.work.projectId ||
+            row.output.stageKind !== publication.work.kind ||
+            row.output.path !== row.asset.path ||
+            row.output.bytes !== row.asset.bytes)
+            throw new Error("Output descriptor does not match its owned asset and stage.");
+    }
+    for (const row of pieces) {
+        stagePieceSchema.parse(row.piece);
+        const owned = db
+            .prepare("SELECT work_key,fingerprint FROM revision_work_pieces WHERE id=? AND work_id=?")
+            .get(row.piece.id, publication.work.workId);
+        const file = pieceFile(row.piece.payload);
+        if (row.stageKind !== publication.work.kind ||
+            row.piece.stageId !== publication.work.stageId ||
+            owned === undefined ||
+            owned.work_key !== row.key ||
+            owned.fingerprint !== row.fingerprint ||
+            (publication.pieceId !== null && row.piece.id !== publication.pieceId) ||
+            (row.asset !== null &&
+                (row.asset.projectId !== publication.work.projectId || file !== row.asset.path)) ||
+            (row.asset === null && file !== undefined))
+            throw new Error("Piece descriptor does not match its owned work and asset.");
+    }
+}
+export function isPublicationReplay(db, publication, outputs, pieces) {
+    const oldOutputs = outputsForRevision(db, publication.work.projectId, publication.work.revisionId).filter((row) => row.publicationId === publication.publicationId);
+    const oldPieces = piecesForRevision(db, publication.work.projectId, publication.work.revisionId).filter((row) => row.publicationId === publication.publicationId);
+    if (oldOutputs.length + oldPieces.length === 0)
+        return false;
+    const descriptors = outputs.map((row) => ({
+        slot: row.slot,
+        workKey: row.workKey,
+        assetId: row.asset.id,
+        output: row.output,
+        fingerprint: row.fingerprint,
+        state: "ready",
+    }));
+    const pieceDescriptors = pieces.map((row) => ({
+        key: row.key,
+        stageKind: row.stageKind,
+        assetId: row.asset?.id ?? null,
+        piece: row.piece,
+        fingerprint: row.fingerprint,
+    }));
+    const normalize = (rows) => rows
+        .map((row) => JSON.parse(JSON.stringify(row)))
+        .sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+    if (!isDeepStrictEqual(normalize(oldOutputs.map(outputDescriptor)), normalize(descriptors)) ||
+        !isDeepStrictEqual(normalize(oldPieces.map(pieceDescriptor)), normalize(pieceDescriptors)))
+        throw new Error("Publication conflicts with its complete retained result.");
+    return true;
+}
+function outputDescriptor({ recordId: _recordId, publicationId: _publicationId, selected: _selected, ...row }) {
+    return row;
+}
+function pieceDescriptor({ recordId: _recordId, publicationId: _publicationId, selected: _selected, ...row }) {
+    return row;
+}
+export function replacementSlots(authority, outputs) {
+    if (authority === "article:body")
+        return ["article:article_md", "article:article_txt", "article:sources", "article:glossary"];
+    if (authority === "subtitles:files" || authority === "export:wav" || authority === "export:video")
+        return [
+            "video:subtitles_srt",
+            "video:subtitles_vtt",
+            "video:subtitle_ass",
+            "video:subtitle_font",
+            ...(authority === "subtitles:files"
+                ? []
+                : ["video:video", "video:audio_export", "video:render_params"]),
+        ];
+    return outputs.map((row) => row.slot);
+}
+export function validateBundle(authority, outputs) {
+    const allowed = (row) => row.workKey === authority ||
+        ((authority === "export:wav" || authority === "export:video") &&
+            ["subtitles:files", "subtitles:cues"].includes(row.workKey)) ||
+        (authority === "subtitles:files" &&
+            ((row.workKey === "export:wav" && row.output.role === "audio_export") ||
+                (row.workKey === "export:video" &&
+                    row.output.role === "video" &&
+                    row.output.meta.subtitlesMode !== "burn-in")));
+    if (outputs.some((row) => !allowed(row)))
+        throw new Error("Publication member is outside its authorized result bundle.");
+    const roles = new Set(outputs.map((row) => row.output.role));
+    const media = outputs.find((row) => row.output.role === "video" || row.output.role === "audio_export");
+    if ((authority === "export:wav" && (!roles.has("audio_export") || !roles.has("render_params"))) ||
+        (authority === "export:video" && (!roles.has("video") || !roles.has("render_params"))))
+        throw new Error("Media and render parameters must publish as one complete bundle.");
+    if (media !== undefined &&
+        media.output.meta.subtitlesMode !== undefined &&
+        media.output.meta.subtitlesMode !== "off") {
+        if (!roles.has("subtitles_srt") ||
+            !roles.has("subtitles_vtt") ||
+            (media.output.meta.subtitlesMode === "burn-in" &&
+                (!roles.has("subtitle_ass") || !roles.has("subtitle_font"))))
+            throw new Error("Declared subtitle files must be committed with their media descriptor.");
+    }
+}

package/dist/slices/revisions/publish.js

@@ -0,0 +1,115 @@
+import { transact } from "../../kernel/db/tx.js";
+import { publicationTargets } from "../rebuild/repo.js";
+import { discardPreparedAssets } from "../storage/assets.js";
+import { positionedOutput, positionedPiece, projectSelected } from "./projection.js";
+import { isPublicationReplay, publicationAuthority, replacementSlots, validateBundle, validatePublication, } from "./publication-rules.js";
+import { insertAsset, insertManifestOutput, insertManifestPiece, outputsForRevision, revisionById, selectOutputRecord, selectPieceRecord, } from "./repo.js";
+export function commitRevisionOutputs(deps, publication, outputs, pieces) {
+    const assets = [
+        ...outputs.map((row) => row.asset),
+        ...pieces.flatMap((row) => (row.asset === null ? [] : [row.asset])),
+    ];
+    try {
+        return transact(deps.db, () => {
+            const result = { originRevisionId: publication.work.revisionId, currentAttached: false };
+            const authority = publicationAuthority(deps.db, publication);
+            if (authority === undefined)
+                return result;
+            validatePublication(deps.db, publication, outputs, pieces);
+            validateBundle(authority.key, outputs);
+            if (isPublicationReplay(deps.db, publication, outputs, pieces))
+                return result;
+            const targets = publicationTargets(deps.db, publication, authority.key, authority.fingerprint);
+            if (targets.length === 0)
+                return result;
+            for (const asset of assets)
+                insertAsset(deps.db, asset);
+            let currentAttached = false;
+            for (const target of targets) {
+                const revision = revisionById(deps.db, publication.work.projectId, target.revisionId);
+                if (revision === undefined)
+                    throw new Error("Publication target disappeared inside its transaction.");
+                const selected = target.selected;
+                const before = outputsForRevision(deps.db, revision.projectId, revision.id);
+                const exportAuthority = authority.key === "export:wav" || authority.key === "export:video";
+                const selectsMember = (output) => {
+                    if (!selected)
+                        return false;
+                    if (authority.key === "subtitles:files" &&
+                        (output.output.role === "audio_export" || output.output.role === "video"))
+                        return before.some((row) => row.selected &&
+                            row.state === "ready" &&
+                            row.workKey === output.workKey &&
+                            row.assetId === output.asset.id &&
+                            row.fingerprint === output.fingerprint);
+                    if (!exportAuthority || output.workKey !== "subtitles:files")
+                        return true;
+                    if ((revision.config.subtitles?.mode ?? "off") === "off")
+                        return false;
+                    return (revision.fingerprints[output.workKey] === output.fingerprint ||
+                        before.some((row) => row.selected &&
+                            row.state === "ready" &&
+                            row.slot === output.slot &&
+                            row.assetId === output.asset.id &&
+                            row.fingerprint === output.fingerprint));
+                };
+                if (selected)
+                    for (const slot of replacementSlots(authority.key, outputs)) {
+                        const captionSlot = [
+                            "video:subtitles_srt",
+                            "video:subtitles_vtt",
+                            "video:subtitle_ass",
+                            "video:subtitle_font",
+                        ].includes(slot);
+                        if (exportAuthority &&
+                            captionSlot &&
+                            (revision.config.subtitles?.mode ?? "off") !== "off" &&
+                            !outputs.some((output) => output.slot === slot && selectsMember(output)))
+                            continue;
+                        deps.db
+                            .prepare("UPDATE revision_outputs SET selected=0 WHERE revision_id=? AND slot=?")
+                            .run(revision.id, slot);
+                    }
+                for (const output of outputs) {
+                    const row = {
+                        slot: output.slot,
+                        workKey: output.workKey,
+                        assetId: output.asset.id,
+                        output: output.output,
+                        fingerprint: output.fingerprint,
+                        state: "ready",
+                    };
+                    const recordId = deps.ids.next();
+                    insertManifestOutput(deps.db, revision, target.revisionId === publication.work.revisionId
+                        ? row
+                        : positionedOutput(revision, row), recordId, publication.publicationId);
+                    if (selectsMember(output))
+                        selectOutputRecord(deps.db, revision.id, row.slot, recordId);
+                }
+                for (const piece of pieces) {
+                    const row = {
+                        key: piece.key,
+                        stageKind: piece.stageKind,
+                        assetId: piece.asset?.id ?? null,
+                        piece: piece.piece,
+                        fingerprint: piece.fingerprint,
+                    };
+                    const recordId = deps.ids.next();
+                    insertManifestPiece(deps.db, revision, target.revisionId === publication.work.revisionId
+                        ? row
+                        : positionedPiece(revision, row), recordId, publication.publicationId);
+                    if (selected)
+                        selectPieceRecord(deps.db, revision.id, row.key, recordId);
+                }
+                if (selected && target.current) {
+                    projectSelected(deps.db, revision);
+                    currentAttached = true;
+                }
+            }
+            return { ...result, currentAttached };
+        });
+    }
+    finally {
+        discardPreparedAssets(deps, assets);
+    }
+}

package/dist/slices/revisions/repo.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { projectRevisionSchema } from "./schema.js";
+export { insertManifestOutput, insertManifestPiece, outputsForRevision, piecesForRevision, selectOutputRecord, selectPieceRecord, } from "./manifest-repo.js";
+const revisionRow = z.object({
+    id: z.string(),
+    project_id: z.string(),
+    parent_id: z.string().nullable(),
+    restored_from_id: z.string().nullable(),
+    config: z.string(),
+    content: z.string(),
+    fingerprints: z.string(),
+    created_at: z.string(),
+});
+const assetRow = z.object({
+    id: z.string(),
+    project_id: z.string(),
+    path: z.string(),
+    bytes: z.number().nullable(),
+    created_at: z.string(),
+});
+export function insertRevision(db, revision) {
+    db.prepare(`INSERT INTO project_revisions
+    (id,project_id,parent_id,restored_from_id,config,content,fingerprints,created_at)
+    VALUES (?,?,?,?,?,?,?,?)`).run(revision.id, revision.projectId, revision.parentId, revision.restoredFromId, JSON.stringify(revision.config), JSON.stringify(revision.content), JSON.stringify(revision.fingerprints), revision.createdAt);
+}
+export function revisionById(db, projectId, revisionId) {
+    const row = db
+        .prepare("SELECT * FROM project_revisions WHERE project_id=? AND id=?")
+        .get(projectId, revisionId);
+    return row === undefined ? undefined : toRevision(row);
+}
+export function currentRevisionId(db, projectId) {
+    const row = db.prepare("SELECT revision_id FROM project_heads WHERE project_id=?").get(projectId);
+    return row === undefined
+        ? undefined
+        : z.object({ revision_id: z.string() }).parse(row).revision_id;
+}
+export function listRevisionHistory(db, projectId) {
+    const head = currentRevisionId(db, projectId);
+    return db
+        .prepare("SELECT * FROM project_revisions WHERE project_id=? ORDER BY created_at DESC,id DESC")
+        .all(projectId)
+        .map((row) => {
+        const revision = toRevision(row);
+        return {
+            id: revision.id,
+            parentId: revision.parentId,
+            restoredFromId: revision.restoredFromId,
+            title: revision.config.title,
+            createdAt: revision.createdAt,
+            current: revision.id === head,
+        };
+    });
+}
+export function insertAsset(db, asset) {
+    const existing = db
+        .prepare("SELECT * FROM project_assets WHERE id=? OR (project_id=? AND path=?)")
+        .all(asset.id, asset.projectId, asset.path);
+    if (existing.length > 0) {
+        const row = assetRow.parse(existing[0]);
+        if (existing.length !== 1 ||
+            row.id !== asset.id ||
+            row.project_id !== asset.projectId ||
+            row.path !== asset.path ||
+            row.bytes !== asset.bytes)
+            throw new Error("Asset identity conflicts with a registered file.");
+        return;
+    }
+    db.prepare("INSERT INTO project_assets(id,project_id,path,bytes,created_at) VALUES (?,?,?,?,?)").run(asset.id, asset.projectId, asset.path, asset.bytes, asset.createdAt);
+}
+function toRevision(value) {
+    const row = revisionRow.parse(value);
+    return projectRevisionSchema.parse({
+        id: row.id,
+        projectId: row.project_id,
+        parentId: row.parent_id,
+        restoredFromId: row.restored_from_id,
+        config: JSON.parse(row.config),
+        content: JSON.parse(row.content),
+        fingerprints: JSON.parse(row.fingerprints),
+        createdAt: row.created_at,
+    });
+}