@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/slices/rebuild/admission-repo.js

@@ -0,0 +1,120 @@
+import { transact } from "../../kernel/db/tx.js";
+import { setProjectPaused } from "../admission/repo.js";
+import { requestHash as hash } from "../revisions/mutation-request.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { rebuildAdmissionSchema, } from "./model.js";
+import { executionSnapshotSchema, planPreview, reviewStillCovers } from "./preview-plan.js";
+import { previewById } from "./repo.js";
+import { insertInvocation } from "./runtime-admission.js";
+import { bindNarrationReuse } from "./runtime-narration-reuse.js";
+import { projectStandings } from "./runtime-store.js";
+export function admissionReceipt(db, projectId, idempotencyKey, requestHash) {
+    const row = db
+        .prepare("SELECT request_hash,response_json FROM rebuild_admissions WHERE project_id=? AND idempotency_key=?")
+        .get(projectId, idempotencyKey);
+    if (row !== undefined)
+        return row.request_hash !== requestHash
+            ? { ok: false, reason: "conflict" }
+            : {
+                ok: true,
+                value: {
+                    ...rebuildAdmissionSchema.parse(JSON.parse(String(row.response_json))),
+                    replayed: true,
+                },
+            };
+    if (db
+        .prepare("SELECT 1 FROM revision_mutations WHERE project_id=? AND idempotency_key=? UNION ALL SELECT 1 FROM project_control_receipts WHERE project_id=? AND idempotency_key=?")
+        .get(projectId, idempotencyKey, projectId, idempotencyKey) !== undefined)
+        return { ok: false, reason: "conflict" };
+    return undefined;
+}
+export function admitPreview(deps, input) {
+    return transact(deps.db, () => {
+        const { preview } = input;
+        const replay = admissionReceipt(deps.db, preview.projectId, input.idempotencyKey, input.requestHash);
+        if (replay !== undefined)
+            return replay;
+        if (currentRevisionId(deps.db, preview.projectId) !== preview.baseRevisionId)
+            return { ok: false, reason: "conflict" };
+        const persisted = previewById(deps.db, preview.projectId, preview.id);
+        const row = deps.db
+            .prepare("SELECT execution_json FROM rebuild_previews WHERE id=? AND project_id=?")
+            .get(preview.id, preview.projectId);
+        if (persisted === undefined ||
+            typeof row?.execution_json !== "string" ||
+            hash("body", "", persisted) !== hash("body", "", preview))
+            return { ok: false, reason: "stale-preview" };
+        const snapshot = executionSnapshotSchema.parse(JSON.parse(row.execution_json));
+        const view = getRevisionView(deps, preview.projectId, preview.baseRevisionId);
+        if (view === undefined)
+            return { ok: false, reason: "no-project" };
+        const fresh = planPreview(deps, view, snapshot.catalogue, preview.selection, preview.id);
+        if (!fresh.ok || !reviewStillCovers(preview, snapshot, fresh.value))
+            return { ok: false, reason: "stale-preview" };
+        const admissionId = deps.ids.next();
+        const workIds = [];
+        for (const recipe of snapshot.recipes) {
+            const disposition = snapshot.dispositions.find((row) => row.key === recipe.key)?.disposition;
+            const existing = deps.db
+                .prepare(`SELECT w.id,w.state,w.recipe_context,r.piece_id,r.fingerprint FROM revision_work_reservations r JOIN revision_work w ON w.id=r.work_id WHERE r.revision_id=? AND r.work_key=?`)
+                .get(view.revision.id, recipe.key);
+            if (disposition === "reuse") {
+                bindNarrationReuse(deps, view, recipe, snapshot.ordinals[recipe.key] ?? 0);
+                continue;
+            }
+            if (existing?.fingerprint === recipe.fingerprint &&
+                typeof existing.recipe_context === "string" &&
+                existing.state !== "done") {
+                workIds.push(String(existing.id));
+                if (existing.state !== "running") {
+                    deps.db
+                        .prepare("UPDATE revision_work SET state='pending',dispatch_state='allowed',failure_reason=NULL WHERE id=?")
+                        .run(String(existing.id));
+                    deps.db
+                        .prepare(`UPDATE revision_work_pieces SET state='pending',dispatch_state='allowed'
+              WHERE work_id=? AND state!='done' AND id IN (
+                SELECT p.id FROM revision_work_pieces p
+                JOIN revision_work_reservations r ON r.piece_id=p.id AND r.work_id=p.work_id
+                  AND r.work_key=p.work_key AND r.fingerprint=p.fingerprint
+                JOIN project_revisions v ON v.id=r.revision_id
+                JOIN json_each(v.fingerprints) f ON f.key=COALESCE(r.logical_key,r.work_key)
+                  AND f.value=COALESCE(r.desired_fingerprint,r.fingerprint)
+                WHERE r.revision_id=? AND (p.id=? OR
+                  (?='article:body' AND p.work_key LIKE 'article:continuation:%'
+                   AND COALESCE(r.logical_key,r.work_key)='article:body'))
+              )`)
+                        .run(String(existing.id), view.revision.id, String(existing.piece_id), recipe.key);
+                }
+                continue;
+            }
+            if (existing?.state === "running")
+                throw new Error("Selected work has a mismatched running reservation.");
+            deps.db
+                .prepare("DELETE FROM revision_work_reservations WHERE revision_id=? AND work_key=?")
+                .run(view.revision.id, recipe.key);
+            const key = recipe.input.kind === "tts" ? `${recipe.input.logicalKey}:1` : recipe.key;
+            const fingerprint = snapshot.anchors[key];
+            if (fingerprint === undefined)
+                throw new Error("Selected work has no reviewed desired anchor.");
+            const work = insertInvocation(deps, view, recipe, snapshot.catalogue, { key, fingerprint }, false, view.revision.id, admissionId);
+            workIds.push(work.workId);
+        }
+        const receipt = {
+            revisionId: view.revision.id,
+            admissionId,
+            workIds: [...new Set(workIds)],
+            replayed: false,
+        };
+        deps.db
+            .prepare("INSERT INTO rebuild_admissions(id,project_id,revision_id,idempotency_key,request_hash,preview_id,response_json,created_at) VALUES (?,?,?,?,?,?,?,?)")
+            .run(admissionId, preview.projectId, view.revision.id, input.idempotencyKey, input.requestHash, preview.id, JSON.stringify(receipt), deps.clock.now().toISOString());
+        for (const review of snapshot.reviews)
+            deps.db
+                .prepare("INSERT INTO revision_provided_reviews(project_id,revision_id,work_key,dependency_fingerprint,admission_id) VALUES (?,?,?,?,?) ON CONFLICT(revision_id,work_key) DO UPDATE SET dependency_fingerprint=excluded.dependency_fingerprint,admission_id=excluded.admission_id")
+                .run(preview.projectId, view.revision.id, review.key, review.fingerprint, admissionId);
+        setProjectPaused(deps.db, preview.projectId, false, deps.clock.now().toISOString());
+        projectStandings(deps, preview.projectId);
+        return { ok: true, value: receipt };
+    });
+}

