fix(player): stop the pitch worklet running twelve idle chains at zero transpose

Both engines wired all thirteen semitone buses into the SoundTouch worklet
at construction. The processor decides whether a semitone is in use by
whether its input has channels, and takes its bypass path only when none
do. A bus wired with nothing playing into it still reaches the processor
as one channel of silence in Chrome, so every pitch input read as live,
twelve WSOLA chains were built and ran on silence for the whole track,
and the bypass never engaged even with nothing transposed.

Measured in headless Chromium, offline render of 60 s, seven stems, no
transpose: 13% of real time with every bus wired, 0.6% with only the
unpitched bus wired, 0.5% with no worklet at all. On a laptop that load
lands on the audio thread's 128-sample deadline and is heard as pops.
It also meant the playhead ran ahead of the audio by the worklet's
priming latency, since the engine assumes none when no lane is transposed.

A pitch bus is now wired into the worklet only while a lane is on it and
unwired once the last lane leaves, so the processor sees the empty input
its contract describes. The unpitched bus stays wired: the click is
scheduled onto it directly. The routing test now walks the graph for
which inputs are wired as lanes arrive, share a key, and leave.

Author: pywkt

static/js/audioEngine.js

@@ -34,6 +34,13 @@ export function createAudioEngine(stems, { onTime, onEnded, context } = {}) {
   // as which bus it is connected to, so several lanes can sit in different
   // keys at once while still sharing the worklet's single tempo stage.
   const buses = Array.from({ length: INPUT_COUNT }, () => ctx.createGain());
+  // How many tracks sit on each bus. A pitch bus is wired into the worklet only
+  // while this is non-zero; the unpitched bus is wired for good. See the same
+  // field in chunkedAudioEngine.js for why: a bus wired with nothing playing
+  // into it still reaches the processor as a channel of silence, which it took
+  // as a lane to transpose, so twelve pitch chains ran on silence for every
+  // track at zero transpose.
+  const busLanes = new Array(INPUT_COUNT).fill(0);
   master.connect(ctx.destination);
 
   let _playbackRate = 1.0;
@@ -57,7 +64,12 @@ export function createAudioEngine(stems, { onTime, onEnded, context } = {}) {
         // The worklet loads asynchronously, so anything set before it arrived
         // would otherwise be dropped. Re-apply the current value now.
         stNode.parameters.get('tempo').value = _playbackRate;
-        for (let k = 0; k < INPUT_COUNT; k++) buses[k].connect(stNode, 0, k);
+        // Tracks decoded before the worklet arrived are already routed, so
+        // wire whichever pitch buses they occupy.
+        buses[ZERO_INPUT].connect(stNode, 0, ZERO_INPUT);
+        for (let k = 0; k < INPUT_COUNT; k++) {
+          if (k !== ZERO_INPUT && busLanes[k] > 0) buses[k].connect(stNode, 0, k);
+        }
         stNode.connect(master);
       }).catch((err) => {
         console.warn('[audioEngine] SoundTouch worklet load failed, using tape-effect fallback:', err);
@@ -314,16 +326,37 @@ export function createAudioEngine(stems, { onTime, onEnded, context } = {}) {
   const ROUTE_FADE = 0.006;
   const ROUTE_HOLD = 0.02;
 
+  // A track arriving on, or leaving, a bus. Mirrors chunkedAudioEngine.js:
+  // only the first arrival and the last departure touch the worklet, the
+  // unpitched bus stays wired whatever its count because the click is
+  // scheduled onto it directly, and arrival is announced before the track
+  // connects so the bus is live by the time anything reaches it. No worklet
+  // means the tape-effect fallback, where every bus already feeds master.
+  function _laneArriving(bus) {
+    const k = buses.indexOf(bus);
+    if (busLanes[k]++ === 0 && k !== ZERO_INPUT && stNode) buses[k].connect(stNode, 0, k);
+  }
+  function _laneLeft(bus) {
+    if (!bus) return;
+    const k = buses.indexOf(bus);
+    if (--busLanes[k] === 0 && k !== ZERO_INPUT && stNode) {
+      try { buses[k].disconnect(stNode, 0, k); } catch { /* worklet already gone */ }
+    }
+  }
+
   /** Connect a track to the bus for its current transpose. */
   function routeTrack(t, immediate = false) {
     if (t.visualOnly) return;
     const target = buses[inputForPitch(effectivePitch(t.name, t.pitch, t.pitchable))];
     if (t.bus === target) return;
     const swap = () => {
       if (destroyed) return;
+      const previous = t.bus;
+      _laneArriving(target);
       try { t.analyser.disconnect(); } catch { /* was not connected yet */ }
       t.analyser.connect(target);
       t.bus = target;
+      _laneLeft(previous);
     };
     if (immediate || !playing) { swap(); return; }
     const g = t.gain.gain;

static/js/chunkedAudioEngine.js

@@ -198,6 +198,20 @@ export function createChunkedAudioEngine(stems, { onTime, onEnded, context } = {
   // as which bus it is connected to, so several lanes can sit in different
   // keys at once while still sharing the worklet's single tempo stage.
   const buses = Array.from({ length: INPUT_COUNT }, () => ctx.createGain());
+  // How many lanes sit on each bus. A pitch bus is wired into the worklet only
+  // while this is non-zero; the unpitched bus is wired for good.
+  //
+  // The processor decides whether a semitone is in use by whether its input
+  // has any channels, and it takes its bypass path (a straight copy) only when
+  // none do. Wiring every bus up front defeated that: a bus with nothing
+  // playing into it still arrives as one channel of silence in Chrome, so the
+  // processor built a pitch chain for all twelve semitones and ran WSOLA on
+  // silence for the whole track, at zero transpose. Measured at 13% of real
+  // time for seven stems on a desktop, against 0.6% with only the unpitched
+  // input wired -- enough to starve the audio thread on a laptop and be heard
+  // as pops. Connecting a bus only while a lane is on it hands the processor
+  // the empty input its contract describes.
+  const busLanes = new Array(INPUT_COUNT).fill(0);
   master.connect(ctx.destination);
 
   let stNode = null;
@@ -218,7 +232,12 @@ export function createChunkedAudioEngine(stems, { onTime, onEnded, context } = {
         // The worklet loads asynchronously, so anything set before it arrived
         // would otherwise be dropped. Re-apply the current value now.
         stNode.parameters.get('tempo').value = _playbackRate;
-        for (let k = 0; k < INPUT_COUNT; k++) buses[k].connect(stNode, 0, k);
+        // Lanes were routed before the worklet arrived (see the stem loop
+        // below), so wire whichever pitch buses they already occupy.
+        buses[ZERO_INPUT].connect(stNode, 0, ZERO_INPUT);
+        for (let k = 0; k < INPUT_COUNT; k++) {
+          if (k !== ZERO_INPUT && busLanes[k] > 0) buses[k].connect(stNode, 0, k);
+        }
         stNode.connect(master);
       }).catch((err) => {
         console.warn('[chunkedEngine] SoundTouch worklet failed, tape-effect fallback:', err);
@@ -320,15 +339,40 @@ export function createChunkedAudioEngine(stems, { onTime, onEnded, context } = {
   const ROUTE_FADE = 0.006;
   const ROUTE_HOLD = 0.02;
 
+  // A lane arriving on, or leaving, a bus. Only the first arrival and the last
+  // departure touch the worklet: the bus is wired in while occupied and taken
+  // out again once empty, so the processor sees exactly the inputs that carry
+  // a lane. The unpitched bus stays wired whatever its count, because the
+  // click is scheduled onto it directly. In the tape-effect fallback there is
+  // no worklet and every bus already feeds master, so there is nothing to do.
+  //
+  // Arrival is announced before the lane connects, so a bus is live in the
+  // worklet by the time anything reaches it, and nothing watching the graph
+  // sees a lane land on a bus that leads nowhere.
+  function _laneArriving(bus) {
+    const k = buses.indexOf(bus);
+    if (busLanes[k]++ === 0 && k !== ZERO_INPUT && stNode) buses[k].connect(stNode, 0, k);
+  }
+  function _laneLeft(bus) {
+    if (!bus) return;
+    const k = buses.indexOf(bus);
+    if (--busLanes[k] === 0 && k !== ZERO_INPUT && stNode) {
+      try { buses[k].disconnect(stNode, 0, k); } catch { /* worklet already gone */ }
+    }
+  }
+
   /** Connect a stem to the bus for its current transpose. */
   function routeStem(stem, immediate = false) {
     const target = buses[inputForPitch(effectivePitch(stem.name, stem.pitch, stem.pitchable))];
     if (stem.bus === target) return;
     const swap = () => {
       if (destroyed) return;
+      const previous = stem.bus;
+      _laneArriving(target);
       try { stem.analyser.disconnect(); } catch { /* was not connected yet */ }
       stem.analyser.connect(target);
       stem.bus = target;
+      _laneLeft(previous);
     };
     if (immediate || !playing) { swap(); return; }
     const g = stem.gain.gain;

tests/js/audio-routing.test.mjs

@@ -243,6 +243,17 @@ async function verifyEngine(name, create) {
   };
   check(`${name} exposes the unpitched bus for the metronome`, engine.getMasterNode() === bus(ZERO_INPUT));
 
+  // Wiring a bus into the worklet is what tells the processor that semitone is
+  // in use, and a wired bus with nothing on it still reaches the processor as a
+  // channel of silence. So at start only the unpitched bus may be wired, and
+  // the checks below watch pitch buses come and go with the lanes on them.
+  const wired = () => {
+    const out = [];
+    for (let k = 0; k < INPUT_COUNT; k++) if (bus(k)) out.push(k - ZERO_INPUT);
+    return out.join(',');
+  };
+  check(`${name} wires only the unpitched bus while nothing is transposed`, wired() === '0', `wired ${wired()}`);
+
   const originalAnalysers = engine.getAnalysers('original');
   check(`${name} groups all complement analysers under original`, originalAnalysers.length === 2);
   const drumAnalyser = originalAnalysers[0];
@@ -266,6 +277,7 @@ async function verifyEngine(name, create) {
   check(`${name} puts a lane in the key it was given`, vocalBus === -2, `landed on ${vocalBus}`);
   check(`${name} reports the key it was given`, engine.getStemPitch('vocals') === -2);
   check(`${name} leaves other lanes where they were`, busOf(melodicAnalyser) === 0);
+  check(`${name} wires a bus when a lane arrives on it`, wired() === '-2,0', `wired ${wired()}`);
 
   // A key past the range the DSP is measured over stops at the edge rather
   // than landing somewhere unusable.
@@ -274,6 +286,7 @@ async function verifyEngine(name, create) {
     `${name} clamps a lane to the offered range`,
     busOf(engine.getAnalysers('vocals')[0]) === 6,
   );
+  check(`${name} unwires a bus once its last lane has left`, wired() === '0,6', `wired ${wired()}`);
 
   // One control drives both sources in the `original` group, and only one of
   // them is allowed to move. This is the whole reason the unpitched input
@@ -291,6 +304,16 @@ async function verifyEngine(name, create) {
   );
   check(`${name} reports drums as not pitchable`, engine.isStemPitchable('drums') === false);
 
+  // Two lanes share the +3 bus, so it must survive one of them leaving and
+  // go only when the other does too. The unpitched bus is never unwired: the
+  // click is scheduled onto it whether or not any lane sits there.
+  engine.setStemPitch('vocals', 3);
+  check(`${name} shares one bus between lanes in the same key`, wired() === '0,3', `wired ${wired()}`);
+  engine.setStemPitch('vocals', 0);
+  check(`${name} keeps a bus wired while another lane is still on it`, wired() === '0,3', `wired ${wired()}`);
+  engine.setStemPitch('original', 0);
+  check(`${name} unwires a shared bus only when it empties`, wired() === '0', `wired ${wired()}`);
+  engine.setStemPitch('original', 3);
   engine.setStemPitch('vocals', 3);
 
   if (name === 'full-decode engine') {