@seedcord/core 0.11.0 → 0.12.0-next.2

package/dist/internal.index.d.mts

@@ -1,19 +1,19 @@
 import { t as bindEnv } from "./bindViteEnv-BgFewlZ0.mjs";
-import { A as RegisteredCount, B as InteractionMetadataKey, C as AckState, D as AckTrace, E as sendTarget, F as CommandMetadataKey, G as WebhookUrlMetadataKey, H as InteractionRouteKeys, I as EventMetadataKey, K as Notice, L as EventMiddlewareMetadataKey, M as VerifyWebhooks, N as PublishDefault, O as RegisterDefaults, R as GatedMetadataKey, S as reportedWrite, T as checkAckLegality, U as MiddlewareKind, V as InteractionMiddlewareMetadataKey, W as SubscribeMetadataKey, a as StoredSubscriberCtor, c as registrationFor, d as DefaultSubscriptions, f as DispatchOutcome, i as Bus, j as UnregisterSubscriber, k as RegisterSubscriber, o as SubscriberRegistration, r as CoreBase, s as busLoggerOf, w as ReplyMethod, x as ReplyTelemetry, z as InteractionKind } from "./phases-FTM69J3a.mjs";
-import { $ as SlashRouteBrand, A as Gate, At as CacheFor, Ct as CommandMeta, Et as BuilderComponent, Ft as SlashRouteEntry, H as AnyMiddlewareCtor, I as SerializedReply, It as ContextMenuKind, J as ComponentDefsBrand, K as interactionMiddlewareMetaOf, L as serializeReply, Lt as MenuCacheFor, Mt as RouteCache, Nt as SlashOption, Pt as SlashRegistry, Q as MiddlewareKindsBrand, R as DispatchResult, St as resolveDeployTarget, T as GateFitsWith, U as InteractionMiddlewareMetadata, V as HandlerResult, X as ContextMenuKindBrand, Y as ComponentKindBrand, Z as ContextMenuNamesBrand, _t as ScopeId, bt as scopeIdsOf, c as PageCursor, ct as CommandRef, dt as commandRefOf, f as ChoiceValueOf, ft as indexById, gt as GLOBAL_ID, h as ResolvedEmoji, ht as DeployResult, j as GateContextBase, jt as OptionKind, l as pageCursor, lt as LinkedCommands, m as FocusedField, mt as CommandBuilder, ot as installLinks, p as EntryFor, pt as linkCommands, q as AutocompleteRouteBrand, s as PAGE_MAX, st as warnLinks, u as AutocompletableNames, ut as commandKey, vt as commandsRoute, w as pickNotice, x as PermissionNames, xt as skippedNote, yt as globalFirst, z as EventDispatchResult, zt as NamesFor } from "./index-Du71Xx69.mjs";
-import { a as FixedScope, c as PluginArgs, i as sealAttachments, l as PluginCtor, o as Initializeable, r as attachmentsOf, t as Attachment } from "./PluginHost-DB4j8unu.mjs";
-import { n as CoordinatedStartup, t as CoordinatedShutdown } from "./CoordinatedShutdown-H5YjZn8A.mjs";
+import { A as RegisteredCount, B as EventMiddlewareMetadataKey, C as AckState, D as AckTrace, E as sendTarget, G as InteractionRouteKeys, H as InteractionKind, I as DispatchContext, J as WebhookUrlMetadataKey, K as MiddlewareKind, L as InteractionDispatch, M as VerifyWebhooks, N as PublishDefault, O as RegisterDefaults, R as CommandMetadataKey, S as reportedWrite, T as checkAckLegality, U as InteractionMetadataKey, V as GatedMetadataKey, W as InteractionMiddlewareMetadataKey, Y as Notice, a as Bus, f as FaultSource, i as CoreBase, j as UnregisterSubscriber, k as RegisterSubscriber, o as StoredSubscriberCtor, p as InteractionFaultSource, q as SubscribeMetadataKey, s as busLoggerOf, u as DefaultSubscriptions, v as SubscriptionData, w as ReplyMethod, x as ReplyTelemetry, z as EventMetadataKey } from "./phases-C2QCSqRu.mjs";
+import { At as SlashOption, B as InteractionMiddlewareMetadata, Ct as BuilderComponent, Dt as CacheFor, F as DispatchResult, G as ComponentDefsBrand, I as EventDispatchResult, It as NamesFor, J as ContextMenuNamesBrand, K as ComponentKindBrand, Mt as SlashRouteEntry, N as SerializedReply, Nt as ContextMenuKind, O as GateContextBase, Ot as OptionKind, P as serializeReply, Pt as MenuCacheFor, R as HandlerResult, U as interactionMiddlewareMetaOf, W as AutocompleteRouteBrand, X as SlashRouteBrand, Y as MiddlewareKindsBrand, _ as ChoiceValueOf, _t as scopeIdsOf, at as CommandRef, b as ResolvedEmoji, bt as CommandMeta, c as CaseReturn, ct as commandRefOf, d as runCase, dt as CommandBuilder, f as PAGE_MAX, ft as DeployResult, gt as globalFirst, h as AutocompletableNames, ht as commandsRoute, it as warnLinks, jt as SlashRegistry, kt as RouteCache, l as MatchResult, lt as indexById, m as pageCursor, mt as ScopeId, ot as LinkedCommands, p as PageCursor, pt as GLOBAL_ID, q as ContextMenuKindBrand, rt as installLinks, st as commandKey, u as OnlyCases, ut as linkCommands, v as EntryFor, vt as skippedNote, x as GateFitsWith, y as FocusedField, yt as resolveDeployTarget, z as AnyMiddlewareCtor } from "./index-DGHng1IN.mjs";
+import { a as FixedScope, c as PluginArgs, d as Runtime, f as Transport, i as sealAttachments, l as PluginCtor, o as Initializeable, r as attachmentsOf, t as Attachment } from "./PluginHost-DFnkIldj.mjs";
+import { i as StartupTasks, n as ShutdownTasks, r as CoordinatedStartup } from "./CoordinatedShutdown-fPKLWjc5.mjs";
 import "reflect-metadata";
 import { AnyCustomId, DecodedParams } from "@seedcord/custom-id";
 import { ContextMenuCommandBuilder, SlashCommandBuilder } from "@discordjs/builders";
