@sorisdk/matcher 0.4.0 → 0.6.0

package/README.md

@@ -72,7 +72,9 @@ If you want campaign events and browser recognition flow on top of matching, use
 ## Metadata lookup
 
 Audiopack footer metadata is available through explicit lookup rather than being
-embedded in `MatchResult`.
+embedded in `MatchResult`. Segment timing is the exception: when a pack provides
+valid `matcherSegments` metadata, `MatchResult.position` is segment-local and
+`MatchResult.durationMillis` contains the matched segment duration.
 
 ```ts
 const best = await session.bestMatch(queryBytes);

package/dist/generated/core.d.ts

@@ -21,10 +21,31 @@ export class WasmMatcherEngine {
     [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

@@ -164,6 +164,113 @@ export class WasmMatcherEngine {
         }
         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
@@ -210,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;
@@ -15,6 +22,13 @@ 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_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;

package/dist/index.d.ts

@@ -7,11 +7,62 @@ 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;
@@ -47,6 +98,7 @@ interface MatchResult {
     name: string;
     score: number;
     position: number;
+    durationMillis?: number;
     afpType: AudioFingerprintType;
 }
 interface VariantMatch {
@@ -171,6 +223,11 @@ declare class MatcherSession {
     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;
@@ -185,4 +242,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, type VariantDecision, type VariantDecisionStatus, type VariantMatch, type VariantMatchConfig, type VariantMatchQuery, __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

@@ -375,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) {
@@ -448,12 +511,17 @@ var WrappedMatcher = class {
 };
 function normalizeResult(raw) {
   const afpType = Number(raw.afpType ?? raw.afp_type);
-  return {
+  const durationMillis = raw.durationMillis ?? raw.duration_millis;
+  const result = {
     name: String(raw.name),
     score: Number(raw.score),
     position: Number(raw.position),
     afpType
   };
+  if (durationMillis != null) {
+    result.durationMillis = Number(durationMillis);
+  }
+  return result;
 }
 function normalizeVariantMatch(raw) {
   const rawMatch = raw.matchResult ?? raw.match;
@@ -467,6 +535,64 @@ function normalizeVariantMatch(raw) {
     }
   };
 }
+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";
 }
@@ -526,6 +652,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) {
@@ -547,6 +692,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);
+      }
     }
   };
 }
@@ -731,6 +986,108 @@ 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();

package/package.json

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