@gentbajko/slopify 0.8.3 → 1.0.0

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(),
+]);

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

@@ -0,0 +1,135 @@
+import { z } from "zod";
+import { buildRecipes } from "./recipe-build.js";
+export function baselineFingerprints(project, outputs, pieces, content, stages = []) {
+    const recipes = buildRecipes({
+        config: project.config,
+        content,
+        manifest: { outputs: [], pieces: [] },
+        resolved: {
+            articleMarkdown: content.articleMarkdown ?? project.config.provided.article ?? null,
+            researchNotes: project.config.provided.research ?? null,
+        },
+    });
+    const fingerprints = Object.fromEntries(recipes.map((value) => [value.key, value.fingerprint]));
+    for (const output of outputs) {
+        const key = legacyOutputWorkKey(output, project.config);
+        if (fingerprints[key] === undefined)
+            fingerprints[key] = `legacy:${output.id}`;
+    }
+    for (const piece of pieces) {
+        const key = legacyPieceKey(piece, legacyStageKind(piece, stages), outputs);
+        if (fingerprints[key] === undefined)
+            fingerprints[key] = `legacy:${piece.id}`;
+    }
+    return fingerprints;
+}
+export function legacyOutputSlot(output) {
+    return output.role === "image" ? `image:${output.id}` : `${output.stageKind}:${output.role}`;
+}
+export function legacyOutputWorkKey(output, config) {
+    switch (output.role) {
+        case "image":
+            return `image:${output.id}`;
+        case "thumbnail":
+            return "thumbnail:image";
+        case "notes":
+            return "research:notes";
+        case "article_md":
+        case "article_txt":
+        case "sources":
+        case "glossary":
+            return "article:body";
+        case "audio_body":
+            return config?.sources.audio === "provide" ? "audio:provided" : "audio:body:concat";
+        case "audio_intro":
+            return "audio:intro";
+        case "audio_outro":
+            return "audio:outro";
+        case "audio_export":
+            return "export:wav";
+        case "video":
+            return "export:video";
+        case "subtitles_srt":
+        case "subtitles_vtt":
+        case "subtitle_ass":
+        case "subtitle_font":
+            return "subtitles:files";
+        case "subtitle_words":
+            return "subtitles:timing";
+        case "render_params":
+        case "instructions":
+            return `${output.stageKind}:${output.role}`;
+    }
+}
+export function legacyPieceKey(piece, stageKind, outputs = []) {
+    if (piece.kind === "chunk")
+        return `audio:body:${piece.id}:1`;
+    if (piece.kind === "image")
+        return `image:${legacyImageOutput(piece, outputs)?.id ?? piece.id}`;
+    if (piece.kind === "prompt_written" && stageKind === "thumbnail")
+        return "thumbnail:prompt";
+    if (piece.kind === "segment") {
+        const category = piece.idx === 1 ? "intro" : "outro";
+        if (stageKind === "article")
+            return `entry:${category}:text`;
+        if (stageKind === "audio")
+            return `audio:${category}`;
+    }
+    return `${stageKind}:${piece.kind}:${piece.id}`;
+}
+function legacyStageKind(piece, stages) {
+    const stage = stages.find((row) => row.id === piece.stageId);
+    if (stage !== undefined)
+        return stage.kind;
+    switch (piece.kind) {
+        case "chunk":
+            return "audio";
+        case "chapter":
+            return "research";
+        case "image":
+            return "images";
+        case "prompt_written":
+            return "thumbnail";
+        case "article_written":
+        case "segment":
+            return "article";
+    }
+}
+export function legacyImageOutput(piece, outputs) {
+    if (piece.kind !== "image")
+        return undefined;
+    const parsed = legacyImageMetadata.safeParse(piece.payload);
+    if (!parsed.success)
+        return undefined;
+    const { file, prompt, promptName } = parsed.data;
+    const matches = outputs.filter((row) => row.role === "image" &&
+        (file !== undefined
+            ? row.path === file
+            : typeof prompt === "string" &&
+                row.meta.index === piece.idx &&
+                row.meta.prompt === prompt &&
+                (typeof promptName !== "string" ||
+                    row.meta.promptName === undefined ||
+                    row.meta.promptName === promptName)));
+    if (matches.length > 1)
+        throw new Error(`Legacy image piece ${piece.id} matches multiple outputs.`);
+    return matches[0];
+}
+const legacyImageMetadata = z
+    .string()
+    .transform((value, context) => {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+        context.addIssue({ code: "custom", message: "Invalid legacy piece JSON." });
+        return z.NEVER;
+    }
+})
+    .pipe(z.object({
+    file: z.string().optional(),
+    prompt: z.unknown().optional(),
+    promptName: z.unknown().optional(),
+}));

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

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { fingerprint } from "../../kernel/runner/work.js";
+import { narrationRegenerationToken, narrationRequestFingerprint } from "../narration/plan.js";
+export const localOperations = [
+    "export-wav",
+    "wav2vec2-en-a19f851-v2-omissions",
+    "automatic-cues-v1",
+    "manual-cues-v1",
+    "subtitle-files-v1",
+    "render-video",
+    "render-selected-video",
+    "provided-notes",
+    "provided-article",
+    "manual-article",
+    "entry-text",
+    "concat-narration",
+];
+export const deferredOperations = [
+    "research-synthesis",
+    "article",
+    "entry:intro:text",
+    "entry:outro:text",
+    "thumbnail-prompt",
+    "thumbnail-image",
+    "body-narration",
+    "intro-narration",
+    "outro-narration",
+    "resolve-revision-recipe",
+];
+export function recipe(context, key, stage, input, dependsOn = [], options = {}) {
+    const requestFingerprint = input.kind === "tts"
+        ? narrationRequestFingerprint({
+            ...input,
+            wholeText: input.wholeRequest === true ? input.logicalText : null,
+        })
+        : fingerprint(JSON.parse(JSON.stringify(input, (_key, value) => typeof value === "number" ? z.number().finite().parse(value) : value)));
+    const workFingerprint = fingerprint([
+        requestFingerprint,
+        input.kind === "tts"
+            ? narrationRegenerationToken(context.content.regenerationTokens, input.logicalKey, input.segment)
+            : (context.content.regenerationTokens[options.tokenKey ?? key] ?? null),
+    ]);
+    return {
+        key,
+        stage,
+        kind: options.kind ??
+            (input.kind === "llm" ||
+                input.kind === "tts" ||
+                input.kind === "image" ||
+                input.kind === "deferred"
+                ? "provider"
+                : input.kind),
+        input,
+        requestFingerprint,
+        fingerprint: workFingerprint,
+        logicalFingerprint: options.logicalFingerprint ?? workFingerprint,
+        dependsOn,
+        unresolved: options.unresolved ?? false,
+        deferred: input.kind === "deferred",
+    };
+}
+export function selectedAsset(context, key, desired) {
+    const output = context.manifest.outputs.find((row) => row.workKey === key && row.state === "ready" && selectedReference(row));
+    if (output !== undefined)
+        return output.assetId;
+    const piece = context.manifest.pieces.find((row) => row.key === key &&
+        row.piece.state === "done" &&
+        selectedReference(row) &&
+        (desired === undefined || row.fingerprint === desired));
+    return piece?.assetId ?? null;
+}
+export function resourceIdentity(context, value) {
+    return [value.fingerprint, selectedAsset(context, value.key, value.fingerprint)];
+}
+export function selectedReference(value) {
+    return !("selected" in value) || value.selected === true;
+}

package/dist/slices/rebuild/recipe-provider-choice.js

@@ -0,0 +1,14 @@
+export function recipeProviderChoice(recipe, config) {
+    const input = recipe.input;
+    if (input.kind === "llm" || input.kind === "tts" || input.kind === "image")
+        return { ...input, family: input.kind };
+    if (input.kind !== "deferred")
+        return undefined;
+    const family = recipe.stage === "audio"
+        ? "tts"
+        : recipe.stage === "images" || input.operation === "thumbnail-image"
+            ? "image"
+            : "llm";
+    const choice = family === "tts" ? config.audio : family === "image" ? config.images : config.llm;
+    return choice === undefined ? undefined : { ...choice, family };
+}