@gentbajko/slopify 3.18.2 → 3.20.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/3.20.0.md

@@ -0,0 +1,10 @@
+# Slopify 3.20.0
+
+Released 11 October 2026.
+
+- **Remove breaths is now Soften breaths, and it no longer clips words.** 3.19.0 muted every breath it found to silence. On a full-length narration some of those stretches held the edge of a word, which came out clipped ("Highs" as "Hi…s"), and the drops to silence were abrupt. Breaths are now turned down 12 dB with gentle fades, and any stretch with a word sound in it is left alone. See `docs/breaths.md`.
+- **Soften S sounds.** A new switch under Soften breaths (Play → Video and style, Edit project → Pauses and volume) takes the sharp edge off s and sh sounds with a very light de-esser. It is off by default and works with or without Soften breaths.
+
+## Upgrading from 3.19.0
+
+- A project that had Remove breaths on joins its narration again once, from the pieces it already has. No speech is made again. If you used Remove breaths, remake those videos.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.20.0",
+    "title": "Slopify 3.20.0",
+    "version": "3.20.0",
+    "date": "2026-10-11"
+  },
+  {
+    "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,9 @@ 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(),
+    // Soften breaths and Soften S sounds (`narration/breaths-model.ts`); absent is off.
+    removeBreaths: z.boolean().optional(),
+    deEss: z.boolean().optional(),
     // Absent is English (`kernel/ports/languages.ts`).
     language: languageSchema.optional(),
 });

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

@@ -0,0 +1,291 @@
+import { setImmediate as nextTurn } from "node:timers/promises";
+// The breath detector behind Soften 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. A stretch whose loudest 10 ms (RMS over its non-overlapping 10 ms blocks) is above -26 dB
+//    at the calibration (8.74 dB under the voice's level) holds a word sound, and is left alone. 3.19.0 muted those too
+//    and clipped word edges ("Highs" came out "Hi…s").
+// 4. Each other breath is turned down 12 dB, with 45 ms linear fades inside its own stretch (a
+//    fade outside it once landed on the next word's first sound). Silencing it, as 3.19.0 did,
+//    dropped to nothing abruptly; a stretch of 90 ms or less is left as it is.
+// 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 prototype's absolute ones, which
+// Gent approved by ear on the finished video's audio: its median voiced frame (read as
+// `speechLevel` reads it, over the whole 2.5 h video) is -17.26 dB. The levelled pieces the
+// join works on sit about 4 dB lower, and every threshold moves down with them.
+export const breathRate = 48_000;
+const frameLength = 960; // 20 ms
+const hop = 480; // 10 ms
+// Calibrated on the finished video's audio, which is what was approved by ear.
+const referenceSpeech = -17.26;
+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;
+// A stretch with a 10 ms block louder than this (at the calibration) is left alone.
+const wordCeiling = -26;
+const softGain = 10 ** (-12 / 20);
+const fadeSamples = 2160; // 45 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, and which hold a word sound, read once from its PCM in order.
+export async function scanBreaths(chunks) {
+    return breathsIn(await featuresOf(chunks));
+}
+// The breaths to soften in a piece.
+export async function findBreaths(chunks) {
+    return (await scanBreaths(chunks)).stretches;
+}
+// The chunk starting `offset` samples into the piece with the stretches turned down; a new array.
+export function softenChunk(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;
+        if (stretch.end - stretch.start <= 2 * fadeSamples)
+            continue;
+        const fade = fadeSamples;
+        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 1 + ((softGain - 1) * into) / (fade - 1);
+    const out = at - (stretch.end - fade);
+    if (out >= 0)
+        return softGain + ((1 - softGain) * out) / (fade - 1);
+    return softGain;
+}
+async function featuresOf(chunks) {
+    let capacity = 4096;
+    let db = new Float32Array(capacity);
+    let crossings = new Float32Array(capacity);
+    let centroid = new Float32Array(capacity);
+    let blockDb = new Float32Array(capacity + 1);
+    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);
+                blockDb = grown(blockDb, capacity + 1);
+            }
+            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);
+            // A frame's halves are blocks count and count + 1; the next frame reads the second again.
+            blockDb[count] = levelOf(frame.subarray(0, hop));
+            blockDb[count + 1] = levelOf(frame.subarray(hop));
+            count += 1;
+            if (count % framesPerTurn === 0)
+                await nextTurn();
+        }
+        const keep = count * hop - base;
+        carry = pending.slice(keep);
+        base += keep;
+    }
+    return { count, db, crossings, centroid, blockDb };
+}
+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 { stretches: [], skipped: [] };
+    const level = (prototype) => prototype - referenceSpeech + speech;
+    const ceiling = level(breathCeiling);
+    const floor = level(breathFloor);
+    const voicedAbove = level(voicedFloor);
+    const silentBelow = level(silenceFloor);
+    const wordAbove = level(wordCeiling);
+    const { count, db, crossings, centroid, blockDb } = 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 = [];
+    const skipped = [];
+    // Blocks a to b: the stretch from a * hop to (b - 1) * hop + frameLength = (b + 1) * hop.
+    const holdsWord = (a, b) => {
+        for (let block = a; block <= b; block += 1)
+            if (at(blockDb, block) > wordAbove)
+                return true;
+        return false;
+    };
+    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;
+            const stretch = { start: a * hop, end: (b - 1) * hop + frameLength };
+            (holdsWord(a, b) ? skipped : stretches).push(stretch);
+        }
+        i = j;
+    }
+    return { stretches, skipped };
+}
+// 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,30 @@
+// Soften breaths (the config keeps its first name, `removeBreaths`). 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 turns them down 12 dB (`breaths.ts`, `breaths-detect.ts`),
+// leaving alone any stretch with a word sound in it: 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.
+//
+// Soften S sounds (`deEss`): each narration piece in the join goes through ffmpeg's de-esser,
+// set very light (Gent approved these values by ear), after the breaths and before the pauses.
+//
+// Browser-safe: Play and Edit project read it. Off is absent from the config, which is what
+// every project saved before them 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 } : {};
+}
+// ffmpeg's `deesser` options: intensity, most de-essing, frequency (each 0 to 1).
+export const deEsser = { intensity: 0.35, max: 0.5, frequency: 0.5 };
+export function deEssOn(config) {
+    return config.deEss === true;
+}
+// Play's switch as a run's config holds it: only on is written.
+export function deEssOfForm(form) {
+    return form.deEss === true ? { deEss: true } : {};
+}

