@sorisdk/matcher 0.6.8 → 0.6.10

package/README.md

@@ -55,6 +55,38 @@ const session = new MatcherSession({
 });
 ```
 
+## Continuous recognition and reset
+
+Every query returns its matching result, including repeated material matches.
+`match`, `bestMatch`, and their variant methods share one event observer:
+continuous A → A emits one `match`, while A → B → A emits three. Material
+identity includes the fingerprint type. There is no material cooldown.
+
+Every successful observation resets the consecutive-miss counter and renews
+the run, even when its public event is suppressed. Two consecutive no-match
+results end the run and emit one `nomatch`; a single transient miss does not.
+A gap **greater than 30 seconds since the last successful observation** also
+ends continuity, including periods with no queries. This boundary is evaluated
+on the next query: a success emits a new `match` immediately, or a no-match
+emits `nomatch` without waiting for a second miss. The exported
+`MATCH_CONTINUITY_GAP_MS` is shared with Web activity reporting.
+
+Call `session.resetRecognitionState()` at an explicit input/capture boundary.
+It synchronously clears event suppression and invalidates pending queries from
+the previous run, retaining the loaded database. Invalidated queries return
+`null` (best-match methods) or `[]` (multi-match methods) without match/no-match
+events. Successful pack replacement and entry mutations also reset recognition
+state; a failed pack load retains the previous state and entries.
+
+The low-level generated WASM matcher always returns successful observations;
+event deduplication belongs to `MatcherSession`. Its existing
+`resetDistinctMatchState()` export remains available for compatibility.
+
+For source regression tests, build the package first with
+`corepack pnpm --filter @sorisdk/matcher build`, then run
+`corepack pnpm --filter @sorisdk/matcher test`. Tests include production WASM
+instantiated with the TypeScript session, using deterministic fingerprints.
+
 ## Pack loading
 
 `loadPack(...)` accepts:
@@ -89,6 +121,44 @@ 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 default policy (0.6.10)
+
+`session.detectAudioMarker(pcm16Le, actualSampleRate)` and
+`detectAudioMarkerWithLimits` now select the shared level-robust v1 policy.
+An empty config or waveform/search-only config also uses this default. No PCM
+amplification is applied: `score`, `syncScore`, `margin`, and runner-up scores
+remain in raw input-amplitude units. `confidence` uses the v1 calibration.
+
+Results keep the existing flat detection shape and add `levelPolicy`,
+`diagnostics`, `candidateEligible`, and `materialFallbackGuardEligible`.
+Eligibility flags come directly from the shared DSP. They do not authorize a
+marker hit: only a non-null accepted `code` is eligible for activity enrichment.
+The Web path does not apply extra legacy raw-score gates or implement native
+SDK temporal voting/material-fallback heuristics. Early JS input rejections
+include false eligibility flags and may omit DSP diagnostics.
+
+For compatibility, explicitly setting any of `minSyncScore`, `minScore`,
+`minMargin`, `minRatio`, `minConfidence`, or `minVotes` retains legacy behavior.
+Choose `levelPolicy` explicitly to override this compatibility rule:
+
+```ts
+await session.detectAudioMarker(pcm, rate, { levelPolicy: "legacy" });
+await session.detectAudioMarker(pcm, rate, {
+  levelPolicy: "levelRobust", minVotes: 2
+});
+```
+
+With explicit robust policy, shared v1 amplitude gates replace `minSyncScore`,
+`minScore`, and `minMargin`; waveform/search/codebook/vote parameters and stricter
+ratio/confidence requirements retain the shared Rust semantics. The generated
+low-level `detectAudioMarker` / `detectPatternMark` exports and their bounded
+variants remain legacy APIs; `detectAudioMarkerLevelRobust` returns the shared
+nested envelope. Rust, C, Python, and native Node legacy APIs are unchanged.
+
+Upgrade the JS package and its generated WASM together. A custom loader lacking
+the robust export fails with an upgrade error on the default path; it never
+silently downgrades. An explicit legacy config remains supported with old WASM.
+
 ## Audio-marker detection limits
 
 `MatcherSession.detectAudioMarker(...)` preserves its existing signature and
@@ -117,7 +187,9 @@ const detection = await session.detectAudioMarkerWithLimits(
 ```
 
 The generated WASM module exposes the corresponding
