@gentbajko/slopify 0.8.4 → 1.0.1

package/dist/slices/revisions/publication-rules.js

@@ -0,0 +1,166 @@
+import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+import { workExists } from "../../kernel/runner/work-authority.js";
+import { pieceFile } from "../storage/reconcile.js";
+import { outputSchema } from "../storage/schema.js";
+import { outputsForRevision, piecesForRevision, revisionById } from "./repo.js";
+import { stagePieceSchema } from "./schema.js";
+export function publicationAuthority(db, publication) {
+    const { work, pieceId, publicationId } = publication;
+    if (publicationId !== (pieceId ?? work.workId))
+        throw new Error("Publication identity does not match its durable work.");
+    if (!workExists(db, work))
+        return undefined;
+    const row = pieceId === null
+        ? db
+            .prepare("SELECT work_key,fingerprint FROM revision_work_reservations WHERE work_id=? AND piece_id IS NULL")
+            .get(work.workId)
+        : db
+            .prepare("SELECT work_key,fingerprint FROM revision_work_pieces WHERE work_id=? AND id=?")
+            .get(work.workId, pieceId);
+    if (row === undefined && pieceId === null) {
+        const candidates = Object.entries(revisionById(db, work.projectId, work.revisionId)?.fingerprints ?? {}).filter(([, value]) => value === work.fingerprint);
+        const candidate = candidates.length === 1 ? candidates[0] : undefined;
+        if (candidate !== undefined)
+            return { key: candidate[0], fingerprint: candidate[1] };
+    }
+    if (row === undefined)
+        throw new Error("Publication has no unambiguous durable authority.");
+    const parsed = z.object({ work_key: z.string(), fingerprint: z.string() }).parse(row);
+    return { key: parsed.work_key, fingerprint: parsed.fingerprint };
+}
+export function validatePublication(db, publication, outputs, pieces) {
+    if (outputs.length + pieces.length === 0)
+        throw new Error("A publication must contain a result.");
+    if (new Set(outputs.map((row) => row.slot)).size !== outputs.length ||
+        new Set(pieces.map((row) => row.key)).size !== pieces.length)
+        throw new Error("Publication destinations must be unique.");
+    const authority = publicationAuthority(db, publication);
+    const durablePiece = publication.pieceId === null
+        ? undefined
+        : db
+            .prepare("SELECT logical_fingerprint FROM revision_work_pieces WHERE id=? AND work_id=?")
+            .get(publication.pieceId, publication.work.workId);
+    const revision = revisionById(db, publication.work.projectId, publication.work.revisionId);
+    for (const row of outputs) {
+        const retainedMember = ((authority?.key === "subtitles:files" &&
+            ((row.workKey === "export:wav" && row.output.role === "audio_export") ||
+                (row.workKey === "export:video" &&
+                    row.output.role === "video" &&
+                    row.output.meta.subtitlesMode !== "burn-in"))) ||
+            ((authority?.key === "export:wav" || authority?.key === "export:video") &&
+                row.workKey === "subtitles:files" &&
+                ["subtitles_srt", "subtitles_vtt", "subtitle_ass", "subtitle_font"].includes(row.output.role))) &&
+            outputsForRevision(db, publication.work.projectId, publication.work.revisionId).some((old) => old.selected &&
+                old.state === "ready" &&
+                old.workKey === row.workKey &&
+                old.output.role === row.output.role &&
+                old.assetId === row.asset.id &&
+                old.fingerprint === row.fingerprint);
+        if (!retainedMember &&
+            row.fingerprint !== revision?.fingerprints[row.workKey] &&
+            !(row.workKey === authority?.key &&
+                (row.fingerprint === authority.fingerprint ||
+                    row.fingerprint === durablePiece?.logical_fingerprint)))
+            throw new Error("Output fingerprint differs from its authorized recipe.");
+        outputSchema.parse(row.output);
+        if (row.output.projectId !== publication.work.projectId ||
+            row.asset.projectId !== publication.work.projectId ||
+            row.output.stageKind !== publication.work.kind ||
+            row.output.path !== row.asset.path ||
+            row.output.bytes !== row.asset.bytes)
+            throw new Error("Output descriptor does not match its owned asset and stage.");
+    }
+    for (const row of pieces) {
+        stagePieceSchema.parse(row.piece);
+        const owned = db
+            .prepare("SELECT work_key,fingerprint FROM revision_work_pieces WHERE id=? AND work_id=?")
+            .get(row.piece.id, publication.work.workId);
+        const file = pieceFile(row.piece.payload);
+        if (row.stageKind !== publication.work.kind ||
+            row.piece.stageId !== publication.work.stageId ||
+            owned === undefined ||
+            owned.work_key !== row.key ||
+            owned.fingerprint !== row.fingerprint ||
+            (publication.pieceId !== null && row.piece.id !== publication.pieceId) ||
+            (row.asset !== null &&
+                (row.asset.projectId !== publication.work.projectId || file !== row.asset.path)) ||
+            (row.asset === null && file !== undefined))
+            throw new Error("Piece descriptor does not match its owned work and asset.");
+    }
+}
+export function isPublicationReplay(db, publication, outputs, pieces) {
+    const oldOutputs = outputsForRevision(db, publication.work.projectId, publication.work.revisionId).filter((row) => row.publicationId === publication.publicationId);
+    const oldPieces = piecesForRevision(db, publication.work.projectId, publication.work.revisionId).filter((row) => row.publicationId === publication.publicationId);
+    if (oldOutputs.length + oldPieces.length === 0)
+        return false;
+    const descriptors = outputs.map((row) => ({
+        slot: row.slot,
+        workKey: row.workKey,
+        assetId: row.asset.id,
+        output: row.output,
+        fingerprint: row.fingerprint,
+        state: "ready",
+    }));
+    const pieceDescriptors = pieces.map((row) => ({
+        key: row.key,
+        stageKind: row.stageKind,
+        assetId: row.asset?.id ?? null,
+        piece: row.piece,
+        fingerprint: row.fingerprint,
+    }));
+    const normalize = (rows) => rows
+        .map((row) => JSON.parse(JSON.stringify(row)))
+        .sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+    if (!isDeepStrictEqual(normalize(oldOutputs.map(outputDescriptor)), normalize(descriptors)) ||
+        !isDeepStrictEqual(normalize(oldPieces.map(pieceDescriptor)), normalize(pieceDescriptors)))
+        throw new Error("Publication conflicts with its complete retained result.");
+    return true;
+}
+function outputDescriptor({ recordId: _recordId, publicationId: _publicationId, selected: _selected, ...row }) {
+    return row;
+}
+function pieceDescriptor({ recordId: _recordId, publicationId: _publicationId, selected: _selected, ...row }) {
+    return row;
+}
+export function replacementSlots(authority, outputs) {
+    if (authority === "article:body")
+        return ["article:article_md", "article:article_txt", "article:sources", "article:glossary"];
+    if (authority === "subtitles:files" || authority === "export:wav" || authority === "export:video")
+        return [
+            "video:subtitles_srt",
+            "video:subtitles_vtt",
+            "video:subtitle_ass",
+            "video:subtitle_font",
+            ...(authority === "subtitles:files"
+                ? []
+                : ["video:video", "video:audio_export", "video:render_params"]),
+        ];
+    return outputs.map((row) => row.slot);
+}
+export function validateBundle(authority, outputs) {
+    const allowed = (row) => row.workKey === authority ||
+        ((authority === "export:wav" || authority === "export:video") &&
+            ["subtitles:files", "subtitles:cues"].includes(row.workKey)) ||
+        (authority === "subtitles:files" &&
+            ((row.workKey === "export:wav" && row.output.role === "audio_export") ||
+                (row.workKey === "export:video" &&
+                    row.output.role === "video" &&
+                    row.output.meta.subtitlesMode !== "burn-in")));
+    if (outputs.some((row) => !allowed(row)))
+        throw new Error("Publication member is outside its authorized result bundle.");
+    const roles = new Set(outputs.map((row) => row.output.role));
+    const media = outputs.find((row) => row.output.role === "video" || row.output.role === "audio_export");
+    if ((authority === "export:wav" && (!roles.has("audio_export") || !roles.has("render_params"))) ||
+        (authority === "export:video" && (!roles.has("video") || !roles.has("render_params"))))
+        throw new Error("Media and render parameters must publish as one complete bundle.");
+    if (media !== undefined &&
+        media.output.meta.subtitlesMode !== undefined &&
+        media.output.meta.subtitlesMode !== "off") {
+        if (!roles.has("subtitles_srt") ||
+            !roles.has("subtitles_vtt") ||
+            (media.output.meta.subtitlesMode === "burn-in" &&
+                (!roles.has("subtitle_ass") || !roles.has("subtitle_font"))))
+            throw new Error("Declared subtitle files must be committed with their media descriptor.");
+    }
+}

