lunibee 0.3.1 → 0.3.3

package/dist/managers/index.js

@@ -1,4 +1,102 @@
 // @bun
+// packages/collection/src/redis.ts
+var PRELUDE = `
+local exp, lru, clock, ep = KEYS[1], KEYS[2], KEYS[3], ARGV[1]
+local t = redis.call('TIME')
+local now = tonumber(t[1]) * 1000 + math.floor(tonumber(t[2]) / 1000)
+local out = {}
+local function drop(m, reason)
+  local v = redis.call('GET', ep .. m)
+  redis.call('DEL', ep .. m)
+  redis.call('ZREM', exp, m)
+  redis.call('ZREM', lru, m)
+  if reason then
+    table.insert(out, m)
+    table.insert(out, v or false)
+    table.insert(out, reason)
+  end
+end
+local gone = redis.call('ZRANGEBYSCORE', exp, '-inf', now, 'LIMIT', 0, 1000)
+for _, m in ipairs(gone) do drop(m, 'expired') end
+local function touch(m) redis.call('ZADD', lru, redis.call('INCR', clock), m) end
+`;
+var SET_SCRIPT = `${PRELUDE}
+local m, payload, ttl, max, mode = ARGV[2], ARGV[3], tonumber(ARGV[4]), tonumber(ARGV[5]), ARGV[6]
+if mode == 'nx' then
+  local cur = redis.call('GET', ep .. m)
+  if cur then
+    touch(m)
+    table.insert(out, 1, cur)
+    return out
+  end
+end
+local env = ttl .. ':' .. payload
+if ttl > 0 then
+  -- The key outlives its logical expiry by a grace second, so the prune
+  -- that reports the expiry can still hand the value to onEvict.
+  redis.call('SET', ep .. m, env, 'PX', ttl + 1000)
+  redis.call('ZADD', exp, now + ttl, m)
+else
+  redis.call('SET', ep .. m, env)
+  redis.call('ZREM', exp, m)
+end
+touch(m)
+if max > 0 then
+  local n = redis.call('ZCARD', lru)
+  while n > max do
+    local popped = redis.call('ZPOPMIN', lru)
+    local victim = popped[1]
+    if victim == nil then break end
+    if victim ~= m then drop(victim, 'evicted') end
+    n = n - 1
+  end
+end
+table.insert(out, 1, false)
+return out
+`;
+var GET_SCRIPT = `${PRELUDE}
+local m, slide, mark = ARGV[2], ARGV[3], ARGV[4]
+local env = redis.call('GET', ep .. m)
+if not env then
+  redis.call('ZREM', exp, m)
+  redis.call('ZREM', lru, m)
+  table.insert(out, 1, false)
+  return out
+end
+if mark == '1' then touch(m) end
+if slide == '1' then
+  local ttl = tonumber(string.match(env, '^(%d+):'))
+  if ttl and ttl > 0 then
+    redis.call('PEXPIRE', ep .. m, ttl + 1000)
+    redis.call('ZADD', exp, now + ttl, m)
+  end
+end
+table.insert(out, 1, env)
+return out
+`;
+var DELETE_SCRIPT = `${PRELUDE}
+local m = ARGV[2]
+local existed = redis.call('EXISTS', ep .. m)
+drop(m, nil)
+table.insert(out, 1, existed)
+return out
+`;
+var LIST_SCRIPT = `${PRELUDE}
+local what = ARGV[2]
+if what == 'clear' then
+  local n = 0
+  repeat
+    local batch = redis.call('ZRANGE', lru, 0, 999)
+    for _, m in ipairs(batch) do drop(m, nil) end
+    n = n + #batch
+  until #batch == 0
+  redis.call('DEL', exp, lru, clock)
+  return {n}
+end
+local result = what == 'size' and redis.call('ZCARD', lru) or redis.call('ZRANGE', lru, 0, -1)
+return {result, unpack(out)}
+`;
+
 // packages/collection/src/index.ts
 function newPolicy(options = {}) {
   return {
@@ -56,21 +154,35 @@ class Collection extends Map {
         this.set(key, value);
   }
   set(key, value, ttl) {
-    if (ttl === undefined && this.#policy === undefined)
-      return super.set(key, value);
-    assertTTL(ttl);
-    let window = ttl ?? this.#policy?.ttl;
-    const jitter = this.#policy?.jitter ?? 0;
-    if (window !== undefined && jitter > 0)
-      window = Math.max(1, window * (1 - jitter * Math.random()));
-    if (window !== undefined)
-      this.#policy ??= newPolicy();
-    if (!this.#policy)
+    let policy = this.#policy;
+    if (ttl === undefined && policy === undefined)
       return super.set(key, value);
-    const before = super.size;
+    if (ttl !== undefined)
+      assertTTL(ttl);
+    let window = ttl ?? policy?.ttl;
+    if (window !== undefined && policy !== undefined && policy.jitter > 0)
+      window = Math.max(1, window * (1 - policy.jitter * Math.random()));
+    if (policy === undefined) {
+      if (window === undefined)
+        return super.set(key, value);
+      policy = this.#policy = newPolicy();
+    }
+    const entry = policy.entries.get(key);
     super.set(key, value);
-    this.#track(key, value, window, super.size !== before);
-    this.#enforceCap();
+    if (entry !== undefined && window !== undefined && entry.window !== 0) {
+      const deadline = Date.now() + window;
+      if (deadline >= entry.filed) {
+        entry.value = value;
+        entry.deadline = deadline;
+        entry.window = window;
+        if (entry.inLru)
+          this.#promote(policy, entry);
+        return this;
+      }
+    }
+    this.#track(key, value, window, entry);
+    if (policy.maxSize !== undefined && policy.lruSize > policy.maxSize)
+      this.#enforceCap();
     return this;
   }
   setWithoutTTL(key, value) {
@@ -226,10 +338,10 @@ class Collection extends Map {
       this.#unlink(policy, entry);
     policy.entries.delete(key);
   }
-  #track(key, value, window, isNew) {
+  #track(key, value, window, existing) {
     const policy = this.#policy;
     const lru = policy.maxSize !== undefined;
-    let entry = isNew ? undefined : policy.entries.get(key);
+    let entry = existing;
     if (entry)
       entry.value = value;
     if (window === undefined) {
@@ -361,11 +473,20 @@ class Collection extends Map {
     while (policy.lruSize > max) {
       const oldest = policy.oldest;
       const value = policy.onEvict ? super.get(oldest.key) : undefined;
-      this.#unlink(policy, oldest);
+      const next = oldest.newer;
+      policy.oldest = next;
+      if (next)
+        next.older = undefined;
+      else
+        policy.newest = undefined;
+      oldest.newer = undefined;
+      oldest.inLru = false;
+      policy.lruSize--;
       policy.entries.delete(oldest.key);
       super.delete(oldest.key);
       policy.evicted++;
-      this.#notify(oldest.key, value, "evicted");
+      if (policy.onEvict)
+        this.#notify(oldest.key, value, "evicted");
     }
   }
   #nextDeadline() {
@@ -780,13 +901,25 @@ class Collection extends Map {
 }
 
 // packages/managers/src/base.ts
+function assignFields(into, from) {
+  const target = into;
+  const source = from;
+  for (const key of Object.keys(source))
+    target[key] = source[key];
+  return into;
+}
 function splitReason(options) {
   const { reason, ...payload } = options;
   return [payload, reason];
 }
 
 class Manager {
-  cache = new Collection;
+  cache;
+  #bounded;
+  constructor(maxSize) {
+    this.#bounded = maxSize !== undefined;
+    this.cache = new Collection(null, { maxSize });
+  }
   get(id) {
     return this.cache.get(id);
   }
@@ -822,7 +955,10 @@ class Manager {
   }
   set(id, value) {
     this.#markDirty(id);
-    this.cache.setWithoutTTL(id, value);
+    if (this.#bounded)
+      this.cache.set(id, value);
+    else
+      this.cache.setWithoutTTL(id, value);
     return this;
   }
   delete(id) {
@@ -852,8 +988,8 @@ class Manager {
 class ResourceManager extends Manager {
   #fetcher;
   #key;
-  constructor(fetcher, key) {
-    super();
+  constructor(fetcher, key, maxSize) {
+    super(maxSize);
     if (typeof fetcher !== "function" || typeof key !== "function")
       throw new TypeError("ResourceManager requires fetcher and key functions.");
     this.#fetcher = fetcher;
@@ -863,7 +999,7 @@ class ResourceManager extends Manager {
     return this.get(id) ?? this.fetch(id);
   }
   fetch(id) {
-    return this.fetchOnce(id, () => this.#fetcher(id));
+    return this.fetchOnce(id, () => this.#fetcher(id), (value) => this.upsert(value));
   }
   async fetchMany(ids) {
     return Promise.all([...ids].map((id) => this.resolve(id)));
@@ -872,7 +1008,7 @@ class ResourceManager extends Manager {
     const key = this.#key(resource);
     const existing = this.get(key);
     if (existing !== undefined && existing !== resource && typeof existing === "object" && existing !== null) {
-      Object.assign(existing, resource);
+      assignFields(existing, resource);
       this.set(key, existing);
       return existing;
     }
@@ -886,7 +1022,7 @@ class ResourceManager extends Manager {
 // packages/rest/package.json
 var package_default = {
   name: "@lunibee/rest",
-  version: "0.3.1",
+  version: "0.3.3",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -996,6 +1132,139 @@ function snowflake(value, field) {
     throw new TypeError(`${field} must be a valid Discord snowflake.`);
   return value;
 }
+// packages/rest/src/redis.ts
+var LUA_PRELUDE = `
+local function now_ms()
+  local t = redis.call('TIME')
+  return tonumber(t[1]) * 1000 + math.floor(tonumber(t[2]) / 1000)
+end
+local function load(key)
+  local raw = redis.call('GET', key)
+  if not raw then return nil end
+  local ok, s = pcall(cjson.decode, raw)
+  if ok and type(s) == 'table' and type(s.resetAt) == 'number'
+    and type(s.remaining) == 'number' then return s end
+  return nil
+end
+local function save(key, s, now, linger)
+  local ttl = math.max(1, math.ceil(s.resetAt - now)) + linger
+  redis.call('SET', key, cjson.encode(s), 'PX', ttl)
+end
+`;
+var RESERVE_SCRIPT = `${LUA_PRELUDE}
+local now = now_ms()
+local glimit, gwindow = tonumber(ARGV[4]) or 0, tonumber(ARGV[5]) or 1000
+if #KEYS > 1 then
+  local g = tonumber(redis.call('GET', KEYS[2]) or '0') or 0
+  if g > now then return {0, math.ceil(g - now), 'global'} end
+end
+if #KEYS < 3 then glimit = 0 end
+-- A sliding log of send times: at most glimit in any gwindow span.
+if glimit > 0 then
+  redis.call('ZREMRANGEBYSCORE', KEYS[3], '-inf', now - gwindow)
+  if redis.call('ZCARD', KEYS[3]) >= glimit then
+    local oldest = redis.call('ZRANGE', KEYS[3], 0, 0, 'WITHSCORES')
+    return {0, math.max(1, tonumber(oldest[2]) + gwindow - now + 1), 'global'}
+  end
+end
+local function count()
+  if glimit > 0 then
+    local seq = redis.call('ZCARD', KEYS[3])
+    redis.call('ZADD', KEYS[3], now, now .. ':' .. seq)
+    redis.call('PEXPIRE', KEYS[3], gwindow + 1000)
+  end
+end
+local probe, poll, linger = tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3])
+local s = load(KEYS[1])
+if s and s.resetAt > now then
+  if s.remaining > 0 then
+    s.remaining = s.remaining - 1
+    save(KEYS[1], s, now, linger)
+    count()
+    return {1, s.resetAt, 1}
+  end
+  local wait = s.resetAt - now
+  if s.provisional then wait = math.min(wait, poll) end
+  local reason = 'bucket'
+  if s.probe then reason = 'probe' end
+  return {0, math.ceil(wait), reason}
+end
+local resetAt = now + probe
+if s and type(s.limit) == 'number' and s.limit > 0 then
+  save(KEYS[1], {remaining = s.limit - 1, resetAt = resetAt, limit = s.limit, provisional = true}, now, linger)
+  count()
+  return {1, resetAt, 1}
+end
+save(KEYS[1], {remaining = 0, resetAt = resetAt, provisional = true, probe = true}, now, 0)
+count()
+return {1, resetAt, 0}
+`;
+var RECONCILE_SCRIPT = `${LUA_PRELUDE}
+local now = now_ms()
+local rem, after, limit = tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3])
+local win, retry, linger = tonumber(ARGV[4]), tonumber(ARGV[5]), tonumber(ARGV[6])
+local tol = 50
+local incoming = nil
+if after then incoming = math.ceil(now + after) end
+local s = load(KEYS[1])
+local n
+if s and s.resetAt > now and not s.probe then
+  n = s
+  local stale = win and n.window and win < n.window - tol
+  if not stale then
+    if rem then n.remaining = math.min(n.remaining, rem) end
+    if incoming then
+      local newer = win and n.window and win > n.window + tol
+      if n.provisional or newer then n.resetAt = incoming
+      else n.resetAt = math.max(n.resetAt, incoming) end
+      n.provisional = nil
+    end
+    if win then n.window = math.max(n.window or 0, win) end
+  end
+else
+  if not rem and not retry then
+    if s and s.probe then redis.call('DEL', KEYS[1]) end
+    return 0
+  end
+  n = {remaining = rem or 0, resetAt = incoming or now}
+  if s and type(s.limit) == 'number' then n.limit = s.limit end
+  if win then n.window = win end
+end
+if limit and limit > 0 then n.limit = limit end
+if retry then
+  n.remaining = 0
+  n.resetAt = math.max(n.resetAt, math.ceil(now + retry))
+  n.provisional = nil
+end
+save(KEYS[1], n, now, linger)
+return 1
+`;
+var EXTEND_GLOBAL_SCRIPT = `${LUA_PRELUDE}
+local now = now_ms()
+local target = math.ceil(now + tonumber(ARGV[1]))
+local cur = tonumber(redis.call('GET', KEYS[1]) or '0') or 0
+if target > cur then
+  redis.call('SET', KEYS[1], tostring(target), 'PX', math.max(1, target - now))
+  return target - now
+end
+return math.max(0, cur - now)
+`;
+var RELEASE_SCRIPT = `${LUA_PRELUDE}
+local s = load(KEYS[1])
+if not s or s.resetAt ~= tonumber(ARGV[1]) then return 0 end
+if s.probe then
+  redis.call('DEL', KEYS[1])
+  return 1
+end
+if ARGV[2] == '1' then
+  local cap = s.remaining + 1
+  if type(s.limit) == 'number' then cap = math.min(cap, s.limit) end
+  s.remaining = cap
+  redis.call('SET', KEYS[1], cjson.encode(s), 'KEEPTTL')
+  return 1
+end
+return 0
+`;
 
 // packages/rest/src/index.ts
 var LIBRARY_VERSION = package_default.version;
@@ -1008,7 +1277,8 @@ var REQUEST_DATA_KEYS = new Set([
   "headers",
   "reason",
   "auth",
-  "signal"
+  "signal",
+  "maxQueueWait"
 ]);
 
 // packages/types/src/channel-kind.ts
@@ -1157,8 +1427,9 @@ class Channel extends BaseStructure {
   rateLimitPerUser;
   position;
   permissionOverwrites;
+  partial;
   #context;
-  constructor(data, context) {
+  constructor(data, context, options) {
     super(data.id);
     if (!Number.isInteger(data.type) || data.type < 0)
       throw new RangeError("A Discord channel requires a valid channel type.");
@@ -1171,6 +1442,7 @@ class Channel extends BaseStructure {
     this.rateLimitPerUser = data.rate_limit_per_user;
     this.position = data.position;
     this.permissionOverwrites = (data.permission_overwrites ?? []).map((overwrite) => ({ ...overwrite }));
+    this.partial = options?.partial ?? false;
     this.#context = context;
   }
   send(options) {
@@ -1361,7 +1633,7 @@ class Guild extends BaseStructure {
   }
 }
 
-// packages/core/src/permissions.ts
+// packages/structures/src/permissions.ts
 var Permission = {
   createInstantInvite: 1n << 0n,
   kickMembers: 1n << 1n,
@@ -1643,6 +1915,15 @@ class PermissionSet {
   get useExternalApps() {
     return (this.bitfield & Permission.useExternalApps) === Permission.useExternalApps;
   }
+  get setVoiceChannelStatus() {
+    return (this.bitfield & Permission.setVoiceChannelStatus) === Permission.setVoiceChannelStatus;
+  }
+  get pinMessages() {
+    return (this.bitfield & Permission.pinMessages) === Permission.pinMessages;
+  }
+  get bypassSlowmode() {
+    return (this.bitfield & Permission.bypassSlowmode) === Permission.bypassSlowmode;
+  }
   has(...permissions) {
     if (permissions.length === 1) {
       const p = permissions[0];
@@ -1745,60 +2026,7 @@ class PermissionsBitField extends PermissionSet {
   }
 }
 var ALL_PERMISSIONS = Object.values(Permission).reduce((bits, bit) => bits | bit, 0n);
-// packages/builders/src/components.ts
-var IS_COMPONENTS_V2 = 1 << 15;
-// packages/builders/src/commands.ts
-var MAX_SAFE = Number.MAX_SAFE_INTEGER;
-// packages/utils/src/args.ts
-var TRUE_WORDS = new Set([
-  "true",
-  "yes",
-  "y",
-  "on",
-  "1",
-  "enable",
-  "enabled"
-]);
-var FALSE_WORDS = new Set([
-  "false",
-  "no",
-  "n",
-  "off",
-  "0",
-  "disable",
-  "disabled"
-]);
-// packages/ws/src/close-codes.ts
-var GatewayCloseCodes = {
-  UnknownError: 4000,
-  UnknownOpcode: 4001,
-  DecodeError: 4002,
-  NotAuthenticated: 4003,
-  AuthenticationFailed: 4004,
-  AlreadyAuthenticated: 4005,
-  InvalidSeq: 4007,
-  RateLimited: 4008,
-  SessionTimedOut: 4009,
-  InvalidShard: 4010,
-  ShardingRequired: 4011,
-  InvalidAPIVersion: 4012,
-  InvalidIntents: 4013,
-  DisallowedIntents: 4014
-};
 
-// packages/ws/src/reconnect.ts
-var FATAL_CLOSE_CODES = [
-  GatewayCloseCodes.AuthenticationFailed,
-  GatewayCloseCodes.InvalidShard,
-  GatewayCloseCodes.ShardingRequired,
-  GatewayCloseCodes.InvalidAPIVersion,
-  GatewayCloseCodes.InvalidIntents,
-  GatewayCloseCodes.DisallowedIntents
-];
-var IDENTIFY_CLOSE_CODES = [
-  GatewayCloseCodes.InvalidSeq,
-  GatewayCloseCodes.SessionTimedOut
-];
 // packages/structures/src/resources.ts
 function toDateOrNull(value) {
   if (!value)
@@ -1954,7 +2182,7 @@ class TextChannel extends Channel {
     return `<#${this.id}>`;
   }
 }
-class Emoji2 extends BaseStructure {
+class Emoji extends BaseStructure {
   name;
   roleIds;
   user;
@@ -2302,7 +2530,7 @@ class Message extends BaseStructure {
       user: data.member.user ?? data.author,
       guild_id: data.guild_id
     }, context) : null;
-    this.channel = new Channel({ id: data.channel_id, type: 0, guild_id: data.guild_id }, context);
+    this.channel = context?.cachedChannel?.(data.channel_id) ?? new Channel({ id: data.channel_id, type: 0, guild_id: data.guild_id }, context, { partial: true });
   }
   get embedsSuppressed() {
     return (this.flags & 4) !== 0;
@@ -2430,18 +2658,41 @@ class Message extends BaseStructure {
 
 // packages/managers/src/message.ts
 function toAttachments(files) {
-  return files.map((file) => ({
+  return files.map((file) => ("toBuffer" in file) ? { name: file.name, data: file.toBuffer() } : {
     name: file.name,
     data: typeof file.data === "string" ? new TextEncoder().encode(file.data) : file.data,
     contentType: file.contentType
-  }));
+  });
+}
+function assertAllowedMentions(mentions) {
+  const parse = mentions.parse ?? [];
+  for (const kind of parse)
+    if (!["roles", "users", "everyone"].includes(kind))
+      throw new TypeError(`allowed_mentions.parse has unknown value "${String(kind)}".`);
+  for (const [kind, list] of [
+    ["users", mentions.users],
+    ["roles", mentions.roles]
+  ]) {
+    if (list === undefined)
+      continue;
+    if (!Array.isArray(list) || list.some((id) => typeof id !== "string"))
+      throw new TypeError(`allowed_mentions.${kind} must be an array of ID strings.`);
+    if (list.length > 100)
+      throw new RangeError(`allowed_mentions.${kind} holds at most 100 IDs.`);
+    if (list.length > 0 && parse.includes(kind))
+      throw new TypeError(`allowed_mentions cannot list ${kind} by ID and also parse "${kind}".`);
+  }
 }
 function toRequest(options, allowedMentions) {
   const { files, ...body } = options;
   if (allowedMentions !== undefined && body.allowed_mentions === undefined)
     body.allowed_mentions = allowedMentions;
+  if (body.allowed_mentions)
+    assertAllowedMentions(body.allowed_mentions);
   if (!files?.length)
     return body;
+  if (body.attachments === undefined && files.some((f) => f.description))
+    body.attachments = files.map((file, id) => file.description ? { id, description: file.description } : { id });
   return {
     body,
     files: toAttachments(files)
@@ -2486,7 +2737,7 @@ class MessageManager {
     const existing = this.cache.peek(data.id);
     const message = new Message(data, this.#context);
     if (existing) {
-      Object.assign(existing, message);
+      assignFields(existing, message);
       return existing;
     }
     if (this.#caching)
@@ -2503,12 +2754,14 @@ class ThreadManager {
   #rest;
   #context;
   #channelId;
-  constructor(rest, context, channelId) {
+  #allowedMentions;
+  constructor(rest, context, channelId, allowedMentions) {
     if (!channelId)
       throw new TypeError("Channel ID is required.");
     this.#rest = rest;
     this.#context = context;
     this.#channelId = channelId;
+    this.#allowedMentions = allowedMentions;
   }
   async createFromMessage(messageId, options) {
     const data = await this.#rest.post(Routes.messageThread(this.#channelId, messageId), {
@@ -2530,14 +2783,17 @@ class ThreadManager {
   }
   async createForumPost(options) {
     const { message, appliedTags, reason, ...thread } = options;
-    const { files, ...content } = message;
+    const request = toRequest(message, this.#allowedMentions);
+    const withFiles = "body" in request && "files" in request;
+    const content = withFiles ? request.body : request;
+    const files = withFiles ? request.files : undefined;
     const data = await this.#rest.post(Routes.channelThreads(this.#channelId), {
       name: thread.name,
       auto_archive_duration: thread.autoArchiveDuration,
       rate_limit_per_user: thread.rateLimitPerUser,
       applied_tags: appliedTags,
       message: content
-    }, { files: files?.length ? toAttachments(files) : undefined, reason });
+    }, { files, reason });
     return createChannel(data, this.#context);
   }
   async fetchArchived(scope, options = {}) {
@@ -2631,7 +2887,7 @@ class EmojiManager extends Manager {
     this.#guildId = guildId;
   }
   fetch(emojiId) {
-    return this.fetchOnce(emojiId, async () => new Emoji2(await this.#rest.get(Routes.guildEmoji(this.#guildId, emojiId))), (emoji) => this.#merge(emojiId, emoji));
+    return this.fetchOnce(emojiId, async () => new Emoji(await this.#rest.get(Routes.guildEmoji(this.#guildId, emojiId))), (emoji) => this.#merge(emojiId, emoji));
   }
   async fetchAll() {
     const data = await this.#rest.get(Routes.guildEmoji(this.#guildId));
@@ -2653,12 +2909,12 @@ class EmojiManager extends Manager {
   }
   upsert(data) {
     const key = data.id != null ? data.id : `unicode:${data.name ?? ""}`;
-    return this.#merge(key, new Emoji2(data));
+    return this.#merge(key, new Emoji(data));
   }
   #merge(key, emoji) {
     const existing = this.get(key);
     if (existing) {
-      Object.assign(existing, emoji);
+      assignFields(existing, emoji);
       return existing;
     }
     this.set(key, emoji);
@@ -2871,8 +3127,8 @@ class GuildMemberManager extends ResourceManager {
   guildId;
   constructor(guildId, rest, context = () => {
     return;
-  }) {
-    super((id) => rest.get(Routes.guildMember(guildId, id)).then((data) => new GuildMember({ ...data, guild_id: guildId }, context())), (member) => member.user.id);
+  }, maxSize) {
+    super((id) => rest.get(Routes.guildMember(guildId, id)).then((data) => new GuildMember({ ...data, guild_id: guildId }, context())), (member) => member.user.id, maxSize);
     this.guildId = guildId;
     this.#rest = rest;
     this.#context = context;
@@ -3202,9 +3458,11 @@ class GuildManager extends ResourceManager {
       map.set(guildId, manager = create());
     return manager;
   }
-  constructor(rest) {
+  #maxMembers;
+  constructor(rest, options = {}) {
     super(async (id) => new Guild(await rest.get(Routes.guild(id))), (guild) => guild.id);
     this.#rest = rest;
+    this.#maxMembers = options.maxMembers;
   }
   bans(guildId) {
     let manager = this.#bans.get(guildId);
@@ -3221,7 +3479,7 @@ class GuildManager extends ResourceManager {
   members(guildId) {
     let manager = this.#members.get(guildId);
     if (!manager)
-      this.#members.set(guildId, manager = new GuildMemberManager(guildId, this.#rest, () => this.#context));
+      this.#members.set(guildId, manager = new GuildMemberManager(guildId, this.#rest, () => this.#context, this.#maxMembers));
     return manager;
   }
   roles(guildId) {
@@ -3265,9 +3523,13 @@ class GuildManager extends ResourceManager {
     const existing = this.get(guild.id);
     if (!existing)
       return this.upsert(guild);
-    for (const [key, value] of Object.entries(guild))
+    const from = guild;
+    const into = existing;
+    for (const key of Object.keys(from)) {
+      const value = from[key];
       if (value !== undefined)
-        existing[key] = value;
+        into[key] = value;
+    }
     return existing;
   }
   delete(id) {
@@ -3435,6 +3697,10 @@ var AuditLogEvent = {
   AutoModerationBlockMessage: 143
 };
 // packages/managers/src/application.ts
+function commandPayload(command) {
+  return "toJSON" in command && typeof command.toJSON === "function" ? command.toJSON() : command;
+}
+
 class ApplicationCommandManager {
   #rest;
   #applicationId;
@@ -3446,13 +3712,13 @@ class ApplicationCommandManager {
     return this.#rest.get(Routes.applicationCommands(this.#applicationId));
   }
   create(data) {
-    return this.#rest.post(Routes.applicationCommands(this.#applicationId), data);
+    return this.#rest.post(Routes.applicationCommands(this.#applicationId), commandPayload(data));
   }
   set(commands) {
-    return this.#rest.put(Routes.applicationCommands(this.#applicationId), commands);
+    return this.#rest.put(Routes.applicationCommands(this.#applicationId), commands.map(commandPayload));
   }
   edit(commandId, data) {
-    return this.#rest.patch(Routes.applicationCommand(this.#applicationId, commandId), data);
+    return this.#rest.patch(Routes.applicationCommand(this.#applicationId, commandId), commandPayload(data));
   }
   async delete(commandId) {
     await this.#rest.delete(Routes.applicationCommand(this.#applicationId, commandId));
@@ -3461,13 +3727,13 @@ class ApplicationCommandManager {
     return this.#rest.get(Routes.guildApplicationCommands(this.#applicationId, guildId));
   }
   createGuild(guildId, data) {
-    return this.#rest.post(Routes.guildApplicationCommands(this.#applicationId, guildId), data);
+    return this.#rest.post(Routes.guildApplicationCommands(this.#applicationId, guildId), commandPayload(data));
   }
   setGuild(guildId, commands) {
-    return this.#rest.put(Routes.guildApplicationCommands(this.#applicationId, guildId), commands);
+    return this.#rest.put(Routes.guildApplicationCommands(this.#applicationId, guildId), commands.map(commandPayload));
   }
   editGuild(guildId, commandId, data) {
-    return this.#rest.patch(Routes.guildApplicationCommand(this.#applicationId, guildId, commandId), data);
+    return this.#rest.patch(Routes.guildApplicationCommand(this.#applicationId, guildId, commandId), commandPayload(data));
   }
   async deleteGuild(guildId, commandId) {
     await this.#rest.delete(Routes.guildApplicationCommand(this.#applicationId, guildId, commandId));
@@ -3515,10 +3781,13 @@ class ChannelManager extends Manager {
     return manager;
   }
   permissionOverwrites(channelId) {
-    return new PermissionOverwriteManager(this.#rest, channelId, () => this.get(channelId)?.permissionOverwrites);
+    return new PermissionOverwriteManager(this.#rest, channelId, () => {
+      const channel = this.get(channelId);
+      return channel && !channel.partial ? channel.permissionOverwrites : undefined;
+    });
   }
   threads(channelId) {
-    return new ThreadManager(this.#rest, this.#context, channelId);
+    return new ThreadManager(this.#rest, this.#context, channelId, this.#allowedMentions);
   }
   fetch(channelId) {
     return this.fetchOnce(channelId, async () => createChannel(await this.#rest.get(Routes.channel(channelId)), this.#context), (channel) => this.#merge(channel));
@@ -3532,7 +3801,7 @@ class ChannelManager extends Manager {
   #merge(channel) {
     const existing = this.get(channel.id);
     if (existing && existing.type === channel.type) {
-      Object.assign(existing, channel);
+      assignFields(existing, channel);
       return existing;
     }
     this.set(channel.id, channel);
@@ -3542,9 +3811,14 @@ class ChannelManager extends Manager {
     return this.set(channel.id, channel);
   }
   deleteGuildChannels(guildId) {
+    const ids = [];
+    this.cache.forEach((channel, id) => {
+      if (channel.guildId === guildId)
+        ids.push(id);
+    });
     let removed = 0;
-    for (const channel of this.values())
-      if (channel.guildId === guildId && this.delete(channel.id))
+    for (const id of ids)
+      if (this.delete(id))
         removed++;
     return removed;
   }
@@ -3785,4 +4059,4 @@ export {
   toRequest
 };
 
-//# debugId=61ED1928FE071E3964756E2164756E21
+//# debugId=2CD7EF31353EB8CE64756E2164756E21