@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/slices/revisions/adopt-content.js

@@ -0,0 +1,112 @@
+import { readFileSync, statSync } from "node:fs";
+import { z } from "zod";
+import { legacyImageOutput } from "../rebuild/recipe-legacy.js";
+import { outputPath } from "../storage/layout.js";
+import { pieceFile } from "../storage/reconcile.js";
+const imagePayload = z.object({
+    prompt: z.string().optional(),
+    promptIndex: z.number().int().positive().optional(),
+});
+export function baselineContent(deps, project, outputs, pieces, assets, templates = {}) {
+    const article = outputs.find((row) => row.role === "article_md");
+    const articlePath = article === undefined ? undefined : outputPath(deps.paths, project.id, article.path);
+    const articleMarkdown = articlePath !== undefined && statSync(articlePath, { throwIfNoEntry: false })?.isFile() === true
+        ? readFileSync(articlePath, "utf8")
+        : undefined;
+    const provided = {};
+    const roles = {
+        research: "notes",
+        article: "article_md",
+        audio: "audio_body",
+        thumbnail: "thumbnail",
+    };
+    for (const [stage, role] of Object.entries(roles)) {
+        if (stage !== "research" && stage !== "article" && stage !== "audio" && stage !== "thumbnail")
+            continue;
+        if (project.config.sources[stage] !== "provide")
+            continue;
+        const output = outputs.find((row) => row.role === role);
+        const asset = output === undefined ? undefined : assets.get(output.path);
+        if (asset !== undefined)
+            provided[stage] = asset.id;
+    }
+    const imageDefinitions = {};
+    const order = [];
+    const imagePieces = pieces.filter((row) => row.kind === "image");
+    const images = outputs.filter((row) => row.role === "image");
+    for (const output of images) {
+        const piece = imagePieces.find((row) => legacyImageOutput(row, images)?.id === output.id);
+        const payload = parsedImage(piece?.payload ?? null);
+        const supplied = project.config.sources.images === "provide" ||
+            (project.config.sources.images === "off" &&
+                piece === undefined &&
+                output.originalFilename !== null &&
+                output.meta.provider === undefined &&
+                output.meta.prompt === undefined);
+        imageDefinitions[output.id] = {
+            source: supplied ? "provide" : "generate",
+            assetId: assets.get(output.path)?.id ?? null,
+            prompt: supplied ? null : (payload?.prompt ?? output.meta.prompt ?? null),
+            templateKey: supplied ? null : templateKey(payload?.promptIndex),
+        };
+        order.push({ key: output.id, index: output.meta.index ?? 0 });
+    }
+    for (const piece of imagePieces) {
+        if (legacyImageOutput(piece, images) !== undefined)
+            continue;
+        const payload = parsedImage(piece.payload);
+        const path = pieceFile(piece.payload);
+        imageDefinitions[piece.id] = {
+            source: "generate",
+            assetId: path === undefined ? null : (assets.get(path)?.id ?? null),
+            prompt: payload?.prompt ?? null,
+            templateKey: templateKey(payload?.promptIndex),
+        };
+        order.push({ key: piece.id, index: piece.idx });
+    }
+    if (project.config.sources.images === "generate" &&
+        images.length === 0 &&
+        imagePieces.length === 0) {
+        for (const [index, prompt] of project.config.imagePrompts.entries()) {
+            const key = `imagePrompts.${index}`;
+            for (let send = 0; send < prompt.number; send += 1) {
+                const id = deps.ids.next();
+                imageDefinitions[id] = {
+                    source: "generate",
+                    assetId: null,
+                    prompt: project.config.rendered[key] ?? null,
+                    templateKey: templates[key] === undefined ? null : key,
+                };
+                order.push({ key: id, index: order.length });
+            }
+        }
+    }
+    return {
+        ...(articleMarkdown === undefined ? {} : { articleMarkdown }),
+        articleEdited: false,
+        provided,
+        imageOrder: order.sort((a, b) => a.index - b.index).map((row) => row.key),
+        imageDefinitions,
+        narrationOverrides: {},
+        regenerationTokens: {},
+        promptTemplates: Object.fromEntries(Object.keys(project.config.rendered).map((key) => [key, templates[key] ?? null])),
+    };
+}
+function parsedImage(payload) {
+    if (payload === null)
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(payload);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+    const result = imagePayload.safeParse(value);
+    return result.success ? result.data : undefined;
+}
+function templateKey(index) {
+    return index === undefined ? null : `imagePrompts.${index - 1}`;
+}

package/dist/slices/revisions/adopt.js

