@libraz/libsonare 1.7.2 → 1.8.1

package/src/worklet/engine.ts

@@ -22,6 +22,7 @@ import type {
   MidiCcBindOptions,
   PanLaw,
   PanMode,
+  SidechainSourceKind,
 } from '../index';
 import { RealtimeEngine } from '../index';
 import { createOpfsClipPageProvider, type OpfsClipPageProviderBinding } from '../opfs_clip_pages';
@@ -34,7 +35,7 @@ import type { EngineClipContext } from './engine-clips';
 import * as clips from './engine-clips';
 import type { EngineMarkerContext } from './engine-markers';
 import * as markers from './engine-markers';
-import type { EngineMixerContext } from './engine-mixer-facade';
+import type { EngineMixerContext, InsertParamOverrideMap } from './engine-mixer-facade';
 import * as mixer from './engine-mixer-facade';
 import { SonareRealtimeEngineNode } from './engine-node';
 import { buildTransportFacade, type CaptureOptions } from './engine-offline';
@@ -94,19 +95,30 @@ export class SonareEngine {
   private readonly offlineBlockSize: number;
   private readonly offlineChannelCount: number;
   private readonly automationLanes = new Map<number, EngineAutomationPoint[]>();
+  private readonly insertAutomationIdsByTarget = new Map<string, Set<number>>();
   private readonly clips = new Map<number, EngineClip>();
   private readonly midiClips = new Map<number, EngineMidiClipSchedule>();
   private readonly markers = new Map<number, EngineMarker>();
   private readonly trackLaneIds: number[] = [];
   private readonly trackSends = new Map<number, EngineTrackSend[]>();
   private readonly trackOutputBus = new Map<number, number>();
+  private readonly trackSourceChannelLayout = new Map<number, number>();
   private readonly laneSidechains = new Map<
     string,
     { trackId: number; insertIndex: number; sourceTrackId: number }
   >();
+  private readonly busSidechains = new Map<
+    string,
+    { busId: number; insertIndex: number; sourceKind: number; sourceId: number }
+  >();
+  private readonly masterSidechains = new Map<
+    number,
+    { insertIndex: number; sourceKind: number; sourceId: number }
+  >();
   private readonly buses: EngineBus[] = [];
   private readonly trackStripJson = new Map<number, string>();
   private readonly busStripJson = new Map<number, string>();
+  private readonly insertParamOverrides: InsertParamOverrideMap = new Map();
   private masterStripJson: string | undefined;
   private captureConfig: Omit<SonareEngineSyncCaptureMessage, 'type'> | undefined;
   private tempoBpm = 120;
@@ -231,6 +243,11 @@ export class SonareEngine {
     tempo.setTimeSignatureSegments(this.tempoContext, segments);
   }
 
+  /**
+   * A loop wrap, seek or stop sends note-offs plus CC64=0, CC121, CC123 and a
+   * centred pitch bend on every channel played since the last reset, so
+   * controller values set before a loop region are not restored at the wrap.
+   */
   setLoop(startPpq: number, endPpq: number, enabled = true): boolean {
     return tempo.setLoop(this.tempoContext, startPpq, endPpq, enabled);
   }
@@ -310,6 +327,15 @@ export class SonareEngine {
    * mixer lane first (like automationParamId) so the offline engine resolves the
    * same strip selector the realtime engine uses.
    *
+   * The returned id uses the track's current positional lane selector. When
+   * setTrackLanes successfully changes lane order or membership, the engine
+   * remaps already queued and published track automation by track id, but it
+   * cannot update a numeric id retained by the caller. Re-resolve every track
+   * insert id after such a topology change before passing it to
+   * setAutomationLane. Use setTrackStripInsertParamByName when the operation
+   * needs a stable track identity. Master and bus insert ids are separate and
+   * are not invalidated by track-lane changes.
+   *
    * @param target Track id (declares a mixer lane on first use).
    * @param insertIndex Index into the strip's combined insert sequence.
    * @param paramName Processor JSON-key parameter name.
@@ -320,12 +346,17 @@ export class SonareEngine {
     insertIndex: number,
     paramName: string,
   ): number {
-    return parameter.resolveTrackInsertAutomationId(
+    const id = parameter.resolveTrackInsertAutomationId(
       this.parameterContext,
       target,
       insertIndex,
       paramName,
     );
+    if (id >= 0) {
+      const trackId = this.trackLaneIds[this.ensureTrackLane(target)];
+      this.rememberInsertAutomationId({ kind: 'track', trackId }, id);
+    }
+    return id;
   }
 
   /**
@@ -337,7 +368,15 @@ export class SonareEngine {
    * @returns Reserved insert-automation id, or -1 when insert/key unknown.
    */
   resolveMasterInsertAutomationId(insertIndex: number, paramName: string): number {
-    return parameter.resolveMasterInsertAutomationId(this.parameterContext, insertIndex, paramName);
+    const id = parameter.resolveMasterInsertAutomationId(
+      this.parameterContext,
+      insertIndex,
+      paramName,
+    );
+    if (id >= 0) {
+      this.rememberInsertAutomationId({ kind: 'master' }, id);
+    }
+    return id;
   }
 
   /**
@@ -351,12 +390,30 @@ export class SonareEngine {
    * @returns Reserved insert-automation id, or -1 when bus/insert/key unknown.
    */
   resolveBusInsertAutomationId(busId: number, insertIndex: number, paramName: string): number {
-    return parameter.resolveBusInsertAutomationId(
+    const id = parameter.resolveBusInsertAutomationId(
       this.parameterContext,
       busId,
       insertIndex,
       paramName,
     );
+    if (id >= 0) {
+      this.rememberInsertAutomationId({ kind: 'bus', busId }, id);
+    }
+    return id;
+  }
+
+  /**
+   * Resolves a hosted instrument's continuous parameter to its reserved
+   * instrument-automation id, so an instrument parameter follows a breakpoint
+   * lane at audio-block precision like a strip insert. Bind the instrument
+   * (`setSynthInstrument`) before resolving.
+   *
+   * @param destinationId MIDI destination the instrument is bound to.
+   * @param paramName Instrument JSON-key parameter name (e.g. `cutoffHz`).
+   * @returns Reserved instrument-automation id, or -1 when destination/key unknown.
+   */
+  resolveInstrumentAutomationId(destinationId: number, paramName: string): number {
+    return parameter.resolveInstrumentAutomationId(this.parameterContext, destinationId, paramName);
   }
 
   /**
@@ -397,21 +454,39 @@ export class SonareEngine {
   }
 
   setStripGain(target: string | number, db: number): boolean {
-    return this.sendSmoothedParam(this.stripParamId(target, ENGINE_MIXER_PARAM_FADER_DB), db);
+    const sent = this.sendSmoothedParam(this.stripParamId(target, ENGINE_MIXER_PARAM_FADER_DB), db);
+    if (sent && target === 'master') {
+      strips.cacheMasterStripScalar(this.stripContext, 'faderDb', db);
+    }
+    return sent;
   }
 
   setStripPan(target: string | number, pan: number): boolean {
-    return this.sendSmoothedParam(this.stripParamId(target, ENGINE_MIXER_PARAM_PAN), pan);
+    const sent = this.sendSmoothedParam(this.stripParamId(target, ENGINE_MIXER_PARAM_PAN), pan);
+    if (sent && target === 'master') {
+      strips.cacheMasterStripScalar(this.stripContext, 'pan', pan);
+    }
+    return sent;
+  }
+
+  /** Resets the master's integrated loudness accumulator in both engine mirrors. */
+  resetMasterLoudnessMeter(renderFrame = -1): boolean {
+    this.offlineEngine.resetMasterLoudnessMeter(renderFrame);
+    return this.sendMirroredCommand({
+      type: SonareEngineCommandType.ResetMasterLoudnessMeter,
+      sampleTime: renderFrame,
+    });
   }
 
   /**
    * Declares the mixer track lanes in an explicit order.
    *
-   * Lane indices are append-only: once a track id occupies a lane, its index
-   * stays fixed for the engine's lifetime. The given list must therefore start
-   * with the already-declared lane ids in their current order and may only
-   * append new track ids after them. Entries carrying `sends` replace that
-   * track's send list; entries without `sends` leave existing sends untouched.
+   * A successful call may reorder existing track ids, remove track ids, or add
+   * new ones. Existing queued and published track automation follows the track
+   * id, while numeric track-insert automation ids retained by the caller do
+   * not; re-resolve those ids after every topology change. Entries carrying
+   * `sends` replace that track's send list; entries without `sends` leave
+   * existing sends untouched.
    *
    * @param lanes Track ids or lane descriptors in the desired lane order.
    */
@@ -448,15 +523,48 @@ export class SonareEngine {
     mixer.setTrackBuses(this.mixerContext, buses);
   }
 
+  /**
+   * Keys one insert of a bus strip from a track lane or another bus
+   * (ducking/sidechainRouter inserts). `sourceId` 0 removes the binding.
+   */
+  setBusSidechain(
+    busId: number,
+    insertIndex: number,
+    sourceKind: SidechainSourceKind | number,
+    sourceId: number,
+  ): void {
+    mixer.setBusSidechain(this.mixerContext, busId, insertIndex, sourceKind, sourceId);
+  }
+
+  /**
+   * Keys one insert of the master strip from a track lane or a bus. Same
+   * source rules as {@link setBusSidechain}.
+   */
+  setMasterSidechain(
+    insertIndex: number,
+    sourceKind: SidechainSourceKind | number,
+    sourceId: number,
+  ): void {
+    mixer.setMasterSidechain(this.mixerContext, insertIndex, sourceKind, sourceId);
+  }
+
   setBusGain(busId: number, db: number): boolean {
     return mixer.setBusGain(this.mixerContext, busId, db);
   }
 
   setTrackStripJson(target: string | number, sceneJson: string): void {
+    // Parse before declaring a new lane so malformed text cannot declare one.
+    mixer.decodedInsertSignature(sceneJson, { kind: 'track', trackId: 0 });
     const laneIndex = this.ensureTrackLane(target);
     const trackId = this.trackLaneIds[laneIndex];
-    strips.setTrackStripJson(this.stripContext, trackId, sceneJson, this.trackStripJson);
-    this.syncMixer();
+    const { insertBaseResets, constructionOverrides } = strips.setTrackStripJson(
+      this.stripContext,
+      trackId,
+      sceneJson,
+      this.trackStripJson,
+    );
+    mixer.pruneStripSidechains(this.mixerContext, { kind: 'track', trackId }, sceneJson);
+    this.syncMixer(insertBaseResets, constructionOverrides);
   }
 
   setTrackStripEqBand(target: string | number, bandIndex: number, band: EqBand | string): void {
@@ -541,9 +649,7 @@ export class SonareEngine {
   }
 
   setMasterStripJson(sceneJson: string): void {
-    this.offlineEngine.setMasterStripJson(sceneJson);
-    this.masterStripJson = sceneJson;
-    this.syncMixer();
+    mixer.setMasterStripJson(this.mixerContext, sceneJson);
   }
 
   setMasterStripEqBand(bandIndex: number, band: EqBand | string): void {
@@ -572,6 +678,58 @@ export class SonareEngine {
     strips.setBusStripInsertParamByName(this.stripContext, busId, insertIndex, paramName, value);
   }
 
+  /**
+   * Bus-strip counterpart of {@link setStripInsertBypassed}. A bus is addressed
+   * by its numeric id, which the `target` of the track/master form cannot
+   * express, so it is its own method exactly like
+   * {@link setBusStripInsertParamByName}. Bypassing keeps the insert's internal
+   * state (reverb tail, compressor envelope) unless `resetOnBypass` is set;
+   * re-posting the bus scene JSON, the only workaround before this existed,
+   * rebuilds the chain and loses it.
+   */
+  setBusStripInsertBypassed(
+    busId: number,
+    insertIndex: number,
+    bypassed: boolean,
+    resetOnBypass = false,
+  ): void {
+    this.ensureBus(busId);
+    strips.setBusStripInsertBypassed(
+      this.stripContext,
+      busId,
+      insertIndex,
+      bypassed,
+      resetOnBypass,
+    );
+  }
+
+  /** Bus-strip counterpart of {@link setTrackStripEqBand}. */
+  setBusStripEqBand(busId: number, bandIndex: number, band: EqBand | string): void {
+    this.ensureBus(busId);
+    strips.setBusStripEqBand(this.stripContext, busId, bandIndex, band);
+  }
+
+  /** Bus-strip counterpart of {@link setTrackStripPan}; refused on a surround bus. */
+  setBusStripPan(busId: number, pan: number): void {
+    this.ensureBus(busId);
+    strips.setBusStripPan(this.stripContext, busId, pan);
+  }
+
+  setBusStripPanLaw(busId: number, panLaw: PanLaw | number): void {
+    this.ensureBus(busId);
+    strips.setBusStripPanLaw(this.stripContext, busId, panLaw);
+  }
+
+  setBusStripPanMode(busId: number, panMode: PanMode | number): void {
+    this.ensureBus(busId);
+    strips.setBusStripPanMode(this.stripContext, busId, panMode);
+  }
+
+  setBusStripDualPan(busId: number, leftPan: number, rightPan: number): void {
+    this.ensureBus(busId);
+    strips.setBusStripDualPan(this.stripContext, busId, leftPan, rightPan);
+  }
+
   setStripInsertParamByName(
     target: string | number,
     insertIndex: number,
@@ -664,6 +822,52 @@ export class SonareEngine {
     return { binding, provider: binding.provider };
   }
 
+  /**
+   * Sets the clip-page look-ahead window in timeline frames on both the worklet
+   * engine and this thread's offline engine.
+   *
+   * The audio thread reports the pages it is *about to* read that are not
+   * resident yet, so the sliding-window streamer can service them before the
+   * playhead reaches them. Without look-ahead a page miss is only reported
+   * after the read already produced silence, which costs one block of silence
+   * at every page boundary that was not primed.
+   *
+   * Defaults to half a second at the engine's sample rate. `0` disables it.
+   * Safe to call during playback.
+   */
+  setClipPagePrefetchFrames(frames: number): void {
+    if (this.destroyed) {
+      throw new Error('SonareEngine is destroyed.');
+    }
+    if (!Number.isFinite(frames) || frames < 0) {
+      throw new Error('clip page prefetch frames must be a finite value >= 0.');
+    }
+    this.offlineEngine.setClipPagePrefetchFrames(frames);
+    this.postSync({ type: 'syncClipPagePrefetchFrames', frames });
+  }
+
+  /**
+   * Sets the number of concurrent time-stretch voices on both this thread's
+   * offline engine and the live worklet engine. `voices` must be an integer
+   * in `[0, 64]`; a non-integer, negative, or larger value throws and leaves
+   * the capacity unchanged on both engines. Default is 8. Capacity 0 disables
+   * time-stretch, so every warped clip plays resampled instead. A change
+   * applied while the engine is running restarts the splice state of any clip
+   * stretching through a voice at that moment.
+   */
+  setWarpVoiceCapacity(voices: number): void {
+    if (this.destroyed) {
+      throw new Error('SonareEngine is destroyed.');
+    }
+    this.offlineEngine.setWarpVoiceCapacity(voices);
+    this.postSync({ type: 'syncWarpVoiceCapacity', voices });
+  }
+
+  /** Reads the current time-stretch voice capacity (default 8). */
+  warpVoiceCapacity(): number {
+    return this.offlineEngine.warpVoiceCapacity();
+  }
+
   addClip(
     trackId: string | number,
     buffer: Float32Array[] | ClipPageProvider,
@@ -703,6 +907,8 @@ export class SonareEngine {
       gain?: number;
       polyphony?: number;
       preferModelForModeledFamilies?: boolean;
+      clearBankRig?: boolean;
+      gsEfxRealization?: 'modern' | 'classic';
     } = {},
   ): void {
     strips.setSf2Instrument(this.stripContext, trackId, config);
@@ -711,7 +917,10 @@ export class SonareEngine {
   /**
    * Route a track's MIDI to the external output (drained via {@link onMidiOut})
    * instead of an internal instrument, so the track plays an external device.
-   * Pass `external=false` to restore internal-synth playback.
+   * Pass `external=false` to restore internal-synth playback. The change takes
+   * effect at the next processed block; switching a destination's route first
+   * releases its notes and resets its controllers through the old route, and
+   * drops its pending MIDI-FX events.
    */
   setMidiDestinationExternal(trackId: string | number, external: boolean): void {
     strips.setMidiDestinationExternal(this.stripContext, trackId, external);
@@ -776,6 +985,52 @@ export class SonareEngine {
     strips.pushMidiCc(this.stripContext, trackId, group, channel, controller, value, renderFrame);
   }
 
+  pushMidiPitchBend(
+    trackId: string | number,
+    group: number,
+    channel: number,
+    bend14: number,
+    renderFrame = -1,
+  ): void {
+    strips.pushMidiPitchBend(this.stripContext, trackId, group, channel, bend14, renderFrame);
+  }
+
+  pushMidiChannelPressure(
+    trackId: string | number,
+    group: number,
+    channel: number,
+    pressure: number,
+    renderFrame = -1,
+  ): void {
+    strips.pushMidiChannelPressure(
+      this.stripContext,
+      trackId,
+      group,
+      channel,
+      pressure,
+      renderFrame,
+    );
+  }
+
+  pushMidiPolyPressure(
+    trackId: string | number,
+    group: number,
+    channel: number,
+    note: number,
+    pressure: number,
+    renderFrame = -1,
+  ): void {
+    strips.pushMidiPolyPressure(
+      this.stripContext,
+      trackId,
+      group,
+      channel,
+      note,
+      pressure,
+      renderFrame,
+    );
+  }
+
   pushMidiUmp(trackId: string | number, word0: number, renderFrame = -1): void {
     strips.pushMidiUmp(this.stripContext, trackId, word0, renderFrame);
   }
@@ -860,6 +1115,58 @@ export class SonareEngine {
     });
   }
 
+  pushMidiInputPitchBend(
+    group: number,
+    channel: number,
+    bend14: number,
+    portTimeSamples = 0,
+  ): void {
+    this.offlineEngine.pushMidiInputPitchBend(group, channel, bend14, portTimeSamples);
+    this.postSync({
+      type: 'syncMidiInputPitchBend',
+      group,
+      channel,
+      data0: bend14,
+      data1: 0,
+      portTimeSamples,
+    });
+  }
+
+  pushMidiInputChannelPressure(
+    group: number,
+    channel: number,
+    pressure: number,
+    portTimeSamples = 0,
+  ): void {
+    this.offlineEngine.pushMidiInputChannelPressure(group, channel, pressure, portTimeSamples);
+    this.postSync({
+      type: 'syncMidiInputChannelPressure',
+      group,
+      channel,
+      data0: pressure,
+      data1: 0,
+      portTimeSamples,
+    });
+  }
+
+  pushMidiInputPolyPressure(
+    group: number,
+    channel: number,
+    note: number,
+    pressure: number,
+    portTimeSamples = 0,
+  ): void {
+    this.offlineEngine.pushMidiInputPolyPressure(group, channel, note, pressure, portTimeSamples);
+    this.postSync({
+      type: 'syncMidiInputPolyPressure',
+      group,
+      channel,
+      data0: note,
+      data1: pressure,
+      portTimeSamples,
+    });
+  }
+
   pushMidiPanic(renderFrame = -1): void {
     this.offlineEngine.pushMidiPanic(renderFrame);
     this.postSync({ type: 'syncMidiPanic', renderFrame });
@@ -1106,8 +1413,45 @@ export class SonareEngine {
     return mixer.mixerLanes(this.mixerContext);
   }
 
-  private syncMixer(): void {
-    mixer.syncMixer(this.mixerContext);
+  private syncMixer(
+    insertBaseResets: mixer.StripJsonTarget[] = [],
+    oneShotInsertParamOverrides: mixer.InsertParamOverride[] = [],
+  ): void {
+    mixer.syncMixer(this.mixerContext, false, insertBaseResets, oneShotInsertParamOverrides);
+  }
+
+  private insertAutomationTargetKey(target: mixer.StripJsonTarget): string {
+    return target.kind === 'track'
+      ? `track:${target.trackId}`
+      : target.kind === 'bus'
+        ? `bus:${target.busId}`
+        : 'master';
+  }
+
+  private rememberInsertAutomationId(target: mixer.StripJsonTarget, id: number): void {
+    const key = this.insertAutomationTargetKey(target);
+    const ids = this.insertAutomationIdsByTarget.get(key) ?? new Set<number>();
+    ids.add(id);
+    this.insertAutomationIdsByTarget.set(key, ids);
+  }
+
+  private clearInsertAutomationLanes(
+    target: mixer.StripJsonTarget,
+    forgetResolvedIds = false,
+  ): void {
+    const key = this.insertAutomationTargetKey(target);
+    const ids = this.insertAutomationIdsByTarget.get(key);
+    if (!ids) {
+      return;
+    }
+    for (const id of ids) {
+      if (this.automationLanes.has(id)) {
+        this.setAutomationLane(id, []);
+      }
+    }
+    if (forgetResolvedIds) {
+      this.insertAutomationIdsByTarget.delete(key);
+    }
   }
 
   private postInstrumentSync(message: SonareEngineInstrumentSyncMessage): void {
@@ -1138,22 +1482,17 @@ export class SonareEngine {
     if (this.destroyed) {
       return;
     }
-    try {
-      if (transfer && transfer.length > 0) {
-        this.realtimeNode.node.port.postMessage(message, transfer);
-      } else {
-        this.realtimeNode.node.port.postMessage(message);
-      }
-    } finally {
-      this.flushOfflineMirror();
+    if (transfer && transfer.length > 0) {
+      this.realtimeNode.node.port.postMessage(message, transfer);
+    } else {
+      this.realtimeNode.node.port.postMessage(message);
     }
   }
 
-  // The offline engine is a control-thread mirror. It has no render loop to
-  // drain its command ring, so drain it after each control operation. Never
-  // call this from the worklet/audio path: it is intentionally control-only.
+  // The control-only mirror applies due commands immediately while preserving
+  // scheduled ones for its next render block.
   private flushOfflineMirror(): void {
-    this.offlineEngine.flushControlCommands();
+    this.offlineEngine.applyCommandsDueNowPreservingFuture();
   }
 
   private sendMirroredCommand(
@@ -1174,17 +1513,28 @@ export class SonareEngine {
       trackLaneIds: this.trackLaneIds,
       trackSends: this.trackSends,
       trackOutputBus: this.trackOutputBus,
+      trackSourceChannelLayout: this.trackSourceChannelLayout,
       laneSidechains: this.laneSidechains,
+      busSidechains: this.busSidechains,
+      masterSidechains: this.masterSidechains,
       buses: this.buses,
       trackStripJson: this.trackStripJson,
       busStripJson: this.busStripJson,
+      insertParamOverrides: this.insertParamOverrides,
+      flushOfflineMirror: () => this.flushOfflineMirror(),
       postSync: (message) => this.postSync(message),
       ensureTrackLane: (target) => this.ensureTrackLane(target),
       ensureBus: (busId) => this.ensureBus(busId),
       mixerLanes: () => this.mixerLanes(),
-      syncMixer: () => this.syncMixer(),
+      syncMixer: (insertBaseResets, oneShotInsertParamOverrides) =>
+        this.syncMixer(insertBaseResets, oneShotInsertParamOverrides),
+      clearInsertAutomationLanes: (target, forgetResolvedIds) =>
+        this.clearInsertAutomationLanes(target, forgetResolvedIds),
       sendSmoothedParam: (paramId, value) => this.sendSmoothedParam(paramId, value),
       getMasterStripJson: () => this.masterStripJson,
+      cacheMasterStripJson: (sceneJson) => {
+        this.masterStripJson = sceneJson;
+      },
     };
   }
 
@@ -1199,6 +1549,11 @@ export class SonareEngine {
       postInstrumentSync: (message) => this.postInstrumentSync(message),
       ensureTrackLane: (target) => this.ensureTrackLane(target),
       resolveTargetId: (target) => this.resolveTargetId(target),
+      readStripJson: (target) => mixer.cachedStripJson(this.mixerContext, target),
+      writeStripJson: (target, sceneJson) =>
+        mixer.cacheStripJson(this.mixerContext, target, sceneJson),
+      insertParamOverrides: this.insertParamOverrides,
+      clearInsertAutomationLanes: (target) => this.clearInsertAutomationLanes(target),
     };
   }
 
@@ -1350,29 +1705,20 @@ export class SonareEngine {
   }
 
   private ensureTrackLane(target: string | number): number {
-    const trackId = this.resolveTargetId(target);
-    if (!Number.isInteger(trackId) || trackId <= 0) {
-      throw new Error(`Invalid track id for mixer lane: ${String(target)}`);
-    }
-    const existing = this.trackLaneIds.indexOf(trackId);
-    if (existing >= 0) {
-      return existing;
-    }
-    this.trackLaneIds.push(trackId);
-    this.syncMixer();
-    return this.trackLaneIds.length - 1;
+    return mixer.ensureTrackLane(this.mixerContext, target);
   }
 
   private ensureBus(busId: number): number {
-    const resolved = Math.trunc(busId);
-    if (!Number.isInteger(resolved) || resolved <= 0) {
-      throw new Error(`Invalid bus id for mixer bus: ${String(busId)}`);
+    // Tested on the raw id: truncating first leaves the integrality check
+    // unreachable, and registers a bus under an id the caller never named.
+    if (!Number.isInteger(busId) || busId <= 0) {
+      throw new RangeError(`Invalid bus id for mixer bus: ${String(busId)}`);
     }
-    const existing = this.buses.findIndex((bus) => bus.busId === resolved);
+    const existing = this.buses.findIndex((bus) => bus.busId === busId);
     if (existing >= 0) {
       return existing;
     }
-    this.buses.push({ busId: resolved });
+    this.buses.push({ busId });
     this.syncMixer();
     return this.buses.length - 1;
   }