@libraz/libsonare 1.3.2 → 1.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libraz/libsonare",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "type": "module",
   "packageManager": "yarn@4.15.0",
   "description": "Audio analysis library for music information retrieval",

package/src/index.ts

@@ -401,6 +401,7 @@ export type {
   EngineAutomationPoint,
   EngineBounceOptions,
   EngineBounceResult,
+  EngineBus,
   EngineCapabilities,
   EngineCaptureStatus,
   EngineClip,
@@ -410,8 +411,14 @@ export type {
   EngineMarker,
   EngineMeterTelemetry,
   EngineMetronomeConfig,
+  EngineMidiClipSchedule,
+  EngineMidiEvent,
   EngineParameterInfo,
   EngineTelemetry,
+  EngineTempoSegment,
+  EngineTimeSignatureSegment,
+  EngineTrackLane,
+  EngineTrackSend,
   EngineTransportState,
   MidiCcBindOptions,
 } from './realtime_engine';
@@ -484,6 +491,11 @@ let initPromise: Promise<void> | null = null;
  */
 export async function init(options?: {
   locateFile?: (path: string, prefix: string) => string;
+  wasmBinary?: ArrayBuffer | Uint8Array;
+  moduleFactory?: (options?: {
+    locateFile?: (path: string, prefix: string) => string;
+    wasmBinary?: ArrayBuffer | Uint8Array;
+  }) => Promise<SonareModule>;
 }): Promise<void> {
   if (module) {
     return;
@@ -495,7 +507,7 @@ export async function init(options?: {
 
   initPromise = (async () => {
     try {
-      const createModule = (await import('./sonare.js')).default;
+      const createModule = options?.moduleFactory ?? (await import('./sonare.js')).default;
       module = await createModule(options);
       setSonareModule(module);
     } catch (error) {

package/src/module_state.ts

@@ -70,6 +70,7 @@ function makeSonareError(raw: SonareModule, thrown: number): SonareError {
  */
 function wrapModuleErrors(raw: SonareModule): SonareModule {
   const cache = new Map<PropertyKey, unknown>();
+  const objectCache = new WeakMap<object, unknown>();
   const convert = (error: unknown): never => {
     const ptr = nativeExceptionPtr(error);
     if (ptr !== null) {
@@ -77,6 +78,86 @@ function wrapModuleErrors(raw: SonareModule): SonareModule {
     }
     throw error;
   };
+
+  const wrapNativeObject = (value: unknown): unknown => {
+    if (value === null || typeof value !== 'object') {
+      return value;
+    }
+    if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof Promise) {
+      return value;
+    }
+    const objectValue = value as object;
+    const cached = objectCache.get(objectValue);
+    if (cached) {
+      return cached;
+    }
+    const methodCache = new Map<PropertyKey, unknown>();
+    const wrapped = new Proxy(objectValue, {
+      get(target, prop, receiver) {
+        const member = Reflect.get(target, prop, receiver);
+        if (typeof member !== 'function') {
+          return member;
+        }
+        const cachedMethod = methodCache.get(prop);
+        if (cachedMethod) {
+          return cachedMethod;
+        }
+        const method = member as (...a: unknown[]) => unknown;
+        const wrappedMethod = (...args: unknown[]) => {
+          try {
+            return wrapNativeObject(Reflect.apply(method, target, args));
+          } catch (error) {
+            return convert(error);
+          }
+        };
+        methodCache.set(prop, wrappedMethod);
+        return wrappedMethod;
+      },
+    });
+    objectCache.set(objectValue, wrapped);
+    return wrapped;
+  };
+
+  const wrapFunction = (value: (...a: unknown[]) => unknown): unknown => {
+    const fnCache = new Map<PropertyKey, unknown>();
+    return new Proxy(value, {
+      get(target, prop, receiver) {
+        const member = Reflect.get(target, prop, receiver);
+        if (typeof member !== 'function') {
+          return member;
+        }
+        const cachedMember = fnCache.get(prop);
+        if (cachedMember) {
+          return cachedMember;
+        }
+        const fn = member as (...a: unknown[]) => unknown;
+        const wrappedMember = (...args: unknown[]) => {
+          try {
+            return wrapNativeObject(Reflect.apply(fn, target, args));
+          } catch (error) {
+            return convert(error);
+          }
+        };
+        fnCache.set(prop, wrappedMember);
+        return wrappedMember;
+      },
+      apply(t, thisArg, args) {
+        try {
+          return wrapNativeObject(Reflect.apply(t, thisArg, args as unknown[]));
+        } catch (error) {
+          return convert(error);
+        }
+      },
+      construct(t, args, newTarget) {
+        try {
+          return wrapNativeObject(Reflect.construct(t, args as unknown[], newTarget));
+        } catch (error) {
+          return convert(error) as object;
+        }
+      },
+    });
+  };
+
   return new Proxy(raw, {
     get(target, prop, receiver) {
       const value = Reflect.get(target, prop, receiver);
@@ -90,23 +171,7 @@ function wrapModuleErrors(raw: SonareModule): SonareModule {
       // Wrap as a Proxy (not a plain function) so embind class constructors
       // invoked via `new module.Foo(...)` keep their `[[Construct]]` behaviour
       // and prototype while still converting thrown native pointers.
-      const fn = value as (...a: unknown[]) => unknown;
-      const wrapped = new Proxy(fn, {
-        apply(t, thisArg, args) {
-          try {
-            return Reflect.apply(t, thisArg, args as unknown[]);
-          } catch (error) {
-            return convert(error);
-          }
-        },
-        construct(t, args, newTarget) {
-          try {
-            return Reflect.construct(t, args as unknown[], newTarget) as object;
-          } catch (error) {
-            return convert(error) as object;
-          }
-        },
-      });
+      const wrapped = wrapFunction(value as (...a: unknown[]) => unknown);
       cache.set(prop, wrapped);
       return wrapped;
     },

package/src/opfs_clip_pages.ts

@@ -29,10 +29,25 @@ interface PageResponse {
 }
 
 export const opfsClipPageWorkerSource = `
+const sonareClipPageReadQueues = new Map();
+
+function sonareEnqueueClipPageRead(key, task) {
+  const previous = sonareClipPageReadQueues.get(key) || Promise.resolve();
+  const next = previous.catch(() => undefined).then(task);
+  const queued = next.finally(() => {
+    if (sonareClipPageReadQueues.get(key) === queued) {
+      sonareClipPageReadQueues.delete(key);
+    }
+  });
+  sonareClipPageReadQueues.set(key, queued);
+  return next;
+}
+
 self.onmessage = async (event) => {
   const message = event.data;
   if (!message || message.type !== 'sonare:read-clip-page') return;
   const { requestId, path, pageIndex, numChannels, numSamples, pageFrames, dataOffsetBytes = 0 } = message;
+  await sonareEnqueueClipPageRead(String(path), async () => {
   try {
     if (pageIndex < 0) {
       self.postMessage({ type: 'sonare:clip-page', requestId, pageIndex, ok: false });
@@ -95,6 +110,7 @@ self.onmessage = async (event) => {
       error: error instanceof Error ? error.message : String(error),
     });
   }
+  });
 };
 `;
 
@@ -119,6 +135,7 @@ export function createOpfsClipPageProvider(
   const ownsWorker = options.worker === undefined || options.terminateWorkerOnClose === true;
   let nextRequestId = 1;
   let closed = false;
+  let readQueue: Promise<void> = Promise.resolve();
   const pending = new Map<
     number,
     { resolve: (value: boolean) => void; reject: (reason: unknown) => void }
@@ -165,15 +182,32 @@ export function createOpfsClipPageProvider(
     const promise = new Promise<boolean>((resolve, reject) => {
       pending.set(requestId, { resolve, reject });
     });
-    worker.postMessage({
-      type: 'sonare:read-clip-page',
-      requestId,
-      path: options.path,
-      pageIndex,
-      numChannels: options.numChannels,
-      numSamples: options.numSamples,
-      pageFrames: options.pageFrames,
-      dataOffsetBytes: options.dataOffsetBytes ?? 0,
+    readQueue = readQueue
+      .catch(() => undefined)
+      .then(() => {
+        if (closed) {
+          const entry = pending.get(requestId);
+          pending.delete(requestId);
+          entry?.reject(new Error('OpfsClipPageProvider is closed'));
+          return;
+        }
+        worker.postMessage({
+          type: 'sonare:read-clip-page',
+          requestId,
+          path: options.path,
+          pageIndex,
+          numChannels: options.numChannels,
+          numSamples: options.numSamples,
+          pageFrames: options.pageFrames,
+          dataOffsetBytes: options.dataOffsetBytes ?? 0,
+        });
+        return promise.then(
+          () => undefined,
+          () => undefined,
+        );
+      });
+    readQueue.catch(() => {
+      // The per-request promise carries the user-visible failure.
     });
     return promise;
   };