@@ -0,0 +1,100 @@
+import { transact } from "../../kernel/db/tx.js";
+import { allPiecesOf } from "../../kernel/runner/piece-repo.js";
+import { projectById, stagesOf } from "../admission/repo.js";
+import { withProjectControl } from "../control/lock.js";
+import { legacyImageOutput } from "../rebuild/recipe-legacy.js";
+import { baselineFingerprints, legacyOutputSlot, legacyOutputWorkKey, legacyPieceKey, } from "../rebuild/recipes.js";
+import { pieceFile } from "../storage/reconcile.js";
+import { outputsOf } from "../storage/repo.js";
+import { adoptAssets } from "./adopt-assets.js";
+import { baselineContent } from "./adopt-content.js";
+import { currentRevisionId, insertManifestOutput, insertManifestPiece, insertRevision, selectOutputRecord, selectPieceRecord, } from "./repo.js";
+import { getRevisionView } from "./view.js";
+export function ensureBaseline(deps, projectId) {
+    return withProjectControl(deps.db, projectId, () => adoptBaseline(deps, projectId));
+}
+export function adoptBaseline(deps, projectId, templates) {
+    return transact(deps.db, () => {
+        const project = projectById(deps.db, projectId);
+        if (project === undefined)
+            return { ok: false, reason: "no-project" };
+        const head = currentRevisionId(deps.db, projectId);
+        if (head !== undefined) {
+            const view = getRevisionView(deps, projectId, head);
+            if (view === undefined)
+                throw new Error("The project head has no revision.");
+            return { ok: true, created: false, view };
+        }
+        const outputs = outputsOf(deps.db, projectId);
+        const stages = stagesOf(deps.db, projectId);
+        const pieces = stages.flatMap((stage) => allPiecesOf(deps.db, stage.id));
+        const assets = adoptAssets(deps, projectId, outputs, pieces);
+        const content = baselineContent(deps, project, outputs, pieces, assets, templates);
+        const fingerprints = baselineFingerprints(project, outputs, pieces, content, stages);
+        const revision = {
+            id: deps.ids.next(),
+            projectId,
+            parentId: null,
+            restoredFromId: null,
+            config: project.config,
+            content,
+            fingerprints,
+            createdAt: deps.clock.now().toISOString(),
+        };
+        insertRevision(deps.db, revision);
+        const selectedSlots = new Set();
+        const selectedPieces = new Set();
+        const recordedFingerprint = (key) => {
+            const value = fingerprints[key];
+            if (value === undefined)
+                throw new Error(`No baseline fingerprint for retained work ${key}`);
+            return value;
+        };
+        for (const output of outputs) {
+            const asset = assets.get(output.path);
+            if (asset === undefined)
+                throw new Error("The retained output has no registered asset.");
+            const slot = legacyOutputSlot(output);
+            const workKey = legacyOutputWorkKey(output, project.config);
+            const recordId = deps.ids.next();
+            insertManifestOutput(deps.db, revision, {
+                slot,
+                workKey,
+                assetId: asset.id,
+                output,
+                fingerprint: recordedFingerprint(workKey),
+                state: "ready",
+            }, recordId);
+            if (!selectedSlots.has(slot)) {
+                selectOutputRecord(deps.db, revision.id, slot, recordId);
+                selectedSlots.add(slot);
+            }
+        }
+        for (const stage of stages) {
+            for (const piece of pieces.filter((row) => row.stageId === stage.id)) {
+                const image = piece.kind === "image" ? legacyImageOutput(piece, outputs) : undefined;
+                const path = pieceFile(piece.payload) ?? image?.path;
+                const key = legacyPieceKey(piece, stage.kind, outputs);
+                const recordId = deps.ids.next();
+                insertManifestPiece(deps.db, revision, {
+                    key,
+                    stageKind: stage.kind,
+                    piece,
+                    assetId: path === undefined ? null : (assets.get(path)?.id ?? null),
+                    fingerprint: recordedFingerprint(key),
+                }, recordId);
+                if (!selectedPieces.has(key)) {
+                    selectPieceRecord(deps.db, revision.id, key, recordId);
+                    selectedPieces.add(key);
+                }
+            }
+        }
+        deps.db
+            .prepare("INSERT INTO project_heads(project_id,revision_id) VALUES (?,?)")
+            .run(projectId, revision.id);
+        const view = getRevisionView(deps, projectId, revision.id);
+        if (view === undefined)
+            throw new Error("The adopted revision was not retained.");
+        return { ok: true, created: true, view };
+    });
+}

package/dist/slices/revisions/downloads.js

