fix(core): stop the rack telling a music bed it will thin the voice out

Applying Cut Rumble to a bass line said "Thins the voice out" under the
knob. The rack sits on whatever the author selected — a bed, a sound
effect, a room tone — and every effect, job and profile is offered on all
of them, so copy that names the material describes something the author
does not have.

This is the rule the copy layer's own header already states — describe a
control by what changes in THE SOUND — applied to the words rather than
to the mechanism. The offending strings were written one at a time over
months and each reads fine beside a voiceover; the assumption only shows
when the module lands somewhere else.

Fifteen strings, audited across the whole surface rather than fixing the
one that was reported:

- `highpass` ends (x2): "Thins the voice out" → "Thins it out"
- `compressor`: "Some words are much louder" → "Some parts…"
- `gate`: blurb, reach-for, both ends and the release ends — pauses and
  gaps rather than words and sentences
- `gate` profile "Tightness": "Cuts quiet words too" → "…parts too"
- Jobs: "Too much chest" → "Too much low-end body"; "Words are hard to
  make out" → "It is hard to make out — it sits back"
- Presets: room-gate and boom-tame, which are in the Fix family and so
  are still offered on a bed
- BANDS: Weight, Middle, Presence and Edge — these get taught once and
  reused by every spectral module, so a voice-only word here spreads

The three `voice-*` presets keep their language: they are voice by
definition, and the shelf now hides them on a track that classifies as
music or as an effect.

Encoded the audit as tests over EFFECT_COPY, BANDS, PRESET_PROBLEM, the
jobs and the profiles, since the next entry added would otherwise
reintroduce it. All three fail against the old strings — checked by
reverting them. The voice-preset exception is asserted too, so the rule
cannot pass vacuously on a catalogue that stopped saying "voice" at all.

Deliberately left: `highpass`'s "traffic, footsteps, air conditioning,
hands on the mic" names what rumble IS in the world, matching the BANDS
entry — it teaches the range rather than claiming anything about the
track.

Author: vanceingalls

packages/core/src/audioFxCopy.test.ts

@@ -103,3 +103,74 @@ describe("audioBandAt", () => {
     expect(audioBandAt(Number.NaN)).toBeUndefined();
   });
 });
+
+/**
+ * Copy that assumes the track is a voice.
+ *
+ * The rack sits on whatever the author selected — a music bed, a sound effect,
+ * a room tone. Every effect, every named job and every profile is offered on
+ * all of them, so a control that reads "Thins the voice out" on a synth pad is
+ * describing something the author cannot hear and does not have. It is the same
+ * rule this file's header already states — describe a control by what changes in
+ * THE SOUND — applied to the words rather than to the mechanism.
+ *
+ * The voice presets are the deliberate exception: they are voice by definition,
+ * and the shelf hides them on a track that classifies as music or as an effect,
+ * so "My voice sounds amateur" is only ever read next to a voice.
+ *
+ * This is a lint on the words, not a judgement about mixing. It exists because
+ * the offending strings were written one at a time over months and read fine in
+ * isolation — nobody notices the assumption until they apply Cut Rumble to a
+ * bass line and the panel tells them it will thin their voice out.
+ */
+describe("no copy assumes the track is a voice", () => {
+  /** Words that only mean something if the material is speech. */
+  const SPEECH =
+    /\b(voice|vocal|voices|speech|spoken|word|words|sentence|sentences|syllable|syllables|narration|narrator|talking|chest)\b/i;
+
+  /** Presets whose whole purpose is a voice, so their copy may say so. */
+  const VOICE_PRESETS = new Set(
+    HF_AUDIO_FX_PRESETS.filter((p) => p.family === "voice").map((p) => p.id),
+  );
+
+  const offenders = (entries: [string, string][]): string[] =>
+    entries.filter(([, text]) => SPEECH.test(text)).map(([where, text]) => `${where}: "${text}"`);
+
+  it("not in an effect's name, blurb, reach-for line or any knob", () => {
+    const entries: [string, string][] = [];
+    for (const [id, copy] of Object.entries(EFFECT_COPY)) {
+      entries.push([`${id}.title`, copy.title], [`${id}.does`, copy.does]);
+      entries.push([`${id}.reachFor`, copy.reachFor]);
+      entries.push([`${id}.primaryEnds.low`, copy.primaryEnds.low]);
+      entries.push([`${id}.primaryEnds.high`, copy.primaryEnds.high]);
+      for (const [key, param] of Object.entries(copy.params)) {
+        entries.push([`${id}.${key}.label`, param.label]);
+        if (param.hint) entries.push([`${id}.${key}.hint`, param.hint]);
+        if (param.ends) {
+          entries.push([`${id}.${key}.ends.low`, param.ends.low]);
+          entries.push([`${id}.${key}.ends.high`, param.ends.high]);
+        }
+      }
+    }
+    expect(offenders(entries)).toEqual([]);
+  });
+
+  it("not in the band vocabulary, which every spectral module shares", () => {
+    // These names get taught once and then reused everywhere, so a voice-only
+    // word here spreads to every filter in the rack.
+    expect(offenders(BANDS.map((b) => [b.name, b.says]))).toEqual([]);
+  });
+
+  it("not in the complaint a non-voice preset answers", () => {
+    const entries = Object.entries(PRESET_PROBLEM).filter(([id]) => !VOICE_PRESETS.has(id));
+    expect(offenders(entries as [string, string][])).toEqual([]);
+  });
+
+  it("still lets the voice presets say what they are for", () => {
+    // The exception has to be real, or the rule above is untested — a catalogue
+    // where nothing said "voice" would pass every assertion here vacuously.
+    const voiced = Object.entries(PRESET_PROBLEM).filter(([id]) => VOICE_PRESETS.has(id));
+    expect(voiced.length).toBeGreaterThan(0);
+    expect(voiced.some(([, text]) => SPEECH.test(text))).toBe(true);
+  });
+});

