@sorisdk/matcher 0.1.5 → 0.5.1

package/dist/generated/core.d.ts

@@ -12,6 +12,7 @@ export class WasmMatcherDatabase {
     loadPackBytesAppend(bytes: Uint8Array): void;
     constructor();
     removeEntry(name: string): void;
+    setEntryVariantMetadata(name: string, encoded_metadata: string): void;
     readonly length: number;
 }
 
@@ -19,9 +20,32 @@ export class WasmMatcherEngine {
     free(): void;
     [Symbol.dispose](): void;
     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;
+    detectPatternMark(pcm16_le: Uint8Array, sample_rate: number, config?: 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;
+    extractPitchReference(pcm16_le: Uint8Array, sample_rate: number): any;
+    extractSpectralShiftReference(pcm16_le: Uint8Array, sample_rate: number): any;
     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();
     resetDistinctMatchState(): void;
 }
 
+export function detectAudioMarker(pcm16_le: Uint8Array, sample_rate: number, config?: any | null): any;
+
+export function detectPatternMark(pcm16_le: Uint8Array, sample_rate: number, config?: 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;
+
+export function estimatePitchRatioAgainstSpectralFeatures(pcm16_le: Uint8Array, sample_rate: number, reference_features: string, reference_position_millis: number, reference_confidence?: number | null): any;
+
+export function extractPitchReference(pcm16_le: Uint8Array, sample_rate: number): any;
+
+export function extractSpectralShiftReference(pcm16_le: Uint8Array, sample_rate: number): any;
+
 export function init_matcher_wasm(): void;

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

package/dist/generated/core_bg.js

@@ -102,6 +102,20 @@ export class WasmMatcherDatabase {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * @param {string} name
+     * @param {string} encoded_metadata
+     */
+    setEntryVariantMetadata(name, encoded_metadata) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(encoded_metadata, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmatcherdatabase_setEntryVariantMetadata(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
 }
 if (Symbol.dispose) WasmMatcherDatabase.prototype[Symbol.dispose] = WasmMatcherDatabase.prototype.free;
 
@@ -132,6 +146,131 @@ export class WasmMatcherEngine {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * @param {WasmMatcherDatabase} database
+     * @param {Uint8Array} query
+     * @param {any} pitch_query
+     * @param {any | null} [config]
+     * @param {any | null} [variant_config]
+     * @returns {any}
+     */
+    bestMatchWithVariants(database, query, pitch_query, config, variant_config) {
+        _assertClass(database, WasmMatcherDatabase);
+        const ptr0 = passArray8ToWasm0(query, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmatcherengine_bestMatchWithVariants(this.__wbg_ptr, database.__wbg_ptr, ptr0, len0, pitch_query, isLikeNone(config) ? 0 : addToExternrefTable0(config), isLikeNone(variant_config) ? 0 : addToExternrefTable0(variant_config));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} pcm16_le
+     * @param {number} sample_rate
+     * @param {any | null} [config]
+     * @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));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} pcm16_le
+     * @param {number} sample_rate
+     * @param {any | null} [config]
+     * @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));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} pcm16_le
+     * @param {number} sample_rate
+     * @returns {any}
+     */
+    estimatePitchRatio(pcm16_le, sample_rate) {
+        const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmatcherengine_estimatePitchRatio(this.__wbg_ptr, ptr0, len0, sample_rate);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} pcm16_le
+     * @param {number} sample_rate
+     * @param {number} reference_pitch_hz
+     * @param {number | null} [reference_confidence]
+     * @returns {any}
+     */
+    estimatePitchRatioAgainstReference(pcm16_le, sample_rate, reference_pitch_hz, reference_confidence) {
+        const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmatcherengine_estimatePitchRatioAgainstReference(this.__wbg_ptr, ptr0, len0, sample_rate, reference_pitch_hz, !isLikeNone(reference_confidence), isLikeNone(reference_confidence) ? 0 : reference_confidence);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} pcm16_le
+     * @param {number} sample_rate
+     * @param {string} reference_features
+     * @param {number} reference_position_millis
+     * @param {number | null} [reference_confidence]
+     * @returns {any}
+     */
+    estimatePitchRatioAgainstSpectralFeatures(pcm16_le, sample_rate, reference_features, reference_position_millis, reference_confidence) {
+        const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(reference_features, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmatcherengine_estimatePitchRatioAgainstSpectralFeatures(this.__wbg_ptr, ptr0, len0, sample_rate, ptr1, len1, reference_position_millis, !isLikeNone(reference_confidence), isLikeNone(reference_confidence) ? 0 : reference_confidence);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} pcm16_le
+     * @param {number} sample_rate
+     * @returns {any}
+     */
+    extractPitchReference(pcm16_le, sample_rate) {
+        const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmatcherengine_extractPitchReference(this.__wbg_ptr, ptr0, len0, sample_rate);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} pcm16_le
+     * @param {number} sample_rate
+     * @returns {any}
+     */
+    extractSpectralShiftReference(pcm16_le, sample_rate) {
+        const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmatcherengine_extractSpectralShiftReference(this.__wbg_ptr, ptr0, len0, sample_rate);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @param {WasmMatcherDatabase} database
      * @param {Uint8Array} query
@@ -148,6 +287,24 @@ export class WasmMatcherEngine {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * @param {WasmMatcherDatabase} database
+     * @param {Uint8Array} query
+     * @param {any} pitch_query
+     * @param {any | null} [config]
+     * @param {any | null} [variant_config]
+     * @returns {any}
+     */
+    matchQueryWithVariants(database, query, pitch_query, config, variant_config) {
+        _assertClass(database, WasmMatcherDatabase);
+        const ptr0 = passArray8ToWasm0(query, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmatcherengine_matchQueryWithVariants(this.__wbg_ptr, database.__wbg_ptr, ptr0, len0, pitch_query, isLikeNone(config) ? 0 : addToExternrefTable0(config), isLikeNone(variant_config) ? 0 : addToExternrefTable0(variant_config));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     constructor() {
         const ret = wasm.wasmmatcherengine_new();
         this.__wbg_ptr = ret >>> 0;
@@ -160,6 +317,120 @@ export class WasmMatcherEngine {
 }
 if (Symbol.dispose) WasmMatcherEngine.prototype[Symbol.dispose] = WasmMatcherEngine.prototype.free;
 
+/**
+ * @param {Uint8Array} pcm16_le
+ * @param {number} sample_rate
+ * @param {any | null} [config]
+ * @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));
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} pcm16_le
+ * @param {number} sample_rate
+ * @param {any | null} [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));
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} pcm16_le
+ * @param {number} sample_rate
+ * @returns {any}
+ */
+export function estimatePitchRatio(pcm16_le, sample_rate) {
+    const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.estimatePitchRatio(ptr0, len0, sample_rate);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} pcm16_le
+ * @param {number} sample_rate
+ * @param {number} reference_pitch_hz
+ * @param {number | null} [reference_confidence]
+ * @returns {any}
+ */
+export function estimatePitchRatioAgainstReference(pcm16_le, sample_rate, reference_pitch_hz, reference_confidence) {
+    const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.estimatePitchRatioAgainstReference(ptr0, len0, sample_rate, reference_pitch_hz, !isLikeNone(reference_confidence), isLikeNone(reference_confidence) ? 0 : reference_confidence);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} pcm16_le
+ * @param {number} sample_rate
+ * @param {string} reference_features
+ * @param {number} reference_position_millis
+ * @param {number | null} [reference_confidence]
+ * @returns {any}
+ */
+export function estimatePitchRatioAgainstSpectralFeatures(pcm16_le, sample_rate, reference_features, reference_position_millis, reference_confidence) {
+    const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(reference_features, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.estimatePitchRatioAgainstSpectralFeatures(ptr0, len0, sample_rate, ptr1, len1, reference_position_millis, !isLikeNone(reference_confidence), isLikeNone(reference_confidence) ? 0 : reference_confidence);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} pcm16_le
+ * @param {number} sample_rate
+ * @returns {any}
+ */
+export function extractPitchReference(pcm16_le, sample_rate) {
+    const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.extractPitchReference(ptr0, len0, sample_rate);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} pcm16_le
+ * @param {number} sample_rate
+ * @returns {any}
+ */
+export function extractSpectralShiftReference(pcm16_le, sample_rate) {
+    const ptr0 = passArray8ToWasm0(pcm16_le, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.extractSpectralShiftReference(ptr0, len0, sample_rate);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 export function init_matcher_wasm() {
     wasm.init_matcher_wasm();
 }

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

@@ -3,6 +3,13 @@
 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 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];
+export const extractPitchReference: (a: number, b: number, c: number) => [number, number, number];
+export const extractSpectralShiftReference: (a: number, b: number, c: number) => [number, number, number];
 export const wasmmatcherdatabase_addEntry: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
 export const wasmmatcherdatabase_addOrReplace: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
 export const wasmmatcherdatabase_clear: (a: number) => void;
@@ -12,8 +19,18 @@ export const wasmmatcherdatabase_loadPackBytes: (a: number, b: number, c: number
 export const wasmmatcherdatabase_loadPackBytesAppend: (a: number, b: number, c: number) => [number, number];
 export const wasmmatcherdatabase_new: () => number;
 export const wasmmatcherdatabase_removeEntry: (a: number, b: number, c: number) => [number, 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_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];
+export const wasmmatcherengine_extractPitchReference: (a: number, b: number, c: number, d: number) => [number, number, number];
+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 init_matcher_wasm: () => void;

package/dist/index.d.ts

@@ -7,6 +7,84 @@ interface MatchConfig {
     maxResults?: number;
     scoreThreshold?: number;
     gapThreshold?: number;
+    audiomarker?: boolean;
+}
+interface AudioMarkerCode {
+    code: string;
+    pattern: string;
+}
+interface AudioMarkerConfig {
+    bandLowHz?: number;
+    bandHighHz?: number;
+    syncDurationMillis?: number;
+    codeDurationMillis?: number;
+    frameIntervalMillis?: number;
+    syncSearchStepMillis?: number;
+    minSyncScore?: number;
+    minScore?: number;
+    minMargin?: number;
+    minRatio?: number;
+    minConfidence?: number;
+    minVotes?: number;
+    maxSyncCandidates?: number;
+    codebook?: AudioMarkerCode[];
+}
+interface AudioMarkerDetection {
+    pattern?: string | null;
+    code?: string | null;
+    confidence?: number | null;
+    score: number;
+    margin: number;
+    accuracy: number;
+    bandLowHz: number;
+    bandHighHz: number;
+    syncScore: number;
+    chipCount: number;
+    frameStartSample: number;
+    frameCount: number;
+    voteCount: number;
+    reason?: string | null;
+    candidatePattern?: string | null;
+    candidateCode?: string | null;
+    candidateConfidence?: number | null;
+    runnerUpPattern?: string | null;
+    runnerUpCode?: string | null;
+    runnerUpScore?: number | null;
+    runnerUpAccuracy?: number | null;
+}
+interface VariantMatchQuery {
+    estimatedPitchRatio?: number | null;
+    pitchConfidence?: number | null;
+}
+/** Query-side estimate produced from mono PCM16 little-endian audio. */
+type PitchRatioEstimate = VariantMatchQuery;
+interface PitchReferenceEstimate {
+    pitchHz?: number | null;
+    pitchConfidence?: number | null;
+    features?: string | null;
+}
+interface VariantMatchConfig {
+    minConfidence?: number;
+    defaultToleranceRatio?: number;
+    minRatioMargin?: number;
+    candidateLimit?: number;
+}
+type VariantDecisionStatus = "variant" | "variant_unknown" | "no_variant";
+interface VariantDecision {
+    status: VariantDecisionStatus;
+    reason?: string | null;
+    canonicalMaterialId?: string | null;
+    matchedEntryName?: string | null;
+    variantId?: string | null;
+    variantLabel?: string | null;
+    nominalRatio?: number | null;
+    estimatedPitchRatio?: number | null;
+    pitchConfidence?: number | null;
+    ratioError?: number | null;
+    pitchScore?: number | null;
+    toleranceMinRatio?: number | null;
+    toleranceMaxRatio?: number | null;
+    candidateCount: number;
 }
 interface EntryMetadata {
     id?: string | null;
@@ -22,6 +100,10 @@ interface MatchResult {
     position: number;
     afpType: AudioFingerprintType;
 }
+interface VariantMatch {
+    matchResult: MatchResult;
+    variant: VariantDecision;
+}
 type PackSource = Uint8Array | ArrayBuffer | Blob | Response | Request | string | URL;
 type MatcherSessionEventMap = {
     ready: {
@@ -134,11 +216,19 @@ declare class MatcherSession {
     loadPack(source: PackSource): Promise<void>;
     addEntry(name: string, afpType: AudioFingerprintType, fingerprint: Uint8Array): Promise<void>;
     addOrReplace(name: string, afpType: AudioFingerprintType, fingerprint: Uint8Array, metadata?: EntryMetadata | null): Promise<void>;
+    setEntryVariantMetadata(name: string, encodedMetadata: string): Promise<void>;
     removeEntry(name: string): Promise<void>;
     clear(): Promise<void>;
     getEntryMetadata(name: string): Promise<EntryMetadata | null>;
     match(query: Uint8Array, config?: MatchConfig): Promise<MatchResult[]>;
     bestMatch(query: Uint8Array, config?: MatchConfig): Promise<MatchResult | null>;
+    estimatePitchRatio(pcm16Le: Uint8Array, sampleRate: number): Promise<PitchRatioEstimate>;
+    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>;
+    detectAudioMarker(pcm16Le: Uint8Array, sampleRate: number, config?: AudioMarkerConfig): 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;
     private bootstrap;
     private ensureLiveReady;
@@ -151,4 +241,4 @@ declare function __setMatcherWasmModuleForTests(moduleLike: unknown): void;
 declare function __setMatcherEmbeddedPackForTests(bytes: Uint8Array): void;
 declare function __resetMatcherWasmForTests(): void;
 
-export { AudioFingerprintType, 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, __resetMatcherWasmForTests, __setMatcherEmbeddedPackForTests, __setMatcherWasmModuleForTests, initMatcher };
+export { AudioFingerprintType, type AudioMarkerCode, type AudioMarkerConfig, type AudioMarkerDetection, 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

@@ -358,6 +358,13 @@ var WrappedDatabase = class {
     }
     return normalizeEntryMetadata(raw);
   }
+  setEntryVariantMetadata(name, encodedMetadata) {
+    const fn = getCallable(this.inner, ["setEntryVariantMetadata", "set_entry_variant_metadata"]);
+    if (!fn) {
+      throw new Error("WASM database is missing setEntryVariantMetadata-compatible method");
+    }
+    fn.call(this.inner, name, encodedMetadata);
+  }
   destroy() {
     const fn = getCallable(this.inner, ["destroy", "free"]);
     if (fn) {
@@ -368,7 +375,70 @@ var WrappedDatabase = class {
 var WrappedMatcher = class {
   constructor(inner) {
     this.inner = inner;
+    const estimatePitchRatioFn = getCallable(this.inner, [
+      "estimatePitchRatio",
+      "estimate_pitch_ratio"
+    ]);
+    if (estimatePitchRatioFn) {
+      this.estimatePitchRatio = (pcm16Le, sampleRate) => normalizePitchRatioEstimate(estimatePitchRatioFn.call(this.inner, pcm16Le, sampleRate));
+    }
+    const extractPitchReferenceFn = getCallable(this.inner, [
+      "extractPitchReference",
+      "extract_pitch_reference"
+    ]);
+    if (extractPitchReferenceFn) {
+      this.extractPitchReference = (pcm16Le, sampleRate) => normalizePitchReferenceEstimate(
+        extractPitchReferenceFn.call(this.inner, pcm16Le, sampleRate)
+      );
+    }
+    const estimateAgainstReferenceFn = getCallable(this.inner, [
+      "estimatePitchRatioAgainstReference",
+      "estimate_pitch_ratio_against_reference"
+    ]);
+    if (estimateAgainstReferenceFn) {
+      this.estimatePitchRatioAgainstReference = (pcm16Le, sampleRate, referencePitchHz, referenceConfidence) => normalizePitchRatioEstimate(
+        estimateAgainstReferenceFn.call(
+          this.inner,
+          pcm16Le,
+          sampleRate,
+          referencePitchHz,
+          referenceConfidence
+        )
+      );
+    }
+    const estimateAgainstReferenceFeaturesFn = getCallable(this.inner, [
+      "estimatePitchRatioAgainstReferenceFeatures",
+      "estimate_pitch_ratio_against_reference_features"
+    ]);
+    if (estimateAgainstReferenceFeaturesFn) {
+      this.estimatePitchRatioAgainstReferenceFeatures = (pcm16Le, sampleRate, referenceFeatures, referencePositionMillis, referenceConfidence) => normalizePitchRatioEstimate(
+        estimateAgainstReferenceFeaturesFn.call(
+          this.inner,
+          pcm16Le,
+          sampleRate,
+          referenceFeatures,
+          referencePositionMillis,
+          referenceConfidence
+        )
+      );
+    }
+    const detectAudioMarkerFn = getCallable(this.inner, [
+      "detectAudioMarker",
+      "detect_audio_marker",
+      "detectPatternMark",
+      "detect_pattern_mark"
+    ]);
+    if (detectAudioMarkerFn) {
+      this.detectAudioMarker = (pcm16Le, sampleRate, config) => normalizeAudioMarkerDetection(
+        detectAudioMarkerFn.call(this.inner, pcm16Le, sampleRate, config)
+      );
+    }
   }
+  estimatePitchRatio;
+  extractPitchReference;
+  estimatePitchRatioAgainstReference;
+  estimatePitchRatioAgainstReferenceFeatures;
+  detectAudioMarker;
   findMatches(database, query, config) {
     const fn = getCallable(this.inner, ["findMatches", "find_matches", "matchQuery", "match_query", "match"]);
     if (!fn) {
@@ -403,6 +473,31 @@ var WrappedMatcher = class {
     }
     return normalizeResult(raw);
   }
+  findMatchesWithVariants(database, query, pitchQuery, config, variantConfig) {
+    const fn = getCallable(this.inner, [
+      "findMatchesWithVariants",
+      "matchQueryWithVariants",
+      "match_query_with_variants"
+    ]);
+    if (!fn) {
+      throw new Error("WASM matcher is missing findMatchesWithVariants-compatible method");
+    }
+    const dbRecord = typeof database.raw === "function" ? database.raw() : database;
+    const rawResults = fn.call(this.inner, dbRecord, query, pitchQuery, config, variantConfig);
+    return normalizeVariantMatches(rawResults ?? []);
+  }
+  bestMatchWithVariants(database, query, pitchQuery, config, variantConfig) {
+    const fn = getCallable(this.inner, [
+      "bestMatchWithVariants",
+      "best_match_with_variants"
+    ]);
+    if (!fn) {
+      throw new Error("WASM matcher is missing bestMatchWithVariants-compatible method");
+    }
+    const dbRecord = typeof database.raw === "function" ? database.raw() : database;
+    const raw = fn.call(this.inner, dbRecord, query, pitchQuery, config, variantConfig);
+    return raw && typeof raw === "object" ? normalizeVariantMatch(raw) : null;
+  }
   resetDistinctMatchState() {
     const fn = getCallable(this.inner, ["resetDistinctMatchState", "reset_distinct_match_state"]);
     fn?.call(this.inner);
@@ -423,6 +518,76 @@ function normalizeResult(raw) {
     afpType
   };
 }
+function normalizeVariantMatch(raw) {
+  const rawMatch = raw.matchResult ?? raw.match;
+  const rawVariant = raw.variant ?? {};
+  return {
+    matchResult: normalizeResult(rawMatch),
+    variant: {
+      ...rawVariant,
+      status: String(rawVariant.status),
+      candidateCount: Number(rawVariant.candidateCount ?? 0)
+    }
+  };
+}
+function normalizeOptionalNumber(camelValue, snakeValue) {
+  const value = camelValue ?? snakeValue;
+  return value == null ? null : Number(value);
+}
+function normalizePitchRatioEstimate(raw) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  return {
+    estimatedPitchRatio: normalizeOptionalNumber(
+      record.estimatedPitchRatio,
+      record.estimated_pitch_ratio
+    ),
+    pitchConfidence: normalizeOptionalNumber(record.pitchConfidence, record.pitch_confidence)
+  };
+}
+function normalizeOptionalString(value) {
+  return value == null ? null : String(value);
+}
+function normalizePitchReferenceEstimate(raw) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  return {
+    pitchHz: normalizeOptionalNumber(record.pitchHz, record.pitch_hz),
+    pitchConfidence: normalizeOptionalNumber(record.pitchConfidence, record.pitch_confidence),
+    features: normalizeOptionalString(record.features)
+  };
+}
+function normalizeNumber(camelValue, snakeValue, fallback = 0) {
+  const value = camelValue ?? snakeValue;
+  return value == null ? fallback : Number(value);
+}
+function normalizeAudioMarkerDetection(raw) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  return {
+    pattern: normalizeOptionalString(record.pattern),
+    code: normalizeOptionalString(record.code),
+    confidence: normalizeOptionalNumber(record.confidence, void 0),
+    score: normalizeNumber(record.score, void 0),
+    margin: normalizeNumber(record.margin, void 0),
+    accuracy: normalizeNumber(record.accuracy, void 0),
+    bandLowHz: normalizeNumber(record.bandLowHz, record.band_low_hz),
+    bandHighHz: normalizeNumber(record.bandHighHz, record.band_high_hz),
+    syncScore: normalizeNumber(record.syncScore, record.sync_score),
+    chipCount: normalizeNumber(record.chipCount, record.chip_count),
+    frameStartSample: normalizeNumber(record.frameStartSample, record.frame_start_sample),
+    frameCount: normalizeNumber(record.frameCount, record.frame_count),
+    voteCount: normalizeNumber(record.voteCount, record.vote_count),
+    reason: normalizeOptionalString(record.reason),
+    candidatePattern: normalizeOptionalString(record.candidatePattern ?? record.candidate_pattern),
+    candidateCode: normalizeOptionalString(record.candidateCode ?? record.candidate_code),
+    candidateConfidence: normalizeOptionalNumber(
+      record.candidateConfidence,
+      record.candidate_confidence
+    ),
+    runnerUpPattern: normalizeOptionalString(record.runnerUpPattern ?? record.runner_up_pattern),
+    runnerUpCode: normalizeOptionalString(record.runnerUpCode ?? record.runner_up_code),
+    runnerUpScore: normalizeOptionalNumber(record.runnerUpScore, record.runner_up_score),
+    runnerUpAccuracy: normalizeOptionalNumber(record.runnerUpAccuracy, record.runner_up_accuracy)
+  };
+}
 function isMapLike(raw) {
   return raw instanceof Map || Object.prototype.toString.call(raw) === "[object Map]" && typeof raw.entries === "function";
 }
@@ -462,6 +627,9 @@ function normalizeEntryMetadata(raw) {
 function normalizeResults(rawResults) {
   return rawResults.filter((item) => typeof item === "object" && item !== null).map((item) => normalizeResult(item));
 }
+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
@@ -479,6 +647,25 @@ function createBindingsFromModule(moduleLike) {
   const initFn = getCallable(mod, ["initMatcher"]) ?? (typeof mod.default === "function" ? mod.default.bind(mod) : null);
   const createDatabaseFactory = resolveFactory(mod, ["createDatabase"]);
   const createMatcherFactory = resolveFactory(mod, ["createMatcher"]);
+  const estimatePitchRatioFn = resolveFactory(mod, ["estimatePitchRatio", "estimate_pitch_ratio"]);
+  const extractPitchReferenceFn = resolveFactory(mod, [
+    "extractPitchReference",
+    "extract_pitch_reference"
+  ]);
+  const estimatePitchRatioAgainstReferenceFn = resolveFactory(mod, [
+    "estimatePitchRatioAgainstReference",
+    "estimate_pitch_ratio_against_reference"
+  ]);
+  const estimatePitchRatioAgainstReferenceFeaturesFn = resolveFactory(mod, [
+    "estimatePitchRatioAgainstReferenceFeatures",
+    "estimate_pitch_ratio_against_reference_features"
+  ]);
+  const detectAudioMarkerFn = resolveFactory(mod, [
+    "detectAudioMarker",
+    "detect_audio_marker",
+    "detectPatternMark",
+    "detect_pattern_mark"
+  ]);
   const DatabaseCtor = mod.WasmMatcherDatabase ?? mod.MatcherDatabase ?? mod.Database;
   const MatcherCtor = mod.WasmMatcherEngine ?? mod.MatcherEngine ?? mod.Matcher ?? mod.AudioMatcher;
   if (!createDatabaseFactory && !DatabaseCtor) {
@@ -500,6 +687,116 @@ function createBindingsFromModule(moduleLike) {
     createMatcher() {
       const matcher = createMatcherFactory ? createMatcherFactory() : new MatcherCtor();
       return new WrappedMatcher(matcher);
+    },
+    estimatePitchRatio(pcm16Le, sampleRate) {
+      if (estimatePitchRatioFn) {
+        return normalizePitchRatioEstimate(estimatePitchRatioFn(pcm16Le, sampleRate));
+      }
+      const matcher = createMatcherFactory ? createMatcherFactory() : new MatcherCtor();
+      try {
+        const wrapped = new WrappedMatcher(matcher);
+        if (!wrapped.estimatePitchRatio) {
+          throw new Error("WASM matcher is missing estimatePitchRatio-compatible method");
+        }
+        return wrapped.estimatePitchRatio(pcm16Le, sampleRate);
+      } finally {
+        const destroy = getCallable(matcher, ["destroy", "free"]);
+        destroy?.call(matcher);
+      }
+    },
+    extractPitchReference(pcm16Le, sampleRate) {
+      if (extractPitchReferenceFn) {
+        return normalizePitchReferenceEstimate(extractPitchReferenceFn(pcm16Le, sampleRate));
+      }
+      const matcher = createMatcherFactory ? createMatcherFactory() : new MatcherCtor();
+      try {
+        const wrapped = new WrappedMatcher(matcher);
+        if (!wrapped.extractPitchReference) {
+          throw new Error("WASM matcher is missing extractPitchReference-compatible method");
+        }
+        return wrapped.extractPitchReference(pcm16Le, sampleRate);
+      } finally {
+        const destroy = getCallable(matcher, ["destroy", "free"]);
+        destroy?.call(matcher);
+      }
+    },
+    estimatePitchRatioAgainstReference(pcm16Le, sampleRate, referencePitchHz, referenceConfidence) {
+      if (estimatePitchRatioAgainstReferenceFn) {
+        return normalizePitchRatioEstimate(
+          estimatePitchRatioAgainstReferenceFn(
+            pcm16Le,
+            sampleRate,
+            referencePitchHz,
+            referenceConfidence
+          )
+        );
+      }
+      const matcher = createMatcherFactory ? createMatcherFactory() : new MatcherCtor();
+      try {
+        const wrapped = new WrappedMatcher(matcher);
+        if (!wrapped.estimatePitchRatioAgainstReference) {
+          throw new Error(
+            "WASM matcher is missing estimatePitchRatioAgainstReference-compatible method"
+          );
+        }
+        return wrapped.estimatePitchRatioAgainstReference(
+          pcm16Le,
+          sampleRate,
+          referencePitchHz,
+          referenceConfidence
+        );
+      } finally {
+        const destroy = getCallable(matcher, ["destroy", "free"]);
+        destroy?.call(matcher);
+      }
+    },
+    estimatePitchRatioAgainstReferenceFeatures(pcm16Le, sampleRate, referenceFeatures, referencePositionMillis, referenceConfidence) {
+      if (estimatePitchRatioAgainstReferenceFeaturesFn) {
+        return normalizePitchRatioEstimate(
+          estimatePitchRatioAgainstReferenceFeaturesFn(
+            pcm16Le,
+            sampleRate,
+            referenceFeatures,
+            referencePositionMillis,
+            referenceConfidence
+          )
+        );
+      }
+      const matcher = createMatcherFactory ? createMatcherFactory() : new MatcherCtor();
+      try {
+        const wrapped = new WrappedMatcher(matcher);
+        if (!wrapped.estimatePitchRatioAgainstReferenceFeatures) {
+          throw new Error(
+            "WASM matcher is missing estimatePitchRatioAgainstReferenceFeatures-compatible method"
+          );
+        }
+        return wrapped.estimatePitchRatioAgainstReferenceFeatures(
+          pcm16Le,
+          sampleRate,
+          referenceFeatures,
+          referencePositionMillis,
+          referenceConfidence
+        );
+      } finally {
+        const destroy = getCallable(matcher, ["destroy", "free"]);
+        destroy?.call(matcher);
+      }
+    },
+    detectAudioMarker(pcm16Le, sampleRate, config) {
+      if (detectAudioMarkerFn) {
+        return normalizeAudioMarkerDetection(detectAudioMarkerFn(pcm16Le, sampleRate, config));
+      }
+      const matcher = createMatcherFactory ? createMatcherFactory() : new MatcherCtor();
+      try {
+        const wrapped = new WrappedMatcher(matcher);
+        if (!wrapped.detectAudioMarker) {
+          throw new Error("WASM matcher is missing detectAudioMarker-compatible method");
+        }
+        return wrapped.detectAudioMarker(pcm16Le, sampleRate, config);
+      } finally {
+        const destroy = getCallable(matcher, ["destroy", "free"]);
+        destroy?.call(matcher);
+      }
     }
   };
 }
@@ -619,6 +916,16 @@ var MatcherSession = class {
       handleError(this.events, "addOrReplace", error);
     }
   }
+  async setEntryVariantMetadata(name, encodedMetadata) {
+    try {
+      await this.ensureLiveReady();
+      this.databaseOrThrow().setEntryVariantMetadata(name, encodedMetadata);
+      this.distinctMatchDeduper.reset();
+      this.matcher?.resetDistinctMatchState?.();
+    } catch (error) {
+      handleError(this.events, "setEntryVariantMetadata", error);
+    }
+  }
   async removeEntry(name) {
     try {
       await this.ensureLiveReady();
@@ -674,6 +981,152 @@ var MatcherSession = class {
       handleError(this.events, "bestMatch", error);
     }
   }
+  async estimatePitchRatio(pcm16Le, sampleRate) {
+    try {
+      await this.ensureLiveReady();
+      const safePcm = toUint8ArrayCopy(pcm16Le);
+      const matcher = this.matcherOrThrow();
+      if (matcher.estimatePitchRatio) {
+        return matcher.estimatePitchRatio(safePcm, sampleRate);
+      }
+      if (!this.bindings) {
+        throw new Error("Matcher bindings are not initialized");
+      }
+      return this.bindings.estimatePitchRatio(safePcm, sampleRate);
+    } catch (error) {
+      handleError(this.events, "estimatePitchRatio", error);
+    }
+  }
+  async extractPitchReference(pcm16Le, sampleRate) {
+    try {
+      await this.ensureLiveReady();
+      const safePcm = toUint8ArrayCopy(pcm16Le);
+      const matcher = this.matcherOrThrow();
+      if (matcher.extractPitchReference) {
+        return matcher.extractPitchReference(safePcm, sampleRate);
+      }
+      if (!this.bindings) {
+        throw new Error("Matcher bindings are not initialized");
+      }
+      return this.bindings.extractPitchReference(safePcm, sampleRate);
+    } catch (error) {
+      handleError(this.events, "extractPitchReference", error);
+    }
+  }
+  async estimatePitchRatioAgainstReference(pcm16Le, sampleRate, referencePitchHz, referenceConfidence) {
+    try {
+      await this.ensureLiveReady();
+      const safePcm = toUint8ArrayCopy(pcm16Le);
+      const matcher = this.matcherOrThrow();
+      if (matcher.estimatePitchRatioAgainstReference) {
+        return matcher.estimatePitchRatioAgainstReference(
+          safePcm,
+          sampleRate,
+          referencePitchHz,
+          referenceConfidence
+        );
+      }
+      if (!this.bindings) {
+        throw new Error("Matcher bindings are not initialized");
+      }
+      return this.bindings.estimatePitchRatioAgainstReference(
+        safePcm,
+        sampleRate,
+        referencePitchHz,
+        referenceConfidence
+      );
+    } catch (error) {
+      handleError(this.events, "estimatePitchRatioAgainstReference", error);
+    }
+  }
+  async estimatePitchRatioAgainstReferenceFeatures(pcm16Le, sampleRate, referenceFeatures, referencePositionMillis, referenceConfidence) {
+    try {
+      await this.ensureLiveReady();
+      const safePcm = toUint8ArrayCopy(pcm16Le);
+      const matcher = this.matcherOrThrow();
+      if (matcher.estimatePitchRatioAgainstReferenceFeatures) {
+        return matcher.estimatePitchRatioAgainstReferenceFeatures(
+          safePcm,
+          sampleRate,
+          referenceFeatures,
+          referencePositionMillis,
+          referenceConfidence
+        );
+      }
+      if (!this.bindings) {
+        throw new Error("Matcher bindings are not initialized");
+      }
+      return this.bindings.estimatePitchRatioAgainstReferenceFeatures(
+        safePcm,
+        sampleRate,
+        referenceFeatures,
+        referencePositionMillis,
+        referenceConfidence
+      );
+    } catch (error) {
+      handleError(this.events, "estimatePitchRatioAgainstReferenceFeatures", error);
+    }
+  }
+  async detectAudioMarker(pcm16Le, sampleRate, config) {
+    try {
+      await this.ensureLiveReady();
+      const safePcm = toUint8ArrayCopy(pcm16Le);
+      const matcher = this.matcherOrThrow();
+      if (matcher.detectAudioMarker) {
+        return matcher.detectAudioMarker(safePcm, sampleRate, config);
+      }
+      if (!this.bindings) {
+        throw new Error("Matcher bindings are not initialized");
+      }
+      return this.bindings.detectAudioMarker(safePcm, sampleRate, config);
+    } catch (error) {
+      handleError(this.events, "detectAudioMarker", error);
+    }
+  }
+  async matchWithVariants(query, pitchQuery, config, variantConfig) {
+    try {
+      await this.ensureLiveReady();
+      const safeQuery = toUint8ArrayCopy(query);
+      this.events.emit("querystart", { queryByteLength: safeQuery.byteLength });
+      const results = this.matcherOrThrow().findMatchesWithVariants(
+        this.databaseOrThrow(),
+        safeQuery,
+        pitchQuery,
+        config,
+        variantConfig
+      );
+      this.emitDistinctMatchEvent(
+        results[0]?.matchResult ?? null,
+        safeQuery.byteLength,
+        results.map((result) => result.matchResult)
+      );
+      return results;
+    } catch (error) {
+      handleError(this.events, "matchWithVariants", error);
+    }
+  }
+  async bestMatchWithVariants(query, pitchQuery, config, variantConfig) {
+    try {
+      await this.ensureLiveReady();
+      const safeQuery = toUint8ArrayCopy(query);
+      this.events.emit("querystart", { queryByteLength: safeQuery.byteLength });
+      const best = this.matcherOrThrow().bestMatchWithVariants(
+        this.databaseOrThrow(),
+        safeQuery,
+        pitchQuery,
+        config,
+        variantConfig
+      );
+      this.emitDistinctMatchEvent(
+        best?.matchResult ?? null,
+        safeQuery.byteLength,
+        best ? [best.matchResult] : []
+      );
+      return best;
+    } catch (error) {
+      handleError(this.events, "bestMatchWithVariants", error);
+    }
+  }
   destroy() {
     if (this.destroyed) {
       return;

package/package.json

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