@gentbajko/slopify 0.8.4 → 1.0.1

package/dist/slices/play-drafts/review-inputs.js

@@ -0,0 +1,150 @@
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { z } from "zod";
+import { modelFields } from "../../catalog/validate.js";
+import { admit } from "../admission/rules.js";
+import { estimateRun } from "../estimate/index.js";
+import { listEntries } from "../library/repo.js";
+import { pickTemplates, renderPicked } from "../library/slots.js";
+import { reviewCheckpointSet } from "../rebuild/recipe-checkpoints.js";
+import { readSettings } from "../settings/playback.js";
+import { stagedFiles } from "../storage/repo.js";
+import { toAdmissionDraft } from "./convert.js";
+import { requestHash } from "./repo.js";
+import { readDraft } from "./service.js";
+export function reviewRefusal(view, fields, reason = "readiness") {
+    return { ok: false, reason, currentVersion: view.draft.version, fields };
+}
+export function reviewBinding(value) {
+    return requestHash({
+        ...(value.checkpointSet === undefined ? {} : { checkpointSet: value.checkpointSet }),
+        runs: value.runs,
+        estimates: value.estimates,
+        catalogue: value.catalogue,
+        attachmentIdentity: value.attachmentIdentity,
+    });
+}
+export function resolveReviewInputs(deps, view, font) {
+    const fresh = readDraft(deps, view.draft.id);
+    if (!fresh.ok)
+        return fresh;
+    if (fresh.value.draft.version !== view.draft.version ||
+        requestHash(fresh.value.draft.document) !== requestHash(view.draft.document))
+        return reviewRefusal(fresh.value, [], "stale-review");
+    const { document } = view.draft;
+    const fields = [];
+    if (document.fontUpload !== null)
+        fields.push({
+            field: "fontUpload",
+            message: "Wait for the font upload to finish or choose another font.",
+        });
+    const words = z
+        .number()
+        .int()
+        .min(1)
+        .max(100000)
+        .safeParse(document.expectedWords.trim() === "" ? Number.NaN : Number(document.expectedWords));
+    if (!words.success)
+        fields.push({ field: "expectedWords", message: "Enter a whole number between 1 and 100000." });
+    if (document.variants.length > 49)
+        fields.push({ field: "variants", message: "Review at most 50 runs including the base run." });
+    const converted = toAdmissionDraft({
+        document,
+        attachments: fresh.value.attachments,
+        entries: [...(document.librarySnapshot?.entries ?? []), ...listEntries(deps.db)],
+        silenceGapSeconds: readSettings(deps).silenceGapSeconds,
+    });
+    if (!converted.ok)
+        fields.push(...converted.fields);
+    if (!converted.ok || !words.success || fields.length)
+        return reviewRefusal(view, fields);
+    const catalogue = deps.catalogue.read();
+    const captured = {
+        ...deps.catalogue,
+        read: () => catalogue,
+        models: (provider, family) => catalogue[family].filter((model) => model.provider === provider && model.enabled && !model.deprecated),
+    };
+    const staged = stagedFiles(deps.db);
+    const basePicked = pickTemplates(deps.db, converted.draft, document.librarySnapshot);
+    const drafts = [
+        basePicked.draft,
+        ...document.variants.map((variant) => ({
+            ...basePicked.draft,
+            title: variant.title,
+            values: { ...basePicked.draft.values, ...variant.values },
+        })),
+    ];
+    const runs = [];
+    for (const [index, draft] of drafts.entries()) {
+        const values = Object.fromEntries(basePicked.requiredSlots.map((name) => [
+            name,
+            Object.hasOwn(draft.values, name) ? (draft.values[name] ?? "") : "",
+        ]));
+        const admitted = admit({
+            draft: { ...draft, values },
+            staged,
+            requiredSlots: basePicked.requiredSlots,
+        });
+        const accepted = admitted.ok ? admitted.draft : draft;
+        const issues = [
+            ...basePicked.missing,
+            ...(admitted.ok ? [] : admitted.fields),
+            ...modelFields(accepted, captured),
+        ];
+        fields.push(...issues.map((issue) => ({
+            ...issue,
+            field: index > 0 && (issue.field === "title" || issue.field.startsWith("values."))
+                ? `variants.${index - 1}.${issue.field}`
+                : issue.field,
+            message: `${index > 0 ? `Run ${index + 1}: ` : ""}${issue.message}`,
+        })));
+        runs.push({
+            draft: accepted,
+            rendered: renderPicked(basePicked, accepted.values),
+            templates: Object.fromEntries(basePicked.bodies.map(({ key, body }) => [key, body])),
+        });
+    }
+    const activeIds = new Set(runs.flatMap((run) => [
+        run.draft.provided.audio,
+        run.draft.provided.thumbnail,
+        ...(run.draft.provided.images ?? []),
+    ]));
+    const attachmentIdentity = fresh.value.attachments.flatMap((file) => file.stagedFileId !== null && activeIds.has(file.stagedFileId)
+        ? [{ id: file.id, stagedFileId: file.stagedFileId, bytes: file.bytes }]
+        : []);
+    let fontHash = null;
+    if (font !== null) {
+        const stat = statSync(font.path, { throwIfNoEntry: false });
+        if (!stat?.isFile() || font.id !== converted.draft.subtitles?.fontId)
+            fields.push({
+                field: "subtitles.fontId",
+                message: "The selected font is no longer available. Choose another font.",
+            });
+        else
+            fontHash = createHash("sha256").update(readFileSync(font.path)).digest("hex");
+    }
+    if (fields.length)
+        return reviewRefusal(view, fields);
+    const estimates = runs.map((run) => estimateRun(run.draft, run.rendered, words.data, captured));
+    for (const run of runs)
+        for (const stage of run.draft.checkpoints ?? [])
+            if (stage === "video"
+                ? run.draft.sources.video === "off" && run.draft.sources.audio === "off"
+                : run.draft.sources[stage] !== "generate")
+                fields.push({
+                    field: `checkpoints.${stage}`,
+                    message: "Choose a checkpoint only before an enabled generated stage or export.",
+                });
+    if (fields.length)
+        return reviewRefusal(view, fields);
+    const checkpointSet = reviewCheckpointSet(runs, catalogue, attachmentIdentity, fontHash);
+    const resolved = {
+        runs,
+        estimates,
+        catalogue,
+        attachmentIdentity,
+        font,
+        ...(checkpointSet.length ? { checkpointSet } : {}),
+    };
+    return { ok: true, value: { ...resolved, fingerprint: requestHash({ ...resolved, fontHash }) } };
+}

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

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { isMissingFont } from "../fonts/index.js";
+import { draftRow } from "./repo.js";
+import { resolveReviewInputs, reviewBinding, reviewRefusal } from "./review-inputs.js";
+import { draftViewSchema, playReviewSchema } from "./schema.js";
+import { readDraft } from "./service.js";
+export { resolveReviewInputs } from "./review-inputs.js";
+export async function resolvePlayReview(deps, view) {
+    const parsed = draftViewSchema.safeParse(view);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-edit", currentVersion: null, fields: [] };
+    const before = resolveReviewInputs(deps, parsed.data, null);
+    if (!before.ok)
+        return before;
+    let font = null;
+    const subtitles = before.value.runs[0]?.draft.subtitles;
+    if (subtitles !== undefined && subtitles.mode !== "off") {
+        try {
+            font = await deps.resolveFont(subtitles.fontId);
+        }
+        catch (error) {
+            if (!isMissingFont(error))
+                throw error;
+            return reviewRefusal(view, [
+                {
+                    field: "subtitles.fontId",
+                    message: "The selected font is no longer available. Choose another font.",
+                },
+            ]);
+        }
+    }
+    const after = resolveReviewInputs(deps, parsed.data, font);
+    if (!after.ok)
+        return after;
+    return reviewBinding(before.value) === reviewBinding(after.value)
+        ? after
+        : reviewRefusal(view, [], "stale-review");
+}
+const inputSchema = z.object({ id: z.uuid(), baseVersion: z.number().int().positive() }).strict();
+export async function reviewDraft(deps, input) {
+    const parsed = inputSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-edit", currentVersion: null, fields: [] };
+    const view = readDraft(deps, parsed.data.id);
+    if (!view.ok)
+        return view;
+    const gate = reviewGate(view.value, parsed.data.baseVersion);
+    if (gate !== null)
+        return gate;
+    const resolved = await resolvePlayReview(deps, view.value);
+    if (!resolved.ok)
+        return resolved;
+    return transact(deps.db, () => {
+        const current = readDraft(deps, parsed.data.id);
+        if (!current.ok)
+            return current;
+        const denied = reviewGate(current.value, parsed.data.baseVersion);
+        if (denied !== null)
+            return denied;
+        const final = resolveReviewInputs(deps, current.value, resolved.value.font);
+        if (!final.ok)
+            return final;
+        if (final.value.fingerprint !== resolved.value.fingerprint)
+            return reviewRefusal(current.value, [], "stale-review");
+        const old = current.value.review;
+        if (old?.draftVersion === current.value.draft.version &&
+            old.fingerprint === final.value.fingerprint)
+            return { ok: true, value: old };
+        const review = playReviewSchema.parse({
+            ...(final.value.checkpointSet === undefined
+                ? {}
+                : { checkpointSet: final.value.checkpointSet }),
+            id: deps.uuid(),
+            draftId: parsed.data.id,
+            draftVersion: parsed.data.baseVersion,
+            fingerprint: final.value.fingerprint,
+            runs: final.value.runs,
+            estimates: final.value.estimates,
+        });
+        const { catalogue, attachmentIdentity, font } = final.value;
+        const changed = deps.db
+            .prepare("UPDATE play_drafts SET review_id=?,review_json=?,review_fingerprint=? WHERE id=? AND version=? AND state='active'")
+            .run(review.id, JSON.stringify({ review, execution: { catalogue, attachmentIdentity, font } }), review.fingerprint, parsed.data.id, parsed.data.baseVersion);
+        if (Number(changed.changes) !== 1)
+            return {
+                ok: false,
+                reason: "conflict",
+                currentVersion: draftRow(deps.db, parsed.data.id)?.version ?? null,
+                fields: [],
+            };
+        return { ok: true, value: review };
+    });
+}
+function reviewGate(view, baseVersion) {
+    if (view.pendingStart !== null)
+        return {
+            ok: false,
+            reason: "pending-start",
+            currentVersion: view.draft.version,
+            reviewId: view.pendingStart.reviewId,
+            fields: [],
+        };
+    if (view.start !== null)
+        return { ok: false, reason: "already-started", currentVersion: view.draft.version, fields: [] };
+    if (view.draft.version !== baseVersion)
+        return { ok: false, reason: "conflict", currentVersion: view.draft.version, fields: [] };
+    return null;
+}

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();