@sorisdk/web-audio 0.6.4 → 0.6.7

package/README.md

@@ -22,7 +22,7 @@ configuration, or Node-based asset server is required:
 ```html
 <script type="module">
   import { AudioRecognizer } from
-    "https://cdn.iplateia.com/web/sorisdk/v0.6.4/sori-web-audio.mjs";
+    "https://cdn.iplateia.com/web/sorisdk/v0.6.7/sori-web-audio.mjs";
 
   const recognizer = new AudioRecognizer({
     appId: "YOUR_APP_ID",
@@ -49,13 +49,39 @@ configuration, or Node-based asset server is required:
 ```
 
 Static URL imports are valid inside `<script type="module">`. Dynamic
-`await import("https://cdn.iplateia.com/web/sorisdk/v0.6.4/sori-web-audio.mjs")`
+`await import("https://cdn.iplateia.com/web/sorisdk/v0.6.7/sori-web-audio.mjs")`
 is an optional alternative when the SDK should be loaded conditionally.
 
 Pin an exact version in production. Do not construct a mutable `latest` URL.
 The module loads its versioned WASM assets and the shared
 `https://cdn.iplateia.com/web/sorisdk/model.pack` automatically.
 
+The fixed model response and caller-supplied AudioPacks use the matcher's same
+64 MiB browser transport limit by default. A valid oversized `Content-Length`
+is rejected before the body is consumed, and an unknown-length response is
+canceled on the first chunk that crosses the limit. The response is never
+truncated; failures use the deterministic
+`Pack source exceeds maximum size of <limit> bytes` error.
+
+Set an intentional shared override through the matcher options when a larger
+pack is required:
+
+```ts
+const recognizer = new AudioRecognizer({
+  appId: "YOUR_APP_ID",
+  ephemeralKey,
+  wasm: {
+    matcher: {
+      maxPackBytes: 96 * 1024 * 1024
+    }
+  }
+});
+```
+
+The override applies to both the standalone fixed-model response and ordinary
+pack sources. A caller-supplied `embeddedPackLoader` remains a zero-argument
+callback and is not replaced by the standalone loader.
+
 The standalone module removes the frontend build/server requirement, but it
 does not remove the trusted server requirement for ephemeral credentials.
 Provide a backend or serverless endpoint for the `ephemeralKey` callback, and
@@ -93,7 +119,7 @@ An import map can give the standalone URL the npm package name:
 <script type="importmap">
 {
   "imports": {
-    "@sorisdk/web-audio": "https://cdn.iplateia.com/web/sorisdk/v0.6.4/sori-web-audio.mjs"
+    "@sorisdk/web-audio": "https://cdn.iplateia.com/web/sorisdk/v0.6.7/sori-web-audio.mjs"
   }
 }
 </script>
