@gentbajko/slopify 3.0.3 → 3.0.5

package/dist/slices/loudness/line-level.js

@@ -0,0 +1,138 @@
+import { rmSync, writeFileSync } from "node:fs";
+import { runFfmpeg } from "../video/ffmpeg.js";
+// Level the volume, line by line, for a narration with several speakers. The pieces are levelled
+// before they are joined (`level-pieces.ts`), but a piece is one request to the voice provider,
+// and with native dialogue one request speaks several people's lines. Its average hides them: a
+// narrator with a few loud words averages the same as a character who speaks up throughout, and
+// the character sits 2 dB above the narrator all the way. Once the words are timed, each line's
+// typical level (the median of its 400 ms momentary loudness while it speaks) is brought to
+// within `withinLu` of the narrator's; the gain changes in the pause between two lines, so no
+// word is cut into and nothing moves in time, and the captions keep their timing.
+// ceiling: how far from the narrator's typical level a line may stay.
+export const withinLu = 1;
+// ceiling: the most a line is moved either way; a line further off than this is left to the
+// listener rather than turned into noise or distortion.
+const gainCapDb = 10;
+// A momentary reading under this is a pause, not speech.
+const speechFloor = -45;
+// The first readings of a line still hold the line before it (the window is 400 ms long).
+const settleSeconds = 0.4;
+// Consecutive words by one speaker, from the timed words, in `offset`'s time (the file's own).
+export function linesOf(words, offset) {
+    const lines = [];
+    for (const word of words) {
+        if (word.speaker === undefined)
+            continue;
+        const last = lines.at(-1);
+        if (last !== undefined && last.speaker === word.speaker)
+            lines[lines.length - 1] = { ...last, end: word.end - offset };
+        else
+            lines.push({ speaker: word.speaker, start: word.start - offset, end: word.end - offset });
+    }
+    return lines;
+}
+// Each line's gain in dB, and the time it starts at: the middle of the pause before the line.
+export function lineGains(lines, frames, narrator = "narrator") {
+    const typical = lines.map((line) => {
+        const spoken = (from) => frames
+            .filter((frame) => frame.t >= from && frame.t <= line.end && frame.momentary > speechFloor)
+            .map((frame) => frame.momentary)
+            .sort((a, b) => a - b);
+        // A short line has too few settled readings; its whole span is the best there is.
+        const settled = spoken(line.start + settleSeconds);
+        const readings = settled.length >= 3 ? settled : spoken(line.start);
+        return readings.length === 0 ? undefined : readings[Math.floor(readings.length / 2)];
+    });
+    const median = (values) => [...values].sort((a, b) => a - b)[Math.floor(values.length / 2)];
+    const known = (values) => values.filter((value) => value !== undefined);
+    const reference = median(known(typical.filter((_value, at) => lines[at]?.speaker === narrator))) ??
+        median(known(typical));
+    if (reference === undefined)
+        return [];
+    return lines.map((line, at) => {
+        const level = typical[at];
+        const off = level === undefined ? 0 : level - reference;
+        const gain = off > withinLu ? withinLu - off : off < -withinLu ? -withinLu - off : 0;
+        const before = lines[at - 1];
+        return {
+            at: before === undefined ? 0 : (before.end + line.start) / 2,
+            gainDb: Math.max(-gainCapDb, Math.min(gainCapDb, Math.round(gain * 100) / 100)),
+        };
+    });
+}
+// ffmpeg's EBU R128 readings, ten a second, as its verbose log prints them.
+export function parseFrames(stderr) {
+    const frames = [];
+    for (const match of stderr.matchAll(/t:\s*([0-9.]+)\s+TARGET:[^\n]*?\sM:\s*(-?[0-9.]+)/g))
+        frames.push({ t: Number(match[1]), momentary: Number(match[2]) });
+    return frames;
+}
+// `input` levelled line by line into `output` (16-bit PCM WAV). `words` are timed on a timeline
+// where the file starts at `offset` seconds. False, with nothing written, when there is nothing
+// to level: no speakers in the words, or every line already within `withinLu`.
+export async function levelLines(run, input, output, words, offset) {
+    const lines = linesOf(words, offset);
+    if (new Set(lines.map((line) => line.speaker)).size < 2)
+        return false;
+    let stderr = "";
+    await runFfmpeg({
+        bin: run.bin,
+        args: [
+            "-hide_banner",
+            "-nostdin",
+            "-v",
+            "verbose",
+            "-nostats",
+            "-i",
+            input,
+            "-af",
+            "ebur128",
+            "-f",
+            "null",
+            "-",
+        ],
+        signal: run.signal,
+        log: run.log,
+        onProgress: () => { },
+        onStderr: (text) => {
+            stderr += text;
+        },
+    });
+    const gains = lineGains(lines, parseFrames(stderr));
+    if (gains.every((one) => one.gainDb === 0))
+        return false;
+    // The gain for each line, set at its start by a timed command to the volume filter.
+    const commands = `${output}.lines.txt`;
+    writeFileSync(commands, gains
+        .map((one) => `${Math.max(0, one.at).toFixed(3)} volume@lines volume ${(10 ** (one.gainDb / 20)).toFixed(5)};`)
+        .join("\n"), { mode: 0o600 });
+    try {
+        await runFfmpeg({
+            bin: run.bin,
+            args: [
+                "-hide_banner",
+                "-nostdin",
+                "-loglevel",
+                "error",
+                "-nostats",
+                "-y",
+                "-i",
+                input,
+                "-af",
+                `asendcmd=f=${commands.replaceAll("\\", "/").replaceAll(":", "\\\\:")},volume@lines=volume=1:precision=float:eval=frame`,
+                "-c:a",
+                "pcm_s16le",
+                "-f",
+                "wav",
+                output,
+            ],
+            signal: run.signal,
+            log: run.log,
+            onProgress: () => { },
+        });
+    }
+    finally {
+        rmSync(commands, { force: true });
+    }
+    return true;
+}

