@gentbajko/slopify 3.22.0 → 3.23.0

package/dist/adapters/alignment/text.js

@@ -7,7 +7,10 @@ import { cardinal, numberForms } from "../../kernel/ports/number-words.js";
 // `formsOf` is the language's normaliser (`multilingual.ts` passes its own); the default is
 // English, and `empty` is the sentence for a text with nothing to say.
 export function speechWords(text, observed = "", aliases = [], formsOf = wordForms, empty = "Local subtitles currently require an English transcript with spoken words.") {
-    const matches = aliases.length === 0 ? [] : aliasMatches(text, aliases);
+    // An alias spoken as IPA ("Gygax's" said /ˈɡaɪɡæksɪz/) is a pronunciation, not other
+    // words: like a glossary entry, the recording is matched against the written word.
+    const worded = aliases.filter((alias) => !spokenAsIpa(alias.spoken));
+    const matches = worded.length === 0 ? [] : aliasMatches(text, worded);
     const words = [];
     for (const token of text.matchAll(/\S+/g)) {
         const textWord = token[0];
@@ -57,6 +60,9 @@ export function speechWords(text, observed = "", aliases = [], formsOf = wordFor
     // the written text again without the aliases, and "&" alone says nothing.
     return words.map(({ text: shown, spoken, forms, aliased }) => forms.length > 1 || aliased ? { text: shown, spoken, forms } : { text: shown, spoken });
 }
+function spokenAsIpa(spoken) {
+    return /^\/[^/]+\/(?:\s+\/[^/]+\/)*$/u.test(spoken.trim());
+}
 // The form of a word the recording seems to say, else its default.
 export function respoken(word, observed, formsOf = wordForms) {
     if (word.forms === undefined)

package/dist/patch-notes/3.22.1.md

@@ -0,0 +1,9 @@
+# Slopify 3.22.1
+
+Released 13 October 2026.
+
+- **Subtitles work with a pronunciation alias.** A narration alias spoken as IPA (for example "Gygax's" said /ˈɡaɪɡæksɪz/) stopped the subtitles with "Local subtitles currently support English speech and Latin-script names only." Subtitles now time that word from its written form, the same way they do for a Pronunciation Glossary entry.
+
+## Upgrading from 3.22.0
+
+- A run stopped by that message goes on with Try again; nothing is voiced again.

package/dist/patch-notes/3.23.0.md

@@ -0,0 +1,11 @@
+# Slopify 3.23.0
+
+Released 14 October 2026.
+
+- **Level each sentence.** A new switch beside Soften breaths and Soften S sounds (Play → Video and style, Edit project → Pauses and volume) holds every sentence of the narration to the sentences in the minute around it, so no line jumps out or drops away and the joins between voice requests stop jumping. A loud sentence comes down by up to 6 dB, a quiet one up by up to 3 dB, and the volume only changes in the pauses, so no word is cut into and the captions keep their timing. It runs before Soften breaths and Soften S sounds. Needs Level the volume and one voice. Off by default.
+- On a 2½-hour narration, the spread of sentence loudness against the surrounding minute fell from 1.0 dB to 0.6 dB, and joins between requests jumping more than 3 dB went from 15% to none.
+- **Tip:** set the Video volume to −2 dB (−16 LUFS) with it. The final limiter then never squashes a peak by more than about 3 dB; at the recommended −14 LUFS it flattens the voice's loudest syllables by 3 to 5 dB about 22 times a minute.
+
+## Upgrading from 3.22.1
+
+- Nothing changes until you turn the switch on. Turning it on joins the narration again from the pieces it already has and renders the video and shorts again; no speech is made again.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.23.0",
+    "title": "Slopify 3.23.0",
+    "version": "3.23.0",
+    "date": "2026-10-14"
+  },
+  {
+    "id": "3.22.1",
+    "title": "Slopify 3.22.1",
+    "version": "3.22.1",
+    "date": "2026-10-13"
+  },
   {
     "id": "3.22.0",
     "title": "Slopify 3.22.0",

package/dist/slices/admission/schema.js

@@ -189,6 +189,8 @@ export const runDraftSchema = z.object({
     // Soften breaths and Soften S sounds (`narration/breaths-model.ts`); absent is off.
     removeBreaths: z.boolean().optional(),
     deEss: z.boolean().optional(),
+    // Level each sentence (`loudness/sentence-level.ts`); absent is off.
+    levelSentences: z.boolean().optional(),
     // Absent is English (`kernel/ports/languages.ts`).
     language: languageSchema.optional(),
 });

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

@@ -11,7 +11,9 @@ import { lowerLoudPhrases, phrasePasses } from "./phrase-level.js";
 // the report says what the levelling did, not what it meant to do.
 const format = { sampleRate: 44100, channels: 1 };
 const goal = { lufs: pieceLufs, truePeak: pieceTruePeak };
-export async function levelPieces(run, files, directory) {
+export async function levelPieces(run, files, directory, 
+// Level each sentence takes the place of the phrase step (`sentence-level.ts`).
+options = { phrases: true }) {
     mkdirSync(directory, { recursive: true, mode: 0o700 });
     const levelled = [];
     const before = [];
@@ -25,7 +27,7 @@ export async function levelPieces(run, files, directory) {
         // are quieter too, and an opening still stands above them. Quiet passages are never raised.
         let source = file;
         const made = [];
-        for (let pass = 1; pass <= phrasePasses; pass++) {
+        for (let pass = 1; options.phrases && pass <= phrasePasses; pass++) {
             const phrased = `${output}.phrases-${String(pass)}.wav`;
             if (!(await lowerLoudPhrases(run, source, phrased)))
                 break;

package/dist/slices/loudness/sentence-level-model.js

@@ -0,0 +1,16 @@
+// Level each sentence's numbers (`sentence-level.ts`), browser-safe so recipes can carry them.
+export const sentenceLevel = {
+    // The sentences a sentence is held to: those whose middle is this close to its own.
+    contextSeconds: 30,
+    // ceiling: the most a quiet sentence is raised, and a loud one lowered.
+    raiseDb: 3,
+    lowerDb: 6,
+    // ceiling: a raised sentence's loudest sample stays under this, in dBFS.
+    peakCeilingDb: -1,
+    // Speech is cut into parts at each pause at least this long, a part shorter than the
+    // minimum joined to its neighbour.
+    cutSeconds: 0.2,
+    partSecondsMin: 1.5,
+    // A second pass holds each sentence to its neighbours as the first left them.
+    passes: 2,
+};

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

@@ -0,0 +1,331 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, resolve as resolvePath } from "node:path";
+import { measurePiece } from "../narration/pauses.js";
+import { runFfmpeg } from "../video/ffmpeg.js";
+import { sentenceLevel } from "./sentence-level-model.js";
+export { sentenceLevel } from "./sentence-level-model.js";
+// Level each sentence (`levelSentences` on a run's config). The voice provider reads a narration
+// a request at a time, and inside a request the voice drifts: the first sentences come out
+// louder, the last ones quieter, and now and then one line stands well above or below the lines
+// around it. Levelling a request by its average can't see that. With the setting on, once each
+// request is brought to the common level (`level-pieces.ts`, without the phrase step), every
+// sentence is measured (its K-weighted loudness, gated as EBU R128 gates a programme) and moved
+// toward the median of the sentences in the minute around it, across the joins between
+// requests too. A loud sentence comes down by up to `lowerDb`, a quiet one up by up to
+// `raiseDb`, and never so far that its loudest sample would pass `peakCeilingDb` (what comes
+// after is written as 16-bit PCM). The gain changes only in the quiet between two sentences, so
+// no word is cut into and nothing moves in time. It runs before Soften breaths and Soften S
+// sounds, which then work on the levelled voice.
+// Fewer neighbours than this within the context, and the context is doubled.
+const neighboursMin = 6;
+// A change smaller than this isn't sent to the volume filter.
+const changeDb = 0.05;
+// The meter's rate: K-weighting's filters are specified at 48 kHz.
+const meterRate = 48000;
+// One reading per 10 ms.
+const frameSamples = 480;
+const framesPerSecond = meterRate / frameSamples;
+// ITU-R BS.1770 K-weighting at 48 kHz: a high shelf, then the RLB high-pass.
+const shelf = {
+    b: [1.53512485958697, -2.69169618940638, 1.19839281085285],
+    a: [-1.69065929318241, 0.73248077421585],
+};
+const highPass = {
+    b: [1.0, -2.0, 1.0],
+    a: [-1.99004745483398, 0.99007225036621],
+};
+// K-weighted mean power and sample peak per 10 ms, fed samples (48 kHz mono) as they come.
+export class Meter {
+    power = [];
+    peaks = [];
+    s1 = [0, 0, 0, 0];
+    s2 = [0, 0, 0, 0];
+    sum = 0;
+    peak = 0;
+    count = 0;
+    feed(samples) {
+        const [b0, b1, b2] = shelf.b;
+        const [a1, a2] = shelf.a;
+        const [c0, c1, c2] = highPass.b;
+        const [d1, d2] = highPass.a;
+        let [x1, x2, y1, y2] = this.s1;
+        let [u1, u2, v1, v2] = this.s2;
+        for (const x of samples) {
+            const y = b0 * x + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2;
+            x2 = x1;
+            x1 = x;
+            y2 = y1;
+            y1 = y;
+            const v = c0 * y + c1 * u1 + c2 * u2 - d1 * v1 - d2 * v2;
+            u2 = u1;
+            u1 = y;
+            v2 = v1;
+            v1 = v;
+            this.sum += v * v;
+            const level = Math.abs(x);
+            if (level > this.peak)
+                this.peak = level;
+            this.count += 1;
+            if (this.count === frameSamples) {
+                this.power.push(this.sum / frameSamples);
+                this.peaks.push(this.peak);
+                this.sum = 0;
+                this.peak = 0;
+                this.count = 0;
+            }
+        }
+        this.s1 = [x1, x2, y1, y2];
+        this.s2 = [u1, u2, v1, v2];
+    }
+    readings() {
+        return { power: this.power, peaks: this.peaks };
+    }
+}
+const loudnessOf = (power) => -0.691 + 10 * Math.log10(Math.max(power, 1e-12));
+// The gated loudness of readings `from` to `to` (seconds), as EBU R128 gates a programme: 400 ms
+// blocks every 100 ms, those under -70 LUFS and those 10 LU under the rest left out. Undefined
+// when nothing in it is loud enough to count.
+export function gatedLoudness(power, from, to) {
+    const a = Math.max(0, Math.round(from * framesPerSecond));
+    const b = Math.min(power.length, Math.round(to * framesPerSecond));
+    if (b - a < 10)
+        return undefined;
+    const block = 40;
+    const blocks = [];
+    if (b - a < block) {
+        let sum = 0;
+        for (let at = a; at < b; at++)
+            sum += power[at] ?? 0;
+        blocks.push(sum / (b - a));
+    }
+    else
+        for (let start = a; start + block <= b; start += 10) {
+            let sum = 0;
+            for (let at = start; at < start + block; at++)
+                sum += power[at] ?? 0;
+            blocks.push(sum / block);
+        }
+    const heard = blocks.filter((one) => loudnessOf(one) > -70);
+    if (heard.length === 0)
+        return undefined;
+    const mean = (values) => values.reduce((sum, one) => sum + one, 0) / values.length;
+    const relative = loudnessOf(mean(heard)) - 10;
+    const kept = heard.filter((one) => loudnessOf(one) > relative);
+    return kept.length === 0 ? undefined : loudnessOf(mean(kept));
+}
+const median = (values) => {
+    const sorted = [...values].sort((a, b) => a - b);
+    return sorted[Math.floor(sorted.length / 2)];
+};
+// Each sentence's gain in dB: toward the median of its neighbours, within the caps.
+export function sentenceGains(readings) {
+    const gains = readings.map(() => 0);
+    const known = readings.flatMap((one, at) => (one.loudness === undefined ? [] : [at]));
+    for (let pass = 0; pass < sentenceLevel.passes; pass++) {
+        const now = readings.map((one, at) => one.loudness === undefined ? undefined : one.loudness + (gains[at] ?? 0));
+        for (const at of known) {
+            const reading = readings[at];
+            const near = (seconds) => known.filter((other) => other !== at &&
+                Math.abs(readings[other].at - reading.at) <= seconds);
+            let around = near(sentenceLevel.contextSeconds);
+            if (around.length < neighboursMin)
+                around = near(2 * sentenceLevel.contextSeconds);
+            if (around.length === 0)
+                continue;
+            const target = median(around.map((other) => now[other]));
+            const wanted = (gains[at] ?? 0) + target - now[at];
+            const headroom = Math.max(0, sentenceLevel.peakCeilingDb - reading.peakDb);
+            gains[at] = Math.max(-sentenceLevel.lowerDb, Math.min(sentenceLevel.raiseDb, headroom, wanted));
+        }
+    }
+    return gains.map((gain) => Math.round(gain * 100) / 100);
+}
+// What a piece is levelled in: its speech cut at each pause of at least `cutSeconds`, a part
+// shorter than `partSecondsMin` joined to the one before (or after, for the first). These are
+// sentences, and the halves of a long one; the gain only ever changes in such a pause.
+export function speechSpans(durationSeconds, silences) {
+    const edge = 0.02;
+    const lead = silences.find((one) => one.start <= edge);
+    const tail = silences.find((one) => one !== lead && one.end >= durationSeconds - edge);
+    const start = lead?.end ?? 0;
+    const end = tail?.start ?? durationSeconds;
+    if (end <= start)
+        return [];
+    const spans = [];
+    let from = start;
+    for (const silence of silences) {
+        if (silence === lead || silence === tail)
+            continue;
+        if (silence.end - silence.start < sentenceLevel.cutSeconds)
+            continue;
+        if (silence.start <= from || silence.end >= end)
+            continue;
+        spans.push({ start: from, end: silence.start });
+        from = silence.end;
+    }
+    spans.push({ start: from, end });
+    const merged = [];
+    for (const span of spans) {
+        const last = merged.at(-1);
+        if (last !== undefined &&
+            (span.end - span.start < sentenceLevel.partSecondsMin ||
+                last.end - last.start < sentenceLevel.partSecondsMin))
+            last.end = span.end;
+        else
+            merged.push({ ...span });
+    }
+    return merged;
+}
+// A piece's gain changes: the first sentence's from the start, each next one's from the middle of
+// the quiet before it. Spans and times are the piece's own.
+export function gainChanges(spans, gains) {
+    const changes = [];
+    let sent = Number.NaN;
+    for (const [index, span] of spans.entries()) {
+        const gain = gains[index] ?? 0;
+        if (Math.abs(gain - sent) < changeDb)
+            continue;
+        const before = spans[index - 1];
+        changes.push({
+            at: before === undefined ? 0 : Math.round(((before.end + span.start) / 2) * 1000) / 1000,
+            gainDb: gain,
+        });
+        sent = gain;
+    }
+    return changes;
+}
+// The piece's readings: decoded to 48 kHz mono and metered as it streams.
+export async function meterFile(run, file) {
+    const meter = new Meter();
+    await new Promise((resolve, reject) => {
+        const executable = !isAbsolute(run.bin) && /[\\/]/.test(run.bin) ? resolvePath(run.bin) : run.bin;
+        const child = spawn(executable, [
+            "-hide_banner",
+            "-nostdin",
+            "-loglevel",
+            "error",
+            "-i",
+            file,
+            "-ac",
+            "1",
+            "-ar",
+            String(meterRate),
+            "-f",
+            "f32le",
+            "pipe:1",
+        ], { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+        let carry = Buffer.alloc(0);
+        let errors = "";
+        child.stdout.on("data", (chunk) => {
+            const bytes = carry.length === 0 ? chunk : Buffer.concat([carry, chunk]);
+            const whole = bytes.length - (bytes.length % 4);
+            const aligned = new Float32Array(whole / 4);
+            new Uint8Array(aligned.buffer).set(bytes.subarray(0, whole));
+            meter.feed(aligned);
+            carry = Buffer.from(bytes.subarray(whole));
+        });
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (text) => {
+            errors = (errors + text).slice(-2000);
+        });
+        const stop = () => child.kill("SIGKILL");
+        run.signal.addEventListener("abort", stop, { once: true });
+        child.on("error", (error) => {
+            run.signal.removeEventListener("abort", stop);
+            reject(new Error(`Slopify could not start ffmpeg to measure the narration (${error.message}). Reinstall Slopify, then Try again.`));
+        });
+        child.on("close", (code) => {
+            run.signal.removeEventListener("abort", stop);
+            if (run.signal.aborted)
+                reject(new Error("the levelling was canceled"));
+            else if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Slopify couldn't measure a narration piece's sentences (ffmpeg said: ${errors.trim().split("\n").at(-1) ?? "nothing"}). Try again; if it happens again, turn off Level each sentence in Edit project → Pauses and volume, then use Download diagnostics in Settings and report it.`));
+        });
+    });
+    return meter.readings();
+}
+// The pieces with each sentence levelled, as WAVs in `directory`, in the order given; a piece
+// none of whose sentences moves is passed on as it is. Returns the files and how many sentences
+// were raised and lowered by more than 1 dB.
+export async function levelSentences(run, files, directory) {
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const measured = [];
+    let offset = 0;
+    for (const file of files) {
+        run.signal.throwIfAborted();
+        const { durationSeconds, silences } = await measurePiece(run, file);
+        const spans = speechSpans(durationSeconds, silences);
+        const { power, peaks } = await meterFile(run, file);
+        const readings = spans.map((span) => {
+            let loudest = 0;
+            const a = Math.max(0, Math.floor(span.start * framesPerSecond));
+            const b = Math.min(peaks.length, Math.ceil(span.end * framesPerSecond));
+            for (let at = a; at < b; at++)
+                loudest = Math.max(loudest, peaks[at] ?? 0);
+            return {
+                at: offset + (span.start + span.end) / 2,
+                loudness: gatedLoudness(power, span.start, span.end),
+                peakDb: 20 * Math.log10(Math.max(loudest, 1e-9)),
+            };
+        });
+        measured.push({ spans, readings });
+        offset += durationSeconds;
+    }
+    const gains = sentenceGains(measured.flatMap((one) => one.readings));
+    const written = [];
+    let next = 0;
+    for (const [index, file] of files.entries()) {
+        run.signal.throwIfAborted();
+        const { spans } = measured[index];
+        const own = gains.slice(next, next + spans.length);
+        next += spans.length;
+        const changes = gainChanges(spans, own);
+        if (changes.every((one) => Math.abs(one.gainDb) < changeDb)) {
+            written.push(file);
+            continue;
+        }
+        const output = join(directory, `sentences-${String(index + 1).padStart(4, "0")}.wav`);
+        const commands = `${output}.gains.txt`;
+        writeFileSync(commands, changes
+            .map((one) => `${one.at.toFixed(3)} volume@sentences 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",
+                    file,
+                    "-af",
+                    `asendcmd=f=${commands.replaceAll("\\", "/").replaceAll(":", "\\\\:")},volume@sentences=volume=${(10 ** ((changes[0]?.at === 0 ? changes[0].gainDb : 0) / 20)).toFixed(5)}:precision=float:eval=frame`,
+                    "-c:a",
+                    "pcm_f32le",
+                    "-f",
+                    "wav",
+                    output,
+                ],
+                signal: run.signal,
+                log: run.log,
+                onProgress: () => { },
+            });
+        }
+        finally {
+            rmSync(commands, { force: true });
+        }
+        written.push(output);
+    }
+    return {
+        files: written,
+        raised: gains.filter((gain) => gain > 1).length,
+        lowered: gains.filter((gain) => gain < -1).length,
+        sentences: gains.length,
+    };
+}

package/dist/slices/play-drafts/convert.js

@@ -296,6 +296,10 @@ export function toAdmissionDraft(input) {
         // Soften breaths and Soften S sounds: only while on, with a narration made here to clean.
         ...(sources.audio === "generate" ? breathsOfForm(form) : {}),
         ...(sources.audio === "generate" ? deEssOfForm(form) : {}),
+        // Level each sentence: only while on, with a narration made here.
+        ...(sources.audio === "generate" && form.levelSentences === true
+            ? { levelSentences: true }
+            : {}),
         edgeSilenceSeconds: measure("edgeSilenceSeconds", sources.audio !== "off", defaultEdgeSilenceSeconds, edgeSilenceSecondsProblem),
     };
     const parsed = runDraftSchema.safeParse(draft);

package/dist/slices/play-drafts/schema.js

@@ -90,6 +90,8 @@ export const playDraftFormSchema = z
     // templates saved before them: off.
     removeBreaths: z.boolean().optional(),
     deEss: z.boolean().optional(),
+    // Level each sentence (`loudness/sentence-level.ts`). Absent on drafts saved before it: off.
+    levelSentences: z.boolean().optional(),
     // Absent on drafts and templates saved before the YouTube description: off, built-in prompt.
     youtubeDescription: z.boolean().optional(),
     showFigures: z.boolean().optional(),

package/dist/slices/project-templates/from-project.js

@@ -238,6 +238,7 @@ export function documentFromProject(deps, revision) {
                 : { paragraphPause: String(config.paragraphPauseSeconds) }),
             ...(config.removeBreaths === true ? { removeBreaths: true } : {}),
             ...(config.deEss === true ? { deEss: true } : {}),
+            ...(config.levelSentences === true ? { levelSentences: true } : {}),
             imagePrompts,
             ...(config.imageScale === undefined ? {} : { imageScale: imageScaleForm(config.imageScale) }),
             ...(config.imageScenes === true ? { imageScenes: true } : {}),

package/dist/slices/rebuild/preview-details.js

@@ -161,6 +161,7 @@ function inputChanges(parent, view) {
     add("Pause between paragraphs (seconds)", before.paragraphPauseSeconds ?? 0, after.paragraphPauseSeconds ?? 0);
     add("Soften breaths", before.removeBreaths === true ? "On" : "Off", after.removeBreaths === true ? "On" : "Off");
     add("Soften S sounds", before.deEss === true ? "On" : "Off", after.deEss === true ? "On" : "Off");
+    add("Level each sentence", before.levelSentences === true ? "On" : "Off", after.levelSentences === true ? "On" : "Off");
     add("Level the volume", before.loudness === undefined ? "Off" : loudnessSummary(before.loudness), after.loudness === undefined ? "Off" : loudnessSummary(after.loudness));
     add("YouTube description", before.youtubeDescription === true ? "On" : "Off", after.youtubeDescription === true ? "On" : "Off");
     add("Description prompt", before.descriptionPrompt, after.descriptionPrompt);

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

@@ -1,4 +1,6 @@
 import { pieceLufs, pieceTruePeak, truePeakOf, usesLoudness, } from "../loudness/model.js";
+import { sentenceLevel } from "../loudness/sentence-level-model.js";
+import { usesVoices } from "../voices/model.js";
 import { recipe, resourceIdentity, } from "./recipe-model.js";
 // Level the volume (`loudness/model.ts`): beside each narration join, a step that joins the
 // same pieces again, each brought to one loudness first. The plain join stays what it was, and
@@ -10,6 +12,17 @@ export const levelOperation = "level-narration-v1";
 export function levelKey(segment) {
     return `level:${segment}`;
 }
+export const sentencesValue = "sentences-v1";
+// Level each sentence (`loudness/sentence-level.ts`): asked for, with Level the volume on and one
+// voice (a multi-voice run is levelled line by line instead).
+export function sentencesLevelled(config) {
+    return config.levelSentences === true && usesLoudness(config) && !usesVoices(config);
+}
+// Whether a levelled join's values ask for it.
+export function sentencesAsked(values) {
+    return (Array.isArray(values) &&
+        values.slice(3).some((value) => Array.isArray(value) && value[0] === sentencesValue));
+}
 export function levelRecipe(context, join, segment) {
     if (!usesLoudness(context.config) || join.input.kind !== "local")
         return undefined;
@@ -22,6 +35,21 @@ export function levelRecipe(context, join, segment) {
             join.input.operation,
             join.input.values,
             ["piece-level-v1", pieceLufs, pieceTruePeak],
+            // Level each sentence: the body's sentences instead of its loud phrases. Nothing while
+            // it is off, so every levelled join made before it keeps its fingerprint.
+            ...(sentencesLevelled(context.config) && segment === "body"
+                ? [
+                    [
+                        sentencesValue,
+                        sentenceLevel.contextSeconds,
+                        sentenceLevel.raiseDb,
+                        sentenceLevel.lowerDb,
+                        sentenceLevel.peakCeilingDb,
+                        sentenceLevel.cutSeconds,
+                        sentenceLevel.partSecondsMin,
+                    ],
+                ]
+                : []),
         ],
     }, join.dependsOn, { unresolved: join.unresolved });
 }

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

@@ -5,6 +5,7 @@ import { referenceKey, thumbnailVariant } from "../admission/model.js";
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
 import { levelPieces } from "../loudness/level-pieces.js";
+import { levelSentences } from "../loudness/sentence-level.js";
 import { cleanPieces } from "../narration/clean-pieces.js";
 import { joinNarration } from "../narration/concat.js";
 import { applyPauses, planPieces } from "../narration/pauses.js";
@@ -13,7 +14,7 @@ import { outputPath } from "../storage/layout.js";
 import { probeDurationMs, runFfmpeg } from "../video/ffmpeg.js";
 import { turnJoinArgs } from "../voices/join.js";
 import { breathsAsked, deEssAsked } from "./recipe-breaths.js";
-import { levelOperation } from "./recipe-loudness.js";
+import { levelOperation, sentencesAsked } from "./recipe-loudness.js";
 import { executeFigureCard } from "./runtime-figure-card.js";
 import { publishNarrationText } from "./runtime-narration-text.js";
 import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
@@ -129,13 +130,33 @@ async function concatenate(deps, context, piece) {
     const [operation, values] = recipe.input.kind !== "local"
         ? ["", undefined]
         : level
-            ? z.tuple([z.string(), z.unknown(), z.unknown()]).parse(recipe.input.values)
+            ? z
+                .tuple([z.string(), z.unknown(), z.unknown()])
+                .rest(z.unknown())
+                .parse(recipe.input.values)
             : [recipe.input.operation, recipe.input.values];
     const pending = allocateAsset(deps, context.work.projectId, "narration.mp3");
     const piecesDirectory = join(dirname(pending.absolutePath), "levelled");
     try {
         const run = { bin: deps.ffmpeg, log: deps.log, signal: context.signal };
-        const levelled = level ? await levelPieces(run, files, piecesDirectory) : undefined;
+        // Level each sentence: in place of the phrase step, then sentence by sentence, before the
+        // breaths and S sounds are softened (`loudness/sentence-level.ts`).
+        const sentences = level && sentencesAsked(recipe.input.kind === "local" ? recipe.input.values : undefined);
+        const pieceLevelled = level
+            ? await levelPieces(run, files, piecesDirectory, { phrases: !sentences })
+            : undefined;
+        const levelledSentences = pieceLevelled !== undefined && sentences
+            ? await levelSentences(run, pieceLevelled.files, join(piecesDirectory, "sentences"))
+            : undefined;
+        if (levelledSentences !== undefined)
+            deps.log.write("info", "narration.sentences", {
+                projectId: context.work.projectId,
+                stage: "audio",
+                detail: `${String(levelledSentences.sentences)} sentences: ${String(levelledSentences.raised)} raised and ${String(levelledSentences.lowered)} lowered by more than 1 dB`,
+            });
+        const levelled = pieceLevelled === undefined
+            ? undefined
+            : { ...pieceLevelled, files: levelledSentences?.files ?? pieceLevelled.files };
         // Soften breaths, then Soften S sounds: made in what is joined, before the pauses; nothing
         // moves, so the pauses are still planned from the pieces as spoken.
         const cleaned = await cleanPieces(run, levelled?.files ?? files, piecesDirectory, {

package/dist/tutorials/Editing-a-Project.md

@@ -136,6 +136,7 @@ See [Narration Aliases and Glossary](Narration-Aliases-and-Glossary).
 | **Pause between paragraphs (seconds)** | The least quiet at the end of a paragraph, when you want more than between sentences. At 0 paragraphs get the sentence pause. Try 0.8 to 1.2 for a slower read. A speaker's turn gap is set under Speakers instead. | 0; 0 to 2 |
 | **Soften breaths** | Turns the audible in-breaths a voice takes between sentences and after commas down by 12 dB, with soft fades (Inworld's TTS-2 takes a loud one almost every time). A breath with any word sound in it is left alone; words, pauses and captions stay where they were. | Off |
 | **Soften S sounds** | Takes the sharp edge off s and sh sounds with a very light de-esser; the voice keeps its brightness. Works with or without Soften breaths. | Off |
+| **Level each sentence** | Holds every sentence to the sentences in the minute around it, so no line jumps out or drops away: a loud one comes down by up to 6 dB, a quiet one up by up to 3 dB, and the volume only changes in the pauses. Runs before Soften breaths and Soften S sounds. Needs Level the volume; one voice only. Pairs well with a Video volume of −2 dB, which gives the final limiter more room. | Off |
 | **Level the volume** | Brings every narration piece to one loudness before they are joined, then sets the video, shorts and audio files to a finished loudness. | On for new runs (Settings → General → **Level the volume for new runs**) |
 | **Video volume** | How loud the video and shorts are, in dB from the recommended level (0 dB is -14 LUFS, what YouTube and Spotify play at). -6 dB is about 50%, +4 dB about 158%. Peaks stay under -1.5 dBTP. | 0 dB; -10 to +4 dB in 0.5 dB steps |
 | **Audio files volume** | How loud the WAV, MP3 and M4B are, in dB from -18 LUFS (what audiobook shops such as ACX ask for). Peaks stay under -3 dBTP. | 0 dB; -10 to +4 dB |
@@ -144,7 +145,7 @@ You can type a volume in dB or as a percentage of the recommended level.
 
 What changing them remakes:
 
-- **Pauses, Soften breaths or Soften S sounds**: the narration is joined again from the pieces it already has and timed again, which remakes what is timed from it: captions, the video and, when on, the YouTube description and the shorts' pick (those two are text calls). No speech is made again.
+- **Pauses, Soften breaths, Soften S sounds or Level each sentence**: the narration is joined again from the pieces it already has and timed again, which remakes what is timed from it: captions, the video and, when on, the YouTube description and the shorts' pick (those two are text calls). No speech is made again.
 - **Level the volume on or off**: the levelled narration is joined again and the exports rendered again. No speech is made again, and word timing, description, shorts' pick and reviews are not redone.
 - **A volume only**: the exports are mastered again, nothing else.