@gentbajko/slopify 0.6.1 → 0.7.0

package/dist/model-catalog.js

@@ -0,0 +1,37 @@
+import { falModels } from "./adapters/image/fal.js";
+import { googleImageModels } from "./adapters/image/google.js";
+import { openAiImageModels } from "./adapters/image/openai.js";
+import { replicateModels } from "./adapters/image/replicate.js";
+import { claudeCodeModels } from "./adapters/llm/claude-code.js";
+import { codexModels } from "./adapters/llm/codex.js";
+import { geminiModels } from "./adapters/llm/gemini.js";
+import { cartesiaModels } from "./adapters/tts/cartesia.js";
+import { elevenLabsModels } from "./adapters/tts/elevenlabs.js";
+import { inworldModels } from "./adapters/tts/inworld.js";
+import { openAiTtsModels } from "./adapters/tts/openai.js";
+// Composition keeps provider-specific fallback data out of the HTTP and settings layers.
+export function modelSources(registry) {
+    const fallbacks = {
+        "claude-code": claudeCodeModels,
+        codex: codexModels,
+        gemini: geminiModels,
+        elevenlabs: elevenLabsModels,
+        "openai-tts": openAiTtsModels,
+        cartesia: cartesiaModels,
+        inworld: inworldModels,
+        fal: falModels,
+        replicate: replicateModels,
+        "openai-image": openAiImageModels,
+        "google-image": googleImageModels,
+    };
+    return {
+        modelsFor: (provider, family) => {
+            if (family === "llm")
+                return registry.llm(provider).models();
+            if (family === "image")
+                return registry.image(provider).models();
+            return registry.tts(provider).models();
+        },
+        fallbackModelsFor: (provider) => Object.hasOwn(fallbacks, provider) ? (fallbacks[provider] ?? []) : [],
+    };
+}

package/dist/slices/control/index.js

