lunibee 0.2.3 → 0.2.4

package/dist/collection/index.js.map

@@ -2,10 +2,10 @@
   "version": 3,
   "sources": ["../../packages/collection/src/cache.ts", "../../packages/collection/src/index.ts"],
   "sourcesContent": [
-    "import { Collection } from \"./index.js\";\n\n/** Cache policy for bounded resource storage. */\nexport interface CacheOptions {\n    /** Maximum number of entries retained. */\n    maxSize?: number;\n    /** Time-to-live in milliseconds. Omit to disable expiration. */\n    ttl?: number;\n    /** Sweep interval in milliseconds. */\n    sweepInterval?: number;\n}\n\ntype Entry<V> = { value: V; expiresAt: number };\n\n/** Bounded cache with TTL expiration and explicit invalidation support. */\nexport class Cache<K, V> {\n    readonly #entries = new Collection<K, Entry<V>>();\n    readonly #maxSize: number;\n    readonly #ttl: number;\n    #timer?: ReturnType<typeof setInterval>;\n\n    /** Creates a cache using the supplied retention policy. */\n    public constructor(options: CacheOptions = {}) {\n        this.#maxSize = options.maxSize ?? Infinity;\n        this.#ttl = options.ttl ?? 0;\n        if (\n            (!Number.isInteger(this.#maxSize) && this.#maxSize !== Infinity) ||\n            this.#maxSize < 1\n        )\n            throw new RangeError(\"Cache maxSize must be a positive integer.\");\n        if (!Number.isFinite(this.#ttl) || this.#ttl < 0)\n            throw new RangeError(\n                \"Cache ttl must be a non-negative finite number.\",\n            );\n        if (this.#ttl > 0) {\n            const interval =\n                options.sweepInterval ?? Math.min(this.#ttl, 60_000);\n            if (!Number.isFinite(interval) || interval < 1)\n                throw new RangeError(\"Cache sweepInterval must be positive.\");\n            this.#timer = setInterval(() => this.sweep(), interval);\n            // A sweeper is housekeeping, not work: keeping it referenced makes\n            // a TTL cache hold the process open until dispose() is called.\n            (this.#timer as { unref?: () => void }).unref?.();\n        }\n    }\n\n    /** Number of currently live entries. */\n    public get size(): number {\n        this.#sweepExpired();\n        return this.#entries.size;\n    }\n    /** Reads a live entry. */\n    public get(key: K): V | undefined {\n        const entry = this.#entries.get(key);\n        if (!entry) return undefined;\n        if (entry.expiresAt > 0 && entry.expiresAt <= Date.now()) {\n            this.#entries.delete(key);\n            return undefined;\n        }\n        // LRU Promotion: move to end of insertion order\n        this.#entries.delete(key);\n        this.#entries.set(key, entry);\n        return entry.value;\n    }\n    /** Returns whether a live entry exists. */\n    public has(key: K): boolean {\n        const entry = this.#entries.get(key);\n        if (!entry) return false;\n        if (entry.expiresAt > 0 && entry.expiresAt <= Date.now()) {\n            this.#entries.delete(key);\n            return false;\n        }\n        return true;\n    }\n    /** Stores an entry and evicts the oldest entries when the bound is exceeded. */\n    public set(key: K, value: V): this {\n        const expiresAt = this.#ttl > 0 ? Date.now() + this.#ttl : 0;\n        this.#entries.delete(key);\n        this.#entries.set(key, { value, expiresAt });\n        // Skip eviction entirely for unbounded caches (maxSize === Infinity).\n        if (this.#maxSize !== Infinity) {\n            while (this.#entries.size > this.#maxSize) {\n                const oldest = this.#entries.firstKey();\n                if (oldest !== undefined) this.#entries.delete(oldest);\n                else break;\n            }\n        }\n        return this;\n    }\n    /** Invalidates one key. */\n    public delete(key: K): boolean {\n        return this.#entries.delete(key);\n    }\n    /** Invalidates every cached resource. */\n    public clear(): void {\n        this.#entries.clear();\n    }\n    /** Invalidates every entry matching a predicate. */\n    public invalidate(predicate: (value: V, key: K) => boolean): number {\n        return this.#entries.sweep((entry, key) => predicate(entry.value, key));\n    }\n    /** Removes expired entries and returns the number removed. */\n    public sweep(): number {\n        return this.#entries.sweep((entry) => this.#expired(entry));\n    }\n    /** Stops the background sweeper and releases its timer. */\n    public dispose(): void {\n        if (this.#timer) clearInterval(this.#timer);\n        this.#timer = undefined;\n    }\n    /** Returns live cached values. */\n    public values(): V[] {\n        this.#sweepExpired();\n        return this.#entries.map((entry) => entry.value);\n    }\n    /** Returns live cached entries. */\n    public entries(): [K, V][] {\n        this.#sweepExpired();\n        return this.#entries.map((entry, key) => [key, entry.value]);\n    }\n    #expired(entry: Entry<V>): boolean {\n        return entry.expiresAt > 0 && entry.expiresAt <= Date.now();\n    }\n    #sweepExpired(): void {\n        if (this.#ttl > 0) this.sweep();\n    }\n}\n",
-    "type RecencyNode<K> = {\n    key: K;\n    older?: RecencyNode<K>;\n    newer?: RecencyNode<K>;\n};\n\n/**\n * Keys in recency order with O(1) touch, promote, delete and oldest. A Set\n * cannot do this: repeatedly removing its first key leaves tombstones that\n * every new iterator scans past.\n */\nclass RecencyList<K> {\n    readonly #nodes = new Map<K, RecencyNode<K>>();\n    #oldest?: RecencyNode<K>;\n    #newest?: RecencyNode<K>;\n\n    public get size(): number {\n        return this.#nodes.size;\n    }\n\n    public oldest(): K | undefined {\n        return this.#oldest?.key;\n    }\n\n    /** Adds the key as newest, or moves it there. */\n    public touch(key: K): void {\n        const node = this.#nodes.get(key);\n        if (node) return this.#moveNewest(node);\n        const created: RecencyNode<K> = { key, older: this.#newest };\n        if (this.#newest) this.#newest.newer = created;\n        else this.#oldest = created;\n        this.#newest = created;\n        this.#nodes.set(key, created);\n    }\n\n    /** Moves an existing key to newest; ignores unknown keys. */\n    public promote(key: K): void {\n        const node = this.#nodes.get(key);\n        if (node) this.#moveNewest(node);\n    }\n\n    public delete(key: K): boolean {\n        const node = this.#nodes.get(key);\n        if (!node) return false;\n        this.#unlink(node);\n        this.#nodes.delete(key);\n        return true;\n    }\n\n    public clear(): void {\n        this.#nodes.clear();\n        this.#oldest = this.#newest = undefined;\n    }\n\n    #unlink(node: RecencyNode<K>): void {\n        if (node.older) node.older.newer = node.newer;\n        else this.#oldest = node.newer;\n        if (node.newer) node.newer.older = node.older;\n        else this.#newest = node.older;\n        node.older = node.newer = undefined;\n    }\n\n    #moveNewest(node: RecencyNode<K>): void {\n        if (node === this.#newest) return;\n        this.#unlink(node);\n        node.older = this.#newest;\n        if (this.#newest) this.#newest.newer = node;\n        else this.#oldest = node;\n        this.#newest = node;\n    }\n}\n\n/** Retention policy for a {@link Collection}. */\nexport interface CollectionOptions<K = unknown, V = unknown> {\n    /** Default sliding TTL in ms for `set()`. Omit for no expiry. */\n    ttl?: number;\n    /** Maximum entries stored with `set()`; least-recently-used are evicted past it. `setWithoutTTL()` entries are never counted or evicted. */\n    maxSize?: number;\n    /** Called after an entry is removed automatically, with why. Exceptions are swallowed. */\n    onEvict?: (key: K, value: V, reason: EvictionReason) => void;\n}\n\n/** Why an entry was removed automatically. */\nexport type EvictionReason = \"expired\" | \"evicted\";\n\n/** Cumulative counters from {@link Collection.stats}. */\nexport interface CollectionStats {\n    /** `get`/`peek` calls that found a value. */ hits: number;\n    /** `get`/`peek` calls that found nothing. */ misses: number;\n    /** Entries removed because their TTL lapsed. */ expired: number;\n    /** Entries removed to stay within `maxSize`. */ evicted: number;\n}\n\ntype Expiry = { deadline: number; window: number; filed: number };\n\nfunction assertTTL(ttl: number | undefined): void {\n    if (ttl !== undefined && (!Number.isFinite(ttl) || ttl <= 0))\n        throw new RangeError(\"TTL must be a positive number, or omitted.\");\n}\n\n/**\n * A keyed collection for Lunibee resource and application state.\n *\n * - `set(key, value, ttl?)` is TTL/LRU-aware: with a TTL (the default from\n *   options, or per call) the entry expires after that window of inactivity,\n *   and with `maxSize` it counts toward the cap.\n * - `setWithoutTTL(key, value)` never expires: no deadline, no heap record,\n *   no timer, and exempt from `maxSize` eviction. Resource managers store\n *   Discord state this way, so it leaves only through an explicit delete.\n *\n * Without options, a Collection behaves like a plain Map.\n */\nexport class Collection<K, V> extends Map<K, V> {\n    readonly #ttl?: number;\n    readonly #maxSize?: number;\n    /** Stored loosely typed so the callback does not make Collection invariant in K and V. */\n    readonly #onEvict?: (\n        key: unknown,\n        value: unknown,\n        reason: EvictionReason,\n    ) => void;\n    /** Deadlines of TTL entries only. */\n    readonly #expiry = new Map<K, Expiry>();\n    /** `set()` keys in recency order (oldest first), tracked only when `maxSize` is set; `setWithoutTTL()` keys are never here. */\n    readonly #lru = new RecencyList<K>();\n    readonly #stats: CollectionStats = {\n        hits: 0,\n        misses: 0,\n        expired: 0,\n        evicted: 0,\n    };\n    /** Min-heap of filed deadlines; stale records are dropped lazily. */\n    readonly #heap: { key: K; deadline: number }[] = [];\n    #timer?: ReturnType<typeof setTimeout>;\n    #armedFor = Infinity;\n\n    /**\n     * @param entries Initial entries, stored with `set()`.\n     * @param options TTL and size policy.\n     * @throws {RangeError} On a non-positive TTL or non-integer `maxSize`.\n     */\n    public constructor(\n        entries?: Iterable<readonly [K, V]> | null,\n        options: CollectionOptions<K, V> = {},\n    ) {\n        super();\n        assertTTL(options.ttl);\n        if (\n            options.maxSize !== undefined &&\n            (!Number.isInteger(options.maxSize) || options.maxSize <= 0)\n        )\n            throw new RangeError(\"maxSize must be a positive integer.\");\n        this.#ttl = options.ttl;\n        this.#maxSize = options.maxSize;\n        this.#onEvict = options.onEvict as\n            | ((key: unknown, value: unknown, reason: EvictionReason) => void)\n            | undefined;\n        if (entries) for (const [key, value] of entries) this.set(key, value);\n    }\n\n    /**\n     * Stores an entry with the default TTL (or `ttl`), marks it most recently\n     * used, and enforces `maxSize`. Turns a `setWithoutTTL()` entry back into\n     * a TTL/LRU entry.\n     */\n    public override set(key: K, value: V, ttl?: number): this {\n        assertTTL(ttl);\n        const window = ttl ?? this.#ttl;\n        if (this.#maxSize !== undefined) {\n            this.#lru.touch(key);\n        }\n        super.set(key, value);\n        if (window !== undefined) this.#schedule(key, window);\n        else if (this.#expiry.size > 0) this.#expiry.delete(key);\n        this.#enforceCap();\n        return this;\n    }\n\n    /**\n     * Stores an entry that never expires: no deadline, heap record, timer or\n     * LRU eviction. It leaves only through `delete`, `sweep`, `clear`, or a\n     * later `set()`.\n     */\n    public setWithoutTTL(key: K, value: V): this {\n        if (this.#expiry.size > 0) this.#expiry.delete(key);\n        if (this.#lru.size > 0) this.#lru.delete(key);\n        super.set(key, value);\n        return this;\n    }\n\n    /** Reads a value; restarts a TTL entry's window and promotes it. */\n    public override get(key: K): V | undefined {\n        if (this.#expireIfDue(key)) {\n            this.#stats.misses++;\n            return undefined;\n        }\n        const value = super.get(key);\n        if (value === undefined && !super.has(key)) {\n            this.#stats.misses++;\n            return undefined;\n        }\n        this.#stats.hits++;\n        const expiry = this.#expiry.get(key);\n        if (expiry) expiry.deadline = Date.now() + expiry.window;\n        this.#lru.promote(key);\n        return value;\n    }\n\n    /** Reads a value without restarting its TTL or promoting it. */\n    public peek(key: K): V | undefined {\n        if (!this.#expireIfDue(key) && super.has(key)) {\n            this.#stats.hits++;\n            return super.get(key);\n        }\n        this.#stats.misses++;\n        return undefined;\n    }\n\n    /** Cumulative hit, miss, expiry and eviction counters (a copy). */\n    public get stats(): CollectionStats {\n        return { ...this.#stats };\n    }\n\n    public override has(key: K): boolean {\n        return !this.#expireIfDue(key) && super.has(key);\n    }\n\n    public override delete(key: K): boolean {\n        if (this.#expireIfDue(key)) return false;\n        this.#expiry.delete(key);\n        this.#lru.delete(key);\n        return super.delete(key);\n    }\n\n    public override clear(): void {\n        super.clear();\n        this.#expiry.clear();\n        this.#lru.clear();\n        this.#heap.length = 0;\n        if (this.#timer) clearTimeout(this.#timer);\n        this.#timer = undefined;\n        this.#armedFor = Infinity;\n    }\n\n    public override get size(): number {\n        this.purge();\n        return super.size;\n    }\n\n    public override entries(): MapIterator<[K, V]> {\n        this.purge();\n        return super.entries();\n    }\n\n    public override keys(): MapIterator<K> {\n        this.purge();\n        return super.keys();\n    }\n\n    public override values(): MapIterator<V> {\n        this.purge();\n        return super.values();\n    }\n\n    public override [Symbol.iterator](): MapIterator<[K, V]> {\n        return this.entries();\n    }\n\n    public override forEach(\n        callback: (value: V, key: K, map: Map<K, V>) => void,\n        thisArg?: unknown,\n    ): void {\n        this.purge();\n        super.forEach(callback, thisArg);\n    }\n\n    /** Milliseconds until a key lapses, or undefined if absent or never expiring. */\n    public ttlRemaining(key: K): number | undefined {\n        if (this.#expireIfDue(key)) return undefined;\n        const expiry = this.#expiry.get(key);\n        return expiry && Math.max(0, expiry.deadline - Date.now());\n    }\n\n    /** Drops every lapsed TTL entry now. @returns How many were dropped. */\n    public purge(): number {\n        if (this.#expiry.size === 0) return 0;\n        const now = Date.now();\n        let removed = 0;\n        const dropped: [K, V][] = [];\n        while (this.#nextDeadline() <= now) {\n            const due = this.#heapPop()!;\n            dropped.push([due.key, super.get(due.key)!]);\n            this.#remove(due.key);\n            removed++;\n        }\n        this.#stats.expired += removed;\n        this.#rearm();\n        for (const [key, value] of dropped) this.#notify(key, value, \"expired\");\n        return removed;\n    }\n\n    #expireIfDue(key: K): boolean {\n        const expiry = this.#expiry.get(key);\n        if (!expiry || expiry.deadline > Date.now()) return false;\n        const value = super.get(key)!;\n        this.#remove(key);\n        this.#stats.expired++;\n        this.#notify(key, value, \"expired\");\n        return true;\n    }\n\n    #remove(key: K): void {\n        this.#expiry.delete(key);\n        this.#lru.delete(key);\n        super.delete(key);\n    }\n\n    #notify(key: K, value: V, reason: EvictionReason): void {\n        if (!this.#onEvict) return;\n        try {\n            this.#onEvict(key, value, reason);\n        } catch {\n            // A throwing callback must not leave the collection inconsistent.\n        }\n    }\n\n    /** Evicts least-recently-used `set()` entries past `maxSize`; O(1) per eviction. */\n    #enforceCap(): void {\n        if (this.#maxSize === undefined) return;\n        while (this.#lru.size > this.#maxSize) {\n            const oldest = this.#lru.oldest()!;\n            const value = super.get(oldest)!;\n            this.#remove(oldest);\n            this.#stats.evicted++;\n            this.#notify(oldest, value, \"evicted\");\n        }\n    }\n\n    /**\n     * Gives an entry a deadline. Extending one writes a number; the stale\n     * heap record re-files itself when it surfaces. Only a deadline that\n     * moves earlier (or a new one) is pushed.\n     */\n    #schedule(key: K, window: number): void {\n        const deadline = Date.now() + window;\n        const expiry = this.#expiry.get(key);\n        if (expiry) {\n            expiry.deadline = deadline;\n            expiry.window = window;\n            if (deadline >= expiry.filed) return;\n            expiry.filed = deadline;\n        } else this.#expiry.set(key, { deadline, window, filed: deadline });\n        this.#heapPush({ key, deadline });\n        if (this.#heap.length > 2 * this.#expiry.size + 8) this.#compact();\n        this.#rearm();\n    }\n\n    #nextDeadline(): number {\n        for (;;) {\n            const top = this.#heap[0];\n            if (top === undefined) return Infinity;\n            const expiry = this.#expiry.get(top.key);\n            if (!expiry || expiry.filed !== top.deadline) {\n                this.#heapPop();\n                continue;\n            }\n            if (expiry.deadline === top.deadline) return top.deadline;\n            // Extended since it was filed: re-file for its current deadline.\n            this.#heapPop();\n            expiry.filed = expiry.deadline;\n            this.#heapPush({ key: top.key, deadline: expiry.deadline });\n        }\n    }\n\n    #compact(): void {\n        const live = this.#heap.filter(\n            (record) => this.#expiry.get(record.key)?.filed === record.deadline,\n        );\n        this.#heap.length = 0;\n        for (const record of live) this.#heapPush(record);\n    }\n\n    #rearm(): void {\n        const deadline = this.#nextDeadline();\n        if (this.#timer !== undefined && deadline >= this.#armedFor) return;\n        if (this.#timer) clearTimeout(this.#timer);\n        this.#timer = undefined;\n        this.#armedFor = deadline;\n        if (deadline === Infinity) return;\n        this.#timer = setTimeout(\n            () => {\n                this.#timer = undefined;\n                this.#armedFor = Infinity;\n                this.purge();\n            },\n            Math.max(0, deadline - Date.now()),\n        );\n        // Pending expiry is housekeeping, not a reason to keep the process alive.\n        (this.#timer as { unref?: () => void }).unref?.();\n    }\n\n    #heapPush(record: { key: K; deadline: number }): void {\n        const heap = this.#heap;\n        heap.push(record);\n        let i = heap.length - 1;\n        while (i > 0) {\n            const parent = (i - 1) >> 1;\n            if (heap[parent]!.deadline <= heap[i]!.deadline) break;\n            [heap[parent], heap[i]] = [heap[i]!, heap[parent]!];\n            i = parent;\n        }\n    }\n\n    #heapPop(): { key: K; deadline: number } | undefined {\n        const heap = this.#heap;\n        const top = heap[0];\n        const last = heap.pop();\n        if (top === undefined || heap.length === 0) return top;\n        heap[0] = last!;\n        for (let i = 0; ;) {\n            const left = 2 * i + 1;\n            const right = left + 1;\n            let smallest = i;\n            if (\n                left < heap.length &&\n                heap[left]!.deadline < heap[smallest]!.deadline\n            )\n                smallest = left;\n            if (\n                right < heap.length &&\n                heap[right]!.deadline < heap[smallest]!.deadline\n            )\n                smallest = right;\n            if (smallest === i) break;\n            [heap[smallest], heap[i]] = [heap[i]!, heap[smallest]!];\n            i = smallest;\n        }\n        return top;\n    }\n\n    /** Returns the first stored value. */\n    public first(): V | undefined {\n        for (const value of this.values()) return value;\n        return undefined;\n    }\n    /** Returns the first stored key. */\n    public firstKey(): K | undefined {\n        for (const key of this.keys()) return key;\n        return undefined;\n    }\n    /** Returns the last stored value. */\n    public last(): V | undefined {\n        let value: V | undefined;\n        for (const item of this.values()) value = item;\n        return value;\n    }\n    /** Returns the last stored key. */\n    public lastKey(): K | undefined {\n        let key: K | undefined;\n        for (const item of this.keys()) key = item;\n        return key;\n    }\n    /** Finds the first value matching a predicate. */\n    public find(\n        predicate: (value: V, key: K, collection: this) => boolean,\n    ): V | undefined {\n        for (const [key, value] of this) {\n            if (predicate(value, key, this)) return value;\n        }\n        return undefined;\n    }\n    /** Returns all values matching a predicate. */\n    public filter(\n        predicate: (value: V, key: K, collection: this) => boolean,\n    ): Collection<K, V> {\n        const result = new Collection<K, V>();\n        for (const [key, value] of this) {\n            if (predicate(value, key, this)) result.set(key, value);\n        }\n        return result;\n    }\n    /** Transforms every stored value into an array. */\n    public map<T>(transform: (value: V, key: K, collection: this) => T): T[] {\n        const result: T[] = [];\n        for (const [key, value] of this) {\n            result.push(transform(value, key, this));\n        }\n        return result;\n    }\n    /** Returns whether at least one stored value satisfies a predicate. */\n    public some(\n        predicate: (value: V, key: K, collection: this) => boolean,\n    ): boolean {\n        for (const [key, value] of this) {\n            if (predicate(value, key, this)) return true;\n        }\n        return false;\n    }\n    /** Returns whether every stored value satisfies a predicate. */\n    public every(\n        predicate: (value: V, key: K, collection: this) => boolean,\n    ): boolean {\n        for (const [key, value] of this) {\n            if (!predicate(value, key, this)) return false;\n        }\n        return true;\n    }\n    /** Runs a callback for each stored value. */\n    public each(\n        callback: (value: V, key: K, collection: this) => unknown,\n    ): this {\n        for (const [key, value] of this) {\n            callback(value, key, this);\n        }\n        return this;\n    }\n    /** Returns an array containing all stored values. */\n    public array(): V[] {\n        return [...this.values()];\n    }\n    /** Returns an array containing all stored keys. */\n    public keyArray(): K[] {\n        return [...this.keys()];\n    }\n    /** Returns a plain array of entries. */\n    public entriesArray(): [K, V][] {\n        return [...this.entries()];\n    }\n    /** Returns a new collection with the same entries. */\n    public clone(): Collection<K, V> {\n        const copy = new Collection<K, V>();\n        for (const [key, value] of this) copy.set(key, value);\n        return copy;\n    }\n    /** Returns whether all supplied keys are present. */\n    public hasAll(...keys: K[]): boolean {\n        for (let i = 0; i < keys.length; i++) {\n            if (!this.has(keys[i]!)) return false;\n        }\n        return true;\n    }\n    /** Returns whether at least one supplied key is present. */\n    public hasAny(...keys: K[]): boolean {\n        for (let i = 0; i < keys.length; i++) {\n            if (this.has(keys[i]!)) return true;\n        }\n        return false;\n    }\n    /** Returns the first key whose value matches a predicate. */\n    public findKey(\n        predicate: (value: V, key: K, collection: this) => boolean,\n    ): K | undefined {\n        for (const [key, value] of this) {\n            if (predicate(value, key, this)) return key;\n        }\n        return undefined;\n    }\n    /** Returns whether a predicate matches at least one entry. */\n    public someEntry(\n        predicate: (value: V, key: K, collection: this) => boolean,\n    ): boolean {\n        return this.some(predicate);\n    }\n    /** Removes every entry matching a predicate and returns the number removed. */\n    public sweep(\n        predicate: (value: V, key: K, collection: this) => boolean,\n    ): number {\n        let removed = 0;\n        for (const [key, value] of this) {\n            if (predicate(value, key, this) && this.delete(key)) removed++;\n        }\n        return removed;\n    }\n    /** Returns the collection's first matching entry as a tuple. */\n    public firstEntry(): [K, V] | undefined {\n        for (const [key, value] of this) return [key, value];\n        return undefined;\n    }\n    /** Returns the collection's last matching entry as a tuple. */\n    public lastEntry(): [K, V] | undefined {\n        let entry: [K, V] | undefined;\n        for (const item of this) entry = [item[0], item[1]];\n        return entry;\n    }\n    /** Returns a new Collection containing elements from both collections. */\n    public union(other: Collection<K, V>): Collection<K, V> {\n        const result = this.clone();\n        for (const [key, value] of other) result.set(key, value);\n        return result;\n    }\n    /** Returns a new Collection containing only elements present in both collections. */\n    public intersection(other: Collection<K, V>): Collection<K, V> {\n        const result = new Collection<K, V>();\n        for (const [key, value] of this) {\n            if (other.has(key)) result.set(key, value);\n        }\n        return result;\n    }\n    /** Returns a new Collection containing elements present in this collection but not the other. */\n    public difference(other: Collection<K, V>): Collection<K, V> {\n        const result = new Collection<K, V>();\n        for (const [key, value] of this) {\n            if (!other.has(key)) result.set(key, value);\n        }\n        return result;\n    }\n    /** Splits the collection into two collections based on a predicate.\n     * @returns `[passing, failing]` — entries satisfying the predicate, then those that don't.\n     */\n    public partition(\n        predicate: (value: V, key: K, collection: this) => boolean,\n    ): [Collection<K, V>, Collection<K, V>] {\n        const pass = new Collection<K, V>();\n        const fail = new Collection<K, V>();\n        for (const [key, value] of this) {\n            if (predicate(value, key, this)) pass.set(key, value);\n            else fail.set(key, value);\n        }\n        return [pass, fail];\n    }\n    /** Calls `fn` with this collection and returns the collection unchanged.\n     * Useful for inserting debug side-effects in a chain without breaking the flow.\n     */\n    public tap(fn: (collection: this) => unknown): this {\n        fn(this);\n        return this;\n    }\n    /** Maps every entry to an array of items and flattens the results. */\n    public flatMap<T>(\n        transform: (value: V, key: K, collection: this) => T[],\n    ): T[] {\n        const result: T[] = [];\n        for (const [key, value] of this) {\n            for (const item of transform(value, key, this)) result.push(item);\n        }\n        return result;\n    }\n    /** Reduces the collection to a single value. */\n    public reduce<T>(\n        fn: (accumulator: T, value: V, key: K, collection: this) => T,\n        initialValue: T,\n    ): T {\n        let acc = initialValue;\n        for (const [key, value] of this) acc = fn(acc, value, key, this);\n        return acc;\n    }\n    /** Returns a new Collection with entries sorted by comparator (non-mutating).\n     * Defaults to insertion order if no comparator is provided.\n     */\n    public sorted(\n        comparator?: (a: V, b: V, aKey: K, bKey: K) => number,\n    ): Collection<K, V> {\n        // Decorate with the original insertion index and use it as a tiebreaker so\n        // equal elements keep their insertion order (a stable sort independent of\n        // the engine's Array.prototype.sort stability guarantees).\n        const decorated = [...this.entries()].map((entry, index) => ({\n            entry,\n            index,\n        }));\n        if (comparator)\n            decorated.sort((x, y) => {\n                const comparison = comparator(\n                    x.entry[1],\n                    y.entry[1],\n                    x.entry[0],\n                    y.entry[0],\n                );\n                return comparison !== 0 ? comparison : x.index - y.index;\n            });\n        const result = new Collection<K, V>();\n        for (const { entry } of decorated) result.set(entry[0], entry[1]);\n        return result;\n    }\n    /** Returns a random value from the collection, or `undefined` if empty.\n     * Uses `Math.random()` (fast, non-cryptographic) — do not use for security-sensitive\n     * selection such as tokens or secrets. */\n    public random(): V | undefined {\n        const arr = [...this.values()];\n        if (!arr.length) return undefined;\n        return arr[Math.floor(Math.random() * arr.length)];\n    }\n    /** Returns a random key from the collection, or `undefined` if empty.\n     * Uses `Math.random()` (fast, non-cryptographic) — do not use for security-sensitive\n     * selection such as tokens or secrets. */\n    public randomKey(): K | undefined {\n        const arr = [...this.keys()];\n        if (!arr.length) return undefined;\n        return arr[Math.floor(Math.random() * arr.length)];\n    }\n    /** Returns the value at a given insertion-order index (supports negative indices). */\n    public at(index: number): V | undefined {\n        const arr = [...this.values()];\n        const i = index < 0 ? arr.length + index : index;\n        return arr[i];\n    }\n    /** Returns the key at a given insertion-order index (supports negative indices). */\n    public keyAt(index: number): K | undefined {\n        const arr = [...this.keys()];\n        const i = index < 0 ? arr.length + index : index;\n        return arr[i];\n    }\n    /** Serializes the collection to a plain `[key, value]` array. */\n    public toJSON(): [K, V][] {\n        return [...this.entries()];\n    }\n}\n\nexport { Cache } from \"./cache.js\";\nexport type { CacheOptions } from \"./cache.js\";\n"
+    "import { Collection } from \"./index.js\";\r\n\r\n/** Cache policy for bounded resource storage. */\r\nexport interface CacheOptions {\r\n    /** Maximum number of entries retained. */\r\n    maxSize?: number;\r\n    /** Time-to-live in milliseconds. Omit to disable expiration. */\r\n    ttl?: number;\r\n    /**\r\n     * Accepted for compatibility and still validated. Expired entries are now\r\n     * dropped at their deadline, so no periodic sweep is needed.\r\n     */\r\n    sweepInterval?: number;\r\n}\r\n\r\n/**\r\n * Bounded cache with a fixed TTL, least-recently-used eviction and explicit\r\n * invalidation. A thin policy layer over {@link Collection}: reads promote an\r\n * entry but do not extend its TTL.\r\n */\r\nexport class Cache<K, V> {\r\n    readonly #entries: Collection<K, V>;\r\n\r\n    /** Creates a cache using the supplied retention policy. */\r\n    public constructor(options: CacheOptions = {}) {\r\n        const maxSize = options.maxSize ?? Infinity;\r\n        const ttl = options.ttl ?? 0;\r\n        if ((!Number.isInteger(maxSize) && maxSize !== Infinity) || maxSize < 1)\r\n            throw new RangeError(\"Cache maxSize must be a positive integer.\");\r\n        if (!Number.isFinite(ttl) || ttl < 0)\r\n            throw new RangeError(\r\n                \"Cache ttl must be a non-negative finite number.\",\r\n            );\r\n        if (ttl > 0) {\r\n            const interval = options.sweepInterval ?? Math.min(ttl, 60_000);\r\n            if (!Number.isFinite(interval) || interval < 1)\r\n                throw new RangeError(\"Cache sweepInterval must be positive.\");\r\n        }\r\n        this.#entries = new Collection<K, V>(null, {\r\n            ttl: ttl > 0 ? ttl : undefined,\r\n            maxSize: maxSize === Infinity ? undefined : maxSize,\r\n            slide: false,\r\n        });\r\n    }\r\n\r\n    /** Number of currently live entries. */\r\n    public get size(): number {\r\n        return this.#entries.size;\r\n    }\r\n    /** Reads a live entry and marks it most recently used. */\r\n    public get(key: K): V | undefined {\r\n        return this.#entries.get(key);\r\n    }\r\n    /** Returns whether a live entry exists. */\r\n    public has(key: K): boolean {\r\n        return this.#entries.has(key);\r\n    }\r\n    /** Stores an entry and evicts the least recently used ones when the bound is exceeded. */\r\n    public set(key: K, value: V): this {\r\n        this.#entries.set(key, value);\r\n        return this;\r\n    }\r\n    /** Invalidates one key. */\r\n    public delete(key: K): boolean {\r\n        return this.#entries.delete(key);\r\n    }\r\n    /** Invalidates every cached resource. */\r\n    public clear(): void {\r\n        this.#entries.clear();\r\n    }\r\n    /** Invalidates every entry matching a predicate. */\r\n    public invalidate(predicate: (value: V, key: K) => boolean): number {\r\n        return this.#entries.sweep(predicate);\r\n    }\r\n    /** Removes expired entries now and returns the number removed. */\r\n    public sweep(): number {\r\n        return this.#entries.purge();\r\n    }\r\n    /** Kept for compatibility: there is no background sweeper to stop. */\r\n    public dispose(): void {}\r\n    /** Returns live cached values. */\r\n    public values(): V[] {\r\n        return [...this.#entries.values()];\r\n    }\r\n    /** Returns live cached entries. */\r\n    public entries(): [K, V][] {\r\n        return [...this.#entries.entries()];\r\n    }\r\n}\r\n",
+    "/** Retention policy for a {@link Collection}. */\r\nexport interface CollectionOptions<K = unknown, V = unknown> {\r\n    /** Default sliding TTL in ms for `set()`. Omit for no expiry. */\r\n    ttl?: number;\r\n    /** Maximum entries stored with `set()`; least-recently-used are evicted past it. `setWithoutTTL()` entries are never counted or evicted. */\r\n    maxSize?: number;\r\n    /** Whether a read restarts a TTL entry's window. Default `true`; with `false` an entry lapses a fixed time after it was set, and reads only mark it recently used. */\r\n    slide?: boolean;\r\n    /** Called after an entry is removed automatically, with why. Exceptions are swallowed. */\r\n    onEvict?: (key: K, value: V, reason: EvictionReason) => void;\r\n}\r\n\r\n/** Why an entry was removed automatically. */\r\nexport type EvictionReason = \"expired\" | \"evicted\";\r\n\r\n/** Cumulative counters from {@link Collection.stats}. */\r\nexport interface CollectionStats {\r\n    /** `get`/`peek` calls that found a value. */\r\n    hits: number;\r\n    /** `get`/`peek` calls that found nothing. */\r\n    misses: number;\r\n    /** Entries removed because their TTL lapsed. */\r\n    expired: number;\r\n    /** Entries removed to stay within `maxSize`. */\r\n    evicted: number;\r\n}\r\n\r\n/**\r\n * Everything the policy knows about one key: its place in the recency list\r\n * and its TTL. One record serves the policy map, the recency list and the\r\n * expiry heap, so a write touches one extra hash entry and allocates once.\r\n */\r\ntype Entry<K, V> = {\r\n    key: K;\r\n    /** A copy of the stored value, so a read needs one lookup instead of two. */\r\n    value: V;\r\n    /** Neighbours in recency order; meaningful while `inLru`. */\r\n    older: Entry<K, V> | undefined;\r\n    newer: Entry<K, V> | undefined;\r\n    inLru: boolean;\r\n    /** TTL window in ms; 0 when the entry does not expire (and is not in the heap). */\r\n    window: number;\r\n    /** The current deadline; a read moves it later without touching the heap. */\r\n    deadline: number;\r\n    /** The deadline the heap ordered this record by. */\r\n    filed: number;\r\n};\r\n\r\n/**\r\n * Everything a retention policy needs. A Collection without `ttl` or\r\n * `maxSize` never creates one, so plain collections cost no more than a Map.\r\n */\r\ntype Policy<K, V> = {\r\n    /** Keys with a TTL or a recency position; `setWithoutTTL()` keys are absent. */\r\n    entries: Map<K, Entry<K, V>>;\r\n    /** Oldest and newest entries of the recency list; only `maxSize` collections use it. */\r\n    oldest: Entry<K, V> | undefined;\r\n    newest: Entry<K, V> | undefined;\r\n    lruSize: number;\r\n    /** Min-heap by `filed`. A record that is no longer its key's map value is stale and dropped lazily. */\r\n    heap: Entry<K, V>[];\r\n    timer?: ReturnType<typeof setTimeout>;\r\n    armedFor: number;\r\n    /** The options, kept here so a plain collection carries none of them. */\r\n    ttl: number | undefined;\r\n    maxSize: number | undefined;\r\n    slide: boolean;\r\n    /** Stored loosely typed so the callback does not make Collection invariant in K and V. */\r\n    onEvict:\r\n        | ((key: unknown, value: unknown, reason: EvictionReason) => void)\r\n        | undefined;\r\n    expired: number;\r\n    evicted: number;\r\n};\r\n\r\nfunction newPolicy<K, V>(options: CollectionOptions<K, V> = {}): Policy<K, V> {\r\n    return {\r\n        ttl: options.ttl,\r\n        maxSize: options.maxSize,\r\n        slide: options.slide ?? true,\r\n        onEvict: options.onEvict as Policy<K, V>[\"onEvict\"],\r\n        expired: 0,\r\n        evicted: 0,\r\n        entries: new Map(),\r\n        oldest: undefined,\r\n        newest: undefined,\r\n        lruSize: 0,\r\n        heap: [],\r\n        armedFor: Infinity,\r\n    };\r\n}\r\n\r\n/**\r\n * Reads a value that `has()` just confirmed, without touching a Lunibee\r\n * collection's TTL, recency or hit counters.\r\n */\r\nfunction peekOf<K, V>(\r\n    collection: ReadonlyCollection<K, V>,\r\n    key: K,\r\n): V | undefined {\r\n    return collection instanceof Map\r\n        ? (Map.prototype.get.call(collection, key) as V | undefined)\r\n        : collection.get(key);\r\n}\r\n\r\n/** What `merge()` does with one entry: keep it with `value`, or drop it. */\r\nexport type Keep<V> = { keep: true; value: V } | { keep: false };\r\n\r\n/**\r\n * A `Collection` seen read-only: every method that does not change it. Pass it\r\n * where you only read, so a function cannot add to or remove from the cache.\r\n */\r\nexport type ReadonlyCollection<K, V> = Omit<\r\n    Collection<K, V>,\r\n    | \"set\"\r\n    | \"setWithoutTTL\"\r\n    | \"delete\"\r\n    | \"clear\"\r\n    | \"ensure\"\r\n    | \"forEach\"\r\n    | \"get\"\r\n    | \"sweep\"\r\n    | \"purge\"\r\n> &\r\n    ReadonlyMap<K, V>;\r\n\r\nconst mapGet = Map.prototype.get as (\r\n    this: Map<unknown, unknown>,\r\n    key: unknown,\r\n) => unknown;\r\nconst mapHas = Map.prototype.has as (\r\n    this: Map<unknown, unknown>,\r\n    key: unknown,\r\n) => boolean;\r\n\r\n/** Picks `amount` different items at random (a partial Fisher-Yates shuffle of `items`). */\r\nfunction sample<T>(items: T[], amount: number): T[] {\r\n    if (!Number.isInteger(amount) || amount < 0)\r\n        throw new RangeError(\"amount must be a non-negative integer.\");\r\n    const count = Math.min(amount, items.length);\r\n    for (let i = 0; i < count; i++) {\r\n        const j = i + Math.floor(Math.random() * (items.length - i));\r\n        [items[i], items[j]] = [items[j]!, items[i]!];\r\n    }\r\n    items.length = count;\r\n    return items;\r\n}\r\n\r\nfunction assertTTL(ttl: number | undefined): void {\r\n    if (ttl !== undefined && (!Number.isFinite(ttl) || ttl <= 0))\r\n        throw new RangeError(\"TTL must be a positive number, or omitted.\");\r\n}\r\n\r\n/**\r\n * A keyed collection for Lunibee resource and application state.\r\n *\r\n * - `set(key, value, ttl?)` is TTL/LRU-aware: with a TTL (the default from\r\n *   options, or per call) the entry expires after that window of inactivity,\r\n *   and with `maxSize` it counts toward the cap.\r\n * - `setWithoutTTL(key, value)` never expires: no deadline, no heap record,\r\n *   no timer, and exempt from `maxSize` eviction. Resource managers store\r\n *   Discord state this way, so it leaves only through an explicit delete.\r\n *\r\n * Without options, a Collection behaves like a plain Map.\r\n */\r\nexport class Collection<K, V> extends Map<K, V> {\r\n    /** Created with any option, or by the first `set()` with its own TTL. */\r\n    #policy?: Policy<K, V>;\r\n    #hits = 0;\r\n    #misses = 0;\r\n\r\n    /**\r\n     * @param entries Initial entries, stored with `set()`.\r\n     * @param options TTL and size policy.\r\n     * @throws {RangeError} On a non-positive TTL or non-integer `maxSize`.\r\n     */\r\n    public constructor(\r\n        entries?: Iterable<readonly [K, V]> | null,\r\n        options: CollectionOptions<K, V> = {},\r\n    ) {\r\n        super();\r\n        assertTTL(options.ttl);\r\n        if (\r\n            options.maxSize !== undefined &&\r\n            (!Number.isInteger(options.maxSize) || options.maxSize <= 0)\r\n        )\r\n            throw new RangeError(\"maxSize must be a positive integer.\");\r\n        if (\r\n            options.ttl !== undefined ||\r\n            options.maxSize !== undefined ||\r\n            options.slide !== undefined ||\r\n            options.onEvict !== undefined\r\n        )\r\n            this.#policy = newPolicy(options);\r\n        if (entries) for (const [key, value] of entries) this.set(key, value);\r\n    }\r\n\r\n    /**\r\n     * Stores an entry with the default TTL (or `ttl`), marks it most recently\r\n     * used, and enforces `maxSize`. Turns a `setWithoutTTL()` entry back into\r\n     * a TTL/LRU entry.\r\n     */\r\n    public override set(key: K, value: V, ttl?: number): this {\r\n        if (ttl === undefined && this.#policy === undefined)\r\n            return super.set(key, value);\r\n        assertTTL(ttl);\r\n        const window = ttl ?? this.#policy?.ttl;\r\n        if (window !== undefined) this.#policy ??= newPolicy();\r\n        if (!this.#policy) return super.set(key, value);\r\n        // A key that was not stored before has no policy entry.\r\n        const before = super.size;\r\n        super.set(key, value);\r\n        this.#track(key, value, window, super.size !== before);\r\n        this.#enforceCap();\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Stores an entry that never expires: no deadline, heap record, timer or\r\n     * LRU eviction. It leaves only through `delete`, `sweep`, `clear`, or a\r\n     * later `set()`.\r\n     */\r\n    public setWithoutTTL(key: K, value: V): this {\r\n        if (this.#policy) this.#forget(key);\r\n        super.set(key, value);\r\n        return this;\r\n    }\r\n\r\n    /** Reads a value; restarts a TTL entry's window and promotes it. */\r\n    public override get(key: K): V | undefined {\r\n        const policy = this.#policy;\r\n        const entry = policy?.entries.get(key);\r\n        if (entry === undefined) {\r\n            const value = mapGet.call(this, key) as V | undefined;\r\n            if (value !== undefined || mapHas.call(this, key)) {\r\n                this.#hits++;\r\n                return value;\r\n            }\r\n            this.#misses++;\r\n            return undefined;\r\n        }\r\n        const timed = entry.window !== 0;\r\n        const now = timed ? Date.now() : 0;\r\n        if (timed && entry.deadline <= now) {\r\n            this.#expire(entry);\r\n            this.#misses++;\r\n            return undefined;\r\n        }\r\n        this.#hits++;\r\n        if (timed && policy!.slide) entry.deadline = now + entry.window;\r\n        if (entry.inLru) this.#promote(policy!, entry);\r\n        return entry.value;\r\n    }\r\n\r\n    /**\r\n     * Returns the value for `key`, or stores and returns what `factory`\r\n     * makes. Reading counts as a `get()` (restarts the TTL, marks it recently\r\n     * used); creating stores with `set()`, so `ttl` applies.\r\n     * @param factory Called with the key and this collection only when the key is missing; if it throws, nothing is stored.\r\n     * @param ttl TTL in ms for a created entry; defaults to the collection's.\r\n     */\r\n    public ensure(\r\n        key: K,\r\n        factory: (key: K, collection: this) => V,\r\n        ttl?: number,\r\n    ): V {\r\n        const existing = this.get(key);\r\n        if (existing !== undefined || super.has(key)) return existing as V;\r\n        const created = factory(key, this);\r\n        this.set(key, created, ttl);\r\n        return created;\r\n    }\r\n\r\n    /** Reads a value without restarting its TTL or promoting it. */\r\n    public peek(key: K): V | undefined {\r\n        if (!this.#expireIfDue(key) && super.has(key)) {\r\n            this.#hits++;\r\n            return super.get(key);\r\n        }\r\n        this.#misses++;\r\n        return undefined;\r\n    }\r\n\r\n    /** Cumulative hit, miss, expiry and eviction counters (a copy). */\r\n    public get stats(): CollectionStats {\r\n        return {\r\n            hits: this.#hits,\r\n            misses: this.#misses,\r\n            expired: this.#policy?.expired ?? 0,\r\n            evicted: this.#policy?.evicted ?? 0,\r\n        };\r\n    }\r\n\r\n    public override has(key: K): boolean {\r\n        return !this.#expireIfDue(key) && super.has(key);\r\n    }\r\n\r\n    public override delete(key: K): boolean {\r\n        if (this.#expireIfDue(key)) return false;\r\n        if (this.#policy) this.#forget(key);\r\n        return super.delete(key);\r\n    }\r\n\r\n    public override clear(): void {\r\n        super.clear();\r\n        const policy = this.#policy;\r\n        if (!policy) return;\r\n        policy.entries.clear();\r\n        policy.oldest = policy.newest = undefined;\r\n        policy.lruSize = 0;\r\n        policy.heap.length = 0;\r\n        if (policy.timer) clearTimeout(policy.timer);\r\n        policy.timer = undefined;\r\n        policy.armedFor = Infinity;\r\n    }\r\n\r\n    public override get size(): number {\r\n        this.purge();\r\n        return super.size;\r\n    }\r\n\r\n    public override entries(): MapIterator<[K, V]> {\r\n        this.purge();\r\n        return super.entries();\r\n    }\r\n\r\n    public override keys(): MapIterator<K> {\r\n        this.purge();\r\n        return super.keys();\r\n    }\r\n\r\n    public override values(): MapIterator<V> {\r\n        this.purge();\r\n        return super.values();\r\n    }\r\n\r\n    public override [Symbol.iterator](): MapIterator<[K, V]> {\r\n        return this.entries();\r\n    }\r\n\r\n    public override forEach(\r\n        callback: (value: V, key: K, map: Map<K, V>) => void,\r\n        thisArg?: unknown,\r\n    ): void {\r\n        this.purge();\r\n        super.forEach(callback, thisArg);\r\n    }\r\n\r\n    /** Milliseconds until a key lapses, or undefined if absent or never expiring. */\r\n    public ttlRemaining(key: K): number | undefined {\r\n        if (this.#expireIfDue(key)) return undefined;\r\n        const entry = this.#policy?.entries.get(key);\r\n        return entry && entry.window !== 0\r\n            ? Math.max(0, entry.deadline - Date.now())\r\n            : undefined;\r\n    }\r\n\r\n    /** Drops every lapsed TTL entry now. @returns How many were dropped. */\r\n    public purge(): number {\r\n        if (!this.#policy || this.#policy.heap.length === 0) return 0;\r\n        const now = Date.now();\r\n        let removed = 0;\r\n        const dropped: [K, V][] = [];\r\n        while (this.#nextDeadline() <= now) {\r\n            const due = this.#heapPop()!;\r\n            dropped.push([due.key, super.get(due.key)!]);\r\n            this.#remove(due.key);\r\n            removed++;\r\n        }\r\n        this.#policy!.expired += removed;\r\n        this.#rearm();\r\n        for (const [key, value] of dropped) this.#notify(key, value, \"expired\");\r\n        return removed;\r\n    }\r\n\r\n    /** Drops `key` if its TTL has lapsed. @returns Whether it did. */\r\n    #expireIfDue(key: K): boolean {\r\n        const entry = this.#policy?.entries.get(key);\r\n        if (!entry || entry.window === 0 || entry.deadline > Date.now())\r\n            return false;\r\n        this.#expire(entry);\r\n        return true;\r\n    }\r\n\r\n    #expire(entry: Entry<K, V>): void {\r\n        const value = super.get(entry.key)!;\r\n        this.#remove(entry.key);\r\n        this.#policy!.expired++;\r\n        this.#notify(entry.key, value, \"expired\");\r\n    }\r\n\r\n    #remove(key: K): void {\r\n        this.#forget(key);\r\n        super.delete(key);\r\n    }\r\n\r\n    /** Drops a key's policy entry (recency position and TTL); its heap record goes stale. */\r\n    #forget(key: K): void {\r\n        const policy = this.#policy!;\r\n        const entry = policy.entries.get(key);\r\n        if (!entry) return;\r\n        if (entry.inLru) this.#unlink(policy, entry);\r\n        policy.entries.delete(key);\r\n    }\r\n\r\n    /**\r\n     * Brings the key's policy entry in line with a `set()`: marks it newest\r\n     * when `maxSize` is set, and gives it a deadline when `window` is defined.\r\n     * Only a new entry, or a deadline that moves earlier, gets a heap record;\r\n     * a later one is a number write and the record re-files itself when it\r\n     * surfaces.\r\n     */\r\n    #track(key: K, value: V, window: number | undefined, isNew: boolean): void {\r\n        const policy = this.#policy!;\r\n        const lru = policy.maxSize !== undefined;\r\n        let entry = isNew ? undefined : policy.entries.get(key);\r\n        if (entry) entry.value = value;\r\n        if (window === undefined) {\r\n            if (entry && entry.window !== 0) {\r\n                // It had a TTL and now has none.\r\n                if (lru) entry = this.#replace(policy, entry, 0, 0);\r\n                else {\r\n                    this.#forget(key);\r\n                    return;\r\n                }\r\n            }\r\n            if (!entry && lru) {\r\n                entry = this.#create(key, value, 0, 0);\r\n                policy.entries.set(key, entry);\r\n            }\r\n            if (entry) this.#promote(policy, entry);\r\n            return;\r\n        }\r\n        const deadline = Date.now() + window;\r\n        if (entry && entry.window !== 0) {\r\n            entry.deadline = deadline;\r\n            entry.window = window;\r\n            if (deadline < entry.filed)\r\n                // The heap cannot move a record up, and this one is in it: file a fresh one.\r\n                entry = this.#replace(policy, entry, window, deadline);\r\n            else {\r\n                if (entry.inLru) this.#promote(policy, entry);\r\n                return;\r\n            }\r\n        } else if (entry) {\r\n            entry.window = window;\r\n            entry.deadline = entry.filed = deadline;\r\n        } else {\r\n            entry = this.#create(key, value, window, deadline);\r\n            policy.entries.set(key, entry);\r\n        }\r\n        if (lru) this.#promote(policy, entry);\r\n        this.#heapPush(entry);\r\n        if (policy.heap.length > 2 * policy.entries.size + 8) this.#compact();\r\n        // A timer already armed for an earlier deadline stays correct.\r\n        if (policy.timer === undefined || deadline < policy.armedFor)\r\n            this.#rearm();\r\n    }\r\n\r\n    #create(key: K, value: V, window: number, deadline: number): Entry<K, V> {\r\n        return {\r\n            key,\r\n            value,\r\n            older: undefined,\r\n            newer: undefined,\r\n            inLru: false,\r\n            window,\r\n            deadline,\r\n            filed: deadline,\r\n        };\r\n    }\r\n\r\n    /** Swaps in a fresh record for `old` (which goes stale), keeping its recency position. */\r\n    #replace(\r\n        policy: Policy<K, V>,\r\n        old: Entry<K, V>,\r\n        window: number,\r\n        deadline: number,\r\n    ): Entry<K, V> {\r\n        const entry: Entry<K, V> = {\r\n            ...old,\r\n            window,\r\n            deadline,\r\n            filed: deadline,\r\n        };\r\n        if (old.inLru) {\r\n            if (old.older) old.older.newer = entry;\r\n            else policy.oldest = entry;\r\n            if (old.newer) old.newer.older = entry;\r\n            else policy.newest = entry;\r\n        }\r\n        policy.entries.set(old.key, entry);\r\n        return entry;\r\n    }\r\n\r\n    /** Makes an entry the newest in recency order, linking it first if needed. */\r\n    #promote(policy: Policy<K, V>, entry: Entry<K, V>): void {\r\n        if (entry === policy.newest) return;\r\n        if (entry.inLru) this.#unlink(policy, entry, true);\r\n        else {\r\n            entry.inLru = true;\r\n            policy.lruSize++;\r\n        }\r\n        entry.older = policy.newest;\r\n        entry.newer = undefined;\r\n        if (policy.newest) policy.newest.newer = entry;\r\n        else policy.oldest = entry;\r\n        policy.newest = entry;\r\n    }\r\n\r\n    /** Takes an entry out of the recency list; `keepCount` is for a move within it. */\r\n    #unlink(policy: Policy<K, V>, entry: Entry<K, V>, keepCount = false): void {\r\n        if (entry.older) entry.older.newer = entry.newer;\r\n        else policy.oldest = entry.newer;\r\n        if (entry.newer) entry.newer.older = entry.older;\r\n        else policy.newest = entry.older;\r\n        entry.older = entry.newer = undefined;\r\n        if (!keepCount) {\r\n            entry.inLru = false;\r\n            policy.lruSize--;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * An empty collection of the species this one derives, so `filter()` and\r\n     * friends on a subclass return the subclass. It is built without\r\n     * arguments and carries no `ttl` or `maxSize`.\r\n     */\r\n    #derived(): this {\r\n        const Species =\r\n            (\r\n                this.constructor as {\r\n                    [Symbol.species]?: new () => Collection<K, V>;\r\n                }\r\n            )[Symbol.species] ?? Collection;\r\n        return new Species() as this;\r\n    }\r\n\r\n    #notify(key: K, value: V, reason: EvictionReason): void {\r\n        const onEvict = this.#policy?.onEvict;\r\n        if (!onEvict) return;\r\n        try {\r\n            onEvict(key, value, reason);\r\n        } catch {\r\n            // A throwing callback must not leave the collection inconsistent.\r\n        }\r\n    }\r\n\r\n    /** Evicts least-recently-used `set()` entries past `maxSize`; O(1) per eviction. */\r\n    #enforceCap(): void {\r\n        const policy = this.#policy!;\r\n        const max = policy.maxSize;\r\n        if (max === undefined) return;\r\n        // Lapsed entries must not push live ones out.\r\n        if (\r\n            policy.lruSize > max &&\r\n            policy.heap.length > 0 &&\r\n            policy.heap[0]!.filed <= Date.now()\r\n        )\r\n            this.purge();\r\n        while (policy.lruSize > max) {\r\n            const oldest = policy.oldest!;\r\n            const value = policy.onEvict ? super.get(oldest.key) : undefined;\r\n            this.#unlink(policy, oldest);\r\n            policy.entries.delete(oldest.key);\r\n            super.delete(oldest.key);\r\n            policy.evicted++;\r\n            this.#notify(oldest.key, value as V, \"evicted\");\r\n        }\r\n    }\r\n\r\n    #nextDeadline(): number {\r\n        const policy = this.#policy!;\r\n        for (;;) {\r\n            const top = policy.heap[0];\r\n            if (top === undefined) return Infinity;\r\n            if (policy.entries.get(top.key) !== top) {\r\n                this.#heapPop();\r\n                continue;\r\n            }\r\n            if (top.deadline === top.filed) return top.filed;\r\n            // Extended since it was filed: re-file for its current deadline.\r\n            this.#heapPop();\r\n            top.filed = top.deadline;\r\n            this.#heapPush(top);\r\n        }\r\n    }\r\n\r\n    #compact(): void {\r\n        const policy = this.#policy!;\r\n        const live = policy.heap.filter(\r\n            (entry) => policy.entries.get(entry.key) === entry,\r\n        );\r\n        policy.heap.length = 0;\r\n        for (const entry of live) this.#heapPush(entry);\r\n    }\r\n\r\n    #rearm(): void {\r\n        const p = this.#policy!;\r\n        const deadline = this.#nextDeadline();\r\n        if (p.timer !== undefined && deadline >= p.armedFor) return;\r\n        if (p.timer) clearTimeout(p.timer);\r\n        p.timer = undefined;\r\n        p.armedFor = deadline;\r\n        if (deadline === Infinity) return;\r\n        p.timer = setTimeout(\r\n            () => {\r\n                p.timer = undefined;\r\n                p.armedFor = Infinity;\r\n                this.purge();\r\n            },\r\n            Math.max(0, deadline - Date.now()),\r\n        );\r\n        // Pending expiry is housekeeping, not a reason to keep the process alive.\r\n        (p.timer as { unref?: () => void }).unref?.();\r\n    }\r\n\r\n    #heapPush(entry: Entry<K, V>): void {\r\n        const heap = this.#policy!.heap;\r\n        let i = heap.length;\r\n        heap.push(entry);\r\n        while (i > 0) {\r\n            const parent = (i - 1) >> 1;\r\n            const above = heap[parent]!;\r\n            if (above.filed <= entry.filed) break;\r\n            heap[i] = above;\r\n            i = parent;\r\n        }\r\n        heap[i] = entry;\r\n    }\r\n\r\n    #heapPop(): Entry<K, V> | undefined {\r\n        const heap = this.#policy!.heap;\r\n        const top = heap[0];\r\n        const last = heap.pop();\r\n        if (top === undefined || heap.length === 0) return top;\r\n        let i = 0;\r\n        for (;;) {\r\n            let child = 2 * i + 1;\r\n            if (child >= heap.length) break;\r\n            if (\r\n                child + 1 < heap.length &&\r\n                heap[child + 1]!.filed < heap[child]!.filed\r\n            )\r\n                child++;\r\n            if (heap[child]!.filed >= last!.filed) break;\r\n            heap[i] = heap[child]!;\r\n            i = child;\r\n        }\r\n        heap[i] = last!;\r\n        return top;\r\n    }\r\n\r\n    /** Returns the first stored value. */\r\n    public first(): V | undefined {\r\n        for (const value of this.values()) return value;\r\n        return undefined;\r\n    }\r\n    /** Returns the first stored key. */\r\n    public firstKey(): K | undefined {\r\n        for (const key of this.keys()) return key;\r\n        return undefined;\r\n    }\r\n    /** Returns the last stored value. */\r\n    public last(): V | undefined {\r\n        let value: V | undefined;\r\n        for (const item of this.values()) value = item;\r\n        return value;\r\n    }\r\n    /** Returns the last stored key. */\r\n    public lastKey(): K | undefined {\r\n        let key: K | undefined;\r\n        for (const item of this.keys()) key = item;\r\n        return key;\r\n    }\r\n    /** Finds the first value matching a predicate. */\r\n    public find(\r\n        predicate: (value: V, key: K, collection: this) => boolean,\r\n    ): V | undefined {\r\n        for (const [key, value] of this) {\r\n            if (predicate(value, key, this)) return value;\r\n        }\r\n        return undefined;\r\n    }\r\n    /** Finds the last value (in insertion order) matching a predicate. */\r\n    public findLast(\r\n        predicate: (value: V, key: K, collection: this) => boolean,\r\n    ): V | undefined {\r\n        const entries = [...this];\r\n        for (let i = entries.length - 1; i >= 0; i--) {\r\n            const [key, value] = entries[i]!;\r\n            if (predicate(value, key, this)) return value;\r\n        }\r\n        return undefined;\r\n    }\r\n    /** Finds the key of the last entry (in insertion order) matching a predicate. */\r\n    public findLastKey(\r\n        predicate: (value: V, key: K, collection: this) => boolean,\r\n    ): K | undefined {\r\n        const entries = [...this];\r\n        for (let i = entries.length - 1; i >= 0; i--) {\r\n            const [key, value] = entries[i]!;\r\n            if (predicate(value, key, this)) return key;\r\n        }\r\n        return undefined;\r\n    }\r\n    /** Returns all values matching a predicate. */\r\n    public filter(\r\n        predicate: (value: V, key: K, collection: this) => boolean,\r\n    ): this {\r\n        const result = this.#derived();\r\n        for (const [key, value] of this) {\r\n            if (predicate(value, key, this)) result.set(key, value);\r\n        }\r\n        return result;\r\n    }\r\n    /** Transforms every stored value into an array. */\r\n    public map<T>(transform: (value: V, key: K, collection: this) => T): T[] {\r\n        const result: T[] = [];\r\n        for (const [key, value] of this) {\r\n            result.push(transform(value, key, this));\r\n        }\r\n        return result;\r\n    }\r\n    /** Returns whether at least one stored value satisfies a predicate. */\r\n    public some(\r\n        predicate: (value: V, key: K, collection: this) => boolean,\r\n    ): boolean {\r\n        for (const [key, value] of this) {\r\n            if (predicate(value, key, this)) return true;\r\n        }\r\n        return false;\r\n    }\r\n    /** Returns whether every stored value satisfies a predicate. */\r\n    public every(\r\n        predicate: (value: V, key: K, collection: this) => boolean,\r\n    ): boolean {\r\n        for (const [key, value] of this) {\r\n            if (!predicate(value, key, this)) return false;\r\n        }\r\n        return true;\r\n    }\r\n    /** Runs a callback for each stored value. */\r\n    public each(\r\n        callback: (value: V, key: K, collection: this) => unknown,\r\n    ): this {\r\n        for (const [key, value] of this) {\r\n            callback(value, key, this);\r\n        }\r\n        return this;\r\n    }\r\n    /** Returns an array containing all stored values. */\r\n    public array(): V[] {\r\n        return [...this.values()];\r\n    }\r\n    /** Returns an array containing all stored keys. */\r\n    public keyArray(): K[] {\r\n        return [...this.keys()];\r\n    }\r\n    /** Returns a plain array of entries. */\r\n    public entriesArray(): [K, V][] {\r\n        return [...this.entries()];\r\n    }\r\n    /** Returns a new collection with the same entries. */\r\n    public clone(): this {\r\n        const copy = this.#derived();\r\n        for (const [key, value] of this) copy.set(key, value);\r\n        return copy;\r\n    }\r\n    /** Returns whether all supplied keys are present. */\r\n    public hasAll(...keys: K[]): boolean {\r\n        for (let i = 0; i < keys.length; i++) {\r\n            if (!this.has(keys[i]!)) return false;\r\n        }\r\n        return true;\r\n    }\r\n    /** Returns whether at least one supplied key is present. */\r\n    public hasAny(...keys: K[]): boolean {\r\n        for (let i = 0; i < keys.length; i++) {\r\n            if (this.has(keys[i]!)) return true;\r\n        }\r\n        return false;\r\n    }\r\n    /** Returns the first key whose value matches a predicate. */\r\n    public findKey(\r\n        predicate: (value: V, key: K, collection: this) => boolean,\r\n    ): K | undefined {\r\n        for (const [key, value] of this) {\r\n            if (predicate(value, key, this)) return key;\r\n        }\r\n        return undefined;\r\n    }\r\n    /** Returns whether a predicate matches at least one entry. */\r\n    public someEntry(\r\n        predicate: (value: V, key: K, collection: this) => boolean,\r\n    ): boolean {\r\n        return this.some(predicate);\r\n    }\r\n    /** Removes every entry matching a predicate and returns the number removed. */\r\n    public sweep(\r\n        predicate: (value: V, key: K, collection: this) => boolean,\r\n    ): number {\r\n        let removed = 0;\r\n        for (const [key, value] of this) {\r\n            if (predicate(value, key, this) && this.delete(key)) removed++;\r\n        }\r\n        return removed;\r\n    }\r\n    /** Returns the collection's first matching entry as a tuple. */\r\n    public firstEntry(): [K, V] | undefined {\r\n        for (const [key, value] of this) return [key, value];\r\n        return undefined;\r\n    }\r\n    /** Returns the collection's last matching entry as a tuple. */\r\n    public lastEntry(): [K, V] | undefined {\r\n        let entry: [K, V] | undefined;\r\n        for (const item of this) entry = [item[0], item[1]];\r\n        return entry;\r\n    }\r\n    /** Returns a new Collection containing elements from both collections. */\r\n    public union(other: ReadonlyCollection<K, V>): this {\r\n        const result = this.clone();\r\n        for (const [key, value] of other) result.set(key, value);\r\n        return result;\r\n    }\r\n    /** Returns a new Collection containing only elements present in both collections. */\r\n    public intersection(other: ReadonlyCollection<K, V>): this {\r\n        const result = this.#derived();\r\n        for (const [key, value] of this) {\r\n            if (other.has(key)) result.set(key, value);\r\n        }\r\n        return result;\r\n    }\r\n    /** Returns a new Collection containing elements present in this collection but not the other. */\r\n    public difference(other: ReadonlyCollection<K, V>): this {\r\n        const result = this.#derived();\r\n        for (const [key, value] of this) {\r\n            if (!other.has(key)) result.set(key, value);\r\n        }\r\n        return result;\r\n    }\r\n    /** Splits the collection into two collections based on a predicate.\r\n     * @returns `[passing, failing]` — entries satisfying the predicate, then those that don't.\r\n     */\r\n    public partition(\r\n        predicate: (value: V, key: K, collection: this) => boolean,\r\n    ): [this, this] {\r\n        const pass = this.#derived();\r\n        const fail = this.#derived();\r\n        for (const [key, value] of this) {\r\n            if (predicate(value, key, this)) pass.set(key, value);\r\n            else fail.set(key, value);\r\n        }\r\n        return [pass, fail];\r\n    }\r\n    /** Returns the entries of both collections that are in only one of them. */\r\n    public symmetricDifference(other: ReadonlyCollection<K, V>): this {\r\n        const result = this.#derived();\r\n        for (const [key, value] of this)\r\n            if (!other.has(key)) result.set(key, value);\r\n        for (const [key, value] of other)\r\n            if (!this.has(key)) result.set(key, value);\r\n        return result;\r\n    }\r\n    /** Returns a new Collection with this one's entries followed by each of `collections`'; a later collection wins a shared key. */\r\n    public concat(...collections: ReadonlyCollection<K, V>[]): this {\r\n        const result = this.clone();\r\n        for (const collection of collections)\r\n            for (const [key, value] of collection) result.set(key, value);\r\n        return result;\r\n    }\r\n    /**\r\n     * Combines this collection with `other`, deciding per key what to keep.\r\n     * @param whenInSelf Called for a key only in this collection.\r\n     * @param whenInOther Called for a key only in `other`.\r\n     * @param whenInBoth Called for a key in both.\r\n     * @returns A new collection of the entries the callbacks kept, in this collection's order, then `other`'s new keys.\r\n     */\r\n    public merge<T, R>(\r\n        other: ReadonlyCollection<K, T>,\r\n        whenInSelf: (value: V, key: K) => Keep<R>,\r\n        whenInOther: (valueOther: T, key: K) => Keep<R>,\r\n        whenInBoth: (value: V, valueOther: T, key: K) => Keep<R>,\r\n    ): Collection<K, R> {\r\n        const result = this.#derived() as unknown as Collection<K, R>;\r\n        const decide = (key: K, kept: Keep<R>): void => {\r\n            if (kept.keep) result.set(key, kept.value);\r\n        };\r\n        for (const [key, value] of this) {\r\n            decide(\r\n                key,\r\n                other.has(key)\r\n                    ? whenInBoth(value, peekOf(other, key) as T, key)\r\n                    : whenInSelf(value, key),\r\n            );\r\n        }\r\n        for (const [key, value] of other)\r\n            if (!this.has(key)) decide(key, whenInOther(value, key));\r\n        return result;\r\n    }\r\n    /** Returns whether `other` holds the same keys with `===` equal values. Neither side's TTL or recency is touched. */\r\n    public equals(other: ReadonlyCollection<K, V> | null | undefined): boolean {\r\n        if (!other) return false;\r\n        if (other === (this as unknown)) return true;\r\n        if (this.size !== other.size) return false;\r\n        for (const [key, value] of this) {\r\n            if (!other.has(key)) return false;\r\n            if (value !== peekOf(other, key)) return false;\r\n        }\r\n        return true;\r\n    }\r\n    /** Returns a new collection with the same keys and each value passed through `transform`. */\r\n    public mapValues<T>(\r\n        transform: (value: V, key: K, collection: this) => T,\r\n    ): Collection<K, T> {\r\n        const result = this.#derived() as unknown as Collection<K, T>;\r\n        for (const [key, value] of this)\r\n            result.set(key, transform(value, key, this));\r\n        return result;\r\n    }\r\n    /** Returns a new collection with the entries in reverse order. */\r\n    public toReversed(): this {\r\n        const result = this.#derived();\r\n        const entries = [...this];\r\n        for (let i = entries.length - 1; i >= 0; i--)\r\n            result.set(entries[i]![0], entries[i]![1]);\r\n        return result;\r\n    }\r\n    /** Same as {@link sorted}, under the name the standard `Array` uses. */\r\n    public toSorted(\r\n        comparator?: (a: V, b: V, aKey: K, bKey: K) => number,\r\n    ): this {\r\n        return this.sorted(comparator);\r\n    }\r\n    /**\r\n     * Groups `items` by the key `keySelector` returns for each.\r\n     * @param keySelector Called with each item and its index.\r\n     * @returns A new collection from each key to its items, in input order.\r\n     */\r\n    public static override groupBy<K, V>(\r\n        items: Iterable<V>,\r\n        keySelector: (item: V, index: number) => K,\r\n    ): Collection<K, V[]> {\r\n        const groups = new Collection<K, V[]>();\r\n        let index = 0;\r\n        for (const item of items)\r\n            groups.ensure(keySelector(item, index++), () => []).push(item);\r\n        return groups;\r\n    }\r\n    /**\r\n     * Builds a collection from `entries`, merging values that share a key.\r\n     * @param combine Called with the value stored so far, the new one and the key; its result is stored.\r\n     */\r\n    public static combineEntries<K, V>(\r\n        entries: Iterable<readonly [K, V]>,\r\n        combine: (firstValue: V, secondValue: V, key: K) => V,\r\n    ): Collection<K, V> {\r\n        const result = new Collection<K, V>();\r\n        for (const [key, value] of entries)\r\n            result.set(\r\n                key,\r\n                result.has(key) ? combine(result.get(key)!, value, key) : value,\r\n            );\r\n        return result;\r\n    }\r\n    /** Calls `fn` with this collection and returns the collection unchanged.\r\n     * Useful for inserting debug side-effects in a chain without breaking the flow.\r\n     */\r\n    public tap(fn: (collection: this) => unknown): this {\r\n        fn(this);\r\n        return this;\r\n    }\r\n    /** Maps every entry to an array of items and flattens the results. */\r\n    public flatMap<T>(\r\n        transform: (value: V, key: K, collection: this) => T[],\r\n    ): T[] {\r\n        const result: T[] = [];\r\n        for (const [key, value] of this) {\r\n            for (const item of transform(value, key, this)) result.push(item);\r\n        }\r\n        return result;\r\n    }\r\n    /** Reduces the collection to a single value. */\r\n    public reduce<T>(\r\n        fn: (accumulator: T, value: V, key: K, collection: this) => T,\r\n        initialValue: T,\r\n    ): T {\r\n        let acc = initialValue;\r\n        for (const [key, value] of this) acc = fn(acc, value, key, this);\r\n        return acc;\r\n    }\r\n    /** Like {@link reduce}, but from the last entry to the first. */\r\n    public reduceRight<T>(\r\n        fn: (accumulator: T, value: V, key: K, collection: this) => T,\r\n        initialValue: T,\r\n    ): T {\r\n        const entries = [...this];\r\n        let acc = initialValue;\r\n        for (let i = entries.length - 1; i >= 0; i--)\r\n            acc = fn(acc, entries[i]![1], entries[i]![0], this);\r\n        return acc;\r\n    }\r\n    /** Returns a new Collection with entries sorted by comparator (non-mutating).\r\n     * Defaults to insertion order if no comparator is provided.\r\n     */\r\n    public sorted(comparator?: (a: V, b: V, aKey: K, bKey: K) => number): this {\r\n        // Decorate with the original insertion index and use it as a tiebreaker so\r\n        // equal elements keep their insertion order (a stable sort independent of\r\n        // the engine's Array.prototype.sort stability guarantees).\r\n        const decorated = [...this.entries()].map((entry, index) => ({\r\n            entry,\r\n            index,\r\n        }));\r\n        if (comparator)\r\n            decorated.sort((x, y) => {\r\n                const comparison = comparator(\r\n                    x.entry[1],\r\n                    y.entry[1],\r\n                    x.entry[0],\r\n                    y.entry[0],\r\n                );\r\n                return comparison !== 0 ? comparison : x.index - y.index;\r\n            });\r\n        const result = this.#derived();\r\n        for (const { entry } of decorated) result.set(entry[0], entry[1]);\r\n        return result;\r\n    }\r\n    /**\r\n     * Returns a random value, or `undefined` if empty. With `amount`, returns\r\n     * that many different values (all of them, shuffled, when `amount` is at\r\n     * least the size).\r\n     * Uses `Math.random()` (fast, non-cryptographic): do not use it for\r\n     * security-sensitive selection such as tokens or secrets.\r\n     * @param amount How many values to pick.\r\n     * @throws {RangeError} If `amount` is not a non-negative integer.\r\n     */\r\n    public random(): V | undefined;\r\n    public random(amount: number): V[];\r\n    public random(amount?: number): V | V[] | undefined {\r\n        if (amount !== undefined) return sample([...this.values()], amount);\r\n        const size = this.size;\r\n        if (size === 0) return undefined;\r\n        let index = Math.floor(Math.random() * size);\r\n        for (const value of this.values()) if (index-- === 0) return value;\r\n        return undefined;\r\n    }\r\n    /**\r\n     * Returns a random key, or `undefined` if empty. With `amount`, returns\r\n     * that many different keys. Same randomness and errors as {@link random}.\r\n     * @param amount How many keys to pick.\r\n     */\r\n    public randomKey(): K | undefined;\r\n    public randomKey(amount: number): K[];\r\n    public randomKey(amount?: number): K | K[] | undefined {\r\n        if (amount !== undefined) return sample([...this.keys()], amount);\r\n        const size = this.size;\r\n        if (size === 0) return undefined;\r\n        let index = Math.floor(Math.random() * size);\r\n        for (const key of this.keys()) if (index-- === 0) return key;\r\n        return undefined;\r\n    }\r\n    /** Returns the value at a given insertion-order index (supports negative indices). */\r\n    public at(index: number): V | undefined {\r\n        const arr = [...this.values()];\r\n        const i = index < 0 ? arr.length + index : index;\r\n        return arr[i];\r\n    }\r\n    /** Returns the key at a given insertion-order index (supports negative indices). */\r\n    public keyAt(index: number): K | undefined {\r\n        const arr = [...this.keys()];\r\n        const i = index < 0 ? arr.length + index : index;\r\n        return arr[i];\r\n    }\r\n    /** Serializes the collection to a plain `[key, value]` array. */\r\n    public toJSON(): [K, V][] {\r\n        return [...this.entries()];\r\n    }\r\n}\r\n\r\nexport { Cache } from \"./cache.js\";\r\nexport type { CacheOptions } from \"./cache.js\";\r\n"
   ],