-import { APIApplicationCommand, ChannelType, RESTGetCurrentApplicationResult, RESTPostAPIApplicationCommandsJSONBody } from "discord-api-types/v10";
+import { APIApplicationCommand, ApplicationCommandType, ChannelType, ComponentType, RESTGetCurrentApplicationResult, RESTPostAPIApplicationCommandsJSONBody } from "discord-api-types/v10";
 import { SeedcordErrorCode } from "@seedcord/errors";
 import { BotToken, SeedcordError } from "@seedcord/errors/internal";
-import { Logger } from "@seedcord/logger";
+import { Logger, LoggerOptions } from "@seedcord/logger";
 import { REST } from "@discordjs/rest";
 import { DeployedHashes, DevChannel, SeedcordCliEvents, SeedcordFrameworkEvents, WireError } from "@seedcord/types/internal";
-import { BotColor, DeferOpts, EpochMs, ErrorsConfig, HmrAware, HmrUpdateEvent, ILogger, LogRecord, ReplyResponse, SendOpts } from "@seedcord/types";
-import { Constructor, IsNever, Promisable } from "type-fest";
+import { BotColor, DeferOpts, EpochMs, EventFrequency, HmrAware, HmrUpdateEvent, ILogger, LogRecord, RenderContext, ReplyResponse, SendOpts, TypedOmit } from "@seedcord/types";
+import { Constructor, IsNever, LiteralUnion, Promisable } from "type-fest";
 //#region src/subscribers/SubscriberLoader.d.ts
 export declare class SubscriberLoader implements Initializeable, HmrAware {
   private readonly bus;
@@ -78,8 +78,48 @@ export declare class MiddlewareRegistry<Ctor extends AnyMiddlewareCtor, Key exte
 //#region src/components/botColorHolder.d.ts
 export declare function bindBotColor(read: () => BotColor | undefined): void;
 //#endregion
-//#region src/notices/logUnknownFault.d.ts
-export declare function logUnknownFault(logger: Logger, uuid: string, error: Error, errors: ErrorsConfig | undefined): void;
+//#region src/notices/FaultBoundary.d.ts
+type ApiErrorClass = abstract new (...args: never[]) => {
+  readonly code: number | string;
+};
+interface FaultDetails extends Pick<SubscriptionData<'unknownException'>, 'guild' | 'user'> {
+  readonly origin: string;
+  readonly source: FaultSource | null;
+  readonly metadata: unknown;
+}
+interface FaultSender {
+  send(response: ReplyResponse, options: {
+    ephemeral: boolean;
+  }): Promise<unknown>;
+}
+interface ReportedFault {
+  readonly error: Error;
+  readonly uuid: RenderContext['uuid'];
+}
+export declare class FaultBoundary {
+  private readonly core;
+  private readonly apiError;
+  private readonly dispatch;
+  private readonly detailsOf;
+  private readonly ignoredCodes;
+  constructor(core: CoreBase, ignoredCodes: readonly (number | string)[] | undefined, apiError: ApiErrorClass, dispatch: DispatchContext, detailsOf: () => FaultDetails);
+  report(caught: unknown): ReportedFault | null;
+  answerWithReply(caught: unknown, sender: FaultSender): Promise<void>;
+  answerWithEmptyChoices(caught: unknown, clearChoices: () => Promise<unknown>): Promise<void>;
+  private publish;
+  private rendered;
+  private fallbackReply;
+  private render;
+  private renderContext;
+  private sendGuarded;
+}
+//#endregion
+//#region src/plugin/splitPluginKey.d.ts
+interface PluginKeyParts {
+  readonly head: string;
+  readonly leaf: string | undefined;
+}
+export declare function splitPluginKey(key: string): PluginKeyParts;
 //#endregion
 //#region src/lifecycle/PluginLifecycle.d.ts
 export declare class PluginLifecycle {
@@ -91,7 +131,7 @@ export declare class PluginLifecycle {
   private readonly timedOutInits;
   private attachments;
   private registered;
-  constructor(startup: Pick<CoordinatedStartup, 'addTask'>, shutdown: Pick<CoordinatedShutdown, 'addTask'>);
+  constructor(startup: StartupTasks, shutdown: ShutdownTasks);
   register(attachments: readonly Attachment[]): void;
   rollback(): Promise<void>;
   afterTimedOutInits(run: () => void): void;
@@ -106,25 +146,13 @@ export declare class PluginLifecycle {
 //#region src/decorators/interactionRoutes.d.ts
 type RoutableConstructor = new (...args: never[]) => unknown;
 export declare function interactionRoutesOf(constructor: RoutableConstructor): [InteractionKind, string[]][];
-export declare function storeInteractionRoute(route: InteractionKind, routes: string | readonly string[], constructor: RoutableConstructor): void;
+export declare function storeInteractionRoute(route: InteractionKind, routes: string | readonly string[], constructor: RoutableConstructor, fix?: string): void;
 export declare function storeComponentRoute(route: InteractionKind, defs: readonly AnyCustomId[], constructor: RoutableConstructor): void;
 export declare function contextMenuRouteOf(kind: ContextMenuKind): InteractionKind;
 //#endregion
 //#region src/gates/runGates.d.ts
 type GateObserver = (gateName: string, elapsedMs: number) => void;
-export declare function runGates(gates: readonly Gate<GateContextBase>[], ctx: GateContextBase, observe?: GateObserver): Promise<void>;
-export declare function runHandlerGates(handlerCtor: object, ctx: GateContextBase, declaredRoute?: string, observe?: GateObserver): Promise<void>;
-//#endregion
-//#region src/gates/slowGate.d.ts
-/**
- * collects each gate check's elapsed time for one dispatch. `report` warns once when the checks sum
- * past the threshold, naming the total, the route, and each gate's share.
- */
-interface SlowGateMonitor {
-  readonly observe: GateObserver;
-  report(declaredRoute: string | null): void;
-}
-export declare function slowGateMonitor(): SlowGateMonitor | undefined;
+export declare function runHandlerGates(handlerCtor: object, ctx: GateContextBase, observe?: GateObserver): Promise<void>;
 //#endregion
 //#region src/miscellaneous/guarded.d.ts
 export declare function accessorStore<Value>(): Record<string, Value>;
@@ -134,6 +162,9 @@ export declare function guardedAccessor<Value>(accessor: string, storage: Record
 //#region src/miscellaneous/emojiConfig.d.ts
 export declare function isEmojiTuple(value: unknown): value is readonly [string, string];
 //#endregion
+//#region src/miscellaneous/lazyLogger.d.ts
+export declare function lazyLogger(label: string, options: LoggerOptions): () => Logger;
+//#endregion
 //#region src/miscellaneous/currentApplication.d.ts
 export declare function currentApplication(rest: Pick<REST, 'get'>): Promise<RESTGetCurrentApplicationResult>;
 //#endregion
@@ -185,6 +216,7 @@ export declare class CommandRegistry implements Initializeable, HmrAware {
   private readonly loadedCommands;
   private readonly hmrHandler?;
   private readonly pendingEvents;
+  private readonly deploys;
   private readonly injector;
   private readonly lastDeploy;
   private readonly reporter;
@@ -197,6 +229,8 @@ export declare class CommandRegistry implements Initializeable, HmrAware {
   private reportLoad;
   /** @internal */
   refresh(shouldRefresh?: boolean): Promise<void>;
+  private afterRunningDeploy;
+  private applyEvents;
   /** @internal */
   onHmr(event: HmrUpdateEvent): Promise<void>;
   private loadCommands;
@@ -268,6 +302,19 @@ export declare function isCommandClass(value: unknown): value is CommandCtor;
  */
 export declare function slashRouteLeaves(commands: Iterable<SlashCommandBuilder | ContextMenuCommandBuilder>): Set<string>;
 //#endregion
+//#region src/decorators/assertUniqueKeys.d.ts
+export declare function assertUniqueKeys(decorator: string, ctor: {
+  name: string;
+}, keys: readonly string[], fix?: string): void;
+//#endregion
+//#region src/handlers/MiddlewareRoute.d.ts
+interface RegisteredRoutes {
+  [InteractionKind.Slash]: keyof SlashRegistry;
+  [InteractionKind.UserContextMenu]: NamesFor<ApplicationCommandType.User>;
+  [InteractionKind.MessageContextMenu]: NamesFor<ApplicationCommandType.Message>;
+}
+type MiddlewareRoute<Kind extends MiddlewareKind> = Kind extends keyof RegisteredRoutes ? LiteralUnion<RegisteredRoutes[Kind], string> : string;
+//#endregion
 //#region src/hmr/devChannel.d.ts
 type CliChannel = DevChannel<SeedcordFrameworkEvents, SeedcordCliEvents>;
 /** @internal */
@@ -303,21 +350,18 @@ export declare function fromDevLogLine(line: string): LogRecord | undefined;
 export declare function forwardLogsToCli(): void;
 //#endregion
 //#region src/notices/index.d.ts
-export declare abstract class GateNotice extends Notice {
-  render(): ReplyResponse;
-}
-export declare class NotOwner extends GateNotice {
-  constructor(message?: string);
+export declare class NotOwner extends Notice {
+  constructor();
 }
-export declare class NotInGuild extends GateNotice {
-  constructor(message?: string);
+export declare class NotInGuild extends Notice {
+  constructor();
 }
-export declare class NotInDm extends GateNotice {
-  constructor(message?: string);
+export declare class NotInDm extends Notice {
+  constructor();
 }
-export declare class OnCooldown extends GateNotice {
+export declare class OnCooldown extends Notice {
   readonly resetAt: EpochMs;
-  constructor(resetAt: EpochMs, message?: string);
+  constructor(resetAt: EpochMs);
 }
 export declare class NotAllowed extends Notice {
   constructor();
@@ -328,22 +372,8 @@ export declare class NeedsAny extends Notice {
   constructor(summaries: readonly string[]);
   render(): ReplyResponse;
 }
-export declare class MissingRole extends GateNotice {
-  constructor(message: string | undefined, roleId: string | null);
-}
-export declare class MissingPermissions extends Notice {
-  private readonly subject;
-  private readonly missingPerms;
-  private readonly customLead;
-  constructor(message: string | undefined, subject: string | null, missingPerms: readonly string[]);
-  render(): ReplyResponse;
-}
-export declare class HasDangerousPermissions extends Notice {
-  private readonly subject;
-  private readonly dangerousPerms;
-  private readonly customLead;
-  constructor(message: string | undefined, subject: string, dangerousPerms: readonly string[]);
-  render(): ReplyResponse;
+export declare class MissingRole extends Notice {
+  constructor(roleId: string);
 }
 //#endregion
 //#region src/stops/NoticeCard.d.ts
@@ -386,7 +416,7 @@ export declare function decodeComponentRoute(handlerClass: {
 /** @internal */
 type SingleParams<Defs extends readonly AnyCustomId[]> = Defs extends readonly [infer One extends AnyCustomId] ? DecodedParams<One['shape']> : never;
 /** @internal */
-type MatchArms<Defs extends readonly AnyCustomId[], Ret> = { [Def in Defs[number] as Def['prefix']]: (params: DecodedParams<Def['shape']>) => Promisable<Ret>; };
+type MatchCases<Defs extends readonly AnyCustomId[], Ret> = { [Def in Defs[number] as Def['prefix']]: (params: DecodedParams<Def['shape']>) => CaseReturn<Ret>; };
 //#endregion
 //#region src/inputs/OptionLens.d.ts
 interface OptionLens {
@@ -441,6 +471,16 @@ type SlashOptions<Route extends keyof SlashRegistry, Lens extends OptionLens> =
 export declare function sendFlags(opts?: SendOpts): number;
 export declare function deferFlags(opts?: DeferOpts): number;
 //#endregion
+//#region src/reply/AutocompleteResponder.d.ts
+export declare class AutocompleteResponder<Choice> {
+  private readonly telemetry;
+  private readonly post;
+  private attempt?;
+  constructor(telemetry: ReplyTelemetry, post: (choices: readonly Choice[]) => Promise<unknown>);
+  respond(choices: readonly Choice[]): Promise<void>;
+  clear(): Promise<void>;
+}
+//#endregion
 //#region src/reply/translateSerialization.d.ts
 export declare function translateSerializationError(error: unknown, componentClass: string, index: number, routeId: string): SeedcordError<SeedcordErrorCode.ReplyComponentSerialization>;
 //#endregion
@@ -456,41 +496,127 @@ export declare class ReportThrottle {
   restore(key: string, suppressed: number): void;
 }
 //#endregion
-//#region src/dispatch/dispatchReport.d.ts
-/**
- * Classifies a caught stop for `interactionDispatched` so a gate and a
- * handler label the same stop identically.
- *
- * @internal
- */
-export declare function outcomeFor(caught: unknown): Exclude<DispatchOutcome, 'handled'>;
-interface DispatchReport {
-  readonly dispatchId: string;
-  readonly routeId: string;
+//#region src/dispatch/InteractionRun.d.ts
+interface RunnableHandler {
+  execute(): Promisable<void>;
+}
+interface RunnableMiddleware extends RunnableHandler {
+  after?(result: DispatchResult): Promisable<void>;
+}
+type PreparedRun = (() => Promise<void>) | null;
+interface RepliableTarget {
+  readonly sender: FaultSender;
+  gateContext(): GateContextBase;
+}
+interface AutocompleteTarget {
+  readonly responder: {
+    clear(): Promise<void>;
+  };
+}
+interface InteractionRunConfig {
+  readonly dispatch: InteractionDispatch;
+  readonly core: CoreBase;
+  readonly event: unknown;
+  readonly customId: string | null;
+  readonly HandlerCtor: Constructor<RunnableHandler, never[]>;
+  readonly middlewares: {
+    chainFor(kind: MiddlewareKind): readonly Constructor<RunnableMiddleware, never[]>[];
+  };
+  readonly apiError: ApiErrorClass;
+  readonly logger: Logger;
   readonly interactionId: string;
-  readonly kind: `${InteractionKind}`;
-  readonly outcome: DispatchOutcome;
-  /** True when no route matched and the unhandled default ran. */
-  readonly fallback: boolean;
-  readonly userId: string | null;
+  readonly userId: string;
   readonly guildId: string | null;
-  /** `performance.now()` captured as the dispatch began. */
-  readonly startedAt: number;
-  /** {@link queuedMsFor} read at the same moment as `startedAt`. */
-  readonly queuedMs: number;
+  readonly target: RepliableTarget | AutocompleteTarget;
+  faultDetails(): FaultDetails;
+}
+export declare class InteractionRun {
+  private readonly config;
+  private readonly ran;
+  private readonly startedAt;
+  private readonly queuedMs;
+  private readonly boundary;
+  constructor(config: InteractionRunConfig);
+  prepare(): Promise<PreparedRun>;
+  private warnIfUnhandled;
+  private prepareAutocomplete;
+  private prepareRepliable;
+  private builtHandler;
+  private refusal;
+  private runMiddlewares;
+  private start;
+  private finish;
+  private report;
+}
+//#endregion
+//#region src/dispatch/componentKindOf.d.ts
+export declare function componentKindOf(type: ComponentType): InteractionKind | null;
+//#endregion
+//#region src/dispatch/HandlerLoader.d.ts
+interface LoadedUnit {
+  readonly name: string;
+  readonly from: string;
+}
+interface HandlerLoaderOptions<Handler, Middleware extends AnyMiddlewareCtor, Key extends string, Artifacts> {
+  readonly handlersDir: string;
+  readonly middlewaresDir: string | undefined;
+  readonly middlewares: MiddlewareRegistry<Middleware, Key>;
+  readonly logger: Logger;
+  isHandler(value: unknown): value is Handler;
+  isMiddleware(value: unknown): value is Middleware;
+  storeHandler(handler: Handler, from: string): boolean;
+  removeHandler(handler: Handler, artifacts?: Artifacts): void;
+  artifactsOf(handler: Handler): Artifacts;
+}
+export declare class HandlerLoader<Handler extends {
+  name: string;
+}, Middleware extends AnyMiddlewareCtor, Key extends string, Artifacts> {
+  private readonly options;
+  readonly loadedHandlers: LoadedUnit[];
+  readonly loadedMiddlewares: LoadedUnit[];
+  private initialLoad;
+  private readonly hmr?;
+  constructor(options: HandlerLoaderOptions<Handler, Middleware, Key, Artifacts>);
+  load(): Promise<void>;
+  onHmr(event: HmrUpdateEvent): Promise<void>;
+  private loadHandlers;
+  private loadMiddlewares;
+  private registerHandler;
+  private registerMiddleware;
+}
+//#endregion
+//#region src/dispatch/RouteRegistry.d.ts
+interface RegisteredRoute<Ctor> {
+  readonly kind: InteractionKind;
+  readonly route: string;
+  readonly fallback: boolean;
+  readonly ctor: Ctor;
+}
+type KindMaps<Entry> = Readonly<Record<InteractionKind, Map<string, Entry>>>;
+type RouteMaps<Ctor> = KindMaps<RegisteredRoute<Ctor>>;
+export declare function emptyRouteMaps<Entry>(): KindMaps<Entry>;
+export declare function matchRoute<Ctor>(maps: RouteMaps<Ctor>, kind: InteractionKind, route: string, unhandled: {
+  readonly repliable: Ctor;
+  readonly autocomplete: Ctor;
+}): RegisteredRoute<Ctor>;
+interface LoadedRoute<Ctor> extends RegisteredRoute<Ctor> {
+  readonly from: string;
+}
+export declare class RouteRegistry<Ctor extends RoutableConstructor> {
+  readonly maps: KindMaps<LoadedRoute<Ctor>>;
+  private get allRoutes();
+  get size(): number;
+  register(ctor: Ctor, from: string): boolean;
+  unregister(ctor: Ctor, routes?: readonly RegisteredRoute<Ctor>[]): void;
+  routesOf(ctor: Ctor): RegisteredRoute<Ctor>[];
+  warnUnhandledRoutes(logger: Logger, leaves: Iterable<string>): void;
+  warnUnhandledContextMenuRoutes(logger: Logger, leaves: ContextMenuLeaves): void;
+  private warnMissing;
 }
-/**
- * Discord's interaction creation to now, read from the snowflake. Called at dispatch entry, since
- * a later read would count the handler run into the queue time as well.
- *
- * @internal
- */
-export declare function queuedMsFor(interactionId: string): number;
-export declare function reportDispatch(bus: Bus, report: DispatchReport): void;
 //#endregion
 //#region src/dispatch/runAfter.d.ts
 interface Afterable<Result> {
-  after?(result: Result): Promise<void>;
+  after?(result: Result): Promisable<void>;
 }
 /** @internal */
 export declare function resultFor(caught: unknown): DispatchResult;
@@ -511,5 +637,19 @@ export declare function eventResultFor(stopped: {
  */
 export declare function runAfter<Result>(ran: readonly Afterable<Result>[], result: Result, logger: Logger): Promise<void>;
 //#endregion
-export { type AckState, AckTrace, type AutocompletableNames, AutocompleteRouteBrand, type BakedIds, type CacheFor, type ChoiceValueOf, type CommandBody, type CommandBuilder, type CommandCtor, type CommandMeta, CommandMetadataKey, type CommandRef, type CommandScopes, ComponentDefsBrand, ComponentKindBrand, ContextMenuKindBrand, type ContextMenuLeaves, ContextMenuNamesBrand, CoordinatedStartup, type DecodedComponentRoute, type DefaultSubscriptions, type DeployResult, type EntryFor, EventMetadataKey, EventMiddlewareMetadataKey, FixedScope, type FocusedField, GLOBAL_ID, type GateFitsWith, type GateObserver, GatedMetadataKey, type GuildSummary, type HasComponentDefs, type Initializeable, InteractionMetadataKey, type InteractionMiddlewareMetadata, InteractionMiddlewareMetadataKey, InteractionRouteKeys, type LinkedCommands, type MatchArms, type MenuCacheFor, MiddlewareKindsBrand, type MiddlewareRegistration, type MiddlewareRegistrationOf, type NamesFor, type OptionKind, type OptionLens, PAGE_MAX, type PageCursor, PermissionNames, type PluginArgs, type PluginCtor, PublishDefault, RegisterDefaults, RegisterSubscriber, RegisteredCount, type ReplyMethod, type ReplyTelemetry, type RoutableConstructor, type RouteCache, type ScopeId, type SerializedReply, type SingleParams, type SlashOption, type SlashOptions, SlashRouteBrand, type SlashRouteEntry, type SlowGateMonitor, type StoredSubscriberCtor, SubscribeMetadataKey, type SubscriberRegistration, UnregisterSubscriber, VerifyWebhooks, WebhookUrlMetadataKey, attachmentsOf, bindEnv, busLoggerOf, checkAckLegality, commandKey, commandRefOf, commandsRoute, globalFirst, indexById, installLinks, interactionMiddlewareMetaOf, linkCommands, pageCursor, pickNotice, registrationFor, reportedWrite, resolveDeployTarget, scopeIdsOf, sealAttachments, sendTarget, serializeReply, skippedNote, warnLinks };
+//#region src/dispatch/OnceTracker.d.ts
+interface Registered {
+  readonly ctor: object;
+  readonly frequency: EventFrequency;
+}
+export declare class OnceTracker {
+  private readonly spent;
+  isSpent(entry: Registered, key: string): boolean;
+  claim(entry: Registered, key: string): boolean;
+}
+//#endregion
+//#region src/subscribers/interactionFaultSource.d.ts
+export declare function interactionFaultSource(dispatch: InteractionDispatch, fields: TypedOmit<InteractionFaultSource, 'kind' | 'interactionKind' | 'command'>): InteractionFaultSource | null;
+//#endregion
+export { type AckState, AckTrace, type AutocompletableNames, AutocompleteRouteBrand, type BakedIds, type CacheFor, type CaseReturn, type ChoiceValueOf, type CommandBody, type CommandBuilder, type CommandCtor, type CommandMeta, CommandMetadataKey, type CommandRef, type CommandScopes, ComponentDefsBrand, ComponentKindBrand, ContextMenuKindBrand, type ContextMenuLeaves, ContextMenuNamesBrand, CoordinatedStartup, type DecodedComponentRoute, type DefaultSubscriptions, type DeployResult, DispatchContext, type EntryFor, EventMetadataKey, EventMiddlewareMetadataKey, type FaultDetails, FixedScope, type FocusedField, GLOBAL_ID, type GateFitsWith, GatedMetadataKey, type GuildSummary, type HasComponentDefs, type Initializeable, type InteractionDispatch, InteractionMetadataKey, type InteractionMiddlewareMetadata, InteractionMiddlewareMetadataKey, InteractionRouteKeys, type InteractionRunConfig, type LinkedCommands, type MatchCases, type MatchResult, type MenuCacheFor, MiddlewareKindsBrand, type MiddlewareRegistration, type MiddlewareRegistrationOf, type MiddlewareRoute, type NamesFor, type OnlyCases, type OptionKind, type OptionLens, PAGE_MAX, type PageCursor, type PluginArgs, type PluginCtor, PublishDefault, RegisterDefaults, RegisterSubscriber, RegisteredCount, type RegisteredRoute, type ReplyMethod, type ReplyTelemetry, type RoutableConstructor, type RouteCache, type RouteMaps, type Runtime, type ScopeId, type SerializedReply, type SingleParams, type SlashOption, type SlashOptions, SlashRouteBrand, type SlashRouteEntry, type StartupTasks, type StoredSubscriberCtor, SubscribeMetadataKey, type Transport, UnregisterSubscriber, VerifyWebhooks, WebhookUrlMetadataKey, attachmentsOf, bindEnv, busLoggerOf, checkAckLegality, commandKey, commandRefOf, commandsRoute, globalFirst, indexById, installLinks, interactionMiddlewareMetaOf, linkCommands, pageCursor, reportedWrite, resolveDeployTarget, runCase, scopeIdsOf, sealAttachments, sendTarget, serializeReply, skippedNote, warnLinks };
 //# sourceMappingURL=internal.index.d.mts.map