packages/core/src/audioFxCopy.ts

@@ -66,13 +66,13 @@ export const EFFECT_COPY: Record<string, EffectCopy> = {
     does: "Cuts the very bottom — traffic, footsteps, air conditioning, hands on the mic.",
     reachFor: "There's a low hum or thump under everything.",
     primary: "frequency",
-    primaryEnds: { low: "Only the deepest", high: "Thins the voice out" },
+    primaryEnds: { low: "Only the deepest", high: "Thins it out" },
     band: [20, 300],
     params: {
       frequency: {
         label: "Cut below",
         hint: "Everything under this is removed.",
-        ends: { low: "Only the deepest", high: "Thins the voice out" },
+        ends: { low: "Only the deepest", high: "Thins it out" },
       },
       q: { label: "Sharpness", hint: "How abruptly the cut starts." },
       poles: { label: "Steepness", hint: "How fast it falls away below the point." },
@@ -134,7 +134,7 @@ export const EFFECT_COPY: Record<string, EffectCopy> = {
   compressor: {
     title: "Even Out Loudness",
     does: "Brings the quiet parts up and holds the loud parts down, so nothing jumps out at the listener.",
-    reachFor: "Some words are much louder than others.",
+    reachFor: "Some parts are much louder than others.",
     primary: "strength",
     primaryEnds: { low: "Barely touched", high: "Very even, quite squashed" },
     params: {
@@ -168,10 +168,10 @@ export const EFFECT_COPY: Record<string, EffectCopy> = {
   },
   gate: {
     title: "Silence the Gaps",
-    does: "Mutes the pauses between words. Room tone under speech stays — this closes the silences, it does not remove noise.",
-    reachFor: "You can hear the room breathing between sentences.",
+    does: "Mutes the pauses. Whatever sits underneath stays — this closes the gaps, it does not remove noise.",
+    reachFor: "You can hear the room in the gaps.",
     primary: "strength",
-    primaryEnds: { low: "Only true silence", high: "Cuts quiet words too" },
+    primaryEnds: { low: "Only true silence", high: "Cuts quiet parts too" },
     params: {
       threshold: { label: "Quieter than this is a gap" },
       range: {
@@ -182,7 +182,7 @@ export const EFFECT_COPY: Record<string, EffectCopy> = {
       attack: { label: "How fast it opens" },
       release: {
         label: "How fast it closes",
-        ends: { low: "Clips word endings", high: "Leaves tails intact" },
+        ends: { low: "Clips tails short", high: "Leaves tails intact" },
       },
       knee: { label: "How gradual" },
     },
@@ -286,11 +286,11 @@ export const EFFECT_COPY: Record<string, EffectCopy> = {
  */
 export const BANDS: { from: number; to: number; name: string; says: string }[] = [
   { from: 20, to: 80, name: "Rumble", says: "traffic, footsteps, handling" },
-  { from: 80, to: 250, name: "Weight", says: "chest, body, warmth" },
+  { from: 80, to: 250, name: "Weight", says: "body, warmth, low end" },
   { from: 250, to: 600, name: "Mud", says: "boxy, muffled, cardboard" },
-  { from: 600, to: 2000, name: "Middle", says: "the body of a voice" },
-  { from: 2000, to: 5000, name: "Presence", says: "consonants, intelligibility" },
-  { from: 5000, to: 10000, name: "Edge", says: "sibilance, harshness" },
+  { from: 600, to: 2000, name: "Middle", says: "the body of the sound" },
+  { from: 2000, to: 5000, name: "Presence", says: "definition, consonants" },
+  { from: 5000, to: 10000, name: "Edge", says: "harshness, sibilance" },
   { from: 10000, to: 20000, name: "Air", says: "sparkle, openness" },
 ];
 
@@ -318,8 +318,8 @@ export const PRESET_PROBLEM: Record<string, string> = {
   "voice-broadcast": "I want it to sound like radio",
   "voice-warm": "I want it intimate and close",
   "rumble-cut": "There's a hum or thump underneath",
-  "room-gate": "I can hear the room between sentences",
-  "boom-tame": "My voice sounds boomy",
+  "room-gate": "I can hear the room in the gaps",
+  "boom-tame": "It sounds boomy",
   "harsh-tame": "It's harsh and tiring to listen to",
   telephone: "Make it sound like a phone call",
   "radio-am": "Make it sound like an old radio",

packages/core/src/audioFxJobs.test.ts

@@ -61,3 +61,20 @@ describe("named jobs", () => {
     for (const id of ids) expect(getAudioFxJob(id)?.id).toBe(id);
   });
 });
+
+/**
+ * A job's `does` is the complaint that leads to it, shown in the add menu on
+ * whatever track is selected — so it is under the same rule as the effect copy
+ * in `audioFxCopy.test.ts`: it may not assume the material is speech. Reduce Mud
+ * is as right on a boxy guitar as on a boxy voice, and the menu should say so.
+ */
+describe("no job assumes the track is a voice", () => {
+  const SPEECH =
+    /\b(voice|vocal|speech|spoken|word|words|sentence|syllable|narration|talking|chest)\b/i;
+  it("names the symptom without naming the source", () => {
+    const bad = HF_AUDIO_FX_JOBS.filter((j) => SPEECH.test(`${j.label} ${j.does}`)).map(
+      (j) => `${j.id}: "${j.does}"`,
+    );
+    expect(bad).toEqual([]);
+  });
+});

packages/core/src/audioFxJobs.ts

@@ -51,7 +51,7 @@ export const HF_AUDIO_FX_JOBS: readonly HfAudioFxJob[] = [
   {
     id: "tame-boominess",
     label: "Tame Boominess",
-    does: "Too much chest — it booms.",
+    does: "Too much low-end body — it booms.",
     type: "peaking",
     params: { frequency: 200, gain: -4, q: 1.4 },
   },
@@ -72,7 +72,7 @@ export const HF_AUDIO_FX_JOBS: readonly HfAudioFxJob[] = [
   {
     id: "add-clarity",
     label: "Add Clarity",
-    does: "Words are hard to make out.",
+    does: "It is hard to make out — it sits back.",
     type: "peaking",
     params: { frequency: 3000, gain: 2.5, q: 1 },
   },

packages/core/src/audioFxProfiles.test.ts

@@ -138,3 +138,27 @@ describe("derived one-knob profiles", () => {
     expect(audioFxProfileStrength("not-an-effect", {})).toBe(0.5);
   });
 });
+
+/**
+ * A profile's knob name and its two ends are read on every track that carries
+ * the effect, so they fall under the same rule as the rest of the copy: say what
+ * changes in the sound, not what it does to a voice. See the matching audit in
+ * `audioFxCopy.test.ts`.
+ */
+describe("no profile assumes the track is a voice", () => {
+  const SPEECH =
+    /\b(voice|vocal|speech|spoken|word|words|sentence|syllable|narration|talking|chest)\b/i;
+  it("labels the knob and both ends without assuming speech", () => {
+    const bad: string[] = [];
+    for (const [type, p] of Object.entries(HF_AUDIO_FX_PROFILES)) {
+      for (const [where, text] of [
+        ["label", p.label],
+        ["ends.low", p.ends.low],
+        ["ends.high", p.ends.high],
+      ] as const) {
+        if (SPEECH.test(text)) bad.push(`${type}.${where}: "${text}"`);
+      }
+    }
+    expect(bad).toEqual([]);
+  });
+});

packages/core/src/audioFxProfiles.ts

@@ -81,7 +81,7 @@ export const HF_AUDIO_FX_PROFILES: Record<string, HfAudioFxProfile> = {
 
   gate: {
     label: "Tightness",
-    ends: { low: "Only true silence", high: "Cuts quiet words too" },
+    ends: { low: "Only true silence", high: "Cuts quiet parts too" },
     derives: ["threshold", "range", "release"],
     at(strength) {
       const s = clamp01(strength);