@sorisdk/matcher 0.6.5 → 0.6.7

package/README.md

@@ -89,6 +89,39 @@ per-entry limits remain independently enforced.
 
 If you want campaign events and browser recognition flow on top of matching, use `@sorisdk/web-audio`.
 
+## Audio-marker detection limits
+
+`MatcherSession.detectAudioMarker(...)` preserves its existing signature and
+preflights PCM before the browser copy into WASM. The defaults are 336,000
+PCM16 bytes, 168,000 samples, 3,500 ms, and 1,000,000,000 conservative detector
+work units. These are exported as `DEFAULT_MAX_AUDIO_MARKER_*` constants.
+Input-budget failures return a normal absent detection whose `reason` is
+`pcm_input_budget_exceeded`; work failures use
+`detector_work_budget_exceeded`, and checked-estimate overflow uses
+`detector_work_overflow`. Input is rejected, never silently truncated.
+
+Use the additive API only for bounded, trusted offline input:
+
+```ts
+const detection = await session.detectAudioMarkerWithLimits(
+  trustedPcm16Le,
+  48_000,
+  undefined,
+  {
+    maxPcmBytes: 960_000,
+    maxSamples: 480_000,
+    maxDurationMillis: 10_000,
+    maxWorkUnits: 3_000_000_000
+  }
+);
+```
+
+The generated WASM module exposes the corresponding
+`detectAudioMarkerWithLimits` function and method. It inspects the JavaScript
+`Uint8Array` length before allocating a Rust-owned copy. Raising these budgets
+permits greater memory and CPU use; it does not protect an untrusted host after
+the caller opts into the larger envelope.
+
 ## Metadata lookup
 
 Audiopack footer metadata is available through explicit lookup rather than being

package/dist/generated/core.d.ts