package/dist/slices/revisions/publish.js

@@ -0,0 +1,115 @@
+import { transact } from "../../kernel/db/tx.js";
+import { publicationTargets } from "../rebuild/repo.js";
+import { discardPreparedAssets } from "../storage/assets.js";
+import { positionedOutput, positionedPiece, projectSelected } from "./projection.js";
+import { isPublicationReplay, publicationAuthority, replacementSlots, validateBundle, validatePublication, } from "./publication-rules.js";
+import { insertAsset, insertManifestOutput, insertManifestPiece, outputsForRevision, revisionById, selectOutputRecord, selectPieceRecord, } from "./repo.js";
+export function commitRevisionOutputs(deps, publication, outputs, pieces) {
+    const assets = [
+        ...outputs.map((row) => row.asset),
+        ...pieces.flatMap((row) => (row.asset === null ? [] : [row.asset])),
+    ];
+    try {
+        return transact(deps.db, () => {
+            const result = { originRevisionId: publication.work.revisionId, currentAttached: false };
+            const authority = publicationAuthority(deps.db, publication);
+            if (authority === undefined)
+                return result;
+            validatePublication(deps.db, publication, outputs, pieces);
+            validateBundle(authority.key, outputs);
+            if (isPublicationReplay(deps.db, publication, outputs, pieces))
+                return result;
+            const targets = publicationTargets(deps.db, publication, authority.key, authority.fingerprint);
+            if (targets.length === 0)
+                return result;
+            for (const asset of assets)
+                insertAsset(deps.db, asset);
+            let currentAttached = false;
+            for (const target of targets) {
+                const revision = revisionById(deps.db, publication.work.projectId, target.revisionId);
+                if (revision === undefined)
+                    throw new Error("Publication target disappeared inside its transaction.");
+                const selected = target.selected;
+                const before = outputsForRevision(deps.db, revision.projectId, revision.id);
+                const exportAuthority = authority.key === "export:wav" || authority.key === "export:video";
+                const selectsMember = (output) => {
+                    if (!selected)
+                        return false;
+                    if (authority.key === "subtitles:files" &&
+                        (output.output.role === "audio_export" || output.output.role === "video"))
+                        return before.some((row) => row.selected &&
+                            row.state === "ready" &&
+                            row.workKey === output.workKey &&
+                            row.assetId === output.asset.id &&
+                            row.fingerprint === output.fingerprint);
+                    if (!exportAuthority || output.workKey !== "subtitles:files")
+                        return true;
+                    if ((revision.config.subtitles?.mode ?? "off") === "off")
+                        return false;
+                    return (revision.fingerprints[output.workKey] === output.fingerprint ||
+                        before.some((row) => row.selected &&
+                            row.state === "ready" &&
+                            row.slot === output.slot &&
+                            row.assetId === output.asset.id &&
+                            row.fingerprint === output.fingerprint));
+                };
+                if (selected)
+                    for (const slot of replacementSlots(authority.key, outputs)) {
+                        const captionSlot = [
+                            "video:subtitles_srt",
+                            "video:subtitles_vtt",
+                            "video:subtitle_ass",
+                            "video:subtitle_font",
+                        ].includes(slot);
+                        if (exportAuthority &&
+                            captionSlot &&
+                            (revision.config.subtitles?.mode ?? "off") !== "off" &&
+                            !outputs.some((output) => output.slot === slot && selectsMember(output)))
+                            continue;
+                        deps.db
+                            .prepare("UPDATE revision_outputs SET selected=0 WHERE revision_id=? AND slot=?")
+                            .run(revision.id, slot);
+                    }
+                for (const output of outputs) {
+                    const row = {
+                        slot: output.slot,
+                        workKey: output.workKey,
+                        assetId: output.asset.id,
+                        output: output.output,
+                        fingerprint: output.fingerprint,
+                        state: "ready",
+                    };
+                    const recordId = deps.ids.next();
+                    insertManifestOutput(deps.db, revision, target.revisionId === publication.work.revisionId
+                        ? row
+                        : positionedOutput(revision, row), recordId, publication.publicationId);
+                    if (selectsMember(output))
+                        selectOutputRecord(deps.db, revision.id, row.slot, recordId);
+                }
+                for (const piece of pieces) {
+                    const row = {
+                        key: piece.key,
+                        stageKind: piece.stageKind,
+                        assetId: piece.asset?.id ?? null,
+                        piece: piece.piece,
+                        fingerprint: piece.fingerprint,
+                    };
+                    const recordId = deps.ids.next();
+                    insertManifestPiece(deps.db, revision, target.revisionId === publication.work.revisionId
+                        ? row
+                        : positionedPiece(revision, row), recordId, publication.publicationId);
+                    if (selected)
+                        selectPieceRecord(deps.db, revision.id, row.key, recordId);
+                }
+                if (selected && target.current) {
+                    projectSelected(deps.db, revision);
+                    currentAttached = true;
+                }
+            }
+            return { ...result, currentAttached };
+        });
+    }
+    finally {
+        discardPreparedAssets(deps, assets);
+    }
+}

