@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/slices/revisions/manifest-repo.js

@@ -0,0 +1,125 @@
+import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { stageKinds } from "../../kernel/pipeline.js";
+import { outputSchema } from "../storage/schema.js";
+import { stagePieceSchema } from "./schema.js";
+const selected = z.union([z.literal(0), z.literal(1)]).transform((value) => value === 1);
+const commonRow = z.object({
+    id: z.string(),
+    asset_id: z.string().nullable(),
+    fingerprint: z.string(),
+    descriptor: z.string(),
+    publication_id: z.string().nullable(),
+    selected,
+});
+const outputRow = commonRow.extend({
+    slot: z.string(),
+    work_key: z.string(),
+    asset_id: z.string(),
+    state: z.enum(["ready", "outdated", "review"]),
+});
+const pieceRow = commonRow.extend({ piece_key: z.string(), stage_kind: z.enum(stageKinds) });
+export function insertManifestOutput(db, revision, output, recordId, publicationId = null) {
+    if (publicationId !== null) {
+        const row = db
+            .prepare("SELECT * FROM revision_outputs WHERE project_id=? AND revision_id=? AND publication_id=? AND slot=?")
+            .get(revision.projectId, revision.id, publicationId, output.slot);
+        if (row !== undefined) {
+            const previous = toOutput(row);
+            if (!isDeepStrictEqual(previous, {
+                ...output,
+                output: outputSchema.parse(JSON.parse(JSON.stringify(output.output))),
+                recordId: previous.recordId,
+                publicationId,
+                selected: previous.selected,
+            }))
+                throw new Error("Output publication conflicts with its retained result.");
+            return;
+        }
+    }
+    db.prepare(`INSERT INTO revision_outputs
+    (id,project_id,revision_id,slot,work_key,asset_id,fingerprint,state,descriptor,publication_id,selected,created_at)
+    VALUES (?,?,?,?,?,?,?,?,?,?,0,?)`).run(recordId, revision.projectId, revision.id, output.slot, output.workKey, output.assetId, output.fingerprint, output.state, JSON.stringify(output.output), publicationId, revision.createdAt);
+}
+export function insertManifestPiece(db, revision, piece, recordId, publicationId = null) {
+    if (publicationId !== null) {
+        const row = db
+            .prepare("SELECT * FROM revision_pieces WHERE project_id=? AND revision_id=? AND publication_id=? AND piece_key=?")
+            .get(revision.projectId, revision.id, publicationId, piece.key);
+        if (row !== undefined) {
+            const previous = toPiece(row);
+            if (!isDeepStrictEqual(previous, {
+                ...piece,
+                piece: stagePieceSchema.parse(JSON.parse(JSON.stringify(piece.piece))),
+                recordId: previous.recordId,
+                publicationId,
+                selected: previous.selected,
+            }))
+                throw new Error("Piece publication conflicts with its retained result.");
+            return;
+        }
+    }
+    db.prepare(`INSERT INTO revision_pieces
+    (id,project_id,revision_id,piece_key,stage_kind,asset_id,fingerprint,descriptor,publication_id,selected,created_at)
+    VALUES (?,?,?,?,?,?,?,?,?,0,?)`).run(recordId, revision.projectId, revision.id, piece.key, piece.stageKind, piece.assetId, piece.fingerprint, JSON.stringify(piece.piece), publicationId, revision.createdAt);
+}
+export function outputsForRevision(db, projectId, revisionId) {
+    return db
+        .prepare("SELECT * FROM revision_outputs WHERE project_id=? AND revision_id=? ORDER BY created_at,id")
+        .all(projectId, revisionId)
+        .map(toOutput);
+}
+export function piecesForRevision(db, projectId, revisionId) {
+    return db
+        .prepare("SELECT * FROM revision_pieces WHERE project_id=? AND revision_id=? ORDER BY created_at,id")
+        .all(projectId, revisionId)
+        .map(toPiece);
+}
+export function selectOutputRecord(db, revisionId, slot, recordId) {
+    transact(db, () => {
+        db.prepare("UPDATE revision_outputs SET selected=0 WHERE revision_id=? AND slot=? AND selected=1").run(revisionId, slot);
+        const result = db
+            .prepare("UPDATE revision_outputs SET selected=1 WHERE id=? AND revision_id=? AND slot=?")
+            .run(recordId, revisionId, slot);
+        if (Number(result.changes) !== 1)
+            throw new Error("Published output record was not found.");
+    });
+}
+export function selectPieceRecord(db, revisionId, key, recordId) {
+    transact(db, () => {
+        db.prepare("UPDATE revision_pieces SET selected=0 WHERE revision_id=? AND piece_key=? AND selected=1").run(revisionId, key);
+        const result = db
+            .prepare("UPDATE revision_pieces SET selected=1 WHERE id=? AND revision_id=? AND piece_key=?")
+            .run(recordId, revisionId, key);
+        if (Number(result.changes) !== 1)
+            throw new Error("Published piece record was not found.");
+    });
+}
+function toOutput(value) {
+    const row = outputRow.parse(value);
+    return {
+        recordId: row.id,
+        publicationId: row.publication_id,
+        selected: row.selected,
+        slot: row.slot,
+        workKey: row.work_key,
+        assetId: row.asset_id,
+        output: outputSchema.parse(JSON.parse(row.descriptor)),
+        fingerprint: row.fingerprint,
+        state: row.state,
+    };
+}
+function toPiece(value) {
+    const row = pieceRow.parse(value);
+    return {
+        recordId: row.id,
+        publicationId: row.publication_id,
+        selected: row.selected,
+        key: row.piece_key,
+        stageKind: row.stage_kind,
+        piece: stagePieceSchema.parse(JSON.parse(row.descriptor)),
+        assetId: row.asset_id,
+        fingerprint: row.fingerprint,
+    };
+}

