@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/slices/rebuild/provided-review.js

@@ -0,0 +1,32 @@
+import { requestHash } from "../revisions/mutation-request.js";
+export function providedDependencyFingerprint(plan, key) {
+    const recipe = plan.recipes.find((one) => one.key === key);
+    const timing = plan.recipes.find((one) => one.key === "subtitles:timing");
+    return requestHash("provided-review-v1", key, {
+        recipe,
+        dependencies: recipe?.dependsOn.map((dependency) => plan.recipes.find((one) => one.key === dependency)),
+        timing: key === "subtitles:cues"
+            ? timing?.input.kind === "local" && Array.isArray(timing.input.values)
+                ? timing.input.values.slice(1)
+                : null
+            : null,
+    });
+}
+export function applyProvidedReviews(db, revisionId, plan) {
+    const approved = new Set(db
+        .prepare("SELECT work_key,dependency_fingerprint FROM revision_provided_reviews WHERE revision_id=?")
+        .all(revisionId)
+        .filter((row) => row.dependency_fingerprint === providedDependencyFingerprint(plan, String(row.work_key)))
+        .map((row) => String(row.work_key)));
+    return {
+        ...plan,
+        work: plan.work.map((row) => approved.has(row.key) && row.disposition === "review"
+            ? {
+                ...row,
+                disposition: row.kind === "provided" ? "reuse" : "local",
+                reason: "Provided content was reviewed against these exact inputs.",
+            }
+            : row),
+        providedReuseRequired: plan.providedReuseRequired.filter((key) => !approved.has(key)),
+    };
+}

package/dist/slices/rebuild/recipe-audio.js

