@gentbajko/slopify 0.8.4 → 1.0.1

package/dist/slices/checkpoints/change.js

@@ -0,0 +1,250 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { projectExists, stagesOf } from "../admission/repo.js";
+import { executionPlan, executionView, savedCatalogue } from "../rebuild/runtime-plan.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { checkpointClosure, checkpointFingerprint } from "./fingerprint.js";
+import { listCheckpoints } from "./repo.js";
+import { canChangeCheckpoint } from "./rules.js";
+import { checkpointRowSchema, checkpointStageSchema } from "./schema.js";
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[0-9A-Za-z_-]+$/);
+export const checkpointChangeSchema = z
+    .object({
+    revisionId: id,
+    stages: z
+        .array(checkpointStageSchema)
+        .max(3)
+        .refine((values) => new Set(values).size === values.length)
+        .readonly(),
+})
+    .strict();
+function current(deps, projectId, revisionId) {
+    if (!projectExists(deps.db, projectId))
+        return { ok: false, reason: "not-found" };
+    if (currentRevisionId(deps.db, projectId) !== revisionId)
+        return { ok: false, reason: "conflict" };
+    if (stagesOf(deps.db, projectId).some((stage) => stage.state === "canceled"))
+        return { ok: false, reason: "conflict" };
+    return { ok: true, value: true };
+}
+export function resolvedGate(deps, row, currentInputs = false, catalogue) {
+    try {
+        const stored = deps.db
+            .prepare("SELECT recipe_context FROM revision_work WHERE id=? AND project_id=? AND revision_id=?")
+            .get(row.workId, row.projectId, row.revisionId);
+        const view = executionView(deps, row.projectId, row.revisionId);
+        if (!view || (catalogue === undefined && stored?.recipe_context == null))
+            throw new Error("Checkpoint work snapshot is missing");
+        const plan = executionPlan(deps, view, catalogue ?? savedCatalogue(stored?.recipe_context));
+        const closure = checkpointClosure(row.stage, plan.recipes);
+        return {
+            ...row,
+            currentFingerprint: checkpointFingerprint(currentInputs
+                ? {
+                    ...view.revision,
+                    fingerprints: Object.fromEntries(plan.recipes.map((recipe) => [recipe.key, recipe.fingerprint])),
+                }
+                : view.revision, closure),
+            dependents: [...new Set(closure.map((recipe) => recipe.stage))]
+                .filter((stage) => stage !== row.stage)
+                .sort(),
+            workKeys: closure.map((recipe) => recipe.key),
+        };
+    }
+    catch {
+        deps.log.write("warn", "checkpoint.resolve", { projectId: row.projectId, stage: row.stage });
+        return undefined;
+    }
+}
+export function readCheckpointStatus(deps, projectId) {
+    if (!projectExists(deps.db, projectId))
+        return { ok: false, reason: "not-found" };
+    const revisionId = currentRevisionId(deps.db, projectId);
+    if (!revisionId)
+        return { ok: false, reason: "not-found" };
+    const checkpoints = [];
+    for (const row of listCheckpoints(deps.db, projectId, revisionId)) {
+        const resolved = refreshCheckpointGate(deps, row);
+        if (!resolved)
+            return { ok: false, reason: "conflict" };
+        checkpoints.push(resolved);
+    }
+    return { ok: true, value: { revisionId, checkpoints } };
+}
+export function refreshCheckpointGate(deps, row) {
+    const resolved = resolvedGate(deps, row);
+    if (!resolved ||
+        resolved.currentFingerprint === row.fingerprint ||
+        row.approvedAt !== null ||
+        !["held", "pending-review"].includes(row.state))
+        return resolved;
+    const changed = deps.db
+        .prepare("UPDATE review_checkpoints SET fingerprint=? WHERE project_id=? AND revision_id=? AND checkpoint_id=? AND fingerprint=? AND approved_at IS NULL AND state IN ('held','pending-review')")
+        .run(resolved.currentFingerprint, row.projectId, row.revisionId, row.checkpointId, row.fingerprint);
+    return Number(changed.changes) === 1
+        ? { ...resolved, fingerprint: resolved.currentFingerprint }
+        : undefined;
+}
+export function validateCheckpointApproval(deps, input) {
+    const allowed = current(deps, input.projectId, input.revisionId);
+    if (!allowed.ok)
+        return { ok: false, reason: allowed.reason };
+    const row = listCheckpoints(deps.db, input.projectId, input.revisionId).find((gate) => gate.checkpointId === input.checkpointId);
+    if (!row)
+        return { ok: false, reason: "not-found" };
+    const stage = stagesOf(deps.db, input.projectId).find((stage) => stage.kind === row.stage);
+    const work = deps.db.prepare("SELECT state FROM revision_work WHERE id=?").get(row.workId);
+    const resolved = resolvedGate(deps, row);
+    const outstanding = resolved !== undefined &&
+        deps.db
+            .prepare(`SELECT r.work_key FROM revision_work_reservations r
+    JOIN revision_work w ON w.id=r.work_id WHERE r.project_id=? AND r.revision_id=? AND w.state IN ('pending','running')`)
+            .all(input.projectId, input.revisionId)
+            .some((entry) => resolved.workKeys.includes(z.string().parse(entry.work_key)));
+    if (!stage ||
+        !work ||
+        stage.state === "canceled" ||
+        (["done", "provided", "skipped"].includes(stage.state) && !outstanding) ||
+        work.state === "canceled")
+        return { ok: false, reason: "conflict" };
+    if ((stage.state === "running" || work.state === "running") && row.state !== "released")
+        return { ok: false, reason: "conflict" };
+    if (row.fingerprint !== input.fingerprint || resolved?.currentFingerprint !== input.fingerprint)
+        return { ok: false, reason: "conflict" };
+    return { ok: true, value: row };
+}
+export function replayCheckpointApproval(deps, input) {
+    const receipt = deps.db
+        .prepare("SELECT revision_id,checkpoint_id,fingerprint FROM review_checkpoint_approvals WHERE project_id=? AND idempotency_key=?")
+        .get(input.projectId, input.idempotencyKey);
+    if (!receipt)
+        return undefined;
+    const valid = current(deps, input.projectId, input.revisionId);
+    if (!valid.ok)
+        return { ok: false, reason: valid.reason };
+    if (receipt.revision_id !== input.revisionId ||
+        receipt.checkpoint_id !== input.checkpointId ||
+        receipt.fingerprint !== input.fingerprint)
+        return { ok: false, reason: "conflict" };
+    const row = listCheckpoints(deps.db, input.projectId, input.revisionId).find((gate) => gate.checkpointId === input.checkpointId);
+    return row &&
+        row.fingerprint === input.fingerprint &&
+        row.approvedAt !== null &&
+        ["released", "satisfied"].includes(row.state)
+        ? { ok: true, value: row }
+        : { ok: false, reason: "conflict" };
+}
+export function changeCheckpoints(deps, input) {
+    const parsed = checkpointChangeSchema.safeParse({
+        revisionId: input.revisionId,
+        stages: input.stages,
+    });
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    return transact(deps.db, () => {
+        const allowed = current(deps, input.projectId, input.revisionId);
+        if (!allowed.ok)
+            return { ok: false, reason: allowed.reason };
+        const existing = listCheckpoints(deps.db, input.projectId, input.revisionId);
+        const remove = existing.filter((row) => !parsed.data.stages.includes(row.stage));
+        const add = parsed.data.stages.filter((stage) => !existing.some((row) => row.stage === stage));
+        const changedStages = new Set([...remove.map((row) => row.stage), ...add]);
+        const additions = [];
+        const stages = stagesOf(deps.db, input.projectId);
+        for (const kind of changedStages) {
+            const stage = stages.find((row) => row.kind === kind);
+            const work = deps.db
+                .prepare(`SELECT w.* FROM revision_work w WHERE w.project_id=? AND w.kind=? AND
+        (w.revision_id=? OR EXISTS (SELECT 1 FROM revision_work_reservations r WHERE r.work_id=w.id AND r.revision_id=?)) ORDER BY w.id`)
+                .all(input.projectId, kind, input.revisionId, input.revisionId);
+            const submitted = work.some((row) => {
+                if (row.revision_id !== input.revisionId && row.state === "done")
+                    return false;
+                const workId = z.string().parse(row.id);
+                if (row.state === "done" &&
+                    deps.db
+                        .prepare("SELECT 1 FROM revision_work_pieces WHERE work_id=? AND (submitted_at IS NOT NULL OR state='done') LIMIT 1")
+                        .get(workId) === undefined &&
+                    deps.db
+                        .prepare("SELECT 1 FROM revision_work_reservations WHERE revision_id=? AND work_id=? LIMIT 1")
+                        .get(input.revisionId, workId) === undefined)
+                    return false;
+                return (row.state !== "pending" ||
+                    deps.db
+                        .prepare("SELECT 1 FROM revision_work_pieces WHERE work_id=? AND (submitted_at IS NOT NULL OR state IN ('running','done')) LIMIT 1")
+                        .get(workId) !== undefined);
+            });
+            if (!stage || canChangeCheckpoint(stage.state, submitted).kind !== "eligible")
+                return { ok: false, reason: "conflict" };
+            if (!add.includes(kind))
+                continue;
+            let anchor = work.find((row) => row.revision_id === input.revisionId);
+            let synthetic = false;
+            if (!anchor) {
+                const carried = work.find((row) => typeof row.recipe_context === "string");
+                if (!carried)
+                    return { ok: false, reason: "conflict" };
+                anchor = { ...carried, id: deps.ids.next(), revision_id: input.revisionId };
+                synthetic = true;
+            }
+            if (typeof anchor?.id !== "string")
+                return { ok: false, reason: "conflict" };
+            let catalogue;
+            try {
+                catalogue = synthetic
+                    ? savedCatalogue(anchor.recipe_context)
+                    : anchor.recipe_context == null
+                        ? deps.catalogue?.read()
+                        : undefined;
+            }
+            catch {
+                deps.log.write("warn", "checkpoint.resolve", { projectId: input.projectId, stage: kind });
+                return { ok: false, reason: "conflict" };
+            }
+            const row = {
+                projectId: input.projectId,
+                revisionId: input.revisionId,
+                checkpointId: deps.ids.next(),
+                stage: kind,
+                workId: anchor.id,
+                fingerprint: "0".repeat(64),
+                state: "held",
+                createdAt: deps.clock.now().toISOString(),
+                approvedAt: null,
+            };
+            const resolved = resolvedGate(deps, row, false, catalogue);
+            if (!resolved || resolved.workKeys.length === 0)
+                return { ok: false, reason: "conflict" };
+            additions.push({
+                row: checkpointRowSchema.parse({ ...row, fingerprint: resolved.currentFingerprint }),
+                catalogue,
+                newStageId: synthetic ? stage.id : undefined,
+            });
+        }
+        for (const { row: gate, catalogue, newStageId: stageId } of additions) {
+            if (catalogue === undefined)
+                continue;
+            if (stageId !== undefined)
+                deps.db
+                    .prepare("INSERT INTO revision_work(id,project_id,revision_id,stage_id,kind,fingerprint,state,dispatch_state,recipe_context,created_at) VALUES (?,?,?,?,?,?,'done','held',?,?)")
+                    .run(gate.workId, input.projectId, input.revisionId, stageId, gate.stage, gate.fingerprint, JSON.stringify(catalogue), gate.createdAt);
+            else
+                deps.db
+                    .prepare("UPDATE revision_work SET recipe_context=? WHERE id=? AND recipe_context IS NULL")
+                    .run(JSON.stringify(catalogue), gate.workId);
+        }
+        for (const row of remove)
+            deps.db
+                .prepare("DELETE FROM review_checkpoints WHERE project_id=? AND revision_id=? AND checkpoint_id=?")
+                .run(row.projectId, row.revisionId, row.checkpointId);
+        for (const { row } of additions)
+            deps.db
+                .prepare("INSERT INTO review_checkpoints(project_id,revision_id,checkpoint_id,stage,work_id,fingerprint,state,created_at,approved_at) VALUES (?,?,?,?,?,?,?,?,?)")
+                .run(row.projectId, row.revisionId, row.checkpointId, row.stage, row.workId, row.fingerprint, row.state, row.createdAt, row.approvedAt);
+        return { ok: true, value: { changed: changedStages.size > 0, released: remove.length > 0 } };
+    });
+}