package/dist/slices/revisions/model.js

@@ -0,0 +1 @@
+export {};

package/dist/slices/revisions/mutation-assets.js

@@ -0,0 +1,143 @@
+import { statSync } from "node:fs";
+import { z } from "zod";
+import { outputPath, stagingPath } from "../storage/layout.js";
+import { stagedFileById } from "../storage/repo.js";
+export function bindUpload(content, upload, assetId) {
+    const to = upload.destination;
+    if (to.kind === "provided")
+        return { ...content, provided: { ...content.provided, [to.stage]: assetId } };
+    if (to.kind === "narration")
+        return {
+            ...content,
+            narrationOverrides: { ...content.narrationOverrides, [to.key]: { kind: "asset", assetId } },
+        };
+    const image = content.imageDefinitions[to.imageKey];
+    if (image === undefined)
+        throw new Error("Validated image destination disappeared.");
+    return {
+        ...content,
+        imageDefinitions: {
+            ...content.imageDefinitions,
+            [to.imageKey]: { ...image, source: "provide", assetId, prompt: null, templateKey: null },
+        },
+    };
+}
+export function validateUploads(deps, edit) {
+    const fields = [];
+    const staged = new Set();
+    const destinations = new Set();
+    for (const [index, upload] of (edit.uploads ?? []).entries()) {
+        const field = `uploads.${index}`;
+        const to = upload.destination;
+        if ((to.kind === "provided" && edit.config.sources[to.stage] !== "provide") ||
+            (to.kind === "narration" && edit.config.sources.audio !== "generate") ||
+            (to.kind === "image" && edit.config.sources.images === "off"))
+            fields.push({
+                field,
+                message: "Enable the corresponding provided or generated content before importing this file.",
+            });
+        const destination = JSON.stringify(to);
+        if (staged.has(upload.stagedFileId) || destinations.has(destination))
+            fields.push({ field, message: "Each upload and destination must be unique." });
+        staged.add(upload.stagedFileId);
+        destinations.add(destination);
+        const file = stagedFileById(deps.db, upload.stagedFileId);
+        const kind = to.kind === "provided" ? to.stage : to.kind === "image" ? "images" : "audio";
+        if (file === undefined ||
+            file.state !== "staged" ||
+            file.stageKind !== kind ||
+            !statSync(stagingPath(deps.paths, file.path), { throwIfNoEntry: false })?.isFile())
+            fields.push({ field, message: "Choose a completed upload for this stage." });
+        if (to.kind === "image" && edit.content.imageDefinitions[to.imageKey] === undefined)
+            fields.push({ field, message: "Choose an image in this revision." });
+        if (to.kind === "narration" && !to.key.startsWith("audio:"))
+            fields.push({ field, message: "Choose a narration segment." });
+    }
+    return fields;
+}
+export function validateAssetReferences(deps, projectId, content, prepared) {
+    const fields = [];
+    const refs = [];
+    for (const key of ["research", "article", "audio", "thumbnail"]) {
+        const id = content.provided[key];
+        if (id !== undefined)
+            refs.push([`content.provided.${key}`, id, key, false]);
+    }
+    for (const [key, row] of Object.entries(content.imageDefinitions))
+        if (row.assetId !== null)
+            refs.push([`content.imageDefinitions.${key}.assetId`, row.assetId, "images", true]);
+    for (const [key, row] of Object.entries(content.narrationOverrides))
+        if (row.kind === "asset")
+            refs.push([`content.narrationOverrides.${key}.assetId`, row.assetId, "audio", true]);
+    const roles = {
+        research: ["notes"],
+        article: ["article_md", "article_txt"],
+        audio: ["audio_body", "audio_intro", "audio_outro", "audio_export"],
+        images: ["image"],
+        thumbnail: ["thumbnail"],
+    };
+    for (const [field, id, kind, allowPiece] of refs) {
+        if (!prepared.some((row) => row.id === id && row.projectId === projectId) &&
+            deps.db
+                .prepare("SELECT 1 FROM project_assets WHERE project_id=? AND id=?")
+                .get(projectId, id) === undefined)
+            fields.push({ field, message: "Choose an asset belonging to this project." });
+        if (!prepared.some((row) => row.id === id) &&
+            deps.db
+                .prepare("SELECT 1 FROM revision_outputs WHERE project_id=? AND asset_id=? AND json_extract(descriptor,'$.stageKind')=? AND json_extract(descriptor,'$.role') IN (SELECT value FROM json_each(?))")
+                .get(projectId, id, kind, JSON.stringify(roles[kind])) === undefined &&
+            (!allowPiece ||
+                deps.db
+                    .prepare("SELECT 1 FROM revision_pieces WHERE project_id=? AND asset_id=? AND stage_kind=? AND json_extract(descriptor,'$.kind') IN (SELECT value FROM json_each(?))")
+                    .get(projectId, id, kind, JSON.stringify(kind === "audio" ? ["chunk", "segment"] : ["image"])) === undefined))
+            fields.push({ field, message: "Choose an asset for this content stage." });
+    }
+    return fields;
+}
+export async function measureAudio(deps, projectId, path) {
+    if (deps.measureAudio === undefined)
+        throw new Error("Audio inspection is unavailable.");
+    const duration = await deps.measureAudio(outputPath(deps.paths, projectId, path));
+    if (!Number.isFinite(duration) || duration < 0)
+        throw new Error("Audio inspection returned an invalid duration.");
+    return duration;
+}
+export function assetPath(deps, projectId, id) {
+    return z
+        .object({ path: z.string() })
+        .parse(deps.db
+        .prepare("SELECT path FROM project_assets WHERE project_id=? AND id=?")
+        .get(projectId, id)).path;
+}
+export function providedAssetSelected(base, kind, assetId) {
+    return (base.revision.config.sources[kind] === "provide" &&
+        base.outputs.some((row) => row.selected &&
+            row.assetId === assetId &&
+            row.workKey === (kind === "audio" ? "audio:provided" : "thumbnail:image") &&
+            row.output.role === (kind === "audio" ? "audio_body" : "thumbnail")));
+}
+export function validateReplacementAvailability(deps, base, edit) {
+    const previous = new Set([
+        ...Object.values(base.revision.content.provided),
+        ...Object.values(base.revision.content.imageDefinitions).map((row) => row.assetId),
+        ...Object.values(base.revision.content.narrationOverrides).flatMap((row) => row.kind === "asset" ? [row.assetId] : []),
+    ]);
+    for (const kind of ["audio", "thumbnail"]) {
+        const assetId = edit.content.provided[kind];
+        if (assetId !== undefined &&
+            edit.config.sources[kind] === "provide" &&
+            !providedAssetSelected(base, kind, assetId) &&
+            !edit.uploads?.some((row) => row.destination.kind === "provided" && row.destination.stage === kind))
+            previous.delete(assetId);
+    }
+    const next = [
+        ...Object.values(edit.content.provided),
+        ...Object.values(edit.content.imageDefinitions).map((row) => row.assetId),
+        ...Object.values(edit.content.narrationOverrides).flatMap((row) => row.kind === "asset" ? [row.assetId] : []),
+    ];
+    return next.flatMap((id) => id == null ||
+        previous.has(id) ||
+        statSync(outputPath(deps.paths, base.revision.projectId, assetPath(deps, base.revision.projectId, id)), { throwIfNoEntry: false })?.isFile()
+        ? []
+        : [{ field: "content", message: "The replacement asset is missing. Upload it again." }]);
+}

