@seedcord/http 0.9.2 → 0.10.0

package/README.md

@@ -8,8 +8,8 @@
 <div align="center">
   <h3>The whole Discord bot, typed end to end</h3>
   <a href="https://seedcord.org">Website</a> ·
-  <a href="https://guide.seedcord.org">Guide</a> ·
-  <a href="https://docs.seedcord.org">Reference</a> ·
+  <a href="https://seedcord.org/guide">Guide</a> ·
+  <a href="https://seedcord.org/docs">Reference</a> ·
   <a href="https://discord.gg/DzFxY58WXf">Discord</a>
 </div>
 

package/dist/Manifest-D61MNdcV.d.mts

@@ -0,0 +1,476 @@
+import { AutocompletableNames, AutocompleteRouteBrand, ChoiceValueOf, ComponentDefsBrand, ComponentKindBrand, EntryFor, FocusedField, HasComponentDefs, MatchArms, MiddlewareKindsBrand, SingleParams, StoredSubscriberCtor } from "@seedcord/core/internal";
+import { REST } from "@discordjs/rest";
+import { AutocompleteOptions, BaseHandler, BaseReplySender, Bus, CoreBase, DispatchContext, DispatchResult, InteractionKind, MiddlewareKind, ModalLike, RepliableHandler, SlashRegistry } from "@seedcord/core";
+import { APIApplicationCommandAutocompleteInteraction, APIApplicationCommandOptionChoice, APIChatInputApplicationCommandInteraction, APIContextMenuInteraction, APIInteractionDataResolvedChannel, APIInteractionDataResolvedGuildMember, APIMessage, APIMessageApplicationCommandInteraction, APIMessageChannelSelectInteractionData, APIMessageComponentButtonInteraction, APIMessageComponentInteraction, APIMessageComponentSelectMenuInteraction, APIMessageMentionableSelectInteractionData, APIMessageRoleSelectInteractionData, APIMessageStringSelectInteractionData, APIMessageUserSelectInteractionData, APIModalInteractionResponseCallbackData, APIModalSubmitInteraction, APIRole, APIUser, APIUserApplicationCommandInteraction } from "discord-api-types/v10";
+import { API } from "@discordjs/core/http-only";
+import { AnyCustomId } from "@seedcord/custom-id";
+import { Collection } from "@discordjs/collection";
+import { CoordinatedShutdown, CoordinatedStartup } from "@seedcord/core/node";
+import { Config, DeferOpts, ReplyResponse, SendOpts, TypedConstructor } from "@seedcord/types";
+import { Constructor, Promisable } from "type-fest";
+//#region src/interfaces/Config.d.ts
+/**
+ * Config for a long-running node server. Pass to `new Seedcord(config).start()`.
+ */
+interface HttpServerConfig extends Config {
+  runtime?: 'server';
+  /**
+   * Port the interactions server uses.
+   *
+   * @defaultValue `3000`
+   */
+  port?: number;
+}
+/**
+ * Config for a bundled isolate deployment. `seedcord build` generates a worker entry that calls
+ * `createSeedcord`.
+ */
+interface HttpEdgeConfig extends Config {
+  runtime: 'edge';
+  port?: never;
+  lifecycle?: never;
+}
+/**
+ * The http transport's configuration, discriminated on `runtime`.
+ */
+type HttpConfig = HttpServerConfig | HttpEdgeConfig;
+//#endregion
+//#region src/interfaces/Core.d.ts
+/**
+ * Main interface for Seedcord core functionality on the HTTP transport.
+ *
+ * This interface can be augmented via declaration merging to add type-safe plugin definitions when
+ * using `this.core` in handlers.
+ *
+ * @example
+ * ```typescript
+ * declare module '@seedcord/http' {
+ *   interface Core {
+ *     db: Mongoose;
+ *   }
+ * }
+ * ```
+ */
+interface Core extends CoreBase {
+  readonly shutdown: Pick<CoordinatedShutdown, 'addTask'>;
+  readonly startup: Pick<CoordinatedStartup, 'addTask'>;
+  readonly config: HttpConfig;
+}
+//#endregion
+//#region src/handlers/interaction/AutocompleteHandler.d.ts
+type FocusedArms<Route extends keyof SlashRegistry, Ret> = { [Name in AutocompletableNames<Route>]: (value: string, respond: (choices: readonly APIApplicationCommandOptionChoice<ChoiceValueOf<EntryFor<Route, Name>>>[]) => Promise<void>) => Promisable<Ret>; };
+/**
+ * Base class for an autocomplete handler on the HTTP transport.
+ *
+ * Pass the command route(s) from the generated registry as the generic. Branch on the focused field with
+ * `this.match`, read already-entered sibling options with `this.options`, and find which command fired
+ * with `this.route`.
+ *
+ * @typeParam Route - One or more route keys from {@link SlashRegistry}, e.g. `'search'`.
+ */
+declare abstract class AutocompleteHandler<Route extends keyof SlashRegistry> extends BaseHandler<APIApplicationCommandAutocompleteInteraction, Core> {
+  constructor(event: APIApplicationCommandAutocompleteInteraction, core: Core, dispatch: DispatchContext);
+  /** @internal */
+  readonly [AutocompleteRouteBrand]?: Route;
+  /**
+   * Typed Discord REST API (`@discordjs/core/http-only`) over `core.rest`, one instance per core.
+   */
+  protected get api(): API;
+  private resolver?;
+  private get reader();
+  /**
+   * The focused option for this interaction. `value` is always the raw partial string the user is typing,
+   * even for an integer or number option, so coerce it yourself when you need a number.
+   */
+  protected get focused(): FocusedField<Route>;
+  /**
+   * Run the arm for the focused field. An autocomplete always dispatches by which field is focused.
+   * Match is how you read it.
+   *
+   * Provide one arm per autocompletable field across the registered commands, keyed by field name. Each
+   * arm receives the focused partial value and a `respond` typed to that field's choice value. The
+   * arms must cover every autocompletable field, a missing field or an unknown key is a compile error. A
+   * focused field with no arm, only reachable from a stale-deployed command, throws at runtime.
+   *
+   * @param arms - One handler per autocompletable field, keyed by field name.
+   * @returns The result of the arm that ran.
+   */
+  protected match<Ret>(arms: FocusedArms<Route, Ret>): Promise<Ret>;
+  /** Send autocomplete suggestions, callback type 8. Prefer {@link match}, which restricts each field's choices to its declared type. */
+  protected respond(choices: readonly APIApplicationCommandOptionChoice[]): Promise<void>;
+  /** The firing command route, for a field whose completion differs per registered command. */
+  protected get route(): Route;
+  /**
+   * The already-entered options on this command, restricted to the kinds Discord resolves during autocomplete
+   * (string, integer, number, boolean) with every read nullable, since a sibling is partial while the user
+   * types the focused field. The focused field is on `this.focused`.
+   */
+  protected get options(): AutocompleteOptions<Route>;
+}
+//#endregion
+//#region src/reply/ReplySender.d.ts
+/** The interaction payload fields the sender writes its wire from. */
+interface InteractionRef {
+  readonly application_id: string;
+  readonly id: string;
+  readonly token: string;
+}
+/** The created message an http reply resolves to (the http `SentMessage` lens). */
+type SentMessage = APIMessage;
+/**
+ * Writes interaction responses over the Discord REST callback and webhook endpoints. Construction is
+ * internal to the repliable handler bases and the dispatcher.
+ */
+declare class ReplySender extends BaseReplySender<SentMessage> {
+  private readonly ref;
+  private readonly rest;
+  constructor(ref: InteractionRef, rest: REST, dispatch: DispatchContext, bus: Bus);
+  protected writeReply(response: ReplyResponse | string, opts?: SendOpts): Promise<SentMessage | undefined>;
+  protected writeDefer(opts?: DeferOpts): Promise<void>;
+  protected writeDeferUpdate(): Promise<void>;
+  protected writeUpdate(response: ReplyResponse | string): Promise<SentMessage | undefined>;
+  protected writeFollowUp(response: ReplyResponse | string, opts?: SendOpts): Promise<SentMessage>;
+  protected writeEditOriginal(response: ReplyResponse | string): Promise<SentMessage>;
+  protected writeEditTarget(targetId: string, response: ReplyResponse | string): Promise<SentMessage>;
+  protected writeDeleteOriginal(): Promise<void>;
+  protected writeDeleteTarget(targetId: string): Promise<void>;
+  protected writeModal(data: APIModalInteractionResponseCallbackData): Promise<void>;
+  private callback;
+  private editMessage;
+  private rawFiles;
+  private createdMessage;
+}
+//#endregion
+//#region src/handlers/interactionTypes.d.ts
+type ValidInteractionTypes = APIChatInputApplicationCommandInteraction | APIContextMenuInteraction | APIMessageComponentInteraction | APIModalSubmitInteraction | APIApplicationCommandAutocompleteInteraction;
+type Repliables = Exclude<ValidInteractionTypes, APIApplicationCommandAutocompleteInteraction>;
+//#endregion
+//#region src/handlers/RepliableHandler.d.ts
+/**
+ * Shared base the repliable HTTP interaction handlers extend.
+ *
+ * Not a public entry point. Extend {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
+ * {@link ContextMenuHandler}, or one of the select menu bases instead. This class binds the core
+ * reply base to the http sender.
+ *
+ * @typeParam Event - The repliable interaction type this handler processes
+ */
+declare abstract class RepliableHandler$1<Event extends Repliables> extends RepliableHandler<Event, Core, SentMessage, never, ReplySender> {
+  /** @internal */
+  getEvent(): Event;
+  protected buildSender(event: Event, core: Core, dispatch: DispatchContext): ReplySender;
+  /**
+   * Typed Discord REST API (`@discordjs/core/http-only`) over `core.rest`, one instance per core.
+   * The interaction callbacks on `api.interactions` bypass the reply surface. The
+   * `no-raw-interaction-acks` rule flags them in handler classes.
+   */
+  protected get api(): API;
+}
+//#endregion
+//#region src/handlers/interaction/InteractionHandler.d.ts
+/**
+ * Shared base the repliable interaction handlers extend.
+ *
+ * Not a public entry point. Extend {@link SlashHandler}, {@link ContextMenuHandler}, {@link ButtonHandler},
+ * {@link ModalHandler}, or one of the select menu bases instead. This class adds `showModal` on top
+ * of the reply members.
+ *
+ * @typeParam Event - The repliable interaction type this handler processes
+ */
+declare abstract class InteractionHandler<Event extends Repliables> extends RepliableHandler$1<Event> {
+  constructor(event: Event, core: Core, dispatch: DispatchContext);
+  /**
+   * Open a modal. Must be the initial response to this interaction. The modal kind rejects this call at
+   * compile time (Discord forbids a modal in response to a modal).
+   */
+  protected showModal(this: InteractionHandler<Exclude<Repliables, APIModalSubmitInteraction>>, modal: ModalLike): Promise<void>;
+}
+//#endregion
+//#region src/handlers/interaction/components/ComponentHandler.d.ts
+/**
+ * Shared base the customId-routed component handlers extend on the HTTP transport.
+ *
+ * Not a public entry point. Extend {@link ButtonHandler}, {@link ModalHandler}, or one of the select menu
+ * bases instead. This class defines the customId decode, the route matching, and the source-message
+ * verbs `update` and `deferUpdate`.
+ *
+ * @typeParam Event - The component or modal interaction type this handler processes
+ * @typeParam Defs - The customId route definitions registered on the concrete handler
+ */
+declare abstract class ComponentHandler<Event extends APIMessageComponentInteraction | APIModalSubmitInteraction, Defs extends readonly AnyCustomId[]> extends InteractionHandler<Event> implements HasComponentDefs<Defs> {
+  /** @internal */
+  readonly [ComponentDefsBrand]?: Defs;
+  /** Rewrite the source message this component interaction came from. */
+  protected update(response: ReplyResponse | string): Promise<SentMessage>;
+  /** Acknowledge the component without changing the source message. */
+  protected deferUpdate(): Promise<void>;
+  private decoded?;
+  private get route();
+  /**
+   * The decoded params of the single route this handler is registered for.
+   *
+   * Reading this decodes `this.event.data.custom_id` once (cached after the first read) and throws
+   * `StaleCustomId` or `InvalidCustomId` when the wire no longer matches the current shape, which the
+   * dispatcher boundary turns into a reply. On a handler registered for several routes this is
+   * `never`, so use {@link match} instead.
+   */
+  protected get params(): SingleParams<Defs>;
+  /**
+   * Run the arm for whichever route the component was minted from. Use this only when the handler is
+   * registered for several routes. A single-route handler reads `this.params` directly. On a multi-route
+   * handler `this.params` is `never`, so match is the only way to read the decoded params.
+   *
+   * Provide one arm per registered route, keyed by its prefix, and each arm receives that route's own
+   * decoded params. The arms cover every registered route prefix, checked at compile time, and a prefix
+   * unmatched at runtime throws `CustomIdMatchArmMissing`. Decoding runs before any arm, so a stale or
+   * corrupt wire throws before an arm body executes.
+   *
+   * @param arms - One callback per registered route, keyed by prefix.
+   * @returns The result of the arm that ran.
+   *
+   * @example
+   * ```ts
+   * \@ButtonRoute(Approve, Reject)
+   * class ReviewButtons extends ButtonHandler<[typeof Approve, typeof Reject]> {
+   *     async execute() {
+   *         await this.match({
+   *             approve: ({ userId }) => this.reply(`approved <@${userId}>`),
+   *             reject: ({ userId }) => this.reply(`rejected <@${userId}>`)
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret>(arms: MatchArms<Defs, Ret>): Promise<Ret>;
+}
+//#endregion
+//#region src/handlers/interaction/components/SelectMenuHandler.d.ts
+/** @internal */
+type SelectInteraction<Data> = APIMessageComponentSelectMenuInteraction & {
+  data: Data;
+};
+/**
+ * Shared base the select menu handlers extend on the HTTP transport.
+ *
+ * Not a public entry point. Extend {@link StringMenuHandler}, {@link UserMenuHandler},
+ * {@link RoleMenuHandler}, {@link ChannelMenuHandler}, or {@link MentionableMenuHandler} instead. This
+ * class defines the `values` getter those bases share.
+ *
+ * @typeParam Event - The select menu interaction type this handler processes
+ * @typeParam Defs - The customId route definitions registered on the concrete handler
+ */
+declare abstract class SelectMenuHandler<Event extends APIMessageComponentSelectMenuInteraction, Defs extends readonly AnyCustomId[]> extends ComponentHandler<Event, Defs> {
+  /** The values this select picked. On every kind but the string menu they are snowflake ids. */
+  protected get values(): string[];
+}
+/**
+ * Base class for a string select menu handler on the HTTP transport.
+ *
+ * Register the customId definitions with `@StringMenuRoute`, list the same ones in the generic, then read
+ * the chosen option values from `this.values`. Read `this.params` for a single route or `this.match` for
+ * several. Reply through the handler members, or rewrite the source message with `this.update`.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof TopicsId]`.
+ *
+ * @example
+ * ```ts
+ * \@StringMenuRoute(TopicsId)
+ * class Topics extends StringMenuHandler<[typeof TopicsId]> {
+ *     async execute() {
+ *         const { userId } = this.params;
+ *         await this.update(`<@${userId}> now follows ${this.values.join(', ')}`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class StringMenuHandler<Defs extends readonly AnyCustomId[]> extends SelectMenuHandler<SelectInteraction<APIMessageStringSelectInteractionData>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.StringMenu;
+}
+/**
+ * Base class for a user select menu handler on the HTTP transport.
+ *
+ * Beside `this.values` this handler declares `this.users` and `this.members`. Register the customId
+ * definitions with `@UserMenuRoute` and list the same ones in the generic.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
+ *
+ * @example
+ * ```ts
+ * \@UserMenuRoute(AssignId)
+ * class Assign extends UserMenuHandler<[typeof AssignId]> {
+ *     async execute() {
+ *         const { roleId } = this.params;
+ *         await this.reply(`assigning ${this.users.size} member(s) to <@&${roleId}>`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class UserMenuHandler<Defs extends readonly AnyCustomId[]> extends SelectMenuHandler<SelectInteraction<APIMessageUserSelectInteractionData>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.UserMenu;
+  /** The users this select picked. */
+  protected get users(): Collection<string, APIUser>;
+  /** The guild members behind the picked users. Discord resolves these only inside a guild. */
+  protected get members(): Collection<string, APIInteractionDataResolvedGuildMember>;
+}
+/**
+ * Base class for a role select menu handler on the HTTP transport.
+ *
+ * Beside `this.values` this handler declares `this.roles`. Register the customId definitions with
+ * `@RoleMenuRoute` and list the same ones in the generic.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof GrantId]`.
+ *
+ * @example
+ * ```ts
+ * \@RoleMenuRoute(GrantId)
+ * class Grant extends RoleMenuHandler<[typeof GrantId]> {
+ *     async execute() {
+ *         await this.update(`granting ${this.roles.size} role(s)`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class RoleMenuHandler<Defs extends readonly AnyCustomId[]> extends SelectMenuHandler<SelectInteraction<APIMessageRoleSelectInteractionData>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.RoleMenu;
+  /** The roles this select picked. */
+  protected get roles(): Collection<string, APIRole>;
+}
+/**
+ * Base class for a channel select menu handler on the HTTP transport.
+ *
+ * Beside `this.values` this handler declares `this.channels`. Register the customId definitions with
+ * `@ChannelMenuRoute` and list the same ones in the generic.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof LogTargetId]`.
+ *
+ * @example
+ * ```ts
+ * \@ChannelMenuRoute(LogTargetId)
+ * class LogTarget extends ChannelMenuHandler<[typeof LogTargetId]> {
+ *     async execute() {
+ *         await this.update(`logging to ${this.channels.size} channel(s)`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class ChannelMenuHandler<Defs extends readonly AnyCustomId[]> extends SelectMenuHandler<SelectInteraction<APIMessageChannelSelectInteractionData>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.ChannelMenu;
+  /** The channels this select picked. */
+  protected get channels(): Collection<string, APIInteractionDataResolvedChannel>;
+}
+/**
+ * Base class for a mentionable select menu handler on the HTTP transport.
+ *
+ * A mentionable menu accepts users and roles together. `this.users`, `this.members`, and `this.roles`
+ * can each come back empty.
+ *
+ * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof InviteId]`.
+ *
+ * @example
+ * ```ts
+ * \@MentionableMenuRoute(InviteId)
+ * class Invite extends MentionableMenuHandler<[typeof InviteId]> {
+ *     async execute() {
+ *         await this.update(`inviting ${this.users.size} user(s) and ${this.roles.size} role(s)`);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class MentionableMenuHandler<Defs extends readonly AnyCustomId[]> extends SelectMenuHandler<SelectInteraction<APIMessageMentionableSelectInteractionData>, Defs> {
+  /** @internal */
+  readonly [ComponentKindBrand]?: InteractionKind.MentionableMenu;
+  /** The users this select picked. */
+  protected get users(): Collection<string, APIUser>;
+  /** The guild members behind the picked users. Discord resolves these only inside a guild. */
+  protected get members(): Collection<string, APIInteractionDataResolvedGuildMember>;
+  /** The roles this select picked. */
+  protected get roles(): Collection<string, APIRole>;
+}
+//#endregion
+//#region src/handlers/interaction/middlewareKinds.d.ts
+interface Payloads {
+  [InteractionKind.Slash]: APIChatInputApplicationCommandInteraction;
+  [InteractionKind.Button]: APIMessageComponentButtonInteraction;
+  [InteractionKind.Modal]: APIModalSubmitInteraction;
+  [InteractionKind.StringMenu]: SelectInteraction<APIMessageStringSelectInteractionData>;
+  [InteractionKind.UserMenu]: SelectInteraction<APIMessageUserSelectInteractionData>;
+  [InteractionKind.RoleMenu]: SelectInteraction<APIMessageRoleSelectInteractionData>;
+  [InteractionKind.ChannelMenu]: SelectInteraction<APIMessageChannelSelectInteractionData>;
+  [InteractionKind.MentionableMenu]: SelectInteraction<APIMessageMentionableSelectInteractionData>;
+  [InteractionKind.MessageContextMenu]: APIMessageApplicationCommandInteraction;
+  [InteractionKind.UserContextMenu]: APIUserApplicationCommandInteraction;
+}
+type InteractionForKind = { [Kind in MiddlewareKind]: Payloads[Kind]; };
+/** @internal */
+type InteractionOf<Kind extends MiddlewareKind> = InteractionForKind[Kind];
+//#endregion
+//#region src/handlers/interaction/InteractionMiddleware.d.ts
+/**
+ * Base class for interaction middleware on the HTTP transport.
+ *
+ * Middleware runs after the dispatcher builds the handler and before the gates, over the handler's own
+ * reply surface. Name the kinds in the generic and list the same ones in `{ kinds }`. Several kinds give
+ * `this.event` a union. Narrow it on `type` and `data.component_type`. A catchall reads every repliable
+ * kind.
+ *
+ * @typeParam Kind - One or more {@link InteractionKind} members. Defaults to every repliable kind.
+ *
+ * @example
+ * ```ts
+ * \@RegisterInteractionMiddleware({ kinds: [InteractionKind.Button] })
+ * class Audit extends InteractionMiddleware<InteractionKind.Button> {
+ *     async execute() {
+ *         this.logger.info(this.event.data.custom_id);
+ *     }
+ * }
+ * ```
+ */
+declare abstract class InteractionMiddleware<in out Kind extends MiddlewareKind = MiddlewareKind> extends RepliableHandler$1<InteractionOf<Kind>> {
+  /** @internal */
+  readonly [MiddlewareKindsBrand]?: Kind;
+  constructor(event: InteractionOf<Kind>, core: Core, dispatch: DispatchContext, sender: ReplySender);
+  /**
+   * Runs once the handler settles, newest middleware first. A refusal or a throw still reaches it,
+   * since seedcord calls it on every middleware whose `execute()` started. Implement it to release
+   * something this middleware took in `execute()`, such as a lock or an open span. A throw in here
+   * is logged and goes no further.
+   *
+   * @param result - How the dispatch ended. Either failure state carries the thrown value on `caught`.
+   *
+   * @example
+   * ```ts
+   * // the base declares it. an implementation carries `override`.
+   * override async after(result: DispatchResult) {
+   *     this.lock.release();
+   * }
+   * ```
+   */
+  after?(result: DispatchResult): Promise<void>;
+}
+//#endregion
+//#region src/handlers/constructors.d.ts
+type AnyHandler = BaseHandler<unknown, Core> & {
+  readonly [MiddlewareKindsBrand]?: undefined;
+};
+/** @internal Typed parameters would exclude every handler that narrows `event`. */
+type HandlerConstructor = Constructor<AnyHandler, never[]>;
+/** @internal */
+type InteractionMiddlewareConstructor = TypedConstructor<typeof InteractionMiddleware>;
+//#endregion
+//#region src/manifest/Manifest.d.ts
+/**
+ * The classes a bundled isolate registers at startup, standing in for the filesystem scan an isolate
+ * cannot run. `seedcord build` emits it for an edge bot. A hand-mounted host writes it.
+ */
+interface Manifest {
+  readonly handlers: readonly HandlerConstructor[];
+  readonly middleware: readonly InteractionMiddlewareConstructor[];
+  readonly subscribers: readonly StoredSubscriberCtor[];
+}
+//#endregion
+export { Core as _, RoleMenuHandler as a, HttpServerConfig as b, UserMenuHandler as c, RepliableHandler$1 as d, Repliables as f, AutocompleteHandler as g, SentMessage as h, MentionableMenuHandler as i, ComponentHandler as l, ReplySender as m, InteractionMiddleware as n, SelectMenuHandler as o, InteractionRef as p, ChannelMenuHandler as r, StringMenuHandler as s, Manifest as t, InteractionHandler as u, HttpConfig as v, HttpEdgeConfig as y };
+//# sourceMappingURL=Manifest-D61MNdcV.d.mts.map