@libraz/libsonare 1.8.0 → 1.8.2

package/src/worklet/engine.ts

@@ -23,9 +23,11 @@ import type {
   PanLaw,
   PanMode,
   SidechainSourceKind,
+  UmpWords,
 } from '../index';
 import { RealtimeEngine } from '../index';
 import { createOpfsClipPageProvider, type OpfsClipPageProviderBinding } from '../opfs_clip_pages';
+import type { SurroundPan } from '../public_types';
 import type { ClipPageProvider } from '../realtime_engine';
 import type { EngineAutomationContext } from './engine-automation';
 import * as automation from './engine-automation';
@@ -102,6 +104,7 @@ export class SonareEngine {
   private readonly trackLaneIds: number[] = [];
   private readonly trackSends = new Map<number, EngineTrackSend[]>();
   private readonly trackOutputBus = new Map<number, number>();
+  private readonly trackSourceChannelLayout = new Map<number, number>();
   private readonly laneSidechains = new Map<
     string,
     { trackId: number; insertIndex: number; sourceTrackId: number }
@@ -242,6 +245,11 @@ export class SonareEngine {
     tempo.setTimeSignatureSegments(this.tempoContext, segments);
   }
 
+  /**
+   * A loop wrap, seek or stop sends note-offs plus CC64=0, CC121, CC123 and a
+   * centred pitch bend on every channel played since the last reset, so
+   * controller values set before a loop region are not restored at the wrap.
+   */
   setLoop(startPpq: number, endPpq: number, enabled = true): boolean {
     return tempo.setLoop(this.tempoContext, startPpq, endPpq, enabled);
   }
@@ -321,6 +329,15 @@ export class SonareEngine {
    * mixer lane first (like automationParamId) so the offline engine resolves the
    * same strip selector the realtime engine uses.
    *
+   * The returned id uses the track's current positional lane selector. When
+   * setTrackLanes successfully changes lane order or membership, the engine
+   * remaps already queued and published track automation by track id, but it
+   * cannot update a numeric id retained by the caller. Re-resolve every track
+   * insert id after such a topology change before passing it to
+   * setAutomationLane. Use setTrackStripInsertParamByName when the operation
+   * needs a stable track identity. Master and bus insert ids are separate and
+   * are not invalidated by track-lane changes.
+   *
    * @param target Track id (declares a mixer lane on first use).
    * @param insertIndex Index into the strip's combined insert sequence.
    * @param paramName Processor JSON-key parameter name.
@@ -454,14 +471,24 @@ export class SonareEngine {
     return sent;
   }
 
+  /** Resets the master's integrated loudness accumulator in both engine mirrors. */
+  resetMasterLoudnessMeter(renderFrame = -1): boolean {
+    this.offlineEngine.resetMasterLoudnessMeter(renderFrame);
+    return this.sendMirroredCommand({
+      type: SonareEngineCommandType.ResetMasterLoudnessMeter,
+      sampleTime: renderFrame,
+    });
+  }
+
   /**
    * Declares the mixer track lanes in an explicit order.
    *
-   * Lane indices are append-only: once a track id occupies a lane, its index
-   * stays fixed for the engine's lifetime. The given list must therefore start
-   * with the already-declared lane ids in their current order and may only
-   * append new track ids after them. Entries carrying `sends` replace that
-   * track's send list; entries without `sends` leave existing sends untouched.
+   * A successful call may reorder existing track ids, remove track ids, or add
+   * new ones. Existing queued and published track automation follows the track
+   * id, while numeric track-insert automation ids retained by the caller do
+   * not; re-resolve those ids after every topology change. Entries carrying
+   * `sends` replace that track's send list; entries without `sends` leave
+   * existing sends untouched.
    *
    * @param lanes Track ids or lane descriptors in the desired lane order.
    */
@@ -480,7 +507,9 @@ export 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: string | number,
@@ -528,19 +557,18 @@ export class SonareEngine {
   }
 
   setTrackStripJson(target: string | number, sceneJson: string): void {
+    // Parse before declaring a new lane so malformed text cannot declare one.
+    mixer.decodedInsertSignature(sceneJson, { kind: 'track', trackId: 0 });
     const laneIndex = this.ensureTrackLane(target);
     const trackId = this.trackLaneIds[laneIndex];
-    const { resetInserts } = strips.setTrackStripJson(
+    const { insertBaseResets, constructionOverrides } = strips.setTrackStripJson(
       this.stripContext,
       trackId,
       sceneJson,
       this.trackStripJson,
     );
-    if (resetInserts) {
-      this.clearInsertAutomationLanes({ kind: 'track', trackId });
-    }
     mixer.pruneStripSidechains(this.mixerContext, { kind: 'track', trackId }, sceneJson);
-    this.syncMixer(resetInserts ? [{ kind: 'track', trackId }] : []);
+    this.syncMixer(insertBaseResets, constructionOverrides);
   }
 
   setTrackStripEqBand(target: string | number, bandIndex: number, band: EqBand | string): void {
@@ -587,6 +615,15 @@ export class SonareEngine {
     strips.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: string | number, pan: SurroundPan): void {
+    strips.setTrackStripSurroundPan(this.stripContext, target, pan);
+  }
+
   setTrackStripChannelDelaySamples(target: string | number, delaySamples: number): void {
     strips.setTrackStripChannelDelaySamples(this.stripContext, target, delaySamples);
   }
@@ -625,18 +662,7 @@ export class SonareEngine {
   }
 
   setMasterStripJson(sceneJson: string): void {
-    const target = { kind: 'master' } as const;
-    const resetInserts =
-      (this.masterStripJson !== undefined && this.masterStripJson !== sceneJson) ||
-      mixer.hasInsertParamOverrides(this.insertParamOverrides, target);
-    mixer.applyFullStripJson(this.offlineEngine, target, sceneJson, resetInserts);
-    if (resetInserts) {
-      this.clearInsertAutomationLanes(target);
-    }
-    mixer.pruneStripSidechains(this.mixerContext, target, sceneJson);
-    mixer.clearInsertParamOverrides(this.insertParamOverrides, target);
-    this.masterStripJson = sceneJson;
-    this.syncMixer(resetInserts ? [target] : []);
+    mixer.setMasterStripJson(this.mixerContext, sceneJson);
   }
 
   setMasterStripEqBand(bandIndex: number, band: EqBand | string): void {
@@ -904,7 +930,10 @@ export class SonareEngine {
   /**
    * Route a track's MIDI to the external output (drained via {@link onMidiOut})
    * instead of an internal instrument, so the track plays an external device.
-   * Pass `external=false` to restore internal-synth playback.
+   * Pass `external=false` to restore internal-synth playback. The change takes
+   * effect at the next processed block; switching a destination's route first
+   * releases its notes and resets its controllers through the old route, and
+   * drops its pending MIDI-FX events.
    */
   setMidiDestinationExternal(trackId: string | number, external: boolean): void {
     strips.setMidiDestinationExternal(this.stripContext, trackId, external);
@@ -1015,8 +1044,8 @@ export class SonareEngine {
     );
   }
 
-  pushMidiUmp(trackId: string | number, word0: number, renderFrame = -1): void {
-    strips.pushMidiUmp(this.stripContext, trackId, word0, renderFrame);
+  pushMidiUmp(trackId: string | number, words: number | UmpWords, renderFrame = -1): void {
+    strips.pushMidiUmp(this.stripContext, trackId, words, renderFrame);
   }
 
   pushMidiSysex(trackId: string | number, data: Uint8Array, renderFrame = -1): void {
@@ -1151,6 +1180,12 @@ export class SonareEngine {
     });
   }
 
+  pushMidiInputUmp(words: UmpWords, portTimeSamples = 0): void {
+    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): void {
     this.offlineEngine.pushMidiPanic(renderFrame);
     this.postSync({ type: 'syncMidiPanic', renderFrame });
@@ -1272,6 +1307,11 @@ export class SonareEngine {
     return this.realtimeNode.pollScope();
   }
 
+  /** Per-insert gain reduction for a meter target; see {@link SonareRealtimeEngineNode.pollInsertGainReduction}. */
+  pollInsertGainReduction(targetId: number): Promise<number[]> {
+    return this.realtimeNode.pollInsertGainReduction(targetId);
+  }
+
   destroy(): void {
     if (this.destroyed) {
       return;
@@ -1397,8 +1437,11 @@ export class SonareEngine {
     return mixer.mixerLanes(this.mixerContext);
   }
 
-  private syncMixer(forceInsertResets: mixer.StripJsonTarget[] = []): void {
-    mixer.syncMixer(this.mixerContext, false, forceInsertResets);
+  private syncMixer(
+    insertBaseResets: mixer.StripJsonTarget[] = [],
+    oneShotInsertParamOverrides: mixer.InsertParamOverride[] = [],
+  ): void {
+    mixer.syncMixer(this.mixerContext, false, insertBaseResets, oneShotInsertParamOverrides);
   }
 
   private insertAutomationTargetKey(target: mixer.StripJsonTarget): string {
@@ -1494,6 +1537,7 @@ export class SonareEngine {
       trackLaneIds: this.trackLaneIds,
       trackSends: this.trackSends,
       trackOutputBus: this.trackOutputBus,
+      trackSourceChannelLayout: this.trackSourceChannelLayout,
       laneSidechains: this.laneSidechains,
       busSidechains: this.busSidechains,
       masterSidechains: this.masterSidechains,
@@ -1506,7 +1550,8 @@ export 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),
@@ -1532,6 +1577,7 @@ export class SonareEngine {
       writeStripJson: (target, sceneJson) =>
         mixer.cacheStripJson(this.mixerContext, target, sceneJson),
       insertParamOverrides: this.insertParamOverrides,
+      clearInsertAutomationLanes: (target) => this.clearInsertAutomationLanes(target),
     };
   }
 
@@ -1683,17 +1729,7 @@ export class SonareEngine {
   }
 
   private ensureTrackLane(target: string | number): number {
-    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 mixer.ensureTrackLane(this.mixerContext, target);
   }
 
   private ensureBus(busId: number): number {

package/src/worklet/guards.ts

@@ -3,6 +3,8 @@ import type {
   SonareEngineCaptureRequestMessage,
   SonareEngineCaptureResponseMessageInternal,
   SonareEngineClipPageRequestMessage,
+  SonareEngineInsertGainReductionRequestMessage,
+  SonareEngineInsertGainReductionResponseMessage,
   SonareEngineSyncMessage,
   SonareEngineTransportRequestMessage,
   SonareEngineTransportResponseMessage,
@@ -13,9 +15,11 @@ import type {
 } from './messages';
 import {
   isRecord,
+  SONARE_SCOPE_DEFAULT_BANDS,
   type SonareEngineCommandRecord,
   type SonareEngineTelemetryRecord,
   type SonareWorkletMeterSnapshot,
+  type SonareWorkletScopeSnapshot,
 } from './protocol';
 
 export function isWorkletMessage(value: unknown): value is SonareWorkletMessage {
@@ -84,6 +88,7 @@ export const ENGINE_SYNC_MESSAGE_TYPES: Record<SonareEngineSyncMessage['type'],
   syncMidiInputPitchBend: true,
   syncMidiInputPolyPressure: true,
   syncMidiInputSource: true,
+  syncMidiInputUmp: true,
   syncMidiNoteOff: true,
   syncMidiNoteOn: true,
   syncMidiPanic: true,
@@ -104,6 +109,7 @@ export const ENGINE_SYNC_MESSAGE_TYPES: Record<SonareEngineSyncMessage['type'],
   syncTrackStripPan: true,
   syncTrackStripPanLaw: true,
   syncTrackStripPanMode: true,
+  syncTrackStripSurroundPan: true,
   syncWarpVoiceCapacity: true,
 };
 
@@ -252,6 +258,28 @@ export function isEngineTransportResponseMessage(
   );
 }
 
+export function isEngineInsertGainReductionRequestMessage(
+  value: unknown,
+): value is SonareEngineInsertGainReductionRequestMessage {
+  return (
+    isRecord(value) &&
+    value.type === 'insertGainReductionRequest' &&
+    typeof value.requestId === 'number' &&
+    typeof value.targetId === 'number'
+  );
+}
+
+export function isEngineInsertGainReductionResponseMessage(
+  value: unknown,
+): value is SonareEngineInsertGainReductionResponseMessage {
+  return (
+    isRecord(value) &&
+    value.type === 'insertGainReductionResponse' &&
+    typeof value.requestId === 'number' &&
+    typeof value.ok === 'boolean'
+  );
+}
+
 export function isRealtimeVoiceChangerMessage(
   value: unknown,
 ): value is SonareRealtimeVoiceChangerMessage {
@@ -331,10 +359,55 @@ export function isMeterSnapshot(value: unknown): value is SonareWorkletMeterSnap
     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 === undefined)
   );
 }
 
+export const SONARE_SCOPE_MAX_BANDS = 64;
+export const SONARE_SCOPE_MAX_POINTS = 32;
+
+function isPlainFloat32Array(
+  value: unknown,
+  maxLength: number,
+  evenLength = false,
+): value is Float32Array {
+  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;
+}
+
+/** Validates the bounded postMessage representation of a scope snapshot. */
+export function isScopeSnapshot(value: unknown): value is SonareWorkletScopeSnapshot {
+  return (
+    isRecord(value) &&
+    value.type === 'scope' &&
+    typeof value.targetId === 'number' &&
+    Number.isSafeInteger(value.targetId) &&
+    value.targetId >= 0 &&
+    value.targetId <= 0xffff_ffff &&
+    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)
+  );
+}
+
 /**
  * Resolves an integer option, refusing anything the field's own domain cannot
  * hold instead of rounding it into range.
@@ -356,6 +429,14 @@ export function requireIntegerOption(
   return resolved;
 }
 
+/** Resolves scope bands and applies the native tap's fixed 64-band ceiling. */
+export function resolveScopeBandCount(
+  value: number | undefined,
+  fallback = SONARE_SCOPE_DEFAULT_BANDS,
+): number {
+  return Math.min(requireIntegerOption(value, fallback, 'scopeBands', 1), SONARE_SCOPE_MAX_BANDS);
+}
+
 /** As {@link requireIntegerOption}, for a field whose domain admits either sign. */
 export function requireInteger(value: number | undefined, fallback: number, name: string): number {
   const resolved = value ?? fallback;

package/src/worklet/messages.ts

@@ -15,12 +15,14 @@ import type {
   PlaybackRendererConfig,
   RealtimeVoiceChangerConfigInput,
   RealtimeVoiceChangerPodConfig,
+  UmpWords,
 } from '../index';
-import type { AutomationCurve } from '../public_types';
+import type { AutomationCurve, SurroundPan } from '../public_types';
 import type {
   SonareEngineCommandRecord,
   SonareEngineTelemetryRecord,
   SonareWorkletMeterSnapshot,
+  SonareWorkletScopeSnapshot,
   SonareWorkletSpectrumSnapshot,
 } from './protocol';
 
@@ -44,6 +46,18 @@ export interface SonareRealtimeEngineWorkletProcessorOptions {
   initialCommands?: SonareEngineCommandRecord[];
   sampleRate?: number;
   blockSize?: number;
+  /**
+   * Output plane count (default 2). Planes follow the canonical order
+   * L R C LFE Ls Rs [Lss Rss] for 6 (5.1) and 8 (7.1) planes.
+   *
+   * The Web Audio default destination is 2-channel `'speakers'`, so a wider
+   * output is mixed down to stereo unless the app raises
+   * `audioContext.destination.channelCount` (up to its `maxChannelCount`) to
+   * match. Interpretation matters only while the counts differ: `'speakers'`
+   * applies the spec's down-mix for mono, stereo, quad and 5.1 sources only,
+   * and `'discrete'` copies the first planes and drops the rest. With equal
+   * counts the planes pass through unchanged in either mode.
+   */
   channelCount?: number;
   meterIntervalFrames?: number;
   commandSharedBuffer?: SharedArrayBuffer;
@@ -288,6 +302,7 @@ export interface SonareEngineSyncErrorMessage {
 
 export type SonareWorkletTransportMessage =
   | SonareWorkletMeterSnapshot
+  | SonareWorkletScopeSnapshot
   | SonareWorkletSpectrumSnapshot
   | SonareWorkletExternalMidiMessage
   | SonareEngineClipPageRequestMessage
@@ -299,6 +314,7 @@ export interface WorkletTransport {
       | SonareWorkletTransportMessage
       | SonareEngineCaptureResponseMessageInternal
       | SonareEngineTransportResponseMessage
+      | SonareEngineInsertGainReductionResponseMessage
       | SonareEngineSyncErrorMessage,
     transfer?: Transferable[],
   ) => void;
@@ -511,8 +527,8 @@ export interface SonareEngineSyncMixerMessage {
   masterStripJson?: string;
   /** Retained by-name insert values, applied after strip and sidechain replay. */
   insertParamOverrides?: SonareEngineSyncMixerInsertParamOverride[];
-  /** Explicit full strip replacements that must reset retained insert state. */
-  forceInsertResets?: Array<
+  /** Strips whose manual insert bases are cleared after the strip replay, before insertParamOverrides. */
+  insertBaseResets?: Array<
     { kind: 'track'; trackId: number } | { kind: 'bus'; busId: number } | { kind: 'master' }
   >;
   /** Lane insert sidechain bindings (replayed after lanes/strips). */
@@ -631,6 +647,12 @@ export interface SonareEngineSyncTrackStripDualPanMessage {
   rightPan: number;
 }
 
+export interface SonareEngineSyncTrackStripSurroundPanMessage {
+  type: 'syncTrackStripSurroundPan';
+  trackId: number;
+  pan: Required<SurroundPan>;
+}
+
 export interface SonareEngineSyncBusStripPanMessage {
   type: 'syncBusStripPan';
   busId: number;
@@ -719,13 +741,26 @@ export interface SonareEngineSyncMidiCcMessage {
   renderFrame: number;
 }
 
-export interface SonareEngineSyncMidiUmpMessage {
+export interface SonareEngineSyncMidiUmpWordMessage {
   type: 'syncMidiUmp';
   destinationId: number;
   word0: number;
+  words?: never;
   renderFrame: number;
 }
 
+export interface SonareEngineSyncMidiUmpWordsMessage {
+  type: 'syncMidiUmp';
+  destinationId: number;
+  word0?: never;
+  words: UmpWords;
+  renderFrame: number;
+}
+
+export type SonareEngineSyncMidiUmpMessage =
+  | SonareEngineSyncMidiUmpWordMessage
+  | SonareEngineSyncMidiUmpWordsMessage;
+
 /**
  * One of the three per-note expression dimensions, addressed to a destination.
  * `data0`/`data1` carry the dimension's own payload the way the live-input
@@ -794,6 +829,12 @@ export interface SonareEngineSyncMidiInputEventMessage {
   portTimeSamples: number;
 }
 
+export interface SonareEngineSyncMidiInputUmpMessage {
+  type: 'syncMidiInputUmp';
+  words: UmpWords;
+  portTimeSamples: number;
+}
+
 /** Releases the realtime engine and all worklet-owned clip buffers. */
 export interface SonareEngineDestroyMessage {
   type: 'destroy';
@@ -837,6 +878,7 @@ export type SonareEngineSyncMessage =
   | SonareEngineSyncTrackStripPanLawMessage
   | SonareEngineSyncTrackStripPanModeMessage
   | SonareEngineSyncTrackStripDualPanMessage
+  | SonareEngineSyncTrackStripSurroundPanMessage
   | SonareEngineSyncBusStripPanMessage
   | SonareEngineSyncBusStripPanLawMessage
   | SonareEngineSyncBusStripPanModeMessage
@@ -858,6 +900,7 @@ export type SonareEngineSyncMessage =
   | SonareEngineSyncMidiInputSourceMessage
   | SonareEngineSyncMidiCcBindingMessage
   | SonareEngineSyncMidiInputEventMessage
+  | SonareEngineSyncMidiInputUmpMessage
   | SonareEngineDestroyMessage;
 
 export interface WorkletPort {
@@ -935,3 +978,19 @@ export interface SonareEngineTransportResponseMessage {
   state?: EngineTransportState;
   error?: string;
 }
+
+/** Asks the worklet for one target's per-insert gain reduction (any meter delivery mode). */
+export interface SonareEngineInsertGainReductionRequestMessage {
+  type: 'insertGainReductionRequest';
+  requestId: number;
+  targetId: number;
+}
+
+/** Reply to {@link SonareEngineInsertGainReductionRequestMessage}; `values` is present when `ok`. */
+export interface SonareEngineInsertGainReductionResponseMessage {
+  type: 'insertGainReductionResponse';
+  requestId: number;
+  ok: boolean;
+  values?: number[];
+  error?: string;
+}

package/src/worklet/mixer-processor.ts

@@ -15,6 +15,7 @@ import {
   meterRingFromSharedBuffer,
   type SharedMeterRingWriter,
   type SharedSpectrumRingWriter,
+  SONARE_FLOOR_DB,
   SONARE_METER_RING_RECORD_FLOATS,
   type SonareWorkletMeterSnapshot,
   type SonareWorkletSpectrumSnapshot,
@@ -47,8 +48,8 @@ export class SonareWorkletProcessor {
    *
    * `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.
    */
   private readonly meterScratch: SonareWorkletMeterSnapshot = {
     type: 'meter',
@@ -65,6 +66,8 @@ export class SonareWorkletProcessor {
     shortTermLufs: Number.NaN,
     integratedLufs: Number.NaN,
     gainReductionDb: Number.NaN,
+    inputPeakDbL: SONARE_FLOOR_DB,
+    inputPeakDbR: SONARE_FLOOR_DB,
   };
   private spectrumRing?: SharedSpectrumRingWriter;
   private spectrumBands: Float32Array;
@@ -276,6 +279,8 @@ export class SonareWorkletProcessor {
       shortTermLufs: Number.NaN,
       integratedLufs: Number.NaN,
       gainReductionDb: Number.NaN,
+      inputPeakDbL: SONARE_FLOOR_DB,
+      inputPeakDbR: SONARE_FLOOR_DB,
     };
     // Alternative channels for one record, not a broadcast pair: a transport
     // that supplies both (the engine registration resolves both to
@@ -309,6 +314,8 @@ export class SonareWorkletProcessor {
     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);
     // writeIndex is a free-running monotonic counter, so an overflow guard here
     // would fire on essentially every write past the first `capacity` records
@@ -377,7 +384,7 @@ export class SonareWorkletProcessor {
       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;