@sorisdk/web-audio 0.6.5 → 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.5/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.5/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.5/sori-web-audio.mjs"
+    "@sorisdk/web-audio": "https://cdn.iplateia.com/web/sorisdk/v0.6.7/sori-web-audio.mjs"
   }
 }
 </script>
@@ -161,23 +187,61 @@ 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 `audioMarker.code`, 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. 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` 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
@@ -211,6 +275,31 @@ 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
@@ -296,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,10 @@ 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;
@@ -107,7 +111,7 @@ interface MicrophoneMatcherActivityReporterOptions {
 }
 interface CreateMicrophoneMatcherWasmOptions {
     afpgen?: InitAfpgenOptions;
-    matcher?: Omit<InitMatcherOptions, "auth">;
+    matcher?: Omit<MatcherSessionOptions, "auth">;
     matchWindow?: InitMatchWindowWasmOptions;
 }
 interface CreateMicrophoneMatcherOptions {
@@ -147,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;
@@ -291,4 +296,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, 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 };

package/dist/index.js

@@ -181,6 +181,18 @@ function getBrowserMediaDevices() {
 }
 
 // src/match-window.ts
+var FINGERPRINT_LEVEL_BYTE_LENGTH = 8;
+function getTypedArrayByteLengthGetter() {
+  const getter = Object.getOwnPropertyDescriptor(
+    Object.getPrototypeOf(Uint8Array.prototype),
+    "byteLength"
+  )?.get;
+  if (!getter) {
+    throw new Error("Uint8Array byteLength intrinsic is unavailable");
+  }
+  return getter;
+}
+var typedArrayByteLengthGetter = getTypedArrayByteLengthGetter();
 var cachedBindings = null;
 var initPromise = null;
 var testInjectedWasmModule = null;
@@ -197,18 +209,46 @@ var defaultLoader = async () => {
   const loaderModule = await import("./default-loader.js");
   return loaderModule.default();
 };
+function calculateMaxAppendFingerprintByteLength(options) {
+  const hopSize = options.afpgenConfig.hopSize ?? 1e3;
+  const levelCount = options.afpgenConfig.levelCount ?? 2;
+  const hopDurationMs = hopSize / options.sampleRate * 1e3;
+  const hopsInWindow = Math.ceil(options.matchWindowMs / hopDurationMs);
+  return Math.max(1, hopsInWindow) * levelCount * FINGERPRINT_LEVEL_BYTE_LENGTH;
+}
+function appendLimitError(byteLength, maxByteLength) {
+  return new RangeError(
+    `Fingerprint append byteLength ${byteLength} exceeds the per-instance limit of ${maxByteLength} bytes`
+  );
+}
+function intrinsicUint8ArrayByteLength(bytes) {
+  return typedArrayByteLengthGetter.call(bytes);
+}
 var WrappedFingerprintMatchWindow = class {
-  constructor(inner) {
+  constructor(inner, options) {
     this.inner = inner;
+    const maxLengthFn = getCallable(this.inner, [
+      "maxAppendFingerprintByteLength",
+      "max_append_fingerprint_byte_length"
+    ]);
+    this.maxAppendByteLength = maxLengthFn ? Number(maxLengthFn.call(this.inner)) : calculateMaxAppendFingerprintByteLength(options);
   }
   inner;
+  maxAppendByteLength;
   appendFingerprint(bytes) {
+    const byteLength = intrinsicUint8ArrayByteLength(bytes);
+    if (byteLength > this.maxAppendByteLength) {
+      throw appendLimitError(byteLength, this.maxAppendByteLength);
+    }
     const fn = getCallable(this.inner, ["appendFingerprint", "append_fingerprint"]);
     if (!fn) {
       throw new Error("web-audio wasm window is missing appendFingerprint");
     }
     fn.call(this.inner, bytes);
   }
+  maxAppendFingerprintByteLength() {
+    return this.maxAppendByteLength;
+  }
   hasReadyQuery() {
     const fn = getCallable(this.inner, ["hasReadyQuery", "has_ready_query"]);
     if (!fn) {
@@ -261,7 +301,8 @@ function createBindingsFromModule(moduleLike) {
           options.afpgenConfig,
           options.matchWindowMs,
           options.matchStrideMs
-        )
+        ),
+        options
       );
     }
   };
@@ -357,6 +398,14 @@ function defaultRequestPayload(match) {
     ...typeof marker === "string" && marker.length > 0 ? { trait: { marker } } : {}
   };
 }
+function captureActivityRecognitionTiming(match) {
+  const recognizedAtMillis = Date.now();
+  const position = match.position;
+  return Object.freeze({
+    recognizedAt: new Date(recognizedAtMillis).toISOString(),
+    position
+  });
+}
 function validateRequestPayload(payload) {
   if (payload === null) {
     return null;
@@ -373,7 +422,12 @@ async function resolveCreateRequestPayload(reporter, match) {
   if (!payload) {
     return null;
   }
-  const { refinement_expected: _ignored, ...requestPayload } = payload;
+  const {
+    position: _ignoredPosition,
+    recognized_at: _ignoredRecognizedAt,
+    refinement_expected: _ignoredRefinementExpected,
+    ...requestPayload
+  } = payload;
   return requestPayload;
 }
 async function resolveRefineRequestPayload(reporter, match, context) {
@@ -387,7 +441,12 @@ async function resolveRefineRequestPayload(reporter, match, context) {
   if (!payload) {
     return null;
   }
-  const { refinement_expected: _ignored, ...requestPayload } = payload;
+  const {
+    position: _ignoredPosition,
+    recognized_at: _ignoredRecognizedAt,
+    refinement_expected: _ignoredRefinementExpected,
+    ...requestPayload
+  } = payload;
   return requestPayload;
 }
 function defaultCampaignMapper(payload, match) {
@@ -457,10 +516,20 @@ function responseActivityId(data, campaign) {
 }
 async function mapCreateResponse(reporter, data, match, refinementExpected) {
   if (!data) {
-    return { activityId: null, campaign: null, refinementExpected };
+    return {
+      activityId: null,
+      campaign: null,
+      creationAttempted: true,
+      refinementExpected
+    };
   }
   const campaign = reporter.mapResponseToCampaign ? await reporter.mapResponseToCampaign(data, match) : defaultCampaignMapper(data, match);
-  return { activityId: responseActivityId(data, campaign), campaign, refinementExpected };
+  return {
+    activityId: responseActivityId(data, campaign),
+    campaign,
+    creationAttempted: true,
+    refinementExpected
+  };
 }
 async function resolveRefinementEndpoint(reporter, activityId) {
   const configured = reporter.refinement && reporter.refinement.endpoint;
@@ -470,10 +539,15 @@ async function resolveRefinementEndpoint(reporter, activityId) {
   const prefix = String(configured ?? reporter.endpoint);
   return `${prefix.endsWith("/") ? prefix : `${prefix}/`}${encodeURIComponent(activityId)}`;
 }
-async function createMatchedMaterialActivity(reporter, match, refinementExpected = false) {
+async function createMatchedMaterialActivity(reporter, match, refinementExpected = false, recognitionTiming = captureActivityRecognitionTiming(match)) {
   const payload = await resolveCreateRequestPayload(reporter, match);
   if (!payload) {
-    return { activityId: null, campaign: null, refinementExpected: false };
+    return {
+      activityId: null,
+      campaign: null,
+      creationAttempted: false,
+      refinementExpected: false
+    };
   }
   const headers = await resolveHeaders(reporter);
   const actualMarker = match.audioMarker?.code;
@@ -481,7 +555,12 @@ async function createMatchedMaterialActivity(reporter, match, refinementExpected
   const hasMarker = typeof actualMarker === "string" && actualMarker.length > 0 || typeof payloadMarker === "string" && payloadMarker.length > 0;
   const lifecycleOpen = typeof refinementExpected === "function" ? refinementExpected() : refinementExpected;
   const requestRefinementExpected = Boolean(reporter.refinement && lifecycleOpen && !hasMarker);
-  const requestPayload = requestRefinementExpected ? { ...payload, refinement_expected: true } : payload;
+  const requestPayload = {
+    ...payload,
+    recognized_at: recognitionTiming.recognizedAt,
+    position: recognitionTiming.position,
+    ...requestRefinementExpected ? { refinement_expected: true } : {}
+  };
   const response = await resolveFetch(reporter.fetch)(reporter.endpoint, {
     method: "POST",
     headers,
@@ -531,6 +610,7 @@ async function refineMatchedMaterialActivity(reporter, match, context, isActive
 
 // src/activity-refinement.ts
 var ACTIVITY_REFINEMENT_WINDOW_MS = 3e4;
+var ACTIVITY_CONTINUITY_GAP_MS = 3e4;
 var DEFAULT_MAX_REFINEMENT_ATTEMPTS = 2;
 var MAX_REFINEMENT_ATTEMPTS = 10;
 function normalizeError(error) {
@@ -566,9 +646,6 @@ var ActivityRefinementCoordinator = class {
   }
   report(recognitionId, match, captureGeneration, requestId = null) {
     const coordinatorGeneration = this.generation;
-    if (this.activeLifecycle && this.activeLifecycle.recognitionId !== recognitionId) {
-      this.deleteLifecycle(this.activeLifecycle);
-    }
     const hasMarker = typeof match.audioMarker?.code === "string" && match.audioMarker.code.length > 0;
     const refinement = this.reporter.refinement;
     const requestCanRefine = requestId !== null && !this.settledRequests.has(requestId);
@@ -578,39 +655,71 @@ var ActivityRefinementCoordinator = class {
       this.registeredRequests.delete(requestId);
       this.settledRequests.delete(requestId);
     }
+    if (refinement && this.activeLifecycle) {
+      const now = this.now();
+      const activeLifecycle = this.activeLifecycle;
+      if (this.isContinuousMatch(activeLifecycle, match, captureGeneration, now)) {
+        this.renewContinuity(activeLifecycle, now);
+        if (requestId !== null) {
+          if (requestCanRefine && this.canAcceptMarker(activeLifecycle)) {
+            this.requestLifecycles.set(requestId, activeLifecycle);
+          } else {
+            this.requestLifecycles.delete(requestId);
+          }
+        }
+        if (pendingMarker) {
+          this.claimMarker(activeLifecycle, pendingMarker);
+        }
+        if (hasMarker && match.audioMarker) {
+          this.claimMarker(activeLifecycle, match.audioMarker);
+        }
+        return;
+      }
+      this.sealLifecycle(activeLifecycle);
+    }
     const refinementExpected = Boolean(refinement && !hasMarker && requestCanRefine);
     let lifecycle = null;
-    if (refinementExpected && refinement) {
-      const now = refinement.now?.() ?? Date.now();
+    if (refinement) {
+      const now = this.now();
       lifecycle = {
         recognitionId,
         captureGeneration,
         match,
         deadline: now + ACTIVITY_REFINEMENT_WINDOW_MS,
+        lastObservedAt: now,
         activityId: null,
-        markerMatch: null,
-        markerCode: null,
-        timer: null,
+        markerMatch: hasMarker ? match : null,
+        markerCode: hasMarker ? match.audioMarker?.code ?? null : null,
+        refinementTimer: null,
+        continuityTimer: null,
         createSettled: false,
-        refinementStarted: false
+        refinementStarted: false,
+        refinementInFlight: false,
+        refinementClosed: !refinementExpected,
+        sealed: false
       };
       const createdLifecycle = lifecycle;
-      lifecycle.timer = setTimeout(() => {
-        this.deleteLifecycle(createdLifecycle);
-      }, ACTIVITY_REFINEMENT_WINDOW_MS);
+      if (refinementExpected) {
+        lifecycle.refinementTimer = setTimeout(() => {
+          this.closeRefinement(createdLifecycle);
+        }, ACTIVITY_REFINEMENT_WINDOW_MS);
+      }
+      this.scheduleContinuityExpiry(lifecycle);
       this.lifecycles.set(recognitionId, lifecycle);
-      if (requestId !== null) {
+      if (requestId !== null && refinementExpected) {
         this.requestLifecycles.set(requestId, lifecycle);
       }
       this.activeLifecycle = lifecycle;
-      if (pendingMarker) {
-        this.refine(requestId ?? recognitionId, pendingMarker, captureGeneration);
+      if (pendingMarker && refinementExpected) {
+        this.claimMarker(lifecycle, pendingMarker);
       }
     }
+    const recognitionTiming = captureActivityRecognitionTiming(match);
     void createMatchedMaterialActivity(
       this.reporter,
       match,
-      () => Boolean(lifecycle && this.isRefinementActive(lifecycle))
+      () => Boolean(lifecycle && this.isRefinementActive(lifecycle)),
+      recognitionTiming
     ).then(
       (result) => {
         if (coordinatorGeneration === this.generation && result.campaign && this.callbacks.isCurrentCapture(captureGeneration)) {
@@ -619,12 +728,17 @@ var ActivityRefinementCoordinator = class {
         if (coordinatorGeneration !== this.generation || !lifecycle || this.lifecycles.get(recognitionId) !== lifecycle) {
           return;
         }
-        if (!result.refinementExpected) {
+        lifecycle.createSettled = true;
+        lifecycle.activityId = result.activityId;
+        if (!result.creationAttempted) {
           this.deleteLifecycle(lifecycle);
           return;
         }
-        lifecycle.createSettled = true;
-        lifecycle.activityId = result.activityId;
+        if (!result.refinementExpected) {
+          this.closeRefinement(lifecycle);
+          this.maybeDeleteSealed(lifecycle);
+          return;
+        }
         if (lifecycle.markerMatch) {
           if (lifecycle.activityId) {
             this.startRefinement(lifecycle);
@@ -632,9 +746,11 @@ var ActivityRefinementCoordinator = class {
             this.failMissingActivityId(lifecycle);
           }
         }
+        this.maybeDeleteSealed(lifecycle);
       },
       (error) => {
         if (lifecycle) {
+          lifecycle.createSettled = true;
           this.deleteLifecycle(lifecycle);
         }
         if (coordinatorGeneration === this.generation && this.callbacks.isCurrentCapture(captureGeneration)) {
@@ -646,14 +762,26 @@ var ActivityRefinementCoordinator = class {
   associate(requestId, match, captureGeneration) {
     const lifecycle = this.activeLifecycle;
     this.registeredRequests.delete(requestId);
-    if (!lifecycle || !match || lifecycle.captureGeneration !== captureGeneration || lifecycle.match.name !== match.name || lifecycle.match.afpType !== match.afpType || !this.isActive(lifecycle)) {
+    if (!lifecycle || !match) {
+      return false;
+    }
+    const now = this.now();
+    if (!this.isContinuousMatch(lifecycle, match, captureGeneration, now)) {
+      this.sealLifecycle(lifecycle);
       return false;
     }
-    this.requestLifecycles.set(requestId, lifecycle);
+    this.renewContinuity(lifecycle, now);
     const pendingMarker = this.pendingMarkers.get(requestId);
-    if (pendingMarker) {
+    if (this.canAcceptMarker(lifecycle)) {
+      this.requestLifecycles.set(requestId, lifecycle);
+    } else {
+      this.requestLifecycles.delete(requestId);
+    }
+    if (pendingMarker && this.canAcceptMarker(lifecycle)) {
+      this.pendingMarkers.delete(requestId);
+      this.claimMarker(lifecycle, pendingMarker);
+    } else if (pendingMarker) {
       this.pendingMarkers.delete(requestId);
-      this.refine(requestId, pendingMarker, captureGeneration);
     }
     return true;
   }
@@ -666,18 +794,14 @@ var ActivityRefinementCoordinator = class {
   settleRequest(requestId) {
     const awaitingAssociation = this.registeredRequests.delete(requestId);
     this.pendingMarkers.delete(requestId);
-    const lifecycle = this.requestLifecycles.get(requestId);
-    if (lifecycle) {
-      this.deleteLifecycle(lifecycle);
-      return;
-    }
+    this.requestLifecycles.delete(requestId);
     if (awaitingAssociation) {
       this.settledRequests.add(requestId);
     }
   }
   clearActive(captureGeneration) {
     if (this.activeLifecycle?.captureGeneration === captureGeneration) {
-      this.deleteLifecycle(this.activeLifecycle);
+      this.sealLifecycle(this.activeLifecycle);
     }
   }
   refine(recognitionId, marker, captureGeneration) {
@@ -696,24 +820,19 @@ var ActivityRefinementCoordinator = class {
       }
       return;
     }
-    const now = this.reporter.refinement?.now?.() ?? Date.now();
-    if (now > lifecycle.deadline) {
-      this.deleteLifecycle(lifecycle);
+    if (!this.canAcceptMarker(lifecycle)) {
       return;
     }
-    lifecycle.markerCode = markerCode;
-    lifecycle.markerMatch = { ...lifecycle.match, audioMarker: marker };
-    if (lifecycle.activityId) {
-      this.startRefinement(lifecycle);
-    } else if (lifecycle.createSettled) {
-      this.failMissingActivityId(lifecycle);
-    }
+    this.claimMarker(lifecycle, marker);
   }
   reset() {
     this.generation += 1;
     for (const lifecycle of this.lifecycles.values()) {
-      if (lifecycle.timer) {
-        clearTimeout(lifecycle.timer);
+      if (lifecycle.refinementTimer) {
+        clearTimeout(lifecycle.refinementTimer);
+      }
+      if (lifecycle.continuityTimer) {
+        clearTimeout(lifecycle.continuityTimer);
       }
     }
     this.lifecycles.clear();
@@ -724,17 +843,21 @@ var ActivityRefinementCoordinator = class {
     this.activeLifecycle = null;
   }
   startRefinement(lifecycle) {
-    if (lifecycle.refinementStarted || !lifecycle.activityId || !lifecycle.markerMatch) {
+    if (lifecycle.refinementStarted || lifecycle.refinementClosed || !lifecycle.activityId || !lifecycle.markerMatch) {
       return;
     }
     lifecycle.refinementStarted = true;
-    void this.runRefinement(lifecycle);
+    lifecycle.refinementInFlight = true;
+    void this.runRefinement(lifecycle).finally(() => {
+      lifecycle.refinementInFlight = false;
+      this.maybeDeleteSealed(lifecycle);
+    });
   }
   failMissingActivityId(lifecycle) {
     if (!this.isRefinementActive(lifecycle)) {
       return;
     }
-    this.deleteLifecycle(lifecycle);
+    this.closeRefinement(lifecycle);
     this.callbacks.emitError(
       "activity-refinement",
       new Error("Activity refinement requires a non-empty activity_id from the create response")
@@ -743,7 +866,7 @@ var ActivityRefinementCoordinator = class {
   async runRefinement(lifecycle) {
     const refinement = this.reporter.refinement;
     if (!refinement || !lifecycle.activityId || !lifecycle.markerMatch) {
-      this.deleteLifecycle(lifecycle);
+      this.closeRefinement(lifecycle);
       return;
     }
     const maxAttempts = Math.min(
@@ -754,12 +877,12 @@ var ActivityRefinementCoordinator = class {
       )
     );
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-      if (!this.isActive(lifecycle)) {
+      if (!this.isRefinementActive(lifecycle)) {
         return;
       }
-      const now = refinement.now?.() ?? Date.now();
+      const now = this.now();
       if (now > lifecycle.deadline) {
-        this.deleteLifecycle(lifecycle);
+        this.closeRefinement(lifecycle);
         return;
       }
       try {
@@ -777,7 +900,7 @@ var ActivityRefinementCoordinator = class {
         if (!this.isRefinementActive(lifecycle)) {
           return;
         }
-        this.deleteLifecycle(lifecycle);
+        this.closeRefinement(lifecycle);
         if (result.campaign) {
           this.callbacks.emitCampaign(result.campaign);
         }
@@ -807,7 +930,7 @@ var ActivityRefinementCoordinator = class {
           if (!this.isRefinementActive(lifecycle)) {
             return;
           }
-          this.deleteLifecycle(lifecycle);
+          this.closeRefinement(lifecycle);
           this.callbacks.emitError("activity-refinement", policyError);
           return;
         }
@@ -817,35 +940,95 @@ var ActivityRefinementCoordinator = class {
         if (retry) {
           continue;
         }
-        this.deleteLifecycle(lifecycle);
+        this.closeRefinement(lifecycle);
         this.callbacks.emitError("activity-refinement", error);
         return;
       }
     }
   }
-  isActive(lifecycle) {
+  isTransportActive(lifecycle) {
     return this.lifecycles.get(lifecycle.recognitionId) === lifecycle && this.callbacks.isCurrentCapture(lifecycle.captureGeneration);
   }
   isRefinementActive(lifecycle) {
-    if (!this.isActive(lifecycle)) {
+    if (!this.isTransportActive(lifecycle) || lifecycle.refinementClosed) {
       return false;
     }
-    const refinement = this.reporter.refinement;
-    const now = refinement && refinement.now ? refinement.now() : Date.now();
+    const now = this.now();
     if (now > lifecycle.deadline) {
-      this.deleteLifecycle(lifecycle);
+      this.closeRefinement(lifecycle);
       return false;
     }
     return true;
   }
-  deleteLifecycle(lifecycle) {
-    if (lifecycle.timer) {
-      clearTimeout(lifecycle.timer);
-      lifecycle.timer = null;
+  canAcceptMarker(lifecycle) {
+    return lifecycle.markerCode === null && this.isRefinementActive(lifecycle);
+  }
+  claimMarker(lifecycle, marker) {
+    const markerCode = marker.code;
+    if (typeof markerCode !== "string" || markerCode.length === 0 || !this.canAcceptMarker(lifecycle)) {
+      return;
     }
-    if (this.lifecycles.get(lifecycle.recognitionId) === lifecycle) {
-      this.lifecycles.delete(lifecycle.recognitionId);
+    lifecycle.markerCode = markerCode;
+    lifecycle.markerMatch = { ...lifecycle.match, audioMarker: marker };
+    if (lifecycle.activityId) {
+      this.startRefinement(lifecycle);
+    } else if (lifecycle.createSettled) {
+      this.failMissingActivityId(lifecycle);
+    }
+  }
+  isContinuousMatch(lifecycle, match, captureGeneration, now) {
+    return !lifecycle.sealed && this.activeLifecycle === lifecycle && lifecycle.captureGeneration === captureGeneration && lifecycle.match.name === match.name && lifecycle.match.afpType === match.afpType && this.isTransportActive(lifecycle) && now - lifecycle.lastObservedAt <= ACTIVITY_CONTINUITY_GAP_MS;
+  }
+  renewContinuity(lifecycle, now) {
+    lifecycle.lastObservedAt = now;
+    this.scheduleContinuityExpiry(lifecycle);
+  }
+  scheduleContinuityExpiry(lifecycle) {
+    if (lifecycle.continuityTimer) {
+      clearTimeout(lifecycle.continuityTimer);
+    }
+    const remainingMs = lifecycle.lastObservedAt + ACTIVITY_CONTINUITY_GAP_MS - this.now();
+    lifecycle.continuityTimer = setTimeout(() => {
+      lifecycle.continuityTimer = null;
+      if (this.activeLifecycle !== lifecycle || lifecycle.sealed) {
+        return;
+      }
+      const now = this.now();
+      if (now - lifecycle.lastObservedAt <= ACTIVITY_CONTINUITY_GAP_MS) {
+        this.scheduleContinuityExpiry(lifecycle);
+        return;
+      }
+      this.sealLifecycle(lifecycle);
+    }, Math.max(1, remainingMs + 1));
+  }
+  sealLifecycle(lifecycle) {
+    if (lifecycle.sealed) {
+      return;
     }
+    lifecycle.sealed = true;
+    if (lifecycle.continuityTimer) {
+      clearTimeout(lifecycle.continuityTimer);
+      lifecycle.continuityTimer = null;
+    }
+    if (this.activeLifecycle === lifecycle) {
+      this.activeLifecycle = null;
+    }
+    this.removeRequestAssociations(lifecycle);
+    this.maybeDeleteSealed(lifecycle);
+  }
+  closeRefinement(lifecycle) {
+    if (lifecycle.refinementClosed) {
+      return;
+    }
+    lifecycle.refinementClosed = true;
+    if (lifecycle.refinementTimer) {
+      clearTimeout(lifecycle.refinementTimer);
+      lifecycle.refinementTimer = null;
+    }
+    this.removeRequestAssociations(lifecycle);
+    this.maybeDeleteSealed(lifecycle);
+  }
+  removeRequestAssociations(lifecycle) {
     for (const [requestId, requestLifecycle] of this.requestLifecycles) {
       if (requestLifecycle === lifecycle) {
         this.requestLifecycles.delete(requestId);
@@ -853,6 +1036,28 @@ var ActivityRefinementCoordinator = class {
         this.registeredRequests.delete(requestId);
       }
     }
+  }
+  maybeDeleteSealed(lifecycle) {
+    if (lifecycle.sealed && lifecycle.createSettled && !lifecycle.refinementInFlight) {
+      this.deleteLifecycle(lifecycle);
+    }
+  }
+  now() {
+    return this.reporter.refinement && this.reporter.refinement.now ? this.reporter.refinement.now() : Date.now();
+  }
+  deleteLifecycle(lifecycle) {
+    if (lifecycle.refinementTimer) {
+      clearTimeout(lifecycle.refinementTimer);
+      lifecycle.refinementTimer = null;
+    }
+    if (lifecycle.continuityTimer) {
+      clearTimeout(lifecycle.continuityTimer);
+      lifecycle.continuityTimer = null;
+    }
+    if (this.lifecycles.get(lifecycle.recognitionId) === lifecycle) {
+      this.lifecycles.delete(lifecycle.recognitionId);
+    }
+    this.removeRequestAssociations(lifecycle);
     if (this.activeLifecycle === lifecycle) {
       this.activeLifecycle = null;
     }
@@ -1576,6 +1781,8 @@ function createLocalStorageSessionManager(options) {
 
 // src/audio-recognizer.ts
 var DEFAULT_SORI_API_ENDPOINT = "https://console.soriapi.com/api";
+var MAX_API_ENDPOINT_LENGTH = 32 * 1024;
+var ASCII_SLASH_CODE_UNIT = 47;
 var FORWARDED_EVENTS = [
   "ready",
   "microphoneready",
@@ -1603,12 +1810,24 @@ function ensureNonEmptyString(name, value) {
   }
   return value;
 }
-function normalizeEndpointPrefix(endpoint) {
-  const value = String(endpoint).replace(/\/+$/, "");
+function stringifyAndValidateApiEndpoint(endpoint) {
+  const value = String(endpoint);
+  if (value.length > MAX_API_ENDPOINT_LENGTH) {
+    throw new Error(
+      `AudioRecognizer apiEndpoint exceeds maximum length of ${MAX_API_ENDPOINT_LENGTH} UTF-16 code units`
+    );
+  }
   return value;
 }
+function normalizeValidatedEndpointPrefix(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === ASCII_SLASH_CODE_UNIT) {
+    end -= 1;
+  }
+  return end === value.length ? value : value.slice(0, end);
+}
 function joinEndpoint(prefix, path) {
-  return `${normalizeEndpointPrefix(prefix)}${path.startsWith("/") ? path : `/${path}`}`;
+  return `${prefix}${path.startsWith("/") ? path : `/${path}`}`;
 }
 function createEphemeralKeyResolver(endpoint, fetcher, requestInit) {
   return async () => {
@@ -1636,8 +1855,15 @@ function resolveRecognizerOptions(options) {
   const activityReportingDisabled = options.activityReporter === false;
   const customActivityReporter = activityReportingDisabled ? void 0 : options.activityReporter;
   const appId = legacyAuth?.appId ?? options.appId;
-  const authEndpoint = legacyAuth?.endpoint ?? options.authEndpoint ?? joinEndpoint(apiEndpoint, "/auth");
-  const activityEndpoint = activityReportingDisabled ? void 0 : customActivityReporter?.endpoint ?? options.activityEndpoint ?? joinEndpoint(apiEndpoint, "/activity/");
+  const configuredAuthEndpoint = legacyAuth?.endpoint ?? options.authEndpoint;
+  const configuredActivityEndpoint = activityReportingDisabled ? void 0 : customActivityReporter?.endpoint ?? options.activityEndpoint;
+  const derivesAuthEndpoint = configuredAuthEndpoint == null;
+  const derivesActivityEndpoint = !activityReportingDisabled && configuredActivityEndpoint == null;
+  const derivesApiEndpoint = derivesAuthEndpoint || derivesActivityEndpoint;
+  const validatedApiEndpoint = options.apiEndpoint !== void 0 || derivesApiEndpoint ? stringifyAndValidateApiEndpoint(apiEndpoint) : void 0;
+  const normalizedApiEndpoint = derivesApiEndpoint ? normalizeValidatedEndpointPrefix(validatedApiEndpoint) : void 0;
+  const authEndpoint = configuredAuthEndpoint ?? joinEndpoint(normalizedApiEndpoint, "/auth");
+  const activityEndpoint = activityReportingDisabled ? void 0 : configuredActivityEndpoint ?? joinEndpoint(normalizedApiEndpoint, "/activity/");
   const ephemeralKey = legacyAuth?.ephemeralKey ?? options.ephemeralKey ?? options.ephemeraKey ?? (legacyAuth?.ephemeralKeyEndpoint ?? options.ephemeralKeyEndpoint ? createEphemeralKeyResolver(
     legacyAuth?.ephemeralKeyEndpoint ?? options.ephemeralKeyEndpoint,
     legacyAuth?.ephemeralKeyFetch ?? options.ephemeralKeyFetch ?? legacyAuth?.fetch ?? sharedFetch,
@@ -1825,6 +2051,7 @@ export {
   AudioRecognizer,
   DEFAULT_BROWSER_AUDIOPACK_VERSION,
   DEFAULT_SORI_API_ENDPOINT,
+  MAX_API_ENDPOINT_LENGTH,
   MicrophoneMatcher,
   authenticateAndLoadAudioPack,
   createLocalStorageAudioPackStore,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sorisdk/web-audio",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Web SDK for browser-based audio recognition with SORI API",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,8 +34,8 @@
   "license": "SEE LICENSE IN LICENSE.md",
   "homepage": "https://docs.soriapi.com/ko/integration/web",
   "dependencies": {
-    "@sorisdk/afpgen": "0.6.5",
-    "@sorisdk/matcher": "0.6.5"
+    "@sorisdk/matcher": "0.6.7",
+    "@sorisdk/afpgen": "0.6.7"
   },
   "devDependencies": {
     "tsup": "^8.5.1",