@libraz/libsonare 1.8.0 → 1.8.2

package/src/worklet/engine-node.ts

@@ -5,12 +5,15 @@ import {
   isClipPageRequestMessage,
   isEngineCaptureResponseForOperation,
   isEngineCaptureResponseMessage,
+  isEngineInsertGainReductionResponseMessage,
   isEngineTelemetryRecord,
   isEngineTransportResponseMessage,
   isExternalMidiBatchMessage,
   isMeterSnapshot,
+  isScopeSnapshot,
   requireChannelCount,
   requireIntegerOption,
+  resolveScopeBandCount,
 } from './guards';
 import type {
   SonareEngineCaptureRequestMessage,
@@ -72,7 +75,8 @@ function isValidCommandRecord(command: SonareEngineCommandRecord): boolean {
     !Number.isSafeInteger(type) ||
     type < SonareEngineCommandType.SetParam ||
     (type > SonareEngineCommandType.SeekMarker &&
-      type !== SonareEngineCommandType.SetTrackMonitorMode)
+      type !== SonareEngineCommandType.SetTrackMonitorMode &&
+      type !== SonareEngineCommandType.ResetMasterLoudnessMeter)
   ) {
     return false;
   }
@@ -141,6 +145,14 @@ export class SonareRealtimeEngineNode {
       reject: (reason?: unknown) => void;
     }
   >();
+  private insertGainReductionRequestId = 1;
+  private readonly insertGainReductionRequests = new Map<
+    number,
+    {
+      resolve: (values: number[]) => void;
+      reject: (reason?: unknown) => void;
+    }
+  >();
   private resolveReady!: () => void;
   private rejectReady!: (reason?: unknown) => void;
   private destroyed = false;
@@ -202,10 +214,22 @@ export class SonareRealtimeEngineNode {
             pending.reject(new Error(event.data.error ?? 'Transport request failed'));
           }
         }
+      } else if (isEngineInsertGainReductionResponseMessage(event.data)) {
+        const pending = this.insertGainReductionRequests.get(event.data.requestId);
+        if (pending) {
+          this.insertGainReductionRequests.delete(event.data.requestId);
+          if (event.data.ok && Array.isArray(event.data.values)) {
+            pending.resolve(event.data.values);
+          } else {
+            pending.reject(new Error(event.data.error ?? 'Insert gain reduction request failed'));
+          }
+        }
       } else if (isEngineTelemetryRecord(event.data)) {
         this.emitTelemetry(event.data);
       } else if (isMeterSnapshot(event.data)) {
         this.emitMeter(event.data);
+      } else if (isScopeSnapshot(event.data)) {
+        this.emitScope(event.data);
       } else if (isExternalMidiBatchMessage(event.data)) {
         this.emitMidiOut(event.data.events);
       } else if (isClipPageRequestMessage(event.data)) {
@@ -273,6 +297,13 @@ export class SonareRealtimeEngineNode {
       );
     }
 
