@seedcord/core 0.11.0 → 0.12.0-next.2

package/dist/index.mjs

@@ -1,13 +1,13 @@
-import { $ as RegisterInteractionMiddleware, A as rollbackCommits, B as NotInGuild, D as pickNotice, E as presentNames, F as MissingPermissions, G as serializeReply, H as OnCooldown, Ht as Notice, J as publishResponse, K as translateSerializationError, L as NeedsAny, Lt as NoticeCard, P as HasDangerousPermissions, Q as sendTarget, R as NotAllowed, Rt as BuilderComponent, S as RequireRole, T as missingNames, U as defineEffectGate, V as NotOwner, W as defineGate, X as AckTrace, Z as checkAckLegality, _ as pageCursor, b as RequireBotPermissions, bt as Commands, ct as RegisterCommand, d as WebhookLog, f as Subscriber, g as PAGE_MAX, it as storeInteractionRoute, j as runCheck, k as markCommits, l as WebhookUrl, pt as InteractionKind, q as attemptWrite, rt as storeComponentRoute, t as Bus, tt as contextMenuRouteOf, u as Subscribe, v as ResolvedEmoji, w as hasAll, x as RequirePermissions, xt as ContextMenus, y as Silence, z as NotInDm, zt as RowComponent } from "./subscribers-Ce3SWy23.mjs";
-import { n as StartupPhase, t as ShutdownPhase } from "./phases-BauKJOTT.mjs";
+import { D as InteractionKind, N as BuilderComponent, P as RowComponent, b as StartupPhase, d as WebhookLog, f as Subscriber, l as WebhookUrl, t as Bus, u as Subscribe, v as MemoryDriver, y as ShutdownPhase } from "./Bus-VJw-QpoY.mjs";
+import { A as RegisterInteractionMiddleware, B as RegisterCommand, C as attemptWrite, D as AckTrace, F as storeComponentRoute, H as Commands, I as storeInteractionRoute, M as contextMenuRouteOf, O as checkAckLegality, S as translateSerializationError, U as ContextMenus, _ as NotInGuild, at as Notice, b as PermissionsUnresolved, c as runCheck, d as HasPresentPermissions, f as MissingPermissions, g as NotInDm, h as NotAllowed, i as Silence, k as sendTarget, m as NeedsAny, n as pageCursor, o as markCommits, ot as NoticeCard, p as MissingRole, r as ResolvedEmoji, s as rollbackCommits, t as PAGE_MAX, u as Fault, v as NotOwner, w as publishResponse, x as serializeReply, y as OnCooldown } from "./subscribers-CGuVjbrg.mjs";
 import "reflect-metadata";
 import { CustomId, decodeFor, prefixOf, setCustomIdErrors, setCustomIdErrors as setCustomIdErrors$1 } from "@seedcord/custom-id";
 import { ActionRowBuilder, ButtonBuilder, TextDisplayBuilder } from "@discordjs/builders";
-import { ApplicationCommandType, ButtonStyle } from "discord-api-types/v10";
+import { ApplicationCommandType, ButtonStyle, PermissionFlagsBits } from "discord-api-types/v10";
 import { SeedcordErrorCode } from "@seedcord/errors";
 import { SeedcordError, SeedcordRangeError, SeedcordTypeError } from "@seedcord/errors/internal";
 import { Logger } from "@seedcord/logger";
