@gentbajko/slopify 3.19.0 → 3.21.0

package/SUBTITLES.md

@@ -3,7 +3,7 @@
 1. In Play, enable narration or provide matching English audio and article text.
 2. In Subtitles, choose **Subtitle files (.srt + .vtt)** or **Burn into video + files**.
 3. For burned captions, select a bundled or system font, or upload a `.ttf` or `.otf` file (up to 32 MiB). Choose a size from 16 to 120 and a position: top, upper-middle, center, lower-middle or bottom. The side preview shows the selected font, size and position in a 16:9 or 9:16 frame.
-4. Start the run. Slopify times the article against the actual narration on your computer. The first use downloads an approximately 95 MB English speech model; later runs work offline with the cached model. Allow roughly 1 GB of available memory during alignment. No extra API key, Python, or compiler is needed.
+4. Start the run. Slopify times the article against the actual narration on your computer. The first use downloads the English speech model chosen in Settings → Production defaults → **Subtitle timing model** (378 MB unless changed); later runs work offline with the cached model. Allow roughly 1.2 GB of available memory during alignment (0.7 GB with Smallest). No extra API key, Python, or compiler is needed.
 5. Download SRT/VTT beside the final export. Files mode adds an optional native caption track to the in-app video preview. Burned captions remain visible in the downloaded MP4.
 
 For a completed project, open its final Video or Audio export section, set subtitles, and click **Save subtitles**. This rebuilds only the local export from saved narration and images. Changing font, size or position reuses word timing when the audio and spoken text are unchanged. A paused run saves these choices until Resume; pause an active run before editing. Failed alignment or rendering keeps the previous finished export.
@@ -18,6 +18,14 @@ Fonts are copied into the completed project's caption assets, so an existing exp
 
 Speech inference uses MIT-licensed `onnxruntime-node@1.30.0` (native CPU) in a separate process, with `min(8, CPUs − 1)` threads; set `SLOPIFY_SUBTITLE_THREADS` to override. The npm package bundles CPU builds for Linux x64/arm64, Windows x64/arm64 and Apple silicon macOS (about 220 MB unpacked); Intel Macs have no build, so subtitle timing falls back to the slower single-threaded `onnxruntime-web` there. Its postinstall script only fetches optional CUDA files on Linux x64 and is not needed (the Docker image installs with `--ignore-scripts`); model weights are downloaded lazily into `<data-dir>/models/english-subtitles/`.
 
