@seedcord/core 0.12.0-next.0 → 0.12.0-next.2

package/dist/hmr.index.d.mts

@@ -1,17 +1,22 @@
 import { Logger } from "@seedcord/logger";
 import { HmrUpdateEvent } from "@seedcord/types";
 //#region src/hmr/HmrModuleHandler.d.ts
-interface HmrModuleHandlerOptions<THandler, TMiddleware = void, TArtifacts = unknown> {
-  handlersDir: string;
-  middlewaresDir?: string;
-  isHandler: (val: unknown) => val is THandler;
-  isMiddleware?: (val: unknown) => val is TMiddleware;
-  registerHandler: (handler: THandler, file: string) => void;
-  registerMiddleware?: (middleware: TMiddleware, file: string) => void;
-  unregisterHandler: (handler: THandler, artifacts?: TArtifacts) => void;
-  unregisterMiddleware?: (middleware: TMiddleware) => void;
-  /** Snapshotted per handler so a rollback re-registers with the same artifacts after the module re-imports. */
+interface HmrFolderOptions<TUnit> {
+  dir: string;
+  is: (val: unknown) => val is TUnit;
+  register: (unit: TUnit, file: string) => void;
+}
+interface HmrHandlerOptions<THandler, TArtifacts> extends HmrFolderOptions<THandler> {
+  unregister: (handler: THandler, artifacts?: TArtifacts) => void;
+  /** Called each time a handler is tracked. `unregister` receives the result as its second argument. */
   getArtifacts?: (handler: THandler) => TArtifacts;
+}
+interface HmrMiddlewareOptions<TMiddleware> extends HmrFolderOptions<TMiddleware> {
+  unregister: (middleware: TMiddleware) => void;
+}
+interface HmrModuleHandlerOptions<THandler, TMiddleware = void, TArtifacts = unknown> {
+  handlers: HmrHandlerOptions<THandler, TArtifacts>;
+  middlewares?: HmrMiddlewareOptions<TMiddleware>;
   logger: Logger;
 }
 /**
@@ -22,22 +27,17 @@ interface HmrModuleHandlerOptions<THandler, TMiddleware = void, TArtifacts = unk
  * This is only useful during development.
  */
 export declare class HmrModuleHandler<THandler, TMiddleware = void, TArtifacts = unknown> {
-  private readonly store;
-  private readonly options;
+  #private;
   constructor(options: HmrModuleHandlerOptions<THandler, TMiddleware, TArtifacts>);
-  /** Unloads or reloads the modules affected by an {@link HmrUpdateEvent}, scoped to the handler and middleware directories. */
+  /**
+   * Unloads or reloads the modules affected by an {@link HmrUpdateEvent}, scoped to the handler and middleware directories.
+   * When that unloads something, it also retries every file that failed earlier on a duplicate name.
+   */
   handle(event: HmrUpdateEvent): Promise<void>;
-  private inScope;
-  private report;
-  private reloadWithRollback;
   /** Links the handler to its source file so a later update can unload it. */
   trackHandler(file: string, handler: THandler): void;
   /** Links the middleware to its source file so a later update can unload it. */
   trackMiddleware(file: string, middleware: TMiddleware): void;
-  private unload;
-  private reloadFile;
-  private snapshotUnits;
-  private restoreUnits;
 }
 //#endregion
 //# sourceMappingURL=hmr.index.d.mts.map

package/dist/hmr.index.mjs

@@ -1,3 +1,3 @@
-import { t as HmrModuleHandler } from "./HmrModuleHandler-BMD7dg8N.mjs";
+import { t as HmrModuleHandler } from "./HmrModuleHandler-Btgu8r96.mjs";
 
 export { HmrModuleHandler };

package/dist/{index-Boo33hh3.d.mts → index-DGHng1IN.d.mts}

@@ -1,10 +1,11 @@
-import { K as MiddlewareKind, L as DispatchContext, Y as Notice, b as SubscriptionKey, i as CoreBase, u as Subscriber } from "./phases-Dojnr-ng.mjs";
+import { I as DispatchContext, K as MiddlewareKind, c as AllSubscriptions, i as CoreBase, y as SubscriptionKey } from "./phases-C2QCSqRu.mjs";
 import "reflect-metadata";
 import { CustomId, CustomIdField } from "@seedcord/custom-id";
 import { ActionRowBuilder, ButtonBuilder, ChannelSelectMenuBuilder, CheckboxBuilder, CheckboxGroupBuilder, CheckboxGroupOptionBuilder, ContainerBuilder, ContextMenuCommandBuilder, EmbedBuilder, FileBuilder, FileUploadBuilder, LabelBuilder, MediaGalleryBuilder, MentionableSelectMenuBuilder, ModalBuilder, RadioGroupBuilder, RadioGroupOptionBuilder, RoleSelectMenuBuilder, SectionBuilder, SeparatorBuilder, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, StringSelectMenuBuilder, StringSelectMenuOptionBuilder, TextDisplayBuilder, TextInputBuilder, UserSelectMenuBuilder } from "@discordjs/builders";
 import { APIApplicationCommand, APIMessageComponentEmoji, APIMessageTopLevelComponent, ApplicationCommandType, ChannelType, RESTPostAPIApplicationCommandsJSONBody, Snowflake } from "discord-api-types/v10";
+import { Logger } from "@seedcord/logger";
 import { EventFrequency, ILogger, ReplyFile, ReplyResponse } from "@seedcord/types";
-import { Constructor, IsNever, LiteralUnion, NonEmptyTuple, Simplify } from "type-fest";
+import { Constructor, IsNever, IsUnion, LiteralUnion, NonEmptyTuple, Promisable, Simplify } from "type-fest";
 //#region src/registries/ContextMenuRegistry.d.ts
 /** The two context-menu command kinds Discord defines. */
 type ContextMenuKind = ApplicationCommandType.User | ApplicationCommandType.Message;
@@ -471,7 +472,7 @@ declare function serializeReply<TNative>(response: ReplyResponse<TNative> | stri
 /**
  * The transport-agnostic gate context, the scalar identity of the acting user resolvable from any
  * transport's payload. Every field except `core` is nullable, since an event or DM may carry no
- * guild or member. Each transport extends it with its own arm. For example, the gateway adds the djs
+ * guild or member. Each transport extends it with its own context. For example, the gateway adds the djs
  * `user`/`guild`/`member` objects and the live interaction or event payload.
  *
  * @example
@@ -501,19 +502,9 @@ interface GateContextBase {
    * channel-scoped permissions the payload contains, and on a gateway event they're the member's guild-level ones.
    */
   readonly memberPermissions: bigint | null;
-  /**
-   * The bot's permissions in the invoked channel, the wire `app_permissions` value. Null on gateway events.
-   */
-  readonly appPermissions: bigint | null;
-  /**
-   * The handler's own route, as `kind:route` (`slash:daily`, `button:confirm`). A handler registered
-   * on several reports the one this dispatch matched. Null when the handler declares none, which
-   * covers a plain event handler, the unhandled default, and a gate run outside a handler.
-   */
-  readonly declaredRoute: string | null;
   /**
    * The bag for this dispatch, the same instance the handler and its middleware hold. Every middleware
-   * runs before the first gate. A gate therefore reads what a middleware wrote.
+   * runs before the first gate. A gate can therefore read what a middleware wrote.
    */
   readonly dispatch: DispatchContext;
 }
@@ -535,10 +526,25 @@ interface GuildPermissionsContext extends GateContextBase {
    */
   readonly memberGuildPermissions: bigint | null;
   /**
-   * The bot's base permission set from the transport's cache. Null when the cached member is unavailable.
+   * The bot's base permission set from the transport's cache. It's `0n` in a guild the bot isn't in. It's null
+   * when the guild is cached but the bot's member isn't.
    */
   readonly appGuildPermissions: bigint | null;
 }
+/**
+ * The context an interaction provides on both transports, where Discord always sends the bot's channel
+ * permissions. A gate that requires it fits no event handler.
+ *
+ * @example
+ * ```ts
+ * // the default channel scope returns a Gate<AppPermissionsContext>
+ * \@Gated(RequireBotPermissions([PermissionFlagsBits.ManageMessages]))
+ * ```
+ */
+interface AppPermissionsContext extends GateContextBase {
+  /** The bot's permissions in the invoked channel, the wire `app_permissions` value. */
+  readonly appPermissions: bigint;
+}
 declare const GateBrand: unique symbol;
 /**
  * A precondition attached to a handler. It refuses by throwing a `Notice` (a reply) or a `Silence`
@@ -632,11 +638,11 @@ interface EffectGate<Ctx extends GateContextBase = GateContextBase, Name extends
  * });
  * ```
  */
-declare function defineGate<const Name extends string, Ctx extends GateContextBase = GateContextBase>(name: Name, fn: (ctx: Ctx) => void | Promise<void>): Gate<Ctx, Name>;
+declare function defineGate<const Name extends string, Ctx extends GateContextBase = GateContextBase>(name: Name, fn: (ctx: Ctx) => Promisable<void>): Gate<Ctx, Name>;
 /**
  * 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`, a refusing arm's queued commit is rolled back. This is how {@link Cooldown} peeks
+ * 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.
@@ -668,7 +674,7 @@ declare function defineGate<const Name extends string, Ctx extends GateContextBa
  * }
  * ```
  */
-declare function defineEffectGate<const Name extends string, Ctx extends GateContextBase = GateContextBase>(name: Name, check: (ctx: Ctx) => void | Promise<void>, commit: (ctx: Ctx) => void | Promise<void>): EffectGate<Ctx, Name>;
+declare function defineEffectGate<const Name extends string, Ctx extends GateContextBase = GateContextBase>(name: Name, check: (ctx: Ctx) => Promisable<void>, commit: (ctx: Ctx) => Promisable<void>): EffectGate<Ctx, Name>;
 /**
  * The context a {@link Gate} requires.
  *
@@ -687,164 +693,9 @@ type TwoOrMore<Item> = readonly [Item, Item, ...Item[]];
 type GateName<TGate> = TGate extends Gate<GateContextBase, infer Name> ? Name : string;
 type Grouped<Name extends string> = Name extends `${string} & ${string}` | `${string} | ${string}` ? `(${Name})` : Name;
 type JoinNames<Gates extends readonly Gate<GateContextBase>[], Sep extends string> = Gates extends readonly [infer Only extends Gate<GateContextBase>] ? Grouped<GateName<Only>> : Gates extends readonly [infer First extends Gate<GateContextBase>, ...infer Rest extends readonly Gate<GateContextBase>[]] ? `${Grouped<GateName<First>>}${Sep}${JoinNames<Rest, Sep>}` : string;
-type GateMismatch<Name extends string, Want extends string, Got extends string> = `gate '${Name}' requires a ${Want} handler, and this handler is ${Got}`;
+type GateMismatch<Name extends string, Want extends string, Got extends string> = `gate '${Name}' needs a handler of kind ${Want}, but this handler's kind is ${Got}`;
 type GateFitsWith<Provided, ProvidedLabel extends string, TGate, ReqLabel extends string> = [Provided] extends [RequiredOf<TGate>] ? TGate : Constructor<[GateMismatch<GateName<TGate>, ReqLabel, ProvidedLabel>]>;
 //#endregion
-//#region src/gates/catalog/options.d.ts
-/**
- * The override a catalog gate accepts. A one-line `message` reword or a full `notice` replacement. Accepted by
- * the agnostic catalog gates and, nested per refusal, by {@link RequireRole}. {@link RequirePermissions} and
- * {@link RequireBotPermissions} take `RequirePermissionsOptions` instead.
- *
- * @example
- * ```ts
- * // reword the default refusal
- * OwnerOnly({ message: 'Bot owners only.' });
- * ```
- *
- * @example
- * ```ts
- * // replace the refusal entirely, for example a translated Notice
- * GuildOnly({ notice: new MyTranslatedNotice() });
- * ```
- */
-interface GateNoticeOptions {
-  /** Reword the default refusal, keeping its embed styling. */
-  message?: string;
-  /** Replace the default refusal Notice entirely, for full control or a translated copy. */
-  notice?: Notice;
-}
-declare function pickNotice(options: GateNoticeOptions | undefined, makeDefault: (message?: string) => Notice): Notice;
-//#endregion
-//#region src/permissions/bits.d.ts
-/**
- * The permission flag bits a caller or the bot must hold. Pass the `PermissionFlagsBits` values from
- * `discord-api-types/v10` (or `discord.js`).
- */
-type PermissionScope = readonly bigint[];
-declare const PermissionNames: Map<bigint, string>;
-//#endregion
-//#region src/gates/catalog/permissions.d.ts
-/**
- * Options for {@link RequirePermissions} and {@link RequireBotPermissions}.
- */
-interface RequirePermissionsOptions {
-  /**
-   * The set the check reads. `'channel'` reads the effective channel set the payload carries, what
-   * Discord enforces in the invoked channel. `'guild'` reads the base set from roles, available on the
-   * gateway transport only.
-   *
-   * @defaultValue `'channel'`
-   */
-  in?: 'channel' | 'guild';
-  /** Reword or replace the refusal shown when the set is unavailable (outside a guild, or unresolved inside one). */
-  notInGuild?: GateNoticeOptions;
-  /** Reword or replace the refusal shown when a permission is missing. */
-  missing?: GateNoticeOptions;
-}
-/**
- * Options for {@link RequireRole}.
- */
-interface RequireRoleOptions {
-  /** Reword or replace the refusal shown outside a guild. */
-  notInGuild?: GateNoticeOptions;
-  /** Reword or replace the refusal shown when the caller lacks the role. */
-  missingRole?: GateNoticeOptions;
-}
-/**
- * Requires the caller to hold every permission in `scope`. Refuses outside a guild first, then when a
- * permission is missing. The Administrator bit passes any scope.
- *
- * The default `'channel'` scope reads the effective channel set the payload carries, what Discord enforces
- * in the invoked channel. The `'guild'` scope reads the base set from roles and requires a
- * {@link GuildPermissionsContext}, so it fits a gateway handler only.
- *
- * @param scope - The permission flag bits the caller must all hold.
- * @param options - Pick the scope with `in`, and override each refusal with `notInGuild` or `missing`.
- *
- * @see the `@Gated` decorator from your transport package
- *
- * @example
- * ```ts
- * import { PermissionFlagsBits } from 'discord-api-types/v10';
- *
- * \@Gated(RequirePermissions([PermissionFlagsBits.BanMembers]))
- * \@SlashRoute('ban')
- * class BanHandler extends SlashHandler<'ban'> {
- *     async execute() {
- *         // ...
- *     }
- * }
- * ```
- *
- * @example
- * ```ts
- * // the base set from roles, on a gateway handler
- * RequirePermissions([PermissionFlagsBits.BanMembers], { in: 'guild' });
- * ```
- */
-declare function RequirePermissions(scope: PermissionScope, options: RequirePermissionsOptions & {
-  in: 'guild';
-}): Gate<GuildPermissionsContext, 'RequirePermissions'>;
-declare function RequirePermissions(scope: PermissionScope, options?: RequirePermissionsOptions & {
-  in?: 'channel';
-}): Gate<GateContextBase, 'RequirePermissions'>;
-/**
- * Requires the bot to hold every permission in `scope`. Refuses outside a guild first, then when a
- * permission is missing. The Administrator bit passes any scope.
- *
- * The default `'channel'` scope reads the bot's effective channel set (wire `app_permissions`), what
- * Discord enforces in the invoked channel. The `'guild'` scope reads the bot's base set from roles and
- * requires a {@link GuildPermissionsContext}, fitting a gateway handler only. `app_permissions` is
- * absent on gateway events, the channel scope refuses there as unresolved, use `in: 'guild'` on an
- * event handler.
- *
- * @param scope - The permission flag bits the bot must all hold.
- * @param options - Pick the scope with `in`, and override each refusal with `notInGuild` or `missing`.
- *
- * @see the `@Gated` decorator from your transport package
- *
- * @example
- * ```ts
- * import { PermissionFlagsBits } from 'discord-api-types/v10';
- *
- * \@Gated(RequireBotPermissions([PermissionFlagsBits.ManageMessages]))
- * \@SlashRoute('purge')
- * class PurgeHandler extends SlashHandler<'purge'> {
- *     async execute() {
- *         // ...
- *     }
- * }
- * ```
- */
-declare function RequireBotPermissions(scope: PermissionScope, options: RequirePermissionsOptions & {
-  in: 'guild';
-}): Gate<GuildPermissionsContext, 'RequireBotPermissions'>;
-declare function RequireBotPermissions(scope: PermissionScope, options?: RequirePermissionsOptions & {
-  in?: 'channel';
-}): Gate<GateContextBase, 'RequireBotPermissions'>;
-/**
- * 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 - Override each refusal, the outside-guild one with `notInGuild` and the missing-role one with `missingRole`.
- *
- * @see the `@Gated` decorator from your transport package
- *
- * @example
- * ```ts
- * \@Gated(RequireRole('123456789012345678'))
- * \@SlashRoute('vip')
- * class VipHandler extends SlashHandler<'vip'> {
- *     async execute() {
- *         // ...
- *     }
- * }
- * ```
- */
-declare function RequireRole(roleId: string, options?: RequireRoleOptions): Gate<GateContextBase, 'RequireRole'>;
-//#endregion
 //#region src/miscellaneous/ResolvedEmoji.d.ts
 /**
  * A resolved custom emoji. Renders as `<:name:id>` in message content, or `<a:name:id>` when animated,
@@ -907,6 +758,66 @@ type PageCursor<Prefix extends string> = CustomId<Prefix, {
 /** Build the page cursor for a paginator. */
 declare function pageCursor<Prefix extends string>(prefix: Prefix): PageCursor<Prefix>;
 //#endregion
+//#region src/handlers/runCase.d.ts
+type ResolvedReturn<Case> = Case extends ((...args: never[]) => infer Result) ? Awaited<Result> : never;
+type CaseReturn<Ret> = [Ret] extends [never] ? unknown : Promisable<Ret>;
+type MatchResult<Ret, Cases> = [Ret] extends [never] ? ResolvedReturn<Cases[keyof Cases]> : Ret;
+type ShapeKey<Shape> = keyof Shape | `${Extract<keyof Shape, string>}`;
+type OnlyCases<Cases, Shape> = Cases & Record<Exclude<keyof Cases, ShapeKey<Shape>>, never>;
+declare function runCase<Result>(handler: object, cases: object, kind: string, value: string, ...args: unknown[]): Promise<Result>;
+//#endregion
+//#region src/subscribers/Subscriber.d.ts
+type SubscriberMatchCases<Keys extends SubscriptionKey, Ret> = { [Key in Keys]: (data: AllSubscriptions[Key]) => CaseReturn<Ret>; };
+type SingleKeyData<Keys extends SubscriptionKey> = IsUnion<Keys> extends true ? never : AllSubscriptions[Keys];
+/**
+ * Abstract base class for handling application subscribers.
+ *
+ * Pass the subscription key(s) as the generic, the same one(s) as `@Subscribe`. On a single-key subscriber, read
+ * `this.data` directly. On a subscriber for several keys, branch with `this.match`, keyed by subscription key.
+ *
+ * @typeParam Keys - One or more subscription keys, like `'userJoin'` or `'userJoin' | 'userLeave'`.
+ * @typeParam TCore - The transport's Core
+ */
+declare abstract class Subscriber<in out Keys extends SubscriptionKey, TCore extends CoreBase> {
+  #private;
+  protected readonly core: TCore;
+  protected readonly key: Keys;
+  protected readonly logger: Logger;
+  constructor(payload: AllSubscriptions[Keys], core: TCore, key: Keys);
+  /** The published payload. It's `never` on a subscriber for several keys, where `this.match` reads it. */
+  protected get data(): SingleKeyData<Keys>;
+  /**
+   * Executes the subscriber handler logic.
+   */
+  abstract execute(): Promise<void>;
+  /**
+   * Run the case for the published key. Use this only when the subscriber is registered for several
+   * keys. On a single-key subscriber, read `this.data` directly.
+   *
+   * Provide one case per registered key. Each case receives that key's own payload. A missing key or an unknown
+   * key is a compile error.
+   *
+   * @typeParam Ret - The type that every case must return. Leave it out to get the union of what the cases return.
+   * @throws A **SeedcordTypeError** with `MatchCaseMissing` when the published key doesn't have a case.
+   *
+   * @example
+   * ```ts
+   * import { Subscribe, Subscriber } from '@seedcord/gateway';
+   *
+   * \@Subscribe(['interactionDispatched'], ['eventDispatched'])
+   * class Metrics extends Subscriber<'interactionDispatched' | 'eventDispatched'> {
+   *     async execute() {
+   *         await this.match({
+   *             interactionDispatched: (data) => this.logger.info(data.routeId),
+   *             eventDispatched: (data) => this.logger.info(data.name)
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret = never, Cases extends SubscriberMatchCases<Keys, Ret> = SubscriberMatchCases<Keys, Ret>>(cases: OnlyCases<Cases, SubscriberMatchCases<Keys, Ret>>): Promise<MatchResult<Ret, Cases>>;
+}
+//#endregion
 //#region src/subscribers/decorators/Subscribe.d.ts
 /**
  * Options accepted by the `@Subscribe` decorator.
@@ -919,32 +830,36 @@ interface SubscribeOptions {
    */
   readonly frequency?: EventFrequency | undefined;
 }
+type SubscribeSpec<Key extends SubscriptionKey> = readonly [key: Key, options?: SubscribeOptions];
 /**
- * Registers a subscriber handler class with a specific subscriber event.
+ * Registers a subscriber class with one or more subscription keys.
  *
- * Associates the decorated class with a subscriber event type for automatic
- * registration and execution when the subscriber is emitted.
+ * Supply one `[key, options?]` tuple per key. The subscriber's generic must list the same keys.
  *
- * @typeParam TSubscriber - The subscriber event name to register for
- * @param subscriber - The subscriber event name to register for
- * @param options - Options to configure the subscriber handler registration.
  * @decorator
  * @example
- * ```typescript
- * \@Subscribe('userJoin')
+ * ```ts
+ * \@Subscribe(['userJoin'])
  * class WelcomeHandler extends Subscriber<'userJoin'> {
- *   async execute() {
- *   }
+ *     async execute() {
+ *         this.logger.info(`${this.data.userId} joined`);
+ *     }
  * }
  * ```
  * @example
  * ```ts
- * \@Subscribe('userJoin', { frequency: 'once' })
- * // or
- * \@Subscribe('userJoin')
+ * \@Subscribe(['userJoin', { frequency: 'once' }], ['userLeave'])
+ * class Presence extends Subscriber<'userJoin' | 'userLeave'> {
+ *     async execute() {
+ *         await this.match({
+ *             userJoin: (data) => this.logger.info(`${data.userId} joined`),
+ *             userLeave: (data) => this.logger.info(`${data.userId} left`)
+ *         });
+ *     }
+ * }
  * ```
  */
-declare function Subscribe<TSubscriber extends SubscriptionKey>(subscriber: TSubscriber, options?: SubscribeOptions): <HandlerCtor extends Constructor<Subscriber<TSubscriber, CoreBase>>>(constructor: HandlerCtor) => void;
+declare function Subscribe<const Defs extends readonly SubscribeSpec<SubscriptionKey>[]>(...defs: Defs): <HandlerCtor extends Constructor<Subscriber<Defs[number][0], CoreBase>>>(constructor: HandlerCtor) => void;
 //#endregion
 //#region src/subscribers/bases/WebhookSender.d.ts
 /** A file attached to a webhook report. */
@@ -989,7 +904,7 @@ interface WebhookReport {
  * resolves the url, validates it, reuses one sender per url, and sends. Registration skips a reporter
  * whose variable is unset and warns at boot.
  *
- * @typeParam KeyOfSubscribers - The subscription key this reporter receives
+ * @typeParam KeyOfSubscribers - The subscription key or keys that this reporter receives, the same ones as `@Subscribe`
  * @typeParam TCore - The transport's Core
  */
 declare abstract class WebhookLog<KeyOfSubscribers extends SubscriptionKey, TCore extends CoreBase> extends Subscriber<KeyOfSubscribers, TCore> {
@@ -1024,7 +939,7 @@ declare abstract class WebhookLog<KeyOfSubscribers extends SubscriptionKey, TCor
  * @decorator
  * @example
  * ```ts
- * \@Subscribe('memberBanned')
+ * \@Subscribe(['memberBanned'])
  * \@WebhookUrl('BAN_LOG_WEBHOOK_URL')
  * class BanLog extends WebhookLog<'memberBanned'> {
  *   report() {
@@ -1033,7 +948,7 @@ declare abstract class WebhookLog<KeyOfSubscribers extends SubscriptionKey, TCor
  * }
  * ```
  */
-declare function WebhookUrl(envKey: string): <HandlerCtor extends Constructor<WebhookLog<SubscriptionKey, CoreBase>>>(constructor: HandlerCtor) => void;
+declare function WebhookUrl(envKey: string): <Keys extends SubscriptionKey>(constructor: Constructor<WebhookLog<Keys, CoreBase>>) => void;
 //#endregion
-export { SlashRouteBrand as $, Gate as A, CacheFor as At, HandlerOutcome as B, UserContextMenuRegistry as Bt, GateNoticeOptions as C, CommandMeta as Ct, JoinNames as D, RowComponent as Dt, IntersectRequired as E, BuilderComponent as Et, defineGate as F, SlashRouteEntry as Ft, RegisterInteractionMiddleware as G, AnyMiddlewareCtor as H, SerializedReply as I, ContextMenuKind as It, ComponentDefsBrand as J, interactionMiddlewareMetaOf as K, serializeReply as L, MenuCacheFor as Lt, GuildPermissionsContext as M, RouteCache as Mt, RequiredOf as N, SlashOption as Nt, TwoOrMore as O, BuilderType as Ot, defineEffectGate as P, SlashRegistry as Pt, MiddlewareKindsBrand as Q, DispatchResult as R, MessageContextMenuRegistry as Rt, PermissionScope as S, resolveDeployTarget as St, GateFitsWith as T, RegisterCommand as Tt, InteractionMiddlewareMetadata as U, HandlerResult as V, InteractionMiddlewareOptions as W, ContextMenuKindBrand as X, ComponentKindBrand as Y, ContextMenuNamesBrand as Z, RequirePermissions as _, ScopeId as _t, Subscribe as a, InjectedContextMenuMap as at, RequireRoleOptions as b, scopeIdsOf as bt, PageCursor as c, CommandRef as ct, AutocompleteOptions as d, commandRefOf as dt, CommandInfo as et, ChoiceValueOf as f, indexById as ft, RequireBotPermissions as g, GLOBAL_ID as gt, ResolvedEmoji as h, DeployResult as ht, WebhookFile as i, InjectedCommandMap as it, GateContextBase as j, OptionKind as jt, EffectGate as k, RowType as kt, pageCursor as l, LinkedCommands as lt, FocusedField as m, CommandBuilder as mt, WebhookLog as n, ContextMenuInfo as nt, SubscribeOptions as o, installLinks as ot, EntryFor as p, linkCommands as pt, AutocompleteRouteBrand as q, WebhookReport as r, ContextMenus as rt, PAGE_MAX as s, warnLinks as st, WebhookUrl as t, Commands as tt, AutocompletableNames as u, commandKey as ut, RequirePermissionsOptions as v, commandsRoute as vt, pickNotice as w, GuildTarget as wt, PermissionNames as x, skippedNote as xt, RequireRole as y, globalFirst as yt, EventDispatchResult as z, NamesFor as zt };
-//# sourceMappingURL=index-Boo33hh3.d.mts.map
+export { ContextMenuInfo as $, RequiredOf as A, SlashOption as At, InteractionMiddlewareMetadata as B, JoinNames as C, BuilderComponent as Ct, Gate as D, CacheFor as Dt, EffectGate as E, RowType as Et, DispatchResult as F, MessageContextMenuRegistry as Ft, ComponentDefsBrand as G, RegisterInteractionMiddleware as H, EventDispatchResult as I, NamesFor as It, ContextMenuNamesBrand as J, ComponentKindBrand as K, HandlerOutcome as L, UserContextMenuRegistry as Lt, defineGate as M, SlashRouteEntry as Mt, SerializedReply as N, ContextMenuKind as Nt, GateContextBase as O, OptionKind as Ot, serializeReply as P, MenuCacheFor as Pt, Commands as Q, HandlerResult as R, IntersectRequired as S, RegisterCommand as St, AppPermissionsContext as T, BuilderType as Tt, interactionMiddlewareMetaOf as U, InteractionMiddlewareOptions as V, AutocompleteRouteBrand as W, SlashRouteBrand as X, MiddlewareKindsBrand as Y, CommandInfo as Z, ChoiceValueOf as _, scopeIdsOf as _t, Subscribe as a, CommandRef as at, ResolvedEmoji as b, CommandMeta as bt, CaseReturn as c, commandRefOf as ct, runCase as d, CommandBuilder as dt, ContextMenus as et, PAGE_MAX as f, DeployResult as ft, AutocompleteOptions as g, globalFirst as gt, AutocompletableNames as h, commandsRoute as ht, WebhookFile as i, warnLinks as it, defineEffectGate as j, SlashRegistry as jt, GuildPermissionsContext as k, RouteCache as kt, MatchResult as l, indexById as lt, pageCursor as m, ScopeId as mt, WebhookLog as n, InjectedContextMenuMap as nt, SubscribeOptions as o, LinkedCommands as ot, PageCursor as p, GLOBAL_ID as pt, ContextMenuKindBrand as q, WebhookReport as r, installLinks as rt, Subscriber as s, commandKey as st, WebhookUrl as t, InjectedCommandMap as tt, OnlyCases as u, linkCommands as ut, EntryFor as v, skippedNote as vt, TwoOrMore as w, RowComponent as wt, GateFitsWith as x, GuildTarget as xt, FocusedField as y, resolveDeployTarget as yt, AnyMiddlewareCtor as z };
+//# sourceMappingURL=index-DGHng1IN.d.mts.map