-import { parseDuration } from "@seedcord/utils";
+import { parseDuration, prettify } from "@seedcord/utils";
 
 //#region src/customId/Errors.ts
 /**
@@ -47,8 +47,8 @@ setCustomIdErrors$1({
 /**
 * Routes one or more slash commands to a `SlashHandler`.
 *
-* Pass the same route string(s) as the handler's generic. A single command reads `this.options`, several
-* commands branch with `this.match`. The decorator routes and the generic must match exactly. Listing
+* Pass the same route string(s) as the handler's generic. On a handler for one command, read
+* `this.options`. On a handler for several, branch with `this.match`. The decorator routes and the generic must match exactly. Listing
 * fewer or more than the handler declares is a compile error. Subcommands use a slash path.
 *
 * @param routes - The route string(s) this handler serves, e.g. `'ban'`, `'ban', 'kick'`, or `'demo/setup'`.
@@ -72,7 +72,7 @@ function SlashRoute(...routes) {
 * Routes one or more commands' autocomplete to an `AutocompleteHandler`.
 *
 * Pass the same command route string(s) as the handler's generic. One command branches with `this.match`
-* over its autocompletable fields, several commands share one handler whose arms span every command's
+* over its autocompletable fields, several commands share one handler whose cases span every command's
 * fields. Listing fewer or more commands than the handler declares is a compile error, since the
 * decorator routes and the generic must match exactly.
 *
@@ -174,7 +174,7 @@ function ModalRoute(...defs) {
 * Routes string select menu interactions to a `StringMenuHandler`.
 *
 * Pass the {@link CustomId} definition(s) this handler decodes and list the same ones in the handler's
-* generic. The handler reads the chosen option values from `this.values`.
+* generic. Read the chosen option values from `this.values`.
 *
 * @param defs - The customId definition(s) this handler decodes, one per route.
 * @decorator
@@ -289,38 +289,6 @@ function MentionableMenuRoute(...defs) {
 	};
 }
 
-//#endregion
-//#region src/dispatch/DispatchContext.ts
-/**
-* A typed bag allocated once per interaction dispatch and handed to the handler. The middleware and i18n
-* work reads and writes it through {@link DispatchState}. Today the bag is empty, so it only carries the
-* dispatched `routeId`.
-*/
-var DispatchContext = class {
-	routeId;
-	state = Object.create(null);
-	id = crypto.randomUUID();
-	constructor(routeId) {
-		this.routeId = routeId;
-	}
-	set(key, value) {
-		this.state[key] = value;
-	}
-	get(key) {
-		return this.state[key];
-	}
-	/**
-	* Read a key that must be present, with `undefined` stripped from the result.
-	*
-	* @throws A **SeedcordError** when nothing set the key on this dispatch.
-	*/
-	require(key) {
-		const value = this.state[key];
-		if (value === void 0) throw new SeedcordError(SeedcordErrorCode.DispatchStateMissing, [String(key)]);
-		return value;
-	}
-};
-
 //#endregion
 //#region src/handlers/BaseHandler.ts
 /**
@@ -336,11 +304,14 @@ var BaseHandler = class {
 	logger;
 	/** The bag for this dispatch. Each interaction gets its own. Every handler for one event shares a single bag. */
 	dispatch;
+	/** The route that started this dispatch. Each handler base narrows it to its own routes. */
+	route;
 	constructor(event, core, dispatch, channel) {
 		this.core = core;
 		this.event = event;
 		this.logger = new Logger(this.constructor.name, { channel });
 		this.dispatch = dispatch;
+		this.route = dispatch.route;
 	}
 };
 
