@sorisdk/web-audio 0.6.5 → 0.6.8

package/README.md

@@ -13,6 +13,36 @@ Public integration guide: https://docs.soriapi.com/ko/integration/web
 - An ephemeral key issued by your server
 - Microphone permission granted by the user
 
+## Unreleased: Console-resolved audio marker events
+
+The public `audiomarker` event now contains only the marker identity managed in
+SORI Console. The SDK emits it after a successful activity POST or refinement
+PUT returns both a non-blank `audio_marker_id` and `audio_marker_name`:
+
+```ts
+recognizer.on("audiomarker", ({ marker }) => {
+  console.log(marker.id, marker.name);
+});
+```
+
+The event is independent from campaign mapping and can be emitted when the
+activity response has no campaign. Repeated responses within one continuous
+material segment emit once; an intervening material, no-match, capture reset,
+or expired continuity gap starts a new segment that may emit again.
+
+Local WASM detection and labels such as `code_000` remain private inputs to the
+activity request. They are no longer present on public `audiomarker` or `match`
+events, `campaign.match`, the exported `DetectedMatch`, or the
+`@sorisdk/web-audio` type exports. Custom request and campaign mappers receive
+the public codebook-free match; the SDK adds its private `trait.marker` only to
+the outgoing activity payload after request mapping.
+
+This deliberately replaces the 0.6.7-and-earlier event shape. Migrate from
+`event.marker` as a nullable string and `event.detection` as a raw detector
+result to the non-null `event.marker.id` and `event.marker.name` fields above.
+There is no legacy fallback: disabled activity reporting, failed transport, or
+a response with a missing or malformed id/name pair emits no public marker.
+
 ## Standalone CDN
 
 For a browser application that does not use npm or a bundler, import the
