@sorisdk/web-audio 0.6.5 → 0.6.8

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
       );
     }
   };
@@ -313,6 +354,12 @@ var FingerprintMatchWindow = class {
   }
 };
 
+// src/detected-match.ts
+function toPublicDetectedMatch(match) {
+  const { audioMarker: _internalAudioMarker, ...publicMatch } = match;
+  return publicMatch;
+}
+
 // src/activity.ts
 var ActivityReportingError = class extends Error {
   status;
@@ -357,6 +404,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;
@@ -368,13 +423,18 @@ function validateRequestPayload(payload) {
 }
 async function resolveCreateRequestPayload(reporter, match) {
   const payload = validateRequestPayload(
-    reporter.mapMatchToRequest ? await reporter.mapMatchToRequest(match) : defaultRequestPayload(match)
+    reporter.mapMatchToRequest ? await reporter.mapMatchToRequest(toPublicDetectedMatch(match)) : defaultRequestPayload(match)
   );
   if (!payload) {
     return null;
   }
-  const { refinement_expected: _ignored, ...requestPayload } = payload;
-  return requestPayload;
+  const {
+    position: _ignoredPosition,
+    recognized_at: _ignoredRecognizedAt,
+    refinement_expected: _ignoredRefinementExpected,
+    ...requestPayload
+  } = payload;
+  return withInternalAudioMarker(requestPayload, match);
 }
 async function resolveRefineRequestPayload(reporter, match, context) {
   const refinement = reporter.refinement;
@@ -382,13 +442,31 @@ async function resolveRefineRequestPayload(reporter, match, context) {
     return null;
   }
   const payload = validateRequestPayload(
-    refinement.mapMatchToRequest ? await refinement.mapMatchToRequest(match, context) : reporter.mapMatchToRequest ? await reporter.mapMatchToRequest(match) : defaultRequestPayload(match)
+    refinement.mapMatchToRequest ? await refinement.mapMatchToRequest(toPublicDetectedMatch(match), context) : reporter.mapMatchToRequest ? await reporter.mapMatchToRequest(toPublicDetectedMatch(match)) : defaultRequestPayload(match)
   );
   if (!payload) {
     return null;
   }
-  const { refinement_expected: _ignored, ...requestPayload } = payload;
-  return requestPayload;
+  const {
+    position: _ignoredPosition,
+    recognized_at: _ignoredRecognizedAt,
+    refinement_expected: _ignoredRefinementExpected,
+    ...requestPayload
+  } = payload;
+  return withInternalAudioMarker(requestPayload, match);
+}
+function withInternalAudioMarker(payload, match) {
+  const marker = match.audioMarker?.code;
+  if (typeof marker !== "string" || marker.length === 0) {
+    return payload;
+  }
+  return {
+    ...payload,
+    trait: {
+      ...payload.trait,
+      marker
+    }
+  };
 }
 function defaultCampaignMapper(payload, match) {
   const campaign = payload.campaign;
@@ -396,12 +474,23 @@ function defaultCampaignMapper(payload, match) {
     return null;
   }
   return {
-    match,
+    match: toPublicDetectedMatch(match),
     campaign,
     activityId: typeof payload.activity_id === "string" ? payload.activity_id : null,
     raw: payload
   };
 }
+function resolvedAudioMarker(payload) {
+  if (!payload) {
+    return null;
+  }
+  const id = payload.audio_marker_id;
+  const name = payload.audio_marker_name;
+  if (typeof id !== "string" || id.trim().length === 0 || typeof name !== "string" || name.trim().length === 0) {
+    return null;
+  }
+  return Object.freeze({ id, name });
+}
 async function resolveHeaders(reporter, refinement = false) {
   const refinementHeaders = reporter.refinement && reporter.refinement.headers;
   const baseHeaders = reporter.headers ? typeof reporter.headers === "function" ? await reporter.headers() : reporter.headers : void 0;
@@ -457,10 +546,31 @@ function responseActivityId(data, campaign) {
 }
 async function mapCreateResponse(reporter, data, match, refinementExpected) {
   if (!data) {
-    return { activityId: null, campaign: null, refinementExpected };
+    return {
+      activityId: null,
+      audioMarker: null,
+      campaign: null,
+      creationAttempted: true,
+      refinementExpected
+    };
+  }
+  const audioMarker = resolvedAudioMarker(data);
+  let campaign;
+  let campaignMappingFailure;
+  try {
+    campaign = reporter.mapResponseToCampaign ? await reporter.mapResponseToCampaign(data, toPublicDetectedMatch(match)) : defaultCampaignMapper(data, match);
+  } catch (error) {
+    campaign = null;
+    campaignMappingFailure = { error };
   }
-  const campaign = reporter.mapResponseToCampaign ? await reporter.mapResponseToCampaign(data, match) : defaultCampaignMapper(data, match);
-  return { activityId: responseActivityId(data, campaign), campaign, refinementExpected };
+  return {
+    activityId: responseActivityId(data, campaign),
+    audioMarker,
+    campaign,
+    creationAttempted: true,
+    refinementExpected,
+    ...campaignMappingFailure ? { campaignMappingFailure } : {}
+  };
 }
 async function resolveRefinementEndpoint(reporter, activityId) {
   const configured = reporter.refinement && reporter.refinement.endpoint;
@@ -470,10 +580,16 @@ 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,
+      audioMarker: null,
+      campaign: null,
+      creationAttempted: false,
+      refinementExpected: false
+    };
   }
   const headers = await resolveHeaders(reporter);
   const actualMarker = match.audioMarker?.code;
@@ -481,7 +597,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,
@@ -497,11 +618,11 @@ async function createMatchedMaterialActivity(reporter, match, refinementExpected
 async function refineMatchedMaterialActivity(reporter, match, context, isActive = () => true) {
   const refinement = reporter.refinement;
   if (!refinement) {
-    return { activityId: null, campaign: null };
+    return { activityId: null, audioMarker: null, campaign: null };
   }
   const payload = await resolveRefineRequestPayload(reporter, match, context);
   if (!payload) {
-    return { activityId: null, campaign: null };
+    return { activityId: null, audioMarker: null, campaign: null };
   }
   const endpoint = await resolveRefinementEndpoint(reporter, context.activityId);
   const headers = await resolveHeaders(reporter, true);
@@ -517,8 +638,16 @@ async function refineMatchedMaterialActivity(reporter, match, context, isActive
   if (!data) {
     throw new ActivityReportingError("Activity refine failed: empty response", response.status);
   }
-  const mappedCampaign = refinement.mapResponseToCampaign ? await refinement.mapResponseToCampaign(data, match, context) : reporter.mapResponseToCampaign ? await reporter.mapResponseToCampaign(data, match) : defaultCampaignMapper(data, match);
-  const activityId = responseActivityId(data, mappedCampaign);
+  const audioMarker = resolvedAudioMarker(data);
+  let mappedCampaign;
+  let campaignMappingFailure;
+  try {
+    mappedCampaign = refinement.mapResponseToCampaign ? await refinement.mapResponseToCampaign(data, toPublicDetectedMatch(match), context) : reporter.mapResponseToCampaign ? await reporter.mapResponseToCampaign(data, toPublicDetectedMatch(match)) : defaultCampaignMapper(data, match);
+  } catch (error) {
+    mappedCampaign = null;
+    campaignMappingFailure = { error };
+  }
+  const activityId = responseActivityId(data, mappedCampaign) ?? (campaignMappingFailure ? context.activityId : null);
   if (activityId !== context.activityId) {
     throw new ActivityReportingError(
       "Activity refine failed: response activity_id does not match the requested activity",
@@ -526,11 +655,17 @@ async function refineMatchedMaterialActivity(reporter, match, context, isActive
     );
   }
   const campaign = mappedCampaign ? { ...mappedCampaign, activityId: context.activityId } : null;
-  return { activityId, campaign };
+  return {
+    activityId,
+    audioMarker,
+    campaign,
+    ...campaignMappingFailure ? { campaignMappingFailure } : {}
+  };
 }
 
 // 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) {
@@ -554,6 +689,7 @@ var ActivityRefinementCoordinator = class {
   registeredRequests = /* @__PURE__ */ new Set();
   settledRequests = /* @__PURE__ */ new Set();
   activeLifecycle = null;
+  activeMarkerSegment = null;
   generation = 0;
   constructor(reporter, callbacks) {
     this.reporter = reporter;
@@ -566,9 +702,7 @@ 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 markerSegment = this.resolveMarkerSegment(match, captureGeneration);
     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,53 +712,97 @@ 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,
+        markerSegment,
+        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.audioMarker && this.callbacks.isCurrentCapture(captureGeneration)) {
+          this.emitResolvedAudioMarker(markerSegment, result.audioMarker);
+        }
         if (coordinatorGeneration === this.generation && result.campaign && this.callbacks.isCurrentCapture(captureGeneration)) {
           this.callbacks.emitCampaign(result.campaign);
         }
+        if (coordinatorGeneration === this.generation && result.campaignMappingFailure && this.callbacks.isCurrentCapture(captureGeneration)) {
+          this.callbacks.emitError("activity", result.campaignMappingFailure.error);
+        }
         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 +810,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 +826,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 +858,17 @@ 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);
+    }
+    if (this.activeMarkerSegment?.captureGeneration === captureGeneration) {
+      this.activeMarkerSegment = null;
     }
   }
   refine(recognitionId, marker, captureGeneration) {
@@ -696,24 +887,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();
@@ -722,19 +908,24 @@ var ActivityRefinementCoordinator = class {
     this.registeredRequests.clear();
     this.settledRequests.clear();
     this.activeLifecycle = null;
+    this.activeMarkerSegment = 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 +934,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 +945,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,10 +968,19 @@ var ActivityRefinementCoordinator = class {
         if (!this.isRefinementActive(lifecycle)) {
           return;
         }
-        this.deleteLifecycle(lifecycle);
+        this.closeRefinement(lifecycle);
+        if (result.audioMarker) {
+          this.emitResolvedAudioMarker(lifecycle.markerSegment, result.audioMarker);
+        }
         if (result.campaign) {
           this.callbacks.emitCampaign(result.campaign);
         }
+        if (result.campaignMappingFailure) {
+          this.callbacks.emitError(
+            "activity-refinement",
+            result.campaignMappingFailure.error
+          );
+        }
         return;
       } catch (caught) {
         if (caught instanceof ActivityReportingCancelledError) {
@@ -807,7 +1007,7 @@ var ActivityRefinementCoordinator = class {
           if (!this.isRefinementActive(lifecycle)) {
             return;
           }
-          this.deleteLifecycle(lifecycle);
+          this.closeRefinement(lifecycle);
           this.callbacks.emitError("activity-refinement", policyError);
           return;
         }
@@ -817,35 +1017,119 @@ 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;
+  }
+  resolveMarkerSegment(match, captureGeneration) {
+    const now = this.now();
+    const active = this.activeMarkerSegment;
+    if (active && active.captureGeneration === captureGeneration && active.materialName === match.name && active.afpType === match.afpType && now - active.lastObservedAt <= ACTIVITY_CONTINUITY_GAP_MS) {
+      active.lastObservedAt = now;
+      return active;
+    }
+    const segment = {
+      captureGeneration,
+      materialName: match.name,
+      afpType: match.afpType,
+      lastObservedAt: now,
+      emitted: false
+    };
+    this.activeMarkerSegment = segment;
+    return segment;
+  }
+  emitResolvedAudioMarker(segment, marker) {
+    if (segment.emitted) {
+      return;
+    }
+    segment.emitted = true;
+    this.callbacks.emitAudioMarker(Object.freeze({ marker }));
+  }
+  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 +1137,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;
     }
@@ -1020,7 +1326,6 @@ var MicrophoneMatcher = class {
   markerPcmBuffer = new Float32Array(0);
   resampleBuffer = new Float32Array(0);
   resampleOffset = 0;
-  latestAudioMarker = null;
   latestAudioMarkerDetection = null;
   audioMarkerRequestId = 0;
   activityRecognitionId = 0;
@@ -1047,6 +1352,7 @@ var MicrophoneMatcher = class {
     this.packSource = options.packSource;
     this.activityRefinement = options.activityReporter ? new ActivityRefinementCoordinator(options.activityReporter, {
       isCurrentCapture: (captureGeneration) => captureGeneration === this.captureGeneration && this.running,
+      emitAudioMarker: (event) => this.events.emit("audiomarker", event),
       emitCampaign: (campaign) => this.events.emit("campaign", campaign),
       emitError: (phase, error) => emitError(this.events, phase, error)
     }) : null;
@@ -1316,7 +1622,7 @@ var MicrophoneMatcher = class {
           return;
         }
         if (matchedBest) {
-          this.events.emit("match", { best: matchedBest });
+          this.events.emit("match", { best: toPublicDetectedMatch(matchedBest) });
           this.activityRecognitionId += 1;
           this.reportCampaign(
             this.activityRecognitionId,
@@ -1348,7 +1654,6 @@ var MicrophoneMatcher = class {
     this.markerPcmBuffer = new Float32Array(0);
     this.resampleBuffer = new Float32Array(0);
     this.resampleOffset = 0;
-    this.latestAudioMarker = null;
     this.latestAudioMarkerDetection = null;
     this.audioMarkerRequestId += 1;
     this.activityRefinement?.reset();
@@ -1384,7 +1689,6 @@ var MicrophoneMatcher = class {
         return null;
       }
       this.latestAudioMarkerDetection = { requestId, detection };
-      this.emitAudioMarkerIfChanged(detection);
       this.activityRefinement?.refine(requestId, detection, captureGeneration);
       return detection;
     } catch (error) {
@@ -1411,14 +1715,6 @@ var MicrophoneMatcher = class {
       audioMarker: this.latestAudioMarkerDetection.detection
     };
   }
-  emitAudioMarkerIfChanged(detection) {
-    const marker = detection.code ?? null;
-    if (marker === this.latestAudioMarker) {
-      return;
-    }
-    this.latestAudioMarker = marker;
-    this.events.emit("audiomarker", { marker, detection });
-  }
   normalizeInputSamples(samples) {
     if (this.audioContext.sampleRate === TARGET_SAMPLE_RATE) {
       return samples;
@@ -1576,6 +1872,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 +1901,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 +1946,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 +2142,7 @@ export {
   AudioRecognizer,
   DEFAULT_BROWSER_AUDIOPACK_VERSION,
   DEFAULT_SORI_API_ENDPOINT,
+  MAX_API_ENDPOINT_LENGTH,
   MicrophoneMatcher,
   authenticateAndLoadAudioPack,
   createLocalStorageAudioPackStore,