@@ -348,7 +319,7 @@ var BaseHandler = class {
 //#region src/handlers/RepliableHandler.ts
 /**
 * Shared base the repliable handlers on both transports extend. Defines the reply members over one sender.
-* A handler builds its own through `buildSender`. A middleware takes the handler's.
+* The dispatch run builds that sender and passes it to the handler and each middleware.
 *
 * @typeParam Event - The repliable interaction type this handler processes
 * @typeParam TCore - The transport's Core
@@ -359,11 +330,9 @@ var BaseHandler = class {
 var RepliableHandler = class extends BaseHandler {
 	/** The reply surface for this interaction. Pass the handler to reply from outside its class. */
 	sender;
-	routeId;
 	constructor(event, core, dispatch, sender) {
 		super(event, core, dispatch, "interactions");
-		this.routeId = dispatch.routeId;
-		this.sender = sender ?? this.buildSender(event, core, dispatch);
+		this.sender = sender;
 	}
 	/** Send the initial response, exactly once. */
 	reply(response, opts) {
@@ -559,44 +528,88 @@ var BaseReplySender = class {
 };
 
 //#endregion
-//#region src/stops/Fault.ts
+//#region src/gates/Gate.ts
 /**
-* A generic fault you throw after catching an error you do not have a specific message for.
+* Builds a {@link Gate} from a check. The check refuses by throwing a Notice or a Silence and passes
+* by returning. The required context is inferred from `ctx`, so annotate it as narrowly as the fields
+* the check reads. No annotation defaults to {@link GateContextBase}, an agnostic gate that fits every
+* handler.
 *
-* The user sees a fixed generic reply with the tracking uuid, never the cause. `report` defaults to
-* `true`, so the framework logs it and publishes it to the `handledException` bus. Pass `report: false`
-* to show the generic reply without the bus publish. The original error is stored as the standard
-* `cause`, so the real stack reaches the webhook. When the user should see a real message for a fault,
-* subclass {@link Notice} and write your own `render` instead.
+* @typeParam Name - The gate's name, captured as a literal for mismatch errors.
+* @typeParam Ctx - The context the check reads, inferred from the `ctx` annotation.
 *
-* The framework also renders this for an unhandled throw, where it points the user at
-* `ctx.developerUsername`.
+* @param name - The gate's name, used in mismatch errors.
+* @param fn - The check, which refuses by throwing a Notice or a Silence and passes by returning.
+*
+* @see {@link defineEffectGate}
+* @see the `@Gated` decorator from your transport package
 *
 * @example
 * ```ts
-* import { Fault } from '@seedcord/gateway';
+* // a gate factory that takes its own option and closes over it
+* function MinRoles(min: number): Gate<GateContextBase, 'MinRoles'> {
+*     return defineGate('MinRoles', (ctx) => {
+*         if (ctx.memberRoleIds.length < min) throw new NotEnoughRoles(min);
+*     });
+* }
+* ```
 *
-* try {
-*     await db.write(record);
-* } catch (cause) {
-*     // user sees the generic reply with the uuid, and the real error rides along as cause for the webhook
-*     throw new Fault({ cause });
+* @example
+* ```ts
+* // agnostic gate (no ctx annotation): fits any handler
+* const Owner = defineGate('owner', (ctx) => {
+*     if (!ctx.userId) throw new NotOwner();
+* });
+* ```
+*/
+function defineGate(name, fn) {
+	return {
+		name,
+		check: async (ctx) => fn(ctx)
+	};
+}
+/**
+* Builds an {@link EffectGate} from a `check` and a `commit`. `check` peeks and refuses by throwing, and
+* `commit` applies the side effect, running only once the whole gate set passes so a later refusal never
+* commits. In an `or`, seedcord rolls back the commit a refusing gate queued. This is how {@link Cooldown} peeks
+* in `check` and charges the slot in `commit`.
+*
+* @typeParam Name - The gate's literal name, used to name a mismatch error.
+* @typeParam Ctx - The context both `check` and `commit` read, inferred from the `ctx` annotation.
+*
+* @param name - The gate's name, used in mismatch errors.
+* @param check - Peeks and refuses by throwing, without applying the side effect.
+* @param commit - Applies the side effect, running only after the whole gate set passes.
 *
-*     // pass report: false to show the same reply without publishing to the handledException bus
-*     // throw new Fault({ cause, report: false });
+* @see {@link defineGate}
+* @see the `@Gated` decorator from your transport package
+* @see {@link Cooldown}
+*
+* @example
+* ```ts
+* // an effect-gate factory that takes its own limit and closes over it
+* function UsesPerDay(max: number): EffectGate<GateContextBase, 'UsesPerDay'> {
+*     return defineEffectGate(
+*         'UsesPerDay',
+*         (ctx) => {
+*             // peek and refuse by throwing. do not mutate yet
+*             if (usedToday(ctx.userId) >= max) throw new OutOfUsesNotice(max);
+*         },
+*         (ctx) => {
+*             // runs only after the whole gate set passes
+*             recordUse(ctx.userId);
+*         }
+*     );
 * }
 * ```
 */
-var Fault = class extends Notice {
-	constructor(options) {
-		super("A fault occurred", options?.cause === void 0 ? void 0 : { cause: options.cause });
-		this.report = options?.report ?? true;
-	}
-	render(ctx) {
-		const contact = ctx.developerUsername ?? "the developer";
-		return { components: [new NoticeCard(`Something went wrong. Please reach out to ${contact} with a way to reproduce the error and the following:\n### UUID: \`${ctx.uuid}\``, "Error").component] };
-	}
-};
+function defineEffectGate(name, check, commit) {
+	return {
+		name,
+		check: async (ctx) => check(ctx),
+		commit: async (ctx) => commit(ctx)
+	};
+}
 
 //#endregion
 //#region src/gates/combinators.ts
@@ -645,9 +658,9 @@ function or(...args) {
 /**
 * Passes only for a user id listed in `config.ownerIds`, else refuses.
 *
-* Agnostic, so it attaches to interaction and event handlers alike. With no `ownerIds` configured it refuses every caller. Pass {@link GateNoticeOptions} to reword or replace the refusal.
+* Agnostic, so it attaches to interaction and event handlers alike. With no `ownerIds` configured it refuses every caller. Pass a Notice class as `notice` to replace the refusal.
 *
-* @param options - Reword the default refusal with `message`, or replace it with `notice`.
+* @param options - Replace the refusal with a Notice class as `notice`.
 *
 * @see the `@Gated` decorator from your transport package
 *
@@ -664,15 +677,15 @@ function or(...args) {
 *
 * @example
 * ```ts
-* // reword the refusal, keeping the embed styling
-* OwnerOnly({ message: 'Owners only.' });
+* // OwnersOnly is your own Notice class
+* OwnerOnly({ notice: OwnersOnly });
 * ```
 */
 function OwnerOnly(options) {
 	return defineGate("OwnerOnly", (ctx) => {
 		const owners = ctx.core.config.ownerIds ?? [];
 		if (ctx.userId !== null && owners.includes(ctx.userId)) return;
-		throw pickNotice(options, (message) => new NotOwner(message));
+		throw new ((options?.notice) ?? NotOwner)();
 	});
 }
 /**
@@ -680,7 +693,7 @@ function OwnerOnly(options) {
 *
 * Agnostic. Attaches to any handler kind. Often paired with `RequirePermissions` in an {@link and}.
 *
-* @param options - Reword the default refusal with `message`, or replace it with `notice`.
+* @param options - Replace the refusal with a Notice class as `notice`.
 *
 * @see the `@Gated` decorator from your transport package
 *
@@ -700,7 +713,7 @@ function OwnerOnly(options) {
 function GuildOnly(options) {
 	return defineGate("GuildOnly", (ctx) => {
 		if (ctx.guildId) return;
-		throw pickNotice(options, (message) => new NotInGuild(message));
+		throw new ((options?.notice) ?? NotInGuild)();
 	});
 }
 /**
@@ -708,7 +721,7 @@ function GuildOnly(options) {
 *
 * Agnostic, fitting any handler kind. The inverse of {@link GuildOnly}, so combining the two in an {@link and} can never pass.
 *
-* @param options - Reword the default refusal with `message`, or replace it with `notice`.
+* @param options - Replace the refusal with a Notice class as `notice`.
 *
 * @see the `@Gated` decorator from your transport package
 *
@@ -726,7 +739,7 @@ function GuildOnly(options) {
 function DmOnly(options) {
 	return defineGate("DmOnly", (ctx) => {
 		if (!ctx.guildId) return;
-		throw pickNotice(options, (message) => new NotInDm(message));
+		throw new ((options?.notice) ?? NotInDm)();
 	});
 }
 
@@ -744,10 +757,10 @@ function scopeValue(ctx, per) {
 * so a later refusal never burns the cooldown.
 * That split also means two requests racing the same key can both pass before either charges the slot.
 * The key combines the handler's route with the window settings, keeping two different handlers on separate
-* windows. Reword the refusal with {@link CooldownOptions.message} or replace it with {@link CooldownOptions.notice}.
+* windows. Replace the refusal with {@link CooldownOptions.notice}.
 *
 * @param duration - A number is seconds, and a string is a duration like `30m` or `24h`.
-* @param options - Sets the scope with `per`, the uses per window with `limit`, and the refusal text with `message` or `notice`.
+* @param options - Sets the scope with `per`, the uses per window with `limit`, and the refusal with `notice`.
 * @throws A **SeedcordTypeError** when `duration` is a string that doesn't parse.
 * @throws A **SeedcordRangeError** when `duration` is zero or negative.
 *
@@ -799,22 +812,46 @@ function Cooldown(duration, options) {
 		limit: options.limit
 	};
 	const anonId = anonSeq++;
-	const keyOf = (ctx) => `cooldown:${ctx.declaredRoute ?? `anon${anonId}`}:${per}:w${windowMs}:l${options?.limit ?? 1}:${scopeValue(ctx, per)}`;
+	const keyOf = (ctx) => `cooldown:${ctx.dispatch.declaredRoute ?? `anon${anonId}`}:${per}:w${windowMs}:l${options?.limit ?? 1}:${scopeValue(ctx, per)}`;
 	return defineEffectGate("Cooldown", async (ctx) => {
 		const result = await ctx.core.rateLimiter.peek(keyOf(ctx), window);
 		if (!result.limited) return;
-		if (options?.notice) throw options.notice(result.resetAt);
-		throw new OnCooldown(result.resetAt, options?.message?.(result.resetAt));
+		throw new ((options?.notice) ?? OnCooldown)(result.resetAt);
 	}, async (ctx) => {
 		await ctx.core.rateLimiter.charge(keyOf(ctx), window);
 	});
 }
 
+//#endregion
+//#region src/permissions/bits.ts
+const PermissionNames = new Map(Object.entries(PermissionFlagsBits).map(([key, bit]) => [bit, prettify(key)]));
+const ADMINISTRATOR = PermissionFlagsBits.Administrator;
+function nameOf(bit) {
+	return PermissionNames.get(bit) ?? String(bit);
+}
+function holds(held, bit) {
+	return (held & ADMINISTRATOR) === ADMINISTRATOR || (held & bit) === bit;
+}
+function namesWhere(held, scope, isHeld) {
+	return scope.reduce((names, bit) => {
+		if (holds(held, bit) === isHeld) names.push(nameOf(bit));
+		return names;
+	}, []);
+}
+/** @internal */
+function missingNames(held, scope) {
+	return namesWhere(held, scope, false);
+}
+/** @internal */
+function presentNames(held, scope) {
+	return namesWhere(held, scope, true);
+}
+
 //#endregion
 //#region src/permissions/assert.ts
 /**
 * Refuses when the subject is missing a permission in `scope`, or with `inverse` when it holds one.
-* The Administrator bit passes any scope, and on the inverse arm it reports every bit in `scope`.
+* The Administrator bit passes any scope, and with `inverse` it reports every bit in `scope`.
 *
 * The caller computes `permissions`, gateway off a discord.js role, member, or channel, and HTTP off the
 * bitfield the interaction payload carries.
@@ -859,14 +896,12 @@ function Cooldown(duration, options) {
 * ```ts
 * import { Notice } from '@seedcord/core';
 *
-* // a replacement notice takes the same three arguments the default one does
 * class CannotBan extends Notice {
 *     public constructor(
-*         message: string | undefined,
-*         private readonly subject: string,
+*         private readonly subject: string | null,
 *         private readonly missing: readonly string[]
 *     ) {
-*         super(message ?? 'You cannot ban here.');
+*         super('You cannot ban here.');
 *     }
 *
 *     public render(): ReplyResponse {
@@ -878,19 +913,97 @@ function Cooldown(duration, options) {
 *     subject: `<@${member.id}>`,
 *     permissions: member.permissions.bitfield,
 *     scope: [PermissionFlagsBits.BanMembers],
-*     missingNotice: CannotBan
+*     notice: CannotBan
 * });
 * ```
 */
-function assertPermissions(check) {
-	const { subject, permissions, scope, inverse = false, missingNotice, dangerousNotice } = check;
-	if (inverse) {
-		const present = presentNames(permissions, scope);
-		if (present.length === 0) return;
-		throw new (dangerousNotice ?? HasDangerousPermissions)(void 0, subject, present);
-	}
-	if (hasAll(permissions, scope)) return;
-	throw new (missingNotice ?? MissingPermissions)(void 0, subject, missingNames(permissions, scope));
+function assertPermissions({ subject, permissions, scope, inverse = false, notice }) {
+	const [refused, Default] = inverse ? [presentNames(permissions, scope), HasPresentPermissions] : [missingNames(permissions, scope), MissingPermissions];
+	if (refused.length === 0) return;
+	throw new (notice ?? Default)(subject, refused);
+}
+
+//#endregion
+//#region src/gates/catalog/permissions.ts
+const BOT_SUBJECT = "The bot";
+function requireHeld({ guildId, subject, readOrThrow }, scope, options) {
+	if (!guildId) throw new ((options?.notInGuild) ?? NotInGuild)();
+	const permissions = readOrThrow(guildId);
+	assertPermissions({
+		subject,
+		permissions,
+		scope,
+		notice: options?.missing
+	});
+}
+function botMemberMissing(guildId) {
+	throw new SeedcordError(SeedcordErrorCode.CoreBotMemberMissing, [guildId]);
+}
+function RequirePermissions(scope, options) {
+	const resolved = (held) => {
+		if (held === null) throw new ((options?.unresolved) ?? PermissionsUnresolved)();
+		return held;
+	};
+	if (options?.in === "guild") return defineGate("RequirePermissions", (ctx) => {
+		const readOrThrow = () => resolved(ctx.memberGuildPermissions);
+		requireHeld({
+			guildId: ctx.guildId,
+			subject: null,
+			readOrThrow
+		}, scope, options);
+	});
+	return defineGate("RequirePermissions", (ctx) => {
+		const readOrThrow = () => resolved(ctx.memberPermissions);
+		requireHeld({
+			guildId: ctx.guildId,
+			subject: null,
+			readOrThrow
+		}, scope, options);
+	});
+}
+function RequireBotPermissions(scope, options) {
+	if (options?.in === "guild") return defineGate("RequireBotPermissions", (ctx) => {
+		const readOrThrow = (guildId) => ctx.appGuildPermissions ?? botMemberMissing(guildId);
+		requireHeld({
+			guildId: ctx.guildId,
+			subject: BOT_SUBJECT,
+			readOrThrow
+		}, scope, options);
+	});
+	return defineGate("RequireBotPermissions", (ctx) => {
+		requireHeld({
+			guildId: ctx.guildId,
+			subject: BOT_SUBJECT,
+			readOrThrow: () => ctx.appPermissions
+		}, scope, options);
+	});
+}
+/**
+* Requires the caller to hold `roleId`, read from the member's role ids. Refuses outside a guild first,
+* then when the role is missing. Roles are guild-global, so there is no scope dimension.
+*
+* @param roleId - The role snowflake the caller must hold.
+* @param options - Replace a refusal with a Notice class as `notInGuild` or `missingRole`.
+*
+* @see the `@Gated` decorator from your transport package
+*
+* @example
+* ```ts
+* \@Gated(RequireRole('123456789012345678'))
+* \@SlashRoute('vip')
+* class VipHandler extends SlashHandler<'vip'> {
+*     async execute() {
+*         // ...
+*     }
+* }
+* ```
+*/
+function RequireRole(roleId, options) {
+	return defineGate("RequireRole", (ctx) => {
+		if (!ctx.guildId) throw new ((options?.notInGuild) ?? NotInGuild)();
+		if (ctx.memberRoleIds.includes(roleId)) return;
+		throw new ((options?.missingRole) ?? MissingRole)(roleId);
+	});
 }
 
 //#endregion
@@ -1146,11 +1259,119 @@ var CursorSourceBase = class {
 	}
 };
 
+//#endregion
+//#region src/kv/KeyvDriver.ts
+/**
+* Wraps a Keyv instance for `config.kv`.
+*
+* @example
+* ```ts
+* new Seedcord({ ...config, kv: new KeyvDriver(new Keyv(new KeyvSqlite('sqlite://./kv.sqlite'))) });
+* ```
+*/
+var KeyvDriver = class {
+	keyv;
+	constructor(keyv) {
+		this.keyv = keyv;
+	}
+	async get(key) {
+		const value = await this.keyv.get(key);
+		return typeof value === "string" ? value : void 0;
+	}
+	async set(key, value, ttlMs) {
+		if (!await this.keyv.set(key, value, ttlMs)) throw new SeedcordError(SeedcordErrorCode.CoreKvDriverFailed, ["write", key]);
+	}
+	async delete(key) {
+		await this.keyv.delete(key);
+	}
+	/** @throws A **SeedcordError** when the Keyv store can't list its keys, like `@keyv/memcache`. */
+	async *entries(prefix) {
+		if (!this.#canListKeys()) throw new SeedcordError(SeedcordErrorCode.CoreKvKeysUnsupported);
+		for await (const [key, value] of this.keyv.iterator()) if (key.startsWith(prefix) && typeof value === "string") yield [key, value];
+	}
+	async [Symbol.asyncDispose]() {
+		await this.keyv.disconnect();
+	}
+	#canListKeys() {
+		const capabilities = this.keyv.store.capabilities;
+		return capabilities?.store === "mapLike" || capabilities?.methods.iterator.exists === true;
+	}
+};
+
+//#endregion
+//#region src/kv/UnstorageDriver.ts
+const MIN_TTL_SECONDS = 60;
+const MS_PER_SECOND = 1e3;
+function storageKey(key) {
+	return `_${encodeURIComponent(key).replaceAll(".", "%2E")}`;
+}
+function originalKey(stored) {
+	return decodeURIComponent(stored.slice(1));
+}
+function text(raw) {
+	if (raw === null) return void 0;
+	return typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+}
+/**
+* Wraps an unstorage `Storage` for `config.kv`.
+*
+* @example
+* ```ts
+* new Seedcord({ ...config, kv: new UnstorageDriver(createStorage({ driver: fsDriver({ base: './.kv' }) })) });
+* ```
+*/
+var UnstorageDriver = class {
+	storage;
+	constructor(storage) {
+		this.storage = storage;
+	}
+	async get(key) {
+		return text(await this.storage.getItemRaw(storageKey(key)));
+	}
+	async set(key, value, ttlMs) {
+		const ttl = ttlMs === void 0 ? {} : { ttl: Math.max(MIN_TTL_SECONDS, Math.ceil(ttlMs / MS_PER_SECOND)) };
+		await this.storage.setItemRaw(storageKey(key), value, ttl);
+	}
+	async delete(key) {
+		await this.storage.removeItem(storageKey(key));
+	}
+	async *entries(prefix) {
+		const storedPrefix = storageKey(prefix);
+		for (const key of await this.storage.getKeys()) {
+			if (!key.startsWith(storedPrefix)) continue;
+			const value = text(await this.storage.getItemRaw(key));
+			if (value !== void 0) yield [originalKey(key), value];
+		}
+	}
+	async [Symbol.asyncDispose]() {
+		await this.storage.dispose();
+	}
+};
+
+//#endregion
+//#region src/rateLimiter/buildKey.ts
+/**
+* Builds a rate-limit key from a prefix and scope parts, joined with `:`. A null or undefined part
+* becomes `'global'`. A key built from a DM's guild id reads `<prefix>:global` for every DM caller.
+*
+* @param prefix - The bucket family, e.g. `'cooldown'`.
+* @param parts - Scope values, e.g. a user or guild id.
+*
+* @example
+* ```ts
+* buildKey('report', interaction.guildId); // 'report:1234...' or 'report:global' in a DM
+* ```
+*/
+function buildKey(prefix, ...parts) {
+	if (parts.length === 0) return prefix;
+	return [prefix, ...parts.map((part) => part ?? "global")].join(":");
+}
+
 //#endregion
 //#region src/index.ts
 /** Package version */
-const version = "0.11.0";
+const version = "0.12.0-next.2";
 
 //#endregion
-export { ArraySourceBase, AutocompleteRoute, BaseHandler, BaseReplySender, BuilderComponent, Bus, ButtonRoute, ChannelMenuRoute, Commands, ContextMenus, Cooldown, CursorSourceBase, CustomId, DispatchContext, DmOnly, Fault, GuildOnly, InteractionKind, MentionableMenuRoute, MessageContextMenuRoute, ModalRoute, Notice, OwnerOnly, PaginatorBase, RegisterCommand, RegisterInteractionMiddleware, RepliableHandler, RequireBotPermissions, RequirePermissions, RequireRole, ResolvedEmoji, RoleMenuRoute, RowComponent, ShutdownPhase, Silence, SlashRoute, StartupPhase, StringMenuRoute, Subscribe, Subscriber, UserContextMenuRoute, UserMenuRoute, WebhookLog, WebhookUrl, and, assertPermissions, decodeFor, defineEffectGate, defineGate, mergeRoles, or, paginate, prefixOf, setCustomIdErrors, version };
+export { ArraySourceBase, AutocompleteRoute, BaseHandler, BaseReplySender, BuilderComponent, Bus, ButtonRoute, ChannelMenuRoute, Commands, ContextMenus, Cooldown, CursorSourceBase, CustomId, DmOnly, Fault, GuildOnly, InteractionKind, KeyvDriver, MemoryDriver, MentionableMenuRoute, MessageContextMenuRoute, ModalRoute, Notice, OwnerOnly, PaginatorBase, RegisterCommand, RegisterInteractionMiddleware, RepliableHandler, RequireBotPermissions, RequirePermissions, RequireRole, ResolvedEmoji, RoleMenuRoute, RowComponent, ShutdownPhase, Silence, SlashRoute, StartupPhase, StringMenuRoute, Subscribe, Subscriber, UnstorageDriver, UserContextMenuRoute, UserMenuRoute, WebhookLog, WebhookUrl, and, assertPermissions, buildKey, decodeFor, defineEffectGate, defineGate, mergeRoles, or, paginate, prefixOf, setCustomIdErrors, version };
 //# sourceMappingURL=index.mjs.map