-`detectAudioMarkerWithLimits` function and method. It inspects the JavaScript
+`detectAudioMarkerWithLimits` legacy function and method, and the robust
+`detectAudioMarkerLevelRobust(pcm, rate, config, limits)` function. The session
+selects the correct export from the policy above. Each 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.

package/dist/generated/core.d.ts

@@ -35,11 +35,21 @@ export class WasmMatcherEngine {
     matchQuery(database: WasmMatcherDatabase, query: Uint8Array, config?: any | null): any;
     matchQueryWithVariants(database: WasmMatcherDatabase, query: Uint8Array, pitch_query: any, config?: any | null, variant_config?: any | null): any;
     constructor();
+    /**
+     * Compatibility no-op: continuous-run deduplication belongs to MatcherSession.
+     * The binding returns every successful observation and retains no run state.
+     */
     resetDistinctMatchState(): void;
 }
 
 export function detectAudioMarker(pcm16_le: Uint8Array, sample_rate: number, config?: any | null): any;
 
+/**
+ * Explicit v1 policy; existing marker exports remain on the legacy policy.
+ * Result includes raw detection, normalized diagnostics and shared eligibility.
+ */
+export function detectAudioMarkerLevelRobust(pcm16_le: Uint8Array, sample_rate: number, config?: any | null, limits?: 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;

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, detectAudioMarkerWithLimits, detectPatternMark, detectPatternMarkWithLimits, estimatePitchRatio, estimatePitchRatioAgainstReference, estimatePitchRatioAgainstSpectralFeatures, extractPitchReference, extractSpectralShiftReference, init_matcher_wasm
+    WasmMatcherDatabase, WasmMatcherEngine, detectAudioMarker, detectAudioMarkerLevelRobust, detectAudioMarkerWithLimits, detectPatternMark, detectPatternMarkWithLimits, estimatePitchRatio, estimatePitchRatioAgainstReference, estimatePitchRatioAgainstSpectralFeatures, extractPitchReference, extractSpectralShiftReference, init_matcher_wasm
 } from "./core_bg.js";

package/dist/generated/core_bg.js

@@ -359,6 +359,10 @@ export class WasmMatcherEngine {
         WasmMatcherEngineFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Compatibility no-op: continuous-run deduplication belongs to MatcherSession.
+     * The binding returns every successful observation and retains no run state.
+     */
     resetDistinctMatchState() {
         wasm.wasmmatcherengine_resetDistinctMatchState(this.__wbg_ptr);
     }
@@ -379,6 +383,23 @@ export function detectAudioMarker(pcm16_le, sample_rate, config) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Explicit v1 policy; existing marker exports remain on the legacy policy.
+ * Result includes raw detection, normalized diagnostics and shared eligibility.
+ * @param {Uint8Array} pcm16_le
+ * @param {number} sample_rate
+ * @param {any | null} [config]
+ * @param {any | null} [limits]
+ * @returns {any}
+ */
+export function detectAudioMarkerLevelRobust(pcm16_le, sample_rate, config, limits) {
+    const ret = wasm.detectAudioMarkerLevelRobust(pcm16_le, sample_rate, isLikeNone(config) ? 0 : addToExternrefTable0(config), isLikeNone(limits) ? 0 : addToExternrefTable0(limits));
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @param {Uint8Array} pcm16_le
  * @param {number} sample_rate
@@ -599,6 +620,10 @@ export function __wbg_call_14b169f759b26747() { return handleError(function (arg
     const ret = arg0.call(arg1);
     return ret;
 }, arguments); }
+export function __wbg_call_a24592a6f349a97e() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+}, arguments); }
 export function __wbg_done_9158f7cc8751ba32(arg0) {
     const ret = arg0.done;
     return ret;
@@ -618,10 +643,22 @@ export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
 }
+export function __wbg_getOwnPropertyDescriptor_131bd582a45a6f5d(arg0, arg1) {
+    const ret = Object.getOwnPropertyDescriptor(arg0, arg1);
+    return ret;
+}
+export function __wbg_getPrototypeOf_a56da9261bbd1e5b(arg0) {
+    const ret = Object.getPrototypeOf(arg0);
+    return ret;
+}
 export function __wbg_get_1affdbdd5573b16a() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(arg0, arg1);
     return ret;
 }, arguments); }