package/dist/slices/revisions/mutation-cues.js

@@ -0,0 +1,95 @@
+import { isDeepStrictEqual } from "node:util";
+import { assetPath, measureAudio } from "./mutation-assets.js";
+import { validateCues } from "./rules.js";
+export function cuesChanged(base, edit) {
+    return (edit.content.subtitleCues !== undefined &&
+        !isDeepStrictEqual(base.revision.content.subtitleCues, edit.content.subtitleCues));
+}
+export async function inspectCueAudio(deps, base, edit, prepared) {
+    const durations = new Map();
+    if (!cuesChanged(base, edit))
+        return durations;
+    for (const row of [
+        ...base.outputs
+            .filter((row) => row.selected && row.available)
+            .map((row) => ({ assetId: row.assetId, output: row.output })),
+        ...prepared.map((row) => ({ assetId: row.asset.id, output: row.output })),
+    ]) {
+        if (!row.output.role.startsWith("audio_") || row.output.role === "audio_export")
+            continue;
+        durations.set(row.assetId, row.output.durationMs ?? (await measureAudio(deps, base.revision.projectId, row.output.path)));
+    }
+    for (const row of base.pieces.filter((row) => row.selected && row.available && row.stageKind === "audio" && row.assetId !== null))
+        if (row.assetId !== null && !durations.has(row.assetId))
+            durations.set(row.assetId, await measureAudio(deps, base.revision.projectId, assetPath(deps, base.revision.projectId, row.assetId)));
+    for (const row of Object.values(edit.content.narrationOverrides))
+        if (row.kind === "asset" && !durations.has(row.assetId))
+            durations.set(row.assetId, await measureAudio(deps, base.revision.projectId, assetPath(deps, base.revision.projectId, row.assetId)));
+    return durations;
+}
+export function validateProposedCues(base, edit, plan, prepared, durations) {
+    const cues = edit.content.subtitleCues;
+    if (cues === undefined || !cuesChanged(base, edit))
+        return [];
+    const fail = () => [
+        {
+            field: "content.subtitleCues",
+            message: "Save captions against the current, complete narration timeline.",
+        },
+    ];
+    const candidates = [
+        ...plan.manifest.outputs
+            .filter((row) => row.state === "ready")
+            .map((row) => ({ key: row.workKey, assetId: row.assetId, duration: row.output.durationMs })),
+        ...prepared
+            .filter((row) => row.upload?.destination.kind !== "narration")
+            .map((row) => ({ key: row.workKey, assetId: row.asset.id, duration: row.output.durationMs })),
+    ];
+    const durationFor = (key) => {
+        const selected = candidates.findLast((row) => row.key === key);
+        if (selected !== undefined)
+            return selected.duration ?? durations.get(selected.assetId);
+        const recipe = plan.recipes.find((row) => row.key === key);
+        if (recipe === undefined)
+            return undefined;
+        if (recipe.input.kind === "provided" && recipe.input.assetId !== null)
+            return durations.get(recipe.input.assetId);
+        if (recipe.input.kind === "local" && recipe.input.operation === "concat-narration") {
+            const parts = recipe.dependsOn.map(durationFor);
+            return parts.some((one) => one === undefined)
+                ? undefined
+                : parts.reduce((sum, one) => sum + (one ?? 0), 0);
+        }
+        if (plan.baseFingerprints[key] !== plan.fingerprints[key])
+            return undefined;
+        const prefix = key.replace(/:1$/, ":");
+        const parts = plan.manifest.pieces.filter((row) => row.stageKind === "audio" &&
+            row.piece.state === "done" &&
+            (row.key === key || row.key.startsWith(prefix)));
+        if (parts.length === 0)
+            return undefined;
+        const values = parts.map((row) => row.assetId === null ? undefined : durations.get(row.assetId));
+        return values.some((one) => one === undefined)
+            ? undefined
+            : values.reduce((sum, one) => sum + (one ?? 0), 0);
+    };
+    const keys = plan.config.sources.audio === "provide"
+        ? ["audio:provided"]
+        : ["audio:intro", "audio:body:concat", "audio:outro"].filter((key) => plan.fingerprints[key] !== undefined);
+    if (keys.length === 0)
+        return fail();
+    const parts = keys.map(durationFor);
+    if (parts.some((one) => one === undefined))
+        return fail();
+    const seconds = parts.reduce((sum, one) => sum + (one ?? 0), 0) / 1000 +
+        Math.max(0, keys.length - 1) * plan.config.silenceGapSeconds;
+    return validateCues(cues.cues, seconds);
+}
+export function measuredOutputs(deps, base, durations) {
+    return base.outputs.flatMap((row) => {
+        const durationMs = durations.get(row.assetId);
+        return row.selected && row.output.durationMs === null && durationMs !== undefined
+            ? [{ ...row, output: { ...row.output, id: deps.ids.next(), durationMs } }]
+            : [];
+    });
+}

