@audd/sdk 1.4.7

package/dist/index.cjs

@@ -0,0 +1,1442 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var crypto = require('crypto');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/version.ts
+var VERSION = "1.4.6";
+
+// src/errors.ts
+var AudDError = class extends Error {
+  name = "AudDError";
+};
+var AudDAPIError = class extends AudDError {
+  name = "AudDAPIError";
+  errorCode;
+  httpStatus;
+  requestId;
+  requestedParams;
+  requestMethod;
+  brandedMessage;
+  rawResponse;
+  /** Original `error_message` from the server. (`Error.message` may be overridden by subclasses.) */
+  serverMessage;
+  constructor(init) {
+    super(`[#${init.errorCode}] ${init.message}`);
+    this.errorCode = init.errorCode;
+    this.serverMessage = init.message;
+    this.httpStatus = init.httpStatus;
+    this.requestId = init.requestId ?? null;
+    this.requestedParams = init.requestedParams ?? {};
+    this.requestMethod = init.requestMethod ?? null;
+    this.brandedMessage = init.brandedMessage ?? null;
+    this.rawResponse = init.rawResponse ?? null;
+  }
+};
+var AudDAuthenticationError = class extends AudDAPIError {
+  name = "AudDAuthenticationError";
+};
+var AudDQuotaError = class extends AudDAPIError {
+  name = "AudDQuotaError";
+};
+var AudDSubscriptionError = class extends AudDAPIError {
+  name = "AudDSubscriptionError";
+};
+var AudDCustomCatalogAccessError = class extends AudDSubscriptionError {
+  name = "AudDCustomCatalogAccessError";
+};
+var AudDInvalidRequestError = class extends AudDAPIError {
+  name = "AudDInvalidRequestError";
+};
+var AudDInvalidAudioError = class extends AudDAPIError {
+  name = "AudDInvalidAudioError";
+};
+var AudDRateLimitError = class extends AudDAPIError {
+  name = "AudDRateLimitError";
+};
+var AudDStreamLimitError = class extends AudDAPIError {
+  name = "AudDStreamLimitError";
+};
+var AudDNotReleasedError = class extends AudDAPIError {
+  name = "AudDNotReleasedError";
+};
+var AudDBlockedError = class extends AudDAPIError {
+  name = "AudDBlockedError";
+};
+var AudDNeedsUpdateError = class extends AudDAPIError {
+  name = "AudDNeedsUpdateError";
+};
+var AudDServerError = class extends AudDAPIError {
+  name = "AudDServerError";
+};
+var AudDConnectionError = class extends AudDError {
+  name = "AudDConnectionError";
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+  }
+};
+var AudDSerializationError = class extends AudDError {
+  name = "AudDSerializationError";
+  rawText;
+  constructor(message, rawText = "") {
+    super(message);
+    this.rawText = rawText;
+  }
+};
+var CODE_MAP = {
+  900: AudDAuthenticationError,
+  901: AudDAuthenticationError,
+  903: AudDAuthenticationError,
+  902: AudDQuotaError,
+  904: AudDSubscriptionError,
+  905: AudDSubscriptionError,
+  50: AudDInvalidRequestError,
+  51: AudDInvalidRequestError,
+  600: AudDInvalidRequestError,
+  601: AudDInvalidRequestError,
+  602: AudDInvalidRequestError,
+  700: AudDInvalidRequestError,
+  701: AudDInvalidRequestError,
+  702: AudDInvalidRequestError,
+  906: AudDInvalidRequestError,
+  300: AudDInvalidAudioError,
+  400: AudDInvalidAudioError,
+  500: AudDInvalidAudioError,
+  610: AudDStreamLimitError,
+  611: AudDRateLimitError,
+  907: AudDNotReleasedError,
+  19: AudDBlockedError,
+  31337: AudDBlockedError,
+  20: AudDNeedsUpdateError,
+  100: AudDServerError,
+  1e3: AudDServerError
+};
+function errorClassForCode(code) {
+  return CODE_MAP[code] ?? AudDServerError;
+}
+function brandedMessageOf(result) {
+  if (typeof result !== "object" || result === null) return null;
+  const r = result;
+  const parts = [];
+  if (typeof r.artist === "string" && r.artist.length > 0) parts.push(r.artist);
+  if (typeof r.title === "string" && r.title.length > 0) parts.push(r.title);
+  return parts.length === 0 ? null : parts.join(" \u2014 ");
+}
+var CUSTOM_CATALOG_PREFIX = "Adding songs to your custom catalog requires enterprise access that isn't enabled on your account.\n\nNote: the custom-catalog endpoint is for adding songs to your private fingerprint database, not for music recognition. If you intended to identify music, use recognize(...) (or recognizeEnterprise(...) for files longer than 25 seconds) instead.\n\nTo request custom-catalog access, contact api@audd.io.\n\n";
+function raiseFromErrorResponse(body, opts) {
+  const code = body.error?.error_code ?? 0;
+  const message = body.error?.error_message ?? "";
+  const requestedParams = body.request_params ?? body.requested_params ?? {};
+  const requestMethod = body.request_api_method ?? null;
+  const branded = brandedMessageOf(body.result);
+  const fields = {
+    errorCode: code,
+    message,
+    httpStatus: opts.httpStatus,
+    requestId: opts.requestId,
+    requestedParams,
+    requestMethod,
+    brandedMessage: branded,
+    rawResponse: body
+  };
+  const Cls = errorClassForCode(code);
+  if (opts.customCatalogContext === true && Cls === AudDSubscriptionError) {
+    const overridden = `${CUSTOM_CATALOG_PREFIX}[Server message: ${message}]`;
+    throw new AudDCustomCatalogAccessError({ ...fields, message: overridden });
+  }
+  throw new Cls(fields);
+}
+
+// src/userAgent.ts
+function userAgent() {
+  const node = typeof process !== "undefined" && process.version ? process.version.replace(/^v/, "") : "unknown";
+  const platform = typeof process !== "undefined" && process.platform ? process.platform : "browser";
+  return `audd-node/${VERSION} node/${node} (${platform})`;
+}
+
+// src/http.ts
+var STANDARD_TIMEOUT_MS = 6e4;
+var ENTERPRISE_TIMEOUT_MS = 36e5;
+var HttpClient = class {
+  apiToken;
+  fetchImpl;
+  defaultTimeoutMs;
+  constructor(opts) {
+    this.apiToken = opts.apiToken;
+    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+    this.defaultTimeoutMs = opts.defaultTimeoutMs ?? STANDARD_TIMEOUT_MS;
+  }
+  /** Atomically swap the token used for subsequent requests. */
+  setApiToken(newToken) {
+    this.apiToken = newToken;
+  }
+  async postForm(url, fields, opts = {}) {
+    const form = new FormData();
+    form.set("api_token", this.apiToken);
+    for (const [k, v] of Object.entries(fields)) {
+      if (v === void 0) continue;
+      form.set(k, v);
+    }
+    return this.send(url, { method: "POST", body: form }, opts);
+  }
+  async get(url, params, opts = {}) {
+    const u = new URL(url);
+    if (!u.searchParams.has("api_token")) u.searchParams.set("api_token", this.apiToken);
+    for (const [k, v] of Object.entries(params)) {
+      if (v === void 0) continue;
+      u.searchParams.set(k, v);
+    }
+    return this.send(u.toString(), { method: "GET" }, opts);
+  }
+  async send(url, init, { timeoutMs, signal: userSignal }) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => {
+      controller.abort();
+    }, timeoutMs ?? this.defaultTimeoutMs);
+    const userAbortHandler = () => controller.abort();
+    if (userSignal !== void 0) {
+      if (userSignal.aborted) {
+        controller.abort();
+      } else {
+        userSignal.addEventListener("abort", userAbortHandler, { once: true });
+      }
+    }
+    try {
+      const headers = new Headers(init.headers);
+      headers.set("User-Agent", userAgent());
+      const response = await this.fetchImpl(url, {
+        ...init,
+        headers,
+        signal: controller.signal
+      });
+      const text = await response.text();
+      let json = null;
+      if (text !== "") {
+        try {
+          json = JSON.parse(text);
+        } catch {
+          json = null;
+        }
+      }
+      return {
+        jsonBody: json,
+        httpStatus: response.status,
+        requestId: response.headers.get("x-request-id"),
+        rawText: text
+      };
+    } finally {
+      clearTimeout(timer);
+      if (userSignal !== void 0) {
+        userSignal.removeEventListener("abort", userAbortHandler);
+      }
+    }
+  }
+};
+
+// src/models.ts
+function pickExtras(raw, knownKeys) {
+  const known = new Set(knownKeys);
+  const extras = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (!known.has(k)) extras[k] = v;
+  }
+  return extras;
+}
+function asObject(raw) {
+  if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+    return raw;
+  }
+  return void 0;
+}
+function requireObject(raw, what) {
+  const o = asObject(raw);
+  if (o === void 0) throw new TypeError(`${what}: expected object`);
+  return o;
+}
+function asString(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function asNumber(v) {
+  return typeof v === "number" ? v : void 0;
+}
+function asBoolean(v) {
+  return typeof v === "boolean" ? v : void 0;
+}
+var STREAMING_PROVIDERS = [
+  "spotify",
+  "apple_music",
+  "deezer",
+  "napster",
+  "youtube"
+];
+function lisTnStreamingUrl(songLink, provider) {
+  if (songLink === void 0 || songLink === "") return null;
+  let parsed;
+  try {
+    parsed = new URL(songLink);
+  } catch {
+    return null;
+  }
+  if (parsed.hostname !== "lis.tn") return null;
+  const sep = parsed.search ? "&" : "?";
+  return `${songLink}${sep}${provider}`;
+}
+function directStreamingUrl(result, provider) {
+  if (provider === "apple_music" && result.appleMusic !== void 0) {
+    const url = result.appleMusic["url"];
+    if (typeof url === "string" && url.length > 0) return url;
+  } else if (provider === "spotify" && result.spotify !== void 0) {
+    const ext = result.spotify["external_urls"];
+    if (typeof ext === "object" && ext !== null) {
+      const sp = ext["spotify"];
+      if (typeof sp === "string" && sp.length > 0) return sp;
+    }
+    const uri = result.spotify["uri"];
+    if (typeof uri === "string" && uri.length > 0) return uri;
+  } else if (provider === "deezer" && result.deezer !== void 0) {
+    const link = result.deezer["link"];
+    if (typeof link === "string" && link.length > 0) return link;
+  } else if (provider === "napster" && result.napster !== void 0) {
+    const href = result.napster["href"];
+    if (typeof href === "string" && href.length > 0) return href;
+  }
+  return null;
+}
+function previewFrom(result) {
+  if (result.appleMusic !== void 0) {
+    const previews = result.appleMusic["previews"];
+    if (Array.isArray(previews) && previews.length > 0) {
+      const first = previews[0];
+      if (typeof first === "object" && first !== null) {
+        const url = first["url"];
+        if (typeof url === "string" && url.length > 0) return url;
+      }
+    }
+  }
+  if (result.spotify !== void 0) {
+    const url = result.spotify["preview_url"];
+    if (typeof url === "string" && url.length > 0) return url;
+  }
+  if (result.deezer !== void 0) {
+    const url = result.deezer["preview"];
+    if (typeof url === "string" && url.length > 0) return url;
+  }
+  return null;
+}
+var RECOGNITION_KEYS = [
+  "timecode",
+  "audio_id",
+  "artist",
+  "title",
+  "album",
+  "release_date",
+  "label",
+  "song_link",
+  "apple_music",
+  "spotify",
+  "deezer",
+  "napster",
+  "musicbrainz"
+];
+function parseRecognitionResult(raw) {
+  const r = requireObject(raw, "RecognitionResult");
+  const timecode = asString(r.timecode);
+  if (timecode === void 0) {
+    throw new TypeError("RecognitionResult: timecode missing or not string");
+  }
+  const audioId = asNumber(r.audio_id);
+  const artist = asString(r.artist);
+  const title = asString(r.title);
+  const songLink = asString(r.song_link);
+  const musicbrainz = Array.isArray(r.musicbrainz) ? r.musicbrainz.filter((x) => asObject(x) !== void 0) : void 0;
+  const result = {
+    timecode,
+    audioId,
+    artist,
+    title,
+    album: asString(r.album),
+    releaseDate: asString(r.release_date),
+    label: asString(r.label),
+    songLink,
+    appleMusic: asObject(r.apple_music),
+    spotify: asObject(r.spotify),
+    deezer: asObject(r.deezer),
+    napster: asObject(r.napster),
+    musicbrainz,
+    extras: pickExtras(r, RECOGNITION_KEYS),
+    rawResponse: r,
+    get isCustomMatch() {
+      return audioId !== void 0;
+    },
+    get isPublicMatch() {
+      return audioId === void 0 && (artist !== void 0 || title !== void 0);
+    },
+    get thumbnailUrl() {
+      return lisTnStreamingUrl(songLink, "thumb");
+    },
+    streamingUrl(provider) {
+      if (!STREAMING_PROVIDERS.includes(provider)) {
+        throw new TypeError(
+          `Unknown streaming provider: ${String(provider)}. Valid: ${STREAMING_PROVIDERS.join(", ")}`
+        );
+      }
+      const direct = directStreamingUrl(result, provider);
+      if (direct !== null) return direct;
+      return lisTnStreamingUrl(songLink, provider);
+    },
+    streamingUrls() {
+      const out = {};
+      for (const p of STREAMING_PROVIDERS) {
+        const url = result.streamingUrl(p);
+        if (url !== null) out[p] = url;
+      }
+      return out;
+    },
+    previewUrl() {
+      return previewFrom(result);
+    }
+  };
+  return result;
+}
+var ENTERPRISE_MATCH_KEYS = [
+  "score",
+  "timecode",
+  "artist",
+  "title",
+  "album",
+  "release_date",
+  "label",
+  "isrc",
+  "upc",
+  "song_link",
+  "start_offset",
+  "end_offset"
+];
+function parseEnterpriseMatch(raw) {
+  const r = requireObject(raw, "EnterpriseMatch");
+  const score = asNumber(r.score);
+  const timecode = asString(r.timecode);
+  if (score === void 0) throw new TypeError("EnterpriseMatch: score not number");
+  if (timecode === void 0) throw new TypeError("EnterpriseMatch: timecode not string");
+  const songLink = asString(r.song_link);
+  return {
+    score,
+    timecode,
+    artist: asString(r.artist),
+    title: asString(r.title),
+    album: asString(r.album),
+    releaseDate: asString(r.release_date),
+    label: asString(r.label),
+    isrc: asString(r.isrc),
+    upc: asString(r.upc),
+    songLink,
+    startOffset: asNumber(r.start_offset),
+    endOffset: asNumber(r.end_offset),
+    extras: pickExtras(r, ENTERPRISE_MATCH_KEYS),
+    rawResponse: r,
+    streamingUrl(provider) {
+      if (!STREAMING_PROVIDERS.includes(provider)) {
+        throw new TypeError(`Unknown streaming provider: ${String(provider)}`);
+      }
+      return lisTnStreamingUrl(songLink, provider);
+    },
+    streamingUrls() {
+      const out = {};
+      for (const p of STREAMING_PROVIDERS) {
+        const url = lisTnStreamingUrl(songLink, p);
+        if (url !== null) out[p] = url;
+      }
+      return out;
+    },
+    get thumbnailUrl() {
+      if (songLink === void 0 || songLink === "") return null;
+      try {
+        const parsed = new URL(songLink);
+        if (parsed.hostname !== "lis.tn") return null;
+        const sep = parsed.search ? "&" : "?";
+        return `${songLink}${sep}thumb`;
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+var ENTERPRISE_CHUNK_KEYS = ["songs", "offset"];
+function parseEnterpriseChunkResult(raw) {
+  const r = requireObject(raw, "EnterpriseChunkResult");
+  const songsRaw = r.songs;
+  if (!Array.isArray(songsRaw)) {
+    throw new TypeError("EnterpriseChunkResult: songs not array");
+  }
+  const offset = asString(r.offset);
+  if (offset === void 0) throw new TypeError("EnterpriseChunkResult: offset not string");
+  return {
+    songs: songsRaw.map(parseEnterpriseMatch),
+    offset,
+    extras: pickExtras(r, ENTERPRISE_CHUNK_KEYS),
+    rawResponse: r
+  };
+}
+var STREAM_KEYS = ["radio_id", "url", "stream_running", "longpoll_category"];
+function parseStream(raw) {
+  const r = requireObject(raw, "Stream");
+  const radioId = asNumber(r.radio_id);
+  const url = asString(r.url);
+  const streamRunning = asBoolean(r.stream_running);
+  if (radioId === void 0) throw new TypeError("Stream: radio_id not number");
+  if (url === void 0) throw new TypeError("Stream: url not string");
+  if (streamRunning === void 0) throw new TypeError("Stream: stream_running not boolean");
+  return {
+    radioId,
+    url,
+    streamRunning,
+    longpollCategory: asString(r.longpoll_category),
+    extras: pickExtras(r, STREAM_KEYS),
+    rawResponse: r
+  };
+}
+var STREAM_CALLBACK_RESULT_ENTRY_KEYS = [
+  "artist",
+  "title",
+  "score",
+  "album",
+  "release_date",
+  "label",
+  "song_link",
+  "apple_music",
+  "spotify",
+  "deezer",
+  "napster",
+  "musicbrainz"
+];
+function parseStreamCallbackResultEntry(raw) {
+  const r = requireObject(raw, "StreamCallbackResultEntry");
+  const artist = asString(r.artist);
+  const title = asString(r.title);
+  const score = asNumber(r.score);
+  if (artist === void 0) throw new TypeError("StreamCallbackResultEntry: artist not string");
+  if (title === void 0) throw new TypeError("StreamCallbackResultEntry: title not string");
+  if (score === void 0) throw new TypeError("StreamCallbackResultEntry: score not number");
+  const musicbrainz = Array.isArray(r.musicbrainz) ? r.musicbrainz.filter((x) => asObject(x) !== void 0) : void 0;
+  return {
+    artist,
+    title,
+    score,
+    album: asString(r.album),
+    releaseDate: asString(r.release_date),
+    label: asString(r.label),
+    songLink: asString(r.song_link),
+    appleMusic: asObject(r.apple_music),
+    spotify: asObject(r.spotify),
+    deezer: asObject(r.deezer),
+    napster: asObject(r.napster),
+    musicbrainz,
+    extras: pickExtras(r, STREAM_CALLBACK_RESULT_ENTRY_KEYS),
+    rawResponse: r
+  };
+}
+var STREAM_CALLBACK_RESULT_KEYS = [
+  "radio_id",
+  "timestamp",
+  "play_length",
+  "results"
+];
+function parseStreamCallbackResult(raw) {
+  const r = requireObject(raw, "StreamCallbackResult");
+  const radioId = asNumber(r.radio_id);
+  if (radioId === void 0) throw new TypeError("StreamCallbackResult: radio_id not number");
+  const resultsRaw = r.results;
+  if (!Array.isArray(resultsRaw)) throw new TypeError("StreamCallbackResult: results not array");
+  return {
+    radioId,
+    timestamp: asString(r.timestamp),
+    playLength: asNumber(r.play_length),
+    results: resultsRaw.map(parseStreamCallbackResultEntry),
+    extras: pickExtras(r, STREAM_CALLBACK_RESULT_KEYS),
+    rawResponse: r
+  };
+}
+var STREAM_CALLBACK_NOTIFICATION_KEYS = [
+  "radio_id",
+  "stream_running",
+  "notification_code",
+  "notification_message"
+];
+function parseStreamCallbackNotification(raw) {
+  const r = requireObject(raw, "StreamCallbackNotification");
+  const radioId = asNumber(r.radio_id);
+  if (radioId === void 0)
+    throw new TypeError("StreamCallbackNotification: radio_id not number");
+  const code = asNumber(r.notification_code);
+  if (code === void 0)
+    throw new TypeError("StreamCallbackNotification: notification_code not number");
+  const message = asString(r.notification_message);
+  if (message === void 0)
+    throw new TypeError("StreamCallbackNotification: notification_message not string");
+  return {
+    radioId,
+    streamRunning: asBoolean(r.stream_running),
+    notificationCode: code,
+    notificationMessage: message,
+    extras: pickExtras(r, STREAM_CALLBACK_NOTIFICATION_KEYS),
+    rawResponse: r
+  };
+}
+function parseStreamCallback(raw) {
+  const r = requireObject(raw, "StreamCallbackPayload");
+  if ("notification" in r) {
+    const notification = parseStreamCallbackNotification(r.notification);
+    const time = asNumber(r.time) ?? null;
+    return {
+      result: null,
+      notification,
+      time,
+      rawPayload: r,
+      get isResult() {
+        return false;
+      },
+      get isNotification() {
+        return true;
+      }
+    };
+  }
+  const inner = requireObject(r.result, "StreamCallbackPayload.result");
+  const result = parseStreamCallbackResult(inner);
+  return {
+    result,
+    notification: null,
+    time: null,
+    rawPayload: r,
+    get isResult() {
+      return true;
+    },
+    get isNotification() {
+      return false;
+    }
+  };
+}
+var LYRICS_KEYS = [
+  "artist",
+  "title",
+  "lyrics",
+  "song_id",
+  "full_title",
+  "artist_id",
+  "song_link",
+  "media"
+];
+function parseLyricsResult(raw) {
+  const r = requireObject(raw, "LyricsResult");
+  const artist = asString(r.artist);
+  const title = asString(r.title);
+  if (artist === void 0) throw new TypeError("LyricsResult: artist not string");
+  if (title === void 0) throw new TypeError("LyricsResult: title not string");
+  return {
+    artist,
+    title,
+    lyrics: asString(r.lyrics),
+    songId: asNumber(r.song_id),
+    fullTitle: asString(r.full_title),
+    artistId: asNumber(r.artist_id),
+    songLink: asString(r.song_link),
+    media: asString(r.media),
+    extras: pickExtras(r, LYRICS_KEYS),
+    rawResponse: r
+  };
+}
+
+// src/retry.ts
+var DEFAULT_BACKOFF_FACTOR_MS = 500;
+var DEFAULT_BACKOFF_MAX_MS = 3e4;
+var DEFAULT_MAX_ATTEMPTS = 3;
+var HTTP_REQUEST_TIMEOUT = 408;
+var HTTP_TOO_MANY_REQUESTS = 429;
+var HTTP_SERVER_ERROR_FLOOR = 500;
+function defaultPolicy(retryClass) {
+  return {
+    retryClass,
+    maxAttempts: DEFAULT_MAX_ATTEMPTS,
+    backoffFactorMs: DEFAULT_BACKOFF_FACTOR_MS,
+    backoffMaxMs: DEFAULT_BACKOFF_MAX_MS
+  };
+}
+function backoffDelayMs(attempt, policy) {
+  const base = Math.min(policy.backoffFactorMs * 2 ** attempt, policy.backoffMaxMs);
+  return base * (0.5 + Math.random());
+}
+function isAbortError(err) {
+  if (err === null || typeof err !== "object") return false;
+  const e = err;
+  return e.name === "AbortError";
+}
+function isPreUploadConnectionError(err) {
+  if (isAbortError(err)) return false;
+  return err instanceof TypeError;
+}
+function shouldRetryResponse(resp, retryClass) {
+  const s = resp.httpStatus;
+  switch (retryClass) {
+    case "read":
+      return s === HTTP_REQUEST_TIMEOUT || s === HTTP_TOO_MANY_REQUESTS || s >= HTTP_SERVER_ERROR_FLOOR;
+    case "recognition":
+      return s >= HTTP_SERVER_ERROR_FLOOR;
+    case "mutating":
+      return false;
+  }
+}
+function shouldRetryError(err, retryClass) {
+  switch (retryClass) {
+    case "read":
+      return isPreUploadConnectionError(err) || isAbortError(err);
+    case "recognition":
+      return isPreUploadConnectionError(err);
+    case "mutating":
+      return isPreUploadConnectionError(err);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, policy) {
+  let lastError;
+  let lastResp;
+  let haveResp = false;
+  for (let attempt = 0; attempt < policy.maxAttempts; attempt++) {
+    try {
+      const resp = await fn();
+      if (!shouldRetryResponse(resp, policy.retryClass)) return resp;
+      lastResp = resp;
+      haveResp = true;
+      lastError = void 0;
+    } catch (err) {
+      if (!shouldRetryError(err, policy.retryClass)) throw err;
+      lastError = err;
+      haveResp = false;
+      if (attempt + 1 >= policy.maxAttempts) throw err;
+    }
+    if (attempt + 1 >= policy.maxAttempts) break;
+    await sleep(backoffDelayMs(attempt, policy));
+  }
+  if (haveResp && lastResp !== void 0) return lastResp;
+  throw lastError;
+}
+function looksLikeUrl(s) {
+  return s.startsWith("http://") || s.startsWith("https://");
+}
+function isNodeRuntime() {
+  return typeof process !== "undefined" && process.versions !== void 0 && typeof process.versions.node === "string";
+}
+function prepareSource(source) {
+  if (typeof source === "string") {
+    if (looksLikeUrl(source)) {
+      const url = source;
+      return () => Promise.resolve({ fields: { url }, isMultipart: false });
+    }
+    if (!isNodeRuntime()) {
+      throw new TypeError(
+        `Source string ${JSON.stringify(source)} is not an HTTP URL (must start with http:// or https://). Filesystem paths are only supported on Node. In a browser, pass a Blob/File or Uint8Array instead.`
+      );
+    }
+    let exists = false;
+    try {
+      exists = fs.statSync(source).isFile();
+    } catch {
+      exists = false;
+    }
+    if (!exists) {
+      throw new TypeError(
+        `${JSON.stringify(source)} is not an HTTP URL (must start with http:// or https://) and is not an existing file path. Pass a URL, a path, a Blob, or bytes.`
+      );
+    }
+    const filePath = source;
+    const filename = path__namespace.basename(filePath);
+    return async () => {
+      const buf = await fs.promises.readFile(filePath);
+      const blob = new Blob([new Uint8Array(buf)], {
+        type: "application/octet-stream"
+      });
+      const file = new File([blob], filename, { type: "application/octet-stream" });
+      return { fields: { file }, isMultipart: true };
+    };
+  }
+  if (source instanceof URL) {
+    const url = source.toString();
+    return () => Promise.resolve({ fields: { url }, isMultipart: false });
+  }
+  if (typeof Blob !== "undefined" && source instanceof Blob) {
+    const blob = source;
+    const filename = "name" in blob && typeof blob.name === "string" ? blob.name : "upload.bin";
+    return () => {
+      const file = new File([blob], filename, { type: blob.type || "application/octet-stream" });
+      return Promise.resolve({ fields: { file }, isMultipart: true });
+    };
+  }
+  if (source instanceof Uint8Array) {
+    const buf = new Uint8Array(source);
+    return () => {
+      const blob = new Blob([buf], { type: "application/octet-stream" });
+      const file = new File([blob], "upload.bin", { type: "application/octet-stream" });
+      return Promise.resolve({ fields: { file }, isMultipart: true });
+    };
+  }
+  throw new TypeError(
+    `Unsupported source type ${typeof source}; pass a URL string, URL, Blob/File, Uint8Array, or Buffer.`
+  );
+}
+var DuplicateReturnParameterError = class extends AudDInvalidRequestError {
+  name = "DuplicateReturnParameterError";
+  constructor() {
+    super({
+      errorCode: 0,
+      message: "URL already contains a `return` query parameter; pass returnMetadata: undefined or remove the parameter from the URL \u2014 refusing to silently overwrite.",
+      httpStatus: 0,
+      requestId: null,
+      requestedParams: {},
+      requestMethod: null,
+      brandedMessage: null,
+      rawResponse: null
+    });
+  }
+};
+function deriveLongpollCategory(apiToken, radioId) {
+  const inner = crypto.createHash("md5").update(apiToken, "utf8").digest("hex");
+  const full = crypto.createHash("md5").update(inner + String(radioId), "utf8").digest("hex");
+  return full.slice(0, 9);
+}
+function addReturnToUrl(url, returnMetadata) {
+  if (returnMetadata === void 0) return url;
+  const value = Array.isArray(returnMetadata) ? returnMetadata.join(",") : returnMetadata;
+  const u = new URL(url);
+  if (u.searchParams.has("return")) {
+    throw new DuplicateReturnParameterError();
+  }
+  u.searchParams.set("return", value);
+  return u.toString();
+}
+
+// src/streams.ts
+var API_BASE = "https://api.audd.io";
+var NO_CALLBACK_ERROR_CODE = 19;
+var PREFLIGHT_NO_CALLBACK_HINT = "Longpoll won't deliver events because no callback URL is configured for this account. Set one first via streams.setCallbackUrl(...) \u2014 `https://audd.tech/empty/` is fine if you only want longpolling and don't need a real receiver. To skip this check, pass skipCallbackCheck: true.";
+function decodeSuccess(body, httpStatus, requestId) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    throw new AudDSerializationError("Unparseable response");
+  }
+  const obj = body;
+  if (obj.status === "error") {
+    raiseFromErrorResponse(obj, {
+      httpStatus,
+      requestId
+    });
+  }
+  if (obj.status === "success") {
+    return obj.result;
+  }
+  throw new AudDServerError({
+    errorCode: 0,
+    message: `Unexpected response status: ${JSON.stringify(obj.status)}`,
+    httpStatus,
+    requestId,
+    rawResponse: obj
+  });
+}
+async function runRetried(fn, policy) {
+  try {
+    return await retry(fn, policy);
+  } catch (err) {
+    if (err instanceof TypeError) {
+      throw new AudDConnectionError(`Network error: ${err.message}`, err);
+    }
+    if (err !== null && typeof err === "object" && err.name === "AbortError") {
+      throw new AudDConnectionError("Request was aborted (timeout)", err);
+    }
+    throw err;
+  }
+}
+var Streams = class {
+  constructor(http, readPolicy, mutatingPolicy, apiToken) {
+    this.http = http;
+    this.readPolicy = readPolicy;
+    this.mutatingPolicy = mutatingPolicy;
+    this.apiToken = apiToken;
+  }
+  http;
+  readPolicy;
+  mutatingPolicy;
+  apiToken;
+  async post(path2, fields, policy) {
+    const resp = await runRetried(
+      () => this.http.postForm(`${API_BASE}/${path2}/`, fields),
+      policy
+    );
+    return decodeSuccess(resp.jsonBody, resp.httpStatus, resp.requestId);
+  }
+  /**
+   * Set the callback URL where AudD will POST recognition events.
+   *
+   * @param url   The URL to register.
+   * @param opts.returnMetadata Optional metadata block list — appended as
+   * `?return=...` to the URL. Raises `DuplicateReturnParameterError` if the
+   * URL already contains a `?return=` parameter.
+   */
+  async setCallbackUrl(url, opts = {}) {
+    const finalUrl = addReturnToUrl(url, opts.returnMetadata);
+    await this.post("setCallbackUrl", { url: finalUrl }, this.mutatingPolicy);
+  }
+  /** Get the currently registered callback URL. */
+  async getCallbackUrl() {
+    const result = await this.post("getCallbackUrl", {}, this.readPolicy);
+    return String(result);
+  }
+  /** Register a new stream for real-time recognition. */
+  async add(opts) {
+    const fields = {
+      url: opts.url,
+      radio_id: String(opts.radioId)
+    };
+    if (opts.callbacks !== void 0) fields["callbacks"] = opts.callbacks;
+    await this.post("addStream", fields, this.mutatingPolicy);
+  }
+  /** Update the upstream URL of an existing stream. */
+  async setUrl(radioId, url) {
+    await this.post(
+      "setStreamUrl",
+      { radio_id: String(radioId), url },
+      this.mutatingPolicy
+    );
+  }
+  /** Delete an existing stream. */
+  async delete(radioId) {
+    await this.post("deleteStream", { radio_id: String(radioId) }, this.mutatingPolicy);
+  }
+  /** List all streams on this account. */
+  async list() {
+    const result = await this.post("getStreams", {}, this.readPolicy);
+    if (!Array.isArray(result)) return [];
+    return result.map(parseStream);
+  }
+  /** Compute the 9-char longpoll category locally — pure, no network. */
+  deriveLongpollCategory(radioId) {
+    return deriveLongpollCategory(this.apiToken, radioId);
+  }
+  /** Parse a callback POST body into a typed `StreamCallbackPayload`. */
+  parseCallback(body) {
+    return parseStreamCallback(body);
+  }
+  /**
+   * Longpoll the AudD subscription endpoint, yielding parsed JSON dicts
+   * (recognition events, notifications, or `{ timeout: ... }` markers).
+   *
+   * By default, performs a one-time `getCallbackUrl` preflight. If the
+   * server returns code 19 (no callback URL configured), throws
+   * `AudDInvalidRequestError` with an actionable hint. Pass
+   * `skipCallbackCheck: true` to bypass.
+   */
+  longpoll(category, opts = {}) {
+    const skipCheck = opts.skipCallbackCheck ?? false;
+    const timeoutSec = opts.timeout ?? 50;
+    const initialSince = opts.sinceTime;
+    const getCallbackUrl = () => this.getCallbackUrl();
+    const httpGet = (params) => this.http.get(`${API_BASE}/longpoll/`, params);
+    const readPolicy = this.readPolicy;
+    return {
+      [Symbol.asyncIterator]() {
+        let preflighted = skipCheck;
+        let curSince = initialSince;
+        return {
+          async next() {
+            if (!preflighted) {
+              try {
+                await getCallbackUrl();
+              } catch (err) {
+                if (err instanceof AudDAPIError && err.errorCode === NO_CALLBACK_ERROR_CODE) {
+                  throw new AudDInvalidRequestError({
+                    errorCode: 0,
+                    message: PREFLIGHT_NO_CALLBACK_HINT,
+                    httpStatus: err.httpStatus,
+                    requestId: err.requestId
+                  });
+                }
+                throw err;
+              }
+              preflighted = true;
+            }
+            const params = {
+              category,
+              timeout: String(timeoutSec)
+            };
+            if (curSince !== void 0) params["since_time"] = String(curSince);
+            const resp = await runRetried(() => httpGet(params), readPolicy);
+            const body = resp.jsonBody;
+            if (typeof body !== "object" || body === null || Array.isArray(body)) {
+              throw new AudDSerializationError(
+                "Unparseable longpoll response",
+                resp.rawText
+              );
+            }
+            const dict = body;
+            const ts = dict["timestamp"];
+            if (typeof ts === "number") curSince = ts;
+            return { value: dict, done: false };
+          }
+        };
+      }
+    };
+  }
+};
+
+// src/customCatalog.ts
+var UPLOAD_URL = "https://api.audd.io/upload/";
+function decodeSuccess2(body, httpStatus, requestId) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    throw new AudDSerializationError("Unparseable response");
+  }
+  const obj = body;
+  if (obj.status === "error") {
+    raiseFromErrorResponse(obj, {
+      httpStatus,
+      requestId,
+      customCatalogContext: true
+    });
+  }
+  if (obj.status !== "success") {
+    throw new AudDServerError({
+      errorCode: 0,
+      message: `Unexpected status: ${JSON.stringify(obj.status)}`,
+      httpStatus,
+      requestId,
+      rawResponse: obj
+    });
+  }
+}
+async function runRetried2(fn, policy) {
+  try {
+    return await retry(fn, policy);
+  } catch (err) {
+    if (err instanceof TypeError) {
+      throw new AudDConnectionError(`Network error: ${err.message}`, err);
+    }
+    if (err !== null && typeof err === "object" && err.name === "AbortError") {
+      throw new AudDConnectionError("Request was aborted (timeout)", err);
+    }
+    throw err;
+  }
+}
+var CustomCatalog = class {
+  constructor(http, mutatingPolicy) {
+    this.http = http;
+    this.mutatingPolicy = mutatingPolicy;
+  }
+  http;
+  mutatingPolicy;
+  /**
+   * **This is NOT how you submit audio for music recognition.** For
+   * recognition, use `audd.recognize()` (or `audd.recognizeEnterprise()` for
+   * files longer than 25 seconds). This method adds a song to your
+   * **private fingerprint catalog** so AudD's recognition can later identify
+   * *your own* tracks for *your account only*. Requires special access —
+   * contact api@audd.io if you need it enabled.
+   *
+   * Calling this again with the same `audioId` re-fingerprints that slot.
+   * There is no public list/delete endpoint; track `audioId` ↔ song
+   * mappings on your side.
+   */
+  async add(opts) {
+    const reopen = prepareSource(opts.source);
+    const audioId = String(opts.audioId);
+    const resp = await runRetried2(async () => {
+      const prepared = await reopen();
+      const fields = { ...prepared.fields, audio_id: audioId };
+      return this.http.postForm(UPLOAD_URL, fields);
+    }, this.mutatingPolicy);
+    decodeSuccess2(resp.jsonBody, resp.httpStatus, resp.requestId);
+  }
+};
+
+// src/advanced.ts
+var API_BASE2 = "https://api.audd.io";
+async function runRetried3(fn, policy) {
+  try {
+    return await retry(fn, policy);
+  } catch (err) {
+    if (err instanceof TypeError) {
+      throw new AudDConnectionError(`Network error: ${err.message}`, err);
+    }
+    if (err !== null && typeof err === "object" && err.name === "AbortError") {
+      throw new AudDConnectionError("Request was aborted (timeout)", err);
+    }
+    throw err;
+  }
+}
+var Advanced = class {
+  /**
+   * @param recognitionPolicy The findLyrics endpoint is metered and shouldn't
+   * double-bill on post-upload read timeout: Advanced uses RECOGNITION retry
+   * policy, not READ.
+   */
+  constructor(http, recognitionPolicy) {
+    this.http = http;
+    this.recognitionPolicy = recognitionPolicy;
+  }
+  http;
+  recognitionPolicy;
+  /** Find lyrics by free-text query. Returns a list of matches (possibly empty). */
+  async findLyrics(query) {
+    const body = await this.rawRequest("findLyrics", { q: query });
+    if (body["status"] === "error") {
+      raiseFromErrorResponse(body, {
+        httpStatus: 200,
+        requestId: null
+      });
+    }
+    const result = body["result"];
+    if (!Array.isArray(result)) return [];
+    return result.map(parseLyricsResult);
+  }
+  /**
+   * Hit any AudD endpoint by method name and return the raw JSON object.
+   * Useful for endpoints not yet wrapped by typed methods on this SDK.
+   */
+  async rawRequest(method, params = {}) {
+    const fields = {};
+    for (const [k, v] of Object.entries(params)) {
+      if (v === void 0) continue;
+      fields[k] = String(v);
+    }
+    const resp = await runRetried3(
+      () => this.http.postForm(`${API_BASE2}/${method}/`, fields),
+      this.recognitionPolicy
+    );
+    const body = resp.jsonBody;
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+      throw new AudDSerializationError("Unparseable response", resp.rawText);
+    }
+    return body;
+  }
+};
+
+// src/client.ts
+var API_BASE3 = "https://api.audd.io";
+var ENTERPRISE_BASE = "https://enterprise.audd.io";
+var DEPRECATED_PARAMS_CODE = 51;
+var HTTP_CLIENT_ERROR_FLOOR = 400;
+var TOKEN_ENV_VAR = "AUDD_API_TOKEN";
+function safeEmit(hook, event) {
+  if (hook === void 0) return;
+  try {
+    hook(event);
+  } catch {
+  }
+}
+function resolveToken(apiToken) {
+  if (apiToken !== void 0 && apiToken !== "") return apiToken;
+  const env = (typeof process !== "undefined" ? process.env[TOKEN_ENV_VAR] : void 0) ?? "";
+  if (env !== "") return env;
+  throw new Error(
+    `AudD apiToken not supplied and ${TOKEN_ENV_VAR} env var is unset. Get a token at https://dashboard.audd.io and pass it as new AudD("<token>") (or new AudD({ apiToken: "<token>" })), or set AUDD_API_TOKEN.`
+  );
+}
+function formatReturn(value) {
+  if (value === void 0) return void 0;
+  return Array.isArray(value) ? value.join(",") : value;
+}
+function buildEnterpriseFields(opts) {
+  const fields = {};
+  const ret = formatReturn(opts.return);
+  if (ret !== void 0) fields["return"] = ret;
+  if (opts.skip !== void 0) fields["skip"] = String(opts.skip);
+  if (opts.every !== void 0) fields["every"] = String(opts.every);
+  if (opts.limit !== void 0) fields["limit"] = String(opts.limit);
+  if (opts.skipFirstSeconds !== void 0)
+    fields["skip_first_seconds"] = String(opts.skipFirstSeconds);
+  if (opts.useTimecode !== void 0) fields["use_timecode"] = opts.useTimecode ? "true" : "false";
+  if (opts.accurateOffsets !== void 0)
+    fields["accurate_offsets"] = opts.accurateOffsets ? "true" : "false";
+  return fields;
+}
+function isDeprecationPassThrough(body) {
+  return body.error?.error_code === DEPRECATED_PARAMS_CODE && body.result != null;
+}
+function maybeWarnAndStrip(body) {
+  if (!isDeprecationPassThrough(body)) return;
+  const msg = body.error?.error_message ?? "Deprecated parameter used";
+  console.warn(`audd: deprecated parameter \u2014 ${msg}`);
+  delete body.error;
+  body.status = "success";
+}
+function decodeOrRaise(resp) {
+  const body = resp.jsonBody;
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    if (resp.httpStatus >= HTTP_CLIENT_ERROR_FLOOR) {
+      throw new AudDServerError({
+        errorCode: 0,
+        message: `HTTP ${String(resp.httpStatus)} with non-JSON response body`,
+        httpStatus: resp.httpStatus,
+        requestId: resp.requestId,
+        rawResponse: resp.rawText
+      });
+    }
+    throw new AudDSerializationError("Unparseable response", resp.rawText);
+  }
+  const obj = body;
+  maybeWarnAndStrip(obj);
+  if (obj.status === "error") {
+    raiseFromErrorResponse(obj, {
+      httpStatus: resp.httpStatus,
+      requestId: resp.requestId
+    });
+  }
+  if (obj.status === "success") {
+    return obj;
+  }
+  throw new AudDServerError({
+    errorCode: 0,
+    message: `Unexpected response status: ${JSON.stringify(obj.status)}`,
+    httpStatus: resp.httpStatus,
+    requestId: resp.requestId,
+    rawResponse: obj
+  });
+}
+function decodeRecognize(resp) {
+  const body = decodeOrRaise(resp);
+  const result = body["result"];
+  if (result == null) return null;
+  return parseRecognitionResult(result);
+}
+function decodeEnterprise(resp) {
+  const body = decodeOrRaise(resp);
+  const chunks = body["result"];
+  if (!Array.isArray(chunks)) return [];
+  const out = [];
+  for (const c of chunks) {
+    const chunk = parseEnterpriseChunkResult(c);
+    out.push(...chunk.songs);
+  }
+  return out;
+}
+async function runRetried4(fn, policy) {
+  try {
+    return await retry(fn, policy);
+  } catch (err) {
+    if (err instanceof TypeError) {
+      throw new AudDConnectionError(`Network error: ${err.message}`, err);
+    }
+    if (err !== null && typeof err === "object" && err.name === "AbortError") {
+      throw new AudDConnectionError("Request was aborted (timeout)", err);
+    }
+    throw err;
+  }
+}
+var AudD = class {
+  _http;
+  _enterpriseHttp;
+  _maxRetries;
+  _backoffFactorMs;
+  _apiToken;
+  _onEvent;
+  _streams;
+  _customCatalog;
+  _advanced;
+  constructor(arg, extra) {
+    const opts = typeof arg === "string" ? { apiToken: arg, ...extra ?? {} } : arg ?? {};
+    const token = resolveToken(opts.apiToken);
+    this._apiToken = token;
+    this._onEvent = opts.onEvent;
+    this._maxRetries = opts.maxRetries ?? 3;
+    this._backoffFactorMs = opts.backoffFactorMs ?? 500;
+    this._http = new HttpClient({
+      apiToken: token,
+      ...opts.fetch !== void 0 ? { fetch: opts.fetch } : {}
+    });
+    this._enterpriseHttp = new HttpClient({
+      apiToken: token,
+      ...opts.fetch !== void 0 ? { fetch: opts.fetch } : {},
+      defaultTimeoutMs: ENTERPRISE_TIMEOUT_MS
+    });
+  }
+  /** Current api_token. Returns the in-effect token after any rotations. */
+  get apiToken() {
+    return this._apiToken;
+  }
+  /**
+   * Rotate the api_token used for subsequent requests. In-flight requests
+   * continue with the old token (no abort).
+   */
+  setApiToken(newToken) {
+    if (typeof newToken !== "string" || newToken === "") {
+      throw new Error("setApiToken requires a non-empty string");
+    }
+    this._apiToken = newToken;
+    this._http.setApiToken(newToken);
+    this._enterpriseHttp.setApiToken(newToken);
+  }
+  policyFor(retryClass) {
+    return {
+      ...defaultPolicy(retryClass),
+      maxAttempts: this._maxRetries,
+      backoffFactorMs: this._backoffFactorMs
+    };
+  }
+  /** Sub-namespace for stream management + longpoll. Lazy-instantiated. */
+  get streams() {
+    if (this._streams === void 0) {
+      this._streams = new Streams(
+        this._http,
+        this.policyFor("read"),
+        this.policyFor("mutating"),
+        this._apiToken
+      );
+    }
+    return this._streams;
+  }
+  /** Sub-namespace for the private fingerprint catalog. NOT for recognition. */
+  get customCatalog() {
+    if (this._customCatalog === void 0) {
+      this._customCatalog = new CustomCatalog(this._http, this.policyFor("mutating"));
+    }
+    return this._customCatalog;
+  }
+  /** Lyrics search + raw-request escape hatch. */
+  get advanced() {
+    if (this._advanced === void 0) {
+      this._advanced = new Advanced(this._http, this.policyFor("recognition"));
+    }
+    return this._advanced;
+  }
+  /**
+   * Recognize a short audio clip (≤25s) from a URL, file path, Blob, or bytes.
+   *
+   * Returns `null` when the server returns `status=success` with `result=null`
+   * (no match) — distinct from a thrown error.
+   */
+  async recognize(source, opts = {}) {
+    const reopen = prepareSource(source);
+    const ret = formatReturn(opts.return);
+    const market = opts.market;
+    const policy = this.policyFor("recognition");
+    const url = `${API_BASE3}/`;
+    const startedAt = Date.now();
+    safeEmit(this._onEvent, {
+      kind: "request",
+      method: "recognize",
+      url,
+      requestId: null,
+      httpStatus: null,
+      elapsedMs: null,
+      errorCode: null,
+      extras: {}
+    });
+    let resp;
+    try {
+      resp = await runRetried4(async () => {
+        const prepared = await reopen();
+        const fields = { ...prepared.fields };
+        if (ret !== void 0) fields["return"] = ret;
+        if (market !== void 0) fields["market"] = market;
+        return this._http.postForm(url, fields, {
+          ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
+          ...opts.signal !== void 0 ? { signal: opts.signal } : {}
+        });
+      }, policy);
+    } catch (err) {
+      safeEmit(this._onEvent, {
+        kind: "exception",
+        method: "recognize",
+        url,
+        requestId: null,
+        httpStatus: null,
+        elapsedMs: Date.now() - startedAt,
+        errorCode: null,
+        extras: { name: err instanceof Error ? err.name : String(err) }
+      });
+      throw err;
+    }
+    safeEmit(this._onEvent, {
+      kind: "response",
+      method: "recognize",
+      url,
+      requestId: resp.requestId,
+      httpStatus: resp.httpStatus,
+      elapsedMs: Date.now() - startedAt,
+      errorCode: null,
+      extras: {}
+    });
+    return decodeRecognize(resp);
+  }
+  /**
+   * Enterprise recognition (long files). Returns a flat array of matches
+   * across all chunks in the upstream response.
+   *
+   * Recommended: pass `limit: N` to cap result count when developing.
+   */
+  async recognizeEnterprise(source, opts = {}) {
+    const reopen = prepareSource(source);
+    const extra = buildEnterpriseFields(opts);
+    const policy = this.policyFor("recognition");
+    const resp = await runRetried4(async () => {
+      const prepared = await reopen();
+      const fields = { ...prepared.fields, ...extra };
+      return this._enterpriseHttp.postForm(`${ENTERPRISE_BASE}/`, fields, {
+        ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
+        ...opts.signal !== void 0 ? { signal: opts.signal } : {}
+      });
+    }, policy);
+    return decodeEnterprise(resp);
+  }
+  /** Release any underlying resources. (Currently a no-op for `fetch`-based transport.) */
+  close() {
+  }
+  async [Symbol.asyncDispose]() {
+    this.close();
+    await Promise.resolve();
+  }
+};
+
+exports.AudD = AudD;
+exports.AudDAPIError = AudDAPIError;
+exports.AudDAuthenticationError = AudDAuthenticationError;
+exports.AudDBlockedError = AudDBlockedError;
+exports.AudDConnectionError = AudDConnectionError;
+exports.AudDCustomCatalogAccessError = AudDCustomCatalogAccessError;
+exports.AudDError = AudDError;
+exports.AudDInvalidAudioError = AudDInvalidAudioError;
+exports.AudDInvalidRequestError = AudDInvalidRequestError;
+exports.AudDNeedsUpdateError = AudDNeedsUpdateError;
+exports.AudDNotReleasedError = AudDNotReleasedError;
+exports.AudDQuotaError = AudDQuotaError;
+exports.AudDRateLimitError = AudDRateLimitError;
+exports.AudDSerializationError = AudDSerializationError;
+exports.AudDServerError = AudDServerError;
+exports.AudDStreamLimitError = AudDStreamLimitError;
+exports.AudDSubscriptionError = AudDSubscriptionError;
+exports.DuplicateReturnParameterError = DuplicateReturnParameterError;
+exports.VERSION = VERSION;
+exports.addReturnToUrl = addReturnToUrl;
+exports.deriveLongpollCategory = deriveLongpollCategory;
+exports.errorClassForCode = errorClassForCode;
+exports.parseCallback = parseStreamCallback;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map