@@ -15,6 +15,7 @@ async function providerFields(deps, changes) {
                 providers: await deps.providers(),
                 voices: listVoices(deps.db),
                 modelsFor: deps.modelsFor,
+                allowsCustomModels: deps.allowsCustomModels,
             }))(),
             new Promise((_resolve, reject) => {
                 timeout = setTimeout(() => reject(new Error("Provider catalog timed out")), providerCheckTimeoutMs);

package/dist/slices/control/providers.js

@@ -50,6 +50,8 @@ export async function validateProviderChanges(changes, current) {
         const picked = changes[key];
         if (picked === undefined || fields.some((field) => field.field === key))
             continue;
+        if (current.allowsCustomModels?.(picked.provider) === true)
+            continue;
         const models = await current.modelsFor(picked.provider, families[key]);
         if (!models.some((model) => model.id === picked.model)) {
             fields.push({ field: `${key}.model`, message: "Choose a model supported by this provider." });

package/dist/slices/narration/live.js

@@ -0,0 +1,21 @@
+export function observeNarration(store, projectId, key, label) {
+    if (store === undefined)
+        return undefined;
+    let sink;
+    return (event) => {
+        switch (event.type) {
+            case "start":
+                sink = store.begin(projectId, key, label);
+                break;
+            case "chunk":
+                sink?.append(event.bytes);
+                break;
+            case "complete":
+                sink?.complete();
+                break;
+            case "interrupted":
+                sink?.interrupt();
+                break;
+        }
+    };
+}

package/dist/slices/narration/run.js

@@ -11,6 +11,7 @@ import { insertOutput, outputsOf } from "../storage/repo.js";
 import { probeDurationMs } from "../video/ffmpeg.js";
 import { chunkNarration, defaultChunking } from "./chunk.js";
 import { joinNarration } from "./concat.js";
+import { observeNarration } from "./live.js";
 // An empty narration source fails the stage immediately with no retries. Thrown from the
 // slice rather than from a provider call, so the attempt wrapper never sees it.
 export const nothingToNarrate = "nothing to narrate";
@@ -31,6 +32,7 @@ const segmentPayload = z.object({
 const chunkDir = "audio-chunks";
 export async function runNarration(deps, context, providers) {
     const { projectId } = context.stage;
+    deps.audioPreviews?.clear(projectId);
     const project = projectById(deps.db, projectId);
     if (project === undefined) {
         throw new Error(`project ${projectId} has no row`);
@@ -110,9 +112,10 @@ async function speakChunks(deps, context, providers, choice, pieces) {
         try {
             const spoken = await providers.forPiece(piece.id).tts({
                 provider: choice.provider,
+                model: choice.model,
                 voiceId: choice.voice,
                 text: carried.text,
-            });
+            }, observeNarration(deps.audioPreviews, projectId, piece.id, total === 1 ? "Body" : `Body part ${piece.idx} of ${total}`));
             write(deps, projectId, file, spoken.bytes);
             // The file is on disk before the row says so: a crash between the two leaves a
             // file the reconcile collects, where the other order would leave a `done` chunk
@@ -180,9 +183,10 @@ async function speakSegments(deps, context, providers, choice, outputs) {
         }
         const spoken = await providers.forPiece(piece.id).tts({
             provider: choice.provider,
+            model: choice.model,
             voiceId: choice.voice,
             text,
-        });
+        }, observeNarration(deps.audioPreviews, projectId, piece.id, segment.category === "intro" ? "Intro" : "Outro"));
         const name = outputFileName(role, 1, ".mp3", "audio");
         write(deps, projectId, name, spoken.bytes);
         // Measured the same way the body is, because the render adds all three and the gaps to
@@ -208,14 +212,13 @@ function segmentPieces(deps, projectId) {
     }
     return piecesOf(deps.db, article.id, "segment");
 }
-// Audio seconds come from the measured duration per segment, never from the text's length:
-// the real duration goes on the row and the video timeline is built from it. No model is
-// named because the TTS port carries none - the same reason `store` above leaves it off.
+// Audio seconds come from the measured duration per segment, never from the text's length.
 function counted(deps, segment, durationMs, choice) {
     deps.count("stage.completed", {
         stage: "audio",
         segment,
         provider: choice.provider,
+        model: choice.model,
         audioSeconds: durationMs / 1000,
     });
 }
@@ -246,9 +249,6 @@ function write(deps, projectId, path, bytes) {
     mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
     writeFileSync(target, bytes, { mode: 0o600 });
 }
-// The provider and the voice are stored with the audio they made. The model is not:
-// the TTS port carries no model, so every request went to the adapter's own, and writing
-// the run's dropdown value here would record something that was never sent.
 function store(deps, projectId, role, path, durationMs, choice) {
     insertOutput(deps.db, {
         id: deps.ids.next(),
@@ -259,7 +259,7 @@ function store(deps, projectId, role, path, durationMs, choice) {
         originalFilename: null,
         bytes: statSync(outputPath(deps.paths, projectId, path)).size,
         durationMs,
-        meta: { provider: choice.provider, voice: choice.voice },
+        meta: { provider: choice.provider, model: choice.model, voice: choice.voice },
         createdAt: deps.clock.now().toISOString(),
     });
 }

package/dist/slices/research/run.js

@@ -53,6 +53,7 @@ async function research(deps, context, providers, choice, brief) {
         provider: choice.provider,
         model: choice.model,
         messages: synthesisMessages(brief, findings),
+        previewLabel: "Writing research notes",
         check: (given) => sourcedAnswer("the synthesis", given.text),
     });
     add(answer.usage);
@@ -89,6 +90,7 @@ async function plan(deps, context, providers, choice, brief, add) {
         provider: choice.provider,
         model: choice.model,
         messages: plannerMessages(brief),
+        previewLabel: "Planning research",
         // An empty answer, or one with no chapter in it, is a failed attempt.
         check: (given) => chaptersFrom(given.text).length === 0 ? "the planner named no chapters" : undefined,
     });
@@ -129,6 +131,7 @@ async function researchChapters(deps, context, providers, choice, brief, chapter
                 provider: choice.provider,
                 model: choice.model,
                 messages: subAgentMessages(brief, kept.title, outline),
+                previewLabel: kept.title,
                 // Grounding is asked for explicitly, so a model without it says so
                 // instead of answering from what it already knows.
                 webSearch: true,

package/dist/slices/settings/model.js

@@ -12,6 +12,7 @@ export const providerIds = [
     "elevenlabs",
     "openai-tts",
     "cartesia",
+    "inworld",
     "fal",
     "replicate",
     "openai-image",
@@ -46,6 +47,7 @@ export const providers = [
     { id: "elevenlabs", family: "tts", displayName: "ElevenLabs", auth: "key" },
     { id: "openai-tts", family: "tts", displayName: "OpenAI", auth: "key" },
     { id: "cartesia", family: "tts", displayName: "Cartesia", auth: "key" },
+    { id: "inworld", family: "tts", displayName: "Inworld", auth: "key" },
     { id: "fal", family: "image", displayName: "fal.ai", auth: "key" },
     { id: "replicate", family: "image", displayName: "Replicate", auth: "key" },
     { id: "openai-image", family: "image", displayName: "OpenAI", auth: "key" },

package/dist/slices/settings/models.js

@@ -0,0 +1,89 @@
+// These marketplaces host models with different input schemas. Discovery alone cannot
+// make an arbitrary endpoint compatible with our image request.
+export function allowsCustomModel(provider) {
+    return provider !== "fal" && provider !== "replicate";
+}
+const ttlMs = 5 * 60_000;
+const retryMs = 30_000;
+export function createModelCatalog(deps) {
+    const cache = new Map();
+    const pending = new Map();
+    const generations = new Map();
+    async function get(provider, family, refresh = false) {
+        const active = pending.get(provider);
+        if (active !== undefined)
+            return active;
+        const previous = cache.get(provider);
+        if (!refresh && previous !== undefined && previous.expires > deps.now())
+            return previous.value;
+        const generation = generations.get(provider) ?? 0;
+        const task = Promise.resolve()
+            .then(async () => {
+            let value;
+            let lifetime = ttlMs;
+            try {
+                const models = await deps.load(provider, family);
+                value = {
+                    models: uniqueModels(models),
+                    allowsCustom: allowsCustomModel(provider),
+                    ...catalogNotice(provider),
+                };
+            }
+            catch {
+                // A catalogue is metadata, not generation. Never expose an upstream response
+                // here: it can quote credentials that belong only inside its adapter.
+                deps.report(provider);
+                const saved = previous?.value.models;
+                value = {
+                    models: saved ?? deps.fallback(provider),
+                    ...catalogNotice(provider),
+                    allowsCustom: allowsCustomModel(provider),
+                    warning: saved === undefined
+                        ? "Could not load the model list. Showing bundled choices; refresh to try again."
+                        : "Could not refresh the model list. Showing the last loaded choices.",
+                };
+                lifetime = retryMs;
+            }
+            if ((generations.get(provider) ?? 0) === generation) {
+                cache.set(provider, { value, expires: deps.now() + lifetime });
+            }
+            return value;
+        })
+            .finally(() => {
+            if (pending.get(provider) === task)
+                pending.delete(provider);
+        });
+        pending.set(provider, task);
+        return task;
+    }
+    return {
+        get,
+        invalidate: (provider) => {
+            generations.set(provider, (generations.get(provider) ?? 0) + 1);
+            cache.delete(provider);
+            pending.delete(provider);
+        },
+    };
+}
+function uniqueModels(models) {
+    const seen = new Set();
+    return models.filter((model) => {
+        if (model.id.trim() === "" || seen.has(model.id))
+            return false;
+        seen.add(model.id);
+        return true;
+    });
+}
+function catalogNotice(provider) {
+    const notices = {
+        codex: "Models come from Codex's local catalogue. Open Codex to refresh that catalogue, then refresh this list.",
+        gemini: "Models and aliases come from the installed Gemini CLI. Update that CLI to discover newer models.",
+        "claude-code": "These aliases follow Claude Code's model families. You can also enter an exact model ID.",
+        inworld: "These are Inworld’s documented TTS models. You can also enter a compatible model ID.",
+        cartesia: "Cartesia has no model-list API. These are bundled compatible choices; you can enter a newer model ID.",
+        fal: "These models have input formats supported by Slopify's fal adapter.",
+        replicate: "These models have input formats supported by Slopify's Replicate adapter.",
+    };
+    const notice = Object.hasOwn(notices, provider) ? notices[provider] : undefined;
+    return notice === undefined ? {} : { notice };
+}

package/dist/slices/subtitles/captions.js

@@ -1,3 +1,4 @@
+import { subtitlePlacement } from "./layout.js";
 // Keep spoken spelling and punctuation. Word times come only from acoustic alignment.
 export function captionCues(words) {
     const cues = [];
@@ -61,10 +62,12 @@ export function serializeVtt(cues) {
 }
 export function serializeAss(cues, style) {
     const name = style.fontName.replace(/[\p{Cc},]/gu, " ").trim();
+    const placement = subtitlePlacement(style.position ?? "bottom", style.height);
+    const position = `{\\an${placement.alignment}\\pos(${style.width / 2},${placement.y})}`;
     const header = `[Script Info]\nScriptType: v4.00+\nPlayResX: ${style.width}\nPlayResY: ${style.height}\nWrapStyle: 0\nScaledBorderAndShadow: yes\n\n[V4+ Styles]\nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\nStyle: Default,${name},${style.fontSize},&H00FFFFFF,&H00FFFFFF,&H00101010,&H80000000,0,0,0,0,100,100,0,0,1,2.5,1,2,60,60,60,1\n\n[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n`;
     return (header +
         cues
-            .map((cue) => `Dialogue: 0,${assStamp(cue.start)},${assStamp(cue.end)},Default,,0,0,0,,${assText(cue.text)}\n`)
+            .map((cue) => `Dialogue: 0,${assStamp(cue.start)},${assStamp(cue.end)},Default,,0,0,0,,${position}${assText(cue.text)}\n`)
             .join(""));
 }
 function markup(text) {

package/dist/slices/subtitles/layout.js

@@ -0,0 +1,19 @@
+export function subtitleFrame(format) {
+    return format === "9:16" ? { width: 1080, height: 1920 } : { width: 1920, height: 1080 };
+}
+// ASS and the browser preview share anchors. Edge positions keep the existing
+// 60-pixel safe margin; interior positions center both single and multiline cues.
+export function subtitlePlacement(position, height) {
+    switch (position) {
+        case "top":
+            return { y: 60, alignment: 8, translateY: 0 };
+        case "upper-middle":
+            return { y: height / 4, alignment: 5, translateY: -50 };
+        case "center":
+            return { y: height / 2, alignment: 5, translateY: -50 };
+        case "lower-middle":
+            return { y: (height * 3) / 4, alignment: 5, translateY: -50 };
+        case "bottom":
+            return { y: height - 60, alignment: 2, translateY: -100 };
+    }
+}

package/dist/slices/subtitles/model.js

@@ -1,5 +1,12 @@
 import { z } from "zod";
 export const subtitleModes = ["off", "files", "burn-in"];
+export const subtitlePositions = [
+    "top",
+    "upper-middle",
+    "center",
+    "lower-middle",
+    "bottom",
+];
 export const subtitleConfigSchema = z.object({
     mode: z.enum(subtitleModes),
     language: z.literal("en").default("en"),
@@ -8,6 +15,7 @@ export const subtitleConfigSchema = z.object({
         .max(160)
         .regex(/^[A-Za-z0-9_-]+$/)
         .default("default"),
+    position: z.enum(subtitlePositions).default("bottom"),
     fontSize: z.number().int().min(16).max(120).default(48),
 });
 export const defaultSubtitles = {
@@ -15,4 +23,5 @@ export const defaultSubtitles = {
     language: "en",
     fontId: "default",
     fontSize: 48,
+    position: "bottom",
 };

package/dist/slices/subtitles/prepare.js

@@ -59,7 +59,12 @@ export async function prepareSubtitles(deps, context, audio, frame) {
             throw new Error("No spoken words could be aligned. Check that the English article matches the audio.");
         writeFileSync(join(directory, "subtitles.srt"), serializeSrt(cues), { mode: 0o600 });
         writeFileSync(join(directory, "subtitles.vtt"), serializeVtt(cues), { mode: 0o600 });
-        writeFileSync(join(directory, "subtitles.ass"), serializeAss(cues, { ...frame, fontSize: config.fontSize, fontName: font.assName }), { mode: 0o600 });
+        writeFileSync(join(directory, "subtitles.ass"), serializeAss(cues, {
+            ...frame,
+            fontSize: config.fontSize,
+            fontName: font.assName,
+            position: config.position,
+        }), { mode: 0o600 });
         writeFileSync(join(directory, "subtitles.json"), JSON.stringify({ key, words, font }), {
             mode: 0o600,
         });

package/dist/updater/candidate.js

@@ -0,0 +1,28 @@
+export function watchActivation(updater, token, expired, report) {
+    let checking = false;
+    const until = Date.now() + 120_000;
+    const timer = setInterval(() => {
+        if (checking)
+            return;
+        checking = true;
+        void updater
+            .activate(token)
+            .then(async (activated) => {
+            if (activated)
+                clearInterval(timer);
+            else if (Date.now() >= until) {
+                clearInterval(timer);
+                report("The update was not committed; stopping the candidate server.");
+                await expired();
+            }
+        })
+            .catch(() => {
+            report("The update activation marker could not be checked.");
+        })
+            .finally(() => {
+            checking = false;
+        });
+    }, 250);
+    timer.unref();
+    return () => clearInterval(timer);
+}

package/dist/updater/forward.js

@@ -0,0 +1,35 @@
+import { spawn } from "node:child_process";
+import { activeUpdateEntry } from "./plan.js";
+export async function forwardManagedUpdate(dataDir, version, args) {
+    if (process.env.SLOPIFY_SKIP_MANAGED_UPDATE === "1")
+        return undefined;
+    const entry = await activeUpdateEntry(dataDir, version);
+    if (entry === undefined)
+        return undefined;
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, [entry, ...args], {
+            stdio: "inherit",
+            windowsHide: true,
+        });
+        const interrupt = () => {
+            child.kill("SIGINT");
+        };
+        const terminate = () => {
+            child.kill("SIGTERM");
+        };
+        process.once("SIGINT", interrupt);
+        process.once("SIGTERM", terminate);
+        const cleanup = () => {
+            process.off("SIGINT", interrupt);
+            process.off("SIGTERM", terminate);
+        };
+        child.once("error", () => {
+            cleanup();
+            resolve(undefined);
+        });
+        child.once("close", (code) => {
+            cleanup();
+            resolve(code ?? 1);
+        });
+    });
+}

package/dist/updater/install-flow.js

@@ -0,0 +1,26 @@
+export async function runUpdateFlow(plan, deps) {
+    const entry = await deps.install();
+    // npm or package verification failures leave the currently serving app entirely alone.
+    await deps.handoff();
+    let backedUp = false;
+    try {
+        await deps.backup();
+        backedUp = true;
+        await deps.start(entry);
+        await deps.healthy(plan.version);
+        await deps.activate();
+    }
+    catch {
+        await deps.stopCandidate();
+        if (backedUp)
+            await deps.restore();
+        await deps.start(plan.oldEntry);
+        await deps.healthy(plan.previousVersion);
+        deps.report("The update did not start; the previous version and database were restored.");
+        throw new Error("The previous Slopify version was restored.");
+    }
+    // The pointer rename commits the new database. The candidate may already observe
+    // it and accept writes, so a lost unlock acknowledgement can never trigger rollback.
+    await deps.release();
+    deps.report(`Slopify ${plan.version} started successfully.`);
+}

package/dist/updater/install.js

@@ -0,0 +1,50 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { updatePlanSchema } from "./plan.js";
+export async function launchUpdate(worker, plan, handoff) {
+    updatePlanSchema.parse(plan);
+    const directory = join(plan.dataDir, "updates");
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const planPath = join(directory, `plan-${randomUUID()}.json`);
+    await writeFile(planPath, JSON.stringify(plan), { mode: 0o600 });
+    const child = spawn(process.execPath, [worker, planPath], {
+        cwd: plan.cwd,
+        detached: true,
+        windowsHide: true,
+        stdio: ["ignore", "ignore", "ignore", "ipc"],
+    });
+    try {
+        await new Promise((resolve, reject) => {
+            let restarting = false;
+            const send = (type) => {
+                if (!child.connected) {
+                    reject(new Error("The update worker disconnected."));
+                    return;
+                }
+                child.send({ type }, (error) => {
+                    if (error !== null)
+                        reject(new Error("The update handoff failed."));
+                });
+            };
+            child.once("error", () => reject(new Error("The update worker could not start.")));
+            child.once("exit", (code) => code === 0 ? resolve() : reject(new Error("The update worker could not finish.")));
+            child.on("message", (message) => {
+                if (typeof message !== "object" || message === null || !("type" in message))
+                    return;
+                if (message.type === "installed" && !restarting) {
+                    restarting = true;
+                    void handoff().then(() => send("handoff"), () => {
+                        send("abort");
+                        reject(new Error("Slopify could not release its server for the update."));
+                    });
+                }
+            });
+        });
+    }
+    finally {
+        child.unref();
+        await rm(planPath, { force: true });
+    }
+}

package/dist/updater/model.js

@@ -0,0 +1,24 @@
+export const updatePackage = "@gentbajko/slopify";
+export const npmRegistry = "https://registry.npmjs.org/";
+const stableVersion = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+export function isStableVersion(value) {
+    return value.length <= 50 && stableVersion.test(value);
+}
+export function newerVersion(candidate, current) {
+    if (!isStableVersion(candidate) || !isStableVersion(current))
+        return false;
+    const left = candidate.split(".").map(BigInt);
+    const right = current.split(".").map(BigInt);
+    for (let index = 0; index < 3; index++) {
+        const a = left[index];
+        const b = right[index];
+        if (a === undefined || b === undefined)
+            return false;
+        if (a !== b)
+            return a > b;
+    }
+    return false;
+}
+export function isUpdateToken(value) {
+    return /^[a-f0-9]{64}$/.test(value);
+}