+export function __wbg_get_6011fa3a58f61074() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments); }
 export function __wbg_get_8360291721e2339f(arg0, arg1) {
     const ret = arg0[arg1 >>> 0];
     return ret;
@@ -716,10 +753,6 @@ export function __wbg_next_7646edaa39458ef7(arg0) {
     const ret = arg0.next;
     return ret;
 }
-export function __wbg_now_a9b7df1cbee90986() {
-    const ret = Date.now();
-    return ret;
-}
 export function __wbg_prototypesetcall_a6b02eb00b0f4ce2(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
 }
@@ -740,6 +773,26 @@ export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
+export function __wbg_static_accessor_GLOBAL_8cfadc87a297ca02() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_GLOBAL_THIS_602256ae5c8f42cf() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_SELF_e445c1c7484aecc3() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_WINDOW_f20e8576ef1e0f17() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_toStringTag_d6b1716c86d4892d() {
+    const ret = Symbol.toStringTag;
+    return ret;
+}
 export function __wbg_value_ee3a06f4579184fa(arg0) {
     const ret = arg0.value;
     return ret;
@@ -755,11 +808,16 @@ export function __wbindgen_cast_0000000000000002(arg0) {
     return ret;
 }
 export function __wbindgen_cast_0000000000000003(arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000004(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
 }
-export function __wbindgen_cast_0000000000000004(arg0) {
+export function __wbindgen_cast_0000000000000005(arg0) {
     // Cast intrinsic for `U64 -> Externref`.
     const ret = BigInt.asUintN(64, arg0);
     return ret;

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

@@ -4,6 +4,7 @@ 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: any, b: number, c: number) => [number, number, number];
+export const detectAudioMarkerLevelRobust: (a: any, b: number, c: number, d: 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];
@@ -27,7 +28,6 @@ export const wasmmatcherengine_bestMatch: (a: number, b: number, c: number, d: n
 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: 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];
@@ -36,10 +36,11 @@ export const wasmmatcherengine_extractPitchReference: (a: number, b: number, c:
 export const wasmmatcherengine_extractSpectralShiftReference: (a: number, b: number, c: number, d: number) => [number, number, number];
 export const wasmmatcherengine_matchQuery: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
 export const wasmmatcherengine_matchQueryWithVariants: (a: number, b: number, c: number, d: number, e: any, f: number, g: number) => [number, number, number];
-export const wasmmatcherengine_new: () => number;
 export const wasmmatcherengine_resetDistinctMatchState: (a: number) => void;
+export const wasmmatcherengine_new: () => number;
 export const init_matcher_wasm: () => void;
 export const detectPatternMark: (a: any, b: number, c: number) => [number, number, number];
+export const wasmmatcherengine_detectPatternMark: (a: number, b: any, c: number, d: 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

@@ -20,7 +20,10 @@ 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";
+type AudioMarkerLevelPolicy = "levelRobust" | "legacy";
 interface AudioMarkerConfig {
+    /** Defaults to levelRobust; explicit thresholds retain legacy semantics unless overridden. */
+    levelPolicy?: AudioMarkerLevelPolicy;
     bandLowHz?: number;
     bandHighHz?: number;
     syncDurationMillis?: number;
@@ -43,7 +46,31 @@ interface AudioMarkerLimits {
     maxDurationMillis?: number;
     maxWorkUnits?: number;
 }
+/** Shared v1 diagnostics; levels are band estimates, not calibrated SPL or SNR. */
+interface AudioMarkerLevelDiagnostics {
+    policyVersion: number;
+    markerBandDbfs: number;
+    lowerNeighborDbfs: number;
+    upperNeighborDbfs: number;
+    normalizationRms: number;
+    effectiveGain: number;
+    normalizedSyncScore: number;
+    normalizedScore: number;
+    normalizedMargin: number;
+    policyConfidence: number;
+    codeHalfBalance: number | null;
+    effectiveMinSyncScore: number;
+    effectiveMinScore: number;
+    effectiveMinMargin: number;
+    qualityReason: string | null;
+}
 interface AudioMarkerDetection {
+    /** Present on level-robust session results; raw score units below are unchanged. */
+    levelPolicy?: AudioMarkerLevelPolicy;
+    diagnostics?: AudioMarkerLevelDiagnostics;
+    /** Shared eligibility only; a candidate is not an accepted marker identity. */
+    candidateEligible?: boolean;
+    materialFallbackGuardEligible?: boolean;
     pattern?: string | null;
     code?: string | null;
     confidence?: number | null;
@@ -230,6 +257,7 @@ declare class MatcherSession {
     private matcher;
     private destroyed;
     private packLoadTail;
+    private recognitionGeneration;
     private readonly distinctMatchDeduper;
     constructor(options?: MatcherSessionOptions);
     on<T extends MatcherSessionEventName>(eventName: T, listener: MatcherSessionListener<T>): this;
@@ -250,11 +278,16 @@ declare class MatcherSession {
     extractPitchReference(pcm16Le: Uint8Array, sampleRate: number): Promise<PitchReferenceEstimate>;
     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>;
+    /** Uses level-robust detection by default, preserving explicit legacy thresholds. */
     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>;
+    /** End the current recognition run without removing loaded entries.
+     * Pending queries from the previous run cannot update event suppression state.
+     */
+    resetRecognitionState(): void;
     destroy(): void;
     private bootstrap;
     private ensureLiveReady;
@@ -268,4 +301,7 @@ declare function __setMatcherWasmModuleForTests(moduleLike: unknown): void;
 declare function __setMatcherEmbeddedPackForTests(bytes: Uint8Array): void;
 declare function __resetMatcherWasmForTests(): void;
 
-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 };
+/** Maximum gap between successful observations in one continuous material run. */
+declare const MATCH_CONTINUITY_GAP_MS = 30000;
+
+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 AudioMarkerLevelDiagnostics, type AudioMarkerLevelPolicy, 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, MATCH_CONTINUITY_GAP_MS, 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

@@ -327,28 +327,31 @@ var AUDIO_MARKER_WORK_OVERFLOW_REASON = "detector_work_overflow";
 
 // src/match-deduper.ts
 var DEFAULT_NO_MATCH_CONFIRMATION_COUNT = 2;
+var MATCH_CONTINUITY_GAP_MS = 3e4;
 function getMatchIdentity(match) {
   return `${match.name}:${match.afpType}`;
 }
 var DistinctMatchDeduper = class {
   lastIdentity = null;
   pendingNoMatchCount = 0;
-  observe(best) {
+  lastObservedAt = null;
+  observe(best, now = Date.now()) {
+    const expired = this.lastObservedAt !== null && now - this.lastObservedAt > MATCH_CONTINUITY_GAP_MS;
     if (!best) {
       if (this.lastIdentity === null) {
         return { kind: "repeat", best: null };
       }
       this.pendingNoMatchCount += 1;
-      if (this.pendingNoMatchCount < DEFAULT_NO_MATCH_CONFIRMATION_COUNT) {
+      if (!expired && this.pendingNoMatchCount < DEFAULT_NO_MATCH_CONFIRMATION_COUNT) {
         return { kind: "repeat", best: null };
       }
-      this.lastIdentity = null;
-      this.pendingNoMatchCount = 0;
+      this.reset();
       return { kind: "nomatch" };
     }
     const nextIdentity = getMatchIdentity(best);
     this.pendingNoMatchCount = 0;
-    if (this.lastIdentity === nextIdentity) {
+    this.lastObservedAt = now;
+    if (!expired && this.lastIdentity === nextIdentity) {
       return { kind: "repeat", best };
     }
     this.lastIdentity = nextIdentity;
@@ -357,6 +360,7 @@ var DistinctMatchDeduper = class {
   reset() {
     this.lastIdentity = null;
     this.pendingNoMatchCount = 0;
+    this.lastObservedAt = null;
   }
 };
 
@@ -711,6 +715,19 @@ function normalizeAudioMarkerDetection(raw) {
     runnerUpAccuracy: normalizeOptionalNumber(record.runnerUpAccuracy, record.runner_up_accuracy)
   };
 }
+function normalizeLevelRobustDetection(raw) {
+  const envelope = raw;
+  if (!envelope || typeof envelope.detection !== "object" || !envelope.detection || typeof envelope.diagnostics !== "object" || !envelope.diagnostics || typeof envelope.candidateEligible !== "boolean" || typeof envelope.materialFallbackGuardEligible !== "boolean") {
+    throw new Error("Invalid level-robust marker result envelope");
+  }
+  return {
+    ...normalizeAudioMarkerDetection(envelope.detection),
+    levelPolicy: "levelRobust",
+    diagnostics: { ...envelope.diagnostics },
+    candidateEligible: envelope.candidateEligible,
+    materialFallbackGuardEligible: envelope.materialFallbackGuardEligible
+  };
+}
 function isMapLike(raw) {
   return raw instanceof Map || Object.prototype.toString.call(raw) === "[object Map]" && typeof raw.entries === "function";
 }
@@ -753,11 +770,6 @@ function normalizeResults(rawResults) {
 function normalizeVariantMatches(rawResults) {
   return rawResults.filter((item) => typeof item === "object" && item !== null).map((item) => normalizeVariantMatch(item));
 }
-function isInternallyDuplicatedBestMatch(result) {
-  return Boolean(
-    result && typeof result === "object" && result[INTERNAL_DUPLICATE_MATCH_FLAG] === true
-  );
-}
 function resolveFactory(moduleLike, names) {
   const fn = getCallable(moduleLike, names);
   return fn ? fn.bind(moduleLike) : null;
@@ -783,6 +795,10 @@ function createBindingsFromModule(moduleLike) {
     "estimatePitchRatioAgainstReferenceFeatures",
     "estimate_pitch_ratio_against_reference_features"
   ]);
+  const detectAudioMarkerLevelRobustFn = resolveFactory(mod, [
+    "detectAudioMarkerLevelRobust",
+    "detect_audio_marker_level_robust"
+  ]);
   const detectAudioMarkerFn = resolveFactory(mod, [
     "detectAudioMarker",
     "detect_audio_marker",
@@ -927,6 +943,26 @@ function createBindingsFromModule(moduleLike) {
         destroy?.call(matcher);
       }
     },
+    detectAudioMarkerLevelRobust(pcm16Le, sampleRate, config, limits) {
+      if (detectAudioMarkerLevelRobustFn) {
+        return normalizeLevelRobustDetection(
+          detectAudioMarkerLevelRobustFn(pcm16Le, sampleRate, config, limits)
+        );
+      }
+      const matcher = createMatcherFactory ? createMatcherFactory() : new MatcherCtor();
+      try {
+        const fn = getCallable(matcher, [
+          "detectAudioMarkerLevelRobust",
+          "detect_audio_marker_level_robust"
+        ]);
+        if (!fn) {
+          throw new Error("WASM matcher is missing detectAudioMarkerLevelRobust; upgrade the WASM assets or explicitly select levelPolicy: legacy");
+        }
+        return normalizeLevelRobustDetection(fn.call(matcher, pcm16Le, sampleRate, config, limits));
+      } finally {
+        getCallable(matcher, ["destroy", "free"])?.call(matcher);
+      }
+    },
     detectAudioMarkerWithLimits(pcm16Le, sampleRate, config, limits) {
       if (detectAudioMarkerWithLimitsFn) {
         return normalizeAudioMarkerDetection(
@@ -971,6 +1007,42 @@ async function getBindings(options) {
 function toUint8ArrayCopy(input) {
   return new Uint8Array(input);
 }
+var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+var typedArrayByteLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
+var typedArrayTag = Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag).get;
+var typedArraySet = Uint8Array.prototype.set;
+function markerByteLength(input) {
+  if (typedArrayTag.call(input) !== "Uint8Array") {
+    throw new TypeError("Audio marker PCM must be a Uint8Array");
+  }
+  return typedArrayByteLength.call(input);
+}
+function copyMarkerPcm(input) {
+  const copy = new Uint8Array(markerByteLength(input));
+  typedArraySet.call(copy, input);
+  return copy;
+}
+function usesLevelRobust(config) {
+  if (config?.levelPolicy !== void 0) {
+    if (config.levelPolicy !== "levelRobust" && config.levelPolicy !== "legacy") {
+      throw new RangeError("Invalid audio marker levelPolicy");
+    }
+    return config.levelPolicy === "levelRobust";
+  }
+  return ![
+    config?.minSyncScore,
+    config?.minScore,
+    config?.minMargin,
+    config?.minRatio,
+    config?.minConfidence,
+    config?.minVotes
+  ].some((value) => value !== void 0);
+}
+function detectorConfig(config) {
+  if (!config || config.levelPolicy === void 0) return config;
+  const { levelPolicy: _policy, ...rest } = config;
+  return rest;
+}
 function resolveAudioMarkerLimits(limits) {
   const resolved = {
     maxPcmBytes: limits?.maxPcmBytes ?? DEFAULT_MAX_AUDIO_MARKER_PCM_BYTES,
@@ -986,13 +1058,17 @@ function resolveAudioMarkerLimits(limits) {
   return resolved;
 }
 function audioMarkerInputFailureReason(pcm16Le, sampleRate, limits) {
-  if (pcm16Le.byteLength > limits.maxPcmBytes) {
+  const byteLength = markerByteLength(pcm16Le);
+  if (byteLength > limits.maxPcmBytes) {
     return AUDIO_MARKER_INPUT_BUDGET_EXCEEDED_REASON;
   }
-  if (pcm16Le.byteLength % 2 !== 0) {
+  if (byteLength % 2 !== 0) {
     return "invalid_pcm16_byte_length";
   }
-  const sampleCount = pcm16Le.byteLength / 2;
+  if (!Number.isInteger(sampleRate) || sampleRate <= 0 || sampleRate > 4294967295) {
+    return "invalid_sample_rate";
+  }
+  const sampleCount = byteLength / 2;
   if (sampleCount > limits.maxSamples) {
     return AUDIO_MARKER_INPUT_BUDGET_EXCEEDED_REASON;
   }
@@ -1050,6 +1126,7 @@ var MatcherSession = class {
   matcher = null;
   destroyed = false;
   packLoadTail = Promise.resolve();
+  recognitionGeneration = 0;
   distinctMatchDeduper = new DistinctMatchDeduper();
   constructor(options) {
     this.fetcher = options?.fetch;
@@ -1102,8 +1179,7 @@ var MatcherSession = class {
       }
       this.database = stagedDatabase;
       previousDatabase.destroy();
-      this.distinctMatchDeduper.reset();
-      this.matcher?.resetDistinctMatchState?.();
+      this.resetRecognitionState();
       this.events.emit("packload", {
         sourceType: normalized.sourceType,
         byteLength: normalized.bytes.byteLength
@@ -1116,8 +1192,7 @@ var MatcherSession = class {
     try {
       await this.ensureLiveReady();
       this.databaseOrThrow().addEntry(name, afpType, toUint8ArrayCopy(fingerprint));
-      this.distinctMatchDeduper.reset();
-      this.matcher?.resetDistinctMatchState?.();
+      this.resetRecognitionState();
     } catch (error) {
       handleError(this.events, "addEntry", error);
     }
@@ -1131,8 +1206,7 @@ var MatcherSession = class {
         toUint8ArrayCopy(fingerprint),
         metadata
       );
-      this.distinctMatchDeduper.reset();
-      this.matcher?.resetDistinctMatchState?.();
+      this.resetRecognitionState();
     } catch (error) {
       handleError(this.events, "addOrReplace", error);
     }
@@ -1141,8 +1215,7 @@ var MatcherSession = class {
     try {
       await this.ensureLiveReady();
       this.databaseOrThrow().setEntryVariantMetadata(name, encodedMetadata);
-      this.distinctMatchDeduper.reset();
-      this.matcher?.resetDistinctMatchState?.();
+      this.resetRecognitionState();
     } catch (error) {
       handleError(this.events, "setEntryVariantMetadata", error);
     }
@@ -1151,8 +1224,7 @@ var MatcherSession = class {
     try {
       await this.ensureLiveReady();
       this.databaseOrThrow().removeEntry(name);
-      this.distinctMatchDeduper.reset();
-      this.matcher?.resetDistinctMatchState?.();
+      this.resetRecognitionState();
     } catch (error) {
       handleError(this.events, "removeEntry", error);
     }
@@ -1161,8 +1233,7 @@ var MatcherSession = class {
     try {
       await this.ensureLiveReady();
       this.databaseOrThrow().clear();
-      this.distinctMatchDeduper.reset();
-      this.matcher?.resetDistinctMatchState?.();
+      this.resetRecognitionState();
     } catch (error) {
       handleError(this.events, "clear", error);
     }
@@ -1176,27 +1247,38 @@ var MatcherSession = class {
     }
   }
   async match(query, config) {
+    const generation = this.recognitionGeneration;
     try {
       await this.ensureLiveReady();
+      if (generation !== this.recognitionGeneration) {
+        return [];
+      }
       const safeQuery = toUint8ArrayCopy(query);
       this.events.emit("querystart", { queryByteLength: safeQuery.byteLength });
+      if (generation !== this.recognitionGeneration || this.destroyed) {
+        return [];
+      }
       const results = this.matcherOrThrow().findMatches(this.databaseOrThrow(), safeQuery, config);
-      this.emitDistinctMatchEvent(results[0] ?? null, safeQuery.byteLength, results);
+      this.emitDistinctMatchEvent(generation, results[0] ?? null, safeQuery.byteLength, results);
       return results;
     } catch (error) {
       handleError(this.events, "match", error);
     }
   }
   async bestMatch(query, config) {
+    const generation = this.recognitionGeneration;
     try {
       await this.ensureLiveReady();
+      if (generation !== this.recognitionGeneration) {
+        return null;
+      }
       const safeQuery = toUint8ArrayCopy(query);
       this.events.emit("querystart", { queryByteLength: safeQuery.byteLength });
-      const best = this.matcherOrThrow().bestMatch(this.databaseOrThrow(), safeQuery, config);
-      if (isInternallyDuplicatedBestMatch(best)) {
-        return best;
+      if (generation !== this.recognitionGeneration || this.destroyed) {
+        return null;
       }
-      this.emitDistinctMatchEvent(best, safeQuery.byteLength, best ? [best] : []);
+      const best = this.matcherOrThrow().bestMatch(this.databaseOrThrow(), safeQuery, config);
+      this.emitDistinctMatchEvent(generation, best, safeQuery.byteLength, best ? [best] : []);
       return best;
     } catch (error) {
       handleError(this.events, "bestMatch", error);
@@ -1288,15 +1370,24 @@ var MatcherSession = class {
       handleError(this.events, "estimatePitchRatioAgainstReferenceFeatures", error);
     }
   }
+  /** Uses level-robust detection by default, preserving explicit legacy thresholds. */
   async detectAudioMarker(pcm16Le, sampleRate, config) {
     try {
       await this.ensureLiveReady();
+      const robust = usesLevelRobust(config);
       const limits = resolveAudioMarkerLimits();
       const failureReason = audioMarkerInputFailureReason(pcm16Le, sampleRate, limits);
       if (failureReason) {
-        return absentAudioMarkerDetection(config, failureReason);
+        return {
+          ...absentAudioMarkerDetection(config, failureReason),
+          ...robust ? { levelPolicy: "levelRobust", candidateEligible: false, materialFallbackGuardEligible: false } : {}
+        };
+      }
+      const safePcm = copyMarkerPcm(pcm16Le);
+      config = detectorConfig(config);
+      if (robust) {
+        return this.bindings.detectAudioMarkerLevelRobust(safePcm, sampleRate, config);
       }
-      const safePcm = toUint8ArrayCopy(pcm16Le);
       const matcher = this.matcherOrThrow();
       if (matcher.detectAudioMarker) {
         return matcher.detectAudioMarker(safePcm, sampleRate, config);
@@ -1313,6 +1404,7 @@ var MatcherSession = class {
   async detectAudioMarkerWithLimits(pcm16Le, sampleRate, config, limits) {
     try {
       await this.ensureLiveReady();
+      const robust = usesLevelRobust(config);
       const resolvedLimits = resolveAudioMarkerLimits(limits);
       const failureReason = audioMarkerInputFailureReason(
         pcm16Le,
@@ -1320,9 +1412,16 @@ var MatcherSession = class {
         resolvedLimits
       );
       if (failureReason) {
-        return absentAudioMarkerDetection(config, failureReason);
+        return {
+          ...absentAudioMarkerDetection(config, failureReason),
+          ...robust ? { levelPolicy: "levelRobust", candidateEligible: false, materialFallbackGuardEligible: false } : {}
+        };
+      }
+      const safePcm = copyMarkerPcm(pcm16Le);
+      config = detectorConfig(config);
+      if (robust) {
+        return this.bindings.detectAudioMarkerLevelRobust(safePcm, sampleRate, config, resolvedLimits);
       }
-      const safePcm = toUint8ArrayCopy(pcm16Le);
       const matcher = this.matcherOrThrow();
       if (matcher.detectAudioMarkerWithLimits) {
         return matcher.detectAudioMarkerWithLimits(
@@ -1346,10 +1445,17 @@ var MatcherSession = class {
     }
   }
   async matchWithVariants(query, pitchQuery, config, variantConfig) {
+    const generation = this.recognitionGeneration;
     try {
       await this.ensureLiveReady();
+      if (generation !== this.recognitionGeneration) {
+        return [];
+      }
       const safeQuery = toUint8ArrayCopy(query);
       this.events.emit("querystart", { queryByteLength: safeQuery.byteLength });
+      if (generation !== this.recognitionGeneration || this.destroyed) {
+        return [];
+      }
       const results = this.matcherOrThrow().findMatchesWithVariants(
         this.databaseOrThrow(),
         safeQuery,
@@ -1358,6 +1464,7 @@ var MatcherSession = class {
         variantConfig
       );
       this.emitDistinctMatchEvent(
+        generation,
         results[0]?.matchResult ?? null,
         safeQuery.byteLength,
         results.map((result) => result.matchResult)
@@ -1368,10 +1475,17 @@ var MatcherSession = class {
     }
   }
   async bestMatchWithVariants(query, pitchQuery, config, variantConfig) {
+    const generation = this.recognitionGeneration;
     try {
       await this.ensureLiveReady();
+      if (generation !== this.recognitionGeneration) {
+        return null;
+      }
       const safeQuery = toUint8ArrayCopy(query);
       this.events.emit("querystart", { queryByteLength: safeQuery.byteLength });
+      if (generation !== this.recognitionGeneration || this.destroyed) {
+        return null;
+      }
       const best = this.matcherOrThrow().bestMatchWithVariants(
         this.databaseOrThrow(),
         safeQuery,
@@ -1380,6 +1494,7 @@ var MatcherSession = class {
         variantConfig
       );
       this.emitDistinctMatchEvent(
+        generation,
         best?.matchResult ?? null,
         safeQuery.byteLength,
         best ? [best.matchResult] : []
@@ -1389,10 +1504,19 @@ var MatcherSession = class {
       handleError(this.events, "bestMatchWithVariants", error);
     }
   }
+  /** End the current recognition run without removing loaded entries.
+   * Pending queries from the previous run cannot update event suppression state.
+   */
+  resetRecognitionState() {
+    this.recognitionGeneration += 1;
+    this.distinctMatchDeduper.reset();
+    this.matcher?.resetDistinctMatchState?.();
+  }
   destroy() {
     if (this.destroyed) {
       return;
     }
+    this.resetRecognitionState();
     this.destroyed = true;
     this.matcher?.destroy();
     this.database?.destroy();
@@ -1456,7 +1580,10 @@ var MatcherSession = class {
     }
     return this.database;
   }
-  emitDistinctMatchEvent(best, queryByteLength, results) {
+  emitDistinctMatchEvent(generation, best, queryByteLength, results) {
+    if (generation !== this.recognitionGeneration || this.destroyed) {
+      return;
+    }
     const observation = this.distinctMatchDeduper.observe(best);
     if (observation.kind === "match") {
       this.events.emit("match", { results, best: observation.best });
@@ -1489,6 +1616,7 @@ export {
   DEFAULT_MAX_AUDIO_MARKER_SAMPLES,
   DEFAULT_MAX_AUDIO_MARKER_WORK_UNITS,
   DEFAULT_MAX_PACK_BYTES,
+  MATCH_CONTINUITY_GAP_MS,
   MatcherSession,
   __resetMatcherWasmForTests,
   __setMatcherEmbeddedPackForTests,

package/package.json

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