@gentbajko/slopify 0.8.3 → 1.0.0

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

@@ -0,0 +1,218 @@
+import { z } from "zod";
+import { formats } from "../../kernel/pipeline.js";
+import { thinkingModes } from "../../kernel/ports/llm.js";
+import { stageSources } from "../admission/model.js";
+import { runDraftSchema } from "../admission/schema.js";
+import { checkpointRowSchema, checkpointStageSchema } from "../checkpoints/schema.js";
+import { librarySnapshotSchema } from "../library/snapshot.js";
+import { chunkModes } from "../narration/chunk.js";
+import { subtitleModes, subtitlePositions } from "../subtitles/model.js";
+const id = z.uuid();
+const text = z.string();
+const values = z.record(text, text).readonly();
+const provider = z
+    .object({ provider: text, model: text, thinking: z.enum(thinkingModes).optional() })
+    .strict();
+const file = z.object({ attachmentId: id, name: text }).strict().readonly();
+export const playDraftFormSchema = z
+    .object({
+    title: text,
+    checkpoints: runDraftSchema.shape.checkpoints,
+    format: z.enum(formats),
+    sources: z
+        .object({
+        research: z.enum(stageSources),
+        article: z.enum(stageSources),
+        audio: z.enum(stageSources),
+        images: z.enum(stageSources),
+        thumbnail: z.enum(stageSources),
+        video: z.enum(stageSources),
+    })
+        .strict()
+        .readonly(),
+    llm: provider.readonly(),
+    audio: provider.extend({ voice: text }).readonly(),
+    images: provider.readonly(),
+    articlePrompt: text,
+    imagePrompts: z.array(z.object({ name: text, number: text }).strict().readonly()).readonly(),
+    thumbnailPrompt: text,
+    intro: text,
+    outro: text,
+    chunking: z
+        .object({ mode: z.enum(chunkModes), words: text, characters: text })
+        .strict()
+        .readonly(),
+    subtitles: z
+        .object({
+        mode: z.enum(subtitleModes),
+        language: z.literal("en"),
+        fontId: text,
+        fontSize: text,
+        position: z.enum(subtitlePositions),
+    })
+        .strict()
+        .readonly(),
+    values,
+    provided: z
+        .object({
+        research: text,
+        article: text,
+        audio: file.nullable(),
+        thumbnail: file.nullable(),
+        images: z.array(file).readonly(),
+    })
+        .strict()
+        .readonly(),
+})
+    .strict()
+    .readonly();
+export const playDraftDocumentSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    librarySnapshot: librarySnapshotSchema.optional(),
+    templateSource: z
+        .object({ id, version: z.number().int().positive() })
+        .strict()
+        .readonly()
+        .optional(),
+    form: playDraftFormSchema,
+    section: z.enum(["content", "outputs", "style", "review"]),
+    variants: z.array(z.object({ id, title: text, values }).strict().readonly()).readonly(),
+    expectedWords: text,
+    previewText: text,
+    fontUpload: z.object({ operationId: id, name: text }).strict().readonly().nullable(),
+})
+    .strict()
+    .readonly();
+export const createDraftInputSchema = z
+    .object({ id, document: playDraftDocumentSchema })
+    .strict()
+    .readonly();
+export const saveDraftInputSchema = createDraftInputSchema
+    .unwrap()
+    .extend({ baseVersion: z.number().int().positive(), mutationId: id })
+    .strict()
+    .readonly();
+export const forkDraftInputSchema = createDraftInputSchema
+    .unwrap()
+    .extend({ sourceId: id })
+    .strict()
+    .readonly();
+export const discardDraftInputSchema = z
+    .object({ id, baseVersion: z.number().int().positive() })
+    .strict()
+    .readonly();
+export const draftAttachmentSchema = z
+    .object({
+    id,
+    kind: z.enum(["audio", "images", "thumbnail"]),
+    name: text,
+    state: z.enum(["pending", "copying", "ready", "reattach"]),
+    stagedFileId: text.nullable(),
+    bytes: z.number().nonnegative(),
+    error: text.nullable(),
+})
+    .strict()
+    .readonly();
+export const playDraftSchema = z
+    .object({
+    id,
+    version: z.number().int().positive(),
+    createdAt: text,
+    updatedAt: text,
+    document: playDraftDocumentSchema,
+})
+    .strict()
+    .readonly();
+export const playStartResultSchema = z
+    .object({
+    checkpointSet: z
+        .array(checkpointRowSchema.unwrap().extend({ reviewedFingerprint: text }).strict().readonly())
+        .readonly()
+        .optional(),
+    requestId: id,
+    projectIds: z.array(text).readonly(),
+    queue: z
+        .array(z
+        .object({
+        projectId: text,
+        batchId: text,
+        position: z.number(),
+        state: z.enum(["queued", "active", "finished"]),
+    })
+        .strict()
+        .readonly())
+        .readonly(),
+    replayed: z.boolean(),
+})
+    .strict()
+    .readonly();
+const costEstimateSchema = z
+    .object({
+    currency: z.literal("USD"),
+    rows: z
+        .array(z
+        .object({
+        stage: text,
+        low: z.number().nullable(),
+        high: z.number().nullable(),
+        detail: text,
+    })
+        .strict()
+        .readonly())
+        .readonly(),
+    low: z.number(),
+    high: z.number(),
+    unknown: z.number(),
+    expectedWords: z.number(),
+    catalogueDate: text.nullable(),
+    assumptions: z.array(text).readonly(),
+})
+    .strict()
+    .readonly();
+export const playReviewSchema = z
+    .object({
+    checkpointSet: z
+        .array(z
+        .object({
+        runIndex: z.number().int().nonnegative(),
+        checkpointId: text,
+        stage: checkpointStageSchema,
+        fingerprint: text,
+        workKeys: z.array(text).readonly(),
+        dependents: z
+            .array(z.enum(["research", "article", "audio", "images", "thumbnail", "video"]))
+            .readonly(),
+    })
+        .strict()
+        .readonly())
+        .readonly()
+        .optional(),
+    id,
+    draftId: id,
+    draftVersion: z.number().int().positive(),
+    fingerprint: text,
+    runs: z
+        .array(z
+        .object({ draft: runDraftSchema, rendered: values, templates: values })
+        .strict()
+        .readonly())
+        .readonly(),
+    estimates: z.array(costEstimateSchema).readonly(),
+})
+    .strict()
+    .readonly();
+export const draftViewSchema = z
+    .object({
+    draft: playDraftSchema,
+    attachments: z.array(draftAttachmentSchema).readonly(),
+    review: playReviewSchema.nullable(),
+    pendingStart: z
+        .object({ reviewId: id, draftVersion: z.number().int().positive() })
+        .strict()
+        .readonly()
+        .nullable(),
+    start: playStartResultSchema.nullable(),
+})
+    .strict()
+    .readonly();

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