package/dist/slices/rebuild/dependencies.js

@@ -0,0 +1,33 @@
+export function planDependencies(desired, retained) {
+    return desired.map((recipe) => {
+        const old = retained.find((one) => one.key === recipe.key &&
+            one.fingerprint === recipe.fingerprint &&
+            (one.available || one.inflight));
+        const changedProvided = recipe.kind === "provided" &&
+            retained.some((one) => one.key === recipe.key && one.fingerprint !== recipe.fingerprint);
+        const disposition = recipe.unresolved
+            ? "blocked"
+            : old
+                ? "reuse"
+                : changedProvided
+                    ? "review"
+                    : recipe.kind === "provided"
+                        ? "blocked"
+                        : recipe.kind === "local"
+                            ? "local"
+                            : "generate";
+        return {
+            ...recipe,
+            disposition,
+            inflight: old?.inflight ?? false,
+            pieceIds: old?.pieceIds ?? [],
+            reason: disposition === "reuse"
+                ? "Inputs match retained work."
+                : disposition === "review"
+                    ? "Confirm the provided content against changed inputs."
+                    : disposition === "blocked"
+                        ? "An input is unavailable or needs a fresh preview."
+                        : "Inputs changed or a required output is missing.",
+        };
+    });
+}

package/dist/slices/rebuild/model.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { stageKinds } from "../../kernel/pipeline.js";
+export const rebuildSelectionSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("allAffected") }).strict(),
+    z
+        .object({
+        kind: z.literal("selected"),
+        workKeys: z.array(z.string().min(1).max(200)).min(1).max(10000),
+    })
+        .strict(),
+]);
+const revisionId = z.string().min(1).max(64);
+export const previewRebuildSchema = z
+    .object({
+    baseRevisionId: revisionId,
+    request: rebuildSelectionSchema,
+})
+    .strict();
+export const startRebuildSchema = z
+    .object({
+    baseRevisionId: revisionId,
+    idempotencyKey: z.uuid(),
+    previewId: z.string().min(1).max(64),
+    acknowledgeUnknownCosts: z.boolean(),
+    confirmedProvidedWorkKeys: z.array(z.string().min(1).max(200)).max(10000),
+})
+    .strict();
+const costRowSchema = z.object({
+    stage: z.string(),
+    low: z.number().finite().nonnegative().nullable(),
+    high: z.number().finite().nonnegative().nullable(),
+    detail: z.string(),
+});
+const costEstimateSchema = z.object({
+    currency: z.literal("USD"),
+    rows: z.array(costRowSchema),
+    low: z.number().finite().nonnegative(),
+    high: z.number().finite().nonnegative(),
+    unknown: z.number().int().nonnegative(),
+    expectedWords: z.number().finite().nonnegative(),
+    catalogueDate: z.string().nullable(),
+    assumptions: z.array(z.string()),
+});
+export const rebuildAdmissionSchema = z.object({
+    revisionId,
+    admissionId: z.string().min(1).max(64),
+    workIds: z.array(z.string().min(1).max(64)),
+    replayed: z.boolean(),
+});
+export const rebuildPreviewSchema = z.object({
+    id: z.string().min(1).max(64),
+    projectId: z.string().min(1).max(64),
+    baseRevisionId: revisionId,
+    planFingerprint: z.string().min(1),
+    selection: rebuildSelectionSchema,
+    changedInputs: z.array(z.object({ path: z.string(), before: z.string().nullable(), after: z.string().nullable() })),
+    work: z.array(z.object({
+        key: z.string(),
+        stage: z.enum(stageKinds),
+        kind: z.enum(["provider", "local", "provided"]),
+        disposition: z.enum(["reuse", "generate", "local", "review", "blocked"]),
+        requestFingerprint: z.string(),
+        fingerprint: z.string(),
+        dependsOn: z.array(z.string()),
+        reason: z.string(),
+        inflight: z.boolean(),
+        pieceIds: z.array(z.string()),
+    })),
+    retained: z.array(z.object({
+        slot: z.string(),
+        outputId: z.string(),
+        assetId: z.string(),
+        state: z.enum(["ready", "outdated", "review"]),
+    })),
+    providedReuseRequired: z.array(z.string()),
+    costs: costEstimateSchema,
+    wholeRequestNotice: z.string().nullable(),
+    warnings: z.array(z.string()),
+    review: z
+        .object({
+        inputChanges: z.array(z.object({
+            label: z.string(),
+            before: z.string().nullable(),
+            after: z.string().nullable(),
+        })),
+        requests: z.array(z.object({
+            key: z.string(),
+            label: z.string(),
+            text: z.string().nullable(),
+            settings: z.string().nullable(),
+        })),
+    })
+        .optional(),
+});

