@fluxerjs/rest 1.0.2

package/dist/index.d.mts

@@ -0,0 +1,134 @@
+import { EventEmitter } from 'events';
+import { Routes, APIErrorBody, RateLimitErrorBody } from '@fluxerjs/types';
+export { Routes } from '@fluxerjs/types';
+
+interface RESTOptions {
+    api?: string;
+    version?: string;
+    authPrefix?: 'Bot' | 'Bearer';
+    timeout?: number;
+    retries?: number;
+    userAgent?: string;
+}
+declare class REST extends EventEmitter {
+    private readonly requestManager;
+    private _token;
+    constructor(options?: RESTOptions);
+    setToken(token: string | null): this;
+    get token(): string | null;
+    get<T>(route: string, options?: {
+        auth?: boolean;
+    }): Promise<T>;
+    post<T>(route: string, options?: {
+        body?: unknown;
+        auth?: boolean;
+        files?: Array<{
+            name: string;
+            data: Blob | ArrayBuffer | Uint8Array;
+            filename?: string;
+        }>;
+    }): Promise<T>;
+    patch<T>(route: string, options?: {
+        body?: unknown;
+        auth?: boolean;
+    }): Promise<T>;
+    put<T>(route: string, options?: {
+        body?: unknown;
+        auth?: boolean;
+    }): Promise<T>;
+    delete<T>(route: string, options?: {
+        auth?: boolean;
+    }): Promise<T>;
+    /** Route helpers (from @fluxerjs/types) for building paths. */
+    static get Routes(): typeof Routes;
+}
+
+interface RequestOptions {
+    body?: unknown | FormData;
+    headers?: Record<string, string>;
+    files?: Array<{
+        name: string;
+        data: Blob | ArrayBuffer | Uint8Array;
+        filename?: string;
+    }>;
+    auth?: boolean;
+}
+interface RestOptions {
+    api: string;
+    version: string;
+    authPrefix: 'Bot' | 'Bearer';
+    timeout: number;
+    retries: number;
+    userAgent: string;
+}
+declare class RequestManager {
+    private token;
+    private readonly options;
+    private readonly rateLimiter;
+    constructor(options: Partial<RestOptions>);
+    setToken(token: string | null): void;
+    get baseUrl(): string;
+    /** Hash route for rate limit bucket (use path without ids for grouping). */
+    private getRouteHash;
+    private waitForRateLimit;
+    private buildHeaders;
+    request<T>(method: string, route: string, options?: RequestOptions): Promise<T>;
+}
+
+/**
+ * Tracks rate limit state per bucket (route hash).
+ * Delays requests when limit is exceeded.
+ */
+interface RateLimitState {
+    limit: number;
+    remaining: number;
+    resetAt: number;
+}
+declare class RateLimitManager {
+    private buckets;
+    private globalResetAt;
+    getBucket(route: string): RateLimitState | undefined;
+    setBucket(route: string, limit: number, remaining: number, resetAt: number): void;
+    setGlobalReset(resetAt: number): void;
+    getGlobalReset(): number;
+    /** Returns ms to wait before we can send again (0 if no wait). */
+    getWaitTime(route: string): number;
+    /** Parse rate limit headers and update state. */
+    updateFromHeaders(route: string, headers: Headers): void;
+}
+
+declare class FluxerAPIError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    readonly errors?: APIErrorBody['errors'];
+    constructor(body: APIErrorBody, statusCode: number);
+}
+
+declare class RateLimitError extends FluxerAPIError {
+    readonly retryAfter: number;
+    readonly global: boolean;
+    constructor(body: RateLimitErrorBody, statusCode: number);
+}
+
+declare class HTTPError extends Error {
+    readonly statusCode: number;
+    readonly body: string | null;
+    constructor(statusCode: number, body: string | null);
+}
+
+/**
+ * Attachment data for multipart requests.
+ */
+type AttachmentData = Blob | ArrayBuffer | Uint8Array;
+interface AttachmentPayload {
+    name: string;
+    data: AttachmentData;
+    filename?: string;
+}
+/**
+ * Build FormData for message with attachments.
+ * payload_json is the JSON body; files are attached as files[0], files[1], etc.
+ */
+declare function buildFormData(payloadJson: Record<string, unknown>, files?: AttachmentPayload[]): FormData;
+
+export { type AttachmentData, type AttachmentPayload, FluxerAPIError, HTTPError, REST, type RESTOptions, RateLimitError, RateLimitManager, type RateLimitState, RequestManager, type RequestOptions, type RestOptions, buildFormData };