@@ -24,7 +24,9 @@ export class WasmMatcherEngine {
     bestMatch(database: WasmMatcherDatabase, query: Uint8Array, config?: any | null): any;
     bestMatchWithVariants(database: WasmMatcherDatabase, query: Uint8Array, pitch_query: any, config?: any | null, variant_config?: any | null): any;
     detectAudioMarker(pcm16_le: Uint8Array, sample_rate: number, config?: any | null): any;
+    detectAudioMarkerWithLimits(pcm16_le: Uint8Array, sample_rate: number, config?: any | null, limits?: any | null): any;
     detectPatternMark(pcm16_le: Uint8Array, sample_rate: number, config?: any | null): any;
+    detectPatternMarkWithLimits(pcm16_le: Uint8Array, sample_rate: number, config?: any | null, limits?: any | null): any;
     estimatePitchRatio(pcm16_le: Uint8Array, sample_rate: number): any;
     estimatePitchRatioAgainstReference(pcm16_le: Uint8Array, sample_rate: number, reference_pitch_hz: number, reference_confidence?: number | null): any;
     estimatePitchRatioAgainstSpectralFeatures(pcm16_le: Uint8Array, sample_rate: number, reference_features: string, reference_position_millis: number, reference_confidence?: number | null): any;
@@ -38,8 +40,12 @@ export class WasmMatcherEngine {
 
 export function detectAudioMarker(pcm16_le: Uint8Array, sample_rate: number, config?: any | null): any;
 
+export function detectAudioMarkerWithLimits(pcm16_le: Uint8Array, sample_rate: number, config?: any | null, limits?: any | null): any;
+
 export function detectPatternMark(pcm16_le: Uint8Array, sample_rate: number, config?: any | null): any;
 
+export function detectPatternMarkWithLimits(pcm16_le: Uint8Array, sample_rate: number, config?: any | null, limits?: any | null): any;
+
 export function estimatePitchRatio(pcm16_le: Uint8Array, sample_rate: number): any;
 
 export function estimatePitchRatioAgainstReference(pcm16_le: Uint8Array, sample_rate: number, reference_pitch_hz: number, reference_confidence?: number | null): any;

package/dist/generated/core.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./core_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    WasmMatcherDatabase, WasmMatcherEngine, detectAudioMarker, detectPatternMark, estimatePitchRatio, estimatePitchRatioAgainstReference, estimatePitchRatioAgainstSpectralFeatures, extractPitchReference, extractSpectralShiftReference, init_matcher_wasm
+    WasmMatcherDatabase, WasmMatcherEngine, detectAudioMarker, detectAudioMarkerWithLimits, detectPatternMark, detectPatternMarkWithLimits, estimatePitchRatio, estimatePitchRatioAgainstReference, estimatePitchRatioAgainstSpectralFeatures, extractPitchReference, extractSpectralShiftReference, init_matcher_wasm
 } from "./core_bg.js";

package/dist/generated/core_bg.js

@@ -195,9 +195,21 @@ export class WasmMatcherEngine {
      * @returns {any}
      */
     detectAudioMarker(pcm16_le, sample_rate, config) {
-        const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmmatcherengine_detectAudioMarker(this.__wbg_ptr, ptr0, len0, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config));
+        const ret = wasm.wasmmatcherengine_detectAudioMarker(this.__wbg_ptr, pcm16_le, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} pcm16_le
+     * @param {number} sample_rate
+     * @param {any | null} [config]
+     * @param {any | null} [limits]
+     * @returns {any}
+     */
+    detectAudioMarkerWithLimits(pcm16_le, sample_rate, config, limits) {
+        const ret = wasm.wasmmatcherengine_detectAudioMarkerWithLimits(this.__wbg_ptr, pcm16_le, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config), isLikeNone(limits) ? 0 : addToExternrefTable0(limits));
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -210,9 +222,21 @@ export class WasmMatcherEngine {
      * @returns {any}
      */
     detectPatternMark(pcm16_le, sample_rate, config) {
-        const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmmatcherengine_detectPatternMark(this.__wbg_ptr, ptr0, len0, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config));
+        const ret = wasm.wasmmatcherengine_detectPatternMark(this.__wbg_ptr, pcm16_le, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} pcm16_le
+     * @param {number} sample_rate
+     * @param {any | null} [config]
+     * @param {any | null} [limits]
+     * @returns {any}
+     */
+    detectPatternMarkWithLimits(pcm16_le, sample_rate, config, limits) {
+        const ret = wasm.wasmmatcherengine_detectPatternMarkWithLimits(this.__wbg_ptr, pcm16_le, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config), isLikeNone(limits) ? 0 : addToExternrefTable0(limits));
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -348,9 +372,22 @@ if (Symbol.dispose) WasmMatcherEngine.prototype[Symbol.dispose] = WasmMatcherEng
  * @returns {any}
  */
 export function detectAudioMarker(pcm16_le, sample_rate, config) {
-    const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.detectAudioMarker(ptr0, len0, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config));
+    const ret = wasm.detectAudioMarker(pcm16_le, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config));
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} pcm16_le
+ * @param {number} sample_rate
+ * @param {any | null} [config]
+ * @param {any | null} [limits]
+ * @returns {any}
+ */
+export function detectAudioMarkerWithLimits(pcm16_le, sample_rate, config, limits) {
+    const ret = wasm.detectAudioMarkerWithLimits(pcm16_le, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config), isLikeNone(limits) ? 0 : addToExternrefTable0(limits));
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -364,9 +401,22 @@ export function detectAudioMarker(pcm16_le, sample_rate, config) {
  * @returns {any}
  */
 export function detectPatternMark(pcm16_le, sample_rate, config) {
-    const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.detectPatternMark(ptr0, len0, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config));
+    const ret = wasm.detectPatternMark(pcm16_le, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config));
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} pcm16_le
+ * @param {number} sample_rate
+ * @param {any | null} [config]
+ * @param {any | null} [limits]
+ * @returns {any}
+ */
+export function detectPatternMarkWithLimits(pcm16_le, sample_rate, config, limits) {
+    const ret = wasm.detectPatternMarkWithLimits(pcm16_le, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config), isLikeNone(limits) ? 0 : addToExternrefTable0(limits));
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }

package/dist/generated/core_bg.wasm.d.ts

@@ -3,8 +3,9 @@
 export const memory: WebAssembly.Memory;
 export const __wbg_wasmmatcherdatabase_free: (a: number, b: number) => void;
 export const __wbg_wasmmatcherengine_free: (a: number, b: number) => void;