-  "mappings": "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",
-  "debugId": "4109A00736CB03B064756E2164756E21",
+  "mappings": "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",
+  "debugId": "72EF4AA34379CD3464756E2164756E21",
   "names": []
 }

package/dist/core/index.d.ts

@@ -20,6 +20,8 @@ declare class EventEmitter<Events extends {
     [K in keyof Events]: unknown[];
 }> {
     #private;
+    /** Removes secrets from text this emitter prints; the client removes its token. */
+    protected readonly redactSecrets: (text: string) => string;
     on<K extends keyof Events>(event: K, listener: Listener<Events[K]>): this;
     once<K extends keyof Events>(event: K, listener: Listener<Events[K]>): this;
     off<K extends keyof Events>(event: K, listener: Listener<Events[K]>): this;
@@ -52,6 +54,8 @@ export declare class Client extends EventEmitter<ClientEvents> implements Intera
      * The bot token this client is authenticated with, or `null` once the
      * client has been destroyed. Mirrors `Client#token` in Discord.js.
      */
+    /** Replaces the bot token in text Lunibee prints (listener warnings). */
+    protected readonly redactSecrets: (text: string) => string;
     get token(): string | null;
     get uptime(): number | null;
     get ping(): number;
@@ -82,6 +86,10 @@ export declare class Client extends EventEmitter<ClientEvents> implements Intera
     permissionsFor(memberId: string, guildOrChannelId: string): PermissionSet | null;
     /** Fetches Discord's default soundboard sounds. */
     fetchDefaultSoundboardSounds(): Promise<APISoundboardSound[]>;
+    /**
+     * Connects to the Gateway. Resolves with the token used, like discord.js;
+     * do not log the return value.
+     */
     login(token?: string): Promise<string>;
     /**
      * Destroys the client, permanently closing the Gateway connection.