package/dist/index.d.ts

@@ -0,0 +1,134 @@
+import { EventEmitter } from 'events';
+import { Routes, APIErrorBody, RateLimitErrorBody } from '@fluxerjs/types';
+export { Routes } from '@fluxerjs/types';
+
+interface RESTOptions {
+    api?: string;
+    version?: string;
+    authPrefix?: 'Bot' | 'Bearer';
+    timeout?: number;
+    retries?: number;
+    userAgent?: string;
+}
+declare class REST extends EventEmitter {
+    private readonly requestManager;
+    private _token;
+    constructor(options?: RESTOptions);
+    setToken(token: string | null): this;
+    get token(): string | null;
+    get<T>(route: string, options?: {
+        auth?: boolean;
+    }): Promise<T>;
+    post<T>(route: string, options?: {
+        body?: unknown;
+        auth?: boolean;
+        files?: Array<{
+            name: string;
+            data: Blob | ArrayBuffer | Uint8Array;
+            filename?: string;
+        }>;
+    }): Promise<T>;
+    patch<T>(route: string, options?: {
+        body?: unknown;
+        auth?: boolean;
+    }): Promise<T>;
+    put<T>(route: string, options?: {
+        body?: unknown;
+        auth?: boolean;
+    }): Promise<T>;
+    delete<T>(route: string, options?: {
+        auth?: boolean;
+    }): Promise<T>;
+    /** Route helpers (from @fluxerjs/types) for building paths. */
+    static get Routes(): typeof Routes;
+}
+
+interface RequestOptions {
+    body?: unknown | FormData;
+    headers?: Record<string, string>;
+    files?: Array<{
+        name: string;
+        data: Blob | ArrayBuffer | Uint8Array;
+        filename?: string;
+    }>;
+    auth?: boolean;
+}
+interface RestOptions {
+    api: string;
+    version: string;
+    authPrefix: 'Bot' | 'Bearer';
+    timeout: number;
+    retries: number;
+    userAgent: string;
+}
+declare class RequestManager {
+    private token;
+    private readonly options;
+    private readonly rateLimiter;
+    constructor(options: Partial<RestOptions>);
+    setToken(token: string | null): void;
+    get baseUrl(): string;
+    /** Hash route for rate limit bucket (use path without ids for grouping). */
+    private getRouteHash;
+    private waitForRateLimit;
+    private buildHeaders;
+    request<T>(method: string, route: string, options?: RequestOptions): Promise<T>;
+}
+
+/**
+ * Tracks rate limit state per bucket (route hash).
+ * Delays requests when limit is exceeded.
+ */
+interface RateLimitState {
+    limit: number;
+    remaining: number;
+    resetAt: number;
+}
+declare class RateLimitManager {
+    private buckets;
+    private globalResetAt;
+    getBucket(route: string): RateLimitState | undefined;
+    setBucket(route: string, limit: number, remaining: number, resetAt: number): void;
+    setGlobalReset(resetAt: number): void;
+    getGlobalReset(): number;
+    /** Returns ms to wait before we can send again (0 if no wait). */
+    getWaitTime(route: string): number;
+    /** Parse rate limit headers and update state. */
+    updateFromHeaders(route: string, headers: Headers): void;
+}
+
+declare class FluxerAPIError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    readonly errors?: APIErrorBody['errors'];
+    constructor(body: APIErrorBody, statusCode: number);
+}
+
+declare class RateLimitError extends FluxerAPIError {
+    readonly retryAfter: number;
+    readonly global: boolean;
+    constructor(body: RateLimitErrorBody, statusCode: number);
+}
+
+declare class HTTPError extends Error {
+    readonly statusCode: number;
+    readonly body: string | null;
+    constructor(statusCode: number, body: string | null);
+}
+
+/**
+ * Attachment data for multipart requests.
+ */
+type AttachmentData = Blob | ArrayBuffer | Uint8Array;
+interface AttachmentPayload {
+    name: string;
+    data: AttachmentData;
+    filename?: string;
+}
+/**
+ * Build FormData for message with attachments.
+ * payload_json is the JSON body; files are attached as files[0], files[1], etc.
+ */
+declare function buildFormData(payloadJson: Record<string, unknown>, files?: AttachmentPayload[]): FormData;
+
+export { type AttachmentData, type AttachmentPayload, FluxerAPIError, HTTPError, REST, type RESTOptions, RateLimitError, RateLimitManager, type RateLimitState, RequestManager, type RequestOptions, type RestOptions, buildFormData };