package/dist/slices/checkpoints/fingerprint.js

@@ -0,0 +1,33 @@
+import { fingerprint } from "../../kernel/runner/work.js";
+export function checkpointClosure(stage, work) {
+    const held = new Set(work.filter((row) => row.stage === stage).map((row) => row.key));
+    let previous = -1;
+    while (previous !== held.size) {
+        previous = held.size;
+        for (const row of work)
+            if (row.dependsOn.some((key) => held.has(key)))
+                held.add(row.key);
+    }
+    return work.filter((row) => held.has(row.key)).toSorted(byKey);
+}
+function byKey(a, b) {
+    return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+}
+export function checkpointFingerprint(revision, closure) {
+    return fingerprint({
+        projectId: revision.projectId,
+        work: closure.toSorted(byKey).map((row) => ({
+            key: row.key,
+            stage: row.stage,
+            kind: row.kind,
+            requestFingerprint: row.requestFingerprint,
+            fingerprint: row.fingerprint,
+            revisionFingerprint: revision.fingerprints[row.key] ?? null,
+            unresolved: row.unresolved,
+            dependencies: [...new Set(row.dependsOn)].sort().map((key) => ({
+                key,
+                fingerprint: revision.fingerprints[key] ?? null,
+            })),
+        })),
+    });
+}