@@ -142,7 +168,7 @@ const recognizer = new AudioRecognizer({
 });
 
 recognizer.on("campaign", (event) => {
-  console.log(event.campaign);
+  console.log(event.activityId, event.campaign);
 });
 
 recognizer.on("error", ({ error }) => {
@@ -159,6 +185,121 @@ await recognizer.stop();
 await recognizer.destroy();
 ```
 
+## Activity refinement
+
+The default `AudioRecognizer` activity reporter represents one ordered,
+continuous material segment and its later audio-marker enrichment as one
+server activity:
+
+1. When the coordinator accepts a successful material match, it captures one
+   UTC RFC 3339 `recognized_at` value before any asynchronous request mapping,
+   header, token, or fetch work.
+2. The initial `POST /api/activity/` includes that timestamp and the exact
+   `DetectedMatch.position` integer in milliseconds. With valid
+   `matcherSegments` metadata, the position is local to the matched segment.
+3. A marker-free match with an active marker-scan request also includes
+   top-level `refinement_expected: true`.
+4. The returned `activity_id` is retained for 30 seconds.
+5. If the same recognition gains `audioMarker.code`, the SDK sends
+   `PUT /api/activity/{activity_id}` with the same material and
+   `trait.marker`.
+6. The refined `campaign` event keeps the same non-empty `activityId`, so an
+   application can replace the earlier campaign row deterministically.
+
+A consecutive match for the same material and fingerprint type renews a local
+30-second continuity lease without another POST or campaign event. That local
+lease can keep one segment alive beyond the initial server refinement window,
+but it never extends the original PUT deadline. A marker confirmed anywhere
+inside the segment is sticky: the first confirmation can issue at most one PUT,
+and later marker misses or repeated marker evidence issue no mutation or
+downgrade.
+
+A marker present on the first match is included in the POST and does not cause
+a PUT or include `refinement_expected`; that marker-first segment is still
+retained for continuity. Recognition without an active marker scan, plus
+legacy/custom POST-only reporters, also omit the opt-in flag. Custom reporters
+enable segment coalescing only when `refinement` is enabled, preserving legacy
+POST-only behavior otherwise.
+
+A different material, an emitted `nomatch`, a gap beyond the continuity lease,
+or stop, clear, destroy, authentication/capture replacement, or reset seals the
+segment. Returning to A after B always creates a new A activity and can never
+refine the earlier A. Marker evidence arriving after a segment is sealed is
+ignored for that segment; create or PUT transport that already started may
+finish under the existing capture, deadline, and cancellation guards.
+
+Ordinary fingerprint `match` and marker-state `audiomarker` events remain
+independently observable; coalescing only changes activity mutation and
+campaign delivery. An `audiomarker` event alone does not mean that server
+activity refinement completed.
+
+Recognition timing belongs only to the segment's first material POST. Later
+same-material observations update only the internal `lastObservedAt` lease;
+they never replace the first `recognized_at` or `position`. A later marker PUT
+does not include either field, and marker-only events do not create timing
+metadata. `recognized_at` identifies first SDK match acceptance rather than
+HTTP receipt, marker confirmation, refinement, or webhook delivery time. Do not
+derive playback start as `recognized_at - position`: the match is accepted
+after its query window was collected, so that calculation lacks the query
+window's wall-clock anchor.
+
+Network and 5xx PUT failures are retried at most twice within the original
+30-second deadline. Server responses 404, 409, and 410 are terminal. An
+expired or failed refinement is dropped and never becomes a second POST.
+Stopping, clearing, destroying, or replacing the authenticated capture clears
+pending refinement identity.
+
+Custom `activityReporter` configurations remain POST-only by default. Enable
+refinement explicitly and, if needed, provide operation-specific transport or
+mapping hooks:
+
+```ts
+const recognizer = new AudioRecognizer({
+  appId: "YOUR_APP_ID",
+  ephemeralKey: fetchEphemeralKeyFromYourServer,
+  activityReporter: {
+    endpoint: "https://example.com/activity/",
+    refinement: {
+      endpoint: (activityId) =>
+        `https://example.com/activity/${encodeURIComponent(activityId)}`,
+      maxAttempts: 2,
+      shouldRetry: ({ status }) => status === null || status >= 500
+    }
+  }
+});
+```
+
+Existing `mapMatchToRequest` and `mapResponseToCampaign` hooks continue to
+handle POST. Additive refinement hooks can override the PUT payload, response
+mapping, endpoint, headers, fetcher, and retry policy. The stable terminal
+statuses 404, 409, and 410 are never retried even if a custom policy returns
+`true`.
+
+`recognized_at` and `position` are optional public request properties for
+source compatibility, but they are SDK-owned transport values. After a custom
+POST mapper returns an eligible material payload, the SDK overwrites any
+conflicting values with the captured recognition timestamp and exact matcher
+position. The SDK removes both properties from all refinement PUT payloads,
+including custom refinement mappings. Existing one-argument POST mappers and
+POST-only transports require no signature changes. Activity responses and
+`campaign` events do not gain timing properties from this request contract.
+
+## API endpoint normalization
+
+`apiEndpoint` continues to accept a `string` or `URL`. When the SDK derives the
+default authentication and activity URLs, it removes all trailing ASCII `/`
+characters and appends `/auth` or `/activity/` with the existing URL shapes.
+
+The endpoint is limited to `MAX_API_ENDPOINT_LENGTH` (32,768 UTF-16 code units).
+The first code unit over that limit throws
+`AudioRecognizer apiEndpoint exceeds maximum length of 32768 UTF-16 code units`
+before trailing-slash scanning or endpoint joining. The SDK rejects the input;
+it never truncates it. An explicitly supplied `apiEndpoint` is length-validated
+during construction even when custom `authEndpoint` and `activityEndpoint`
+values mean its prefix is not used for either join. This resource bound limits
+construction work only. It is not an authentication, authorization, quota, or
+abuse-prevention control.
+
 ## Session identifiers
 
 `AudioRecognizer` creates one pseudonymous session identifier per application
@@ -244,6 +385,21 @@ const recognizer = new AudioRecognizer({
 });
 ```
 
+Advanced callers that import `@sorisdk/web-audio/generated/window.js`
+directly still use `appendFingerprint(bytes: Uint8Array): void`. Each generated
+window exposes `maxAppendFingerprintByteLength()`, which is the byte length of
+one complete query for that instance. An append exactly at that limit is
+accepted. A larger append throws a `RangeError` before the JavaScript array is
+copied into WASM, with this deterministic message:
+
+```text
+Fingerprint append byteLength <actual> exceeds the per-instance limit of <limit> bytes
+```
+
+The high-level SDK enforces the same boundary before it invokes the generated
+class. Oversized input is rejected, never truncated or split; normal microphone
+fingerprint chunks and the existing match-window cadence are unchanged.
+
 ## Integration flow
 
 1. Prepare your `appId` and ephemeral key flow.

package/dist/generated/window.d.ts

@@ -6,6 +6,7 @@ export class WasmFingerprintMatchWindow {
     [Symbol.dispose](): void;
     appendFingerprint(bytes: Uint8Array): void;
     hasReadyQuery(): boolean;
+    maxAppendFingerprintByteLength(): number;
     constructor(sample_rate: number, afpgen_config: any | null | undefined, match_window_ms: number, match_stride_ms: number);
     reset(): void;
     takeReadyQuery(): any;

package/dist/generated/window_bg.js

@@ -13,9 +13,10 @@ export class WasmFingerprintMatchWindow {
      * @param {Uint8Array} bytes
      */
     appendFingerprint(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.wasmfingerprintmatchwindow_appendFingerprint(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.wasmfingerprintmatchwindow_appendFingerprint(this.__wbg_ptr, bytes);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
      * @returns {boolean}
@@ -24,6 +25,13 @@ export class WasmFingerprintMatchWindow {
         const ret = wasm.wasmfingerprintmatchwindow_hasReadyQuery(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * @returns {number}
+     */
+    maxAppendFingerprintByteLength() {
+        const ret = wasm.wasmfingerprintmatchwindow_maxAppendFingerprintByteLength(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * @param {number} sample_rate
      * @param {any | null | undefined} afpgen_config
@@ -47,7 +55,10 @@ export class WasmFingerprintMatchWindow {
      */
     takeReadyQuery() {
         const ret = wasm.wasmfingerprintmatchwindow_takeReadyQuery(this.__wbg_ptr);
-        return ret;
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
 }
 if (Symbol.dispose) WasmFingerprintMatchWindow.prototype[Symbol.dispose] = WasmFingerprintMatchWindow.prototype.free;
@@ -82,6 +93,10 @@ export function __wbg___wbindgen_in_a5d8b22e52b24dd1(arg0, arg1) {
     const ret = arg0 in arg1;
     return ret;
 }
+export function __wbg___wbindgen_is_function_3baa9db1a987f47d(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
+}
 export function __wbg___wbindgen_is_null_52ff4ec04186736f(arg0) {
     const ret = arg0 === null;
     return ret;
@@ -116,6 +131,26 @@ export function __wbg___wbindgen_string_get_7ed5322991caaec5(arg0, arg1) {
 export function __wbg___wbindgen_throw_6b64449b9b9ed33c(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
+export function __wbg_call_14b169f759b26747() { return handleError(function (arg0, arg1) {
+    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_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_6011fa3a58f61074() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments); }
 export function __wbg_get_with_ref_key_6412cf3094599694(arg0, arg1) {
     const ret = arg0[arg1];
     return ret;
@@ -152,6 +187,10 @@ export function __wbg_new_0c7403db6e782f19(arg0) {
     const ret = new Uint8Array(arg0);
     return ret;
 }
+export function __wbg_new_191521fecb171639(arg0, arg1) {
+    const ret = new RangeError(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
 export function __wbg_new_from_slice_b5ea43e23f6008c0(arg0, arg1) {
     const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
     return ret;
@@ -159,7 +198,28 @@ export function __wbg_new_from_slice_b5ea43e23f6008c0(arg0, arg1) {
 export function __wbg_prototypesetcall_a6b02eb00b0f4ce2(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
 }
+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 __wbindgen_cast_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
@@ -274,15 +334,17 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
-function isLikeNone(x) {
-    return x === undefined || x === null;
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
 }
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
+function isLikeNone(x) {
+    return x === undefined || x === null;
 }
 
 function passStringToWasm0(arg, malloc, realloc) {

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

@@ -2,14 +2,16 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_wasmfingerprintmatchwindow_free: (a: number, b: number) => void;
-export const wasmfingerprintmatchwindow_appendFingerprint: (a: number, b: number, c: number) => void;
+export const wasmfingerprintmatchwindow_appendFingerprint: (a: number, b: any) => [number, number];
 export const wasmfingerprintmatchwindow_hasReadyQuery: (a: number) => number;
+export const wasmfingerprintmatchwindow_maxAppendFingerprintByteLength: (a: number) => number;
 export const wasmfingerprintmatchwindow_new: (a: number, b: number, c: number, d: number) => [number, number, number];
 export const wasmfingerprintmatchwindow_reset: (a: number) => void;
-export const wasmfingerprintmatchwindow_takeReadyQuery: (a: number) => any;
+export const wasmfingerprintmatchwindow_takeReadyQuery: (a: 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_externrefs: WebAssembly.Table;
+export const __wbindgen_exn_store: (a: number) => void;
 export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
 export const __externref_table_dealloc: (a: number) => void;
 export const __wbindgen_start: () => void;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { MatcherEphemeralAuthOptions, InitMatcherOptions, MatcherEphemeralAuthResult, AudioMarkerDetection, PackSource, MatchResult, AudioFingerprintType } from '@sorisdk/matcher';
+import { MatcherEphemeralAuthOptions, InitMatcherOptions, MatcherEphemeralAuthResult, AudioMarkerDetection, PackSource, MatchResult, MatcherSessionOptions, AudioFingerprintType } from '@sorisdk/matcher';
 export { AudioFingerprintType, AudioMarkerConfig, AudioMarkerDetection, PackSource } from '@sorisdk/matcher';
 import { InitAfpgenOptions } from '@sorisdk/afpgen';
 
@@ -62,6 +62,15 @@ interface AudioMarkerEvent {
 interface MaterialActivityRequestPayload {
     type: "material";
     material_id: string;
+    /** SDK-owned UTC recognition timestamp. Custom mapper values are overwritten on POST. */
+    recognized_at?: string;
+    /** SDK-owned matcher position in milliseconds. Custom mapper values are overwritten on POST. */
+    position?: number;
+    refinement_expected?: true;
+    trait?: {
+        marker?: string;
+        [key: string]: unknown;
+    };
     metadata?: unknown;
 }
 interface MicrophoneMatcherCampaignEvent {
@@ -70,6 +79,27 @@ interface MicrophoneMatcherCampaignEvent {
     activityId: string | null;
     raw: Record<string, unknown>;
 }
+interface ActivityRefinementRequestContext {
+    operation: "refine";
+    activityId: string;
+    attempt: number;
+    deadline: number;
+}
+interface ActivityRefinementFailureContext extends ActivityRefinementRequestContext {
+    error: Error;
+    status: number | null;
+    detail: string | null;
+}
+interface MicrophoneMatcherActivityRefinementOptions {
+    endpoint?: string | URL | ((activityId: string) => string | URL | Promise<string | URL>);
+    fetch?: typeof fetch;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    mapMatchToRequest?: (match: DetectedMatch, context: ActivityRefinementRequestContext) => MaterialActivityRequestPayload | null | Promise<MaterialActivityRequestPayload | null>;
+    mapResponseToCampaign?: (response: Record<string, unknown>, match: DetectedMatch, context: ActivityRefinementRequestContext) => MicrophoneMatcherCampaignEvent | null | Promise<MicrophoneMatcherCampaignEvent | null>;
+    shouldRetry?: (context: ActivityRefinementFailureContext) => boolean | Promise<boolean>;
+    maxAttempts?: number;
+    now?: () => number;
+}
 interface MicrophoneMatcherActivityReporterOptions {
     endpoint: string | URL;
     token: string | (() => string | Promise<string>);
@@ -77,10 +107,11 @@ interface MicrophoneMatcherActivityReporterOptions {
     headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
     mapMatchToRequest?: (match: DetectedMatch) => MaterialActivityRequestPayload | null | Promise<MaterialActivityRequestPayload | null>;
     mapResponseToCampaign?: (response: Record<string, unknown>, match: DetectedMatch) => MicrophoneMatcherCampaignEvent | null | Promise<MicrophoneMatcherCampaignEvent | null>;
+    refinement?: false | MicrophoneMatcherActivityRefinementOptions;
 }
 interface CreateMicrophoneMatcherWasmOptions {
     afpgen?: InitAfpgenOptions;
-    matcher?: Omit<InitMatcherOptions, "auth">;
+    matcher?: Omit<MatcherSessionOptions, "auth">;
     matchWindow?: InitMatchWindowWasmOptions;
 }
 interface CreateMicrophoneMatcherOptions {
@@ -120,6 +151,7 @@ type MicrophoneMatcherListener<T extends MicrophoneMatcherEventName> = (payload:
 type Awaitable<T> = T | Promise<T>;
 type AudioRecognizerMatcherOptions = Omit<CreateMicrophoneMatcherOptions, "activityReporter" | "packSource">;
 declare const DEFAULT_SORI_API_ENDPOINT = "https://console.soriapi.com/api";
+declare const MAX_API_ENDPOINT_LENGTH: number;
 interface AudioRecognizerAuthOptions {
     endpoint: string | URL;
     appId: string;
@@ -182,6 +214,8 @@ declare class AudioRecognizer {
     private setAuthResult;
 }
 
+declare const ACTIVITY_REFINEMENT_WINDOW_MS = 30000;
+
 declare class MicrophoneMatcher {
     private readonly events;
     private readonly matcherSession;
@@ -193,6 +227,7 @@ declare class MicrophoneMatcher {
     private readonly captureSampleRate;
     private readonly audioGraphFactory;
     private readonly packSource;
+    private readonly activityRefinement;
     private readonly options;
     private extractor;
     private graphController;
@@ -211,6 +246,7 @@ declare class MicrophoneMatcher {
     private latestAudioMarker;
     private latestAudioMarkerDetection;
     private audioMarkerRequestId;
+    private activityRecognitionId;
     private hopSize;
     private diagnostics;
     constructor(options: CreateMicrophoneMatcherOptions);
@@ -260,4 +296,4 @@ declare function requestMicrophoneStream(mediaDevices: MediaDevices, mediaConstr
     preferredSampleRate?: number;
 }): Promise<MediaStream>;
 
-export { type AudioMarkerEvent, AudioRecognizer, type AudioRecognizerAuthOptions, type AudioRecognizerOptions, type AuthenticateAndLoadAudioPackOptions, type AuthenticateAndLoadAudioPackResult, type BrowserAudioPackLoader, type BrowserAudioPackState, type BrowserAudioPackStateStore, type BrowserSessionManager, type CreateLocalStorageAudioPackStoreOptions, type CreateLocalStorageSessionManagerOptions, type CreateMicrophoneMatcherOptions, type CreateMicrophoneMatcherWasmOptions, DEFAULT_BROWSER_AUDIOPACK_VERSION, DEFAULT_SORI_API_ENDPOINT, type DetectedMatch, type MaterialActivityRequestPayload, MicrophoneMatcher, type MicrophoneMatcherActivityReporterOptions, type MicrophoneMatcherCampaignEvent, type MicrophoneMatcherEventMap, type MicrophoneMatcherEventName, type MicrophoneMatcherListener, authenticateAndLoadAudioPack, createLocalStorageAudioPackStore, createLocalStorageSessionManager, createMicrophoneMatcher, requestMicrophoneStream };
+export { ACTIVITY_REFINEMENT_WINDOW_MS, type ActivityRefinementFailureContext, type ActivityRefinementRequestContext, type AudioMarkerEvent, AudioRecognizer, type AudioRecognizerAuthOptions, type AudioRecognizerOptions, type AuthenticateAndLoadAudioPackOptions, type AuthenticateAndLoadAudioPackResult, type BrowserAudioPackLoader, type BrowserAudioPackState, type BrowserAudioPackStateStore, type BrowserSessionManager, type CreateLocalStorageAudioPackStoreOptions, type CreateLocalStorageSessionManagerOptions, type CreateMicrophoneMatcherOptions, type CreateMicrophoneMatcherWasmOptions, DEFAULT_BROWSER_AUDIOPACK_VERSION, DEFAULT_SORI_API_ENDPOINT, type DetectedMatch, MAX_API_ENDPOINT_LENGTH, type MaterialActivityRequestPayload, MicrophoneMatcher, type MicrophoneMatcherActivityRefinementOptions, type MicrophoneMatcherActivityReporterOptions, type MicrophoneMatcherCampaignEvent, type MicrophoneMatcherEventMap, type MicrophoneMatcherEventName, type MicrophoneMatcherListener, authenticateAndLoadAudioPack, createLocalStorageAudioPackStore, createLocalStorageSessionManager, createMicrophoneMatcher, requestMicrophoneStream };