@wolfstar/plugin-gateway 0.8.0 → 0.9.0-next-20261002081721

package/dist/esm/index.js

@@ -1,12 +1,13 @@
 import { Client, Listener, container } from "@wolfstar/http-framework";
 import { CloseCodes, DefaultWebSocketManagerOptions, WebSocketManager, WebSocketShardEvents, WebSocketShardStatus } from "@discordjs/ws";
 import { Client as Client$1 } from "@discordjs/core";
-import { applyGatewayDispatch, autoModerationRuleKey, banKey, createCache, emojiKey, integrationKey, inviteKey, isIterableCache, memberKey, mergeValues, messageKey, presenceKey, roleKey, scheduledEventKey, soundboardSoundKey, stageInstanceKey, stickerKey, threadMemberKey, voiceStateKey } from "@wolfstar/plugin-cache";
+import { MemoryEntityCache, applyGatewayDispatch, autoModerationRuleKey, banKey, createCache, emojiKey, integrationKey, inviteKey, isIterableCache, memberKey, messageKey, presenceKey, roleKey, scheduledEventKey, soundboardSoundKey, stageInstanceKey, stickerKey, threadMemberKey, voiceStateKey } from "@wolfstar/plugin-cache";
 import { ActivityType, ApplicationFlags, AuditLogEvent, ButtonStyle, ChannelType, ComponentType, FormattingPatterns, GatewayDispatchEvents, GatewayIntentBits, GatewayOpcodes, GuildFeature, GuildMemberFlags, GuildPremiumTier, GuildScheduledEventStatus, GuildSystemChannelFlags, GuildWidgetStyle, InviteType, MessageFlags, MessageReferenceType, MessageType, OverwriteType, PermissionFlagsBits, PresenceUpdateStatus, RoleFlags, RouteBases, Routes, SeparatorSpacingSize, StickerFormatType, UserFlags, WebhookType } from "discord-api-types/v10";
 import { ActionRowComponent, Activity as Activity$1, ActivityFlagsBitField as ActivityFlagsBitField$1, AnnouncementChannel as AnnouncementChannel$1, AnnouncementThreadChannel as AnnouncementThreadChannel$1, Attachment as Attachment$1, AttachmentFlagsBitField as AttachmentFlagsBitField$1, AutoModerationRule as AutoModerationRule$1, BitField, BitField as BitField$1, CategoryChannel as CategoryChannel$1, Channel as Channel$1, ChannelFlagsBitField as ChannelFlagsBitField$1, ChannelSelectMenuComponent as ChannelSelectMenuComponent$1, Component as Component$1, ContainerComponent as ContainerComponent$1, DMChannel as DMChannel$1, Embed as Embed$1, Emoji as Emoji$1, FileComponent as FileComponent$1, FileUploadComponent as FileUploadComponent$1, ForumChannel as ForumChannel$1, GroupDMChannel as GroupDMChannel$1, InteractiveButtonComponent as InteractiveButtonComponent$1, Invite, LinkButtonComponent as LinkButtonComponent$1, MediaChannel as MediaChannel$1, MediaGalleryComponent as MediaGalleryComponent$1, MediaGalleryItem as MediaGalleryItem$1, MentionableSelectMenuComponent as MentionableSelectMenuComponent$1, Message as Message$1, MessageFlagsBitField as MessageFlagsBitField$1, PermissionsBitField, Poll as Poll$1, PollAnswer as PollAnswer$1, PremiumButtonComponent as PremiumButtonComponent$1, Presence as Presence$1, PrivateThreadChannel as PrivateThreadChannel$1, PublicThreadChannel as PublicThreadChannel$1, Reaction, RoleSelectMenuComponent as RoleSelectMenuComponent$1, SectionComponent as SectionComponent$1, SeparatorComponent as SeparatorComponent$1, SoundboardSound as SoundboardSound$1, StageChannel as StageChannel$1, StageInstance as StageInstance$1, Sticker as Sticker$1, StickerPack as StickerPack$1, StringSelectMenuComponent as StringSelectMenuComponent$1, Structure as Structure$1, TextChannel as TextChannel$1, TextDisplayComponent as TextDisplayComponent$1, TextInputComponent as TextInputComponent$1, ThumbnailComponent as ThumbnailComponent$1, UnfurledMediaItem as UnfurledMediaItem$1, User as User$1, UserSelectMenuComponent as UserSelectMenuComponent$1, VoiceChannel as VoiceChannel$1, VoiceState as VoiceState$1, Webhook as Webhook$1 } from "@discordjs/structures";
 import { CDN, DiscordAPIError } from "@discordjs/rest";
 import { basename as basename$1, parse, resolve } from "node:path";
 import { readFile, stat } from "node:fs/promises";
+import { Collection } from "@discordjs/collection";
 import { randomBytes } from "node:crypto";
 
 //#region src/EventGatewayListener.ts