package/dist/slices/revisions/mutation-prepare.js

@@ -0,0 +1,182 @@
+import { z } from "zod";
+import { plainText } from "../article/plain.js";
+import { splitEndMatter } from "../article/split.js";
+import { normalizeArticleIntent } from "../rebuild/recipe-save.js";
+import { discardPreparedAssets } from "../storage/assets.js";
+import { prepareStagedFile, prepareText } from "../storage/prepare.js";
+import { outputSchema } from "../storage/schema.js";
+import { bindUpload, measureAudio, providedAssetSelected, } from "./mutation-assets.js";
+export async function prepareEditAssets(deps, base, edit) {
+    const prepared = [];
+    const allocated = [];
+    try {
+        const projectId = base.revision.projectId;
+        let content = normalizeArticleIntent(base, edit);
+        for (const upload of edit.uploads ?? []) {
+            const to = upload.destination;
+            const role = to.kind === "image"
+                ? "image"
+                : to.kind === "provided" && to.stage === "thumbnail"
+                    ? "thumbnail"
+                    : "audio_body";
+            const result = prepareStagedFile(deps, {
+                projectId,
+                stagedFileId: upload.stagedFileId,
+                role,
+                index: to.kind === "image" ? content.imageOrder.indexOf(to.imageKey) + 1 : 1,
+            });
+            if (!result.ok)
+                throw new Error("A validated upload became unavailable.");
+            const workKey = to.kind === "image"
+                ? `image:${to.imageKey}`
+                : to.kind === "narration"
+                    ? to.key
+                    : to.stage === "audio"
+                        ? "audio:provided"
+                        : "thumbnail:image";
+            const item = {
+                ...result,
+                upload,
+                workKey,
+                slot: to.kind === "image"
+                    ? workKey
+                    : to.kind === "narration"
+                        ? workKey
+                        : `${result.output.stageKind}:${role}`,
+            };
+            allocated.push(result.asset);
+            const durationMs = result.output.stageKind === "audio"
+                ? await measureAudio(deps, projectId, result.asset.path)
+                : item.output.durationMs;
+            prepared.push({ ...item, output: { ...item.output, durationMs } });
+            content = bindUpload(content, upload, result.asset.id);
+        }
+        for (const [index, key] of content.imageOrder.entries()) {
+            const definition = content.imageDefinitions[key];
+            const assetId = definition?.assetId;
+            const workKey = `image:${key}`;
+            if (definition?.source !== "provide" ||
+                assetId == null ||
+                prepared.some((row) => row.workKey === workKey) ||
+                base.outputs.some((row) => row.selected &&
+                    row.workKey === workKey &&
+                    row.assetId === assetId &&
+                    row.output.role === "image"))
+                continue;
+            const asset = retainedAsset(deps, projectId, assetId);
+            const existing = deps.db
+                .prepare("SELECT descriptor FROM revision_outputs WHERE project_id=? AND asset_id=? AND json_extract(descriptor,'$.stageKind')='images' AND json_extract(descriptor,'$.role')='image' LIMIT 1")
+                .get(projectId, assetId);
+            const descriptor = existing === undefined
+                ? {
+                    projectId,
+                    stageKind: "images",
+                    role: "image",
+                    path: asset.path,
+                    originalFilename: null,
+                    bytes: asset.bytes,
+                    durationMs: null,
+                    meta: {},
+                    createdAt: asset.createdAt,
+                }
+                : outputSchema.parse(JSON.parse(z.string().parse(existing.descriptor)));
+            prepared.push({
+                asset,
+                output: {
+                    ...descriptor,
+                    id: deps.ids.next(),
+                    meta: { ...descriptor.meta, index: index + 1 },
+                },
+                workKey,
+                slot: workKey,
+            });
+        }
+        for (const kind of ["audio", "thumbnail"]) {
+            const assetId = content.provided[kind];
+            if (edit.config.sources[kind] !== "provide" ||
+                assetId === undefined ||
+                providedAssetSelected(base, kind, assetId) ||
+                prepared.some((row) => row.asset.id === assetId))
+                continue;
+            const existing = deps.db
+                .prepare("SELECT descriptor FROM revision_outputs WHERE project_id=? AND asset_id=? AND json_extract(descriptor,'$.stageKind')=? LIMIT 1")
+                .get(projectId, assetId, kind);
+            if (existing === undefined)
+                throw new Error("Validated replacement asset has no descriptor.");
+            const descriptor = outputSchema.parse(JSON.parse(z.string().parse(existing.descriptor)));
+            const asset = retainedAsset(deps, projectId, assetId);
+            const role = kind === "audio" ? "audio_body" : "thumbnail";
+            const item = {
+                asset,
+                output: {
+                    ...descriptor,
+                    id: deps.ids.next(),
+                    role,
+                    durationMs: kind === "audio"
+                        ? await measureAudio(deps, projectId, asset.path)
+                        : descriptor.durationMs,
+                },
+                workKey: kind === "audio" ? "audio:provided" : "thumbnail:image",
+                slot: `${kind}:${role}`,
+            };
+            prepared.push(item);
+        }
+        const article = edit.config.sources.article === "provide" || content.articleEdited === true
+            ? (content.articleMarkdown ?? edit.config.provided.article)
+            : undefined;
+        if (article !== undefined &&
+            (article !== base.articleMarkdown ||
+                !base.outputs.some((row) => row.selected && row.available && row.output.role === "article_md"))) {
+            const end = splitEndMatter(article);
+            const texts = [
+                ["article_md", article],
+                ["article_txt", plainText(end.body)],
+                ["sources", end.sources],
+                ["glossary", end.glossary],
+            ];
+            for (const [role, text] of texts)
+                if (text.trim() !== "" || role === "article_md" || role === "article_txt") {
+                    const row = prepareText(deps, { projectId, stageKind: "article", role, text });
+                    allocated.push(row.asset);
+                    prepared.push({ ...row, workKey: "article:body", slot: `article:${role}` });
+                }
+        }
+        if (edit.config.sources.research === "provide" &&
+            (edit.config.provided.research !== base.revision.config.provided.research ||
+                !base.outputs.some((row) => row.selected && row.output.role === "notes"))) {
+            const row = prepareText(deps, {
+                projectId,
+                stageKind: "research",
+                role: "notes",
+                text: edit.config.provided.research ?? "",
+            });
+            allocated.push(row.asset);
+            prepared.push({ ...row, workKey: "research:notes", slot: "research:notes" });
+        }
+        return { edit: { ...edit, content }, assets: prepared };
+    }
+    catch (error) {
+        discardPreparedAssets(deps, allocated);
+        throw error;
+    }
+}
+function retainedAsset(deps, projectId, assetId) {
+    const row = z
+        .object({
+        id: z.string(),
+        project_id: z.string(),
+        path: z.string(),
+        bytes: z.number(),
+        created_at: z.string(),
+    })
+        .parse(deps.db
+        .prepare("SELECT * FROM project_assets WHERE project_id=? AND id=?")
+        .get(projectId, assetId));
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        path: row.path,
+        bytes: row.bytes,
+        createdAt: row.created_at,
+    };
+}