package/dist/index.js

@@ -0,0 +1,303 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FluxerAPIError: () => FluxerAPIError,
+  HTTPError: () => HTTPError,
+  REST: () => REST,
+  RateLimitError: () => RateLimitError,
+  RateLimitManager: () => RateLimitManager,
+  RequestManager: () => RequestManager,
+  Routes: () => import_types2.Routes,
+  buildFormData: () => buildFormData
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/REST.ts
+var import_events = require("events");
+
+// src/RateLimitManager.ts
+var RateLimitManager = class {
+  buckets = /* @__PURE__ */ new Map();
+  globalResetAt = 0;
+  getBucket(route) {
+    return this.buckets.get(route);
+  }
+  setBucket(route, limit, remaining, resetAt) {
+    this.buckets.set(route, { limit, remaining, resetAt });
+  }
+  setGlobalReset(resetAt) {
+    this.globalResetAt = resetAt;
+  }
+  getGlobalReset() {
+    return this.globalResetAt;
+  }
+  /** Returns ms to wait before we can send again (0 if no wait). */
+  getWaitTime(route) {
+    const now = Date.now();
+    const globalWait = this.globalResetAt > now ? this.globalResetAt - now : 0;
+    const bucket = this.buckets.get(route);
+    const bucketWait = bucket && bucket.remaining <= 0 && bucket.resetAt > now ? bucket.resetAt - now : 0;
+    return Math.max(globalWait, bucketWait);
+  }
+  /** Parse rate limit headers and update state. */
+  updateFromHeaders(route, headers) {
+    const limit = headers.get("X-RateLimit-Limit");
+    const remaining = headers.get("X-RateLimit-Remaining");
+    const reset = headers.get("X-RateLimit-Reset");
+    if (limit !== null && remaining !== null && reset !== null) {
+      const resetAt = parseInt(reset, 10) * 1e3;
+      this.setBucket(route, parseInt(limit, 10), parseInt(remaining, 10), resetAt);
+    }
+    const retryAfter = headers.get("Retry-After");
+    if (retryAfter !== null) {
+      const sec = parseInt(retryAfter, 10);
+      const resetAt = Date.now() + (isNaN(sec) ? 0 : sec * 1e3);
+      this.setBucket(route, 1, 0, resetAt);
+    }
+  }
+};
+
+// src/errors/FluxerAPIError.ts
+var FluxerAPIError = class _FluxerAPIError extends Error {
+  code;
+  statusCode;
+  errors;
+  constructor(body, statusCode) {
+    super(body.message);
+    this.name = "FluxerAPIError";
+    this.code = body.code;
+    this.statusCode = statusCode;
+    this.errors = body.errors;
+    Object.setPrototypeOf(this, _FluxerAPIError.prototype);
+  }
+};
+
+// src/errors/RateLimitError.ts
+var RateLimitError = class _RateLimitError extends FluxerAPIError {
+  retryAfter;
+  global;
+  constructor(body, statusCode) {
+    super(body, statusCode);
+    this.retryAfter = body.retry_after;
+    this.global = body.global ?? false;
+    this.name = "RateLimitError";
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+
+// src/errors/HTTPError.ts
+var HTTPError = class _HTTPError extends Error {
+  statusCode;
+  body;
+  constructor(statusCode, body) {
+    super(`HTTP ${statusCode}: ${body ?? "No body"}`);
+    this.name = "HTTPError";
+    this.statusCode = statusCode;
+    this.body = body;
+    Object.setPrototypeOf(this, _HTTPError.prototype);
+  }
+};
+
+// src/RequestManager.ts
+var RequestManager = class {
+  token = null;
+  options;
+  rateLimiter = new RateLimitManager();
+  constructor(options) {
+    this.options = {
+      api: options.api ?? "https://api.fluxer.app",
+      version: options.version ?? "1",
+      authPrefix: options.authPrefix ?? "Bot",
+      timeout: options.timeout ?? 15e3,
+      retries: options.retries ?? 3,
+      userAgent: options.userAgent ?? "fluxer-core.js"
+    };
+  }
+  setToken(token) {
+    this.token = token;
+  }
+  get baseUrl() {
+    return `${this.options.api}/v${this.options.version}`;
+  }
+  /** Hash route for rate limit bucket (use path without ids for grouping). */
+  getRouteHash(route) {
+    return route.replace(/\d{17,19}/g, ":id");
+  }
+  async waitForRateLimit(routeHash) {
+    const wait = this.rateLimiter.getWaitTime(routeHash);
+    if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+  }
+  buildHeaders(route, options) {
+    const headers = {
+      "User-Agent": this.options.userAgent,
+      ...options.headers
+    };
+    if (options.auth !== false && this.token) {
+      headers["Authorization"] = `${this.options.authPrefix} ${this.token}`;
+    }
+    if (options.body !== void 0 && !(options.body instanceof FormData)) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
+  async request(method, route, options = {}) {
+    const routeHash = this.getRouteHash(route);
+    const url = route.startsWith("http") ? route : `${this.baseUrl}${route}`;
+    await this.waitForRateLimit(routeHash);
+    let body;
+    if (options.body !== void 0) {
+      if (options.body instanceof FormData) {
+        body = options.body;
+      } else {
+        body = JSON.stringify(options.body);
+      }
+    }
+    const headers = this.buildHeaders(route, options);
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.options.retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+        const response = await fetch(url, {
+          method,
+          headers,
+          body,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        this.rateLimiter.updateFromHeaders(routeHash, response.headers);
+        if (response.status === 429) {
+          const data = await response.json().catch(() => ({}));
+          const retryAfter = (data.retry_after ?? parseInt(response.headers.get("Retry-After") ?? "0", 10)) * 1e3;
+          this.rateLimiter.setBucket(routeHash, 1, 0, Date.now() + retryAfter);
+          if (data.global) this.rateLimiter.setGlobalReset(Date.now() + retryAfter);
+          throw new RateLimitError(
+            { ...data, code: "RATE_LIMITED", message: data.message ?? "Rate limited", retry_after: data.retry_after ?? 0 },
+            response.status
+          );
+        }
+        const text = await response.text();
+        if (!response.ok) {
+          let parsed;
+          try {
+            parsed = JSON.parse(text);
+          } catch {
+            throw new HTTPError(response.status, text);
+          }
+          throw new FluxerAPIError(parsed, response.status);
+        }
+        if (response.status === 204 || text.length === 0) return void 0;
+        return JSON.parse(text);
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (err instanceof RateLimitError && attempt < this.options.retries) {
+          await new Promise((r) => setTimeout(r, err.retryAfter * 1e3));
+          continue;
+        }
+        if (err instanceof FluxerAPIError || err instanceof HTTPError) throw err;
+        if (attempt < this.options.retries) {
+          await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
+          continue;
+        }
+        throw lastError;
+      }
+    }
+    throw lastError ?? new Error("Request failed");
+  }
+};
+
+// src/REST.ts
+var import_types = require("@fluxerjs/types");
+var REST = class extends import_events.EventEmitter {
+  requestManager;
+  _token = null;
+  constructor(options = {}) {
+    super();
+    this.requestManager = new RequestManager({
+      api: options.api ?? "https://api.fluxer.app",
+      version: options.version ?? "1",
+      authPrefix: options.authPrefix ?? "Bot",
+      timeout: options.timeout ?? 15e3,
+      retries: options.retries ?? 3,
+      userAgent: options.userAgent ?? "fluxer-core.js"
+    });
+  }
+  setToken(token) {
+    this._token = token;
+    this.requestManager.setToken(token);
+    return this;
+  }
+  get token() {
+    return this._token;
+  }
+  async get(route, options) {
+    return this.requestManager.request("GET", route, { auth: options?.auth });
+  }
+  async post(route, options) {
+    return this.requestManager.request("POST", route, {
+      body: options?.body,
+      auth: options?.auth,
+      files: options?.files
+    });
+  }
+  async patch(route, options) {
+    return this.requestManager.request("PATCH", route, { body: options?.body, auth: options?.auth });
+  }
+  async put(route, options) {
+    return this.requestManager.request("PUT", route, { body: options?.body, auth: options?.auth });
+  }
+  async delete(route, options) {
+    return this.requestManager.request("DELETE", route, { auth: options?.auth });
+  }
+  /** Route helpers (from @fluxerjs/types) for building paths. */
+  static get Routes() {
+    return import_types.Routes;
+  }
+};
+
+// src/utils/files.ts
+function buildFormData(payloadJson, files) {
+  const form = new FormData();
+  form.append("payload_json", JSON.stringify(payloadJson));
+  if (files?.length) {
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      const blob = file.data instanceof Blob ? file.data : new Blob([file.data]);
+      form.append(`files[${i}]`, blob, file.filename ?? file.name);
+    }
+  }
+  return form;
+}
+
+// src/index.ts
+var import_types2 = require("@fluxerjs/types");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FluxerAPIError,
+  HTTPError,
+  REST,
+  RateLimitError,
+  RateLimitManager,
+  RequestManager,
+  Routes,
+  buildFormData
+});

