@libraz/libsonare 1.7.2 → 1.8.1

package/src/worklet/engine-processor.ts

@@ -1,6 +1,13 @@
 import type { EngineClip } from '../index';
 import { RealtimeEngine } from '../index';
-import type { WorkletInput, WorkletOutput } from './audio_types';
+import { copyPlanesToOutput, type WorkletInput, type WorkletOutput } from './audio_types';
+import {
+  requireChannelCount,
+  requireIntegerOption,
+  resolveScopeBandCount,
+  SONARE_SCOPE_MAX_BANDS,
+  SONARE_SCOPE_MAX_POINTS,
+} from './guards';
 import {
   DEFAULT_METRONOME_CONFIG,
   type ResolvedMetronomeConfig,
@@ -39,37 +46,13 @@ import {
   type SonareEngineTelemetryRecord,
   type SonareEngineTelemetryRingBuffer,
   SonareEngineTelemetryType,
-  type SonareWorkletMeterSnapshot,
+  type SonareWorkletScopeSnapshot,
   scopeRingFromSharedBuffer,
   telemetryFromEngine,
   writeInt64Words,
   writeSonareEngineTelemetryRingBuffer,
 } from './protocol';
 
-/**
- * Copies one plane per output channel, zero-filling the tail past `frames` and
- * any channel the source does not cover. Shared by the program and cue outputs
- * so the two cannot drift in their padding behaviour. Allocation-free.
- */
-function copyPlanesToOutput(
-  output: Float32Array[],
-  planes: readonly Float32Array[],
-  frames: number,
-): void {
-  for (let ch = 0; ch < output.length; ch++) {
-    const target = output[ch];
-    const source = planes[ch] ?? planes[0];
-    if (source) {
-      target.set(source.subarray(0, Math.min(target.length, frames)));
-      if (target.length > frames) {
-        target.fill(0, frames);
-      }
-    } else {
-      target.fill(0);
-    }
-  }
-}
-
 function captureTransferList(channels: readonly Float32Array[]): Transferable[] {
   const transfers: ArrayBuffer[] = [];
   const seen = new Set<ArrayBuffer>();
@@ -107,6 +90,9 @@ export class SonareRealtimeEngineWorkletProcessor {
   private transport?: WorkletTransport;
   private meterIntervalFrames: number;
   private lastMeterFrame = Number.NEGATIVE_INFINITY;
+  private scopeIntervalFrames: number;
+  private scopeEnabled: boolean;
+  private scopeBands: number;
   // Latest metronome gains/click length pushed via 'syncMetronome'. The
   // SetMetronome command only toggles enabled state; the config arrives here.
   private metronomeConfig: ResolvedMetronomeConfig = { ...DEFAULT_METRONOME_CONFIG };
@@ -141,9 +127,15 @@ export class SonareRealtimeEngineWorkletProcessor {
   ) {
     this.sampleRate = options.sampleRate ?? 48000;
     this.blockSize = options.blockSize ?? 128;
-    this.channelCount = Math.max(1, Math.floor(options.channelCount ?? 2));
+    this.channelCount = requireChannelCount(options.channelCount, 2);
     this.transport = transport;
-    this.meterIntervalFrames = Math.max(0, Math.floor(options.meterIntervalFrames ?? 2048));
+    // Zero is the off switch for meter publication, so the floor is 0.
+    this.meterIntervalFrames = requireIntegerOption(
+      options.meterIntervalFrames,
+      2048,
+      'meterIntervalFrames',
+      0,
+    );
     this.commandRing = options.commandSharedBuffer
       ? this.commandRingFromSharedBuffer(options.commandSharedBuffer, options.commandRingCapacity)
       : undefined;
@@ -163,6 +155,16 @@ export class SonareRealtimeEngineWorkletProcessor {
           options.scopeBands,
         )
       : undefined;
+    this.scopeIntervalFrames = requireIntegerOption(
+      options.scopeIntervalFrames,
+      this.scopeRing ? this.blockSize : 0,
+      'scopeIntervalFrames',
+      0,
+    );
+    this.scopeBands = resolveScopeBandCount(options.scopeBands);
+    this.scopeEnabled =
+      this.scopeIntervalFrames > 0 &&
+      (this.scopeRing !== undefined || typeof this.transport?.postMessage === 'function');
     this.clipPageRequestRing = options.clipPageRequestSharedBuffer
       ? clipPageRequestRingFromSharedBuffer(
           options.clipPageRequestSharedBuffer,
@@ -175,10 +177,13 @@ export class SonareRealtimeEngineWorkletProcessor {
           options.externalMidiRingCapacity,
         )
       : undefined;
+    if (this.commandRing && this.commandRing.capacity > 65536) {
+      throw new RangeError('commandRingCapacity must be at most 65536');
+    }
     this.engine = new RealtimeEngine(
       this.sampleRate,
       this.blockSize,
-      1024,
+      Math.max(1024, this.commandRing?.capacity ?? 0),
       1024,
       this.channelCount,
     );
@@ -197,12 +202,12 @@ export class SonareRealtimeEngineWorkletProcessor {
         this.monitorBuffers[ch] = this.engine.getMonitorChannelBuffer(ch, this.blockSize);
       }
     }
-    // Arm the engine's scope producer only when a scope ring was provided. The
-    // band count follows the ring's record layout so writeScopeRing never
-    // overruns its slot.
-    if (this.scopeRing) {
-      const interval = Math.max(1, Math.floor(options.scopeIntervalFrames ?? this.blockSize));
-      this.engine.configureScopeTelemetry(interval, this.scopeRing.bands);
+    // Arm the native scope producer only when a SAB ring or postMessage sink exists.
+    if (this.scopeEnabled) {
+      this.engine.configureScopeTelemetry(
+        this.scopeIntervalFrames,
+        Math.min(this.scopeRing?.bands ?? this.scopeBands, SONARE_SCOPE_MAX_BANDS),
+      );
     }
   }
 
@@ -395,6 +400,14 @@ export class SonareRealtimeEngineWorkletProcessor {
         }
         break;
       }
+      case 'syncClipPagePrefetchFrames': {
+        this.engine.setClipPagePrefetchFrames(message.frames);
+        break;
+      }
+      case 'syncWarpVoiceCapacity': {
+        this.engine.setWarpVoiceCapacity(message.voices);
+        break;
+      }
       case 'syncClipPageCommit': {
         const providerId = this.pagedClipProviders.get(message.clipId);
         const clip = message.clip ?? this.pendingPagedClips.get(message.clipId);
@@ -455,7 +468,47 @@ export class SonareRealtimeEngineWorkletProcessor {
           );
         }
         break;
-      case 'syncMixer':
+      case 'syncMixer': {
+        if (message.sidechainDelta === true) {
+          // Sidechain setters send a binding delta through this message type.
+          // Their `lanes` field is context, not a request to rebuild routing;
+          // rebuilding it here would discard live insert smoother slots.
+          for (const binding of message.laneSidechains ?? []) {
+            this.engine.setLaneSidechain(
+              binding.trackId,
+              binding.insertIndex,
+              binding.sourceTrackId,
+            );
+          }
+          for (const binding of message.busSidechains ?? []) {
+            this.engine.setBusSidechain(
+              binding.busId,
+              binding.insertIndex,
+              binding.sourceKind,
+              binding.sourceId,
+            );
+          }
+          for (const binding of message.masterSidechains ?? []) {
+            this.engine.setMasterSidechain(
+              binding.insertIndex,
+              binding.sourceKind,
+              binding.sourceId,
+            );
+          }
+          break;
+        }
+        // SAB commands are published before the control thread posts this
+        // structural sync. Drain the whole snapshot so a future command past
+        // the normal 64-per-render budget cannot enter native after the strip
+        // replacement has invalidated its target.
+        if (this.commandRing) {
+          const write = Atomics.load(this.commandRing.header, 0);
+          const read = Atomics.load(this.commandRing.header, 1);
+          this.drainCommands(Math.min(this.commandRing.capacity, Math.max(0, write - read)));
+        }
+        // Complete earlier immediate edits in message order. Scheduled
+        // commands remain queued for their render frame.
+        this.engine.applyCommandsDueNowPreservingFuture();
         if (message.buses) {
           this.engine.setTrackBuses(message.buses);
         }
@@ -469,10 +522,62 @@ export class SonareRealtimeEngineWorkletProcessor {
         if (message.masterStripJson) {
           this.engine.setMasterStripJson(message.masterStripJson);
         }
+        for (const target of message.insertBaseResets ?? []) {
+          switch (target.kind) {
+            case 'track':
+              this.engine.clearTrackInsertParameterBases(target.trackId);
+              break;
+            case 'bus':
+              this.engine.clearBusInsertParameterBases(target.busId);
+              break;
+            case 'master':
+              this.engine.clearMasterInsertParameterBases();
+              break;
+          }
+        }
         for (const binding of message.laneSidechains ?? []) {
           this.engine.setLaneSidechain(binding.trackId, binding.insertIndex, binding.sourceTrackId);
         }
+        for (const binding of message.busSidechains ?? []) {
+          this.engine.setBusSidechain(
+            binding.busId,
+            binding.insertIndex,
+            binding.sourceKind,
+            binding.sourceId,
+          );
+        }
+        for (const binding of message.masterSidechains ?? []) {
+          this.engine.setMasterSidechain(binding.insertIndex, binding.sourceKind, binding.sourceId);
+        }
+        for (const override of message.insertParamOverrides ?? []) {
+          switch (override.kind) {
+            case 'track':
+              this.engine.restoreTrackStripInsertParamByName(
+                override.trackId,
+                override.insertIndex,
+                override.paramName,
+                override.value,
+              );
+              break;
+            case 'bus':
+              this.engine.restoreBusStripInsertParamByName(
+                override.busId,
+                override.insertIndex,
+                override.paramName,
+                override.value,
+              );
+              break;
+            case 'master':
+              this.engine.restoreMasterStripInsertParamByName(
+                override.insertIndex,
+                override.paramName,
+                override.value,
+              );
+              break;
+          }
+        }
         break;
+      }
       case 'syncCapture':
         this.engine.setCaptureBuffer(message.channels, message.bufferFrames);
         this.engine.setCaptureSource(message.source);
@@ -485,6 +590,9 @@ export class SonareRealtimeEngineWorkletProcessor {
       case 'syncMasterStripEqBand':
         this.engine.setMasterStripEqBandJson(message.bandIndex, message.bandJson);
         break;
+      case 'syncBusStripEqBand':
+        this.engine.setBusStripEqBandJson(message.busId, message.bandIndex, message.bandJson);
+        break;
       case 'syncTrackStripInsertBypassed':
         this.engine.setTrackStripInsertBypassed(
           message.trackId,
@@ -501,26 +609,65 @@ export class SonareRealtimeEngineWorkletProcessor {
         );
         break;
       case 'syncTrackStripInsertParamByName':
-        this.engine.setTrackStripInsertParamByName(
-          message.trackId,
-          message.insertIndex,
-          message.paramName,
-          message.value,
-        );
+        this.engine.applyCommandsDueNowPreservingFuture();
+        if (
+          !this.engine.applyTrackStripInsertParamByNameNow(
+            message.trackId,
+            message.insertIndex,
+            message.paramName,
+            message.value,
+          )
+        ) {
+          // A burst can exhaust the fixed smoother slots before the next
+          // render quantum. Apply the last knob value exactly in that case.
+          this.engine.restoreTrackStripInsertParamByName(
+            message.trackId,
+            message.insertIndex,
+            message.paramName,
+            message.value,
+          );
+        }
         break;
       case 'syncMasterStripInsertParamByName':
-        this.engine.setMasterStripInsertParamByName(
-          message.insertIndex,
-          message.paramName,
-          message.value,
-        );
+        this.engine.applyCommandsDueNowPreservingFuture();
+        if (
+          !this.engine.applyMasterStripInsertParamByNameNow(
+            message.insertIndex,
+            message.paramName,
+            message.value,
+          )
+        ) {
+          this.engine.restoreMasterStripInsertParamByName(
+            message.insertIndex,
+            message.paramName,
+            message.value,
+          );
+        }
         break;
       case 'syncBusStripInsertParamByName':
-        this.engine.setBusStripInsertParamByName(
+        this.engine.applyCommandsDueNowPreservingFuture();
+        if (
+          !this.engine.applyBusStripInsertParamByNameNow(
+            message.busId,
+            message.insertIndex,
+            message.paramName,
+            message.value,
+          )
+        ) {
+          this.engine.restoreBusStripInsertParamByName(
+            message.busId,
+            message.insertIndex,
+            message.paramName,
+            message.value,
+          );
+        }
+        break;
+      case 'syncBusStripInsertBypassed':
+        this.engine.setBusStripInsertBypassed(
           message.busId,
           message.insertIndex,
-          message.paramName,
-          message.value,
+          message.bypassed,
+          message.resetOnBypass,
         );
         break;
       case 'syncTrackStripPan':
@@ -535,6 +682,18 @@ export class SonareRealtimeEngineWorkletProcessor {
       case 'syncTrackStripDualPan':
         this.engine.setTrackStripDualPan(message.trackId, message.leftPan, message.rightPan);
         break;
+      case 'syncBusStripPan':
+        this.engine.setBusStripPan(message.busId, message.pan);
+        break;
+      case 'syncBusStripPanLaw':
+        this.engine.setBusStripPanLaw(message.busId, message.panLaw);
+        break;
+      case 'syncBusStripPanMode':
+        this.engine.setBusStripPanMode(message.busId, message.panMode);
+        break;
+      case 'syncBusStripDualPan':
+        this.engine.setBusStripDualPan(message.busId, message.leftPan, message.rightPan);
+        break;
       case 'syncTrackStripChannelDelaySamples':
         this.engine.setTrackStripChannelDelaySamples(message.trackId, message.delaySamples);
         break;
@@ -586,8 +745,36 @@ export class SonareRealtimeEngineWorkletProcessor {
           message.renderFrame,
         );
         break;
+      case 'syncMidiPitchBend':
+        this.engine.pushMidiPitchBend(
+          message.destinationId,
+          message.group,
+          message.channel,
+          message.data0,
+          message.renderFrame,
+        );
+        break;
+      case 'syncMidiChannelPressure':
+        this.engine.pushMidiChannelPressure(
+          message.destinationId,
+          message.group,
+          message.channel,
+          message.data0,
+          message.renderFrame,
+        );
+        break;
+      case 'syncMidiPolyPressure':
+        this.engine.pushMidiPolyPressure(
+          message.destinationId,
+          message.group,
+          message.channel,
+          message.data0,
+          message.data1,
+          message.renderFrame,
+        );
+        break;
       case 'syncMidiUmp':
-        this.engine.pushMidiUmp(message.destinationId, message.word0, message.renderFrame);
+        this.engine.pushMidiUmp(message.destinationId, [message.word0], message.renderFrame);
         break;
       case 'syncMidiSysex':
         this.engine.pushMidiSysex(message.destinationId, message.data, message.renderFrame);
@@ -640,6 +827,31 @@ export class SonareRealtimeEngineWorkletProcessor {
           message.portTimeSamples,
         );
         break;
+      case 'syncMidiInputPitchBend':
+        this.engine.pushMidiInputPitchBend(
+          message.group,
+          message.channel,
+          message.data0,
+          message.portTimeSamples,
+        );
+        break;
+      case 'syncMidiInputChannelPressure':
+        this.engine.pushMidiInputChannelPressure(
+          message.group,
+          message.channel,
+          message.data0,
+          message.portTimeSamples,
+        );
+        break;
+      case 'syncMidiInputPolyPressure':
+        this.engine.pushMidiInputPolyPressure(
+          message.group,
+          message.channel,
+          message.data0,
+          message.data1,
+          message.portTimeSamples,
+        );
+        break;
     }
   }
 
@@ -727,11 +939,11 @@ export class SonareRealtimeEngineWorkletProcessor {
     }
   }
 
-  private drainCommands(): void {
+  private drainCommands(limit = 64): void {
     if (!this.commandRing) {
       return;
     }
-    for (let i = 0; i < 64; i++) {
+    for (let i = 0; i < limit; i++) {
       const command = popSonareEngineCommandRingBuffer(this.commandRing);
       if (!command) {
         return;
@@ -852,6 +1064,9 @@ export class SonareRealtimeEngineWorkletProcessor {
         this.engine.setTrackMonitorMode(laneIndex, mode as 0 | 1 | 2, sampleTime);
         break;
       }
+      case SonareEngineCommandType.ResetMasterLoudnessMeter:
+        this.engine.resetMasterLoudnessMeter(sampleTime);
+        break;
       default:
         this.publishTelemetryRecord({
           type: SonareEngineTelemetryType.Error,
@@ -947,14 +1162,15 @@ export class SonareRealtimeEngineWorkletProcessor {
       if (meter.frame !== this.lastMeterFrame) {
         this.lastMeterFrame = meter.frame;
       }
-      // Prefer the lock-free SAB meter ring (matching the telemetry path and
-      // SonareWorkletProcessor); only fall back to structured-clone postMessage
-      // when no ring was provided, so we do not allocate/post from the audio
-      // render callback in SAB mode.
-      if (this.meterRing) {
-        this.writeMeterRing(meter);
+      // The ring branch returned above, so this is the structured-clone
+      // fallback. `onMeter` and `postMessage` are alternative channels for the
+      // same record, not a broadcast pair: the AudioWorklet registration
+      // resolves BOTH to `port.postMessage`, so calling them in turn delivered
+      // every record twice and doubled the host's peak-hold decay rate. Take
+      // the first channel the transport offers.
+      if (this.transport?.onMeter) {
+        this.transport.onMeter(meter);
       } else {
-        this.transport?.onMeter?.(meter);
         this.transport?.postMessage?.(meter);
       }
     }
@@ -970,49 +1186,72 @@ export class SonareRealtimeEngineWorkletProcessor {
     for (let field = 0; field < 11; field++) {
       ring.records[offset + 3 + field] = this.engine.meterScratchValue(field);
     }
+    ring.records[offset + 14] = this.engine.meterScratchInputPeakDbL();
+    ring.records[offset + 15] = this.engine.meterScratchInputPeakDbR();
     Atomics.store(ring.header, 0, writeIndex + 1);
   }
 
-  private writeMeterRing(meter: SonareWorkletMeterSnapshot): void {
-    const ring = this.meterRing;
-    if (!ring) {
-      return;
-    }
-    const writeIndex = Atomics.load(ring.header, 0);
-    const offset = (writeIndex % ring.capacity) * SONARE_METER_RING_RECORD_FLOATS;
-    ring.records[offset] = encodeFrameLo(meter.frame);
-    ring.records[offset + 1] = encodeFrameHi(meter.frame);
-    ring.records[offset + 2] = meter.targetId;
-    ring.records[offset + 3] = meter.peakDbL;
-    ring.records[offset + 4] = meter.peakDbR;
-    ring.records[offset + 5] = meter.rmsDbL;
-    ring.records[offset + 6] = meter.rmsDbR;
-    ring.records[offset + 7] = meter.correlation;
-    ring.records[offset + 8] = meter.truePeakDbL;
-    ring.records[offset + 9] = meter.truePeakDbR;
-    ring.records[offset + 10] = meter.momentaryLufs;
-    ring.records[offset + 11] = meter.shortTermLufs;
-    ring.records[offset + 12] = meter.integratedLufs;
-    ring.records[offset + 13] = meter.gainReductionDb;
-    Atomics.store(ring.header, 0, writeIndex + 1);
-    // writeIndex is a free-running monotonic counter, so an overflow guard here
-    // would fire on essentially every write past the first `capacity` records
-    // and store an ever-growing value, not a dropped-record count. Readers
-    // already detect silent overrun via firstReadable = max(readIndex,
-    // writeIndex - capacity), so header slot 3 is left at its initial 0.
-  }
+  // A snapshot-object ring writer used to live here as well. It was
+  // unreachable: publishMeters returns after the writeMeterScratch loop
+  // whenever a ring exists, so the ring is never fed from a materialised
+  // snapshot. writeMeterScratch above is the only ring writer, and it keeps the
+  // render callback allocation-free by reading the engine's scratch registers
+  // directly.
+  //
+  // writeIndex is a free-running monotonic counter, so an overflow guard would
+  // fire on essentially every write past the first `capacity` records and store
+  // an ever-growing value, not a dropped-record count. Readers already detect
+  // silent overrun via firstReadable = max(readIndex, writeIndex - capacity),
+  // so header slot 3 is left at its initial 0.
 
   // Drains the engine's scope producer (FFT spectrum + goniometer points) into
-  // the lock-free SAB scope ring. No allocation on the render path: records are
-  // written field-by-field into the ring.
+  // the lock-free SAB scope ring or the bounded postMessage fallback. The SAB
+  // path remains allocation-free; postMessage materialises only records that
+  // are ready to publish.
   private publishScope(): void {
-    const ring = this.scopeRing;
-    if (!ring) {
+    if (!this.scopeEnabled) {
       return;
     }
+    const ring = this.scopeRing;
+    const transport = this.transport;
     for (let count = 0; count < 64 && this.engine.popScopeTelemetryToScratch(); count++) {
-      this.writeScopeScratch(ring);
+      if (ring) {
+        this.writeScopeScratch(ring);
+      } else {
+        this.postScopeScratch(transport);
+      }
+    }
+  }
+
+  private postScopeScratch(transport: WorkletTransport | undefined): void {
+    if (!transport?.postMessage) {
+      return;
+    }
+    const bandCount = Math.min(
+      SONARE_SCOPE_MAX_BANDS,
+      Math.max(0, Math.trunc(Number(this.engine.scopeScratchBandCount()))),
+    );
+    const pointCount = Math.min(
+      SONARE_SCOPE_MAX_POINTS,
+      Math.max(0, Math.trunc(Number(this.engine.scopeScratchPointCount()))),
+    );
+    const bands = new Float32Array(bandCount);
+    for (let i = 0; i < bandCount; i++) {
+      bands[i] = this.engine.scopeScratchBand(i);
+    }
+    const points = new Float32Array(pointCount * 2);
+    for (let i = 0; i < pointCount; i++) {
+      points[2 * i] = this.engine.scopeScratchPointLeft(i);
+      points[2 * i + 1] = this.engine.scopeScratchPointRight(i);
     }
+    const scope: SonareWorkletScopeSnapshot = {
+      type: 'scope',
+      targetId: this.engine.scopeScratchTargetId(),
+      frame: Number(this.engine.scopeScratchRenderFrame()),
+      bands,
+      points,
+    };
+    transport.postMessage(scope, [bands.buffer, points.buffer]);
   }
 
   private writeScopeScratch(ring: SharedScopeRingWriter): void {

package/src/worklet/engine-register.ts

@@ -9,6 +9,7 @@ import {
   isEngineTransportRequestMessage,
 } from './guards';
 import type { SonareRealtimeEngineWorkletProcessorOptions, WorkletPort } from './messages';
+import { isRecord } from './protocol';
 
 export function registerSonareRealtimeEngineWorkletProcessor(
   name = 'sonare-realtime-engine-processor',
@@ -43,15 +44,7 @@ export function registerSonareRealtimeEngineWorkletProcessor(
           }
           return;
         }
-        if (isEngineCommandRecord(event.data)) {
-          this.bridge.receiveCommand(event.data);
-        } else if (isEngineSyncMessage(event.data)) {
-          this.bridge.receiveSync(event.data);
-        } else if (isEngineCaptureRequestMessage(event.data)) {
-          this.bridge.receiveCaptureRequest(event.data);
-        } else if (isEngineTransportRequestMessage(event.data)) {
-          this.bridge.receiveTransportRequest(event.data);
-        }
+        this.routeMessage(event.data);
       };
       if (port?.addEventListener) {
         port.addEventListener('message', onMessage);
@@ -72,18 +65,39 @@ export function registerSonareRealtimeEngineWorkletProcessor(
       return true;
     }
 
+    /**
+     * Single dispatch point for the port, shared with the buffered replay so
+     * the two cannot recognize different message sets.
+     */
+    private routeMessage(data: unknown): void {
+      const bridge = this.bridge;
+      if (!bridge) {
+        return;
+      }
+      if (isEngineCommandRecord(data)) {
+        bridge.receiveCommand(data);
+      } else if (isEngineSyncMessage(data)) {
+        bridge.receiveSync(data);
+      } else if (isEngineCaptureRequestMessage(data)) {
+        bridge.receiveCaptureRequest(data);
+      } else if (isEngineTransportRequestMessage(data)) {
+        bridge.receiveTransportRequest(data);
+      } else if (isRecord(data) && typeof data.type === 'string' && data.type.startsWith('sync')) {
+        // A sync the guard does not accept would otherwise vanish, leaving the
+        // live engine out of step with the offline mirror and nothing to see.
+        // Report it through the same channel as a sync the engine rejected.
+        this.port?.postMessage?.({
+          type: 'syncError',
+          syncType: data.type,
+          message: `Unrecognized worklet sync message: ${data.type}`,
+        });
+      }
+    }
+
     private replayPendingMessages(): void {
       const messages = this.pendingMessages.splice(0);
       for (const data of messages) {
-        if (isEngineCommandRecord(data)) {
-          this.bridge?.receiveCommand(data);
-        } else if (isEngineSyncMessage(data)) {
-          this.bridge?.receiveSync(data);
-        } else if (isEngineCaptureRequestMessage(data)) {
-          this.bridge?.receiveCaptureRequest(data);
-        } else if (isEngineTransportRequestMessage(data)) {
-          this.bridge?.receiveTransportRequest(data);
-        }
+        this.routeMessage(data);
       }
     }