@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/slices/subtitles/prepare.js

@@ -1,194 +0,0 @@
-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 { subtitleModelDir } from "../../kernel/paths.js";
-import { projectLanguage } from "../../kernel/ports/languages.js";
-import { projectById } from "../admission/repo.js";
-import { setStageProgress } from "../admission/stage-writes.js";
-import { captionFont, captionFontDeps } from "../fonts/coverage.js";
-import { resolveFont } from "../fonts/index.js";
-import { outputPath, projectDir } from "../storage/layout.js";
-import { outputsOf } from "../storage/repo.js";
-import { spoken } from "../video/plan.js";
-import { captionCues, serializeAss, serializeSrt, serializeVtt } from "./captions.js";
-import { defaultSubtitles, timingOperation } 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,
-    omissions: z
-        .array(z.object({ start: z.number().finite().nonnegative(), text: z.string() }))
-        .default([]),
-});
-// Preparation writes into a new directory; export writers commit 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("This project no longer exists; it may have been deleted while it was running.");
-    const config = project.config.subtitles ?? defaultSubtitles;
-    if (config.mode === "off")
-        return undefined;
-    context.signal.throwIfAborted();
-    setStageProgress(deps.db, context.stage.id, 0, 100);
-    context.emit({ type: "stage.progress", projectId, stage: "video", current: 0, total: 100 });
-    if (audio.length === 0)
-        throw new Error("Captions need narration audio, but this project has none. Turn captions off in Edit project → Subtitles, or turn narration on, then Try again.");
-    const outputs = outputsOf(deps.db, projectId);
-    const segments = audio.map((segment) => ({
-        ...segment,
-        text: spoken(segment.kind) ? spokenText(deps, projectId, segment.kind, outputs) : "",
-    }));
-    const language = projectLanguage(project.config);
-    const key = await timingKey(segments, language, 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, language);
-        const omissions = cache?.key === key ? [...cache.omissions] : [];
-        const words = cache?.key === key
-            ? cache.words
-            : await alignSegments(deps, context, segments, omissions, language);
-        context.signal.throwIfAborted();
-        const cues = captionCues(words);
-        if (cues.length === 0)
-            throw new Error("None of the narration could be matched to the article text, so captions can't be timed. The narration must be in the project language set in Edit project → Language; if you uploaded your own audio, make sure it reads the article text, then Try again.");
-        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,
-            position: config.position,
-            color: config.color,
-            outlineColor: config.outlineColor,
-        }), { mode: 0o600 });
-        writeFileSync(join(directory, "subtitles.json"), JSON.stringify({ key, words, font, omissions }), {
-            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,
-            omissions,
-            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, language, signal) {
-    // Bump when alignment normalization/model changes. Hash file contents, not timestamps.
-    // English hashes the operation it always did (`timingOperation`).
-    const hash = createHash("sha256").update(timingOperation(language));
-    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, omissions, language) {
-    if (deps.alignSubtitles === undefined)
-        throw new Error("Slopify hit an internal error (the caption timing tool is missing from this build). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    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,
-                onOmission: (omission) => omissions.push({ ...omission, start: omission.start + offset }),
-                text: segment.text,
-                cacheDir: subtitleModelDir(deps.paths.dataDir, language),
-                ...(language === "en" ? {} : { language }),
-                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("Caption timing came out longer than the narration audio. Try again; if it happens again, use Download diagnostics in Settings and report it.");
-                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, language) {
-    const previous = outputs.find((one) => one.role === "subtitle_font");
-    const previousPath = previous === undefined ? undefined : outputPath(deps.paths, projectId, previous.path);
-    const saved = language !== "en"
-        ? await captionFont(captionFontDeps(deps.paths), id, language)
-        : 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

@@ -1,34 +0,0 @@
-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 text of the ${kind === "body" ? "article" : kind} is missing, and captions need the text spoken in the narration. Use More → Write the article again in the Article section, then Try again.`);
-}
-function payload(raw) {
-    return textPayload.parse(JSON.parse(raw ?? "null"));
-}

package/dist/slices/thumbnail/run.js

@@ -1,219 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import { z } from "zod";
-import { thumbnailAspect } from "../../kernel/pipeline.js";
-import { insertPiece, piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
-import { projectById } from "../admission/repo.js";
-import { outputFileName, outputPath } from "../storage/layout.js";
-import { insertOutput, outputsOf } from "../storage/repo.js";
-import { storeText } from "../storage/staging.js";
-import { noTokens, plusUsage } from "../telemetry/model.js";
-import { thumbnailMessages, writtenPrompt } from "./by-llm.js";
-// The `prompt_written` sub-step, persisted for resume: the prompt the LLM wrote and the
-// messages that asked for it, so a resumed run reproduces the record without asking
-// again.
-const writtenPayload = z.object({ prompt: z.string(), sent: z.string() });
-export async function runThumbnail(deps, context, providers) {
-    const { projectId } = context.stage;
-    const project = projectById(deps.db, projectId);
-    if (project === undefined) {
-        throw new Error("This project no longer exists; it may have been deleted while it was running.");
-    }
-    const source = project.config.sources.thumbnail;
-    if (source !== "from_prompt" && source !== "prompt_by_llm") {
-        // Off is `skipped` and Provide is `provided` at project creation,
-        // so the runner never starts this stage for either.
-        throw new Error(`Slopify hit an internal error (the thumbnail stage cannot run with its source set to ${source}). Try again; if it happens again, use Download diagnostics in Settings and report it.`);
-    }
-    const choice = project.config.images;
-    if (choice === undefined) {
-        // Admission requires the image provider whenever the thumbnail is generated, so reaching
-        // here is a bug in admission rather than the user's.
-        throw new Error("No image model is set for the thumbnail. Choose one in Edit project → Providers, then Try again.");
-    }
-    const result = source === "from_prompt" ? undefined : await byLlm(deps, context, providers, project);
-    if (result !== undefined && !result.ok)
-        return "held";
-    const written = result?.value;
-    const prompt = written?.prompt ?? fromTemplate(project);
-    if ((await make(deps, context, providers, project, choice, prompt)) === "held")
-        return "held";
-    // Tokens are counted with a provider and model name per stage, and a payload names one
-    // provider. This stage can use two - the LLM that writes the prompt and the image model
-    // that draws it - so the event names whichever one's usage it reports, because both are
-    // shown beside the token columns on the Usage page. A thumbnail from a picked template
-    // makes no LLM call, so it names the image model and reports zero tokens.
-    deps.count("stage.completed", {
-        stage: "thumbnail",
-        provider: written?.provider ?? choice.provider,
-        model: written?.model ?? choice.model,
-        ...(written?.tokens ?? noTokens),
-        thumbnails: 1,
-    });
-    deps.log.write("info", "thumbnail.done", {
-        projectId,
-        stage: "thumbnail",
-        detail: source === "from_prompt" ? "from the picked prompt" : "from the prompt the LLM wrote",
-    });
-    return "done";
-}
-// The rendered thumbnail template goes to the image provider as it is.
-function fromTemplate(project) {
-    const rendered = project.config.rendered.thumbnailPrompt;
-    if (rendered === undefined) {
-        throw new Error("Slopify hit an internal error (the thumbnail prompt was never filled in). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    }
-    return rendered;
-}
-// A written prompt already on the project is reused, so a manual retry redoes only the
-// image call and the wording the user is looking at does not change under them.
-async function byLlm(deps, context, providers, project) {
-    const kept = piecesOf(deps.db, context.stage.id, "prompt_written")[0];
-    const llm = project.config.llm;
-    if (kept !== undefined && kept.state === "done") {
-        // The wording the user is looking at does not change under them. No call was
-        // made, so this run counts none - the run that wrote the prompt already did.
-        return {
-            ok: true,
-            value: {
-                prompt: payloadOf(kept).prompt,
-                ...(llm === undefined ? {} : named(llm)),
-                tokens: noTokens,
-            },
-        };
-    }
-    if (llm === undefined) {
-        // Admission requires the LLM row when the thumbnail source is Prompt by LLM.
-        throw new Error("No AI model is set for writing the thumbnail prompt. Choose one in Edit project → Providers, then Try again.");
-    }
-    const messages = thumbnailMessages(brief(deps, project));
-    const answer = await providers.llm({
-        provider: llm.provider,
-        model: llm.model,
-        ...(llm.thinking === undefined ? {} : { thinking: llm.thinking }),
-        messages,
-        // An empty answer is a failed attempt, and the wrapper is what retries it.
-        check: (given) => writtenPrompt(given.text),
-    });
-    // The image prompt is exactly the LLM's output, never edited by the app.
-    if (!answer.ok)
-        return answer;
-    const prompt = answer.value.text.trim();
-    keepWritten(deps, context, kept?.id, prompt, messages);
-    // The messages sent are stored beside the article stage's, per stage.
-    storeText(deps, {
-        projectId: context.stage.projectId,
-        stageKind: "thumbnail",
-        role: "instructions",
-        text: instructionsText(messages),
-    });
-    return {
-        ok: true,
-        value: { prompt, ...named(llm), tokens: plusUsage(noTokens, answer.value.usage) },
-    };
-}
-function named(choice) {
-    return { provider: choice.provider, model: choice.model };
-}
-function brief(deps, project) {
-    const instruction = project.config.rendered.thumbnailPrompt;
-    if (instruction === undefined) {
-        throw new Error("Slopify hit an internal error (the thumbnail prompt was never filled in). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    }
-    return {
-        instruction,
-        title: project.title,
-        values: project.config.values,
-        format: project.format,
-        article: articleText(deps, project.id),
-    };
-}
-// The stage never starts without an article on the project. The runner's graph holds the other
-// half - the thumbnail waits on the article stage - so a project with no article row here is a
-// stage that started against a run that never wrote one.
-function articleText(deps, projectId) {
-    const article = outputsOf(deps.db, projectId).find((output) => output.role === "article_txt");
-    if (article === undefined) {
-        throw new Error("The thumbnail prompt is written from the article, but the article isn't ready. Let the Article stage finish, then Try again.");
-    }
-    return readFileSync(outputPath(deps.paths, projectId, article.path), "utf8");
-}
-// The one row is keyed by `idx` within the stage, so a stage that runs again replaces what
-// it wrote rather than colliding with it.
-function keepWritten(deps, context, existing, prompt, messages) {
-    const payload = JSON.stringify({ prompt, sent: instructionsText(messages) });
-    if (existing === undefined) {
-        insertPiece(deps.db, {
-            id: deps.ids.next(),
-            stageId: context.stage.id,
-            kind: "prompt_written",
-            idx: 1,
-            state: "done",
-            payload,
-        });
-        return;
-    }
-    setPiece(deps.db, existing, "done", payload);
-}
-// One call, the same aspect rule as the slideshow, stored apart from it
-// with the prompt text, the provider and the model.
-async function make(deps, context, providers, project, choice, prompt) {
-    const { projectId } = context.stage;
-    if (outputsOf(deps.db, projectId).some((output) => output.role === "thumbnail")) {
-        // The `image-done` sub-step: a retry that failed after the image landed keeps it.
-        return "done";
-    }
-    const result = await providers.image({
-        provider: choice.provider,
-        model: choice.model,
-        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
-        prompt,
-        aspect: thumbnailAspect(project.format),
-    });
-    if (!result.ok)
-        return "held";
-    const made = result.value;
-    const name = outputFileName("thumbnail", 1, made.mime === "image/png" ? ".png" : ".jpg", "thumbnail");
-    write(deps, projectId, name, made);
-    // A cancel protects an output already stored, not one about to be: one landing between
-    // the write and the row leaves a file the boot reconcile collects.
-    context.signal.throwIfAborted();
-    const output = {
-        id: deps.ids.next(),
-        projectId,
-        stageKind: "thumbnail",
-        role: "thumbnail",
-        path: name,
-        originalFilename: null,
-        bytes: made.bytes.byteLength,
-        durationMs: null,
-        // There is no `index`: the thumbnail stays out of the slideshow, and the render reads
-        // that list by role.
-        meta: {
-            promptName: project.config.thumbnailPrompt ?? "",
-            prompt,
-            provider: choice.provider,
-            model: choice.model,
-            ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
-        },
-        createdAt: deps.clock.now().toISOString(),
-    };
-    // No `image.landed`: the thumbnail stays out of the slideshow, and that event's `index`
-    // is a place in it. The stage reaching `done` is what tells the page.
-    insertOutput(deps.db, output);
-    return "done";
-}
-function write(deps, projectId, name, made) {
-    const target = outputPath(deps.paths, projectId, name);
-    mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
-    writeFileSync(target, made.bytes, { mode: 0o600 });
-}
-function instructionsText(messages) {
-    return `=== Thumbnail prompt ===\n\n${messages.map((message) => message.content).join("\n\n")}\n`;
-}
-function payloadOf(piece) {
-    if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (the saved thumbnail prompt is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    }
-    return writtenPayload.parse(JSON.parse(piece.payload));
-}

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

@@ -1,33 +0,0 @@
-import { relative } from "node:path";
-import { outputPath, projectDir } from "../storage/layout.js";
-import { probeDurationMs } from "./ffmpeg.js";
-export async function audioInputs(deps, projectId, outputs, signal) {
-    const dir = projectDir(deps.paths, projectId);
-    const body = await audio(deps, outputs, "audio_body", dir, signal);
-    if (!body)
-        throw new Error("The video has no narration audio to play. Let the Narration stage finish, then Try again.");
-    if (body.seconds <= 0)
-        throw new Error("The narration audio contains no sound; the file may be damaged or empty. Regenerate the narration (or upload a different audio file in Edit project → Narration), then Try again.");
-    const intro = await audio(deps, outputs, "audio_intro", dir, signal);
-    const outro = await audio(deps, outputs, "audio_outro", dir, signal);
-    return { body, intro, outro };
-}
-async function audio(deps, outputs, role, dir, signal) {
-    const output = outputs.find((candidate) => candidate.role === role);
-    if (output === undefined) {
-        return undefined;
-    }
-    const path = outputPath(deps.paths, output.projectId, output.path);
-    const durationMs = output.durationMs ??
-        (deps.measureAudio === undefined
-            ? await probeDurationMs(deps.ffmpeg, path, signal, deps.log)
-            : await deps.measureAudio(path, signal));
-    if (output.durationMs === null) {
-        deps.log.write("info", "video.probe", {
-            projectId: output.projectId,
-            stage: "video",
-            detail: `${relative(dir, path)} is ${durationMs} ms`,
-        });
-    }
-    return { path, seconds: durationMs / 1000 };
-}

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

@@ -1,62 +0,0 @@
-import { readFileSync, statSync } from "node:fs";
-import { z } from "zod";
-import { outputPath } from "../storage/layout.js";
-const planSchema = z.object({
-    sampleRate: z.number(),
-    channels: z.number(),
-    codec: z.string(),
-    gapSeconds: z.number(),
-    // Absent from records written before the edge silence existed, which then never match.
-    edgeSeconds: z.number().optional(),
-    totalSeconds: z.number(),
-    audio: z.array(z.object({ kind: z.string(), path: z.string().nullable(), seconds: z.number() })),
-    output: z.string(),
-    sourceIds: z.array(z.string()).optional(),
-    sourceHashes: z
-        .array(z.object({ id: z.string(), sha256: z.string().regex(/^[a-f0-9]{64}$/) }))
-        .optional(),
-});
-// Old releases did not record source IDs. Their relative timeline plus source dates and
-// file metadata let subtitle-only edits reuse those exports without a one-time re-encode.
-export function reusableAudioExport(paths, projectId, outputs, plan) {
-    const media = outputs.find((output) => output.role === "audio_export");
-    const record = outputs.find((output) => output.role === "render_params");
-    if (media === undefined || record === undefined)
-        return undefined;
-    let saved;
-    try {
-        saved = planSchema.parse(JSON.parse(readFileSync(outputPath(paths, projectId, record.path), "utf8")));
-        const { sourceIds: previousIds, sourceHashes: previousHashes, ...previousPlan } = saved;
-        const { sourceIds, sourceHashes, ...currentPlan } = plan;
-        if (JSON.stringify(previousPlan) !== JSON.stringify(currentPlan) ||
-            (previousIds !== undefined && JSON.stringify(previousIds) !== JSON.stringify(sourceIds)) ||
-            (previousHashes !== undefined &&
-                JSON.stringify(previousHashes) !== JSON.stringify(sourceHashes)))
-            return undefined;
-        const wav = statSync(outputPath(paths, projectId, media.path));
-        if (!wav.isFile() ||
-            wav.size !== media.bytes ||
-            media.durationMs !== Math.round(plan.totalSeconds * 1000))
-            return undefined;
-        for (const segment of plan.audio) {
-            if (segment.path === null)
-                continue;
-            const source = outputs.find((output) => ["audio_body", "audio_intro", "audio_outro"].includes(output.role) &&
-                output.path === segment.path);
-            if (source === undefined ||
-                !Number.isFinite(Date.parse(source.createdAt)) ||
-                Date.parse(source.createdAt) > Date.parse(media.createdAt))
-                return undefined;
-            const file = statSync(outputPath(paths, projectId, source.path));
-            if (!file.isFile() ||
-                file.size !== source.bytes ||
-                (previousHashes === undefined && file.mtimeMs > wav.mtimeMs))
-                return undefined;
-        }
-        return media;
-    }
-    catch {
-        // Missing/corrupt old records or files require a normal export.
-        return undefined;
-    }
-}

package/dist/slices/video/run.js

@@ -1,78 +0,0 @@
-import { relative } from "node:path";
-import { projectById } from "../admission/repo.js";
-import { outputPath, projectDir } from "../storage/layout.js";
-import { outputsOf } from "../storage/repo.js";
-import { prepareSubtitles } from "../subtitles/prepare.js";
-import { exportAudioWav } from "./audio-export.js";
-import { audioInputs } from "./audio-inputs.js";
-import { withPaths } from "./edit-list.js";
-import { planRender } from "./plan.js";
-import { renderSlideshow } from "./slideshow.js";
-import { writeExport } from "./write-export.js";
-export async function renderVideo(deps, context) {
-    const { projectId } = context.stage;
-    const project = projectById(deps.db, projectId);
-    if (!project)
-        throw new Error("This project no longer exists; it may have been deleted while it was running.");
-    if (project.config.sources.video === "off") {
-        if (project.config.sources.audio === "off")
-            throw new Error("There is nothing to export because both video and narration are turned off for this project. Turn one on in Edit project, then Try again.");
-        await exportAudioWav(deps, context, project.config.silenceGapSeconds, project.config.edgeSilenceSeconds);
-        return;
-    }
-    const outputs = outputsOf(deps.db, projectId);
-    const dir = projectDir(deps.paths, projectId);
-    const narration = project.config.sources.audio === "off"
-        ? {}
-        : await audioInputs(deps, projectId, outputs, context.signal);
-    const plan = planRender({
-        format: project.format,
-        gapSeconds: project.config.silenceGapSeconds,
-        edgeSeconds: project.config.edgeSilenceSeconds,
-        imageSeconds: project.config.imageSeconds,
-        zoomPercent: project.config.zoomPercent,
-        motionStyle: project.config.motionStyle,
-        ...narration,
-        images: slideshow(outputs).map((output) => outputPath(deps.paths, projectId, output.path)),
-        output: outputPath(deps.paths, projectId, "video.mp4"),
-    });
-    const subtitles = await prepareSubtitles(deps, context, plan.editList.audio, plan.editList);
-    await writeExport(deps, context, {
-        role: "video",
-        filename: "video.mp4",
-        partName: "video.part.mp4",
-        totalSeconds: plan.totalSeconds,
-        record: { ...recorded(plan, dir), subtitles: project.config.subtitles ?? null },
-        subtitles,
-        render: async (part, onProgress) => {
-            await renderSlideshow({
-                bin: deps.ffmpeg,
-                edit: plan.editList,
-                output: part,
-                burnSubtitles: subtitles?.burnIn ?? false,
-                cwd: subtitles?.directory,
-                scratch: dir,
-                signal: context.signal,
-                log: deps.log,
-                onProgress,
-            });
-        },
-    });
-    deps.count("stage.completed", { stage: "video" });
-}
-// Written with project-relative paths, so the record of what was rendered can be read
-// beside the files it names and carries no absolute path off the machine.
-function recorded(plan, dir) {
-    return {
-        ...plan,
-        editList: withPaths(plan.editList, (path) => relative(dir, path)),
-        output: relative(dir, plan.output),
-    };
-}
-// Every slideshow image, once each, in slideshow order; the plan cycles through them.
-// The thumbnail is a different role, so it is never in this list.
-function slideshow(outputs) {
-    return outputs
-        .filter((output) => output.role === "image")
-        .toSorted((left, right) => (left.meta.index ?? 0) - (right.meta.index ?? 0));
-}