lunibee 0.1.6 → 0.1.7

package/dist/rest/index.d.ts

@@ -12,15 +12,86 @@ export declare class RESTError extends Error {
         cause?: unknown;
     });
 }
-/** Options controlling an individual REST request. */
-export interface RESTRequestOptions {
-    /** Abort signal used to cancel the request and any queued wait. */ signal?: AbortSignal;
-}
+import { type RateLimitStore } from "./store.js";
+/** A file attachment sent as part of a multipart REST request. */
 export interface RESTFileAttachment {
     name: string;
     data: Blob | Uint8Array | ArrayBuffer;
     contentType?: string;
 }
+/** Query-string value accepted by {@link RESTRequestOptions.query}. */
+export type RESTQuery = URLSearchParams | Record<string, string | number | boolean | null | undefined> | string;
+/**
+ * Options controlling an individual REST request.
+ *
+ * Lunibee's canonical call shape is positional (`post(path, body)`); these options
+ * add the Discord.js-`@discordjs/rest`-familiar per-request knobs (`query`, `headers`,
+ * `reason`, `auth`) additively without changing that positional default.
+ */
+export interface RESTRequestOptions {
+    /** Abort signal used to cancel the request and any queued wait. */ signal?: AbortSignal;
+    /** Query-string appended to the path (`URLSearchParams`, a record, or a raw string). */ query?: RESTQuery;
+    /** Extra request headers merged in (library headers such as `Authorization` win). */ headers?: Record<string, string>;
+    /** Audit-log reason, sent as the `X-Audit-Log-Reason` header. */ reason?: string;
+    /** Set `false` to omit the `Authorization` header for this request. Defaults to `true`. */ auth?: boolean;
+}
+/**
+ * Discord.js-familiar request payload. Superset of {@link RESTRequestOptions} that also
+ * carries the `body` and `files`, matching `@discordjs/rest`'s `RequestData`. It powers the
+ * additive `method(path, { body })` overloads without breaking the positional signature.
+ */
+export interface RequestData extends RESTRequestOptions {
+    /** Request body. Encoded as JSON unless `files` are present (then multipart). */ body?: unknown;
+    /** File attachments; presence upgrades the request to `multipart/form-data`. */ files?: RESTFileAttachment[];
+}
+/** Context passed to `RESTHooks.onRequest`. */
+export interface RESTRequestContext {
+    method: string;
+    path: string;
+    attempt: number;
+}
+/** Context passed to `RESTHooks.onResponse`. */
+export interface RESTResponseContext {
+    method: string;
+    path: string;
+    status: number;
+    durationMs: number;
+}
+/** Context passed to `RESTHooks.onRateLimit`. */
+export interface RESTRateLimitContext {
+    method: string;
+    path: string;
+    retryAfterMs: number;
+    global: boolean;
+    bucket?: string;
+}
+/** Context passed to `RESTHooks.onRetry`. */
+export interface RESTRetryContext {
+    method: string;
+    path: string;
+    attempt: number;
+    status: number;
+    delayMs: number;
+}
+/**
+ * Lightweight callback hooks for REST request lifecycle events.
+ *
+ * All callbacks are optional. They are dispatched in isolation from the request
+ * path (deferred to a microtask, and any thrown error is swallowed), so a hook
+ * cannot break or reject a request. Even so, hooks **must** be fast and
+ * non-blocking: heavy synchronous work in a hook still steals event-loop time
+ * from in-flight requests. Offload anything expensive to your own queue.
+ */
+export interface RESTHooks {
+    /** Called just before every HTTP attempt. */
+    onRequest?(ctx: RESTRequestContext): void;
+    /** Called after a successful or failed response is received. */
+    onResponse?(ctx: RESTResponseContext): void;
+    /** Called when a rate limit is encountered and the client is about to wait. */
+    onRateLimit?(ctx: RESTRateLimitContext): void;
+    /** Called when a failed request is about to be retried. */
+    onRetry?(ctx: RESTRetryContext): void;
+}
 /** Configures which REST failures may be retried. */
 export interface RetryPolicy {
     /** Maximum retry attempts. */ maxRetries: number;
@@ -39,7 +110,11 @@ export declare class REST {
         retries?: number;
         retryPolicy?: RetryPolicy;
         baseURL?: string;
+        hooks?: RESTHooks;
+        store?: RateLimitStore;
     });