package/dist/slices/revisions/repo.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { projectRevisionSchema } from "./schema.js";
+export { insertManifestOutput, insertManifestPiece, outputsForRevision, piecesForRevision, selectOutputRecord, selectPieceRecord, } from "./manifest-repo.js";
+const revisionRow = z.object({
+    id: z.string(),
+    project_id: z.string(),
+    parent_id: z.string().nullable(),
+    restored_from_id: z.string().nullable(),
+    config: z.string(),
+    content: z.string(),
+    fingerprints: z.string(),
+    created_at: z.string(),
+});
+const assetRow = z.object({
+    id: z.string(),
+    project_id: z.string(),
+    path: z.string(),
+    bytes: z.number().nullable(),
+    created_at: z.string(),
+});
+export function insertRevision(db, revision) {
+    db.prepare(`INSERT INTO project_revisions
+    (id,project_id,parent_id,restored_from_id,config,content,fingerprints,created_at)
+    VALUES (?,?,?,?,?,?,?,?)`).run(revision.id, revision.projectId, revision.parentId, revision.restoredFromId, JSON.stringify(revision.config), JSON.stringify(revision.content), JSON.stringify(revision.fingerprints), revision.createdAt);
+}
+export function revisionById(db, projectId, revisionId) {
+    const row = db
+        .prepare("SELECT * FROM project_revisions WHERE project_id=? AND id=?")
+        .get(projectId, revisionId);
+    return row === undefined ? undefined : toRevision(row);
+}
+export function currentRevisionId(db, projectId) {
+    const row = db.prepare("SELECT revision_id FROM project_heads WHERE project_id=?").get(projectId);
+    return row === undefined
+        ? undefined
+        : z.object({ revision_id: z.string() }).parse(row).revision_id;
+}
+export function listRevisionHistory(db, projectId) {
+    const head = currentRevisionId(db, projectId);
+    return db
+        .prepare("SELECT * FROM project_revisions WHERE project_id=? ORDER BY created_at DESC,id DESC")
+        .all(projectId)
+        .map((row) => {
+        const revision = toRevision(row);
+        return {
+            id: revision.id,
+            parentId: revision.parentId,
+            restoredFromId: revision.restoredFromId,
+            title: revision.config.title,
+            createdAt: revision.createdAt,
+            current: revision.id === head,
+        };
+    });
+}
+export function insertAsset(db, asset) {
+    const existing = db
+        .prepare("SELECT * FROM project_assets WHERE id=? OR (project_id=? AND path=?)")
+        .all(asset.id, asset.projectId, asset.path);
+    if (existing.length > 0) {
+        const row = assetRow.parse(existing[0]);
+        if (existing.length !== 1 ||
+            row.id !== asset.id ||
+            row.project_id !== asset.projectId ||
+            row.path !== asset.path ||
+            row.bytes !== asset.bytes)
+            throw new Error("Asset identity conflicts with a registered file.");
+        return;
+    }
+    db.prepare("INSERT INTO project_assets(id,project_id,path,bytes,created_at) VALUES (?,?,?,?,?)").run(asset.id, asset.projectId, asset.path, asset.bytes, asset.createdAt);
+}
+function toRevision(value) {
+    const row = revisionRow.parse(value);
+    return projectRevisionSchema.parse({
+        id: row.id,
+        projectId: row.project_id,
+        parentId: row.parent_id,
+        restoredFromId: row.restored_from_id,
+        config: JSON.parse(row.config),
+        content: JSON.parse(row.content),
+        fingerprints: JSON.parse(row.fingerprints),
+        createdAt: row.created_at,
+    });
+}