@@ -22,7 +52,7 @@ configuration, or Node-based asset server is required:
 ```html
 <script type="module">
   import { AudioRecognizer } from
-    "https://cdn.iplateia.com/web/sorisdk/v0.6.5/sori-web-audio.mjs";
+    "https://cdn.iplateia.com/web/sorisdk/v0.6.8/sori-web-audio.mjs";
 
   const recognizer = new AudioRecognizer({
     appId: "YOUR_APP_ID",
@@ -49,13 +79,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.5/sori-web-audio.mjs")`
+`await import("https://cdn.iplateia.com/web/sorisdk/v0.6.8/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 +149,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.5/sori-web-audio.mjs"
+    "@sorisdk/web-audio": "https://cdn.iplateia.com/web/sorisdk/v0.6.8/sori-web-audio.mjs"
   }
 }
 </script>
@@ -145,6 +201,10 @@ recognizer.on("campaign", (event) => {
   console.log(event.activityId, event.campaign);
 });
 
+recognizer.on("audiomarker", ({ marker }) => {
+  console.log(marker.id, marker.name);
+});
+
 recognizer.on("error", ({ error }) => {
   console.error(error);
 });
@@ -161,23 +221,63 @@ await recognizer.destroy();
 
 ## Activity refinement
 
-The default `AudioRecognizer` activity reporter represents one fingerprint
-recognition and its later audio-marker enrichment as one server activity:
-
-1. A marker-free match with an active marker-scan request is created with
-   `POST /api/activity/` and top-level `refinement_expected: true`.
-2. The returned `activity_id` is retained for 30 seconds.
-3. If the same recognition gains `audioMarker.code`, the SDK sends
+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 a private local marker detection, the SDK sends
    `PUT /api/activity/{activity_id}` with the same material and
    `trait.marker`.
-4. The refined `campaign` event keeps the same non-empty `activityId`, so an
+6. A valid response marker id/name pair emits one public structured
+   `audiomarker` event, even when the response has no campaign.
+7. 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`. Recognition without an active marker
-scan, plus legacy/custom POST-only reporters, also omit the opt-in flag.
-Marker-state `audiomarker` events remain independently observable; they do not
-mean that server activity refinement completed.
+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` events remain independently observable and never
+contain the private detector result. Public `audiomarker` delivery is sourced
+only from a completed activity response. It is independent from campaign
+availability but does prove that the server resolved the marker id and name.
+
+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
@@ -209,7 +309,35 @@ 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`.
+`true`. Match arguments passed to these hooks omit private detector state. When
+local detection succeeds, the SDK injects its private marker into the outgoing
+`trait.marker` after request mapping, while resolved public identity is parsed
+directly from the unmodified activity response before campaign delivery.
+
+`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
 
@@ -296,11 +424,27 @@ 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.
 2. Create an `AudioRecognizer`.
-3. Subscribe to the events you need, such as `campaign`, `match`, and `error`.
+3. Subscribe to the events you need, such as `campaign`, `audiomarker`, `match`,
+   and `error`.
 4. Call `start()` to begin recognition.
 5. Call `stop()` or `destroy()` when leaving the page or stopping capture.
 

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,5 +1,5 @@
-import { MatcherEphemeralAuthOptions, InitMatcherOptions, MatcherEphemeralAuthResult, AudioMarkerDetection, PackSource, MatchResult, AudioFingerprintType } from '@sorisdk/matcher';
-export { AudioFingerprintType, AudioMarkerConfig, AudioMarkerDetection, PackSource } from '@sorisdk/matcher';
+import { MatcherEphemeralAuthOptions, InitMatcherOptions, MatcherEphemeralAuthResult, PackSource, MatchResult, MatcherSessionOptions, AudioFingerprintType } from '@sorisdk/matcher';
+export { AudioFingerprintType, AudioMarkerConfig, PackSource } from '@sorisdk/matcher';
 import { InitAfpgenOptions } from '@sorisdk/afpgen';
 
 declare const DEFAULT_BROWSER_AUDIOPACK_VERSION = "20220401000000";
@@ -53,15 +53,22 @@ interface InitMatchWindowWasmOptions {
 }
 
 interface DetectedMatch extends Pick<MatchResult, "afpType" | "durationMillis" | "name" | "position" | "score"> {
-    audioMarker?: AudioMarkerDetection | null;
+}
+/** SORI Console-managed identity resolved from a successful activity response. */
+interface AudioMarkerIdentity {
+    readonly id: string;
+    readonly name: string;
 }
 interface AudioMarkerEvent {
-    marker: string | null;
-    detection: AudioMarkerDetection;
+    readonly marker: AudioMarkerIdentity;
 }
 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;
@@ -107,7 +114,7 @@ interface MicrophoneMatcherActivityReporterOptions {
 }
 interface CreateMicrophoneMatcherWasmOptions {
     afpgen?: InitAfpgenOptions;
-    matcher?: Omit<InitMatcherOptions, "auth">;
+    matcher?: Omit<MatcherSessionOptions, "auth">;
     matchWindow?: InitMatchWindowWasmOptions;
 }
 interface CreateMicrophoneMatcherOptions {
@@ -147,6 +154,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;
@@ -238,7 +246,6 @@ declare class MicrophoneMatcher {
     private markerPcmBuffer;
     private resampleBuffer;
     private resampleOffset;
-    private latestAudioMarker;
     private latestAudioMarkerDetection;
     private audioMarkerRequestId;
     private activityRecognitionId;
@@ -276,7 +283,6 @@ declare class MicrophoneMatcher {
     private detectAudioMarkerForRequest;
     private matchConfig;
     private withAudioMarkerForRequest;
-    private emitAudioMarkerIfChanged;
     private normalizeInputSamples;
     private resampleToTargetRate;
     private cleanupAfterStartFailure;
@@ -291,4 +297,4 @@ declare function requestMicrophoneStream(mediaDevices: MediaDevices, mediaConstr
     preferredSampleRate?: number;
 }): Promise<MediaStream>;
 
-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, type MaterialActivityRequestPayload, MicrophoneMatcher, type MicrophoneMatcherActivityRefinementOptions, 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, type AudioMarkerIdentity, 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 };