-export const detectAudioMarker: (a: number, b: number, c: number, d: number) => [number, number, number];
-export const detectPatternMark: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const detectAudioMarker: (a: any, b: number, c: number) => [number, number, number];
+export const detectAudioMarkerWithLimits: (a: any, b: number, c: number, d: number) => [number, number, number];
+export const detectPatternMarkWithLimits: (a: any, b: number, c: number, d: number) => [number, number, number];
 export const estimatePitchRatio: (a: number, b: number, c: number) => [number, number, number];
 export const estimatePitchRatioAgainstReference: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
 export const estimatePitchRatioAgainstSpectralFeatures: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
@@ -24,8 +25,10 @@ export const wasmmatcherdatabase_removeEntry: (a: number, b: number, c: number)
 export const wasmmatcherdatabase_setEntryVariantMetadata: (a: number, b: number, c: number, d: number, e: number) => [number, number];
 export const wasmmatcherengine_bestMatch: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
 export const wasmmatcherengine_bestMatchWithVariants: (a: number, b: number, c: number, d: number, e: any, f: number, g: number) => [number, number, number];
-export const wasmmatcherengine_detectAudioMarker: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
-export const wasmmatcherengine_detectPatternMark: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+export const wasmmatcherengine_detectAudioMarker: (a: number, b: any, c: number, d: number) => [number, number, number];
+export const wasmmatcherengine_detectAudioMarkerWithLimits: (a: number, b: any, c: number, d: number, e: number) => [number, number, number];
+export const wasmmatcherengine_detectPatternMark: (a: number, b: any, c: number, d: number) => [number, number, number];
+export const wasmmatcherengine_detectPatternMarkWithLimits: (a: number, b: any, c: number, d: number, e: number) => [number, number, number];
 export const wasmmatcherengine_estimatePitchRatio: (a: number, b: number, c: number, d: number) => [number, number, number];
 export const wasmmatcherengine_estimatePitchRatioAgainstReference: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
 export const wasmmatcherengine_estimatePitchRatioAgainstSpectralFeatures: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