@@ -0,0 +1,172 @@
+import { fingerprint } from "../../kernel/runner/work.js";
+import { chunkNarration, defaultChunking } from "../narration/chunk.js";
+import { concatArgs } from "../narration/concat.js";
+import { narrationRegenerationToken, normalizeNarrationText, planNarration, } from "../narration/plan.js";
+import { recipe, resourceIdentity, selectedReference, } from "./recipe-model.js";
+export function audioRecipes(context, text) {
+    const { config, content } = context;
+    const recipes = [];
+    if (config.sources.audio === "off")
+        return { recipes, mediaFingerprint: null, timeline: [], keys: [] };
+    let body;
+    if (config.sources.audio === "provide") {
+        body = recipe(context, "audio:provided", "audio", {
+            kind: "provided",
+            version: 1,
+            assetId: content.provided.audio ?? null,
+            semantic: text.articleText ?? text.article.fingerprint,
+        }, [text.article.key], { unresolved: content.provided.audio === undefined });
+        recipes.push(body);
+    }
+    else {
+        const groups = text.articleText === null
+            ? []
+            : chunkNarration(normalizeNarrationText(text.articleText), config.chunking ?? defaultChunking);
+        const occurrences = new Map();
+        const parts = [];
+        for (const logicalText of groups) {
+            const hash = fingerprint(logicalText).slice(0, 20);
+            const occurrence = (occurrences.get(hash) ?? 0) + 1;
+            occurrences.set(hash, occurrence);
+            const logicalKey = `audio:body:${hash}-${occurrence}`;
+            parts.push(...narrationParts(context, logicalKey, logicalText, "body", [text.article.key]));
+        }
+        if (text.articleText === null)
+            parts.push(recipe(context, "audio:body:future", "audio", {
+                kind: "deferred",
+                version: 1,
+                operation: "body-narration",
+                template: [text.article.fingerprint, voiceValues(context), chunkingValues(context)],
+            }, [text.article.key]));
+        recipes.push(...parts);
+        body = recipe(context, "audio:body:concat", "audio", {
+            kind: "local",
+            version: 1,
+            operation: "concat-narration",
+            values: [
+                parts.map((part) => resourceIdentity(context, part)),
+                parts.length === 1 ? "copy-single-file" : concatArgs("$parts", "$output"),
+            ],
+        }, parts.map((part) => part.key), { unresolved: text.articleText !== null && groups.length === 0 });
+        recipes.push(body);
+    }
+    const ordered = [];
+    for (const category of ["intro", "body", "outro"]) {
+        if (category === "body") {
+            ordered.push({ value: body, transcript: text.articleText ?? text.article.fingerprint });
+            continue;
+        }
+        const entry = text.entries[category];
+        if (entry === undefined)
+            continue;
+        const parts = entry.text === null
+            ? [
+                recipe(context, `audio:${category}:future`, "audio", {
+                    kind: "deferred",
+                    version: 1,
+                    operation: `${category}-narration`,
+                    template: [entry.recipe.fingerprint, voiceValues(context)],
+                }, [entry.recipe.key]),
+            ]
+            : narrationParts(context, `audio:${category}`, entry.text, category, [entry.recipe.key]);
+        recipes.push(...parts);
+        const audio = recipe(context, `audio:${category}`, "audio", {
+            kind: "local",
+            version: 1,
+            operation: "concat-narration",
+            values: [
+                parts.map((part) => resourceIdentity(context, part)),
+                parts.length === 1 ? "copy-single-file" : concatArgs("$parts", "$output"),
+            ],
+        }, parts.map((part) => part.key));
+        recipes.push(audio);
+        ordered.push({ value: audio, transcript: entry.text ?? entry.recipe.fingerprint });
+    }
+    const timeline = ordered.map(({ value, transcript }) => {
+        const retained = context.manifest.outputs.find((row) => row.workKey === value.key && row.state === "ready" && selectedReference(row));
+        return {
+            audio: resourceIdentity(context, value),
+            transcript,
+            durationMs: retained?.output.durationMs ?? null,
+        };
+    });
+    return {
+        recipes,
+        mediaFingerprint: fingerprint([
+            "audio-media-v1",
+            ordered.map(({ value }) => resourceIdentity(context, value)),
+            config.silenceGapSeconds,
+        ]),
+        timeline,
+        keys: ordered.map(({ value }) => value.key),
+    };
+}
+function narrationParts(context, logicalKey, originalText, segment, dependsOn) {
+    const override = context.content.narrationOverrides[logicalKey];
+    if (override?.kind === "asset")
+        return [
+            recipe(context, `${logicalKey}:1`, "audio", {
+                kind: "provided",
+                version: 1,
+                assetId: override.assetId,
+                semantic: [normalizeNarrationText(originalText), voiceValues(context)],
+            }, dependsOn, { tokenKey: logicalKey }),
+        ];
+    const logicalText = normalizeNarrationText(override?.kind === "text" ? override.text : originalText);
+    const wholeRequest = segment !== "body" || (context.config.chunking?.mode ?? "whole") === "whole";
+    const choice = context.config.audio;
+    const model = context.catalogue?.tts.find((row) => row.provider === choice?.provider &&
+        row.id === choice.model &&
+        row.enabled &&
+        !row.deprecated);
+    const requests = planNarration({
+        groups: [
+            {
+                key: logicalKey,
+                text: logicalText,
+                segment,
+                wholeRequest,
+                regenerationToken: narrationRegenerationToken(context.content.regenerationTokens, logicalKey, segment),
+            },
+        ],
+        provider: choice?.provider ?? "",
+        model: choice?.model ?? "",
+        voice: choice?.voice ?? "",
+        maxCharacters: context.catalogue === undefined
+            ? Math.max(2, logicalText.length)
+            : (model?.tts.maxCharacters ?? Math.max(2, logicalText.length)),
+        retained: [],
+    });
+    return requests.map(({ text, key }) => recipe(context, key, "audio", {
+        kind: "tts",
+        version: 1,
+        provider: choice?.provider ?? "",
+        model: choice?.model ?? "",
+        voice: choice?.voice ?? "",
+        text,
+        logicalKey,
+        logicalText,
+        segment,
+        pronunciation: null,
+        wholeRequest,
+    }, dependsOn, { tokenKey: logicalKey, unresolved: logicalText.length === 0 }));
+}
+function voiceValues(context) {
+    return [
+        context.config.audio?.provider ?? null,
+        context.config.audio?.model ?? null,
+        context.config.audio?.voice ?? null,
+        null,
+    ];
+}
+function chunkingValues(context) {
+    const chunking = context.config.chunking ?? defaultChunking;
+    return [
+        chunking.mode,
+        chunking.mode === "words"
+            ? (chunking.words ?? 500)
+            : chunking.mode === "characters"
+                ? (chunking.characters ?? 3000)
+                : null,
+    ];
+}

package/dist/slices/rebuild/recipe-build.js

