@raven_app/raven.js 0.0.0-stage → 1.0.2

package/dist/index.cjs

@@ -0,0 +1,3076 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var index_exports = {};
+__export(index_exports, {
+  AuthenticationError: () => AuthenticationError,
+  BOT_STATUSES: () => BOT_STATUSES,
+  CHANNEL_TYPES: () => CHANNEL_TYPES,
+  CommandHandler: () => CommandHandler,
+  DEFAULT_ADMIN_PERMS: () => DEFAULT_ADMIN_PERMS,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  DEFAULT_EVERYONE_PERMS: () => DEFAULT_EVERYONE_PERMS,
+  ETHAN_KEY_PREFIX: () => ETHAN_KEY_PREFIX,
+  ETHAN_MESSAGE_MAX: () => ETHAN_MESSAGE_MAX,
+  ETHAN_MODEL: () => ETHAN_MODEL,
+  ETHAN_PERSONALITIES: () => ETHAN_PERSONALITIES,
+  EthanClient: () => EthanClient,
+  GATEWAY_EVENTS: () => GATEWAY_EVENTS,
+  GatewayNotAvailableError: () => GatewayNotAvailableError,
+  MemoryCooldownStore: () => MemoryCooldownStore,
+  MessagePoller: () => MessagePoller,
+  MissingScopeError: () => MissingScopeError,
+  NotFoundError: () => NotFoundError,
+  NotInstalledError: () => NotInstalledError,
+  PERMISSIONS: () => PERMISSIONS,
+  PERMISSION_MASK: () => PERMISSION_MASK,
+  RateLimitedError: () => RateLimitedError,
+  RavenAPIError: () => RavenAPIError,
+  RavenAuthError: () => RavenAuthError,
+  RavenBot: () => RavenBot,
+  RavenClient: () => RavenClient,
+  RavenError: () => RavenError,
+  RavenGateway: () => RavenGateway,
+  RavenNotFoundError: () => RavenNotFoundError,
+  RavenPermissionError: () => RavenPermissionError,
+  RavenRateLimitError: () => RavenRateLimitError,
+  RavenValidationError: () => RavenValidationError,
+  ValidationError: () => ValidationError,
+  assertChannelName: () => assertChannelName,
+  assertChannelType: () => assertChannelType,
+  assertEthanMessage: () => assertEthanMessage,
+  assertPersonality: () => assertPersonality,
+  assertRoleColor: () => assertRoleColor,
+  assertRoleName: () => assertRoleName,
+  assertRolePermissions: () => assertRolePermissions,
+  assertTemperature: () => assertTemperature,
+  canAssignRole: () => canAssignRole,
+  canManageRole: () => canManageRole,
+  canModerate: () => canModerate,
+  createBot: () => createBot,
+  createClient: () => createClient,
+  createCommandHandler: () => createCommandHandler,
+  createEthanClient: () => createEthanClient,
+  editDistance: () => editDistance,
+  escapeContent: () => escapeContent,
+  formatError: () => formatError,
+  getHighestRole: () => getHighestRole,
+  getMemberPermissions: () => getMemberPermissions,
+  hasPermission: () => hasPermission,
+  invalidChoice: () => invalidChoice,
+  isBotAuthorId: () => isBotAuthorId,
+  markDiff: () => markDiff,
+  missingArgument: () => missingArgument,
+  normalizeRole: () => normalizeRole,
+  parseMentions: () => parseMentions,
+  sanitizeContent: () => sanitizeContent,
+  sortRoles: () => sortRoles,
+  suggest: () => suggest,
+  suggestAll: () => suggestAll,
+  toCamel: () => toCamel,
+  unknownOption: () => unknownOption,
+  withSuggestions: () => withSuggestions
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.js
+var RavenError = class extends Error {
+  constructor(message, { status = 0, code = "RAVEN_ERROR", details = null, retryAfter = null } = {}) {
+    super(message);
+    this.name = "RavenError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.retryAfter = retryAfter;
+  }
+};
+var RavenAPIError = class extends RavenError {
+  constructor(message, { status = 0, code = "API_ERROR", endpoint = null, details = null, retryAfter = null } = {}) {
+    super(message, { status, code, details, retryAfter });
+    this.name = "RavenAPIError";
+    this.endpoint = endpoint;
+  }
+};
+var RavenAuthError = class extends RavenAPIError {
+  constructor(message = "Invalid or missing bot token. Use Authorization: Bot <rvb_...>.", { endpoint = null, details = null } = {}) {
+    super(message, { status: 401, code: "AUTHENTICATION_ERROR", endpoint, details });
+    this.name = "RavenAuthError";
+  }
+};
+var RavenPermissionError = class extends RavenAPIError {
+  constructor(message, { status = 403, code = "PERMISSION_ERROR", endpoint = null, details = null } = {}) {
+    super(message, { status, code, endpoint, details });
+    this.name = "RavenPermissionError";
+  }
+};
+var RavenRateLimitError = class extends RavenAPIError {
+  constructor(retryAfter = null, message = "Bot rate limit exceeded. Slow down.", { endpoint = null, details = null } = {}) {
+    super(message, { status: 429, code: "RATE_LIMITED", endpoint, details, retryAfter });
+    this.name = "RavenRateLimitError";
+  }
+};
+var RavenValidationError = class extends RavenAPIError {
+  constructor(message, { endpoint = null, details = null } = {}) {
+    super(message, { status: 400, code: "VALIDATION_ERROR", endpoint, details });
+    this.name = "RavenValidationError";
+  }
+};
+var RavenNotFoundError = class extends RavenAPIError {
+  constructor(message = "Not found.", { code = "NOT_FOUND", endpoint = null, details = null } = {}) {
+    super(message, { status: 404, code, endpoint, details });
+    this.name = "RavenNotFoundError";
+  }
+};
+var AuthenticationError = class extends RavenAuthError {
+  constructor(message = "Invalid or missing bot token. Use Authorization: Bot <rvb_...>.", details = null, endpoint = null) {
+    super(message, { endpoint, details });
+    this.name = "AuthenticationError";
+  }
+};
+var MissingScopeError = class extends RavenPermissionError {
+  constructor(scope, details = null, endpoint = null) {
+    super(`Missing scope: ${scope}`, { status: 403, code: "MISSING_SCOPE", endpoint, details });
+    this.name = "MissingScopeError";
+    this.scope = scope;
+  }
+};
+var NotInstalledError = class extends RavenAPIError {
+  constructor(message = "Guild not found or bot not installed.", details = null, endpoint = null) {
+    super(message, { status: 404, code: "NOT_INSTALLED", endpoint, details });
+    this.name = "NotInstalledError";
+  }
+};
+var NotFoundError = class extends RavenNotFoundError {
+  constructor(message = "Not found.", details = null, endpoint = null) {
+    super(message, { endpoint, details });
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends RavenValidationError {
+  constructor(message, details = null, endpoint = null) {
+    super(message, { endpoint, details });
+    this.name = "ValidationError";
+  }
+};
+var RateLimitedError = class extends RavenRateLimitError {
+  constructor(retryAfter = null, message = "Bot rate limit exceeded. Slow down.", details = null, endpoint = null) {
+    super(retryAfter, message, { endpoint, details });
+    this.name = "RateLimitedError";
+  }
+};
+var GatewayNotAvailableError = class extends RavenError {
+  constructor(message = "Bot gateway is not available on this server version. Use client.onMessage() (REST polling) instead.") {
+    super(message, { status: 501, code: "GATEWAY_NOT_AVAILABLE" });
+    this.name = "GatewayNotAvailableError";
+  }
+};
+function toRavenError(status, body, { endpoint = null } = {}) {
+  const msg = body?.error || `Request failed with status ${status}`;
+  const retryAfter = body?.retry_after ?? null;
+  if (status === 401) return new AuthenticationError(msg, body, endpoint);
+  if (status === 429) return new RateLimitedError(retryAfter, msg, body, endpoint);
+  if (status === 400) return new ValidationError(msg, body, endpoint);
+  if (status === 403) {
+    if (/missing scope/i.test(msg)) {
+      const m = msg.match(/missing scope:\s*(\S+)/i);
+      return new MissingScopeError(m ? m[1] : "unknown", body, endpoint);
+    }
+    if (/not installed/i.test(msg)) return new NotInstalledError(msg, body, endpoint);
+    return new RavenPermissionError(msg, { status, code: "FORBIDDEN", endpoint, details: body });
+  }
+  if (status === 404) {
+    if (/not installed|guild not found/i.test(msg)) return new NotInstalledError(msg, body, endpoint);
+    return new NotFoundError(msg, body, endpoint);
+  }
+  return new RavenAPIError(msg, { status, code: "API_ERROR", endpoint, details: body, retryAfter });
+}
+
+// src/http.js
+var TOKEN_PREFIX = "rvb_";
+var ETHAN_KEY_PREFIX = "rve_";
+var DEFAULT_BASE_URL = "https://ravenapp.xyz";
+function assertToken(token, prefix = TOKEN_PREFIX) {
+  if (!token || typeof token !== "string" || !token.startsWith(prefix)) {
+    throw new Error(`Invalid token: expected a string starting with "${prefix}".`);
+  }
+  if (token.length < 20 || token.length > 120) {
+    throw new Error("Invalid token: unexpected token length.");
+  }
+}
+function assertEthanKey(key) {
+  assertToken(key, ETHAN_KEY_PREFIX);
+}
+function buildUrl(path2, query = {}) {
+  const base = DEFAULT_BASE_URL.replace(/\/+$/, "");
+  const url = new URL(base + path2);
+  for (const [k, v] of Object.entries(query)) {
+    if (v === void 0 || v === null || v === "") continue;
+    url.searchParams.set(k, String(v));
+  }
+  return url.toString();
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function ravenRequest({
+  token,
+  path: path2,
+  method = "GET",
+  query = {},
+  body,
+  timeoutMs = 15e3,
+  retryOn429 = true,
+  maxRetries = 1,
+  // Bot API: scheme "Bot" + prefix "rvb_".
+  // Ethan API: scheme "Bearer" + prefix "rve_" (Plus/Pro key).
+  authScheme = "Bot",
+  tokenPrefix = TOKEN_PREFIX
+}) {
+  assertToken(token, tokenPrefix);
+  const url = buildUrl(path2, query);
+  const controller = new AbortController();
+  const t = setTimeout(() => controller.abort(), timeoutMs);
+  let res;
+  try {
+    res = await fetch(url, {
+      method,
+      signal: controller.signal,
+      headers: {
+        Authorization: `${authScheme} ${token}`,
+        ...body !== void 0 ? { "Content-Type": "application/json" } : {}
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  } catch (err) {
+    clearTimeout(t);
+    if (err?.name === "AbortError") throw new Error(`Request timed out after ${timeoutMs}ms: ${method} ${path2}`);
+    throw err;
+  }
+  clearTimeout(t);
+  let json = null;
+  try {
+    json = await res.json();
+  } catch {
+    json = null;
+  }
+  if (res.status === 429 && retryOn429 && maxRetries > 0) {
+    const retryAfter = json?.retry_after ?? Number(res.headers.get("retry-after")) ?? 1;
+    await sleep(Math.min(Math.max(Number(retryAfter) || 1, 1), 10) * 1e3);
+    return ravenRequest({ token, path: path2, method, query, body, timeoutMs, retryOn429: false, maxRetries: 0, authScheme, tokenPrefix });
+  }
+  if (!res.ok) throw toRavenError(res.status, json, { endpoint: `${method} ${path2}` });
+  void RateLimitedError;
+  return json;
+}
+
+// src/errors/format.js
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+
+// src/suggest.js
+function editDistance(a, b) {
+  const s = String(a);
+  const t = String(b);
+  if (s === t) return 0;
+  if (!s.length) return t.length;
+  if (!t.length) return s.length;
+  let prev2 = new Array(t.length + 1);
+  let prev = new Array(t.length + 1);
+  let curr = new Array(t.length + 1);
+  for (let j = 0; j <= t.length; j++) prev[j] = j;
+  for (let i = 1; i <= s.length; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= t.length; j++) {
+      const cost = s[i - 1] === t[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+      if (i > 1 && j > 1 && s[i - 1] === t[j - 2] && s[i - 2] === t[j - 1]) {
+        curr[j] = Math.min(curr[j], prev2[j - 2] + 1);
+      }
+    }
+    const tmp = prev2;
+    prev2 = prev;
+    prev = curr;
+    curr = tmp;
+  }
+  return prev[t.length];
+}
+function threshold(input, candidate) {
+  return Math.max(1, Math.floor(Math.max(String(input).length, String(candidate).length) * 0.4));
+}
+var LEET = { 0: "o", 1: "l", 3: "e", 4: "a", 5: "s", 7: "t" };
+function fold(s) {
+  return String(s).toLowerCase().replace(/[013457]/g, (ch) => LEET[ch]);
+}
+function suggestAll(input, candidates = [], { limit = 3 } = {}) {
+  const text = String(input ?? "");
+  if (!text) return [];
+  const out = [];
+  for (const c of candidates ?? []) {
+    const value = String(c);
+    if (!value || value === text) continue;
+    const distance = editDistance(fold(text), fold(value));
+    if (distance > threshold(text, value)) continue;
+    const confidence = Math.max(0, Math.round((1 - distance / Math.max(text.length, value.length)) * 100) / 100);
+    out.push({ value, distance, confidence });
+  }
+  out.sort((a, b) => a.distance - b.distance || a.value.localeCompare(b.value));
+  return out.slice(0, Math.max(0, limit));
+}
+function suggest(input, candidates, options) {
+  return suggestAll(input, candidates, { ...options, limit: 1 })[0] ?? null;
+}
+var PROTOCOL_PROPS = /* @__PURE__ */ new Set(["then", "toJSON"]);
+function unknownMethod(label, received, candidates, display) {
+  const top = suggestAll(received, candidates, { limit: 3 });
+  const err = new RavenError(`Unknown method: ${label}.${received}()`, { status: 0, code: "UNKNOWN_METHOD" });
+  err.received = `${label}.${received}()`;
+  if (top.length) {
+    err.suggestion = `${label}.${top[0].value}()`;
+    err.suggestions = top.map((s) => `${label}.${s.value}()`);
+  }
+  err.suggestionsHint = "Use the full method name to continue.";
+  err.validTitle = "Available methods";
+  err.valid = [...display ?? candidates].sort();
+  return err;
+}
+function withSuggestions(target, label) {
+  const proto = Object.getPrototypeOf(target);
+  const methods = proto ? Object.getOwnPropertyNames(proto).filter((m) => m !== "constructor") : [];
+  const candidates = [.../* @__PURE__ */ new Set([...methods, ...Object.keys(target)])];
+  const display = [...new Set(methods)];
+  return new Proxy(target, {
+    get(t, prop, recv) {
+      if (typeof prop === "symbol") return Reflect.get(t, prop, recv);
+      if (PROTOCOL_PROPS.has(prop)) return void 0;
+      if (prop in t) return Reflect.get(t, prop, recv);
+      throw unknownMethod(label, String(prop), candidates, display);
+    }
+  });
+}
+
+// src/errors/format.js
+var import_meta = {};
+var SRC_DIR = (() => {
+  try {
+    if (typeof import_meta !== "undefined" && import_meta.url) {
+      return import_node_path.default.resolve(import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url)), "..");
+    }
+  } catch {
+  }
+  try {
+    if (typeof __dirname !== "undefined" && __dirname) {
+      return import_node_path.default.resolve(__dirname, "..");
+    }
+  } catch {
+  }
+  return "";
+})();
+var HTTP_REASON = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable"
+};
+var RUNTIME_WITH_COLUMNS = /* @__PURE__ */ new Set(["ReferenceError", "TypeError", "SyntaxError", "RangeError"]);
+var IDENT_RE = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "const",
+  "let",
+  "var",
+  "function",
+  "return",
+  "await",
+  "async",
+  "new",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "this",
+  "typeof",
+  "require",
+  "import",
+  "export",
+  "from",
+  "if",
+  "else"
+]);
+var FRAME_RE = /at (?:.+?\()?(.+?):(\d+):(\d+)\)?$/;
+function normalizeFile(file) {
+  if (file.startsWith("file://")) {
+    try {
+      return (0, import_node_url.fileURLToPath)(file);
+    } catch {
+      return file;
+    }
+  }
+  return file;
+}
+function parseStack(stack) {
+  const frames = [];
+  for (const line of String(stack ?? "").split("\n").slice(1)) {
+    const m = FRAME_RE.exec(line.trim());
+    if (m) frames.push({ file: normalizeFile(m[1]), line: Number(m[2]), column: Number(m[3]) });
+  }
+  return frames;
+}
+function isSkipped(file) {
+  if (!file || file.startsWith("node:")) return true;
+  if (!SRC_DIR) return false;
+  return file === SRC_DIR || file.startsWith(SRC_DIR + import_node_path.default.sep);
+}
+function pickFrame(err) {
+  const frames = parseStack(err?.stack);
+  return frames.find((f) => !isSkipped(f.file)) ?? frames.find((f) => !f.file.startsWith("node:")) ?? null;
+}
+function readWindow(file, line, radius = 2) {
+  try {
+    const text = (0, import_node_fs.readFileSync)(file, "utf8");
+    if (text.length > 512 * 1024) return null;
+    const lines = text.split("\n");
+    if (line < 1 || line > lines.length) return null;
+    return { lines, start: Math.max(1, line - radius), end: Math.min(lines.length, line + radius) };
+  } catch {
+    return null;
+  }
+}
+function harvestIdentifiers(win, exclude) {
+  const found = /* @__PURE__ */ new Set();
+  for (let i = win.start; i <= win.end; i++) {
+    for (const m of win.lines[i - 1].matchAll(IDENT_RE)) {
+      const id = m[0];
+      if (id.length < 2 || id === exclude || STOPWORDS.has(id)) continue;
+      found.add(id);
+    }
+  }
+  return [...found];
+}
+function misspelledOf(err) {
+  if (err?.name !== "ReferenceError") return null;
+  const msg = String(err.message ?? "");
+  return /(.+?) is not defined/.exec(msg)?.[1] ?? /Cannot access '(.+?)' before/.exec(msg)?.[1] ?? null;
+}
+function rel(file, baseDir) {
+  try {
+    const r = import_node_path.default.relative(baseDir, file);
+    return r && !r.startsWith("..") ? r : file;
+  } catch {
+    return file;
+  }
+}
+function makeColors(enabled) {
+  if (!enabled) {
+    const id = (s) => s;
+    return { bold: id, red: id, dim: id, yellow: id };
+  }
+  const wrap = (code) => (s) => `\x1B[${code}m${s}\x1B[0m`;
+  return { bold: wrap(1), red: wrap(31), dim: wrap(2), yellow: wrap(33) };
+}
+function markDiff(received, suggested) {
+  const a = String(received);
+  const b = String(suggested);
+  if (a === b) return null;
+  let p = 0;
+  while (p < a.length && p < b.length && a[p] === b[p]) p++;
+  let s = 0;
+  while (s < b.length - p && s < a.length - p && a[a.length - 1 - s] === b[b.length - 1 - s]) s++;
+  const start = p;
+  const end = b.length - s;
+  if (end <= start) return "^".repeat(Math.max(1, b.length));
+  return " ".repeat(start) + "^".repeat(end - start);
+}
+function unknownOption({ option, valid, label = "command option" }) {
+  const s = suggest(option, valid);
+  const err = new RavenError(`Unknown ${label} "${option}"`, { status: 0, code: "UNKNOWN_OPTION" });
+  err.received = option;
+  if (s) err.suggestion = s.value;
+  err.validTitle = "Available options";
+  err.valid = [...valid].sort();
+  return err;
+}
+function invalidChoice({ label, received, valid, validTitle }) {
+  const s = suggest(received, valid);
+  const err = new RavenError(`Unknown ${label} "${received}"`, { status: 0, code: "INVALID_VALUE" });
+  err.received = String(received);
+  if (s) err.suggestion = s.value;
+  err.validTitle = validTitle ?? `Valid ${label}s`;
+  err.valid = [...valid];
+  return err;
+}
+function missingArgument({ label, param, example }) {
+  const err = new RavenError(`Missing required argument: ${param}`, { status: 0, code: "MISSING_ARGUMENT" });
+  err.received = `${label}()`;
+  err.expected = `${label}(${param})`;
+  if (example) err.example = example;
+  return err;
+}
+function formatError(err, options = {}) {
+  try {
+    const baseDir = options.baseDir ?? process.cwd();
+    const useColor = options.color ?? (process.stdout?.isTTY === true && !process.env.NO_COLOR);
+    const c = makeColors(useColor);
+    const name = err?.name || "Error";
+    const message = String(err?.message ?? err);
+    const [first, ...rest] = message.split("\n");
+    const out = [c.bold(c.red(`\u2716 ${name}: ${first}`))];
+    if (rest.join("\n").trim()) out.push("", ...rest);
+    const frame = options.file ? { file: options.file, line: options.line ?? 1, column: options.column ?? 1 } : pickFrame(err);
+    let win = null;
+    if (frame) {
+      out.push("", `  ${c.dim("at")} ${rel(frame.file, baseDir)}:${frame.line}:${frame.column}`);
+      win = readWindow(frame.file, frame.line);
+      if (win) {
+        out.push("");
+        for (let i = win.start; i <= win.end; i++) {
+          const no = String(i).padStart(5, " ");
+          const mark = i === frame.line ? c.red("\u203A") : " ";
+          out.push(`  ${mark}${c.dim(no + " \u2502")} ${win.lines[i - 1]}`);
+          if (i === frame.line && RUNTIME_WITH_COLUMNS.has(name) && frame.column >= 1) {
+            out.push(`  ${" ".repeat(9 + Math.max(0, frame.column - 1))}${c.red("^".repeat(3))}`);
+          }
+        }
+      }
+    }
+    let suggestion = err?.suggestion ?? null;
+    let receivedRaw = err?.received ?? null;
+    if (!suggestion && win) {
+      const miss = misspelledOf(err);
+      if (miss) {
+        const wide = readWindow(frame.file, frame.line, 8) ?? win;
+        suggestion = suggest(miss, harvestIdentifiers(wide, miss))?.value ?? null;
+        if (suggestion) receivedRaw = miss;
+      }
+    }
+    if (err instanceof RavenAPIError) {
+      const reason = HTTP_REASON[err.status];
+      out.push("", `  Status: ${err.status}${reason ? ` ${reason}` : ""}`);
+      if (err.endpoint) out.push(`  Endpoint: ${err.endpoint}`);
+      if (err.code) out.push(`  Code: ${err.code}`);
+    }
+    const suggestions = err?.suggestions ?? (suggestion ? [suggestion] : []);
+    if (suggestions.length > 1) {
+      out.push("", `  ${c.yellow("Did you mean one of these?")}`);
+      suggestions.slice(0, 5).forEach((s, i) => out.push(`    ${i + 1}. ${s}`));
+      out.push("", `  ${err.suggestionsHint ?? "Use the full method name to continue."}`);
+    } else if (suggestions.length === 1) {
+      out.push("", `  ${c.yellow("Did you mean:")}`, `    ${suggestions[0]}`);
+      if (receivedRaw) {
+        const marks = markDiff(receivedRaw, suggestions[0]);
+        if (marks) out.push(`    ${marks}`);
+      }
+    }
+    if (err?.scope) out.push("", "  Missing scope:", `    ${err.scope}`);
+    if (err?.received) out.push("", "  Received:", `    ${err.received}`);
+    if (err?.expected) out.push("", "  Expected:", `    ${err.expected}`);
+    if (err?.example) out.push("", "  Example:", `    ${err.example}`);
+    if (Array.isArray(err?.valid) && err.valid.length) {
+      out.push("", `  ${err.validTitle ?? "Available options:"}`);
+      for (const v of err.valid.slice(0, 12)) out.push(`    ${v}`);
+    }
+    if (Array.isArray(err?.hints) && err.hints.length) {
+      out.push("");
+      for (const h of err.hints.slice(0, 5)) out.push(`  ${c.dim(h)}`);
+    }
+    if (err?.docs) out.push("", "  Learn more:", `    ${err.docs}`);
+    return out.join("\n");
+  } catch {
+    try {
+      return `${err?.name || "Error"}: ${err?.message || err}`;
+    } catch {
+      return "Unknown error";
+    }
+  }
+}
+
+// src/resources/me.js
+var BOT_STATUSES = ["online", "idle", "dnd"];
+function assertStatus(status) {
+  const s = String(status || "").toLowerCase();
+  if (!BOT_STATUSES.includes(s)) {
+    throw invalidChoice({ label: "status", received: String(status), valid: BOT_STATUSES, validTitle: "Valid statuses" });
+  }
+  return s;
+}
+var MeResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async get() {
+    const json = await this.ctx.request("GET", "/api/v1/users/@me");
+    return {
+      id: json.id,
+      username: json.username,
+      avatar: json.avatar,
+      applicationId: json.application_id,
+      scopes: json.scopes ?? [],
+      bot: json.bot ?? true,
+      status: json.status ?? "offline",
+      statusLocked: json.status_locked ?? false,
+      raw: json
+    };
+  }
+  /**
+   * Set the bot status (online, idle, dnd). Pass null/undefined/"" to
+   * release the manual lock and let the server manage by activity again.
+   * Returns { status, locked, shown }.
+   */
+  async setStatus(status) {
+    let body;
+    if (status === void 0 || status === null || status === "") {
+      body = {};
+    } else {
+      body = { status: assertStatus(status) };
+    }
+    const json = await this.ctx.request("PATCH", "/api/v1/users/@me", { body });
+    return { status: json.status, locked: json.locked ?? true, shown: json.shown ?? json.status, raw: json };
+  }
+};
+
+// src/resources/guilds.js
+var GuildsResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async list() {
+    const json = await this.ctx.request("GET", "/api/v1/guilds");
+    return (json.guilds ?? []).map((g) => ({
+      id: g.id,
+      name: g.name,
+      icon: g.icon ?? null,
+      ownerId: g.owner_id,
+      memberCount: g.member_count ?? 0,
+      raw: g
+    }));
+  }
+  async get(guildId) {
+    if (!guildId) {
+      throw missingArgument({
+        label: "bot.client.guilds.get",
+        param: "guildId",
+        example: `bot.client.guilds.get("123456789")`
+      });
+    }
+    const json = await this.ctx.request("GET", `/api/v1/guilds/${encodeURIComponent(guildId)}`);
+    return {
+      id: json.id,
+      name: json.name,
+      description: json.description ?? "",
+      icon: json.icon ?? null,
+      ownerId: json.owner_id,
+      memberCount: json.member_count ?? 0,
+      verified: json.verified ?? false,
+      raw: json
+    };
+  }
+  async stats(guildId) {
+    if (!guildId) {
+      throw missingArgument({
+        label: "bot.client.guilds.stats",
+        param: "guildId",
+        example: `bot.client.guilds.stats("123456789")`
+      });
+    }
+    const json = await this.ctx.request("GET", `/api/v1/guilds/${encodeURIComponent(guildId)}/stats`);
+    return {
+      guildId: json.guild_id,
+      memberCount: json.member_count ?? 0,
+      ...json
+    };
+  }
+};
+
+// src/resources/channels.js
+var CHANNEL_TYPES = ["text", "voice"];
+function assertChannelType(type) {
+  const t = String(type || "").toLowerCase();
+  if (!CHANNEL_TYPES.includes(t)) {
+    throw invalidChoice({ label: "type", received: String(type), valid: CHANNEL_TYPES, validTitle: "Valid channel types" });
+  }
+  return t;
+}
+function assertChannelName(name) {
+  const s = String(name ?? "").replace(/<\/?script/gi, "").trim().replace(/^\s*(?:#\s*)+/, "");
+  if (!s) throw new Error("Channel name is required (1-100 chars).");
+  if (s.length > 100) throw new Error("Channel name must be 100 characters or less.");
+  return s;
+}
+function toCamelChannel(c) {
+  return {
+    id: c.id,
+    guildId: c.guild_id ?? c.guildId,
+    name: c.name,
+    type: c.type,
+    topic: c.topic ?? "",
+    position: c.position ?? 0,
+    parentId: c.parent_id ?? c.parentId ?? null,
+    icon: c.icon ?? "",
+    raw: c
+  };
+}
+var ChannelsResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async list(guildId) {
+    if (!guildId) {
+      throw missingArgument({
+        label: "bot.client.channels.list",
+        param: "guildId",
+        example: `bot.client.channels.list("123456789")`
+      });
+    }
+    const json = await this.ctx.request(
+      "GET",
+      `/api/v1/guilds/${encodeURIComponent(guildId)}/channels`
+    );
+    return (json.channels ?? []).map((c) => ({
+      id: c.id,
+      name: c.name,
+      type: c.type,
+      position: c.position ?? 0,
+      parentId: c.parent_id ?? null,
+      raw: c
+    }));
+  }
+  /** Single channel by id (guild membership implied by install). */
+  async get(channelId) {
+    if (!channelId) {
+      throw missingArgument({
+        label: "bot.client.channels.get",
+        param: "channelId",
+        example: `bot.client.channels.get("CHANNEL_ID")`
+      });
+    }
+    const json = await this.ctx.request("GET", `/api/v1/channels/${encodeURIComponent(channelId)}`);
+    return toCamelChannel(json.channel ?? json);
+  }
+  /**
+   * Create a text/voice channel.
+   * opts: { name, type = "text", parentId?, topic? }
+   */
+  async create(guildId, opts = {}) {
+    if (!guildId) {
+      throw missingArgument({
+        label: "bot.client.channels.create",
+        param: "guildId",
+        example: `bot.client.channels.create("123456789", { name: "announcements" })`
+      });
+    }
+    const body = { name: assertChannelName(opts.name), type: assertChannelType(opts.type ?? "text") };
+    if (opts.parentId !== void 0 && opts.parentId !== null && opts.parentId !== "") {
+      body.parent_id = String(opts.parentId);
+    }
+    if (opts.topic !== void 0) body.topic = String(opts.topic ?? "").slice(0, 1024);
+    const json = await this.ctx.request("POST", `/api/v1/guilds/${encodeURIComponent(guildId)}/channels`, { body });
+    return toCamelChannel(json.channel ?? json);
+  }
+  /**
+   * Edit a channel. patch: { name?, topic?, parentId? ("" = no category) }
+   */
+  async update(channelId, patch = {}) {
+    if (!channelId) {
+      throw missingArgument({
+        label: "bot.client.channels.update",
+        param: "channelId",
+        example: `bot.client.channels.update("CHANNEL_ID", { topic: "hello" })`
+      });
+    }
+    const body = {};
+    if (patch.name !== void 0) body.name = assertChannelName(patch.name);
+    if (patch.type !== void 0) body.type = assertChannelType(patch.type);
+    if (patch.topic !== void 0) body.topic = String(patch.topic ?? "").slice(0, 1024);
+    if (patch.parentId !== void 0) body.parent_id = patch.parentId ? String(patch.parentId) : null;
+    if (patch.position !== void 0) {
+      if (!Number.isInteger(Number(patch.position))) throw new Error("position must be an integer.");
+      body.position = Number(patch.position);
+    }
+    const json = await this.ctx.request("PATCH", `/api/v1/channels/${encodeURIComponent(channelId)}`, { body });
+    return toCamelChannel(json.channel ?? json);
+  }
+  /** Delete a channel (messages go with it). Returns { id }. */
+  async delete(channelId) {
+    if (!channelId) {
+      throw missingArgument({
+        label: "bot.client.channels.delete",
+        param: "channelId",
+        example: `bot.client.channels.delete("CHANNEL_ID")`
+      });
+    }
+    const json = await this.ctx.request("DELETE", `/api/v1/channels/${encodeURIComponent(channelId)}`);
+    return { id: json.id ?? json.channel_id ?? channelId, raw: json };
+  }
+  /**
+   * Reorder/move channels: items = [{ id, position?, parentId? }].
+   * Returns the fresh channel list.
+   */
+  async reorder(guildId, items) {
+    if (!guildId) {
+      throw missingArgument({
+        label: "bot.client.channels.reorder",
+        param: "guildId",
+        example: `bot.client.channels.reorder("123456789", [{ id: "c1", position: 0 }])`
+      });
+    }
+    if (!Array.isArray(items) || !items.length) {
+      throw missingArgument({
+        label: "bot.client.channels.reorder",
+        param: "items",
+        example: `bot.client.channels.reorder("123456789", [{ id: "c1", position: 0 }])`
+      });
+    }
+    const json = await this.ctx.request("POST", `/api/v1/guilds/${encodeURIComponent(guildId)}/channels/reorder`, {
+      body: {
+        items: items.map((it) => ({
+          id: String(it.id ?? it.channelId ?? ""),
+          ...it.position !== void 0 ? { position: Number(it.position) } : {},
+          ...it.parentId !== void 0 ? { parent_id: it.parentId ? String(it.parentId) : null } : {}
+        }))
+      }
+    });
+    return (json.channels ?? []).map(toCamelChannel);
+  }
+};
+
+// src/utils.js
+function sanitizeContent(s) {
+  return String(s ?? "").replace(/<\/?script/gi, "").trim().slice(0, 2e3);
+}
+function escapeContent(s) {
+  return String(s ?? "").replace(/[<>&"]/g, (c) => ({ "<": "&lt", ">": "&gt", "&": "&amp", '"': "&quot" })[c]);
+}
+function isBotAuthorId(id) {
+  return typeof id === "string" && /^bot_\d{16}$/.test(id);
+}
+var KEY_MAP = {
+  channel_id: "channelId",
+  guild_id: "guildId",
+  author_id: "authorId",
+  user_id: "userId",
+  is_bot: "isBot",
+  is_owner: "isOwner",
+  bot_id: "botId",
+  created_at: "createdAt",
+  edited_at: "editedAt",
+  joined_at: "joinedAt",
+  banned_at: "bannedAt",
+  banned_by: "bannedBy",
+  expires_at: "expiresAt",
+  display_name: "displayName",
+  role_ids: "roleIds",
+  ordered_ids: "orderedIds",
+  member_count: "memberCount",
+  owner_id: "ownerId",
+  parent_id: "parentId",
+  application_id: "applicationId",
+  guild_id_hint: "guildId",
+  has_more: "hasMore"
+};
+function toCamel(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(toCamel);
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) out[KEY_MAP[k] ?? k] = v;
+  return out;
+}
+function toCamelMessage(m) {
+  const c = toCamel(m);
+  for (const k of ["createdAt", "editedAt"]) {
+    if (c[k] && !(c[k] instanceof Date)) {
+      const d = new Date(c[k]);
+      if (!Number.isNaN(d.getTime())) c[k] = d;
+    }
+  }
+  return c;
+}
+function parseMentions(content) {
+  const text = String(content ?? "");
+  const userIds = [...text.matchAll(/<@!?([^>\s]+)>/g)].map((m) => m[1]);
+  const everyone = /@everyone/.test(text);
+  const here = /@here/.test(text);
+  return { userIds, everyone, here };
+}
+
+// src/resources/messages.js
+var MessagesResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  normalizeSendArgs(channelId, contentOrOpts) {
+    if (!channelId) {
+      throw missingArgument({
+        label: "bot.client.messages.send",
+        param: "channelId",
+        example: `bot.client.messages.send("CHANNEL_ID", "hello")`
+      });
+    }
+    let content = "";
+    let replyTo;
+    if (typeof contentOrOpts === "string") content = contentOrOpts;
+    else if (contentOrOpts && typeof contentOrOpts === "object") {
+      content = contentOrOpts.content ?? "";
+      replyTo = contentOrOpts.replyTo ?? contentOrOpts.reply_to;
+    }
+    content = sanitizeContent(content);
+    if (!content) throw new Error("Content is required (1-2000 chars after sanitizing).");
+    return { content, reply_to: replyTo };
+  }
+  async send(channelId, contentOrOpts) {
+    const { content, reply_to } = this.normalizeSendArgs(channelId, contentOrOpts);
+    const json = await this.ctx.request("POST", `/api/v1/channels/${encodeURIComponent(channelId)}/messages`, {
+      body: reply_to ? { content, reply_to } : { content }
+    });
+    const m = json.message ?? json;
+    return toCamelMessage(m);
+  }
+  /** Short reply helper: send with reply_to preset. */
+  async reply(channelId, messageId, content) {
+    return this.send(channelId, { content, reply_to: messageId });
+  }
+  normalizeEditArgs(channelId, messageId, content) {
+    if (!channelId) {
+      throw missingArgument({
+        label: "bot.client.messages.edit",
+        param: "channelId",
+        example: `bot.client.messages.edit("CHANNEL_ID", "MSG_ID", "new content")`
+      });
+    }
+    if (!messageId) {
+      throw missingArgument({
+        label: "bot.client.messages.edit",
+        param: "messageId",
+        example: `bot.client.messages.edit("CHANNEL_ID", "MSG_ID", "new content")`
+      });
+    }
+    content = sanitizeContent(content);
+    if (!content) throw new Error("Content is required (1-2000 chars after sanitizing).");
+    return { content };
+  }
+  /** Edit your own message. Only the author can edit (server enforces). */
+  async edit(channelId, messageId, content) {
+    const { content: clean } = this.normalizeEditArgs(channelId, messageId, content);
+    const json = await this.ctx.request("PATCH", `/api/v1/channels/${encodeURIComponent(channelId)}/messages/${encodeURIComponent(messageId)}`, {
+      body: { content: clean }
+    });
+    const m = json.message ?? json;
+    return toCamelMessage(m);
+  }
+  /** Delete a message. Own messages always; others need MANAGE_MESSAGES (server enforces). */
+  async delete(channelId, messageId) {
+    if (!channelId) {
+      throw missingArgument({
+        label: "bot.client.messages.delete",
+        param: "channelId",
+        example: `bot.client.messages.delete("CHANNEL_ID", "MSG_ID")`
+      });
+    }
+    if (!messageId) {
+      throw missingArgument({
+        label: "bot.client.messages.delete",
+        param: "messageId",
+        example: `bot.client.messages.delete("CHANNEL_ID", "MSG_ID")`
+      });
+    }
+    const json = await this.ctx.request("DELETE", `/api/v1/channels/${encodeURIComponent(channelId)}/messages/${encodeURIComponent(messageId)}`);
+    return { id: json.id ?? messageId, raw: json };
+  }
+  async fetch(channelId, { limit = 50, before } = {}) {
+    if (!channelId) {
+      throw missingArgument({
+        label: "bot.client.messages.fetch",
+        param: "channelId",
+        example: `bot.client.messages.fetch("CHANNEL_ID", { limit: 20 })`
+      });
+    }
+    limit = Math.min(Math.max(Number(limit) || 50, 1), 100);
+    const json = await this.ctx.request(
+      "GET",
+      `/api/v1/channels/${encodeURIComponent(channelId)}/messages`,
+      { query: { limit, ...before ? { before } : {} } }
+    );
+    return {
+      messages: (json.messages ?? []).map(toCamelMessage),
+      hasMore: json.has_more ?? false,
+      raw: json
+    };
+  }
+  /** Auto-paginate history (newest-first pages, returns ascending list). */
+  async fetchAll(channelId, { max = 200, pageSize = 100 } = {}) {
+    let before;
+    const acc = [];
+    while (acc.length < max) {
+      const page = await this.fetch(channelId, { limit: Math.min(pageSize, max - acc.length), before });
+      if (!page.messages.length) break;
+      acc.unshift(...page.messages);
+      if (!page.hasMore) break;
+      before = page.messages[0]?.id;
+      if (!before) break;
+    }
+    return acc.slice(-max);
+  }
+};
+
+// src/permissions.js
+var PERMISSIONS = {
+  VIEW_CHANNEL: 1 << 0,
+  SEND_MESSAGES: 1 << 1,
+  MANAGE_MESSAGES: 1 << 2,
+  MANAGE_CHANNELS: 1 << 3,
+  MANAGE_ROLES: 1 << 4,
+  MANAGE_SERVER: 1 << 5,
+  KICK_MEMBERS: 1 << 6,
+  BAN_MEMBERS: 1 << 7,
+  CREATE_INVITE: 1 << 8,
+  CONNECT: 1 << 9,
+  MUTE_MEMBERS: 1 << 10,
+  ADMINISTRATOR: 1 << 11,
+  VIEW_AUDIT_LOG: 1 << 12
+};
+var PERMISSION_MASK = 8191;
+var DEFAULT_EVERYONE_PERMS = PERMISSIONS.VIEW_CHANNEL | PERMISSIONS.SEND_MESSAGES | PERMISSIONS.CREATE_INVITE | PERMISSIONS.CONNECT;
+var DEFAULT_ADMIN_PERMS = Object.values(PERMISSIONS).reduce((a, b) => a | b, 0);
+function normalizeRole(r = {}) {
+  return {
+    id: r.id,
+    name: r.name,
+    color: r.color ?? "#99AAB5",
+    hoist: !!r.hoist,
+    mentionable: !!r.mentionable,
+    position: Number(r.position ?? r.pos ?? 0) || 0,
+    permissions: Number(r.permissions ?? 0) || 0,
+    managed: !!r.managed,
+    raw: r.raw ?? r
+  };
+}
+function roleListOf(roles) {
+  return (Array.isArray(roles) ? roles : []).map(normalizeRole);
+}
+function getHighestRole(roles, roleIds, isOwner = false) {
+  if (isOwner) return { id: "@owner", name: "Owner", position: Infinity, permissions: DEFAULT_ADMIN_PERMS, managed: true };
+  const all = roleListOf(roles);
+  const ids = new Set(Array.isArray(roleIds) ? roleIds : []);
+  const mine = all.filter((r) => ids.has(r.id));
+  if (!mine.length) return null;
+  return mine.reduce((a, b) => b.position > a.position ? b : a, mine[0]);
+}
+function getMemberPermissions(roles, roleIds, isOwner = false) {
+  if (isOwner) return DEFAULT_ADMIN_PERMS;
+  const all = roleListOf(roles);
+  const ids = new Set(Array.isArray(roleIds) ? roleIds : []);
+  let perms = 0;
+  for (const r of all) if (ids.has(r.id)) perms |= r.permissions;
+  if (perms & PERMISSIONS.ADMINISTRATOR) return DEFAULT_ADMIN_PERMS;
+  return perms;
+}
+function hasPermission(roles, roleIds, permission, isOwner = false) {
+  const perms = getMemberPermissions(roles, roleIds, isOwner);
+  if (perms & PERMISSIONS.ADMINISTRATOR) return true;
+  return (perms & permission) === permission;
+}
+function canManageRole(actorRoles, actorRoleIds, targetRole, { actorIsOwner = false } = {}) {
+  const target = normalizeRole(targetRole);
+  if (actorIsOwner) {
+    if (target.id === "everyone") return { ok: false, reason: "The @everyone role cannot be moved or deleted." };
+    return { ok: true, reason: null };
+  }
+  if (target.id === "everyone") return { ok: false, reason: "The @everyone role cannot be managed." };
+  if (target.managed) return { ok: false, reason: `Role "${target.name}" is managed and cannot be edited.` };
+  const highest = getHighestRole(actorRoles, actorRoleIds, false);
+  if (!highest) return { ok: false, reason: "Actor has no roles on this guild." };
+  if (highest.permissions & PERMISSIONS.ADMINISTRATOR) return { ok: true, reason: null };
+  if (!(highest.permissions & PERMISSIONS.MANAGE_ROLES)) {
+    return { ok: false, reason: "Missing permission: MANAGE_ROLES." };
+  }
+  if (highest.position <= target.position) {
+    return { ok: false, reason: `Role "${target.name}" is equal to or higher than your highest role.` };
+  }
+  return { ok: true, reason: null };
+}
+function canAssignRole(actorRoles, actorRoleIds, role, { actorIsOwner = false } = {}) {
+  const target = normalizeRole(role);
+  if (actorIsOwner) return { ok: true, reason: null };
+  if (target.id === "everyone") return { ok: true, reason: null };
+  if (target.managed) return { ok: false, reason: `Role "${target.name}" is managed and cannot be assigned.` };
+  const highest = getHighestRole(actorRoles, actorRoleIds, false);
+  if (!highest) return { ok: false, reason: "Actor has no roles on this guild." };
+  if (highest.permissions & PERMISSIONS.ADMINISTRATOR) return { ok: true, reason: null };
+  if (!(highest.permissions & PERMISSIONS.MANAGE_ROLES)) {
+    return { ok: false, reason: "Missing permission: MANAGE_ROLES." };
+  }
+  if (highest.position <= target.position) {
+    return { ok: false, reason: `Role "${target.name}" is equal to or higher than your highest role.` };
+  }
+  return { ok: true, reason: null };
+}
+function canModerate(actorRoles, actorRoleIds, targetRoleIds, { actorIsOwner = false, targetIsOwner = false, self = false } = {}) {
+  if (self) return { ok: false, reason: "You cannot moderate yourself." };
+  if (targetIsOwner) return { ok: false, reason: "You cannot moderate the server owner." };
+  if (actorIsOwner) return { ok: true, reason: null };
+  const actorHighest = getHighestRole(actorRoles, actorRoleIds, false);
+  const targetHighest = getHighestRole(actorRoles, targetRoleIds, false);
+  const actorPos = actorHighest?.position ?? 0;
+  const targetPos = targetHighest?.position ?? 0;
+  if (targetPos >= actorPos) {
+    return { ok: false, reason: "Target has an equal or higher role." };
+  }
+  return { ok: true, reason: null };
+}
+function sortRoles(roles) {
+  return roleListOf(roles).sort((a, b) => a.position - b.position);
+}
+
+// src/resources/roles.js
+var COLOR_RE = /^#[0-9A-Fa-f]{6}$/;
+function needGuild(guildId, label) {
+  if (!guildId) {
+    throw missingArgument({
+      label,
+      param: "guildId",
+      example: `bot.client.roles.list("123456789")`
+    });
+  }
+}
+function needRole(roleId, label) {
+  if (!roleId) {
+    throw missingArgument({
+      label,
+      param: "roleId",
+      example: `bot.client.roles.get("123456789", "987654321")`
+    });
+  }
+}
+function needUser(userId, label) {
+  if (!userId) {
+    throw missingArgument({
+      label,
+      param: "userId",
+      example: `bot.client.roles.setMemberRoles("123456789", "555", ["everyone"])`
+    });
+  }
+}
+function assertRoleName(name) {
+  const s = String(name ?? "").trim().slice(0, 32);
+  if (!s) throw new Error("Role name is required (1-32 chars).");
+  return s;
+}
+function assertRoleColor(color) {
+  if (color === void 0 || color === null || color === "") return void 0;
+  if (!COLOR_RE.test(String(color))) {
+    throw invalidChoice({
+      label: "color",
+      received: String(color),
+      valid: ["#FF0000", "#00FF00", "#5865F2", "#99AAB5"],
+      validTitle: "Valid colors look like"
+    });
+  }
+  return String(color);
+}
+function assertRolePermissions(permissions) {
+  if (permissions === void 0 || permissions === null) return void 0;
+  const n = Number(permissions);
+  if (!Number.isInteger(n) || n < 0) throw new Error("permissions must be a non-negative integer bitfield.");
+  return n & PERMISSION_MASK;
+}
+function toSnakeCreate({ name, color, hoist, mentionable, permissions, position }) {
+  const body = { name: assertRoleName(name) };
+  const c = assertRoleColor(color);
+  if (c !== void 0) body.color = c;
+  if (hoist !== void 0) body.hoist = !!hoist;
+  if (mentionable !== void 0) body.mentionable = !!mentionable;
+  const p = assertRolePermissions(permissions);
+  if (p !== void 0) body.permissions = p;
+  if (position !== void 0) {
+    if (!Number.isInteger(Number(position))) throw new Error("position must be an integer.");
+    body.position = Number(position);
+  }
+  return body;
+}
+function toSnakePatch(patch = {}) {
+  const body = {};
+  if (patch.name !== void 0) body.name = assertRoleName(patch.name);
+  if (patch.color !== void 0) {
+    if (!COLOR_RE.test(String(patch.color))) {
+      throw invalidChoice({
+        label: "color",
+        received: String(patch.color),
+        valid: ["#FF0000", "#00FF00", "#5865F2", "#99AAB5"],
+        validTitle: "Valid colors look like"
+      });
+    }
+    body.color = String(patch.color);
+  }
+  if (patch.hoist !== void 0) body.hoist = !!patch.hoist;
+  if (patch.mentionable !== void 0) body.mentionable = !!patch.mentionable;
+  if (patch.permissions !== void 0) {
+    const p = assertRolePermissions(patch.permissions);
+    if (p === void 0) throw new Error("Invalid permissions value.");
+    body.permissions = p;
+  }
+  if (patch.position !== void 0) {
+    if (!Number.isInteger(Number(patch.position))) throw new Error("position must be an integer.");
+    body.position = Number(patch.position);
+  }
+  return body;
+}
+function toCamelRole(r) {
+  const n = normalizeRole({
+    id: r.id,
+    name: r.name,
+    color: r.color,
+    hoist: r.hoist,
+    mentionable: r.mentionable,
+    position: r.position,
+    permissions: r.permissions,
+    managed: r.managed
+  });
+  n.raw = r;
+  return n;
+}
+var RolesResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /** All roles of a guild, ascending by position. */
+  async list(guildId) {
+    needGuild(guildId, "bot.client.roles.list");
+    const json = await this.ctx.request("GET", `/api/v1/guilds/${encodeURIComponent(guildId)}/roles`);
+    return sortRoles(json.roles ?? []).map((r) => {
+      const full = (json.roles ?? []).find((x) => x.id === r.id) ?? r;
+      return toCamelRole(full);
+    });
+  }
+  async get(guildId, roleId) {
+    needGuild(guildId, "bot.client.roles.get");
+    needRole(roleId, "bot.client.roles.get");
+    const json = await this.ctx.request(
+      "GET",
+      `/api/v1/guilds/${encodeURIComponent(guildId)}/roles/${encodeURIComponent(roleId)}`
+    );
+    return toCamelRole(json.role ?? json);
+  }
+  /**
+   * Create a role. Position defaults server-side to just below your highest
+   * role (owner: on top). Throws when the new role would land above you.
+   */
+  async create(guildId, opts = {}) {
+    needGuild(guildId, "bot.client.roles.create");
+    const body = toSnakeCreate(opts);
+    const json = await this.ctx.request("POST", `/api/v1/guilds/${encodeURIComponent(guildId)}/roles`, { body });
+    return toCamelRole(json.role ?? json);
+  }
+  /** Edit name/color/hoist/mentionable/permissions/position. */
+  async update(guildId, roleId, patch = {}) {
+    needGuild(guildId, "bot.client.roles.update");
+    needRole(roleId, "bot.client.roles.update");
+    const body = toSnakePatch(patch);
+    const json = await this.ctx.request(
+      "PATCH",
+      `/api/v1/guilds/${encodeURIComponent(guildId)}/roles/${encodeURIComponent(roleId)}`,
+      { body }
+    );
+    const role = json.role ?? json.roles?.find((r) => r.id === roleId) ?? json;
+    return Array.isArray(json.roles) ? sortRoles(json.roles).map(toCamelRole) : toCamelRole(role);
+  }
+  /** Delete a role (removes it from all members + bots). Returns { id }. */
+  async delete(guildId, roleId) {
+    needGuild(guildId, "bot.client.roles.delete");
+    needRole(roleId, "bot.client.roles.delete");
+    const json = await this.ctx.request(
+      "DELETE",
+      `/api/v1/guilds/${encodeURIComponent(guildId)}/roles/${encodeURIComponent(roleId)}`
+    );
+    return { id: json.id ?? roleId, raw: json };
+  }
+  /** Reorder roles by id array (ascending = low to high). Returns sorted roles. */
+  async reorder(guildId, orderedIds) {
+    needGuild(guildId, "bot.client.roles.reorder");
+    if (!Array.isArray(orderedIds) || !orderedIds.length) {
+      throw missingArgument({
+        label: "bot.client.roles.reorder",
+        param: "orderedIds",
+        example: `bot.client.roles.reorder("123456789", ["everyone", "roleA", "roleB"])`
+      });
+    }
+    const json = await this.ctx.request("POST", `/api/v1/guilds/${encodeURIComponent(guildId)}/roles/reorder`, {
+      body: { ordered_ids: orderedIds.map(String) }
+    });
+    return sortRoles(json.roles ?? []).map(toCamelRole);
+  }
+  /** Role ids of a member (user id or `bot_<botId>`). Always includes "everyone". */
+  async memberRoles(guildId, userId) {
+    needGuild(guildId, "bot.client.roles.memberRoles");
+    needUser(userId, "bot.client.roles.memberRoles");
+    const json = await this.ctx.request(
+      "GET",
+      `/api/v1/guilds/${encodeURIComponent(guildId)}/members/${encodeURIComponent(userId)}/roles`
+    );
+    return { userId: json.user_id ?? userId, roleIds: json.role_ids ?? json.roleIds ?? ["everyone"], raw: json };
+  }
+  /**
+   * Replace a member's roles (full set, "everyone" auto-added).
+   * Fails server-side when a role is above your highest role or the target
+   * outranks you.
+   */
+  async setMemberRoles(guildId, userId, roleIds) {
+    needGuild(guildId, "bot.client.roles.setMemberRoles");
+    needUser(userId, "bot.client.roles.setMemberRoles");
+    if (!Array.isArray(roleIds)) {
+      throw missingArgument({
+        label: "bot.client.roles.setMemberRoles",
+        param: "roleIds",
+        example: `bot.client.roles.setMemberRoles("123456789", "555", ["everyone", "roleA"])`
+      });
+    }
+    const json = await this.ctx.request(
+      "PUT",
+      `/api/v1/guilds/${encodeURIComponent(guildId)}/members/${encodeURIComponent(userId)}/roles`,
+      { body: { role_ids: roleIds.map(String) } }
+    );
+    return { userId: json.user_id ?? json.member?.user_id ?? userId, roleIds: json.role_ids ?? json.member?.role_ids ?? [], raw: json };
+  }
+  /** Convenience: add one role (reads current set first). */
+  async addMemberRole(guildId, userId, roleId) {
+    needRole(roleId, "bot.client.roles.addMemberRole");
+    const cur = await this.memberRoles(guildId, userId);
+    if (cur.roleIds.includes(String(roleId))) return cur;
+    return this.setMemberRoles(guildId, userId, [...cur.roleIds, String(roleId)]);
+  }
+  /** Convenience: remove one role (never removes "everyone"). */
+  async removeMemberRole(guildId, userId, roleId) {
+    needRole(roleId, "bot.client.roles.removeMemberRole");
+    if (String(roleId) === "everyone") throw new Error('The "everyone" role cannot be removed.');
+    const cur = await this.memberRoles(guildId, userId);
+    return this.setMemberRoles(
+      guildId,
+      userId,
+      cur.roleIds.filter((id) => id !== String(roleId))
+    );
+  }
+  // ---- offline hierarchy helpers (same rules the server enforces) ----
+  /** Highest role object of `roleIds` within `roles` (null when none). */
+  highestOf(roles, roleIds, isOwner = false) {
+    return getHighestRole(roles, roleIds, isOwner);
+  }
+  highestPosition(roles, roleIds, isOwner = false) {
+    if (isOwner) return Infinity;
+    return getHighestRole(roles, roleIds, false)?.position ?? 0;
+  }
+  memberPermissions(roles, roleIds, isOwner = false) {
+    return getMemberPermissions(roles, roleIds, isOwner);
+  }
+  hasPermission(roles, roleIds, permission, isOwner = false) {
+    return hasPermission(roles, roleIds, permission, isOwner);
+  }
+  /**
+   * Pre-check: may these `actorRoleIds` manage `targetRole`?
+   * Returns { ok, reason } — the server re-checks authoritatively.
+   */
+  canManage(roles, actorRoleIds, targetRole, opts) {
+    return canManageRole(roles, actorRoleIds, targetRole, opts);
+  }
+  /** Pre-check: may these `actorRoleIds` grant `role` to someone? */
+  canAssign(roles, actorRoleIds, role, opts) {
+    return canAssignRole(roles, actorRoleIds, role, opts);
+  }
+  /** Pre-check: may actor moderate target (position compare)? */
+  canModerate(roles, actorRoleIds, targetRoleIds, opts) {
+    return canModerate(roles, actorRoleIds, targetRoleIds, opts);
+  }
+};
+
+// src/resources/members.js
+function needGuild2(guildId, label) {
+  if (!guildId) {
+    throw missingArgument({
+      label,
+      param: "guildId",
+      example: `bot.client.members.list("123456789")`
+    });
+  }
+}
+function needUser2(userId, label) {
+  if (!userId) {
+    throw missingArgument({
+      label,
+      param: "userId",
+      example: `bot.client.members.get("123456789", "555")`
+    });
+  }
+}
+function toCamelMember(m) {
+  const c = toCamel(m);
+  if (c.joinedAt && !(c.joinedAt instanceof Date)) {
+    const d = new Date(c.joinedAt);
+    if (!Number.isNaN(d.getTime())) c.joinedAt = d;
+  }
+  if (c.createdAt && !(c.createdAt instanceof Date)) {
+    const d = new Date(c.createdAt);
+    if (!Number.isNaN(d.getTime())) c.createdAt = d;
+  }
+  return c;
+}
+function toCamelBan(b) {
+  const c = toCamel(b);
+  for (const k of ["bannedAt", "expiresAt"]) {
+    if (c[k] && !(c[k] instanceof Date)) {
+      const d = new Date(c[k]);
+      if (!Number.isNaN(d.getTime())) c[k] = d;
+    }
+  }
+  return c;
+}
+var MembersResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * List members (users first, then installed bots). Cursor pagination:
+   * `{ limit: 1-100 (default 50), after: "<userId>" }`.
+   */
+  async list(guildId, { limit = 50, after } = {}) {
+    needGuild2(guildId, "bot.client.members.list");
+    limit = Math.min(Math.max(Number(limit) || 50, 1), 100);
+    const json = await this.ctx.request("GET", `/api/v1/guilds/${encodeURIComponent(guildId)}/members`, {
+      query: { limit, ...after ? { after } : {} }
+    });
+    return {
+      members: (json.members ?? []).map(toCamelMember),
+      hasMore: json.has_more ?? false,
+      raw: json
+    };
+  }
+  /** Single member (`userId` or `bot_<botId>`). */
+  async get(guildId, userId) {
+    needGuild2(guildId, "bot.client.members.get");
+    needUser2(userId, "bot.client.members.get");
+    const json = await this.ctx.request(
+      "GET",
+      `/api/v1/guilds/${encodeURIComponent(guildId)}/members/${encodeURIComponent(userId)}`
+    );
+    return toCamelMember(json.member ?? json);
+  }
+  /**
+   * Kick a member (needs KICK_MEMBERS + higher top role, server enforces).
+   * Returns { id }.
+   */
+  async kick(guildId, userId, reason) {
+    needGuild2(guildId, "bot.client.members.kick");
+    needUser2(userId, "bot.client.members.kick");
+    const body = {};
+    if (typeof reason === "string" && reason.trim()) body.reason = reason.trim().slice(0, 256);
+    else if (reason && typeof reason === "object" && reason.reason) {
+      body.reason = String(reason.reason).trim().slice(0, 256);
+    }
+    const json = await this.ctx.request(
+      "POST",
+      `/api/v1/guilds/${encodeURIComponent(guildId)}/members/${encodeURIComponent(userId)}/kick`,
+      { body }
+    );
+    return { id: json.id ?? json.user_id ?? userId, raw: json };
+  }
+  /**
+   * Ban a member. `duration` accepts seconds (number) or strings like
+   * "10m", "1h", "7d", "1w", "permanent" (default). Returns
+   * { userId, reason, expiresAt, duration }.
+   */
+  async ban(guildId, userId, opts = {}) {
+    needGuild2(guildId, "bot.client.members.ban");
+    needUser2(userId, "bot.client.members.ban");
+    const body = {};
+    const o = typeof opts === "string" ? { reason: opts } : opts || {};
+    if (o.reason !== void 0) body.reason = String(o.reason).slice(0, 256);
+    if (o.duration !== void 0) body.duration = o.duration;
+    if (o.durationSec !== void 0) body.duration = o.durationSec;
+    const json = await this.ctx.request(
+      "POST",
+      `/api/v1/guilds/${encodeURIComponent(guildId)}/members/${encodeURIComponent(userId)}/ban`,
+      { body }
+    );
+    return toCamel(json);
+  }
+  /** Unban a user id. Returns { id }. */
+  async unban(guildId, userId) {
+    needGuild2(guildId, "bot.client.members.unban");
+    needUser2(userId, "bot.client.members.unban");
+    const json = await this.ctx.request(
+      "POST",
+      `/api/v1/guilds/${encodeURIComponent(guildId)}/members/${encodeURIComponent(userId)}/unban`
+    );
+    return { id: json.id ?? json.user_id ?? userId, raw: json };
+  }
+  /** Active bans (prunes expired server-side). */
+  async bans(guildId) {
+    needGuild2(guildId, "bot.client.members.bans");
+    const json = await this.ctx.request("GET", `/api/v1/guilds/${encodeURIComponent(guildId)}/bans`);
+    return {
+      bans: (json.bans ?? []).map(toCamelBan),
+      bannedUserIds: json.banned_user_ids ?? json.bannedMemberIds ?? [],
+      raw: json
+    };
+  }
+};
+
+// src/resources/dms.js
+function needChannel(channelId, label) {
+  if (!channelId) {
+    throw missingArgument({
+      label,
+      param: "channelId",
+      example: `bot.client.dms.send("DM_CHANNEL_ID", "hello")`
+    });
+  }
+}
+function needUser3(userId, label) {
+  if (!userId) {
+    throw missingArgument({
+      label,
+      param: "userId",
+      example: `bot.client.dms.open("555")`
+    });
+  }
+}
+function toCamelDm(m) {
+  const c = toCamel(m);
+  if (c.createdAt && !(c.createdAt instanceof Date)) {
+    const d = new Date(c.createdAt);
+    if (!Number.isNaN(d.getTime())) c.createdAt = d;
+  }
+  if (c.editedAt && !(c.editedAt instanceof Date)) {
+    const d = new Date(c.editedAt);
+    if (!Number.isNaN(d.getTime())) c.editedAt = d;
+  }
+  return c;
+}
+var DmsResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /** All DM conversations of this bot (newest first). */
+  async list() {
+    const json = await this.ctx.request("GET", "/api/v1/dms");
+    return {
+      conversations: (json.conversations ?? []).map(toCamelDm),
+      raw: json
+    };
+  }
+  /**
+   * Find-or-create the DM with a user. Fails when there is no shared
+   * server, the user blocks DMs, or the target is a bot/system account.
+   */
+  async open(userId) {
+    needUser3(userId, "bot.client.dms.open");
+    const json = await this.ctx.request("POST", "/api/v1/dms", { body: { user_id: String(userId) } });
+    return toCamelDm(json.conversation ?? json);
+  }
+  /** Fetch messages (counter pagination, newest page first -> ascending list). */
+  async fetch(channelId, { limit = 50, before } = {}) {
+    needChannel(channelId, "bot.client.dms.fetch");
+    limit = Math.min(Math.max(Number(limit) || 50, 1), 100);
+    const json = await this.ctx.request("GET", `/api/v1/dms/${encodeURIComponent(channelId)}/messages`, {
+      query: { limit, ...before !== void 0 && before !== null ? { before } : {} }
+    });
+    return {
+      messages: (json.messages ?? []).map(toCamelDm),
+      hasMore: json.has_more ?? false,
+      raw: json
+    };
+  }
+  /** Auto-paginate DM history (returns ascending list, up to max). */
+  async fetchAll(channelId, { max = 200, pageSize = 100 } = {}) {
+    let before;
+    const acc = [];
+    while (acc.length < max) {
+      const page = await this.fetch(channelId, { limit: Math.min(pageSize, max - acc.length), before });
+      if (!page.messages.length) break;
+      acc.unshift(...page.messages);
+      if (!page.hasMore) break;
+      before = page.messages[0]?.counter ?? page.messages[0]?.enc?.counter;
+      if (before === void 0) break;
+    }
+    return acc.slice(-max);
+  }
+  /** Send a DM (1-4000 chars after sanitizing). */
+  async send(channelId, content) {
+    needChannel(channelId, "bot.client.dms.send");
+    const clean = sanitizeContent(content).slice(0, 4e3);
+    if (!clean) throw new Error("Content is required (1-4000 chars after sanitizing).");
+    const json = await this.ctx.request("POST", `/api/v1/dms/${encodeURIComponent(channelId)}/messages`, {
+      body: { content: clean }
+    });
+    return toCamelDm(json.message ?? json);
+  }
+  /** Edit your own DM. Only the author can edit (server enforces). */
+  async edit(channelId, messageId, content) {
+    needChannel(channelId, "bot.client.dms.edit");
+    if (!messageId) {
+      throw missingArgument({
+        label: "bot.client.dms.edit",
+        param: "messageId",
+        example: `bot.client.dms.edit("DM_ID", "MSG_ID", "new text")`
+      });
+    }
+    const clean = sanitizeContent(content).slice(0, 4e3);
+    if (!clean) throw new Error("Content is required (1-4000 chars after sanitizing).");
+    const json = await this.ctx.request(
+      "PATCH",
+      `/api/v1/dms/${encodeURIComponent(channelId)}/messages/${encodeURIComponent(messageId)}`,
+      { body: { content: clean } }
+    );
+    return toCamelDm(json.message ?? json);
+  }
+  /** Delete your own DM. Returns { id }. */
+  async delete(channelId, messageId) {
+    needChannel(channelId, "bot.client.dms.delete");
+    if (!messageId) {
+      throw missingArgument({
+        label: "bot.client.dms.delete",
+        param: "messageId",
+        example: `bot.client.dms.delete("DM_ID", "MSG_ID")`
+      });
+    }
+    const json = await this.ctx.request(
+      "DELETE",
+      `/api/v1/dms/${encodeURIComponent(channelId)}/messages/${encodeURIComponent(messageId)}`
+    );
+    return { id: json.id ?? messageId, raw: json };
+  }
+  /** Mark a DM as read (clears the unread counter). */
+  async read(channelId) {
+    needChannel(channelId, "bot.client.dms.read");
+    const json = await this.ctx.request("POST", `/api/v1/dms/${encodeURIComponent(channelId)}/read`);
+    return { ok: json.success ?? true, raw: json };
+  }
+};
+
+// src/resources/ethan.js
+var ETHAN_MODEL = "e3n-v1-beta";
+var ETHAN_PERSONALITIES = ["friendly", "objective", "humorous", "neutral", "grumpy"];
+var ETHAN_MESSAGE_MAX = 5e3;
+function assertPersonality(personality) {
+  const p = String(personality ?? "neutral").toLowerCase();
+  if (!ETHAN_PERSONALITIES.includes(p)) {
+    throw invalidChoice({ label: "personality", received: String(personality), valid: ETHAN_PERSONALITIES, validTitle: "Valid personalities" });
+  }
+  return p;
+}
+function assertEthanMessage(message) {
+  const text = String(message ?? "").trim();
+  if (!text) {
+    throw missingArgument({
+      label: "bot.client.ethan.chat",
+      param: "message",
+      example: `bot.client.ethan.chat("Explain recursion in one sentence")`
+    });
+  }
+  if (text.length > ETHAN_MESSAGE_MAX) {
+    throw new Error(`message too long (max ${ETHAN_MESSAGE_MAX} chars, got ${text.length}).`);
+  }
+  return text;
+}
+function assertTemperature(temperature) {
+  if (temperature === void 0 || temperature === null) return void 0;
+  if (typeof temperature !== "number" || Number.isNaN(temperature) || temperature < 0 || temperature > 100) {
+    throw new Error(`temperature must be a number between 0 and 100 (got ${String(temperature)}).`);
+  }
+  return temperature;
+}
+function normalizeChatArgs(messageOrOpts, opts = {}) {
+  let o = {};
+  if (typeof messageOrOpts === "string") o = { ...opts, message: messageOrOpts };
+  else if (messageOrOpts && typeof messageOrOpts === "object") o = { ...messageOrOpts, ...opts };
+  const message = assertEthanMessage(o.message ?? o.input ?? o.prompt);
+  const body = { message, personality: assertPersonality(o.personality ?? "neutral") };
+  if (o.reasoning !== void 0) body.reasoning = o.reasoning === true;
+  const temperature = assertTemperature(o.temperature);
+  if (temperature !== void 0) body.temperature = temperature;
+  return body;
+}
+var EthanClient = class {
+  constructor({ key, timeoutMs = 3e4, retryOn429 = true } = {}) {
+    if (!key) {
+      throw new Error(
+        `Ethan API key required (rve_...). Pass { key } to EthanClient, or { ethanKey } to RavenClient. Keys need an active EthanPlus/EthanPro plan.`
+      );
+    }
+    assertEthanKey(key);
+    this.key = key;
+    this.timeoutMs = timeoutMs;
+    this.retryOn429 = retryOn429;
+    return withSuggestions(this, "bot.ethan");
+  }
+  /** Low-level request (Bearer rve_... auth). */
+  request(method, path2, { query, body } = {}) {
+    return ravenRequest({
+      token: this.key,
+      authScheme: "Bearer",
+      tokenPrefix: ETHAN_KEY_PREFIX,
+      path: path2,
+      method,
+      query,
+      body,
+      timeoutMs: this.timeoutMs,
+      retryOn429: this.retryOn429
+    });
+  }
+  /** Which model the Ethan API serves (no key needed server-side, cheap). */
+  async models() {
+    const json = await this.request("GET", "/api/v1/ethan/models");
+    return {
+      models: (json.models ?? []).map((m) => ({ id: m.id, name: m.name, via: m.via ?? null, raw: m })),
+      raw: json
+    };
+  }
+  /**
+   * Ask Ethan something.
+   * `chat("Explain recursion")` or `chat({ message, personality, reasoning, temperature })`.
+   * personality: friendly|objective|humorous|neutral|grumpy (default neutral).
+   * Returns { reply, thinking, model, plan }.
+   */
+  async chat(messageOrOpts, opts) {
+    const body = normalizeChatArgs(messageOrOpts, opts);
+    const json = await this.request("POST", "/api/v1/ethan/chat", { body });
+    return {
+      reply: json.reply ?? "",
+      thinking: json.thinking ?? "",
+      model: json.model ?? ETHAN_MODEL,
+      plan: json.plan ?? null,
+      raw: json
+    };
+  }
+  /** Alias for chat(). */
+  async ask(messageOrOpts, opts) {
+    return this.chat(messageOrOpts, opts);
+  }
+};
+function createEthanClient(options) {
+  return new EthanClient(options);
+}
+
+// src/resources/oauth.js
+var OAuthResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async info(guildId) {
+    const json = await this.ctx.request("GET", "/api/v1/oauth2/authorize", {
+      query: guildId ? { guild_id: guildId } : {}
+    });
+    return {
+      clientId: json.client_id,
+      username: json.username,
+      scopes: json.scopes ?? [],
+      authorizeUrl: json.authorize_url,
+      installed: json.installed ?? null,
+      raw: json
+    };
+  }
+};
+
+// src/realtime/poller.js
+var import_node_events = require("node:events");
+function toTime(m) {
+  const t = m?.createdAt ? new Date(m.createdAt).getTime() : 0;
+  return Number.isNaN(t) ? 0 : t;
+}
+var MessagePoller = class extends import_node_events.EventEmitter {
+  constructor(client, channelIds, options = {}) {
+    super();
+    this.client = client;
+    this.channelIds = [...new Set((Array.isArray(channelIds) ? channelIds : [channelIds]).filter(Boolean))];
+    if (!this.channelIds.length) throw new Error("At least one channelId is required for polling.");
+    this.pollInterval = Math.max(Number(options.pollInterval) || 3e3, 1e3);
+    this.limit = Math.min(Math.max(Number(options.limit) || 25, 1), 100);
+    this.emitHistory = options.emitHistory ?? false;
+    this.ignoreBots = options.ignoreBots ?? true;
+    this.selfAuthorId = options.selfAuthorId ?? null;
+    this.signal = options.signal ?? null;
+    this.timers = /* @__PURE__ */ new Map();
+    this.seen = /* @__PURE__ */ new Map();
+    this.lastAt = /* @__PURE__ */ new Map();
+    this.running = false;
+    this.onError = options.onError ?? null;
+    if (this.signal) {
+      if (this.signal.aborted) throw new Error("AbortSignal already aborted.");
+      this._onAbort = () => this.stop();
+      this.signal.addEventListener("abort", this._onAbort, { once: true });
+    }
+  }
+  async _primeChannel(channelId) {
+    try {
+      const { messages } = await this.client.messages.fetch(channelId, { limit: this.limit });
+      const ids = new Set(messages.map((m) => m.id));
+      this.seen.set(channelId, ids);
+      const latest = messages[messages.length - 1];
+      if (latest) this.lastAt.set(channelId, toTime(latest));
+      if (this.emitHistory) for (const m of messages) this.emit("message", m);
+    } catch (err) {
+      this.emit("error", err);
+      if (typeof this.onError === "function") this.onError(err);
+    }
+  }
+  async _pollChannel(channelId) {
+    if (!this.running) return;
+    try {
+      const { messages } = await this.client.messages.fetch(channelId, { limit: this.limit });
+      let known = this.seen.get(channelId);
+      if (!known) {
+        known = /* @__PURE__ */ new Set();
+        this.seen.set(channelId, known);
+      }
+      const fresh = messages.filter((m) => !known.has(m.id));
+      for (const m of fresh) known.add(m.id);
+      if (known.size > 500) {
+        const keep = new Set([...known].slice(-300));
+        this.seen.set(channelId, keep);
+      }
+      const cutoff = this.lastAt.get(channelId) ?? 0;
+      const ordered = fresh.filter((m) => toTime(m) >= cutoff).sort((a, b) => toTime(a) - toTime(b));
+      for (const m of ordered) {
+        if (this.ignoreBots && m.isBot) {
+          if (!this.selfAuthorId || m.authorId !== this.selfAuthorId) {
+            continue;
+          }
+        }
+        if (this.selfAuthorId && m.authorId === this.selfAuthorId) continue;
+        this.emit("message", m);
+      }
+      const latest = messages[messages.length - 1];
+      if (latest) this.lastAt.set(channelId, Math.max(cutoff, toTime(latest)));
+    } catch (err) {
+      this.emit("error", err);
+      if (typeof this.onError === "function") {
+        try {
+          this.onError(err);
+        } catch {
+        }
+      }
+    }
+  }
+  async start() {
+    if (this.running) return this;
+    this.running = true;
+    for (const ch of this.channelIds) {
+      await this._primeChannel(ch);
+    }
+    for (const ch of this.channelIds) {
+      const tick = () => {
+        if (!this.running) return;
+        this._pollChannel(ch).finally(() => {
+          if (this.running) this.timers.set(ch, setTimeout(tick, this.pollInterval));
+        });
+      };
+      this.timers.set(ch, setTimeout(tick, this.pollInterval));
+    }
+    return this;
+  }
+  stop() {
+    this.running = false;
+    for (const t of this.timers.values()) clearTimeout(t);
+    this.timers.clear();
+    if (this.signal && this._onAbort) {
+      try {
+        this.signal.removeEventListener("abort", this._onAbort);
+      } catch {
+      }
+    }
+    this.emit("stopped");
+    return this;
+  }
+};
+
+// src/realtime/gateway.js
+var import_node_events2 = require("node:events");
+var import_socket = require("socket.io-client");
+var GATEWAY_EVENTS = [
+  "ready",
+  "dispatch",
+  "message:new",
+  "message:update",
+  "message:delete",
+  "guildCreate",
+  "guildRemove",
+  "roleCreate",
+  "roleUpdate",
+  "roleDelete",
+  "rolesReordered",
+  "memberRolesUpdate",
+  "memberJoin",
+  "memberLeave",
+  "memberBan",
+  "memberUnban",
+  "channelCreate",
+  "channelUpdate",
+  "channelDelete",
+  "channelsReordered",
+  "dmCreate",
+  "dmMessage",
+  "dmMessageUpdate",
+  "dmMessageDelete",
+  "commandError",
+  "heartbeat",
+  "disconnect",
+  "error"
+];
+var IDENTIFY_TIMEOUT_MS = 15e3;
+var RavenGateway = class extends import_node_events2.EventEmitter {
+  constructor(client, options = {}) {
+    super();
+    this.client = client;
+    this.options = options;
+    this.socket = null;
+    this.connected = false;
+    this.sessionId = null;
+    this.lastSeq = 0;
+    this.bot = null;
+    this.guilds = [];
+    this._identifyTimer = null;
+    this._manualClose = false;
+  }
+  get token() {
+    return this.options.token || this.client.token;
+  }
+  /** Open the socket and identify. Resolves with the `ready` payload. */
+  async connect() {
+    if (this.socket && this.connected) return this._readyInfo();
+    if (this.socket) {
+      this._manualClose = false;
+      this.socket.connect();
+      return this._waitForReady();
+    }
+    this._manualClose = false;
+    this.socket = (0, import_socket.io)(`${DEFAULT_BASE_URL}/gateway`, {
+      transports: ["websocket", "polling"],
+      reconnection: true
+    });
+    this.socket.on("connect", () => this._identify(false));
+    this.socket.on("ready", (msg) => this._onReady(msg));
+    this.socket.on("dispatch", (env) => this._onDispatch(env));
+    this.socket.on("heartbeat", () => this._onHeartbeat());
+    this.socket.on("invalid_session", () => this._onInvalidSession());
+    this.socket.on("message:error", (err) => this.emit("error", new RavenError(err?.error || "Gateway error")));
+    this.socket.on("disconnect", (reason) => {
+      this.connected = false;
+      this._clearIdentifyTimer();
+      this.emit("disconnect", reason);
+    });
+    this.socket.on("connect_error", (err) => {
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    });
+    return this._waitForReady();
+  }
+  /** Send a message over the gateway (same rules as REST send). */
+  async send(channelId, contentOrOpts) {
+    const { content, reply_to } = this.client.messages.normalizeSendArgs(channelId, contentOrOpts);
+    const ack = await this._emitAck("message:create", reply_to ? { channel_id: channelId, content, reply_to } : { channel_id: channelId, content });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Send failed.", { status: 0, code: "GATEWAY_SEND_FAILED" });
+    }
+    return toCamelMessage(ack.message);
+  }
+  /** Reply to a message over the gateway. */
+  async reply(channelId, messageId, content) {
+    return this.send(channelId, { content, reply_to: messageId });
+  }
+  /** Edit your own message over the gateway. */
+  async edit(channelId, messageId, content) {
+    const { content: clean } = this.client.messages.normalizeEditArgs(channelId, messageId, content);
+    const ack = await this._emitAck("message:update", { channel_id: channelId, message_id: messageId, content: clean });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Edit failed.", { status: 0, code: "GATEWAY_EDIT_FAILED" });
+    }
+    return toCamelMessage(ack.message);
+  }
+  /** Delete a message over the gateway (own always, others need MANAGE_MESSAGES). */
+  async delete(channelId, messageId) {
+    if (!channelId || !messageId) {
+      throw new Error("channelId and messageId are required.");
+    }
+    const ack = await this._emitAck("message:delete", { channel_id: channelId, message_id: messageId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Delete failed.", { status: 0, code: "GATEWAY_DELETE_FAILED" });
+    }
+    return { id: ack.id ?? messageId };
+  }
+  /**
+   * Set the bot status over the gateway (online, idle, dnd).
+   * Pass null/undefined/"" to release the manual lock.
+   */
+  async setStatus(status) {
+    let payload;
+    if (status === void 0 || status === null || status === "") {
+      payload = {};
+    } else {
+      payload = { status: assertStatus(status) };
+    }
+    const ack = await this._emitAck("status:set", payload);
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Status update failed.", { status: 0, code: "GATEWAY_STATUS_FAILED" });
+    }
+    return { status: ack.status, locked: ack.locked ?? true };
+  }
+  // ---- roles (same rules as REST: MANAGE_ROLES + strictly higher position) ----
+  /** All roles of a guild, ascending by position. */
+  async listRoles(guildId) {
+    if (!guildId) throw new Error("guildId is required.");
+    const ack = await this._emitAck("role:list", { guild_id: guildId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Role list failed.", { status: 0, code: "GATEWAY_ROLES_FAILED" });
+    }
+    return (ack.roles || []).map((r) => toCamel(r));
+  }
+  async getRole(guildId, roleId) {
+    if (!guildId || !roleId) throw new Error("guildId and roleId are required.");
+    const ack = await this._emitAck("role:get", { guild_id: guildId, role_id: roleId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Role fetch failed.", { status: 0, code: "GATEWAY_ROLES_FAILED" });
+    }
+    return toCamel(ack.role);
+  }
+  /** Create a role (position defaults to just below your highest role). */
+  async createRole(guildId, opts = {}) {
+    if (!guildId) throw new Error("guildId is required.");
+    const ack = await this._emitAck("role:create", { guild_id: guildId, ...opts });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Role create failed.", { status: 0, code: "GATEWAY_ROLES_FAILED" });
+    }
+    return toCamel(ack.role);
+  }
+  /** Edit a role (name/color/hoist/mentionable/permissions/position). */
+  async updateRole(guildId, roleId, patch = {}) {
+    if (!guildId || !roleId) throw new Error("guildId and roleId are required.");
+    const ack = await this._emitAck("role:update", { guild_id: guildId, role_id: roleId, ...patch });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Role update failed.", { status: 0, code: "GATEWAY_ROLES_FAILED" });
+    }
+    return ack.roles ? ack.roles.map((r) => toCamel(r)) : toCamel(ack.role);
+  }
+  /** Delete a role. Returns { id }. */
+  async deleteRole(guildId, roleId) {
+    if (!guildId || !roleId) throw new Error("guildId and roleId are required.");
+    const ack = await this._emitAck("role:delete", { guild_id: guildId, role_id: roleId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Role delete failed.", { status: 0, code: "GATEWAY_ROLES_FAILED" });
+    }
+    return { id: ack.id ?? roleId };
+  }
+  /** Reorder roles by id array (low to high). Returns sorted roles. */
+  async reorderRoles(guildId, orderedIds) {
+    if (!guildId || !Array.isArray(orderedIds) || !orderedIds.length) {
+      throw new Error("guildId and orderedIds (string[]) are required.");
+    }
+    const ack = await this._emitAck("roles:reorder", { guild_id: guildId, ordered_ids: orderedIds.map(String) });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Role reorder failed.", { status: 0, code: "GATEWAY_ROLES_FAILED" });
+    }
+    return (ack.roles || []).map((r) => toCamel(r));
+  }
+  /** Role ids of a member (user id or `bot_<botId>`). */
+  async memberRoles(guildId, userId) {
+    if (!guildId || !userId) throw new Error("guildId and userId are required.");
+    const ack = await this._emitAck("member:roles-get", { guild_id: guildId, user_id: userId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Member roles fetch failed.", { status: 0, code: "GATEWAY_ROLES_FAILED" });
+    }
+    return { userId: ack.user_id ?? userId, roleIds: ack.role_ids ?? [] };
+  }
+  /** Replace a member's roles (full set, "everyone" auto-added server-side). */
+  async setMemberRoles(guildId, userId, roleIds) {
+    if (!guildId || !userId || !Array.isArray(roleIds)) {
+      throw new Error("guildId, userId and roleIds (string[]) are required.");
+    }
+    const ack = await this._emitAck("member:roles-set", {
+      guild_id: guildId,
+      user_id: userId,
+      role_ids: roleIds.map(String)
+    });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Member roles update failed.", { status: 0, code: "GATEWAY_ROLES_FAILED" });
+    }
+    return { userId: ack.user_id ?? userId, roleIds: ack.role_ids ?? [] };
+  }
+  // ---- members & moderation (KICK_MEMBERS/BAN_MEMBERS + hierarchy) ----
+  /** List members (users first, then installed bots). */
+  async listMembers(guildId, { limit = 50, after } = {}) {
+    if (!guildId) throw new Error("guildId is required.");
+    const ack = await this._emitAck("member:list", { guild_id: guildId, limit, ...after ? { after } : {} });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Member list failed.", { status: 0, code: "GATEWAY_MEMBERS_FAILED" });
+    }
+    return { members: (ack.members || []).map((m) => toCamel(m)), hasMore: ack.has_more ?? false };
+  }
+  /** Single member (`userId` or `bot_<botId>`). */
+  async getMember(guildId, userId) {
+    if (!guildId || !userId) throw new Error("guildId and userId are required.");
+    const ack = await this._emitAck("member:get", { guild_id: guildId, user_id: userId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Member fetch failed.", { status: 0, code: "GATEWAY_MEMBERS_FAILED" });
+    }
+    return toCamel(ack.member);
+  }
+  /** Kick a member. Returns { id }. */
+  async kick(guildId, userId, reason) {
+    if (!guildId || !userId) throw new Error("guildId and userId are required.");
+    const body = { guild_id: guildId, user_id: userId };
+    const r = typeof reason === "string" ? reason : reason?.reason;
+    if (r) body.reason = String(r).slice(0, 256);
+    const ack = await this._emitAck("member:kick", body);
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Kick failed.", { status: 0, code: "GATEWAY_MEMBERS_FAILED" });
+    }
+    return { id: ack.id ?? ack.user_id ?? userId };
+  }
+  /**
+   * Ban a member. `duration` accepts seconds or "10m"/"1h"/"7d"/"1w"/
+   * "permanent" (default). Returns { userId, reason, expiresAt, duration }.
+   */
+  async ban(guildId, userId, opts = {}) {
+    if (!guildId || !userId) throw new Error("guildId and userId are required.");
+    const o = typeof opts === "string" ? { reason: opts } : opts || {};
+    const ack = await this._emitAck("member:ban", {
+      guild_id: guildId,
+      user_id: userId,
+      ...o.reason !== void 0 ? { reason: String(o.reason).slice(0, 256) } : {},
+      ...o.duration !== void 0 ? { duration: o.duration } : {}
+    });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Ban failed.", { status: 0, code: "GATEWAY_MEMBERS_FAILED" });
+    }
+    return toCamel(ack);
+  }
+  /** Unban a user id. Returns { id }. */
+  async unban(guildId, userId) {
+    if (!guildId || !userId) throw new Error("guildId and userId are required.");
+    const ack = await this._emitAck("member:unban", { guild_id: guildId, user_id: userId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Unban failed.", { status: 0, code: "GATEWAY_MEMBERS_FAILED" });
+    }
+    return { id: ack.id ?? ack.user_id ?? userId };
+  }
+  /** Active bans. */
+  async bans(guildId) {
+    if (!guildId) throw new Error("guildId is required.");
+    const ack = await this._emitAck("ban:list", { guild_id: guildId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Ban list failed.", { status: 0, code: "GATEWAY_MEMBERS_FAILED" });
+    }
+    return { bans: (ack.bans || []).map((b) => toCamel(b)), bannedUserIds: ack.banned_user_ids ?? [] };
+  }
+  // ---- channels (needs MANAGE_CHANNELS + channels.write) ----
+  /** Single channel by id. */
+  async getChannel(channelId) {
+    if (!channelId) throw new Error("channelId is required.");
+    const ack = await this._emitAck("channel:get", { channel_id: channelId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Channel fetch failed.", { status: 0, code: "GATEWAY_CHANNELS_FAILED" });
+    }
+    return toCamel(ack.channel);
+  }
+  /** Create a text/voice channel. opts: { name, type?, parentId?, topic? } */
+  async createChannel(guildId, opts = {}) {
+    if (!guildId) throw new Error("guildId is required.");
+    const ack = await this._emitAck("channel:create", { guild_id: guildId, ...opts });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Channel create failed.", { status: 0, code: "GATEWAY_CHANNELS_FAILED" });
+    }
+    return toCamel(ack.channel);
+  }
+  /** Edit a channel. patch: { name?, topic?, parentId?, position? } */
+  async updateChannel(channelId, patch = {}) {
+    if (!channelId) throw new Error("channelId is required.");
+    const ack = await this._emitAck("channel:update", { channel_id: channelId, ...patch });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Channel update failed.", { status: 0, code: "GATEWAY_CHANNELS_FAILED" });
+    }
+    return toCamel(ack.channel);
+  }
+  /** Delete a channel (messages go with it). Returns { id }. */
+  async deleteChannel(channelId) {
+    if (!channelId) throw new Error("channelId is required.");
+    const ack = await this._emitAck("channel:delete", { channel_id: channelId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Channel delete failed.", { status: 0, code: "GATEWAY_CHANNELS_FAILED" });
+    }
+    return { id: ack.id ?? channelId };
+  }
+  /** Reorder/move channels: items = [{ id, position?, parentId? }]. */
+  async reorderChannels(guildId, items) {
+    if (!guildId || !Array.isArray(items) || !items.length) {
+      throw new Error("guildId and items ([{ id, position?, parentId? }]) are required.");
+    }
+    const ack = await this._emitAck("channels:reorder", { guild_id: guildId, items });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Channel reorder failed.", { status: 0, code: "GATEWAY_CHANNELS_FAILED" });
+    }
+    return (ack.channels || []).map((c) => toCamel(c));
+  }
+  // ---- direct messages (dms.read / dms.write, shared server required) ----
+  /** All DM conversations of this bot (newest first). */
+  async listDms() {
+    const ack = await this._emitAck("dm:list", {});
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "DM list failed.", { status: 0, code: "GATEWAY_DMS_FAILED" });
+    }
+    return { conversations: (ack.conversations || []).map((c) => toCamel(c)) };
+  }
+  /** Find-or-create the DM with a user. */
+  async openDm(userId) {
+    if (!userId) throw new Error("userId is required.");
+    const ack = await this._emitAck("dm:open", { user_id: userId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "DM open failed.", { status: 0, code: "GATEWAY_DMS_FAILED" });
+    }
+    return toCamel(ack.conversation);
+  }
+  /** Fetch DM messages (counter pagination). */
+  async fetchDm(channelId, { limit = 50, before } = {}) {
+    if (!channelId) throw new Error("channelId is required.");
+    const ack = await this._emitAck("dm:fetch", {
+      channel_id: channelId,
+      limit,
+      ...before !== void 0 && before !== null ? { before } : {}
+    });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "DM fetch failed.", { status: 0, code: "GATEWAY_DMS_FAILED" });
+    }
+    return { messages: (ack.messages || []).map((m) => toCamel(m)), hasMore: ack.has_more ?? false };
+  }
+  /** Send a DM (1-4000 chars). */
+  async sendDm(channelId, content) {
+    if (!channelId || !content) throw new Error("channelId and content are required.");
+    const ack = await this._emitAck("dm:send", { channel_id: channelId, content: String(content).slice(0, 4e3) });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "DM send failed.", { status: 0, code: "GATEWAY_DMS_FAILED" });
+    }
+    return toCamel(ack.message);
+  }
+  /** Edit your own DM. */
+  async editDm(channelId, messageId, content) {
+    if (!channelId || !messageId || !content) throw new Error("channelId, messageId and content are required.");
+    const ack = await this._emitAck("dm:update", {
+      channel_id: channelId,
+      message_id: messageId,
+      content: String(content).slice(0, 4e3)
+    });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "DM edit failed.", { status: 0, code: "GATEWAY_DMS_FAILED" });
+    }
+    return toCamel(ack.message);
+  }
+  /** Delete your own DM. Returns { id }. */
+  async deleteDm(channelId, messageId) {
+    if (!channelId || !messageId) throw new Error("channelId and messageId are required.");
+    const ack = await this._emitAck("dm:delete", { channel_id: channelId, message_id: messageId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "DM delete failed.", { status: 0, code: "GATEWAY_DMS_FAILED" });
+    }
+    return { id: ack.id ?? messageId };
+  }
+  /** Mark a DM as read. */
+  async readDm(channelId) {
+    if (!channelId) throw new Error("channelId is required.");
+    const ack = await this._emitAck("dm:read", { channel_id: channelId });
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "DM read failed.", { status: 0, code: "GATEWAY_DMS_FAILED" });
+    }
+    return { ok: true };
+  }
+  /**
+   * Re-sync server-side subscriptions: picks up channels created after
+   * connect and drops rooms of removed installs. The gateway joins every
+   * text channel of every installed guild, so after sync the bot hears the
+   * whole server. Returns { guilds, channels }.
+   */
+  async sync() {
+    const ack = await this._emitAck("sync", {});
+    if (!ack || ack.ok !== true) {
+      throw new RavenError(ack?.error || "Sync failed.", { status: 0, code: "GATEWAY_SYNC_FAILED" });
+    }
+    return { guilds: ack.guilds || [], channels: ack.channels || 0 };
+  }
+  disconnect() {
+    this._manualClose = true;
+    this._clearIdentifyTimer();
+    if (this.socket) this.socket.disconnect();
+    this.socket = null;
+    this.connected = false;
+    this.emit("disconnect", "client");
+    return this;
+  }
+  /** Compat helper: forward poller messages as gateway `message:new` events. */
+  attachPoller(poller) {
+    poller.on("message", (m) => this.emit("message:new", m));
+    poller.on("error", (e) => this.emit("error", e));
+    return this;
+  }
+  /**
+   * Emit an event. Listeners on "*" receive every event as (event, ...args),
+   * e.g. `gateway.on("*", (event, data) => console.log(event, data))`.
+   */
+  emit(event, ...args) {
+    if (event === "*") return super.emit(event, ...args);
+    super.emit(event, ...args);
+    super.emit("*", event, ...args);
+    return true;
+  }
+  _readyInfo() {
+    return { sessionId: this.sessionId, bot: this.bot, guilds: this.guilds };
+  }
+  _waitForReady() {
+    return new Promise((resolve, reject) => {
+      const onReady = (info) => {
+        cleanup();
+        resolve(info);
+      };
+      const onError = (err) => {
+        cleanup();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      };
+      const onTimeout = () => {
+        cleanup();
+        reject(new GatewayNotAvailableError("Gateway identify timed out. Is the server reachable?"));
+      };
+      const cleanup = () => {
+        this._clearIdentifyTimer();
+        this.off("ready", onReady);
+        this.off("error", onError);
+      };
+      this.on("ready", onReady);
+      this.on("error", onError);
+      this._clearIdentifyTimer();
+      this._identifyTimer = setTimeout(onTimeout, this.options.identifyTimeoutMs || IDENTIFY_TIMEOUT_MS);
+      this._identifyTimer.unref?.();
+    });
+  }
+  _clearIdentifyTimer() {
+    if (this._identifyTimer) {
+      clearTimeout(this._identifyTimer);
+      this._identifyTimer = null;
+    }
+  }
+  _identify(isRetry) {
+    if (!this.socket || this._manualClose) return;
+    const payload = this.sessionId ? { token: this.token, session_id: this.sessionId, seq: this.lastSeq } : { token: this.token };
+    this.socket.emit("identify", payload, (ack) => {
+      if (!ack || ack.ok !== true) {
+        if (ack?.error && /session/i.test(ack.error) && !isRetry) {
+          this.sessionId = null;
+          this.lastSeq = 0;
+          this._identify(true);
+          return;
+        }
+        this.emit("error", new RavenError(ack?.error || "Identify failed.", { status: 401, code: "AUTHENTICATION_ERROR" }));
+        return;
+      }
+      if (ack.session_id) this.sessionId = ack.session_id;
+    });
+  }
+  _onReady(msg) {
+    const d = msg?.d || {};
+    this.connected = true;
+    if (d.session_id) this.sessionId = d.session_id;
+    this.bot = d.bot || null;
+    this.guilds = d.guilds || [];
+    this._clearIdentifyTimer();
+    this.emit("ready", this._readyInfo());
+  }
+  _onDispatch(env) {
+    if (env && typeof env.s === "number" && env.s > this.lastSeq) this.lastSeq = env.s;
+    this.emit("dispatch", env);
+    const type = env?.t;
+    if (!type) return;
+    if (type === "message:new" && env.d) {
+      this.emit("message:new", toCamelMessage(env.d));
+      return;
+    }
+    if (type === "message:update" && env.d) {
+      this.emit("message:update", toCamelMessage(env.d));
+      return;
+    }
+    if (type === "message:delete" && env.d) {
+      this.emit("message:delete", toCamel(env.d));
+      return;
+    }
+    if (type === "guildCreate" || type === "install:added") {
+      this.emit("guildCreate", toCamel(env.d));
+      return;
+    }
+    if (type === "guildRemove" || type === "install:removed") {
+      this.emit("guildRemove", toCamel(env.d));
+      return;
+    }
+    if (type === "role:create") {
+      this.emit("roleCreate", toCamel(env.d));
+      return;
+    }
+    if (type === "role:update") {
+      this.emit("roleUpdate", toCamel(env.d));
+      return;
+    }
+    if (type === "role:delete") {
+      this.emit("roleDelete", toCamel(env.d));
+      return;
+    }
+    if (type === "roles:reordered" || type === "roles:updated") {
+      const d = toCamel(env.d);
+      this.emit("rolesReordered", d);
+      return;
+    }
+    if (type === "member:roles-updated" || type === "members:roles-updated") {
+      this.emit("memberRolesUpdate", toCamel(env.d));
+      return;
+    }
+    if (type === "member:join" || type === "members:member-joined") {
+      this.emit("memberJoin", toCamel(env.d));
+      return;
+    }
+    if (type === "member:leave" || type === "members:member-left") {
+      this.emit("memberLeave", toCamel(env.d));
+      return;
+    }
+    if (type === "member:ban") {
+      this.emit("memberBan", toCamel(env.d));
+      return;
+    }
+    if (type === "member:unban") {
+      this.emit("memberUnban", toCamel(env.d));
+      return;
+    }
+    if (type === "channel:create") {
+      this.emit("channelCreate", toCamel(env.d));
+      return;
+    }
+    if (type === "channel:update") {
+      this.emit("channelUpdate", toCamel(env.d));
+      return;
+    }
+    if (type === "channel:delete") {
+      this.emit("channelDelete", toCamel(env.d));
+      return;
+    }
+    if (type === "channels:reordered") {
+      this.emit("channelsReordered", toCamel(env.d));
+      return;
+    }
+    if (type === "dm:create") {
+      this.emit("dmCreate", toCamel(env.d));
+      return;
+    }
+    if (type === "dm:message:new" || type === "dm:new") {
+      this.emit("dmMessage", toCamel(env.d));
+      return;
+    }
+    if (type === "dm:message:update") {
+      this.emit("dmMessageUpdate", toCamel(env.d));
+      return;
+    }
+    if (type === "dm:message:delete") {
+      this.emit("dmMessageDelete", toCamel(env.d));
+      return;
+    }
+    if (type === "auth:revoked") {
+      this.emit("error", new RavenError("Gateway session revoked. Send identify again.", { status: 401, code: "AUTHENTICATION_ERROR" }));
+      return;
+    }
+    this.emit(type, env.d);
+  }
+  _onHeartbeat() {
+    this.emit("heartbeat", { seq: this.lastSeq });
+    if (this.socket) this.socket.emit("heartbeat_ack");
+  }
+  _onInvalidSession() {
+    this.sessionId = null;
+    this.lastSeq = 0;
+    this.emit("error", new RavenError("Gateway session invalid. Re-identifying.", { status: 401, code: "GATEWAY_SESSION_INVALID" }));
+    this._identify(true);
+  }
+  _emitAck(event, payload) {
+    return new Promise((resolve, reject) => {
+      if (!this.socket || !this.connected) {
+        reject(new RavenError("Gateway not connected. Call gateway.connect() first.", { status: 0, code: "GATEWAY_NOT_CONNECTED" }));
+        return;
+      }
+      this.socket.timeout(15e3).emit(event, payload, (err, ack) => {
+        if (err) reject(err instanceof Error ? err : new Error(String(err)));
+        else resolve(ack);
+      });
+    });
+  }
+};
+
+// src/commands/cooldown-store.js
+var MemoryCooldownStore = class {
+  constructor({ maxKeys = 2e3 } = {}) {
+    this.map = /* @__PURE__ */ new Map();
+    this.maxKeys = maxKeys;
+  }
+  get(key) {
+    const until = this.map.get(key);
+    if (until === void 0) return null;
+    if (until <= Date.now()) {
+      this.map.delete(key);
+      return null;
+    }
+    return until;
+  }
+  set(key, expiresAt) {
+    this.map.set(key, expiresAt);
+    if (this.map.size > this.maxKeys) this._prune();
+    return null;
+  }
+  get size() {
+    return this.map.size;
+  }
+  _prune(now = Date.now()) {
+    for (const [k, until] of this.map) {
+      if (until <= now) this.map.delete(k);
+    }
+  }
+};
+
+// src/commands/handler.js
+var COMMAND_OPTS = ["alias", "aliases", "cooldown", "description", "usage"];
+var CommandHandler = class {
+  constructor(options = {}) {
+    this.prefix = options.prefix ?? "!";
+    this.commands = /* @__PURE__ */ new Map();
+    this.aliases = /* @__PURE__ */ new Map();
+    this.cooldownStore = options.cooldownStore ?? new MemoryCooldownStore();
+    this.onUnknown = options.onUnknown ?? null;
+    this.onError = options.onError ?? null;
+    this.onCooldown = options.onCooldown ?? null;
+    this.ignoreBots = options.ignoreBots ?? true;
+    return withSuggestions(this, "bot.commands");
+  }
+  command(name, fn, opts = {}) {
+    if (!name || typeof fn !== "function") throw new Error("command(name, fn) required.");
+    const bad = Object.keys(opts).find((k) => !COMMAND_OPTS.includes(k));
+    if (bad) throw unknownOption({ option: bad, valid: COMMAND_OPTS });
+    const key = String(name).toLowerCase();
+    for (const [alias, target] of this.aliases) {
+      if (target === key) this.aliases.delete(alias);
+    }
+    const raw = opts.aliases ?? opts.alias ?? [];
+    const list = (Array.isArray(raw) ? raw : [raw]).map((a) => String(a).toLowerCase()).filter((a) => a && a !== key);
+    const cooldown = Number(opts.cooldown ?? 0) || 0;
+    this.commands.set(key, {
+      fn,
+      description: opts.description ?? "",
+      usage: opts.usage ?? "",
+      aliases: list,
+      cooldown: cooldown > 0 ? cooldown : 0
+    });
+    for (const a of list) this.aliases.set(a, key);
+    return this;
+  }
+  /** Resolve a name or alias to the canonical command name (or null). */
+  resolve(name) {
+    const key = String(name ?? "").toLowerCase();
+    if (this.commands.has(key)) return key;
+    return this.aliases.get(key) ?? null;
+  }
+  /** Closest command name (or alias target) for a typo, or null. */
+  suggestCommand(name) {
+    const s = suggest(name, [...this.commands.keys(), ...this.aliases.keys()]);
+    if (!s) return null;
+    return this.resolve(s.value) ?? s.value;
+  }
+  parse(content) {
+    const text = String(content ?? "");
+    if (!text.startsWith(this.prefix)) return null;
+    const rest = text.slice(this.prefix.length).trim();
+    if (!rest) return null;
+    const [name, ...args] = rest.split(/\s+/);
+    return { name: name.toLowerCase(), args, raw: rest.slice(name.length).trim() };
+  }
+  makeCtx(client, message) {
+    const channelId = message.channelId ?? message.channel_id;
+    const authorId = message.authorId ?? message.author_id;
+    const guildId = message.guildId ?? message.guild_id;
+    return {
+      message,
+      content: message.content ?? "",
+      args: [],
+      rawArgs: "",
+      command: "",
+      authorId,
+      channelId,
+      guildId,
+      user: message.author ?? message.user ?? { id: authorId },
+      guild: guildId ? { id: guildId } : null,
+      channel: channelId ? { id: channelId } : null,
+      reply: (content) => client.messages.reply(channelId, message.id, content),
+      send: (content) => client.messages.send(channelId, content),
+      delete: () => client.messages.delete(channelId, message.id)
+    };
+  }
+  async handle(client, message) {
+    if (this.ignoreBots && (message.isBot ?? message.is_bot)) return false;
+    const parsed = this.parse(message.content ?? "");
+    if (!parsed) return false;
+    const key = this.resolve(parsed.name);
+    const entry = key ? this.commands.get(key) : null;
+    const ctx = this.makeCtx(client, message);
+    ctx.args = parsed.args;
+    ctx.rawArgs = parsed.raw;
+    ctx.command = key ?? parsed.name;
+    if (!entry) {
+      if (typeof this.onUnknown === "function") {
+        try {
+          await this.onUnknown(ctx);
+        } catch (err) {
+          if (typeof this.onError === "function") await this.onError(err, ctx);
+        }
+      } else {
+        const similar = this.suggestCommand(parsed.name);
+        if (similar) {
+          try {
+            await ctx.reply(
+              `Unknown command "${parsed.name}". Did you mean "${this.prefix}${similar}"?`
+            );
+          } catch {
+          }
+        }
+      }
+      return false;
+    }
+    if (entry.cooldown > 0) {
+      const now = Date.now();
+      const id = ctx.authorId ?? ctx.channelId ?? "unknown";
+      const cdKey = `${key}:${id}`;
+      const until = Number(await this.cooldownStore.get(cdKey)) || 0;
+      if (until > now) {
+        const wait = (until - now) / 1e3;
+        if (typeof this.onCooldown === "function") {
+          await this.onCooldown(ctx, wait);
+        } else {
+          try {
+            await ctx.reply(`Slow down \u2014 try again in ${Math.ceil(wait)}s.`);
+          } catch {
+          }
+        }
+        return true;
+      }
+      await this.cooldownStore.set(cdKey, now + entry.cooldown * 1e3, entry.cooldown * 1e3);
+    }
+    try {
+      await entry.fn(ctx);
+    } catch (err) {
+      if (typeof this.onError === "function") await this.onError(err, ctx);
+      else throw err;
+    }
+    return true;
+  }
+  /** Wire handler to one poller over given channels. Returns { poller, stop }. */
+  async attach(client, channelIds, pollOptions = {}) {
+    const poller = new MessagePoller(client, channelIds, pollOptions);
+    poller.on("message", (m) => {
+      this.handle(client, m).catch((err) => {
+        if (typeof this.onError === "function") this.onError(err, this.makeCtx(client, m));
+      });
+    });
+    await poller.start();
+    return { poller, stop: () => poller.stop() };
+  }
+  /**
+   * Render help text. `command` selects a detail view: description, usage,
+   * aliases and cooldown (`!help stats`). `prefix: true` (default) prepends
+   * the command prefix, `descriptions: true` (default) appends descriptions.
+   */
+  help(options = {}) {
+    const { prefix = true, descriptions = true, command = null } = options;
+    const pre = prefix === true ? this.prefix : prefix || "";
+    if (command) {
+      const key = this.resolve(command);
+      const entry = key ? this.commands.get(key) : null;
+      if (!entry) return `Unknown command "${command}". Try ${this.prefix}help.`;
+      const lines = [`${pre}${key}`];
+      if (entry.aliases.length) lines.push(`Aliases: ${entry.aliases.map((a) => `${pre}${a}`).join(", ")}`);
+      if (entry.description) lines.push(entry.description);
+      if (entry.usage) lines.push(`Usage: ${pre}${key} ${entry.usage}`);
+      if (entry.cooldown > 0) lines.push(`Cooldown: ${entry.cooldown}s`);
+      return lines.join("\n");
+    }
+    const names = [...this.commands.entries()].map(([n, e]) => {
+      let line = `${pre}${n}`;
+      if (descriptions && e.description) line += `: ${e.description}`;
+      return line;
+    });
+    return names.length ? `Commands:
+${names.join("\n")}` : "No commands registered.";
+  }
+  helpText() {
+    return this.help();
+  }
+};
+function createCommandHandler(options) {
+  return new CommandHandler(options);
+}
+
+// src/client.js
+var RavenClient = class {
+  constructor({ token, timeoutMs = 15e3, retryOn429 = true, ethanKey = null } = {}) {
+    assertToken(token);
+    this.token = token;
+    this.timeoutMs = timeoutMs;
+    this.retryOn429 = retryOn429;
+    this.ethanKey = ethanKey || null;
+    const ctx = {
+      request: (method, path2, { query, body } = {}) => ravenRequest({
+        token: this.token,
+        path: path2,
+        method,
+        query,
+        body,
+        timeoutMs: this.timeoutMs,
+        retryOn429: this.retryOn429
+      })
+    };
+    let ethanClient = null;
+    const ethanProxy = new Proxy(
+      {},
+      {
+        get: (_, prop) => {
+          if (typeof prop === "symbol" || prop === "then" || prop === "toJSON" || prop === "__ethanProxy") {
+            return prop === "__ethanProxy" ? true : void 0;
+          }
+          if (!ethanClient) {
+            if (!this.ethanKey) {
+              throw new Error(
+                "Ethan API key required (rve_...). Pass { ethanKey } to RavenClient or use EthanClient directly. Keys need an active EthanPlus/EthanPro plan."
+              );
+            }
+            ethanClient = withSuggestions(
+              new EthanClient({ key: this.ethanKey, timeoutMs: Math.max(this.timeoutMs, 3e4) }),
+              "bot.client.ethan"
+            );
+          }
+          const value = ethanClient[prop];
+          return typeof value === "function" ? value.bind(ethanClient) : value;
+        }
+      }
+    );
+    this.me = withSuggestions(new MeResource(ctx), "bot.client.me");
+    this.ethan = ethanProxy;
+    this.guilds = withSuggestions(new GuildsResource(ctx), "bot.client.guilds");
+    this.channels = withSuggestions(new ChannelsResource(ctx), "bot.client.channels");
+    this.messages = withSuggestions(new MessagesResource(ctx), "bot.client.messages");
+    this.roles = withSuggestions(new RolesResource(ctx), "bot.client.roles");
+    this.members = withSuggestions(new MembersResource(ctx), "bot.client.members");
+    this.dms = withSuggestions(new DmsResource(ctx), "bot.client.dms");
+    this.oauth = withSuggestions(new OAuthResource(ctx), "bot.client.oauth");
+    this.gateway = withSuggestions(new RavenGateway(this), "bot.client.gateway");
+    return withSuggestions(this, "bot.client");
+  }
+  /** Low-level request escape hatch (e.g. future endpoints). */
+  request(method, path2, opts) {
+    return ravenRequest({
+      token: this.token,
+      path: path2,
+      method,
+      query: opts?.query,
+      body: opts?.body,
+      timeoutMs: opts?.timeoutMs ?? this.timeoutMs,
+      retryOn429: opts?.retryOn429 ?? this.retryOn429
+    });
+  }
+  /**
+   * Poll one or more channels for new messages.
+   * @param {Function} callback async (message) => void
+   * @param {Object} opts { channelId | channelIds, pollInterval, limit, ignoreBots, selfAuthorId, signal }
+   * @returns {Promise<MessagePoller>} call .stop() to end
+   */
+  async onMessage(callback, opts = {}) {
+    const ids = opts.channelIds ?? opts.channelId ?? opts.channels;
+    if (!ids) throw new Error("onMessage requires opts.channelId (string or string[]).");
+    const poller = new MessagePoller(this, ids, {
+      pollInterval: opts.pollInterval,
+      limit: opts.limit,
+      emitHistory: opts.emitHistory ?? false,
+      ignoreBots: opts.ignoreBots ?? true,
+      selfAuthorId: opts.selfAuthorId ?? null,
+      signal: opts.signal ?? null,
+      onError: opts.onError ?? null
+    });
+    poller.on("message", (m) => {
+      Promise.resolve().then(() => callback(m)).catch((err) => poller.emit("error", err));
+    });
+    await poller.start();
+    return poller;
+  }
+  /** Discover all text channels of all installed guilds (helper for polling setups). */
+  async discoverTextChannels() {
+    const guilds = await this.guilds.list();
+    const out = [];
+    for (const g of guilds) {
+      const channels = await this.channels.list(g.id);
+      for (const c of channels) if (c.type === "text") out.push({ guild: g, channel: c });
+    }
+    return out;
+  }
+  createCommands(options) {
+    return new CommandHandler(options);
+  }
+};
+function createClient(options) {
+  return new RavenClient(options);
+}
+
+// src/bot.js
+var RESYNC_MS = 5 * 60 * 1e3;
+var RavenBot = class {
+  constructor({ token, prefix = "!", status = null, testGuild = null, testChannel = null, timeoutMs, retryOn429, log = true, debug = false, cooldownStore } = {}) {
+    this.client = new RavenClient({ token, ...timeoutMs ? { timeoutMs } : {}, ...retryOn429 !== void 0 ? { retryOn429 } : {} });
+    this.commands = new CommandHandler({ prefix, ...cooldownStore ? { cooldownStore } : {} });
+    this.commands.onError = (err, ctx) => this._reportError(ctx?.message ?? null, err, ctx);
+    this.status = status;
+    this.debug = debug || process.env.RAVEN_DEBUG === "1" || false;
+    this.testGuild = testGuild || process.env.RAVEN_TEST_GUILD || null;
+    this.testChannel = testChannel || process.env.RAVEN_TEST_CHANNEL || null;
+    this.testChannelId = null;
+    this.log = log === true ? console.log.bind(console) : log || (() => {
+    });
+    this.errors = { format: (err, opts) => formatError(err, opts), suggest };
+    this.started = false;
+    this._resyncTimer = null;
+    this._onMessage = null;
+    this._onSigint = null;
+    return withSuggestions(this, "bot");
+  }
+  _debug(...args) {
+    if (this.debug) console.log("[Raven]", ...args);
+  }
+  /** Register a prefix command. Chainable. */
+  command(name, fn, opts) {
+    this.commands.command(name, fn, opts);
+    return this;
+  }
+  /** Forward gateway events (message:new, ready, disconnect, guildCreate, ...). Chainable. */
+  on(event, fn) {
+    this.client.gateway.on(event, fn);
+    return this;
+  }
+  /** Forward once-listeners, e.g. `bot.once("ready", (info) => ...)`. Chainable. */
+  once(event, fn) {
+    this.client.gateway.once(event, fn);
+    return this;
+  }
+  /** Remove a forwarded listener. Chainable. */
+  off(event, fn) {
+    this.client.gateway.off(event, fn);
+    return this;
+  }
+  /** Connect, sync subscriptions, wire commands. Resolves with { bot, guilds, channels }. */
+  async start() {
+    if (this.started) return this.info();
+    this._debug("Connecting...");
+    const info = await this.client.gateway.connect();
+    this.started = true;
+    this._debug("Gateway connected");
+    this._debug(`Authenticated as ${info.bot?.username ?? "unknown"}`);
+    this._debug(`Loaded ${this.commands.commands.size} command(s)`);
+    this._onMessage = (m) => {
+      this.commands.handle(this.client, m).catch((err) => this._reportError(m, err));
+    };
+    this.client.gateway.on("message:new", this._onMessage);
+    let synced = { guilds: info.guilds || [], channels: 0 };
+    try {
+      synced = await this.client.gateway.sync();
+    } catch (err) {
+      this.log("sync failed:", err?.message || err);
+    }
+    this._debug(`Guilds: ${synced.guilds.length}`);
+    if (this.status !== void 0 && this.status !== null) {
+      try {
+        const res = await this.client.gateway.setStatus(this.status);
+        this.log(`status: ${res.status}${res.locked ? " (locked)" : ""}`);
+      } catch (err) {
+        this.log("status failed:", err?.message || err);
+      }
+    }
+    this._resyncTimer = setInterval(() => {
+      this.client.gateway.sync().catch(() => {
+      });
+    }, RESYNC_MS);
+    this._resyncTimer.unref?.();
+    await this._resolveTestChannel();
+    this._onSigint = () => this.stop();
+    process.on("SIGINT", this._onSigint);
+    this.log(`online as ${info.bot.username}: prefix "${this.commands.prefix}": ${synced.channels} channel(s) on ${synced.guilds.length} guild(s)`);
+    return { bot: info.bot, guilds: synced.guilds, channels: synced.channels };
+  }
+  /** Disconnect and clean up timers/listeners. */
+  stop() {
+    if (this._resyncTimer) {
+      clearInterval(this._resyncTimer);
+      this._resyncTimer = null;
+    }
+    if (this._onMessage) {
+      this.client.gateway.off("message:new", this._onMessage);
+      this._onMessage = null;
+    }
+    if (this._onSigint) {
+      process.off("SIGINT", this._onSigint);
+      this._onSigint = null;
+    }
+    this.client.gateway.disconnect();
+    this.started = false;
+    return this;
+  }
+  info() {
+    return { bot: this.client.gateway.bot, guilds: this.client.gateway.guilds };
+  }
+  /** Find the bug channel: testChannel wins, else #bot-test / #test / first text channel of testGuild. */
+  async _resolveTestChannel() {
+    this.testChannelId = null;
+    if (this.testChannel) {
+      this.testChannelId = this.testChannel;
+      this.log(`test area: bugs go to channel ${this.testChannelId}`);
+      return this.testChannelId;
+    }
+    if (!this.testGuild) return null;
+    try {
+      const channels = await this.client.channels.list(this.testGuild);
+      const texts = channels.filter((c) => c.type === "text");
+      const pick = texts.find((c) => c.name === "bot-test") || texts.find((c) => c.name === "test") || texts[0] || null;
+      if (pick) {
+        this.testChannelId = pick.id;
+        this.log(`test area: #${pick.name} on ${this.testGuild}: errors land here`);
+      } else {
+        this.log(`test area: no text channel found on ${this.testGuild}`);
+      }
+    } catch (err) {
+      this.log("test area failed:", err?.message || err);
+    }
+    return this.testChannelId;
+  }
+  /** Emit commandError, log when unhandled, post to the test channel (if set). Never throws. */
+  async _reportError(m, err, ctx = null) {
+    let handled = false;
+    try {
+      const gw = this.client.gateway;
+      if (typeof gw?.listenerCount === "function") {
+        handled = gw.listenerCount("commandError") > 0 || gw.listenerCount("*") > 0;
+      }
+      const c = ctx ?? this.commands.makeCtx(this.client, m ?? {});
+      gw.emit("commandError", err, c);
+    } catch {
+    }
+    if (!handled) {
+      try {
+        this.log(formatError(err));
+      } catch {
+      }
+    }
+    if (!this.testChannelId) return;
+    try {
+      const cmd = m?.content ? String(m.content).split(/\s+/)[0] : "?";
+      const pretty = formatError(err, { color: false });
+      await this.client.messages.send(this.testChannelId, `Error in ${cmd}:
+${pretty}`.slice(0, 1500));
+    } catch {
+    }
+  }
+};
+function createBot(options) {
+  return new RavenBot(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  BOT_STATUSES,
+  CHANNEL_TYPES,
+  CommandHandler,
+  DEFAULT_ADMIN_PERMS,
+  DEFAULT_BASE_URL,
+  DEFAULT_EVERYONE_PERMS,
+  ETHAN_KEY_PREFIX,
+  ETHAN_MESSAGE_MAX,
+  ETHAN_MODEL,
+  ETHAN_PERSONALITIES,
+  EthanClient,
+  GATEWAY_EVENTS,
+  GatewayNotAvailableError,
+  MemoryCooldownStore,
+  MessagePoller,
+  MissingScopeError,
+  NotFoundError,
+  NotInstalledError,
+  PERMISSIONS,
+  PERMISSION_MASK,
+  RateLimitedError,
+  RavenAPIError,
+  RavenAuthError,
+  RavenBot,
+  RavenClient,
+  RavenError,
+  RavenGateway,
+  RavenNotFoundError,
+  RavenPermissionError,
+  RavenRateLimitError,
+  RavenValidationError,
+  ValidationError,
+  assertChannelName,
+  assertChannelType,
+  assertEthanMessage,
+  assertPersonality,
+  assertRoleColor,
+  assertRoleName,
+  assertRolePermissions,
+  assertTemperature,
+  canAssignRole,
+  canManageRole,
+  canModerate,
+  createBot,
+  createClient,
+  createCommandHandler,
+  createEthanClient,
+  editDistance,
+  escapeContent,
+  formatError,
+  getHighestRole,
+  getMemberPermissions,
+  hasPermission,
+  invalidChoice,
+  isBotAuthorId,
+  markDiff,
+  missingArgument,
+  normalizeRole,
+  parseMentions,
+  sanitizeContent,
+  sortRoles,
+  suggest,
+  suggestAll,
+  toCamel,
+  unknownOption,
+  withSuggestions
+});