lunibee 0.3.3 → 0.4.0

package/dist/rest/index.js

@@ -1,2188 +1,61 @@
 // @bun
-// packages/rest/package.json
-var package_default = {
-  name: "@lunibee/rest",
-  version: "0.3.3",
-  type: "module",
-  module: "./src/index.ts",
-  types: "./src/index.ts",
-  exports: {
-    ".": "./src/index.ts"
-  },
-  dependencies: {
-    "@lunibee/types": "workspace:*"
-  }
-};
-
-// packages/rest/src/store.ts
-var GLOBAL_WINDOW_MS = 1050;
-function takeGlobalSlot(log, now, limit, window = GLOBAL_WINDOW_MS) {
-  while (log.length > 0 && log[0] <= now - window)
-    log.shift();
-  if (log.length >= limit)
-    return Math.max(1, log[0] + window - now + 1);
-  log.push(now);
-  return 0;
-}
-var PROBE_POLL_MS = 50;
-var DEFAULT_PROBE_MS = 16000;
-var BUCKET_LINGER_MS = 60000;
-var WINDOW_TOLERANCE_MS = 50;
-function reserveState(state, now, probeMs) {
-  if (state && state.resetAt > now) {
-    if (state.remaining > 0)
-      return {
-        reservation: {
-          granted: true,
-          known: true,
-          resetAt: state.resetAt
-        },
-        next: { ...state, remaining: state.remaining - 1 }
-      };
-    const wait = state.resetAt - now;
-    return {
-      reservation: {
-        granted: false,
-        retryAfterMs: state.provisional ? Math.min(wait, PROBE_POLL_MS) : wait,
-        reason: state.probe ? "probe" : "bucket"
-      }
-    };
-  }
-  const resetAt = now + probeMs;
-  if (state?.limit !== undefined && state.limit > 0)
-    return {
-      reservation: { granted: true, known: true, resetAt },
-      next: {
-        remaining: state.limit - 1,
-        resetAt,
-        limit: state.limit,
-        provisional: true
-      }
-    };
-  return {
-    reservation: { granted: true, known: false, resetAt },
-    next: { remaining: 0, resetAt, provisional: true, probe: true }
-  };
-}
-function reconcileState(state, update, now) {
-  const incoming = update.resetAfterMs === undefined ? undefined : Math.ceil(now + update.resetAfterMs);
-  const active = !!state && state.resetAt > now && !state.probe;
-  let next;
-  if (active) {
-    next = { ...state };
-    const stale = update.window !== undefined && next.window !== undefined && update.window < next.window - WINDOW_TOLERANCE_MS;
-    if (!stale) {
-      if (update.remaining !== undefined)
-        next.remaining = Math.min(next.remaining, update.remaining);
-      if (incoming !== undefined) {
-        const newer = update.window !== undefined && next.window !== undefined && update.window > next.window + WINDOW_TOLERANCE_MS;
-        next.resetAt = next.provisional || newer ? incoming : Math.max(next.resetAt, incoming);
-        delete next.provisional;
-      }
-      if (update.window !== undefined)
-        next.window = Math.max(next.window ?? 0, update.window);
-    }
-  } else {
-    if (update.remaining === undefined && update.retryAfterMs === undefined) {
-      return state?.probe ? null : undefined;
-    }
-    next = {
-      remaining: update.remaining ?? 0,
-      resetAt: incoming ?? now
-    };
-    if (state?.limit !== undefined)
-      next.limit = state.limit;
-    if (update.window !== undefined)
-      next.window = update.window;
-  }
-  if (update.limit !== undefined && update.limit > 0)
-    next.limit = update.limit;
-  if (update.retryAfterMs !== undefined) {
-    next.remaining = 0;
-    next.resetAt = Math.max(next.resetAt, Math.ceil(now + update.retryAfterMs));
-    delete next.provisional;
-  }
-  return next;
-}
-
-class MemoryRateLimitStore {
-  #buckets = new Map;
-  #routeBuckets = new Map;
-  #globals = new Map;
-  #globalLogs = new Map;
-  static #PRUNE_INTERVAL = 60000;
-  #lastPruneAt = 0;
-  static #MAX_ENTRIES = 1e4;
-  reservesGlobal = true;
-  constructor() {}
-  static #evict(map) {
-    while (map.size > MemoryRateLimitStore.#MAX_ENTRIES)
-      map.delete(map.keys().next().value);
-  }
-  getBucketHash(route) {
-    return this.#routeBuckets.get(route);
-  }
-  setBucketHash(route, hash) {
-    this.#routeBuckets.delete(route);
-    this.#routeBuckets.set(route, hash);
-    MemoryRateLimitStore.#evict(this.#routeBuckets);
-  }
-  getBucket(key) {
-    return this.#buckets.get(key);
-  }
-  reserve(key, options = {}) {
-    const now = Date.now();
-    if (options.global !== undefined) {
-      const globalWait = this.getGlobalReset(options.global) - now;
-      if (globalWait > 0)
-        return {
-          granted: false,
-          retryAfterMs: globalWait,
-          reason: "global"
-        };
-    }
-    const limit = options.global === undefined ? 0 : options.globalLimit ?? 0;
-    let log;
-    if (limit > 0) {
-      log = this.#globalLogs.get(options.global);
-      if (!log) {
-        this.#globalLogs.set(options.global, log = []);
-        MemoryRateLimitStore.#evict(this.#globalLogs);
-      }
-      const wait = takeGlobalSlot(log, now, limit);
-      if (wait > 0)
-        return { granted: false, retryAfterMs: wait, reason: "global" };
-      log.pop();
-    }
-    const { reservation, next } = reserveState(this.#buckets.get(key), now, options.probeMs ?? DEFAULT_PROBE_MS);
-    if (log && reservation.granted)
-      log.push(now);
-    if (next)
-      this.#write(key, next);
-    return reservation;
-  }
-  reconcile(key, update) {
-    const next = reconcileState(this.#buckets.get(key), update, Date.now());
-    if (next === null)
-      this.#buckets.delete(key);
-    else if (next)
-      this.#write(key, next);
-  }
-  release(key, grant, refund) {
-    const state = this.#buckets.get(key);
-    if (!state || state.resetAt !== grant.resetAt)
-      return;
-    if (state.probe)
-      this.#buckets.delete(key);
-    else if (refund)
-      state.remaining = Math.min(state.remaining + 1, state.limit ?? Number.POSITIVE_INFINITY);
-  }
-  updateBucket(key, state) {
-    this.#write(key, state);
-  }
-  #write(key, state) {
-    this.#buckets.delete(key);
-    this.#buckets.set(key, state);
-    MemoryRateLimitStore.#evict(this.#buckets);
-    const now = Date.now();
-    if (now - this.#lastPruneAt >= MemoryRateLimitStore.#PRUNE_INTERVAL) {
-      this.#lastPruneAt = now;
-      this.prune(BUCKET_LINGER_MS);
-    }
-  }
-  prune(maxAge = 0) {
-    const cutoff = Date.now() - Math.max(0, maxAge);
-    for (const [key, state] of this.#buckets) {
-      if (state.resetAt <= cutoff)
-        this.#buckets.delete(key);
-    }
-    for (const [scope, resetAt] of this.#globals)
-      if (resetAt <= Date.now())
-        this.#globals.delete(scope);
-    for (const [scope, log] of this.#globalLogs)
-      if ((log.at(-1) ?? 0) <= Date.now() - GLOBAL_WINDOW_MS)
-        this.#globalLogs.delete(scope);
-  }
-  getGlobalReset(scope = "") {
-    return this.#globals.get(scope) ?? 0;
-  }
-  setGlobalReset(resetAt, scope = "") {
-    this.#globals.set(scope, resetAt);
-    MemoryRateLimitStore.#evict(this.#globals);
-  }
-  extendGlobalReset(scope, waitMs) {
-    const resetAt = Date.now() + Math.max(0, waitMs);
-    if (resetAt > this.getGlobalReset(scope))
-      this.setGlobalReset(resetAt, scope);
-  }
-  get size() {
-    return this.#buckets.size;
-  }
-}
-
-// packages/rest/src/errors.ts
-function kindFromStatus(status) {
-  if (status === 429)
-    return "rateLimited";
-  if (status === 401)
-    return "authentication";
-  if (status === 403)
-    return "permission";
-  if (status === 404)
-    return "notFound";
-  if (status === 400 || status === 422)
-    return "validation";
-  if (status >= 500)
-    return "server";
-  if (status === 0)
-    return "network";
-  return "client";
-}
-function redactPath(path) {
-  return path.replace(/^(\/webhooks\/[^/?]+\/)[^/?]+/i, "$1:token").replace(/^(\/interactions\/[^/?]+\/)[^/?]+/i, "$1:token");
-}
-var TOKEN_IN_TEXT = /(\/(?:webhooks|interactions)\/[^/\s?"'`]+\/)[^/\s?"'`]+/gi;
-function redactText(text) {
-  return text.replace(TOKEN_IN_TEXT, "$1:token");
-}
-function sanitizeCause(error) {
-  if (!(error instanceof Error))
-    return;
-  const copy = new Error(redactText(error.message));
-  copy.name = error.name;
-  if (error.stack)
-    copy.stack = redactText(error.stack);
-  for (const key of ["code", "errno", "syscall"]) {
-    const value = error[key];
-    if (typeof value === "string" || typeof value === "number")
-      copy[key] = value;
-  }
-  return copy;
-}
-var HINTS = {
-  50001: "The bot cannot see this resource: check that it is in the guild and has View Channel there.",
-  50013: "The bot lacks a permission for this action, or the target role or member is at or above the bot's highest role."
-};
-
-class RESTError extends Error {
-  kind;
-  status;
-  code;
-  errors;
-  method;
-  path;
-  hint;
-  constructor(message, status, code, errors, options = {}) {
-    super(message, options.cause === undefined ? undefined : { cause: options.cause });
-    this.name = "RESTError";
-    this.status = status;
-    this.kind = options.kind ?? kindFromStatus(status);
-    this.code = code;
-    this.hint = code === undefined ? undefined : HINTS[code];
-    this.errors = errors;
-    this.method = options.method;
-    this.path = options.path === undefined ? undefined : redactPath(options.path);
-  }
-  get retryable() {
-    return this.kind === "rateLimited" || this.kind === "server" || this.kind === "network" || this.kind === "timeout" || this.kind === "coordination" || this.kind === "overloaded";
-  }
-}
-function abortError(path, reason) {
-  return new RESTError(reason instanceof Error ? reason.message : "Discord REST request was aborted", 0, undefined, undefined, { path, cause: reason, kind: "aborted" });
-}
-var MAX_TIMER_MS = 2147483647;
-async function sleep(delay, signal, path) {
-  if (delay <= 0)
-    return;
-  delay = Math.min(delay, MAX_TIMER_MS);
-  await new Promise((resolve, reject) => {
-    const finish = (error) => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", onAbort);
-      if (error)
-        reject(error);
-      else
-        resolve();
-    };
-    const onAbort = () => finish(abortError(path, signal?.reason));
-    const timer = setTimeout(finish, delay);
-    if (signal?.aborted)
-      return onAbort();
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-async function abortable(promise, signal, path) {
-  if (!signal)
-    return promise;
-  if (signal.aborted)
-    throw abortError(path, signal.reason);
-  return new Promise((resolve, reject) => {
-    const onAbort = () => reject(abortError(path, signal.reason));
-    signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, (error) => {
-      signal.removeEventListener("abort", onAbort);
-      reject(error);
-    });
-  });
-}
-
-// packages/rest/src/route.ts
-import { createHash } from "crypto";
-function normalizeRoutePath(path) {
-  const queryIndex = path.indexOf("?");
-  const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
-  return redactPath(routePath).replace(/\/\d+(?=\/|$)/g, "/:id").replace(/\/reactions\/[^/]+/i, "/reactions/:emoji");
-}
-function majorParameter(path) {
-  const match = /^\/(channels|guilds|webhooks)\/(\d+)(?:\/([^/?]+))?/i.exec(path);
-  if (!match)
-    return "@none";
-  if (match[1].toLowerCase() === "webhooks" && match[3] !== undefined)
-    return `${match[2]}:${tokenDigest(match[3])}`;
-  return match[2];
-}
-function tokenDigest(token) {
-  return createHash("sha256").update(token).digest("hex").slice(0, 16);
-}
-function scopeBucket(hashOrRoute, major) {
-  return `${hashOrRoute}|${major}`;
-}
-function createRouteKey(method, path) {
-  const normalizedMethod = method.toUpperCase();
-  return {
-    method: normalizedMethod,
-    path,
-    route: `${normalizedMethod}:${normalizeRoutePath(path)}`,
-    major: majorParameter(path)
-  };
-}
-function serializeQuery(query) {
-  if (query === undefined)
-    return "";
-  if (typeof query === "string")
-    return query.length === 0 || query.startsWith("?") ? query : `?${query}`;
-  const params = query instanceof URLSearchParams ? query : new URLSearchParams(Object.entries(query).flatMap(([key, value]) => value === undefined || value === null ? [] : [[key, String(value)]]));
-  const serialized = params.toString();
-  return serialized.length === 0 ? "" : `?${serialized}`;
-}
-
-// packages/rest/src/scheduler.ts
-class RequestScheduler {
-  static MAX_REMAPS = 2;
-  #queues = new Map;
-  #waiting = new Map;
-  #queued = 0;
-  #maxQueued;
-  #maxQueuedPerBucket;
-  constructor(options = {}) {
-    this.#maxQueued = options.maxQueued ?? Number.POSITIVE_INFINITY;
-    this.#maxQueuedPerBucket = options.maxQueuedPerBucket ?? Number.POSITIVE_INFINITY;
-    if (!(this.#maxQueued >= 0) || !(this.#maxQueuedPerBucket >= 0))
-      throw new RangeError("Queue limits must be non-negative numbers.");
-  }
-  get size() {
-    return this.#queues.size;
-  }
-  get queued() {
-    return this.#queued;
-  }
-  async runResolved(resolveKey, signal, path, task) {
-    let key = await resolveKey();
-    for (let hop = 0;hop < RequestScheduler.MAX_REMAPS; hop++) {
-      const outcome = await this.run(key, signal, path, async (release) => {
-        const current = await resolveKey();
-        if (current !== key)
-          return { done: false, key: current };
-        return { done: true, value: await task(key, release) };
-      });
-      if (outcome.done)
-        return outcome.value;
-      key = outcome.key;
-    }
-    return this.run(key, signal, path, (release) => task(key, release));
-  }
-  async run(key, signal, path, task) {
-    const previous = this.#queues.get(key);
-    const waiting = this.#waiting.get(key) ?? 0;
-    if (previous && (this.#queued >= this.#maxQueued || waiting >= this.#maxQueuedPerBucket))
-      throw new RESTError("The REST request queue is full; request not sent.", 0, undefined, undefined, { path, kind: "overloaded" });
-    let open;
-    const gate = new Promise((resolve) => {
-      open = resolve;
-    });
-    this.#queues.set(key, gate);
-    let released = false;
-    const release = () => {
-      if (released)
-        return;
-      released = true;
-      open();
-      if (this.#queues.get(key) === gate)
-        this.#queues.delete(key);
-    };
-    try {
-      if (previous) {
-        this.#queued++;
-        this.#waiting.set(key, waiting + 1);
-        try {
-          await abortable(previous, signal, path);
-        } finally {
-          this.#queued--;
-          const left = (this.#waiting.get(key) ?? 1) - 1;
-          if (left > 0)
-            this.#waiting.set(key, left);
-          else
-            this.#waiting.delete(key);
-        }
-      } else
-        await abortable(Promise.resolve(), signal, path);
-      return await task(release);
-    } finally {
-      release();
-    }
-  }
-}
-
-// packages/rest/src/headers.ts
-function headerNumber(headers, name) {
-  const raw = headers.get(name);
-  if (raw === null || raw.trim() === "")
-    return;
-  const value = Number(raw);
-  return Number.isFinite(value) && value >= 0 ? value : undefined;
-}
-var BUCKET_HASH = /^[A-Za-z0-9:_\-.]{1,64}$/;
-var MAX_COUNT = 1e5;
-function count(value) {
-  return value === undefined || value > MAX_COUNT ? undefined : Math.floor(value);
-}
-function parseRateLimitHeaders(headers) {
-  const remaining = headerNumber(headers, "X-RateLimit-Remaining");
-  const limit = headerNumber(headers, "X-RateLimit-Limit");
-  const resetAfter = headerNumber(headers, "X-RateLimit-Reset-After");
-  const reset = headerNumber(headers, "X-RateLimit-Reset");
-  const retryAfter = headerNumber(headers, "Retry-After");
-  const bucket = headers.get("X-RateLimit-Bucket")?.trim();
-  const scope = headers.get("X-RateLimit-Scope")?.trim().toLowerCase();
-  return {
-    limit: count(limit),
-    remaining: count(remaining),
-    resetAfterMs: resetAfter === undefined ? undefined : resetAfter * 1000,
-    resetAtMs: reset === undefined ? undefined : reset * 1000,
-    bucket: bucket && BUCKET_HASH.test(bucket) ? bucket : undefined,
-    scope: scope === "user" || scope === "global" || scope === "shared" ? scope : undefined,
-    global: headers.get("X-RateLimit-Global")?.trim().toLowerCase() === "true",
-    retryAfterMs: retryAfter === undefined ? undefined : retryAfter * 1000
-  };
-}
-
-// packages/rest/src/telemetry.ts
-function emitTelemetry(sink, event) {
-  if (!sink)
-    return;
-  try {
-    sink.emit(event);
-  } catch {}
-}
-var LATENCY_BOUNDS = [
-  1,
-  5,
-  10,
-  25,
-  50,
-  100,
-  250,
-  500,
-  1000,
-  2500,
-  5000,
-  1e4,
-  30000,
-  60000
-];
-
-class RESTMetrics {
-  #counters = new Map;
-  #gauges = new Map;
-  #histograms = new Map;
-  #routes = new Set;
-  #maxRoutes;
-  constructor(options = {}) {
-    this.#maxRoutes = options.maxRoutes ?? 500;
-  }
-  #route(route) {
-    if (this.#routes.has(route))
-      return route;
-    if (this.#routes.size >= this.#maxRoutes)
-      return "other";
-    this.#routes.add(route);
-    return route;
-  }
-  #inc(name, labels = {}, by = 1) {
-    const key = metricKey(name, labels);
-    this.#counters.set(key, (this.#counters.get(key) ?? 0) + by);
-  }
-  #observe(name, value, labels = {}) {
-    const key = metricKey(name, labels);
-    let h = this.#histograms.get(key);
-    if (!h) {
-      h = {
-        counts: new Array(LATENCY_BOUNDS.length + 1).fill(0),
-        sum: 0,
-        count: 0
-      };
-      this.#histograms.set(key, h);
-    }
-    let i = LATENCY_BOUNDS.findIndex((bound) => value <= bound);
-    if (i === -1)
-      i = LATENCY_BOUNDS.length;
-    h.counts[i]++;
-    h.sum += value;
-    h.count++;
-  }
-  emit(event) {
-    switch (event.type) {
-      case "response":
-        this.#inc("responses_total", {
-          method: event.method,
-          route: this.#route(event.route),
-          status: String(event.status)
-        });
-        this.#observe("response_latency_ms", event.durationMs, {
-          method: event.method
-        });
-        break;
-      case "request":
-        this.#inc("requests_total", {
-          method: event.method,
-          outcome: event.ok ? "ok" : "error"
-        });
-        this.#observe("request_latency_ms", event.durationMs, {
-          method: event.method
-        });
-        break;
-      case "rateLimited":
-        this.#inc("rate_limited_total", {
-          scope: event.scope,
-          route: this.#route(event.route)
-        });
-        break;
-      case "wait":
-        this.#inc("waits_total", { reason: event.reason });
-        this.#observe("wait_ms", event.durationMs, {
-          reason: event.reason
-        });
-        break;
-      case "reservation":
-        this.#inc("reservations_total", {
-          outcome: event.granted ? "granted" : "refused"
-        });
-        this.#observe("reservation_latency_ms", event.latencyMs);
-        break;
-      case "retry":
-        this.#inc("retries_total", { reason: event.reason });
-        break;
-      case "cancelled":
-        this.#inc("cancellations_total", { stage: event.stage });
-        break;
-      case "overloaded":
-        this.#inc("overloaded_total");
-        break;
-      case "tokenRejected":
-        this.#inc("token_rejected_total");
-        break;
-      case "networkError":
-        this.#inc("network_errors_total", {
-          timeout: String(event.timedOut)
-        });
-        break;
-      case "bucket":
-        this.#inc("bucket_changes_total", { change: event.change });
-        break;
-      case "store":
-        this.#inc("store_commands_total", {
-          operation: event.operation,
-          ok: String(event.ok)
-        });
-        this.#observe("store_latency_ms", event.latencyMs, {
-          operation: event.operation
-        });
-        break;
-      case "mode":
-        this.#inc("mode_changes_total", { mode: event.mode });
-        this.#gauges.set("degraded", event.mode === "degraded-local" || event.mode === "unavailable" ? 1 : 0);
-        break;
-      case "queue":
-        this.#gauges.set("queued", event.queued);
-        this.#gauges.set("in_flight", event.inFlight);
-        break;
-    }
-  }
-  snapshot() {
-    const histograms = {};
-    for (const [key, h] of this.#histograms) {
-      const buckets = {};
-      let running = 0;
-      LATENCY_BOUNDS.forEach((bound, i) => {
-        running += h.counts[i];
-        buckets[String(bound)] = running;
-      });
-      buckets["+Inf"] = h.count;
-      histograms[key] = { count: h.count, sum: h.sum, buckets };
-    }
-    return {
-      counters: Object.fromEntries(this.#counters),
-      gauges: Object.fromEntries(this.#gauges),
-      histograms
-    };
-  }
-  reset() {
-    this.#counters.clear();
-    this.#gauges.clear();
-    this.#histograms.clear();
-    this.#routes.clear();
-  }
-  toPrometheus(prefix = "lunibee_rest") {
-    const lines = [];
-    const typed = new Set;
-    const type = (name, kind) => {
-      if (typed.has(name))
-        return;
-      typed.add(name);
-      lines.push(`# TYPE ${name} ${kind}`);
-    };
-    for (const [key, value] of this.#counters) {
-      const name = `${prefix}_${key.split("{")[0]}`;
-      type(name, "counter");
-      lines.push(`${prefix}_${key} ${value}`);
-    }
-    for (const [key, value] of this.#gauges) {
-      type(`${prefix}_${key}`, "gauge");
-      lines.push(`${prefix}_${key} ${value}`);
-    }
-    for (const [key, h] of this.#histograms) {
-      const [base, rawLabels = ""] = key.split("{");
-      const labels = rawLabels.replace(/\}$/, "");
-      const name = `${prefix}_${base}`;
-      type(name, "histogram");
-      const join = (extra) => `{${[labels, extra].filter(Boolean).join(",")}}`;
-      let running = 0;
-      LATENCY_BOUNDS.forEach((bound, i) => {
-        running += h.counts[i];
-        lines.push(`${name}_bucket${join(`le="${bound}"`)} ${running}`);
-      });
-      lines.push(`${name}_bucket${join('le="+Inf"')} ${h.count}`);
-      lines.push(`${name}_sum${labels ? `{${labels}}` : ""} ${h.sum}`);
-      lines.push(`${name}_count${labels ? `{${labels}}` : ""} ${h.count}`);
-    }
-    return `${lines.join(`
-`)}
-`;
-  }
-}
-function metricKey(name, labels) {
-  const entries = Object.entries(labels);
-  if (entries.length === 0)
-    return name;
-  return `${name}{${entries.map(([k, v]) => `${k}="${v.replace(/["\\\n]/g, "_")}"`).join(",")}}`;
-}
-
-// packages/rest/src/limiter.ts
-var DEFAULT_MAX_BACKOFF_MS = 600000;
-var MAX_IDLE_REFUSALS = 16;
-var MAX_CACHED_ROUTES = 1e4;
-
-class RateLimiter {
-  #store;
-  #maxBackoff;
-  #telemetry;
-  #probeMs;
-  #routes = new Map;
-  #globalLimit;
-  #localGlobal = new Map;
-  constructor(store, options = {}) {
-    this.#store = store;
-    this.#maxBackoff = options.maxBackoff ?? DEFAULT_MAX_BACKOFF_MS;
-    if (!(this.#maxBackoff >= 0))
-      throw new RangeError("maxBackoff must be a non-negative number.");
-    this.#probeMs = options.probeMs ?? DEFAULT_PROBE_MS;
-    if (!(this.#probeMs > 0))
-      throw new RangeError("probeMs must be a positive number.");
-    this.#telemetry = options.telemetry;
-    this.#globalLimit = options.globalLimit ?? 0;
-    if (!(this.#globalLimit >= 0) || !Number.isFinite(this.#globalLimit))
-      throw new RangeError("globalLimit must be a non-negative number.");
-  }
-  get maxBackoff() {
-    return this.#maxBackoff;
-  }
-  #capWait(ms) {
-    return Math.min(Math.max(0, ms), this.#maxBackoff);
-  }
-  get store() {
-    return this.#store;
-  }
-  get reserves() {
-    return typeof this.#store.reserve === "function";
-  }
-  #cacheRoute(route, hash) {
-    this.#routes.delete(route);
-    this.#routes.set(route, hash);
-    if (this.#routes.size > MAX_CACHED_ROUTES)
-      this.#routes.delete(this.#routes.keys().next().value);
-  }
-  async resolveBucketKey(route, major, identity) {
-    let hash = this.#routes.get(`${route}\x00${major}`) ?? this.#routes.get(route);
-    if (hash === undefined) {
-      hash = await this.#store.getBucketHash(route);
-      if (hash !== undefined)
-        this.#cacheRoute(route, hash);
-    }
-    const key = scopeBucket(hash ?? route, major);
-    return identity === undefined ? key : `${identity}/${key}`;
-  }
-  async#call(path, operation, call) {
-    try {
-      return await call();
-    } catch (error) {
-      if (error instanceof RESTError)
-        throw error;
-      throw new RESTError(`The rate-limit store failed (${operation}); request not sent.`, 0, undefined, undefined, { path, kind: "coordination", cause: sanitizeCause(error) });
-    }
-  }
-  async acquire(bucketKey, signal, path, options = {}) {
-    const store = this.#store;
-    const global = "global" in options ? options.global : "";
-    if (!store.reserve) {
-      await this.#waitGlobal(global ?? "", signal, path);
-      if (global !== undefined)
-        await this.#localGlobalSlot(global, signal, path);
-      const bucket = await this.#call(path, "getBucket", () => store.getBucket(bucketKey));
-      if (bucket) {
-        const delay = bucket.resetAt - Date.now();
-        if (bucket.remaining <= 0 && delay > 0)
-          await this.#wait("bucket", delay, signal, path);
-      }
-      return {
-        reserved: false,
-        known: !!bucket && bucket.resetAt > Date.now()
-      };
-    }
-    const started = performance.now();
-    let idle = 0;
-    for (;; ) {
-      if (global !== undefined && !store.reservesGlobal) {
-        await this.#waitGlobal(global, signal, path);
-        await this.#localGlobalSlot(global, signal, path);
-      }
-      const asked = performance.now();
-      const reservation = await this.#call(path, "reserve", () => store.reserve(bucketKey, {
-        global,
-        probeMs: this.#probeMs,
-        globalLimit: this.#globalLimit || undefined
-      }));
-      if (!reservation || typeof reservation !== "object" || typeof reservation.granted !== "boolean")
-        throw new RESTError("The rate-limit store returned an invalid reservation; request not sent.", 0, undefined, undefined, { path, kind: "coordination" });
-      if (reservation.granted) {
-        let known = reservation.known;
-        if (known === undefined) {
-          const bucket = await this.#call(path, "getBucket", () => store.getBucket(bucketKey));
-          known = !!bucket && bucket.resetAt > Date.now();
-        }
-        emitTelemetry(this.#telemetry, {
-          type: "reservation",
-          granted: true,
-          known,
-          latencyMs: performance.now() - asked
-        });
-        return { reserved: true, known, resetAt: reservation.resetAt };
-      }
-      emitTelemetry(this.#telemetry, {
-        type: "reservation",
-        granted: false,
-        known: true,
-        latencyMs: performance.now() - asked
-      });
-      let wait = Number(reservation.retryAfterMs);
-      if (!(wait > 0)) {
-        if (++idle > MAX_IDLE_REFUSALS)
-          throw new RESTError("The rate-limit store keeps refusing without a wait; request not sent.", 0, undefined, undefined, { path, kind: "coordination" });
-        wait = Math.min(100, 2 ** idle);
-      } else
-        idle = 0;
-      if (performance.now() - started + wait > 2 * this.#maxBackoff)
-        throw new RESTError(`Waited for the rate limit longer than twice maxBackoff (${Math.ceil(this.#maxBackoff / 1000)}s); request not sent.`, 429, undefined, undefined, { path });
-      await this.#wait(reservation.reason ?? "bucket", wait, signal, path);
-    }
-  }
-  async#wait(reason, delay, signal, path) {
-    const ms = Math.min(delay, this.#maxBackoff);
-    await sleep(ms, signal, path);
-    emitTelemetry(this.#telemetry, {
-      type: "wait",
-      reason,
-      durationMs: ms
-    });
-  }
-  async#localGlobalSlot(scope, signal, path) {
-    if (!this.#globalLimit)
-      return;
-    let log = this.#localGlobal.get(scope);
-    if (!log) {
-      this.#localGlobal.set(scope, log = []);
-      if (this.#localGlobal.size > MAX_CACHED_ROUTES)
-        this.#localGlobal.delete(this.#localGlobal.keys().next().value);
-    }
-    for (;; ) {
-      const wait = takeGlobalSlot(log, Date.now(), this.#globalLimit);
-      if (wait === 0)
-        return;
-      await this.#wait("global", wait, signal, path);
-    }
-  }
-  async#waitGlobal(scope, signal, path) {
-    const globalDelay = await this.#call(path, "getGlobalReset", () => this.#store.getGlobalReset(scope)) - Date.now();
-    if (globalDelay > 0)
-      await this.#wait("global", globalDelay, signal, path);
-  }
-  async noteGlobalReset(resetAt, scope = "") {
-    const waitMs = this.#capWait(resetAt - Date.now());
-    if (this.#store.extendGlobalReset) {
-      await this.#store.extendGlobalReset(scope, waitMs);
-      return;
-    }
-    const current = await this.#store.getGlobalReset(scope);
-    const target = Date.now() + waitMs;
-    if (target > current)
-      await this.#store.setGlobalReset(target, scope);
-  }
-  retryAfterMs(response, body = {}) {
-    const fromBody = body.retry_after;
-    if (typeof fromBody === "number" && Number.isFinite(fromBody) && fromBody >= 0)
-      return fromBody * 1000;
-    const headers = parseRateLimitHeaders(response.headers);
-    return headers.retryAfterMs ?? headers.resetAfterMs ?? 1000;
-  }
-  async applyResponse(response, bucketKey, route, major, options = {}) {
-    const headers = parseRateLimitHeaders(response.headers);
-    let currentKey = bucketKey;
-    if (headers.bucket) {
-      const previous = this.#routes.get(route);
-      this.#cacheRoute(`${route}\x00${major}`, headers.bucket);
-      if (previous !== headers.bucket) {
-        await this.#store.setBucketHash(route, headers.bucket);
-        this.#cacheRoute(route, headers.bucket);
-        emitTelemetry(this.#telemetry, {
-          type: "bucket",
-          change: previous === undefined ? "discovered" : "remapped",
-          route
-        });
-      }
-      const key = scopeBucket(headers.bucket, major);
-      currentKey = options.identity === undefined ? key : `${options.identity}/${key}`;
-    }
-    const limited = response.status === 429;
-    const retryAfterMs = limited ? this.#capWait(this.retryAfterMs(response, options.body)) : undefined;
-    const global = limited && (options.body?.global === true || headers.global || headers.scope === "global");
-    const onGlobal = global && options.global !== undefined;
-    let resetAfterMs = headers.resetAfterMs;
-    if (resetAfterMs === undefined && headers.resetAtMs !== undefined)
-      resetAfterMs = Math.max(0, headers.resetAtMs - Date.now());
-    const update = {
-      remaining: headers.remaining,
-      resetAfterMs: resetAfterMs === undefined ? undefined : this.#capWait(resetAfterMs),
-      limit: headers.limit,
-      window: headers.resetAtMs !== undefined && Math.abs(headers.resetAtMs - Date.now()) <= this.#maxBackoff ? headers.resetAtMs : undefined,
-      retryAfterMs: limited && !onGlobal ? retryAfterMs : undefined
-    };
-    if (this.#store.reconcile)
-      await this.#store.reconcile(currentKey, update);
-    else {
-      const next = reconcileState(await this.#store.getBucket(currentKey), update, Date.now());
-      if (next === null)
-        await this.#store.updateBucket(currentKey, {
-          remaining: 0,
-          resetAt: 0
-        });
-      else if (next)
-        await this.#store.updateBucket(currentKey, next);
-    }
-    if (currentKey !== bucketKey && options.grant?.reserved && this.#store.release)
-      await this.#store.release(bucketKey, options.grant, false);
-    if (onGlobal)
-      await this.noteGlobalReset(Date.now() + retryAfterMs, options.global);
-    return currentKey;
-  }
-  async releaseGrant(bucketKey, grant, notSent) {
-    if (!grant.reserved || !this.#store.release)
-      return;
-    try {
-      await this.#store.release(bucketKey, grant, notSent);
-    } catch {}
-  }
-}
-
-// packages/rest/src/identity.ts
-import { createHash as createHash2 } from "crypto";
-function tokenFingerprint(token) {
-  return createHash2("sha256").update(token).digest("hex").slice(0, 16);
-}
-function requestIdentity(path, fingerprint) {
-  if (/^\/interactions\//i.test(path))
-    return { bucket: "shared" };
-  if (/^\/webhooks\/[^/?]+\/[^/?]+/i.test(path))
-    return { bucket: "shared", global: fingerprint ?? "anon" };
-  if (!fingerprint)
-    return { bucket: "anon", global: "anon" };
-  return { bucket: fingerprint, global: fingerprint };
-}
-
-// packages/rest/src/transport.ts
-var LOOPBACK = /^(?:localhost|127(?:\.\d{1,3}){3}|\[::1\])$/i;
-function parseBaseURL(raw, allowInsecure = false) {
-  let url;
-  try {
-    url = new URL(raw);
-  } catch {
-    throw new TypeError("baseURL must be an absolute http(s) URL.");
-  }
-  if (url.protocol !== "https:" && url.protocol !== "http:")
-    throw new TypeError("baseURL must use https.");
-  if (url.username || url.password)
-    throw new TypeError("baseURL must not contain credentials.");
-  if (url.search || url.hash || /[?#]/.test(raw))
-    throw new TypeError("baseURL must not contain a query or fragment.");
-  if (url.protocol === "http:" && !allowInsecure && !LOOPBACK.test(url.hostname))
-    throw new TypeError("baseURL must use https: the bot token would travel in cleartext (allowInsecureBaseURL: true overrides this for a trusted network).");
-  return url.href.replace(/\/$/, "");
-}
-
-class TransportError extends Error {
-  timedOut;
-  constructor(message, timedOut, cause) {
-    super(message, cause === undefined ? undefined : { cause });
-    this.name = "TransportError";
-    this.timedOut = timedOut;
-  }
-}
-
-class HttpTransport {
-  #baseURL;
-  #timeout;
-  #fetch;
-  constructor(options = {}) {
-    this.#baseURL = parseBaseURL(options.baseURL ?? "https://discord.com/api/v10", options.allowInsecureBaseURL);
-    this.#timeout = Math.max(1, options.timeout ?? 15000);
-    this.#fetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
-  }
-  get baseURL() {
-    return this.#baseURL;
-  }
-  get timeout() {
-    return this.#timeout;
-  }
-  async send(request) {
-    if (request.signal?.aborted)
-      throw abortError(request.path, request.signal.reason);
-    const controller = new AbortController;
-    const onAbort = () => controller.abort(request.signal?.reason);
-    request.signal?.addEventListener("abort", onAbort, { once: true });
-    const timer = setTimeout(() => controller.abort(new DOMException("REST request timeout", "TimeoutError")), this.#timeout);
-    try {
-      return await this.#fetch(`${this.#baseURL}${request.path}`, {
-        method: request.method,
-        headers: request.headers,
-        body: request.body,
-        signal: controller.signal,
-        redirect: "error"
-      });
-    } catch (error) {
-      if (error instanceof RESTError)
-        throw error;
-      const timedOut = error instanceof DOMException && (error.name === "TimeoutError" || error.name === "AbortError");
-      throw new TransportError(timedOut ? `Discord REST request timed out after ${this.#timeout}ms` : "Discord REST request failed", timedOut, sanitizeCause(error));
-    } finally {
-      clearTimeout(timer);
-      request.signal?.removeEventListener("abort", onAbort);
-    }
-  }
-}
-
-// packages/rest/src/decoder.ts
-class ResponseDecoder {
-  constructor() {}
-  async read(response) {
-    if (response.status === 204)
-      return;
-    const contentType = response.headers.get("content-type") ?? "";
-    if (contentType.includes("application/json"))
-      return response.json().catch(() => {
-        return;
-      });
-    return response.text().catch(() => {
-      return;
-    });
-  }
-  errorData(payload) {
-    if (!payload || typeof payload !== "object")
-      return {};
-    const data = payload;
-    return {
-      message: typeof data.message === "string" ? data.message : undefined,
-      code: typeof data.code === "number" ? data.code : undefined,
-      retry_after: typeof data.retry_after === "number" ? data.retry_after : undefined,
-      global: data.global === true
-    };
-  }
-  retryAfter(response, data) {
-    const raw = response.headers.get("Retry-After");
-    const header = raw === null ? Number.NaN : Number(raw);
-    const retryAfter = data.retry_after ?? (Number.isFinite(header) ? header : 1);
-    return Math.max(0, retryAfter);
-  }
-}
-
-// packages/rest/src/routes.ts
-var Routes = {
-  user: () => "/users/@me",
-  userById: (userId) => `/users/${snowflake(userId, "User ID")}`,
-  guild: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}`,
-  currentUserGuild: (guildId) => `/users/@me/guilds/${snowflake(guildId, "Guild ID")}`,
-  sticker: (stickerId) => `/stickers/${snowflake(stickerId, "Sticker ID")}`,
-  messageReactionUser: (channelId, messageId, emoji, userId) => `${Routes.messageReactions(channelId, messageId, emoji)}/${snowflake(userId, "User ID")}`,
-  guildPreview: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/preview`,
-  guildActiveThreads: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/threads/active`,
-  guildWebhooks: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/webhooks`,
-  guildInvites: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/invites`,
-  guildChannels: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/channels`,
-  guildMember: (guildId, userId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/${snowflake(userId, "User ID")}`,
-  guildRoles: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/roles`,
-  guildRole: (guildId, roleId) => `/guilds/${snowflake(guildId, "Guild ID")}/roles/${snowflake(roleId, "Role ID")}`,
-  guildMemberRole: (guildId, userId, roleId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/${snowflake(userId, "User ID")}/roles/${snowflake(roleId, "Role ID")}`,
-  guildBans: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/bans`,
-  guildBan: (guildId, userId) => `/guilds/${snowflake(guildId, "Guild ID")}/bans/${snowflake(userId, "User ID")}`,
-  channel: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}`,
-  channelMessages: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/messages`,
-  message: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/${snowflake(messageId, "Message ID")}`,
-  crosspostMessage: (channelId, messageId) => `${Routes.message(channelId, messageId)}/crosspost`,
-  messageReactions: (channelId, messageId, emoji) => `${Routes.message(channelId, messageId)}/reactions/${encodeURIComponent(emoji)}`,
-  messageReactionMe: (channelId, messageId, emoji) => `${Routes.messageReactions(channelId, messageId, emoji)}/@me`,
-  messageReactionsAll: (channelId, messageId) => `${Routes.message(channelId, messageId)}/reactions`,
-  channelMessagesPins: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/pins`,
-  channelMessagesPin: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/pins/${snowflake(messageId, "Message ID")}`,
-  messageThread: (channelId, messageId) => `${Routes.message(channelId, messageId)}/threads`,
-  channelBulkDelete: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/messages/bulk-delete`,
-  channelWebhooks: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/webhooks`,
-  channelInvites: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/invites`,
-  webhook: (webhookId, token) => `/webhooks/${snowflake(webhookId, "Webhook ID")}${token ? `/${encodeURIComponent(token)}` : ""}`,
-  webhookMessage: (webhookId, token, messageId) => `/webhooks/${snowflake(webhookId, "Webhook ID")}/${encodeURIComponent(token)}/messages/${snowflake(messageId, "Message ID")}`,
-  applicationCommands: (applicationId) => `/applications/${snowflake(applicationId, "Application ID")}/commands`,
-  applicationCommand: (applicationId, commandId) => `/applications/${snowflake(applicationId, "Application ID")}/commands/${snowflake(commandId, "Command ID")}`,
-  guildApplicationCommands: (applicationId, guildId) => `/applications/${snowflake(applicationId, "Application ID")}/guilds/${snowflake(guildId, "Guild ID")}/commands`,
-  guildApplicationCommand: (applicationId, guildId, commandId) => `/applications/${snowflake(applicationId, "Application ID")}/guilds/${snowflake(guildId, "Guild ID")}/commands/${snowflake(commandId, "Command ID")}`,
-  interactionCallback: (interactionId, token) => `/interactions/${snowflake(interactionId, "Interaction ID")}/${encodeURIComponent(token)}/callback`,
-  interactionOriginalResponse: (applicationId, token) => `/webhooks/${snowflake(applicationId, "Application ID")}/${encodeURIComponent(token)}/messages/@original`,
-  channelPublicArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/public`,
-  channelPrivateArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/private`,
-  channelJoinedPrivateArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/users/@me/threads/archived/private`,
-  threadMember: (threadId, userId) => `/channels/${snowflake(threadId, "Thread ID")}/thread-members/${userOrMe(userId)}`,
-  channelTyping: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/typing`,
-  channelThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads`,
-  threadMembers: (threadId) => `/channels/${snowflake(threadId, "Thread ID")}/thread-members`,
-  guildScheduledEvents: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events`,
-  guildScheduledEvent: (guildId, eventId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events/${snowflake(eventId, "Event ID")}`,
-  guildScheduledEventUsers: (guildId, eventId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events/${snowflake(eventId, "Event ID")}/users`,
-  channelPermission: (channelId, overwriteId) => `/channels/${snowflake(channelId, "Channel ID")}/permissions/${snowflake(overwriteId, "Overwrite ID")}`,
-  guildAutoModerationRules: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules`,
-  guildAutoModerationRule: (guildId, ruleId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules/${snowflake(ruleId, "Rule ID")}`,
-  voiceRegions: () => "/voice/regions",
-  gateway: () => "/gateway",
-  gatewayBot: () => "/gateway/bot",
-  guildAuditLog: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/audit-logs`,
-  guildMembers: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/members`,
-  guildMembersSearch: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/search`,
-  guildMemberMe: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/@me`,
-  guildBulkBan: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/bulk-ban`,
-  guildVoiceState: (guildId, userId) => `/guilds/${snowflake(guildId, "Guild ID")}/voice-states/${userOrMe(userId)}`,
-  guildIntegration: (guildId, integrationId) => `/guilds/${snowflake(guildId, "Guild ID")}/integrations/${snowflake(integrationId, "Integration ID")}`,
-  userGuilds: () => "/users/@me/guilds",
-  stickerPacks: (packId) => packId ? `/sticker-packs/${snowflake(packId, "Sticker pack ID")}` : "/sticker-packs",
-  guildWelcomeScreen: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/welcome-screen`,
-  guildOnboarding: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/onboarding`,
-  guildPrune: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/prune`,
-  stageInstances: () => "/stage-instances",
-  stageInstanceByChannel: (channelId) => `/stage-instances/${snowflake(channelId, "Channel ID")}`,
-  invite: (code) => `/invites/${encodeURIComponent(code)}`,
-  guildVanity: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/vanity-url`,
-  guildEmoji: (guildId, emojiId) => emojiId ? `/guilds/${snowflake(guildId, "Guild ID")}/emojis/${snowflake(emojiId, "Emoji ID")}` : `/guilds/${snowflake(guildId, "Guild ID")}/emojis`,
-  applicationEmoji: (applicationId, emojiId) => emojiId ? `/applications/${snowflake(applicationId, "Application ID")}/emojis/${snowflake(emojiId, "Emoji ID")}` : `/applications/${snowflake(applicationId, "Application ID")}/emojis`,
-  pollExpire: (channelId, messageId) => `/channels/${snowflake(channelId, "Channel ID")}/polls/${snowflake(messageId, "Message ID")}/expire`,
-  pollAnswerVoters: (channelId, messageId, answerId) => `/channels/${snowflake(channelId, "Channel ID")}/polls/${snowflake(messageId, "Message ID")}/answers/${integer(answerId, "Answer ID")}`,
-  guildSticker: (guildId, stickerId) => stickerId ? `/guilds/${snowflake(guildId, "Guild ID")}/stickers/${snowflake(stickerId, "Sticker ID")}` : `/guilds/${snowflake(guildId, "Guild ID")}/stickers`,
-  sendSoundboardSound: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/send-soundboard-sound`,
-  soundboardDefaultSounds: () => "/soundboard-default-sounds",
-  guildSoundboardSound: (guildId, soundId) => soundId ? `/guilds/${snowflake(guildId, "Guild ID")}/soundboard-sounds/${snowflake(soundId, "Sound ID")}` : `/guilds/${snowflake(guildId, "Guild ID")}/soundboard-sounds`,
-  applicationSkus: (applicationId) => `/applications/${snowflake(applicationId, "Application ID")}/skus`,
-  applicationEntitlement: (applicationId, entitlementId) => entitlementId ? `/applications/${snowflake(applicationId, "Application ID")}/entitlements/${snowflake(entitlementId, "Entitlement ID")}` : `/applications/${snowflake(applicationId, "Application ID")}/entitlements`,
-  consumeEntitlement: (applicationId, entitlementId) => `/applications/${snowflake(applicationId, "Application ID")}/entitlements/${snowflake(entitlementId, "Entitlement ID")}/consume`,
-  skuSubscription: (skuId, subscriptionId) => subscriptionId ? `/skus/${snowflake(skuId, "SKU ID")}/subscriptions/${snowflake(subscriptionId, "Subscription ID")}` : `/skus/${snowflake(skuId, "SKU ID")}/subscriptions`
-};
-function userOrMe(value) {
-  return value === "@me" ? value : snowflake(value, "User ID");
-}
-function integer(value, field) {
-  if (!Number.isInteger(value) || value < 0)
-    throw new TypeError(`${field} must be a non-negative integer.`);
-  return String(value);
-}
-function snowflake(value, field) {
-  if (!/^\d{1,20}$/.test(value))
-    throw new TypeError(`${field} must be a valid Discord snowflake.`);
-  return value;
-}
-// packages/rest/src/error-codes.ts
-var RESTErrorCode = {
-  UnknownAccount: 10001,
-  UnknownChannel: 10003,
-  UnknownGuild: 10004,
-  UnknownInvite: 10006,
-  UnknownMember: 10007,
-  UnknownMessage: 10008,
-  UnknownPermissionOverwrite: 10009,
-  UnknownRole: 10011,
-  UnknownUser: 10013,
-  UnknownEmoji: 10014,
-  UnknownWebhook: 10015,
-  UnknownBan: 10026,
-  UnknownSticker: 10060,
-  UnknownInteraction: 10062,
-  UnknownScheduledEvent: 10070,
-  BotsCannotUseEndpoint: 20001,
-  MaxGuilds: 30001,
-  MaxPins: 30003,
-  MaxRoles: 30005,
-  MaxWebhooks: 30007,
-  MaxEmojis: 30008,
-  MaxReactions: 30010,
-  MaxChannels: 30013,
-  InteractionAlreadyAcknowledged: 40060,
-  MissingAccess: 50001,
-  CannotExecuteInDM: 50003,
-  CannotEditOthersMessage: 50005,
-  CannotSendEmptyMessage: 50006,
-  CannotSendMessagesToUser: 50007,
-  MissingPermissions: 50013,
-  InvalidToken: 50014,
-  MessageTooOldToBulkDelete: 50034,
-  InvalidFormBody: 50035,
-  ThreadArchived: 50083,
-  CannotReplyWithoutReadHistory: 160002
-};
-// packages/rest/src/redis.ts
-var LUA_PRELUDE = `
-local function now_ms()
-  local t = redis.call('TIME')
-  return tonumber(t[1]) * 1000 + math.floor(tonumber(t[2]) / 1000)
-end
-local function load(key)
-  local raw = redis.call('GET', key)
-  if not raw then return nil end
-  local ok, s = pcall(cjson.decode, raw)
-  if ok and type(s) == 'table' and type(s.resetAt) == 'number'
-    and type(s.remaining) == 'number' then return s end
-  return nil
-end
-local function save(key, s, now, linger)
-  local ttl = math.max(1, math.ceil(s.resetAt - now)) + linger
-  redis.call('SET', key, cjson.encode(s), 'PX', ttl)
-end
-`;
-var RESERVE_SCRIPT = `${LUA_PRELUDE}
-local now = now_ms()
-local glimit, gwindow = tonumber(ARGV[4]) or 0, tonumber(ARGV[5]) or 1000
-if #KEYS > 1 then
-  local g = tonumber(redis.call('GET', KEYS[2]) or '0') or 0
-  if g > now then return {0, math.ceil(g - now), 'global'} end
-end
-if #KEYS < 3 then glimit = 0 end
--- A sliding log of send times: at most glimit in any gwindow span.
-if glimit > 0 then
-  redis.call('ZREMRANGEBYSCORE', KEYS[3], '-inf', now - gwindow)
-  if redis.call('ZCARD', KEYS[3]) >= glimit then
-    local oldest = redis.call('ZRANGE', KEYS[3], 0, 0, 'WITHSCORES')
-    return {0, math.max(1, tonumber(oldest[2]) + gwindow - now + 1), 'global'}
-  end
-end
-local function count()
-  if glimit > 0 then
-    local seq = redis.call('ZCARD', KEYS[3])
-    redis.call('ZADD', KEYS[3], now, now .. ':' .. seq)
-    redis.call('PEXPIRE', KEYS[3], gwindow + 1000)
-  end
-end
-local probe, poll, linger = tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3])
-local s = load(KEYS[1])
-if s and s.resetAt > now then
-  if s.remaining > 0 then
-    s.remaining = s.remaining - 1
-    save(KEYS[1], s, now, linger)
-    count()
-    return {1, s.resetAt, 1}
-  end
-  local wait = s.resetAt - now
-  if s.provisional then wait = math.min(wait, poll) end
-  local reason = 'bucket'
-  if s.probe then reason = 'probe' end
-  return {0, math.ceil(wait), reason}
-end
-local resetAt = now + probe
-if s and type(s.limit) == 'number' and s.limit > 0 then
-  save(KEYS[1], {remaining = s.limit - 1, resetAt = resetAt, limit = s.limit, provisional = true}, now, linger)
-  count()
-  return {1, resetAt, 1}
-end
-save(KEYS[1], {remaining = 0, resetAt = resetAt, provisional = true, probe = true}, now, 0)
-count()
-return {1, resetAt, 0}
-`;
-var RECONCILE_SCRIPT = `${LUA_PRELUDE}
-local now = now_ms()
-local rem, after, limit = tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3])
-local win, retry, linger = tonumber(ARGV[4]), tonumber(ARGV[5]), tonumber(ARGV[6])
-local tol = 50
-local incoming = nil
-if after then incoming = math.ceil(now + after) end
-local s = load(KEYS[1])
-local n
-if s and s.resetAt > now and not s.probe then
-  n = s
-  local stale = win and n.window and win < n.window - tol
-  if not stale then
-    if rem then n.remaining = math.min(n.remaining, rem) end
-    if incoming then
-      local newer = win and n.window and win > n.window + tol
-      if n.provisional or newer then n.resetAt = incoming
-      else n.resetAt = math.max(n.resetAt, incoming) end
-      n.provisional = nil
-    end
-    if win then n.window = math.max(n.window or 0, win) end
-  end
-else
-  if not rem and not retry then
-    if s and s.probe then redis.call('DEL', KEYS[1]) end
-    return 0
-  end
-  n = {remaining = rem or 0, resetAt = incoming or now}
-  if s and type(s.limit) == 'number' then n.limit = s.limit end
-  if win then n.window = win end
-end
-if limit and limit > 0 then n.limit = limit end
-if retry then
-  n.remaining = 0
-  n.resetAt = math.max(n.resetAt, math.ceil(now + retry))
-  n.provisional = nil
-end
-save(KEYS[1], n, now, linger)
-return 1
-`;
-var EXTEND_GLOBAL_SCRIPT = `${LUA_PRELUDE}
-local now = now_ms()
-local target = math.ceil(now + tonumber(ARGV[1]))
-local cur = tonumber(redis.call('GET', KEYS[1]) or '0') or 0
-if target > cur then
-  redis.call('SET', KEYS[1], tostring(target), 'PX', math.max(1, target - now))
-  return target - now
-end
-return math.max(0, cur - now)
-`;
-var RELEASE_SCRIPT = `${LUA_PRELUDE}
-local s = load(KEYS[1])
-if not s or s.resetAt ~= tonumber(ARGV[1]) then return 0 end
-if s.probe then
-  redis.call('DEL', KEYS[1])
-  return 1
-end
-if ARGV[2] == '1' then
-  local cap = s.remaining + 1
-  if type(s.limit) == 'number' then cap = math.min(cap, s.limit) end
-  s.remaining = cap
-  redis.call('SET', KEYS[1], cjson.encode(s), 'KEEPTTL')
-  return 1
-end
-return 0
-`;
-var VERIFY_SCRIPT = "return redis.call('TIME')[1]";
-function fromBunRedis(client) {
-  return {
-    get: (key) => client.send("GET", [key]),
-    mget: (keys) => client.send("MGET", keys),
-    set: (key, value, mode, duration) => client.send("SET", mode === undefined ? [key, String(value)] : [key, String(value), mode, String(duration)]),
-    del: (...keys) => client.send("DEL", keys),
-    eval: (script, numKeys, ...args) => client.send("EVAL", [script, String(numKeys), ...args.map(String)])
-  };
-}
-var SCHEMA = "v1";
-
-class RedisRateLimitStore {
-  #client;
-  #prefix;
-  #onErrorCallback;
-  #policy;
-  #timeout;
-  #telemetry;
-  #atomic;
-  #local = new MemoryRateLimitStore;
-  #lastError;
-  #warnedSlots = false;
-  #lastFailureAt;
-  #failures = 0;
-  #mode;
-  constructor(options) {
-    this.#client = options.client;
-    this.#prefix = `${options.prefix ?? "lunibee:rest:"}${SCHEMA}:`;
-    this.#onErrorCallback = options.onError;
-    this.#policy = options.failurePolicy ?? "degraded-local";
-    if (this.#policy !== "degraded-local" && this.#policy !== "fail-closed")
-      throw new TypeError('failurePolicy must be "degraded-local" or "fail-closed".');
-    this.#timeout = options.commandTimeout ?? 2000;
-    if (!(this.#timeout > 0))
-      throw new RangeError("commandTimeout must be a positive number.");
-    this.#telemetry = options.telemetry;
-    this.#atomic = typeof options.client.eval === "function";
-    if (options.requireAtomic && !this.#atomic)
-      throw new TypeError("requireAtomic: the Redis client has no eval method, so reservations cannot be atomic.");
-    this.#mode = this.#atomic ? "distributed" : "observational";
-    if (this.#atomic) {
-      this.reserve = (key, opts) => this.#reserve(key, opts);
-      this.reconcile = (key, update) => this.#reconcile(key, update);
-      this.extendGlobalReset = (scope, waitMs) => this.#extendGlobal(scope, waitMs);
-      this.release = (key, grant, refund) => this.#release(key, grant, refund);
-      this.reservesGlobal = true;
-    }
-  }
-  get lastError() {
-    return this.#lastError;
-  }
-  isHealthy() {
-    return this.#lastError === undefined;
-  }
-  get mode() {
-    return this.#mode;
-  }
-  get supportsReservation() {
-    return this.#atomic;
-  }
-  diagnostics() {
-    const error = this.#lastError;
-    return {
-      mode: this.#mode,
-      failurePolicy: this.#policy,
-      atomic: this.#atomic,
-      failures: this.#failures,
-      lastFailureAt: this.#lastFailureAt,
-      lastError: error === undefined ? undefined : String(sanitizeCause(error)?.message ?? error)
-    };
-  }
-  async verify() {
-    if (!this.#atomic)
-      throw new TypeError("The Redis client has no eval method: reservations cannot be atomic.");
-    try {
-      await this.#withTimeout(this.#client.eval(VERIFY_SCRIPT, 0));
-    } catch (error) {
-      throw new RESTError("The Redis rate-limit store cannot run its scripts.", 0, undefined, undefined, { kind: "coordination", cause: sanitizeCause(error) });
-    }
-  }
-  #setMode(mode) {
-    if (mode === this.#mode)
-      return;
-    const previous = this.#mode;
-    this.#mode = mode;
-    emitTelemetry(this.#telemetry, { type: "mode", mode, previous });
-    console.warn(mode === "degraded-local" ? "[lunibee/rest] Redis rate-limit store unreachable: limiting locally in this process until it answers." : mode === "unavailable" ? "[lunibee/rest] Redis rate-limit store unreachable: requests fail until it answers (fail-closed)." : "[lunibee/rest] Redis rate-limit store reachable again: limits are shared.");
-  }
-  #withTimeout(promise) {
-    let timer;
-    return Promise.race([
-      promise,
-      new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(`Redis command timed out after ${this.#timeout}ms`)), this.#timeout);
-      })
-    ]).finally(() => clearTimeout(timer));
-  }
-  async#run(operation, command, fallback, enforcing) {
-    const started = performance.now();
-    try {
-      const value = await this.#withTimeout(command());
-      emitTelemetry(this.#telemetry, {
-        type: "store",
-        operation,
-        latencyMs: performance.now() - started,
-        ok: true
-      });
-      this.#lastError = undefined;
-      this.#setMode(this.#atomic ? "distributed" : "observational");
-      return value;
-    } catch (error) {
-      emitTelemetry(this.#telemetry, {
-        type: "store",
-        operation,
-        latencyMs: performance.now() - started,
-        ok: false
-      });
-      this.#lastError = error;
-      this.#lastFailureAt = Date.now();
-      this.#failures++;
-      if (!this.#warnedSlots && /CROSSSLOT/.test(String(error))) {
-        this.#warnedSlots = true;
-        console.warn('[lunibee/rest] Redis Cluster refused a script whose keys hash to different slots (CROSSSLOT): use a hash-tagged prefix such as "{mybot}:rest:".');
-      }
-      try {
-        this.#onErrorCallback?.(operation, error);
-      } catch {}
-      if (this.#policy === "fail-closed") {
-        this.#setMode("unavailable");
-        if (enforcing)
-          throw new RESTError(`The Redis rate-limit store is unavailable (${operation}); request not sent (failurePolicy: "fail-closed").`, 0, undefined, undefined, { kind: "coordination", cause: sanitizeCause(error) });
-      } else
-        this.#setMode("degraded-local");
-      return fallback();
-    }
-  }
-  #bucketKey(key) {
-    return `${this.#prefix}bucket:${key}`;
-  }
-  #globalKey(scope) {
-    return `${this.#prefix}global:${scope}`;
-  }
-  async getBucketHash(route) {
-    return this.#run("getBucketHash", async () => await this.#client.get(`${this.#prefix}route:${route}`) ?? undefined, () => this.#local.getBucketHash(route), false);
-  }
-  async setBucketHash(route, hash) {
-    this.#local.setBucketHash(route, hash);
-    await this.#run("setBucketHash", async () => {
-      await this.#client.set(`${this.#prefix}route:${route}`, hash, "EX", 604800);
-    }, () => {
-      return;
-    }, false);
-  }
-  async getBucket(key) {
-    return this.#run("getBucket", async () => {
-      const data = await this.#client.get(this.#bucketKey(key));
-      if (!data)
-        return;
-      try {
-        return JSON.parse(data);
-      } catch {
-        return;
-      }
-    }, () => this.#local.getBucket(key), true);
-  }
-  async updateBucket(key, state) {
-    this.#local.updateBucket(key, state);
-    const ttl = Math.ceil(state.resetAt - Date.now());
-    await this.#run("updateBucket", async () => {
-      if (ttl <= 0)
-        await this.#client.del(this.#bucketKey(key));
-      else
-        await this.#client.set(this.#bucketKey(key), JSON.stringify(state), "PX", ttl);
-    }, () => {
-      return;
-    }, false);
-  }
-  reserve;
-  reconcile;
-  extendGlobalReset;
-  release;
-  reservesGlobal;
-  async#reserve(key, options = {}) {
-    const keys = [this.#bucketKey(key)];
-    if (options.global !== undefined) {
-      keys.push(this.#globalKey(options.global));
-      if (options.globalLimit)
-        keys.push(`${this.#prefix}global-log:${options.global}`);
-    }
-    return this.#run("reserve", async () => {
-      const result = await this.#client.eval(RESERVE_SCRIPT, keys.length, ...keys, options.probeMs ?? DEFAULT_PROBE_MS, PROBE_POLL_MS, BUCKET_LINGER_MS, options.globalLimit ?? 0, GLOBAL_WINDOW_MS);
-      return parseReservation(result);
-    }, () => this.#local.reserve(key, options), true);
-  }
-  async#reconcile(key, update) {
-    this.#local.reconcile(key, update);
-    const arg = (value) => value === undefined ? "" : String(value);
-    await this.#run("reconcile", async () => {
-      await this.#client.eval(RECONCILE_SCRIPT, 1, this.#bucketKey(key), arg(update.remaining), arg(update.resetAfterMs), arg(update.limit), arg(update.window), arg(update.retryAfterMs), BUCKET_LINGER_MS);
-    }, () => {
-      return;
-    }, false);
-  }
-  async#extendGlobal(scope, waitMs) {
-    this.#local.extendGlobalReset(scope, waitMs);
-    await this.#run("extendGlobalReset", async () => {
-      await this.#client.eval(EXTEND_GLOBAL_SCRIPT, 1, this.#globalKey(scope), Math.max(0, Math.ceil(waitMs)));
-    }, () => {
-      return;
-    }, false);
-  }
-  async#release(key, grant, refund) {
-    this.#local.release(key, grant, refund);
-    if (grant.resetAt === undefined)
-      return;
-    await this.#run("release", async () => {
-      await this.#client.eval(RELEASE_SCRIPT, 1, this.#bucketKey(key), grant.resetAt, refund ? "1" : "0");
-    }, () => {
-      return;
-    }, false);
-  }
-  async getGlobalReset(scope = "") {
-    return this.#run("getGlobalReset", async () => {
-      const resetAt = await this.#client.get(this.#globalKey(scope));
-      return resetAt ? Number(resetAt) || 0 : 0;
-    }, () => this.#local.getGlobalReset(scope), true);
-  }
-  async setGlobalReset(resetAt, scope = "") {
-    this.#local.setGlobalReset(resetAt, scope);
-    const ttl = Math.ceil(resetAt - Date.now());
-    await this.#run("setGlobalReset", async () => {
-      if (ttl <= 0)
-        await this.#client.del(this.#globalKey(scope));
-      else
-        await this.#client.set(this.#globalKey(scope), String(resetAt), "PX", ttl);
-    }, () => {
-      return;
-    }, false);
-  }
-}
-function parseReservation(result) {
-  if (!Array.isArray(result) || result.length < 3)
-    throw new Error("Unexpected reply from the reservation script.");
-  const [granted, value, flag] = result;
-  const n = Number(value);
-  if (!Number.isFinite(n))
-    throw new Error("Unexpected reply from the reservation script.");
-  if (Number(granted) === 1)
-    return { granted: true, known: Number(flag) === 1, resetAt: n };
-  const reason = String(flag);
-  return {
-    granted: false,
-    retryAfterMs: Math.max(0, n),
-    reason: reason === "global" || reason === "probe" ? reason : "bucket"
-  };
-}
-// packages/rest/src/webhook.ts
-class WebhookClient {
-  id;
-  token;
-  #rest;
-  constructor(options, restOptions) {
-    if (options.url) {
-      const match = options.url.match(/^https:\/\/(?:(?:ptb|canary)\.)?discord(?:app)?\.com\/api(?:\/v\d+)?\/webhooks\/(\d{1,20})\/([A-Za-z0-9_-]+)\/?(?:[?#].*)?$/);
-      if (!match)
-        throw new Error("Invalid Discord webhook URL format.");
-      this.id = match[1];
-      this.token = match[2];
-    } else if (options.id && options.token) {
-      this.id = options.id;
-      this.token = options.token;
-    } else {
-      throw new Error("WebhookClient requires either a webhook 'url' or both 'id' and 'token'.");
-    }
-    this.#rest = new REST(restOptions);
-  }
-  #prepare(options, base = {}) {
-    const payload = typeof options === "string" ? { content: options } : options;
-    const {
-      thread_id: threadWire,
-      threadId,
-      avatarURL,
-      allowedMentions,
-      files,
-      ...body
-    } = payload;
-    const thread_id = threadWire ?? threadId;
-    if (avatarURL !== undefined && body.avatar_url === undefined)
-      body.avatar_url = avatarURL;
-    if (allowedMentions !== undefined && body.allowed_mentions === undefined)
-      body.allowed_mentions = allowedMentions;
-    const params = new URLSearchParams(base);
-    if (thread_id)
-      params.set("thread_id", String(thread_id));
-    const json = { ...body };
-    if (body.embeds)
-      json.embeds = body.embeds.map((e) => ("toJSON" in e) ? e.toJSON() : e);
-    if (body.components)
-      json.components = body.components.map((c) => ("toJSON" in c) ? c.toJSON() : c);
-    const text = params.toString();
-    return { query: text ? `?${text}` : "", json, files };
-  }
-  async send(options) {
-    const { query, json, files } = this.#prepare(options, { wait: "true" });
-    const path = `${Routes.webhook(this.id, this.token)}${query}`;
-    return files?.length ? this.#rest.postWithFiles(path, json, files) : this.#rest.post(path, json);
-  }
-  async fetchMessage(messageId, options = {}) {
-    const query = options.threadId ? `?${new URLSearchParams({ thread_id: options.threadId })}` : "";
-    return this.#rest.get(`${Routes.webhookMessage(this.id, this.token, messageId)}${query}`);
-  }
-  async editMessage(messageId, options) {
-    const { query, json, files } = this.#prepare(options);
-    const path = `${Routes.webhookMessage(this.id, this.token, messageId)}${query}`;
-    return files?.length ? this.#rest.patchWithFiles(path, json, files) : this.#rest.patch(path, json);
-  }
-  async deleteMessage(messageId, options = {}) {
-    const query = options.threadId ? `?${new URLSearchParams({ thread_id: options.threadId })}` : "";
-    await this.#rest.delete(`${Routes.webhookMessage(this.id, this.token, messageId)}${query}`);
-  }
-}
-
-// packages/rest/src/index.ts
-var LIBRARY_VERSION = package_default.version;
-var LIBRARY_URL = "https://github.com/Ekretos/lunibee";
-var USER_AGENT = `DiscordBot (${LIBRARY_URL}, ${LIBRARY_VERSION})`;
-function assertSafePath(path) {
-  if (/[\u0000-\u0020\u007f#]/.test(path))
-    throw new TypeError("REST paths must not contain control characters, spaces or '#'.");
-  const end = path.indexOf("?");
-  const pathname = end === -1 ? path : path.slice(0, end);
-  if (pathname.includes("\\"))
-    throw new TypeError("REST paths must not contain backslashes.");
-  for (const segment of pathname.split("/")) {
-    let decoded;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-      throw new TypeError("REST path has malformed percent-encoding.");
-    }
-    const bare = decoded.replace(/[\u0000-\u0020\u007f]/g, "");
-    if (bare === "." || bare === ".." || /[\\/]/.test(decoded) && decoded.split(/[\\/]/).some((s) => {
-      const part = s.replace(/[\u0000-\u0020\u007f]/g, "");
-      return part === "." || part === "..";
-    }))
-      throw new TypeError("REST paths must not contain '.' or '..' segments.");
-  }
-}
-var REQUEST_DATA_KEYS = new Set([
-  "body",
-  "files",
-  "query",
-  "headers",
-  "reason",
-  "auth",
-  "signal",
-  "maxQueueWait"
-]);
-function isRequestData(value) {
-  if (value === null || typeof value !== "object")
-    return false;
-  if (Array.isArray(value))
-    return false;
-  if (typeof FormData !== "undefined" && value instanceof FormData)
-    return false;
-  if (value instanceof Blob || value instanceof Uint8Array || value instanceof ArrayBuffer)
-    return false;
-  const keys = Object.keys(value);
-  if (keys.length === 0)
-    return false;
-  return keys.every((key) => REQUEST_DATA_KEYS.has(key));
-}
-function createRetryPolicy(maxRetries = 2) {
-  if (!Number.isFinite(maxRetries) || maxRetries < 0)
-    throw new TypeError("maxRetries must be a non-negative finite number.");
-  return {
-    maxRetries: Math.floor(maxRetries),
-    shouldRetry(method, status) {
-      const normalized = method.toUpperCase();
-      const idempotent = ["GET", "HEAD", "PUT", "DELETE"].includes(normalized);
-      if (status === 0)
-        return idempotent;
-      return status === 429 || status >= 500 && status <= 599 && idempotent;
-    },
-    getDelay(attempt, retryAfter) {
-      if (retryAfter !== undefined)
-        return Math.max(0, retryAfter * 1000);
-      return Math.min(1e4, 500 * 2 ** attempt) + Math.random() * 250;
-    }
-  };
-}
-
-class QueueWaitExceeded extends Error {
-  ms;
-  constructor(ms) {
-    super("maxQueueWait exceeded");
-    this.ms = ms;
-  }
-}
-function checkWait(ms) {
-  if (ms === undefined)
-    return;
-  if (!(ms >= 0) || !Number.isFinite(ms))
-    throw new RangeError("maxQueueWait must be a non-negative number.");
-  return ms;
-}
-
-class REST {
-  #retryPolicy;
-  #token;
-  #fingerprint;
-  #telemetry;
-  #closing = new AbortController;
-  #inFlight = 0;
-  #idle;
-  #rejected;
-  #stopOnInvalidToken;
-  #maxQueueWait;
-  #invalid = new Array(10).fill(0);
-  #invalidMinute = 0;
-  #drained;
-  #limiter;
-  #scheduler;
-  #transport;
-  #decoder = new ResponseDecoder;
-  #hooks = {};
-  #concurrentBuckets;
-  constructor(options = {}) {
-    this.#token = options.token;
-    this.#fingerprint = options.token ? tokenFingerprint(options.token) : undefined;
-    this.#telemetry = options.telemetry;
-    this.#scheduler = new RequestScheduler({
-      maxQueued: options.maxQueued,
-      maxQueuedPerBucket: options.maxQueuedPerBucket
-    });
-    this.#retryPolicy = options.retryPolicy ?? createRetryPolicy(options.retries ?? 2);
-    this.#transport = options.transport ?? new HttpTransport({
-      baseURL: options.baseURL,
-      allowInsecureBaseURL: options.allowInsecureBaseURL,
-      timeout: options.timeout
-    });
-    const store = options.store ?? new MemoryRateLimitStore;
-    this.#concurrentBuckets = (options.concurrentBuckets ?? true) && typeof store.reserve === "function";
-    this.#limiter = new RateLimiter(store, {
-      concurrent: this.#concurrentBuckets,
-      maxBackoff: options.maxBackoff,
-      probeMs: this.#transport.timeout > 0 ? this.#transport.timeout + 1000 : undefined,
-      telemetry: options.telemetry,
-      globalLimit: options.globalLimit === false ? undefined : options.globalLimit ?? 50
-    });
-    this.#stopOnInvalidToken = options.stopOnInvalidToken ?? true;
-    this.#maxQueueWait = checkWait(options.maxQueueWait);
-    if (options.hooks)
-      this.#hooks = options.hooks;
-  }
-  get store() {
-    return this.#limiter.store;
-  }
-  setHooks(hooks) {
-    this.#hooks = hooks;
-    return this;
-  }
-  setToken(token) {
-    if (!token.trim())
-      throw new TypeError("A Discord bot token is required.");
-    this.#token = token;
-    this.#fingerprint = tokenFingerprint(token);
-    this.#rejected = undefined;
-  }
-  diagnostics() {
-    const store = this.#limiter.store;
-    return {
-      mode: store.mode ?? (store instanceof MemoryRateLimitStore ? "local" : "distributed"),
-      queued: this.#scheduler.queued,
-      inFlight: this.#inFlight,
-      buckets: this.#scheduler.size,
-      closed: this.#closing.signal.aborted,
-      invalidRequests: this.#invalidCount(0),
-      tokenRejected: this.#rejected !== undefined && this.#rejected === this.#fingerprint
-    };
-  }
-  async close() {
-    if (!this.#closing.signal.aborted)
-      this.#closing.abort(new Error("The REST client was closed."));
-    if (this.#inFlight === 0)
-      return;
-    this.#drained ??= new Promise((resolve) => {
-      this.#idle = resolve;
-    });
-    await this.#drained;
-  }
-  #invalidCount(add) {
-    const minute = Math.floor(Date.now() / 60000);
-    const elapsed = Math.min(10, minute - this.#invalidMinute);
-    for (let i = 1;i <= elapsed; i++)
-      this.#invalid[(this.#invalidMinute + i) % 10] = 0;
-    if (elapsed > 0)
-      this.#invalidMinute = minute;
-    this.#invalid[minute % 10] += add;
-    return this.#invalid.reduce((a, b) => a + b, 0);
-  }
-  #queueChanged() {
-    emitTelemetry(this.#telemetry, {
-      type: "queue",
-      queued: this.#scheduler.queued,
-      inFlight: this.#inFlight
-    });
-  }
-  async request(methodOrOptions, pathArg, bodyArg, optionsArg = {}) {
-    let method;
-    let path;
-    let body = bodyArg;
-    let options = optionsArg;
-    if (typeof methodOrOptions === "object" && methodOrOptions !== null) {
-      const { method: m, path: p, fullRoute, ...rest } = methodOrOptions;
-      method = m;
-      path = p ?? fullRoute ?? "";
-      body = rest.body;
-      options = rest;
-    } else {
-      method = methodOrOptions;
-      path = pathArg;
-    }
-    if (typeof method !== "string" || !method.toUpperCase())
-      throw new TypeError("REST method is required.");
-    if (!path.startsWith("/"))
-      throw new TypeError("REST paths must start with '/'.");
-    assertSafePath(path);
-    const route = createRouteKey(method, path);
-    const files = options.files;
-    if (files && files.length > 0 && !(body instanceof FormData))
-      body = this.#fileForm(body, await Promise.all(files.map(async (file) => ({
-        ...file,
-        data: await file.data
-      }))));
-    const query = serializeQuery(options.query);
-    const requestPath = query ? `${path}${query}` : path;
-    if (this.#closing.signal.aborted)
-      throw abortError(path, this.#closing.signal.reason);
-    const identity = requestIdentity(path, options.auth !== false && this.#token ? this.#fingerprint : undefined);
-    if (identity.bucket === this.#fingerprint && this.#rejected === this.#fingerprint)
-      throw new RESTError("Discord rejected this bot token (401); request not sent. Call setToken() with a valid token.", 401, undefined, undefined, { method: route.method, path, kind: "authentication" });
-    const queueWait = checkWait(options.maxQueueWait) ?? this.#maxQueueWait;
-    let deadline;
-    const sources = [this.#closing.signal];
-    if (options.signal)
-      sources.push(options.signal);
-    if (queueWait !== undefined) {
-      const expired = new AbortController;
-      deadline = setTimeout(() => expired.abort(new QueueWaitExceeded(queueWait)), queueWait);
-      sources.push(expired.signal);
-    }
-    const waitSignal = sources.length === 1 ? sources[0] : AbortSignal.any(sources);
-    const state = { attempts: 0, status: 0 };
-    const started = performance.now();
-    this.#inFlight++;
-    this.#queueChanged();
-    try {
-      return await this.#scheduler.runResolved(() => this.#limiter.resolveBucketKey(route.route, route.major, identity.bucket), waitSignal, path, (bucketKey, release) => {
-        this.#queueChanged();
-        return this.#attempts(route, requestPath, body, options, { identity, waitSignal, state }, bucketKey, release);
-      });
-    } catch (caught) {
-      let error = caught;
-      if (error instanceof RESTError && error.kind === "aborted" && error.cause instanceof QueueWaitExceeded)
-        error = new RESTError(`The request waited longer than maxQueueWait (${error.cause.ms}ms) before it could be sent.`, 0, undefined, undefined, { method: route.method, path, kind: "overloaded" });
-      if (error instanceof RESTError) {
-        if (error.kind === "aborted" && state.attempts === 0)
-          emitTelemetry(this.#telemetry, {
-            type: "cancelled",
-            stage: "queued"
-          });
-        else if (error.kind === "overloaded")
-          emitTelemetry(this.#telemetry, { type: "overloaded" });
-        if (state.status === 0)
-          state.status = error.status;
-      }
-      throw error;
-    } finally {
-      clearTimeout(deadline);
-      emitTelemetry(this.#telemetry, {
-        type: "request",
-        method: route.method,
-        route: route.route,
-        status: state.status,
-        attempts: state.attempts,
-        durationMs: performance.now() - started,
-        ok: state.status >= 200 && state.status < 300
-      });
-      if (--this.#inFlight === 0 && this.#idle) {
-        this.#idle();
-        this.#idle = undefined;
-        this.#drained = undefined;
-      }
-      this.#queueChanged();
-    }
-  }
-  async#attempts(route, requestPath, body, options, context, initialBucketKey, release) {
-    const { method, path } = route;
-    const { identity, waitSignal, state } = context;
-    const label = route.route;
-    let bucketKey = initialBucketKey;
-    for (let attempt = 0;attempt <= this.#retryPolicy.maxRetries; attempt++) {
-      let grant;
-      try {
-        grant = await this.#limiter.acquire(bucketKey, waitSignal, path, { global: identity.global });
-      } catch (error) {
-        if (error instanceof RESTError && error.kind === "aborted")
-          emitTelemetry(this.#telemetry, {
-            type: "cancelled",
-            stage: "waiting"
-          });
-        throw error;
-      }
-      if (this.#concurrentBuckets && grant.known)
-        release();
-      if (waitSignal.aborted) {
-        await this.#limiter.releaseGrant(bucketKey, grant, true);
-        emitTelemetry(this.#telemetry, {
-          type: "cancelled",
-          stage: "waiting"
-        });
-        throw abortError(path, waitSignal.reason);
-      }
-      this.#emit(this.#hooks.onRequest, { method, path, attempt });
-      state.attempts = attempt + 1;
-      const requestStart = Date.now();
-      let response;
-      try {
-        response = await this.#transport.send({
-          method,
-          path: requestPath,
-          headers: this.#headers(body, options),
-          body: this.#encodeBody(body),
-          signal: options.signal
-        });
-      } catch (error) {
-        const notSent = error instanceof RESTError && error.kind === "aborted";
-        await this.#limiter.releaseGrant(bucketKey, grant, notSent);
-        if (error instanceof RESTError) {
-          if (error.kind === "aborted")
-            emitTelemetry(this.#telemetry, {
-              type: "cancelled",
-              stage: "transport"
-            });
-          throw error;
-        }
-        if (options.signal?.aborted) {
-          emitTelemetry(this.#telemetry, {
-            type: "cancelled",
-            stage: "transport"
-          });
-          throw abortError(path, options.signal.reason);
-        }
-        const failure = error instanceof TransportError ? error : new TransportError("Discord REST request failed", false, sanitizeCause(error));
-        emitTelemetry(this.#telemetry, {
-          type: "networkError",
-          timedOut: failure.timedOut
-        });
-        if (!failure.timedOut && attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(method, 0)) {
-          const delay = this.#retryPolicy.getDelay(attempt);
-          this.#emit(this.#hooks.onRetry, {
-            method,
-            path,
-            attempt,
-            status: 0,
-            delayMs: delay
-          });
-          emitTelemetry(this.#telemetry, {
-            type: "retry",
-            route: label,
-            reason: "network",
-            attempt
-          });
-          await this.#retrySleep(delay, waitSignal, path);
-          continue;
-        }
-        throw new RESTError(failure.message, 0, undefined, undefined, {
-          method,
-          path,
-          cause: failure.cause ?? failure,
-          kind: failure.timedOut ? "timeout" : "network"
-        });
-      }
-      state.status = response.status;
-      if (response.status === 401 || response.status === 403 || response.status === 429 && response.headers.get("X-RateLimit-Scope") !== "shared")
-        this.#invalidCount(1);
-      if (response.status === 401 && this.#stopOnInvalidToken && identity.bucket === this.#fingerprint) {
-        this.#rejected = this.#fingerprint;
-        emitTelemetry(this.#telemetry, { type: "tokenRejected" });
-      }
-      const durationMs = Date.now() - requestStart;
-      this.#emit(this.#hooks.onResponse, {
-        method,
-        path,
-        status: response.status,
-        durationMs
-      });
-      emitTelemetry(this.#telemetry, {
-        type: "response",
-        method,
-        route: label,
-        status: response.status,
-        durationMs
-      });
-      const payload = await this.#decoder.read(response);
-      const data = response.ok ? {} : this.#decoder.errorData(payload);
-      bucketKey = await this.#limiter.applyResponse(response, bucketKey, route.route, route.major, {
-        identity: identity.bucket,
-        global: identity.global,
-        body: data,
-        grant
-      });
-      if (response.ok)
-        return response.status === 204 ? undefined : payload;
-      const limited = response.status === 429;
-      const retryAfterMs = limited ? this.#limiter.retryAfterMs(response, data) : undefined;
-      if (limited) {
-        const global = data.global === true || response.headers.get("X-RateLimit-Global") === "true";
-        const scope = response.headers.get("X-RateLimit-Scope")?.toLowerCase();
-        emitTelemetry(this.#telemetry, {
-          type: "rateLimited",
-          route: label,
-          scope: global ? "global" : scope === "user" || scope === "shared" ? scope : "unknown",
-          retryAfterMs
-        });
-        this.#emit(this.#hooks.onRateLimit, {
-          method,
-          path,
-          retryAfterMs,
-          global,
-          bucket: response.headers.get("X-RateLimit-Bucket") ?? await this.#limiter.store.getBucketHash(route.route)
-        });
-      }
-      if (attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(method, response.status)) {
-        const delay = this.#retryPolicy.getDelay(attempt, limited ? retryAfterMs / 1000 : undefined);
-        if (delay > this.#limiter.maxBackoff)
-          throw new RESTError(`Discord asked to wait ${Math.ceil(delay / 1000)}s before retrying, longer than maxBackoff (${Math.ceil(this.#limiter.maxBackoff / 1000)}s).`, response.status, data.code, payload, { method, path });
-        this.#emit(this.#hooks.onRetry, {
-          method,
-          path,
-          attempt,
-          status: response.status,
-          delayMs: delay
-        });
-        emitTelemetry(this.#telemetry, {
-          type: "retry",
-          route: label,
-          reason: limited ? "rateLimited" : "server",
-          attempt
-        });
-        await this.#retrySleep(limited ? delay - retryAfterMs : delay, waitSignal, path);
-        continue;
-      }
-      throw new RESTError(data.message ?? response.statusText ?? `Discord REST request failed with status ${response.status}`, response.status, data.code, payload, { method, path });
-    }
-    throw new RESTError("Discord REST request exhausted its retry attempts", 0, undefined, undefined, { method, path });
-  }
-  async#retrySleep(delay, signal, path) {
-    try {
-      await sleep(delay, signal, path);
-    } catch (error) {
-      emitTelemetry(this.#telemetry, {
-        type: "cancelled",
-        stage: "retry"
-      });
-      throw error;
-    }
-  }
-  #headers(body, options) {
-    const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
-    const headers = { ...options.headers };
-    const set = (name, value) => {
-      for (const key of Object.keys(headers))
-        if (key.toLowerCase() === name.toLowerCase())
-          delete headers[key];
-      headers[name] = value;
-    };
-    if (options.auth !== false && this.#token)
-      set("Authorization", `Bot ${this.#token}`);
-    set("User-Agent", USER_AGENT);
-    if (options.reason !== undefined)
-      set("X-Audit-Log-Reason", encodeURIComponent(options.reason));
-    if (!isFormData)
-      set("Content-Type", "application/json");
-    return headers;
-  }
-  #encodeBody(body) {
-    if (typeof FormData !== "undefined" && body instanceof FormData)
-      return body;
-    return body === undefined ? undefined : JSON.stringify(body);
-  }
-  #dispatch(method, path, bodyOrOptions, options) {
-    if (options === undefined && isRequestData(bodyOrOptions))
-      return this.request(method, path, bodyOrOptions.body, bodyOrOptions);
-    return this.request(method, path, bodyOrOptions, options);
-  }
-  get(path, options) {
-    return this.request("GET", path, options?.body, options);
-  }
-  post(path, body, options) {
-    return this.#dispatch("POST", path, body, options);
-  }
-  patch(path, body, options) {
-    return this.#dispatch("PATCH", path, body, options);
-  }
-  put(path, body, options) {
-    return this.#dispatch("PUT", path, body, options);
-  }
-  delete(path, options) {
-    return this.request("DELETE", path, options?.body, options);
-  }
-  #fileForm(payload, files) {
-    const form = new FormData;
-    form.append("payload_json", JSON.stringify(payload));
-    for (let i = 0;i < files.length; i++) {
-      const file = files[i];
-      const blob = file.data instanceof Blob ? file.data : new Blob([file.data], {
-        type: file.contentType ?? "application/octet-stream"
-      });
-      form.append(`files[${i}]`, blob, file.name.replace(/[\r\n"\\]/g, "_"));
-    }
-    return form;
-  }
-  postWithFiles(path, payload, files, options) {
-    return this.request("POST", path, payload, { ...options, files });
-  }
-  patchWithFiles(path, payload, files, options) {
-    return this.request("PATCH", path, payload, { ...options, files });
-  }
-  #emit(hook, ctx) {
-    if (!hook)
-      return;
-    const withPath = ctx;
-    if (typeof withPath.path === "string")
-      ctx = { ...ctx, path: redactPath(withPath.path) };
-    Promise.resolve().then(() => hook(ctx)).catch(() => {});
-  }
-}
+import {
+  MemoryRateLimitStore2,
+  redactPath2,
+  RESTError2,
+  abortError2,
+  normalizeRoutePath2,
+  majorParameter2,
+  scopeBucket2,
+  createRouteKey2,
+  serializeQuery2,
+  RequestScheduler2,
+  headerNumber2,
+  parseRateLimitHeaders2,
+  RESTMetrics2,
+  DEFAULT_MAX_BACKOFF_MS2,
+  RateLimiter2,
+  tokenFingerprint2,
+  requestIdentity2,
+  TransportError2,
+  HttpTransport2,
+  ResponseDecoder2,
+  Routes2,
+  RESTErrorCode2,
+  fromBunRedis2,
+  RedisRateLimitStore2,
+  WebhookClient2,
+  createRetryPolicy2,
+  REST2
+} from "../chunks/index-7fp2hvmg.js";
 export {
-  DEFAULT_MAX_BACKOFF_MS,
-  RESTError as DiscordAPIError,
-  HttpTransport,
-  MemoryRateLimitStore,
-  REST,
-  RESTError,
-  RESTErrorCode,
-  RESTMetrics,
-  RateLimiter,
-  RedisRateLimitStore,
-  RequestScheduler,
-  ResponseDecoder,
-  Routes,
-  TransportError,
-  WebhookClient,
-  abortError,
-  createRetryPolicy,
-  createRouteKey,
-  fromBunRedis,
-  headerNumber,
-  majorParameter,
-  normalizeRoutePath,
-  parseRateLimitHeaders,
-  redactPath,
-  requestIdentity,
-  scopeBucket,
-  serializeQuery,
-  tokenFingerprint
+  DEFAULT_MAX_BACKOFF_MS2 as DEFAULT_MAX_BACKOFF_MS,
+  HttpTransport2 as HttpTransport,
+  MemoryRateLimitStore2 as MemoryRateLimitStore,
+  REST2 as REST,
+  RESTError2 as RESTError,
+  RESTErrorCode2 as RESTErrorCode,
+  RESTMetrics2 as RESTMetrics,
+  RateLimiter2 as RateLimiter,
+  RedisRateLimitStore2 as RedisRateLimitStore,
+  RequestScheduler2 as RequestScheduler,
+  ResponseDecoder2 as ResponseDecoder,
+  Routes2 as Routes,
+  TransportError2 as TransportError,
+  WebhookClient2 as WebhookClient,
+  abortError2 as abortError,
+  createRetryPolicy2 as createRetryPolicy,
+  createRouteKey2 as createRouteKey,
+  fromBunRedis2 as fromBunRedis,
+  headerNumber2 as headerNumber,
+  majorParameter2 as majorParameter,
+  normalizeRoutePath2 as normalizeRoutePath,
+  parseRateLimitHeaders2 as parseRateLimitHeaders,
+  redactPath2 as redactPath,
+  requestIdentity2 as requestIdentity,
+  scopeBucket2 as scopeBucket,
+  serializeQuery2 as serializeQuery,
+  tokenFingerprint2 as tokenFingerprint
 };
 
-//# debugId=94C16174A190B15864756E2164756E21
+//# debugId=74F3F0A0834E8AED64756E2164756E21