@@ -0,0 +1,17 @@
+import { audioRecipes } from "./recipe-audio.js";
+import { exportRecipes } from "./recipe-exports.js";
+import { textRecipes } from "./recipe-text.js";
+import { thumbnailRecipes, visualAssets, visualRecipes } from "./recipe-visual.js";
+export function buildRecipes(context) {
+    const text = textRecipes(context);
+    const audio = audioRecipes(context, text);
+    const exports = exportRecipes(context, audio);
+    const captions = exports.find((value) => value.key === "subtitles:files");
+    return [
+        ...text.recipes,
+        ...audio.recipes,
+        ...exports,
+        ...thumbnailRecipes(context, text.recipes),
+        ...visualAssets(context, visualRecipes(context.config, context.content, audio.mediaFingerprint, captions?.fingerprint ?? null)),
+    ];
+}

package/dist/slices/rebuild/recipe-checkpoints.js

@@ -0,0 +1,75 @@
+import { fingerprint } from "../../kernel/runner/work.js";
+import { checkpointClosure, checkpointFingerprint } from "../checkpoints/fingerprint.js";
+import { buildRecipes } from "./recipe-build.js";
+export function reviewCheckpointSet(runs, catalogue, attachments, fontHash) {
+    return runs.flatMap((run, runIndex) => {
+        if (!run.draft.checkpoints?.length)
+            return [];
+        const config = { ...run.draft, rendered: run.rendered };
+        const images = config.sources.images === "provide"
+            ? (config.provided.images ?? []).map((id) => [
+                id,
+                { source: "provide", assetId: id, prompt: null, templateKey: null },
+            ])
+            : config.imagePrompts.flatMap((prompt, index) => Array.from({ length: prompt.number }, (_, number) => [
+                `${index}:${number}`,
+                {
+                    source: "generate",
+                    assetId: null,
+                    prompt: run.rendered[`imagePrompts.${index}`] ?? null,
+                    templateKey: `imagePrompts.${index}`,
+                },
+            ]));
+        const content = {
+            articleMarkdown: config.sources.article === "provide" ? config.provided.article : undefined,
+            provided: { audio: config.provided.audio, thumbnail: config.provided.thumbnail },
+            imageOrder: images.map(([key]) => key),
+            imageDefinitions: Object.fromEntries(images),
+            narrationOverrides: {},
+            regenerationTokens: {},
+            promptTemplates: run.templates,
+        };
+        const recipes = buildRecipes({
+            config,
+            content,
+            catalogue,
+            manifest: { outputs: [], pieces: [] },
+            resolved: {
+                articleMarkdown: content.articleMarkdown ?? null,
+                researchNotes: config.provided.research ?? null,
+            },
+        });
+        // Project and retained asset IDs do not exist until Start; these are setup identities.
+        const revision = {
+            id: "review",
+            projectId: "review",
+            parentId: null,
+            restoredFromId: null,
+            config,
+            content,
+            fingerprints: Object.fromEntries(recipes.map((recipe) => [recipe.key, recipe.fingerprint])),
+            createdAt: "review",
+        };
+        return (config.checkpoints?.map((stage) => {
+            const closure = checkpointClosure(stage, recipes);
+            const video = closure.some((recipe) => recipe.stage === "video");
+            const audio = video || closure.some((recipe) => recipe.stage === "audio");
+            const inputs = new Set([
+                ...(audio && config.provided.audio ? [config.provided.audio] : []),
+                ...(video ? (config.provided.images ?? []) : []),
+            ]);
+            return {
+                runIndex,
+                checkpointId: stage,
+                stage,
+                fingerprint: fingerprint({
+                    recipes: checkpointFingerprint(revision, closure),
+                    attachments: attachments.filter((file) => inputs.has(file.stagedFileId)),
+                    font: video ? fontHash : null,
+                }),
+                workKeys: closure.map((recipe) => recipe.key),
+                dependents: [...new Set(closure.map((recipe) => recipe.stage))].filter((kind) => kind !== stage),
+            };
+        }) ?? []);
+    });
+}

package/dist/slices/rebuild/recipe-exports.js

