@libraz/libsonare 1.8.0 → 1.8.2

package/dist/worklet.js

@@ -720,6 +720,13 @@ var SampleBank = class {
 };
 
 // src/project_internal.ts
+var projectTimelineHandles = /* @__PURE__ */ new WeakMap();
+function projectTimelineNativeId(owner) {
+  if (owner === null || typeof owner !== "object" && typeof owner !== "function") {
+    return void 0;
+  }
+  return projectTimelineHandles.get(owner)?.id;
+}
 function normalizeSynthInstrument(patch) {
   if (patch === null || typeof patch !== "object") {
     return patch;
@@ -736,6 +743,20 @@ function normalizeSynthInstrument(patch) {
   }
   return { ...rest, sampleBankId: sampleBank.nativeId };
 }
+function partRigInsertsJson(inserts) {
+  if (inserts === void 0 || inserts === null) {
+    return void 0;
+  }
+  if (!Array.isArray(inserts)) {
+    throw new TypeError("inserts must be an array");
+  }
+  return JSON.stringify(
+    inserts.map((insert) => {
+      const { processor, params } = insert;
+      return params === void 0 ? { processor } : { processor, params: typeof params === "string" ? params : JSON.stringify(params) };
+    })
+  );
+}
 function projectModule() {
   const candidate = getSonareModule();
   if (typeof candidate.projectAbiVersion !== "function" || candidate.Project === void 0) {
@@ -1149,6 +1170,17 @@ var RealtimeEngine = class _RealtimeEngine {
   setArticulation(destinationId, channel, articulation) {
     this.native.setArticulation(destinationId, channel, articulation);
   }
+  /**
+   * Set the rig of one part (0-15), or of the destination's default when `part`
+   * is `PART_RIG_ALL_PARTS`, on the instrument bound to `destinationId`. A
+   * direct call, not a stored edit: a destination with no instrument is an
+   * invalid parameter, and an instrument without part rigs (a builtin, a
+   * host-callback instrument) is refused as not implemented rather than
+   * succeeding quietly. `'chain'` takes 1-8 `inserts`; no other mode does.
+   */
+  setPartRig(destinationId, part, mode, inserts) {
+    this.native.setPartRig(destinationId, part, mode, partRigInsertsJson(inserts));
+  }
   /**
    * Read back {@link setArticulation} as the canonical name. An ordinal this
    * build cannot spell is handed back as the number, the way every other enum
@@ -1194,7 +1226,10 @@ var RealtimeEngine = class _RealtimeEngine {
   /**
    * Route a destination's (track lane's) MIDI to the external output queue
    * instead of the internal instrument rack, so the track plays an external
-   * device. Clearing it restores internal-synth playback.
+   * device. Clearing it restores internal-synth playback. Control-thread only.
+   * 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. Single writer.
    */
   setMidiDestinationExternal(destinationId, external) {
     this.native.setMidiDestinationExternal(destinationId, external);
@@ -1348,8 +1383,11 @@ var RealtimeEngine = class _RealtimeEngine {
   /**
    * Queue an immediate (live) MIDI SysEx frame to a MIDI destination. `data` is
    * the full message including the leading 0xF0 and trailing 0xF7 (1..512
-   * bytes). `renderFrame` is the frame to fire at, or -1 for immediate. Mirrors
-   * the Node/Python/C-ABI `pushMidiSysex`.
+   * bytes). `renderFrame` is the frame to fire at, or -1 for immediate. Throws
+   * `InvalidParameter` when the destination instrument cannot prepare
+   * the SysEx (retrying cannot help), and `OutOfMemory` when the payload
+   * slots or the command queue are full (retry after a processed block).
+   * Mirrors the Node/Python/C-ABI `pushMidiSysex`.
    */
   pushMidiSysex(destinationId, data, renderFrame = -1) {
     this.native.pushMidiSysex(destinationId, data, renderFrame);
@@ -1372,12 +1410,30 @@ var RealtimeEngine = class _RealtimeEngine {
   getTransportState() {
     return this.native.getTransportState();
   }
+  /** Queues an integrated-loudness reset; short-term and momentary windows are retained. */
+  resetMasterLoudnessMeter(renderFrame = -1) {
+    this.native.resetMasterLoudnessMeter(renderFrame);
+  }
+  /** Reads the immutable factory value for a resolved insert parameter id. */
+  insertParameterConstructedValue(paramId) {
+    return this.native.insertParameterConstructedValue(paramId);
+  }
   play(renderFrame = -1) {
     this.native.play(renderFrame);
   }
+  /**
+   * 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.
+   */
   stop(renderFrame = -1) {
     this.native.stop(renderFrame);
   }
+  /**
+   * 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.
+   */
   seekSample(timelineSample, renderFrame = -1) {
     this.native.seekSample(timelineSample, renderFrame);
   }
@@ -1402,6 +1458,11 @@ var RealtimeEngine = class _RealtimeEngine {
   applyCommandsDueNowPreservingFuture() {
     this.native.applyCommandsDueNowPreservingFuture();
   }
+  /**
+   * 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.
+   */
   seekPpq(ppq, renderFrame = -1) {
     this.native.seekPpq(ppq, renderFrame);
   }
@@ -1421,6 +1482,11 @@ var RealtimeEngine = class _RealtimeEngine {
   sampleAtPpq(ppq) {
     return Number(this.native.sampleAtPpq(ppq));
   }
+  /**
+   * 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, endPpq, enabled = true) {
     this.native.setLoop(startPpq, endPpq, enabled);
   }
@@ -1515,25 +1581,56 @@ var RealtimeEngine = class _RealtimeEngine {
         if (typeof lane === "number") {
           return { trackId: lane };
         }
-        if (!lane.sends) {
-          return lane;
-        }
-        return { ...lane, sends: _RealtimeEngine.normalizeSends(lane.sends) };
+        return {
+          ...lane,
+          sends: lane.sends ? _RealtimeEngine.normalizeSends(lane.sends) : void 0
+        };
       })
     );
   }
   /**
    * Keys one insert of a lane strip from another lane's post-strip audio
    * (ducking/sidechainRouter inserts). sourceTrackId 0 removes the binding.
+   * Lanes are processed in key order and the key is delay-compensated to the
+   * destination strip input, so the result depends on neither the lane order
+   * nor the block size. Throws, leaving the bindings unchanged, for a lane
+   * keying itself, a binding that would close a cycle over the lane bindings,
+   * a full binding table and an alignment past the delay ceiling. Not callable
+   * while a block is being processed.
    */
   setLaneSidechain(trackId, insertIndex, sourceTrackId) {
     this.native.setLaneSidechain(trackId, insertIndex, sourceTrackId);
   }
+  /**
+   * Installs a compiled project timeline into this stopped engine, all or
+   * nothing: tempo and time-signature segments, markers, track lanes, track
+   * automation, audio and MIDI clips, and the per-track strips of the project's
+   * mixer scene are replaced in full (a later low-level setter on those domains
+   * is overwritten by the next apply). Instruments, buses, the master strip,
+   * metronome, loop and capture are not touched; bind instruments separately.
+   *
+   * Throws while the transport is playing, for a timeline the engine cannot
+   * hold, and for a scene strip routed from several tracks. A validation
+   * failure leaves the engine unchanged. The engine keeps its own reference, so
+   * {@link ProjectTimeline.dispose} may follow immediately.
+   *
+   * Also throws on an unprepared engine and on a timeline whose sample rate
+   * differs from the engine's. Once a timeline is applied, a later prepare at
+   * another rate is refused until the timeline's clips are cleared.
+   */
+  applyProjectTimeline(timeline) {
+    const timelineId = projectTimelineNativeId(timeline);
+    if (timelineId === void 0) {
+      throw new TypeError("timeline must be a ProjectTimeline instance");
+    }
+    this.native.applyProjectTimeline(timelineId);
+  }
   setTrackBuses(buses) {
     this.native.setTrackBuses(
-      Array.isArray(buses) ? buses.map(
-        (bus) => bus.sends ? { ...bus, sends: _RealtimeEngine.normalizeSends(bus.sends) } : bus
-      ) : buses
+      Array.isArray(buses) ? buses.map((bus) => ({
+        ...bus,
+        sends: bus.sends ? _RealtimeEngine.normalizeSends(bus.sends) : void 0
+      })) : buses
     );
   }
   /**
@@ -1687,6 +1784,16 @@ var RealtimeEngine = class _RealtimeEngine {
    * stages of the offline mastering chain (`repair.*`, `loudness`, and the
    * match stages) have no insert form and no automation id: they buffer the
    * entire signal by construction and do not run on the realtime path.
+   *
+   * 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`, `setParameter`, or `setParameterSmoothed`. 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.
    */
   resolveTrackInsertAutomationId(trackId, insertIndex, paramName) {
     return this.native.resolveTrackInsertAutomationId(trackId, insertIndex, paramName);
@@ -1719,12 +1826,9 @@ var RealtimeEngine = class _RealtimeEngine {
    * return `-1`: they resize voice pools or swap DSP topology, which is not
    * audio-thread safe. Rebind the instrument with a new patch instead.
    *
-   * `gain`, `busDrive`, `cutoffHz`, `resonanceQ`, `envToCutoffCents`,
-   * `lfoToPitchCents` and `pitchOffsetCents` reach voices that are already
-   * sounding from the next block; the rest are cached into per-voice state at
-   * note-on and take effect from the next note, so a lane that moves one of
-   * them under a held note looks inert until the next one speaks — that is the
-   * behaviour, not a dropped write.
+   * All automatable parameters of a NativeSynth reach already-sounding voices
+   * from the next processed block. Voices using GM program patches are
+   * unaffected; parameters apply to NativeSynth's own patch only.
    *
    * The id survives an unbind/rebind of the same destination and applies
    * nothing while that destination is unbound.
@@ -1748,6 +1852,16 @@ var RealtimeEngine = class _RealtimeEngine {
   setTrackStripDualPan(trackId, leftPan, rightPan) {
     this.native.setTrackStripDualPan(trackId, leftPan, rightPan);
   }
+  /**
+   * Sets a track lane strip's surround placement in realtime (glitch-free; a
+   * constant-power 5 ms one-pole glide). Used when the destination has more than
+   * two channels. Omitted fields default to a centered point source
+   * (`distance` 1); a `distance` of 0 or less is treated as 1. Throws for an
+   * unknown track, a track without a lane strip, or a non-finite field.
+   */
+  setTrackStripSurroundPan(trackId, pan) {
+    this.native.setTrackStripSurroundPan(trackId, pan);
+  }
   /**
    * Sets a bus strip's output pan position in realtime (glitch-free). Throws
    * for an unknown bus or one wider than stereo.
@@ -1768,8 +1882,9 @@ var RealtimeEngine = class _RealtimeEngine {
     this.native.setBusStripDualPan(busId, leftPan, rightPan);
   }
   /**
-   * Sets a track lane strip's inter-channel alignment delay (whole samples).
-   * Adjusts strip latency, so PDC and reported graph latency are refreshed.
+   * Sets a track lane strip's alignment delay (whole samples), moving this lane
+   * later relative to every other lane. It is not latency: PDC does not
+   * compensate it and the reported graph latency is unchanged.
    */
   setTrackStripChannelDelaySamples(trackId, delaySamples) {
     this.native.setTrackStripChannelDelaySamples(trackId, delaySamples);
@@ -2013,6 +2128,12 @@ var RealtimeEngine = class _RealtimeEngine {
   meterScratchRenderFrame() {
     return Number(this.native.meterScratchRenderFrame());
   }
+  meterScratchInputPeakDbL() {
+    return this.native.meterScratchInputPeakDbL();
+  }
+  meterScratchInputPeakDbR() {
+    return this.native.meterScratchInputPeakDbR();
+  }
   meterScratchValue(field) {
     return this.native.meterScratchValue(field);
   }
@@ -2022,14 +2143,24 @@ var RealtimeEngine = class _RealtimeEngine {
   /**
    * Drains pending meter telemetry as per-plane (wide) records for a surround
    * target. Use this for a surround mix target; {@link drainMeterTelemetry}
-   * stays the stereo fast path. The two share one queue — call only one per
-   * target. The live AudioWorklet path owns the queue via the stereo drain, so
-   * this wide drain is for an offline (non-worklet) engine instance; per-plane
+   * stays the stereo fast path. The two share one queue and each consumes every
+   * target's records, so an engine uses only one of them. The live AudioWorklet
+   * path owns the queue via the stereo drain, so this wide drain is for an
+   * offline (non-worklet) engine instance; per-plane
    * surround meters are not delivered over the live worklet meter ring.
    */
   drainMeterTelemetryWide(maxRecords = 1024) {
     return this.native.drainMeterTelemetryWide(maxRecords);
   }
+  /**
+   * Per-insert gain reduction in dB (each <= 0) of a meter target's strip from the
+   * last rendered block, in combined pre-to-post insert order. `targetId` uses the
+   * meter-record encoding (0 master, 1..32 lanes, 33..40 buses; 0xFFFF monitor
+   * yields an empty array). Throws for an id outside that range.
+   */
+  meterTargetInsertGainReduction(targetId) {
+    return this.native.meterTargetInsertGainReduction(targetId);
+  }
   /**
    * Enables per-target spectrum + vectorscope capture. @param intervalFrames is
    * the minimum render-frame gap between snapshots (0 disables). @param bandCount
@@ -2186,47 +2317,60 @@ var Mixer = class _Mixer {
    * after {@link delete}.
    */
   createRealtimeBuffer() {
-    const stripCount = this.stripCount();
-    let leftInputs = [];
-    let rightInputs = [];
+    const leftInputs = [];
+    const rightInputs = [];
     let outLeft = this.mixer.outputLeftView();
     let outRight = this.mixer.outputRightView();
+    let acquiredStripCount = -1;
+    const viewsDetached = () => outLeft.byteLength === 0 || outRight.byteLength === 0;
     const acquire = () => {
-      leftInputs = [];
-      rightInputs = [];
-      for (let index = 0; index < stripCount; index++) {
+      const stripCount = this.stripCount();
+      const detached = viewsDetached();
+      if (detached) {
+        leftInputs.length = 0;
+        rightInputs.length = 0;
+      } else {
+        leftInputs.length = Math.min(leftInputs.length, stripCount);
+        rightInputs.length = Math.min(rightInputs.length, stripCount);
+      }
+      for (let index = leftInputs.length; index < stripCount; index++) {
         leftInputs.push(this.mixer.inputLeftView(index));
+      }
+      for (let index = rightInputs.length; index < stripCount; index++) {
         rightInputs.push(this.mixer.inputRightView(index));
       }
-      outLeft = this.mixer.outputLeftView();
-      outRight = this.mixer.outputRightView();
+      if (detached) {
+        outLeft = this.mixer.outputLeftView();
+        outRight = this.mixer.outputRightView();
+      }
+      acquiredStripCount = stripCount;
     };
     acquire();
-    const reacquireIfDetached = () => {
-      if (outLeft.byteLength === 0 || (leftInputs[0]?.byteLength ?? 1) === 0) {
+    const acquireIfNeeded = () => {
+      if (acquiredStripCount !== this.stripCount() || viewsDetached()) {
         acquire();
       }
     };
     return {
       get leftInputs() {
-        reacquireIfDetached();
+        acquireIfNeeded();
         return leftInputs;
       },
       get rightInputs() {
-        reacquireIfDetached();
+        acquireIfNeeded();
         return rightInputs;
       },
       get outLeft() {
-        reacquireIfDetached();
+        acquireIfNeeded();
         return outLeft;
       },
       get outRight() {
-        reacquireIfDetached();
+        acquireIfNeeded();
         return outRight;
       },
-      process: (numSamples = outLeft.length) => {
-        reacquireIfDetached();
-        this.mixer.processPreparedStereo(numSamples);
+      process: (numSamples) => {
+        acquireIfNeeded();
+        this.mixer.processPreparedStereo(numSamples ?? outLeft.length);
       }
     };
   }
@@ -2444,8 +2588,8 @@ var Mixer = class _Mixer {
     this.mixer.setPanLaw(stripIndex, panLawCode(panLaw));
   }
   /**
-   * Set a per-strip channel delay in samples. This changes the strip's reported
-   * latency; recompile to re-run latency compensation.
+   * Set a per-strip channel delay in samples, moving the strip later relative to
+   * the others. It is not latency: latency compensation does not undo it.
    */
   setChannelDelaySamples(stripIndex, delaySamples) {
     this.mixer.setChannelDelaySamples(stripIndex, delaySamples);
@@ -2999,6 +3143,13 @@ var StreamingMasteringChain = class {
   reset() {
     this.chain.reset();
   }
+  /**
+   * Set one realtime-safe full-chain parameter at a serialized block boundary.
+   * Structural, disabled-stage and unknown parameters are rejected.
+   */
+  setParameter(key, value) {
+    this.chain.setParameter(key, value);
+  }
   /** Total reported latency in samples across all active processors. */
   latencySamples() {
     return this.chain.latencySamples();
@@ -3105,14 +3256,16 @@ function isInitialized() {
 }
 
 // src/worklet/engine-sync.ts
-function buildMixerLanes(trackLaneIds, trackSends, trackOutputBus) {
+function buildMixerLanes(trackLaneIds, trackSends, trackOutputBus, trackSourceChannelLayout) {
   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 !== void 0 ? { outputBusId } : {}
+      ...outputBusId !== void 0 ? { outputBusId } : {},
+      ...sourceChannelLayout !== void 0 ? { sourceChannelLayout } : {}
     };
   });
 }
@@ -3187,10 +3340,12 @@ function engineMixerMasterTarget(paramKind) {
   return ENGINE_MIXER_TARGET_BASE | 255 << 8 | paramKind & 255;
 }
 var SONARE_METER_RING_HEADER_INTS = 4;
-var SONARE_METER_RING_RECORD_FLOATS = 14;
+var SONARE_METER_RING_RECORD_FLOATS = 16;
 var SONARE_SPECTRUM_RING_HEADER_INTS = 5;
 var SONARE_SCOPE_RING_HEADER_INTS = 6;
 var SONARE_SCOPE_RING_RECORD_PREFIX_FLOATS = 5;
+var SONARE_SCOPE_DEFAULT_BANDS = 48;
+var SONARE_SCOPE_DEFAULT_MAX_POINTS = 32;
 var SONARE_FRAME_LANE_BASE = 16777216;
 function encodeFrameLo(frame) {
   const f = Math.max(0, Math.floor(frame));
@@ -3230,6 +3385,7 @@ var SonareEngineCommandType = /* @__PURE__ */ ((SonareEngineCommandType2) => {
   SonareEngineCommandType2[SonareEngineCommandType2["SetMarker"] = 16] = "SetMarker";
   SonareEngineCommandType2[SonareEngineCommandType2["SeekMarker"] = 17] = "SeekMarker";
   SonareEngineCommandType2[SonareEngineCommandType2["SetTrackMonitorMode"] = 26] = "SetTrackMonitorMode";
+  SonareEngineCommandType2[SonareEngineCommandType2["ResetMasterLoudnessMeter"] = 28] = "ResetMasterLoudnessMeter";
   return SonareEngineCommandType2;
 })(SonareEngineCommandType || {});
 var SonareEngineTelemetryType = /* @__PURE__ */ ((SonareEngineTelemetryType2) => {
@@ -3262,6 +3418,7 @@ var SonareEngineTelemetryError = /* @__PURE__ */ ((SonareEngineTelemetryError2)
   SonareEngineTelemetryError2[SonareEngineTelemetryError2["ParameterBaseOverflow"] = 21] = "ParameterBaseOverflow";
   return SonareEngineTelemetryError2;
 })(SonareEngineTelemetryError || {});
+var SONARE_FLOOR_DB = -120;
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -3301,7 +3458,9 @@ function readSonareMeterRingBuffer(ring, readIndex = 0) {
       momentaryLufs: ring.records[offset + 10],
       shortTermLufs: ring.records[offset + 11],
       integratedLufs: ring.records[offset + 12],
-      gainReductionDb: ring.records[offset + 13]
+      gainReductionDb: ring.records[offset + 13],
+      inputPeakDbL: ring.records[offset + 14],
+      inputPeakDbR: ring.records[offset + 15]
     });
   }
   return { nextReadIndex: writeIndex, meters };
@@ -3353,13 +3512,13 @@ function readSonareSpectrumRingBuffer(ring, readIndex = 0) {
 function sonareScopeRingRecordFloats(bands, maxPoints) {
   return SONARE_SCOPE_RING_RECORD_PREFIX_FLOATS + bands + 2 * maxPoints;
 }
-function sonareScopeRingBufferByteLength(capacity, bands = 48, maxPoints = 32) {
+function sonareScopeRingBufferByteLength(capacity, bands = SONARE_SCOPE_DEFAULT_BANDS, maxPoints = SONARE_SCOPE_DEFAULT_MAX_POINTS) {
   const clampedCapacity = Math.max(1, Math.floor(capacity));
   const clampedBands = Math.max(1, Math.floor(bands));
   const clampedPoints = Math.max(0, Math.floor(maxPoints));
   return SONARE_SCOPE_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT + clampedCapacity * sonareScopeRingRecordFloats(clampedBands, clampedPoints) * Float32Array.BYTES_PER_ELEMENT;
 }
-function createSonareScopeRingBuffer(capacity = 64, bands = 48, maxPoints = 32) {
+function createSonareScopeRingBuffer(capacity = 64, bands = SONARE_SCOPE_DEFAULT_BANDS, maxPoints = SONARE_SCOPE_DEFAULT_MAX_POINTS) {
   const clampedCapacity = Math.max(1, Math.floor(capacity));
   const clampedBands = Math.max(1, Math.floor(bands));
   const clampedPoints = Math.max(0, Math.floor(maxPoints));
@@ -3426,8 +3585,14 @@ function scopeRingFromSharedBuffer(sharedBuffer, fallbackCapacity, fallbackBands
   const existingBands = Atomics.load(header, 3);
   const existingMaxPoints = Atomics.load(header, 4);
   const capacity = Math.max(1, Math.floor(existingCapacity || fallbackCapacity || 1));
-  const bands = Math.max(1, Math.floor(existingBands || fallbackBands || 48));
-  const maxPoints = Math.max(0, Math.floor(existingMaxPoints || (fallbackMaxPoints ?? 32)));
+  const bands = Math.max(
+    1,
+    Math.floor(existingBands || fallbackBands || SONARE_SCOPE_DEFAULT_BANDS)
+  );
+  const maxPoints = Math.max(
+    0,
+    Math.floor(existingMaxPoints || (fallbackMaxPoints ?? SONARE_SCOPE_DEFAULT_MAX_POINTS))
+  );
   const recordFloats = sonareScopeRingRecordFloats(bands, maxPoints);
   const minBytes = sonareScopeRingBufferByteLength(capacity, bands, maxPoints);
   if (sharedBuffer.byteLength < minBytes) {
@@ -3832,7 +3997,9 @@ function meterFromEngine(meter) {
     momentaryLufs: meter.momentaryLufs,
     shortTermLufs: meter.shortTermLufs,
     integratedLufs: meter.integratedLufs,
-    gainReductionDb: meter.gainReductionDb
+    gainReductionDb: meter.gainReductionDb,
+    inputPeakDbL: meter.inputPeakDbL,
+    inputPeakDbR: meter.inputPeakDbR
   };
 }
 function magnitudeToDb(value) {
@@ -3891,6 +4058,7 @@ var ENGINE_SYNC_MESSAGE_TYPES = {
   syncMidiInputPitchBend: true,
   syncMidiInputPolyPressure: true,
   syncMidiInputSource: true,
+  syncMidiInputUmp: true,
   syncMidiNoteOff: true,
   syncMidiNoteOn: true,
   syncMidiPanic: true,
@@ -3911,6 +4079,7 @@ var ENGINE_SYNC_MESSAGE_TYPES = {
   syncTrackStripPan: true,
   syncTrackStripPanLaw: true,
   syncTrackStripPanMode: true,
+  syncTrackStripSurroundPan: true,
   syncWarpVoiceCapacity: true
 };
 var engineSyncMessageTypes = new Set(Object.keys(ENGINE_SYNC_MESSAGE_TYPES));
@@ -3981,6 +4150,12 @@ function isEngineTransportRequestMessage(value) {
 function isEngineTransportResponseMessage(value) {
   return isRecord(value) && value.type === "transportResponse" && typeof value.requestId === "number" && typeof value.ok === "boolean";
 }
+function isEngineInsertGainReductionRequestMessage(value) {
+  return isRecord(value) && value.type === "insertGainReductionRequest" && typeof value.requestId === "number" && typeof value.targetId === "number";
+}
+function isEngineInsertGainReductionResponseMessage(value) {
+  return isRecord(value) && value.type === "insertGainReductionResponse" && typeof value.requestId === "number" && typeof value.ok === "boolean";
+}
 function isRealtimeVoiceChangerMessage(value) {
   if (!isRecord(value) || typeof value.type !== "string") {
     return false;
@@ -4017,7 +4192,23 @@ function isClipPageRequestMessage(value) {
   );
 }
 function isMeterSnapshot(value) {
-  return isRecord(value) && value.type === "meter" && typeof value.frame === "number" && typeof value.peakDbL === "number" && typeof value.peakDbR === "number" && typeof value.rmsDbL === "number" && typeof value.rmsDbR === "number" && typeof value.correlation === "number" && (typeof value.targetId === "number" || value.targetId === void 0);
+  return isRecord(value) && value.type === "meter" && typeof value.frame === "number" && typeof value.peakDbL === "number" && typeof value.peakDbR === "number" && typeof value.rmsDbL === "number" && typeof value.rmsDbR === "number" && typeof value.correlation === "number" && Number.isFinite(value.inputPeakDbL) && Number.isFinite(value.inputPeakDbR) && (typeof value.targetId === "number" || value.targetId === void 0);
+}
+var SONARE_SCOPE_MAX_BANDS = 64;
+var SONARE_SCOPE_MAX_POINTS = 32;
+function isPlainFloat32Array(value, maxLength, evenLength = false) {
+  if (!(value instanceof Float32Array) || typeof ArrayBuffer === "undefined" || !(value.buffer instanceof ArrayBuffer) || value.length > maxLength || evenLength && value.length % 2 !== 0) {
+    return false;
+  }
+  for (const sample of value) {
+    if (!Number.isFinite(sample)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isScopeSnapshot(value) {
+  return isRecord(value) && value.type === "scope" && typeof value.targetId === "number" && Number.isSafeInteger(value.targetId) && value.targetId >= 0 && value.targetId <= 4294967295 && typeof value.frame === "number" && Number.isSafeInteger(value.frame) && value.frame >= 0 && isPlainFloat32Array(value.bands, SONARE_SCOPE_MAX_BANDS) && value.bands.length > 0 && isPlainFloat32Array(value.points, SONARE_SCOPE_MAX_POINTS * 2, true);
 }
 function requireIntegerOption(value, fallback, name, minimum) {
   const resolved = value ?? fallback;
@@ -4026,6 +4217,9 @@ function requireIntegerOption(value, fallback, name, minimum) {
   }
   return resolved;
 }
+function resolveScopeBandCount(value, fallback = SONARE_SCOPE_DEFAULT_BANDS) {
+  return Math.min(requireIntegerOption(value, fallback, "scopeBands", 1), SONARE_SCOPE_MAX_BANDS);
+}
 function requireInteger(value, fallback, name) {
   const resolved = value ?? fallback;
   if (!Number.isSafeInteger(resolved)) {
@@ -4325,6 +4519,156 @@ function syncMarkers(ctx) {
 }
 
 // src/worklet/engine-mixer-facade.ts
+function isSceneObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasOwn2(object, key) {
+  return Object.getOwnPropertyDescriptor(object, key) !== void 0;
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    const object = value;
+    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(object[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function aliasedValue(object, primary, legacy) {
+  if (hasOwn2(object, primary)) {
+    return { present: true, value: object[primary] };
+  }
+  if (hasOwn2(object, legacy)) {
+    return { present: true, value: object[legacy] };
+  }
+  return { present: false, value: void 0 };
+}
+function insertSignature(insert) {
+  const object = insert !== null && typeof insert === "object" ? insert : {};
+  const slot = object.slot === void 0 ? "pre" : object.slot;
+  const processor = aliasedValue(object, "processor", "processor_name");
+  const params = aliasedValue(object, "params", "params_json");
+  const sidechain = aliasedValue(object, "sidechainKey", "sidechain_key");
+  const processorValue = typeof processor.value === "string" ? processor.value : "";
+  const sidechainValue = typeof sidechain.value === "string" ? sidechain.value : "";
+  let paramsValue;
+  if (!params.present) {
+    paramsValue = ["absent"];
+  } else if (typeof params.value === "string") {
+    if (params.value.length === 0) {
+      paramsValue = ["absent"];
+    } else {
+      try {
+        paramsValue = ["params", canonicalJson(JSON.parse(params.value))];
+      } catch {
+        paramsValue = ["params-invalid", params.value];
+      }
+    }
+  } else {
+    paramsValue = ["params", canonicalJson(params.value)];
+  }
+  return JSON.stringify([slot, processorValue, paramsValue, sidechainValue]);
+}
+function decodedInsertSignature(sceneJson, target) {
+  const scene = JSON.parse(sceneJson);
+  const entries = target.kind === "bus" ? scene.buses : scene.strips;
+  const strip = Array.isArray(entries) ? entries.find(isSceneObject) : void 0;
+  const object = isSceneObject(strip) ? strip : {};
+  const inserts = Array.isArray(object.inserts) ? object.inserts.filter(isSceneObject) : [];
+  const ordered = target.kind === "bus" ? inserts : [
+    ...inserts.filter((insert) => insert.slot !== "post"),
+    ...inserts.filter((insert) => insert.slot === "post")
+  ];
+  return JSON.stringify(ordered.map(insertSignature));
+}
+function constructionValue(engine, target, override) {
+  let parameterId = -1;
+  switch (target.kind) {
+    case "track":
+      parameterId = engine.resolveTrackInsertAutomationId(
+        target.trackId,
+        override.insertIndex,
+        override.paramName
+      );
+      break;
+    case "bus":
+      parameterId = engine.resolveBusInsertAutomationId(
+        target.busId,
+        override.insertIndex,
+        override.paramName
+      );
+      break;
+    case "master":
+      parameterId = engine.resolveMasterInsertAutomationId(
+        override.insertIndex,
+        override.paramName
+      );
+      break;
+  }
+  if (parameterId < 0) {
+    return void 0;
+  }
+  return engine.insertParameterConstructedValue(parameterId);
+}
+function constructionInsertOverrides(engine, target, overrides) {
+  const restored = [];
+  for (const override of overrides.values()) {
+    if (!sameStripTarget(override.target, target)) {
+      continue;
+    }
+    const value = constructionValue(engine, target, override);
+    if (value !== void 0) {
+      restored.push({ ...override, value });
+    }
+  }
+  return restored;
+}
+function applyInsertParamOverride(engine, override) {
+  switch (override.target.kind) {
+    case "track":
+      engine.restoreTrackStripInsertParamByName(
+        override.target.trackId,
+        override.insertIndex,
+        override.paramName,
+        override.value
+      );
+      break;
+    case "bus":
+      engine.restoreBusStripInsertParamByName(
+        override.target.busId,
+        override.insertIndex,
+        override.paramName,
+        override.value
+      );
+      break;
+    case "master":
+      engine.restoreMasterStripInsertParamByName(
+        override.insertIndex,
+        override.paramName,
+        override.value
+      );
+      break;
+  }
+}
+function applyConstructionInsertOverrides(engine, overrides) {
+  for (const override of overrides) {
+    applyInsertParamOverride(engine, override);
+  }
+}
+function clearInsertParameterBases(engine, target) {
+  switch (target.kind) {
+    case "track":
+      engine.clearTrackInsertParameterBases(target.trackId);
+      break;
+    case "bus":
+      engine.clearBusInsertParameterBases(target.busId);
+      break;
+    case "master":
+      engine.clearMasterInsertParameterBases();
+      break;
+  }
+}
 function emptyStripJson(target) {
   switch (target.kind) {
     case "track":
@@ -4367,7 +4711,7 @@ function hasInsertParamOverrides(overrides, target) {
   }
   return false;
 }
-function applyFullStripJson(engine, target, sceneJson, resetInserts) {
+function applyFullStripJson(engine, target, sceneJson) {
   const apply = (json) => {
     switch (target.kind) {
       case "track":
@@ -4383,21 +4727,6 @@ function applyFullStripJson(engine, target, sceneJson, resetInserts) {
   };
   engine.applyCommandsDueNowPreservingFuture();
   apply(sceneJson);
-  if (resetInserts) {
-    switch (target.kind) {
-      case "track":
-        engine.clearTrackInsertParameterBases(target.trackId);
-        break;
-      case "bus":
-        engine.clearBusInsertParameterBases(target.busId);
-        break;
-      case "master":
-        engine.clearMasterInsertParameterBases();
-        break;
-    }
-    apply(emptyStripJson(target));
-    apply(sceneJson);
-  }
 }
 function insertParamOverrideKey(override) {
   const targetId = override.target.kind === "track" ? override.target.trackId : override.target.kind === "bus" ? override.target.busId : "master";
@@ -4473,42 +4802,64 @@ function cacheStripJson(ctx, target, sceneJson) {
   }
 }
 function mixerLanes(ctx) {
-  return buildMixerLanes(ctx.trackLaneIds, ctx.trackSends, ctx.trackOutputBus);
+  return buildMixerLanes(
+    ctx.trackLaneIds,
+    ctx.trackSends,
+    ctx.trackOutputBus,
+    ctx.trackSourceChannelLayout
+  );
+}
+function cloneMixerRouting(ctx) {
+  return {
+    trackLaneIds: [...ctx.trackLaneIds],
+    trackSends: new Map(
+      Array.from(ctx.trackSends, ([trackId, sends]) => [
+        trackId,
+        sends.map((send) => ({ ...send }))
+      ])
+    ),
+    trackOutputBus: new Map(ctx.trackOutputBus),
+    trackSourceChannelLayout: new Map(ctx.trackSourceChannelLayout)
+  };
+}
+function commitMixerRouting(ctx, draft) {
+  ctx.trackLaneIds.splice(0, ctx.trackLaneIds.length, ...draft.trackLaneIds);
+  ctx.trackSends.clear();
+  for (const [trackId, sends] of draft.trackSends) {
+    ctx.trackSends.set(
+      trackId,
+      sends.map((send) => ({ ...send }))
+    );
+  }
+  ctx.trackOutputBus.clear();
+  for (const [trackId, busId] of draft.trackOutputBus) {
+    ctx.trackOutputBus.set(trackId, busId);
+  }
+  ctx.trackSourceChannelLayout.clear();
+  for (const [trackId, layout] of draft.trackSourceChannelLayout) {
+    ctx.trackSourceChannelLayout.set(trackId, layout);
+  }
 }
-function syncMixer(ctx, busesAlreadyApplied = false, forceInsertResets = []) {
-  const lanes = mixerLanes(ctx);
+function buildDraftMixerLanes(draft) {
+  return buildMixerLanes(
+    draft.trackLaneIds,
+    draft.trackSends,
+    draft.trackOutputBus,
+    draft.trackSourceChannelLayout
+  );
+}
+function applyMixerRouting(ctx, draft, busesAlreadyApplied) {
+  const lanes = buildDraftMixerLanes(draft);
   const buses = ctx.buses.map((bus) => ({ ...bus }));
   if (!busesAlreadyApplied) {
     ctx.offlineEngine.setTrackBuses(buses);
   }
   if (lanes.length > 0) {
-    ctx.offlineEngine.settleInsertParameters();
     ctx.offlineEngine.setTrackLanes(lanes);
   }
-  if (forceInsertResets.length > 0) {
-    for (const binding of ctx.laneSidechains.values()) {
-      ctx.offlineEngine.setLaneSidechain(
-        binding.trackId,
-        binding.insertIndex,
-        binding.sourceTrackId
-      );
-    }
-    for (const binding of ctx.busSidechains.values()) {
-      ctx.offlineEngine.setBusSidechain(
-        binding.busId,
-        binding.insertIndex,
-        binding.sourceKind,
-        binding.sourceId
-      );
-    }
-    for (const binding of ctx.masterSidechains.values()) {
-      ctx.offlineEngine.setMasterSidechain(
-        binding.insertIndex,
-        binding.sourceKind,
-        binding.sourceId
-      );
-    }
-  }
+  return { lanes, buses };
+}
+function postMixerSync(ctx, lanes, buses, insertBaseResets, oneShotInsertParamOverrides) {
   replayInsertParamOverrides(ctx, lanes, buses);
   const trackStrips = Array.from(ctx.trackStripJson, ([trackId, sceneJson]) => ({
     trackId,
@@ -4518,10 +4869,10 @@ function syncMixer(ctx, busesAlreadyApplied = false, forceInsertResets = []) {
     busId,
     sceneJson
   }));
-  const insertParamOverrides = Array.from(
-    ctx.insertParamOverrides.values(),
-    flattenInsertParamOverride
-  );
+  const insertParamOverrides = [
+    ...Array.from(ctx.insertParamOverrides.values(), flattenInsertParamOverride),
+    ...oneShotInsertParamOverrides.map(flattenInsertParamOverride)
+  ];
   ctx.postSync({
     type: "syncMixer",
     lanes,
@@ -4533,9 +4884,23 @@ function syncMixer(ctx, busesAlreadyApplied = false, forceInsertResets = []) {
     busSidechains: Array.from(ctx.busSidechains.values()),
     masterSidechains: Array.from(ctx.masterSidechains.values()),
     ...insertParamOverrides.length > 0 ? { insertParamOverrides } : {},
-    ...forceInsertResets.length > 0 ? { forceInsertResets } : {}
+    ...insertBaseResets.length > 0 ? { insertBaseResets } : {}
   });
 }
+function syncMixerDraft(ctx, draft, busesAlreadyApplied = false, insertBaseResets = [], oneShotInsertParamOverrides = []) {
+  const { lanes, buses } = applyMixerRouting(ctx, draft, busesAlreadyApplied);
+  commitMixerRouting(ctx, draft);
+  postMixerSync(ctx, lanes, buses, insertBaseResets, oneShotInsertParamOverrides);
+}
+function syncMixer(ctx, busesAlreadyApplied = false, insertBaseResets = [], oneShotInsertParamOverrides = []) {
+  syncMixerDraft(
+    ctx,
+    cloneMixerRouting(ctx),
+    busesAlreadyApplied,
+    insertBaseResets,
+    oneShotInsertParamOverrides
+  );
+}
 function replayInsertParamOverrides(ctx, lanes = mixerLanes(ctx), buses = ctx.buses) {
   const activeTrackIds = new Set(lanes.map((lane) => lane.trackId));
   const activeBusIds = new Set(buses.map((bus) => bus.busId));
@@ -4573,34 +4938,59 @@ function replayInsertParamOverrides(ctx, lanes = mixerLanes(ctx), buses = ctx.bu
   }
 }
 function setTrackLanes(ctx, lanes) {
-  const { entries, ids } = normalizeTrackLanes(ctx.trackLaneIds, lanes);
+  const draft = cloneMixerRouting(ctx);
+  const { entries, ids } = normalizeTrackLanes(draft.trackLaneIds, lanes);
   for (const entry of entries) {
     if (entry.sends) {
-      ctx.trackSends.set(
+      draft.trackSends.set(
         entry.trackId,
         entry.sends.map((send) => ({ ...send }))
       );
     }
     if (entry.outputBusId !== void 0) {
       if (entry.outputBusId === 0) {
-        ctx.trackOutputBus.delete(entry.trackId);
+        draft.trackOutputBus.delete(entry.trackId);
       } else {
-        ctx.trackOutputBus.set(entry.trackId, entry.outputBusId);
+        draft.trackOutputBus.set(entry.trackId, entry.outputBusId);
       }
     }
+    if (entry.sourceChannelLayout !== void 0) {
+      draft.trackSourceChannelLayout.set(entry.trackId, entry.sourceChannelLayout);
+    }
   }
-  ctx.trackLaneIds.splice(0, ctx.trackLaneIds.length, ...ids);
-  ctx.syncMixer();
+  draft.trackLaneIds = ids;
+  syncMixerDraft(ctx, draft, true);
+}
+function ensureTrackLaneInDraft(draft, target) {
+  const trackId = resolveTargetId(target);
+  if (!Number.isInteger(trackId) || trackId <= 0) {
+    throw new RangeError(`Invalid track id for mixer lane: ${String(target)}`);
+  }
+  const existing = draft.trackLaneIds.indexOf(trackId);
+  if (existing >= 0) {
+    return existing;
+  }
+  draft.trackLaneIds.push(trackId);
+  return draft.trackLaneIds.length - 1;
+}
+function ensureTrackLane(ctx, target) {
+  const draft = cloneMixerRouting(ctx);
+  const laneIndex = ensureTrackLaneInDraft(draft, target);
+  if (draft.trackLaneIds.length !== ctx.trackLaneIds.length) {
+    syncMixerDraft(ctx, draft, true);
+  }
+  return laneIndex;
 }
 function setTrackOutputBus(ctx, target, busId) {
-  const laneIndex = ctx.ensureTrackLane(target);
-  const trackId = ctx.trackLaneIds[laneIndex];
+  const draft = cloneMixerRouting(ctx);
+  const laneIndex = ensureTrackLaneInDraft(draft, target);
+  const trackId = draft.trackLaneIds[laneIndex];
   if (busId === 0) {
-    ctx.trackOutputBus.delete(trackId);
+    draft.trackOutputBus.delete(trackId);
   } else {
-    ctx.trackOutputBus.set(trackId, busId);
+    draft.trackOutputBus.set(trackId, busId);
   }
-  ctx.syncMixer();
+  syncMixerDraft(ctx, draft, true);
 }
 function setLaneSidechain(ctx, target, insertIndex, sourceTarget) {
   const laneIndex = ctx.ensureTrackLane(target);
@@ -4669,13 +5059,14 @@ function ensureSidechainSource(ctx, sourceKind, sourceId) {
   }
 }
 function setSends(ctx, target, sends) {
-  const laneIndex = ctx.ensureTrackLane(target);
-  const trackId = ctx.trackLaneIds[laneIndex];
-  ctx.trackSends.set(
+  const draft = cloneMixerRouting(ctx);
+  const laneIndex = ensureTrackLaneInDraft(draft, target);
+  const trackId = draft.trackLaneIds[laneIndex];
+  draft.trackSends.set(
     trackId,
     sends.map((send) => ({ ...send }))
   );
-  ctx.syncMixer();
+  syncMixerDraft(ctx, draft, true);
 }
 function setTrackBuses(ctx, buses) {
   ctx.offlineEngine.setTrackBuses(buses);
@@ -4709,18 +5100,45 @@ function setBusGain(ctx, busId, db) {
   ctx.buses[busIndex] = { ...ctx.buses[busIndex], busId, gainDb: db };
   return ctx.sendSmoothedParam(engineMixerBusTarget(busIndex, ENGINE_MIXER_PARAM_FADER_DB), db);
 }
+function replaceStripScene(ctx, target, previousJson, sceneJson) {
+  const chainChanged = previousJson !== void 0 && decodedInsertSignature(previousJson, target) !== decodedInsertSignature(sceneJson, target);
+  const hasOverrides = hasInsertParamOverrides(ctx.insertParamOverrides, target);
+  applyFullStripJson(ctx.offlineEngine, target, sceneJson);
+  if (!chainChanged && !hasOverrides) {
+    return { insertBaseResets: [], constructionOverrides: [] };
+  }
+  const constructionOverrides = chainChanged ? [] : constructionInsertOverrides(ctx.offlineEngine, target, ctx.insertParamOverrides);
+  ctx.clearInsertAutomationLanes(target);
+  clearInsertParameterBases(ctx.offlineEngine, target);
+  applyConstructionInsertOverrides(ctx.offlineEngine, constructionOverrides);
+  clearInsertParamOverrides(ctx.insertParamOverrides, target);
+  return { insertBaseResets: [target], constructionOverrides };
+}
 function setBusStripJson(ctx, busId, sceneJson) {
-  ctx.ensureBus(busId);
   const target = { kind: "bus", busId };
-  const resetInserts = ctx.busStripJson.has(busId) && ctx.busStripJson.get(busId) !== sceneJson || hasInsertParamOverrides(ctx.insertParamOverrides, target);
-  applyFullStripJson(ctx.offlineEngine, target, sceneJson, resetInserts);
-  if (resetInserts) {
-    ctx.clearInsertAutomationLanes(target);
-  }
+  decodedInsertSignature(sceneJson, target);
+  ctx.ensureBus(busId);
+  const { insertBaseResets, constructionOverrides } = replaceStripScene(
+    ctx,
+    target,
+    ctx.busStripJson.get(busId),
+    sceneJson
+  );
   pruneStripSidechains(ctx, target, sceneJson);
   ctx.busStripJson.set(busId, sceneJson);
-  clearInsertParamOverrides(ctx.insertParamOverrides, target);
-  ctx.syncMixer(resetInserts ? [target] : []);
+  ctx.syncMixer(insertBaseResets, constructionOverrides);
+}
+function setMasterStripJson(ctx, sceneJson) {
+  const target = { kind: "master" };
+  const { insertBaseResets, constructionOverrides } = replaceStripScene(
+    ctx,
+    target,
+    ctx.getMasterStripJson(),
+    sceneJson
+  );
+  pruneStripSidechains(ctx, target, sceneJson);
+  ctx.cacheMasterStripJson(sceneJson);
+  ctx.syncMixer(insertBaseResets, constructionOverrides);
 }
 
 // src/worklet/engine-node.ts
@@ -4739,7 +5157,7 @@ function isTrackMonitorMode(value) {
 }
 function isValidCommandRecord(command) {
   const type = Number(command.type);
-  if (!Number.isSafeInteger(type) || type < 0 /* SetParam */ || type > 17 /* SeekMarker */ && type !== 26 /* SetTrackMonitorMode */) {
+  if (!Number.isSafeInteger(type) || type < 0 /* SetParam */ || type > 17 /* SeekMarker */ && type !== 26 /* SetTrackMonitorMode */ && type !== 28 /* ResetMasterLoudnessMeter */) {
     return false;
   }
   return (
@@ -4775,6 +5193,8 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     this.captureRequests = /* @__PURE__ */ new Map();
     this.transportRequestId = 1;
     this.transportRequests = /* @__PURE__ */ new Map();
+    this.insertGainReductionRequestId = 1;
+    this.insertGainReductionRequests = /* @__PURE__ */ new Map();
     this.destroyed = false;
     this.node = node;
     this.capabilities = capabilities;
@@ -4820,10 +5240,22 @@ var SonareRealtimeEngineNode = 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)) {
@@ -4876,6 +5308,12 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
         "SharedArrayBuffer mode requested but SharedArrayBuffer/Atomics are unavailable."
       );
     }
+    const meterIntervalFrames = requireIntegerOption(
+      options.meterIntervalFrames,
+      2048,
+      "meterIntervalFrames",
+      0
+    );
     const commandRingCapacity = requireIntegerOption(
       options.commandRingCapacity,
       128,
@@ -4903,7 +5341,7 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       "scopeRingCapacity",
       1
     );
-    const scopeBands = requireIntegerOption(options.scopeBands, 48, "scopeBands", 1);
+    const scopeBands = resolveScopeBandCount(options.scopeBands);
     const clipPageRequestRingCapacity = requireIntegerOption(
       options.clipPageRequestRingCapacity,
       128,
@@ -4934,6 +5372,7 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       sampleRate: options.sampleRate ?? context.sampleRate,
       blockSize,
       channelCount,
+      meterIntervalFrames,
       cueOutput,
       commandSharedBuffer: commandRing?.sharedBuffer,
       commandRingCapacity: commandRing?.capacity,
@@ -4943,8 +5382,8 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       meterRingCapacity: meterRing?.capacity,
       scopeSharedBuffer: scopeRing?.sharedBuffer,
       scopeRingCapacity: scopeRing?.capacity,
-      scopeBands: scopeRing?.bands,
-      scopeIntervalFrames: scopeRing ? scopeIntervalFrames : void 0,
+      scopeBands: scopeIntervalFrames > 0 ? scopeRing?.bands ?? scopeBands : void 0,
+      scopeIntervalFrames: scopeIntervalFrames > 0 ? scopeIntervalFrames : void 0,
       clipPageRequestSharedBuffer: clipPageRequestRing?.sharedBuffer,
       clipPageRequestRingCapacity: clipPageRequestRing?.capacity,
       externalMidiSharedBuffer: externalMidiRing?.sharedBuffer,
@@ -4993,6 +5432,10 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
   play(sampleTime = -1) {
     return this.sendCommand({ type: 2 /* TransportPlay */, sampleTime });
   }
+  /** Queues a reset of the master's integrated-loudness accumulator. */
+  resetMasterLoudnessMeter(sampleTime = -1) {
+    return this.sendCommand({ type: 28 /* ResetMasterLoudnessMeter */, sampleTime });
+  }
   stop(sampleTime = -1) {
     return this.sendCommand({ type: 3 /* TransportStop */, sampleTime });
   }
@@ -5200,6 +5643,10 @@ var SonareRealtimeEngineNode = 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();
@@ -5249,6 +5696,29 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       listener(message);
     }
   }
+  /**
+   * 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) {
+    if (this.destroyed) {
+      return Promise.reject(new Error("Realtime engine node is destroyed."));
+    }
+    const requestId = this.insertGainReductionRequestId++;
+    let rejectRequest;
+    const promise = new Promise((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;
+  }
   emitScope(scope) {
     for (const listener of this.scopeListeners) {
       listener(scope);
@@ -5397,11 +5867,9 @@ function setInsertParamByName(ctx, target, insertIndex, paramName, value, applyN
 }
 function setTrackStripJson(ctx, trackId, sceneJson, trackStripJson) {
   const target = { 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;
 }
 function setTrackStripEqBand(ctx, target, bandIndex, band) {
   const trackId = trackIdFor(ctx, target);
@@ -5468,6 +5936,21 @@ function setTrackStripDualPan(ctx, target, leftPan, rightPan) {
   });
   ctx.postSync({ type: "syncTrackStripDualPan", trackId, leftPan, rightPan });
 }
+function setTrackStripSurroundPan(ctx, target, pan) {
+  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 === void 0 || pan.distance <= 0 ? 1 : pan.distance
+  };
+  mergeStripJson(ctx, { kind: "track", trackId }, (entry) => {
+    entry.surroundPan = resolved;
+  });
+  ctx.postSync({ type: "syncTrackStripSurroundPan", trackId, pan: resolved });
+}
 function setTrackStripChannelDelaySamples(ctx, target, delaySamples) {
   const trackId = trackIdFor(ctx, target);
   ctx.offlineEngine.setTrackStripChannelDelaySamples(trackId, delaySamples);
@@ -5641,8 +6124,14 @@ function pushMidiPolyPressure(ctx, trackId, group, channel, note, pressure, rend
 }
 function pushMidiUmp(ctx, trackId, word0, renderFrame) {
   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 });
 }
 function setBuiltinInstrument(ctx, trackId, config) {
   const destinationId = ctx.resolveTargetId(trackId);
@@ -5774,6 +6263,7 @@ var SonareEngine = class _SonareEngine {
     this.trackLaneIds = [];
     this.trackSends = /* @__PURE__ */ new Map();
     this.trackOutputBus = /* @__PURE__ */ new Map();
+    this.trackSourceChannelLayout = /* @__PURE__ */ new Map();
     this.laneSidechains = /* @__PURE__ */ new Map();
     this.busSidechains = /* @__PURE__ */ new Map();
     this.masterSidechains = /* @__PURE__ */ new Map();
@@ -5875,6 +6365,11 @@ var SonareEngine = class _SonareEngine {
   setTimeSignatureSegments(segments) {
     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, endPpq, enabled = true) {
     return setLoop(this.tempoContext, startPpq, endPpq, enabled);
   }
@@ -5933,6 +6428,15 @@ var SonareEngine = 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.
@@ -6046,14 +6550,23 @@ var SonareEngine = class _SonareEngine {
     }
     return sent;
   }
+  /** Resets the master's integrated loudness accumulator in both engine mirrors. */
+  resetMasterLoudnessMeter(renderFrame = -1) {
+    this.offlineEngine.resetMasterLoudnessMeter(renderFrame);
+    return this.sendMirroredCommand({
+      type: 28 /* 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.
    */
@@ -6070,7 +6583,9 @@ var SonareEngine = class _SonareEngine {
   /**
    * Keys one insert of a lane strip from another lane's post-strip pre-fader
    * audio (ducking/sidechainRouter inserts). sourceTarget null removes the
-   * binding.
+   * binding. Throws, leaving the existing bindings unchanged, for a lane keying
+   * itself or a binding that would close a cycle over the lane bindings; a
+   * refused binding is never recorded, so it is not replayed on resync.
    */
   setLaneSidechain(target, insertIndex, sourceTarget) {
     setLaneSidechain(this.mixerContext, target, insertIndex, sourceTarget);
@@ -6099,19 +6614,17 @@ var SonareEngine = class _SonareEngine {
     return setBusGain(this.mixerContext, busId, db);
   }
   setTrackStripJson(target, sceneJson) {
+    decodedInsertSignature(sceneJson, { kind: "track", trackId: 0 });
     const laneIndex = this.ensureTrackLane(target);
     const trackId = this.trackLaneIds[laneIndex];
-    const { resetInserts } = setTrackStripJson(
+    const { insertBaseResets, constructionOverrides } = setTrackStripJson(
       this.stripContext,
       trackId,
       sceneJson,
       this.trackStripJson
     );
-    if (resetInserts) {
-      this.clearInsertAutomationLanes({ kind: "track", trackId });
-    }
     pruneStripSidechains(this.mixerContext, { kind: "track", trackId }, sceneJson);
-    this.syncMixer(resetInserts ? [{ kind: "track", trackId }] : []);
+    this.syncMixer(insertBaseResets, constructionOverrides);
   }
   setTrackStripEqBand(target, bandIndex, band) {
     setTrackStripEqBand(this.stripContext, target, bandIndex, band);
@@ -6140,6 +6653,14 @@ var SonareEngine = class _SonareEngine {
   setTrackStripDualPan(target, leftPan, rightPan) {
     setTrackStripDualPan(this.stripContext, target, leftPan, rightPan);
   }
+  /**
+   * Sets a track lane strip's surround placement (glitch-free, 5 ms placement
+   * glide). Takes effect on a destination wider than stereo, so set `channelCount`
+   * to the layout's plane count. Omitted fields default to a centered point source.
+   */
+  setTrackStripSurroundPan(target, pan) {
+    setTrackStripSurroundPan(this.stripContext, target, pan);
+  }
   setTrackStripChannelDelaySamples(target, delaySamples) {
     setTrackStripChannelDelaySamples(this.stripContext, target, delaySamples);
   }
@@ -6168,16 +6689,7 @@ var SonareEngine = class _SonareEngine {
     setBusStripJson(this.mixerContext, busId, sceneJson);
   }
   setMasterStripJson(sceneJson) {
-    const target = { kind: "master" };
-    const resetInserts = this.masterStripJson !== void 0 && this.masterStripJson !== sceneJson || hasInsertParamOverrides(this.insertParamOverrides, target);
-    applyFullStripJson(this.offlineEngine, target, sceneJson, resetInserts);
-    if (resetInserts) {
-      this.clearInsertAutomationLanes(target);
-    }
-    pruneStripSidechains(this.mixerContext, target, sceneJson);
-    clearInsertParamOverrides(this.insertParamOverrides, target);
-    this.masterStripJson = sceneJson;
-    this.syncMixer(resetInserts ? [target] : []);
+    setMasterStripJson(this.mixerContext, sceneJson);
   }
   setMasterStripEqBand(bandIndex, band) {
     setMasterStripEqBand(this.stripContext, bandIndex, band);
@@ -6380,7 +6892,10 @@ var SonareEngine = 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, external) {
     setMidiDestinationExternal(this.stripContext, trackId, external);
@@ -6441,8 +6956,8 @@ var SonareEngine = class _SonareEngine {
       renderFrame
     );
   }
-  pushMidiUmp(trackId, word0, renderFrame = -1) {
-    pushMidiUmp(this.stripContext, trackId, word0, renderFrame);
+  pushMidiUmp(trackId, words, renderFrame = -1) {
+    pushMidiUmp(this.stripContext, trackId, words, renderFrame);
   }
   pushMidiSysex(trackId, data, renderFrame = -1) {
     pushMidiSysex(this.stripContext, trackId, data, renderFrame);
@@ -6527,6 +7042,11 @@ var SonareEngine = class _SonareEngine {
       portTimeSamples
     });
   }
+  pushMidiInputUmp(words, portTimeSamples = 0) {
+    const copiedWords = words instanceof Uint32Array ? new Uint32Array(words) : words.slice();
+    this.offlineEngine.pushMidiInputUmp(copiedWords, portTimeSamples);
+    this.postSync({ type: "syncMidiInputUmp", words: copiedWords, portTimeSamples });
+  }
   pushMidiPanic(renderFrame = -1) {
     this.offlineEngine.pushMidiPanic(renderFrame);
     this.postSync({ type: "syncMidiPanic", renderFrame });
@@ -6622,6 +7142,10 @@ var SonareEngine = class _SonareEngine {
   pollScope() {
     return this.realtimeNode.pollScope();
   }
+  /** Per-insert gain reduction for a meter target; see {@link SonareRealtimeEngineNode.pollInsertGainReduction}. */
+  pollInsertGainReduction(targetId) {
+    return this.realtimeNode.pollInsertGainReduction(targetId);
+  }
   destroy() {
     if (this.destroyed) {
       return;
@@ -6724,8 +7248,8 @@ var SonareEngine = class _SonareEngine {
   mixerLanes() {
     return mixerLanes(this.mixerContext);
   }
-  syncMixer(forceInsertResets = []) {
-    syncMixer(this.mixerContext, false, forceInsertResets);
+  syncMixer(insertBaseResets = [], oneShotInsertParamOverrides = []) {
+    syncMixer(this.mixerContext, false, insertBaseResets, oneShotInsertParamOverrides);
   }
   insertAutomationTargetKey(target) {
     return target.kind === "track" ? `track:${target.trackId}` : target.kind === "bus" ? `bus:${target.busId}` : "master";
@@ -6803,6 +7327,7 @@ var SonareEngine = class _SonareEngine {
       trackLaneIds: this.trackLaneIds,
       trackSends: this.trackSends,
       trackOutputBus: this.trackOutputBus,
+      trackSourceChannelLayout: this.trackSourceChannelLayout,
       laneSidechains: this.laneSidechains,
       busSidechains: this.busSidechains,
       masterSidechains: this.masterSidechains,
@@ -6815,7 +7340,7 @@ var SonareEngine = class _SonareEngine {
       ensureTrackLane: (target) => this.ensureTrackLane(target),
       ensureBus: (busId) => this.ensureBus(busId),
       mixerLanes: () => this.mixerLanes(),
-      syncMixer: (forceInsertResets) => this.syncMixer(forceInsertResets),
+      syncMixer: (insertBaseResets, oneShotInsertParamOverrides) => this.syncMixer(insertBaseResets, oneShotInsertParamOverrides),
       clearInsertAutomationLanes: (target, forgetResolvedIds) => this.clearInsertAutomationLanes(target, forgetResolvedIds),
       sendSmoothedParam: (paramId, value) => this.sendSmoothedParam(paramId, value),
       getMasterStripJson: () => this.masterStripJson,
@@ -6837,7 +7362,8 @@ var SonareEngine = class _SonareEngine {
       resolveTargetId: (target) => this.resolveTargetId(target),
       readStripJson: (target) => cachedStripJson(this.mixerContext, target),
       writeStripJson: (target, sceneJson) => cacheStripJson(this.mixerContext, target, sceneJson),
-      insertParamOverrides: this.insertParamOverrides
+      insertParamOverrides: this.insertParamOverrides,
+      clearInsertAutomationLanes: (target) => this.clearInsertAutomationLanes(target)
     };
   }
   // Collaborator surface handed to the automation-lane free functions so they
@@ -6977,17 +7503,7 @@ var SonareEngine = class _SonareEngine {
     return resolveTargetId(target);
   }
   ensureTrackLane(target) {
-    const trackId = this.resolveTargetId(target);
-    if (!Number.isInteger(trackId) || trackId <= 0) {
-      throw new RangeError(`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 ensureTrackLane(this.mixerContext, target);
   }
   ensureBus(busId) {
     if (!Number.isInteger(busId) || busId <= 0) {
@@ -7099,6 +7615,14 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       options.scopeRingCapacity,
       options.scopeBands
     ) : void 0;
+    this.scopeIntervalFrames = requireIntegerOption(
+      options.scopeIntervalFrames,
+      this.scopeRing ? this.blockSize : 0,
+      "scopeIntervalFrames",
+      0
+    );
+    this.scopeBands = resolveScopeBandCount(options.scopeBands);
+    this.scopeEnabled = this.scopeIntervalFrames > 0 && (this.scopeRing !== void 0 || typeof this.transport?.postMessage === "function");
     this.clipPageRequestRing = options.clipPageRequestSharedBuffer ? clipPageRequestRingFromSharedBuffer(
       options.clipPageRequestSharedBuffer,
       options.clipPageRequestRingCapacity
@@ -7130,14 +7654,11 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
         this.monitorBuffers[ch] = this.engine.getMonitorChannelBuffer(ch, this.blockSize);
       }
     }
-    if (this.scopeRing) {
-      const interval = requireIntegerOption(
-        options.scopeIntervalFrames,
-        this.blockSize,
-        "scopeIntervalFrames",
-        0
+    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);
     }
   }
   process(inputs, outputs) {
@@ -7398,37 +7919,32 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
           this.drainCommands(Math.min(this.commandRing.capacity, Math.max(0, write - read)));
         }
         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);
         }
@@ -7568,6 +8084,9 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       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;
@@ -7660,7 +8179,11 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
         );
         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);
@@ -7738,6 +8261,9 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
           message.portTimeSamples
         );
         break;
+      case "syncMidiInputUmp":
+        this.engine.pushMidiInputUmp(message.words, message.portTimeSamples);
+        break;
     }
   }
   receiveCaptureRequest(message) {
@@ -7811,6 +8337,26 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       });
     }
   }
+  receiveInsertGainReductionRequest(message) {
+    if (this.closed) {
+      return;
+    }
+    try {
+      this.transport?.postMessage?.({
+        type: "insertGainReductionResponse",
+        requestId: message.requestId,
+        ok: true,
+        values: this.engine.meterTargetInsertGainReduction(message.targetId)
+      });
+    } catch (error) {
+      this.transport?.postMessage?.({
+        type: "insertGainReductionResponse",
+        requestId: message.requestId,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   destroy() {
     if (!this.closed) {
       this.clearPagedClipProviders();
@@ -7924,6 +8470,9 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
         this.engine.setTrackMonitorMode(laneIndex, mode, sampleTime);
         break;
       }
+      case 28 /* ResetMasterLoudnessMeter */:
+        this.engine.resetMasterLoudnessMeter(sampleTime);
+        break;
       default:
         this.publishTelemetryRecord({
           type: 1 /* Error */,
@@ -8001,6 +8550,8 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       }
       return;
     }
+    const delivered = [];
+    const newestByTarget = /* @__PURE__ */ new Map();
     for (const item of this.engine.drainMeterTelemetry(64)) {
       const meter = meterFromEngine(item);
       if (meter.frame !== this.lastMeterFrame && meter.frame - this.lastMeterFrame < this.meterIntervalFrames) {
@@ -8009,6 +8560,13 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       if (meter.frame !== this.lastMeterFrame) {
         this.lastMeterFrame = meter.frame;
       }
+      delivered.push(meter);
+      newestByTarget.set(meter.targetId, meter);
+    }
+    for (const meter of delivered) {
+      if (newestByTarget.get(meter.targetId) === meter) {
+        meter.insertGainReductionDb = this.engine.meterTargetInsertGainReduction(meter.targetId);
+      }
       if (this.transport?.onMeter) {
         this.transport.onMeter(meter);
       } else {
@@ -8026,6 +8584,8 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     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);
   }
   // A snapshot-object ring writer used to live here as well. It was
@@ -8041,16 +8601,52 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
   // 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.
   publishScope() {
-    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);
+      }
+    }
+  }
+  postScopeScratch(transport) {
+    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 = {
+      type: "scope",
+      targetId: this.engine.scopeScratchTargetId(),
+      frame: Number(this.engine.scopeScratchRenderFrame()),
+      bands,
+      points
+    };
+    transport.postMessage(scope, [bands.buffer, points.buffer]);
   }
   writeScopeScratch(ring) {
     const writeIndex = Atomics.load(ring.header, 0);
@@ -8283,6 +8879,8 @@ function registerSonareRealtimeEngineWorkletProcessor(name = "sonare-realtime-en
         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")) {
         this.port?.postMessage?.({
           type: "syncError",
@@ -8352,8 +8950,8 @@ var SonareWorkletProcessor = class {
      *
      * `targetId` is always the master and the four LUFS / gain-reduction fields
      * are always unavailable here — the mixer worklet does not run the
-     * K-weighting filters, and a floor value would read as silence — so both are
-     * set once rather than per interval.
+     * K-weighting filters or the engine's pre-trim input tap — so finite floor
+     * values are set once rather than per interval.
      */
     this.meterScratch = {
       type: "meter",
@@ -8369,7 +8967,9 @@ var SonareWorkletProcessor = class {
       momentaryLufs: Number.NaN,
       shortTermLufs: Number.NaN,
       integratedLufs: Number.NaN,
-      gainReductionDb: Number.NaN
+      gainReductionDb: Number.NaN,
+      inputPeakDbL: SONARE_FLOOR_DB,
+      inputPeakDbR: SONARE_FLOOR_DB
     };
     if (!options.sceneJson) {
       throw new Error("sceneJson is required.");
@@ -8532,7 +9132,9 @@ var SonareWorkletProcessor = class {
       momentaryLufs: Number.NaN,
       shortTermLufs: Number.NaN,
       integratedLufs: Number.NaN,
-      gainReductionDb: Number.NaN
+      gainReductionDb: Number.NaN,
+      inputPeakDbL: SONARE_FLOOR_DB,
+      inputPeakDbR: SONARE_FLOOR_DB
     };
     if (this.transport?.onMeter) {
       this.transport.onMeter(meter);
@@ -8561,6 +9163,8 @@ var SonareWorkletProcessor = class {
     ring.records[offset + 11] = meter.shortTermLufs;
     ring.records[offset + 12] = meter.integratedLufs;
     ring.records[offset + 13] = meter.gainReductionDb;
+    ring.records[offset + 14] = meter.inputPeakDbL;
+    ring.records[offset + 15] = meter.inputPeakDbR;
     Atomics.store(ring.header, 0, writeIndex + 1);
   }
   publishSpectrum(left, right) {
@@ -8613,7 +9217,7 @@ var SonareWorkletProcessor = class {
       return;
     }
     const writeIndex = Atomics.load(ring.header, 0);
-    const offset = writeIndex % ring.capacity * ring.recordFloats;
+    const offset = writeIndex % ring.capacity * SONARE_METER_RING_RECORD_FLOATS;
     ring.records[offset] = encodeFrameLo(frame);
     ring.records[offset + 1] = encodeFrameHi(frame);
     ring.records[offset + 2] = bands.length;