package/dist/slices/checkpoints/index.js

@@ -0,0 +1,2 @@
+export { approveCheckpoint, checkpointForWork, listCheckpoints, saveCheckpointSet, settleCheckpointClosures, } from "./repo.js";
+export { checkpointApprovalSchema, checkpointRowSchema, checkpointSetSchema, checkpointStageSchema, checkpointStateSchema, } from "./schema.js";

package/dist/slices/checkpoints/model.js

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

package/dist/slices/checkpoints/recovery.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { workExists } from "../../kernel/runner/work-authority.js";
+import { recoverWork } from "../rebuild/repo.js";
+import { currentRevisionId, revisionById } from "../revisions/repo.js";
+import { refreshCheckpointGate, resolvedGate } from "./change.js";
+import { listCheckpoints, settleCheckpointClosures } from "./repo.js";
+import { isApprovalCurrent } from "./rules.js";
+export function checkpointDecisionForWork(deps, work) {
+    if (!workExists(deps.db, work))
+        return { kind: "refused", reason: "not-found" };
+    const head = currentRevisionId(deps.db, work.projectId);
+    const revision = head === undefined ? undefined : revisionById(deps.db, work.projectId, head);
+    if (!revision)
+        return { kind: "refused", reason: "not-found" };
+    const rows = listCheckpoints(deps.db, work.projectId, revision.id);
+    const held = [];
+    for (const row of rows) {
+        const gate = refreshCheckpointGate(deps, row);
+        if (!gate)
+            return { kind: "refused", reason: "conflict" };
+        const owned = deps.db
+            .prepare("SELECT work_key FROM revision_work_reservations WHERE project_id=? AND revision_id=? AND work_id=?")
+            .all(work.projectId, revision.id, work.workId);
+        if (!owned.some((entry) => gate.workKeys.includes(z.string().parse(entry.work_key))))
+            continue;
+        if (gate.state === "canceled")
+            return { kind: "refused", reason: "conflict" };
+        // A release authorizes this immutable revision, including artifacts produced by its work.
+        // New revisions revalidate the reviewed inputs in carryCheckpointGates.
+        if (gate.state === "released" && gate.approvedAt !== null)
+            continue;
+        if (!isApprovalCurrent(gate, revision, gate.currentFingerprint))
+            held.push(gate.checkpointId);
+    }
+    return held.length ? { kind: "held", checkpointIds: held.sort() } : { kind: "eligible" };
+}
+export function carryCheckpointGates(deps, baseRevisionId, revision) {
+    for (const gate of listCheckpoints(deps.db, revision.projectId, baseRevisionId)) {
+        const stored = deps.db
+            .prepare("SELECT stage_id,recipe_context FROM revision_work WHERE id=?")
+            .get(gate.workId);
+        if (!stored || typeof stored.recipe_context !== "string")
+            throw new Error("Checkpoint snapshot is missing");
+        const anchor = deps.ids.next();
+        deps.db
+            .prepare(`INSERT INTO revision_work(id,project_id,revision_id,stage_id,kind,fingerprint,state,dispatch_state,recipe_context,created_at)
+      VALUES (?,?,?,?,?,?,'done','held',?,?)`)
+            .run(anchor, revision.projectId, revision.id, z.string().parse(stored.stage_id), gate.stage, gate.fingerprint, stored.recipe_context, revision.createdAt);
+        const next = {
+            ...gate,
+            revisionId: revision.id,
+            workId: anchor,
+            createdAt: revision.createdAt,
+        };
+        const resolved = resolvedGate(deps, next);
+        if (!resolved)
+            throw new Error("Checkpoint inputs could not be resolved");
+        const before = resolvedGate(deps, gate, true);
+        const after = resolvedGate(deps, next, true);
+        const same = before !== undefined &&
+            after !== undefined &&
+            before.currentFingerprint === after.currentFingerprint;
+        if (!same && gate.state !== "canceled")
+            deps.db
+                .prepare("UPDATE review_checkpoints SET state='invalidated',approved_at=NULL WHERE project_id=? AND revision_id=? AND checkpoint_id=?")
+                .run(gate.projectId, gate.revisionId, gate.checkpointId);
+        deps.db
+            .prepare(`INSERT INTO review_checkpoints(project_id,revision_id,checkpoint_id,stage,work_id,fingerprint,state,created_at,approved_at)
+      VALUES (?,?,?,?,?,?,?,?,?)`)
+            .run(revision.projectId, revision.id, gate.checkpointId, gate.stage, anchor, resolved.currentFingerprint, same && gate.state !== "canceled" ? gate.state : "held", revision.createdAt, same && gate.state !== "canceled" ? gate.approvedAt : null);
+    }
+    settleReleasedCheckpoints(deps, revision.projectId, revision.id);
+}
+export function settleReleasedCheckpoints(deps, projectId, revisionId = currentRevisionId(deps.db, projectId)) {
+    if (revisionId === undefined || currentRevisionId(deps.db, projectId) !== revisionId)
+        return [];
+    const closures = listCheckpoints(deps.db, projectId, revisionId).flatMap((row) => {
+        if (row.state !== "released" || row.approvedAt === null)
+            return [];
+        const resolved = resolvedGate(deps, row);
+        return resolved === undefined
+            ? []
+            : [
+                {
+                    projectId,
+                    revisionId,
+                    checkpointId: row.checkpointId,
+                    workKeys: resolved.workKeys,
+                },
+            ];
+    });
+    return settleCheckpointClosures(deps.db, closures);
+}
+export function recoverCheckpointWork(db) {
+    transact(db, () => {
+        const retained = db
+            .prepare(`SELECT DISTINCT w.id FROM revision_work w
+      JOIN revision_work_reservations r ON r.work_id=w.id
+      JOIN project_heads h ON h.project_id=r.project_id AND h.revision_id=r.revision_id
+      JOIN review_checkpoints c ON c.project_id=h.project_id AND c.revision_id=h.revision_id
+      WHERE w.state='pending' AND w.dispatch_state='allowed'
+      AND c.state IN ('held','pending-review','released')
+      AND (w.kind=c.stage OR w.kind='video')
+      AND NOT EXISTS (SELECT 1 FROM stages s WHERE s.project_id=w.project_id AND s.state='canceled')
+      AND NOT EXISTS (SELECT 1 FROM revision_work_pieces p WHERE p.work_id=w.id
+        AND (p.submitted_at IS NOT NULL OR p.continuation IS NOT NULL OR p.state IN ('running','done')))`)
+            .all()
+            .map((row) => z.string().parse(row.id));
+        recoverWork(db);
+        for (const id of retained) {
+            db.prepare("UPDATE revision_work SET dispatch_state='allowed' WHERE id=? AND state='pending'").run(id);
+            db.prepare("UPDATE revision_work_pieces SET state='pending',dispatch_state='allowed' WHERE work_id=? AND submitted_at IS NULL AND continuation IS NULL").run(id);
+        }
+    });
+}