@@ -0,0 +1,65 @@
+import { audioExportArgs } from "../video/audio-export-args.js";
+import { recipe, resourceIdentity, } from "./recipe-model.js";
+export function exportRecipes(context, audio) {
+    const { config, content } = context;
+    if (audio.mediaFingerprint === null)
+        return [];
+    const recipes = [];
+    if (config.sources.video === "off")
+        recipes.push(recipe(context, "export:wav", "video", {
+            kind: "local",
+            version: 1,
+            operation: "export-wav",
+            values: [
+                audio.mediaFingerprint,
+                audioExportArgs([{ kind: "body", path: "$body", seconds: 0 }], "$output"),
+            ],
+        }, audio.keys));
+    if (config.subtitles === undefined || config.subtitles.mode === "off")
+        return recipes;
+    const timing = recipe(context, "subtitles:timing", "video", {
+        kind: "local",
+        version: 1,
+        operation: "wav2vec2-en-a19f851-v2-omissions",
+        values: [audio.timeline, config.silenceGapSeconds, config.subtitles.language],
+    }, audio.keys);
+    recipes.push(timing);
+    const cues = content.subtitleCues;
+    const cueRecipe = cues === undefined
+        ? recipe(context, "subtitles:cues", "video", {
+            kind: "local",
+            version: 1,
+            operation: "automatic-cues-v1",
+            values: resourceIdentity(context, timing),
+        }, [timing.key])
+        : recipe(context, "subtitles:cues", "video", {
+            kind: "local",
+            version: 1,
+            operation: "manual-cues-v1",
+            values: [cues.audioFingerprint, cues.cues.map((cue) => ({ ...cue }))],
+        }, audio.keys);
+    recipes.push(cueRecipe);
+    recipes.push(recipe(context, "subtitles:files", "video", {
+        kind: "local",
+        version: 1,
+        operation: "subtitle-files-v1",
+        values: [
+            resourceIdentity(context, cueRecipe),
+            config.format,
+            config.subtitles.fontId,
+            config.subtitles.fontSize,
+            config.subtitles.position,
+        ],
+    }, [cueRecipe.key]));
+    return recipes;
+}
+export function manualCuesNeedReview(context, recipes) {
+    const cues = context.content.subtitleCues;
+    if (cues === undefined)
+        return false;
+    const timing = recipes.find((value) => value.key === "subtitles:timing");
+    return (timing !== undefined &&
+        cues.audioFingerprint !== timing.logicalFingerprint &&
+        cues.audioFingerprint !==
+            context.manifest.outputs.find((value) => value.workKey === timing.key && value.state === "ready")?.fingerprint);
+}

package/dist/slices/rebuild/recipe-fixture.js