package/dist/slices/revisions/mutation-request.js

@@ -0,0 +1,58 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { currentRevisionId } from "./repo.js";
+import { getRevisionView } from "./view.js";
+export function requestHash(operation, baseRevisionId, input) {
+    return createHash("sha256")
+        .update(JSON.stringify([operation, baseRevisionId, input], (_key, value) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return value;
+        return Object.fromEntries(Object.entries(value).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+    }))
+        .digest("hex");
+}
+export function refusal(deps, projectId, reason) {
+    return { ok: false, reason, currentRevisionId: currentRevisionId(deps.db, projectId) ?? null };
+}
+export function checkMutation(deps, input) {
+    const { db } = deps;
+    const row = db
+        .prepare("SELECT operation,request_hash,result_revision_id FROM revision_mutations WHERE project_id=? AND idempotency_key=?")
+        .get(input.projectId, input.idempotencyKey);
+    if (row !== undefined) {
+        const receipt = z
+            .object({ operation: z.string(), request_hash: z.string(), result_revision_id: z.string() })
+            .parse(row);
+        if (receipt.operation !== input.operation || receipt.request_hash !== input.hash)
+            return refusal(deps, input.projectId, "idempotency-conflict");
+        return {
+            ok: true,
+            view: requiredView(deps, input.projectId, receipt.result_revision_id),
+            duplicate: true,
+        };
+    }
+    if (db
+        .prepare("SELECT 1 FROM rebuild_admissions WHERE project_id=? AND idempotency_key=?")
+        .get(input.projectId, input.idempotencyKey) !== undefined)
+        return refusal(deps, input.projectId, "idempotency-conflict");
+    if (db
+        .prepare("SELECT 1 FROM project_control_receipts WHERE project_id=? AND idempotency_key=?")
+        .get(input.projectId, input.idempotencyKey) !== undefined)
+        return refusal(deps, input.projectId, "idempotency-conflict");
+    if (db.prepare("SELECT 1 FROM projects WHERE id=?").get(input.projectId) === undefined)
+        return refusal(deps, input.projectId, "no-project");
+    if (currentRevisionId(db, input.projectId) !== input.baseRevisionId)
+        return refusal(deps, input.projectId, "conflict");
+    return undefined;
+}
+export function requiredView(deps, projectId, revisionId) {
+    const view = getRevisionView(deps, projectId, revisionId);
+    if (view === undefined)
+        throw new Error("The retained revision was not found.");
+    return view;
+}
+export function insertReceipt(deps, input, revisionId) {
+    deps.db
+        .prepare("INSERT INTO revision_mutations(project_id,idempotency_key,operation,request_hash,base_revision_id,result_revision_id,created_at) VALUES (?,?,?,?,?,?,?)")
+        .run(input.projectId, input.idempotencyKey, input.operation, input.hash, input.baseRevisionId, revisionId, deps.clock.now().toISOString());
+}