@@ -0,0 +1,80 @@
+import { readFileSync, statSync } from "node:fs";
+import { extname } from "node:path";
+import { zipSync } from "fflate";
+import { z } from "zod";
+import { stageKinds } from "../../kernel/pipeline.js";
+import { contentTypeOf, downloadName, slugOf } from "../storage/downloads.js";
+import { outputPath } from "../storage/layout.js";
+import { projectTitle } from "../storage/repo.js";
+import { outputSchema } from "../storage/schema.js";
+import { positionedOutput } from "./projection.js";
+import { outputsForRevision, revisionById } from "./repo.js";
+import { stagePieceSchema } from "./schema.js";
+export function findRevisionDownload(deps, projectId, revisionId, recordId) {
+    if (projectTitle(deps.db, projectId) === undefined)
+        return { ok: false, reason: "unknown-project" };
+    const revision = revisionById(deps.db, projectId, revisionId);
+    if (revision === undefined)
+        return { ok: false, reason: "unknown-asset" };
+    const output = deps.db
+        .prepare(`SELECT o.descriptor, a.path FROM revision_outputs o
+    JOIN project_assets a ON a.project_id=o.project_id AND a.id=o.asset_id
+    WHERE o.project_id=? AND o.revision_id=? AND o.id=?`)
+        .get(projectId, revisionId, recordId);
+    if (output !== undefined) {
+        const path = outputPath(deps.paths, projectId, z.string().parse(output.path));
+        const descriptor = outputSchema.parse(JSON.parse(z.string().parse(output.descriptor)));
+        return fileDownload(path, downloadName(slugOf(revision.config.title), { ...descriptor, path }));
+    }
+    const piece = deps.db
+        .prepare(`SELECT p.descriptor, p.stage_kind, a.path FROM revision_pieces p
+    JOIN project_assets a ON a.project_id=p.project_id AND a.id=p.asset_id
+    WHERE p.project_id=? AND p.revision_id=? AND p.id=?`)
+        .get(projectId, revisionId, recordId);
+    if (piece === undefined)
+        return { ok: false, reason: "unknown-asset" };
+    const path = outputPath(deps.paths, projectId, z.string().parse(piece.path));
+    const descriptor = stagePieceSchema.parse(JSON.parse(z.string().parse(piece.descriptor)));
+    const stageKind = z.enum(stageKinds).parse(piece.stage_kind);
+    return fileDownload(path, `${slugOf(revision.config.title)}-${stageKind}-${descriptor.kind}-${descriptor.idx}${extname(path)}`);
+}
+export function revisionImagesZip(deps, projectId, revisionId) {
+    if (projectTitle(deps.db, projectId) === undefined)
+        return { ok: false, reason: "unknown-project" };
+    const revision = revisionById(deps.db, projectId, revisionId);
+    if (revision === undefined)
+        return { ok: false, reason: "no-images" };
+    const slug = slugOf(revision.config.title);
+    const entries = {};
+    const images = outputsForRevision(deps.db, projectId, revisionId)
+        .filter((row) => row.selected && (row.output.role === "image" || row.output.role === "thumbnail"))
+        .map((row) => positionedOutput(revision, row))
+        .sort((a, b) => imageOrder(a.output.role, a.output.meta.index) -
+        imageOrder(b.output.role, b.output.meta.index));
+    for (const row of images) {
+        const asset = deps.db
+            .prepare("SELECT path FROM project_assets WHERE project_id=? AND id=?")
+            .get(projectId, row.assetId);
+        if (asset === undefined)
+            throw new Error("Revision image asset is not registered.");
+        const path = outputPath(deps.paths, projectId, z.string().parse(asset.path));
+        if (statSync(path, { throwIfNoEntry: false })?.isFile() !== true)
+            continue;
+        entries[downloadName(slug, { ...row.output, path })] = [readFileSync(path), { level: 0 }];
+    }
+    return Object.keys(entries).length === 0
+        ? { ok: false, reason: "no-images" }
+        : { ok: true, filename: `${slug}-images.zip`, bytes: zipSync(entries) };
+}
+function fileDownload(path, filename) {
+    const stats = statSync(path, { throwIfNoEntry: false });
+    return stats === undefined || !stats.isFile()
+        ? { ok: false, reason: "missing-file" }
+        : {
+            ok: true,
+            download: { path, filename, bytes: stats.size, contentType: contentTypeOf(path) },
+        };
+}
+function imageOrder(role, index) {
+    return role === "thumbnail" ? Number.MAX_SAFE_INTEGER : typeof index === "number" ? index : 0;
+}

package/dist/slices/revisions/index.js

@@ -0,0 +1,5 @@
+export { ensureBaseline } from "./adopt.js";
+export { restoreRevision, saveRevision } from "./mutations.js";
+export { commitRevisionOutputs } from "./publish.js";
+export { listRevisionHistory } from "./repo.js";
+export { getRevisionView } from "./view.js";

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