package/dist/slices/narration/pauses.js

@@ -1,23 +1,37 @@
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { numberForms } from "../../kernel/ports/number-words.js";
 import { measureFile } from "../loudness/loudnorm.js";
 import { pieceLufs, pieceTruePeak } from "../loudness/model.js";
 import { probeDurationMs, runFfmpeg } from "../video/ffmpeg.js";
 import { sentences } from "./chunk.js";
-// The sentence ends inside a text, not counting its last.
+// How long a stretch of text takes to say, in letters. Digits count as their words ("1982" as
+// "nineteen eighty two", English's being a fair measure for any language's), an IPA spelling's
+// slashes and stress marks count nothing, and a run of spacing counts one. Counted as written,
+// a paragraph full of years and issue numbers put its end seconds early.
+export function spokenLength(text) {
+    return Array.from(text
+        .replace(/\d[\d,]*(?:\.\d+)?(?:s|st|nd|rd|th)?\b/gi, (raw) => numberForms(raw)[0] ?? raw)
+        .replace(/[/ˈˌː]/g, "")
+        .replace(/\s+/g, " ")).length;
+}
+// The sentence ends inside a text, not counting its last. A name's initial ("Mary J. Blake")
+// ends no sentence, whatever the sentence splitter makes of its full stop.
 export function textBoundaries(text) {
     const parts = [...sentences(text)];
-    const total = Array.from(text).length;
+    const total = parts.reduce((sum, part) => sum + spokenLength(part), 0);
     if (parts.length < 2 || total === 0)
         return [];
     const boundaries = [];
     let offset = 0;
     for (const part of parts.slice(0, -1)) {
-        offset += Array.from(part).length;
+        offset += spokenLength(part);
         const trailing = /\s*$/.exec(part)?.[0] ?? "";
         // Only a real sentence: text that is only spacing is no sentence of its own.
         if (part.trim() === "")
             continue;
+        if (/(?:^|[\s("'])\p{Lu}\.\s*$/u.test(part))
+            continue;
         boundaries.push({
             ratio: offset / total,
             kind: /\n[ \t\r]*\n/.test(trailing) || /\n/.test(trailing) ? "paragraph" : "sentence",
@@ -54,6 +68,12 @@ const windowShare = 0.2;
 const durationWeight = 3;
 // A stretch this near either end of the piece is the piece's own lead-in or tail.
 const edgeSeconds = 0.02;
+// ceiling: a stretch shorter than this share of the voice's usual sentence pause (the median of
+// its as many longest stretches as the piece has sentence ends) is a breath between words, and
+// never a sentence end. The words only say roughly where an end is: a voice's pace swings with
+// its delivery cues, and one narration put a paragraph end 17 seconds after where its words
+// did. Lengthening a breath there cut "sixty-two" in two.
+const breathShare = 0.4;
 export function planPauses(input) {
     const { durationSeconds, silences, boundaries, settings } = input;
     const leadingSilence = silences.find((one) => one.start <= edgeSeconds);
@@ -65,7 +85,13 @@ export function planPauses(input) {
     const speechStart = leading;
     const speechEnd = Math.max(speechStart, durationSeconds - trailing);
     const speech = speechEnd - speechStart;
-    const inner = silences.filter((one) => one !== leadingSilence && one !== trailingSilence);
+    const between = silences.filter((one) => one !== leadingSilence && one !== trailingSilence);
+    const longest = between
+        .map((one) => one.end - one.start)
+        .sort((a, b) => b - a)
+        .slice(0, boundaries.length);
+    const usual = longest[Math.floor((longest.length - 1) / 2)] ?? 0;
+    const inner = between.filter((one) => one.end - one.start >= usual * breathShare);
     if (speech <= 0 || inner.length === 0 || boundaries.length === 0)
         return { inserts: [], leading, trailing };
     const window = Math.max(windowSeconds, speech * windowShare);

package/dist/slices/rebuild/activity.js

@@ -0,0 +1,58 @@
+import { currentRevisionId } from "../revisions/repo.js";
+function percentOf(row) {
+    if (row?.current === null || row?.total === null || row === undefined || !row.total)
+        return undefined;
+    return Math.max(0, Math.min(99, Math.floor((row.current / row.total) * 100)));
+}
+// The steps of a kind, done of all, while one of them runs.
+function counted(rows, match) {
+    const own = rows.filter((row) => match.test(row.key));
+    if (!own.some((row) => row.state === "running"))
+        return undefined;
+    return { done: own.filter((row) => row.state === "done").length, total: own.length };
+}
+export function videoActivity(db, projectId) {
+    const head = currentRevisionId(db, projectId);
+    if (head === undefined)
+        return undefined;
+    const rows = db
+        .prepare(`SELECT r.work_key AS key, w.state AS state, w.progress_current AS current, w.progress_total AS total
+       FROM revision_work_reservations r JOIN revision_work w ON w.id = r.work_id
+       WHERE r.revision_id = ? AND w.project_id = ? AND w.kind = 'video'`)
+        .all(head, projectId)
+        .map((row) => ({
+        key: String(row.key),
+        state: String(row.state),
+        current: typeof row.current === "number" ? row.current : null,
+        total: typeof row.total === "number" ? row.total : null,
+    }));
+    const running = (key) => rows.find((row) => row.key === key && row.state === "running");
+    const percent = (label, row) => {
+        const value = percentOf(row);
+        return value === undefined ? { label } : { label, percent: value };
+    };
+    if (running("export:video"))
+        return percent("rendering the video", running("export:video"));
+    if (running("export:wav"))
+        return percent("exporting the audio", running("export:wav"));
+    if (running("voices:files"))
+        return { label: "making the MP3 and M4B" };
+    const renders = counted(rows, /^shorts:\d+:render$/);
+    if (renders !== undefined)
+        return { label: "rendering the shorts", ...renders };
+    const pictures = counted(rows, /^shorts:\d+:image:\d+$/);
+    if (pictures !== undefined)
+        return { label: "drawing the shorts' pictures", ...pictures };
+    const prompts = counted(rows, /^shorts:\d+:prompts$/);
+    if (prompts !== undefined)
+        return { label: "planning the shorts' pictures", ...prompts };
+    if (running("shorts:pick"))
+        return { label: "picking the shorts" };
+    if (running("youtube:description"))
+        return { label: "writing the YouTube description" };
+    if (running("subtitles:timing"))
+        return percent("timing the captions", running("subtitles:timing"));
+    if (running("subtitles:cues") || running("subtitles:files"))
+        return { label: "writing the captions" };
+    return undefined;
+}

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

@@ -3,6 +3,7 @@ import { audioRecipes } from "./recipe-audio.js";
 import { documentRecipes } from "./recipe-document.js";
 import { editPlan } from "./recipe-edit.js";
 import { exportRecipes } from "./recipe-exports.js";
+import { linePlan } from "./recipe-lines.js";
 import { masterPlan } from "./recipe-loudness.js";
 import { resourceIdentity } from "./recipe-model.js";
 import { imageReference, referenceRecipe } from "./recipe-reference.js";
@@ -11,6 +12,12 @@ import { shortsRecipes } from "./recipe-shorts.js";
 import { textRecipes } from "./recipe-text.js";
 import { thumbnailRecipes, visualAssets, visualRecipes } from "./recipe-visual.js";
 import { youtubeRecipes } from "./recipe-youtube.js";
+// The video's sound: mastered, and on a multi-voice run levelled line by line first.
+function withLines(master, lines) {
+    return lines.keys.length === 0
+        ? master
+        : { values: [...master.values, ...lines.values], keys: [...master.keys, ...lines.keys] };
+}
 export function buildRecipes(context) {
     const text = textRecipes(context);
     const audio = audioRecipes(context, text);
@@ -31,6 +38,6 @@ export function buildRecipes(context) {
         ...shortsRecipes(context, exports, drawnFrom, audio.cards ?? [], masterPlan(context, audio.levels, "video")),
         ...thumbnail,
         ...documentRecipes(context, text, thumbnail),
-        ...visualAssets(context, visualRecipes(context.config, context.content, audio.mediaFingerprint, captions?.fingerprint ?? null, (images) => editPlan(context, exports, youtube, images, audio.cards ?? []), drawnFrom, timing === undefined ? null : resourceIdentity(context, timing), masterPlan(context, audio.levels, "video"))),
+        ...visualAssets(context, visualRecipes(context.config, context.content, audio.mediaFingerprint, captions?.fingerprint ?? null, (images) => editPlan(context, exports, youtube, images, audio.cards ?? []), drawnFrom, timing === undefined ? null : resourceIdentity(context, timing), withLines(masterPlan(context, audio.levels, "video"), linePlan(context, timing)))),
     ]);
 }

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

@@ -7,6 +7,7 @@ import { audioExportArgs } from "../video/audio-export-args.js";
 import { editNeedsTiming } from "../video/edit-settings.js";
 import { usesVoices } from "../voices/model.js";
 import { portraitValues } from "../voices/portraits.js";
+import { linePlan, linesLevelled } from "./recipe-lines.js";
 import { masterPlan } from "./recipe-loudness.js";
 import { recipe, resourceIdentity, } from "./recipe-model.js";
 export function exportRecipes(context, audio) {
@@ -16,6 +17,42 @@ export function exportRecipes(context, audio) {
     const recipes = [];
     // Level the volume: the listening files are mastered to the audio files' target.
     const master = masterPlan(context, audio.levels, "audioFiles");
+    const captions = config.subtitles !== undefined && config.subtitles.mode !== "off";
+    // The YouTube description's chapters, the shorts' clips and captions, a short's own
+    // captions, and the video's cuts, chapter cards and chapter openers use the same word timing,
+    // so it runs for them even with captions off; only the caption files below wait for captions.
+    // A multi-voice run with Level the volume on levels its speakers line by line from it too.
+    const voices = usesVoices(config) ? config.voices : undefined;
+    const lined = linesLevelled(config);
+    const timed = captions ||
+        usesYoutubeDescription(config) ||
+        usesShorts(config) ||
+        usesShortMode(config) ||
+        editNeedsTiming(config) ||
+        reviewsNarration(config) ||
+        voices?.audioFiles === true ||
+        lined;
+    const timing = timed
+        ? recipe(context, "subtitles:timing", "video", {
+            kind: "local",
+            version: 1,
+            operation: timingOperation(projectLanguage(config)),
+            // The lead-in moves every word, so the edge silence is part of the timing.
+            values: [
+                audio.timeline,
+                config.silenceGapSeconds,
+                // The project language; an English project reads "en" here as it always did.
+                config.language ?? config.subtitles?.language ?? "en",
+                config.edgeSilenceSeconds,
+                // Each word learns its speaker and turn on a multi-voice run.
+                ...(voices === undefined ? [] : ["voice-words-v1"]),
+            ],
+        }, audio.keys)
+        : undefined;
+    const lines = linePlan(context, timing);
+    // The timing goes ahead of what waits for it; any other run keeps its old order.
+    if (lined && timing !== undefined)
+        recipes.push(timing);
     if (config.sources.video === "off")
         recipes.push(recipe(context, "export:wav", "video", {
             kind: "local",
@@ -25,37 +62,13 @@ export function exportRecipes(context, audio) {
                 audio.mediaFingerprint,
                 audioExportArgs([{ kind: "body", path: "$body", seconds: 0 }], "$output"),
                 ...master.values,
+                ...lines.values,
             ],
-        }, [...audio.keys, ...master.keys]));
-    const captions = config.subtitles !== undefined && config.subtitles.mode !== "off";
-    // The YouTube description's chapters, the shorts' clips and captions, a short's own
-    // captions, and the video's cuts, chapter cards and chapter openers use the same word timing,
-    // so it runs for them even with captions off; only the caption files below wait for captions.
-    const voices = usesVoices(config) ? config.voices : undefined;
-    if (!captions &&
-        !usesYoutubeDescription(config) &&
-        !usesShorts(config) &&
-        !usesShortMode(config) &&
-        !editNeedsTiming(config) &&
-        !reviewsNarration(config) &&
-        voices?.audioFiles !== true)
+        }, [...audio.keys, ...master.keys, ...lines.keys]));
+    if (timing === undefined)
         return recipes;
-    const timing = recipe(context, "subtitles:timing", "video", {
-        kind: "local",
-        version: 1,
-        operation: timingOperation(projectLanguage(config)),
-        // The lead-in moves every word, so the edge silence is part of the timing.
-        values: [
-            audio.timeline,
-            config.silenceGapSeconds,
-            // The project language; an English project reads "en" here as it always did.
-            config.language ?? config.subtitles?.language ?? "en",
-            config.edgeSilenceSeconds,
-            // Each word learns its speaker and turn on a multi-voice run.
-            ...(voices === undefined ? [] : ["voice-words-v1"]),
-        ],
-    }, audio.keys);
-    recipes.push(timing);
+    if (!lined)
+        recipes.push(timing);
     if (voices?.audioFiles === true)
         recipes.push(recipe(context, "voices:files", "video", {
             kind: "local",
@@ -67,6 +80,7 @@ export function exportRecipes(context, audio) {
                 (audio.sections ?? []).map((section) => [section.title, section.firstTurn]),
                 config.title,
                 ...master.values,
+                ...lines.values,
                 // The book's title and chapter become the files' album and track tags; a project
                 // that is no chapter of a book keeps the values it always had.
                 ...(voices.book === undefined

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

@@ -0,0 +1,17 @@
+import { usesLoudness } from "../loudness/model.js";
+import { usesVoices } from "../voices/model.js";
+// Level the volume line by line (`loudness/line-level.ts`): a multi-voice run with Level the
+// volume on. Its sound waits for the word timing, which says where each speaker's line is.
+export function linesLevelled(config) {
+    return usesVoices(config) && usesLoudness(config) && config.sources.audio === "generate";
+}
+// What levelling line by line adds to a recipe that plays the sound: it waits for the word
+// timing. No fingerprint value: the levelling follows from the narration and its timing, which
+// the recipe already carries, so a project made before it (and the bundled samples) keeps its
+// files, and whatever is rendered from now on is levelled. A change to how lines are levelled
+// (`withinLu`) is the time to add one, and to rebuild the samples.
+export function linePlan(context, timing) {
+    if (!linesLevelled(context.config) || timing === undefined)
+        return { values: [], keys: [] };
+    return { values: [], keys: [timing.key] };
+}

package/dist/slices/rebuild/runtime-export.js

@@ -11,10 +11,12 @@ import { runFfmpeg } from "../video/ffmpeg.js";
 import { planRender } from "../video/plan.js";
 import { renderSlideshow } from "../video/slideshow.js";
 import { writePortraits } from "../voices/portraits.js";
+import { linesLevelled } from "./recipe-lines.js";
 import { exportBed } from "./runtime-export-bed.js";
 import { exportEdit } from "./runtime-export-edit.js";
 import { exportSnapshot, retainedOutput, revisionAudio, } from "./runtime-export-inputs.js";
 import { executeShortExport } from "./runtime-export-short.js";
+import { lineLevelledAudio } from "./runtime-lines.js";
 import { preparedResult, preparedText, publishResult } from "./runtime-publication.js";
 export async function executeExportRecipe(deps, context, piece) {
     if (deps.db
@@ -38,7 +40,15 @@ export async function executeExportRecipe(deps, context, piece) {
     const pending = allocateAsset(deps, context.work.projectId, filename);
     const prepared = [];
     let directory;
+    // A multi-voice run's body narration levelled line by line (`runtime-lines.ts`), here
+    // until the export is written.
+    const linesDirectory = linesLevelled(view.revision.config)
+        ? mkdtempSync(join(projectDir(deps.paths, context.work.projectId), "lines-"))
+        : undefined;
     try {
+        const sound = linesDirectory === undefined
+            ? audio
+            : await lineLevelledAudio(deps, context, view, audio, linesDirectory);
         const captions = snapshot.view.outputs.filter((row) => row.selected && row.available && row.state === "ready" && row.workKey === "subtitles:files");
         const burn = !wav && view.revision.config.subtitles?.mode === "burn-in";
         if (burn)
@@ -54,7 +64,7 @@ export async function executeExportRecipe(deps, context, piece) {
                 : "off";
         const config = view.revision.config;
         const segment = (kind) => {
-            const row = audio.find((one) => one.kind === kind);
+            const row = sound.find((one) => one.kind === kind);
             return row?.path === null || row === undefined
                 ? undefined
                 : { path: row.path, seconds: row.seconds };
@@ -125,7 +135,7 @@ export async function executeExportRecipe(deps, context, piece) {
             try {
                 await runFfmpeg({
                     bin: deps.ffmpeg,
-                    args: audioExportArgs(audio, mixed),
+                    args: audioExportArgs(sound, mixed),
                     signal: context.signal,
                     log: deps.log,
                     onProgress,
@@ -201,6 +211,8 @@ export async function executeExportRecipe(deps, context, piece) {
         discardPreparedAssets(deps, [pending, ...prepared.map((one) => one.asset)]);
         if (directory !== undefined)
             rmSync(directory, { recursive: true, force: true });
+        if (linesDirectory !== undefined)
+            rmSync(linesDirectory, { recursive: true, force: true });
     }
 }
 // The project's images in slideshow order, as files.

package/dist/slices/rebuild/runtime-lines.js

@@ -0,0 +1,36 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { levelLines } from "../loudness/line-level.js";
+import { outputPath } from "../storage/layout.js";
+import { linesLevelled } from "./recipe-lines.js";
+import { wordsSchema } from "./runtime-subtitles.js";
+// The sound a multi-voice run plays, with its body narration levelled line by line
+// (`loudness/line-level.ts`) into `directory`, for the video, the audio export and the audio
+// files alike. The words are timed on the timeline these segments lay out, so the body starts
+// at the seconds of the segments before it. Anything else plays as it was.
+export async function lineLevelledAudio(deps, context, view, audio, directory) {
+    if (!linesLevelled(view.revision.config))
+        return audio;
+    const timing = view.outputs.find((row) => row.selected &&
+        row.available &&
+        row.state === "ready" &&
+        row.workKey === "subtitles:timing" &&
+        row.output.role === "subtitle_words");
+    if (timing === undefined)
+        throw new Error("The narration's word timing, which evens out the speakers' volume, is missing. Use More → Render the video again in the Video section, then Try again.");
+    const { words } = wordsSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, context.work.projectId, timing.output.path), "utf8")));
+    const run = { bin: deps.ffmpeg, log: deps.log, signal: context.signal };
+    const levelled = [];
+    let offset = 0;
+    for (const segment of audio) {
+        if (segment.kind === "body" && segment.path !== null) {
+            const target = join(directory, "body-lines.wav");
+            const done = await levelLines(run, segment.path, target, words, offset);
+            levelled.push(done ? { ...segment, path: target } : segment);
+        }
+        else
+            levelled.push(segment);
+        offset += segment.seconds;
+    }
+    return levelled;
+}

package/dist/slices/rebuild/runtime-subtitles.js

@@ -283,9 +283,12 @@ export function describeMismatch(chunks, segment, mismatch) {
     const expected = mismatch.expected === "" ? "the end of the text" : `"${mismatch.expected}…"`;
     const heard = mismatch.heard === "" ? "no more speech" : `"${mismatch.heard.toLowerCase()}…"`;
     const fix = chunk === undefined
-        ? "Check that part of the narration, regenerate it in Edit project → Narration, then Continue the run."
-        : `In Edit project → Narration, regenerate narration chunk ${String(at + 1)}, then Continue the run.`;
-    return `Subtitles stopped matching the audio at ${where}. The text expected ${expected} but the audio has ${heard} The recording there probably skips or changes words. ${fix}`;
+        ? `Listen at ${clock(mismatch.at)}: if words are missing or wrong, regenerate that part in Edit project → Narration, then Continue the run.`
+        : `Listen at ${clock(mismatch.at)}: if words are missing or wrong, regenerate narration chunk ${String(at + 1)} in Edit project → Narration, then Continue the run.`;
+    // A voice that reads a year, an abbreviation or a name its own way reads it the same way
+    // again, so a remake would cost a chunk and fail here once more.
+    const same = "If it says them right, only another way (a year, an abbreviation or a name read its own way), regenerating gives the same reading: use Download diagnostics in Settings and report it.";
+    return `Subtitles stopped matching the audio at ${where}. The text expected ${expected} but the audio has ${heard} The recording there probably skips or changes words. ${fix} ${same}`;
 }
 function comparable(text) {
     return text

package/dist/slices/rebuild/runtime-voices.js

@@ -10,6 +10,7 @@ import { runFfmpeg } from "../video/ffmpeg.js";
 import { audioChapters, audioFileArgs, ffmetadata } from "../voices/audio-files.js";
 import { turnStarts } from "../voices/timing.js";
 import { exportSnapshot, revisionAudio } from "./runtime-export-inputs.js";
+import { lineLevelledAudio } from "./runtime-lines.js";
 import { preparedResult, publishResult } from "./runtime-publication.js";
 import { wordsSchema } from "./runtime-subtitles.js";
 // The listening files of a multi-voice run: the MP3 and the M4B of the narration timeline,
@@ -64,9 +65,11 @@ export async function executeVoicesRecipe(deps, context, piece) {
         let sound = audio;
         if (goal !== undefined) {
             const mixed = join(directory, "mix.wav");
+            // A multi-voice run's speakers levelled line by line first (`runtime-lines.ts`).
+            const levelled = await lineLevelledAudio(deps, context, view, audio, directory);
             await runFfmpeg({
                 bin: deps.ffmpeg,
-                args: audioExportArgs(audio, mixed),
+                args: audioExportArgs(levelled, mixed),
                 signal: context.signal,
                 log: deps.log,
                 onProgress: () => { },

package/dist/slices/run-cost/panel.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { stageKinds } from "../../kernel/pipeline.js";
 import { planAccountNames, planAccountOf, planAccounts, } from "../../kernel/ports/plan-limits.js";
+import { projectTiming } from "./timing.js";
 const usageRow = z.object({
     stage: z.enum(stageKinds),
     kind: z.enum(["llm", "tts", "image", "video"]),
@@ -59,12 +60,13 @@ function add(into, row) {
         seconds: into.seconds + (row.seconds ?? 0),
     };
 }
-export function runCostOf(db, projectId) {
+export function runCostOf(db, projectId, now = Date.now()) {
     const rows = db
         .prepare("SELECT stage, kind, provider, model, tokens_in, tokens_out, tokens_cached, characters, images, seconds, on_plan, cost, api_model, api_cost, price_json FROM provider_usage WHERE project_id = ? ORDER BY created_at, rowid")
         .all(projectId)
         .map((row) => usageRow.parse(row));
-    const walls = stageWalls(db, projectId);
+    const timing = projectTiming(db, projectId, now);
+    const walls = timing.byStage;
     const stages = new Map();
     const models = new Map();
     let total = { ...emptyLine, ...emptyTotals };
@@ -104,8 +106,9 @@ export function runCostOf(db, projectId) {
             characters: total.characters,
             images: total.images,
             seconds: total.seconds,
-            wallMs: [...walls.values()].reduce((sum, ms) => sum + ms, 0),
+            wallMs: timing.workingMs,
         },
+        run: timing.run,
         byStage: stageKinds.flatMap((kind) => {
             const found = stages.get(kind);
             return found === undefined ? [] : [found];
@@ -125,26 +128,6 @@ function catalogueOf(json) {
     const parsed = z.object({ catalogue: z.string() }).safeParse(JSON.parse(json));
     return parsed.success ? parsed.data.catalogue : null;
 }
-function stageWalls(db, projectId) {
-    const walls = new Map();
-    for (const raw of db
-        .prepare("SELECT kind, started_at, finished_at FROM stages WHERE project_id = ?")
-        .all(projectId)) {
-        const row = z
-            .object({
-            kind: z.enum(stageKinds),
-            started_at: z.string().nullable(),
-            finished_at: z.string().nullable(),
-        })
-            .parse(raw);
-        if (row.started_at === null || row.finished_at === null)
-            continue;
-        const ms = Date.parse(row.finished_at) - Date.parse(row.started_at);
-        if (Number.isFinite(ms) && ms >= 0)
-            walls.set(row.kind, ms);
-    }
-    return walls;
-}
 // Two readings belong to the same window when their resets agree to within a few minutes;
 // a reset moving on means the window rolled over between them.
 const sameWindowMs = 5 * 60_000;