lunibee 0.1.6 → 0.1.8

package/dist/rest/index.js

@@ -2,7 +2,7 @@
 // packages/rest/package.json
 var package_default = {
   name: "@lunibee/rest",
-  version: "0.1.6",
+  version: "0.1.8",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -11,6 +11,351 @@ var package_default = {
   }
 };
 
+// packages/rest/src/store.ts
+class MemoryRateLimitStore {
+  #buckets = new Map;
+  #routeBuckets = new Map;
+  #globalResetAt = 0;
+  static #PRUNE_INTERVAL = 60000;
+  #lastPruneAt = 0;
+  getBucketHash(route) {
+    return this.#routeBuckets.get(route);
+  }
+  setBucketHash(route, hash) {
+    this.#routeBuckets.set(route, hash);
+  }
+  getBucket(key) {
+    return this.#buckets.get(key);
+  }
+  reserve(key) {
+    const state = this.#buckets.get(key);
+    const now = Date.now();
+    if (!state || state.resetAt <= now)
+      return { granted: true };
+    if (state.remaining > 0) {
+      state.remaining -= 1;
+      return { granted: true };
+    }
+    return { granted: false, retryAfterMs: state.resetAt - now };
+  }
+  updateBucket(key, state) {
+    this.#buckets.set(key, state);
+    const now = Date.now();
+    if (now - this.#lastPruneAt >= MemoryRateLimitStore.#PRUNE_INTERVAL) {
+      this.#lastPruneAt = now;
+      this.prune();
+    }
+  }
+  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);
+    }
+  }
+  getGlobalReset() {
+    return this.#globalResetAt;
+  }
+  setGlobalReset(resetAt) {
+    this.#globalResetAt = resetAt;
+  }
+}
+
+// packages/rest/src/errors.ts
+class RESTError extends Error {
+  status;
+  code;
+  errors;
+  method;
+  path;
+  constructor(message, status, code, errors, options = {}) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "RESTError";
+    this.status = status;
+    this.code = code;
+    this.errors = errors;
+    this.method = options.method;
+    this.path = options.path;
+  }
+}
+function abortError(path, reason) {
+  return new RESTError(reason instanceof Error ? reason.message : "Discord REST request was aborted", 0, undefined, undefined, { path, cause: reason });
+}
+async function sleep(delay, signal, path) {
+  if (delay <= 0)
+    return;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, delay);
+    const abort = () => {
+      clearTimeout(timer);
+      reject(abortError(path, signal?.reason));
+    };
+    if (signal?.aborted)
+      return abort();
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+async function abortable(promise, signal, path) {
+  if (!signal)
+    return promise;
+  if (signal.aborted)
+    throw abortError(path, signal.reason);
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => signal.addEventListener("abort", () => reject(abortError(path, signal.reason)), { once: true }))
+  ]);
+}
+
+// packages/rest/src/route.ts
+function normalizeRoutePath(path) {
+  const queryIndex = path.indexOf("?");
+  const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
+  return routePath.replace(/\/\d+(?=\/|$)/g, "/:id");
+}
+function majorParameter(path) {
+  const match = /^\/(channels|guilds|webhooks)\/(\d+)(?:\/([^/?]+))?/.exec(path);
+  if (!match)
+    return "@none";
+  if (match[1] === "webhooks" && match[3] !== undefined)
+    return `${match[2]}:${match[3]}`;
+  return match[2];
+}
+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;
+  get size() {
+    return this.#queues.size;
+  }
+  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) ?? Promise.resolve();
+    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 {
+      await abortable(previous, signal, path);
+      return await task(release);
+    } finally {
+      release();
+    }
+  }
+}
+
+// packages/rest/src/limiter.ts
+class RateLimiter {
+  #store;
+  #concurrent;
+  constructor(store, options = {}) {
+    this.#store = store;
+    this.#concurrent = options.concurrent ?? false;
+  }
+  get store() {
+    return this.#store;
+  }
+  async resolveBucketKey(route, major) {
+    return scopeBucket(await this.#store.getBucketHash(route) ?? route, major);
+  }
+  get reserves() {
+    return typeof this.#store.reserve === "function";
+  }
+  async acquire(bucketKey, signal, path) {
+    await this.#waitGlobal(signal, path);
+    if (!this.#store.reserve) {
+      const bucket = await this.#store.getBucket(bucketKey);
+      if (bucket) {
+        const delay = bucket.resetAt - Date.now();
+        if (bucket.remaining <= 0 && delay > 0)
+          await sleep(delay, signal, path);
+      }
+      return;
+    }
+    for (let attempt = 0;attempt < 8; attempt++) {
+      const reservation = await this.#store.reserve(bucketKey);
+      if (reservation.granted)
+        return;
+      await sleep(Math.max(1, reservation.retryAfterMs), signal, path);
+      await this.#waitGlobal(signal, path);
+    }
+  }
+  async#waitGlobal(signal, path) {
+    const globalDelay = await this.#store.getGlobalReset() - Date.now();
+    if (globalDelay > 0)
+      await sleep(globalDelay, signal, path);
+  }
+  async noteGlobalReset(resetAt) {
+    const current = await this.#store.getGlobalReset();
+    await this.#store.setGlobalReset(Math.max(current, resetAt));
+  }
+  async applyResponse(response, bucketKey, route, major) {
+    let currentKey = bucketKey;
+    const serverBucket = response.headers.get("X-RateLimit-Bucket");
+    if (serverBucket) {
+      await this.#store.setBucketHash(route, serverBucket);
+      currentKey = scopeBucket(serverBucket, major);
+    }
+    const stored = await this.#store.getBucket(currentKey);
+    const bucket = stored ? { ...stored } : { remaining: 1, resetAt: 0 };
+    const windowActive = this.#concurrent && !!stored && stored.resetAt > Date.now();
+    const remaining = Number(response.headers.get("X-RateLimit-Remaining"));
+    const resetAfter = Number(response.headers.get("X-RateLimit-Reset-After"));
+    const reset = Number(response.headers.get("X-RateLimit-Reset"));
+    if (Number.isFinite(remaining))
+      bucket.remaining = Math.max(0, remaining);
+    if (Number.isFinite(resetAfter))
+      bucket.resetAt = Date.now() + Math.max(0, resetAfter) * 1000;
+    else if (Number.isFinite(reset))
+      bucket.resetAt = reset * 1000;
+    if (windowActive && stored) {
+      bucket.remaining = Math.min(bucket.remaining, stored.remaining);
+      bucket.resetAt = Math.max(bucket.resetAt, stored.resetAt);
+    }
+    if (response.status === 429) {
+      const retryAfter = Number(response.headers.get("Retry-After"));
+      if (Number.isFinite(retryAfter))
+        bucket.resetAt = Math.max(bucket.resetAt, Date.now() + retryAfter * 1000);
+    }
+    await this.#store.updateBucket(currentKey, bucket);
+    if (response.headers.get("X-RateLimit-Global") === "true") {
+      const retryAfter = Number(response.headers.get("Retry-After"));
+      if (Number.isFinite(retryAfter))
+        await this.noteGlobalReset(Date.now() + retryAfter * 1000);
+    }
+    return currentKey;
+  }
+}
+
+// packages/rest/src/transport.ts
+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 = (options.baseURL ?? "https://discord.com/api/v10").replace(/\/$/, "");
+    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
+      });
+    } 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, error);
+    } finally {
+      clearTimeout(timer);
+      request.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+}
+
+// packages/rest/src/decoder.ts
+class ResponseDecoder {
+  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",
@@ -52,17 +397,169 @@ var Routes = {
   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"
+  gatewayBot: () => "/gateway/bot",
+  guildAuditLog: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/audit-logs`,
+  guildMembers: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/members`,
+  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`
 };
 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/redis.ts
+var RESERVE_SCRIPT = `
+local raw = redis.call('GET', KEYS[1])
+if not raw then return {1, 0} end
+local ok, state = pcall(cjson.decode, raw)
+if not ok or type(state) ~= 'table' or type(state.resetAt) ~= 'number' then
+  return {1, 0}
+end
+local now = tonumber(ARGV[1])
+local wait = state.resetAt - now
+if wait <= 0 then return {1, 0} end
+if type(state.remaining) == 'number' and state.remaining > 0 then
+  state.remaining = state.remaining - 1
+  redis.call('SET', KEYS[1], cjson.encode(state), 'PX', math.ceil(wait))
+  return {1, 0}
+end
+return {0, math.ceil(wait)}
+`;
+
+class RedisRateLimitStore {
+  #client;
+  #prefix;
+  #onErrorCallback;
+  #local = new MemoryRateLimitStore;
+  #lastError;
+  constructor(options) {
+    this.#client = options.client;
+    this.#prefix = options.prefix ?? "lunibee:rest:";
+    this.#onErrorCallback = options.onError;
+    if (typeof options.client.eval === "function")
+      this.reserve = (key) => this.#reserve(key);
+  }
+  get lastError() {
+    return this.#lastError;
+  }
+  isHealthy() {
+    return this.#lastError === undefined;
+  }
+  #onError(operation, error) {
+    this.#lastError = error;
+    console.warn(`[lunibee/rest] Redis rate-limit store ${operation} failed; ` + `falling back to local limiting for this call.`, error);
+    try {
+      this.#onErrorCallback?.(operation, error);
+    } catch {}
+  }
+  #markHealthy() {
+    this.#lastError = undefined;
+  }
+  async getBucketHash(route) {
+    try {
+      const hash = await this.#client.get(`${this.#prefix}route:${route}`);
+      this.#markHealthy();
+      return hash ?? undefined;
+    } catch (error) {
+      this.#onError("getBucketHash", error);
+      return this.#local.getBucketHash(route);
+    }
+  }
+  async setBucketHash(route, hash) {
+    this.#local.setBucketHash(route, hash);
+    try {
+      await this.#client.set(`${this.#prefix}route:${route}`, hash, "EX", 604800);
+      this.#markHealthy();
+    } catch (error) {
+      this.#onError("setBucketHash", error);
+    }
+  }
+  async getBucket(key) {
+    try {
+      const data = await this.#client.get(`${this.#prefix}bucket:${key}`);
+      this.#markHealthy();
+      if (!data)
+        return;
+      return JSON.parse(data);
+    } catch (error) {
+      this.#onError("getBucket", error);
+      return this.#local.getBucket(key);
+    }
+  }
+  async updateBucket(key, state) {
+    this.#local.updateBucket(key, state);
+    const bucketKey = `${this.#prefix}bucket:${key}`;
+    const ttl = Math.ceil((state.resetAt - Date.now()) / 1000);
+    try {
+      if (ttl <= 0) {
+        await this.#client.del(bucketKey);
+        this.#markHealthy();
+        return;
+      }
+      await this.#client.set(bucketKey, JSON.stringify(state), "EX", ttl);
+      this.#markHealthy();
+    } catch (error) {
+      this.#onError("updateBucket", error);
+    }
+  }
+  get supportsReservation() {
+    return typeof this.#client.eval === "function";
+  }
+  reserve;
+  async#reserve(key) {
+    try {
+      const result = await this.#client.eval(RESERVE_SCRIPT, 1, `${this.#prefix}bucket:${key}`, Date.now());
+      this.#markHealthy();
+      if (!Array.isArray(result))
+        return { granted: true };
+      const [granted, retryAfterMs] = result;
+      return Number(granted) === 1 ? { granted: true } : { granted: false, retryAfterMs: Number(retryAfterMs) || 0 };
+    } catch (error) {
+      this.#onError("reserve", error);
+      return this.#local.reserve(key);
+    }
+  }
+  async getGlobalReset() {
+    try {
+      const resetAt = await this.#client.get(`${this.#prefix}global`);
+      this.#markHealthy();
+      return resetAt ? Number(resetAt) : 0;
+    } catch (error) {
+      this.#onError("getGlobalReset", error);
+      return this.#local.getGlobalReset();
+    }
+  }
+  async setGlobalReset(resetAt) {
+    this.#local.setGlobalReset(resetAt);
+    const globalKey = `${this.#prefix}global`;
+    const ttl = Math.ceil((resetAt - Date.now()) / 1000);
+    try {
+      if (ttl <= 0) {
+        await this.#client.del(globalKey);
+        this.#markHealthy();
+        return;
+      }
+      await this.#client.set(globalKey, String(resetAt), "EX", ttl);
+      this.#markHealthy();
+    } catch (error) {
+      this.#onError("setGlobalReset", error);
+    }
+  }
+}
 // packages/rest/src/webhook.ts
 class WebhookClient {
   id;
@@ -87,7 +584,7 @@ class WebhookClient {
     const payload = typeof options === "string" ? { content: options } : options;
     const { thread_id, ...body } = payload;
     const query = thread_id ? `?thread_id=${thread_id}&wait=true` : `?wait=true`;
-    const formattedEmbeds = body.embeds?.map((e) => typeof e === "object" && e !== null && ("toJSON" in e) ? e.toJSON() : e);
+    const formattedEmbeds = body.embeds?.map((e) => ("toJSON" in e) ? e.toJSON() : e);
     return this.#rest.post(`${Routes.webhook(this.id, this.token)}${query}`, {
       ...body,
       embeds: formattedEmbeds
@@ -103,25 +600,32 @@ class WebhookClient {
 }
 
 // packages/rest/src/index.ts
-class RESTError extends Error {
-  status;
-  code;
-  errors;
-  method;
-  path;
-  constructor(message, status, code, errors, options = {}) {
-    super(message, options.cause === undefined ? undefined : { cause: options.cause });
-    this.name = "RESTError";
-    this.status = status;
-    this.code = code;
-    this.errors = errors;
-    this.method = options.method;
-    this.path = options.path;
-  }
-}
 var LIBRARY_VERSION = package_default.version;
 var LIBRARY_URL = "https://github.com/Ekretos/lunibee";
 var USER_AGENT = `DiscordBot (${LIBRARY_URL}, ${package_default.version})`;
+var REQUEST_DATA_KEYS = new Set([
+  "body",
+  "files",
+  "query",
+  "headers",
+  "reason",
+  "auth",
+  "signal"
+]);
+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.");
@@ -129,7 +633,10 @@ function createRetryPolicy(maxRetries = 2) {
     maxRetries: Math.floor(maxRetries),
     shouldRetry(method, status) {
       const normalized = method.toUpperCase();
-      return status === 429 || status >= 500 && status <= 599 && ["GET", "HEAD", "PUT", "DELETE"].includes(normalized);
+      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)
@@ -140,18 +647,35 @@ function createRetryPolicy(maxRetries = 2) {
 }
 
 class REST {
-  #baseURL;
-  #timeout;
   #retryPolicy;
   #token;
-  #globalResetAt = 0;
-  #buckets = new Map;
-  #routeBuckets = new Map;
+  #limiter;
+  #scheduler = new RequestScheduler;
+  #transport;
+  #decoder = new ResponseDecoder;
+  #hooks = {};
+  #concurrentBuckets;
   constructor(options = {}) {
     this.#token = options.token;
-    this.#timeout = Math.max(1, options.timeout ?? 15000);
     this.#retryPolicy = options.retryPolicy ?? createRetryPolicy(options.retries ?? 2);
-    this.#baseURL = (options.baseURL ?? "https://discord.com/api/v10").replace(/\/$/, "");
+    this.#transport = options.transport ?? new HttpTransport({
+      baseURL: options.baseURL,
+      timeout: options.timeout
+    });
+    const store = options.store ?? new MemoryRateLimitStore;
+    this.#concurrentBuckets = (options.concurrentBuckets ?? false) && typeof store.reserve === "function";
+    this.#limiter = new RateLimiter(store, {
+      concurrent: this.#concurrentBuckets
+    });
+    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())
@@ -159,99 +683,129 @@ class REST {
     this.#token = token;
   }
   async request(method, path, body, options = {}) {
-    const normalizedMethod = method.toUpperCase();
-    if (!normalizedMethod)
+    if (!method.toUpperCase())
       throw new TypeError("REST method is required.");
     if (!path.startsWith("/"))
       throw new TypeError("REST paths must start with '/'.");
-    const route = `${normalizedMethod}:${this.#normalizeRoute(path)}`;
-    let bucketKey = this.#routeBuckets.get(route) ?? route;
-    let bucket = this.#buckets.get(bucketKey) ?? {
-      remaining: 1,
-      resetAt: 0,
-      queue: Promise.resolve()
-    };
-    this.#buckets.set(bucketKey, bucket);
-    const previous = bucket.queue;
-    let release;
-    bucket.queue = new Promise((resolve) => {
-      release = resolve;
-    });
-    await this.#abortable(previous, options.signal, path);
-    try {
-      for (let attempt = 0;attempt <= this.#retryPolicy.maxRetries; attempt++) {
-        await this.#wait(bucket, options.signal, path);
-        await this.#waitGlobal(options.signal, path);
-        const controller = new AbortController;
-        const onAbort = () => controller.abort(options.signal?.reason);
+    const route = createRouteKey(method, path);
+    const files = options.files;
+    if (files && files.length > 0 && !(body instanceof FormData))
+      body = this.#fileForm(body, files);
+    const query = serializeQuery(options.query);
+    const requestPath = query ? `${path}${query}` : path;
+    return this.#scheduler.runResolved(() => this.#limiter.resolveBucketKey(route.route, route.major), options.signal, path, (bucketKey, release) => this.#attempts(route, requestPath, body, options, bucketKey, release));
+  }
+  async#attempts(route, requestPath, body, options, initialBucketKey, release) {
+    const { method, path } = route;
+    let bucketKey = initialBucketKey;
+    for (let attempt = 0;attempt <= this.#retryPolicy.maxRetries; attempt++) {
+      await this.#limiter.acquire(bucketKey, options.signal, path);
+      if (this.#concurrentBuckets) {
+        const bucket = await this.#limiter.store.getBucket(bucketKey);
+        if (bucket && bucket.resetAt > Date.now())
+          release();
+      }
+      this.#emit(this.#hooks.onRequest, { method, path, attempt });
+      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) {
+        if (error instanceof RESTError)
+          throw error;
         if (options.signal?.aborted)
-          throw this.#abortError(path, options.signal.reason);
-        options.signal?.addEventListener("abort", onAbort, { once: true });
-        const timer = setTimeout(() => controller.abort(new DOMException("REST request timeout", "TimeoutError")), this.#timeout);
-        const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
-        const headers = {
-          ...this.#token ? { Authorization: `Bot ${this.#token}` } : {},
-          "User-Agent": USER_AGENT
-        };
-        if (!isFormData)
-          headers["Content-Type"] = "application/json";
-        const fetchBody = isFormData ? body : body === undefined ? undefined : JSON.stringify(body);
-        try {
-          const response = await fetch(`${this.#baseURL}${path}`, {
-            method: normalizedMethod,
-            headers,
-            body: fetchBody,
-            signal: controller.signal
-          });
-          bucket = this.#update(response, bucket, route, bucketKey);
-          bucketKey = this.#routeBuckets.get(route) ?? bucketKey;
-          const payload = await this.#readPayload(response);
-          if (response.ok)
-            return response.status === 204 ? undefined : payload;
-          const data = this.#errorData(payload);
-          const retryAfter = response.status === 429 ? this.#retryAfter(response, data) : undefined;
-          if (data.global && retryAfter !== undefined)
-            this.#globalResetAt = Date.now() + retryAfter * 1000;
-          if (attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(normalizedMethod, response.status)) {
-            await this.#sleep(this.#retryPolicy.getDelay(attempt, retryAfter), options.signal, path);
-            continue;
-          }
-          throw new RESTError(data.message ?? response.statusText ?? `Discord REST request failed with status ${response.status}`, response.status, data.code, payload, { method: normalizedMethod, path });
-        } catch (error) {
-          if (error instanceof RESTError)
-            throw error;
-          if (options.signal?.aborted)
-            throw this.#abortError(path, options.signal.reason);
-          const isTimeout = error instanceof DOMException && (error.name === "TimeoutError" || error.name === "AbortError");
-          if (!isTimeout && attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(normalizedMethod, 0)) {
-            await this.#sleep(this.#retryPolicy.getDelay(attempt), options.signal, path);
-            continue;
-          }
-          throw new RESTError(isTimeout ? `Discord REST request timed out after ${this.#timeout}ms` : "Discord REST request failed", 0, undefined, undefined, { method: normalizedMethod, path, cause: error });
-        } finally {
-          clearTimeout(timer);
-          options.signal?.removeEventListener("abort", onAbort);
+          throw abortError(path, options.signal.reason);
+        const failure = error instanceof TransportError ? error : new TransportError("Discord REST request failed", false, error);
+        if (!failure.timedOut && attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(method, 0)) {
+          await sleep(this.#retryPolicy.getDelay(attempt), options.signal, path);
+          continue;
         }
+        throw new RESTError(failure.message, 0, undefined, undefined, {
+          method,
+          path,
+          cause: failure.cause ?? failure
+        });
       }
-      throw new RESTError("Discord REST request exhausted its retry attempts", 0, undefined, undefined, { method: normalizedMethod, path });
-    } finally {
-      release();
+      this.#emit(this.#hooks.onResponse, {
+        method,
+        path,
+        status: response.status,
+        durationMs: Date.now() - requestStart
+      });
+      bucketKey = await this.#limiter.applyResponse(response, bucketKey, route.route, route.major);
+      const payload = await this.#decoder.read(response);
+      if (response.ok)
+        return response.status === 204 ? undefined : payload;
+      const data = this.#decoder.errorData(payload);
+      const retryAfter = response.status === 429 ? this.#decoder.retryAfter(response, data) : undefined;
+      if (data.global && retryAfter !== undefined)
+        await this.#limiter.noteGlobalReset(Date.now() + retryAfter * 1000);
+      if (response.status === 429)
+        this.#emit(this.#hooks.onRateLimit, {
+          method,
+          path,
+          retryAfterMs: (retryAfter ?? 1) * 1000,
+          global: data.global ?? false,
+          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, retryAfter);
+        this.#emit(this.#hooks.onRetry, {
+          method,
+          path,
+          attempt,
+          status: response.status,
+          delayMs: delay
+        });
+        await sleep(delay, options.signal, 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 });
+  }
+  #headers(body, options) {
+    const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
+    const headers = { ...options.headers };
+    if (options.auth !== false && this.#token)
+      headers["Authorization"] = `Bot ${this.#token}`;
+    headers["User-Agent"] = USER_AGENT;
+    if (options.reason !== undefined)
+      headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
+    if (!isFormData)
+      headers["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, undefined, options);
+    return this.request("GET", path, options?.body, options);
   }
   post(path, body, options) {
-    return this.request("POST", path, body, options);
+    return this.#dispatch("POST", path, body, options);
   }
   patch(path, body, options) {
-    return this.request("PATCH", path, body, options);
+    return this.#dispatch("PATCH", path, body, options);
   }
   put(path, body, options) {
-    return this.request("PUT", path, body, options);
+    return this.#dispatch("PUT", path, body, options);
   }
   delete(path, options) {
-    return this.request("DELETE", path, undefined, options);
+    return this.request("DELETE", path, options?.body, options);
   }
   #fileForm(payload, files) {
     const form = new FormData;
@@ -271,114 +825,32 @@ class REST {
   patchWithFiles(path, payload, files, options) {
     return this.request("PATCH", path, this.#fileForm(payload, files), options);
   }
-  async#wait(bucket, signal, path) {
-    const delay = bucket.resetAt - Date.now();
-    if (bucket.remaining <= 0 && delay > 0)
-      await this.#sleep(delay, signal, path);
-  }
-  async#waitGlobal(signal, path) {
-    const delay = this.#globalResetAt - Date.now();
-    if (delay > 0)
-      await this.#sleep(delay, signal, path);
-  }
-  async#sleep(delay, signal, path) {
-    if (delay <= 0)
-      return;
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(resolve, delay);
-      const abort = () => {
-        clearTimeout(timer);
-        reject(this.#abortError(path, signal?.reason));
-      };
-      if (signal?.aborted)
-        return abort();
-      signal?.addEventListener("abort", abort, { once: true });
-    });
-  }
-  async#abortable(promise, signal, path) {
-    if (!signal)
-      return promise;
-    if (signal.aborted)
-      throw this.#abortError(path, signal.reason);
-    return Promise.race([
-      promise,
-      new Promise((_, reject) => signal.addEventListener("abort", () => reject(this.#abortError(path, signal.reason)), { once: true }))
-    ]);
-  }
-  #abortError(path, reason) {
-    return new RESTError(reason instanceof Error ? reason.message : "Discord REST request was aborted", 0, undefined, undefined, { path, cause: reason });
-  }
-  async#readPayload(response) {
-    if (response.status === 204)
+  #emit(hook, ctx) {
+    if (!hook)
       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 header = Number(response.headers.get("Retry-After"));
-    const retryAfter = data.retry_after ?? (Number.isFinite(header) ? header : 1);
-    return Math.max(0, retryAfter);
-  }
-  #normalizeRoute(path) {
-    const queryIndex = path.indexOf("?");
-    const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
-    return routePath.replace(/\/\d+(?=\/|$)/g, "/:id");
-  }
-  #update(response, bucket, route, bucketKey) {
-    const serverBucket = response.headers.get("X-RateLimit-Bucket");
-    if (serverBucket) {
-      this.#routeBuckets.set(route, serverBucket);
-      if (serverBucket !== bucketKey) {
-        const shared = this.#buckets.get(serverBucket) ?? bucket;
-        this.#buckets.set(serverBucket, shared);
-        bucket = shared;
-      }
-    }
-    const remaining = Number(response.headers.get("X-RateLimit-Remaining"));
-    const resetAfter = Number(response.headers.get("X-RateLimit-Reset-After"));
-    const reset = Number(response.headers.get("X-RateLimit-Reset"));
-    if (Number.isFinite(remaining))
-      bucket.remaining = Math.max(0, remaining);
-    if (Number.isFinite(resetAfter))
-      bucket.resetAt = Date.now() + Math.max(0, resetAfter) * 1000;
-    else if (Number.isFinite(reset))
-      bucket.resetAt = reset * 1000;
-    if (response.status === 429) {
-      const retryAfter = Number(response.headers.get("Retry-After"));
-      if (Number.isFinite(retryAfter))
-        bucket.resetAt = Math.max(bucket.resetAt, Date.now() + retryAfter * 1000);
-    }
-    if (response.headers.get("X-RateLimit-Global") === "true") {
-      const retryAfter = Number(response.headers.get("Retry-After"));
-      if (Number.isFinite(retryAfter))
-        this.#globalResetAt = Math.max(this.#globalResetAt, Date.now() + retryAfter * 1000);
-    }
-    return bucket;
+    Promise.resolve().then(() => hook(ctx)).catch(() => {});
   }
 }
 export {
+  RESTError as DiscordAPIError,
+  HttpTransport,
+  MemoryRateLimitStore,
   REST,
   RESTError,
+  RateLimiter,
+  RedisRateLimitStore,
+  RequestScheduler,
+  ResponseDecoder,
   Routes,
+  TransportError,
   WebhookClient,
-  createRetryPolicy
+  abortError,
+  createRetryPolicy,
+  createRouteKey,
+  majorParameter,
+  normalizeRoutePath,
+  scopeBucket,
+  serializeQuery
 };
 
-//# debugId=429E85E3F97473C964756E2164756E21
+//# debugId=CCF20CDF4862826C64756E2164756E21