-Model: [Xenova/wav2vec2-base-960h](https://huggingface.co/Xenova/wav2vec2-base-960h/tree/a19f851b3d42865797e410752b4c570c871e4825), an ONNX conversion of [facebook/wav2vec2-base-960h](https://huggingface.co/facebook/wav2vec2-base-960h), licensed Apache-2.0. Pinned revision: `a19f851b3d42865797e410752b4c570c871e4825`. The quantized model is 95,286,046 bytes, SHA256 `cd5040c147381580ed73258143dd8e0c28e800a09e74ee42ee2b3e8cb4d760a3`; every cached/downloaded model is verified before use.
+Model: [Xenova/wav2vec2-base-960h](https://huggingface.co/Xenova/wav2vec2-base-960h/tree/a19f851b3d42865797e410752b4c570c871e4825), an ONNX conversion of [facebook/wav2vec2-base-960h](https://huggingface.co/facebook/wav2vec2-base-960h), licensed Apache-2.0. Pinned revision: `a19f851b3d42865797e410752b4c570c871e4825`. Three precisions of that revision can be chosen per computer, each verified before use and kept under its own file name so they can sit side by side:
+
+| Setting | File | Bytes | SHA256 |
+|---|---|---|---|
+| Most accurate (default) | `onnx/model.onnx` (fp32) | 377,887,594 | `e46614273f03ff4b87923a965e417fa72004825522cb007c9c25633b8475490d` |
+| Balanced | `onnx/model_fp16.onnx` | 189,192,204 | `378348ee38b739cc77e77e3fb8502f0f40ed53da0dbf7401b24c25c8fafe03de` |
+| Smallest | `onnx/model_quantized.onnx` (int8) | 95,286,046 | `cd5040c147381580ed73258143dd8e0c28e800a09e74ee42ee2b3e8cb4d760a3` |
+
+On a 2 h 28 min narration fp32 aligned in 2 min 40 s (1.1 GB peak) and fp16 in 3 min 16 s (1.2 GB), both hearing every line; int8 took 5 min 35 s (0.7 GB) and misheard two lines, stopping the run with a false "Subtitles stopped matching the audio".
 
 The bundled Barlow font uses the SIL Open Font License; its license and source record ship in `dist/assets/fonts/`. Uploaded/system font licensing remains with its author.

package/dist/adapters/alignment/cache.js

@@ -5,13 +5,36 @@ import { join } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { setTimeout as delay } from "node:timers/promises";
+import { defaultEnglishSubtitleModel, } from "../../kernel/ports/subtitles.js";
+// Xenova/wav2vec2-base-960h at one pinned revision, which carries the same model at three
+// precisions. Each keeps its own file name so the cache can hold any of them at once; int8
+// keeps the name every install used before the choice existed.
 const revision = "a19f851b3d42865797e410752b4c570c871e4825";
-export const alignmentModel = {
-    filename: "wav2vec2-base-960h-cd5040c1.onnx",
-    url: `https://huggingface.co/Xenova/wav2vec2-base-960h/resolve/${revision}/onnx/model_quantized.onnx`,
-    bytes: 95_286_046,
-    sha256: "cd5040c147381580ed73258143dd8e0c28e800a09e74ee42ee2b3e8cb4d760a3",
+const repo = `https://huggingface.co/Xenova/wav2vec2-base-960h/resolve/${revision}/onnx`;
+export const englishModels = {
+    fp32: {
+        filename: "wav2vec2-base-960h-fp32-e4661427.onnx",
+        url: `${repo}/model.onnx`,
+        bytes: 377_887_594,
+        sha256: "e46614273f03ff4b87923a965e417fa72004825522cb007c9c25633b8475490d",
+        timeoutMs: 1_800_000,
+    },
+    fp16: {
+        filename: "wav2vec2-base-960h-fp16-378348ee.onnx",
+        url: `${repo}/model_fp16.onnx`,
+        bytes: 189_192_204,
+        sha256: "378348ee38b739cc77e77e3fb8502f0f40ed53da0dbf7401b24c25c8fafe03de",
+        timeoutMs: 1_200_000,
+    },
+    int8: {
+        filename: "wav2vec2-base-960h-cd5040c1.onnx",
+        url: `${repo}/model_quantized.onnx`,
+        bytes: 95_286_046,
+        sha256: "cd5040c147381580ed73258143dd8e0c28e800a09e74ee42ee2b3e8cb4d760a3",
+    },
 };
+// The default English model, and the one the Docker image ships as its seed.
+export const alignmentModel = englishModels[defaultEnglishSubtitleModel];
 export async function prepareModel(input, deps = { model: alignmentModel, fetch: globalThis.fetch }) {
     input.signal.throwIfAborted();
     await mkdir(input.cacheDir, { recursive: true, mode: 0o700 });
@@ -38,7 +61,7 @@ export async function prepareModel(input, deps = { model: alignmentModel, fetch:
             }
         }
     }
-    throw new Error("The free subtitle model download was interrupted after 3 attempts. Check your connection and retry.", { cause: lastFailure });
+    throw new Error(`The free subtitle model download (${megabytes(deps.model.bytes)}) was interrupted after 3 attempts, so the captions could not be timed. Check your internet connection, then Continue the run.${deps.model === alignmentModel || deps.model === englishModels.fp16 ? smaller : ""}`, { cause: lastFailure });
 }
 async function downloadModel(input, deps, target) {
     input.signal.throwIfAborted();
@@ -58,7 +81,7 @@ async function downloadModel(input, deps, target) {
             throw interrupted(error);
         }
         if (!response.ok || response.body === null) {
-            const error = new Error(`The free subtitle model could not be downloaded (HTTP ${response.status}). Check your connection and try again.`);
+            const error = new Error(`The free subtitle model could not be downloaded (HTTP ${response.status}) from Hugging Face, so the captions could not be timed. Check your internet connection, then Continue the run.`);
             let failure = error;
             try {
                 if (response.body !== null)
@@ -91,7 +114,7 @@ async function downloadModel(input, deps, target) {
                         break;
                     current += result.value.length;
                     if (current > deps.model.bytes)
-                        throw new Error("The subtitle model failed download size verification.");
+                        throw new Error("The subtitle model failed download size verification: more arrived than the file Slopify expects, so it was thrown away. Continue the run to download it again.");
                     hash.update(result.value);
                     input.onProgress?.(current, deps.model.bytes);
                     yield result.value;
@@ -112,7 +135,7 @@ async function downloadModel(input, deps, target) {
         });
         input.signal.throwIfAborted();
         if (current !== deps.model.bytes || hash.digest("hex") !== deps.model.sha256)
-            throw new Error("The subtitle model failed download verification. Please try again.");
+            throw new Error("The subtitle model failed download verification: the file that arrived is not the one Slopify expects, so it was thrown away. Continue the run to download it again.");
         // Each caller writes in its own directory. On Windows a completed concurrent download
         // may already own the final filename; reuse it only after the same verification.
         try {
@@ -146,6 +169,10 @@ async function seedModel(input, seed, target) {
         await rm(staging, { recursive: true, force: true });
     }
 }
+const smaller = " To download less, pick a smaller model in Settings → Production defaults → Subtitle timing model.";
+function megabytes(bytes) {
+    return `${String(Math.round(bytes / 1_000_000))} MB`;
+}
 function interrupted(cause) {
     const error = new Error("The subtitle model download was interrupted.", { cause });
     error.name = "SubtitleModelDownloadInterrupted";

package/dist/adapters/alignment/index.js

@@ -1,13 +1,25 @@
 import { mkdir, mkdtemp, readFile, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { languageInfo } from "../../kernel/ports/languages.js";
+import { defaultEnglishSubtitleModel, } from "../../kernel/ports/subtitles.js";
 import { decodeAudio } from "./audio.js";
-import { alignmentModel, prepareModel } from "./cache.js";
+import { englishModels, prepareModel } from "./cache.js";
 import { claimWorker } from "./lock.js";
 import { alignmentSpecFor, multilingualModel } from "./multilingual.js";
 import { runAlignmentWorker } from "./runner.js";
 import { sentenceTiming, speechShape } from "./sentences.js";
-export const alignSubtitles = async (request) => {
+// The model file that times a language: English with the model chosen in Settings, every other
+// word-timed language with the multilingual one.
+export function modelFor(language, english) {
+    return language === undefined || language === "en" ? englishModels[english] : multilingualModel;
+}
+// `chosen` is asked once per alignment, when it starts: an alignment already running keeps the
+// model it opened, and the next one uses whatever Settings says then.
+export function alignSubtitlesWith(chosen) {
+    return (request) => align(request, chosen);
+}
+export const alignSubtitles = alignSubtitlesWith(() => defaultEnglishSubtitleModel);
+async function align(request, chosen) {
     request.signal.throwIfAborted();
     if (languageInfo(request.language).timing === "sentences")
         return timeSentences(request);
@@ -20,7 +32,7 @@ export const alignSubtitles = async (request) => {
             cacheDir: request.cacheDir,
             signal: request.signal,
             onProgress: (current, total) => request.onProgress?.(Math.round((current / total) * 20), 100),
-        }, { model: english ? alignmentModel : multilingualModel, fetch: globalThis.fetch });
+        }, { model: modelFor(request.language, chosen()), fetch: globalThis.fetch });
         request.onProgress?.(20, 100);
         const working = await mkdtemp(join(request.cacheDir, ".alignment-audio-"));
         try {
@@ -42,7 +54,7 @@ export const alignSubtitles = async (request) => {
     finally {
         await release();
     }
-};
+}
 // No model and no download: the narration's loudness says where it pauses, and the sentences
 // are laid over it (`sentences.ts`).
 async function timeSentences(request) {

package/dist/adapters/alignment/prefetch.js

@@ -1,16 +1,21 @@
 import { mkdir, readFile, rm } from "node:fs/promises";
 import { join } from "node:path";
-import { prepareModel } from "./cache.js";
+import { defaultEnglishSubtitleModel, } from "../../kernel/ports/subtitles.js";
+import { englishModels, prepareModel } from "./cache.js";
 import { claimWorker } from "./lock.js";
-// Readies the subtitle model when the app starts, so the first captioned render never waits
-// on a 95 MB download in the middle of a run. It takes the worker lock, so a render that
-// starts meanwhile waits for this copy rather than fetching a second one.
-export async function prefetchModel(input, deps) {
+// Readies the chosen English subtitle model when the app starts, so the first captioned render
+// never waits on a download of up to 378 MB in the middle of a run. It takes the worker lock,
+// so a render that starts meanwhile waits for this copy rather than fetching a second one.
+export async function prefetchModel(input, deps = {}) {
     await mkdir(input.cacheDir, { recursive: true, mode: 0o700 });
     await clearOwnLock(input.cacheDir);
     const release = await claimWorker(input.cacheDir, input.signal);
     try {
-        return await prepareModel({ cacheDir: input.cacheDir, seed: input.seed, signal: input.signal }, deps);
+        return await prepareModel({ cacheDir: input.cacheDir, seed: input.seed, signal: input.signal }, {
+            ...deps,
+            model: deps.model ?? englishModels[input.choice ?? defaultEnglishSubtitleModel],
+            fetch: deps.fetch ?? globalThis.fetch,
+        });
     }
     finally {
         await release();

package/dist/edge/http/settings.js

@@ -1,6 +1,7 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { englishSubtitleModels } from "../../kernel/ports/subtitles.js";
 import { lastAgentConnection } from "../../slices/agents/connection.js";
 import { recentAgentActions } from "../../slices/agents/repo.js";
 import { notificationUrlMax, notificationUrlProblem, testNotice, webhookBody, } from "../../slices/notifications/address.js";
@@ -42,6 +43,8 @@ const playbackBody = z.object({
     loudness: z
         .object({ enabled: z.boolean(), videoLufs: z.number(), audioFilesLufs: z.number() })
         .optional(),
+    // Absent keeps what is saved, as with loudness.
+    subtitleModel: z.enum(englishSubtitleModels).optional(),
 });
 // The return type is inferred so Hono keeps the route types the SPA's client is
 // generated from; see stagingRoutes.
@@ -53,9 +56,11 @@ export function settingsRoutes(deps) {
         .get("/", (c) => c.json(readSettings(playback)))
         .put("/", zValidator("json", playbackBody, onInvalid), (c) => {
         const body = c.req.valid("json");
+        const saved = readSettings(playback);
         const result = saveSettings(playback, {
             ...body,
-            loudness: body.loudness ?? readSettings(playback).loudness,
+            loudness: body.loudness ?? saved.loudness,
+            subtitleModel: body.subtitleModel ?? saved.subtitleModel,
         });
         if (!result.ok) {
             return problem(c, {

package/dist/edge/mcp/tools-setup.js

@@ -52,13 +52,13 @@ const settings = [
         name: "get_settings",
         route: "GET /api/settings",
         title: "Read production defaults",
-        description: "Settings → Production defaults: silence gap, appearance and loudness.",
+        description: "Settings → Production defaults: silence gap, appearance, loudness and the English subtitle timing model.",
     },
     {
         name: "update_settings",
         route: "PUT /api/settings",
         title: "Save production defaults",
-        description: "Body: {silenceGapSeconds, appearance: system | light | dark, loudness?: {enabled, videoLufs, audioFilesLufs}}.",
+        description: "Body: {silenceGapSeconds, appearance: system | light | dark, loudness?: {enabled, videoLufs, audioFilesLufs}, subtitleModel?: fp32 | fp16 | int8}. subtitleModel is this computer's English caption-timing model (fp32 378 MB most accurate, the default; fp16 189 MB; int8 95 MB, less accurate); it never marks subtitles outdated.",
     },
     {
         name: "get_default_channel_links",

package/dist/kernel/ports/subtitles.js

@@ -1,3 +1,9 @@
+// The English timing model, chosen per computer in Settings → Production defaults: the same
+// pinned wav2vec2 conversion at three precisions. Bigger hears more accurately and, on most
+// computers, also runs faster. The choice never enters a fingerprint: every precision times the
+// same words, so switching must not mark finished subtitles outdated.
+export const englishSubtitleModels = ["fp32", "fp16", "int8"];
+export const defaultEnglishSubtitleModel = "fp32";
 // Where the audio stopped matching its transcript: seconds into the aligned file, the
 // transcript words it expected there and what the model heard instead (either may be empty).
 // The aligner throws it so the caller can say which part of the narration to redo.

package/dist/main.js

@@ -5,7 +5,7 @@ import { fileURLToPath } from "node:url";
 import { serve } from "@hono/node-server";
 import ffmpegStatic from "ffmpeg-static";
 import { buildRegistry } from "./adapter-registry.js";
-import { alignSubtitles } from "./adapters/alignment/index.js";
+import { alignSubtitlesWith } from "./adapters/alignment/index.js";
 import { prefetchModel } from "./adapters/alignment/prefetch.js";
 import { prepareFfmpeg } from "./adapters/ffmpeg.js";
 import { createHostCliClient } from "./adapters/host-cli/index.js";
@@ -72,6 +72,7 @@ import { settleTerminalScheduleRuns } from "./slices/schedules/repo.js";
 import { createScheduleRunner } from "./slices/schedules/scheduler.js";
 import { nodeCliProbe } from "./slices/settings/cli-status.js";
 import { isLocalCliProvider, localCliConcurrency } from "./slices/settings/model.js";
+import { readSettings } from "./slices/settings/playback.js";
 import { providerStatuses } from "./slices/settings/readiness.js";
 import { readSetting } from "./slices/settings/repo.js";
 import { arrangeChanged } from "./slices/storage/arrange.js";
@@ -692,6 +693,7 @@ export async function boot(config, options = {}) {
             ? prefetchModel({
                 cacheDir: subtitleModelDir(paths.dataDir),
                 seed: options.subtitleModelSeed,
+                choice: readSettings({ db, log }).subtitleModel,
                 signal: modelPrefetch.signal,
             }).then(() => log.write("info", "subtitle-model.ready"), (error) => {
                 // Not fatal: the first captioned render tries again and says why on its row.
@@ -762,7 +764,9 @@ export async function boot(config, options = {}) {
         throw error;
     }
 }
-export function wireRunner({ onFinished, audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, catalogue, ffmpeg, alignSubtitles: aligner = alignSubtitles, }) {
+export function wireRunner({ onFinished, audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, catalogue, ffmpeg, 
+// Settings → Production defaults → Subtitle timing model, read as each alignment starts.
+alignSubtitles: aligner = alignSubtitlesWith(() => readSettings({ db, log }).subtitleModel), }) {
     // A stage counts what it did and the queue is flushed after each new event. `record`
     // swallows its own failures, so this can neither fail a stage nor widen what leaves the
     // machine - the payload allow-list is checked inside it.

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/3.21.0.md

@@ -0,0 +1,11 @@
+# Slopify 3.21.0
+
+Released 13 October 2026.
+
+- **Captions are timed with a more accurate speech model by default.** The old 95 MB model sometimes misheard a line of narration, stopped the run with "Subtitles stopped matching the audio" and recorded a good narration chunk again at a cost. The full-precision version of the same model hears those lines correctly. On a 2½-hour narration it was also faster: 2 min 40 s instead of 5 min 35 s.
+- **Choose the subtitle timing model** in Settings → Production defaults: Most accurate (378 MB, the default), Balanced (189 MB) or Smallest (95 MB, less accurate). The choice belongs to this computer and downloads once, the first time captions are timed.
+
+## Upgrading from 3.20.0
+
+- The first video you make downloads the 378 MB model once. To keep the smaller model, choose Smallest in Settings → Production defaults.
+- Nothing becomes outdated: the model choice doesn't change any word timings already made.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.21.0",
+    "title": "Slopify 3.21.0",
+    "version": "3.21.0",
+    "date": "2026-10-12"
+  },
+  {
+    "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 } : {};
+}