@omote/core 0.2.1 → 0.2.3

package/dist/index.mjs

@@ -2132,6 +2132,25 @@ async function isWebGPUAvailable() {
     return false;
   }
 }
+var iosWasmPatched = false;
+function applyIOSWasmMemoryPatch() {
+  if (iosWasmPatched || !isIOS()) return;
+  iosWasmPatched = true;
+  const OrigMemory = WebAssembly.Memory;
+  const MAX_IOS_PAGES = 16384;
+  logger.info("Applying iOS WASM memory patch (shared\u2192false, max\u21921GB)");
+  WebAssembly.Memory = function IOSPatchedMemory(descriptor) {
+    const patched = { ...descriptor };
+    if (patched.shared) {
+      patched.shared = false;
+    }
+    if (patched.maximum !== void 0 && patched.maximum > MAX_IOS_PAGES) {
+      patched.maximum = MAX_IOS_PAGES;
+    }
+    return new OrigMemory(patched);
+  };
+  WebAssembly.Memory.prototype = OrigMemory.prototype;
+}
 function configureWasm(ort) {
   ort.env.wasm.wasmPaths = WASM_CDN_PATH;
   const numThreads = getOptimalWasmThreads();
@@ -2157,6 +2176,7 @@ async function getOnnxRuntime(backend) {
     return ortInstance;
   }
   logger.info(`Loading ONNX Runtime with ${backend} backend...`);
+  applyIOSWasmMemoryPatch();
   try {
     if (backend === "wasm") {
       const module = await import("onnxruntime-web");
@@ -3331,6 +3351,8 @@ var SileroVADInference = class {
     // Pre-speech buffer for capturing beginning of speech
     this.preSpeechBuffer = [];
     this.wasSpeaking = false;
+    // Cached sample rate tensor (int64 scalar, never changes per instance)
+    this.srTensor = null;
     const sampleRate = config.sampleRate ?? 16e3;
     if (sampleRate !== 8e3 && sampleRate !== 16e3) {
       throw new Error("Silero VAD only supports 8000 or 16000 Hz sample rates");
@@ -3461,6 +3483,24 @@ var SileroVADInference = class {
     this.context = new Float32Array(this.contextSize);
     this.preSpeechBuffer = [];
     this.wasSpeaking = false;
+    if (!this.srTensor) {
+      try {
+        this.srTensor = new this.ort.Tensor(
+          "int64",
+          new BigInt64Array([BigInt(this.config.sampleRate)]),
+          []
+        );
+      } catch (e) {
+        logger7.warn("BigInt64Array not available, using bigint array fallback", {
+          error: e instanceof Error ? e.message : String(e)
+        });
+        this.srTensor = new this.ort.Tensor(
+          "int64",
+          [BigInt(this.config.sampleRate)],
+          []
+        );
+      }
+    }
   }
   /**
    * Process a single audio chunk
@@ -3592,7 +3632,7 @@ var SileroVADInference = class {
           inputBuffer.set(audioChunkCopy, this.contextSize);
           const inputBufferCopy = new Float32Array(inputBuffer);
           const inputTensor = new this.ort.Tensor("float32", inputBufferCopy, [1, inputSize]);
-          const srTensor = new this.ort.Tensor("int64", BigInt64Array.from([BigInt(this.config.sampleRate)]), []);
+          const srTensor = this.srTensor;
           const stateCopy = new Float32Array(this.state.data);
           const stateTensor = new this.ort.Tensor("float32", stateCopy, this.state.dims);
           const feeds = {
@@ -3681,6 +3721,7 @@ var SileroVADInference = class {
       this.session = null;
     }
     this.state = null;
+    this.srTensor = null;
   }
 };
 /**
@@ -3785,7 +3826,14 @@ async function runInference(audio, state, context) {
   // Create tensors
   const inputTensor = new ort.Tensor('float32', new Float32Array(inputBuffer), [1, inputSize]);
   const stateTensor = new ort.Tensor('float32', new Float32Array(state), [2, 1, 128]);
-  const srTensor = new ort.Tensor('int64', BigInt64Array.from([BigInt(sampleRate)]), []);
+  // Use BigInt64Array constructor (not .from()) for broader compatibility
+  let srTensor;
+  try {
+    srTensor = new ort.Tensor('int64', new BigInt64Array([BigInt(sampleRate)]), []);
+  } catch (e) {
+    // Fallback for environments without BigInt64Array support
+    srTensor = new ort.Tensor('int64', [BigInt(sampleRate)], []);
+  }
 
   const feeds = {
     'input': inputTensor,