package/dist/index.mjs

@@ -0,0 +1,269 @@
+// src/REST.ts
+import { EventEmitter } from "events";
+
+// src/RateLimitManager.ts
+var RateLimitManager = class {
+  buckets = /* @__PURE__ */ new Map();
+  globalResetAt = 0;
+  getBucket(route) {
+    return this.buckets.get(route);
+  }
+  setBucket(route, limit, remaining, resetAt) {
+    this.buckets.set(route, { limit, remaining, resetAt });
+  }
+  setGlobalReset(resetAt) {
+    this.globalResetAt = resetAt;
+  }
+  getGlobalReset() {
+    return this.globalResetAt;
+  }
+  /** Returns ms to wait before we can send again (0 if no wait). */
+  getWaitTime(route) {
+    const now = Date.now();
+    const globalWait = this.globalResetAt > now ? this.globalResetAt - now : 0;
+    const bucket = this.buckets.get(route);
+    const bucketWait = bucket && bucket.remaining <= 0 && bucket.resetAt > now ? bucket.resetAt - now : 0;
+    return Math.max(globalWait, bucketWait);
+  }
+  /** Parse rate limit headers and update state. */
+  updateFromHeaders(route, headers) {
+    const limit = headers.get("X-RateLimit-Limit");
+    const remaining = headers.get("X-RateLimit-Remaining");
+    const reset = headers.get("X-RateLimit-Reset");
+    if (limit !== null && remaining !== null && reset !== null) {
+      const resetAt = parseInt(reset, 10) * 1e3;
+      this.setBucket(route, parseInt(limit, 10), parseInt(remaining, 10), resetAt);
+    }
+    const retryAfter = headers.get("Retry-After");
+    if (retryAfter !== null) {
+      const sec = parseInt(retryAfter, 10);
+      const resetAt = Date.now() + (isNaN(sec) ? 0 : sec * 1e3);
+      this.setBucket(route, 1, 0, resetAt);
+    }
+  }
+};
+
+// src/errors/FluxerAPIError.ts
+var FluxerAPIError = class _FluxerAPIError extends Error {
+  code;
+  statusCode;
+  errors;
+  constructor(body, statusCode) {
+    super(body.message);
+    this.name = "FluxerAPIError";
+    this.code = body.code;
+    this.statusCode = statusCode;
+    this.errors = body.errors;
+    Object.setPrototypeOf(this, _FluxerAPIError.prototype);
+  }
+};
+
+// src/errors/RateLimitError.ts
+var RateLimitError = class _RateLimitError extends FluxerAPIError {
+  retryAfter;
+  global;
+  constructor(body, statusCode) {
+    super(body, statusCode);
+    this.retryAfter = body.retry_after;
+    this.global = body.global ?? false;
+    this.name = "RateLimitError";
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+
+// src/errors/HTTPError.ts
+var HTTPError = class _HTTPError extends Error {
+  statusCode;
+  body;
+  constructor(statusCode, body) {
+    super(`HTTP ${statusCode}: ${body ?? "No body"}`);
+    this.name = "HTTPError";
+    this.statusCode = statusCode;
+    this.body = body;
+    Object.setPrototypeOf(this, _HTTPError.prototype);
+  }
+};
+
+// src/RequestManager.ts
+var RequestManager = class {
+  token = null;
+  options;
+  rateLimiter = new RateLimitManager();
+  constructor(options) {
+    this.options = {
+      api: options.api ?? "https://api.fluxer.app",
+      version: options.version ?? "1",
+      authPrefix: options.authPrefix ?? "Bot",
+      timeout: options.timeout ?? 15e3,
+      retries: options.retries ?? 3,
+      userAgent: options.userAgent ?? "fluxer-core.js"
+    };
+  }
+  setToken(token) {
+    this.token = token;
+  }
+  get baseUrl() {
+    return `${this.options.api}/v${this.options.version}`;
+  }
+  /** Hash route for rate limit bucket (use path without ids for grouping). */
+  getRouteHash(route) {
+    return route.replace(/\d{17,19}/g, ":id");
+  }
+  async waitForRateLimit(routeHash) {
+    const wait = this.rateLimiter.getWaitTime(routeHash);
+    if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+  }
+  buildHeaders(route, options) {
+    const headers = {
+      "User-Agent": this.options.userAgent,
+      ...options.headers
+    };
+    if (options.auth !== false && this.token) {
+      headers["Authorization"] = `${this.options.authPrefix} ${this.token}`;
+    }
+    if (options.body !== void 0 && !(options.body instanceof FormData)) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
+  async request(method, route, options = {}) {
+    const routeHash = this.getRouteHash(route);
+    const url = route.startsWith("http") ? route : `${this.baseUrl}${route}`;
+    await this.waitForRateLimit(routeHash);
+    let body;
+    if (options.body !== void 0) {
+      if (options.body instanceof FormData) {
+        body = options.body;
+      } else {
+        body = JSON.stringify(options.body);
+      }
+    }
+    const headers = this.buildHeaders(route, options);
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.options.retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+        const response = await fetch(url, {
+          method,
+          headers,
+          body,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        this.rateLimiter.updateFromHeaders(routeHash, response.headers);
+        if (response.status === 429) {
+          const data = await response.json().catch(() => ({}));
+          const retryAfter = (data.retry_after ?? parseInt(response.headers.get("Retry-After") ?? "0", 10)) * 1e3;
+          this.rateLimiter.setBucket(routeHash, 1, 0, Date.now() + retryAfter);
+          if (data.global) this.rateLimiter.setGlobalReset(Date.now() + retryAfter);
+          throw new RateLimitError(
+            { ...data, code: "RATE_LIMITED", message: data.message ?? "Rate limited", retry_after: data.retry_after ?? 0 },
+            response.status
+          );
+        }
+        const text = await response.text();
+        if (!response.ok) {
+          let parsed;
+          try {
+            parsed = JSON.parse(text);
+          } catch {
+            throw new HTTPError(response.status, text);
+          }
+          throw new FluxerAPIError(parsed, response.status);
+        }
+        if (response.status === 204 || text.length === 0) return void 0;
+        return JSON.parse(text);
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (err instanceof RateLimitError && attempt < this.options.retries) {
+          await new Promise((r) => setTimeout(r, err.retryAfter * 1e3));
+          continue;
+        }
+        if (err instanceof FluxerAPIError || err instanceof HTTPError) throw err;
+        if (attempt < this.options.retries) {
+          await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
+          continue;
+        }
+        throw lastError;
+      }
+    }
+    throw lastError ?? new Error("Request failed");
+  }
+};
+
+// src/REST.ts
+import { Routes } from "@fluxerjs/types";
+var REST = class extends EventEmitter {
+  requestManager;
+  _token = null;
+  constructor(options = {}) {
+    super();
+    this.requestManager = new RequestManager({
+      api: options.api ?? "https://api.fluxer.app",
+      version: options.version ?? "1",
+      authPrefix: options.authPrefix ?? "Bot",
+      timeout: options.timeout ?? 15e3,
+      retries: options.retries ?? 3,
+      userAgent: options.userAgent ?? "fluxer-core.js"
+    });
+  }
+  setToken(token) {
+    this._token = token;
+    this.requestManager.setToken(token);
+    return this;
+  }
+  get token() {
+    return this._token;
+  }
+  async get(route, options) {
+    return this.requestManager.request("GET", route, { auth: options?.auth });
+  }
+  async post(route, options) {
+    return this.requestManager.request("POST", route, {
+      body: options?.body,
+      auth: options?.auth,
+      files: options?.files
+    });
+  }
+  async patch(route, options) {
+    return this.requestManager.request("PATCH", route, { body: options?.body, auth: options?.auth });
+  }
+  async put(route, options) {
+    return this.requestManager.request("PUT", route, { body: options?.body, auth: options?.auth });
+  }
+  async delete(route, options) {
+    return this.requestManager.request("DELETE", route, { auth: options?.auth });
+  }
+  /** Route helpers (from @fluxerjs/types) for building paths. */
+  static get Routes() {
+    return Routes;
+  }
+};
+
+// src/utils/files.ts
+function buildFormData(payloadJson, files) {
+  const form = new FormData();
+  form.append("payload_json", JSON.stringify(payloadJson));
+  if (files?.length) {
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      const blob = file.data instanceof Blob ? file.data : new Blob([file.data]);
+      form.append(`files[${i}]`, blob, file.filename ?? file.name);
+    }
+  }
+  return form;
+}
+
+// src/index.ts
+import { Routes as Routes2 } from "@fluxerjs/types";
+export {
+  FluxerAPIError,
+  HTTPError,
+  REST,
+  RateLimitError,
+  RateLimitManager,
+  RequestManager,
+  Routes2 as Routes,
+  buildFormData
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@fluxerjs/rest",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.2",
+  "description": "REST client for the Fluxer API",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@fluxerjs/types": "1.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "clean": "rm -rf dist"
+  }
+}