nubis 0.0.0 → 0.1.0-next.1

package/dist/cli.js

@@ -0,0 +1,1019 @@
+#!/usr/bin/env node
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// 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 } 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 NubisError(`${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 } from "node:path";
+import { pathToFileURL } from "node:url";
+async function loadConfig(cwd) {
+  for (const name of NAMES) {
+    const file = join(cwd, name);
+    const exists = await access(file).then(() => true, () => false);
+    if (!exists)
+      continue;
+    const url = pathToFileURL(file);
+    url.searchParams.set("v", String(Date.now()));
+    const module = await import(url.href);
+    const config = validateConfig(module.default, name);
+    return { config, file, root: join(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 join2 } 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 = join2(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/http.ts
+import { NubisError as NubisError2 } from "@nubisjs/core";
+import {
+  InteractionResponseType,
+  InteractionType as InteractionType2
+} from "discord-api-types/v10";
+function importPublicKey(publicKey) {
+  let key = keyCache.get(publicKey);
+  if (!key) {
+    const raw = hexToBytes(publicKey);
+    if (!raw || raw.length !== 32) {
+      throw new NubisError2("The public key must be the 64 hex characters shown in the Developer Portal.");
+    }
+    key = crypto.subtle.importKey("raw", raw, { name: "Ed25519" }, false, [
+      "verify"
+    ]);
+    keyCache.set(publicKey, key);
+  }
+  return key;
+}
+async function verifyDiscordRequest(publicKey, signature, timestamp, body) {
+  const signatureBytes = hexToBytes(signature);
+  if (!signatureBytes || signatureBytes.length !== 64)
+    return false;
+  const key = await importPublicKey(publicKey);
+  return crypto.subtle.verify({ name: "Ed25519" }, key, signatureBytes, new TextEncoder().encode(timestamp + body));
+}
+async function discordError(response, what) {
+  const text = await response.text().catch(() => "");
+  let code;
+  try {
+    code = JSON.parse(text).code;
+  } catch {}
+  if (code === INVALID_WEBHOOK_TOKEN || code === UNKNOWN_WEBHOOK || code === UNKNOWN_INTERACTION) {
+    return new NubisError2(`${what} failed: the interaction token has expired. Discord allows follow-ups and edits for 15 minutes after an interaction.`);
+  }
+  return new NubisError2(`${what} failed: Discord answered ${response.status}${text ? ` ${text.slice(0, 200)}` : ""}.`);
+}
+function requestBody(body, files) {
+  if (body === undefined)
+    return { headers: {} };
+  if (!files?.length) {
+    return {
+      body: JSON.stringify(body),
+      headers: { "content-type": "application/json" }
+    };
+  }
+  const form = new FormData;
+  form.append("payload_json", JSON.stringify(body));
+  files.forEach((file, index) => {
+    const blob = file.data instanceof Blob ? file.data : new Blob([file.data], {
+      type: file.contentType ?? "application/octet-stream"
+    });
+    form.append(`files[${index}]`, blob, file.name);
+  });
+  return { body: form, headers: {} };
+}
+function webhookTransport(options) {
+  const { interaction, api } = options;
+  const webhook = `${api}/webhooks/${interaction.application_id}/${interaction.token}`;
+  const call = async (method, url, what, body, files) => {
+    const request = requestBody(body, files);
+    const response = await options.fetch(url, { method, ...request });
+    if (!response.ok)
+      throw await discordError(response, what);
+  };
+  const editOriginal = (body, files) => call("PATCH", `${webhook}/messages/@original`, "Editing the reply", body, files);
+  return {
+    respond: async (response, files) => {
+      if (files?.length && "data" in response) {
+        const updating = response.type === InteractionResponseType.UpdateMessage;
+        const flags = response.data?.flags;
+        await options.respond(updating ? { type: InteractionResponseType.DeferredMessageUpdate } : {
+          type: InteractionResponseType.DeferredChannelMessageWithSource,
+          data: flags ? { flags } : {}
+        });
+        await editOriginal(response.data, files);
+        return;
+      }
+      await options.respond(response);
+    },
+    editOriginal,
+    deleteOriginal: () => call("DELETE", `${webhook}/messages/@original`, "Deleting the reply"),
+    followUp: (body, files) => call("POST", webhook, "Sending a follow-up", body, files)
+  };
+}
+function createInteractionHandler(options) {
+  const api = options.api ?? DEFAULT_API;
+  const fetcher = options.fetch ?? fetch;
+  importPublicKey(options.publicKey);
+  return async (request) => {
+    if (request.method !== "POST")
+      return new Response(null, { status: 405 });
+    const signature = request.headers.get("x-signature-ed25519");
+    const timestamp = request.headers.get("x-signature-timestamp");
+    const body = await request.text();
+    if (!signature || !timestamp || !await verifyDiscordRequest(options.publicKey, signature, timestamp, body)) {
+      return new Response("Bad request signature", { status: 401 });
+    }
+    const interaction = JSON.parse(body);
+    if (interaction.type === InteractionType2.Ping) {
+      return json({ type: InteractionResponseType.Pong });
+    }
+    let answered = false;
+    let answer = () => {};
+    const initial = new Promise((resolve) => {
+      answer = resolve;
+    });
+    const transport = webhookTransport({
+      interaction,
+      api,
+      fetch: fetcher,
+      respond: async (response) => {
+        if (!answered) {
+          answered = true;
+          answer(response);
+          return;
+        }
+        const callback = await fetcher(`${api}/interactions/${interaction.id}/${interaction.token}/callback`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(response)
+        });
+        if (!callback.ok)
+          throw await discordError(callback, "Responding");
+      }
+    });
+    const work = routeInteraction(options.project, interaction, transport, options.dispatch ?? {}).catch((error) => ({ status: "error", error })).then((result) => {
+      options.onResult?.({ interaction, ...result });
+      return result;
+    });
+    options.waitUntil?.(work);
+    const first = await Promise.race([initial, work.then(() => {
+      return;
+    })]);
+    if (first === undefined) {
+      answered = true;
+      return json({ error: "The handler finished without responding." }, 500);
+    }
+    return json(first);
+  };
+}
+var DEFAULT_API = "https://discord.com/api/v10", hexToBytes = (hex) => {
+  if (hex.length % 2 !== 0 || /[^0-9a-f]/i.test(hex))
+    return;
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0;i < bytes.length; i++) {
+    bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}, keyCache, UNKNOWN_INTERACTION = 10062, UNKNOWN_WEBHOOK = 10015, INVALID_WEBHOOK_TOKEN = 50027, json = (body, status = 200) => new Response(JSON.stringify(body), {
+  status,
+  headers: { "content-type": "application/json" }
+});
+var init_http = __esm(() => {
+  init_route();
+  keyCache = new Map;
+});
+
+// src/loader.ts
+import { readdir, stat } from "node:fs/promises";
+import { extname, join as join3, relative, sep } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import {
+  buildCommandTree,
+  createComponentRegistry,
+  createEventRegistry,
+  NubisError as NubisError3
+} 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 = join3(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 = pathToFileURL2(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 NubisError3(`${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 = join3(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 NubisError3(`${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 NubisError3(`${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(join3(root, "components"), extensions)) {
+    files.push(where(file));
+    const found = Object.values(await load(file)).filter(isComponent);
+    if (found.length === 0) {
+      throw new NubisError3(`${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(join3(root, "menus"), extensions)) {
+    files.push(where(file));
+    const menu = (await load(file)).default;
+    if (!isMenu(menu)) {
+      throw new NubisError3(`${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(join3(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 NubisError3(`${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/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, {
+    query: new URLSearchParams({ with_localizations: "true" })
+  });
+  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/commands.ts
+import { spawn } from "node:child_process";
+import { watch } from "node:fs";
+import { createServer } from "node:http";
+import { relative as relative2, sep as sep2 } from "node:path";
+import { API as API2 } from "@discordjs/core/http-only";
+import { REST as REST2 } from "@discordjs/rest";
+async function setup(cwd) {
+  await loadEnv(cwd);
+  const env = discordEnv();
+  const rest = new REST2({ version: "10" }).setToken(env.token);
+  const loaded = await loadConfig(cwd);
+  return {
+    env,
+    rest,
+    ...loaded,
+    devGuildId: env.devGuildId ?? loaded.config.devGuildId
+  };
+}
+function routeOptionsFor(config, api) {
+  return {
+    api,
+    guards: config.guards,
+    middleware: config.middleware,
+    autoDeferMs: config.autoDeferMs,
+    onError: config.onError ?? logErrors
+  };
+}
+async function runSync(cwd, args) {
+  const { env, rest, root, devGuildId } = await setup(cwd);
+  const global = args.includes("--global");
+  const guildId = global ? undefined : devGuildId;
+  if (!global && !guildId) {
+    throw new Error("Set DISCORD_DEV_GUILD_ID (or devGuildId in nubis.config.ts) to sync to your test server, or pass --global to register commands everywhere.");
+  }
+  const project = await loadProject(root);
+  const result = await syncCommands({
+    rest,
+    applicationId: env.applicationId,
+    project,
+    guildId,
+    dryRun: args.includes("--dry-run")
+  });
+  const lines = describePlan(result.plan);
+  log(hasChanges(result.plan) ? `${result.applied ? "Synced" : "Would sync"} ${result.scope} commands:
+${lines.join(`
+`)}` : `Commands are up to date (${result.plan.unchanged.length}).`);
+  return 0;
+}
+function createHttpServer(options) {
+  const path = options.config.http?.path ?? "/interactions";
+  const handle = createInteractionHandler({
+    publicKey: options.publicKey,
+    project: options.project,
+    dispatch: routeOptionsFor(options.config, options.api)
+  });
+  return createServer(toNodeListener(async (request) => new URL(request.url).pathname === path ? handle(request) : new Response("Not found", { status: 404 })));
+}
+async function runStart(cwd) {
+  const { env, rest, config, root } = await setup(cwd);
+  const project = await loadProject(root);
+  const counts = `${project.tree.size} commands, ${project.components.size} components, ${project.menus.length} menus`;
+  if (config.transport === "http") {
+    if (!env.publicKey) {
+      throw new Error("The HTTP transport needs DISCORD_PUBLIC_KEY to verify Discord's requests.");
+    }
+    if (project.events.size > 0) {
+      log("HTTP bots don't receive gateway events; the handlers in events/ won't run.");
+    }
+    const port = config.http?.port ?? Number(process.env.PORT ?? 3000);
+    const server = createHttpServer({
+      publicKey: env.publicKey,
+      project,
+      config,
+      api: new API2(rest)
+    });
+    server.listen(port);
+    log(`Listening on http://localhost:${port}${config.http?.path ?? "/interactions"} (${counts}). Set it as the Interactions Endpoint URL in the Developer Portal.`);
+    return new Promise(() => {});
+  }
+  const bot = createBot({
+    token: env.token,
+    project,
+    rest,
+    intents: intentBits(config.intents),
+    presence: presenceData(config.presence),
+    dispatch: {
+      guards: config.guards,
+      middleware: config.middleware,
+      autoDeferMs: config.autoDeferMs
+    },
+    onError: config.onError ?? logErrors
+  });
+  const privileged = intentNames(bot.intents & PRIVILEGED_INTENTS);
+  if (privileged.length > 0) {
+    log(`Using privileged intents (${privileged.join(", ")}): they must be switched on in the Developer Portal, under Bot.`);
+  }
+  const stop = async () => {
+    await bot.stop();
+    process.exit(0);
+  };
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  await bot.start();
+  log(`Online: ${counts}.`);
+  return new Promise(() => {});
+}
+async function runDev(cwd) {
+  const { env, rest, devGuildId } = await setup(cwd);
+  if (!devGuildId) {
+    throw new Error("nubis dev needs a test server: set DISCORD_DEV_GUILD_ID (or devGuildId in nubis.config.ts). Commands go there and show up instantly.");
+  }
+  let child;
+  const stopChild = () => new Promise((resolve) => {
+    if (!child || child.exitCode !== null)
+      return resolve();
+    child.once("exit", () => resolve());
+    child.kill("SIGTERM");
+  });
+  const cycle = async () => {
+    await stopChild();
+    try {
+      const { root } = await loadConfig(cwd);
+      const project = await loadProject(root, { version: Date.now() });
+      const result = await syncCommands({
+        rest,
+        applicationId: env.applicationId,
+        project,
+        guildId: devGuildId
+      });
+      if (result.applied)
+        log(`Synced commands:
+${describePlan(result.plan).join(`
+`)}`);
+    } catch (error) {
+      fail(error);
+      log("Fix the error and save; I'll try again.");
+      return;
+    }
+    child = spawn(process.execPath, [process.argv[1] ?? "", "start"], {
+      cwd,
+      stdio: "inherit",
+      env: process.env
+    });
+  };
+  let timer;
+  watch(cwd, { recursive: true }, (_event, file) => {
+    if (!file)
+      return;
+    const parts = relative2(cwd, `${cwd}${sep2}${file}`).split(sep2);
+    if (parts.some((part) => IGNORED.includes(part) || part.startsWith(".")))
+      return;
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      log(`${file} changed, restarting.`);
+      cycle();
+    }, 150);
+  });
+  process.once("SIGINT", async () => {
+    await stopChild();
+    process.exit(0);
+  });
+  log("Watching for changes. Press Ctrl+C to stop.");
+  await cycle();
+  return new Promise(() => {});
+}
+var log = (message) => console.log(`[nubis] ${message}`), fail = (error) => console.error(`[nubis] ${error instanceof Error ? error.message : String(error)}`), logErrors = (error, info) => {
+  console.error(`[nubis] ${info.kind} ${info.name} threw:`, error);
+}, IGNORED;
+var init_commands = __esm(() => {
+  init_bot();
+  init_config();
+  init_config_loader();
+  init_env();
+  init_http();
+  init_intents();
+  init_loader();
+  init_sync();
+  IGNORED = ["node_modules", ".git", "dist", ".turbo"];
+});
+// package.json
+var package_default = {
+  name: "nubis",
+  version: "0.1.0-next.1",
+  description: "The Discord bot framework that feels like building a modern web app. Built by Eytak.",
+  keywords: [
+    "discord",
+    "discord-bot",
+    "framework",
+    "nubis"
+  ],
+  license: "MIT",
+  author: "Eytak",
+  homepage: "https://eytak.com/nubis",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/Eytak-Technologies/nubis.git",
+    directory: "packages/nubis"
+  },
+  bugs: "https://github.com/Eytak-Technologies/nubis/issues",
+  type: "module",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./node": {
+      types: "./dist/node.d.ts",
+      import: "./dist/node.js"
+    },
+    "./testing": {
+      types: "./dist/testing.d.ts",
+      import: "./dist/testing.js"
+    }
+  },
+  bin: {
+    nubis: "./dist/cli.js"
+  },
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=20"
+  },
+  scripts: {
+    build: "bun build ./src/index.ts ./src/node.ts ./src/testing.ts ./src/cli.ts --outdir dist --target node --format esm --packages external && tsc -p tsconfig.build.json",
+    "check-types": "tsc --noEmit",
+    test: "bun test",
+    lint: "biome lint ."
+  },
+  dependencies: {
+    "@discordjs/core": "^2.7.0",
+    "@discordjs/rest": "^2.6.3",
+    "@discordjs/ws": "^2.0.4",
+    "@nubisjs/core": "workspace:*",
+    "@nubisjs/testing": "workspace:*",
+    "discord-api-types": "^0.38.59"
+  }
+};
+
+// src/run-cli.ts
+var HELP = `nubis ${package_default.version}
+
+Usage: nubis <command>
+
+Commands:
+  dev               Sync commands to your test server and run the bot, restarting on changes
+  start             Run the bot
+  sync [--global]   Register commands with Discord (your test server, or --global for everywhere)
+       [--dry-run]  Show what would change without changing it
+
+Settings come from .env: DISCORD_TOKEN, DISCORD_APPLICATION_ID and, for dev
+and sync, DISCORD_DEV_GUILD_ID.
+
+Options:
+  -v, --version  Print the version
+  -h, --help     Print this help`;
+function runCli(args) {
+  const [first, ...rest] = args;
+  if (first === "-v" || first === "--version") {
+    return { code: 0, output: package_default.version };
+  }
+  if (first === undefined || first === "-h" || first === "--help") {
+    return { code: 0, output: HELP };
+  }
+  if (first === "dev" || first === "start" || first === "sync") {
+    return { run: first, args: rest };
+  }
+  return { code: 1, output: `Unknown command: ${first}
+
+${HELP}` };
+}
+
+// src/cli.ts
+var result = runCli(process.argv.slice(2));
+if ("run" in result) {
+  const commands = await Promise.resolve().then(() => (init_commands(), {}));
+  const cwd = process.cwd();
+  const run = {
+    dev: () => runDev(cwd),
+    start: () => runStart(cwd),
+    sync: () => runSync(cwd, result.args)
+  }[result.run];
+  try {
+    process.exitCode = await run();
+  } catch (error) {
+    console.error(`[nubis] ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  }
+} else {
+  (result.code === 0 ? console.log : console.error)(result.output);
+  process.exitCode = result.code;
+}