+    /** Replaces the current hook set. Pass an empty object to clear all hooks. */
+    setHooks(hooks: RESTHooks): this;
     /** Sets the authentication token. @param token Discord bot token. @returns Nothing. @throws {TypeError} If token is empty. */
     setToken(token: string): void;
     /** Executes an HTTP request with Discord bucket/global rate limits, retry handling, and AbortSignal support.
@@ -47,16 +122,23 @@ export declare class REST {
      * @param method HTTP method.
      * @param path API path.
      * @param body Optional JSON body, FormData for file uploads, or undefined.
-     * @param options Cancellation options.
+     * @param options Request options: cancellation `signal` plus the Discord.js-familiar
+     *   `query`, `headers`, `reason`, `auth`, and `files` (which upgrade to multipart).
      * @returns Decoded response body.
      * @throws {RESTError} If Discord or transport rejects the request.
      */
-    request<T>(method: string, path: string, body?: unknown, options?: RESTRequestOptions): Promise<T>;
-    /** Sends a GET request. @param path API path. @param options Cancellation options. @returns Decoded response. @throws {RESTError} When the request fails. */ get<T>(path: string, options?: RESTRequestOptions): Promise<T>;
-    /** Sends a POST request. @param path API path. @param body Optional JSON body. @param options Cancellation options. @returns Decoded response. @throws {RESTError} When the request fails. */ post<T>(path: string, body?: unknown, options?: RESTRequestOptions): Promise<T>;
-    /** Sends a PATCH request. @param path API path. @param body Optional JSON body. @param options Cancellation options. @returns Decoded response. @throws {RESTError} When the request fails. */ patch<T>(path: string, body?: unknown, options?: RESTRequestOptions): Promise<T>;
-    /** Sends a PUT request. @param path API path. @param body Optional JSON body. @param options Cancellation options. @returns Decoded response. @throws {RESTError} When the request fails. */ put<T>(path: string, body?: unknown, options?: RESTRequestOptions): Promise<T>;
-    /** Sends a DELETE request. @param path API path. @param options Cancellation options. @returns Decoded response. @throws {RESTError} When the request fails. */ delete<T>(path: string, options?: RESTRequestOptions): Promise<T>;
+    request<T>(method: string, path: string, body?: unknown, options?: RequestData): Promise<T>;
+    /** Sends a GET request. @param path API path. @param options Request options (`query`, `headers`, `signal`, …). @returns Decoded response. @throws {RESTError} When the request fails. */ get<T>(path: string, options?: RequestData): Promise<T>;
+    /** Sends a POST request. Accepts a raw body (`post(path, body)`) or a Discord.js-familiar `post(path, { body })`. @param path API path. @param body Optional JSON body, or a `RequestData` wrapper. @param options Request options. @returns Decoded response. @throws {RESTError} When the request fails. */
+    post<T>(path: string, options: RequestData): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: RequestData): Promise<T>;
+    /** Sends a PATCH request. Accepts a raw body (`patch(path, body)`) or a Discord.js-familiar `patch(path, { body })`. @param path API path. @param body Optional JSON body, or a `RequestData` wrapper. @param options Request options. @returns Decoded response. @throws {RESTError} When the request fails. */
+    patch<T>(path: string, options: RequestData): Promise<T>;
+    patch<T>(path: string, body?: unknown, options?: RequestData): Promise<T>;
+    /** Sends a PUT request. Accepts a raw body (`put(path, body)`) or a Discord.js-familiar `put(path, { body })`. @param path API path. @param body Optional JSON body, or a `RequestData` wrapper. @param options Request options. @returns Decoded response. @throws {RESTError} When the request fails. */
+    put<T>(path: string, options: RequestData): Promise<T>;
+    put<T>(path: string, body?: unknown, options?: RequestData): Promise<T>;
+    /** Sends a DELETE request. @param path API path. @param options Request options (`reason`, `headers`, `signal`, …). @returns Decoded response. @throws {RESTError} When the request fails. */ delete<T>(path: string, options?: RequestData): Promise<T>;
     /**
      * Sends a multipart/form-data POST request for file uploads.
      * Attaches a JSON payload as `payload_json` and files as additional fields.
@@ -80,4 +162,12 @@ export declare class REST {
     patchWithFiles<T>(path: string, payload: unknown, files: RESTFileAttachment[], options?: RESTRequestOptions): Promise<T>;
 }
 export { Routes } from "./routes.js";
+export { type RateLimitStore, type BucketState, MemoryRateLimitStore, } from "./store.js";
+export { RedisRateLimitStore, type RedisRateLimitStoreOptions, type MinimalRedisClient, } from "./redis.js";
 export { WebhookClient, type WebhookClientOptions, type WebhookMessageOptions, } from "./webhook.js";
+/**
+ * Discord.js-familiar alias for {@link RESTError}. `@discordjs/rest` throws `DiscordAPIError`
+ * on a Discord-rejected request; Lunibee keeps `RESTError` as the canonical class and exports
+ * this alias so Discord.js-shaped `catch (err) { if (err instanceof DiscordAPIError) … }` works.
+ */
+export { RESTError as DiscordAPIError };

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.7",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -11,6 +11,45 @@ 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);
+  }
+  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/routes.ts
 var Routes = {
   user: () => "/users/@me",
@@ -56,13 +95,122 @@ var Routes = {
   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
+class RedisRateLimitStore {
+  #client;
+  #prefix;
+  #onErrorCallback;
+  #lastError;
+  constructor(options) {
+    this.#client = options.client;
+    this.#prefix = options.prefix ?? "lunibee:rest:";
+    this.#onErrorCallback = options.onError;
+  }
+  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;
+    }
+  }
+  async 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;
+    }
+  }
+  async 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);
+    }
+  }
+  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 0;
+    }
+  }
+  async 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 +235,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
@@ -122,6 +270,49 @@ class RESTError extends Error {
 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 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.");
@@ -144,14 +335,21 @@ class REST {
   #timeout;
   #retryPolicy;
   #token;
-  #globalResetAt = 0;
-  #buckets = new Map;
-  #routeBuckets = new Map;
+  #store;
+  #localQueues = new Map;
+  #hooks = {};
   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;
+    if (options.hooks)
+      this.#hooks = options.hooks;
+  }
+  setHooks(hooks) {
+    this.#hooks = hooks;
+    return this;
   }
   setToken(token) {
     if (!token.trim())
@@ -164,56 +362,91 @@ class REST {
       throw new TypeError("REST method is required.");
     if (!path.startsWith("/"))
       throw new TypeError("REST paths must start with '/'.");
+    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)}`;
-    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;
+    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;
-    bucket.queue = new Promise((resolve) => {
+    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(bucket, options.signal, path);
+        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 });
+        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
-        };
+        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 {
-          const response = await fetch(`${this.#baseURL}${path}`, {
+          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
           });
