lunibee 0.3.3 → 0.4.0

package/dist/chunks/index-7fp2hvmg.js

@@ -0,0 +1,2155 @@
+// @bun
+// packages/rest/package.json
+var package_default = {
+  name: "@lunibee/rest",
+  version: "0.4.0",
+  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 MemoryRateLimitStore2 {
+  #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 > MemoryRateLimitStore2.#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);
+    MemoryRateLimitStore2.#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 = []);
+        MemoryRateLimitStore2.#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);
+    MemoryRateLimitStore2.#evict(this.#buckets);
+    const now = Date.now();
+    if (now - this.#lastPruneAt >= MemoryRateLimitStore2.#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);
+    MemoryRateLimitStore2.#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 redactPath2(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 RESTError2 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 : redactPath2(options.path);
+  }
+  get retryable() {
+    return this.kind === "rateLimited" || this.kind === "server" || this.kind === "network" || this.kind === "timeout" || this.kind === "coordination" || this.kind === "overloaded";
+  }
+}
+function abortError2(path, reason) {
+  return new RESTError2(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(abortError2(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 abortError2(path, signal.reason);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(abortError2(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 normalizeRoutePath2(path) {
+  const queryIndex = path.indexOf("?");
+  const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
+  return redactPath2(routePath).replace(/\/\d+(?=\/|$)/g, "/:id").replace(/\/reactions\/[^/]+/i, "/reactions/:emoji");
+}
+function majorParameter2(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 scopeBucket2(hashOrRoute, major) {
+  return `${hashOrRoute}|${major}`;
+}
+function createRouteKey2(method, path) {
+  const normalizedMethod = method.toUpperCase();
+  return {
+    method: normalizedMethod,
+    path,
+    route: `${normalizedMethod}:${normalizeRoutePath2(path)}`,
+    major: majorParameter2(path)
+  };
+}
+function serializeQuery2(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 RequestScheduler2 {
+  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 < RequestScheduler2.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 RESTError2("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;
+    let started = false;
+    const release = () => {
+      if (released)
+        return;
+      released = true;
+      if (!started && previous)
+        previous.then(open, open);
+      else
+        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);
+      started = true;
+      return await task(release);
+    } finally {
+      release();
+    }
+  }
+}
+
+// packages/rest/src/headers.ts
+function headerNumber2(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 parseRateLimitHeaders2(headers) {
+  const remaining = headerNumber2(headers, "X-RateLimit-Remaining");
+  const limit = headerNumber2(headers, "X-RateLimit-Limit");
+  const resetAfter = headerNumber2(headers, "X-RateLimit-Reset-After");
+  const reset = headerNumber2(headers, "X-RateLimit-Reset");
+  const retryAfter = headerNumber2(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 RESTMetrics2 {
+  #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_MS2 = 600000;
+var MAX_IDLE_REFUSALS = 16;
+var MAX_CACHED_ROUTES = 1e4;
+
+class RateLimiter2 {
+  #store;
+  #maxBackoff;
+  #telemetry;
+  #probeMs;
+  #routes = new Map;
+  #globalLimit;
+  #localGlobal = new Map;
+  constructor(store, options = {}) {
+    this.#store = store;
+    this.#maxBackoff = options.maxBackoff ?? DEFAULT_MAX_BACKOFF_MS2;
+    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 = scopeBucket2(hash ?? route, major);
+    return identity === undefined ? key : `${identity}/${key}`;
+  }
+  async#call(path, operation, call) {
+    try {
+      return await call();
+    } catch (error) {
+      if (error instanceof RESTError2)
+        throw error;
+      throw new RESTError2(`The rate-limit store failed (${operation}); request not sent.`, 0, undefined, undefined, { path, kind: "coordination", cause: sanitizeCause(error) });
+    }
+  }
+  async acquire(initialKey, signal, path, options = {}) {
+    const store = this.#store;
+    const global = "global" in options ? options.global : "";
+    if (!store.reserve) {
+      const bucket = await this.#call(path, "getBucket", () => store.getBucket(initialKey));
+      if (bucket) {
+        const delay = bucket.resetAt - Date.now();
+        if (bucket.remaining <= 0 && delay > 0)
+          await this.#wait("bucket", delay, signal, path);
+      }
+      await this.#waitGlobal(global ?? "", signal, path);
+      if (global !== undefined)
+        await this.#localGlobalSlot(global, signal, path);
+      return {
+        reserved: false,
+        known: !!bucket && bucket.resetAt > Date.now()
+      };
+    }
+    const started = performance.now();
+    let idle = 0;
+    let bucketKey = initialKey;
+    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 RESTError2("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,
+          ...bucketKey === initialKey ? {} : { key: bucketKey }
+        };
+      }
+      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 RESTError2("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 RESTError2(`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);
+      if (reservation.reason === "probe" && options.resolve)
+        bucketKey = await this.#call(path, "getBucketHash", options.resolve);
+    }
+  }
+  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 = parseRateLimitHeaders2(response.headers);
+    return headers.retryAfterMs ?? headers.resetAfterMs ?? 1000;
+  }
+  async applyResponse(response, bucketKey, route, major, options = {}) {
+    const headers = parseRateLimitHeaders2(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 = scopeBucket2(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 tokenFingerprint2(token) {
+  return createHash2("sha256").update(token).digest("hex").slice(0, 16);
+}
+function requestIdentity2(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 TransportError2 extends Error {
+  timedOut;
+  constructor(message, timedOut, cause) {
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = "TransportError";
+    this.timedOut = timedOut;
+  }
+}
+
+class HttpTransport2 {
+  #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 abortError2(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 RESTError2)
+        throw error;
+      const timedOut = error instanceof DOMException && (error.name === "TimeoutError" || error.name === "AbortError");
+      throw new TransportError2(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 ResponseDecoder2 {
+  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 Routes2 = {
+  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) => `${Routes2.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) => `${Routes2.message(channelId, messageId)}/crosspost`,
+  messageReactions: (channelId, messageId, emoji) => `${Routes2.message(channelId, messageId)}/reactions/${encodeURIComponent(emoji)}`,
+  messageReactionMe: (channelId, messageId, emoji) => `${Routes2.messageReactions(channelId, messageId, emoji)}/@me`,
+  messageReactionsAll: (channelId, messageId) => `${Routes2.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) => `${Routes2.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 RESTErrorCode2 = {
+  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 fromBunRedis2(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 RedisRateLimitStore2 {
+  #client;
+  #prefix;
+  #onErrorCallback;
+  #policy;
+  #timeout;
+  #telemetry;
+  #atomic;
+  #local = new MemoryRateLimitStore2;
+  #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 RESTError2("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 RESTError2(`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);
+      const reservation = parseReservation(result);
+      if (reservation.granted && reservation.known && this.#local.getBucket(key))
+        this.#local.reserve(key, { probeMs: options.probeMs });
+      return reservation;
+    }, () => 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 WebhookClient2 {
+  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 REST2(restOptions);
+  }
+  #prepare(options, base = {}) {
+    const payload = typeof options === "string" ? { content: options } : options;
+    const { thread_id, files, ...body } = payload;
+    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 = `${Routes2.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(`${Routes2.webhookMessage(this.id, this.token, messageId)}${query}`);
+  }
+  async editMessage(messageId, options) {
+    const { query, json, files } = this.#prepare(options);
+    const path = `${Routes2.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(`${Routes2.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.");
+  if (pathname.includes("//"))
+    throw new TypeError("REST paths must not contain empty segments ('//').");
+  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 WRAPPER_KEYS = new Set([
+  "body",
+  "files",
+  "query",
+  "headers",
+  "reason",
+  "signal",
+  "auth",
+  "timeout"
+]);
+function wrapperError(verb, body) {
+  if (typeof body !== "object" || body === null || Array.isArray(body))
+    return;
+  const keys = Object.keys(body);
+  if ((keys.includes("body") || keys.includes("files")) && keys.every((key) => WRAPPER_KEYS.has(key)))
+    return new TypeError(`rest.${verb}(path, { body, \u2026 }) was removed in 0.4.0: call rest.${verb}(path, body, options). Run \`lunibee migrate\` to find the calls.`);
+  return;
+}
+function createRetryPolicy2(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 REST2 {
+  #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 ResponseDecoder2;
+  #hooks = {};
+  #concurrentBuckets;
+  constructor(options = {}) {
+    this.#token = options.token;
+    this.#fingerprint = options.token ? tokenFingerprint2(options.token) : undefined;
+    this.#telemetry = options.telemetry;
+    this.#scheduler = new RequestScheduler2({
+      maxQueued: options.maxQueued,
+      maxQueuedPerBucket: options.maxQueuedPerBucket
+    });
+    this.#retryPolicy = options.retryPolicy ?? createRetryPolicy2(options.retries ?? 2);
+    this.#transport = options.transport ?? new HttpTransport2({
+      baseURL: options.baseURL,
+      allowInsecureBaseURL: options.allowInsecureBaseURL,
+      timeout: options.timeout
+    });
+    const store = options.store ?? new MemoryRateLimitStore2;
+    this.#concurrentBuckets = (options.concurrentBuckets ?? true) && typeof store.reserve === "function";
+    this.#limiter = new RateLimiter2(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 = tokenFingerprint2(token);
+    this.#rejected = undefined;
+  }
+  diagnostics() {
+    const store = this.#limiter.store;
+    return {
+      mode: store.mode ?? (store instanceof MemoryRateLimitStore2 ? "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(method, path, body, options = {}) {
+    if (typeof method !== "string" || !method.toUpperCase())
+      throw new TypeError("REST method is required.");
+    if (typeof path !== "string" || !path.startsWith("/"))
+      throw new TypeError("REST paths must start with '/'.");
+    assertSafePath(path);
+    const route = createRouteKey2(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 = serializeQuery2(options.query);
+    const requestPath = query ? `${path}${query}` : path;
+    if (this.#closing.signal.aborted)
+      throw abortError2(path, this.#closing.signal.reason);
+    const identity = requestIdentity2(path, options.auth !== false && this.#token ? this.#fingerprint : undefined);
+    if (identity.bucket === this.#fingerprint && this.#rejected === this.#fingerprint)
+      throw new RESTError2("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 RESTError2 && error.kind === "aborted" && error.cause instanceof QueueWaitExceeded)
+        error = new RESTError2(`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 RESTError2) {
+        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,
+          resolve: () => this.#limiter.resolveBucketKey(route.route, route.major, identity.bucket)
+        });
+        if (grant.key)
+          bucketKey = grant.key;
+      } catch (error) {
+        if (error instanceof RESTError2 && 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 abortError2(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 RESTError2 && error.kind === "aborted";
+        await this.#limiter.releaseGrant(bucketKey, grant, notSent);
+        if (error instanceof RESTError2) {
+          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 abortError2(path, options.signal.reason);
+        }
+        const failure = error instanceof TransportError2 ? error : new TransportError2("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 RESTError2(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 RESTError2(`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 RESTError2(data.message ?? response.statusText ?? `Discord REST request failed with status ${response.status}`, response.status, data.code, payload, { method, path });
+    }
+    throw new RESTError2("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);
+  }
+  get(path, options) {
+    return this.request("GET", path, options?.body, options);
+  }
+  post(path, body, options) {
+    const removed = wrapperError("post", body);
+    if (removed)
+      return Promise.reject(removed);
+    return this.request("POST", path, body, options);
+  }
+  patch(path, body, options) {
+    const removed = wrapperError("patch", body);
+    if (removed)
+      return Promise.reject(removed);
+    return this.request("PATCH", path, body, options);
+  }
+  put(path, body, options) {
+    const removed = wrapperError("put", body);
+    if (removed)
+      return Promise.reject(removed);
+    return this.request("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: redactPath2(withPath.path) };
+    Promise.resolve().then(() => hook(ctx)).catch(() => {});
+  }
+}
+
+export { 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 };
+
+//# debugId=D0A76CBA183E199B64756E2164756E21