@gentbajko/slopify 3.18.2 → 3.19.0

package/dist/patch-notes/3.19.0.md

@@ -0,0 +1,9 @@
+# Slopify 3.19.0
+
+Released 11 October 2026.
+
+- **Remove breaths.** A new switch beside the pauses between sentences (Play → Video and style, Edit project → Pauses and volume) mutes the loud in-breath some voices take after almost every comma and full stop, Inworld's TTS-2 among them. Words, pauses and captions stay exactly where they were. It is off by default. See `docs/breaths.md`.
+
+## Upgrading from 3.18.2
+
+- Nothing becomes outdated. Turning Remove breaths on for a project joins its narration again from the pieces it already has; no speech is made again.

package/dist/patch-notes/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "id": "3.19.0",
+    "title": "Slopify 3.19.0",
+    "version": "3.19.0",
+    "date": "2026-10-11"
+  },
   {
     "id": "3.18.2",
     "title": "Slopify 3.18.2",

package/dist/slices/admission/schema.js

@@ -185,6 +185,8 @@ export const runDraftSchema = z.object({
     // Pauses between sentences and paragraphs (`narration/pauses-model.ts`); checked by admission.
     sentencePauseSeconds: z.number().optional(),
     paragraphPauseSeconds: z.number().optional(),
+    // Remove breaths (`narration/breaths-model.ts`); absent is off.
+    removeBreaths: z.boolean().optional(),
     // Absent is English (`kernel/ports/languages.ts`).
     language: languageSchema.optional(),
 });

package/dist/slices/narration/breaths-detect.js

@@ -0,0 +1,261 @@
+import { setImmediate as nextTurn } from "node:timers/promises";
+// The breath detector behind Remove breaths (`breaths-model.ts` says why). It reads 16-bit mono
+// PCM at 48 kHz in 20 ms frames, 10 ms apart, and gives each frame three numbers: its level
+// (RMS in dB), how often it crosses zero (noise crosses often, a voiced vowel seldom) and its
+// spectral centroid (where its sound sits: an in-breath low, an "s" or "f" high).
+// 1. A frame is breath-like when it is noisy (crosses zero in at least 6% of its samples),
+//    between a whisper and speech in level, and centred under 2.8 kHz.
+// 2. A run of breath-like frames 140 ms or longer is a breath. It grows back over the quiet
+//    frames before it until silence, a voiced word's tail or a fricative, and forward over the
+//    quiet after it until silence or the next word's voice.
+// 3. Each breath is muted to -60 dB with 5 ms fades inside its own stretch: a fade outside
+//    it once landed on the next word's first sound.
+// Levels are relative to the voice's own: the median level of its voiced frames. A quieter or
+// louder voice finds the same breaths. The thresholds are the ones of the prototype Gent
+// approved by ear, on a narration whose median voiced frame is -21.03 dB.
+export const breathRate = 48_000;
+const frameLength = 960; // 20 ms
+const hop = 480; // 10 ms
+const referenceSpeech = -21.03;
+const breathCeiling = -22;
+const breathFloor = -55;
+const voicedFloor = -42;
+const silenceFloor = -58;
+const noisyCrossings = 0.06;
+const breathCentroid = 2800;
+const breathFrames = 14; // 140 ms
+// A voiced frame for the reference: under the noisy crossing rate and within 30 dB of the
+// voice's loud frames (the 95th percentile).
+const voicedSpan = 30;
+const mutedGain = 10 ** (-60 / 20);
+const fadeSamples = 240; // 5 ms
+// ceiling: 200 frames (2 s of audio, about 15 ms of work) between yields, so a long piece never
+// holds the server's event loop long enough for the page to notice.
+const framesPerTurn = 200;
+// Where the breaths are in a piece, read once from its PCM in order.
+export async function findBreaths(chunks) {
+    return breathsIn(await featuresOf(chunks));
+}
+// The chunk starting `offset` samples into the piece with the stretches muted; a new array.
+export function muteChunk(chunk, offset, stretches) {
+    const out = Int16Array.from(chunk);
+    const end = offset + chunk.length;
+    for (const stretch of stretches) {
+        if (stretch.end <= offset || stretch.start >= end)
+            continue;
+        const fade = Math.min(fadeSamples, Math.floor((stretch.end - stretch.start) / 2));
+        const from = Math.max(stretch.start, offset);
+        const to = Math.min(stretch.end, end);
+        for (let at = from; at < to; at += 1) {
+            const local = at - offset;
+            out[local] = Math.round((chunk[local] ?? 0) * gainAt(stretch, fade, at));
+        }
+    }
+    return out;
+}
+function gainAt(stretch, fade, at) {
+    const into = at - stretch.start;
+    if (into < fade)
+        return fade === 1 ? 1 : 1 + ((mutedGain - 1) * into) / (fade - 1);
+    const out = at - (stretch.end - fade);
+    if (out >= 0)
+        return fade === 1 ? 1 : mutedGain + ((1 - mutedGain) * out) / (fade - 1);
+    return mutedGain;
+}
+async function featuresOf(chunks) {
+    let capacity = 4096;
+    let db = new Float32Array(capacity);
+    let crossings = new Float32Array(capacity);
+    let centroid = new Float32Array(capacity);
+    let count = 0;
+    const work = fftWorkspace();
+    const frame = new Float64Array(frameLength);
+    let carry = new Int16Array(0);
+    let base = 0;
+    for await (const chunk of chunks) {
+        const pending = new Int16Array(carry.length + chunk.length);
+        pending.set(carry);
+        pending.set(chunk, carry.length);
+        // A frame is read once a sample after it has arrived, so the last frame of the piece is
+        // the last that ends before its final sample, as the prototype read it.
+        while (count * hop + frameLength < base + pending.length) {
+            if (count === capacity) {
+                capacity *= 2;
+                db = grown(db, capacity);
+                crossings = grown(crossings, capacity);
+                centroid = grown(centroid, capacity);
+            }
+            const start = count * hop - base;
+            for (let at = 0; at < frameLength; at += 1)
+                frame[at] = (pending[start + at] ?? 0) / 32768;
+            db[count] = levelOf(frame);
+            crossings[count] = crossingsOf(frame);
+            centroid[count] = powerSpectrumCentroid(frame, work);
+            count += 1;
+            if (count % framesPerTurn === 0)
+                await nextTurn();
+        }
+        const keep = count * hop - base;
+        carry = pending.slice(keep);
+        base += keep;
+    }
+    return { count, db, crossings, centroid };
+}
+function grown(values, capacity) {
+    const next = new Float32Array(capacity);
+    next.set(values);
+    return next;
+}
+function breathsIn(features) {
+    const speech = speechLevel(features);
+    if (speech === undefined)
+        return [];
+    const level = (prototype) => prototype - referenceSpeech + speech;
+    const ceiling = level(breathCeiling);
+    const floor = level(breathFloor);
+    const voicedAbove = level(voicedFloor);
+    const silentBelow = level(silenceFloor);
+    const { count, db, crossings, centroid } = features;
+    const at = (values, index) => values[index] ?? 0;
+    const voiced = (index) => at(db, index) > voicedAbove && at(crossings, index) < noisyCrossings;
+    const hit = (index) => at(crossings, index) >= noisyCrossings &&
+        at(db, index) > floor &&
+        at(db, index) < ceiling &&
+        at(centroid, index) < breathCentroid;
+    const stretches = [];
+    let i = 0;
+    while (i < count) {
+        if (!hit(i)) {
+            i += 1;
+            continue;
+        }
+        let j = i;
+        while (j < count && hit(j))
+            j += 1;
+        if (j - i >= breathFrames) {
+            let a = i;
+            while (a > 0 &&
+                at(db, a - 1) > silentBelow &&
+                !voiced(a - 1) &&
+                at(centroid, a - 1) < breathCentroid)
+                a -= 1;
+            let b = j;
+            while (b < count && at(db, b) > silentBelow && !voiced(b))
+                b += 1;
+            stretches.push({ start: a * hop, end: (b - 1) * hop + frameLength });
+        }
+        i = j;
+    }
+    return stretches;
+}
+// The voice's own level: the median of its voiced frames, those under the noisy crossing rate
+// within 30 dB of its loud frames. Undefined for a piece without a voiced frame.
+function speechLevel(features) {
+    if (features.count === 0)
+        return undefined;
+    const levels = features.db.slice(0, features.count).sort();
+    const loud = percentile(levels, 0.95);
+    const voiced = [];
+    for (let index = 0; index < features.count; index += 1) {
+        const db = features.db[index] ?? 0;
+        if ((features.crossings[index] ?? 1) < noisyCrossings && db > loud - voicedSpan)
+            voiced.push(db);
+    }
+    if (voiced.length === 0)
+        return undefined;
+    return percentile(Float32Array.from(voiced).sort(), 0.5);
+}
+// numpy's default: linear between the two nearest ranks of sorted values.
+function percentile(sorted, share) {
+    const position = share * (sorted.length - 1);
+    const below = Math.floor(position);
+    const low = sorted[below] ?? 0;
+    const high = sorted[Math.min(sorted.length - 1, below + 1)] ?? low;
+    return low + (high - low) * (position - below);
+}
+function levelOf(frame) {
+    let sum = 0;
+    for (const value of frame)
+        sum += value * value;
+    return 20 * Math.log10(Math.sqrt(sum / frame.length) + 1e-9);
+}
+// The share of neighbouring samples whose sign differs, a zero counting half.
+function crossingsOf(frame) {
+    let sum = 0;
+    let previous = Math.sign(frame[0] ?? 0);
+    for (let at = 1; at < frame.length; at += 1) {
+        const sign = Math.sign(frame[at] ?? 0);
+        sum += Math.abs(sign - previous);
+        previous = sign;
+    }
+    return sum / 2 / (frame.length - 1);
+}
+function fftWorkspace() {
+    const angle = (index) => (2 * Math.PI * index) / frameLength;
+    return {
+        re: new Float64Array(frameLength),
+        im: new Float64Array(frameLength),
+        outRe: new Float64Array(frameLength),
+        outIm: new Float64Array(frameLength),
+        tempRe: new Float64Array(8),
+        tempIm: new Float64Array(8),
+        cos: Float64Array.from({ length: frameLength }, (_one, index) => Math.cos(angle(index))),
+        sin: Float64Array.from({ length: frameLength }, (_one, index) => Math.sin(angle(index))),
+        // numpy's hanning: symmetric, zero at both ends.
+        hann: Float64Array.from({ length: frameLength }, (_one, index) => 0.5 - 0.5 * Math.cos((2 * Math.PI * index) / (frameLength - 1))),
+    };
+}
+// Where a 20 ms frame's sound sits, in Hz: the power-weighted mean frequency of its
+// Hann-windowed spectrum, 0 for a silent frame.
+export function powerSpectrumCentroid(frame, work = fftWorkspace()) {
+    for (let at = 0; at < frameLength; at += 1) {
+        work.re[at] = (frame[at] ?? 0) * (work.hann[at] ?? 0);
+        work.im[at] = 0;
+    }
+    transform(work, frameLength, 0, 1, 0);
+    let weighted = 0;
+    let total = 0;
+    for (let bin = 0; bin <= frameLength / 2; bin += 1) {
+        const power = (work.outRe[bin] ?? 0) ** 2 + (work.outIm[bin] ?? 0) ** 2;
+        weighted += ((bin * breathRate) / frameLength) * power;
+        total += power;
+    }
+    return total > 0 ? weighted / total : 0;
+}
+// A mixed-radix decimation-in-time FFT (960 = 2^6 * 3 * 5) from `work.re/im` into
+// `work.outRe/outIm`: the n-point transform of the samples at `from`, `from + stride`, … is
+// written at `to`.
+function transform(work, n, from, stride, to) {
+    if (n === 1) {
+        work.outRe[to] = work.re[from] ?? 0;
+        work.outIm[to] = work.im[from] ?? 0;
+        return;
+    }
+    const radix = n % 2 === 0 ? 2 : n % 3 === 0 ? 3 : n % 5 === 0 ? 5 : n;
+    const m = n / radix;
+    for (let r = 0; r < radix; r += 1)
+        transform(work, m, from + r * stride, stride * radix, to + r * m);
+    const step = frameLength / n;
+    for (let k = 0; k < m; k += 1) {
+        for (let q = 0; q < radix; q += 1) {
+            let sumRe = 0;
+            let sumIm = 0;
+            for (let r = 0; r < radix; r += 1) {
+                const twiddle = ((r * (k + q * m)) % n) * step;
+                const c = work.cos[twiddle] ?? 1;
+                const s = work.sin[twiddle] ?? 0;
+                const yRe = work.outRe[to + r * m + k] ?? 0;
+                const yIm = work.outIm[to + r * m + k] ?? 0;
+                // y · e^(-iθ)
+                sumRe += yRe * c + yIm * s;
+                sumIm += yIm * c - yRe * s;
+            }
+            work.tempRe[q] = sumRe;
+            work.tempIm[q] = sumIm;
+        }
+        for (let q = 0; q < radix; q += 1) {
+            work.outRe[to + q * m + k] = work.tempRe[q] ?? 0;
+            work.outIm[to + q * m + k] = work.tempIm[q] ?? 0;
+        }
+    }
+}

package/dist/slices/narration/breaths-fixture.js

@@ -0,0 +1,52 @@
+import { breathRate } from "./breaths-detect.js";
+// Synthetic narration at 48 kHz: a voiced tone stands for a word, band-limited noise for a
+// breath (low band, under 2.8 kHz) or a fricative (high band, an "s" or "f").
+export const ms = (value) => Math.round((value / 1000) * breathRate);
+export function seeded(seed) {
+    let state = seed >>> 0;
+    return () => {
+        state = (state * 1664525 + 1013904223) >>> 0;
+        return state / 2 ** 32;
+    };
+}
+export function tone(length, rms) {
+    const out = new Float64Array(length);
+    const amplitude = rms * Math.SQRT2;
+    for (let at = 0; at < length; at += 1)
+        out[at] = amplitude * Math.sin((2 * Math.PI * 180 * at) / breathRate);
+    return out;
+}
+// Noise as many random-phase sines spread evenly over a band, scaled to the RMS asked for.
+export function noise(length, low, high, rms, seed) {
+    const random = seeded(seed);
+    const count = 48;
+    const out = new Float64Array(length);
+    for (let one = 0; one < count; one += 1) {
+        const frequency = low + ((high - low) * (one + random())) / count;
+        const phase = 2 * Math.PI * random();
+        for (let at = 0; at < length; at += 1)
+            out[at] = (out[at] ?? 0) + Math.sin((2 * Math.PI * frequency * at) / breathRate + phase);
+    }
+    const power = out.reduce((sum, value) => sum + value * value, 0) / length;
+    const scale = rms / Math.sqrt(power);
+    return out.map((value) => value * scale);
+}
+export function silence(length) {
+    return new Float64Array(length);
+}
+export function pcm(parts, gain = 1) {
+    const length = parts.reduce((sum, part) => sum + part.length, 0);
+    const out = new Int16Array(length);
+    let at = 0;
+    for (const part of parts)
+        for (const value of part) {
+            out[at] = Math.max(-32768, Math.min(32767, Math.round(value * gain * 32767)));
+            at += 1;
+        }
+    return out;
+}
+// The whole clip in chunks of an odd size, so frames straddle the chunk edges.
+export function* chunked(samples, size = 7777) {
+    for (let at = 0; at < samples.length; at += size)
+        yield samples.subarray(at, at + size);
+}

package/dist/slices/narration/breaths-model.js

@@ -0,0 +1,17 @@
+// Remove breaths. Some voices (Inworld's TTS-2 among them) take a loud, audible in-breath after
+// almost every comma and full stop: about a third of a second, only 12 to 15 dB under the
+// words. Switched on, the join finds those breaths in every narration piece and mutes them
+// (`breaths.ts`, `breaths-detect.ts`): nothing is cut out, so every word and its timing stay
+// exactly where they were, and the pauses between sentences (`pauses-model.ts`) are planned
+// from the pieces as spoken just the same. It happens in the join, so the plain narration the
+// word timing reads and the levelled one the video plays lose the same breaths.
+//
+// Browser-safe: Play and Edit project read it. Off is absent from the config, which is what
+// every project saved before it was, and the joins keep their fingerprints then.
+export function breathsOn(config) {
+    return config.removeBreaths === true;
+}
+// Play's switch as a run's config holds it: only on is written.
+export function breathsOfForm(form) {
+    return form.removeBreaths === true ? { removeBreaths: true } : {};
+}

package/dist/slices/narration/breaths.js

@@ -0,0 +1,132 @@
+import { mkdirSync, rmSync } from "node:fs";
+import { open, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { runFfmpeg } from "../video/ffmpeg.js";
+import { breathRate, findBreaths, muteChunk } from "./breaths-detect.js";
+// Remove breaths, made in the join (`breaths-model.ts` says why there). Each narration piece is
+// decoded by ffmpeg to 16-bit mono PCM at 48 kHz in a file beside it, read once to find its
+// breaths (`breaths-detect.ts`) and once more to write it again as a WAV with them muted. Both
+// reads go in chunks, so a long piece never sits in memory whole, and the detector yields to
+// the event loop as it goes, so the server stays responsive while it works. A piece without a
+// breath is written again all the same: the join takes every piece in the one format.
+// ceiling: one second of audio per read.
+const chunkSamples = breathRate;
+export async function removeBreaths(run, files, directory) {
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const written = [];
+    let removed = 0;
+    for (const [index, file] of files.entries()) {
+        run.signal.throwIfAborted();
+        const name = `breaths-${String(index + 1).padStart(4, "0")}`;
+        const raw = join(directory, `${name}.pcm`);
+        const output = join(directory, `${name}.wav`);
+        try {
+            await runFfmpeg({
+                bin: run.bin,
+                args: decodeArgs(file, raw),
+                signal: run.signal,
+                log: run.log,
+                onProgress: () => { },
+            });
+            const stretches = await findBreaths(pcmChunks(raw));
+            run.signal.throwIfAborted();
+            await writeMuted(raw, output, stretches);
+            removed += stretches.length;
+        }
+        catch (error) {
+            if (run.signal.aborted)
+                throw error;
+            throw new Error(`Remove breaths could not process narration piece ${String(index + 1)} (${error instanceof Error ? error.message : String(error)}), so the narration can't be joined together. Use Try again; if it fails again, turn off Remove breaths in Edit project → Pauses and volume and use Save changes, then use Download diagnostics in Settings and report it.`, { cause: error });
+        }
+        finally {
+            rmSync(raw, { force: true });
+        }
+        written.push(output);
+    }
+    return { files: written, removed };
+}
+export function decodeArgs(input, output) {
+    return [
+        "-hide_banner",
+        "-nostdin",
+        "-loglevel",
+        "error",
+        "-nostats",
+        "-y",
+        "-i",
+        input,
+        "-map",
+        "0:a:0",
+        "-ac",
+        "1",
+        "-ar",
+        String(breathRate),
+        "-c:a",
+        "pcm_s16le",
+        "-f",
+        "s16le",
+        output,
+    ];
+}
+async function* pcmChunks(path) {
+    const handle = await open(path, "r");
+    try {
+        for (;;) {
+            const chunk = await readChunk(handle);
+            if (chunk === undefined)
+                return;
+            yield chunk;
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function readChunk(handle) {
+    const buffer = Buffer.alloc(chunkSamples * 2);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+    const samples = Math.floor(bytesRead / 2);
+    if (samples === 0)
+        return undefined;
+    // A copy into its own buffer: Int16Array needs an aligned, even-length view.
+    const out = new Int16Array(samples);
+    for (let at = 0; at < samples; at += 1)
+        out[at] = buffer.readInt16LE(at * 2);
+    return out;
+}
+async function writeMuted(raw, output, stretches) {
+    const size = (await stat(raw)).size;
+    const bytes = size - (size % 2);
+    const target = await open(output, "w", 0o600);
+    try {
+        await target.write(wavHeader(bytes));
+        let offset = 0;
+        for await (const chunk of pcmChunks(raw)) {
+            const muted = muteChunk(chunk, offset, stretches);
+            // Typed arrays are little-endian on every platform Slopify ships for, as WAV is.
+            await target.write(Buffer.from(muted.buffer, muted.byteOffset, muted.byteLength));
+            offset += chunk.length;
+        }
+    }
+    finally {
+        await target.close();
+    }
+}
+// A canonical 44-byte header: PCM, mono, 16-bit, 48 kHz.
+export function wavHeader(dataBytes) {
+    const header = Buffer.alloc(44);
+    header.write("RIFF", 0, "ascii");
+    header.writeUInt32LE(36 + dataBytes, 4);
+    header.write("WAVE", 8, "ascii");
+    header.write("fmt ", 12, "ascii");
+    header.writeUInt32LE(16, 16);
+    header.writeUInt16LE(1, 20);
+    header.writeUInt16LE(1, 22);
+    header.writeUInt32LE(breathRate, 24);
+    header.writeUInt32LE(breathRate * 2, 28);
+    header.writeUInt16LE(2, 32);
+    header.writeUInt16LE(16, 34);
+    header.write("data", 36, "ascii");
+    header.writeUInt32LE(dataBytes, 40);
+    return header;
+}

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

@@ -4,6 +4,7 @@ import { runDraftSchema } from "../admission/schema.js";
 import { draftDocumentThemeOf } from "../document/model.js";
 import { defaultExpectedWords, everyMinutesMax, everyMinutesMin, expectedWordsMax, imagesPerHourMax, imagesPerHourMin, perHourFromMinutes, wordCount, } from "../images/scale.js";
 import { defaultLoudness, loudnessOfForm, } from "../loudness/model.js";
+import { breathsOfForm } from "../narration/breaths-model.js";
 import { pausesOfForm } from "../narration/pauses-model.js";
 import { reviewSettingsFromForm } from "../reviews/model.js";
 import { stageMakesItems } from "../reviews/rules.js";
@@ -292,6 +293,8 @@ export function toAdmissionDraft(input) {
         ...pickLoudness(sources.audio, loudnessOfForm(form.loudness, input.loudness ?? defaultLoudness)),
         // Pauses between sentences: the default for a new run, with a narration to pace.
         ...(sources.audio === "generate" ? pausesOfForm(form) : {}),
+        // Remove breaths: only while on, with a narration made here to clean.
+        ...(sources.audio === "generate" ? breathsOfForm(form) : {}),
         edgeSilenceSeconds: measure("edgeSilenceSeconds", sources.audio !== "off", defaultEdgeSilenceSeconds, edgeSilenceSecondsProblem),
     };
     const parsed = runDraftSchema.safeParse(draft);

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

@@ -86,6 +86,9 @@ export const playDraftFormSchema = z
     // paragraph minimum (`narration/pauses-model.ts`).
     sentencePause: text.optional(),
     paragraphPause: text.optional(),
+    // Remove breaths (`narration/breaths-model.ts`). Absent on drafts and templates saved
+    // before it: off.
+    removeBreaths: 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

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

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

@@ -159,6 +159,7 @@ function inputChanges(parent, view) {
     add("Show tables and figures on screen", before.showFigures === true ? "On" : "Off", after.showFigures === true ? "On" : "Off");
     add("Pause between sentences (seconds)", before.sentencePauseSeconds ?? 0, after.sentencePauseSeconds ?? 0);
     add("Pause between paragraphs (seconds)", before.paragraphPauseSeconds ?? 0, after.paragraphPauseSeconds ?? 0);
+    add("Remove breaths", before.removeBreaths === true ? "On" : "Off", after.removeBreaths === 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-audio.js

@@ -5,6 +5,7 @@ import { concatArgs } from "../narration/concat.js";
 import { normalizeNarrationText } from "../narration/plan.js";
 import { pronunciationChunks } from "../narration/pronunciation-chunks.js";
 import { aliasFutureValues, narrationParts, pronunciationFutureValues, voiceValues, } from "./recipe-audio-parts.js";
+import { breathValues } from "./recipe-breaths.js";
 import { levelRecipe } from "./recipe-loudness.js";
 import { recipe, resourceIdentity, selectedReference, } from "./recipe-model.js";
 import { narrationFileRecipe } from "./recipe-narration-text.js";
@@ -142,6 +143,7 @@ export function audioRecipes(context, text) {
                     : (config.chunking ?? defaultChunking).mode === "paragraph"
                         ? "paragraph"
                         : "sentence")),
+                ...breathValues(config),
             ],
         }, parts.map((part) => part.key), { unresolved: text.narrationText !== null && groups.length === 0 });
         recipes.push(body);
@@ -199,6 +201,7 @@ export function audioRecipes(context, text) {
                 parts.map((part) => resourceIdentity(context, part)),
                 parts.length === 1 ? "copy-single-file" : concatArgs("$parts", "$output"),
                 ...pauseValues(config, parts.map((_part, at) => (at === parts.length - 1 ? "end" : "sentence"))),
+                ...breathValues(config),
             ],
         }, parts.map((part) => part.key));
         recipes.push(audio);

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

@@ -0,0 +1,16 @@
+import { breathsOn } from "../narration/breaths-model.js";
+// Remove breaths (`narration/breaths-model.ts`) is made in the narration joins, so a join carries
+// it in its values, after the pauses when they are set. Nothing at all while it is off, so
+// every join made before it keeps its fingerprint. The levelled join copies these values, so it
+// removes the same breaths.
+export const breathsValue = "breaths-v1";
+export function breathValues(config) {
+    return breathsOn(config) ? [[breathsValue]] : [];
+}
+// Whether a join's values ask for it: any value after the join's own two.
+export function breathsAsked(values) {
+    return (Array.isArray(values) &&
+        values
+            .slice(2)
+            .some((value) => Array.isArray(value) && value.length === 1 && value[0] === breathsValue));
+}

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

@@ -9,6 +9,7 @@ import { prepareRequests } from "../narration/steering.js";
 import { groupTurns } from "../voices/grouping.js";
 import { speakerPace } from "../voices/model.js";
 import { parseScript } from "../voices/script.js";
+import { breathValues } from "./recipe-breaths.js";
 import { describedText, describeFuture, describing } from "./recipe-describe.js";
 import { recipe, resourceIdentity, } from "./recipe-model.js";
 import { pauseValues } from "./recipe-pauses.js";
@@ -125,6 +126,7 @@ export function voiceBodyRecipes(context, voices, script, glossary) {
             layout,
             // Pauses between sentences inside a turn; the turn gap stays the layout's.
             ...pauseValues(context.config, layout.map(([, gap], at) => at === layout.length - 1 ? "end" : gap > 0 || turnEnds.has(at) ? "turn" : "sentence")),
+            ...breathValues(context.config),
         ],
     }, parts.map((part) => part.key), { unresolved: parsed?.ok !== true || pending });
     return {

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

@@ -5,12 +5,14 @@ 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 { removeBreaths } from "../narration/breaths.js";
 import { joinNarration } from "../narration/concat.js";
 import { applyPauses, planPieces } from "../narration/pauses.js";
 import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
 import { outputPath } from "../storage/layout.js";
 import { probeDurationMs, runFfmpeg } from "../video/ffmpeg.js";
 import { turnJoinArgs } from "../voices/join.js";
+import { breathsAsked } from "./recipe-breaths.js";
 import { levelOperation } from "./recipe-loudness.js";
 import { executeFigureCard } from "./runtime-figure-card.js";
 import { publishNarrationText } from "./runtime-narration-text.js";
@@ -134,16 +136,27 @@ async function concatenate(deps, context, piece) {
     try {
         const run = { bin: deps.ffmpeg, log: deps.log, signal: context.signal };
         const levelled = level ? await levelPieces(run, files, piecesDirectory) : undefined;
+        // Remove breaths: muted in what is joined, before the pauses; nothing moves, so the pauses
+        // are still planned from the pieces as spoken.
+        const breathless = breathsAsked(values)
+            ? await removeBreaths(run, levelled?.files ?? files, join(piecesDirectory, "breaths"))
+            : undefined;
+        if (breathless !== undefined)
+            deps.log.write("info", "narration.breaths", {
+                projectId: context.work.projectId,
+                stage: "audio",
+                detail: `${String(breathless.removed)} breaths muted in ${String(files.length)} pieces`,
+            });
         // Pauses between sentences: planned from the pieces as spoken, made in what is joined.
         const pauses = pausesIn(values);
         const paced = pauses === undefined
             ? undefined
-            : await applyPauses(run, levelled?.files ?? files, paceScaled(await planPieces(run, files.map((file, at) => ({
+            : await applyPauses(run, breathless?.files ?? levelled?.files ?? files, paceScaled(await planPieces(run, files.map((file, at) => ({
                 file,
                 text: pieceText(plan.recipes.find((one) => one.key === recipe.dependsOn[at])),
                 next: pauses.next[at] ?? "end",
             })), pauses.settings), operation === "concat-turns-v1" ? values : undefined), join(piecesDirectory, "paced"));
-        const joined = paced?.files ?? levelled?.files ?? files;
+        const joined = paced?.files ?? breathless?.files ?? levelled?.files ?? files;
         const durationMs = operation === "concat-turns-v1"
             ? await joinTurns(run, joined, values, pending.absolutePath)
             : await joinNarration({ bin: deps.ffmpeg, log: deps.log }, {
@@ -151,7 +164,7 @@ async function concatenate(deps, context, piece) {
                 output: pending.absolutePath,
                 listPath: join(dirname(pending.absolutePath), "parts.txt"),
                 signal: context.signal,
-                reencode: level || paced !== undefined,
+                reencode: level || paced !== undefined || breathless !== undefined,
             });
         rmSync(piecesDirectory, { recursive: true, force: true });
         context.signal.throwIfAborted();