@sorisdk/web-audio 0.1.0

package/dist/index.js

@@ -0,0 +1,1217 @@
+// src/auth-cache.ts
+import {
+  initMatcher
+} from "@sorisdk/matcher";
+var DEFAULT_BROWSER_AUDIOPACK_VERSION = "20220401000000";
+function formatUtcVersion(date) {
+  const year = date.getUTCFullYear().toString().padStart(4, "0");
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  const hours = String(date.getUTCHours()).padStart(2, "0");
+  const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+  const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+  return `${year}${month}${day}${hours}${minutes}${seconds}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isAudioPackState(value) {
+  return isRecord(value) && typeof value.version === "string" && value.version.length > 0 && typeof value.packUrl === "string" && value.packUrl.length > 0;
+}
+function resolveStorage(storage) {
+  if (storage) {
+    return storage;
+  }
+  if (typeof globalThis.localStorage === "undefined") {
+    throw new Error("localStorage is not available in this environment");
+  }
+  return globalThis.localStorage;
+}
+function createLocalStorageAudioPackStore(options) {
+  const storage = resolveStorage(options.storage);
+  const { key } = options;
+  return {
+    load() {
+      const raw = storage.getItem(key);
+      if (!raw) {
+        return null;
+      }
+      try {
+        const parsed = JSON.parse(raw);
+        if (isAudioPackState(parsed)) {
+          return parsed;
+        }
+      } catch {
+      }
+      storage.removeItem(key);
+      return null;
+    },
+    save(state) {
+      storage.setItem(key, JSON.stringify(state));
+    },
+    clear() {
+      storage.removeItem(key);
+    }
+  };
+}
+function ensureAuthResult(result) {
+  if (!result) {
+    throw new Error("Expected auth result from initMatcher({ auth })");
+  }
+  return result;
+}
+async function authenticateAndLoadAudioPack(options) {
+  const cachedState = await options.store.load();
+  const requestedVersion = cachedState?.version ?? options.initialVersion ?? DEFAULT_BROWSER_AUDIOPACK_VERSION;
+  const authResult = ensureAuthResult(
+    await initMatcher({
+      ...options.matcherInit,
+      auth: {
+        ...options.auth,
+        version: requestedVersion
+      }
+    })
+  );
+  const canReuseCachedPack = authResult.forceUpdate === false && authResult.updated === 0 && cachedState?.packUrl !== void 0;
+  const loadedPackUrl = canReuseCachedPack ? cachedState.packUrl : authResult.packUrl;
+  if (!loadedPackUrl) {
+    throw new Error("Auth response did not include packUrl and no cached packUrl is available");
+  }
+  await options.loader.loadPack(loadedPackUrl);
+  const persistedVersion = canReuseCachedPack ? requestedVersion : formatUtcVersion(/* @__PURE__ */ new Date());
+  await options.store.save({
+    version: persistedVersion,
+    packUrl: loadedPackUrl
+  });
+  return {
+    ...authResult,
+    requestedVersion,
+    loadedPackUrl,
+    persistedVersion,
+    source: canReuseCachedPack ? "cache" : "network",
+    cachedState
+  };
+}
+
+// src/events.ts
+var TypedEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(eventName, listener) {
+    const bucket = this.listeners.get(eventName) ?? /* @__PURE__ */ new Set();
+    bucket.add(listener);
+    this.listeners.set(eventName, bucket);
+    return this;
+  }
+  off(eventName, listener) {
+    const bucket = this.listeners.get(eventName);
+    if (!bucket) {
+      return this;
+    }
+    bucket.delete(listener);
+    if (bucket.size === 0) {
+      this.listeners.delete(eventName);
+    }
+    return this;
+  }
+  once(eventName, listener) {
+    const wrapped = (payload) => {
+      this.off(eventName, wrapped);
+      listener(payload);
+    };
+    return this.on(eventName, wrapped);
+  }
+  emit(eventName, payload) {
+    const bucket = this.listeners.get(eventName);
+    if (!bucket) {
+      return;
+    }
+    for (const listener of bucket) {
+      listener(payload);
+    }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/microphone-matcher.ts
+import { createExtractor, initAfpgen } from "@sorisdk/afpgen";
+import {
+  MatcherSession,
+  initMatcher as initMatcher2
+} from "@sorisdk/matcher";
+
+// src/internal.ts
+import { AudioFingerprintType } from "@sorisdk/matcher";
+var TARGET_SAMPLE_RATE = 16e3;
+var DEFAULT_RUNTIME_CONFIG = {
+  captureBufferSize: 4096,
+  matchWindowMs: 3250,
+  matchStrideMs: 1e3,
+  afpgenConfig: {
+    hopSize: 1e3,
+    frameSize: 2,
+    radius: 4,
+    levelCount: 2
+  },
+  matchConfig: void 0,
+  initialFingerprintType: AudioFingerprintType.Livestream
+};
+function createBrowserAudioContext() {
+  const AudioContextConstructor = globalThis.AudioContext;
+  if (typeof AudioContextConstructor !== "function") {
+    throw new Error("AudioContext is not available in this environment");
+  }
+  try {
+    return new AudioContextConstructor({
+      sampleRate: TARGET_SAMPLE_RATE,
+      latencyHint: "interactive"
+    });
+  } catch {
+    return new AudioContextConstructor();
+  }
+}
+function getBrowserMediaDevices() {
+  const mediaDevices = globalThis.navigator?.mediaDevices;
+  if (!mediaDevices?.getUserMedia) {
+    throw new Error("MediaDevices.getUserMedia is not available in this environment");
+  }
+  return mediaDevices;
+}
+
+// src/match-window.ts
+var cachedBindings = null;
+var initPromise = null;
+var testInjectedWasmModule = null;
+function getCallable(obj, names) {
+  for (const name of names) {
+    const candidate = obj[name];
+    if (typeof candidate === "function") {
+      return candidate;
+    }
+  }
+  return null;
+}
+var defaultLoader = async () => {
+  const generatedModuleUrl = new URL("./generated/window.js", import.meta.url);
+  return import(
+    /* @vite-ignore */
+    generatedModuleUrl.href
+  );
+};
+var WrappedFingerprintMatchWindow = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  appendFingerprint(bytes) {
+    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);
+  }
+  hasReadyQuery() {
+    const fn = getCallable(this.inner, ["hasReadyQuery", "has_ready_query"]);
+    if (!fn) {
+      throw new Error("web-audio wasm window is missing hasReadyQuery");
+    }
+    return Boolean(fn.call(this.inner));
+  }
+  takeReadyQuery() {
+    const fn = getCallable(this.inner, ["takeReadyQuery", "take_ready_query"]);
+    if (!fn) {
+      throw new Error("web-audio wasm window is missing takeReadyQuery");
+    }
+    const result = fn.call(this.inner);
+    return result instanceof Uint8Array ? result : result ? new Uint8Array(result) : null;
+  }
+  reset() {
+    const fn = getCallable(this.inner, ["reset"]);
+    if (!fn) {
+      throw new Error("web-audio wasm window is missing reset");
+    }
+    fn.call(this.inner);
+  }
+  destroy() {
+    const fn = getCallable(this.inner, ["destroy", "free"]);
+    if (fn) {
+      fn.call(this.inner);
+    }
+  }
+};
+function createBindingsFromModule(moduleLike) {
+  if (!moduleLike || typeof moduleLike !== "object") {
+    throw new Error("Invalid web-audio wasm module");
+  }
+  const mod = moduleLike;
+  const initFn = getCallable(mod, ["initWebAudioWindow"]) ?? (typeof mod.default === "function" ? mod.default.bind(mod) : null);
+  const WindowCtor = mod.WasmFingerprintMatchWindow ?? mod.FingerprintMatchWindow;
+  if (!WindowCtor) {
+    throw new Error("web-audio wasm module is missing window export");
+  }
+  return {
+    async init(initInput) {
+      if (initFn) {
+        await Promise.resolve(initFn(initInput));
+      }
+    },
+    createWindow(options) {
+      return new WrappedFingerprintMatchWindow(
+        new WindowCtor(
+          options.sampleRate,
+          options.afpgenConfig,
+          options.matchWindowMs,
+          options.matchStrideMs
+        )
+      );
+    }
+  };
+}
+async function initMatchWindowWasm(options) {
+  if (cachedBindings) {
+    return;
+  }
+  if (!initPromise) {
+    initPromise = (async () => {
+      try {
+        const loader = options?.loader ?? defaultLoader;
+        const moduleLike = testInjectedWasmModule ?? await loader();
+        const bindings = createBindingsFromModule(moduleLike);
+        await bindings.init(options?.wasmInitInput);
+        cachedBindings = bindings;
+        return bindings;
+      } catch (error) {
+        initPromise = null;
+        cachedBindings = null;
+        throw error;
+      }
+    })();
+  }
+  await initPromise;
+}
+var FingerprintMatchWindow = class {
+  inner;
+  constructor(options) {
+    if (!cachedBindings) {
+      throw new Error("web-audio wasm window is not initialized");
+    }
+    this.inner = cachedBindings.createWindow(options);
+  }
+  appendFingerprint(bytes) {
+    this.inner.appendFingerprint(bytes);
+  }
+  hasReadyQuery() {
+    return this.inner.hasReadyQuery();
+  }
+  consumeReadyQuery() {
+    return this.inner.takeReadyQuery();
+  }
+  reset() {
+    this.inner.reset();
+  }
+  destroy() {
+    this.inner.destroy?.();
+  }
+};
+
+// src/activity.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function resolveFetch(fetcher) {
+  if (fetcher) {
+    return fetcher;
+  }
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error("fetch is not available in this environment");
+  }
+  return globalThis.fetch.bind(globalThis);
+}
+async function resolveToken(token) {
+  const resolved = typeof token === "function" ? await token() : token;
+  if (typeof resolved !== "string" || resolved.length === 0) {
+    throw new Error("Activity reporter token must resolve to a non-empty string");
+  }
+  return resolved;
+}
+async function resolveRequestPayload(reporter, match) {
+  const payload = reporter.mapMatchToRequest ? await reporter.mapMatchToRequest(match) : {
+    type: "material",
+    material_id: match.name
+  };
+  if (payload === null) {
+    return null;
+  }
+  if (payload.type !== "material" || typeof payload.material_id !== "string" || payload.material_id.length === 0) {
+    throw new Error("Activity reporter payload must include a non-empty material_id");
+  }
+  return payload;
+}
+function defaultCampaignMapper(payload, match) {
+  const campaign = payload.campaign;
+  if (!isRecord2(campaign)) {
+    return null;
+  }
+  return {
+    match,
+    campaign,
+    activityId: typeof payload.activity_id === "string" ? payload.activity_id : null,
+    raw: payload
+  };
+}
+async function reportMatchedMaterialActivity(reporter, match) {
+  const payload = await resolveRequestPayload(reporter, match);
+  if (!payload) {
+    return null;
+  }
+  const headers = new Headers(
+    reporter.headers ? typeof reporter.headers === "function" ? await reporter.headers() : reporter.headers : void 0
+  );
+  headers.set("authorization", `Bearer ${await resolveToken(reporter.token)}`);
+  headers.set("content-type", "application/json");
+  const response = await resolveFetch(reporter.fetch)(reporter.endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    throw new Error(`Activity reporting failed: HTTP ${response.status}`);
+  }
+  const responseText = await response.text();
+  if (responseText.trim().length === 0) {
+    return null;
+  }
+  let data;
+  try {
+    data = JSON.parse(responseText);
+  } catch {
+    throw new Error("Activity reporting failed: invalid JSON response");
+  }
+  if (!isRecord2(data)) {
+    throw new Error("Activity reporting failed: expected an object response");
+  }
+  if (reporter.mapResponseToCampaign) {
+    return reporter.mapResponseToCampaign(data, match);
+  }
+  return defaultCampaignMapper(data, match);
+}
+
+// src/microphone.ts
+var WORKLET_PROCESSOR_NAME = "sori-microphone-capture";
+var audioWorkletModuleLoads = /* @__PURE__ */ new WeakMap();
+function createProcessorModuleSource() {
+  return `
+class SoriMicrophoneCaptureProcessor extends AudioWorkletProcessor {
+  process(inputs) {
+    const input = inputs[0];
+    const channel = input && input[0];
+    if (channel && channel.length > 0) {
+      this.port.postMessage(channel.slice(0));
+    }
+    return true;
+  }
+}
+registerProcessor("${WORKLET_PROCESSOR_NAME}", SoriMicrophoneCaptureProcessor);
+`;
+}
+async function createAudioWorkletGraph({
+  audioContext,
+  stream
+}) {
+  await ensureAudioWorkletModule(audioContext);
+  const source = audioContext.createMediaStreamSource(stream);
+  const processor = new AudioWorkletNode(audioContext, WORKLET_PROCESSOR_NAME);
+  const muteNode = audioContext.createGain();
+  muteNode.gain.value = 0;
+  return {
+    async start(onSamples) {
+      processor.port.onmessage = (event) => {
+        onSamples(new Float32Array(event.data));
+      };
+      source.connect(processor);
+      processor.connect(muteNode);
+      muteNode.connect(audioContext.destination);
+    },
+    async stop() {
+      processor.port.onmessage = null;
+      source.disconnect();
+      processor.disconnect();
+      muteNode.disconnect();
+    }
+  };
+}
+async function ensureAudioWorkletModule(audioContext) {
+  const existingLoad = audioWorkletModuleLoads.get(audioContext);
+  if (existingLoad) {
+    await existingLoad;
+    return;
+  }
+  const moduleSource = createProcessorModuleSource();
+  const moduleUrl = URL.createObjectURL(
+    new Blob([moduleSource], { type: "application/javascript" })
+  );
+  const loadPromise = (async () => {
+    try {
+      await audioContext.audioWorklet.addModule(moduleUrl);
+    } finally {
+      URL.revokeObjectURL(moduleUrl);
+    }
+  })();
+  audioWorkletModuleLoads.set(audioContext, loadPromise);
+  try {
+    await loadPromise;
+  } catch (error) {
+    if (audioWorkletModuleLoads.get(audioContext) === loadPromise) {
+      audioWorkletModuleLoads.delete(audioContext);
+    }
+    throw error;
+  }
+}
+async function createScriptProcessorGraph({
+  audioContext,
+  stream,
+  bufferSize
+}) {
+  const source = audioContext.createMediaStreamSource(stream);
+  const processor = audioContext.createScriptProcessor(bufferSize, 1, 1);
+  const muteNode = audioContext.createGain();
+  muteNode.gain.value = 0;
+  return {
+    async start(onSamples) {
+      processor.onaudioprocess = (event) => {
+        const channel = event.inputBuffer.getChannelData(0);
+        onSamples(new Float32Array(channel));
+      };
+      source.connect(processor);
+      processor.connect(muteNode);
+      muteNode.connect(audioContext.destination);
+    },
+    async stop() {
+      processor.onaudioprocess = null;
+      source.disconnect();
+      processor.disconnect();
+      muteNode.disconnect();
+    }
+  };
+}
+async function requestMicrophoneStream(mediaDevices, mediaConstraints) {
+  if (!mediaDevices?.getUserMedia) {
+    throw new Error("MediaDevices.getUserMedia is not available");
+  }
+  return mediaDevices.getUserMedia(
+    mediaConstraints ?? {
+      audio: {
+        channelCount: 1,
+        sampleRate: 16e3,
+        echoCancellation: false,
+        noiseSuppression: false,
+        autoGainControl: false
+      },
+      video: false
+    }
+  );
+}
+var defaultAudioGraphFactory = async (options) => {
+  if ("audioWorklet" in options.audioContext && typeof AudioWorkletNode !== "undefined") {
+    return createAudioWorkletGraph(options);
+  }
+  return createScriptProcessorGraph(options);
+};
+
+// src/microphone-matcher.ts
+function normalizeError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function emitError(emitter, phase, error) {
+  const normalized = normalizeError(error);
+  emitter.emit("error", { phase, error: normalized });
+  return normalized;
+}
+function emitAndThrow(emitter, phase, error) {
+  throw emitError(emitter, phase, error);
+}
+var MicrophoneMatcher = class {
+  events = new TypedEventEmitter();
+  matcherSession;
+  mediaDevices;
+  audioContext;
+  stopTracksOnStop;
+  suspendContextOnStop;
+  audioGraphFactory;
+  packSource;
+  options;
+  extractor = null;
+  graphController = null;
+  matchWindow = null;
+  stream = null;
+  running = false;
+  destroyed = false;
+  loadedPack = false;
+  matchInFlight = false;
+  pendingMatch = false;
+  captureGeneration = 0;
+  pcmBuffer = new Float32Array(0);
+  resampleBuffer = new Float32Array(0);
+  resampleOffset = 0;
+  hopSize = 0;
+  diagnostics = {
+    sampleCallbacks: 0,
+    inputSamples: 0,
+    normalizedSamples: 0,
+    processedChunks: 0,
+    fingerprints: 0,
+    readyQueries: 0,
+    matchRequests: 0
+  };
+  constructor(options) {
+    this.options = options;
+    this.matcherSession = new MatcherSession(options.wasm?.matcher);
+    this.mediaDevices = getBrowserMediaDevices();
+    this.audioContext = createBrowserAudioContext();
+    this.stopTracksOnStop = options.stopTracksOnStop ?? true;
+    this.suspendContextOnStop = options.suspendContextOnStop ?? true;
+    this.audioGraphFactory = defaultAudioGraphFactory;
+    this.packSource = options.packSource;
+  }
+  on(eventName, listener) {
+    this.events.on(eventName, listener);
+    return this;
+  }
+  off(eventName, listener) {
+    this.events.off(eventName, listener);
+    return this;
+  }
+  once(eventName, listener) {
+    this.events.once(eventName, listener);
+    return this;
+  }
+  async prepare() {
+    await this.prepareInternal(true);
+  }
+  async loadPack(source) {
+    try {
+      await this.prepareInternal(source === void 0);
+      const target = source ?? this.packSource;
+      if (target === void 0) {
+        throw new Error("No pack source provided");
+      }
+      await this.matcherSession.loadPack(target);
+      this.loadedPack = true;
+    } catch (error) {
+      emitAndThrow(this.events, "loadPack", error);
+    }
+  }
+  async prepareInternal(loadImplicitPack) {
+    try {
+      this.ensureNotDestroyed();
+      await initAfpgen(this.options.wasm?.afpgen);
+      await initMatcher2(this.options.wasm?.matcher);
+      await initMatchWindowWasm(this.options.wasm?.matchWindow);
+      await this.matcherSession.ready();
+      if (loadImplicitPack && !this.loadedPack && this.packSource !== void 0) {
+        await this.matcherSession.loadPack(this.packSource);
+        this.loadedPack = true;
+      }
+      if (!this.extractor) {
+        const extractor = await createExtractor({
+          sampleRate: TARGET_SAMPLE_RATE,
+          config: DEFAULT_RUNTIME_CONFIG.afpgenConfig
+        });
+        this.extractor = extractor;
+        this.hopSize = DEFAULT_RUNTIME_CONFIG.afpgenConfig.hopSize ?? 1e3;
+        this.matchWindow = new FingerprintMatchWindow({
+          sampleRate: TARGET_SAMPLE_RATE,
+          afpgenConfig: DEFAULT_RUNTIME_CONFIG.afpgenConfig,
+          matchWindowMs: DEFAULT_RUNTIME_CONFIG.matchWindowMs,
+          matchStrideMs: DEFAULT_RUNTIME_CONFIG.matchStrideMs
+        });
+      }
+      this.events.emit("ready", {
+        sampleRate: this.audioContext.sampleRate
+      });
+    } catch (error) {
+      emitAndThrow(this.events, "prepare", error);
+    }
+  }
+  async addEntry(name, fingerprint, afpType = DEFAULT_RUNTIME_CONFIG.initialFingerprintType) {
+    try {
+      this.ensureNotDestroyed();
+      await this.prepare();
+      await this.matcherSession.addEntry(name, afpType, fingerprint);
+    } catch (error) {
+      emitAndThrow(this.events, "addEntry", error);
+    }
+  }
+  async addOrReplace(name, fingerprint, afpType = DEFAULT_RUNTIME_CONFIG.initialFingerprintType) {
+    try {
+      this.ensureNotDestroyed();
+      await this.prepare();
+      await this.matcherSession.addOrReplace(name, afpType, fingerprint);
+    } catch (error) {
+      emitAndThrow(this.events, "addOrReplace", error);
+    }
+  }
+  async clear() {
+    try {
+      this.ensureNotDestroyed();
+      await this.prepare();
+      this.matchWindowOrThrow().reset();
+      await this.matcherSession.clear();
+    } catch (error) {
+      emitAndThrow(this.events, "clear", error);
+    }
+  }
+  async start() {
+    try {
+      this.ensureNotDestroyed();
+      if (this.running) {
+        return;
+      }
+      await this.prepare();
+      if (this.audioContext.state === "suspended") {
+        await this.audioContext.resume();
+      }
+      const stream = await requestMicrophoneStream(this.mediaDevices, this.options.mediaConstraints);
+      this.stream = stream;
+      this.events.emit("microphoneready", {
+        stream,
+        trackCount: stream.getTracks().length
+      });
+      this.graphController = await this.audioGraphFactory({
+        audioContext: this.audioContext,
+        stream,
+        bufferSize: DEFAULT_RUNTIME_CONFIG.captureBufferSize
+      });
+      this.running = true;
+      this.resetDiagnostics();
+      await this.graphController.start((samples) => {
+        void this.handleAudioSamples(samples);
+      });
+      this.events.emit("start", {});
+    } catch (error) {
+      await this.cleanupAfterStartFailure();
+      emitAndThrow(this.events, "start", error);
+    }
+  }
+  async stop() {
+    try {
+      if (!this.running) {
+        return;
+      }
+      this.running = false;
+      await this.graphController?.stop();
+      this.graphController = null;
+      await this.resetCaptureState();
+      if (this.stopTracksOnStop) {
+        this.stream?.getTracks().forEach((track) => track.stop());
+      }
+      this.stream = null;
+      if (this.suspendContextOnStop && this.audioContext.state === "running") {
+        await this.audioContext.suspend();
+      }
+      this.events.emit("stop", {});
+    } catch (error) {
+      emitAndThrow(this.events, "stop", error);
+    }
+  }
+  async destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    try {
+      await this.stop();
+      await this.audioContext.close();
+      this.matchWindow?.destroy();
+      this.matchWindow = null;
+      this.matcherSession.destroy();
+      this.destroyed = true;
+      this.events.emit("destroy", {});
+      this.events.clear();
+    } catch (error) {
+      emitAndThrow(this.events, "destroy", error);
+    }
+  }
+  getDiagnostics() {
+    return { ...this.diagnostics };
+  }
+  async handleAudioSamples(samples) {
+    if (!this.running || !this.extractor) {
+      return;
+    }
+    const captureGeneration = this.captureGeneration;
+    this.diagnostics.sampleCallbacks += 1;
+    this.diagnostics.inputSamples += samples.length;
+    const normalizedSamples = this.normalizeInputSamples(samples);
+    if (normalizedSamples.length === 0) {
+      return;
+    }
+    this.diagnostics.normalizedSamples += normalizedSamples.length;
+    this.pcmBuffer = appendFloat32(this.pcmBuffer, normalizedSamples);
+    while (this.pcmBuffer.length >= this.hopSize) {
+      const chunk = this.pcmBuffer.subarray(0, this.hopSize);
+      this.pcmBuffer = this.pcmBuffer.slice(this.hopSize);
+      this.diagnostics.processedChunks += 1;
+      const fingerprint = await this.extractor.processChunk(chunk);
+      if (captureGeneration !== this.captureGeneration || !this.running) {
+        return;
+      }
+      if (fingerprint) {
+        this.diagnostics.fingerprints += 1;
+        this.matchWindowOrThrow().appendFingerprint(fingerprint);
+        this.queueMatch(captureGeneration);
+      }
+    }
+  }
+  queueMatch(captureGeneration) {
+    if (captureGeneration !== this.captureGeneration || !this.running) {
+      return;
+    }
+    if (!this.matchWindowOrThrow().hasReadyQuery()) {
+      return;
+    }
+    if (this.matchInFlight) {
+      this.pendingMatch = true;
+      return;
+    }
+    this.matchInFlight = true;
+    void this.runMatchLoop(captureGeneration);
+  }
+  async runMatchLoop(captureGeneration) {
+    try {
+      do {
+        this.pendingMatch = false;
+        const query = this.matchWindowOrThrow().consumeReadyQuery();
+        if (!query) {
+          continue;
+        }
+        this.diagnostics.readyQueries += 1;
+        let distinctBest = null;
+        let shouldEmitNoMatch = false;
+        const handleMatch = (event) => {
+          if (!event.best) {
+            return;
+          }
+          distinctBest = event.best;
+          shouldEmitNoMatch = false;
+        };
+        const handleNoMatch = () => {
+          distinctBest = null;
+          shouldEmitNoMatch = true;
+        };
+        this.matcherSession.on("match", handleMatch);
+        this.matcherSession.on("nomatch", handleNoMatch);
+        try {
+          this.diagnostics.matchRequests += 1;
+          await this.matcherSession.bestMatch(query, DEFAULT_RUNTIME_CONFIG.matchConfig);
+        } finally {
+          this.matcherSession.off("match", handleMatch);
+          this.matcherSession.off("nomatch", handleNoMatch);
+        }
+        if (captureGeneration !== this.captureGeneration || !this.running) {
+          return;
+        }
+        if (distinctBest) {
+          this.events.emit("match", { best: distinctBest });
+          void this.reportCampaign(distinctBest, captureGeneration);
+        } else if (shouldEmitNoMatch) {
+          this.events.emit("nomatch", {});
+        }
+      } while (this.pendingMatch || this.matchWindowOrThrow().hasReadyQuery());
+    } catch (error) {
+      emitError(this.events, "match", error);
+    } finally {
+      this.matchInFlight = false;
+    }
+  }
+  async resetCaptureState() {
+    this.captureGeneration += 1;
+    this.pendingMatch = false;
+    this.matchInFlight = false;
+    this.pcmBuffer = new Float32Array(0);
+    this.resampleBuffer = new Float32Array(0);
+    this.resampleOffset = 0;
+    this.matchWindowOrThrow().reset();
+    await this.extractor?.reset();
+  }
+  normalizeInputSamples(samples) {
+    if (this.audioContext.sampleRate === TARGET_SAMPLE_RATE) {
+      return samples;
+    }
+    return this.resampleToTargetRate(samples, this.audioContext.sampleRate, TARGET_SAMPLE_RATE);
+  }
+  resampleToTargetRate(samples, sourceSampleRate, targetSampleRate) {
+    this.resampleBuffer = appendFloat32(this.resampleBuffer, samples);
+    const step = sourceSampleRate / targetSampleRate;
+    const output = [];
+    let offset = this.resampleOffset;
+    while (offset + 1 < this.resampleBuffer.length) {
+      const leftIndex = Math.floor(offset);
+      const fraction = offset - leftIndex;
+      const leftSample = this.resampleBuffer[leftIndex] ?? 0;
+      const rightSample = this.resampleBuffer[leftIndex + 1] ?? leftSample;
+      output.push(leftSample + (rightSample - leftSample) * fraction);
+      offset += step;
+    }
+    const consumed = Math.max(0, Math.floor(offset));
+    if (consumed > 0) {
+      this.resampleBuffer = this.resampleBuffer.slice(consumed);
+      offset -= consumed;
+    }
+    this.resampleOffset = offset;
+    return output.length > 0 ? Float32Array.from(output) : new Float32Array(0);
+  }
+  async cleanupAfterStartFailure() {
+    this.running = false;
+    await this.graphController?.stop();
+    this.graphController = null;
+    await this.resetCaptureState();
+    if (this.stopTracksOnStop) {
+      this.stream?.getTracks().forEach((track) => track.stop());
+    }
+    this.stream = null;
+    if (this.suspendContextOnStop && this.audioContext.state === "running") {
+      await this.audioContext.suspend();
+    }
+  }
+  resetDiagnostics() {
+    this.diagnostics = {
+      sampleCallbacks: 0,
+      inputSamples: 0,
+      normalizedSamples: 0,
+      processedChunks: 0,
+      fingerprints: 0,
+      readyQueries: 0,
+      matchRequests: 0
+    };
+  }
+  ensureNotDestroyed() {
+    if (this.destroyed) {
+      throw new Error("MicrophoneMatcher has been destroyed");
+    }
+  }
+  matchWindowOrThrow() {
+    if (!this.matchWindow) {
+      throw new Error("MicrophoneMatcher is not prepared");
+    }
+    return this.matchWindow;
+  }
+  async reportCampaign(match, captureGeneration) {
+    const reporter = this.options.activityReporter;
+    if (!reporter) {
+      return;
+    }
+    try {
+      const campaign = await reportMatchedMaterialActivity(reporter, match);
+      if (campaign && captureGeneration === this.captureGeneration && this.running) {
+        this.events.emit("campaign", campaign);
+      }
+    } catch (error) {
+      emitError(this.events, "activity", error);
+    }
+  }
+};
+function appendFloat32(left, right) {
+  if (left.length === 0) {
+    return new Float32Array(right);
+  }
+  const merged = new Float32Array(left.length + right.length);
+  merged.set(left, 0);
+  merged.set(right, left.length);
+  return merged;
+}
+async function createMicrophoneMatcher(options = {}) {
+  const matcher = new MicrophoneMatcher(options);
+  await matcher.prepare();
+  return matcher;
+}
+
+// src/session-manager.ts
+function resolveStorage2(storage) {
+  if (storage) {
+    return storage;
+  }
+  if (typeof globalThis.localStorage === "undefined") {
+    throw new Error("localStorage is not available in this environment");
+  }
+  return globalThis.localStorage;
+}
+function defaultGenerateSessionId() {
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return `session-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function createLocalStorageSessionManager(options) {
+  const storage = resolveStorage2(options.storage);
+  const generateSessionId = options.generateSessionId ?? defaultGenerateSessionId;
+  return {
+    getSessionId() {
+      const current = storage.getItem(options.key);
+      if (typeof current === "string" && current.length > 0) {
+        return current;
+      }
+      const next = generateSessionId();
+      storage.setItem(options.key, next);
+      return next;
+    },
+    clear() {
+      storage.removeItem(options.key);
+    }
+  };
+}
+
+// src/audio-recognizer.ts
+var DEFAULT_SORI_API_ENDPOINT = "https://console.soriapi.com/api";
+var FORWARDED_EVENTS = [
+  "ready",
+  "microphoneready",
+  "start",
+  "match",
+  "campaign",
+  "nomatch",
+  "stop",
+  "destroy",
+  "error"
+];
+function ensureFetch(fetcher) {
+  if (fetcher) {
+    return fetcher;
+  }
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error("fetch is not available in this environment");
+  }
+  return globalThis.fetch.bind(globalThis);
+}
+function ensureNonEmptyString(name, value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`AudioRecognizer ${name} is missing`);
+  }
+  return value;
+}
+function normalizeEndpointPrefix(endpoint) {
+  const value = String(endpoint).replace(/\/+$/, "");
+  return value;
+}
+function joinEndpoint(prefix, path) {
+  return `${normalizeEndpointPrefix(prefix)}${path.startsWith("/") ? path : `/${path}`}`;
+}
+function createEphemeralKeyResolver(endpoint, fetcher, requestInit) {
+  return async () => {
+    const resolvedRequestInit = typeof requestInit === "function" ? await requestInit() : requestInit;
+    const response = await ensureFetch(fetcher)(endpoint, {
+      method: resolvedRequestInit?.method ?? "POST",
+      ...resolvedRequestInit
+    });
+    if (!response.ok) {
+      throw new Error(`Ephemeral key request failed: HTTP ${response.status}`);
+    }
+    let payload;
+    try {
+      payload = await response.json();
+    } catch {
+      throw new Error("Ephemeral key request failed: invalid JSON response");
+    }
+    return ensureNonEmptyString("ephemeral key", payload.ephemeralKey ?? payload.ephemeral_key);
+  };
+}
+function resolveRecognizerOptions(options) {
+  const apiEndpoint = options.apiEndpoint ?? DEFAULT_SORI_API_ENDPOINT;
+  const sharedFetch = options.fetch;
+  const legacyAuth = options.auth;
+  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 ephemeralKey = legacyAuth?.ephemeralKey ?? options.ephemeralKey ?? options.ephemeraKey ?? (legacyAuth?.ephemeralKeyEndpoint ?? options.ephemeralKeyEndpoint ? createEphemeralKeyResolver(
+    legacyAuth?.ephemeralKeyEndpoint ?? options.ephemeralKeyEndpoint,
+    legacyAuth?.ephemeralKeyFetch ?? options.ephemeralKeyFetch ?? legacyAuth?.fetch ?? sharedFetch,
+    legacyAuth?.ephemeralKeyRequestInit ?? options.ephemeralKeyRequestInit
+  ) : void 0);
+  const activityReporter = activityEndpoint === void 0 ? void 0 : {
+    ...customActivityReporter,
+    endpoint: activityEndpoint,
+    fetch: customActivityReporter?.fetch ?? sharedFetch
+  };
+  return {
+    ...options,
+    auth: {
+      endpoint: authEndpoint,
+      appId: ensureNonEmptyString("appId", appId),
+      fetch: legacyAuth?.fetch ?? sharedFetch,
+      ephemeralKey
+    },
+    activityReporter
+  };
+}
+function resolvePackStore(options) {
+  if (options.packStore) {
+    return options.packStore;
+  }
+  return createLocalStorageAudioPackStore({
+    key: options.packStorageKey ?? `sorisdk:web-audio:pack:${options.auth.appId}`
+  });
+}
+function resolveSessionManager(options) {
+  if (options.sessionManager) {
+    return options.sessionManager;
+  }
+  return createLocalStorageSessionManager({
+    key: options.sessionStorageKey ?? `sorisdk:web-audio:session:${options.auth.appId}`
+  });
+}
+async function resolveEphemeralKey(auth) {
+  if (typeof auth.ephemeralKey === "string") {
+    return ensureNonEmptyString("ephemeral key", auth.ephemeralKey);
+  }
+  if (typeof auth.ephemeralKey === "function") {
+    return ensureNonEmptyString("ephemeral key", await auth.ephemeralKey());
+  }
+  throw new Error(
+    "AudioRecognizer auth requires either `ephemeralKey` or `ephemeralKeyEndpoint`"
+  );
+}
+var AudioRecognizer = class {
+  events = new TypedEventEmitter();
+  options;
+  packStore;
+  sessionManager;
+  matcher = null;
+  matcherPromise = null;
+  activityToken = null;
+  running = false;
+  destroyed = false;
+  constructor(options) {
+    this.options = resolveRecognizerOptions(options);
+    this.packStore = resolvePackStore(this.options);
+    this.sessionManager = resolveSessionManager(this.options);
+  }
+  on(eventName, listener) {
+    this.events.on(eventName, listener);
+    return this;
+  }
+  off(eventName, listener) {
+    this.events.off(eventName, listener);
+    return this;
+  }
+  once(eventName, listener) {
+    this.events.once(eventName, listener);
+    return this;
+  }
+  async start() {
+    this.ensureNotDestroyed();
+    if (this.running) {
+      return;
+    }
+    const matcher = await this.ensureMatcher();
+    const sessionId = this.sessionManager.getSessionId();
+    const ephemeralKey = await resolveEphemeralKey(this.options.auth);
+    const authResult = await authenticateAndLoadAudioPack({
+      loader: matcher,
+      auth: {
+        endpoint: this.options.auth.endpoint,
+        appId: this.options.auth.appId,
+        ephemeralKey,
+        sessionId,
+        fetch: this.options.auth.fetch
+      },
+      initialVersion: this.options.initialVersion ?? DEFAULT_BROWSER_AUDIOPACK_VERSION,
+      matcherInit: this.options.wasm?.matcher,
+      store: this.packStore
+    });
+    this.setAuthResult(authResult);
+    await matcher.start();
+  }
+  async stop() {
+    const matcher = this.matcher;
+    if (!matcher) {
+      this.running = false;
+      return;
+    }
+    await matcher.stop();
+  }
+  async destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    const matcher = this.matcher ?? (this.matcherPromise ? await this.matcherPromise : null);
+    await matcher?.destroy();
+    this.matcher = null;
+    this.matcherPromise = null;
+    this.activityToken = null;
+    this.running = false;
+    this.events.clear();
+  }
+  getDiagnostics() {
+    return this.matcher?.getDiagnostics() ?? null;
+  }
+  async ensureMatcher() {
+    if (this.matcher) {
+      return this.matcher;
+    }
+    if (!this.matcherPromise) {
+      this.matcherPromise = (async () => {
+        try {
+          const matcher = await createMicrophoneMatcher({
+            ...this.options,
+            activityReporter: this.options.activityReporter ? {
+              ...this.options.activityReporter,
+              token: async () => {
+                if (!this.activityToken) {
+                  throw new Error("AudioRecognizer auth token is not available yet");
+                }
+                return this.activityToken;
+              }
+            } : void 0
+          });
+          this.bindMatcherEvents(matcher);
+          this.matcher = matcher;
+          return matcher;
+        } catch (error) {
+          this.matcherPromise = null;
+          throw error;
+        }
+      })();
+    }
+    return this.matcherPromise;
+  }
+  bindMatcherEvents(matcher) {
+    for (const eventName of FORWARDED_EVENTS) {
+      matcher.on(eventName, (payload) => {
+        if (eventName === "start") {
+          this.running = true;
+        } else if (eventName === "stop" || eventName === "destroy") {
+          this.running = false;
+        }
+        this.events.emit(
+          eventName,
+          payload
+        );
+      });
+    }
+  }
+  ensureNotDestroyed() {
+    if (this.destroyed) {
+      throw new Error("AudioRecognizer has been destroyed");
+    }
+  }
+  setAuthResult(result) {
+    this.activityToken = result.token;
+  }
+};
+
+// src/index.ts
+import { AudioFingerprintType as AudioFingerprintType3 } from "@sorisdk/matcher";
+export {
+  AudioFingerprintType3 as AudioFingerprintType,
+  AudioRecognizer,
+  DEFAULT_BROWSER_AUDIOPACK_VERSION,
+  DEFAULT_SORI_API_ENDPOINT,
+  MicrophoneMatcher,
+  authenticateAndLoadAudioPack,
+  createLocalStorageAudioPackStore,
+  createLocalStorageSessionManager,
+  createMicrophoneMatcher,
+  requestMicrophoneStream
+};