feat(studio): fold a preset shut, and give each one its own title design

packages/core/src/audio/audioFxGraph.test.ts

@@ -698,3 +698,66 @@ describe("a preset's run is wrapped in a wet/dry blend", () => {
     expect(live).toEqual([]);
   });
 });
+
+describe("a preset's wrap stays with the nodes it belongs to", () => {
+  const peak = (over: Partial<HfAudioFxNode>): HfAudioFxNode =>
+    ({
+      type: "peaking",
+      enabled: true,
+      params: defaultAudioFxParams("peaking"),
+      ...over,
+    }) as HfAudioFxNode;
+
+  it("rebuilds when a reorder moves a node across a preset boundary", () => {
+    // The type sequence is identical either way, so without preset identity in
+    // the shape the chain updated in place and left the wet/dry wrap bracketing
+    // the hand-added effect instead of the preset's — preview blending out the
+    // author's own node while the render, which rebuilds, blended out the
+    // preset's.
+    const before: HfAudioFxChain = {
+      version: 1,
+      nodes: [peak({ id: "p1", fromPreset: "boom-tame" }), peak({ id: "own" })],
+    };
+    const after: HfAudioFxChain = {
+      version: 1,
+      nodes: [peak({ id: "own" }), peak({ id: "p1", fromPreset: "boom-tame" })],
+    };
+    expect(buildFxChain(asCtx(ctx()), before).update(after)).toBe(false);
+  });
+
+  it("gives every run of one preset its own blend", () => {
+    // A preset pulled apart by a reorder occupies two runs. Keyed by id and
+    // assigned, the second wrap overwrote the first, so a whole-preset lane
+    // reached one fragment and the switch silently left the rest applied.
+    const split: HfAudioFxChain = {
+      version: 1,
+      nodes: [
+        peak({ id: "t1", fromPreset: "telephone" }),
+        { type: "reverb", id: "own", enabled: true, params: defaultAudioFxParams("reverb") },
+        peak({ id: "t2", fromPreset: "telephone" }),
+      ],
+    };
+    const built = buildFxChain(asCtx(ctx()), split);
+    // Two wraps, so two wet/dry pairs — four params under the one id.
+    expect(built.presets.telephone).toHaveLength(4);
+  });
+
+  it("pushes an amount into each run of a split preset, not one of them twice", () => {
+    const at = (amount: number): HfAudioFxChain => ({
+      version: 1,
+      nodes: [
+        peak({ id: "t1", fromPreset: "telephone", presetAmount: amount }),
+        { type: "reverb", id: "own", enabled: true, params: defaultAudioFxParams("reverb") },
+        peak({ id: "t2", fromPreset: "telephone", presetAmount: amount }),
+      ],
+    });
+    const built = buildFxChain(asCtx(ctx()), at(1));
+    expect(built.update(at(0))).toBe(true);
+    // Every wet leg off and every dry leg fully open: switching the preset off
+    // has to silence all of it, not the last fragment only.
+    const wets = (built.presets.telephone ?? []).filter((_, i) => i % 2 === 0);
+    const drys = (built.presets.telephone ?? []).filter((_, i) => i % 2 === 1);
+    for (const t of wets) expect(t.param.value).toBe(0);
+    for (const t of drys) expect(t.param.value).toBe(1);
+  });
+});

packages/core/src/audio/audioFxGraph.ts

@@ -599,7 +599,16 @@ function shapeOf(chain: HfAudioFxChain): string {
       // same reason: pushed into the running graph it would be a no-op, and
       // preview would keep sweeping on a triangle while the render used a sine.
       const wave = node.type === "phaser" ? `~${p.type}` : "";
-      return `${node.type}${poles}${fixedFreq}${wave}`;
+      // Which preset run this node belongs to, for the same reason again: the
+      // wet/dry wrap is WIRED around a run at construction, so moving a node
+      // across a preset boundary changes the graph's shape even when the type
+      // sequence is identical. Without this, reordering a hand-added peaking
+      // filter past a preset's peaking filter kept the in-place update path and
+      // left the wrap bracketing the wrong effect — preview blending out the
+      // author's own node while the render, which rebuilds, blended out the
+      // preset's.
+      const run = node.fromPreset ? `%${node.fromPreset}` : "";
+      return `${node.type}${poles}${fixedFreq}${wave}${run}`;
     })
     .join("|");
 }
@@ -674,8 +683,14 @@ export function buildFxChain(
 
   const shape = shapeOf(chain);
 
+  // Accumulated, not assigned. A preset pulled apart by a reorder occupies more
+  // than one run, and each run gets its own wrap — keying by id and assigning
+  // dropped every wrap but the last, so a whole-preset lane drove one fragment
+  // and left the rest at full strength while the switch read "Off".
   const presetTargets: Record<string, FxParamTarget[]> = {};
-  for (const p of presets) presetTargets[p.id] = mixTargets(p.wet.gain, p.dry.gain);
+  for (const p of presets) {
+    (presetTargets[p.id] ??= []).push(...mixTargets(p.wet.gain, p.dry.gain));
+  }
   return {
     input,
     output,
@@ -699,10 +714,14 @@ export function buildFxChain(
       // The blend is a value like any other: switching a preset off writes
       // `presetAmount`, and pushing it into the running graph is what keeps that
       // from being a rebuild — and from restarting the audio underneath it.
+      // Walked in step with the build, not looked up by id: `find` returned the
+      // first wrap for every run sharing a preset id, so a split preset wrote
+      // one wrap twice and never touched the other.
+      let wrapIndex = 0;
       for (const run of presetRuns(enabledAudioFxNodes(next))) {
         if (!run.preset) continue;
-        const wrap = presets.find((p) => p.id === run.preset);
-        if (!wrap) continue;
+        const wrap = presets[wrapIndex++];
+        if (!wrap || wrap.id !== run.preset) continue;
         wrap.wet.gain.value = run.amount;
         wrap.dry.gain.value = 1 - run.amount;
       }

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,15 +318,16 @@ 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",
   megaphone: "Make it sound shouted through a horn",
   "lofi-tape": "Make it sound like an old tape",
   "pa-system": "Make it sound like a station announcement",
   intercom: "Make it sound like a door intercom",
+  "doofus-worble": "Make it wobble like it is seasick",
   "room-tight": "It sounds dry and stuck to the speaker",
   "room-natural": "It should sound like a real place",
   hall: "It should sound far away and big",

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 },
   },