@@ -36,6 +39,7 @@ export const wasmmatcherengine_matchQueryWithVariants: (a: number, b: number, c:
 export const wasmmatcherengine_new: () => number;
 export const wasmmatcherengine_resetDistinctMatchState: (a: number) => void;
 export const init_matcher_wasm: () => void;
+export const detectPatternMark: (a: any, b: number, c: number) => [number, number, number];
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;

package/dist/index.d.ts

@@ -13,6 +13,13 @@ interface AudioMarkerCode {
     code: string;
     pattern: string;
 }
+declare const DEFAULT_MAX_AUDIO_MARKER_PCM_BYTES = 336000;
+declare const DEFAULT_MAX_AUDIO_MARKER_SAMPLES = 168000;
+declare const DEFAULT_MAX_AUDIO_MARKER_DURATION_MILLIS = 3500;
+declare const DEFAULT_MAX_AUDIO_MARKER_WORK_UNITS = 1000000000;
+declare const AUDIO_MARKER_INPUT_BUDGET_EXCEEDED_REASON = "pcm_input_budget_exceeded";
+declare const AUDIO_MARKER_WORK_BUDGET_EXCEEDED_REASON = "detector_work_budget_exceeded";
+declare const AUDIO_MARKER_WORK_OVERFLOW_REASON = "detector_work_overflow";
 interface AudioMarkerConfig {
     bandLowHz?: number;
     bandHighHz?: number;
@@ -29,6 +36,13 @@ interface AudioMarkerConfig {
     maxSyncCandidates?: number;
     codebook?: AudioMarkerCode[];
 }
+/** Trusted-input overrides for one-shot audio-marker detection. */
+interface AudioMarkerLimits {
+    maxPcmBytes?: number;
+    maxSamples?: number;
+    maxDurationMillis?: number;
+    maxWorkUnits?: number;
+}
 interface AudioMarkerDetection {
     pattern?: string | null;
     code?: string | null;
@@ -237,6 +251,8 @@ declare class MatcherSession {
     estimatePitchRatioAgainstReference(pcm16Le: Uint8Array, sampleRate: number, referencePitchHz: number, referenceConfidence?: number | null): Promise<PitchRatioEstimate>;
     estimatePitchRatioAgainstReferenceFeatures(pcm16Le: Uint8Array, sampleRate: number, referenceFeatures: string, referencePositionMillis: number, referenceConfidence?: number | null): Promise<PitchRatioEstimate>;
     detectAudioMarker(pcm16Le: Uint8Array, sampleRate: number, config?: AudioMarkerConfig): Promise<AudioMarkerDetection>;
+    /** Detect an audio marker with explicit limits for trusted offline input. */
+    detectAudioMarkerWithLimits(pcm16Le: Uint8Array, sampleRate: number, config: AudioMarkerConfig | undefined, limits: AudioMarkerLimits): Promise<AudioMarkerDetection>;
     matchWithVariants(query: Uint8Array, pitchQuery: VariantMatchQuery, config?: MatchConfig, variantConfig?: VariantMatchConfig): Promise<VariantMatch[]>;
     bestMatchWithVariants(query: Uint8Array, pitchQuery: VariantMatchQuery, config?: MatchConfig, variantConfig?: VariantMatchConfig): Promise<VariantMatch | null>;
     destroy(): void;
@@ -252,4 +268,4 @@ declare function __setMatcherWasmModuleForTests(moduleLike: unknown): void;
 declare function __setMatcherEmbeddedPackForTests(bytes: Uint8Array): void;
 declare function __resetMatcherWasmForTests(): void;
 
-export { AudioFingerprintType, type AudioMarkerCode, type AudioMarkerConfig, type AudioMarkerDetection, DEFAULT_MAX_PACK_BYTES, type EntryMetadata, type InitMatcherOptions, type InitMatcherResult, type MatchConfig, type MatchResult, type MatcherEphemeralAuthOptions, type MatcherEphemeralAuthResult, type MatcherEphemeralKeyExchangeMetadata, type MatcherEphemeralKeyExchangeOptions, MatcherSession, type MatcherSessionEventMap, type MatcherSessionEventName, type MatcherSessionListener, type MatcherSessionOptions, type PackSource, type PitchRatioEstimate, type PitchReferenceEstimate, type VariantDecision, type VariantDecisionStatus, type VariantMatch, type VariantMatchConfig, type VariantMatchQuery, __resetMatcherWasmForTests, __setMatcherEmbeddedPackForTests, __setMatcherWasmModuleForTests, initMatcher };
+export { AUDIO_MARKER_INPUT_BUDGET_EXCEEDED_REASON, AUDIO_MARKER_WORK_BUDGET_EXCEEDED_REASON, AUDIO_MARKER_WORK_OVERFLOW_REASON, AudioFingerprintType, type AudioMarkerCode, type AudioMarkerConfig, type AudioMarkerDetection, type AudioMarkerLimits, DEFAULT_MAX_AUDIO_MARKER_DURATION_MILLIS, DEFAULT_MAX_AUDIO_MARKER_PCM_BYTES, DEFAULT_MAX_AUDIO_MARKER_SAMPLES, DEFAULT_MAX_AUDIO_MARKER_WORK_UNITS, DEFAULT_MAX_PACK_BYTES, type EntryMetadata, type InitMatcherOptions, type InitMatcherResult, type MatchConfig, type MatchResult, type MatcherEphemeralAuthOptions, type MatcherEphemeralAuthResult, type MatcherEphemeralKeyExchangeMetadata, type MatcherEphemeralKeyExchangeOptions, MatcherSession, type MatcherSessionEventMap, type MatcherSessionEventName, type MatcherSessionListener, type MatcherSessionOptions, type PackSource, type PitchRatioEstimate, type PitchReferenceEstimate, type VariantDecision, type VariantDecisionStatus, type VariantMatch, type VariantMatchConfig, type VariantMatchQuery, __resetMatcherWasmForTests, __setMatcherEmbeddedPackForTests, __setMatcherWasmModuleForTests, initMatcher };

package/dist/index.js

@@ -198,6 +198,12 @@ function assertKnownByteLength(byteLength, maxPackBytes) {
     throw packSizeError(maxPackBytes);
   }
 }
+function cancelWithoutWaiting(cancel) {
+  try {
+    void cancel().catch(() => void 0);
+  } catch {
+  }
+}
 function classifyPackSource(source) {
   if (source instanceof Uint8Array) {
     return "uint8array";
@@ -231,7 +237,8 @@ function resolveFetch3(fetcher) {
   }
   return globalThis.fetch.bind(globalThis);
 }
-async function readResponseAsBytes(response, maxPackBytes) {
+async function readResponseAsBytes(response, maxPackBytes = DEFAULT_MAX_PACK_BYTES) {
+  maxPackBytes = validateMaxPackBytes(maxPackBytes);
   if (!response.ok) {
     throw new Error(`Failed to load pack: HTTP ${response.status}`);
   }
@@ -239,7 +246,13 @@ async function readResponseAsBytes(response, maxPackBytes) {
   if (contentLength !== null && /^\d+$/.test(contentLength.trim())) {
     const declaredLength = Number(contentLength);
     if (Number.isSafeInteger(declaredLength)) {
-      assertKnownByteLength(declaredLength, maxPackBytes);
+      if (declaredLength > maxPackBytes) {
+        const body = response.body;
+        if (body) {
+          cancelWithoutWaiting(() => body.cancel());
+        }
+        throw packSizeError(maxPackBytes);
+      }
     }
   }
   if (!response.body) {
@@ -256,7 +269,7 @@ async function readResponseAsBytes(response, maxPackBytes) {
       }
       byteLength += value.byteLength;
       if (byteLength > maxPackBytes) {
-        await reader.cancel();
+        cancelWithoutWaiting(() => reader.cancel());
         throw packSizeError(maxPackBytes);
       }
       chunks.push(value);
@@ -297,6 +310,21 @@ async function normalizePackSource(source, fetcher, maxPackBytes = DEFAULT_MAX_P
   throw new Error("Unsupported pack source type");
 }
 
+// src/types.ts
+var AudioFingerprintType = /* @__PURE__ */ ((AudioFingerprintType3) => {
+  AudioFingerprintType3[AudioFingerprintType3["Livestream"] = 1] = "Livestream";
+  AudioFingerprintType3[AudioFingerprintType3["ArchiveCf"] = 2] = "ArchiveCf";
+  AudioFingerprintType3[AudioFingerprintType3["ArchivePg"] = 4] = "ArchivePg";
+  return AudioFingerprintType3;
+})(AudioFingerprintType || {});
+var DEFAULT_MAX_AUDIO_MARKER_PCM_BYTES = 336e3;
+var DEFAULT_MAX_AUDIO_MARKER_SAMPLES = 168e3;
+var DEFAULT_MAX_AUDIO_MARKER_DURATION_MILLIS = 3500;
+var DEFAULT_MAX_AUDIO_MARKER_WORK_UNITS = 1e9;
+var AUDIO_MARKER_INPUT_BUDGET_EXCEEDED_REASON = "pcm_input_budget_exceeded";
+var AUDIO_MARKER_WORK_BUDGET_EXCEEDED_REASON = "detector_work_budget_exceeded";
+var AUDIO_MARKER_WORK_OVERFLOW_REASON = "detector_work_overflow";
+
 // src/match-deduper.ts
 var DEFAULT_NO_MATCH_CONFIRMATION_COUNT = 2;
 function getMatchIdentity(match) {
@@ -504,6 +532,23 @@ var WrappedMatcher = class {
         detectAudioMarkerFn.call(this.inner, pcm16Le, sampleRate, config)
       );
     }
+    const detectAudioMarkerWithLimitsFn = getCallable(this.inner, [
+      "detectAudioMarkerWithLimits",
+      "detect_audio_marker_with_limits",
+      "detectPatternMarkWithLimits",
+      "detect_pattern_mark_with_limits"
+    ]);
+    if (detectAudioMarkerWithLimitsFn) {
+      this.detectAudioMarkerWithLimits = (pcm16Le, sampleRate, config, limits) => normalizeAudioMarkerDetection(
+        detectAudioMarkerWithLimitsFn.call(
+          this.inner,
+          pcm16Le,
+          sampleRate,
+          config,
+          limits
+        )
+      );
+    }
   }
   inner;
   estimatePitchRatio;
@@ -511,6 +556,7 @@ var WrappedMatcher = class {
   estimatePitchRatioAgainstReference;
   estimatePitchRatioAgainstReferenceFeatures;
   detectAudioMarker;
+  detectAudioMarkerWithLimits;
   findMatches(database, query, config) {
     const fn = getCallable(this.inner, ["findMatches", "find_matches", "matchQuery", "match_query", "match"]);
     if (!fn) {
@@ -743,6 +789,12 @@ function createBindingsFromModule(moduleLike) {
     "detectPatternMark",
     "detect_pattern_mark"
   ]);
+  const detectAudioMarkerWithLimitsFn = resolveFactory(mod, [
+    "detectAudioMarkerWithLimits",
+    "detect_audio_marker_with_limits",
+    "detectPatternMarkWithLimits",
+    "detect_pattern_mark_with_limits"
+  ]);
   const DatabaseCtor = mod.WasmMatcherDatabase ?? mod.MatcherDatabase ?? mod.Database;
   const MatcherCtor = mod.WasmMatcherEngine ?? mod.MatcherEngine ?? mod.Matcher ?? mod.AudioMatcher;
   if (!createDatabaseFactory && !DatabaseCtor) {
@@ -874,6 +926,24 @@ function createBindingsFromModule(moduleLike) {
         const destroy = getCallable(matcher, ["destroy", "free"]);
         destroy?.call(matcher);
       }
+    },
+    detectAudioMarkerWithLimits(pcm16Le, sampleRate, config, limits) {
+      if (detectAudioMarkerWithLimitsFn) {
+        return normalizeAudioMarkerDetection(
+          detectAudioMarkerWithLimitsFn(pcm16Le, sampleRate, config, limits)
+        );
+      }
+      const matcher = createMatcherFactory ? createMatcherFactory() : new MatcherCtor();
+      try {
+        const wrapped = new WrappedMatcher(matcher);
+        if (!wrapped.detectAudioMarkerWithLimits) {
+          throw new Error("WASM matcher is missing detectAudioMarkerWithLimits-compatible method");
+        }
+        return wrapped.detectAudioMarkerWithLimits(pcm16Le, sampleRate, config, limits);
+      } finally {
+        const destroy = getCallable(matcher, ["destroy", "free"]);
+        destroy?.call(matcher);
+      }
     }
   };
 }
@@ -901,6 +971,61 @@ async function getBindings(options) {
 function toUint8ArrayCopy(input) {
   return new Uint8Array(input);
 }
+function resolveAudioMarkerLimits(limits) {
+  const resolved = {
+    maxPcmBytes: limits?.maxPcmBytes ?? DEFAULT_MAX_AUDIO_MARKER_PCM_BYTES,
+    maxSamples: limits?.maxSamples ?? DEFAULT_MAX_AUDIO_MARKER_SAMPLES,
+    maxDurationMillis: limits?.maxDurationMillis ?? DEFAULT_MAX_AUDIO_MARKER_DURATION_MILLIS,
+    maxWorkUnits: limits?.maxWorkUnits ?? DEFAULT_MAX_AUDIO_MARKER_WORK_UNITS
+  };
+  for (const [name, value] of Object.entries(resolved)) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new RangeError(`Invalid audio marker limits: ${name} must be a non-negative safe integer`);
+    }
+  }
+  return resolved;
+}
+function audioMarkerInputFailureReason(pcm16Le, sampleRate, limits) {
+  if (pcm16Le.byteLength > limits.maxPcmBytes) {
+    return AUDIO_MARKER_INPUT_BUDGET_EXCEEDED_REASON;
+  }
+  if (pcm16Le.byteLength % 2 !== 0) {
+    return "invalid_pcm16_byte_length";
+  }
+  const sampleCount = pcm16Le.byteLength / 2;
+  if (sampleCount > limits.maxSamples) {
+    return AUDIO_MARKER_INPUT_BUDGET_EXCEEDED_REASON;
+  }
+  if (Number.isSafeInteger(sampleRate) && sampleRate > 0 && sampleCount * 1e3 > limits.maxDurationMillis * sampleRate) {
+    return AUDIO_MARKER_INPUT_BUDGET_EXCEEDED_REASON;
+  }
+  return null;
+}
+function absentAudioMarkerDetection(config, reason) {
+  return {
+    pattern: null,
+    code: null,
+    confidence: null,
+    score: 0,
+    margin: 0,
+    accuracy: 0,
+    bandLowHz: config?.bandLowHz ?? 15e3,
+    bandHighHz: config?.bandHighHz ?? 15800,
+    syncScore: 0,
+    chipCount: 0,
+    frameStartSample: 0,
+    frameCount: 0,
+    voteCount: 0,
+    reason,
+    candidatePattern: null,
+    candidateCode: null,
+    candidateConfidence: null,
+    runnerUpPattern: null,
+    runnerUpCode: null,
+    runnerUpScore: null,
+    runnerUpAccuracy: null
+  };
+}
 function handleError(emitter, phase, unknownError) {
   const error = unknownError instanceof Error ? unknownError : new Error(String(unknownError));
   emitter.emit("error", { phase, error });
@@ -1166,6 +1291,11 @@ var MatcherSession = class {
   async detectAudioMarker(pcm16Le, sampleRate, config) {
     try {
       await this.ensureLiveReady();
+      const limits = resolveAudioMarkerLimits();
+      const failureReason = audioMarkerInputFailureReason(pcm16Le, sampleRate, limits);
+      if (failureReason) {
+        return absentAudioMarkerDetection(config, failureReason);
+      }
       const safePcm = toUint8ArrayCopy(pcm16Le);
       const matcher = this.matcherOrThrow();
       if (matcher.detectAudioMarker) {
@@ -1179,6 +1309,42 @@ var MatcherSession = class {
       handleError(this.events, "detectAudioMarker", error);
     }
   }
+  /** Detect an audio marker with explicit limits for trusted offline input. */
+  async detectAudioMarkerWithLimits(pcm16Le, sampleRate, config, limits) {
+    try {
+      await this.ensureLiveReady();
+      const resolvedLimits = resolveAudioMarkerLimits(limits);
+      const failureReason = audioMarkerInputFailureReason(
+        pcm16Le,
+        sampleRate,
+        resolvedLimits
+      );
+      if (failureReason) {
+        return absentAudioMarkerDetection(config, failureReason);
+      }
+      const safePcm = toUint8ArrayCopy(pcm16Le);
+      const matcher = this.matcherOrThrow();
+      if (matcher.detectAudioMarkerWithLimits) {
+        return matcher.detectAudioMarkerWithLimits(
+          safePcm,
+          sampleRate,
+          config,
+          resolvedLimits
+        );
+      }
+      if (!this.bindings) {
+        throw new Error("Matcher bindings are not initialized");
+      }
+      return this.bindings.detectAudioMarkerWithLimits(
+        safePcm,
+        sampleRate,
+        config,
+        resolvedLimits
+      );
+    } catch (error) {
+      handleError(this.events, "detectAudioMarkerWithLimits", error);
+    }
+  }
   async matchWithVariants(query, pitchQuery, config, variantConfig) {
     try {
       await this.ensureLiveReady();
@@ -1313,16 +1479,15 @@ function __resetMatcherWasmForTests() {
   __resetEmbeddedPackLoaderForTests();
   initializedBindingsPromise = null;
 }
-
-// src/types.ts
-var AudioFingerprintType = /* @__PURE__ */ ((AudioFingerprintType2) => {
-  AudioFingerprintType2[AudioFingerprintType2["Livestream"] = 1] = "Livestream";
-  AudioFingerprintType2[AudioFingerprintType2["ArchiveCf"] = 2] = "ArchiveCf";
-  AudioFingerprintType2[AudioFingerprintType2["ArchivePg"] = 4] = "ArchivePg";
-  return AudioFingerprintType2;
-})(AudioFingerprintType || {});
 export {
+  AUDIO_MARKER_INPUT_BUDGET_EXCEEDED_REASON,
+  AUDIO_MARKER_WORK_BUDGET_EXCEEDED_REASON,
+  AUDIO_MARKER_WORK_OVERFLOW_REASON,
   AudioFingerprintType,
+  DEFAULT_MAX_AUDIO_MARKER_DURATION_MILLIS,
+  DEFAULT_MAX_AUDIO_MARKER_PCM_BYTES,
+  DEFAULT_MAX_AUDIO_MARKER_SAMPLES,
+  DEFAULT_MAX_AUDIO_MARKER_WORK_UNITS,
   DEFAULT_MAX_PACK_BYTES,
   MatcherSession,
   __resetMatcherWasmForTests,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sorisdk/matcher",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Browser WASM SDK for audio fingerprint matching",
   "type": "module",
   "main": "./dist/index.js",