lunibee 0.1.7 → 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.7",
+  version: "0.1.8",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -27,6 +27,17 @@ class MemoryRateLimitStore {
   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();
@@ -50,6 +61,301 @@ class MemoryRateLimitStore {
   }
 }
 
+// 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",
@@ -91,6 +397,8 @@ 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",
@@ -114,15 +422,36 @@ function snowflake(value, field) {
   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;
@@ -147,10 +476,11 @@ class RedisRateLimitStore {
       return hash ?? undefined;
     } catch (error) {
       this.#onError("getBucketHash", error);
-      return;
+      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();
@@ -167,10 +497,11 @@ class RedisRateLimitStore {
       return JSON.parse(data);
     } catch (error) {
       this.#onError("getBucket", error);
-      return;
+      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 {
@@ -185,6 +516,23 @@ class RedisRateLimitStore {
       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`);
@@ -192,10 +540,11 @@ class RedisRateLimitStore {
       return resetAt ? Number(resetAt) : 0;
     } catch (error) {
       this.#onError("getGlobalReset", error);
-      return 0;
+      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 {
@@ -251,22 +600,6 @@ 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})`;
@@ -293,26 +626,6 @@ function isRequestData(value) {
     return false;
   return keys.every((key) => REQUEST_DATA_KEYS.has(key));
 }
-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}`;
-}
-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 createRetryPolicy(maxRetries = 2) {
   if (!Number.isFinite(maxRetries) || maxRetries < 0)
     throw new TypeError("maxRetries must be a non-negative finite number.");
@@ -320,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)
@@ -331,22 +647,32 @@ function createRetryPolicy(maxRetries = 2) {
 }
 
 class REST {
-  #baseURL;
-  #timeout;
   #retryPolicy;
   #token;
-  #store;
-  #localQueues = 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.#store = options.store ?? new MemoryRateLimitStore;
+    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;
@@ -357,121 +683,109 @@ 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 = 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 finalPath = query ? `${path}${query}` : path;
-    const route = `${normalizedMethod}:${this.#normalizeRoute(path)}`;
-    const major = majorParameter(path);
-    let bucketKey = scopeBucket(await this.#store.getBucketHash(route) ?? route, major);
-    const queueKey = bucketKey;
-    const previous = this.#localQueues.get(queueKey) ?? Promise.resolve();
-    let release;
-    const gate = new Promise((resolve) => {
-      release = resolve;
-    });
-    this.#localQueues.set(queueKey, gate);
-    await this.#abortable(previous, options.signal, path);
-    try {
-      for (let attempt = 0;attempt <= this.#retryPolicy.maxRetries; attempt++) {
-        await this.#wait(bucketKey, options.signal, path);
-        await this.#waitGlobal(options.signal, path);
-        const controller = new AbortController;
-        const onAbort = () => controller.abort(options.signal?.reason);
-        if (options.signal?.aborted)
-          throw this.#abortError(path, options.signal.reason);
-        options.signal?.addEventListener("abort", onAbort, {
-          once: true
+    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
         });
-        const timer = setTimeout(() => controller.abort(new DOMException("REST request timeout", "TimeoutError")), this.#timeout);
-        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";
-        const fetchBody = isFormData ? body : body === undefined ? undefined : JSON.stringify(body);
-        try {
-          this.#emit(this.#hooks.onRequest, {
-            method: normalizedMethod,
-            path,
-            attempt
-          });
-          const requestStart = Date.now();
-          const response = await fetch(`${this.#baseURL}${finalPath}`, {
-            method: normalizedMethod,
-            headers,
-            body: fetchBody,
-            signal: controller.signal
-          });
-          this.#emit(this.#hooks.onResponse, {
-            method: normalizedMethod,
-            path,
-            status: response.status,
-            durationMs: Date.now() - requestStart
-          });
-          bucketKey = await this.#update(response, bucketKey, route, major);
-          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) {
-            const currentGlobal = await this.#store.getGlobalReset();
-            await this.#store.setGlobalReset(Math.max(currentGlobal, Date.now() + retryAfter * 1000));
-          }
-          if (response.status === 429)
-            this.#emit(this.#hooks.onRateLimit, {
-              method: normalizedMethod,
-              path,
-              retryAfterMs: (retryAfter ?? 1) * 1000,
-              global: data.global ?? false,
-              bucket: await this.#store.getBucketHash(route)
-            });
-          if (attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(normalizedMethod, response.status)) {
-            const delay = this.#retryPolicy.getDelay(attempt, retryAfter);
-            this.#emit(this.#hooks.onRetry, {
-              method: normalizedMethod,
-              path,
-              attempt,
-              status: response.status,
-              delayMs: delay
-            });
-            await this.#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: 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);
+      } catch (error) {
+        if (error instanceof RESTError)
+          throw error;
+        if (options.signal?.aborted)
+          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();
-      if (this.#localQueues.get(queueKey) === gate)
-        this.#localQueues.delete(queueKey);
+      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))
@@ -516,125 +830,27 @@ class REST {
       return;
     Promise.resolve().then(() => hook(ctx)).catch(() => {});
   }
-  async#wait(bucketKey, signal, path) {
-    const bucket = await this.#store.getBucket(bucketKey);
-    if (!bucket)
-      return;
-    const delay = bucket.resetAt - Date.now();
-    if (bucket.remaining <= 0 && delay > 0)
-      await this.#sleep(delay, signal, path);
-  }
-  async#waitGlobal(signal, path) {
-    const globalResetAt = await this.#store.getGlobalReset();
-    const delay = 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)
-      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");
-  }
-  async#update(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);
-    }
-    let bucket = await this.#store.getBucket(currentKey) ?? {
-      remaining: 1,
-      resetAt: 0
-    };
-    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);
-    }
-    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)) {
-        const currentGlobal = await this.#store.getGlobalReset();
-        await this.#store.setGlobalReset(Math.max(currentGlobal, Date.now() + retryAfter * 1000));
-      }
-    }
-    return currentKey;
-  }
 }
 export {
   RESTError as DiscordAPIError,
+  HttpTransport,
   MemoryRateLimitStore,
   REST,
   RESTError,
+  RateLimiter,
   RedisRateLimitStore,
+  RequestScheduler,
+  ResponseDecoder,
   Routes,
+  TransportError,
   WebhookClient,
-  createRetryPolicy
+  abortError,
+  createRetryPolicy,
+  createRouteKey,
+  majorParameter,
+  normalizeRoutePath,
+  scopeBucket,
+  serializeQuery
 };
 
-//# debugId=7273A79583E1900164756E2164756E21
+//# debugId=CCF20CDF4862826C64756E2164756E21