@libraz/libsonare 1.3.3 → 1.4.1

package/src/quick_analysis.ts

@@ -107,20 +107,24 @@ export function detectKeyCandidates(
   options: KeyDetectionOptions = {},
 ): KeyCandidate[] {
   validateAnalysisInput('detectKeyCandidates', samples, sampleRate, options);
-  return requireModule()
-    ._detectKeyCandidates(
-      samples,
-      sampleRate,
-      options.nFft ?? 4096,
-      options.hopLength ?? 512,
-      options.useHpss ?? false,
-      options.loudnessWeighted ?? false,
-      options.highPassHz ?? 0,
-      keyModeValues(options.modes),
-      keyProfileValue(options.profile),
-      options.genreHint ?? '',
-    )
-    .map(convertKeyCandidate);
+  // The embind value marshalling returns an array whose constructor is not this
+  // realm's Array; chaining .map() onto it propagates that constructor via
+  // Symbol.species, leaving a result that structuredClone (and so postMessage to
+  // a Worker) rejects with "could not be cloned". Array.from() re-roots it as a
+  // plain Array before mapping.
+  const candidates = requireModule()._detectKeyCandidates(
+    samples,
+    sampleRate,
+    options.nFft ?? 4096,
+    options.hopLength ?? 512,
+    options.useHpss ?? false,
+    options.loudnessWeighted ?? false,
+    options.highPassHz ?? 0,
+    keyModeValues(options.modes),
+    keyProfileValue(options.profile),
+    options.genreHint ?? '',
+  );
+  return Array.from(candidates, convertKeyCandidate);
 }
 
 /**

package/src/realtime_engine.ts

@@ -1,7 +1,8 @@
+import { panLawCode, panModeCode, sendTimingCode } from './codes';
 import { ErrorCode, SonareError } from './errors';
 import { getSonareModule } from './module_state';
 import type { SynthPatch } from './project';
-import type { EqBand } from './public_types';
+import type { EqBand, PanLaw, PanMode, SendTiming } from './public_types';
 import type {
   WasmClipPageRequest,
   WasmEngineAutomationPoint,
@@ -14,9 +15,11 @@ import type {
   WasmEngineGraphSpec,
   WasmEngineMarker,
   WasmEngineMeterTelemetry,
+  WasmEngineMeterTelemetryWide,
   WasmEngineMetronomeConfig,
   WasmEngineParameterInfo,
   WasmEngineProcessWithMonitorResult,
+  WasmEngineScopeTelemetry,
   WasmEngineTelemetry,
   WasmEngineTempoSegment,
   WasmEngineTimeSignatureSegment,
@@ -38,6 +41,8 @@ export type EngineFreezeOptions = WasmEngineFreezeOptions;
 export type EngineFreezeResult = WasmEngineFreezeResult;
 export type EngineTelemetry = WasmEngineTelemetry;
 export type EngineMeterTelemetry = WasmEngineMeterTelemetry;
+export type EngineMeterTelemetryWide = WasmEngineMeterTelemetryWide;
+export type EngineScopeTelemetry = WasmEngineScopeTelemetry;
 export type EngineTransportState = WasmEngineTransportState;
 export type EngineTempoSegment = WasmEngineTempoSegment;
 export type EngineTimeSignatureSegment = WasmEngineTimeSignatureSegment;
@@ -46,16 +51,39 @@ export interface EngineTrackSend {
   busId: number;
   levelDb?: number;
   enabled?: boolean;
+  /**
+   * Pre/post-fader tap point. Defaults to post-fader when omitted, matching the
+   * historical lane-send behavior and the scene-JSON default.
+   */
+  sendTiming?: SendTiming | number;
 }
 
 export interface EngineTrackLane {
   trackId: number;
   sends?: EngineTrackSend[];
+  /**
+   * Bus the lane's post-fader output sums into instead of the master mix
+   * (group/folder routing); 0 or absent keeps the lane on the master mix.
+   */
+  outputBusId?: number;
+  /**
+   * Input channel layout of the source feeding this lane (`SonareChannelLayout`:
+   * 0 mono, 1 stereo, 2 5.1, 3 7.1). Absent defaults to stereo. Stored but inert
+   * until the surround DSP path lands.
+   */
+  sourceChannelLayout?: number;
 }
 
 export interface EngineBus {
   busId: number;
   gainDb?: number;
+  /**
+   * Channel layout of the bus (`SonareChannelLayout`: 0 mono, 1 stereo, 2 5.1,
+   * 3 7.1). A surround layout makes this a surround group bus: lanes routed to
+   * it are surround-panned and it sums into the master plane-by-plane. Defaults
+   * to stereo.
+   */
+  channelLayout?: number;
 }
 
 export interface EngineMidiEvent {
@@ -382,6 +410,16 @@ export class RealtimeEngine {
     this.native.seekSample(timelineSample, renderFrame);
   }
 
+  /**
+   * Snaps every in-flight parameter ramp (engine-level smoothed params, mixer
+   * lane fader/pan/gate, bus gains) to its target value. Offline renders call
+   * this after a priming process() block so the first audible block renders at
+   * settled values instead of ramping in from defaults.
+   */
+  settleParameters(): void {
+    this.native.settleParameters();
+  }
+
   seekPpq(ppq: number, renderFrame = -1): void {
     this.native.seekPpq(ppq, renderFrame);
   }
@@ -500,10 +538,35 @@ export class RealtimeEngine {
 
   setTrackLanes(lanes: Array<number | EngineTrackLane>): void {
     this.native.setTrackLanes(
-      lanes.map((lane) => (typeof lane === 'number' ? { trackId: lane } : lane)),
+      lanes.map((lane) => {
+        if (typeof lane === 'number') {
+          return { trackId: lane };
+        }
+        if (!lane.sends) {
+          return lane;
+        }
+        // Normalize each send's pre/post tap point to the integer the native
+        // layer reads (defaults to post-fader when omitted).
+        return {
+          ...lane,
+          sends: lane.sends.map((send) => ({
+            ...send,
+            // Post-fader (0) is the default for an omitted sendTiming.
+            sendTiming: send.sendTiming === undefined ? 0 : sendTimingCode(send.sendTiming),
+          })),
+        };
+      }),
     );
   }
 
+  /**
+   * Keys one insert of a lane strip from another lane's post-strip audio
+   * (ducking/sidechainRouter inserts). sourceTrackId 0 removes the binding.
+   */
+  setLaneSidechain(trackId: number, insertIndex: number, sourceTrackId: number): void {
+    this.native.setLaneSidechain(trackId, insertIndex, sourceTrackId);
+  }
+
   setTrackBuses(buses: EngineBus[]): void {
     this.native.setTrackBuses(buses);
   }
@@ -578,6 +641,55 @@ export class RealtimeEngine {
     this.native.setMasterStripInsertBypassed(insertIndex, bypassed, resetOnBypass);
   }
 
+  /**
+   * Changes one track-strip insert parameter in realtime, addressed by the
+   * processor's JSON-key parameter name (see {@link masteringInsertParamInfo}).
+   * Applied at the next block head via the engine command queue; safe during
+   * playback. Throws if the track, insert, or name is unknown, the param is not
+   * realtime-safe, or the command queue is full.
+   */
+  setTrackStripInsertParamByName(
+    trackId: number,
+    insertIndex: number,
+    paramName: string,
+    value: number,
+  ): void {
+    this.native.setTrackStripInsertParamByName(trackId, insertIndex, paramName, value);
+  }
+
+  /** Master-strip counterpart of {@link setTrackStripInsertParamByName}. */
+  setMasterStripInsertParamByName(insertIndex: number, paramName: string, value: number): void {
+    this.native.setMasterStripInsertParamByName(insertIndex, paramName, value);
+  }
+
+  /** Sets a track lane strip's pan position in realtime (glitch-free). */
+  setTrackStripPan(trackId: number, pan: number): void {
+    this.native.setTrackStripPan(trackId, pan);
+  }
+
+  /** Sets a track lane strip's pan law in realtime. */
+  setTrackStripPanLaw(trackId: number, panLaw: PanLaw | number): void {
+    this.native.setTrackStripPanLaw(trackId, panLawCode(panLaw));
+  }
+
+  /** Sets a track lane strip's pan mode in realtime. */
+  setTrackStripPanMode(trackId: number, panMode: PanMode | number): void {
+    this.native.setTrackStripPanMode(trackId, panModeCode(panMode));
+  }
+
+  /** Sets a track lane strip's dual-pan left/right positions in realtime. */
+  setTrackStripDualPan(trackId: number, leftPan: number, rightPan: number): void {
+    this.native.setTrackStripDualPan(trackId, 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.
+   */
+  setTrackStripChannelDelaySamples(trackId: number, delaySamples: number): void {
+    this.native.setTrackStripChannelDelaySamples(trackId, delaySamples);
+  }
+
   createClipPageProvider(
     numChannels: number,
     numSamples: number,
@@ -695,6 +807,33 @@ export class RealtimeEngine {
     return this.native.drainMeterTelemetry(maxRecords);
   }
 
+  /**
+   * 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
+   * surround meters are not delivered over the live worklet meter ring.
+   */
+  drainMeterTelemetryWide(maxRecords = 1024): EngineMeterTelemetryWide[] {
+    return this.native.drainMeterTelemetryWide(maxRecords);
+  }
+
+  /**
+   * Enables per-target spectrum + vectorscope capture. @param intervalFrames is
+   * the minimum render-frame gap between snapshots (0 disables). @param bandCount
+   * is the FFT band resolution (1..64); changing it re-prepares the tap. Returns
+   * the band count actually applied.
+   */
+  configureScopeTelemetry(intervalFrames: number, bandCount: number): number {
+    return this.native.configureScopeTelemetry(intervalFrames, bandCount);
+  }
+
+  /** Drains pending spectrum + vectorscope snapshots (per mix target). */
+  drainScopeTelemetry(maxRecords = 1024): EngineScopeTelemetry[] {
+    return this.native.drainScopeTelemetry(maxRecords);
+  }
+
   destroy(): void {
     this.native.delete();
   }

package/src/realtime_voice_changer.ts

@@ -259,7 +259,8 @@ export class RealtimeVoiceChanger {
 }
 
 export function realtimeVoiceChangerPresetNames(): VoicePresetId[] {
-  return getSonareModule().realtimeVoiceChangerPresetNames() as VoicePresetId[];
+  // Array.from re-roots embind's vector as a plain, structured-cloneable Array.
+  return Array.from(getSonareModule().realtimeVoiceChangerPresetNames()) as VoicePresetId[];
 }
 
 export function realtimeVoiceChangerPresetJson(name: VoicePresetId): string {

package/src/sonare.js.d.ts

@@ -2,6 +2,8 @@
  * Type declarations for the Emscripten-generated WASM module with embind
  */
 
+import type { SpectralRegionOp, SurroundPan } from './public_types';
+
 export interface SonareModuleOptions {
   locateFile?: (path: string, prefix: string) => string;
   wasmBinary?: ArrayBuffer | Uint8Array;
@@ -542,11 +544,22 @@ export interface WasmEngineTrackSend {
 export interface WasmEngineTrackLane {
   trackId: number;
   sends?: WasmEngineTrackSend[];
+  /**
+   * Bus the lane's post-fader output sums into instead of the master mix
+   * (group/folder routing); 0 or absent keeps the lane on the master mix.
+   */
+  outputBusId?: number;
+  /**
+   * Input channel layout of the source feeding this lane (`SonareChannelLayout`:
+   * 0 mono, 1 stereo, 2 5.1, 3 7.1). Absent defaults to stereo.
+   */
+  sourceChannelLayout?: number;
 }
 
 export interface WasmEngineBus {
   busId: number;
   gainDb?: number;
+  channelLayout?: number;
 }
 
 export interface WasmClipPageRequest {
@@ -576,6 +589,18 @@ export interface WasmEngineMarker {
   id: number;
   ppq: number;
   name?: string;
+  kind?: number;
+  keyFifths?: number;
+  keyMinor?: boolean;
+}
+
+export interface WasmProjectMarker {
+  id: number;
+  ppq: number;
+  name?: string;
+  kind?: number;
+  keyFifths?: number;
+  keyMinor?: boolean;
 }
 
 export interface WasmEngineMetronomeConfig {
@@ -646,6 +671,38 @@ export interface WasmEngineMeterTelemetry {
   droppedRecords: number;
 }
 
+export interface WasmEngineMeterTelemetryWide {
+  targetId: number;
+  renderFrame: number;
+  seq: number;
+  channelCount: number;
+  peakDb: number[];
+  rmsDb: number[];
+  truePeakDb: number[];
+  maxTruePeakDb: number;
+  correlation: number;
+  monoCompatWidth: number;
+  momentaryLufs: number;
+  shortTermLufs: number;
+  integratedLufs: number;
+  gainReductionDb: number;
+  droppedRecords: number;
+}
+
+export interface WasmEngineScopeTelemetry {
+  targetId: number;
+  renderFrame: number;
+  seq: number;
+  droppedRecords: number;
+  bands: number[];
+  /**
+   * Goniometer/vectorscope sample points as `{ left, right }` objects. The
+   * Python surface exposes the same data as `(left, right)` tuples; this
+   * representation difference is intentional, the values match.
+   */
+  points: { left: number; right: number }[];
+}
+
 export interface WasmEngineCaptureStatus {
   capturedFrames: number;
   overflowCount: number;
@@ -740,6 +797,7 @@ export interface WasmRealtimeEngine {
   play: (renderFrame: number) => void;
   stop: (renderFrame: number) => void;
   seekSample: (timelineSample: number, renderFrame: number) => void;
+  settleParameters: () => void;
   seekPpq: (ppq: number, renderFrame: number) => void;
   setTempo: (bpm: number) => void;
   setTempoSegments: (segments: WasmEngineTempoSegment[]) => void;
@@ -768,6 +826,7 @@ export interface WasmRealtimeEngine {
   setClips: (clips: WasmEngineClip[]) => void;
   clipCount: () => number;
   setTrackLanes: (lanes: Array<number | WasmEngineTrackLane>) => void;
+  setLaneSidechain: (trackId: number, insertIndex: number, sourceTrackId: number) => void;
   setTrackBuses: (buses: WasmEngineBus[]) => void;
   setBusStripJson: (busId: number, sceneJson: string) => void;
   setTrackStripJson: (trackId: number, sceneJson: string) => void;
@@ -785,6 +844,18 @@ export interface WasmRealtimeEngine {
     bypassed: boolean,
     resetOnBypass: boolean,
   ) => void;
+  setTrackStripInsertParamByName: (
+    trackId: number,
+    insertIndex: number,
+    paramName: string,
+    value: number,
+  ) => void;
+  setMasterStripInsertParamByName: (insertIndex: number, paramName: string, value: number) => void;
+  setTrackStripPan: (trackId: number, pan: number) => void;
+  setTrackStripPanLaw: (trackId: number, panLaw: number) => void;
+  setTrackStripPanMode: (trackId: number, panMode: number) => void;
+  setTrackStripDualPan: (trackId: number, leftPan: number, rightPan: number) => void;
+  setTrackStripChannelDelaySamples: (trackId: number, delaySamples: number) => void;
   createClipPageProvider: (numChannels: number, numSamples: number, pageFrames: number) => number;
   supplyClipPage: (providerId: number, pageIndex: number, channels: Float32Array[]) => void;
   clearClipPage: (providerId: number, pageIndex: number) => void;
@@ -877,6 +948,9 @@ export interface WasmRealtimeEngine {
   freezeOffline: (options: WasmEngineFreezeOptions) => WasmEngineFreezeResult;
   drainTelemetry: (maxRecords: number) => WasmEngineTelemetry[];
   drainMeterTelemetry: (maxRecords: number) => WasmEngineMeterTelemetry[];
+  drainMeterTelemetryWide: (maxRecords: number) => WasmEngineMeterTelemetryWide[];
+  configureScopeTelemetry: (intervalFrames: number, bandCount: number) => number;
+  drainScopeTelemetry: (maxRecords: number) => WasmEngineScopeTelemetry[];
   delete: () => void;
 }
 
@@ -1283,6 +1357,8 @@ export interface SonareModule {
     targetLufs: number,
     ceilingDb: number,
     truePeakOversample: number,
+    releaseMs: number,
+    applyGainAtInputRate: boolean,
   ) => WasmMasteringResult;
   masteringProcessorNames: () => string[];
   masteringPairProcessorNames: () => string[];
@@ -1449,6 +1525,12 @@ export interface SonareModule {
     options: Record<string, unknown>,
   ) => WasmMixResult;
   trim: (samples: Float32Array, sampleRate: number, thresholdDb: number) => Float32Array;
+  spectralEdit: (
+    samples: Float32Array,
+    sampleRate: number,
+    ops: SpectralRegionOp[],
+    options: Record<string, unknown>,
+  ) => Float32Array;
 
   // Features - Spectrogram
   stft: (
@@ -2033,6 +2115,7 @@ export interface WasmMixer {
   setChannelDelaySamples: (stripIndex: number, delaySamples: number) => void;
   setVcaOffsetDb: (stripIndex: number, offsetDb: number) => void;
   setDualPan: (stripIndex: number, leftPan: number, rightPan: number) => void;
+  setSurroundPan: (stripIndex: number, pan: SurroundPan) => void;
   addSend: (
     stripIndex: number,
     id: string,

package/src/stream_types.ts

@@ -75,6 +75,11 @@ export interface FrameBuffer {
   /** Number of mel bands; flat `mel` is `[nFrames * nMels]` row-major. */
   nMels: number;
   timestamps: Float32Array;
+  /**
+   * Mel spectrogram in LINEAR power (not dB) — the raw per-frame mel energies.
+   * The quantized read paths (`readFramesU8` / `readFramesI16`) convert to dB
+   * before packing, so their `mel` is dB-scaled; this float buffer is not.
+   */
   mel: Float32Array;
   chroma: Float32Array;
   onsetStrength: Float32Array;
@@ -109,6 +114,7 @@ export interface StreamFramesU8 {
   nFrames: number;
   nMels: number;
   timestamps: Float32Array;
+  /** Row-major `[nFrames * nMels]` mel in dB, quantized over `[melDbMin, melDbMax]`. */
   mel: Uint8Array;
   chroma: Uint8Array;
   onsetStrength: Uint8Array;
@@ -121,6 +127,7 @@ export interface StreamFramesI16 {
   nFrames: number;
   nMels: number;
   timestamps: Float32Array;
+  /** Row-major `[nFrames * nMels]` mel in dB, quantized over `[melDbMin, melDbMax]`. */
   mel: Int16Array;
   chroma: Int16Array;
   onsetStrength: Int16Array;

package/src/validation.ts

@@ -2,6 +2,13 @@
  * Per-call validation options accepted by guarded wrappers. Empty-buffer
  * checks are always performed; pass `{ validate: false }` to opt out of the
  * O(n) NaN/Inf scan on hot paths.
+ *
+ * `{ validate: false }` only skips this JS-side pre-scan (which raises a
+ * `RangeError` naming the exact offending index). It is NOT a way to push
+ * non-finite samples into the core: the native layer always re-validates the
+ * buffer (see `validate_offline_audio_input` in the C++ core), matching the C
+ * ABI / Node / Python surfaces, so an NaN/Inf buffer still throws — just with a
+ * generic native message instead of the indexed JS one.
  */
 export interface ValidateOptions {
   validate?: boolean;

package/src/worklet/audio_types.ts

@@ -0,0 +1,2 @@
+export type WorkletInput = readonly (readonly Float32Array[])[];
+export type WorkletOutput = Float32Array[][];

package/src/worklet/guards.ts

@@ -0,0 +1,146 @@
+import type {
+  SonareEngineCaptureRequestMessage,
+  SonareEngineCaptureResponseMessage,
+  SonareEngineSyncMessage,
+  SonareEngineTransportRequestMessage,
+  SonareEngineTransportResponseMessage,
+  SonareRealtimeVoiceChangerMessage,
+  SonareWorkletMessage,
+} from './messages';
+import {
+  isRecord,
+  type SonareEngineCommandRecord,
+  type SonareEngineTelemetryRecord,
+  type SonareWorkletMeterSnapshot,
+} from './protocol';
+
+export function isWorkletMessage(value: unknown): value is SonareWorkletMessage {
+  if (!isRecord(value) || typeof value.type !== 'string') {
+    return false;
+  }
+  return (
+    value.type === 'scheduleInsertAutomation' ||
+    value.type === 'setMeterInterval' ||
+    value.type === 'destroy'
+  );
+}
+
+export function isEngineCommandRecord(value: unknown): value is SonareEngineCommandRecord {
+  return isRecord(value) && typeof value.type === 'number';
+}
+
+export function isEngineSyncMessage(value: unknown): value is SonareEngineSyncMessage {
+  if (!isRecord(value) || typeof value.type !== 'string') {
+    return false;
+  }
+  return (
+    value.type === 'syncClips' ||
+    value.type === 'syncClipsDelta' ||
+    value.type === 'syncMidiClips' ||
+    value.type === 'syncMarkers' ||
+    value.type === 'syncMetronome' ||
+    value.type === 'syncAutomation' ||
+    value.type === 'syncTempo' ||
+    value.type === 'syncMixer' ||
+    value.type === 'syncCapture' ||
+    value.type === 'syncTrackStripEqBand' ||
+    value.type === 'syncMasterStripEqBand' ||
+    value.type === 'syncTrackStripInsertBypassed' ||
+    value.type === 'syncMasterStripInsertBypassed' ||
+    value.type === 'syncTrackStripInsertParamByName' ||
+    value.type === 'syncMasterStripInsertParamByName' ||
+    value.type === 'syncTrackStripPan' ||
+    value.type === 'syncTrackStripPanLaw' ||
+    value.type === 'syncTrackStripPanMode' ||
+    value.type === 'syncTrackStripDualPan' ||
+    value.type === 'syncTrackStripChannelDelaySamples' ||
+    value.type === 'syncBuiltinInstrument' ||
+    value.type === 'syncSynthInstrument' ||
+    value.type === 'syncSf2Instrument' ||
+    value.type === 'syncLoadSoundFont' ||
+    value.type === 'syncMidiNoteOn' ||
+    value.type === 'syncMidiNoteOff' ||
+    value.type === 'syncMidiCc' ||
+    value.type === 'syncMidiPanic'
+  );
+}
+
+export function isEngineCaptureRequestMessage(
+  value: unknown,
+): value is SonareEngineCaptureRequestMessage {
+  return (
+    isRecord(value) &&
+    value.type === 'captureRequest' &&
+    typeof value.requestId === 'number' &&
+    (value.op === 'status' || value.op === 'read' || value.op === 'reset')
+  );
+}
+
+export function isEngineCaptureResponseMessage(
+  value: unknown,
+): value is SonareEngineCaptureResponseMessage {
+  return (
+    isRecord(value) &&
+    value.type === 'captureResponse' &&
+    typeof value.requestId === 'number' &&
+    typeof value.ok === 'boolean'
+  );
+}
+
+export function isEngineTransportRequestMessage(
+  value: unknown,
+): value is SonareEngineTransportRequestMessage {
+  return (
+    isRecord(value) &&
+    value.type === 'transportRequest' &&
+    typeof value.requestId === 'number' &&
+    value.op === 'state'
+  );
+}
+
+export function isEngineTransportResponseMessage(
+  value: unknown,
+): value is SonareEngineTransportResponseMessage {
+  return (
+    isRecord(value) &&
+    value.type === 'transportResponse' &&
+    typeof value.requestId === 'number' &&
+    typeof value.ok === 'boolean'
+  );
+}
+
+export function isRealtimeVoiceChangerMessage(
+  value: unknown,
+): value is SonareRealtimeVoiceChangerMessage {
+  if (!isRecord(value) || typeof value.type !== 'string') {
+    return false;
+  }
+  return value.type === 'setConfig' || value.type === 'reset' || value.type === 'destroy';
+}
+
+export function isEngineTelemetryRecord(value: unknown): value is SonareEngineTelemetryRecord {
+  return (
+    isRecord(value) &&
+    typeof value.type === 'number' &&
+    typeof value.error === 'number' &&
+    typeof value.renderFrame === 'number' &&
+    typeof value.timelineSample === 'number' &&
+    typeof value.audibleTimelineSample === 'number' &&
+    typeof value.graphLatencySamplesQ8 === 'number' &&
+    typeof value.value === 'number'
+  );
+}
+
+export function isMeterSnapshot(value: unknown): value is SonareWorkletMeterSnapshot {
+  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 === undefined)
+  );
+}