package/dist/slices/revisions/restore.js

@@ -0,0 +1,60 @@
+import { transact } from "../../kernel/db/tx.js";
+import { carryCheckpointGates } from "../checkpoints/recovery.js";
+import { planRevision } from "../rebuild/recipe-save.js";
+import { transitionRevisionWork } from "../rebuild/repo.js";
+import { projectStandings } from "../rebuild/runtime-store.js";
+import { checkMutation, insertReceipt, refusal, requestHash, requiredView, } from "./mutation-request.js";
+import { advanceHead, logicalKeys } from "./mutations.js";
+import { cloneManifest, ensureRevisionStages, projectSelected } from "./projection.js";
+import { insertRevision } from "./repo.js";
+import { getRevisionView } from "./view.js";
+export async function restoreRevision(deps, input) {
+    const identity = {
+        ...input,
+        operation: "restore",
+        hash: requestHash("restore", input.baseRevisionId, {
+            targetRevisionId: input.targetRevisionId,
+        }),
+    };
+    return transact(deps.db, () => {
+        const checked = checkMutation(deps, identity);
+        if (checked !== undefined)
+            return checked;
+        const target = getRevisionView(deps, input.projectId, input.targetRevisionId);
+        if (target === undefined)
+            return refusal(deps, input.projectId, "no-revision");
+        const base = requiredView(deps, input.projectId, input.baseRevisionId);
+        const comparison = planRevision(base, {
+            config: target.revision.config,
+            content: target.revision.content,
+        });
+        const revision = {
+            ...target.revision,
+            id: deps.ids.next(),
+            parentId: base.revision.id,
+            restoredFromId: target.revision.id,
+            createdAt: deps.clock.now().toISOString(),
+        };
+        insertRevision(deps.db, revision);
+        ensureRevisionStages(deps, revision);
+        cloneManifest(deps, revision, {
+            outputs: target.outputs.filter((row) => row.selected),
+            pieces: target.pieces.filter((row) => row.selected),
+        });
+        if (!advanceHead(deps.db, input.projectId, input.baseRevisionId, revision))
+            throw new Error("Project head changed during the restore transaction.");
+        transitionRevisionWork(deps, {
+            projectId: input.projectId,
+            baseRevisionId: input.baseRevisionId,
+            revisionId: revision.id,
+            fingerprints: revision.fingerprints,
+            ...(comparison.ok ? { baseFingerprints: comparison.baseFingerprints } : {}),
+            logicalKeys: logicalKeys(deps, input.projectId, input.baseRevisionId, revision.fingerprints),
+        });
+        carryCheckpointGates(deps, input.baseRevisionId, revision);
+        projectSelected(deps.db, revision);
+        projectStandings(deps, revision.projectId);
+        insertReceipt(deps, identity, revision.id);
+        return { ok: true, view: requiredView(deps, input.projectId, revision.id), duplicate: false };
+    });
+}