+    const meterIntervalFrames = requireIntegerOption(
+      options.meterIntervalFrames,
+      2048,
+      'meterIntervalFrames',
+      0,
+    );
+
     // Resolved before the transport branch, so a capacity the ring could not
     // hold is refused by name whichever transport the caller ends up with.
     const commandRingCapacity = requireIntegerOption(
@@ -302,7 +333,7 @@ export class SonareRealtimeEngineNode {
       'scopeRingCapacity',
       1,
     );
-    const scopeBands = requireIntegerOption(options.scopeBands, 48, 'scopeBands', 1);
+    const scopeBands = resolveScopeBandCount(options.scopeBands);
     const clipPageRequestRingCapacity = requireIntegerOption(
       options.clipPageRequestRingCapacity,
       128,
@@ -352,6 +383,7 @@ export class SonareRealtimeEngineNode {
       sampleRate: options.sampleRate ?? context.sampleRate,
       blockSize,
       channelCount,
+      meterIntervalFrames,
       cueOutput,
       commandSharedBuffer: commandRing?.sharedBuffer,
       commandRingCapacity: commandRing?.capacity,
@@ -361,8 +393,8 @@ export class SonareRealtimeEngineNode {
       meterRingCapacity: meterRing?.capacity,
       scopeSharedBuffer: scopeRing?.sharedBuffer,
       scopeRingCapacity: scopeRing?.capacity,
-      scopeBands: scopeRing?.bands,
-      scopeIntervalFrames: scopeRing ? scopeIntervalFrames : undefined,
+      scopeBands: scopeIntervalFrames > 0 ? (scopeRing?.bands ?? scopeBands) : undefined,
+      scopeIntervalFrames: scopeIntervalFrames > 0 ? scopeIntervalFrames : undefined,
       clipPageRequestSharedBuffer: clipPageRequestRing?.sharedBuffer,
       clipPageRequestRingCapacity: clipPageRequestRing?.capacity,
       externalMidiSharedBuffer: externalMidiRing?.sharedBuffer,
@@ -416,6 +448,11 @@ export class SonareRealtimeEngineNode {
     return this.sendCommand({ type: SonareEngineCommandType.TransportPlay, sampleTime });
   }
 
+  /** Queues a reset of the master's integrated-loudness accumulator. */
+  resetMasterLoudnessMeter(sampleTime = -1): boolean {
+    return this.sendCommand({ type: SonareEngineCommandType.ResetMasterLoudnessMeter, sampleTime });
+  }
+
   stop(sampleTime = -1): boolean {
     return this.sendCommand({ type: SonareEngineCommandType.TransportStop, sampleTime });
   }
@@ -641,6 +678,10 @@ export class SonareRealtimeEngineNode {
       pending.reject(new Error('Realtime engine node is destroyed.'));
     }
     this.transportRequests.clear();
+    for (const pending of this.insertGainReductionRequests.values()) {
+      pending.reject(new Error('Realtime engine node is destroyed.'));
+    }
+    this.insertGainReductionRequests.clear();
     this.telemetryListeners.clear();
     this.meterListeners.clear();
     this.scopeListeners.clear();
@@ -710,6 +751,30 @@ export class SonareRealtimeEngineNode {
     }
   }
 
+  /**
+   * Reads one target's per-insert gain reduction (dB, each <= 0, pre-to-post insert order)
+   * from the worklet. Works in both ring and postMessage meter modes; rejects when the
+   * target is invalid or mixing is not compiled in.
+   */
+  pollInsertGainReduction(targetId: number): Promise<number[]> {
+    if (this.destroyed) {
+      return Promise.reject(new Error('Realtime engine node is destroyed.'));
+    }
+    const requestId = this.insertGainReductionRequestId++;
+    let rejectRequest!: (reason?: unknown) => void;
+    const promise = new Promise<number[]>((resolve, reject) => {
+      rejectRequest = reject;
+      this.insertGainReductionRequests.set(requestId, { resolve, reject });
+    });
+    try {
+      this.node.port.postMessage({ type: 'insertGainReductionRequest', requestId, targetId });
+    } catch (error) {
+      this.insertGainReductionRequests.delete(requestId);
+      rejectRequest(error);
+    }
+    return promise;
+  }
+
   private emitScope(scope: SonareWorkletScopeSnapshot): void {
     for (const listener of this.scopeListeners) {
       listener(scope);

package/src/worklet/engine-processor.ts

@@ -1,14 +1,21 @@
 import type { EngineClip } from '../index';
 import { RealtimeEngine } from '../index';
 import { copyPlanesToOutput, type WorkletInput, type WorkletOutput } from './audio_types';
-import { emptyStripJson } from './engine-mixer-facade';
-import { requireChannelCount, requireIntegerOption } from './guards';
+import {
+  requireChannelCount,
+  requireIntegerOption,
+  resolveScopeBandCount,
+  SONARE_SCOPE_MAX_BANDS,
+  SONARE_SCOPE_MAX_POINTS,
+} from './guards';
 import {
   DEFAULT_METRONOME_CONFIG,
   type ResolvedMetronomeConfig,
   resolveMetronomeConfig,
   type SonareEngineCaptureRequestMessage,
   type SonareEngineCaptureResponseMessageInternal,
+  type SonareEngineInsertGainReductionRequestMessage,
+  type SonareEngineInsertGainReductionResponseMessage,
   type SonareEngineSyncMessage,
   type SonareEngineTransportRequestMessage,
   type SonareEngineTransportResponseMessage,
@@ -41,6 +48,8 @@ import {
   type SonareEngineTelemetryRecord,
   type SonareEngineTelemetryRingBuffer,
   SonareEngineTelemetryType,
+  type SonareWorkletMeterSnapshot,
+  type SonareWorkletScopeSnapshot,
   scopeRingFromSharedBuffer,
   telemetryFromEngine,
   writeInt64Words,
@@ -84,6 +93,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 };
@@ -146,6 +158,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,
@@ -183,18 +205,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) {
-      // Zero is the engine's own off switch for the scope tap, so the floor is 0.
-      const interval = requireIntegerOption(
-        options.scopeIntervalFrames,
-        this.blockSize,
-        'scopeIntervalFrames',
-        0,
+    // 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),
       );
-      this.engine.configureScopeTelemetry(interval, this.scopeRing.bands);
     }
   }
 
@@ -496,37 +512,32 @@ export class SonareRealtimeEngineWorkletProcessor {
         // Complete earlier immediate edits in message order. Scheduled
         // commands remain queued for their render frame.
         this.engine.applyCommandsDueNowPreservingFuture();
-        this.engine.settleInsertParameters();
         if (message.buses) {
           this.engine.setTrackBuses(message.buses);
         }
         this.engine.setTrackLanes(message.lanes);
-        for (const target of message.forceInsertResets ?? []) {
-          const emptyJson = emptyStripJson(target);
+        for (const strip of message.trackStrips ?? []) {
+          this.engine.setTrackStripJson(strip.trackId, strip.sceneJson);
+        }
+        for (const strip of message.busStrips ?? []) {
+          this.engine.setBusStripJson(strip.busId, strip.sceneJson);
+        }
+        if (message.masterStripJson) {
+          this.engine.setMasterStripJson(message.masterStripJson);
+        }
+        for (const target of message.insertBaseResets ?? []) {
           switch (target.kind) {
             case 'track':
               this.engine.clearTrackInsertParameterBases(target.trackId);
-              this.engine.setTrackStripJson(target.trackId, emptyJson);
               break;
             case 'bus':
               this.engine.clearBusInsertParameterBases(target.busId);
-              this.engine.setBusStripJson(target.busId, emptyJson);
               break;
             case 'master':
               this.engine.clearMasterInsertParameterBases();
-              this.engine.setMasterStripJson(emptyJson);
               break;
           }
         }
-        for (const strip of message.trackStrips ?? []) {
-          this.engine.setTrackStripJson(strip.trackId, strip.sceneJson);
-        }
-        for (const strip of message.busStrips ?? []) {
-          this.engine.setBusStripJson(strip.busId, strip.sceneJson);
-        }
-        if (message.masterStripJson) {
-          this.engine.setMasterStripJson(message.masterStripJson);
-        }
         for (const binding of message.laneSidechains ?? []) {
           this.engine.setLaneSidechain(binding.trackId, binding.insertIndex, binding.sourceTrackId);
         }
@@ -674,6 +685,9 @@ export class SonareRealtimeEngineWorkletProcessor {
       case 'syncTrackStripDualPan':
         this.engine.setTrackStripDualPan(message.trackId, message.leftPan, message.rightPan);
         break;
+      case 'syncTrackStripSurroundPan':
+        this.engine.setTrackStripSurroundPan(message.trackId, message.pan);
+        break;
       case 'syncBusStripPan':
         this.engine.setBusStripPan(message.busId, message.pan);
         break;
@@ -766,7 +780,11 @@ export class SonareRealtimeEngineWorkletProcessor {
         );
         break;
       case 'syncMidiUmp':
-        this.engine.pushMidiUmp(message.destinationId, [message.word0], message.renderFrame);
+        this.engine.pushMidiUmp(
+          message.destinationId,
+          message.words ?? [message.word0],
+          message.renderFrame,
+        );
         break;
       case 'syncMidiSysex':
         this.engine.pushMidiSysex(message.destinationId, message.data, message.renderFrame);
@@ -844,6 +862,9 @@ export class SonareRealtimeEngineWorkletProcessor {
           message.portTimeSamples,
         );
         break;
+      case 'syncMidiInputUmp':
+        this.engine.pushMidiInputUmp(message.words, message.portTimeSamples);
+        break;
     }
   }
 
@@ -923,6 +944,27 @@ export class SonareRealtimeEngineWorkletProcessor {
     }
   }
 
+  receiveInsertGainReductionRequest(message: SonareEngineInsertGainReductionRequestMessage): void {
+    if (this.closed) {
+      return;
+    }
+    try {
+      this.transport?.postMessage?.({
+        type: 'insertGainReductionResponse',
+        requestId: message.requestId,
+        ok: true,
+        values: this.engine.meterTargetInsertGainReduction(message.targetId),
+      } satisfies SonareEngineInsertGainReductionResponseMessage);
+    } catch (error) {
+      this.transport?.postMessage?.({
+        type: 'insertGainReductionResponse',
+        requestId: message.requestId,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      } satisfies SonareEngineInsertGainReductionResponseMessage);
+    }
+  }
+
   destroy(): void {
     if (!this.closed) {
       this.clearPagedClipProviders();
@@ -1056,6 +1098,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,
@@ -1140,6 +1185,8 @@ export class SonareRealtimeEngineWorkletProcessor {
       }
       return;
     }
+    const delivered: SonareWorkletMeterSnapshot[] = [];
+    const newestByTarget = new Map<number, SonareWorkletMeterSnapshot>();
     for (const item of this.engine.drainMeterTelemetry(64)) {
       const meter = meterFromEngine(item);
       if (
@@ -1151,6 +1198,15 @@ export class SonareRealtimeEngineWorkletProcessor {
       if (meter.frame !== this.lastMeterFrame) {
         this.lastMeterFrame = meter.frame;
       }
+      delivered.push(meter);
+      newestByTarget.set(meter.targetId, meter);
+    }
+    for (const meter of delivered) {
+      // The board holds only the latest block, so only the newest record per
+      // target in this drain can carry it; the ring layout is fixed and cannot.
+      if (newestByTarget.get(meter.targetId) === meter) {
+        meter.insertGainReductionDb = this.engine.meterTargetInsertGainReduction(meter.targetId);
+      }
       // 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
@@ -1175,6 +1231,8 @@ 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);
   }
 
@@ -1192,16 +1250,53 @@ export class SonareRealtimeEngineWorkletProcessor {
   // 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

@@ -5,6 +5,7 @@ import { SonareRealtimeEngineWorkletProcessor } from './engine-processor';
 import {
   isEngineCaptureRequestMessage,
   isEngineCommandRecord,
+  isEngineInsertGainReductionRequestMessage,
   isEngineSyncMessage,
   isEngineTransportRequestMessage,
 } from './guards';
@@ -82,6 +83,8 @@ export function registerSonareRealtimeEngineWorkletProcessor(
         bridge.receiveCaptureRequest(data);
       } else if (isEngineTransportRequestMessage(data)) {
         bridge.receiveTransportRequest(data);
+      } else if (isEngineInsertGainReductionRequestMessage(data)) {
+        bridge.receiveInsertGainReductionRequest(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.

package/src/worklet/engine-strips.ts

@@ -1,13 +1,12 @@
 import { panLawCode, panModeCode } from '../codes';
-import type { EqBand, PanLawInput, PanMode, RealtimeEngine } from '../index';
+import type { EqBand, PanLawInput, PanMode, RealtimeEngine, UmpWords } from '../index';
+import type { SurroundPan } from '../public_types';
 import type { InsertParamOverrideMap } from './engine-mixer-facade';
 import {
-  applyFullStripJson,
-  clearInsertParamOverrides,
   emptyStripJson,
-  hasInsertParamOverrides,
   type InsertParamOverride,
   insertParamOverrideKey,
+  replaceStripScene,
   type StripJsonTarget,
 } from './engine-mixer-facade';
 import type { SonareEngineInstrumentSyncMessage, SonareEngineSyncMessage } from './messages';
@@ -27,6 +26,7 @@ export interface EngineStripContext {
   readStripJson(target: StripJsonTarget): string | undefined;
   writeStripJson(target: StripJsonTarget, sceneJson: string): void;
   readonly insertParamOverrides: InsertParamOverrideMap;
+  clearInsertAutomationLanes(target: StripJsonTarget): void;
 }
 
 function trackIdFor(ctx: EngineStripContext, target: string | number): number {
@@ -92,15 +92,11 @@ export function setTrackStripJson(
   trackId: number,
   sceneJson: string,
   trackStripJson: Map<number, string>,
-): { resetInserts: boolean } {
+): { insertBaseResets: StripJsonTarget[]; constructionOverrides: InsertParamOverride[] } {
   const target: StripJsonTarget = { kind: 'track', trackId };
-  const resetInserts =
-    (trackStripJson.has(trackId) && trackStripJson.get(trackId) !== sceneJson) ||
-    hasInsertParamOverrides(ctx.insertParamOverrides, target);
-  applyFullStripJson(ctx.offlineEngine, target, sceneJson, resetInserts);
-  clearInsertParamOverrides(ctx.insertParamOverrides, target);
+  const result = replaceStripScene(ctx, target, trackStripJson.get(trackId), sceneJson);
   trackStripJson.set(trackId, sceneJson);
-  return { resetInserts };
+  return result;
 }
 
 export function setTrackStripEqBand(
@@ -210,6 +206,26 @@ export function setTrackStripDualPan(
   ctx.postSync({ type: 'syncTrackStripDualPan', trackId, leftPan, rightPan });
 }
 
+export function setTrackStripSurroundPan(
+  ctx: EngineStripContext,
+  target: string | number,
+  pan: SurroundPan,
+): void {
+  const trackId = trackIdFor(ctx, target);
+  ctx.offlineEngine.setTrackStripSurroundPan(trackId, pan);
+  const resolved = {
+    azimuth: pan.azimuth ?? 0,
+    elevation: pan.elevation ?? 0,
+    divergence: pan.divergence ?? 0,
+    lfe: pan.lfe ?? 0,
+    distance: pan.distance === undefined || pan.distance <= 0 ? 1 : pan.distance,
+  };
+  mergeStripJson(ctx, { kind: 'track', trackId }, (entry) => {
+    entry.surroundPan = resolved;
+  });
+  ctx.postSync({ type: 'syncTrackStripSurroundPan', trackId, pan: resolved });
+}
+
 export function setTrackStripChannelDelaySamples(
   ctx: EngineStripContext,
   target: string | number,
@@ -504,12 +520,18 @@ export function pushMidiPolyPressure(
 export function pushMidiUmp(
   ctx: EngineStripContext,
   trackId: string | number,
-  word0: number,
+  word0: number | UmpWords,
   renderFrame: number,
 ): void {
   const destinationId = ctx.resolveTargetId(trackId);
-  ctx.offlineEngine.pushMidiUmp(destinationId, [word0], renderFrame);
-  ctx.postSync({ type: 'syncMidiUmp', destinationId, word0, renderFrame });
+  if (typeof word0 === 'number') {
+    ctx.offlineEngine.pushMidiUmp(destinationId, word0, renderFrame);
+    ctx.postSync({ type: 'syncMidiUmp', destinationId, word0, renderFrame });
+    return;
+  }
+  const words = word0 instanceof Uint32Array ? new Uint32Array(word0) : word0.slice();
+  ctx.offlineEngine.pushMidiUmp(destinationId, words, renderFrame);
+  ctx.postSync({ type: 'syncMidiUmp', destinationId, words, renderFrame });
 }
 
 export function setBuiltinInstrument(

package/src/worklet/engine-sync.ts

@@ -11,25 +11,30 @@ import type { SonareEngineSyncTempoMessage } from './messages';
  * Builds the ordered mixer-lane descriptors for a sync message.
  *
  * Each declared track id is paired with its current send list and output bus
- * (both omitted when absent), defensively copying the send entries.
+ * (both omitted when absent) and source channel layout, defensively copying the
+ * send entries.
  *
  * @param trackLaneIds Lane order (track ids) declared on the engine.
  * @param trackSends Per-track send lists.
  * @param trackOutputBus Per-track output bus routing.
+ * @param trackSourceChannelLayout Per-track source channel layouts.
  * @returns Lane descriptors in lane order.
  */
 export function buildMixerLanes(
   trackLaneIds: readonly number[],
   trackSends: ReadonlyMap<number, EngineTrackSend[]>,
   trackOutputBus: ReadonlyMap<number, number>,
+  trackSourceChannelLayout: ReadonlyMap<number, number>,
 ): EngineTrackLane[] {
   return trackLaneIds.map((trackId) => {
     const sends = trackSends.get(trackId);
     const outputBusId = trackOutputBus.get(trackId);
+    const sourceChannelLayout = trackSourceChannelLayout.get(trackId);
     return {
       trackId,
       ...(sends && sends.length > 0 ? { sends: sends.map((send) => ({ ...send })) } : {}),
       ...(outputBusId !== undefined ? { outputBusId } : {}),
+      ...(sourceChannelLayout !== undefined ? { sourceChannelLayout } : {}),
     };
   });
 }