@gentbajko/slopify 0.5.0 → 0.5.1

package/dist/slices/reruns/cascade.js

@@ -1,5 +1,5 @@
 import { stageKinds } from "../../kernel/pipeline.js";
-import { deps as graph } from "../../kernel/runner/graph.js";
+import { dependenciesOf } from "../../kernel/runner/graph.js";
 // The stages to redo, in pipeline order, each with how much of itself it throws away.
 export function redoPlan(input) {
     const stale = staleStages(input);
@@ -11,7 +11,7 @@ function staleStages(input) {
     const { action } = input;
     switch (action.kind) {
         case "rerun":
-            return withDependents([action.stage]);
+            return withDependents([action.stage], input);
         case "article-edit": {
             // An article edit re-runs audio, LLM-mode intro/outro text, the LLM-written
             // thumbnail and the video, leaving prompt-based images untouched. The video comes
@@ -20,14 +20,14 @@ function staleStages(input) {
             if (input.thumbnailSource === "prompt_by_llm") {
                 roots.push("thumbnail");
             }
-            return withDependents(roots);
+            return withDependents(roots, input);
         }
         case "image-deleted":
             // The image is removed from the set and the video re-renders. The remaining
             // images stand, so the images stage itself is not redone.
-            return withDependents(["video"]);
+            return input.videoSource === "off" ? new Set() : withDependents(["video"], input);
         case "image-regenerated":
-            return withDependents(["images"]);
+            return withDependents(["images"], input);
     }
 }
 // `provided` → `running` and `skipped` → `running` are forbidden, so a stage whose output
@@ -49,11 +49,15 @@ function clearsOf(action, kind) {
 }
 // The transitive closure of the dependents of `roots` over `kernel/runner/graph.ts`. The
 // graph has six nodes, so one pass per node closes it whatever the edges are.
-function withDependents(roots) {
+function withDependents(roots, input) {
     const found = new Set(roots);
     for (let pass = 0; pass < stageKinds.length; pass += 1) {
         for (const kind of stageKinds) {
-            if (graph[kind].some((dependency) => found.has(dependency))) {
+            const dependencies = dependenciesOf(kind, {
+                thumbnail: input.thumbnailSource,
+                video: input.videoSource ?? "generate",
+            });
+            if (dependencies.some((dependency) => found.has(dependency))) {
                 found.add(kind);
             }
         }

package/dist/slices/reruns/index.js

@@ -142,13 +142,19 @@ function load(deps, projectId) {
         stages,
         outputs: outputsOf(deps.db, projectId),
         thumbnailSource: project.config.sources.thumbnail,
+        videoSource: project.config.sources.video,
     };
 }
 // One transaction for every row the action touches, then the filesystem: an unlink cannot
 // be rolled back, so it waits for the commit. A file with no row is what the boot reconcile
 // collects, where a row with no file is a broken download.
 function apply(deps, projectId, action, loaded, own) {
-    const plan = redoPlan({ action, stages: loaded.stages, thumbnailSource: loaded.thumbnailSource });
+    const plan = redoPlan({
+        action,
+        stages: loaded.stages,
+        thumbnailSource: loaded.thumbnailSource,
+        videoSource: loaded.videoSource,
+    });
     // `own` is the action's own change - the new article, the image that goes - and it runs
     // first and inside the same transaction, so it lands or rolls back with the cascade it
     // triggers. The files it writes take the names they already had, replacing in place
@@ -190,6 +196,22 @@ function clearStage(deps, stage, outputs) {
     deletePieces(deps.db, stage.id);
     return files;
 }
+// Switching narrator halfway through a stage must not join two different voices.
+// The caller includes these row changes with the config update's transaction and
+// runs the returned cleanup only after commit. Finished narration is left intact.
+export function clearUnfinishedAudio(deps, projectId) {
+    const stage = stagesOf(deps.db, projectId).find((one) => one.kind === "audio");
+    if (stage === undefined ||
+        stage.state === "done" ||
+        stage.state === "provided" ||
+        stage.state === "skipped")
+        return [];
+    const orphaned = clearStage(deps, stage, outputsOf(deps.db, projectId));
+    deps.db
+        .prepare("UPDATE stages SET progress_current = NULL, progress_total = NULL WHERE id = ?")
+        .run(stage.id);
+    return [() => removeFiles(deps, projectId, orphaned)];
+}
 // A regenerated image is replaced in place at the same index, so the piece keeps the prompt
 // and the index it was planned with and only stops naming a file: `slices/images/run.ts`
 // then sees one image of its plan still to make, and the file it named can be removed.

package/dist/slices/storage/layout.js

@@ -42,6 +42,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,6 +11,7 @@ export const outputRoles = [
     "audio_body",
     "audio_intro",
     "audio_outro",
+    "audio_export",
     "image",
     "thumbnail",
     "video",

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

@@ -0,0 +1,66 @@
+import { relative } from "node:path";
+import { projectDir } from "../storage/layout.js";
+import { outputsOf } from "../storage/repo.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",
+    };
+    await writeExport(deps, context, {
+        role: "audio_export",
+        filename: "audio.wav",
+        partName: "audio.part.wav",
+        totalSeconds,
+        record: plan,
+        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,
+    ];
+}

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

@@ -0,0 +1,32 @@
+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 project has no narration audio to render against");
+    if (body.seconds <= 0)
+        throw new Error("the narration audio decodes to no sound");
+    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 ?? (await probeDurationMs(deps.ffmpeg, path, signal, deps.log));
+    if (output.durationMs === null) {
+        // A provided file arrives with no duration; measuring it once is worth recording.
+        deps.db.prepare("UPDATE outputs SET duration_ms = ? WHERE id = ?").run(durationMs, output.id);
+        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/ffmpeg.js

@@ -55,14 +55,12 @@ export function renderArgs(plan) {
         filterGraph(plan, audioAt),
         "-map",
         "[v]",
-        "-map",
-        "[a]",
+        ...(plan.audio.length > 0 ? ["-map", "[a]"] : []),
         "-c:v",
         "libx264",
         "-pix_fmt",
         "yuv420p",
-        "-c:a",
-        "aac",
+        ...(plan.audio.length > 0 ? ["-c:a", "aac"] : ["-an"]),
         "-movflags",
         "+faststart",
         plan.output,
@@ -86,7 +84,9 @@ function filterGraph(plan, audioAt) {
         // brought to one format before concat, which refuses to join mismatched streams.
         chains.push(`[${input}:a]aformat=sample_fmts=fltp:sample_rates=${sampleRate}:channel_layouts=${channelLayout}[a${at}]`);
     });
-    chains.push(`${audioAt.map((_input, at) => `[a${at}]`).join("")}concat=n=${audioAt.length}:v=0:a=1[a]`);
+    if (audioAt.length > 0) {
+        chains.push(`${audioAt.map((_input, at) => `[a${at}]`).join("")}concat=n=${audioAt.length}:v=0:a=1[a]`);
+    }
     return chains.join(";");
 }
 // Odd images 100% → 115%, even images 115% → 100%, linear over the slot. `on` is

package/dist/slices/video/plan.js

@@ -12,12 +12,14 @@ export const zoomTo = 1.15;
 export const zoomBy = 0.15;
 export function planRender(input) {
     if (input.images.length === 0) {
-        // Admission makes an image source mandatory, so an empty set is a bug upstream.
+        // Admission permits Video only with an image source, so an empty set is a bug upstream.
         throw new Error("a render needs at least one image");
     }
     const frame = frames[input.format];
-    const audio = timeline(input);
-    const totalSeconds = audio.reduce((sum, segment) => sum + segment.seconds, 0);
+    const audio = input.body === undefined ? [] : audioTimeline({ ...input, body: input.body });
+    const totalSeconds = input.body === undefined
+        ? input.images.length * 5
+        : audio.reduce((sum, segment) => sum + segment.seconds, 0);
     const totalFrames = Math.max(input.images.length, Math.round(totalSeconds * fps));
     return {
         width: frame.width,
@@ -33,13 +35,12 @@ export function planRender(input) {
 }
 // Intro, gap, body, gap, outro, with a gap only where the segment on
 // the other side of it exists.
-function timeline(input) {
+export function audioTimeline(input, minimumGap = 1 / fps) {
     const segments = [];
     const gap = { kind: "gap", path: null, seconds: input.gapSeconds };
-    // A gap shorter than one frame is no gap. The renderer formats a segment's length to
-    // milliseconds, so anything under that would become `-t 0.000`: an anullsrc input with
-    // no samples that still had to be counted in the audio concat.
-    const audible = input.gapSeconds >= 1 / fps;
+    // Video keeps its existing minimum of one frame. WAV passes one sample instead,
+    // because its gap duration is independent of the slideshow's frame rate.
+    const audible = input.gapSeconds >= minimumGap;
     if (input.intro !== undefined) {
         segments.push({ kind: "intro", path: input.intro.path, seconds: input.intro.seconds });
         if (audible) {

package/dist/slices/video/run.js

@@ -1,121 +1,43 @@
-import { mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, relative } from "node:path";
-import { transact } from "../../kernel/db/tx.js";
-import { projectById, setStageProgress } from "../admission/repo.js";
+import { relative } from "node:path";
+import { projectById } from "../admission/repo.js";
 import { outputPath, projectDir } from "../storage/layout.js";
-import { deleteOutput, insertOutput, outputsOf } from "../storage/repo.js";
-import { probeDurationMs, renderArgs, runFfmpeg } from "./ffmpeg.js";
+import { outputsOf } from "../storage/repo.js";
+import { exportAudioWav } from "./audio-export.js";
+import { audioInputs } from "./audio-inputs.js";
+import { renderArgs } from "./ffmpeg.js";
 import { planRender } from "./plan.js";
-// ceiling: progress is coalesced to one event per 500 ms, and the stage's progress
-// columns are written on the same tick so a page that reconnects mid-render sees a bar
-// rather than nothing.
-const progressIntervalMs = 500;
-// The previous video stays downloadable until the new render finishes. ffmpeg therefore writes
-// beside the finished file rather than over it, and the swap below is what replaces it. The
-// name keeps the `.mp4` extension because that is what ffmpeg picks its muxer from, and no row
-// ever names it: a download resolves an outputs row, and the boot reconcile collects a part
-// file left by a killed process as an orphan (`slices/storage/reconcile.ts`).
-const partName = "video.part.mp4";
-// The two outputs one render produces. Both are replaced together, so a project never
-// carries the video of one render beside the parameters of another.
-const renderRoles = ["video", "render_params"];
+import { writeExport } from "./write-export.js";
 export async function renderVideo(deps, context) {
     const { projectId } = context.stage;
     const project = projectById(deps.db, projectId);
-    if (project === undefined) {
+    if (!project)
         throw new Error(`project ${projectId} has no row`);
+    if (project.config.sources.video === "off") {
+        if (project.config.sources.audio === "off")
+            throw new Error("the project has no media export enabled");
+        await exportAudioWav(deps, context, project.config.silenceGapSeconds);
+        return;
     }
     const outputs = outputsOf(deps.db, projectId);
     const dir = projectDir(deps.paths, projectId);
-    const target = outputPath(deps.paths, projectId, "video.mp4");
-    const body = await audio(deps, outputs, "audio_body", dir, context.signal);
-    if (body === undefined) {
-        throw new Error("the project has no narration audio to render against");
-    }
-    if (body.seconds <= 0) {
-        throw new Error("the narration audio decodes to no sound");
-    }
+    const narration = project.config.sources.audio === "off"
+        ? {}
+        : await audioInputs(deps, projectId, outputs, context.signal);
     const plan = planRender({
         format: project.format,
         gapSeconds: project.config.silenceGapSeconds,
-        ...withIntro(await audio(deps, outputs, "audio_intro", dir, context.signal)),
-        body,
-        ...withOutro(await audio(deps, outputs, "audio_outro", dir, context.signal)),
+        ...narration,
         images: slideshow(outputs).map((output) => outputPath(deps.paths, projectId, output.path)),
-        output: target,
-    });
-    mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
-    // The plan is the record of what was rendered and names the file the user downloads,
-    // so it keeps the final path; only the ffmpeg invocation is pointed at the part file.
-    const part = outputPath(deps.paths, projectId, partName);
-    const totalMs = Math.round(plan.totalSeconds * 1000);
-    let announced = 0;
-    try {
-        // No retry and no timeout. A render that fails is terminal.
-        await runFfmpeg({
-            bin: deps.ffmpeg,
-            args: renderArgs({ ...plan, output: part }),
-            signal: context.signal,
-            log: deps.log,
-            onProgress: (elapsedMs) => {
-                const at = deps.clock.now().getTime();
-                if (at - announced < progressIntervalMs) {
-                    return;
-                }
-                announced = at;
-                const current = Math.min(elapsedMs, totalMs);
-                setStageProgress(deps.db, context.stage.id, current, totalMs);
-                context.emit({
-                    type: "stage.progress",
-                    projectId,
-                    stage: "video",
-                    current,
-                    total: totalMs,
-                });
-            },
-        });
-        // A cancel protects an output that was already stored, not one about to be. One
-        // landing between ffmpeg exiting and the rows below discards the render rather than
-        // reporting done to a page that pressed Cancel.
-        context.signal.throwIfAborted();
-    }
-    catch (error) {
-        // A partial render file is discarded, never kept or served. Only the part file: the
-        // previous video is a finished output and stays downloadable.
-        rmSync(part, { force: true });
-        throw error;
-    }
-    // The swap. Everything below replaces the previous render, and nothing above it could.
-    renameSync(part, target);
-    const params = outputPath(deps.paths, projectId, "render.json");
-    writeFileSync(params, `${JSON.stringify(recorded(plan, dir), null, 2)}\n`, { mode: 0o600 });
-    // No version history. The files were written under the names the previous render
-    // already used, so replacing the rows that named them is all that is left to do. In one
-    // transaction, or a crash between the delete and the insert would leave the finished
-    // video with no row and the boot reconcile would collect it. Read back rather than
-    // reused from above: the rows are what a download resolves.
-    transact(deps.db, () => {
-        for (const previous of outputsOf(deps.db, projectId)) {
-            if (renderRoles.includes(previous.role)) {
-                deleteOutput(deps.db, previous.id);
-            }
-        }
-        store(deps, projectId, "render_params", "render.json", null);
-        store(deps, projectId, "video", "video.mp4", totalMs);
+        output: outputPath(deps.paths, projectId, "video.mp4"),
     });
-    // Written as well as emitted: a page opened after the render reads the row, and the
-    // throttled in-flight writes would have left it frozen short of the end.
-    setStageProgress(deps.db, context.stage.id, totalMs, totalMs);
-    context.emit({
-        type: "stage.progress",
-        projectId,
-        stage: "video",
-        current: totalMs,
-        total: totalMs,
+    await writeExport(deps, context, {
+        role: "video",
+        filename: "video.mp4",
+        partName: "video.part.mp4",
+        totalSeconds: plan.totalSeconds,
+        record: recorded(plan, dir),
+        args: (part) => renderArgs({ ...plan, output: part }),
     });
-    // Videos rendered (completed renders). One event per swap, so a render that failed or was
-    // canceled counts nothing and a re-render counts again No provider: ffmpeg is the machine's
-    // own, not a service.
     deps.count("stage.completed", { stage: "video" });
 }
 // Written with project-relative paths, so the record of what was rendered can be read
@@ -138,41 +60,3 @@ function slideshow(outputs) {
         .filter((output) => output.role === "image")
         .toSorted((left, right) => (left.meta.index ?? 0) - (right.meta.index ?? 0));
 }
-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 ?? (await probeDurationMs(deps.ffmpeg, path, signal, deps.log));
-    if (output.durationMs === null) {
-        // A provided file arrives with no duration; measuring it once is worth recording.
-        deps.db.prepare("UPDATE outputs SET duration_ms = ? WHERE id = ?").run(durationMs, output.id);
-        deps.log.write("info", "video.probe", {
-            projectId: output.projectId,
-            stage: "video",
-            detail: `${relative(dir, path)} is ${durationMs} ms`,
-        });
-    }
-    return { path, seconds: durationMs / 1000 };
-}
-function withIntro(intro) {
-    return intro === undefined ? {} : { intro };
-}
-function withOutro(outro) {
-    return outro === undefined ? {} : { outro };
-}
-function store(deps, projectId, role, path, durationMs) {
-    insertOutput(deps.db, {
-        id: deps.ids.next(),
-        projectId,
-        stageKind: "video",
-        role,
-        path,
-        originalFilename: null,
-        bytes: statSync(outputPath(deps.paths, projectId, path)).size,
-        durationMs,
-        meta: {},
-        createdAt: deps.clock.now().toISOString(),
-    });
-}

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

@@ -0,0 +1,98 @@
+import { mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { transact } from "../../kernel/db/tx.js";
+import { setStageProgress } from "../admission/repo.js";
+import { outputPath } from "../storage/layout.js";
+import { deleteOutput, insertOutput, outputsOf } from "../storage/repo.js";
+import { runFfmpeg } from "./ffmpeg.js";
+const progressIntervalMs = 500;
+const renderRoles = ["video", "audio_export", "render_params"];
+// Both local exports retain the previous finished asset until ffmpeg succeeds and
+// the abort check passes. The part file keeps its muxer's filename extension.
+export async function writeExport(deps, context, output) {
+    const { projectId } = context.stage;
+    const target = outputPath(deps.paths, projectId, output.filename);
+    mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+    // The plan is the record of what was rendered and names the file the user downloads,
+    // so it keeps the final path; only the ffmpeg invocation is pointed at the part file.
+    const part = outputPath(deps.paths, projectId, output.partName);
+    const totalMs = Math.round(output.totalSeconds * 1000);
+    let announced = 0;
+    try {
+        // No retry and no timeout. A render that fails is terminal.
+        await runFfmpeg({
+            bin: deps.ffmpeg,
+            args: output.args(part),
+            signal: context.signal,
+            log: deps.log,
+            onProgress: (elapsedMs) => {
+                const at = deps.clock.now().getTime();
+                if (at - announced < progressIntervalMs) {
+                    return;
+                }
+                announced = at;
+                const current = Math.min(elapsedMs, totalMs);
+                setStageProgress(deps.db, context.stage.id, current, totalMs);
+                context.emit({
+                    type: "stage.progress",
+                    projectId,
+                    stage: "video",
+                    current,
+                    total: totalMs,
+                });
+            },
+        });
+        // A cancel protects an output that was already stored, not one about to be. One
+        // landing between ffmpeg exiting and the rows below discards the render rather than
+        // reporting done to a page that pressed Cancel.
+        context.signal.throwIfAborted();
+    }
+    catch (error) {
+        // A partial render file is discarded, never kept or served. Only the part file: the
+        // previous export is a finished output and stays downloadable.
+        rmSync(part, { force: true });
+        throw error;
+    }
+    // The swap. Everything below replaces the previous render, and nothing above it could.
+    renameSync(part, target);
+    const params = outputPath(deps.paths, projectId, "render.json");
+    writeFileSync(params, `${JSON.stringify(output.record, null, 2)}\n`, { mode: 0o600 });
+    // No version history. The files were written under the names the previous render
+    // already used, so replacing the rows that named them is all that is left to do. In one
+    // transaction, or a crash between the delete and the insert would leave the finished
+    // export with no row and the boot reconcile would collect it. Read back rather than
+    // reused from above: the rows are what a download resolves.
+    transact(deps.db, () => {
+        for (const previous of outputsOf(deps.db, projectId)) {
+            if (renderRoles.includes(previous.role)) {
+                deleteOutput(deps.db, previous.id);
+            }
+        }
+        store(deps, projectId, "render_params", "render.json", null);
+        store(deps, projectId, output.role, output.filename, totalMs);
+    });
+    // Written as well as emitted: a page opened after the render reads the row, and the
+    // throttled in-flight writes would have left it frozen short of the end.
+    setStageProgress(deps.db, context.stage.id, totalMs, totalMs);
+    context.emit({
+        type: "stage.progress",
+        projectId,
+        stage: "video",
+        current: totalMs,
+        total: totalMs,
+    });
+}
+function store(deps, projectId, role, path, durationMs) {
+    insertOutput(deps.db, {
+        id: deps.ids.next(),
+        projectId,
+        stageKind: "video",
+        role,
+        path,
+        originalFilename: null,
+        bytes: statSync(outputPath(deps.paths, projectId, path)).size,
+        durationMs,
+        meta: {},
+        createdAt: deps.clock.now().toISOString(),
+    });
+}