@gentbajko/slopify 3.19.0 → 3.20.0

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,10 @@
 [
+  {
+    "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",

package/dist/slices/admission/schema.js

@@ -185,8 +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(),
-    // Remove breaths (`narration/breaths-model.ts`); absent is off.
+    // 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

@@ -1,5 +1,5 @@
 import { setImmediate as nextTurn } from "node:timers/promises";
-// The breath detector behind Remove breaths (`breaths-model.ts` says why). It reads 16-bit mono
+// 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).
@@ -8,15 +8,22 @@ import { setImmediate as nextTurn } from "node:timers/promises";
 // 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.
+// 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 ones of the prototype Gent
-// approved by ear, on a narration whose median voiced frame is -21.03 dB.
+// 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
-const referenceSpeech = -21.03;
+// 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;
@@ -27,23 +34,31 @@ 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
+// 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, read once from its PCM in order.
-export async function findBreaths(chunks) {
+// 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 chunk starting `offset` samples into the piece with the stretches muted; a new array.
-export function muteChunk(chunk, offset, stretches) {
+// 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;
-        const fade = Math.min(fadeSamples, Math.floor((stretch.end - stretch.start) / 2));
+        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) {
@@ -56,17 +71,18 @@ export function muteChunk(chunk, offset, stretches) {
 function gainAt(stretch, fade, at) {
     const into = at - stretch.start;
     if (into < fade)
-        return fade === 1 ? 1 : 1 + ((mutedGain - 1) * into) / (fade - 1);
+        return 1 + ((softGain - 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;
+        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);
@@ -84,6 +100,7 @@ async function featuresOf(chunks) {
                 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)
@@ -91,6 +108,9 @@ async function featuresOf(chunks) {
             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();
@@ -99,7 +119,7 @@ async function featuresOf(chunks) {
         carry = pending.slice(keep);
         base += keep;
     }
-    return { count, db, crossings, centroid };
+    return { count, db, crossings, centroid, blockDb };
 }
 function grown(values, capacity) {
     const next = new Float32Array(capacity);
@@ -109,13 +129,14 @@ function grown(values, capacity) {
 function breathsIn(features) {
     const speech = speechLevel(features);
     if (speech === undefined)
-        return [];
+        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 { count, db, crossings, centroid } = features;
+    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 &&
@@ -123,6 +144,14 @@ function breathsIn(features) {
         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)) {
@@ -142,11 +171,12 @@ function breathsIn(features) {
             let b = j;
             while (b < count && at(db, b) > silentBelow && !voiced(b))
                 b += 1;
-            stretches.push({ start: a * hop, end: (b - 1) * hop + frameLength });
+            const stretch = { start: a * hop, end: (b - 1) * hop + frameLength };
+            (holdsWord(a, b) ? skipped : stretches).push(stretch);
         }
         i = j;
     }
-    return stretches;
+    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.

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

@@ -1,13 +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.
+// 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 it was, and the joins keep their fingerprints then.
+// every project saved before them was, and the joins keep their fingerprints then.
 export function breathsOn(config) {
     return config.removeBreaths === true;
 }
@@ -15,3 +19,12 @@ export function breathsOn(config) {
 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

@@ -2,19 +2,20 @@ 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
+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 muted. Both
+// 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 removeBreaths(run, files, directory) {
+export async function softenBreaths(run, files, directory) {
     mkdirSync(directory, { recursive: true, mode: 0o700 });
     const written = [];
-    let removed = 0;
+    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")}`;
@@ -28,22 +29,23 @@ export async function removeBreaths(run, files, directory) {
                 log: run.log,
                 onProgress: () => { },
             });
-            const stretches = await findBreaths(pcmChunks(raw));
+            const scan = await scanBreaths(pcmChunks(raw));
             run.signal.throwIfAborted();
-            await writeMuted(raw, output, stretches);
-            removed += stretches.length;
+            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(`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 });
+            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, removed };
+    return { files: written, softened, skipped };
 }
 export function decodeArgs(input, output) {
     return [
@@ -94,7 +96,7 @@ async function readChunk(handle) {
         out[at] = buffer.readInt16LE(at * 2);
     return out;
 }
-async function writeMuted(raw, output, stretches) {
+async function writeSoftened(raw, output, stretches) {
     const size = (await stat(raw)).size;
     const bytes = size - (size % 2);
     const target = await open(output, "w", 0o600);
@@ -102,9 +104,9 @@ async function writeMuted(raw, output, stretches) {
         await target.write(wavHeader(bytes));
         let offset = 0;
         for await (const chunk of pcmChunks(raw)) {
-            const muted = muteChunk(chunk, offset, stretches);
+            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(muted.buffer, muted.byteOffset, muted.byteLength));
+            await target.write(Buffer.from(soft.buffer, soft.byteOffset, soft.byteLength));
             offset += chunk.length;
         }
     }

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,7 +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 { 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";
@@ -293,8 +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) : {}),
-        // Remove breaths: only while on, with a narration made here to clean.
+        // 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,9 +86,10 @@ 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.
+    // 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

@@ -237,6 +237,7 @@ export function documentFromProject(deps, revision) {
                 ? {}
                 : { 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 } : {}),

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

@@ -159,7 +159,8 @@ 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("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 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-breaths.js

@@ -1,16 +1,26 @@
-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";
+import { breathsOn, deEsser, deEssOn } from "../narration/breaths-model.js";
+// Soften breaths and Soften S sounds (`narration/breaths-model.ts`) are made in the narration
+// joins, so a join carries them in its values, after the pauses when they are set. Nothing at
+// all while they are off, so every join made before them keeps its fingerprint. The levelled
+// join copies these values, so it softens the same.
+// v2: 3.19.0's v1 muted breaths to silence and could clip word edges; its joins are remade.
+export const breathsValue = "breaths-v2";
+export const deEssValue = "deess-v1";
 export function breathValues(config) {
-    return breathsOn(config) ? [[breathsValue]] : [];
+    return [
+        ...(breathsOn(config) ? [[breathsValue]] : []),
+        ...(deEssOn(config) ? [[deEssValue, deEsser.intensity, deEsser.max, deEsser.frequency]] : []),
+    ];
 }
 // 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));
+    return laterValues(values).some((value) => value.length === 1 && value[0] === breathsValue);
+}
+export function deEssAsked(values) {
+    return laterValues(values).some((value) => value[0] === deEssValue);
+}
+function laterValues(values) {
+    return Array.isArray(values)
+        ? values.slice(2).filter((value) => Array.isArray(value))
+        : [];
 }

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

@@ -5,14 +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 { cleanPieces } from "../narration/clean-pieces.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 { breathsAsked, deEssAsked } from "./recipe-breaths.js";
 import { levelOperation } from "./recipe-loudness.js";
 import { executeFigureCard } from "./runtime-figure-card.js";
 import { publishNarrationText } from "./runtime-narration-text.js";
@@ -136,27 +136,28 @@ 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)
+        // 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, {
+            breaths: breathsAsked(values),
+            deEss: deEssAsked(values),
+        });
+        if (cleaned?.breaths !== undefined)
             deps.log.write("info", "narration.breaths", {
                 projectId: context.work.projectId,
                 stage: "audio",
-                detail: `${String(breathless.removed)} breaths muted in ${String(files.length)} pieces`,
+                detail: `${String(cleaned.breaths.softened)} breaths softened, ${String(cleaned.breaths.skipped)} left alone (a word sound in them) 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, breathless?.files ?? levelled?.files ?? files, paceScaled(await planPieces(run, files.map((file, at) => ({
+            : await applyPauses(run, cleaned?.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 ?? breathless?.files ?? levelled?.files ?? files;
+        const joined = paced?.files ?? cleaned?.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 }, {
@@ -164,7 +165,7 @@ async function concatenate(deps, context, piece) {
                 output: pending.absolutePath,
                 listPath: join(dirname(pending.absolutePath), "parts.txt"),
                 signal: context.signal,
-                reencode: level || paced !== undefined || breathless !== undefined,
+                reencode: level || paced !== undefined || cleaned !== undefined,
             });
         rmSync(piecesDirectory, { recursive: true, force: true });
         context.signal.throwIfAborted();

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

@@ -134,7 +134,8 @@ See [Narration Aliases and Glossary](Narration-Aliases-and-Glossary).
 | --- | --- | --- |
 | **Pause between sentences (seconds)** | The least quiet after each sentence. Adds silence where the pause is shorter; never shortens one or cuts a word. About 0.25 s is brisk, 0.35 to 0.45 natural, 0.5 to 0.8 an audiobook's pace, 0.8 and up sleep content. 0 keeps the voice's own. | 0.4; 0 to 2 in steps of 0.05 |
 | **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 |
-| **Remove breaths** | Mutes the audible in-breaths a voice takes between sentences and after commas (Inworld's TTS-2 takes a loud one almost every time). Only the breath goes quiet: words, pauses and captions stay where they were. | Off |
+| **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 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 |
@@ -143,7 +144,7 @@ You can type a volume in dB or as a percentage of the recommended level.
 
 What changing them remakes:
 
-- **Pauses or Remove breaths**: 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 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.
 - **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.