@sorisdk/matcher 0.1.0

package/dist/index.js

@@ -0,0 +1,716 @@
+// 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/auth.ts
+function resolveFetch(fetcher) {
+  if (fetcher) {
+    return fetcher;
+  }
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error("fetch is not available; pass `auth.fetch` in initMatcher options");
+  }
+  return globalThis.fetch.bind(globalThis);
+}
+function ensureString(name, value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Matcher auth response missing ${name}`);
+  }
+  return value;
+}
+function parseExchangeMetadata(payload) {
+  return {
+    expiresAt: typeof payload.expires_at === "string" ? payload.expires_at : typeof payload.expiresAt === "string" ? payload.expiresAt : null,
+    ttlSeconds: typeof payload.ttl_seconds === "number" ? payload.ttl_seconds : typeof payload.ttlSeconds === "number" ? payload.ttlSeconds : null,
+    raw: payload
+  };
+}
+async function exchangeEphemeralKey(options) {
+  if (!options.secretKey || !options.exchange) {
+    throw new Error(
+      "Matcher auth requires either `ephemeralKey` or `secretKey` with `exchange.endpoint`"
+    );
+  }
+  const fetcher = resolveFetch(options.exchange.fetch ?? options.fetch);
+  const body = new URLSearchParams({
+    app_id: options.appId,
+    secret_key: options.secretKey
+  });
+  const response = await fetcher(options.exchange.endpoint, {
+    method: "POST",
+    body
+  });
+  if (!response.ok) {
+    throw new Error(`Matcher auth exchange failed: HTTP ${response.status}`);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    throw new Error("Matcher auth exchange failed: invalid JSON response");
+  }
+  const exchanged = payload.ephemeral_key ?? payload.ephemeralKey ?? payload.secret_key ?? payload.secretKey;
+  return {
+    ephemeralKey: ensureString("ephemeral key", exchanged),
+    metadata: parseExchangeMetadata(payload)
+  };
+}
+async function authenticateMatcher(options) {
+  const exchangeResult = options.ephemeralKey ? null : await exchangeEphemeralKey(options);
+  const ephemeralKey = options.ephemeralKey ?? exchangeResult?.ephemeralKey;
+  const fetcher = resolveFetch(options.fetch);
+  const body = new URLSearchParams({
+    app_id: options.appId,
+    secret_key: ensureString("ephemeral key", ephemeralKey),
+    session_id: options.sessionId,
+    v: options.version
+  });
+  const response = await fetcher(options.endpoint, {
+    method: "POST",
+    body
+  });
+  if (!response.ok) {
+    throw new Error(`Matcher auth failed: HTTP ${response.status}`);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    throw new Error("Matcher auth failed: invalid JSON response");
+  }
+  const token = ensureString("token", payload.token);
+  return {
+    token,
+    tokenExpiresAt: typeof payload.token_expires_at === "string" ? payload.token_expires_at : typeof payload.tokenExpiresAt === "string" ? payload.tokenExpiresAt : null,
+    packUrl: typeof payload.url === "string" ? payload.url : null,
+    updated: typeof payload.updated === "number" ? payload.updated : 0,
+    forceUpdate: payload.force_update === 1,
+    exchange: exchangeResult?.metadata ?? null,
+    raw: payload
+  };
+}
+
+// src/embedded-pack.ts
+var EMBEDDED_PACK_URL = new URL("./assets/model.pack", import.meta.url);
+var embeddedPackBytesPromise = null;
+var testInjectedEmbeddedPackBytes = null;
+function resolveFetch2(fetcher) {
+  if (fetcher) {
+    return fetcher;
+  }
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error("fetch is not available; pass `fetch` in MatcherSession options");
+  }
+  return globalThis.fetch.bind(globalThis);
+}
+function cloneBytes(bytes) {
+  return new Uint8Array(bytes);
+}
+async function readPackBytes(fetcher) {
+  const response = await resolveFetch2(fetcher)(EMBEDDED_PACK_URL);
+  if (!response.ok) {
+    throw new Error(`Failed to load embedded pack: HTTP ${response.status}`);
+  }
+  const buffer = await response.arrayBuffer();
+  return new Uint8Array(buffer.slice(0));
+}
+async function loadEmbeddedPackBytes(fetcher) {
+  if (testInjectedEmbeddedPackBytes) {
+    return cloneBytes(testInjectedEmbeddedPackBytes);
+  }
+  if (!embeddedPackBytesPromise) {
+    embeddedPackBytesPromise = readPackBytes(fetcher).catch((error) => {
+      embeddedPackBytesPromise = null;
+      throw error;
+    });
+  }
+  const bytes = await embeddedPackBytesPromise;
+  return cloneBytes(bytes);
+}
+function __setEmbeddedPackBytesForTests(bytes) {
+  testInjectedEmbeddedPackBytes = cloneBytes(bytes);
+  embeddedPackBytesPromise = null;
+}
+function __resetEmbeddedPackLoaderForTests() {
+  embeddedPackBytesPromise = null;
+  testInjectedEmbeddedPackBytes = null;
+}
+
+// src/source.ts
+function hasCtor(name) {
+  return typeof globalThis[name] !== "undefined";
+}
+function copyToUint8Array(input) {
+  return new Uint8Array(input);
+}
+function toUint8Array(buffer) {
+  return new Uint8Array(buffer.slice(0));
+}
+function classifyPackSource(source) {
+  if (source instanceof Uint8Array) {
+    return "uint8array";
+  }
+  if (source instanceof ArrayBuffer) {
+    return "arraybuffer";
+  }
+  if (typeof source === "string") {
+    return "string-url";
+  }
+  if (source instanceof URL) {
+    return "url";
+  }
+  if (hasCtor("Request") && source instanceof Request) {
+    return "request";
+  }
+  if (hasCtor("Response") && source instanceof Response) {
+    return "response";
+  }
+  if (hasCtor("Blob") && source instanceof Blob) {
+    return "blob";
+  }
+  return "unknown";
+}
+function resolveFetch3(fetcher) {
+  if (fetcher) {
+    return fetcher;
+  }
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error("fetch is not available; pass `fetch` in MatcherSession options");
+  }
+  return globalThis.fetch.bind(globalThis);
+}
+async function readResponseAsBytes(response) {
+  if (!response.ok) {
+    throw new Error(`Failed to load pack: HTTP ${response.status}`);
+  }
+  return toUint8Array(await response.arrayBuffer());
+}
+async function normalizePackSource(source, fetcher) {
+  const sourceType = classifyPackSource(source);
+  if (source instanceof Uint8Array) {
+    return { sourceType, bytes: copyToUint8Array(source) };
+  }
+  if (source instanceof ArrayBuffer) {
+    return { sourceType, bytes: toUint8Array(source) };
+  }
+  if (hasCtor("Blob") && source instanceof Blob) {
+    return { sourceType, bytes: toUint8Array(await source.arrayBuffer()) };
+  }
+  if (hasCtor("Response") && source instanceof Response) {
+    return { sourceType, bytes: await readResponseAsBytes(source) };
+  }
+  if (typeof source === "string" || source instanceof URL || hasCtor("Request") && source instanceof Request) {
+    const response = await resolveFetch3(fetcher)(source);
+    return { sourceType, bytes: await readResponseAsBytes(response) };
+  }
+  throw new Error("Unsupported pack source type");
+}
+
+// src/match-deduper.ts
+var DEFAULT_NO_MATCH_CONFIRMATION_COUNT = 2;
+function getMatchIdentity(match) {
+  return `${match.name}:${match.afpType}`;
+}
+var DistinctMatchDeduper = class {
+  lastIdentity = null;
+  pendingNoMatchCount = 0;
+  observe(best) {
+    if (!best) {
+      if (this.lastIdentity === null) {
+        return { kind: "repeat", best: null };
+      }
+      this.pendingNoMatchCount += 1;
+      if (this.pendingNoMatchCount < DEFAULT_NO_MATCH_CONFIRMATION_COUNT) {
+        return { kind: "repeat", best: null };
+      }
+      this.lastIdentity = null;
+      this.pendingNoMatchCount = 0;
+      return { kind: "nomatch" };
+    }
+    const nextIdentity = getMatchIdentity(best);
+    this.pendingNoMatchCount = 0;
+    if (this.lastIdentity === nextIdentity) {
+      return { kind: "repeat", best };
+    }
+    this.lastIdentity = nextIdentity;
+    return { kind: "match", best };
+  }
+  reset() {
+    this.lastIdentity = null;
+    this.pendingNoMatchCount = 0;
+  }
+};
+
+// src/wasm.ts
+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/core.js", import.meta.url);
+  return import(
+    /* @vite-ignore */
+    generatedModuleUrl.href
+  );
+};
+var INTERNAL_DUPLICATE_MATCH_FLAG = "__matcherDuplicate";
+var WrappedDatabase = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  raw() {
+    return this.inner;
+  }
+  addEntry(name, afpType, fingerprint) {
+    const fn = getCallable(this.inner, ["addEntry", "add_entry"]);
+    if (!fn) {
+      throw new Error("WASM database is missing addEntry");
+    }
+    fn.call(this.inner, name, afpType, fingerprint);
+  }
+  addOrReplace(name, afpType, fingerprint) {
+    const fn = getCallable(this.inner, ["addOrReplace", "add_or_replace"]);
+    if (!fn) {
+      throw new Error("WASM database is missing addOrReplace");
+    }
+    fn.call(this.inner, name, afpType, fingerprint);
+  }
+  removeEntry(name) {
+    const fn = getCallable(this.inner, ["removeEntry", "remove_entry"]);
+    if (!fn) {
+      throw new Error("WASM database is missing removeEntry");
+    }
+    fn.call(this.inner, name);
+  }
+  clear() {
+    const fn = getCallable(this.inner, ["clear"]);
+    if (!fn) {
+      throw new Error("WASM database is missing clear");
+    }
+    fn.call(this.inner);
+  }
+  loadPackBytes(bytes) {
+    const fn = getCallable(this.inner, [
+      "loadPackBytes",
+      "loadPack",
+      "loadPackFromBytes",
+      "load_audiopack_bytes"
+    ]);
+    if (!fn) {
+      throw new Error("WASM database is missing loadPackBytes-compatible method");
+    }
+    fn.call(this.inner, bytes);
+  }
+  loadPackBytesAppend(bytes) {
+    const appendFn = getCallable(this.inner, ["loadPackBytesAppend", "load_pack_bytes_append"]);
+    if (!appendFn) {
+      throw new Error("WASM database is missing loadPackBytesAppend-compatible method");
+    }
+    appendFn.call(this.inner, bytes);
+  }
+  destroy() {
+    const fn = getCallable(this.inner, ["destroy", "free"]);
+    if (fn) {
+      fn.call(this.inner);
+    }
+  }
+};
+var WrappedMatcher = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  findMatches(database, query, config) {
+    const fn = getCallable(this.inner, ["findMatches", "find_matches", "matchQuery", "match_query", "match"]);
+    if (!fn) {
+      throw new Error("WASM matcher is missing findMatches-compatible method");
+    }
+    const dbRecord = typeof database.raw === "function" ? database.raw() : database;
+    const rawResults = fn.call(this.inner, dbRecord, query, config);
+    return normalizeResults(rawResults ?? []);
+  }
+  bestMatch(database, query, config) {
+    const fn = getCallable(this.inner, ["bestMatch", "best_match"]);
+    if (!fn) {
+      throw new Error("WASM matcher is missing bestMatch-compatible method");
+    }
+    const dbRecord = typeof database.raw === "function" ? database.raw() : database;
+    const raw = fn.call(this.inner, dbRecord, query, config);
+    if (!raw) {
+      return null;
+    }
+    if (typeof raw === "object" && raw !== null && raw.duplicate === true && raw.best) {
+      const normalized = normalizeResult(raw.best);
+      Object.defineProperty(normalized, INTERNAL_DUPLICATE_MATCH_FLAG, {
+        value: true,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+      return normalized;
+    }
+    return normalizeResult(raw);
+  }
+  resetDistinctMatchState() {
+    const fn = getCallable(this.inner, ["resetDistinctMatchState", "reset_distinct_match_state"]);
+    fn?.call(this.inner);
+  }
+  destroy() {
+    const fn = getCallable(this.inner, ["destroy", "free"]);
+    if (fn) {
+      fn.call(this.inner);
+    }
+  }
+};
+function normalizeResult(raw) {
+  const afpType = Number(raw.afpType ?? raw.afp_type);
+  return {
+    name: String(raw.name),
+    score: Number(raw.score),
+    position: Number(raw.position),
+    afpType
+  };
+}
+function normalizeResults(rawResults) {
+  return rawResults.filter((item) => typeof item === "object" && item !== null).map((item) => normalizeResult(item));
+}
+function isInternallyDuplicatedBestMatch(result) {
+  return Boolean(
+    result && typeof result === "object" && result[INTERNAL_DUPLICATE_MATCH_FLAG] === true
+  );
+}
+function resolveFactory(moduleLike, names) {
+  const fn = getCallable(moduleLike, names);
+  return fn ? fn.bind(moduleLike) : null;
+}
+function createBindingsFromModule(moduleLike) {
+  if (!moduleLike || typeof moduleLike !== "object") {
+    throw new Error("Invalid matcher-wasm module");
+  }
+  const mod = moduleLike;
+  const initFn = getCallable(mod, ["initMatcher"]) ?? (typeof mod.default === "function" ? mod.default.bind(mod) : null);
+  const createDatabaseFactory = resolveFactory(mod, ["createDatabase"]);
+  const createMatcherFactory = resolveFactory(mod, ["createMatcher"]);
+  const DatabaseCtor = mod.WasmMatcherDatabase ?? mod.MatcherDatabase ?? mod.Database;
+  const MatcherCtor = mod.WasmMatcherEngine ?? mod.MatcherEngine ?? mod.Matcher ?? mod.AudioMatcher;
+  if (!createDatabaseFactory && !DatabaseCtor) {
+    throw new Error("matcher wasm module is missing database export");
+  }
+  if (!createMatcherFactory && !MatcherCtor) {
+    throw new Error("matcher wasm module is missing matcher export");
+  }
+  return {
+    async init(initInput) {
+      if (initFn) {
+        await Promise.resolve(initFn(initInput));
+      }
+    },
+    createDatabase() {
+      const db = createDatabaseFactory ? createDatabaseFactory() : new DatabaseCtor();
+      return new WrappedDatabase(db);
+    },
+    createMatcher() {
+      const matcher = createMatcherFactory ? createMatcherFactory() : new MatcherCtor();
+      return new WrappedMatcher(matcher);
+    }
+  };
+}
+
+// src/session.ts
+var initializedBindingsPromise = null;
+var testInjectedWasmModule = null;
+async function getBindings(options) {
+  if (initializedBindingsPromise) {
+    return initializedBindingsPromise;
+  }
+  initializedBindingsPromise = (async () => {
+    try {
+      const moduleLike = options?.wasmModule ?? testInjectedWasmModule ?? (options?.loader ? await options.loader() : await defaultLoader());
+      const bindings = createBindingsFromModule(moduleLike);
+      await bindings.init(options?.wasmInitInput);
+      return bindings;
+    } catch (error) {
+      initializedBindingsPromise = null;
+      throw error;
+    }
+  })();
+  return initializedBindingsPromise;
+}
+function toUint8ArrayCopy(input) {
+  return new Uint8Array(input);
+}
+function handleError(emitter, phase, unknownError) {
+  const error = unknownError instanceof Error ? unknownError : new Error(String(unknownError));
+  emitter.emit("error", { phase, error });
+  throw error;
+}
+async function initMatcher(options) {
+  await getBindings(options);
+  if (!options?.auth) {
+    return void 0;
+  }
+  return authenticateMatcher(options.auth);
+}
+var MatcherSession = class {
+  events = new TypedEventEmitter();
+  fetcher;
+  initOptions;
+  readyPromise;
+  bindings = null;
+  database = null;
+  matcher = null;
+  destroyed = false;
+  distinctMatchDeduper = new DistinctMatchDeduper();
+  constructor(options) {
+    this.fetcher = options?.fetch;
+    this.initOptions = {
+      loader: options?.loader,
+      wasmModule: options?.wasmModule,
+      wasmInitInput: options?.wasmInitInput
+    };
+    this.readyPromise = this.bootstrap();
+  }
+  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 ready() {
+    await this.readyPromise;
+  }
+  async loadPack(source) {
+    try {
+      await this.ensureLiveReady();
+      const sourceType = classifyPackSource(source);
+      this.events.emit("packloadstart", { sourceType });
+      const database = this.databaseOrThrow();
+      const normalized = await normalizePackSource(source, this.fetcher);
+      const embeddedPackBytes = await loadEmbeddedPackBytes();
+      database.clear();
+      database.loadPackBytes(embeddedPackBytes);
+      database.loadPackBytesAppend(normalized.bytes);
+      this.distinctMatchDeduper.reset();
+      this.matcher?.resetDistinctMatchState?.();
+      this.events.emit("packload", {
+        sourceType: normalized.sourceType,
+        byteLength: normalized.bytes.byteLength
+      });
+    } catch (error) {
+      handleError(this.events, "loadPack", error);
+    }
+  }
+  async addEntry(name, afpType, fingerprint) {
+    try {
+      await this.ensureLiveReady();
+      this.databaseOrThrow().addEntry(name, afpType, toUint8ArrayCopy(fingerprint));
+      this.distinctMatchDeduper.reset();
+      this.matcher?.resetDistinctMatchState?.();
+    } catch (error) {
+      handleError(this.events, "addEntry", error);
+    }
+  }
+  async addOrReplace(name, afpType, fingerprint) {
+    try {
+      await this.ensureLiveReady();
+      this.databaseOrThrow().addOrReplace(name, afpType, toUint8ArrayCopy(fingerprint));
+      this.distinctMatchDeduper.reset();
+      this.matcher?.resetDistinctMatchState?.();
+    } catch (error) {
+      handleError(this.events, "addOrReplace", error);
+    }
+  }
+  async removeEntry(name) {
+    try {
+      await this.ensureLiveReady();
+      this.databaseOrThrow().removeEntry(name);
+      this.distinctMatchDeduper.reset();
+      this.matcher?.resetDistinctMatchState?.();
+    } catch (error) {
+      handleError(this.events, "removeEntry", error);
+    }
+  }
+  async clear() {
+    try {
+      await this.ensureLiveReady();
+      this.databaseOrThrow().clear();
+      this.distinctMatchDeduper.reset();
+      this.matcher?.resetDistinctMatchState?.();
+    } catch (error) {
+      handleError(this.events, "clear", error);
+    }
+  }
+  async match(query, config) {
+    try {
+      await this.ensureLiveReady();
+      const safeQuery = toUint8ArrayCopy(query);
+      this.events.emit("querystart", { queryByteLength: safeQuery.byteLength });
+      const results = this.matcherOrThrow().findMatches(this.databaseOrThrow(), safeQuery, config);
+      this.emitDistinctMatchEvent(results[0] ?? null, safeQuery.byteLength, results);
+      return results;
+    } catch (error) {
+      handleError(this.events, "match", error);
+    }
+  }
+  async bestMatch(query, config) {
+    try {
+      await this.ensureLiveReady();
+      const safeQuery = toUint8ArrayCopy(query);
+      this.events.emit("querystart", { queryByteLength: safeQuery.byteLength });
+      const best = this.matcherOrThrow().bestMatch(this.databaseOrThrow(), safeQuery, config);
+      if (isInternallyDuplicatedBestMatch(best)) {
+        return best;
+      }
+      this.emitDistinctMatchEvent(best, safeQuery.byteLength, best ? [best] : []);
+      return best;
+    } catch (error) {
+      handleError(this.events, "bestMatch", error);
+    }
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    this.matcher?.destroy();
+    this.database?.destroy();
+    this.matcher = null;
+    this.database = null;
+    this.bindings = null;
+    this.distinctMatchDeduper.reset();
+    this.events.emit("destroy", { destroyedAt: Date.now() });
+    this.events.clear();
+  }
+  async bootstrap() {
+    let database = null;
+    let matcher = null;
+    try {
+      const bindings = await getBindings(this.initOptions);
+      database = bindings.createDatabase();
+      matcher = bindings.createMatcher();
+      if (this.destroyed) {
+        matcher.destroy();
+        database.destroy();
+        return;
+      }
+      this.bindings = bindings;
+      this.database = database;
+      this.matcher = matcher;
+      this.events.emit("ready", { createdAt: Date.now() });
+    } catch (error) {
+      if (this.destroyed) {
+        matcher?.destroy();
+        database?.destroy();
+        return;
+      }
+      handleError(this.events, "init", error);
+    }
+  }
+  async ensureLiveReady() {
+    this.ensureNotDestroyed();
+    await this.readyPromise;
+    this.ensureNotDestroyed();
+  }
+  ensureNotDestroyed() {
+    if (this.destroyed) {
+      throw new Error("MatcherSession has been destroyed");
+    }
+  }
+  matcherOrThrow() {
+    if (!this.matcher) {
+      throw new Error("Matcher is not initialized");
+    }
+    return this.matcher;
+  }
+  databaseOrThrow() {
+    if (!this.database) {
+      throw new Error("Database is not initialized");
+    }
+    return this.database;
+  }
+  emitDistinctMatchEvent(best, queryByteLength, results) {
+    const observation = this.distinctMatchDeduper.observe(best);
+    if (observation.kind === "match") {
+      this.events.emit("match", { results, best: observation.best });
+      return;
+    }
+    if (observation.kind === "nomatch") {
+      this.events.emit("nomatch", { queryByteLength });
+    }
+  }
+};
+function __setMatcherWasmModuleForTests(moduleLike) {
+  testInjectedWasmModule = moduleLike;
+  initializedBindingsPromise = null;
+}
+function __setMatcherEmbeddedPackForTests(bytes) {
+  __setEmbeddedPackBytesForTests(bytes);
+}
+function __resetMatcherWasmForTests() {
+  testInjectedWasmModule = null;
+  __resetEmbeddedPackLoaderForTests();
+  initializedBindingsPromise = null;
+}
+
+// src/types.ts
+var AudioFingerprintType = /* @__PURE__ */ ((AudioFingerprintType2) => {
+  AudioFingerprintType2[AudioFingerprintType2["Livestream"] = 1] = "Livestream";
+  AudioFingerprintType2[AudioFingerprintType2["ArchiveCf"] = 2] = "ArchiveCf";
+  AudioFingerprintType2[AudioFingerprintType2["ArchivePg"] = 4] = "ArchivePg";
+  return AudioFingerprintType2;
+})(AudioFingerprintType || {});
+export {
+  AudioFingerprintType,
+  MatcherSession,
+  __resetMatcherWasmForTests,
+  __setMatcherEmbeddedPackForTests,
+  __setMatcherWasmModuleForTests,
+  initMatcher
+};