package/dist/slices/revisions/rules.js

@@ -0,0 +1,99 @@
+import { isDeepStrictEqual } from "node:util";
+import { buildRecipes } from "../rebuild/recipe-build.js";
+import { normalizeArticleIntent, validateRevisionEdit } from "../rebuild/recipe-save.js";
+export function validateCues(cues, duration) {
+    const fields = [];
+    const seen = new Set();
+    let end = 0;
+    for (const [index, cue] of cues.entries()) {
+        const field = `content.subtitleCues.cues.${index}`;
+        if (seen.has(cue.id))
+            fields.push({ field: `${field}.id`, message: "Caption IDs must be unique." });
+        seen.add(cue.id);
+        if (cue.text.trim() === "")
+            fields.push({ field: `${field}.text`, message: "Caption text is required." });
+        if (!Number.isFinite(cue.start) || cue.start < end)
+            fields.push({ field: `${field}.start`, message: "Start must follow the previous caption." });
+        if (!Number.isFinite(cue.end) || cue.end <= cue.start || cue.end > duration)
+            fields.push({
+                field: `${field}.end`,
+                message: "End must follow start and fit the narration.",
+            });
+        end = cue.end;
+    }
+    return fields;
+}
+export function validateTemplateIntent(base, edit) {
+    const fields = [];
+    if (!isDeepStrictEqual(base.revision.config.values, edit.config.values)) {
+        for (const [key, raw] of Object.entries(base.revision.content.promptTemplates)) {
+            if (raw === null &&
+                edit.content.promptTemplates[key] == null &&
+                base.revision.config.rendered[key] === edit.config.rendered[key])
+                fields.push({
+                    field: `content.promptTemplates.${key}`,
+                    message: "Choose the raw template or explicitly keep the current prompt before changing keywords.",
+                });
+        }
+        for (const [key, image] of Object.entries(base.revision.content.imageDefinitions)) {
+            const next = edit.content.imageDefinitions[key];
+            if (image.source === "generate" &&
+                image.templateKey == null &&
+                next?.source === "generate" &&
+                next.templateKey == null &&
+                next.prompt === image.prompt)
+                fields.push({
+                    field: `content.imageDefinitions.${key}.templateKey`,
+                    message: "Choose the raw template or explicitly keep the current image prompt before changing keywords.",
+                });
+        }
+    }
+    for (const [key, image] of Object.entries(edit.content.imageDefinitions))
+        if (image.source === "generate" &&
+            image.templateKey != null &&
+            edit.content.promptTemplates[image.templateKey] == null &&
+            !(base.revision.content.promptTemplates[image.templateKey] == null &&
+                isDeepStrictEqual(base.revision.content.imageDefinitions[key], image)))
+            fields.push({
+                field: `content.imageDefinitions.${key}.templateKey`,
+                message: "The linked raw image template is missing.",
+            });
+    return fields;
+}
+export function validateNarrationIntent(base, edit) {
+    const content = normalizeArticleIntent(base, edit);
+    const invalid = validateRevisionEdit(edit.config, content);
+    if (invalid.length > 0)
+        return invalid;
+    const recipes = buildRecipes({
+        config: edit.config,
+        content,
+        manifest: {
+            outputs: base.outputs.filter((row) => row.selected),
+            pieces: base.pieces.filter((row) => row.selected),
+        },
+        resolved: {
+            articleMarkdown: base.articleMarkdown,
+            researchNotes: edit.config.provided.research ?? null,
+        },
+    });
+    const keys = new Set(recipes.flatMap((row) => row.input.kind === "tts"
+        ? [row.input.logicalKey]
+        : row.stage === "audio" && row.key.endsWith(":1")
+            ? [row.key.slice(0, -2)]
+            : []));
+    const fields = [];
+    for (const [key, value] of Object.entries(edit.content.narrationOverrides))
+        if (!isDeepStrictEqual(value, base.revision.content.narrationOverrides[key]) && !keys.has(key))
+            fields.push({
+                field: `content.narrationOverrides.${key}`,
+                message: "Choose an active narration group or entry.",
+            });
+    for (const [index, upload] of (edit.uploads ?? []).entries())
+        if (upload.destination.kind === "narration" && !keys.has(upload.destination.key))
+            fields.push({
+                field: `uploads.${index}.destination.key`,
+                message: "Choose an active narration group or entry.",
+            });
+    return fields;
+}