package/dist/slices/checkpoints/repo.js

@@ -0,0 +1,132 @@
+import { transact } from "../../kernel/db/tx.js";
+import { checkpointApprovalSchema, checkpointRowSchema, checkpointSetSchema } from "./schema.js";
+const select = `SELECT project_id AS projectId,revision_id AS revisionId,checkpoint_id AS checkpointId,
+ stage,work_id AS workId,fingerprint,state,created_at AS createdAt,approved_at AS approvedAt
+ FROM review_checkpoints`;
+export function listCheckpoints(db, projectId, revisionId) {
+    return db
+        .prepare(`${select} WHERE project_id=? AND revision_id=? ORDER BY checkpoint_id`)
+        .all(projectId, revisionId)
+        .map((row) => checkpointRowSchema.parse(row));
+}
+export function checkpointForWork(db, workId) {
+    return db
+        .prepare(`${select} WHERE (project_id,revision_id) IN
+    (SELECT project_id,revision_id FROM revision_work WHERE id=?) ORDER BY checkpoint_id`)
+        .all(workId)
+        .map((row) => checkpointRowSchema.parse(row));
+}
+/**
+ * Marks released checkpoints satisfied once every reservation in their exact
+ * reviewed closure has reached a terminal state. Missing reservations keep a
+ * checkpoint released: an incomplete materialization must never look complete.
+ */
+export function settleCheckpointClosures(db, closures) {
+    const settle = () => {
+        const satisfied = [];
+        for (const closure of closures) {
+            if (closure.workKeys.length === 0 ||
+                new Set(closure.workKeys).size !== closure.workKeys.length)
+                continue;
+            const terminal = db.prepare(`SELECT 1 FROM revision_work_reservations r
+        JOIN revision_work w ON w.id=r.work_id
+        WHERE r.project_id=? AND r.revision_id=? AND r.work_key=?
+        AND w.state IN ('done','failed','canceled')`);
+            if (!closure.workKeys.every((key) => terminal.get(closure.projectId, closure.revisionId, key) !== undefined))
+                continue;
+            const changed = db
+                .prepare(`UPDATE review_checkpoints SET state='satisfied'
+          WHERE project_id=? AND revision_id=? AND checkpoint_id=?
+          AND state='released' AND approved_at IS NOT NULL`)
+                .run(closure.projectId, closure.revisionId, closure.checkpointId);
+            if (Number(changed.changes) !== 1)
+                continue;
+            const row = listCheckpoints(db, closure.projectId, closure.revisionId).find((candidate) => candidate.checkpointId === closure.checkpointId);
+            if (row !== undefined)
+                satisfied.push(row);
+        }
+        return satisfied;
+    };
+    return db.isTransaction ? settle() : transact(db, settle);
+}
+export function saveCheckpointSet(db, input) {
+    const parsed = checkpointSetSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const value = parsed.data;
+    return transact(db, () => {
+        if (!db
+            .prepare("SELECT 1 FROM project_revisions WHERE project_id=? AND id=?")
+            .get(value.projectId, value.revisionId))
+            return { ok: false, reason: "not-found" };
+        if (new Set(value.checkpoints.map((gate) => gate.checkpointId)).size !==
+            value.checkpoints.length ||
+            new Set(value.checkpoints.map((gate) => gate.stage)).size !== value.checkpoints.length)
+            return { ok: false, reason: "duplicate" };
+        const existing = listCheckpoints(db, value.projectId, value.revisionId);
+        if (existing.length) {
+            const same = existing.length === value.checkpoints.length &&
+                existing.every((row) => value.checkpoints.some((gate) => gate.checkpointId === row.checkpointId &&
+                    gate.stage === row.stage &&
+                    gate.workId === row.workId &&
+                    gate.fingerprint === row.fingerprint));
+            return same
+                ? { ok: false, reason: "duplicate", value: existing }
+                : { ok: false, reason: "conflict" };
+        }
+        for (const gate of value.checkpoints) {
+            const work = db
+                .prepare("SELECT project_id,revision_id,kind FROM revision_work WHERE id=?")
+                .get(gate.workId);
+            if (!work)
+                return { ok: false, reason: "not-found" };
+            if (work.project_id !== value.projectId ||
+                work.revision_id !== value.revisionId ||
+                work.kind !== gate.stage)
+                return { ok: false, reason: "conflict" };
+        }
+        for (const gate of value.checkpoints)
+            db.prepare(`INSERT INTO review_checkpoints(project_id,revision_id,checkpoint_id,stage,work_id,fingerprint,state,created_at)
+        VALUES (?,?,?,?,?,?,?,?)`).run(value.projectId, value.revisionId, gate.checkpointId, gate.stage, gate.workId, gate.fingerprint, gate.state, value.createdAt);
+        return { ok: true, value: listCheckpoints(db, value.projectId, value.revisionId) };
+    });
+}
+export function approveCheckpoint(db, input) {
+    const parsed = checkpointApprovalSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const value = parsed.data;
+    return transact(db, () => {
+        const receipt = db
+            .prepare("SELECT revision_id,checkpoint_id,fingerprint FROM review_checkpoint_approvals WHERE project_id=? AND idempotency_key=?")
+            .get(value.projectId, value.idempotencyKey);
+        if (receipt &&
+            (receipt.revision_id !== value.revisionId ||
+                receipt.checkpoint_id !== value.checkpointId ||
+                receipt.fingerprint !== value.fingerprint))
+            return { ok: false, reason: "conflict" };
+        const row = listCheckpoints(db, value.projectId, value.revisionId).find((gate) => gate.checkpointId === value.checkpointId);
+        if (!row)
+            return { ok: false, reason: "not-found" };
+        const head = db
+            .prepare("SELECT revision_id FROM project_heads WHERE project_id=?")
+            .get(value.projectId);
+        if (head?.revision_id !== value.revisionId || row.fingerprint !== value.fingerprint)
+            return { ok: false, reason: "conflict" };
+        if (row.state === "released" || (row.state === "satisfied" && receipt))
+            return { ok: false, reason: "duplicate", value: row };
+        if (receipt)
+            return { ok: false, reason: "conflict" };
+        if (row.state !== "held" && row.state !== "pending-review")
+            return { ok: false, reason: "conflict" };
+        const changed = db
+            .prepare(`UPDATE review_checkpoints SET state='released',approved_at=?
+      WHERE project_id=? AND revision_id=? AND checkpoint_id=? AND fingerprint=? AND state=?`)
+            .run(value.approvedAt, value.projectId, value.revisionId, value.checkpointId, value.fingerprint, row.state);
+        if (Number(changed.changes) !== 1)
+            return { ok: false, reason: "conflict" };
+        db.prepare(`INSERT INTO review_checkpoint_approvals(project_id,idempotency_key,revision_id,checkpoint_id,fingerprint,approved_at)
+      VALUES (?,?,?,?,?,?)`).run(value.projectId, value.idempotencyKey, value.revisionId, value.checkpointId, value.fingerprint, value.approvedAt);
+        return { ok: true, value: { ...row, state: "released", approvedAt: value.approvedAt } };
+    });
+}

