@libraz/libsonare 1.5.5 → 1.7.0

package/src/worklet/protocol.ts

@@ -77,6 +77,17 @@ export function decodeFrame(lo: number, hi: number): number {
 export const SONARE_ENGINE_RING_HEADER_INTS = 5;
 export const SONARE_ENGINE_COMMAND_RECORD_BYTES = 32;
 export const SONARE_ENGINE_TELEMETRY_RECORD_BYTES = 48;
+// Clip-page request ring header: [writeIndex, readIndex, capacity,
+// recordUint32s, dropped]. Records are [clipId, pageIndex]. This is an SPSC
+// queue: the AudioWorklet is the sole writer and the main thread is the sole
+// reader. Unlike the telemetry rings, it must not overwrite unread requests:
+// the producer increments `dropped` when the fixed queue is full.
+export const SONARE_CLIP_PAGE_REQUEST_RING_HEADER_INTS = 5;
+export const SONARE_CLIP_PAGE_REQUEST_RING_RECORD_UINT32S = 2;
+// External MIDI records: destination ID, render-frame offset, packed MIDI-1
+// bytes (little-endian), and byte count. SPSC worklet -> main-thread ring.
+export const SONARE_EXTERNAL_MIDI_RING_HEADER_INTS = 5;
+export const SONARE_EXTERNAL_MIDI_RING_RECORD_UINT32S = 4;
 
 export enum SonareEngineCommandType {
   SetParam = 0,
@@ -97,6 +108,9 @@ export enum SonareEngineCommandType {
   SetMetronome = 15,
   SetMarker = 16,
   SeekMarker = 17,
+  // Queueable lane monitor-mode transition. The worklet command vocabulary
+  // deliberately leaves 18..25 unused; this is the stable ABI-v3 ordinal.
+  SetTrackMonitorMode = 26,
 }
 
 export enum SonareEngineTelemetryType {
@@ -124,6 +138,8 @@ export enum SonareEngineTelemetryError {
   InsertAutomationOverflow = 16,
   MidiClockOverflow = 17,
   MetronomeOverflow = 18,
+  InvalidCommand = 19,
+  MaxChannelsExceeded = 20,
 }
 
 export interface SonareMeterRingBuffer {
@@ -182,6 +198,31 @@ export interface SonareScopeRingReadResult {
   scopes: SonareWorkletScopeSnapshot[];
 }
 
+export interface SonareExternalMidiRingEvent {
+  destinationId: number;
+  renderFrame: number;
+  byteWord: number;
+  byteCount: number;
+}
+
+export interface SonareExternalMidiRingBuffer {
+  sharedBuffer: SharedArrayBuffer;
+  header: Int32Array;
+  records: Uint32Array;
+  capacity: number;
+}
+
+export interface SharedExternalMidiRingWriter {
+  header: Int32Array;
+  records: Uint32Array;
+  capacity: number;
+}
+
+export interface SonareExternalMidiRingReadResult {
+  events: SonareExternalMidiRingEvent[];
+  dropped: number;
+}
+
 export interface SharedScopeRingWriter {
   header: Int32Array;
   records: Float32Array;
@@ -228,6 +269,30 @@ export interface SonareEngineTelemetryRingReadResult {
   telemetry: SonareEngineTelemetryRecord[];
 }
 
+export interface SonareClipPageRequest {
+  clipId: number;
+  pageIndex: number;
+}
+
+export interface SonareClipPageRequestRingBuffer {
+  sharedBuffer: SharedArrayBuffer;
+  header: Int32Array;
+  records: Uint32Array;
+  capacity: number;
+}
+
+export interface SharedClipPageRequestRingWriter {
+  header: Int32Array;
+  records: Uint32Array;
+  capacity: number;
+}
+
+export interface SonareClipPageRequestRingReadResult {
+  requests: SonareClipPageRequest[];
+  /** Cumulative uint32 drop count for native and SAB-ring overflows. */
+  dropped: number;
+}
+
 export interface SharedMeterRingWriter {
   header: Int32Array;
   records: Float32Array;
@@ -497,6 +562,190 @@ export function sonareEngineTelemetryRingBufferByteLength(capacity: number): num
   );
 }
 
+export function sonareClipPageRequestRingBufferByteLength(capacity: number): number {
+  const clampedCapacity = Math.max(1, Math.floor(capacity));
+  return (
+    SONARE_CLIP_PAGE_REQUEST_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT +
+    clampedCapacity * SONARE_CLIP_PAGE_REQUEST_RING_RECORD_UINT32S * Uint32Array.BYTES_PER_ELEMENT
+  );
+}
+
+export function sonareExternalMidiRingBufferByteLength(capacity: number): number {
+  const clampedCapacity = Math.max(1, Math.floor(capacity));
+  return (
+    SONARE_EXTERNAL_MIDI_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT +
+    clampedCapacity * SONARE_EXTERNAL_MIDI_RING_RECORD_UINT32S * Uint32Array.BYTES_PER_ELEMENT
+  );
+}
+
+export function externalMidiRingFromSharedBuffer(
+  sharedBuffer: SharedArrayBuffer,
+  fallbackCapacity?: number,
+): SharedExternalMidiRingWriter {
+  const headerBytes = SONARE_EXTERNAL_MIDI_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT;
+  const header = new Int32Array(sharedBuffer, 0, SONARE_EXTERNAL_MIDI_RING_HEADER_INTS);
+  const existingCapacity = Atomics.load(header, 2);
+  const capacity = Math.max(1, Math.floor(existingCapacity || fallbackCapacity || 1));
+  if (sharedBuffer.byteLength < sonareExternalMidiRingBufferByteLength(capacity)) {
+    throw new Error('externalMidiSharedBuffer is too small for the requested ring capacity.');
+  }
+  Atomics.store(header, 2, capacity);
+  Atomics.store(header, 3, SONARE_EXTERNAL_MIDI_RING_RECORD_UINT32S);
+  return {
+    header,
+    records: new Uint32Array(
+      sharedBuffer,
+      headerBytes,
+      capacity * SONARE_EXTERNAL_MIDI_RING_RECORD_UINT32S,
+    ),
+    capacity,
+  };
+}
+
+export function createSonareExternalMidiRingBuffer(capacity = 256): SonareExternalMidiRingBuffer {
+  const clampedCapacity = Math.max(1, Math.floor(capacity));
+  const sharedBuffer = new SharedArrayBuffer(
+    sonareExternalMidiRingBufferByteLength(clampedCapacity),
+  );
+  const ring = externalMidiRingFromSharedBuffer(sharedBuffer, clampedCapacity);
+  Atomics.store(ring.header, 0, 0);
+  Atomics.store(ring.header, 1, 0);
+  Atomics.store(ring.header, 4, 0);
+  return { sharedBuffer, header: ring.header, records: ring.records, capacity: ring.capacity };
+}
+
+/** Write one lowered MIDI-1 event without allocations from the audio worklet. */
+export function pushSonareExternalMidiRingBuffer(
+  ring: SharedExternalMidiRingWriter,
+  destinationId: number,
+  renderFrame: number,
+  byteWord: number,
+  byteCount: number,
+): boolean {
+  // Emscripten can expose an int64 render-frame scalar as bigint when the
+  // host enables WASM_BIGINT. Normalize at this fixed-record boundary.
+  const destination = Number(destinationId);
+  const frame = Number(renderFrame);
+  const packedBytes = Number(byteWord);
+  const count = Number(byteCount);
+  if (
+    !Number.isSafeInteger(destination) ||
+    !Number.isSafeInteger(frame) ||
+    frame < 0 ||
+    !Number.isSafeInteger(packedBytes) ||
+    packedBytes < 0 ||
+    packedBytes > 0xff_ffff ||
+    !Number.isSafeInteger(count) ||
+    count < 1 ||
+    count > 3
+  ) {
+    Atomics.add(ring.header, 4, 1);
+    return false;
+  }
+  const writeIndex = Atomics.load(ring.header, 0);
+  const readIndex = Atomics.load(ring.header, 1);
+  if (writeIndex - readIndex >= ring.capacity) {
+    Atomics.add(ring.header, 4, 1);
+    return false;
+  }
+  const offset = (writeIndex % ring.capacity) * SONARE_EXTERNAL_MIDI_RING_RECORD_UINT32S;
+  Atomics.store(ring.records, offset, destination);
+  Atomics.store(ring.records, offset + 1, frame);
+  Atomics.store(ring.records, offset + 2, packedBytes);
+  Atomics.store(ring.records, offset + 3, count);
+  Atomics.store(ring.header, 0, writeIndex + 1);
+  return true;
+}
+
+/** Main-thread drain. It is intentionally the only place MIDI byte arrays are built. */
+export function readSonareExternalMidiRingBuffer(
+  ring: SonareExternalMidiRingBuffer,
+): SonareExternalMidiRingReadResult {
+  const readIndex = Atomics.load(ring.header, 1);
+  const writeIndex = Atomics.load(ring.header, 0);
+  const events: SonareExternalMidiRingEvent[] = [];
+  for (let index = readIndex; index < writeIndex; index++) {
+    const offset = (index % ring.capacity) * SONARE_EXTERNAL_MIDI_RING_RECORD_UINT32S;
+    events.push({
+      destinationId: Atomics.load(ring.records, offset) >>> 0,
+      renderFrame: Atomics.load(ring.records, offset + 1) >>> 0,
+      byteWord: Atomics.load(ring.records, offset + 2) >>> 0,
+      byteCount: Atomics.load(ring.records, offset + 3) >>> 0,
+    });
+  }
+  Atomics.store(ring.header, 1, writeIndex);
+  return { events, dropped: Atomics.load(ring.header, 4) >>> 0 };
+}
+
+export function createSonareClipPageRequestRingBuffer(
+  capacity = 128,
+): SonareClipPageRequestRingBuffer {
+  const clampedCapacity = Math.max(1, Math.floor(capacity));
+  const sharedBuffer = new SharedArrayBuffer(
+    sonareClipPageRequestRingBufferByteLength(clampedCapacity),
+  );
+  const ring = clipPageRequestRingFromSharedBuffer(sharedBuffer, clampedCapacity);
+  Atomics.store(ring.header, 0, 0);
+  Atomics.store(ring.header, 1, 0);
+  Atomics.store(ring.header, 2, ring.capacity);
+  Atomics.store(ring.header, 3, SONARE_CLIP_PAGE_REQUEST_RING_RECORD_UINT32S);
+  Atomics.store(ring.header, 4, 0);
+  return { sharedBuffer, header: ring.header, records: ring.records, capacity: ring.capacity };
+}
+
+/**
+ * Writes one request without allocating. Invalid uint32 coordinates and a full
+ * ring are counted as drops so the main thread can surface a bounded-loss
+ * diagnostic without receiving a worklet postMessage.
+ */
+export function pushSonareClipPageRequestRingBuffer(
+  ring: SharedClipPageRequestRingWriter,
+  clipId: number,
+  pageIndex: number,
+): boolean {
+  if (
+    !Number.isSafeInteger(clipId) ||
+    clipId < 0 ||
+    clipId > 0xffff_ffff ||
+    !Number.isSafeInteger(pageIndex) ||
+    pageIndex < 0 ||
+    pageIndex > 0xffff_ffff
+  ) {
+    Atomics.add(ring.header, 4, 1);
+    return false;
+  }
+  const writeIndex = Atomics.load(ring.header, 0);
+  const readIndex = Atomics.load(ring.header, 1);
+  if (writeIndex - readIndex >= ring.capacity) {
+    Atomics.add(ring.header, 4, 1);
+    return false;
+  }
+  const offset = (writeIndex % ring.capacity) * SONARE_CLIP_PAGE_REQUEST_RING_RECORD_UINT32S;
+  Atomics.store(ring.records, offset, clipId);
+  Atomics.store(ring.records, offset + 1, pageIndex);
+  // Publish only after both scalar fields have been written.
+  Atomics.store(ring.header, 0, writeIndex + 1);
+  return true;
+}
+
+/** Drains the SPSC request ring on the main thread. Object creation is here, never in process(). */
+export function readSonareClipPageRequestRingBuffer(
+  ring: SonareClipPageRequestRingBuffer,
+): SonareClipPageRequestRingReadResult {
+  const readIndex = Atomics.load(ring.header, 1);
+  const writeIndex = Atomics.load(ring.header, 0);
+  const requests: SonareClipPageRequest[] = [];
+  for (let index = readIndex; index < writeIndex; index++) {
+    const offset = (index % ring.capacity) * SONARE_CLIP_PAGE_REQUEST_RING_RECORD_UINT32S;
+    requests.push({
+      clipId: Atomics.load(ring.records, offset),
+      pageIndex: Atomics.load(ring.records, offset + 1),
+    });
+  }
+  Atomics.store(ring.header, 1, writeIndex);
+  return { requests, dropped: Atomics.load(ring.header, 4) >>> 0 };
+}
+
 export function createSonareEngineCommandRingBuffer(capacity = 128): SonareEngineCommandRingBuffer {
   const clampedCapacity = Math.max(1, Math.floor(capacity));
   const sharedBuffer = new SharedArrayBuffer(
@@ -670,18 +919,56 @@ export function engineRingFromSharedBuffer(
   };
 }
 
+export function clipPageRequestRingFromSharedBuffer(
+  sharedBuffer: SharedArrayBuffer,
+  fallbackCapacity?: number,
+): SharedClipPageRequestRingWriter {
+  const headerBytes = SONARE_CLIP_PAGE_REQUEST_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT;
+  const header = new Int32Array(sharedBuffer, 0, SONARE_CLIP_PAGE_REQUEST_RING_HEADER_INTS);
+  const existingCapacity = Atomics.load(header, 2);
+  const capacity = Math.max(1, Math.floor(existingCapacity || fallbackCapacity || 1));
+  const minBytes = sonareClipPageRequestRingBufferByteLength(capacity);
+  if (sharedBuffer.byteLength < minBytes) {
+    throw new Error('clipPageRequestSharedBuffer is too small for the requested ring capacity.');
+  }
+  Atomics.store(header, 2, capacity);
+  Atomics.store(header, 3, SONARE_CLIP_PAGE_REQUEST_RING_RECORD_UINT32S);
+  return {
+    header,
+    records: new Uint32Array(
+      sharedBuffer,
+      headerBytes,
+      capacity * SONARE_CLIP_PAGE_REQUEST_RING_RECORD_UINT32S,
+    ),
+    capacity,
+  };
+}
+
 function recordOffset(index: number, capacity: number, recordBytes: number): number {
   return (index % capacity) * recordBytes;
 }
 
-export function toBigInt64(value: number | bigint | undefined, fallback: bigint): bigint {
-  if (typeof value === 'bigint') {
-    return value;
+function toSafeInteger(value: number | bigint | undefined, fallback: number): number {
+  const resolved = typeof value === 'bigint' ? Number(value) : value;
+  if (resolved === undefined) {
+    return fallback;
   }
-  if (typeof value === 'number') {
-    return BigInt(Math.trunc(value));
+  if (!Number.isSafeInteger(resolved)) {
+    throw new RangeError('64-bit ring values must be safe integers');
   }
-  return fallback;
+  return resolved;
+}
+
+/** Store a signed 64-bit safe integer as two 32-bit words without BigInt. */
+export function writeInt64Words(view: DataView, offset: number, value: number): void {
+  const integer = toSafeInteger(value, 0);
+  view.setUint32(offset, integer >>> 0, true);
+  view.setInt32(offset + 4, Math.floor(integer / 0x100000000), true);
+}
+
+/** Reconstruct a signed 64-bit safe integer stored by {@link writeInt64Words}. */
+export function readInt64Words(view: DataView, offset: number): number {
+  return view.getInt32(offset + 4, true) * 0x100000000 + view.getUint32(offset, true);
 }
 
 function writeEngineCommandRecord(
@@ -691,21 +978,21 @@ function writeEngineCommandRecord(
 ): void {
   view.setUint32(offset, command.type, true);
   view.setUint32(offset + 4, command.targetId ?? 0, true);
-  view.setBigInt64(offset + 8, toBigInt64(command.sampleTime, -1n), true);
+  writeInt64Words(view, offset + 8, toSafeInteger(command.sampleTime, -1));
   // argFloat occupies a full 8-byte Float64 slot (replacing the old Float32 +
   // 4-byte pad) so PPQ scalars carried here keep full double precision over the
   // SAB transport, matching the engine's double-precision seek/loop contract.
   view.setFloat64(offset + 16, command.argFloat ?? 0, true);
-  view.setBigInt64(offset + 24, toBigInt64(command.argInt, 0n), true);
+  writeInt64Words(view, offset + 24, toSafeInteger(command.argInt, 0));
 }
 
 function readEngineCommandRecord(view: DataView, offset: number): SonareEngineCommandRecord {
   return {
     type: view.getUint32(offset, true),
     targetId: view.getUint32(offset + 4, true),
-    sampleTime: Number(view.getBigInt64(offset + 8, true)),
+    sampleTime: readInt64Words(view, offset + 8),
     argFloat: view.getFloat64(offset + 16, true),
-    argInt: Number(view.getBigInt64(offset + 24, true)),
+    argInt: readInt64Words(view, offset + 24),
   };
 }
 
@@ -716,21 +1003,22 @@ function writeEngineTelemetryRecord(
 ): void {
   view.setUint32(offset, telemetry.type, true);
   view.setUint32(offset + 4, telemetry.error, true);
-  view.setBigInt64(offset + 8, BigInt(Math.trunc(telemetry.renderFrame)), true);
-  view.setBigInt64(offset + 16, BigInt(Math.trunc(telemetry.timelineSample)), true);
-  view.setBigInt64(offset + 24, BigInt(Math.trunc(telemetry.audibleTimelineSample)), true);
+  writeInt64Words(view, offset + 8, telemetry.renderFrame);
+  writeInt64Words(view, offset + 16, telemetry.timelineSample);
+  writeInt64Words(view, offset + 24, telemetry.audibleTimelineSample);
   view.setInt32(offset + 32, telemetry.graphLatencySamplesQ8, true);
   view.setUint32(offset + 36, telemetry.value, true);
-  view.setBigInt64(offset + 40, 0n, true);
+  view.setUint32(offset + 40, 0, true);
+  view.setUint32(offset + 44, 0, true);
 }
 
 function readEngineTelemetryRecord(view: DataView, offset: number): SonareEngineTelemetryRecord {
   return {
     type: view.getUint32(offset, true),
     error: view.getUint32(offset + 4, true),
-    renderFrame: Number(view.getBigInt64(offset + 8, true)),
-    timelineSample: Number(view.getBigInt64(offset + 16, true)),
-    audibleTimelineSample: Number(view.getBigInt64(offset + 24, true)),
+    renderFrame: readInt64Words(view, offset + 8),
+    timelineSample: readInt64Words(view, offset + 16),
+    audibleTimelineSample: readInt64Words(view, offset + 24),
     graphLatencySamplesQ8: view.getInt32(offset + 32, true),
     value: view.getUint32(offset + 36, true),
   };

package/src/worklet/voice-changer-processor.ts

@@ -19,6 +19,7 @@ export class SonareRealtimeVoiceChangerWorkletProcessor {
   // audio-thread process() never crosses an allocation boundary.
   private monoInput: Float32Array;
   private monoOutput: Float32Array;
+  private bufferGeneration: number;
   // Planar heap-backed views (one Float32Array per channel) used by the
   // multi-channel path. AudioWorklet inputs/outputs are already planar
   // Float32Arrays, so this avoids the per-sample interleave/deinterleave
@@ -37,6 +38,7 @@ export class SonareRealtimeVoiceChangerWorkletProcessor {
     // process() than blockSize, we clamp (see ensure*Capacity).
     this.monoInput = this.changer.getMonoInputBuffer(this.blockSize);
     this.monoOutput = this.changer.getMonoOutputBuffer(this.blockSize);
+    this.bufferGeneration = this.changer.bufferGeneration();
     this.planarChannels = [];
     if (this.channelCount > 1) {
       for (let ch = 0; ch < this.channelCount; ch++) {
@@ -46,22 +48,16 @@ export class SonareRealtimeVoiceChangerWorkletProcessor {
   }
 
   /**
-   * Handles a control-plane message from the main thread. Runs on the
-   * AudioWorklet global scope but OUTSIDE of `process()` (i.e. outside the
-   * realtime audio callback), so it is safe to perform JSON parsing and
-   * DSP coefficient recomputation here. `setConfig` MUST NOT be deferred
-   * into `process()` because that would block the audio thread for longer
-   * than one render quantum (e.g. 128 samples / 44.1 kHz = ~2.9 ms).
+   * Handles a control-plane message from the main thread. AudioWorklet port
+   * handlers run on the same audio rendering thread as `process()`: this path
+   * therefore accepts only a pre-normalized POD and never parses JSON.
    */
   receiveMessage(message: SonareRealtimeVoiceChangerMessage): void {
     if (this.destroyed) {
       return;
     }
     if (message.type === 'setConfig') {
-      // Apply synchronously on the message-handler thread. `setConfig` may
-      // allocate and parse JSON internally; doing it here keeps `process()`
-      // realtime-safe.
-      this.changer.setConfig(message.preset);
+      this.changer.setPodConfig(message.config);
     } else if (message.type === 'reset') {
       this.changer.reset();
     } else if (message.type === 'destroy') {
@@ -79,7 +75,10 @@ export class SonareRealtimeVoiceChangerWorkletProcessor {
     // module is built ALLOW_MEMORY_GROWTH). Re-acquire them if detached
     // (byteLength === 0) before touching them; in the common no-growth case this
     // is a cheap branch with no allocation.
-    if (this.monoInput.byteLength === 0) {
+    if (
+      this.bufferGeneration !== this.changer.bufferGeneration() ||
+      this.monoInput.byteLength === 0
+    ) {
       this.reacquireBuffers();
     }
 
@@ -100,10 +99,7 @@ export class SonareRealtimeVoiceChangerWorkletProcessor {
       } else {
         this.monoInput.fill(0, 0, frames);
       }
-      this.changer.processMonoInto(
-        this.monoInput.subarray(0, frames),
-        this.monoOutput.subarray(0, frames),
-      );
+      this.changer.processPreparedMono(frames);
       output[0].set(this.monoOutput.subarray(0, frames));
       return true;
     }
@@ -156,6 +152,7 @@ export class SonareRealtimeVoiceChangerWorkletProcessor {
         this.planarChannels[ch] = this.changer.getPlanarChannelBuffer(ch, this.blockSize);
       }
     }
+    this.bufferGeneration = this.changer.bufferGeneration();
   }
 
   /**

package/src/worklet.ts

@@ -4,19 +4,21 @@
 // AudioWorkletGlobalScope cannot resolve sibling chunks), so the public surface
 // is unchanged.
 
+export type { OpfsClipStream, OpfsClipStreamOptions } from './clip_page_streamer';
+export { attachOpfsClipStream } from './clip_page_streamer';
 // With code-splitting disabled, the worklet bundle carries its own copy of the
 // module singleton. Re-export the lifecycle so that realm can initialize its
 // own wasm instance, independent of the main-thread `index` module.
 export { init, isInitialized } from './index';
 export { SonareEngine } from './worklet/engine';
 export { SonareRealtimeEngineNode } from './worklet/engine-node';
-
 export type { SonareEngineOptions } from './worklet/engine-options';
 export { SonareRealtimeEngineWorkletProcessor } from './worklet/engine-processor';
 export { registerSonareRealtimeEngineWorkletProcessor } from './worklet/engine-register';
 export type {
   SonareEngineCaptureRequestMessage,
   SonareEngineCaptureResponseMessage,
+  SonareEngineClipPageRequestMessage,
   SonareEngineSyncAutomationMessage,
   SonareEngineSyncBuiltinInstrumentMessage,
   SonareEngineSyncCaptureMessage,
@@ -61,8 +63,10 @@ export {
   SonareWorkletProcessor,
 } from './worklet/mixer-processor';
 export {
+  createSonareClipPageRequestRingBuffer,
   createSonareEngineCommandRingBuffer,
   createSonareEngineTelemetryRingBuffer,
+  createSonareExternalMidiRingBuffer,
   createSonareMeterRingBuffer,
   createSonareScopeRingBuffer,
   createSonareSpectrumRingBuffer,
@@ -70,18 +74,29 @@ export {
   encodeFrameHi,
   encodeFrameLo,
   popSonareEngineCommandRingBuffer,
+  pushSonareClipPageRequestRingBuffer,
   pushSonareEngineCommandRingBuffer,
+  pushSonareExternalMidiRingBuffer,
+  readSonareClipPageRequestRingBuffer,
   readSonareEngineTelemetryRingBuffer,
+  readSonareExternalMidiRingBuffer,
   readSonareMeterRingBuffer,
   readSonareScopeRingBuffer,
   readSonareSpectrumRingBuffer,
+  SONARE_CLIP_PAGE_REQUEST_RING_HEADER_INTS,
+  SONARE_CLIP_PAGE_REQUEST_RING_RECORD_UINT32S,
   SONARE_ENGINE_COMMAND_RECORD_BYTES,
   SONARE_ENGINE_RING_HEADER_INTS,
   SONARE_ENGINE_TELEMETRY_RECORD_BYTES,
+  SONARE_EXTERNAL_MIDI_RING_HEADER_INTS,
+  SONARE_EXTERNAL_MIDI_RING_RECORD_UINT32S,
   SONARE_METER_RING_HEADER_INTS,
   SONARE_METER_RING_RECORD_FLOATS,
   SONARE_SCOPE_RING_HEADER_INTS,
   SONARE_SPECTRUM_RING_HEADER_INTS,
+  type SonareClipPageRequest,
+  type SonareClipPageRequestRingBuffer,
+  type SonareClipPageRequestRingReadResult,
   type SonareEngineCommandRecord,
   type SonareEngineCommandRingBuffer,
   SonareEngineCommandType,
@@ -90,6 +105,8 @@ export {
   type SonareEngineTelemetryRingBuffer,
   type SonareEngineTelemetryRingReadResult,
   SonareEngineTelemetryType,
+  type SonareExternalMidiRingBuffer,
+  type SonareExternalMidiRingReadResult,
   type SonareMeterRingBuffer,
   type SonareMeterRingReadResult,
   type SonareScopeRingBuffer,
@@ -99,8 +116,10 @@ export {
   type SonareWorkletMeterSnapshot,
   type SonareWorkletScopeSnapshot,
   type SonareWorkletSpectrumSnapshot,
+  sonareClipPageRequestRingBufferByteLength,
   sonareEngineCommandRingBufferByteLength,
   sonareEngineTelemetryRingBufferByteLength,
+  sonareExternalMidiRingBufferByteLength,
   sonareMeterRingBufferByteLength,
   sonareScopeRingBufferByteLength,
   sonareSpectrumRingBufferByteLength,