package/dist/slices/revisions/mutation-work.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { buildRecipes } from "../rebuild/recipe-build.js";
+import { recipeInputSchema } from "../rebuild/recipe-input-schema.js";
+export function preserveDeferredIntent(deps, base, plan) {
+    const rows = deps.db
+        .prepare("SELECT p.input_json,r.work_key,r.fingerprint,r.logical_key,r.desired_fingerprint FROM revision_work_reservations r JOIN revision_work_pieces p ON p.id=r.piece_id JOIN revision_work w ON w.id=r.work_id WHERE r.project_id=? AND r.revision_id=? AND (w.dispatch_state='allowed' OR p.dispatch_state='allowed')")
+        .all(base.revision.projectId, base.revision.id);
+    const before = buildRecipes({
+        config: base.revision.config,
+        content: base.revision.content,
+        manifest: {
+            outputs: base.outputs.filter((row) => row.selected),
+            pieces: base.pieces.filter((row) => row.selected),
+        },
+        resolved: {
+            articleMarkdown: null,
+            researchNotes: base.revision.config.provided.research ?? null,
+        },
+    });
+    const after = buildRecipes({
+        config: plan.config,
+        content: plan.content,
+        manifest: plan.manifest,
+        resolved: { articleMarkdown: null, researchNotes: plan.config.provided.research ?? null },
+    });
+    const fingerprints = { ...plan.fingerprints };
+    const baseFingerprints = { ...plan.baseFingerprints };
+    const recipes = [...plan.recipes];
+    for (const row of rows) {
+        const input = recipeInputSchema.parse(JSON.parse(z.string().parse(row.input_json)));
+        const key = z.string().parse(row.logical_key ?? row.work_key);
+        if (input.kind !== "deferred" || fingerprints[key] !== undefined)
+            continue;
+        const old = before.find((one) => one.key === key);
+        const next = after.find((one) => one.key === key);
+        const desired = z.string().parse(row.desired_fingerprint ?? row.fingerprint);
+        if (old !== undefined &&
+            next !== undefined &&
+            old.fingerprint === next.fingerprint &&
+            old.fingerprint === desired) {
+            fingerprints[key] = desired;
+            baseFingerprints[key] = desired;
+            recipes.push(next);
+        }
+    }
+    return { ...plan, fingerprints, baseFingerprints, recipes };
+}