package/dist/slices/checkpoints/rules.js

@@ -0,0 +1,30 @@
+import { checkpointClosure, checkpointFingerprint } from "./fingerprint.js";
+export function isApprovalCurrent(row, revision, fingerprint) {
+    return (row.projectId === revision.projectId &&
+        row.revisionId === revision.id &&
+        row.fingerprint === fingerprint &&
+        row.approvedAt !== null &&
+        (row.state === "released" || row.state === "satisfied"));
+}
+export function canChangeCheckpoint(stageState, submitted) {
+    return stageState === "pending" && !submitted
+        ? { kind: "eligible" }
+        : { kind: "refused", reason: "conflict" };
+}
+export function checkpointDecision(work, rows, revision, recipes) {
+    if (work.projectId !== revision.projectId || work.revisionId !== revision.id)
+        return { kind: "refused", reason: "conflict" };
+    const held = new Set();
+    for (const row of rows) {
+        if (row.projectId !== revision.projectId || row.revisionId !== revision.id)
+            return { kind: "refused", reason: "conflict" };
+        const closure = checkpointClosure(row.stage, recipes);
+        if (!closure.some((recipe) => recipe.stage === work.kind))
+            continue;
+        if (row.state === "canceled")
+            return { kind: "refused", reason: "conflict" };
+        if (!isApprovalCurrent(row, revision, checkpointFingerprint(revision, closure)))
+            held.add(row.checkpointId);
+    }
+    return held.size ? { kind: "held", checkpointIds: [...held].sort() } : { kind: "eligible" };
+}

