nubis 0.0.0 → 0.1.0-next.0

package/dist/node.js

@@ -0,0 +1,592 @@
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// src/loader.ts
+import { readdir, stat } from "node:fs/promises";
+import { extname, join, relative, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+  buildCommandTree,
+  createComponentRegistry,
+  createEventRegistry,
+  NubisError
+} from "@nubisjs/core";
+async function listModules(dir, extensions) {
+  let names;
+  try {
+    names = await readdir(dir);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+  const files = [];
+  for (const name of names.sort()) {
+    const path = join(dir, name);
+    if ((await stat(path)).isDirectory()) {
+      files.push(...await listModules(path, extensions));
+      continue;
+    }
+    const base = name.slice(0, name.length - extname(name).length);
+    if (!extensions.includes(extname(name)))
+      continue;
+    if (name.endsWith(".d.ts") || /\.(test|spec)$/.test(base))
+      continue;
+    if (base.startsWith("_") && base !== FOLDER_FILE)
+      continue;
+    files.push(path);
+  }
+  return files;
+}
+async function importModule(file, root, version) {
+  const url = pathToFileURL(file);
+  if (version !== undefined)
+    url.searchParams.set("v", String(version));
+  try {
+    return await import(url.href);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ERR_UNKNOWN_FILE_EXTENSION") {
+      throw new NubisError(`${relative(root, file)}: this runtime can't import ${extname(file)} files. Run the bot with Bun or Node 22.18+, or build it to JavaScript first.`);
+    }
+    throw error;
+  }
+}
+async function loadProject(root, options = {}) {
+  const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+  const load = (file) => importModule(file, root, options.version);
+  const where = (file) => relative(root, file);
+  const files = [];
+  const commandsDir = join(root, "commands");
+  const commandFiles = [];
+  const folders = [];
+  for (const file of await listModules(commandsDir, extensions)) {
+    files.push(where(file));
+    const module = await load(file);
+    const segments = segmentsOf(file, commandsDir);
+    if (segments.at(-1) === FOLDER_FILE) {
+      const settings = module.default;
+      if (!isObject(settings)) {
+        throw new NubisError(`${where(file)}: export the folder's settings as default, e.g. export default folder({ description: "..." }).`);
+      }
+      folders.push({ ...settings, path: segments.slice(0, -1) });
+      continue;
+    }
+    if (!isCommand(module.default)) {
+      throw new NubisError(`${where(file)}: export a command as default, e.g. export default command({ ... }). Helpers that aren't commands can live in files starting with "_".`);
+    }
+    commandFiles.push({ path: segments, definition: module.default });
+  }
+  const components = [];
+  for (const file of await listModules(join(root, "components"), extensions)) {
+    files.push(where(file));
+    const found = Object.values(await load(file)).filter(isComponent);
+    if (found.length === 0) {
+      throw new NubisError(`${where(file)}: no buttons, selects or modals are exported here.`);
+    }
+    for (const component of found) {
+      if (!components.includes(component))
+        components.push(component);
+    }
+  }
+  const menus = [];
+  for (const file of await listModules(join(root, "menus"), extensions)) {
+    files.push(where(file));
+    const menu = (await load(file)).default;
+    if (!isMenu(menu)) {
+      throw new NubisError(`${where(file)}: export a context menu command as default, e.g. export default userCommand({ ... }).`);
+    }
+    menus.push(menu);
+  }
+  const events = [];
+  for (const file of await listModules(join(root, "events"), extensions)) {
+    files.push(where(file));
+    const exported = (await load(file)).default;
+    const list = Array.isArray(exported) ? exported : [exported];
+    if (list.length === 0 || !list.every(isEvent)) {
+      throw new NubisError(`${where(file)}: export an event as default, e.g. export default event("guildMemberAdd", ...), or an array of them.`);
+    }
+    events.push(...list);
+  }
+  return {
+    root,
+    tree: buildCommandTree(commandFiles, folders),
+    components: createComponentRegistry(components),
+    menus,
+    events: createEventRegistry(events),
+    files
+  };
+}
+var DEFAULT_EXTENSIONS, FOLDER_FILE = "_folder", isObject = (value) => (typeof value === "object" || typeof value === "function") && value !== null, isCommand = (value) => isObject(value) && value.kind === "command", isComponent = (value) => isObject(value) && ("~nubis" in value), isMenu = (value) => isObject(value) && (value.kind === "user" || value.kind === "message") && ("config" in value), isEvent = (value) => isObject(value) && value.kind === "event", segmentsOf = (file, dir) => {
+  const path = relative(dir, file);
+  return path.slice(0, path.length - extname(path).length).split(sep);
+};
+var init_loader = __esm(() => {
+  DEFAULT_EXTENSIONS = [".ts", ".mts", ".js", ".mjs"];
+});
+
+// src/node-listener.ts
+function toNodeListener(handler) {
+  return (incoming, outgoing) => {
+    (async () => {
+      try {
+        const chunks = [];
+        for await (const chunk of incoming)
+          chunks.push(chunk);
+        const headers = new Headers;
+        for (const [name, value] of Object.entries(incoming.headers)) {
+          if (typeof value === "string")
+            headers.set(name, value);
+          else if (Array.isArray(value))
+            headers.set(name, value.join(", "));
+        }
+        const method = incoming.method ?? "GET";
+        const request = new Request(`http://${incoming.headers.host ?? "localhost"}${incoming.url ?? "/"}`, {
+          method,
+          headers,
+          body: method === "GET" || method === "HEAD" ? undefined : Buffer.concat(chunks)
+        });
+        const response = await handler(request);
+        outgoing.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+        outgoing.end(Buffer.from(await response.arrayBuffer()));
+      } catch (error) {
+        outgoing.writeHead(500, { "content-type": "text/plain" });
+        outgoing.end("Internal error");
+        console.error(error);
+      }
+    })();
+  };
+}
+
+// src/intents.ts
+import { GatewayIntentBits as I } from "discord-api-types/v10";
+function intentsFor(events, extra = 0) {
+  let intents = I.Guilds | extra;
+  for (const name of events.keys())
+    intents |= EVENT_INTENTS[name] ?? 0;
+  return intents;
+}
+function intentNames(intents) {
+  return Object.entries(I).filter(([name, bit]) => typeof bit === "number" && (intents & bit) === bit && name !== "GuildBans" && name !== "GuildEmojisAndStickers").map(([name]) => name);
+}
+var EVENT_INTENTS, PRIVILEGED_INTENTS;
+var init_intents = __esm(() => {
+  EVENT_INTENTS = {
+    guildMemberAdd: I.GuildMembers,
+    guildMemberUpdate: I.GuildMembers,
+    guildMemberRemove: I.GuildMembers,
+    guildBanAdd: I.GuildModeration,
+    guildBanRemove: I.GuildModeration,
+    guildAuditLogEntryCreate: I.GuildModeration,
+    guildEmojisUpdate: I.GuildExpressions,
+    guildStickersUpdate: I.GuildExpressions,
+    guildSoundboardSoundCreate: I.GuildExpressions,
+    guildSoundboardSoundUpdate: I.GuildExpressions,
+    guildSoundboardSoundDelete: I.GuildExpressions,
+    guildSoundboardSoundsUpdate: I.GuildExpressions,
+    guildIntegrationsUpdate: I.GuildIntegrations,
+    integrationCreate: I.GuildIntegrations,
+    integrationUpdate: I.GuildIntegrations,
+    integrationDelete: I.GuildIntegrations,
+    webhooksUpdate: I.GuildWebhooks,
+    inviteCreate: I.GuildInvites,
+    inviteDelete: I.GuildInvites,
+    voiceStateUpdate: I.GuildVoiceStates,
+    voiceChannelEffectSend: I.GuildVoiceStates,
+    presenceUpdate: I.GuildPresences,
+    messageCreate: I.GuildMessages | I.DirectMessages,
+    messageUpdate: I.GuildMessages | I.DirectMessages,
+    messageDelete: I.GuildMessages | I.DirectMessages,
+    messageDeleteBulk: I.GuildMessages,
+    messageReactionAdd: I.GuildMessageReactions | I.DirectMessageReactions,
+    messageReactionRemove: I.GuildMessageReactions | I.DirectMessageReactions,
+    messageReactionRemoveAll: I.GuildMessageReactions | I.DirectMessageReactions,
+    messageReactionRemoveEmoji: I.GuildMessageReactions | I.DirectMessageReactions,
+    typingStart: I.GuildMessageTyping | I.DirectMessageTyping,
+    guildScheduledEventCreate: I.GuildScheduledEvents,
+    guildScheduledEventUpdate: I.GuildScheduledEvents,
+    guildScheduledEventDelete: I.GuildScheduledEvents,
+    guildScheduledEventUserAdd: I.GuildScheduledEvents,
+    guildScheduledEventUserRemove: I.GuildScheduledEvents,
+    autoModerationRuleCreate: I.AutoModerationConfiguration,
+    autoModerationRuleUpdate: I.AutoModerationConfiguration,
+    autoModerationRuleDelete: I.AutoModerationConfiguration,
+    autoModerationActionExecution: I.AutoModerationExecution,
+    messagePollVoteAdd: I.GuildMessagePolls | I.DirectMessagePolls,
+    messagePollVoteRemove: I.GuildMessagePolls | I.DirectMessagePolls
+  };
+  PRIVILEGED_INTENTS = I.GuildMembers | I.GuildPresences | I.MessageContent;
+});
+
+// src/rest-transport.ts
+import { NubisError as NubisError2 } from "@nubisjs/core";
+import { Routes } from "discord-api-types/v10";
+async function toRawFiles(files) {
+  if (!files?.length)
+    return;
+  return Promise.all(files.map(async (file, index) => ({
+    key: `files[${index}]`,
+    name: file.name,
+    contentType: file.contentType,
+    data: typeof file.data === "string" || file.data instanceof Uint8Array ? file.data : file.data instanceof ArrayBuffer ? new Uint8Array(file.data) : new Uint8Array(await file.data.arrayBuffer())
+  })));
+}
+function explain(error, what) {
+  const code = error.code;
+  if (typeof code === "number" && EXPIRED.has(code)) {
+    return new NubisError2(`${what} failed: the interaction token has expired. Discord allows follow-ups and edits for 15 minutes after an interaction.`);
+  }
+  return error;
+}
+function restTransport(rest, interaction) {
+  const { id, token, application_id: applicationId } = interaction;
+  const call = async (what, send) => {
+    try {
+      await send();
+    } catch (error) {
+      throw explain(error, what);
+    }
+  };
+  return {
+    respond: async (response, files) => call("Responding", async () => rest.post(Routes.interactionCallback(id, token), {
+      auth: false,
+      body: response,
+      files: await toRawFiles(files)
+    })),
+    editOriginal: async (body, files) => call("Editing the reply", async () => rest.patch(Routes.webhookMessage(applicationId, token, "@original"), {
+      auth: false,
+      body,
+      files: await toRawFiles(files)
+    })),
+    deleteOriginal: () => call("Deleting the reply", () => rest.delete(Routes.webhookMessage(applicationId, token, "@original"), {
+      auth: false
+    })),
+    followUp: async (body, files) => call("Sending a follow-up", async () => rest.post(Routes.webhook(applicationId, token), {
+      auth: false,
+      body,
+      files: await toRawFiles(files)
+    }))
+  };
+}
+var EXPIRED;
+var init_rest_transport = __esm(() => {
+  EXPIRED = new Set([10015, 10062, 50027]);
+});
+
+// src/route.ts
+import {
+  dispatch,
+  dispatchAutocomplete,
+  dispatchComponent,
+  dispatchMenu,
+  dispatchModal
+} from "@nubisjs/core";
+import {
+  ApplicationCommandType,
+  InteractionType
+} from "discord-api-types/v10";
+function routeInteraction(project, interaction, transport, options) {
+  switch (interaction.type) {
+    case InteractionType.ApplicationCommand:
+      return interaction.data.type === ApplicationCommandType.ChatInput ? dispatch(project.tree, interaction, transport, options) : dispatchMenu(project.menus, interaction, transport, options);
+    case InteractionType.MessageComponent:
+      return dispatchComponent(project.components, interaction, transport, options);
+    case InteractionType.ApplicationCommandAutocomplete:
+      return dispatchAutocomplete(project.tree, interaction, transport, options);
+    case InteractionType.ModalSubmit:
+      return dispatchModal(project.components, interaction, transport, options);
+    default:
+      return Promise.resolve({ status: "unsupported" });
+  }
+}
+var init_route = () => {};
+
+// src/bot.ts
+import { API } from "@discordjs/core/http-only";
+import { dispatchEvent } from "@nubisjs/core";
+import { REST } from "@discordjs/rest";
+import { WebSocketManager, WebSocketShardEvents } from "@discordjs/ws";
+import {
+  GatewayDispatchEvents
+} from "discord-api-types/v10";
+function createBot(options) {
+  const rest = options.rest ?? new REST({ version: "10" }).setToken(options.token);
+  const intents = intentsFor(options.project.events, options.intents);
+  const presence = options.presence ?? null;
+  const gateway = options.gateway ? options.gateway({ intents, rest, presence }) : new WebSocketManager({
+    token: options.token,
+    intents,
+    rest,
+    initialPresence: presence
+  });
+  const api = new API(rest);
+  const routeOptions = {
+    ...options.dispatch,
+    api,
+    onError: options.onError ?? options.dispatch?.onError
+  };
+  gateway.on(WebSocketShardEvents.Dispatch, (payload, shardId) => {
+    if (payload.t === GatewayDispatchEvents.InteractionCreate) {
+      const interaction = payload.d;
+      routeInteraction(options.project, interaction, restTransport(rest, interaction), routeOptions);
+      return;
+    }
+    dispatchEvent(options.project.events, payload.t, payload.d, {
+      shardId,
+      onError: routeOptions.onError,
+      api
+    });
+  });
+  return {
+    rest,
+    api,
+    intents,
+    start: () => gateway.connect(),
+    stop: async () => {
+      await gateway.destroy();
+    }
+  };
+}
+var init_bot = __esm(() => {
+  init_intents();
+  init_rest_transport();
+  init_route();
+});
+
+// src/config.ts
+import {
+  ActivityType,
+  GatewayIntentBits,
+  PresenceUpdateStatus
+} from "discord-api-types/v10";
+function defineConfig(config) {
+  return config;
+}
+function validateConfig(config, file) {
+  const where = (detail) => new Error(`${file}: ${detail}`);
+  if (typeof config !== "object" || config === null) {
+    throw where("export the config as default: export default defineConfig({ ... }).");
+  }
+  const value = config;
+  for (const key of Object.keys(value)) {
+    if (!KEYS.has(key)) {
+      throw where(`"${key}" isn't a config setting. The settings are: ${[...KEYS].join(", ")}.`);
+    }
+  }
+  for (const name of value.intents ?? []) {
+    if (typeof name !== "string" || !(name in GatewayIntentBits) || !Number.isNaN(Number(name))) {
+      throw where(`"${String(name)}" isn't an intent. Use names like "MessageContent" or "GuildMembers".`);
+    }
+  }
+  const presence = value.presence;
+  if (presence?.status && !(presence.status in STATUSES)) {
+    throw where(`presence.status must be online, idle, dnd or invisible (got "${presence.status}").`);
+  }
+  if (presence?.activity && !(presence.activity.type in ACTIVITY_TYPES)) {
+    throw where(`presence.activity.type must be playing, listening, watching, competing or custom (got "${presence.activity.type}").`);
+  }
+  if (value.transport !== undefined && value.transport !== "gateway" && value.transport !== "http") {
+    throw where(`transport must be "gateway" or "http" (got "${String(value.transport)}").`);
+  }
+  return value;
+}
+function intentBits(names = []) {
+  return names.reduce((bits, name) => bits | GatewayIntentBits[name], 0);
+}
+function presenceData(presence) {
+  if (!presence)
+    return;
+  const activity = presence.activity;
+  return {
+    since: null,
+    afk: false,
+    status: STATUSES[presence.status ?? "online"] ?? PresenceUpdateStatus.Online,
+    activities: activity ? [
+      activity.type === "custom" ? {
+        type: ActivityType.Custom,
+        name: "Custom Status",
+        state: activity.name
+      } : { type: ACTIVITY_TYPES[activity.type], name: activity.name }
+    ] : []
+  };
+}
+var KEYS, ACTIVITY_TYPES, STATUSES;
+var init_config = __esm(() => {
+  KEYS = new Set([
+    "root",
+    "intents",
+    "presence",
+    "guards",
+    "middleware",
+    "onError",
+    "autoDeferMs",
+    "transport",
+    "http",
+    "devGuildId"
+  ]);
+  ACTIVITY_TYPES = {
+    playing: ActivityType.Playing,
+    listening: ActivityType.Listening,
+    watching: ActivityType.Watching,
+    competing: ActivityType.Competing,
+    custom: ActivityType.Custom
+  };
+  STATUSES = {
+    online: PresenceUpdateStatus.Online,
+    idle: PresenceUpdateStatus.Idle,
+    dnd: PresenceUpdateStatus.DoNotDisturb,
+    invisible: PresenceUpdateStatus.Invisible
+  };
+});
+
+// src/config-loader.ts
+import { access } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+async function loadConfig(cwd) {
+  for (const name of NAMES) {
+    const file = join2(cwd, name);
+    const exists = await access(file).then(() => true, () => false);
+    if (!exists)
+      continue;
+    const url = pathToFileURL2(file);
+    url.searchParams.set("v", String(Date.now()));
+    const module = await import(url.href);
+    const config = validateConfig(module.default, name);
+    return { config, file, root: join2(cwd, config.root ?? ".") };
+  }
+  return { config: {}, file: undefined, root: cwd };
+}
+var NAMES;
+var init_config_loader = __esm(() => {
+  init_config();
+  NAMES = [
+    "nubis.config.ts",
+    "nubis.config.mts",
+    "nubis.config.js",
+    "nubis.config.mjs"
+  ];
+});
+
+// src/env.ts
+import { readFile } from "node:fs/promises";
+import { dirname, join as join3 } from "node:path";
+function parseEnv(text) {
+  const values = {};
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const at = line.indexOf("=");
+    if (at === -1)
+      continue;
+    const key = line.slice(0, at).replace(/^export\s+/, "").trim();
+    let value = line.slice(at + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    values[key] = value;
+  }
+  return values;
+}
+async function loadEnv(start, target = process.env) {
+  let dir = start;
+  for (;; ) {
+    const file = join3(dir, ".env");
+    const text = await readFile(file, "utf8").catch(() => {
+      return;
+    });
+    if (text !== undefined) {
+      for (const [key, value] of Object.entries(parseEnv(text))) {
+        target[key] ??= value;
+      }
+      return file;
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+  }
+}
+function discordEnv(env = process.env) {
+  const missing = ["DISCORD_TOKEN", "DISCORD_APPLICATION_ID"].filter((key) => !env[key]);
+  if (missing.length > 0) {
+    throw new Error(`Missing ${missing.join(" and ")}. Put them in a .env file next to your bot (see .env.example).`);
+  }
+  return {
+    token: env.DISCORD_TOKEN,
+    applicationId: env.DISCORD_APPLICATION_ID,
+    publicKey: env.DISCORD_PUBLIC_KEY || undefined,
+    devGuildId: env.DISCORD_DEV_GUILD_ID || undefined
+  };
+}
+var init_env = () => {};
+
+// src/sync.ts
+import {
+  planSync,
+  toCommandPayloads,
+  toMenuPayloads
+} from "@nubisjs/core";
+import { Routes as Routes2 } from "discord-api-types/v10";
+async function syncCommands(options) {
+  const route = options.guildId ? Routes2.applicationGuildCommands(options.applicationId, options.guildId) : Routes2.applicationCommands(options.applicationId);
+  const local = [
+    ...toCommandPayloads(options.project.tree),
+    ...toMenuPayloads(options.project.menus)
+  ];
+  const remote = await options.rest.get(route);
+  const plan = planSync(local, remote);
+  const scope = options.guildId ? "guild" : "global";
+  if (options.dryRun || !hasChanges(plan))
+    return { plan, applied: false, scope };
+  await options.rest.put(route, { body: local });
+  return { plan, applied: true, scope };
+}
+function describePlan(plan) {
+  return [
+    ...plan.create.map((command) => `+ ${command.name}`),
+    ...plan.update.map(({ payload }) => `~ ${payload.name}`),
+    ...plan.remove.map((command) => `- ${command.name}`)
+  ];
+}
+var hasChanges = (plan) => plan.create.length + plan.update.length + plan.remove.length > 0;
+var init_sync = () => {};
+
+// src/node.ts
+init_loader();
+init_bot();
+init_config();
+init_config_loader();
+init_env();
+init_intents();
+init_rest_transport();
+init_sync();
+export {
+  PRIVILEGED_INTENTS,
+  createBot,
+  describePlan,
+  discordEnv,
+  hasChanges,
+  intentBits,
+  intentNames,
+  intentsFor,
+  loadConfig,
+  loadEnv,
+  loadProject,
+  parseEnv,
+  presenceData,
+  restTransport,
+  syncCommands,
+  toNodeListener,
+  validateConfig
+};

package/dist/rest-transport.d.ts

@@ -0,0 +1,16 @@
+import { type Transport } from "@nubisjs/core";
+import { type APIInteraction } from "discord-api-types/v10";
+/** The slice of @discordjs/rest's REST client Nubis uses. */
+export interface RestLike {
+    get(route: `/${string}`, options?: object): Promise<unknown>;
+    post(route: `/${string}`, options?: object): Promise<unknown>;
+    put(route: `/${string}`, options?: object): Promise<unknown>;
+    patch(route: `/${string}`, options?: object): Promise<unknown>;
+    delete(route: `/${string}`, options?: object): Promise<unknown>;
+}
+/**
+ * Answers an interaction received over the gateway, through Discord's REST
+ * API. Interaction callbacks and webhooks use the interaction's own token,
+ * so these calls don't send the bot token.
+ */
+export declare function restTransport(rest: RestLike, interaction: APIInteraction): Transport;

package/dist/route.d.ts

@@ -0,0 +1,17 @@
+import { type CommandTree, type ComponentDispatchOptions, type ComponentRegistry, type DispatchOptions, type MenuDefinition, type Transport } from "@nubisjs/core";
+import { type APIInteraction } from "discord-api-types/v10";
+/** The parts of a project that answer interactions. A loaded Project fits. */
+export interface InteractionProject {
+    readonly tree: CommandTree;
+    readonly components: ComponentRegistry;
+    readonly menus: readonly MenuDefinition[];
+}
+export type RouteOptions = DispatchOptions & ComponentDispatchOptions;
+/**
+ * Sends an interaction to the dispatcher for its type. Shared by the HTTP
+ * endpoint and the gateway bot, which differ only in their transport.
+ */
+export declare function routeInteraction(project: InteractionProject, interaction: APIInteraction, transport: Transport, options: RouteOptions): Promise<{
+    readonly status: string;
+    readonly error?: unknown;
+}>;

package/dist/run-cli.d.ts

@@ -0,0 +1,10 @@
+export type CliResult = {
+    readonly code: number;
+    readonly output: string;
+}
+/** A command that talks to Discord; cli.ts runs it. */
+ | {
+    readonly run: "dev" | "start" | "sync";
+    readonly args: readonly string[];
+};
+export declare function runCli(args: readonly string[]): CliResult;

package/dist/sync.d.ts

@@ -0,0 +1,26 @@
+import { type SyncPlan } from "@nubisjs/core";
+import type { Project } from "./loader";
+import type { RestLike } from "./rest-transport";
+export interface SyncOptions {
+    readonly rest: RestLike;
+    readonly applicationId: string;
+    readonly project: Pick<Project, "tree" | "menus">;
+    /** Register to one server (instant; for development) instead of globally. */
+    readonly guildId?: string;
+    /** Work out the plan without changing anything. */
+    readonly dryRun?: boolean;
+}
+export interface SyncResult {
+    readonly plan: SyncPlan;
+    /** Whether Discord was updated: false for a dry run or when nothing changed. */
+    readonly applied: boolean;
+    readonly scope: "guild" | "global";
+}
+export declare const hasChanges: (plan: SyncPlan) => boolean;
+/**
+ * Makes Discord's registered commands match the project's. Compares first,
+ * so an unchanged bot makes no write; changes go in one bulk overwrite.
+ */
+export declare function syncCommands(options: SyncOptions): Promise<SyncResult>;
+/** One line per change, for the CLI. */
+export declare function describePlan(plan: SyncPlan): string[];

package/dist/testing.d.ts

@@ -0,0 +1,2 @@
+/** Test commands, components, modals and menus without Discord. See @nubisjs/testing. */
+export * from "@nubisjs/testing";

package/dist/testing.js

@@ -0,0 +1,2 @@
+// src/testing.ts
+export * from "@nubisjs/testing";