@gentbajko/slopify 0.8.4 → 1.0.0

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

@@ -0,0 +1,242 @@
+import { statSync } from "node:fs";
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { stagingPath } from "../storage/layout.js";
+import { stagedFileById } from "../storage/repo.js";
+import { releaseStagedFile } from "../storage/staging-refs.js";
+import { attachmentRefs, attachmentRow, attachmentRows, draftRow, draftRows, insertAttachment, insertDraft, requestHash, syncAttachments, } from "./repo.js";
+import { createDraftInputSchema, discardDraftInputSchema, draftViewSchema, forkDraftInputSchema, playDraftDocumentSchema, playReviewSchema, playStartResultSchema, saveDraftInputSchema, } from "./schema.js";
+function refusal(reason, row) {
+    return {
+        ok: false,
+        reason,
+        currentVersion: row?.version ?? null,
+        fields: [],
+        ...(row?.state === "starting" && row.review_id !== null ? { reviewId: row.review_id } : {}),
+    };
+}
+function writable(row) {
+    if (row === undefined)
+        return refusal("not-found");
+    if (row.state === "starting")
+        return refusal("pending-start", row);
+    if (row.state === "started")
+        return refusal("already-started", row);
+    return null;
+}
+function validRefs(deps, id, document) {
+    const refs = attachmentRefs(document);
+    if (new Set(refs.map((ref) => ref.attachmentId)).size !== refs.length)
+        return false;
+    return refs.every((ref) => {
+        const old = attachmentRow(deps.db, ref.attachmentId);
+        return (old === undefined ||
+            (old.draft_id === id && old.kind === ref.kind && old.original_filename === ref.name));
+    });
+}
+function parseStoredJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}
+function documentOf(row) {
+    if (row.schema_version !== 1)
+        return null;
+    const parsed = playDraftDocumentSchema.safeParse(parseStoredJson(row.document_json));
+    return parsed.success ? parsed.data : null;
+}
+function attachmentsOf(deps, id) {
+    return attachmentRows(deps.db, id).map((row) => {
+        const staged = row.staged_file_id === null ? undefined : stagedFileById(deps.db, row.staged_file_id);
+        const file = staged === undefined
+            ? undefined
+            : statSync(stagingPath(deps.paths, staged.path), { throwIfNoEntry: false });
+        const invalid = (row.status === "ready" && row.staged_file_id === null) ||
+            (row.staged_file_id !== null &&
+                (staged === undefined ||
+                    (staged.state === "staged" && (!file?.isFile() || file.size !== staged.bytes))));
+        const state = invalid ? "reattach" : staged?.state === "copying" ? "copying" : row.status;
+        return {
+            id: row.id,
+            kind: row.kind,
+            name: row.original_filename,
+            state,
+            stagedFileId: invalid ? null : row.staged_file_id,
+            bytes: invalid ? 0 : (staged?.bytes ?? 0),
+            error: invalid ? "Upload is missing or incomplete. Reattach the file." : row.error,
+        };
+    });
+}
+export function readDraft(deps, id) {
+    if (!z.uuid().safeParse(id).success)
+        return refusal("invalid-edit");
+    const row = draftRow(deps.db, id);
+    if (row === undefined)
+        return refusal("not-found");
+    const document = documentOf(row);
+    if (document === null)
+        return refusal("invalid-draft", row);
+    const receipt = row.start_id === null
+        ? undefined
+        : deps.db.prepare("SELECT result_json FROM play_start_receipts WHERE id=?").get(row.start_id);
+    const start = receipt === undefined
+        ? null
+        : playStartResultSchema.parse(JSON.parse(z.object({ result_json: z.string() }).parse(receipt).result_json));
+    const parsedReview = row.review_json === null
+        ? null
+        : z.object({ review: playReviewSchema }).safeParse(parseStoredJson(row.review_json));
+    if (parsedReview !== null && !parsedReview.success)
+        return refusal("invalid-draft", row);
+    const review = parsedReview?.data?.review ?? null;
+    return {
+        ok: true,
+        value: draftViewSchema.parse({
+            draft: {
+                id: row.id,
+                version: row.version,
+                createdAt: row.created_at,
+                updatedAt: row.updated_at,
+                document,
+            },
+            attachments: attachmentsOf(deps, id),
+            review,
+            pendingStart: row.state === "starting" && row.review_id !== null
+                ? { reviewId: row.review_id, draftVersion: row.version }
+                : null,
+            start,
+        }),
+    };
+}
+export function listDrafts(deps) {
+    return draftRows(deps.db).map((row) => ({
+        id: row.id,
+        title: row.title,
+        version: row.version,
+        updatedAt: row.updated_at,
+        readable: documentOf(row) !== null,
+    }));
+}
+export function createDraft(deps, input) {
+    const parsed = createDraftInputSchema.safeParse(input);
+    if (!parsed.success)
+        return refusal("invalid-edit");
+    return transact(deps.db, () => {
+        const value = parsed.data;
+        const hash = requestHash(value);
+        const old = draftRow(deps.db, value.id);
+        if (old !== undefined)
+            return old.creation_hash === hash && old.version === 1 && old.state === "active"
+                ? readDraft(deps, value.id)
+                : refusal("conflict", old);
+        if (!validRefs(deps, value.id, value.document))
+            return refusal("invalid-edit");
+        insertDraft(deps.db, value.id, value.document, hash, deps.clock.now().toISOString());
+        syncAttachments(deps.db, value.id, value.document);
+        return readDraft(deps, value.id);
+    });
+}
+export function saveDraft(deps, input) {
+    const parsed = saveDraftInputSchema.safeParse(input);
+    if (!parsed.success)
+        return refusal("invalid-edit");
+    const previous = attachmentRows(deps.db, input.id);
+    const result = transact(deps.db, () => {
+        const value = parsed.data;
+        const row = draftRow(deps.db, value.id);
+        const denied = writable(row);
+        if (denied !== null || row === undefined)
+            return denied ?? refusal("not-found");
+        const hash = requestHash(value);
+        if (row.save_mutation_id === value.mutationId)
+            return row.save_request_hash === hash ? readDraft(deps, value.id) : refusal("conflict", row);
+        if (row.version !== value.baseVersion)
+            return refusal("conflict", row);
+        if (!validRefs(deps, value.id, value.document))
+            return refusal("invalid-edit", row);
+        const changed = deps.db
+            .prepare("UPDATE play_drafts SET version=version+1,document_json=?,title=?,updated_at=?,save_mutation_id=?,save_request_hash=?,review_id=NULL,review_json=NULL,review_fingerprint=NULL WHERE id=? AND version=? AND state='active'")
+            .run(JSON.stringify(value.document), value.document.form.title, deps.clock.now().toISOString(), value.mutationId, hash, value.id, value.baseVersion);
+        if (Number(changed.changes) !== 1)
+            return refusal("conflict", draftRow(deps.db, value.id));
+        syncAttachments(deps.db, value.id, value.document);
+        return readDraft(deps, value.id);
+    });
+    if (result.ok)
+        for (const attachment of previous)
+            if (attachment.staged_file_id !== null)
+                releaseStagedFile({ ...deps, emit: () => undefined }, attachment.staged_file_id);
+    return result;
+}
+export function forkDraft(deps, input) {
+    const parsed = forkDraftInputSchema.safeParse(input);
+    if (!parsed.success)
+        return refusal("invalid-edit");
+    return transact(deps.db, () => {
+        const value = parsed.data;
+        const hash = requestHash(value);
+        const old = draftRow(deps.db, value.id);
+        if (old !== undefined)
+            return old.creation_hash === hash && old.version === 1 && old.state === "active"
+                ? readDraft(deps, value.id)
+                : refusal("conflict", old);
+        const source = draftRow(deps.db, value.sourceId);
+        const denied = writable(source);
+        if (denied !== null)
+            return denied;
+        if (!validRefs(deps, value.sourceId, value.document))
+            return refusal("invalid-edit", source);
+        const states = new Map(attachmentsOf(deps, value.sourceId).map((file) => [file.id, file]));
+        const replacements = new Map(attachmentRefs(value.document).map((ref) => [ref.attachmentId, z.uuid().parse(deps.uuid())]));
+        const rewrite = (ref) => ({
+            attachmentId: z.uuid().parse(replacements.get(ref.attachmentId)),
+            name: ref.name,
+        });
+        const p = value.document.form.provided;
+        const document = {
+            ...value.document,
+            form: {
+                ...value.document.form,
+                provided: {
+                    ...p,
+                    audio: p.audio === null ? null : rewrite(p.audio),
+                    thumbnail: p.thumbnail === null ? null : rewrite(p.thumbnail),
+                    images: p.images.map(rewrite),
+                },
+            },
+        };
+        insertDraft(deps.db, value.id, document, hash, deps.clock.now().toISOString());
+        for (const ref of attachmentRefs(value.document)) {
+            const original = states.get(ref.attachmentId);
+            const ready = original?.state === "ready" && original.stagedFileId !== null;
+            insertAttachment(deps.db, value.id, { ...ref, ...rewrite(ref) }, ready ? "ready" : "reattach", ready ? original.stagedFileId : null);
+        }
+        return readDraft(deps, value.id);
+    });
+}
+export function discardDraft(deps, input) {
+    const parsed = discardDraftInputSchema.safeParse(input);
+    if (!parsed.success)
+        return refusal("invalid-edit");
+    const previous = attachmentRows(deps.db, input.id);
+    const result = transact(deps.db, () => {
+        const row = draftRow(deps.db, input.id);
+        if (row === undefined)
+            return refusal("not-found");
+        if (row.state === "starting")
+            return refusal("pending-start", row);
+        if (row.version !== input.baseVersion)
+            return refusal("conflict", row);
+        deps.db.prepare("DELETE FROM play_drafts WHERE id=?").run(input.id);
+        return { ok: true, value: { discarded: true } };
+    });
+    if (result.ok)
+        for (const attachment of previous)
+            if (attachment.staged_file_id !== null)
+                releaseStagedFile({ ...deps, emit: () => undefined }, attachment.staged_file_id);
+    return result;
+}

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

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import { catalogueSchema } from "../../catalog/schema.js";
+import { draftRow, requestHash } from "./repo.js";
+import { resolveReviewInputs } from "./review.js";
+import { playReviewSchema, playStartResultSchema } from "./schema.js";
+import { readDraft } from "./service.js";
+const receiptSchema = z.object({
+    id: z.uuid(),
+    draft_id: z.uuid(),
+    draft_version: z.number().int().positive(),
+    request_hash: z.string(),
+    result_json: z.string(),
+});
+export const executionSchema = z.object({
+    review: playReviewSchema,
+    execution: z.object({
+        catalogue: catalogueSchema,
+        attachmentIdentity: z.array(z.object({ id: z.uuid(), stagedFileId: z.string(), bytes: z.number() })),
+        font: z
+            .object({
+            id: z.string(),
+            name: z.string(),
+            family: z.string(),
+            source: z.enum(["bundled", "system", "uploaded"]),
+            path: z.string(),
+            extension: z.enum([".ttf", ".otf", ".ttc"]),
+            assName: z.string(),
+            faceIndex: z.number(),
+        })
+            .nullable(),
+    }),
+});
+export function readStartReceipt(db, reviewId) {
+    const raw = db.prepare("SELECT * FROM play_start_receipts WHERE id=?").get(reviewId);
+    if (!raw)
+        return undefined;
+    const row = receiptSchema.parse(raw);
+    return {
+        id: row.id,
+        draftId: row.draft_id,
+        draftVersion: row.draft_version,
+        requestHash: row.request_hash,
+        result: playStartResultSchema.parse(JSON.parse(row.result_json)),
+    };
+}
+export function replayResult(receipt, input) {
+    if (receipt.id !== input.reviewId ||
+        receipt.draftId !== input.draftId ||
+        receipt.draftVersion !== input.baseVersion ||
+        receipt.requestHash !== requestHash(input) ||
+        receipt.result.requestId !== input.reviewId)
+        return { ok: false, reason: "conflict", currentVersion: receipt.draftVersion, fields: [] };
+    return { ok: true, value: { ...receipt.result, replayed: true } };
+}
+export function requireStartingIdentity(deps, input) {
+    const row = draftRow(deps.db, input.draftId);
+    const denied = (reason) => ({
+        ok: false,
+        reason,
+        currentVersion: row?.version ?? null,
+        fields: [],
+        ...(row?.start_id ? { reviewId: row.start_id } : {}),
+    });
+    if (!row)
+        return denied("not-found");
+    if (row.state !== "starting" || row.start_id !== input.reviewId)
+        return denied("pending-start");
+    if (row.version !== input.baseVersion)
+        return denied("conflict");
+    if (row.review_id !== input.reviewId || row.review_json === null)
+        return denied("stale-review");
+    const stored = executionSchema.parse(JSON.parse(row.review_json));
+    const view = readDraft(deps, input.draftId);
+    if (!view.ok)
+        return view;
+    const resolved = resolveReviewInputs(deps, view.value, stored.execution.font);
+    if (!resolved.ok)
+        return { ...resolved, reason: "stale-review" };
+    const { fingerprint: _fingerprint, ...current } = resolved.value;
+    if (requestHash({
+        ...(stored.review.checkpointSet === undefined
+            ? {}
+            : { checkpointSet: stored.review.checkpointSet }),
+        runs: stored.review.runs,
+        estimates: stored.review.estimates,
+        ...stored.execution,
+    }) !== requestHash(current) ||
+        stored.review.draftId !== input.draftId ||
+        stored.review.draftVersion !== input.baseVersion ||
+        stored.review.id !== input.reviewId ||
+        resolved.value.fingerprint !== stored.review.fingerprint ||
+        row.review_fingerprint !== stored.review.fingerprint)
+        return denied("stale-review");
+    return { ok: true, value: stored.review };
+}
+export function insertStartReceipt(deps, input, value) {
+    deps.db
+        .prepare("INSERT INTO play_start_receipts(id,draft_id,draft_version,request_hash,result_json,created_at) VALUES(?,?,?,?,?,?)")
+        .run(input.reviewId, input.draftId, input.baseVersion, requestHash(input), JSON.stringify(playStartResultSchema.parse(value)), deps.clock.now().toISOString());
+}
+export function markDraftStartedAndReleaseRefs(db, input) {
+    const changed = db
+        .prepare("UPDATE play_drafts SET state='started' WHERE id=? AND version=? AND state='starting' AND start_id=?")
+        .run(input.draftId, input.baseVersion, input.reviewId);
+    if (Number(changed.changes) !== 1)
+        throw new Error("The pending Start identity changed");
+    db.prepare("DELETE FROM play_draft_attachments WHERE draft_id=?").run(input.draftId);
+}
+export function releaseStartClaim(deps, input, stale) {
+    deps.db
+        .prepare(`UPDATE play_drafts SET state='active',start_id=NULL${stale ? ",review_id=NULL,review_json=NULL,review_fingerprint=NULL" : ""} WHERE id=? AND version=? AND state='starting' AND start_id=?`)
+        .run(input.draftId, input.baseVersion, input.reviewId);
+}

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

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

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

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