package/dist/slices/checkpoints/schema.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+const id = z.string().min(1);
+const fingerprint = z.string().regex(/^[a-f0-9]{64}$/);
+export const checkpointStageSchema = z.enum(["audio", "images", "video"]);
+export const checkpointStateSchema = z.enum([
+    "configured",
+    "pending-review",
+    "held",
+    "released",
+    "satisfied",
+    "invalidated",
+    "canceled",
+]);
+export const checkpointRowSchema = z
+    .object({
+    projectId: id,
+    revisionId: id,
+    checkpointId: id,
+    stage: checkpointStageSchema,
+    workId: id,
+    fingerprint,
+    state: checkpointStateSchema,
+    createdAt: z.iso.datetime(),
+    approvedAt: z.iso.datetime().nullable(),
+})
+    .strict()
+    .readonly();
+export const checkpointSetSchema = z
+    .object({
+    projectId: id,
+    revisionId: id,
+    checkpoints: z
+        .array(z
+        .object({
+        checkpointId: id,
+        stage: checkpointStageSchema,
+        workId: id,
+        fingerprint,
+        state: z.enum(["configured", "pending-review", "held"]),
+    })
+        .strict()
+        .readonly())
+        .max(3)
+        .readonly(),
+    createdAt: z.iso.datetime(),
+})
+    .strict()
+    .readonly();
+export const checkpointApprovalSchema = z
+    .object({
+    projectId: id,
+    revisionId: id,
+    checkpointId: id,
+    fingerprint,
+    idempotencyKey: z.uuid(),
+    approvedAt: z.iso.datetime(),
+})
+    .strict()
+    .readonly();