@gentbajko/slopify 0.5.0 → 0.6.1

package/dist/slices/settings/cli-paths.js

@@ -0,0 +1,98 @@
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import { extname, isAbsolute } from "node:path";
+import { z } from "zod";
+import { cliProbeTimeoutMs, readinessFromProbe } from "./cli-status.js";
+import { providerById } from "./model.js";
+import { readSetting, writeSetting } from "./repo.js";
+export const cliPathMaxLength = 4096;
+const pathSchema = z
+    .string()
+    .trim()
+    .max(cliPathMaxLength)
+    .refine((value) => value === "" || (isAbsolute(value) && !/[\p{Cc}]/u.test(value)));
+const storedPathSchema = z.string().max(cliPathMaxLength).nullable();
+const saves = new WeakMap();
+export function cliPathStatus(db, id) {
+    const provider = providerById(id);
+    if (provider.auth !== "cli")
+        throw new Error(`${id} is not a CLI provider`);
+    const stored = readSetting(db, `cli.path.${id}`);
+    const configured = stored === undefined ? null : storedPathSchema.parse(JSON.parse(stored));
+    return { configured, command: configured ?? provider.binary };
+}
+// Read on each attempt, so a saved path reaches the next invocation without a restart.
+export function cliBinary(db, id) {
+    return cliPathStatus(db, id).command;
+}
+export async function saveCliPath(deps, id, raw) {
+    // A slow version probe must not overwrite a later Save or Reset from another tab.
+    let queue = saves.get(deps.db);
+    if (queue === undefined) {
+        queue = new Map();
+        saves.set(deps.db, queue);
+    }
+    const previous = queue.get(id) ?? Promise.resolve();
+    const next = previous.then(() => save(deps, id, raw));
+    const settled = next.then(() => { }, () => { });
+    queue.set(id, settled);
+    try {
+        return await next;
+    }
+    finally {
+        if (queue.get(id) === settled)
+            queue.delete(id);
+    }
+}
+async function save(deps, id, raw) {
+    const provider = providerById(id);
+    if (provider.auth !== "cli")
+        return { ok: false, message: `${provider.displayName} uses an API key, not a CLI executable.` };
+    const parsed = pathSchema.safeParse(raw);
+    if (!parsed.success)
+        return {
+            ok: false,
+            message: "Enter an absolute executable file path without quotes or arguments, or leave it blank to use PATH.",
+        };
+    const configured = parsed.data === "" ? null : parsed.data;
+    if (configured !== null) {
+        try {
+            if (!(await stat(configured)).isFile())
+                return { ok: false, message: "Choose an executable file, not a directory." };
+            await access(configured, process.platform === "win32" ||
+                [".js", ".mjs", ".cjs"].includes(extname(configured).toLowerCase())
+                ? constants.R_OK
+                : constants.X_OK);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                "code" in error &&
+                ["ENOENT", "ENOTDIR", "EACCES", "EPERM", "ELOOP"].includes(String(error.code)))
+                return {
+                    ok: false,
+                    message: "That executable file cannot be found or run. Check its path and permissions.",
+                };
+            throw error;
+        }
+    }
+    const command = configured ?? provider.binary;
+    const probed = await deps.probe(command, provider.versionArgs, cliProbeTimeoutMs);
+    const readiness = readinessFromProbe(probed);
+    if (configured !== null && readiness.kind === "cli" && !readiness.installed)
+        return {
+            ok: false,
+            message: probed.error ??
+                `${provider.displayName} did not answer --version successfully within ${cliProbeTimeoutMs / 1000} seconds. Choose its executable file without arguments.`,
+        };
+    writeSetting(deps.db, `cli.path.${id}`, JSON.stringify(configured));
+    return {
+        ok: true,
+        status: {
+            id,
+            family: provider.family,
+            displayName: provider.displayName,
+            readiness,
+            cliPath: { configured, command },
+        },
+    };
+}

package/dist/slices/settings/cli-status.js

@@ -1,24 +1,33 @@
 import { execFile } from "node:child_process";