-          bucket = this.#update(response, bucket, route, bucketKey);
-          bucketKey = this.#routeBuckets.get(route) ?? bucketKey;
+          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)
-            this.#globalResetAt = Date.now() + retryAfter * 1000;
+          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)) {
-            await this.#sleep(this.#retryPolicy.getDelay(attempt, retryAfter), options.signal, path);
+            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 });
@@ -236,22 +469,29 @@ class REST {
       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);
     }
   }
+  #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,13 +511,22 @@ class REST {
   patchWithFiles(path, payload, files, options) {
     return this.request("PATCH", path, this.#fileForm(payload, files), options);
   }
-  async#wait(bucket, signal, path) {
+  #emit(hook, ctx) {
+    if (!hook)
+      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 delay = this.#globalResetAt - Date.now();
+    const globalResetAt = await this.#store.getGlobalReset();
+    const delay = globalResetAt - Date.now();
     if (delay > 0)
       await this.#sleep(delay, signal, path);
   }
@@ -341,16 +590,17 @@ class REST {
     const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
     return routePath.replace(/\/\d+(?=\/|$)/g, "/:id");
   }
-  #update(response, bucket, route, bucketKey) {
+  async#update(response, bucketKey, route, major) {
+    let currentKey = 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;
-      }
+      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"));
@@ -365,20 +615,26 @@ class REST {
       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))
-        this.#globalResetAt = Math.max(this.#globalResetAt, Date.now() + retryAfter * 1000);
+      if (Number.isFinite(retryAfter)) {
+        const currentGlobal = await this.#store.getGlobalReset();
+        await this.#store.setGlobalReset(Math.max(currentGlobal, Date.now() + retryAfter * 1000));
+      }
     }
-    return bucket;
+    return currentKey;
   }
 }
 export {
+  RESTError as DiscordAPIError,
+  MemoryRateLimitStore,
   REST,
   RESTError,
+  RedisRateLimitStore,
   Routes,
   WebhookClient,
   createRetryPolicy
 };
 
-//# debugId=429E85E3F97473C964756E2164756E21
+//# debugId=7273A79583E1900164756E2164756E21