@@ -0,0 +1,150 @@
+import { planRevision, planRevisionWork } from "./recipes.js";
+export const config = {
+    title: "Saved",
+    format: "16:9",
+    sources: {
+        research: "off",
+        article: "provide",
+        audio: "off",
+        images: "generate",
+        thumbnail: "off",
+        video: "generate",
+    },
+    llm: { provider: "text", model: "text-model" },
+    audio: { provider: "voice", model: "tts", voice: "v1" },
+    images: { provider: "fal", model: "image-model" },
+    imagePrompts: [],
+    values: {},
+    provided: { article: "First paragraph.\n\nSecond paragraph." },
+    silenceGapSeconds: 0,
+    rendered: { article: "Write an article." },
+};
+export const content = {
+    articleMarkdown: config.provided.article,
+    articleEdited: false,
+    provided: {},
+    imageOrder: ["harbor", "hill"],
+    imageDefinitions: {
+        harbor: { source: "generate", assetId: null, prompt: "Harbor" },
+        hill: { source: "generate", assetId: null, prompt: "Hill" },
+    },
+    narrationOverrides: {},
+    regenerationTokens: {},
+    promptTemplates: {},
+};
+export const catalogue = {
+    schemaVersion: 1,
+    updatedAt: "2026-09-10",
+    providers: {},
+    llm: [
+        {
+            provider: "text",
+            id: "text-model",
+            name: "Text",
+            enabled: true,
+            deprecated: false,
+            source: "https://example.test",
+            keywords: [],
+            pricing: {},
+            llm: { webSearch: true, thinking: { high: { budget: 1024 } } },
+        },
+    ],
+    tts: [
+        {
+            provider: "voice",
+            id: "tts",
+            name: "Voice",
+            enabled: true,
+            deprecated: false,
+            source: "https://example.test",
+            keywords: [],
+            pricing: { perMillionCharacters: 25 },
+            tts: { maxCharacters: 1000, streaming: true },
+        },
+    ],
+    image: [],
+};
+export function emptyView(c = config, value = content) {
+    return {
+        revision: {
+            id: "r1",
+            projectId: "p1",
+            parentId: null,
+            restoredFromId: null,
+            config: c,
+            content: value,
+            fingerprints: {},
+            createdAt: "2026-09-10T00:00:00Z",
+        },
+        outputs: [],
+        pieces: [],
+        current: true,
+        articleMarkdown: value.articleMarkdown ?? c.provided.article ?? null,
+    };
+}
+export function readyView(c = config, value = content) {
+    const base = emptyView(c, value);
+    const initial = planRevision(base, { config: c, content: value });
+    if (!initial.ok)
+        throw new Error(JSON.stringify(initial.fields));
+    return {
+        ...base,
+        revision: {
+            ...base.revision,
+            config: initial.config,
+            content: initial.content,
+            fingerprints: initial.fingerprints,
+        },
+        outputs: Object.entries(initial.fingerprints).map(([key, fingerprint]) => ({
+            recordId: `record-${key}`,
+            publicationId: null,
+            selected: true,
+            available: true,
+            slot: key,
+            workKey: key,
+            assetId: `asset-${key}`,
+            fingerprint,
+            state: "ready",
+            output: {
+                id: `output-${key}`,
+                projectId: "p1",
+                stageKind: key.startsWith("image:")
+                    ? "images"
+                    : key.startsWith("article:")
+                        ? "article"
+                        : "video",
+                role: key.startsWith("image:")
+                    ? "image"
+                    : key.startsWith("article:")
+                        ? "article_md"
+                        : "video",
+                path: `assets/${key}.bin`,
+                originalFilename: null,
+                bytes: 10,
+                durationMs: 1000,
+                meta: {},
+                createdAt: "2026-09-10T00:00:00Z",
+            },
+        })),
+    };
+}
+export function workFor(base, c = base.revision.config, value = base.revision.content) {
+    const next = planRevision(base, { config: c, content: value });
+    if (!next.ok)
+        throw new Error(JSON.stringify(next.fields));
+    const revision = {
+        ...base.revision,
+        config: next.config,
+        content: next.content,
+        fingerprints: next.fingerprints,
+    };
+    return planRevisionWork(revision, next.manifest, catalogue, new Set([
+        ...base.outputs.map((row) => row.assetId),
+        ...Object.values(value.provided).filter((id) => id !== undefined),
+    ]), {
+        articleMarkdown: next.content.articleEdited || c.sources.article === "provide"
+            ? (next.content.articleMarkdown ?? c.provided.article ?? null)
+            : base.articleMarkdown,
+        researchNotes: null,
+    });
+}

package/dist/slices/rebuild/recipe-input-schema.js

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { messageRoles, thinkingModes } from "../../kernel/ports/llm.js";
+import { deferredOperations, localOperations } from "./recipe-model.js";
+const value = z.lazy(() => z.union([
+    z.null(),
+    z.boolean(),
+    z.number().finite(),
+    z.string(),
+    z.array(value),
+    z.record(z.string(), value),
+]));
+const version = z.literal(1);
+export const recipeInputSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("llm"),
+        version,
+        provider: z.string(),
+        model: z.string(),
+        thinking: z.enum(thinkingModes).nullable(),
+        thinkingConfig: z
+            .object({
+            budget: z.number().finite().optional(),
+            level: z.enum(["minimal", "low", "medium", "high"]).optional(),
+            effort: z.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional(),
+        })
+            .strict()
+            .nullable(),
+        messages: z.array(z.object({ role: z.enum(messageRoles), content: z.string() }).strict()),
+        webSearch: z.boolean(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("tts"),
+        version,
+        provider: z.string(),
+        model: z.string(),
+        voice: z.string(),
+        text: z.string(),
+        logicalKey: z.string(),
+        logicalText: z.string(),
+        segment: z.enum(["body", "intro", "outro"]),
+        pronunciation: z.null(),
+        wholeRequest: z.boolean().optional(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("image"),
+        version,
+        provider: z.string(),
+        model: z.string(),
+        prompt: z.string(),
+        aspect: z.enum(["16:9", "9:16"]),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("provided"),
+        version,
+        assetId: z.string().nullable(),
+        semantic: value,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("local"),
+        version,
+        operation: z.enum(localOperations),
+        values: value,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("deferred"),
+        version,
+        operation: z.enum(deferredOperations),
+        template: value,
+    })
+        .strict(),
+]);