@seedcord/core 0.3.0 → 0.4.0

package/dist/{Plugin-B6iRzm3g.d.mts → phases-F8yvPd60.d.mts}

@@ -1,8 +1,9 @@
 import { Logger } from "@seedcord/logger";
+import { APIApplicationCommand } from "discord-api-types/v10";
 import { TypedEventEmitter } from "@seedcord/event-emitter";
 import { REST } from "@discordjs/rest";
-import { Config, EventFrequency, FrameworkChannel, HmrAware, HmrUpdateEvent, IRateLimiter, RenderContext, ReplyResponse, Tail, TypedExclude } from "@seedcord/types";
 import { UUID } from "node:crypto";
+import { Config, EventFrequency, IRateLimiter, RenderContext, ReplyResponse, TypedExclude } from "@seedcord/types";
 //#region src/metadataKeys.d.ts
 declare enum InteractionRoutes {
   Slash = "slash",
@@ -30,6 +31,13 @@ declare const WebhookUrlMetadataKey: unique symbol;
 /** @internal PublishableKey excludes this key so publish() never emits it externally. */
 declare const PublishDefault: unique symbol;
 //#endregion
+//#region src/subscribers/slots.d.ts
+declare const RegisterDefaults: unique symbol;
+declare const VerifyWebhooks: unique symbol;
+declare const RegisteredCount: unique symbol;
+declare const RegisterSubscriber: unique symbol;
+declare const UnregisterSubscriber: unique symbol;
+//#endregion
 //#region src/reply/AckTrace.d.ts
 declare class AckTrace extends Error {
   constructor(method: ReplyMethod);
@@ -103,8 +111,9 @@ declare abstract class Notice extends Error {
    */
   ephemeral: boolean;
   /**
-   * A short one-line reason. When every arm of an `or` gate refuses and each refusal sets this, `or`
-   * lists them as the reply.
+   * A short one-line reason. When every arm of an {@link or} gate refuses and each one sets this, `or`
+   * throws a refusal listing them under `You need to meet at least one of these:`. Write a verb phrase that
+   * finishes that line, for example, "be the bot owner".
    */
   summary?: string;
   protected constructor(message: string, options?: ErrorOptions);
@@ -122,8 +131,6 @@ declare abstract class Notice extends Error {
  * `Fault`, is `failed`, as is any other throw.
  */
 type DispatchOutcome = 'handled' | 'refused' | 'failed';
-/** Whether a write through the reply surface reached Discord. */
-type ResponseOutcome = 'sent' | 'failed';
 /**
  * Where a reported fault came from.
  */
@@ -132,36 +139,69 @@ type FaultSource = InteractionFaultSource | EventFaultSource;
  * A fault that came from a discord interaction, JSON-safe for a webhook payload.
  */
 interface InteractionFaultSource {
-  kind: 'interaction';
-  interactionKind: 'slash' | 'context-menu' | 'button' | 'select' | 'modal';
+  readonly kind: 'interaction';
+  readonly interactionKind: 'slash' | 'context-menu' | 'button' | 'select' | 'modal';
   /** Slash or context-menu command name, null for component and modal interactions. */
-  command: string | null;
+  readonly command: string | null;
   /** Component or modal customId, null for slash and context-menu interactions. */
-  customId: string | null;
-  userId: string;
+  readonly customId: string | null;
+  readonly userId: string;
   /** Guild the interaction came from, null in DMs. */
-  guildId: string | null;
+  readonly guildId: string | null;
   /** Channel the interaction came from, null when unavailable. */
-  channelId: string | null;
-  interactionId: string;
+  readonly channelId: string | null;
+  readonly interactionId: string;
   /** The raw interaction, made JSON-safe at serialization with filterCirculars. */
-  raw: unknown;
+  readonly raw: unknown;
 }
 /**
  * A fault that came from a client event, JSON-safe for a webhook payload. The actor, guild, and channel
  * are best-effort, derived from the event args. Each is nullable. The raw args carry the full detail.
  */
 interface EventFaultSource {
-  kind: 'event';
-  eventName: string;
-  handler: string;
-  userId: string | null;
+  readonly kind: 'event';
+  readonly eventName: string;
+  readonly handler: string;
+  readonly userId: string | null;
   /** Null outside a guild. */
-  guildId: string | null;
-  channelId: string | null;
+  readonly guildId: string | null;
+  readonly channelId: string | null;
   /** The raw event args, made JSON-safe at serialization with filterCirculars. */
-  raw: unknown;
+  readonly raw: unknown;
+}
+/**
+ * The fields both `responseAttempted` arms carry.
+ */
+interface AttemptedWrite {
+  readonly routeId: string;
+  /** The interaction this write belongs to, for joining against `interactionDispatched`. */
+  readonly interactionId: string;
+  /** `send` routes to another verb, so it reports the verb that ran. */
+  readonly method: WriteMethod;
+  readonly durationMs: number;
+}
+/**
+ * A write Discord accepted.
+ */
+interface ResponseSent extends AttemptedWrite {
+  readonly outcome: 'sent';
+  /** Null for every ack-only and choice-only verb. */
+  readonly messageId: string | null;
 }
+/**
+ * A write that threw. A non-Error throw arrives wrapped, carrying the thrown value as its `cause`.
+ */
+interface ResponseFailed extends AttemptedWrite {
+  readonly outcome: 'failed';
+  readonly messageId: null;
+  readonly error: Error;
+}
+/**
+ * One write through the reply surface. Check `outcome` to reach `error`.
+ */
+type ResponseAttempt = ResponseSent | ResponseFailed;
+/** Whether a write through the reply surface reached Discord. */
+type ResponseOutcome = ResponseAttempt['outcome'];
 /**
  * The framework's own subscription keys. A transport adds a key whose payload type references a type
  * outside this package, through declaration merging on its own module.
@@ -171,69 +211,63 @@ interface EventFaultSource {
  */
 interface DefaultSubscriptions {
   /** Triggered when an unhandled exception (a raw non-Notice throw) occurs. */
-  unknownException: {
-    uuid: UUID;
-    error: Error;
+  readonly unknownException: {
+    readonly uuid: UUID;
+    readonly error: Error;
     /** Where the throw came from, `slash:ban` for an interaction and `event:name:handler` for an event. */
-    routeId: string;
-    guild?: {
-      id: string;
-      name: string;
+    readonly routeId: string;
+    readonly guild?: {
+      readonly id: string;
+      readonly name: string;
     } | undefined;
-    user?: {
-      id: string;
-      username: string;
+    readonly user?: {
+      readonly id: string;
+      readonly username: string;
     } | undefined;
-    metadata?: unknown;
+    readonly metadata?: unknown;
   };
   /** Triggered when a reported Notice (`report: true`) is caught. */
-  handledException: {
-    denial: Notice;
-    uuid: UUID;
+  readonly handledException: {
+    readonly denial: Notice;
+    readonly uuid: UUID;
     /** The same id `interactionDispatched` publishes. An event reads `event:name:handler`. */
-    routeId: string;
-    source: FaultSource;
+    readonly routeId: string;
+    readonly source: FaultSource;
   };
   /** Triggered when an interaction dispatch throws past the fault boundary. */
-  unhandledInteractionError: {
-    error: Error;
+  readonly unhandledInteractionError: {
+    readonly error: Error;
   };
   /** Triggered once per interaction dispatch, after the handler chain settles. */
-  interactionDispatched: {
-    routeId: string;
+  readonly interactionDispatched: {
+    readonly routeId: string;
     /** The interaction this dispatch ran, for joining against `responseAttempted`. */
-    interactionId: string;
-    kind: `${InteractionRoutes}`;
-    outcome: DispatchOutcome;
+    readonly interactionId: string;
+    readonly kind: `${InteractionRoutes}`;
+    readonly outcome: DispatchOutcome;
     /** True when no route matched and the unhandled default ran. */
-    fallback: boolean;
+    readonly fallback: boolean;
     /** Dispatch entry until the user has a response, replies included. A clock change never affects it. */
-    durationMs: number;
+    readonly durationMs: number;
     /**
      * Discord's interaction creation until dispatch entry, read from the snowflake. This covers
      * network transit plus any time your bot was busy before starting. A rise points at either
      * Discord or your own backlog. It subtracts a Discord timestamp from the host clock, so a host
      * running behind Discord reports a negative value.
      */
-    queuedMs: number;
+    readonly queuedMs: number;
   };
   /**
    * Triggered on every write through the reply surface, several times per interaction. A write that
    * throws reports here too, with `outcome` `failed`. A write that reaches Discord and then returns an
    * unexpected shape publishes nothing, since the callback succeeded and carries no message to name.
    */
-  responseAttempted: {
-    routeId: string;
-    /** The interaction this write belongs to, for joining against `interactionDispatched`. */
-    interactionId: string;
-    /** `send` routes to another verb, so it reports the verb that ran. */
-    method: WriteMethod;
-    outcome: ResponseOutcome;
-    durationMs: number;
-    /** Null for every ack-only or choice-only verb, and for a failed write. */
-    messageId: string | null;
-    /** Present when `outcome` is `failed`. */
-    error?: Error;
+  readonly responseAttempted: ResponseAttempt;
+  /** Triggered after each command deploy, including the redeploy after a hot reload. */
+  readonly commandsDeployed: {
+    readonly global: readonly APIApplicationCommand[];
+    /** Keyed by guild id. */
+    readonly guilds: Readonly<Record<string, readonly APIApplicationCommand[]>>;
   };
 }
 /**
@@ -317,7 +351,7 @@ interface SubscriberRegistration {
   /** A server-host registration carries it from the start. A lazy one fills it on first resolve. */
   ctor?: StoredSubscriberCtor | undefined;
 }
-declare const loggerSlot$1: unique symbol;
+declare const loggerSlot: unique symbol;
 /**
  * Registers and dispatches subscribers. Subscribers run on a programmatic or framework publish.
  * Accessed via `core.bus`. Do not construct it directly.
@@ -326,21 +360,21 @@ declare class Bus extends TypedEventEmitter<SubscriptionTuples> {
   protected core: CoreBase;
   private readonly logger;
   /** @internal */
-  readonly [loggerSlot$1]: Logger;
+  readonly [loggerSlot]: Logger;
   private readonly subscribersMap;
   private readonly executedOnce;
   private readonly webhookProbes;
   constructor(core: CoreBase);
-  /** @internal the host calls this during startup, keeping the url validation inside `start()` where a failure can still release the singleton guard. */
-  registerDefaults(): void;
+  /** @internal keep this inside start(). a bad webhook url thrown outside it never resets the singleton guard */
+  [RegisterDefaults](): void;
   /** @internal */
-  register(registration: SubscriberRegistration): void;
+  [RegisterSubscriber](registration: SubscriberRegistration): void;
   /** @internal */
-  unregister(ctor: StoredSubscriberCtor, keys?: readonly SubscriptionKey[]): void;
+  [UnregisterSubscriber](ctor: StoredSubscriberCtor, keys?: readonly SubscriptionKey[]): void;
   /** @internal */
-  get registeredCount(): number;
-  /** @internal Only eagerly registered reporters are probed, which is every server-host one. */
-  verifyWebhooks(): Promise<void>;
+  get [RegisteredCount](): number;
+  /** @internal a lazy edge registration never probes. every server-host reporter registers eagerly */
+  [VerifyWebhooks](): Promise<void>;
   private probeWebhook;
   /**
    * Publishes an event to its subscribers and native listeners.
@@ -359,6 +393,11 @@ declare class Bus extends TypedEventEmitter<SubscriptionTuples> {
    * @returns Whether the underlying emitter had native listeners for the event
    */
   publish<KeyOfSubscribers extends PublishableKey>(event: KeyOfSubscribers, data: AllSubscriptions[KeyOfSubscribers]): boolean;
+  /**
+   * @deprecated Always throws. Call {@link Bus.publish} to reach subscribers and listeners together.
+   * @throws A **SeedcordTypeError** with `CoreBusEmitUnavailable`. `emit` reaches only the `on()` listeners.
+   */
+  emit<KeyOfSubscribers extends SubscriptionKey>(event: KeyOfSubscribers, ..._args: SubscriptionTuples[KeyOfSubscribers]): never;
   /** @internal the framework's own publish path, keyed by a symbol no public entry exports */
   [PublishDefault]<KeyOfSubscribers extends keyof DefaultSubscriptions>(event: KeyOfSubscribers, data: AllSubscriptions[KeyOfSubscribers]): boolean;
   private dispatchKey;
@@ -383,16 +422,14 @@ interface CoreBase {
    * until the Login phase. On http the token is set by `start()`.
    */
   readonly rest: REST;
+  /** The bot's Discord application id. Throws if you read it before the host resolves it. */
+  readonly applicationId: string;
   /** Sliding-window rate limiting, the `Cooldown` gate's backend and a public direct-use API. */
   readonly rateLimiter: IRateLimiter;
   /** Publish and subscribe to framework and application events. */
   readonly bus: Bus;
 }
 //#endregion
-//#region src/plugin/brands.d.ts
-declare const TransportBrand: unique symbol;
-declare const RuntimeBrand: unique symbol;
-//#endregion
 //#region src/lifecycle/phases.d.ts
 /**
  * Startup phases, in run order.
@@ -419,138 +456,5 @@ declare enum ShutdownPhase {
   Logout = 4
 }
 //#endregion
-//#region src/plugin/lifecycle.d.ts
-/**
- * The lifecycle a plugin declares through `super(host, spec)`. Unset fields resolve to the base
- * defaults. `ready` runs at a fixed `StartupPhase.Ready`.
- */
-interface PluginLifecycleSpec {
-  init?: {
-    phase?: StartupPhase;
-    timeout?: number;
-  };
-  ready?: {
-    timeout?: number;
-  };
-  dispose?: {
-    phase?: ShutdownPhase;
-    timeout?: number;
-  };
-}
-/** @internal */
-interface ResolvedPluginLifecycleSpec {
-  readonly init: {
-    readonly phase: StartupPhase;
-    readonly timeout: number;
-  };
-  readonly ready: {
-    readonly timeout: number;
-  };
-  readonly dispose: {
-    readonly phase: ShutdownPhase;
-    readonly timeout: number;
-  };
-}
-//#endregion
-//#region src/plugin/options.d.ts
-/** The options a plugin declares as its `Plugin<Opts>` type argument. */
-interface PluginOptions {
-  /**
-   * Which transport the plugin runs on. `'any'` attaches to either one.
-   * @defaultValue 'any'
-   */
-  transport?: 'gateway' | 'http' | 'any';
-  /**
-   * Which runtime the plugin runs on. `'any'` attaches to either one.
-   * @defaultValue 'any'
-   */
-  runtime?: 'server' | 'edge' | 'any';
-}
-/** @internal */
-type TransportOf<Opts extends PluginOptions> = undefined extends Opts['transport'] ? 'any' : NonNullable<Opts['transport']>;
-/** @internal */
-type RuntimeOf<Opts extends PluginOptions> = undefined extends Opts['runtime'] ? 'any' : NonNullable<Opts['runtime']>;
-/** @internal */
-type Transport = TypedExclude<NonNullable<PluginOptions['transport']>, 'any'>;
-/** @internal */
-type Runtime = TypedExclude<NonNullable<PluginOptions['runtime']>, 'any'>;
-type TransportMismatch<PluginT extends string, BotT extends string> = Record<`this plugin declares transport '${PluginT}' but this bot runs '${BotT}'`, never>;
-type RuntimeMismatch<PluginRt extends string, BotRt extends string> = Record<`this plugin declares runtime '${PluginRt}' but this bot runs '${BotRt}'`, never>;
-type EdgePluginsUnsupported = Record<'an edge bot takes no plugins until edge support ships after v1', never>;
-/** @internal */
-type ChannelKeyAssert<Key extends string> = Key extends FrameworkChannel ? `'${Key}' is a channel the framework logs on. Pick another plugin key.` : Key;
-type BrandTransport<Plug> = Plug extends {
-  readonly [TransportBrand]?: infer T extends string;
-} ? T : 'any';
-type BrandRuntime<Plug> = Plug extends {
-  readonly [RuntimeBrand]?: infer R extends string;
-} ? R : 'any';
-/** @internal */
-type TransportAssert<Plug, BotT extends Transport> = BrandTransport<Plug> extends 'any' | BotT ? unknown : TransportMismatch<BrandTransport<Plug>, BotT>;
-/** @internal */
-type RuntimeAssert<Plug, BotRt extends Runtime> = 'edge' extends BotRt ? EdgePluginsUnsupported : BrandRuntime<Plug> extends 'any' | BotRt ? unknown : RuntimeMismatch<BrandRuntime<Plug>, BotRt>;
-//#endregion
-//#region src/plugin/Plugin.d.ts
-interface Initializeable {
-  init(): Promise<void>;
-}
-/** @internal */
-declare const resolvedSpecSlot: unique symbol;
-/** @internal */
-declare const loggerSlot: unique symbol;
-/**
- * Base class for Seedcord plugins. A subclass declares its options as the `Opts` type argument,
- * implements `init()`, and reads the framework surface through `this.core`.
- *
- * @typeParam Opts - The plugin's declared {@link PluginOptions}.
- * @typeParam TCore - The host type `this.core` resolves to. Each transport binds it to its own `Core`.
- */
-declare abstract class Plugin<Opts extends PluginOptions = {}, TCore extends CoreBase = CoreBase> implements Initializeable, HmrAware {
-  private readonly host;
-  /** @internal */
-  readonly [TransportBrand]?: TransportOf<Opts>;
-  /** @internal */
-  readonly [RuntimeBrand]?: RuntimeOf<Opts>;
-  /** @internal */
-  readonly [resolvedSpecSlot]: ResolvedPluginLifecycleSpec;
-  /** @internal */
-  readonly [loggerSlot]: Logger;
-  /** Logs under the plugin's class name, on the channel its attach key sets. */
-  protected readonly logger: Logger;
-  constructor(host: CoreBase, spec?: PluginLifecycleSpec);
-  /** The host, typed to the transport whose `Plugin` base this class extends. */
-  protected get core(): TCore;
-  abstract init(): Promise<void>;
-  /**
-   * Runs in the startup Ready phase, after `init()`. The gateway client is logged in by this phase,
-   * and the http host binds its server in the same phase.
-   */
-  ready?(): Promise<void>;
-  /** Runs during teardown, only when `init()` resolved. */
-  dispose?(): Promise<void>;
-  /**
-   * Throws a `SeedcordError` that contains the plugin class name and the reason.
-   *
-   * @param reason - Why the options are invalid.
-   */
-  protected rejectOptions(reason: string): never;
-  /** Override to reload plugin state on an HMR update. */
-  onHmr(_event: HmrUpdateEvent): Promise<void>;
-  /**
-   * Registers critical file patterns that should trigger a full restart when changed in Dev HMR.
-   * @param patterns - Glob patterns relative to the project root
-   */
-  protected registerCriticalFiles(patterns: string[]): void;
-}
-/** @internal */
-type PluginLike = Pick<Plugin, 'init' | 'ready' | 'dispose' | 'onHmr' | typeof resolvedSpecSlot | typeof loggerSlot>;
-/** @internal */
-type PluginCtor<TPlugin extends PluginLike = PluginLike> = new (...args: any[]) => TPlugin;
-/** @internal */
-type PluginArgs<Ctor extends PluginCtor> = Tail<ConstructorParameters<Ctor>>;
-type CoreParamTooNarrow = Record<'this plugin constructor must take CoreBase as its first parameter and read the transport Core off this.core', never>;
-/** @internal */
-type CoreParamAssert<Ctor extends PluginCtor> = CoreBase extends ConstructorParameters<Ctor>[0] ? unknown : CoreParamTooNarrow;
-//#endregion
-export { reportedWrite as A, InteractionMetadataKey as B, DispatchOutcome as C, Subscriptions as D, SubscriptionKey as E, AckTrace as F, WebhookUrlMetadataKey as G, InteractionRoutes as H, PublishDefault as I, CommandMetadataKey as L, ReplyMethod as M, checkAckLegality as N, Notice as O, sendTarget as P, EventMetadataKey as R, DefaultSubscriptions as S, SubscriptionData as T, MiddlewareMetadataKey as U, InteractionRouteKeys as V, SubscribeMetadataKey as W, Bus as _, PluginCtor as a, busLoggerOf as b, PluginOptions as c, Transport as d, TransportAssert as f, CoreBase as g, StartupPhase as h, PluginArgs as i, AckState as j, ReplyTelemetry as k, Runtime as l, ShutdownPhase as m, Initializeable as n, PluginLike as o, PluginLifecycleSpec as p, Plugin as r, ChannelKeyAssert as s, CoreParamAssert as t, RuntimeAssert as u, StoredSubscriberCtor as v, FaultSource as w, Subscriber as x, SubscriberRegistration as y, GatedMetadataKey as z };
-//# sourceMappingURL=Plugin-B6iRzm3g.d.mts.map
+export { RegisteredCount as A, MiddlewareMetadataKey as B, AckState as C, AckTrace as D, sendTarget as E, EventMetadataKey as F, WebhookUrlMetadataKey as H, GatedMetadataKey as I, InteractionMetadataKey as L, VerifyWebhooks as M, PublishDefault as N, RegisterDefaults as O, CommandMetadataKey as P, InteractionRouteKeys as R, reportedWrite as S, checkAckLegality as T, SubscribeMetadataKey as V, SubscriptionData as _, StoredSubscriberCtor as a, Notice as b, Subscriber as c, DispatchOutcome as d, FaultSource as f, ResponseSent as g, ResponseOutcome as h, Bus as i, UnregisterSubscriber as j, RegisterSubscriber as k, AttemptedWrite as l, ResponseFailed as m, StartupPhase as n, SubscriberRegistration as o, ResponseAttempt as p, CoreBase as r, busLoggerOf as s, ShutdownPhase as t, DefaultSubscriptions as u, SubscriptionKey as v, ReplyMethod as w, ReplyTelemetry as x, Subscriptions as y, InteractionRoutes as z };
+//# sourceMappingURL=phases-F8yvPd60.d.mts.map

package/dist/plugin.index.d.mts

@@ -1,3 +1,3 @@
-import { c as PluginOptions, n as Initializeable, p as PluginLifecycleSpec, r as Plugin } from "./Plugin-B6iRzm3g.mjs";
+import { c as PluginOptions, p as PluginLifecycleSpec, r as Plugin } from "./Plugin-CG9pWbPF.mjs";
 import { HmrAware, HmrUpdateEvent } from "@seedcord/types";
-export { type HmrAware, type HmrUpdateEvent, type Initializeable, Plugin, type PluginLifecycleSpec, type PluginOptions };
+export { type HmrAware, type HmrUpdateEvent, Plugin, type PluginLifecycleSpec, type PluginOptions };

package/dist/plugin.index.mjs

@@ -1,3 +1,3 @@
-import { t as Plugin } from "./Plugin-Bkeqcjy6.mjs";
+import { t as Plugin } from "./Plugin-C6oMqWf8.mjs";
 
 export { Plugin };

package/dist/publishDefault-D826XXDQ.mjs

@@ -0,0 +1,14 @@
+//#region src/stops/asError.ts
+/** @internal */
+function asError(caught) {
+	return Error.isError(caught) ? caught : new Error(String(caught), { cause: caught });
+}
+
+//#endregion
+//#region src/subscribers/publishDefault.ts
+/** @internal PublishableKey excludes this key so publish() never emits it externally. */
+const PublishDefault = Symbol("seedcord.publishDefault");
+
+//#endregion
+export { asError as n, PublishDefault as t };
+//# sourceMappingURL=publishDefault-D826XXDQ.mjs.map

package/dist/publishDefault-D826XXDQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"publishDefault-D826XXDQ.mjs","names":[],"sources":["../src/stops/asError.ts","../src/subscribers/publishDefault.ts"],"sourcesContent":["// dropping a non-Error throw would leave the user with no fault card, and every report payload declares an Error\n/** @internal */\nexport function asError(caught: unknown): Error {\n    return Error.isError(caught) ? caught : new Error(String(caught), { cause: caught });\n}\n","/** @internal PublishableKey excludes this key so publish() never emits it externally. */\nexport const PublishDefault = Symbol('seedcord.publishDefault');\n"],"mappings":";;AAEA,SAAgB,QAAQ,QAAwB;CAC5C,OAAO,MAAM,QAAQ,MAAM,IAAI,SAAS,IAAI,MAAM,OAAO,MAAM,GAAG,EAAE,OAAO,OAAO,CAAC;AACvF;;;;;ACHA,MAAa,iBAAiB,OAAO,yBAAyB"}

package/dist/{slashRouteLeaves-De1SxqnX.mjs → slashRouteLeaves-CbYRwqMY.mjs}

@@ -1,6 +1,14 @@
+import { b as CommandMetadataKey, v as isBuilderComponentClass } from "./Bus-BVwmKc-A.mjs";
 import { SlashCommandBuilder } from "@discordjs/builders";
 import { routeLeavesOf } from "@seedcord/utils/internal";
 
+//#region src/commands/isCommandClass.ts
+/** @internal */
+function isCommandClass(value) {
+	return isBuilderComponentClass(value) && Reflect.hasMetadata(CommandMetadataKey, value);
+}
+
+//#endregion
 //#region src/commands/slashRouteLeaves.ts
 /**
 * dedupes route keys since the same builder appears once per guild.
@@ -19,5 +27,5 @@ function slashRouteLeaves(commands) {
 }
 
 //#endregion
-export { slashRouteLeaves as t };
-//# sourceMappingURL=slashRouteLeaves-De1SxqnX.mjs.map
+export { isCommandClass as n, slashRouteLeaves as t };
+//# sourceMappingURL=slashRouteLeaves-CbYRwqMY.mjs.map

package/dist/slashRouteLeaves-CbYRwqMY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"slashRouteLeaves-CbYRwqMY.mjs","names":[],"sources":["../src/commands/isCommandClass.ts","../src/commands/slashRouteLeaves.ts"],"sourcesContent":["import { isBuilderComponentClass } from '#components/Component';\nimport { CommandMetadataKey } from '#src/metadataKeys';\n\nimport type { BuilderComponent } from '#components/Component';\n\n/** @internal */\nexport type CommandCtor = new () => BuilderComponent<'command' | 'context_menu'>;\n\n// the cli's codegen scan reads this too\n/** @internal */\nexport function isCommandClass(value: unknown): value is CommandCtor {\n    return isBuilderComponentClass(value) && Reflect.hasMetadata(CommandMetadataKey, value);\n}\n","import { SlashCommandBuilder } from '@discordjs/builders';\nimport { routeLeavesOf } from '@seedcord/utils/internal';\n\nimport type { ContextMenuCommandBuilder } from '@discordjs/builders';\n\n/**\n * dedupes route keys since the same builder appears once per guild.\n * these come from the same {@link routeLeavesOf} that `seedcord codegen` reads, so the boot-time\n * check compares against the generated registry's keys.\n *\n * @internal\n */\nexport function slashRouteLeaves(commands: Iterable<SlashCommandBuilder | ContextMenuCommandBuilder>): Set<string> {\n    const leaves = new Set<string>();\n    for (const command of commands) {\n        if (!(command instanceof SlashCommandBuilder)) continue;\n        for (const leaf of routeLeavesOf(command.toJSON())) leaves.add(leaf.route);\n    }\n    return leaves;\n}\n"],"mappings":";;;;;;AAUA,SAAgB,eAAe,OAAsC;CACjE,OAAO,wBAAwB,KAAK,KAAK,QAAQ,YAAY,oBAAoB,KAAK;AAC1F;;;;;;;;;;;ACAA,SAAgB,iBAAiB,UAAkF;CAC/G,MAAM,yBAAS,IAAI,IAAY;CAC/B,KAAK,MAAM,WAAW,UAAU;EAC5B,IAAI,EAAE,mBAAmB,sBAAsB;EAC/C,KAAK,MAAM,QAAQ,cAAc,QAAQ,OAAO,CAAC,GAAG,OAAO,IAAI,KAAK,KAAK;CAC7E;CACA,OAAO;AACX"}

package/dist/subscribers-CGGQkUfM.mjs

@@ -0,0 +1,139 @@
+import { A as clearStore, M as contextMenuLeaves, j as guardedAccessor, k as accessorStore } from "./Bus-BVwmKc-A.mjs";
+import { SlashCommandBuilder } from "@discordjs/builders";
+import { paint } from "@seedcord/errors";
+import { Logger } from "@seedcord/logger";
+import { routeLeavesOf } from "@seedcord/utils/internal";
+import { ApplicationCommandType } from "discord-api-types/v10";
+
+//#region src/commands/CommandInjector.ts
+const commandStorage = accessorStore();
+const userMenuStorage = accessorStore();
+const messageMenuStorage = accessorStore();
+/**
+* The bot's deployed slash commands, keyed by {@link SlashRegistry}. Filled by
+* {@link CommandInjector} after each deploy, and a read before that throws.
+*
+* @example
+* ```ts
+* import { Commands } from '@seedcord/gateway';
+*
+* await this.reply(`Try ${Commands['config/set'].mention}`);
+*
+* // a help listing
+* const lines = Object.values(Commands).map((c) => `${c.mention} ${c.description}`);
+* ```
+*/
+const Commands = guardedAccessor("Commands", commandStorage);
+/**
+* The bot's deployed context-menu commands. Filled by {@link CommandInjector} after each deploy, and a read
+* before that throws.
+*
+* @example
+* ```ts
+* import { ContextMenus } from '@seedcord/gateway';
+*
+* const id = ContextMenus.user['View Profile'].id;
+* ```
+*/
+const ContextMenus = {
+	user: guardedAccessor("ContextMenus.user", userMenuStorage),
+	message: guardedAccessor("ContextMenus.message", messageMenuStorage)
+};
+const MULTI_GUILD = Symbol("seedcord:commands:multi-guild");
+function commandKey(type, name) {
+	return `${type}:${name}`;
+}
+function slashBuildersOf(all) {
+	const slash = all.filter((command) => command instanceof SlashCommandBuilder);
+	return [...new Set(slash)];
+}
+/** @internal */
+var CommandInjector = class {
+	logger = new Logger("Commands", { channel: "bot" });
+	inject(deploy, all) {
+		this.clear();
+		const ids = {
+			global: this.indexByKey(deploy.global),
+			guild: this.indexGuilds(deploy.guilds),
+			warned: /* @__PURE__ */ new Set()
+		};
+		let clickable = 0;
+		for (const command of slashBuildersOf(all)) {
+			const id = this.resolveId(ApplicationCommandType.ChatInput, command.name, ids, "falling back to plain text (not clickable)");
+			for (const leaf of routeLeavesOf(command.toJSON())) {
+				commandStorage[leaf.route] = {
+					mention: id ? this.toMention(leaf.route, id) : this.toPlain(leaf.route),
+					...id && { id },
+					route: leaf.route,
+					description: leaf.description
+				};
+				if (id) clickable++;
+			}
+		}
+		const menus = contextMenuLeaves(all);
+		this.injectMenus(menus.user, ApplicationCommandType.User, userMenuStorage, ids);
+		this.injectMenus(menus.message, ApplicationCommandType.Message, messageMenuStorage, ids);
+		this.logger.utils.summary("Linked commands", {
+			clickable,
+			plain: Object.keys(commandStorage).length - clickable,
+			"context menus": menus.user.size + menus.message.size
+		});
+	}
+	injectMenus(names, kind, storage, ids) {
+		for (const name of names) {
+			const id = this.resolveId(kind, name, ids, "leaving its id unset");
+			storage[name] = {
+				...id && { id },
+				name,
+				kind
+			};
+		}
+	}
+	indexByKey(collection) {
+		const map = /* @__PURE__ */ new Map();
+		for (const command of collection.values()) map.set(commandKey(command.type, command.name), command.id);
+		return map;
+	}
+	indexGuilds(guilds) {
+		const map = /* @__PURE__ */ new Map();
+		for (const collection of guilds.values()) for (const command of collection.values()) {
+			const key = commandKey(command.type, command.name);
+			const existing = map.get(key);
+			if (existing === void 0) map.set(key, command.id);
+			else if (existing !== command.id) map.set(key, MULTI_GUILD);
+		}
+		return map;
+	}
+	resolveId(type, name, ids, consequence) {
+		const key = commandKey(type, name);
+		const global = ids.global.get(key);
+		if (global) return global;
+		const guild = ids.guild.get(key);
+		if (guild === void 0) return void 0;
+		if (guild === MULTI_GUILD) {
+			if (!ids.warned.has(key)) {
+				this.logger.warn(`${paint.sky.bold(name)} is deployed to multiple guilds, ${consequence}.`);
+				ids.warned.add(key);
+			}
+			return;
+		}
+		return guild;
+	}
+	toMention(route, id) {
+		return `</${route.replaceAll("/", " ")}:${id}>`;
+	}
+	toPlain(route) {
+		return `/${route.replaceAll("/", " ")}`;
+	}
+	clear() {
+		for (const store of [
+			commandStorage,
+			userMenuStorage,
+			messageMenuStorage
+		]) clearStore(store);
+	}
+};
+
+//#endregion
+export { Commands as n, ContextMenus as r, CommandInjector as t };
+//# sourceMappingURL=subscribers-CGGQkUfM.mjs.map