package/dist/slices/rebuild/narration-history.js

@@ -0,0 +1,43 @@
+import { statSync } from "node:fs";
+import { z } from "zod";
+import { stagePieceSchema } from "../revisions/schema.js";
+import { outputPath } from "../storage/layout.js";
+export function retainedNarrationPieces(deps, projectId) {
+    return deps.db
+        .prepare(`SELECT p.piece_key,p.asset_id,p.fingerprint,p.descriptor,a.path FROM revision_pieces p
+    JOIN project_assets a ON a.id=p.asset_id AND a.project_id=p.project_id
+    WHERE p.project_id=? AND p.stage_kind='audio' ORDER BY p.created_at,p.id`)
+        .all(projectId)
+        .map((value) => {
+        const row = z
+            .object({
+            piece_key: z.string(),
+            asset_id: z.string(),
+            fingerprint: z.string(),
+            descriptor: z.string(),
+            path: z.string(),
+        })
+            .parse(value);
+        return {
+            key: row.piece_key,
+            stageKind: "audio",
+            assetId: row.asset_id,
+            fingerprint: row.fingerprint,
+            piece: stagePieceSchema.parse(JSON.parse(row.descriptor)),
+            available: statSync(outputPath(deps.paths, projectId, row.path), {
+                throwIfNoEntry: false,
+            })?.isFile() === true,
+        };
+    });
+}
+export function referencedAssetsAvailable(deps, projectId, ids) {
+    return ids.filter((id) => {
+        const row = deps.db
+            .prepare("SELECT path FROM project_assets WHERE project_id=? AND id=?")
+            .get(projectId, id);
+        return (row !== undefined &&
+            statSync(outputPath(deps.paths, projectId, z.string().parse(row.path)), {
+                throwIfNoEntry: false,
+            })?.isFile() === true);
+    });
+}