package/dist/slices/narration/breaths.js

@@ -0,0 +1,134 @@
+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, scanBreaths, softenChunk } from "./breaths-detect.js";
+// Soften 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 turned down. 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 softenBreaths(run, files, directory) {
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const written = [];
+    let softened = 0;
+    let skipped = 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 scan = await scanBreaths(pcmChunks(raw));
+            run.signal.throwIfAborted();
+            await writeSoftened(raw, output, scan.stretches);
+            softened += scan.stretches.length;
+            skipped += scan.skipped.length;
+        }
+        catch (error) {
+            if (run.signal.aborted)
+                throw error;
+            throw new Error(`Soften 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 Soften 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, softened, skipped };
+}
+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 writeSoftened(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 soft = softenChunk(chunk, offset, stretches);
+            // Typed arrays are little-endian on every platform Slopify ships for, as WAV is.
+            await target.write(Buffer.from(soft.buffer, soft.byteOffset, soft.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/narration/clean-pieces.js

@@ -0,0 +1,69 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { runFfmpeg } from "../video/ffmpeg.js";
+import { softenBreaths } from "./breaths.js";
+import { deEsser } from "./breaths-model.js";
+export async function cleanPieces(run, files, directory, cleaning) {
+    if (!cleaning.breaths && !cleaning.deEss)
+        return undefined;
+    const breaths = cleaning.breaths
+        ? await softenBreaths(run, files, join(directory, "breaths"))
+        : undefined;
+    const soft = breaths?.files ?? files;
+    const cleaned = cleaning.deEss ? await deEssPieces(run, soft, join(directory, "deess")) : soft;
+    return {
+        files: cleaned,
+        ...(breaths === undefined
+            ? {}
+            : { breaths: { softened: breaths.softened, skipped: breaths.skipped } }),
+    };
+}
+export async function deEssPieces(run, files, directory) {
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const written = [];
+    for (const [index, file] of files.entries()) {
+        run.signal.throwIfAborted();
+        const output = join(directory, `deess-${String(index + 1).padStart(4, "0")}.wav`);
+        try {
+            await runFfmpeg({
+                bin: run.bin,
+                args: deEssArgs(file, output),
+                signal: run.signal,
+                log: run.log,
+                onProgress: () => { },
+            });
+        }
+        catch (error) {
+            if (run.signal.aborted)
+                throw error;
+            throw new Error(`Soften S sounds 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 Soften S sounds in Edit project → Pauses and volume and use Save changes, then use Download diagnostics in Settings and report it.`, { cause: error });
+        }
+        written.push(output);
+    }
+    return written;
+}
+export function deEssFilter() {
+    return `deesser=i=${String(deEsser.intensity)}:m=${String(deEsser.max)}:f=${String(deEsser.frequency)}`;
+}
+// The piece's own rate and channels, written as 16-bit WAV like the other cleaned pieces.
+export function deEssArgs(input, output) {
+    return [
+        "-hide_banner",
+        "-nostdin",
+        "-loglevel",
+        "error",
+        "-nostats",
+        "-y",
+        "-i",
+        input,
+        "-map",
+        "0:a:0",
+        "-af",
+        deEssFilter(),
+        "-c:a",
+        "pcm_s16le",
+        "-f",
+        "wav",
+        output,
+    ];
+}

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, deEssOfForm } 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,9 @@ 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) : {}),
+        // 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) : {}),
         edgeSilenceSeconds: measure("edgeSilenceSeconds", sources.audio !== "off", defaultEdgeSilenceSeconds, edgeSilenceSecondsProblem),
     };
     const parsed = runDraftSchema.safeParse(draft);

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

@@ -86,6 +86,10 @@ export const playDraftFormSchema = z
     // paragraph minimum (`narration/pauses-model.ts`).
     sentencePause: text.optional(),
     paragraphPause: text.optional(),
+    // Soften breaths and Soften S sounds (`narration/breaths-model.ts`). Absent on drafts and
+    // templates saved before them: off.
+    removeBreaths: z.boolean().optional(),
+    deEss: 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,8 @@ export function documentFromProject(deps, revision) {
             ...(config.paragraphPauseSeconds === undefined
                 ? {}
                 : { paragraphPause: String(config.paragraphPauseSeconds) }),
+            ...(config.removeBreaths === true ? { removeBreaths: true } : {}),
+            ...(config.deEss === true ? { deEss: true } : {}),
             imagePrompts,
             ...(config.imageScale === undefined ? {} : { imageScale: imageScaleForm(config.imageScale) }),
             ...(config.imageScenes === true ? { imageScenes: true } : {}),