@@ -59,16 +60,19 @@ var EventGatewayListener = class extends Listener {
 */
 const GatewayErrorMessages = {
 	ClientSessionStoreConflict: "sessionStore replaces gateway.retrieveSessionInfo and gateway.updateSessionInfo, pass one or the other",
+	ClientCacheConflict: "cacheConstructor and cacheOptions cannot be combined with cache or makeCache, pass one or the other",
 	ClientNotConstructed: "No GatewayClient has been constructed yet",
 	DispatchHandlerConflict: (event) => `Dispatch event "${event}" is registered in both DispatchHandlers and MultiDispatchHandlers`,
 	DispatchTimeout: (type, shardId, partition, timeout) => `Processing ${type} on shard ${shardId} (${partition ?? "barrier"}) took longer than ${timeout}ms`,
 	SessionStoreFailed: (operation, shardId) => `Cannot ${operation === "get" ? "read" : "write"} the session of shard ${shardId} in the session store`,
 	SessionStoreTimeout: (timeout) => `Timed out after ${timeout}ms`,
-	CacheAsynchronous: (entity) => `The ${entity} cache is asynchronous, use get instead of cached`,
-	CacheRelationsAsynchronous: (entity) => `The relations of the ${entity} cache are read from an asynchronous cache, use get instead of cached`,
+	CacheAsynchronous: (entity) => `The ${entity} cache is asynchronous, await cache.get instead`,
+	CacheConstructorAsynchronous: (entity) => `The ${entity} structures resolve relations from an asynchronous cache, which a cache of instances cannot await`,
 	CacheNotIterable: (entity) => `The ${entity} cache cannot enumerate its entries (it has no keys/values/entries)`,
 	CacheKeyUnresolvable: (entity, reason) => `Cannot key a ${entity} ${reason}`,
 	IdUnresolvable: "Cannot resolve an ID from a structure without one",
+	InvalidType: (name, expected, an = false) => `Supplied ${name} is not a${an ? "n" : ""} ${expected}.`,
+	InvalidElement: (type, name, element) => `Supplied ${type} ${name} includes an invalid element: ${String(element)}`,
 	ChannelGuildUnknown: (channelId) => `Channel ${channelId} has no known guild`,
 	ChannelTypeChanged: (channelId, from, to) => `Channel ${channelId} changed type from ${from} to ${to}`,
 	ChannelLockPermissionsConflict: "Pass either lockPermissions or permissionOverwrites, not both",
@@ -88,6 +92,7 @@ const GatewayErrorMessages = {
 	GuildMembersRateLimited: (guildId, nonce, retryAfter) => `Requesting the members of guild ${guildId} (${nonce}) is rate limited, retry after ${retryAfter}ms`,
 	PresenceNotFetchable: (guildId, userId) => `Presences cannot be fetched from the API, they are only received from the gateway (user ${userId} of guild ${guildId} is not cached); enable the presences cache to read them later`,
 	InviteGuildUnknown: (code) => `Invite ${code} has no known guild`,
+	UserNoDMChannel: "No DM Channel exists!",
 	EmojiEmpty: "Cannot resolve an empty string to an emoji",
 	EmojiType: "Cannot resolve an emoji without an ID nor a name",
 	NotGuildSticker: "Only guild stickers can be edited or deleted",
@@ -645,6 +650,21 @@ function whenAll(values, callback) {
 	return values.some(isPromiseLike) ? Promise.all(values).then(callback) : callback(values);
 }
 /**
+* Resolves the relations of a structure again from its current data, and assigns them to that same structure: what
+* keeps a long-lived instance from holding the relations of the day it was built. Synchronous when `hydrate` is.
+*
+* @param value The structure.
+* @param hydrate Builds a structure of the same data, with its relations.
+* @returns The structure it was given.
+* @internal
+*/
+function refreshRelations(value, hydrate) {
+	return whenAll([hydrate(value.toJSON())], ([fresh]) => {
+		value[kRelations] = fresh[kRelations];
+		return value;
+	});
+}
+/**
 * Picks the cached structures of some IDs, in their order, skipping the ones that are not cached: the equivalent of
 * the collections discord.js fills from its caches, e.g. `MessageMentions#channels`.
 *
@@ -676,6 +696,17 @@ function whenCachedMap(ids, get) {
 		return map;
 	});
 }
+/**
+* Reads what a {@link Cache} holds under a key as is: for a cache of instances (a `Map`, e.g. `CollectionCache`), the
+* instance itself, without re-resolving its relations as `get` does. Other caches are read with `get`.
+*
+* @param cache The cache.
+* @param key The key of the entry.
+* @internal
+*/
+function peekCache(cache, key) {
+	return cache instanceof Map ? Map.prototype.get.call(cache, key) : cache.get(key);
+}
 
 //#endregion
 //#region src/util/Colors.ts
@@ -1019,16 +1050,16 @@ function computePositions(id, position, relative, sorted) {
 */
 function transformResolved({ client, guildId }, { users, members, roles, channels }) {
 	return whenAll([
-		users && resolveEach(users, (id) => client.users._get(id), (raw) => client.users._resolveData(raw)),
-		guildId && members ? resolveEach(members, (id) => client.members._get(guildId, id), (raw) => client.members._resolveData({
+		users && resolveEach(users, (id) => client.users.cache.get(id), (raw) => client.users._resolveData(raw)),
+		guildId && members ? resolveEach(members, (id) => client.members.cache.get(client.members.resolveKey(guildId, id)), (raw) => client.members._resolveData({
 			...raw,
 			guild_id: guildId
 		}), (raw) => raw.user.id) : void 0,
-		guildId && roles ? resolveEach(roles, (id) => client.roles._get(guildId, id), (raw) => client.roles._resolveData({
+		guildId && roles ? resolveEach(roles, (id) => client.roles.cache.get(client.roles.resolveKey(guildId, id)), (raw) => client.roles._resolveData({
 			...raw,
 			guild_id: guildId
 		})) : void 0,
-		channels && resolveEach(channels, (id) => client.channels._get(id), (raw) => client.channels._resolveData(raw))
+		channels && resolveEach(channels, (id) => client.channels.cache.get(id), (raw) => client.channels._resolveData(raw))
 	], ([resolvedUsers, resolvedMembers, resolvedRoles, resolvedChannels]) => {
 		const result = {};
 		if (resolvedUsers) result.users = resolvedUsers;
@@ -1458,10 +1489,19 @@ var User = class extends User$1 {
 		return guild?.identityGuildId && guild.badge ? cdn.guildTagBadge(guild.identityGuildId, guild.badge, options) : null;
 	}
 	/**
-	* Opens a direct message channel with the user, or gets the existing one.
+	* The cached direct message channel with the user, see `UserManager#dmChannel`: `null` when there is none, or when
+	* the channel cache cannot be searched. Synchronous when the channel cache is.
+	*/
+	get dmChannel() {
+		return this.client.users.dmChannel(this.id);
+	}
+	/**
+	* Opens a direct message channel with the user, reusing the cached one.
+	*
+	* @param force Whether to skip the cache lookup and always call the API.
 	*/
-	createDM() {
-		return this.client.users.createDM(this.id);
+	createDM(force = false) {
+		return this.client.users.createDM(this.id, { force });
 	}
 	/**
 	* Closes the direct message channel with the user.
@@ -2132,13 +2172,27 @@ var PermissionOverwrites = class extends Structure {
 	}
 };
 
+//#endregion
+//#region src/managers/BaseManager.ts
+/**
+* Manages the API methods of a data model, like discord.js's `BaseManager`.
+*/
+var BaseManager = class {
+	/**
+	* The client that instantiated this manager.
+	*/
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+};
+
 //#endregion
 //#region src/managers/PermissionOverwriteManager.ts
 /**
 * Manages the permission overwrites of one channel, as they were in the channel's payload.
 */
-var PermissionOverwriteManager = class {
-	client;
+var PermissionOverwriteManager = class extends BaseManager {
 	channelId;
 	guildId;
 	#overwrites;
@@ -2151,7 +2205,7 @@ var PermissionOverwriteManager = class {
 	* @param channel The channel, which the overwrites refer to.
 	*/
 	constructor(client, channelId, guildId, overwrites, channel = null) {
-		this.client = client;
+		super(client);
 		this.channelId = channelId;
 		this.guildId = guildId;
 		this.#overwrites = overwrites;
@@ -2246,16 +2300,13 @@ var PermissionOverwriteManager = class {
 	async guessType(target, id) {
 		if (typeof target !== "string") return "hoist" in target ? OverwriteType.Role : OverwriteType.Member;
 		if (id === this.guildId || !this.guildId) return OverwriteType.Role;
-		if (this.client.roles.cache) return await this.client.roles.get(this.guildId, id) ? OverwriteType.Role : OverwriteType.Member;
+		if (this.client.cache?.roles) return await this.client.roles.cache.get(this.client.roles.resolveKey(this.guildId, id)) ? OverwriteType.Role : OverwriteType.Member;
 		return (await this.client.roles.fetchAll(this.guildId)).some((role) => role.id === id) ? OverwriteType.Role : OverwriteType.Member;
 	}
 	async patchCached(update) {
-		const cache = this.client.cache?.channels;
-		const cached = await cache?.get(this.channelId);
-		if (!cached || !("permission_overwrites" in cached)) return;
-		await cache.set(this.channelId, {
-			...cached,
-			permission_overwrites: update(cached.permission_overwrites ?? [])
+		await this.client.channels._patchCached(this.channelId, (cached) => {
+			const data = cached.toJSON();
+			return "permission_overwrites" in data ? { permission_overwrites: update(data.permission_overwrites ?? []) } : void 0;
 		});
 	}
 };
@@ -2497,12 +2548,11 @@ var ChannelSlowmodeMixin = class {
 /**
 * Manages the threads of one channel: `client.threads`, with the channel's ID filled in.
 */
-var ChannelThreadManager = class {
-	client;
+var ChannelThreadManager = class extends BaseManager {
 	channelId;
 	guildId;
 	constructor(client, channelId, guildId) {
-		this.client = client;
+		super(client);
 		this.channelId = channelId;
 		this.guildId = guildId;
 	}
@@ -2677,18 +2727,17 @@ var GuildChannelMixin = class {
 /**
 * Manages the messages of one channel: `client.messages`, with the channel's ID filled in.
 */
-var ChannelMessageManager = class {
-	client;
+var ChannelMessageManager = class extends BaseManager {
 	channelId;
 	constructor(client, channelId) {
-		this.client = client;
+		super(client);
 		this.channelId = channelId;
 	}
 	/**
 	* Gets a message of the channel from the cache.
 	*/
-	get(messageId) {
-		return this.client.messages.get(this.channelId, messageId);
+	async get(messageId) {
+		return this.client.messages.cache.get(this.client.messages.resolveKey(this.channelId, messageId));
 	}
 	/**
 	* Gets a message of the channel from the cache, falling back to the API.
@@ -2872,18 +2921,17 @@ var ChannelOwnerMixin = class {
 /**
 * Manages the members of one thread: `client.threadMembers`, with the thread's ID filled in.
 */
-var ThreadChannelMemberManager = class {
-	client;
+var ThreadChannelMemberManager = class extends BaseManager {
 	threadId;
 	constructor(client, threadId) {
-		this.client = client;
+		super(client);
 		this.threadId = threadId;
 	}
 	/**
 	* Gets a member of the thread from the cache.
 	*/
-	get(userId) {
-		return this.client.threadMembers.get(this.threadId, userId);
+	async get(userId) {
+		return this.client.threadMembers.cache.get(this.client.threadMembers.resolveKey(this.threadId, userId));
 	}
 	/**
 	* Gets a member of the thread from the cache, falling back to the API.
@@ -3687,187 +3735,222 @@ var StageInstance = class extends StageInstance$1 {
 Mixin(StageInstance, [StructureMixin]);
 
 //#endregion
-//#region src/managers/CachedManager.ts
+//#region src/managers/DataManager.ts
 /**
-* The base class of every manager, the `BaseManager` of the discord.js RFC #11426: it reads raw data from one of the
-* client's entity caches, falls back to the REST API when asked to, and wraps the result in a
-* {@link StructureMixin | structure} with {@link CachedManager.construct}.
-*
-* @remarks
-* The cache only ever holds raw API data, building structures is always the manager's job. Without a store for its
-* entity (see the client's `makeCache`), `get` always resolves to `undefined` and `fetch` always hits the API.
-*
-* A failing store (e.g. Redis being unreachable) emits `cacheError` and, with the client's default
-* `cacheErrors: "miss"`, is treated as a cache miss.
+* Manages the API methods of a data model along with a collection of instances, like discord.js's `DataManager`.
 *
-* Every method is asynchronous since the cache can be Redis, except {@link CachedManager.cached}, which reads a
-* synchronous cache (`createInMemoryCache`) without awaiting it.
-*
-* Like discord.js's `CachedManager`, every payload coming from the API goes through {@link CachedManager._add}, which
-* patches the cached entry and builds the structure. Structures are built by {@link CachedManager.hydrate}, which
-* resolves their relations (a message's author, a member's user, ...) from the cache, so they carry the latest known
-* data rather than the copy embedded in the payload.
-*
-* @typeParam Name The name of the entity cache this manager reads from.
-* @typeParam Value The structure this manager builds.
+* @typeParam Value The structure this manager holds.
 * @typeParam Args The arguments identifying an entity, e.g. `[id]` or `[guildId, userId]`.
 */
-var CachedManager = class {
-	/**
-	* The client this manager belongs to.
-	*/
-	client;
-	/**
-	* The name of the entity cache this manager reads from.
-	*/
-	entity;
-	constructor(client, entity) {
-		this.client = client;
-		this.entity = entity;
-	}
+var DataManager = class extends BaseManager {
 	/**
-	* The entity cache this manager reads from, or `undefined` when the client has no cache.
+	* Resolves a structure or a cache key to a structure.
+	*
+	* @param value A structure, returned as is, or the cache key of an entity (its ID, for managers keyed by ID).
+	* @returns The structure, or `null` if the key is not cached.
 	*/
-	get cache() {
-		return this.client.cache?.[this.entity];
+	resolve(value) {
+		if (typeof value !== "string") return value ?? null;
+		return whenAll([this.cache.get(value)], ([cached]) => cached ?? null);
 	}
 	/**
-	* Gets an entity from the cache.
+	* Resolves a structure or an ID to an ID.
 	*
-	* @param args The arguments identifying the entity.
-	* @returns The entity, or `undefined` if it is not cached.
+	* @param value A structure, or an ID.
+	* @returns The ID, or `null` if the value is neither.
 	*/
-	async get(...args) {
-		return this._get(...args);
+	resolveId(value) {
+		if (typeof value === "string") return value;
+		const id = value?.id;
+		return typeof id === "string" ? id : null;
 	}
+};
+
+//#endregion
+//#region src/managers/CachedManager.ts
+/**
+* Manages the API methods of a data model with a mutable cache of instances: the `CachedManager` of the discord.js
+* RFC #11426.
+*
+* @remarks
+* Reads go through {@link CachedManager.cache}: `client.users.cache.get(id)`. The cache is built by the client's
+* `cacheConstructor` (`CollectionCache` by default) and shared by every manager of the same entity.
+*
+* Caches keyed by more than an ID take the key built by `resolveKey`:
+* `client.members.cache.get(client.members.resolveKey(guildId, userId))`.
+*
+* @typeParam Name The name of the entity this manager holds.
+* @typeParam Value The structure this manager builds.
+* @typeParam Args The arguments identifying an entity, e.g. `[id]` or `[guildId, userId]`.
+*/
+var CachedManager = class extends DataManager {
 	/**
-	* Gets an entity from a synchronous cache, without awaiting it: the synchronous counterpart of
-	* {@link CachedManager.get}, for hot paths such as message filters.
-	*
-	* @remarks
-	* It builds the same structure as `get`, relations included, so the entity caches they are read from must be
-	* synchronous too, which they all are with `createInMemoryCache`. `manager.cache?.synchronous` tells whether it can
-	* be called.
-	*
-	* An asynchronous cache throws rather than returning `undefined`: it cannot tell whether the entity is cached, and
-	* reporting a miss would silently skip whatever the caller does with cached entities, e.g. a filter.
+	* The cache of this manager's entity.
 	*
 	* @example
 	* ```typescript
-	* const member = client.members.cached(guildId, userId);
+	* const user = await client.users.cache.get(userId);
 	* ```
-	*
-	* @param args The arguments identifying the entity.
-	* @returns The entity, or `undefined` if it is not cached or the client has no cache.
-	* @throws {TypeError} When the entity cache, or one of the caches its relations are read from, is asynchronous.
 	*/
-	cached(...args) {
-		const { cache } = this;
-		if (cache === void 0) return void 0;
-		if (cache.synchronous !== true) throw new GatewayTypeError("CacheAsynchronous", this.entity);
-		const value = this._get(...args);
-		if (isPromiseLike(value)) {
-			value.catch(() => void 0);
-			throw new GatewayTypeError("CacheRelationsAsynchronous", this.entity);
-		}
-		return value;
+	cache;
+	/**
+	* The name of the entity this manager holds.
+	*/
+	name;
+	constructor(client, name) {
+		super(client);
+		this.name = name;
+		this.cache = this.createCache();
 	}
 	/**
-	* Gets an entity from the cache, synchronously when every cache it reads is: the {@link Awaitable} counterpart of
-	* {@link CachedManager.get}, which both `get` and {@link CachedManager.cached} rely on.
-	*
-	* @param args The arguments identifying the entity.
-	* @internal
+	* Gets {@link CachedManager.cache} from the client. Managers whose entity spans several caches override it.
 	*/
-	_get(...args) {
-		return this.getByKey(this.resolveKey(...args));
+	createCache() {
+		return this.client.CacheConstructor((data) => this.createStructure(data), this.name);
 	}
 	/**
-	* Resolves a structure or a cache key to a structure, like discord.js's `DataManager#resolve`.
-	*
-	* @param value A structure, returned as is, or the cache key of an entity (its ID, for managers keyed by ID).
-	* @returns The structure, or `null` if the key is not cached.
+	* The raw store of this manager's entity, or `undefined` when it is not cached.
 	*/
-	async resolve(value) {
-		if (typeof value !== "string") return value;
-		return await this.getByKey(value) ?? null;
+	get rawStore() {
+		return this.client.cache?.[this.name];
 	}
 	/**
-	* Adds an API payload to the cache, patching the cached entry with it, and builds its structure. The counterpart of
-	* discord.js's `CachedManager#_add`, asynchronous since the cache can be remote.
+	* Adds an API payload to the cache and returns its structure, as in the RFC.
 	*
 	* @remarks
-	* Like discord.js's `_patch`, the payload is shallowly merged into the cached entry, so the fields a partial payload
-	* lacks keep their cached value. With `cache` set to `false`, the merged entry is built but not written.
+	* The payload is written with `cache.add`: a cached entry is patched and returned, and with a cache of instances
+	* (`CollectionCache`) that is the very instance the application may already hold. An entity that is not cached is
+	* built and stored.
 	*
-	* The merge is a read followed by a write, not an atomic operation: on a shared cache, a write landing in between
-	* (another process, or a dispatch outside the guild's queue) is overwritten. `@wolfstar/plugin-cache` merges partial
-	* dispatches the same way, and the fields at stake are refreshed by the next payload of the entity.
+	* With `cache` set to `false`, a patched clone is returned (or the entity is built) and the cache is left
+	* untouched. The same goes for an entry the `filter` of the entity's policy rejects, whose cached entry is deleted
+	* on top of that: a rejected update must not leave the outdated entry behind.
 	*
 	* @param data The raw data.
-	* @param cache Whether to write the merged entry to the cache.
-	* @param options The cache key, when it cannot be derived from the data.
+	* @param cache Whether to write to the cache.
+	* @param options The cache key, when it cannot be derived from the data, and the extras of `createStructure`.
 	* @internal
 	*/
-	async _add(data, cache = true, { key = this.keyOf(data) } = {}) {
-		const store = this.cache;
-		if (store === void 0) return this.hydrate(data);
-		if (!cache) {
-			const existing = await this.guard("get", key, () => store.get(key), void 0);
-			return this.hydrate(mergeValues(existing, data));
+	async _add(data, cache = true, { id, extras = [] } = {}) {
+		const derived = id === void 0 ? this.keyOf(data) : this.derivedKey(data);
+		const key = id ?? derived;
+		if (!cache) return this.detached(await this.cache.get(key), data, extras);
+		if (this.client.cacheFilter(this.name)) {
+			const existing = await this.cache.get(key);
+			if (!this.accepts(key, existing, data)) {
+				if (existing) await this.cache.delete(key);
+				return this.detached(existing, data, extras);
+			}
 		}
-		const { added } = await this.guard("upsert", key, () => store.upsert(key, data), { added: data });
-		return this.hydrate(added);
+		if (key === derived && extras.length === 0) return this.cache.add(data);
+		const existing = await this.cache.get(key);
+		if (existing) {
+			existing[kPatch](data);
+			await this.cache.set(key, existing);
+			return this.resolveRelations(existing, extras);
+		}
+		const entry = await this._build(data, extras);
+		await this.cache.set(key, entry);
+		return entry;
 	}
 	/**
-	* Gets the cached structure of the entity raw data describes, or builds one from the data when it is not cached.
-	* Used to resolve the relations of other structures, e.g. a message's author.
+	* Patches the cached entry of a key, if any, with the fields an endpoint answered without the entity itself.
 	*
-	* @param data The raw data.
+	* @remarks
+	* Like every write of the managers, it follows the `filter` of the entity's policy: an entry whose patched data is
+	* rejected is deleted from the cache.
+	*
+	* @param key The cache key of the entry.
+	* @param patch The fields to patch, or a function computing them from the cached entry, `undefined` to leave it.
+	* @internal
 	*/
-	async resolveData(data) {
-		return this._resolveData(data);
+	async _patchCached(key, patch) {
+		const cached = await this.cache.get(key);
+		if (!cached) return;
+		const data = typeof patch === "function" ? patch(cached) : patch;
+		if (data === void 0) return;
+		if (!this.accepts(key, cached, data)) {
+			await this.cache.delete(key);
+			return;
+		}
+		cached[kPatch](data);
+		await this.cache.set(key, cached);
+	}
+	accepts(key, existing, data) {
+		const filter = this.client.cacheFilter(this.name);
+		if (!filter) return true;
+		const cached = existing?.toJSON();
+		return filter(cached ? {
+			...cached,
+			...data
+		} : data, key);
+	}
+	detached(existing, data, extras) {
+		return existing ? this.resolveRelations(existing[kClone](data), extras) : this._build(data, extras);
+	}
+	derivedKey(data) {
+		try {
+			return this.keyOf(data);
+		} catch {
+			return;
+		}
+	}
+	resolveRelations(value, extras) {
+		return refreshRelations(value, (data) => this._build(data, extras));
 	}
 	/**
-	* The {@link Awaitable} counterpart of {@link CachedManager.resolveData}, synchronous when every cache it reads is.
+	* Gets the cached structure of the entity raw data describes, or builds one from the data when it is not cached.
+	* Used to resolve the relations of other structures, e.g. a message's author. Synchronous when the cache is.
 	*
 	* @param data The raw data.
 	* @internal
 	*/
 	_resolveData(data) {
-		return whenAll([this.getByKey(this.keyOf(data))], ([cached]) => cached ?? this.build(data));
+		return whenAll([this.cache.get(this.keyOf(data))], ([cached]) => cached ?? this._build(data));
 	}
 	/**
 	* Gets a guild from the cache, to resolve the `guild` of a structure. Synchronous when the guild cache is.
 	*
-	* @param guildId The ID of the guild, if the structure belongs to one.
 	* @remarks
 	* The guild does not resolve its own channel relations, see `GuildManager._getShallow`.
 	*
+	* @param guildId The ID of the guild, if the structure belongs to one.
 	* @returns The guild, or `null` when there is no ID or the guild is not cached.
 	*/
 	cachedGuild(guildId) {
 		return guildId ? whenAll([this.client.guilds._getShallow(guildId)], ([guild]) => guild ?? null) : null;
 	}
 	/**
-	* Builds the structure of raw data, resolving its relations from the cache. Without relations to resolve, the same
-	* as {@link CachedManager.construct}.
+	* Builds the structure of raw data, resolving its relations from the cache; synchronous when every cache the
+	* relations are read from is. Without relations to resolve, the same as `createStructure`.
 	*
 	* @param data The raw data.
+	* @param extras The extra arguments passed to {@link CachedManager._add}.
+	* @internal
 	*/
-	async hydrate(data) {
-		return this.build(data);
+	_hydrate(data, ...extras) {
+		return this.createStructure(data, ...extras);
 	}
 	/**
-	* The {@link Awaitable} counterpart of {@link CachedManager.hydrate}, synchronous when every cache the relations
-	* are read from is. Managers resolving relations override this one, so `hydrate` and
-	* {@link CachedManager.cached} build the same structures.
+	* Wraps raw data in this manager's structure, bound to this manager's client, without resolving its relations: the
+	* creator handed to this entity's cache, always synchronous.
 	*
 	* @param data The raw data.
+	* @param extras The extra arguments passed to {@link CachedManager._add}.
 	* @internal
 	*/
-	_hydrate(data) {
-		return this.construct(data);
+	_construct(data, ...extras) {
+		return bindClient(this.createStructure(data, ...extras), this.client);
+	}
+	/**
+	* Builds the structure of raw data with {@link CachedManager._hydrate}, bound to this manager's client.
+	*
+	* @param data The raw data.
+	* @param extras The extra arguments passed to {@link CachedManager._add}.
+	* @internal
+	*/
+	_build(data, extras = []) {
+		return whenAll([this._hydrate(data, ...extras)], ([value]) => bindClient(value, this.client));
 	}
 	/**
 	* Gets an entity from the cache, fetching it from the API (and caching it) on a cache miss.
@@ -3884,12 +3967,13 @@ var CachedManager = class {
 	async fetch(...args) {
 		const ids = args.slice(0, this.resolveKey.length);
 		const { force = false, cache = true } = args[this.resolveKey.length] ?? {};
+		const id = this.resolveKey(...ids);
 		if (!force) {
-			const cached = await this.get(...ids);
+			const cached = await this.cache.get(id);
 			if (cached) return cached;
 		}
 		const raw = await this.fetchRaw(...ids);
-		return this._add(raw, cache, { key: this.resolveKey(...ids) });
+		return this._add(raw, cache, { id });
 	}
 	/**
 	* Fetches an entity from the API, bypassing and then updating the cache. Same as `fetch(...args, { force: true })`.
@@ -3900,78 +3984,23 @@ var CachedManager = class {
 		return this.fetch(...args, { force: true });
 	}
 	/**
-	* Wraps raw data in this manager's structure.
-	*
-	* @param data The raw data.
-	* @deprecated Use {@link CachedManager.construct}.
-	*/
-	createStructure(data) {
-		return this.construct(data);
-	}
-	/**
-	* Writes raw data to the cache.
-	*
-	* @param key The cache key of the entity.
-	* @param raw The raw data of the entity.
-	*/
-	async storeRaw(key, raw) {
-		const { cache } = this;
-		if (cache) await this.guard("set", key, () => cache.set(key, raw), void 0);
-	}
-	/**
-	* Gets this manager's store when it can enumerate its entries, for the `listCached` methods.
+	* Gets this entity's raw store when it can enumerate its entries, for the `listCached` methods.
 	*
 	* @returns The store, or `undefined` when this entity is not cached.
 	* @throws {TypeError} When the store cannot enumerate its entries.
 	*/
 	iterableCache() {
-		const { cache } = this;
-		if (cache === void 0) return void 0;
-		if (!isIterableCache(cache)) throw new GatewayTypeError("CacheNotIterable", this.entity);
-		return cache;
-	}
-	/**
-	* Gets an entity from the cache by its key, synchronously when every cache it reads is.
-	*
-	* @param key The cache key of the entity.
-	*/
-	getByKey(key) {
-		const { cache } = this;
-		return whenAll([cache ? this.guard("get", key, () => cache.get(key), void 0) : void 0], ([raw]) => raw === void 0 ? void 0 : this.build(raw));
+		const store = this.rawStore;
+		if (store === void 0) return void 0;
+		if (!isIterableCache(store)) throw new GatewayTypeError("CacheNotIterable", this.name);
+		return store;
 	}
 	/**
-	* Runs a cache operation, reporting its failure through `cacheError`. With the client's `cacheErrors: "miss"`, a
-	* failure resolves to `fallback`, otherwise it is rethrown. Synchronous when the operation is.
-	*
-	* @param operation The operation, for `cacheError`.
-	* @param key The key of the entry, for `cacheError`.
-	* @param run Runs the operation.
-	* @param fallback What a failure resolves to under `cacheErrors: "miss"`.
+	* Runs a raw store operation, reporting its failure through `cacheError`. With the client's `cacheErrors: "miss"`,
+	* a failure resolves to `fallback`, otherwise it is rethrown. Synchronous when the operation is.
 	*/
 	guard(operation, key, run, fallback) {
-		const fail = (error) => {
-			this.client.emit("cacheError", error, {
-				entity: this.entity,
-				key,
-				operation
-			});
-			if (this.client.cacheErrors === "throw") throw error;
-			return fallback;
-		};
-		try {
-			const result = run();
-			return isPromiseLike(result) ? result.catch(fail) : result;
-		} catch (error) {
-			return fail(error);
-		}
-	}
-	/**
-	* Builds the structure of raw data with {@link CachedManager._hydrate}, bound to this manager's client.
-	*
-	* @param data The raw data.
-	*/
-	build(data) {
-		return whenAll([this._hydrate(data)], ([value]) => bindClient(value, this.client));
+		return this.client.guardCache(this.name, operation, key, run, fallback);
 	}
 };
 
@@ -4007,17 +4036,59 @@ function channelGuildId(data) {
 	return "guild_id" in data ? data.guild_id ?? void 0 : void 0;
 }
 /**
+* The cache of {@link ChannelManager}: the channel cache, falling back to the thread cache.
+*/
+var ChannelCache = class {
+	#channels;
+	#threads;
+	constructor(channels, threads) {
+		this.#channels = channels;
+		this.#threads = threads;
+	}
+	get synchronous() {
+		return this.#channels.synchronous && this.#threads().synchronous;
+	}
+	get construct() {
+		return this.#channels.construct;
+	}
+	add(data, overwrite = false) {
+		return data.type !== void 0 && isThreadChannelType(data.type) ? this.#threads().add(data, overwrite) : this.#channels.add(data, overwrite);
+	}
+	set(key, value) {
+		const target = isThreadChannelType(value.type) ? this.#threads() : this.#channels;
+		return whenAll([target.set(key, value)], () => this);
+	}
+	get(key) {
+		return whenAll([this.#channels.get(key)], ([channel]) => channel ?? this.#threads().get(key));
+	}
+	has(key) {
+		return whenAll([this.#channels.has(key)], ([has]) => has || this.#threads().has(key));
+	}
+	delete(key) {
+		return whenAll([this.#channels.delete(key)], ([deleted]) => deleted || this.#threads().delete(key));
+	}
+	getSize() {
+		return whenAll([this.#channels.getSize(), this.#threads().getSize()], ([a, b]) => a + b);
+	}
+	clear() {
+		return whenAll([this.#channels.clear(), this.#threads().clear()], () => void 0);
+	}
+};
+/**
 * Manages the channels known to the client, threads included.
 *
 * @remarks
-* Threads live in their own entity cache, managed by `client.threads`, which {@link ChannelManager.get} falls back
+* Threads live in their own entity cache, managed by `client.threads`, which {@link ChannelManager.cache} falls back
 * to, so a thread ID resolves like any other channel ID.
 */
 var ChannelManager = class extends CachedManager {
 	constructor(client) {
 		super(client, "channels");
 	}
-	construct(data) {
+	createCache() {
+		return new ChannelCache(super.createCache(), () => this.client.threads.cache);
+	}
+	createStructure(data) {
 		return createChannel(data);
 	}
 	keyOf(data) {
@@ -4044,11 +4115,13 @@ var ChannelManager = class extends CachedManager {
 		const recipient = data.type === ChannelType.DM ? data.recipients?.[0] : void 0;
 		const guildId = channelGuildId(data) ?? guild?.id;
 		const thread = isThreadChannelType(data.type);
+		const stageKey = data.type === ChannelType.GuildStageVoice && guildId ? stageInstanceKey(guildId, data.id) : null;
+		const meKey = thread ? threadMemberKey(data.id, client.user?.id ?? client.id) : null;
 		return whenAll([
-			parentId && depth < MaxParentDepth ? this.cache?.get(parentId) : void 0,
+			parentId && depth < MaxParentDepth ? this.readRaw(parentId) : void 0,
 			recipient ? client.users._resolveData(recipient) : void 0,
-			data.type === ChannelType.GuildStageVoice && guildId ? client.cache?.stageInstances?.get(stageInstanceKey(guildId, data.id)) : void 0,
-			thread ? client.cache?.threadMembers?.get(threadMemberKey(data.id, client.user?.id ?? client.id)) : void 0
+			stageKey ? client.guardCache("stageInstances", "get", stageKey, () => client.cache?.stageInstances?.get(stageKey), void 0) : void 0,
+			meKey ? client.guardCache("threadMembers", "get", meKey, () => client.cache?.threadMembers?.get(meKey), void 0) : void 0
 		], ([parentData, resolvedRecipient, stageData, me]) => whenAll([parentData ? this._hydrateInGuild(parentData, guild, depth + 1) : null], ([parent]) => {
 			const relations = {
 				guild,
@@ -4072,7 +4145,30 @@ var ChannelManager = class extends CachedManager {
 	* @internal
 	*/
 	_getInGuild(channelId, guild) {
-		return whenAll([this.cache?.get(channelId)], ([data]) => data ? this._hydrateInGuild(data, guild) : null);
+		return whenAll([this.readRaw(channelId)], ([data]) => data ? this._hydrateInGuild(data, guild) : null);
+	}
+	/**
+	* Finds the cached direct message channel with a user, for `client.users`.
+	*
+	* @remarks
+	* Only a synchronous channel cache that can enumerate its entries is searched: scanning every channel of a remote
+	* store costs more than asking Discord for the channel.
+	*
+	* @param userId The ID of the user.
+	* @returns The channel, `null` when the cache was searched and holds none, `undefined` when it cannot be searched.
+	* @internal
+	*/
+	_findDM(userId) {
+		const store = this.rawStore;
+		if (store === void 0 || store.synchronous !== true || !isIterableCache(store)) return;
+		return whenAll([this.guard("entries", null, () => store.entries(), [])], ([entries]) => {
+			const found = entries.find(([, data]) => data.type === ChannelType.DM && data.recipients?.[0]?.id === userId);
+			if (!found) return null;
+			return whenAll([this.cache.get(found[0])], ([channel]) => channel ?? null);
+		});
+	}
+	readRaw(channelId) {
+		return this.guard("get", channelId, () => this.rawStore?.get(channelId), void 0);
 	}
 	resolveKey(channelId) {
 		return channelId;
@@ -4086,25 +4182,6 @@ var ChannelManager = class extends CachedManager {
 		return isThreadChannelType(data.type) ? this.client.threads._add(data, cache, options) : super._add(data, cache, options);
 	}
 	/**
-	* Gets a channel from the cache, looking it up in the thread cache as well, which `get` and `cached` rely on.
-	*
-	* @param channelId The ID of the channel.
-	* @internal
-	*/
-	_get(channelId) {
-		return whenAll([super._get(channelId)], ([channel]) => channel ?? this.client.threads._get(channelId));
-	}
-	/**
-	* Writes a channel to the cache, threads to the thread cache.
-	*
-	* @param channelId The ID of the channel.
-	* @param raw The raw channel.
-	*/
-	async storeRaw(channelId, raw) {
-		if (isThreadChannelType(raw.type)) await this.client.cache?.threads?.set(channelId, raw);
-		else await this.cache?.set(channelId, raw);
-	}
-	/**
 	* Edits a channel.
 	*
 	* @param channelId The ID of the channel.
@@ -4391,9 +4468,13 @@ var Guild = class extends AnonymousGuild {
 		const resolved = this[kRelations][name];
 		if (resolved !== void 0) return resolved;
 		const channelId = this[kData][GuildChannelFields[name]];
-		if (!channelId || this.client.cache?.channels?.synchronous !== true) return null;
+		const { cache } = this.client.channels;
+		if (!channelId || !cache.synchronous) return null;
 		try {
-			return this.client.channels.cached(channelId) ?? null;
+			const channel = cache.get(channelId);
+			if (!isPromiseLike(channel)) return channel ?? null;
+			channel.catch(() => void 0);
+			return null;
 		} catch {
 			return null;
 		}
@@ -6125,8 +6206,12 @@ function changesReduce(changes, initial = {}) {
 	}
 	return data;
 }
-async function read(value) {
-	return value.catch(() => void 0);
+async function read(manager, ...args) {
+	try {
+		return await manager.cache.get(manager.resolveKey(...args));
+	} catch {
+		return;
+	}
 }
 /**
 * Resolves the target of an audit log entry from the cache, like discord.js's `GuildAuditLogsEntry#target`.
@@ -6144,19 +6229,19 @@ async function resolveAuditLogTarget(client, entry, entities = {}) {
 	const { guilds } = client;
 	const built = (value) => bindClient(value, client);
 	if (type === "Unknown") return changesReduce(changes, { id: targetId });
-	const user = async (userId) => entities.users?.get(userId) ?? await read(client.users.get(userId)) ?? null;
+	const user = async (userId) => entities.users?.get(userId) ?? await read(client.users, userId) ?? null;
 	if (type === "User") return targetId ? user(targetId) : null;
 	if (!targetId && type !== "Invite") return null;
 	const id = targetId;
 	switch (type) {
-		case "Guild": return await read(guilds.get(id)) ?? { id };
+		case "Guild": return await read(guilds, id) ?? { id };
 		case "Channel":
-		case "Thread": return await read(client.channels.get(id)) ?? changesReduce(changes, { id });
-		case "Role": return await read(client.roles.get(guildId, id)) ?? { id };
+		case "Thread": return await read(client.channels, id) ?? changesReduce(changes, { id });
+		case "Role": return await read(client.roles, guildId, id) ?? { id };
 		case "Invite": {
 			const { id: _id, ...changed } = changesReduce(changes);
 			const code = changed.code;
-			return (code ? await read(guilds.invites(guildId).get(code)) : void 0) ?? built(new GuildInvite({
+			return (code ? await read(guilds.invites(guildId), code) : void 0) ?? built(new GuildInvite({
 				...changed,
 				code: code ?? "",
 				guild_id: guildId
@@ -6166,28 +6251,28 @@ async function resolveAuditLogTarget(client, entry, entities = {}) {
 			id,
 			guild_id: guildId
 		})));
-		case "Emoji": return await read(guilds.emojis(guildId).get(id)) ?? { id };
-		case "Message": return entry.action_type === AuditLogEvent.MessageBulkDelete ? await read(client.channels.get(id)) ?? { id } : user(id);
-		case "Integration": return entities.integrations?.get(id) ?? await read(guilds.integrations(guildId).get(id)) ?? built(new Integration(changesReduce(changes, {
+		case "Emoji": return await read(guilds.emojis(guildId), id) ?? { id };
+		case "Message": return entry.action_type === AuditLogEvent.MessageBulkDelete ? await read(client.channels, id) ?? { id } : user(id);
+		case "Integration": return entities.integrations?.get(id) ?? await read(guilds.integrations(guildId), id) ?? built(new Integration(changesReduce(changes, {
 			id,
 			guild_id: guildId
 		})));
 		case "StageInstance": {
 			const channelId = options?.channel_id;
-			return (channelId ? await read(guilds.stageInstances(guildId).get(channelId)) : void 0) ?? built(new StageInstance(changesReduce(changes, {
+			return (channelId ? await read(guilds.stageInstances(guildId), channelId) : void 0) ?? built(new StageInstance(changesReduce(changes, {
 				id,
 				channel_id: channelId,
 				guild_id: guildId
 			})));
 		}
-		case "Sticker": return await read(guilds.stickers(guildId).get(id)) ?? built(new Sticker(changesReduce(changes, { id })));
-		case "GuildScheduledEvent": return await read(guilds.scheduledEvents(guildId).get(id)) ?? built(new GuildScheduledEvent(changesReduce(changes, {
+		case "Sticker": return await read(guilds.stickers(guildId), id) ?? built(new Sticker(changesReduce(changes, { id })));
+		case "GuildScheduledEvent": return await read(guilds.scheduledEvents(guildId), id) ?? built(new GuildScheduledEvent(changesReduce(changes, {
 			id,
 			guild_id: guildId
 		})));
 		case "ApplicationCommand": return entities.applicationCommands?.get(id) ?? { id };
-		case "SoundboardSound": return await read(guilds.soundboardSounds(guildId).get(id)) ?? { id };
-		case "AutoModeration": return await read(guilds.autoModerationRules(guildId).get(id)) ?? built(new AutoModerationRule(changesReduce(changes, {
+		case "SoundboardSound": return await read(guilds.soundboardSounds(guildId), id) ?? { id };
+		case "AutoModeration": return await read(guilds.autoModerationRules(guildId), id) ?? built(new AutoModerationRule(changesReduce(changes, {
 			id,
 			guild_id: guildId
 		})));
@@ -6196,59 +6281,146 @@ async function resolveAuditLogTarget(client, entry, entities = {}) {
 	}
 }
 
+//#endregion
+//#region src/util/roles.ts
+/**
+* Whether a value is several roles rather than a single one.
+*
+* @internal
+*/
+function isRoleResolvables(value) {
+	return Array.isArray(value) || value instanceof Collection;
+}
+/**
+* Resolves a role or an ID to an ID.
+*
+* @returns The ID, or `null` if the value is neither.
+* @internal
+*/
+function resolveRoleId(role) {
+	if (typeof role === "string") return role;
+	const id = role?.id;
+	return typeof id === "string" ? id : null;
+}
+/**
+* Resolves several roles to their IDs, without duplicates.
+*
+* @param roles The roles.
+* @throws {GatewayTypeError} `InvalidElement` when an element is neither a role nor an ID.
+* @internal
+*/
+function resolveRoleIds(roles) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const role of roles.values()) {
+		const id = resolveRoleId(role);
+		if (id === null) throw new GatewayTypeError("InvalidElement", "Array or Collection", "roles", role);
+		ids.add(id);
+	}
+	return [...ids];
+}
+/**
+* Reads the cached roles of some IDs into a `Collection`, skipping the ones that are not cached. Synchronous when
+* the role cache is.
+*
+* @param client The client.
+* @param guildId The ID of the guild of the roles.
+* @param ids The IDs of the roles.
+* @internal
+*/
+function cachedRoles(client, guildId, ids) {
+	const { roles } = client;
+	return whenAll([whenCachedMap(ids, (id) => roles.cache.get(roles.resolveKey(guildId, id)))], ([cached]) => new Collection(cached));
+}
+
 //#endregion
 //#region src/managers/GuildEmojiRoleManager.ts
 /**
-* Manages the roles allowed to use one custom emoji. When it has none, everyone can use it.
+* Manages the roles allowed to use one custom emoji, like discord.js's `GuildEmojiRoleManager`. When it has none,
+* everyone can use it.
+*
+* @remarks
+* {@link GuildEmojiRoleManager.cache} is `Awaitable`, unlike discord.js's: synchronous with the default in-memory
+* cache, a promise with a remote store.
 */
-var GuildEmojiRoleManager = class {
-	client;
-	guildId;
-	emojiId;
-	#roleIds;
-	constructor(client, guildId, emojiId, roleIds) {
-		this.client = client;
-		this.guildId = guildId;
-		this.emojiId = emojiId;
-		this.#roleIds = roleIds;
+var GuildEmojiRoleManager = class GuildEmojiRoleManager extends BaseManager {
+	/**
+	* The emoji these roles belong to.
+	*/
+	emoji;
+	/**
+	* @param emoji The emoji.
+	*/
+	constructor(emoji) {
+		super(emoji.client);
+		this.emoji = emoji;
+	}
+	/**
+	* The emoji's guild, from the cache: `null` when it is not cached.
+	*/
+	get guild() {
+		return this.emoji.guild;
+	}
+	get guildId() {
+		return this.emoji.guildId;
+	}
+	get emojiId() {
+		return this.emoji.id;
 	}
 	/**
 	* The IDs of the allowed roles.
 	*/
 	get ids() {
-		return this.#roleIds;
+		return this.emoji.roleIds;
+	}
+	/**
+	* The allowed roles held in the cache, by ID. Roles that are not cached are skipped: use
+	* {@link GuildEmojiRoleManager.fetch} to get them all.
+	*/
+	get cache() {
+		return cachedRoles(this.client, this.guildId, this.ids);
 	}
 	/**
 	* Fetches the allowed roles, cache first.
 	*/
 	fetch() {
-		return Promise.all(this.#roleIds.map((id) => this.client.roles.fetch(this.guildId, id)));
+		return Promise.all(this.ids.map((id) => this.client.roles.fetch(this.guildId, id)));
 	}
 	/**
 	* Allows more roles to use the emoji.
 	*
-	* @param roles The ID of the role, or several IDs.
+	* @param roleOrRoles The role or its ID, or an array or `Collection` of them.
+	* @returns The emoji, patched.
 	*/
-	add(roles) {
-		const added = typeof roles === "string" ? [roles] : roles;
-		return this.set([.../* @__PURE__ */ new Set([...this.#roleIds, ...added])]);
+	async add(roleOrRoles) {
+		return this.set([.../* @__PURE__ */ new Set([...this.ids, ...this.resolve(roleOrRoles)])]);
 	}
 	/**
 	* Stops allowing roles to use the emoji.
 	*
-	* @param roles The ID of the role, or several IDs.
+	* @param roleOrRoles The role or its ID, or an array or `Collection` of them.
+	* @returns The emoji, patched.
 	*/
-	remove(roles) {
-		const removed = new Set(typeof roles === "string" ? [roles] : roles);
-		return this.set(this.#roleIds.filter((id) => !removed.has(id)));
+	async remove(roleOrRoles) {
+		const removed = new Set(this.resolve(roleOrRoles));
+		return this.set(this.ids.filter((id) => !removed.has(id)));
 	}
 	/**
 	* Replaces the allowed roles, everyone when empty.
 	*
-	* @param roles The IDs of the roles.
+	* @param roles The roles: an array of roles or IDs, or a `Collection` of roles.
+	* @returns The emoji, patched.
 	*/
 	set(roles) {
-		return this.client.guilds.emojis(this.guildId).edit(this.emojiId, { roles });
+		return this.emoji.edit({ roles });
+	}
+	/**
+	* Creates another manager of the same emoji's roles.
+	*/
+	clone() {
+		return new GuildEmojiRoleManager(this.emoji);
+	}
+	resolve(roleOrRoles) {
+		return resolveRoleIds(isRoleResolvables(roleOrRoles) ? roleOrRoles : [roleOrRoles]);
 	}
 };
 
@@ -6313,7 +6485,7 @@ var GuildEmoji = class extends Emoji {
 	* The roles allowed to use the emoji.
 	*/
 	get roles() {
-		return new GuildEmojiRoleManager(this.client, this.guildId, this.id, this.roleIds);
+		return new GuildEmojiRoleManager(this);
 	}
 	/**
 	* The user who uploaded the emoji, when the payload includes it (it needs `ManageGuildExpressions`).
@@ -6612,7 +6784,7 @@ var AutoModerationRuleManager = class extends CachedManager {
 		super(client, "autoModerationRules");
 		this.guildId = guildId;
 	}
-	construct(data) {
+	createStructure(data) {
 		return new AutoModerationRule(data);
 	}
 	keyOf(data) {
@@ -6665,7 +6837,7 @@ var AutoModerationRuleManager = class extends CachedManager {
 	*/
 	async delete(ruleId, reason) {
 		await this.client.api.guilds.deleteAutoModerationRule(this.guildId, ruleId, { reason });
-		await this.cache?.delete(this.resolveKey(ruleId));
+		await this.cache.delete(this.resolveKey(ruleId));
 	}
 	async fetchRaw(ruleId) {
 		return this.client.api.guilds.getAutoModerationRule(this.guildId, ruleId);
@@ -6744,7 +6916,7 @@ var GuildBanManager = class extends CachedManager {
 		super(client, "bans");
 		this.guildId = guildId;
 	}
-	construct(data) {
+	createStructure(data) {
 		return new GuildBan(data);
 	}
 	keyOf(data) {
@@ -6795,7 +6967,7 @@ var GuildBanManager = class extends CachedManager {
 	async remove(user, reason) {
 		const userId = resolveId(user);
 		await this.client.members.unban(this.guildId, userId, reason);
-		await this.cache?.delete(this.resolveKey(userId));
+		await this.cache.delete(this.resolveKey(userId));
 	}
 	/**
 	* Bans up to 200 users at once.
@@ -6823,11 +6995,10 @@ var GuildBanManager = class extends CachedManager {
 /**
 * Manages the channels of one guild. Channels are cached by `client.channels`, which this manager writes to.
 */
-var GuildChannelManager = class {
-	client;
+var GuildChannelManager = class extends BaseManager {
 	guildId;
 	constructor(client, guildId) {
-		this.client = client;
+		super(client);
 		this.guildId = guildId;
 	}
 	/**
@@ -6905,7 +7076,7 @@ var GuildChannelManager = class {
 			channel: entry.id,
 			position: entry.position
 		})), options.reason);
-		return await this.client.channels.get(id);
+		return await this.client.channels.cache.get(id);
 	}
 	/**
 	* Fetches the channels a channel is sorted with, itself included, and caches them.
@@ -6949,7 +7120,7 @@ var GuildIntegrationManager = class extends CachedManager {
 		super(client, "integrations");
 		this.guildId = guildId;
 	}
-	construct(data) {
+	createStructure(data) {
 		return new Integration(data);
 	}
 	keyOf(data) {
@@ -6971,7 +7142,7 @@ var GuildIntegrationManager = class extends CachedManager {
 		return whenAll([
 			data.user ? this.client.users._resolveData(data.user) : null,
 			this.cachedGuild(data.guild_id),
-			data.role_id ? this.client.roles._get(data.guild_id, data.role_id) : void 0
+			data.role_id ? this.client.roles.cache.get(this.client.roles.resolveKey(data.guild_id, data.role_id)) : void 0
 		], ([user, guild, role]) => new Integration(data, {
 			user,
 			guild,
@@ -6993,7 +7164,7 @@ var GuildIntegrationManager = class extends CachedManager {
 	*/
 	async delete(integrationId, reason) {
 		await this.client.api.guilds.deleteIntegration(this.guildId, integrationId, { reason });
-		await this.cache?.delete(this.resolveKey(integrationId));
+		await this.cache.delete(this.resolveKey(integrationId));
 	}
 	async fetchRaw(integrationId) {
 		const integration = (await this.list()).find(({ id }) => id === integrationId);
@@ -7019,7 +7190,7 @@ var GuildScheduledEventManager = class extends CachedManager {
 		super(client, "scheduledEvents");
 		this.guildId = guildId;
 	}
-	construct(data) {
+	createStructure(data) {
 		return new GuildScheduledEvent(data);
 	}
 	keyOf(data) {
@@ -7039,9 +7210,9 @@ var GuildScheduledEventManager = class extends CachedManager {
 	}
 	_hydrate(data) {
 		return whenAll([
-			data.creator ? this.client.users._resolveData(data.creator) : data.creator_id ? this.client.users._get(data.creator_id) : void 0,
+			data.creator ? this.client.users._resolveData(data.creator) : data.creator_id ? this.client.users.cache.get(data.creator_id) : void 0,
 			this.cachedGuild(data.guild_id),
-			data.channel_id ? this.client.channels._get(data.channel_id) : void 0
+			data.channel_id ? this.client.channels.cache.get(data.channel_id) : void 0
 		], ([creator, guild, channel]) => new GuildScheduledEvent(data, {
 			creator: creator ?? null,
 			guild,
@@ -7084,7 +7255,7 @@ var GuildScheduledEventManager = class extends CachedManager {
 	*/
 	async delete(eventId, reason) {
 		await this.client.api.guilds.deleteScheduledEvent(this.guildId, eventId, { reason });
-		await this.cache?.delete(this.resolveKey(eventId));
+		await this.cache.delete(this.resolveKey(eventId));
 	}
 	/**
 	* Fetches the users who subscribed to an event, and caches them.
@@ -7230,11 +7401,11 @@ var GuildSoundboardSoundManager = class extends CachedManager {
 		super(client, "soundboardSounds");
 		this.guildId = guildId;
 	}
-	construct(data) {
+	createStructure(data) {
 		return new SoundboardSound(data);
 	}
 	keyOf(data) {
-		return this.resolveKey(data.sound_id);
+		return soundboardSoundKey(data.guild_id ?? this.guildId, data.sound_id);
 	}
 	resolveKey(soundId) {
 		return soundboardSoundKey(this.guildId, soundId);
@@ -7252,7 +7423,7 @@ var GuildSoundboardSoundManager = class extends CachedManager {
 		return whenAll([
 			data.user ? this.client.users._resolveData(data.user) : null,
 			this.cachedGuild(data.guild_id),
-			data.emoji_id && data.guild_id ? this.client.guilds.emojis(data.guild_id)._get(data.emoji_id) : void 0
+			data.emoji_id && data.guild_id ? this.client.guilds.emojis(data.guild_id).cache.get(emojiKey(data.guild_id, data.emoji_id)) : void 0
 		], ([user, guild, emoji]) => new SoundboardSound(data, {
 			user,
 			guild,
@@ -7298,7 +7469,7 @@ var GuildSoundboardSoundManager = class extends CachedManager {
 	*/
 	async delete(soundId, reason) {
 		await this.client.api.guilds.deleteSoundboardSound(this.guildId, soundId, { reason });
-		await this.cache?.delete(this.resolveKey(soundId));
+		await this.cache.delete(this.resolveKey(soundId));
 	}
 	async fetchRaw(soundId) {
 		const sound = await this.client.api.guilds.getSoundboardSound(this.guildId, soundId);
@@ -7340,7 +7511,7 @@ var StageInstanceManager = class extends CachedManager {
 		super(client, "stageInstances");
 		this.guildId = guildId;
 	}
-	construct(data) {
+	createStructure(data) {
 		return new StageInstance(data);
 	}
 	keyOf(data) {
@@ -7352,8 +7523,8 @@ var StageInstanceManager = class extends CachedManager {
 	_hydrate(data) {
 		return whenAll([
 			this.cachedGuild(data.guild_id),
-			this.client.channels._get(data.channel_id),
-			data.guild_scheduled_event_id ? this.client.guilds.scheduledEvents(data.guild_id)._get(data.guild_scheduled_event_id) : void 0
+			this.client.channels.cache.get(data.channel_id),
+			data.guild_scheduled_event_id ? this.client.guilds.scheduledEvents(data.guild_id).cache.get(scheduledEventKey(data.guild_id, data.guild_scheduled_event_id)) : void 0
 		], ([guild, channel, guildScheduledEvent]) => new StageInstance(data, {
 			guild,
 			channel: channel ?? null,
@@ -7399,7 +7570,7 @@ var StageInstanceManager = class extends CachedManager {
 	*/
 	async delete(channelId, reason) {
 		await this.client.api.stageInstances.delete(channelId, { reason });
-		await this.cache?.delete(this.resolveKey(channelId));
+		await this.cache.delete(this.resolveKey(channelId));
 	}
 	async fetchRaw(channelId) {
 		return this.client.api.stageInstances.get(channelId);
@@ -7420,7 +7591,7 @@ var GuildEmojiManager = class extends CachedManager {
 		super(client, "emojis");
 		this.guildId = guildId;
 	}
-	construct(data) {
+	createStructure(data) {
 		return new GuildEmoji(data);
 	}
 	keyOf(data) {
@@ -7460,7 +7631,7 @@ var GuildEmojiManager = class extends CachedManager {
 		const body = {
 			image: await resolveImage(options.attachment),
 			name: options.name,
-			roles: options.roles ? [...options.roles] : void 0
+			roles: options.roles ? resolveRoleIds(options.roles) : void 0
 		};
 		const emoji = await this.client.api.guilds.createEmoji(this.guildId, body, { reason: options.reason });
 		return this.store(emoji);
@@ -7474,7 +7645,7 @@ var GuildEmojiManager = class extends CachedManager {
 	async edit(emojiId, options) {
 		const body = {
 			name: options.name,
-			roles: options.roles === void 0 || options.roles === null ? options.roles : [...options.roles]
+			roles: options.roles === void 0 || options.roles === null ? options.roles : resolveRoleIds(options.roles)
 		};
 		const emoji = await this.client.api.guilds.editEmoji(this.guildId, emojiId, body, { reason: options.reason });
 		return this.store(emoji);
@@ -7487,7 +7658,7 @@ var GuildEmojiManager = class extends CachedManager {
 	*/
 	async delete(emojiId, reason) {
 		await this.client.api.guilds.deleteEmoji(this.guildId, emojiId, { reason });
-		await this.cache?.delete(this.resolveKey(emojiId));
+		await this.cache.delete(this.resolveKey(emojiId));
 	}
 	/**
 	* Fetches the user who uploaded an emoji, which the API only returns with `ManageGuildExpressions`.
@@ -7511,9 +7682,9 @@ var GuildEmojiManager = class extends CachedManager {
 		const cache = this.iterableCache();
 		if (!cache) return [];
 		const prefix = `${this.guildId}:`;
-		const keys = (await cache.keys()).filter((key) => key.startsWith(prefix));
-		const values = await Promise.all(keys.map((key) => cache.get(key)));
-		return Promise.all(values.filter((value) => value !== void 0).map((value) => this.hydrate(value)));
+		const keys = await this.guard("keys", null, () => cache.keys(), []);
+		const values = await Promise.all(keys.filter((key) => key.startsWith(prefix)).map((key) => this.guard("get", key, () => cache.get(key), void 0)));
+		return Promise.all(values.filter((value) => value !== void 0).map((value) => this._build(value)));
 	}
 	async fetchRaw(emojiId) {
 		return {
@@ -7543,11 +7714,11 @@ var GuildInviteManager = class extends CachedManager {
 		super(client, "invites");
 		this.guildId = guildId;
 	}
-	construct(data) {
+	createStructure(data) {
 		return new GuildInvite(data);
 	}
 	keyOf(data) {
-		return this.resolveKey(data.code);
+		return inviteKey(data.guild_id ?? this.guildId, resolveInviteCode(data.code));
 	}
 	/**
 	* Adds an invite to the cache, and its inviter and target user to `client.users`.
@@ -7564,8 +7735,8 @@ var GuildInviteManager = class extends CachedManager {
 		return whenAll([
 			data.inviter ? users._resolveData(data.inviter) : void 0,
 			data.target_user ? users._resolveData(data.target_user) : void 0,
-			this.cachedGuild(this.guildId),
-			data.channel_id ? this.client.channels._get(data.channel_id) : void 0
+			this.cachedGuild(data.guild_id ?? this.guildId),
+			data.channel_id ? this.client.channels.cache.get(data.channel_id) : void 0
 		], ([inviter, targetUser, guild, channel]) => new GuildInvite(data, {
 			inviter,
 			targetUser,
@@ -7619,7 +7790,7 @@ var GuildInviteManager = class extends CachedManager {
 	*/
 	async delete(code, reason) {
 		await this.client.api.invites.delete(resolveInviteCode(code), { reason });
-		await this.cache?.delete(this.resolveKey(code));
+		await this.cache.delete(this.resolveKey(code));
 	}
 	async fetchRaw(code) {
 		const invite = await this.client.api.invites.get(resolveInviteCode(code), { with_counts: true });
@@ -7651,7 +7822,7 @@ var GuildStickerManager = class extends CachedManager {
 		super(client, "stickers");
 		this.guildId = guildId;
 	}
-	construct(data) {
+	createStructure(data) {
 		return new Sticker(data);
 	}
 	keyOf(data) {
@@ -7719,7 +7890,7 @@ var GuildStickerManager = class extends CachedManager {
 	*/
 	async delete(stickerId, reason) {
 		await this.client.api.guilds.deleteSticker(this.guildId, stickerId, { reason });
-		await this.cache?.delete(this.resolveKey(stickerId));
+		await this.cache.delete(this.resolveKey(stickerId));
 	}
 	/**
 	* Fetches the user who uploaded a sticker, which the API only returns with `ManageGuildExpressions`.
@@ -7743,9 +7914,9 @@ var GuildStickerManager = class extends CachedManager {
 		const cache = this.iterableCache();
 		if (!cache) return [];
 		const prefix = `${this.guildId}:`;
-		const keys = (await cache.keys()).filter((key) => key.startsWith(prefix));
-		const values = await Promise.all(keys.map((key) => cache.get(key)));
-		return Promise.all(values.filter((value) => value !== void 0).map((value) => this.hydrate(value)));
+		const keys = await this.guard("keys", null, () => cache.keys(), []);
+		const values = await Promise.all(keys.filter((key) => key.startsWith(prefix)).map((key) => this.guard("get", key, () => cache.get(key), void 0)));
+		return Promise.all(values.filter((value) => value !== void 0).map((value) => this._build(value)));
 	}
 	async fetchRaw(stickerId) {
 		return {
@@ -7770,7 +7941,7 @@ var GuildManager = class extends CachedManager {
 	constructor(client) {
 		super(client, "guilds");
 	}
-	construct(data) {
+	createStructure(data) {
 		return new Guild(data);
 	}
 	keyOf(data) {
@@ -7802,7 +7973,8 @@ var GuildManager = class extends CachedManager {
 	* @internal
 	*/
 	_getShallow(guildId) {
-		return whenAll([this.cache?.get(guildId)], ([raw]) => raw === void 0 ? void 0 : bindClient(this.construct(raw), this.client));
+		const read = this.guard("get", guildId, () => this.rawStore?.get(guildId), void 0);
+		return whenAll([read], ([raw]) => raw === void 0 ? void 0 : bindClient(this.createStructure(raw), this.client));
 	}
 	resolveKey(guildId) {
 		return guildId;
@@ -7895,9 +8067,7 @@ var GuildManager = class extends CachedManager {
 			channel_id: options.channel === void 0 ? void 0 : options.channel && resolveId(options.channel)
 		};
 		const settings = await this.client.api.guilds.editWidgetSettings(guildId, body, { reason: options.reason });
-		const cached = await this.cache?.get(guildId);
-		if (cached) await this.cache.set(guildId, {
-			...cached,
+		await this._patchCached(guildId, {
 			widget_enabled: settings.enabled,
 			widget_channel_id: settings.channel_id
 		});
@@ -7987,9 +8157,9 @@ var GuildManager = class extends CachedManager {
 		const integrations = this.integrations(guildId);
 		const [webhooks, autoModerationRules, threads, pageIntegrations] = await Promise.all([
 			Promise.all(log.webhooks.map((webhook) => this.client.webhooks.hydrate(webhook))),
-			Promise.all(log.auto_moderation_rules.map((rule) => rules.hydrate(rule))),
-			Promise.all(log.threads.map((thread) => this.client.threads.hydrate(thread))),
-			Promise.all(log.integrations.map((integration) => integrations.hydrate({
+			Promise.all(log.auto_moderation_rules.map((rule) => rules._build(rule))),
+			Promise.all(log.threads.map((thread) => this.client.threads._build(thread))),
+			Promise.all(log.integrations.map((integration) => integrations._build({
 				...integration,
 				guild_id: guildId
 			})))
@@ -8161,11 +8331,7 @@ var GuildManager = class extends CachedManager {
 			dms_disabled_until: toISO(options.dmsDisabledUntil)
 		};
 		const incidents = await this.client.api.guilds.editIncidentActions(guildId, body);
-		const cached = await this.cache?.get(guildId);
-		if (cached) await this.cache.set(guildId, {
-			...cached,
-			incidents_data: incidents
-		});
+		await this._patchCached(guildId, { incidents_data: incidents });
 		return transformAPIIncidentsData(incidents);
 	}
 	async fetchRaw(guildId) {
@@ -8176,10 +8342,11 @@ var GuildManager = class extends CachedManager {
 	}
 	async welcomeScreen(guildId, screen) {
 		const channels = screen.welcome_channels;
-		const [guild, cachedChannels, emojis] = await Promise.all([
+		const emojis = this.emojis(guildId);
+		const [guild, cachedChannels, cachedEmojis] = await Promise.all([
 			this.cachedGuild(guildId),
-			cachedMap(channels.map((channel) => channel.channel_id), (id) => this.client.channels.get(id)),
-			cachedMap(channels.flatMap((channel) => channel.emoji_id ? [channel.emoji_id] : []), (id) => this.emojis(guildId).get(id))
+			cachedMap(channels.map((channel) => channel.channel_id), (id) => this.client.channels.cache.get(id)),
+			cachedMap(channels.flatMap((channel) => channel.emoji_id ? [channel.emoji_id] : []), (id) => emojis.cache.get(emojis.resolveKey(id)))
 		]);
 		return bindClient(new WelcomeScreen({
 			...screen,
@@ -8187,22 +8354,23 @@ var GuildManager = class extends CachedManager {
 		}, {
 			guild,
 			channels: cachedChannels,
-			emojis
+			emojis: cachedEmojis
 		}), this.client);
 	}
 	async onboarding(guildId, onboarding) {
 		const options = onboarding.prompts.flatMap((prompt) => prompt.options);
-		const [guild, channels, roles, emojis] = await Promise.all([
+		const emojis = this.emojis(guildId);
+		const [guild, channels, roles, cachedEmojis] = await Promise.all([
 			this.cachedGuild(guildId),
-			cachedMap([...onboarding.default_channel_ids, ...options.flatMap((option) => option.channel_ids)], (id) => this.client.channels.get(id)),
-			cachedMap(options.flatMap((option) => option.role_ids), (id) => this.client.roles.get(guildId, id)),
-			cachedMap(options.flatMap((option) => option.emoji?.id ? [option.emoji.id] : []), (id) => this.emojis(guildId).get(id))
+			cachedMap([...onboarding.default_channel_ids, ...options.flatMap((option) => option.channel_ids)], (id) => this.client.channels.cache.get(id)),
+			cachedMap(options.flatMap((option) => option.role_ids), (id) => this.client.roles.cache.get(this.client.roles.resolveKey(guildId, id))),
+			cachedMap(options.flatMap((option) => option.emoji?.id ? [option.emoji.id] : []), (id) => emojis.cache.get(emojis.resolveKey(id)))
 		]);
 		return bindClient(new GuildOnboarding(onboarding, {
 			guild,
 			channels,
 			roles,
-			emojis
+			emojis: cachedEmojis
 		}), this.client);
 	}
 	async forget(guildId) {
@@ -8218,7 +8386,13 @@ var GuildManager = class extends CachedManager {
 };
 async function cachedMap(ids, get) {
 	const unique = [...new Set(ids)];
-	const values = await Promise.all(unique.map((id) => get(id).catch(() => void 0)));
+	const values = await Promise.all(unique.map(async (id) => {
+		try {
+			return await get(id);
+		} catch {
+			return;
+		}
+	}));
 	const map = /* @__PURE__ */ new Map();
 	for (const [index, value] of values.entries()) if (value) map.set(unique[index], value);
 	return map;
@@ -8234,117 +8408,219 @@ function toISO(value) {
 
 //#endregion
 //#region src/managers/GuildMemberRoleManager.ts
+const pick = {
+	highest: (roles) => roles[0] ?? null,
+	hoist: (roles) => roles.find((role) => role.hoist) ?? null,
+	color: (roles) => roles.find((role) => role.colors.primaryColor !== 0) ?? null,
+	icon: (roles) => roles.find((role) => role.icon ?? role.unicodeEmoji) ?? null,
+	premiumSubscriberRole: (roles) => roles.find((role) => role.tags?.premiumSubscriberRole) ?? null,
+	botRole: (roles, userId) => userId !== null && roles.find((role) => role.tags?.botId === userId) || null
+};
+function highestFirst(roles) {
+	return [...roles].toSorted((a, b) => b.comparePositionTo(a));
+}
 /**
-* Manages the roles of one {@link GuildMember}, reading them through the client's role manager.
+* Manages the roles of one {@link GuildMember}, like discord.js's `GuildMemberRoleManager`.
 *
 * @remarks
-* discord.js's synchronous `member.roles.cache`, `highest`, `color`, ... become the `fetch*` methods here: the roles
-* are read from the (possibly asynchronous) cache, falling back to the API.
+* The one deliberate difference from discord.js: {@link GuildMemberRoleManager.cache} and the getters reading it
+* (`highest`, `hoist`, `color`, ...) are `Awaitable`, like `manager.cache.get`. They are synchronous with the default
+* in-memory cache and a promise with a remote store, so `await` works with both.
+*
+* They only know the roles the cache holds. The `fetch*` methods fall back to the API when a role is not cached.
 */
-var GuildMemberRoleManager = class {
-	client;
-	guildId;
-	userId;
-	#roleIds;
+var GuildMemberRoleManager = class GuildMemberRoleManager extends BaseManager {
 	/**
-	* @param client The client.
-	* @param guildId The ID of the guild.
-	* @param userId The ID of the member's user.
-	* @param roleIds The IDs of the member's roles, as known to the member structure.
+	* The member these roles belong to.
 	*/
-	constructor(client, guildId, userId, roleIds) {
-		this.client = client;
-		this.guildId = guildId;
-		this.userId = userId;
-		this.#roleIds = roleIds;
+	member;
+	/**
+	* @param member The member.
+	*/
+	constructor(member) {
+		super(member.client);
+		this.member = member;
+	}
+	/**
+	* The member's guild, from the cache: `null` when it is not cached.
+	*/
+	get guild() {
+		return this.member.guild;
+	}
+	get guildId() {
+		return this.member.guildId;
+	}
+	/**
+	* The ID of the member's user.
+	*
+	* @throws {GatewayError} `GuildMemberUserUnknown` when the member's payload did not include its user.
+	*/
+	get userId() {
+		const { id } = this.member;
+		if (id === null) throw new GatewayError("GuildMemberUserUnknown");
+		return id;
 	}
 	/**
 	* The IDs of the member's roles, `@everyone` excluded.
 	*/
 	get ids() {
-		return this.#roleIds;
+		return this.member.roleIds;
+	}
+	/**
+	* The member's roles held in the cache, by ID, `@everyone` included. Roles that are not cached are skipped: use
+	* {@link GuildMemberRoleManager.fetch} to get them all.
+	*/
+	get cache() {
+		return cachedRoles(this.client, this.guildId, [...this.ids, this.guildId]);
+	}
+	/**
+	* The member's highest cached role. `null` when none of their roles is cached, `@everyone` included.
+	*/
+	get highest() {
+		return this.fromCache(pick.highest);
+	}
+	/**
+	* The cached role the member is displayed under in the member list, if any.
+	*/
+	get hoist() {
+		return this.fromCache(pick.hoist);
+	}
+	/**
+	* The highest cached role giving the member a color, if any.
+	*/
+	get color() {
+		return this.fromCache(pick.color);
+	}
+	/**
+	* The highest cached role giving the member an icon, if any.
+	*/
+	get icon() {
+		return this.fromCache(pick.icon);
+	}
+	/**
+	* The server booster role, if the member has it and it is cached.
+	*/
+	get premiumSubscriberRole() {
+		return this.fromCache(pick.premiumSubscriberRole);
+	}
+	/**
+	* The role Discord manages for the member, when the member is a bot and the role is cached.
+	*/
+	get botRole() {
+		return this.fromCache((roles) => pick.botRole(roles, this.member.id));
 	}
 	/**
 	* Fetches the member's roles, `@everyone` included, highest first.
 	*/
 	async fetch() {
-		const ids = [...this.#roleIds, this.guildId];
-		let roles = (await Promise.all(ids.map((id) => this.client.roles.get(this.guildId, id)))).filter((role) => role !== void 0);
-		if (roles.length !== ids.length) {
+		const ids = [...this.ids, this.guildId];
+		let roles = [...(await this.cache).values()];
+		if (roles.length !== new Set(ids).size) {
 			const wanted = new Set(ids);
 			roles = (await this.client.roles.fetchAll(this.guildId)).filter((role) => wanted.has(role.id));
 		}
-		return roles.toSorted((a, b) => b.comparePositionTo(a));
+		return highestFirst(roles);
 	}
 	/**
 	* Fetches the member's highest role, `@everyone` when they have no other.
 	*/
 	async fetchHighest() {
-		return (await this.fetch())[0] ?? null;
+		return pick.highest(await this.fetch());
 	}
 	/**
 	* Fetches the role the member is displayed under in the member list, if any.
 	*/
 	async fetchHoist() {
-		return (await this.fetch()).find((role) => role.hoist) ?? null;
+		return pick.hoist(await this.fetch());
 	}
 	/**
 	* Fetches the highest role giving the member a color, if any.
 	*/
 	async fetchColor() {
-		return (await this.fetch()).find((role) => role.color !== 0) ?? null;
+		return pick.color(await this.fetch());
 	}
 	/**
 	* Fetches the highest role giving the member an icon, if any.
 	*/
 	async fetchIcon() {
-		return (await this.fetch()).find((role) => role.icon ?? role.unicodeEmoji) ?? null;
+		return pick.icon(await this.fetch());
 	}
 	/**
 	* Fetches the server booster role, if the member has it.
 	*/
 	async fetchPremiumSubscriberRole() {
-		return (await this.fetch()).find((role) => role.tags?.premiumSubscriberRole) ?? null;
+		return pick.premiumSubscriberRole(await this.fetch());
 	}
 	/**
 	* Fetches the role Discord manages for the member, when the member is a bot.
 	*/
 	async fetchBotRole() {
-		return (await this.fetch()).find((role) => role.tags?.botId === this.userId) ?? null;
+		return pick.botRole(await this.fetch(), this.member.id);
 	}
 	/**
-	* Adds roles to the member.
+	* Adds a role, or several, to the member.
+	*
+	* @remarks
+	* A single role goes through its own endpoint and resolves to a copy of the member with the role added. Several
+	* roles replace the member's roles, like {@link GuildMemberRoleManager.set}.
 	*
-	* @param roles The ID of the role, or several IDs.
+	* @param roleOrRoles The role or its ID, or an array or `Collection` of them.
 	* @param reason The reason for the audit log.
+	* @returns The updated member.
 	*/
-	async add(roles, reason) {
-		if (typeof roles === "string") return this.client.members.addRole(this.guildId, this.userId, roles, reason);
-		return this.set([.../* @__PURE__ */ new Set([...this.#roleIds, ...roles])], reason);
+	async add(roleOrRoles, reason) {
+		if (isRoleResolvables(roleOrRoles)) return this.set([.../* @__PURE__ */ new Set([...this.ids, ...resolveRoleIds(roleOrRoles)])], reason);
+		const roleId = this.resolveSingle(roleOrRoles);
+		await this.client.members.addRole(this.guildId, this.userId, roleId, reason);
+		return this.member[kClone]({ roles: [.../* @__PURE__ */ new Set([...this.ids, roleId])] });
 	}
 	/**
-	* Removes roles from the member.
+	* Removes a role, or several, from the member.
+	*
+	* @remarks
+	* A single role goes through its own endpoint and resolves to a copy of the member with the role removed. Several
+	* roles replace the member's roles, like {@link GuildMemberRoleManager.set}.
 	*
-	* @param roles The ID of the role, or several IDs.
+	* @param roleOrRoles The role or its ID, or an array or `Collection` of them.
 	* @param reason The reason for the audit log.
+	* @returns The updated member.
 	*/
-	async remove(roles, reason) {
-		if (typeof roles === "string") return this.client.members.removeRole(this.guildId, this.userId, roles, reason);
-		const removed = new Set(roles);
-		return this.set(this.#roleIds.filter((id) => !removed.has(id)), reason);
+	async remove(roleOrRoles, reason) {
+		if (isRoleResolvables(roleOrRoles)) {
+			const removed = new Set(resolveRoleIds(roleOrRoles));
+			return this.set(this.ids.filter((id) => !removed.has(id)), reason);
+		}
+		const roleId = this.resolveSingle(roleOrRoles);
+		await this.client.members.removeRole(this.guildId, this.userId, roleId, reason);
+		return this.member[kClone]({ roles: this.ids.filter((id) => id !== roleId) });
 	}
 	/**
 	* Replaces the member's roles.
 	*
-	* @param roles The IDs of the roles the member ends up with.
+	* @param roles The roles the member ends up with: an array of roles or IDs, or a `Collection` of roles.
 	* @param reason The reason for the audit log.
+	* @returns The member, patched.
 	*/
 	set(roles, reason) {
-		return this.client.members.edit(this.guildId, this.userId, {
+		return this.member.edit({
 			roles,
 			reason
 		});
 	}
+	/**
+	* Creates another manager of the same member's roles.
+	*/
+	clone() {
+		return new GuildMemberRoleManager(this.member);
+	}
+	fromCache(picker) {
+		return whenAll([this.cache], ([cache]) => picker(highestFirst(cache.values())));
+	}
+	resolveSingle(role) {
+		const roleId = resolveRoleId(role);
+		if (roleId === null) throw new GatewayTypeError("InvalidType", "roles", "Role, Snowflake or Array or Collection of Roles or Snowflakes");
+		return roleId;
+	}
 };
 
 //#endregion
@@ -8419,10 +8695,10 @@ var GuildMember = class extends Structure {
 		return this[kData].roles;
 	}
 	/**
-	* The member's roles. It needs the member's user ID, which every payload but some partial ones carries.
+	* The member's roles. Changing them needs the member's user ID, which every payload but some partial ones carries.
 	*/
 	get roles() {
-		return new GuildMemberRoleManager(this.client, this.guildId, this.requireId(), this.roleIds);
+		return new GuildMemberRoleManager(this);
 	}
 	get joinedTimestamp() {
 		return this.optimizedTimestamp("joined_at");
@@ -8599,13 +8875,13 @@ var GuildMember = class extends Structure {
 	* @returns The presence, or `null` when it is not cached (the bot needs the `GuildPresences` intent).
 	*/
 	async fetchPresence() {
-		return await this.client.presences.get(this.guildId, this.requireId()) ?? null;
+		return await this.client.presences.cache.get(this.client.presences.resolveKey(this.guildId, this.requireId())) ?? null;
 	}
 	/**
 	* Fetches the color the member's name is displayed in, `0` when none of their roles has one.
 	*/
 	async fetchDisplayColor() {
-		return (await this.roles.fetchColor())?.color ?? 0;
+		return (await this.roles.fetchColor())?.colors.primaryColor ?? 0;
 	}
 	/**
 	* Fetches the color the member's name is displayed in, as a `#rrggbb` string.
@@ -8692,8 +8968,13 @@ var GuildMember = class extends Structure {
 		await this.client.members.ban(this.guildId, this.requireId(), options);
 		return this;
 	}
-	createDM() {
-		return this.client.users.createDM(this.requireId());
+	/**
+	* Opens a direct message channel with the member, reusing the cached one.
+	*
+	* @param force Whether to skip the cache lookup and always call the API.
+	*/
+	createDM(force = false) {
+		return this.client.users.createDM(this.requireId(), { force });
 	}
 	deleteDM() {
 		return this.client.users.deleteDM(this.requireId());
@@ -9303,7 +9584,7 @@ var GuildMemberManager = class extends CachedManager {
 	constructor(client) {
 		super(client, "members");
 	}
-	construct(data) {
+	createStructure(data) {
 		return new GuildMember(data);
 	}
 	keyOf(data) {
@@ -9334,15 +9615,15 @@ var GuildMemberManager = class extends CachedManager {
 		return whenAll([
 			data.user ? client.users._resolveData(data.user) : void 0,
 			this.cachedGuild(data.guild_id),
-			key ? client.cache?.voiceStates?.get(key) : void 0,
-			key ? client.cache?.presences?.get(key) : void 0
+			key ? this.readRelation("voiceStates", key) : void 0,
+			key ? this.readRelation("presences", key) : void 0
 		], ([user, guild, voiceData, presenceData]) => {
 			const relations = {
 				user,
 				guild
 			};
 			const member = bindClient(new GuildMember(data, relations), client);
-			return whenAll([voiceData?.channel_id ? client.channels._get(voiceData.channel_id) : void 0], ([channel]) => {
+			return whenAll([voiceData?.channel_id ? client.channels.cache.get(voiceData.channel_id) : void 0], ([channel]) => {
 				if (key && client.cache?.voiceStates) relations.voice = voiceData ? bindClient(new VoiceState(voiceData, {
 					member,
 					guild,
@@ -9357,6 +9638,10 @@ var GuildMemberManager = class extends CachedManager {
 			});
 		});
 	}
+	readRelation(name, key) {
+		const store = this.client.cache?.[name];
+		return this.client.guardCache(name, "get", key, () => store?.get(key), void 0);
+	}
 	resolveKey(guildId, userId) {
 		return memberKey(guildId, userId);
 	}
@@ -9497,7 +9782,7 @@ var GuildMemberManager = class extends CachedManager {
 		const body = {
 			access_token: options.accessToken,
 			nick: options.nick,
-			roles: options.roles ? [...options.roles] : void 0,
+			roles: options.roles ? resolveRoleIds(options.roles) : void 0,
 			mute: options.mute,
 			deaf: options.deaf
 		};
@@ -9515,7 +9800,7 @@ var GuildMemberManager = class extends CachedManager {
 		const until = options.communicationDisabledUntil;
 		const body = {
 			nick: options.nick,
-			roles: options.roles ? [...options.roles] : void 0,
+			roles: options.roles ? resolveRoleIds(options.roles) : void 0,
 			mute: options.mute,
 			deaf: options.deaf,
 			channel_id: options.channel,
@@ -9550,7 +9835,7 @@ var GuildMemberManager = class extends CachedManager {
 	*/
 	async kick(guildId, userId, reason) {
 		await this.client.api.guilds.removeMember(guildId, userId, { reason });
-		await this.cache?.delete(this.resolveKey(guildId, userId));
+		await this.cache.delete(this.resolveKey(guildId, userId));
 	}
 	/**
 	* Bans a user, member or not.
@@ -9562,7 +9847,7 @@ var GuildMemberManager = class extends CachedManager {
 	async ban(guildId, userId, options = {}) {
 		const body = { delete_message_seconds: options.deleteMessageSeconds };
 		await this.client.api.guilds.banUser(guildId, userId, body, { reason: options.reason });
-		await this.cache?.delete(this.resolveKey(guildId, userId));
+		await this.cache.delete(this.resolveKey(guildId, userId));
 	}
 	/**
 	* Lifts a user's ban.
@@ -9588,7 +9873,7 @@ var GuildMemberManager = class extends CachedManager {
 			delete_message_seconds: options.deleteMessageSeconds
 		};
 		const result = await this.client.api.guilds.bulkBanUsers(guildId, body, { reason: options.reason });
-		await Promise.all(result.banned_users.map((userId) => this.cache?.delete(this.resolveKey(guildId, userId))));
+		await Promise.all(result.banned_users.map((userId) => this.cache.delete(this.resolveKey(guildId, userId))));
 		return {
 			bannedUsers: result.banned_users,
 			failedUsers: result.failed_users
@@ -9643,24 +9928,19 @@ var GuildMemberManager = class extends CachedManager {
 			guild_id: guildId
 		};
 	}
-	store(guildId, member) {
+	async store(guildId, member) {
 		const raw = {
 			...member,
 			guild_id: guildId
 		};
-		return raw.user ? this._add(raw) : this.hydrate(raw);
+		return raw.user ? this._add(raw) : this._build(raw);
 	}
 	settle(nonce, request) {
 		if (request.timer) clearTimeout(request.timer);
 		this.#requests.delete(nonce);
 	}
 	async updateCachedRoles(guildId, userId, update) {
-		const key = this.resolveKey(guildId, userId);
-		const cached = await this.cache?.get(key);
-		if (cached) await this.cache.set(key, {
-			...cached,
-			roles: update(cached.roles)
-		});
+		await this._patchCached(this.resolveKey(guildId, userId), (cached) => ({ roles: update(cached.roleIds) }));
 	}
 };
 
@@ -9669,8 +9949,7 @@ var GuildMemberManager = class extends CachedManager {
 /**
 * Manages the users who reacted to a message with one emoji.
 */
-var ReactionUserManager = class {
-	client;
+var ReactionUserManager = class extends BaseManager {
 	channelId;
 	messageId;
 	/**
@@ -9678,7 +9957,7 @@ var ReactionUserManager = class {
 	*/
 	emoji;
 	constructor(client, channelId, messageId, emoji) {
-		this.client = client;
+		super(client);
 		this.channelId = channelId;
 		this.messageId = messageId;
 		this.emoji = emoji;
@@ -9842,8 +10121,7 @@ Mixin(MessageReaction, [StructureMixin]);
 /**
 * Manages the reactions of one message, as they were in the message's payload.
 */
-var ReactionManager = class {
-	client;
+var ReactionManager = class extends BaseManager {
 	channelId;
 	messageId;
 	#reactions;
@@ -9858,7 +10136,7 @@ var ReactionManager = class {
 	* @param emojis The cached custom emojis of the reactions, by ID.
 	*/
 	constructor(client, channelId, messageId, reactions, message = null, emojis) {
-		this.client = client;
+		super(client);
 		this.channelId = channelId;
 		this.messageId = messageId;
 		this.#reactions = reactions;
@@ -11383,7 +11661,7 @@ var Message = class Message extends Message$1 {
 		const resolved = this[kRelations].thread;
 		if (resolved) return resolved;
 		const { thread } = this[kData];
-		return thread ? this.client.threads.construct(thread) : null;
+		return thread ? this.client.threads.cache.construct(thread) : null;
 	}
 	/**
 	* The content with user, role, and channel mentions replaced by names, and `@everyone`/`@here` defused, like
@@ -11621,7 +11899,7 @@ var MessageManager = class extends CachedManager {
 	constructor(client) {
 		super(client, "messages");
 	}
-	construct(data) {
+	createStructure(data) {
 		return new Message(data);
 	}
 	keyOf(data) {
@@ -11646,15 +11924,15 @@ var MessageManager = class extends CachedManager {
 	_hydrate(data) {
 		const { author, member, guild_id: guildId } = data;
 		return whenAll([
-			data.webhook_id ? this.client.users.construct(author) : this.client.users._resolveData(author),
+			data.webhook_id ? this.client.users.cache.construct(author) : this.client.users._resolveData(author),
 			member && guildId ? this.client.members._resolveData({
 				...member,
 				user: author,
 				guild_id: guildId
 			}) : null,
 			this.cachedGuild(guildId),
-			this.client.channels._get(data.channel_id),
-			data.thread !== void 0 || ((data.flags ?? 0) & MessageFlags.HasThread) !== 0 ? this.client.threads._get(data.id) : void 0,
+			this.client.channels.cache.get(data.channel_id),
+			data.thread !== void 0 || ((data.flags ?? 0) & MessageFlags.HasThread) !== 0 ? this.client.threads.cache.get(data.id) : void 0,
 			this.resolveMentions(data),
 			guildId ? this.resolveEmojis(guildId, data) : void 0
 		], ([resolvedAuthor, resolvedMember, guild, channel, thread, mentions, emojis]) => new Message(data, {
@@ -11688,7 +11966,7 @@ var MessageManager = class extends CachedManager {
 	resolveEmojis(guildId, data) {
 		const ids = [...(data.reactions ?? []).map((reaction) => reaction.emoji.id), ...(data.poll?.answers ?? []).map((answer) => answer.poll_media.emoji?.id)].filter((id) => Boolean(id));
 		const emojis = this.client.guilds.emojis(guildId);
-		return whenCachedMap(ids, (id) => emojis._get(id));
+		return whenCachedMap(ids, (id) => emojis.cache.get(emojis.resolveKey(id)));
 	}
 	resolveKey(channelId, messageId) {
 		return messageKey(channelId, messageId);
@@ -11759,7 +12037,7 @@ var MessageManager = class extends CachedManager {
 	*/
 	async delete(channelId, messageId, reason) {
 		await this.client.api.channels.deleteMessage(channelId, messageId, { reason });
-		await this.cache?.delete(this.resolveKey(channelId, messageId));
+		await this.cache.delete(this.resolveKey(channelId, messageId));
 	}
 	/**
 	* Deletes up to 100 messages at once, skipping the ones older than 14 days that Discord refuses.
@@ -11779,7 +12057,7 @@ var MessageManager = class extends CachedManager {
 		if (ids.length === 1) await this.delete(channelId, ids[0]);
 		else {
 			await this.client.api.channels.bulkDeleteMessages(channelId, ids);
-			await Promise.all(ids.map((id) => this.cache?.delete(this.resolveKey(channelId, id))));
+			await Promise.all(ids.map((id) => this.cache.delete(this.resolveKey(channelId, id))));
 		}
 		return ids;
 	}
@@ -11811,7 +12089,7 @@ var MessageManager = class extends CachedManager {
 	*/
 	async pin(channelId, messageId, reason) {
 		await this.client.api.channels.pinMessage(channelId, messageId, { reason });
-		await this.patchCached(channelId, messageId, { pinned: true });
+		await this._patchCached(this.resolveKey(channelId, messageId), { pinned: true });
 	}
 	/**
 	* Unpins a message.
@@ -11822,7 +12100,7 @@ var MessageManager = class extends CachedManager {
 	*/
 	async unpin(channelId, messageId, reason) {
 		await this.client.api.channels.unpinMessage(channelId, messageId, { reason });
-		await this.patchCached(channelId, messageId, { pinned: false });
+		await this._patchCached(this.resolveKey(channelId, messageId), { pinned: false });
 	}
 	/**
 	* Publishes a message of an announcement channel to the channels following it.
@@ -11862,7 +12140,7 @@ var MessageManager = class extends CachedManager {
 	*/
 	async removeAllReactions(channelId, messageId) {
 		await this.client.api.channels.deleteAllMessageReactions(channelId, messageId);
-		await this.patchCached(channelId, messageId, { reactions: [] });
+		await this._patchCached(this.resolveKey(channelId, messageId), { reactions: [] });
 	}
 	/**
 	* Starts a thread from a message.
@@ -11908,14 +12186,6 @@ var MessageManager = class extends CachedManager {
 	store(message) {
 		return this._add(message);
 	}
-	async patchCached(channelId, messageId, patch) {
-		const key = this.resolveKey(channelId, messageId);
-		const cached = await this.cache?.get(key);
-		if (cached) await this.cache.set(key, {
-			...cached,
-			...patch
-		});
-	}
 };
 
 //#endregion
@@ -12150,7 +12420,7 @@ var RoleManager = class extends CachedManager {
 	constructor(client) {
 		super(client, "roles");
 	}
-	construct(data) {
+	createStructure(data) {
 		return new Role(data);
 	}
 	keyOf(data) {
@@ -12213,7 +12483,7 @@ var RoleManager = class extends CachedManager {
 	*/
 	async delete(guildId, roleId, reason) {
 		await this.client.api.guilds.deleteRole(guildId, roleId, { reason });
-		await this.cache?.delete(this.resolveKey(guildId, roleId));
+		await this.cache.delete(this.resolveKey(guildId, roleId));
 	}
 	/**
 	* Moves a role among the roles of its guild, like discord.js's `RoleManager#setPosition`.
@@ -12333,10 +12603,9 @@ async function toRoleBody(options) {
 * Methods taking a webhook's token call the API with it rather than with the bot's authorization, so they work for
 * webhooks of other applications too.
 */
-var WebhookManager = class {
-	client;
+var WebhookManager = class extends BaseManager {
 	constructor(client) {
-		this.client = client;
+		super(client);
 	}
 	/**
 	* Fetches a webhook.
@@ -12480,11 +12749,11 @@ var WebhookManager = class {
 	*/
 	async hydrate(data) {
 		const [guild, channel, sourceGuild, sourceChannel, owner] = await Promise.all([
-			data.guild_id ? this.client.guilds.get(data.guild_id) : void 0,
-			data.channel_id ? this.client.channels.get(data.channel_id) : void 0,
-			data.source_guild ? this.client.guilds.get(data.source_guild.id) : void 0,
-			data.source_channel ? this.client.channels.get(data.source_channel.id) : void 0,
-			data.user ? this.client.users.resolveData(data.user) : void 0
+			data.guild_id ? this.client.guilds.cache.get(data.guild_id) : void 0,
+			data.channel_id ? this.client.channels.cache.get(data.channel_id) : void 0,
+			data.source_guild ? this.client.guilds.cache.get(data.source_guild.id) : void 0,
+			data.source_channel ? this.client.channels.cache.get(data.source_channel.id) : void 0,
+			data.user ? this.client.users._resolveData(data.user) : void 0
 		]);
 		return bindClient(new Webhook(data, {
 			guild: guild ?? null,
@@ -12622,10 +12891,9 @@ var GuildTemplate = class extends Structure {
 /**
 * Manages guild templates. Discord does not send them over the gateway, so they are never cached.
 */
-var GuildTemplateManager = class {
-	client;
+var GuildTemplateManager = class extends BaseManager {
 	constructor(client) {
-		this.client = client;
+		super(client);
 	}
 	/**
 	* Fetches a template by its code.
@@ -12708,7 +12976,7 @@ var GuildTemplateManager = class {
 	}
 	async build(template) {
 		const creator = await this.client.users._add(template.creator);
-		const guild = await this.client.guilds.get(template.source_guild_id) ?? null;
+		const guild = await this.client.guilds.cache.get(template.source_guild_id) ?? null;
 		return new GuildTemplate(template, {
 			guild,
 			creator
@@ -12729,7 +12997,7 @@ var VoiceStateManager = class extends CachedManager {
 	constructor(client) {
 		super(client, "voiceStates");
 	}
-	construct(data) {
+	createStructure(data) {
 		return new VoiceState(data);
 	}
 	keyOf(data) {
@@ -12745,9 +13013,9 @@ var VoiceStateManager = class extends CachedManager {
 			member?.user && guildId ? this.client.members._resolveData({
 				...member,
 				guild_id: guildId
-			}) : guildId ? this.client.members._get(guildId, userId) : null,
+			}) : guildId ? this.client.members.cache.get(this.client.members.resolveKey(guildId, userId)) : null,
 			this.cachedGuild(guildId),
-			data.channel_id ? this.client.channels._get(data.channel_id) : void 0
+			data.channel_id ? this.client.channels.cache.get(data.channel_id) : void 0
 		], ([resolvedMember, guild, channel]) => new VoiceState(data, {
 			member: resolvedMember ?? null,
 			guild,
@@ -12763,8 +13031,9 @@ var VoiceStateManager = class extends CachedManager {
 	*/
 	async listCached(guildId) {
 		const prefix = `${guildId}:`;
-		const entries = await this.iterableCache()?.entries() ?? [];
-		return Promise.all(entries.filter(([key]) => key.startsWith(prefix)).map(([, raw]) => this.hydrate(raw)));
+		const cache = this.iterableCache();
+		const entries = cache ? await this.guard("entries", null, () => cache.entries(), []) : [];
+		return Promise.all(entries.filter(([key]) => key.startsWith(prefix)).map(([, raw]) => this._build(raw)));
 	}
 	async fetchRaw(guildId, userId) {
 		const client = this.client;
@@ -12783,13 +13052,13 @@ var VoiceStateManager = class extends CachedManager {
 *
 * @remarks
 * Presences only come from the gateway, with the `GuildPresences` intent: there is no API to fetch them, so `fetch`
-* rejects on a cache miss. Use `get`, which resolves to `undefined` instead.
+* rejects on a cache miss. Use `cache.get`, which answers `undefined` instead.
 */
 var PresenceManager = class extends CachedManager {
 	constructor(client) {
 		super(client, "presences");
 	}
-	construct(data) {
+	createStructure(data) {
 		return new Presence(data);
 	}
 	keyOf(data) {
@@ -12800,8 +13069,8 @@ var PresenceManager = class extends CachedManager {
 	}
 	_hydrate(data) {
 		return whenAll([
-			this.client.users._get(data.user.id),
-			this.client.members._get(data.guild_id, data.user.id),
+			this.client.users.cache.get(data.user.id),
+			this.client.members.cache.get(this.client.members.resolveKey(data.guild_id, data.user.id)),
 			this.cachedGuild(data.guild_id)
 		], ([user, member, guild]) => new Presence(data, {
 			user: user ?? null,
@@ -12818,8 +13087,9 @@ var PresenceManager = class extends CachedManager {
 	*/
 	async listCached(guildId) {
 		const prefix = `${guildId}:`;
-		const entries = await this.iterableCache()?.entries() ?? [];
-		return Promise.all(entries.filter(([key]) => key.startsWith(prefix)).map(([, raw]) => this.hydrate(raw)));
+		const cache = this.iterableCache();
+		const entries = cache ? await this.guard("entries", null, () => cache.entries(), []) : [];
+		return Promise.all(entries.filter(([key]) => key.startsWith(prefix)).map(([, raw]) => this._build(raw)));
 	}
 	fetchRaw(guildId, userId) {
 		return Promise.reject(new GatewayError("PresenceNotFetchable", guildId, userId));
@@ -12835,7 +13105,7 @@ var ThreadManager = class extends CachedManager {
 	constructor(client) {
 		super(client, "threads");
 	}
-	construct(data) {
+	createStructure(data) {
 		return createChannel(data);
 	}
 	keyOf(data) {
@@ -13026,7 +13296,7 @@ var ThreadMemberManager = class extends CachedManager {
 	constructor(client) {
 		super(client, "threadMembers");
 	}
-	construct(data) {
+	createStructure(data) {
 		return new ThreadMember(data);
 	}
 	keyOf(data) {
@@ -13055,9 +13325,9 @@ var ThreadMemberManager = class extends CachedManager {
 			member?.user && guildId ? this.client.members._resolveData({
 				...member,
 				guild_id: guildId
-			}) : guildId && userId ? this.client.members._get(guildId, userId) : null,
-			data.id ? this.client.threads._get(data.id) : void 0,
-			userId ? this.client.users._get(userId) : void 0
+			}) : guildId && userId ? this.client.members.cache.get(this.client.members.resolveKey(guildId, userId)) : null,
+			data.id ? this.client.threads.cache.get(data.id) : void 0,
+			userId ? this.client.users.cache.get(userId) : void 0
 		], ([guildMember, thread, user]) => new ThreadMember(data, {
 			guildMember: guildMember ?? null,
 			thread: thread ?? null,
@@ -13113,7 +13383,7 @@ var ThreadMemberManager = class extends CachedManager {
 		if (userId === "@me") await this.client.api.threads.leave(threadId);
 		else await this.client.api.threads.removeMember(threadId, userId);
 		const cachedId = userId === "@me" ? this.client.user?.id ?? this.client.id : userId;
-		await this.cache?.delete(this.resolveKey(threadId, cachedId));
+		await this.cache.delete(this.resolveKey(threadId, cachedId));
 	}
 	async fetchRaw(threadId, userId) {
 		const member = await this.client.api.threads.getMember(threadId, userId);
@@ -13127,7 +13397,7 @@ var ThreadMemberManager = class extends CachedManager {
 		} : member;
 	}
 	async guildIdOf(threadId) {
-		return ((await this.client.threads.get(threadId))?.toJSON())?.guild_id;
+		return ((await this.client.threads.cache.get(threadId))?.toJSON())?.guild_id;
 	}
 };
 
@@ -13140,7 +13410,7 @@ var UserManager = class extends CachedManager {
 	constructor(client) {
 		super(client, "users");
 	}
-	construct(data) {
+	createStructure(data) {
 		return new User(data);
 	}
 	keyOf(data) {
@@ -13150,43 +13420,102 @@ var UserManager = class extends CachedManager {
 		return userId;
 	}
 	/**
-	* Opens a direct message channel with a user, or gets the existing one, and caches it.
+	* Resolves a {@link UserResolvable} to a user: the user of a member or a thread member, the author of a message, or
+	* the cached user of an ID.
+	*
+	* @param user The user, something holding one, or an ID.
+	* @returns The user, or `null` if it is not known.
+	*/
+	resolve(user) {
+		if (typeof user === "string" || user instanceof User) return super.resolve(user);
+		if (user instanceof Message) return user.author;
+		return user.user;
+	}
+	/**
+	* Resolves a {@link UserResolvable} to a user ID.
+	*
+	* @param user The user, something holding one, or an ID.
+	* @returns The ID, or `null` if the value holds none.
+	*/
+	resolveId(user) {
+		return super.resolveId(user instanceof Message ? user.author : user);
+	}
+	/**
+	* Gets a user from the cache, fetching it from the API (and caching it) on a cache miss.
+	*
+	* @param user The user, something holding one, or an ID.
+	* @param options Whether to skip the cache, and whether to store the result.
+	*/
+	fetch(user, options = {}) {
+		return super.fetch(this.requireId(user), options);
+	}
+	/**
+	* Gets the cached direct message channel with a user.
 	*
 	* @remarks
-	* Discord returns the existing channel when there is one, so this always calls the API: unlike discord.js, there is
-	* no synchronous `dmChannel` lookup to try first.
+	* It searches the channel cache, which only a synchronous cache that can enumerate its entries allows: the default
+	* `CollectionCache` and the in-memory stores. Other caches (a Redis store, `cache: null`) answer `null`.
 	*
-	* @param userId The ID of the user.
+	* @param user The user, something holding one, or an ID.
+	* @returns The channel, or `null` when there is none or the cache cannot be searched.
 	*/
-	async createDM(userId) {
+	dmChannel(user) {
+		return whenAll([this.client.channels._findDM(this.requireId(user))], ([channel]) => channel ?? null);
+	}
+	/**
+	* Opens a direct message channel with a user, and caches it. The cached channel is returned without calling the
+	* API, unless `force` is set.
+	*
+	* @param user The user, something holding one, or an ID.
+	* @param options Whether to skip the cache, and whether to store the result.
+	*/
+	async createDM(user, { cache = true, force = false } = {}) {
+		const userId = this.requireId(user);
+		if (!force) {
+			const cached = await this.client.channels._findDM(userId);
+			if (cached && !cached.partial) return cached;
+		}
 		const channel = await this.client.api.users.createDM(userId);
-		return await this.client.channels._add(channel);
+		return await this.client.channels._add(channel, cache);
 	}
 	/**
 	* Closes the direct message channel with a user.
 	*
-	* @param userId The ID of the user.
+	* @remarks
+	* When the channel cache cannot be searched (see {@link UserManager.dmChannel}), whether a channel exists is
+	* unknown: Discord is asked for it first, and nothing is thrown.
+	*
+	* @param user The user, something holding one, or an ID.
 	* @returns The closed channel.
+	* @throws {GatewayError} `UserNoDMChannel` when the cache was searched and holds no channel with the user.
 	*/
-	async deleteDM(userId) {
-		const channel = await this.createDM(userId);
+	async deleteDM(user) {
+		const userId = this.requireId(user);
+		const cached = await this.client.channels._findDM(userId);
+		if (cached === null) throw new GatewayError("UserNoDMChannel");
+		const channel = cached ?? await this.createDM(userId, { force: true });
 		await this.client.api.channels.delete(channel.id);
-		await this.client.cache?.channels?.delete(channel.id);
+		await this.client.channels.cache.delete(channel.id);
 		return channel;
 	}
 	/**
 	* Sends a direct message to a user.
 	*
-	* @param userId The ID of the user.
+	* @param user The user, something holding one, or an ID.
 	* @param options The message, or its content.
 	*/
-	async send(userId, options) {
-		const channel = await this.createDM(userId);
+	async send(user, options) {
+		const channel = await this.createDM(user);
 		return this.client.messages.send(channel.id, options);
 	}
 	async fetchRaw(userId) {
 		return this.client.api.users.get(userId);
 	}
+	requireId(user) {
+		const id = this.resolveId(user);
+		if (id === null) throw new GatewayTypeError("IdUnresolvable");
+		return id;
+	}
 };
 
 //#endregion
@@ -13747,6 +14076,15 @@ const Partials = {
 
 //#endregion
 //#region src/util/dispatch.ts
+async function previousOf(manager, ...args) {
+	const key = manager.resolveKey(...args);
+	const held = await peekCache(manager.cache, key);
+	if (held === void 0) return void 0;
+	return (Object.keys(held[kRelations]).length === 0 ? await manager.cache.get(key) : held)?.[kClone]();
+}
+function cachedOf(manager, ...args) {
+	return manager.cache.get(manager.resolveKey(...args));
+}
 /**
 * The table mapping every supported dispatch to its event.
 *
@@ -13765,30 +14103,30 @@ const DispatchHandlers = {
 	},
 	[GatewayDispatchEvents.GuildCreate]: {
 		event: "guildCreate",
-		build: async (client, data) => [await cachedOrUndefined(client.guilds.get(data.id)) ?? await client.guilds.hydrate(data)]
+		build: async (client, data) => [await cachedOrUndefined(() => client.guilds.cache.get(data.id)) ?? await client.guilds._build(data)]
 	},
 	[GatewayDispatchEvents.GuildUpdate]: {
 		event: "guildUpdate",
-		before: (client, data) => client.guilds.get(data.id),
-		build: async (client, data, previous) => [previous ?? null, await client.guilds.hydrate(data)]
+		before: (client, data) => previousOf(client.guilds, data.id),
+		build: async (client, data, previous) => [previous ?? null, await client.guilds._build(data)]
 	},
 	[GatewayDispatchEvents.GuildDelete]: {
 		event: "guildDelete",
-		before: (client, data) => client.guilds.get(data.id),
+		before: (client, data) => previousOf(client.guilds, data.id),
 		build: (_client, data, previous) => [previous ?? null, data]
 	},
 	[GatewayDispatchEvents.ChannelCreate]: {
 		event: "channelCreate",
-		build: async (client, data) => [await client.channels.hydrate(data)]
+		build: async (client, data) => [await client.channels._build(data)]
 	},
 	[GatewayDispatchEvents.ChannelUpdate]: {
 		event: "channelUpdate",
-		before: (client, data) => client.channels.get(data.id),
-		build: async (client, data, previous) => [previous ?? null, await client.channels.hydrate(data)]
+		before: (client, data) => previousOf(client.channels, data.id),
+		build: async (client, data, previous) => [previous ?? null, await client.channels._build(data)]
 	},
 	[GatewayDispatchEvents.ChannelDelete]: {
 		event: "channelDelete",
-		build: async (client, data) => [await client.channels.hydrate(data)]
+		build: async (client, data) => [await client.channels._build(data)]
 	},
 	[GatewayDispatchEvents.ChannelPinsUpdate]: {
 		event: "channelPinsUpdate",
@@ -13800,23 +14138,23 @@ const DispatchHandlers = {
 	},
 	[GatewayDispatchEvents.ThreadCreate]: {
 		event: "threadCreate",
-		build: async (client, data) => [await client.threads.hydrate(data)]
+		build: async (client, data) => [await client.threads._build(data)]
 	},
 	[GatewayDispatchEvents.ThreadUpdate]: {
 		event: "threadUpdate",
-		before: (client, data) => client.threads.get(data.id),
-		build: async (client, data, previous) => [previous ?? null, await client.threads.hydrate(data)]
+		before: (client, data) => previousOf(client.threads, data.id),
+		build: async (client, data, previous) => [previous ?? null, await client.threads._build(data)]
 	},
 	[GatewayDispatchEvents.ThreadDelete]: {
 		event: "threadDelete",
-		before: (client, data) => client.threads.get(data.id),
+		before: (client, data) => previousOf(client.threads, data.id),
 		build: (_client, data, previous) => [previous ?? null, data]
 	},
 	[GatewayDispatchEvents.ThreadListSync]: {
 		event: "threadListSync",
 		build: async (client, data) => [
-			await Promise.all(data.threads.map((thread) => client.threads.hydrate(thread))),
-			await Promise.all(data.members.map((member) => client.threadMembers.hydrate({
+			await Promise.all(data.threads.map((thread) => client.threads._build(thread))),
+			await Promise.all(data.members.map((member) => client.threadMembers._build({
 				...member,
 				guild_id: data.guild_id
 			}))),
@@ -13825,43 +14163,43 @@ const DispatchHandlers = {
 	},
 	[GatewayDispatchEvents.ThreadMemberUpdate]: {
 		event: "threadMemberUpdate",
-		before: (client, data) => data.id && data.user_id ? client.threadMembers.get(data.id, data.user_id) : Promise.resolve(void 0),
-		build: async (client, data, previous) => [previous ?? (data.id && data.user_id ? partialThreadMember(client, data.id, data.user_id, data.guild_id) : null), await client.threadMembers.hydrate(data)]
+		before: (client, data) => data.id && data.user_id ? previousOf(client.threadMembers, data.id, data.user_id) : Promise.resolve(void 0),
+		build: async (client, data, previous) => [previous ?? (data.id && data.user_id ? partialThreadMember(client, data.id, data.user_id, data.guild_id) : null), await client.threadMembers._build(data)]
 	},
 	[GatewayDispatchEvents.ThreadMembersUpdate]: {
 		event: "threadMembersUpdate",
 		before: async (client, data) => {
-			return (await Promise.all((data.removed_member_ids ?? []).map((userId) => client.threadMembers.get(data.id, userId)))).filter((member) => member !== void 0);
+			return (await Promise.all((data.removed_member_ids ?? []).map((userId) => previousOf(client.threadMembers, data.id, userId)))).filter((member) => member !== void 0);
 		},
 		build: async (client, data, previous) => [
-			await Promise.all((data.added_members ?? []).map((member) => client.threadMembers.hydrate({
+			await Promise.all((data.added_members ?? []).map((member) => client.threadMembers._build({
 				...member,
 				id: data.id,
 				guild_id: data.guild_id
 			}))),
 			withPartials(previous ?? [], data.removed_member_ids ?? [], (userId) => partialThreadMember(client, data.id, userId, data.guild_id)),
-			await cachedOrUndefined(client.threads.get(data.id)) ?? null,
+			await cachedOrUndefined(() => client.threads.cache.get(data.id)) ?? null,
 			data
 		]
 	},
 	[GatewayDispatchEvents.MessageCreate]: {
 		event: "messageCreate",
-		build: async (client, data) => [await client.messages.hydrate(data)]
+		build: async (client, data) => [await client.messages._build(data)]
 	},
 	[GatewayDispatchEvents.MessageUpdate]: {
 		event: "messageUpdate",
-		before: (client, data) => client.messages.get(data.channel_id, data.id),
-		build: async (client, data, previous) => [previous ?? partialMessage(client, data.channel_id, data.id, data.guild_id), await client.messages.hydrate(data)]
+		before: (client, data) => previousOf(client.messages, data.channel_id, data.id),
+		build: async (client, data, previous) => [previous ?? partialMessage(client, data.channel_id, data.id, data.guild_id), await client.messages._build(data)]
 	},
 	[GatewayDispatchEvents.MessageDelete]: {
 		event: "messageDelete",
-		before: (client, data) => client.messages.get(data.channel_id, data.id),
+		before: (client, data) => previousOf(client.messages, data.channel_id, data.id),
 		build: (client, data, previous) => [previous ?? partialMessage(client, data.channel_id, data.id, data.guild_id), data]
 	},
 	[GatewayDispatchEvents.MessageDeleteBulk]: {
 		event: "messageDeleteBulk",
 		before: async (client, data) => {
-			return (await Promise.all(data.ids.map((id) => client.messages.get(data.channel_id, id)))).filter((message) => message !== void 0);
+			return (await Promise.all(data.ids.map((id) => previousOf(client.messages, data.channel_id, id)))).filter((message) => message !== void 0);
 		},
 		build: (client, data, previous) => [withPartials(previous ?? [], data.ids, (id) => partialMessage(client, data.channel_id, id, data.guild_id)), data]
 	},
@@ -13869,7 +14207,7 @@ const DispatchHandlers = {
 		event: "messageReactionAdd",
 		build: async (client, data) => [
 			await reactionOf(client, data),
-			await cachedOrUndefined(client.users.get(data.user_id)) ?? partialUser(client, data.user_id),
+			await cachedOrUndefined(() => client.users.cache.get(data.user_id)) ?? partialUser(client, data.user_id),
 			{
 				userId: data.user_id,
 				type: data.type,
@@ -13881,7 +14219,7 @@ const DispatchHandlers = {
 		event: "messageReactionRemove",
 		build: async (client, data) => [
 			await reactionOf(client, data),
-			await cachedOrUndefined(client.users.get(data.user_id)) ?? partialUser(client, data.user_id),
+			await cachedOrUndefined(() => client.users.cache.get(data.user_id)) ?? partialUser(client, data.user_id),
 			{
 				userId: data.user_id,
 				type: data.type,
@@ -13891,16 +14229,16 @@ const DispatchHandlers = {
 	},
 	[GatewayDispatchEvents.MessageReactionRemoveAll]: {
 		event: "messageReactionRemoveAll",
-		before: async (client, data) => (await client.messages.get(data.channel_id, data.message_id))?.reactions.cache ?? [],
+		before: async (client, data) => (await previousOf(client.messages, data.channel_id, data.message_id))?.reactions.cache ?? [],
 		build: async (client, data, previous) => [
-			await cachedOrUndefined(client.messages.get(data.channel_id, data.message_id)) ?? partialMessage(client, data.channel_id, data.message_id, data.guild_id),
+			await cachedOrUndefined(() => cachedOf(client.messages, data.channel_id, data.message_id)) ?? partialMessage(client, data.channel_id, data.message_id, data.guild_id),
 			previous ?? [],
 			data
 		]
 	},
 	[GatewayDispatchEvents.MessageReactionRemoveEmoji]: {
 		event: "messageReactionRemoveEmoji",
-		before: async (client, data) => (await client.messages.get(data.channel_id, data.message_id))?.reactions.resolve(data.emoji) ?? void 0,
+		before: async (client, data) => (await previousOf(client.messages, data.channel_id, data.message_id))?.reactions.resolve(data.emoji) ?? void 0,
 		build: async (client, data, previous) => [previous ?? await partialReaction(client, data)]
 	},
 	[GatewayDispatchEvents.MessagePollVoteAdd]: {
@@ -13913,25 +14251,25 @@ const DispatchHandlers = {
 	},
 	[GatewayDispatchEvents.GuildMemberAdd]: {
 		event: "guildMemberAdd",
-		build: async (client, data) => [await client.members.hydrate(data)]
+		build: async (client, data) => [await client.members._build(data)]
 	},
 	[GatewayDispatchEvents.GuildMemberUpdate]: {
 		event: "guildMemberUpdate",
-		before: (client, data) => client.members.get(data.guild_id, data.user.id),
-		build: async (client, data, previous) => [previous ?? partialMember(client, data.guild_id, { id: data.user.id }), await cachedOrUndefined(client.members.get(data.guild_id, data.user.id)) ?? await client.members.hydrate(data)]
+		before: (client, data) => previousOf(client.members, data.guild_id, data.user.id),
+		build: async (client, data, previous) => [previous ?? partialMember(client, data.guild_id, { id: data.user.id }), await cachedOrUndefined(() => cachedOf(client.members, data.guild_id, data.user.id)) ?? await client.members._build(data)]
 	},
 	[GatewayDispatchEvents.GuildMemberRemove]: {
 		event: "guildMemberRemove",
-		before: (client, data) => client.members.get(data.guild_id, data.user.id),
+		before: (client, data) => previousOf(client.members, data.guild_id, data.user.id),
 		build: (client, data, previous) => [previous ?? partialMember(client, data.guild_id, data.user), data]
 	},
 	[GatewayDispatchEvents.GuildMembersChunk]: {
 		event: "guildMembersChunk",
 		build: async (client, data) => {
-			const [members, guild] = await Promise.all([Promise.all(data.members.map((member) => client.members.hydrate({
+			const [members, guild] = await Promise.all([Promise.all(data.members.map((member) => client.members._build({
 				...member,
 				guild_id: data.guild_id
-			}))), cachedOrUndefined(client.guilds.get(data.guild_id))]);
+			}))), cachedOrUndefined(() => client.guilds.cache.get(data.guild_id))]);
 			client.members.handleChunk(members, data);
 			return [
 				members,
@@ -13942,31 +14280,31 @@ const DispatchHandlers = {
 	},
 	[GatewayDispatchEvents.GuildRoleCreate]: {
 		event: "guildRoleCreate",
-		build: async (client, data) => [await client.roles.hydrate({
+		build: async (client, data) => [await client.roles._build({
 			...data.role,
 			guild_id: data.guild_id
 		})]
 	},
 	[GatewayDispatchEvents.GuildRoleUpdate]: {
 		event: "guildRoleUpdate",
-		before: (client, data) => client.roles.get(data.guild_id, data.role.id),
-		build: async (client, data, previous) => [previous ?? null, await client.roles.hydrate({
+		before: (client, data) => previousOf(client.roles, data.guild_id, data.role.id),
+		build: async (client, data, previous) => [previous ?? null, await client.roles._build({
 			...data.role,
 			guild_id: data.guild_id
 		})]
 	},
 	[GatewayDispatchEvents.GuildRoleDelete]: {
 		event: "guildRoleDelete",
-		before: (client, data) => client.roles.get(data.guild_id, data.role_id),
+		before: (client, data) => previousOf(client.roles, data.guild_id, data.role_id),
 		build: (_client, data, previous) => [previous ?? null, data]
 	},
 	[GatewayDispatchEvents.InviteCreate]: {
 		event: "inviteCreate",
-		build: async (client, data) => [data.guild_id ? await client.guilds.invites(data.guild_id).hydrate(data) : bindClient(new GuildInvite(data, { channel: await cachedOrUndefined(client.channels.get(data.channel_id)) ?? null }), client)]
+		build: async (client, data) => [data.guild_id ? await client.guilds.invites(data.guild_id)._build(data) : bindClient(new GuildInvite(data, { channel: await cachedOrUndefined(() => client.channels.cache.get(data.channel_id)) ?? null }), client)]
 	},
 	[GatewayDispatchEvents.InviteDelete]: {
 		event: "inviteDelete",
-		before: async (client, data) => data.guild_id ? client.guilds.invites(data.guild_id).get(data.code) : void 0,
+		before: async (client, data) => data.guild_id ? previousOf(client.guilds.invites(data.guild_id), data.code) : void 0,
 		build: (_client, data, previous) => [previous ?? null, data]
 	},
 	[GatewayDispatchEvents.TypingStart]: {
@@ -13975,99 +14313,100 @@ const DispatchHandlers = {
 	},
 	[GatewayDispatchEvents.VoiceStateUpdate]: {
 		event: "voiceStateUpdate",
-		before: async (client, data) => data.guild_id ? client.voiceStates.get(data.guild_id, data.user_id) : void 0,
-		build: async (client, data, previous) => [previous ?? null, await client.voiceStates.hydrate(data)]
+		before: async (client, data) => data.guild_id ? previousOf(client.voiceStates, data.guild_id, data.user_id) : void 0,
+		build: async (client, data, previous) => [previous ?? null, await client.voiceStates._build(data)]
 	},
 	[GatewayDispatchEvents.PresenceUpdate]: {
 		event: "presenceUpdate",
-		before: (client, data) => client.presences.get(data.guild_id, data.user.id),
-		build: async (client, data, previous) => [previous ?? null, await cachedOrUndefined(client.presences.get(data.guild_id, data.user.id)) ?? await client.presences.hydrate(data)]
+		before: (client, data) => previousOf(client.presences, data.guild_id, data.user.id),
+		build: async (client, data, previous) => [previous ?? null, await cachedOrUndefined(() => cachedOf(client.presences, data.guild_id, data.user.id)) ?? await client.presences._build(data)]
 	},
 	[GatewayDispatchEvents.GuildScheduledEventCreate]: {
 		event: "guildScheduledEventCreate",
-		build: async (client, data) => [await client.guilds.scheduledEvents(data.guild_id).hydrate(data)]
+		build: async (client, data) => [await client.guilds.scheduledEvents(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.GuildScheduledEventUpdate]: {
 		event: "guildScheduledEventUpdate",
-		before: (client, data) => client.guilds.scheduledEvents(data.guild_id).get(data.id),
-		build: async (client, data, previous) => [previous ?? partialScheduledEvent(client, data.guild_id, data.id), await client.guilds.scheduledEvents(data.guild_id).hydrate(data)]
+		before: (client, data) => previousOf(client.guilds.scheduledEvents(data.guild_id), data.id),
+		build: async (client, data, previous) => [previous ?? partialScheduledEvent(client, data.guild_id, data.id), await client.guilds.scheduledEvents(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.GuildScheduledEventDelete]: {
 		event: "guildScheduledEventDelete",
-		build: async (client, data) => [await client.guilds.scheduledEvents(data.guild_id).hydrate(data)]
+		build: async (client, data) => [await client.guilds.scheduledEvents(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.GuildScheduledEventUserAdd]: {
 		event: "guildScheduledEventUserAdd",
 		build: async (client, data) => [
-			await cachedOrUndefined(client.guilds.scheduledEvents(data.guild_id).get(data.guild_scheduled_event_id)) ?? partialScheduledEvent(client, data.guild_id, data.guild_scheduled_event_id),
-			await cachedOrUndefined(client.users.get(data.user_id)) ?? partialUser(client, data.user_id),
+			await cachedOrUndefined(() => cachedOf(client.guilds.scheduledEvents(data.guild_id), data.guild_scheduled_event_id)) ?? partialScheduledEvent(client, data.guild_id, data.guild_scheduled_event_id),
+			await cachedOrUndefined(() => client.users.cache.get(data.user_id)) ?? partialUser(client, data.user_id),
 			data
 		]
 	},
 	[GatewayDispatchEvents.GuildScheduledEventUserRemove]: {
 		event: "guildScheduledEventUserRemove",
 		build: async (client, data) => [
-			await cachedOrUndefined(client.guilds.scheduledEvents(data.guild_id).get(data.guild_scheduled_event_id)) ?? partialScheduledEvent(client, data.guild_id, data.guild_scheduled_event_id),
-			await cachedOrUndefined(client.users.get(data.user_id)) ?? partialUser(client, data.user_id),
+			await cachedOrUndefined(() => cachedOf(client.guilds.scheduledEvents(data.guild_id), data.guild_scheduled_event_id)) ?? partialScheduledEvent(client, data.guild_id, data.guild_scheduled_event_id),
+			await cachedOrUndefined(() => client.users.cache.get(data.user_id)) ?? partialUser(client, data.user_id),
 			data
 		]
 	},
 	[GatewayDispatchEvents.StageInstanceCreate]: {
 		event: "stageInstanceCreate",
-		build: async (client, data) => [await client.guilds.stageInstances(data.guild_id).hydrate(data)]
+		build: async (client, data) => [await client.guilds.stageInstances(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.StageInstanceUpdate]: {
 		event: "stageInstanceUpdate",
-		before: (client, data) => client.guilds.stageInstances(data.guild_id).get(data.channel_id),
-		build: async (client, data, previous) => [previous ?? null, await client.guilds.stageInstances(data.guild_id).hydrate(data)]
+		before: (client, data) => previousOf(client.guilds.stageInstances(data.guild_id), data.channel_id),
+		build: async (client, data, previous) => [previous ?? null, await client.guilds.stageInstances(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.StageInstanceDelete]: {
 		event: "stageInstanceDelete",
-		build: async (client, data) => [await client.guilds.stageInstances(data.guild_id).hydrate(data)]
+		build: async (client, data) => [await client.guilds.stageInstances(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.GuildSoundboardSoundCreate]: {
 		event: "guildSoundboardSoundCreate",
-		build: async (client, data) => [await client.guilds.soundboardSounds(data.guild_id).hydrate(data)]
+		build: async (client, data) => [await client.guilds.soundboardSounds(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.GuildSoundboardSoundUpdate]: {
 		event: "guildSoundboardSoundUpdate",
-		before: (client, data) => client.guilds.soundboardSounds(data.guild_id).get(data.sound_id),
-		build: async (client, data, previous) => [previous ?? partialSoundboardSound(client, data.guild_id, data.sound_id), await client.guilds.soundboardSounds(data.guild_id).hydrate(data)]
+		before: (client, data) => previousOf(client.guilds.soundboardSounds(data.guild_id), data.sound_id),
+		build: async (client, data, previous) => [previous ?? partialSoundboardSound(client, data.guild_id, data.sound_id), await client.guilds.soundboardSounds(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.GuildSoundboardSoundDelete]: {
 		event: "guildSoundboardSoundDelete",
-		before: (client, data) => client.guilds.soundboardSounds(data.guild_id).get(data.sound_id),
+		before: (client, data) => previousOf(client.guilds.soundboardSounds(data.guild_id), data.sound_id),
 		build: (client, data, previous) => [previous ?? partialSoundboardSound(client, data.guild_id, data.sound_id), data]
 	},
 	[GatewayDispatchEvents.GuildSoundboardSoundsUpdate]: {
 		event: "guildSoundboardSoundsUpdate",
 		build: async (client, data) => {
 			const sounds = client.guilds.soundboardSounds(data.guild_id);
-			return [await Promise.all(data.soundboard_sounds.map((sound) => sounds.hydrate(sound))), data.guild_id];
+			return [await Promise.all(data.soundboard_sounds.map((sound) => sounds._build(sound))), data.guild_id];
 		}
 	},
 	[GatewayDispatchEvents.SoundboardSounds]: {
 		event: "soundboardSounds",
 		build: async (client, data) => {
 			const sounds = client.guilds.soundboardSounds(data.guild_id);
-			return [await Promise.all(data.soundboard_sounds.map((sound) => sounds.hydrate(sound))), data.guild_id];
+			return [await Promise.all(data.soundboard_sounds.map((sound) => sounds._build(sound))), data.guild_id];
 		}
 	},
 	[GatewayDispatchEvents.GuildBanAdd]: {
 		event: "guildBanAdd",
-		build: async (client, data) => [await client.guilds.bans(data.guild_id).hydrate(data)]
+		build: async (client, data) => [await client.guilds.bans(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.GuildBanRemove]: {
 		event: "guildBanRemove",
-		before: (client, data) => client.guilds.bans(data.guild_id).get(data.user.id),
-		build: async (client, data, previous) => [previous ?? await client.guilds.bans(data.guild_id).hydrate(data)]
+		before: (client, data) => previousOf(client.guilds.bans(data.guild_id), data.user.id),
+		build: async (client, data, previous) => [previous ?? await client.guilds.bans(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.GuildAuditLogEntryCreate]: {
 		event: "guildAuditLogEntryCreate",
 		build: async (client, data) => {
+			const { user_id: userId } = data;
 			const [executor, guild, target] = await Promise.all([
-				data.user_id ? cachedOrUndefined(client.users.get(data.user_id)) : void 0,
-				cachedOrUndefined(client.guilds.get(data.guild_id)),
+				userId ? cachedOrUndefined(() => client.users.cache.get(userId)) : void 0,
+				cachedOrUndefined(() => client.guilds.cache.get(data.guild_id)),
 				resolveAuditLogTarget(client, data)
 			]);
 			return [bindClient(new GuildAuditLogsEntry(data, {
@@ -14079,44 +14418,45 @@ const DispatchHandlers = {
 	},
 	[GatewayDispatchEvents.AutoModerationRuleCreate]: {
 		event: "autoModerationRuleCreate",
-		build: async (client, data) => [await client.guilds.autoModerationRules(data.guild_id).hydrate(data)]
+		build: async (client, data) => [await client.guilds.autoModerationRules(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.AutoModerationRuleUpdate]: {
 		event: "autoModerationRuleUpdate",
-		before: (client, data) => client.guilds.autoModerationRules(data.guild_id).get(data.id),
-		build: async (client, data, previous) => [previous ?? null, await client.guilds.autoModerationRules(data.guild_id).hydrate(data)]
+		before: (client, data) => previousOf(client.guilds.autoModerationRules(data.guild_id), data.id),
+		build: async (client, data, previous) => [previous ?? null, await client.guilds.autoModerationRules(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.AutoModerationRuleDelete]: {
 		event: "autoModerationRuleDelete",
-		build: async (client, data) => [await client.guilds.autoModerationRules(data.guild_id).hydrate(data)]
+		build: async (client, data) => [await client.guilds.autoModerationRules(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.GuildIntegrationsUpdate]: {
 		event: "guildIntegrationsUpdate",
-		build: async (client, data) => [await cachedOrUndefined(client.guilds.get(data.guild_id)) ?? null, data]
+		build: async (client, data) => [await cachedOrUndefined(() => client.guilds.cache.get(data.guild_id)) ?? null, data]
 	},
 	[GatewayDispatchEvents.IntegrationCreate]: {
 		event: "integrationCreate",
-		build: async (client, data) => [await client.guilds.integrations(data.guild_id).hydrate(data)]
+		build: async (client, data) => [await client.guilds.integrations(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.IntegrationUpdate]: {
 		event: "integrationUpdate",
-		before: (client, data) => client.guilds.integrations(data.guild_id).get(data.id),
-		build: async (client, data, previous) => [previous ?? null, await client.guilds.integrations(data.guild_id).hydrate(data)]
+		before: (client, data) => previousOf(client.guilds.integrations(data.guild_id), data.id),
+		build: async (client, data, previous) => [previous ?? null, await client.guilds.integrations(data.guild_id)._build(data)]
 	},
 	[GatewayDispatchEvents.IntegrationDelete]: {
 		event: "integrationDelete",
-		before: (client, data) => client.guilds.integrations(data.guild_id).get(data.id),
+		before: (client, data) => previousOf(client.guilds.integrations(data.guild_id), data.id),
 		build: (_client, data, previous) => [previous ?? null, data]
 	},
 	[GatewayDispatchEvents.AutoModerationActionExecution]: {
 		event: "autoModerationActionExecution",
 		build: async (client, data) => {
+			const { channel_id: channelId } = data;
 			const [user, guild, member, channel, autoModerationRule] = await Promise.all([
-				cachedOrUndefined(client.users.get(data.user_id)),
-				cachedOrUndefined(client.guilds.get(data.guild_id)),
-				cachedOrUndefined(client.members.get(data.guild_id, data.user_id)),
-				data.channel_id ? cachedOrUndefined(client.channels.get(data.channel_id)) : void 0,
-				cachedOrUndefined(client.guilds.autoModerationRules(data.guild_id).get(data.rule_id))
+				cachedOrUndefined(() => client.users.cache.get(data.user_id)),
+				cachedOrUndefined(() => client.guilds.cache.get(data.guild_id)),
+				cachedOrUndefined(() => cachedOf(client.members, data.guild_id, data.user_id)),
+				channelId ? cachedOrUndefined(() => client.channels.cache.get(channelId)) : void 0,
+				cachedOrUndefined(() => cachedOf(client.guilds.autoModerationRules(data.guild_id), data.rule_id))
 			]);
 			return [bindClient(new AutoModerationActionExecution(data, {
 				user: user ?? null,
@@ -14133,13 +14473,13 @@ const DispatchHandlers = {
 	},
 	[GatewayDispatchEvents.UserUpdate]: {
 		event: "userUpdate",
-		before: (client, data) => client.users.get(data.id),
+		before: (client, data) => previousOf(client.users, data.id),
 		build: async (client, data, previous) => {
 			if (client.user?.id === data.id) {
 				client.user[kPatch](data);
 				return [previous ?? partialUser(client, data.id), client.user];
 			}
-			return [previous ?? partialUser(client, data.id), await client.users.hydrate(data)];
+			return [previous ?? partialUser(client, data.id), await client.users._build(data)];
 		}
 	}
 };
@@ -14155,7 +14495,7 @@ const MultiDispatchHandlers = {
 		before: (client, data) => cachedList(client.cache?.emojis, () => client.guilds.emojis(data.guild_id).listCached()),
 		emit: async (client, data, previous) => {
 			const emojis = client.guilds.emojis(data.guild_id);
-			const current = await Promise.all(data.emojis.map((emoji) => emojis.hydrate({
+			const current = await Promise.all(data.emojis.map((emoji) => emojis._build({
 				...emoji,
 				guild_id: data.guild_id
 			})));
@@ -14172,7 +14512,7 @@ const MultiDispatchHandlers = {
 		before: (client, data) => cachedList(client.cache?.stickers, () => client.guilds.stickers(data.guild_id).listCached()),
 		emit: async (client, data, previous) => {
 			const stickers = client.guilds.stickers(data.guild_id);
-			const current = await Promise.all(data.stickers.map((sticker) => stickers.hydrate({
+			const current = await Promise.all(data.stickers.map((sticker) => stickers._build({
 				...sticker,
 				guild_id: data.guild_id
 			})));
@@ -14187,7 +14527,8 @@ const MultiDispatchHandlers = {
 	}
 };
 async function cachedList(store, list) {
-	return store && isIterableCache(store) ? list() : void 0;
+	if (!store || !isIterableCache(store)) return void 0;
+	return (await list()).map((value) => value[kClone]());
 }
 function diff(previous, current, create, update, remove) {
 	const before = new Map(previous.map((value) => [value.id, value]));
@@ -14206,13 +14547,14 @@ function diff(previous, current, create, update, remove) {
 	return events;
 }
 async function reactionOf(client, data) {
-	const message = await cachedOrUndefined(client.messages.get(data.channel_id, data.message_id));
+	const message = await cachedOrUndefined(() => cachedOf(client.messages, data.channel_id, data.message_id));
 	if (!message) return partialReaction(client, data);
 	return message.reactions.resolve(data.emoji) ?? partialReaction(client, data, true, message);
 }
 async function partialReaction(client, data, emptied = false, message = partialMessage(client, data.channel_id, data.message_id, data.guild_id)) {
 	const { guild_id: guildId, emoji } = data;
-	const cachedEmoji = guildId && emoji.id ? await cachedOrUndefined(client.guilds.emojis(guildId).get(emoji.id)) : void 0;
+	const emojiId = emoji.id;
+	const cachedEmoji = guildId && emojiId ? await cachedOrUndefined(() => cachedOf(client.guilds.emojis(guildId), emojiId)) : void 0;
 	return bindClient(new MessageReaction({
 		channel_id: data.channel_id,
 		message_id: data.message_id,
@@ -14233,7 +14575,7 @@ async function partialReaction(client, data, emptied = false, message = partialM
 	}), client);
 }
 async function pollAnswerOf(client, data) {
-	const message = await cachedOrUndefined(client.messages.get(data.channel_id, data.message_id));
+	const message = await cachedOrUndefined(() => cachedOf(client.messages, data.channel_id, data.message_id));
 	return message?.poll?.answers.find((answer) => answer.id === data.answer_id) ?? bindClient(new PollAnswer({
 		answer_id: data.answer_id,
 		poll_media: {},
@@ -14244,13 +14586,13 @@ async function pollAnswerOf(client, data) {
 async function typingOf(client, data) {
 	const { guild_id: guildId, member, user_id: userId } = data;
 	const [channel, user, guild, resolvedMember] = await Promise.all([
-		cachedOrUndefined(client.channels.get(data.channel_id)),
-		cachedOrUndefined(member?.user ? client.users.resolveData(member.user) : client.users.get(userId)),
-		guildId ? cachedOrUndefined(Promise.resolve(client.guilds._getShallow(guildId))) : void 0,
-		guildId ? cachedOrUndefined(member?.user ? client.members.resolveData({
+		cachedOrUndefined(() => client.channels.cache.get(data.channel_id)),
+		cachedOrUndefined(() => member?.user ? client.users._resolveData(member.user) : client.users.cache.get(userId)),
+		guildId ? cachedOrUndefined(() => client.guilds._getShallow(guildId)) : void 0,
+		guildId ? cachedOrUndefined(() => member?.user ? client.members._resolveData({
 			...member,
 			guild_id: guildId
-		}) : client.members.get(guildId, userId)) : void 0
+		}) : cachedOf(client.members, guildId, userId)) : void 0
 	]);
 	return bindClient(new Typing(data, {
 		channel: channel ?? (guildId ? null : partialDMChannel(client, data.channel_id, userId)),
@@ -14326,8 +14668,16 @@ function partialDMChannel(client, channelId, recipientId) {
 		recipients: [{ id: recipientId }]
 	}), client);
 }
-function cachedOrUndefined(read) {
-	return read.catch(() => void 0);
+/**
+* Resolves a cache read, or `undefined` when the cache cannot be read, so an event can still be built from its
+* payload. The failure itself was already reported while applying the dispatch.
+*/
+async function cachedOrUndefined(read) {
+	try {
+		return await read();
+	} catch {
+		return;
+	}
 }
 
 //#endregion
@@ -14562,11 +14912,338 @@ var GatewaySessionMirror = class {
 	}
 };
 
+//#endregion
+//#region src/util/CollectionCache.ts
+/**
+* The default {@link Cache}: an in-memory `Collection` of structure instances, like discord.js's caches.
+*
+* @remarks
+* `add` patches the cached instance in place, so a reference kept by the application sees later updates.
+*
+* Every method is synchronous. Being a `Collection`, it also has `find`, `filter`, `map`, ... which return plain
+* collections. Instances reached by iterating carry the relations of their last `get`.
+*/
+var CollectionCache = class extends Collection {
+	static get [Symbol.species]() {
+		return Collection;
+	}
+	synchronous = true;
+	construct;
+	/**
+	* The name of the entity this cache holds.
+	*/
+	name;
+	#keyOf;
+	#refresh;
+	#maxSize;
+	constructor(creator, name, options = {}) {
+		super();
+		this.construct = creator;
+		this.name = name;
+		this.#keyOf = options.keyOf ?? ((data) => data.id);
+		this.#refresh = options.refresh;
+		this.#maxSize = options.maxSize ?? Infinity;
+	}
+	add(data, overwrite = false) {
+		const key = this.#keyOf(data);
+		const existing = overwrite ? void 0 : super.get(key);
+		if (existing !== void 0) {
+			existing[kPatch](data);
+			return this.#refresh ? this.#refresh(existing) : existing;
+		}
+		const value = this.construct(data);
+		this.set(key, value);
+		return this.#refresh ? this.#refresh(value) : value;
+	}
+	get(key) {
+		const value = super.get(key);
+		return value !== void 0 && this.#refresh ? this.#refresh(value) : value;
+	}
+	set(key, value) {
+		if (this.#maxSize <= 0) return this;
+		if (this.size >= this.#maxSize && !super.has(key)) {
+			const oldest = this.keys().next();
+			if (!oldest.done) super.delete(oldest.value);
+		}
+		return super.set(key, value);
+	}
+	getSize() {
+		return this.size;
+	}
+};
+
+//#endregion
+//#region src/util/EntityStoreCache.ts
+const unguarded = (_operation, _key, run) => run();
+/**
+* A {@link Cache} over a raw `@wolfstar/plugin-cache` store (in memory or Redis): the store holds raw API data, and a
+* structure is built on every read.
+*
+* @remarks
+* Unlike `CollectionCache`, two reads of the same key return two structures: do not rely on object identity.
+*/
+var EntityStoreCache = class {
+	construct;
+	/**
+	* The name of the entity this cache holds.
+	*/
+	name;
+	/**
+	* The raw store.
+	*/
+	store;
+	#keyOf;
+	#hydrate;
+	#guard;
+	#synchronous;
+	constructor(creator, name, options) {
+		this.construct = creator;
+		this.name = name;
+		this.store = options.store;
+		this.#keyOf = options.keyOf;
+		this.#hydrate = options.hydrate ?? creator;
+		this.#guard = options.guard ?? unguarded;
+		this.#synchronous = options.synchronous;
+	}
+	get synchronous() {
+		return this.#synchronous ? this.#synchronous() : this.store.synchronous === true;
+	}
+	add(data, overwrite = false) {
+		const raw = data;
+		const key = this.#keyOf(data);
+		return whenAll([this.#guard("upsert", key, () => this.store.upsert(key, data, { overwrite }), { added: raw })], ([{ added }]) => this.#hydrate(added));
+	}
+	clear() {
+		return this.#guard("clear", null, () => this.store.clear(), void 0);
+	}
+	delete(key) {
+		return this.#guard("delete", key, () => this.store.delete(key), false);
+	}
+	get(key) {
+		return whenAll([this.#guard("get", key, () => this.store.get(key), void 0)], ([raw]) => raw === void 0 ? void 0 : this.#hydrate(raw));
+	}
+	getSize() {
+		return this.#guard("getSize", null, () => this.store.getSize(), 0);
+	}
+	has(key) {
+		return this.#guard("has", key, () => this.store.has(key), false);
+	}
+	set(key, value) {
+		const raw = value.toJSON();
+		return whenAll([this.#guard("set", key, () => this.store.set(key, raw), void 0)], () => this);
+	}
+};
+
+//#endregion
+//#region src/util/entityManagers.ts
+/**
+* The entities of `@wolfstar/plugin-cache` a manager builds structures for.
+*
+* @internal
+*/
+const ManagedEntityNames = [
+	"autoModerationRules",
+	"bans",
+	"channels",
+	"emojis",
+	"guilds",
+	"integrations",
+	"invites",
+	"members",
+	"messages",
+	"presences",
+	"roles",
+	"scheduledEvents",
+	"soundboardSounds",
+	"stageInstances",
+	"stickers",
+	"threadMembers",
+	"threads",
+	"users",
+	"voiceStates"
+];
+function guildIdOf(data) {
+	return data.guild_id ?? "";
+}
+const managers = {
+	autoModerationRules: (client, data) => client.guilds.autoModerationRules(guildIdOf(data)),
+	bans: (client, data) => client.guilds.bans(guildIdOf(data)),
+	channels: (client) => client.channels,
+	emojis: (client, data) => client.guilds.emojis(guildIdOf(data)),
+	guilds: (client) => client.guilds,
+	integrations: (client, data) => client.guilds.integrations(guildIdOf(data)),
+	invites: (client, data) => client.guilds.invites(guildIdOf(data)),
+	members: (client) => client.members,
+	messages: (client) => client.messages,
+	presences: (client) => client.presences,
+	roles: (client) => client.roles,
+	scheduledEvents: (client, data) => client.guilds.scheduledEvents(guildIdOf(data)),
+	soundboardSounds: (client, data) => client.guilds.soundboardSounds(guildIdOf(data)),
+	stageInstances: (client, data) => client.guilds.stageInstances(guildIdOf(data)),
+	stickers: (client, data) => client.guilds.stickers(guildIdOf(data)),
+	threadMembers: (client) => client.threadMembers,
+	threads: (client) => client.threads,
+	users: (client) => client.users,
+	voiceStates: (client) => client.voiceStates
+};
+/**
+* Gets the manager building the structures of an entity. Guild-scoped managers are created for the guild the data
+* belongs to.
+*
+* @param client The client.
+* @param name The name of the entity.
+* @param data The raw data the manager is needed for.
+* @internal
+*/
+function managerOf(client, name, data) {
+	return managers[name](client, data);
+}
+
+//#endregion
+//#region src/util/NullCache.ts
+/**
+* The {@link Cache} of an entity that is not cached: always empty, writes are dropped.
+*/
+var NullCache = class {
+	construct;
+	/**
+	* The name of the entity this cache stands for.
+	*/
+	name;
+	#hydrate;
+	#synchronous;
+	constructor(creator, name, options = {}) {
+		this.construct = creator;
+		this.name = name;
+		this.#hydrate = options.hydrate ?? creator;
+		this.#synchronous = options.synchronous;
+	}
+	get synchronous() {
+		return this.#synchronous?.() ?? true;
+	}
+	add(data) {
+		return this.#hydrate(data);
+	}
+	clear() {}
+	delete() {
+		return false;
+	}
+	get() {}
+	getSize() {
+		return 0;
+	}
+	has() {
+		return false;
+	}
+	set() {
+		return this;
+	}
+};
+
+//#endregion
+//#region src/util/StructureStoreAdapter.ts
+function toRaw(value) {
+	return { ...value.toJSON() };
+}
+/**
+* A raw `@wolfstar/plugin-cache` store over a structure {@link Cache}, so that what writes raw data (the gateway
+* dispatches, their cascades, the policies) works against a cache of structures.
+*
+* @remarks
+* Writes patch the cached instance in place. Time-to-live options are ignored: structure caches have none.
+*
+* @internal
+*/
+var StructureStoreAdapter = class {
+	cache;
+	constructor(cache) {
+		this.cache = cache;
+	}
+	get synchronous() {
+		return this.cache.synchronous;
+	}
+	read(key) {
+		return peekCache(this.cache, key);
+	}
+	get(key) {
+		return whenAll([this.read(key)], ([value]) => value === void 0 ? void 0 : toRaw(value));
+	}
+	/**
+	* Writes an entry. Unlike a raw store's `set`, it merges the value into a cached instance rather than replacing it:
+	* the keys absent from the new value persist.
+	*/
+	set(key, value) {
+		return whenAll([this.read(key)], ([existing]) => {
+			const entry = existing === void 0 ? this.cache.construct(value) : existing;
+			if (existing !== void 0) existing[kPatch](value);
+			return whenAll([this.cache.set(key, entry)], () => void 0);
+		});
+	}
+	/**
+	* Merges data into an entry, creating it when it is missing.
+	*
+	* @remarks
+	* A cached instance is always patched in place, with or without `overwrite`: replacing it would leave the
+	* application holding a stale instance. Since a structure's patch merges, an `overwrite` on a structure cache
+	* behaves like {@link StructureStoreAdapter.set}: the keys absent from the new data keep their cached value,
+	* where a raw store would drop them.
+	*/
+	upsert(key, data, _options) {
+		return whenAll([this.read(key)], ([existing]) => {
+			if (existing === void 0) {
+				const value = this.cache.construct(data);
+				return whenAll([this.cache.set(key, value)], () => ({
+					existing: void 0,
+					added: toRaw(value)
+				}));
+			}
+			const before = toRaw(existing);
+			existing[kPatch](data);
+			return whenAll([this.cache.set(key, existing)], () => ({
+				existing: before,
+				added: toRaw(existing)
+			}));
+		});
+	}
+	has(key) {
+		return this.cache.has(key);
+	}
+	delete(key) {
+		return this.cache.delete(key);
+	}
+	clear() {
+		return this.cache.clear();
+	}
+	getSize() {
+		return this.cache.getSize();
+	}
+};
+var IterableStructureStoreAdapter = class extends StructureStoreAdapter {
+	keys() {
+		return [...this.cache.keys()];
+	}
+	values() {
+		return [...this.cache.values()].map((value) => toRaw(value));
+	}
+	entries() {
+		return [...this.cache.entries()].map(([key, value]) => [key, toRaw(value)]);
+	}
+};
+/**
+* Creates the raw store of a structure cache, enumerable when the cache is a `Map` (e.g. `CollectionCache`).
+*
+* @param cache The structure cache.
+* @internal
+*/
+function createStructureStoreAdapter(cache) {
+	return cache instanceof Map ? new IterableStructureStoreAdapter(cache) : new StructureStoreAdapter(cache);
+}
+
 //#endregion
 //#region src/GatewayClient.ts
 /**
 * A {@link Client} that, on top of serving HTTP interactions, connects to the Discord gateway, writes every dispatch
-* into an optional {@link Cache}, and emits {@link GatewayEventMap} events carrying structures.
+* into its cache, and emits {@link GatewayEventMap} events carrying structures.
 *
 * @example
 * ```typescript
@@ -14586,7 +15263,8 @@ var GatewaySessionMirror = class {
 */
 var GatewayClient = class extends Client {
 	/**
-	* The cache every dispatch is written into, if any.
+	* The raw cache every dispatch is written into, if any: the `@wolfstar/plugin-cache` cache passed as
+	* {@link GatewayClientOptions.cache}, or a raw view of the managers' caches of instances.
 	*/
 	cache;
 	/**
@@ -14656,6 +15334,12 @@ var GatewayClient = class extends Client {
 	*/
 	clientReadyTimestamp = null;
 	#queue = new DispatchQueue();
+	#caches = /* @__PURE__ */ new Map();
+	#cacheConstructor;
+	#cacheOptions;
+	#stores;
+	#storesSynchronous;
+	#policies;
 	#shardCount;
 	#intents;
 	#token;
@@ -14668,7 +15352,14 @@ var GatewayClient = class extends Client {
 		super(options);
 		container.gatewayClient = this;
 		this.rest = container.rest;
-		this.cache = resolveCache(options);
+		const storeBacked = Boolean(options.cache || options.makeCache);
+		if ((options.cacheConstructor || options.cacheOptions) && storeBacked) throw new GatewayTypeError("ClientCacheConflict");
+		this.#cacheOptions = options.cacheOptions ?? {};
+		const stores = resolveCache(options);
+		this.#stores = stores;
+		this.#storesSynchronous = Object.values(stores ?? {}).every((store) => store.synchronous === true);
+		this.#cacheConstructor = options.cache === null || storeBacked ? null : options.cacheConstructor ?? CollectionCache;
+		this.#policies = this.#cacheConstructor ? options.policies : void 0;
 		this.cacheErrors = options.cacheErrors ?? "miss";
 		this.cacheFailure = options.cacheFailure ?? "skip";
 		this.dispatchTimeout = options.dispatchTimeout === void 0 ? 3e4 : options.dispatchTimeout;
@@ -14689,6 +15380,7 @@ var GatewayClient = class extends Client {
 		this.templates = new GuildTemplateManager(this);
 		this.voiceStates = new VoiceStateManager(this);
 		this.presences = new PresenceManager(this);
+		this.cache = this.#cacheConstructor ? this.#createStructureStores(options.policies) : stores;
 		this.gateway = new WebSocketManager({
 			...options.gateway,
 			...this.sessionCallbacks(options),
@@ -14776,6 +15468,96 @@ var GatewayClient = class extends Client {
 		return outcome.value;
 	}
 	/**
+	* Gets the cache of an entity, building it on first use: the `CacheConstructor` of the discord.js RFC #11426.
+	* Every manager of the same entity shares the same cache.
+	*
+	* @param creator Builds a structure from raw data, for entities the client does not know how to build.
+	* @param name The name of the entity.
+	*/
+	CacheConstructor(creator, name) {
+		let cache = this.#caches.get(name);
+		if (cache === void 0) {
+			cache = this.#createCache(creator, name);
+			this.#caches.set(name, cache);
+		}
+		return cache;
+	}
+	/**
+	* Runs a raw store operation, reporting its failure through `cacheError`, see
+	* {@link GatewayClientOptions.cacheErrors}. Synchronous when the operation is.
+	*
+	* @internal
+	*/
+	guardCache(entity, operation, key, run, fallback) {
+		const fail = (error) => {
+			this.emit("cacheError", error, {
+				entity,
+				key,
+				operation
+			});
+			if (this.cacheErrors === "throw") throw error;
+			return fallback;
+		};
+		try {
+			const result = run();
+			return isPromiseLike(result) ? result.catch(fail) : result;
+		} catch (error) {
+			return fail(error);
+		}
+	}
+	/**
+	* Gets the `filter` of an entity's policy the managers must apply themselves before writing to its cache, see
+	* {@link GatewayClientOptions.policies}.
+	*
+	* @param name The name of the entity.
+	* @returns The filter, or `undefined` when there is none or when the entity's store applies it already.
+	* @internal
+	*/
+	cacheFilter(name) {
+		const policy = this.#policies?.[name];
+		return policy?.filter ? (value, key) => policy.filter(value, key) : void 0;
+	}
+	#createCache(creator, name) {
+		const managed = ManagedEntityNames.includes(name);
+		const construct = managed ? (data) => managerOf(this, name, data)._construct(data) : creator;
+		const hydrate = managed ? (data) => managerOf(this, name, data)._build(data) : creator;
+		const keyOf = managed ? (data) => managerOf(this, name, data).keyOf(data) : (data) => data.id;
+		if (this.#cacheConstructor) {
+			const refresh = (value) => {
+				const refreshed = refreshRelations(value, hydrate);
+				if (isPromiseLike(refreshed)) {
+					refreshed.catch(() => void 0);
+					throw new GatewayTypeError("CacheConstructorAsynchronous", name);
+				}
+				return refreshed;
+			};
+			return new this.#cacheConstructor(construct, name, {
+				keyOf,
+				refresh,
+				...this.#cacheOptions[name]
+			});
+		}
+		const store = this.#stores?.[name];
+		const synchronous = () => this.#storesSynchronous;
+		if (store === void 0) return new NullCache(construct, name, {
+			hydrate,
+			synchronous
+		});
+		return new EntityStoreCache(construct, name, {
+			store,
+			keyOf,
+			hydrate,
+			synchronous,
+			guard: (operation, key, run, fallback) => this.guardCache(name, operation, key, run, fallback)
+		});
+	}
+	#createStructureStores(policies) {
+		return createCache({
+			policies,
+			makeCache: (name) => ManagedEntityNames.includes(name) ? createStructureStoreAdapter(this.CacheConstructor(() => void 0, name)) : new MemoryEntityCache(this.#cacheOptions[name]?.maxSize ?? Infinity)
+		});
+	}
+	/**
 	* Resolves once every dispatch received so far has been processed.
 	*/
 	async idle() {
@@ -14824,10 +15606,10 @@ var GatewayClient = class extends Client {
 			guild_scheduled_event_id: options.guildScheduledEventId
 		});
 		const [guild, channel, inviter, targetUser] = await Promise.all([
-			invite.guild ? this.guilds.get(invite.guild.id) : void 0,
-			invite.channel ? this.channels.get(invite.channel.id) : void 0,
-			invite.inviter ? this.users.resolveData(invite.inviter) : void 0,
-			invite.target_user ? this.users.resolveData(invite.target_user) : void 0
+			invite.guild ? this.guilds.cache.get(invite.guild.id) : void 0,
+			invite.channel ? this.channels.cache.get(invite.channel.id) : void 0,
+			invite.inviter ? this.users._resolveData(invite.inviter) : void 0,
+			invite.target_user ? this.users._resolveData(invite.target_user) : void 0
 		]);
 		return bindClient(createInvite(invite, {
 			guild: guild ?? null,
@@ -14971,8 +15753,9 @@ var GatewayClient = class extends Client {
 		}
 	}
 	async dropUnlistedGuilds(data, shardId) {
-		const guilds = this.cache?.guilds;
-		if (!guilds || !isIterableCache(guilds)) return;
+		const { cache } = this;
+		const guilds = cache?.guilds;
+		if (!cache || !guilds || !isIterableCache(guilds)) return;
 		const cached = await guilds.keys();
 		if (cached.length === 0) return;
 		const count = data.shard?.[1] ?? this.#shardCount ?? await this.gateway.getShardCount();
@@ -14980,8 +15763,8 @@ var GatewayClient = class extends Client {
 		const shardCount = BigInt(count);
 		for (const id of cached) {
 			if (listed.has(id) || Number((BigInt(id) >> 22n) % shardCount) !== shardId) continue;
-			const guild = await this.guilds.get(id) ?? null;
-			await applyGatewayDispatch(this.cache, {
+			const guild = await this.guilds.cache.get(id) ?? null;
+			await applyGatewayDispatch(cache, {
 				op: GatewayOpcodes.Dispatch,
 				s: 0,
 				t: GatewayDispatchEvents.GuildDelete,
@@ -15027,8 +15810,8 @@ var GatewayClient = class extends Client {
 	}
 };
 /**
-* Builds the cache of a client out of its options: the stores of `makeCache` (or `cache`), wrapped by `policies`.
-* `undefined` when no entity kind is cached.
+* Builds the raw stores of a client out of its options: the stores of `makeCache` (or `cache`), wrapped by
+* `policies`. `undefined` when no entity kind is stored, which `cache: null` asks for.
 */
 function resolveCache(options) {
 	const { makeCache, cache, policies } = options;
@@ -15097,5 +15880,5 @@ function RegisterAsGatewayListener(event, options = {}) {
 }
 
 //#endregion
-export { Action, ActionRow, ActionsManager, Activity, ActivityFlagsBitField, AnnouncementChannel, AnnouncementThreadChannel, AnonymousGuild, ApplicationFlagsBitField, AppliedTagsMixin, Attachment, AttachmentFlagsBitField, AutoModerationActionExecution, AutoModerationRule, AutoModerationRuleManager, BaseChannel, BaseChannelMixin, BaseInvite, CachedManager as BaseManager, CachedManager, BitField, CategoryChannel, Channel, ChannelFlagsBitField, ChannelManager, ChannelMessageManager, ChannelOwnerMixin, ChannelParentMixin, ChannelPermissionMixin, ChannelSelectMenuComponent, ChannelSlowmodeMixin, ChannelThreadManager, ChannelThreadsMixin, ChannelTopicMixin, ChannelWebhooksMixin, CheckboxComponent, CheckboxGroupComponent, ClientUser, Colors, Component, ComponentMixin, ContainerComponent, DMChannel, DMChannelMixin, DispatchAction, DispatchHandlers, DispatchQueue, DispatchTimeoutError, Embed, Emoji, EventGatewayListener, FileComponent, FileUploadComponent, ForumChannel, GatewayClient, GatewayError, GatewayErrorCodes, GatewayErrorMessages, GatewayEvents, GatewayRangeError, GatewaySessionStoreError, GatewayTypeError, GroupDMChannel, GroupDMInvite, GroupDMMixin, Guild, GuildAuditLogsEntry, GuildBan, GuildBanManager, GuildChannelFields, GuildChannelManager, GuildChannelMixin, GuildEmoji, GuildEmojiManager, GuildEmojiRoleManager, GuildIntegrationManager, GuildInvite, GuildInviteManager, GuildManager, GuildMember, GuildMemberFlagsBitField, GuildMemberManager, GuildMemberRoleManager, GuildMembersRateLimitError, GuildMembersTimeoutError, GuildOnboarding, GuildOnboardingPrompt, GuildOnboardingPromptOption, GuildPreview, GuildScheduledEvent, GuildScheduledEventManager, GuildSoundboardSoundManager, GuildStickerManager, GuildTemplate, GuildTemplateManager, GuildTemplatesPattern, Integration, IntentsBitField, InteractiveButtonComponent, InviteGuild, InvitesPattern, LabelComponent, LinkButtonComponent, MediaChannel, MediaGalleryComponent, MediaGalleryItem, MentionableSelectMenuComponent, Message, MessageFlagsBitField, MessageManager, MessageMentions, MessagePayload, MessageReaction, Mixin, MultiDispatchAction, MultiDispatchHandlers, NumberFlagsBitField, Partials, PermissionOverwriteManager, PermissionOverwrites, PermissionsBitField, Poll, PollAnswer, PremiumButtonComponent, Presence, PresenceManager, PrivateThreadChannel, PublicThreadChannel, RadioGroupComponent, ReactionEmoji, ReactionManager, ReactionUserManager, RegisterAsGatewayListener, RichPresenceAssets, Role, RoleFlagsBitField, RoleManager, RoleSelectMenuComponent, SectionComponent, SeparatorComponent, SoundboardSound, StageChannel, StageInstance, StageInstanceManager, Sticker, StickerPack, StringSelectMenuComponent, Structure, StructureMixin, SystemChannelFlagsBitField, TextChannel, TextChannelMixin, TextDisplayComponent, TextInputComponent, ThreadChannelMemberManager, ThreadChannelMixin, ThreadManager, ThreadMember, ThreadMemberManager, ThreadOnlyChannelMixin, ThumbnailComponent, Typing, UnfurledMediaItem, User, UserFlagsBitField, UserManager, UserSelectMenuComponent, VoiceChannel, VoiceChannelMixin, VoiceState, VoiceStateManager, Webhook, WebhookManager, WebhookMixin, WelcomeScreen, Widget, WidgetMember, basename, bindClient, cleanCodeBlockContent, cleanContent, compareRolePositions, computeChannelPermissions, computeGuildPermissions, computePermissionsIn, computePositions, computeTargetPermissions, createChannel, createComponent, createInvite, discordSort, dispatchPartition, findComponentByCustomId, findName, flatten, getGatewayClient, getSortableGroupTypes, initStructure, isDeepEqual, isThreadChannelType, kClient, kClone, kData, kPatch, kPatchRelations, kRelations, makeError, makePlainError, moveElementInArray, parseEmoji, parseWebhookURL, resolveBase64, resolveCode, resolveColor, resolveFile, resolveGuildTemplateCode, resolveId, resolveImage, resolveImageOption, resolveInviteCode, resolveOverwriteOptions, resolvePartialEmoji, resolveSKUId, snakeCase, snowflakeTimestamp, toAPIOverwrite, toChannelBody, toSnakeCase, transformAPIAuditLogChange, transformAPIAutoModerationAction, transformAPIAutoModerationRuleTriggerMetadata, transformAPIAvatarDecorationData, transformAPIChannelMention, transformAPIEmbedAsset, transformAPIEmbedAuthor, transformAPIEmbedFooter, transformAPIGuildDefaultReaction, transformAPIGuildForumTag, transformAPIGuildScheduledEventEntityMetadata, transformAPIGuildScheduledEventRecurrenceRule, transformAPIIncidentsData, transformAPIMessageActivity, transformAPIMessageCall, transformAPIMessageInteractionMetadata, transformAPIMessageReference, transformAPIRoleSubscriptionData, transformAPIRoleTags, transformAPIUserPrimaryGuild, transformAutoModerationAction, transformAutoModerationRuleTriggerMetadata, transformCollectibles, transformGuildDefaultReaction, transformGuildForumTag, transformGuildScheduledEventRecurrenceRule, transformResolved, verifyString };
+export { Action, ActionRow, ActionsManager, Activity, ActivityFlagsBitField, AnnouncementChannel, AnnouncementThreadChannel, AnonymousGuild, ApplicationFlagsBitField, AppliedTagsMixin, Attachment, AttachmentFlagsBitField, AutoModerationActionExecution, AutoModerationRule, AutoModerationRuleManager, BaseChannel, BaseChannelMixin, BaseInvite, BaseManager, BitField, CachedManager, CategoryChannel, Channel, ChannelFlagsBitField, ChannelManager, ChannelMessageManager, ChannelOwnerMixin, ChannelParentMixin, ChannelPermissionMixin, ChannelSelectMenuComponent, ChannelSlowmodeMixin, ChannelThreadManager, ChannelThreadsMixin, ChannelTopicMixin, ChannelWebhooksMixin, CheckboxComponent, CheckboxGroupComponent, ClientUser, CollectionCache, Colors, Component, ComponentMixin, ContainerComponent, DMChannel, DMChannelMixin, DataManager, DispatchAction, DispatchHandlers, DispatchQueue, DispatchTimeoutError, Embed, Emoji, EntityStoreCache, EventGatewayListener, FileComponent, FileUploadComponent, ForumChannel, GatewayClient, GatewayError, GatewayErrorCodes, GatewayErrorMessages, GatewayEvents, GatewayRangeError, GatewaySessionStoreError, GatewayTypeError, GroupDMChannel, GroupDMInvite, GroupDMMixin, Guild, GuildAuditLogsEntry, GuildBan, GuildBanManager, GuildChannelFields, GuildChannelManager, GuildChannelMixin, GuildEmoji, GuildEmojiManager, GuildEmojiRoleManager, GuildIntegrationManager, GuildInvite, GuildInviteManager, GuildManager, GuildMember, GuildMemberFlagsBitField, GuildMemberManager, GuildMemberRoleManager, GuildMembersRateLimitError, GuildMembersTimeoutError, GuildOnboarding, GuildOnboardingPrompt, GuildOnboardingPromptOption, GuildPreview, GuildScheduledEvent, GuildScheduledEventManager, GuildSoundboardSoundManager, GuildStickerManager, GuildTemplate, GuildTemplateManager, GuildTemplatesPattern, Integration, IntentsBitField, InteractiveButtonComponent, InviteGuild, InvitesPattern, LabelComponent, LinkButtonComponent, MediaChannel, MediaGalleryComponent, MediaGalleryItem, MentionableSelectMenuComponent, Message, MessageFlagsBitField, MessageManager, MessageMentions, MessagePayload, MessageReaction, Mixin, MultiDispatchAction, MultiDispatchHandlers, NullCache, NumberFlagsBitField, Partials, PermissionOverwriteManager, PermissionOverwrites, PermissionsBitField, Poll, PollAnswer, PremiumButtonComponent, Presence, PresenceManager, PrivateThreadChannel, PublicThreadChannel, RadioGroupComponent, ReactionEmoji, ReactionManager, ReactionUserManager, RegisterAsGatewayListener, RichPresenceAssets, Role, RoleFlagsBitField, RoleManager, RoleSelectMenuComponent, SectionComponent, SeparatorComponent, SoundboardSound, StageChannel, StageInstance, StageInstanceManager, Sticker, StickerPack, StringSelectMenuComponent, Structure, StructureMixin, SystemChannelFlagsBitField, TextChannel, TextChannelMixin, TextDisplayComponent, TextInputComponent, ThreadChannelMemberManager, ThreadChannelMixin, ThreadManager, ThreadMember, ThreadMemberManager, ThreadOnlyChannelMixin, ThumbnailComponent, Typing, UnfurledMediaItem, User, UserFlagsBitField, UserManager, UserSelectMenuComponent, VoiceChannel, VoiceChannelMixin, VoiceState, VoiceStateManager, Webhook, WebhookManager, WebhookMixin, WelcomeScreen, Widget, WidgetMember, basename, bindClient, cleanCodeBlockContent, cleanContent, compareRolePositions, computeChannelPermissions, computeGuildPermissions, computePermissionsIn, computePositions, computeTargetPermissions, createChannel, createComponent, createInvite, discordSort, dispatchPartition, findComponentByCustomId, findName, flatten, getGatewayClient, getSortableGroupTypes, initStructure, isDeepEqual, isThreadChannelType, kClient, kClone, kData, kPatch, kPatchRelations, kRelations, makeError, makePlainError, moveElementInArray, parseEmoji, parseWebhookURL, resolveBase64, resolveCode, resolveColor, resolveFile, resolveGuildTemplateCode, resolveId, resolveImage, resolveImageOption, resolveInviteCode, resolveOverwriteOptions, resolvePartialEmoji, resolveSKUId, snakeCase, snowflakeTimestamp, toAPIOverwrite, toChannelBody, toSnakeCase, transformAPIAuditLogChange, transformAPIAutoModerationAction, transformAPIAutoModerationRuleTriggerMetadata, transformAPIAvatarDecorationData, transformAPIChannelMention, transformAPIEmbedAsset, transformAPIEmbedAuthor, transformAPIEmbedFooter, transformAPIGuildDefaultReaction, transformAPIGuildForumTag, transformAPIGuildScheduledEventEntityMetadata, transformAPIGuildScheduledEventRecurrenceRule, transformAPIIncidentsData, transformAPIMessageActivity, transformAPIMessageCall, transformAPIMessageInteractionMetadata, transformAPIMessageReference, transformAPIRoleSubscriptionData, transformAPIRoleTags, transformAPIUserPrimaryGuild, transformAutoModerationAction, transformAutoModerationRuleTriggerMetadata, transformCollectibles, transformGuildDefaultReaction, transformGuildForumTag, transformGuildScheduledEventRecurrenceRule, transformResolved, verifyString };
 //# sourceMappingURL=index.js.map