package/dist/slices/rebuild/narration-reuse.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { fingerprint } from "../../kernel/runner/work.js";
+export function matchingNarrationPiece(recipe, pieces, available) {
+    if (recipe.input.kind !== "tts")
+        return undefined;
+    const noRegeneration = recipe.fingerprint === fingerprint([recipe.requestFingerprint, null]);
+    return pieces.find((piece) => {
+        if (piece.stageKind !== "audio" ||
+            piece.piece.state !== "done" ||
+            piece.assetId === null ||
+            !available.has(piece.assetId))
+            return false;
+        const parsed = z
+            .object({ requestFingerprint: z.string() })
+            .safeParse(JSON.parse(piece.piece.payload ?? "null"));
+        return (parsed.success &&
+            parsed.data.requestFingerprint === recipe.requestFingerprint &&
+            (noRegeneration || piece.fingerprint === recipe.fingerprint));
+    });
+}

package/dist/slices/rebuild/preview-details.js

@@ -0,0 +1,144 @@
+import { stageKinds } from "../../kernel/pipeline.js";
+import { getRevisionView } from "../revisions/view.js";
+export function previewDetails(deps, view, allRecipes, selected) {
+    const parent = view.revision.parentId === null
+        ? undefined
+        : getRevisionView(deps, view.revision.projectId, view.revision.parentId);
+    const requests = allRecipes.flatMap((row) => {
+        if (!selected.has(row.key))
+            return [];
+        const input = row.input;
+        const narration = narrationIdentity(row);
+        if (narration !== undefined) {
+            const groups = [
+                ...new Set(allRecipes.flatMap((one) => {
+                    const identity = narrationIdentity(one);
+                    return identity?.segment === narration.segment ? [identity.logicalKey] : [];
+                })),
+            ];
+            const siblings = allRecipes.filter((one) => narrationIdentity(one)?.logicalKey === narration.logicalKey);
+            const segment = narration.segment === "body" ? "Body" : narration.segment === "intro" ? "Intro" : "Outro";
+            const text = input.kind === "tts"
+                ? input.text
+                : input.kind === "provided" &&
+                    Array.isArray(input.semantic) &&
+                    typeof input.semantic[0] === "string"
+                    ? input.semantic[0]
+                    : null;
+            return [
+                {
+                    key: row.key,
+                    label: `${segment} narration chunk ${groups.indexOf(narration.logicalKey) + 1} · request ${siblings.findIndex((one) => one.key === row.key) + 1}`,
+                    text,
+                    settings: input.kind === "tts"
+                        ? [input.provider, input.model, input.voice].join(" · ")
+                        : "Provided audio",
+                },
+            ];
+        }
+        if (input.kind === "image") {
+            const index = view.revision.content.imageOrder.indexOf(row.key.slice("image:".length));
+            return [
+                {
+                    key: row.key,
+                    label: index < 0 ? "Thumbnail image" : `Image ${index + 1}`,
+                    text: input.prompt,
+                    settings: [input.provider, input.model, input.aspect].join(" · "),
+                },
+            ];
+        }
+        if (input.kind === "llm") {
+            const peers = allRecipes.filter((one) => one.stage === row.stage && one.input.kind === "llm");
+            const category = row.key.startsWith("entry:intro")
+                ? "Intro text"
+                : row.key.startsWith("entry:outro")
+                    ? "Outro text"
+                    : row.stage === "article"
+                        ? "Article"
+                        : row.stage === "research"
+                            ? "Research"
+                            : "Thumbnail prompt";
+            return [
+                {
+                    key: row.key,
+                    label: `${category} request ${peers.findIndex((one) => one.key === row.key) + 1}`,
+                    text: input.messages
+                        .map((message) => `${message.role}:\n${message.content}`)
+                        .join("\n\n"),
+                    settings: [input.provider, input.model, input.thinking]
+                        .filter((value) => value !== null)
+                        .join(" · "),
+                },
+            ];
+        }
+        return [];
+    });
+    return { inputChanges: parent === undefined ? [] : inputChanges(parent, view), requests };
+}
+function narrationIdentity(row) {
+    if (row.input.kind === "tts")
+        return { logicalKey: row.input.logicalKey, segment: row.input.segment };
+    if (row.input.kind !== "provided")
+        return undefined;
+    const match = /^audio:(body:.+|intro|outro):[0-9]+$/.exec(row.key);
+    if (match === null)
+        return undefined;
+    return {
+        logicalKey: row.key.slice(0, row.key.lastIndexOf(":")),
+        segment: row.key.startsWith("audio:body:")
+            ? "body"
+            : row.key.startsWith("audio:intro:")
+                ? "intro"
+                : "outro",
+    };
+}
+function inputChanges(parent, view) {
+    const before = parent.revision.config;
+    const after = view.revision.config;
+    const old = parent.revision.content;
+    const next = view.revision.content;
+    const changes = [];
+    const add = (label, previous, current) => {
+        const text = (value) => value == null ? null : typeof value === "string" ? value : JSON.stringify(value, null, 2);
+        const a = text(previous);
+        const b = text(current);
+        if (a !== b)
+            changes.push({ label, before: a, after: b });
+    };
+    add("Project title", before.title, after.title);
+    add("Aspect ratio", before.format, after.format);
+    for (const kind of stageKinds)
+        add(`${kind[0]?.toUpperCase()}${kind.slice(1)} source`, before.sources[kind], after.sources[kind]);
+    for (const [name, a, b] of [
+        ["Text", before.llm, after.llm],
+        ["Narration", before.audio, after.audio],
+        ["Images", before.images, after.images],
+    ]) {
+        add(`${name} provider`, a?.provider, b?.provider);
+        add(`${name} model`, a?.model, b?.model);
+        add(`${name} thinking`, a?.thinking, b?.thinking);
+    }
+    add("Narration voice", before.audio?.voice, after.audio?.voice);
+    add("Narration chunking", before.chunking, after.chunking);
+    add("Silence gap (seconds)", before.silenceGapSeconds, after.silenceGapSeconds);
+    add("Intro", before.intro, after.intro);
+    add("Outro", before.outro, after.outro);
+    add("Subtitle settings", before.subtitles, after.subtitles);
+    add("Article text", parent.articleMarkdown, view.articleMarkdown);
+    add("Provided research", before.provided.research, after.provided.research);
+    for (const key of new Set([...Object.keys(before.values), ...Object.keys(after.values)]))
+        add(`Keyword: ${key}`, before.values[key], after.values[key]);
+    for (const key of new Set([...Object.keys(before.rendered), ...Object.keys(after.rendered)]))
+        add(`Prompt: ${key}`, before.rendered[key], after.rendered[key]);
+    if (old.imageOrder.join("\0") !== next.imageOrder.join("\0")) {
+        const label = (key) => old.imageOrder.includes(key) ? `Image ${old.imageOrder.indexOf(key) + 1}` : "New image";
+        add("Image order", old.imageOrder.map(label).join(", "), next.imageOrder.map(label).join(", "));
+    }
+    for (const [index, key] of next.imageOrder.entries()) {
+        add(`Image ${index + 1} prompt`, old.imageDefinitions[key]?.prompt, next.imageDefinitions[key]?.prompt);
+        if (old.imageDefinitions[key]?.assetId !== next.imageDefinitions[key]?.assetId)
+            add(`Image ${index + 1} file`, old.imageDefinitions[key]?.assetId == null ? null : "Previous file", next.imageDefinitions[key]?.assetId == null ? null : "Replacement file");
+    }
+    add("Manual captions", old.subtitleCues?.cues, next.subtitleCues?.cues);
+    return changes;
+}