-// ceiling: readiness is computed at request time, so nothing is cached and a hung CLI costs the
-// settings page this long. Both probes run in parallel, so the page waits 2 s in the worst
-// case. Caching the answer for a few seconds is the upgrade if a slow machine makes the status
-// line flap.
-export const cliProbeTimeoutMs = 2000;
+import { cliCommand } from "../../kernel/cli-command.js";
+// Gemini's Node startup can take several seconds on Windows. Providers are probed in
+// parallel; a hung process is bounded without treating ordinary startup as missing.
+export const cliProbeTimeoutMs = 15_000;
 const probeOutputMax = 64 * 1024;
-// The real probe: an argument array, never a shell string, so nothing in a binary name or an
-// argument can be interpreted as a command. It resolves for every outcome; a missing CLI is an
-// answer, not a failure. ceiling: POSIX only. A Windows install puts `claude` on PATH as a
-// `.cmd` shim, which execFile cannot run without a shell; a shim-aware lookup is the upgrade
-// when Windows is supported.
+// Known Windows package-manager shims are resolved to an executable plus fixed args;
+// user input never becomes a shell command. Missing/unsupported commands mean not ready.
 export function nodeCliProbe(binary, args, timeoutMs) {
+    let command;
+    try {
+        command = cliCommand(binary);
+    }
+    catch (error) {
+        return Promise.resolve({
+            ran: false,
+            stdout: "",
+            error: error instanceof Error ? error.message : "The CLI launcher could not be resolved.",
+        });
+    }
     return new Promise((resolve) => {
-        execFile(binary, [...args], { timeout: timeoutMs, maxBuffer: probeOutputMax, windowsHide: true }, (error, stdout) => {
+        execFile(command.file, [...command.args, ...args], { timeout: timeoutMs, maxBuffer: probeOutputMax, windowsHide: true }, (error, stdout) => {
             resolve(error === null ? { ran: true, stdout } : { ran: false, stdout: "" });
         });
     });
 }
 export async function cliReadiness(probe, provider) {
-    const result = await probe(provider.binary, provider.versionArgs, cliProbeTimeoutMs);
+    return readinessFromProbe(await probe(provider.binary, provider.versionArgs, cliProbeTimeoutMs));
+}
+export function readinessFromProbe(result) {
     if (!result.ran) {
         return { kind: "cli", installed: false };
     }

package/dist/slices/settings/model.js

@@ -8,6 +8,7 @@ export const providerIds = [
     "openrouter",
     "claude-code",
     "codex",
+    "gemini",
     "elevenlabs",
     "openai-tts",
     "cartesia",
@@ -34,6 +35,14 @@ export const providers = [
         binary: "codex",
         versionArgs: ["--version"],
     },
+    {
+        id: "gemini",
+        family: "llm",
+        displayName: "Gemini CLI",
+        auth: "cli",
+        binary: "gemini",
+        versionArgs: ["--version"],
+    },
     { 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" },

package/dist/slices/settings/readiness.js

@@ -1,19 +1,23 @@
+import { cliPathStatus } from "./cli-paths.js";
 import { cliReadiness } from "./cli-status.js";
 import { providers } from "./model.js";
 import { keyedProviders } from "./repo.js";
 // Every supported provider is listed, keyed or not, found or not, so Play can grey one out with
 // a reason instead of hiding it. A keyed provider is ready when a key is stored; a CLI provider
-// when its binary answers. Readiness is computed per request and nothing about a CLI is stored.
+// when its binary answers. Readiness is computed per request using the latest saved executable override.
 export async function providerStatuses(deps) {
     const keyed = keyedProviders(deps.db);
-    return await Promise.all(providers.map(async (provider) => ({
-        id: provider.id,
-        family: provider.family,
-        displayName: provider.displayName,
-        readiness: provider.auth === "cli"
-            ? await cliReadiness(deps.probe, provider)
-            : keyedReadiness(keyed, provider.id),
-    })));
+    return await Promise.all(providers.map(async (provider) => {
+        const base = { id: provider.id, family: provider.family, displayName: provider.displayName };
+        if (provider.auth !== "cli")
+            return { ...base, readiness: keyedReadiness(keyed, provider.id) };
+        const cliPath = cliPathStatus(deps.db, provider.id);
+        return {
+            ...base,
+            cliPath,
+            readiness: await cliReadiness(deps.probe, { ...provider, binary: cliPath.command }),
+        };
+    }));
 }
 function keyedReadiness(keyed, id) {
     return { kind: "keyed", hasKey: keyed.has(id) };

package/dist/slices/storage/downloads.js

@@ -19,6 +19,8 @@ const contentTypes = {
     ".ogg": "audio/ogg",
     ".opus": "audio/opus",
     ".mp4": "video/mp4",
+    ".srt": "application/x-subrip; charset=utf-8",
+    ".vtt": "text/vtt; charset=utf-8",
 };
 // Leaves room for "-<asset>.<ext>" inside a 255-byte filename, and keeps a download
 // folder readable when a title runs to the 200 characters the schema allows.

package/dist/slices/storage/layout.js

@@ -34,6 +34,16 @@ export function outputFileName(role, index, extension, stageKind) {
             return "sources.txt";
         case "glossary":
             return "glossary.txt";
+        case "subtitles_srt":
+            return "subtitles.srt";
+        case "subtitles_vtt":
+            return "subtitles.vtt";
+        case "subtitle_words":
+            return "subtitles.json";
+        case "subtitle_ass":
+            return "subtitles.ass";
+        case "subtitle_font":
+            return `subtitle-font${extension}`;
         case "render_params":
             return "render.json";
         case "instructions":
@@ -42,6 +52,8 @@ export function outputFileName(role, index, extension, stageKind) {
             return "video.mp4";
         case "audio_body":
             return `audio-body${extension}`;
+        case "audio_export":
+            return "audio.wav";
         case "audio_intro":
             return `audio-intro${extension}`;
         case "audio_outro":

package/dist/slices/storage/model.js

@@ -11,10 +11,16 @@ export const outputRoles = [
     "audio_body",
     "audio_intro",
     "audio_outro",
+    "audio_export",
     "image",
     "thumbnail",
     "video",
     "render_params",
+    "subtitles_srt",
+    "subtitles_vtt",
+    "subtitle_words",
+    "subtitle_ass",
+    "subtitle_font",
     "instructions",
 ];
 export const stagedFileStates = ["copying", "staged"];

package/dist/slices/storage/repo.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { outputRoles, stagedFileStates, stageKinds } from "./model.js";
 const metaSchema = z.object({
+    subtitlesMode: z.enum(["off", "files", "burn-in"]).optional(),
     promptName: z.string().optional(),
     prompt: z.string().optional(),
     index: z.number().optional(),

package/dist/slices/subtitles/captions.js

@@ -0,0 +1,88 @@
+// Keep spoken spelling and punctuation. Word times come only from acoustic alignment.
+export function captionCues(words) {
+    const cues = [];
+    let pending = [];
+    let previousEnd = 0;
+    const flush = () => {
+        const first = pending[0];
+        const last = pending.at(-1);
+        if (first !== undefined && last !== undefined) {
+            cues.push({
+                start: first.start,
+                end: last.end,
+                text: wrap(pending.map((word) => word.text)),
+            });
+        }
+        pending = [];
+    };
+    for (const word of words) {
+        if (!Number.isFinite(word.start) ||
+            !Number.isFinite(word.end) ||
+            word.start < previousEnd - 0.001 ||
+            word.end <= word.start) {
+            throw new Error("The subtitle word timing is invalid; regenerate alignment.");
+        }
+        const first = pending[0];
+        if (first !== undefined &&
+            (word.start - previousEnd > 0.7 ||
+                word.end - first.start > 5 ||
+                wrap([...pending.map((one) => one.text), word.text]).split("\n").length > 2)) {
+            flush();
+        }
+        pending.push({ ...word, text: word.text.replace(/\s+/g, " ").trim() });
+        previousEnd = word.end;
+        if (/[.!?]["'’”)]*$/.test(word.text))
+            flush();
+    }
+    flush();
+    return cues;
+}
+function wrap(words) {
+    const lines = [];
+    let line = "";
+    for (const word of words) {
+        if (line !== "" && line.length + word.length + 1 > 42) {
+            lines.push(line);
+            line = "";
+        }
+        line = line === "" ? word : `${line} ${word}`;
+    }
+    if (line !== "")
+        lines.push(line);
+    return lines.join("\n");
+}
+export function serializeSrt(cues) {
+    return cues
+        .map((cue, index) => `${index + 1}\n${stamp(cue.start, ",")} --> ${stamp(cue.end, ",")}\n${markup(cue.text)}\n`)
+        .join("\n");
+}
+export function serializeVtt(cues) {
+    return `WEBVTT\n\n${cues.map((cue) => `${stamp(cue.start, ".")} --> ${stamp(cue.end, ".")}\n${markup(cue.text)}\n`).join("\n")}`;
+}
+export function serializeAss(cues, style) {
+    const name = style.fontName.replace(/[\p{Cc},]/gu, " ").trim();
+    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`)
+            .join(""));
+}
+function markup(text) {
+    return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function assText(text) {
+    // Full-width alternatives stay visible and cannot open an ASS override or escape.
+    return text
+        .replaceAll("\\", "＼")
+        .replaceAll("{", "｛")
+        .replaceAll("}", "｝")
+        .replaceAll("\n", "\\N");
+}
+function stamp(seconds, separator) {
+    const ms = Math.max(0, Math.round(seconds * 1000));
+    return `${String(Math.floor(ms / 3_600_000)).padStart(2, "0")}:${String(Math.floor(ms / 60_000) % 60).padStart(2, "0")}:${String(Math.floor(ms / 1000) % 60).padStart(2, "0")}${separator}${String(ms % 1000).padStart(3, "0")}`;
+}
+function assStamp(seconds) {
+    const cs = Math.max(0, Math.round(seconds * 100));
+    return `${Math.floor(cs / 360_000)}:${String(Math.floor(cs / 6000) % 60).padStart(2, "0")}:${String(Math.floor(cs / 100) % 60).padStart(2, "0")}.${String(cs % 100).padStart(2, "0")}`;
+}

package/dist/slices/subtitles/model.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export const subtitleModes = ["off", "files", "burn-in"];
+export const subtitleConfigSchema = z.object({
+    mode: z.enum(subtitleModes),
+    language: z.literal("en").default("en"),
+    fontId: z
+        .string()
+        .max(160)
+        .regex(/^[A-Za-z0-9_-]+$/)
+        .default("default"),
+    fontSize: z.number().int().min(16).max(120).default(48),
+});
+export const defaultSubtitles = {
+    mode: "off",
+    language: "en",
+    fontId: "default",
+    fontSize: 48,
+};

package/dist/slices/subtitles/prepare.js

@@ -0,0 +1,162 @@
+import { createHash } from "node:crypto";
+import { copyFileSync, createReadStream, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { z } from "zod";
+import { projectById, setStageProgress } from "../admission/repo.js";
+import { resolveFont } from "../fonts/index.js";
+import { outputPath, projectDir } from "../storage/layout.js";
+import { outputsOf } from "../storage/repo.js";
+import { captionCues, serializeAss, serializeSrt, serializeVtt } from "./captions.js";
+import { defaultSubtitles } from "./model.js";
+import { spokenText } from "./transcript.js";
+export const subtitleRoles = [
+    "subtitles_srt",
+    "subtitles_vtt",
+    "subtitle_words",
+    "subtitle_ass",
+    "subtitle_font",
+];
+const wordSchema = z.object({
+    text: z.string(),
+    start: z.number().nonnegative(),
+    end: z.number().positive(),
+    confidence: z.number().optional(),
+});
+const fontSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    assName: z.string(),
+    extension: z.enum([".ttf", ".otf", ".ttc"]),
+});
+const cacheSchema = z.object({ key: z.string(), words: z.array(wordSchema), font: fontSchema });
+// Preparation writes into a new directory; only writeExport commits its output rows.
+// The old caption files/font/timing stay usable if alignment or rendering fails.
+export async function prepareSubtitles(deps, context, audio, frame) {
+    const { projectId } = context.stage;
+    const project = projectById(deps.db, projectId);
+    if (project === undefined)
+        throw new Error("The project no longer exists.");
+    const config = project.config.subtitles ?? defaultSubtitles;
+    if (config.mode === "off")
+        return undefined;
+    if (audio.length === 0)
+        throw new Error("Subtitles need narration audio.");
+    const outputs = outputsOf(deps.db, projectId);
+    const segments = audio.map((segment) => ({
+        ...segment,
+        text: segment.kind === "gap" ? "" : spokenText(deps, projectId, segment.kind, outputs),
+    }));
+    const key = await timingKey(segments, context.signal);
+    const cache = readCache(deps, projectId, outputs);
+    const dir = projectDir(deps.paths, projectId);
+    const directory = mkdtempSync(join(dir, "captions-"));
+    try {
+        const font = await snapshotFont(deps, projectId, outputs, config.fontId, cache, directory);
+        const words = cache?.key === key ? cache.words : await alignSegments(deps, context, segments);
+        context.signal.throwIfAborted();
+        const cues = captionCues(words);
+        if (cues.length === 0)
+            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.json"), JSON.stringify({ key, words, font }), {
+            mode: 0o600,
+        });
+        const files = [
+            ["subtitles_srt", "subtitles.srt"],
+            ["subtitles_vtt", "subtitles.vtt"],
+            ["subtitle_words", "subtitles.json"],
+            ["subtitle_ass", "subtitles.ass"],
+            ["subtitle_font", `fonts/selected${font.extension}`],
+        ];
+        return {
+            directory,
+            burnIn: config.mode === "burn-in" && project.config.sources.video !== "off",
+            assets: files.map(([role, path]) => ({
+                role,
+                path: relative(dir, join(directory, path)).split(sep).join("/"),
+            })),
+        };
+    }
+    catch (error) {
+        rmSync(directory, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function timingKey(segments, signal) {
+    // Bump when alignment normalization/model changes. Hash file contents, not timestamps.
+    const hash = createHash("sha256").update("wav2vec2-en-a19f851-v1");
+    for (const segment of segments) {
+        signal.throwIfAborted();
+        hash.update(JSON.stringify({ kind: segment.kind, seconds: segment.seconds, text: segment.text }));
+        if (segment.path !== null) {
+            const stream = createReadStream(segment.path, { signal });
+            for await (const chunk of stream)
+                hash.update(chunk);
+        }
+    }
+    return hash.digest("hex");
+}
+async function alignSegments(deps, context, segments) {
+    if (deps.alignSubtitles === undefined)
+        throw new Error("Local subtitle alignment is unavailable in this build.");
+    const words = [];
+    const total = segments.reduce((sum, segment) => sum + segment.seconds, 0);
+    let offset = 0;
+    for (const segment of segments) {
+        context.signal.throwIfAborted();
+        if (segment.path !== null) {
+            const aligned = await deps.alignSubtitles({
+                audioPath: segment.path,
+                text: segment.text,
+                cacheDir: join(deps.paths.dataDir, "models", "english-subtitles"),
+                ffmpeg: deps.ffmpeg,
+                signal: context.signal,
+                onProgress: (current, maximum) => {
+                    const progress = Math.round((35 * (offset + segment.seconds * (maximum > 0 ? current / maximum : 0))) / total);
+                    setStageProgress(deps.db, context.stage.id, progress, 100);
+                    context.emit({
+                        type: "stage.progress",
+                        projectId: context.stage.projectId,
+                        stage: "video",
+                        current: progress,
+                        total: 100,
+                    });
+                },
+            });
+            for (const word of aligned) {
+                if (word.end > segment.seconds + 0.1)
+                    throw new Error("Subtitle timing exceeds the narration duration.");
+                words.push({
+                    ...word,
+                    start: word.start + offset,
+                    end: Math.min(word.end, segment.seconds) + offset,
+                });
+            }
+        }
+        offset += segment.seconds;
+    }
+    return words;
+}
+function readCache(deps, projectId, outputs) {
+    const output = outputs.find((one) => one.role === "subtitle_words");
+    if (output === undefined)
+        return undefined;
+    try {
+        return cacheSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, projectId, output.path), "utf8")));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function snapshotFont(deps, projectId, outputs, id, cache, directory) {
+    const previous = outputs.find((one) => one.role === "subtitle_font");
+    const previousPath = previous === undefined ? undefined : outputPath(deps.paths, projectId, previous.path);
+    const saved = cache?.font.id === id && previousPath !== undefined && existsSync(previousPath)
+        ? { ...cache.font, path: previousPath }
+        : await resolveFont(deps.paths, id);
+    mkdirSync(join(directory, "fonts"), { mode: 0o700 });
+    copyFileSync(saved.path, join(directory, "fonts", `selected${saved.extension}`));
+    return { id: saved.id, name: saved.name, assName: saved.assName, extension: saved.extension };
+}

package/dist/slices/subtitles/transcript.js

@@ -0,0 +1,34 @@
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import { piecesOf } from "../../kernel/runner/piece-repo.js";
+import { stagesOf } from "../admission/repo.js";
+import { outputPath } from "../storage/layout.js";
+const textPayload = z.object({ text: z.string(), category: z.string().optional() });
+export function spokenText(deps, projectId, kind, outputs) {
+    const stages = stagesOf(deps.db, projectId);
+    if (kind === "body") {
+        const audio = stages.find((stage) => stage.kind === "audio");
+        if (audio?.source === "generate") {
+            const chunks = piecesOf(deps.db, audio.id, "chunk");
+            if (chunks.length > 0)
+                return chunks.map((piece) => payload(piece.payload).text).join("\n");
+        }
+        const article = outputs.find((output) => output.role === "article_txt");
+        if (article !== undefined)
+            return readFileSync(outputPath(deps.paths, projectId, article.path), "utf8");
+    }
+    else {
+        const article = stages.find((stage) => stage.kind === "article");
+        if (article !== undefined) {
+            const segment = piecesOf(deps.db, article.id, "segment")
+                .map((piece) => payload(piece.payload))
+                .find((piece) => piece.category === kind);
+            if (segment !== undefined)
+                return segment.text;
+        }
+    }
+    throw new Error(`The saved ${kind} narration text is missing. Subtitles need the text spoken in the audio.`);
+}
+function payload(raw) {
+    return textPayload.parse(JSON.parse(raw ?? "null"));
+}

package/dist/slices/video/audio-export.js

@@ -0,0 +1,69 @@
+import { relative } from "node:path";
+import { projectDir } from "../storage/layout.js";
+import { outputsOf } from "../storage/repo.js";
+import { prepareSubtitles } from "../subtitles/prepare.js";
+import { audioInputs } from "./audio-inputs.js";
+import { audioTimeline } from "./plan.js";
+import { writeExport } from "./write-export.js";
+const rate = 48000;
+export async function exportAudioWav(deps, context, gapSeconds) {
+    const { projectId } = context.stage;
+    const input = await audioInputs(deps, projectId, outputsOf(deps.db, projectId), context.signal);
+    const audio = audioTimeline({ ...input, gapSeconds }, 1 / rate);
+    const totalSeconds = audio.reduce((sum, segment) => sum + segment.seconds, 0);
+    const dir = projectDir(deps.paths, projectId);
+    const plan = {
+        sampleRate: rate,
+        channels: 2,
+        codec: "pcm_s16le",
+        gapSeconds,
+        totalSeconds,
+        audio: audio.map((segment) => ({
+            ...segment,
+            path: segment.path === null ? null : relative(dir, segment.path),
+        })),
+        output: "audio.wav",
+    };
+    const subtitles = await prepareSubtitles(deps, context, audio, { width: 1920, height: 1080 });
+    await writeExport(deps, context, {
+        role: "audio_export",
+        filename: "audio.wav",
+        partName: "audio.part.wav",
+        totalSeconds,
+        record: plan,
+        subtitles,
+        args: (part) => audioExportArgs(audio, part),
+    });
+}
+export function audioExportArgs(audio, output) {
+    const inputs = audio.flatMap((segment) => segment.path === null
+        ? ["-f", "lavfi", "-t", segment.seconds.toFixed(6), "-i", `anullsrc=r=${rate}:cl=stereo`]
+        : ["-i", segment.path]);
+    const chains = audio.map((_segment, index) => `[${index}:a]aformat=sample_fmts=s16:sample_rates=${rate}:channel_layouts=stereo,asetpts=PTS-STARTPTS[a${index}]`);
+    chains.push(`${audio.map((_segment, index) => `[a${index}]`).join("")}concat=n=${audio.length}:v=0:a=1[a]`);
+    return [
+        "-hide_banner",
+        "-nostdin",
+        "-loglevel",
+        "error",
+        "-progress",
+        "pipe:1",
+        "-nostats",
+        "-y",
+        ...inputs,
+        "-filter_complex",
+        chains.join(";"),
+        "-map",
+        "[a]",
+        "-vn",
+        "-c:a",
+        "pcm_s16le",
+        "-ar",
+        String(rate),
+        "-ac",
+        "2",
+        "-f",
+        "wav",
+        output,
+    ];
+}