@wolfstar/http-framework 3.4.0-next-20260903210435 → 3.4.0

package/dist/esm/resolve-BBb7eiV0.d.ts

@@ -0,0 +1,520 @@
+//#region src/lib/config/load.d.ts
+declare const CONFIG_EXTENSIONS: readonly ['ts', 'mts', 'cts', 'js', 'mjs', 'cjs'];
+declare const CONFIG_FILE_NAMES: string[];
+interface LoadConfigFileOptions {
+  /** The directory to discover the configuration file from. */
+  cwd: string;
+  /** An explicit configuration file (`--config`), resolved from `cwd`. */
+  configFile?: string | null;
+}
+interface LoadedConfigFile {
+  /** The absolute path of the loaded file, `null` when running on defaults. */
+  configFile: string | null;
+  config: StarsConfig;
+}
+/**
+ * Finds the first `stars.config.*` file in `cwd`, in {@link CONFIG_FILE_NAMES} order.
+ */
+declare function discoverConfigFile(cwd: string): string | null;
+/**
+ * Loads the raw configuration object. The loader (`c12`) is imported lazily so
+ * commands that never touch the configuration stay fast.
+ */
+declare function loadConfigFile(options: LoadConfigFileOptions): Promise<LoadedConfigFile>;
+//#endregion
+//#region src/lib/config/errors.d.ts
+interface ConfigErrorOptions {
+  /** A stable, machine readable code, e.g. `INVALID_TYPE`. */
+  code: string;
+  /** A short, actionable suggestion. */
+  hint?: string;
+  /** The dotted path of the offending option, e.g. `dev.debounce`. */
+  path?: string;
+  /** The configuration file the error originates from. */
+  file?: string | null;
+  cause?: unknown;
+}
+/**
+ * A `stars.config.*` error: an invalid option, or a file that failed to load or parse.
+ *
+ * This is a plain data error (no exit code or terminal formatting) so it stays meaningful outside a CLI, e.g. for a
+ * dashboard or test that calls {@link loadStarsConfig} directly. `@wolfstar/cli` maps it to exit code `2` and renders
+ * `message`, `path`, `file` and `hint` for the terminal.
+ */
+declare class ConfigError extends Error {
+  readonly code: string;
+  readonly hint: string | null;
+  readonly path: string | null;
+  readonly file: string | null;
+  constructor(message: string, options: ConfigErrorOptions);
+}
+//#endregion
+//#region src/lib/config/index.d.ts
+interface LoadStarsConfigOptions {
+  /**
+   * The directory to discover `stars.config.*` from.
+   * @default process.cwd()
+   */
+  cwd?: string;
+  /** An explicit configuration file, resolved from `cwd`. */
+  configFile?: string | null;
+  /**
+   * Environment used for defaults such as `HTTP_PORT`.
+   * @default process.env
+   */
+  env?: NodeJS.ProcessEnv;
+}
+/**
+ * Loads, validates and resolves a project's `stars.config.*`.
+ *
+ * @throws {ConfigError} when the configuration file cannot be loaded or contains an invalid option.
+ */
+declare function loadStarsConfig(options?: LoadStarsConfigOptions): Promise<ResolvedStarsConfig>;
+//#endregion
+//#region src/config.d.ts
+/**
+ * Public, side-effect free configuration surface of `@wolfstar/cli`.
+ *
+ * This module is intentionally tiny: importing it from a `stars.config.ts`
+ * file must never start the bot nor pull the heavy runtime of the CLI.
+ *
+ * @module @wolfstar/http-framework/config
+ */
+/**
+ * The build tool used to turn the project sources into runnable JavaScript.
+ *
+ * - `tsdown`: run the project's own `tsdown` (configuration file included) programmatically.
+ * - `tsc`: run the project's `tsc -b` on the configured `tsconfig`.
+ * - `vite`: run the project's own `vite` (configuration file included), requires `experimental.enableVite`.
+ * - `none`: the entry is runnable as-is (JavaScript projects), no build step.
+ * - `auto`: detect from the project (default).
+ */
+type StarsBuildTool = 'tsdown' | 'tsc' | 'none' | 'vite';
+interface StarsBuildConfig {
+  /**
+   * The build tool to use.
+   * @default 'auto'
+   */
+  tool?: StarsBuildTool | 'auto';
+  /**
+   * The directory, relative to {@link StarsConfig.root}, the build writes into.
+   * @default 'dist', or '.output' when `experimental.enableNitro` is on (Nitro's own convention)
+   */
+  outDir?: string;
+  /**
+   * The `tsconfig.json` used by the `tsc` build tool, relative to {@link StarsConfig.root}.
+   * @default 'src/tsconfig.json' when it exists, 'tsconfig.json' otherwise
+   */
+  tsconfig?: string;
+}
+/**
+ * Raw options merged into the project's own `vite.config.*`, the way `vite: {}` in a Nuxt config is merged into
+ * Nuxt's own Vite config. Kept as `unknown` here (the CLI, not the framework, depends on `vite`'s types) and passed
+ * to Vite's `mergeConfig` as-is.
+ */
+type StarsViteConfig = Record<string, unknown>;
+/**
+ * Raw options merged into the project's own `tsdown.config.*`.
+ */
+type StarsTsdownConfig = Record<string, unknown>;
+/**
+ * The type checker `stars dev` runs next to the bot.
+ *
+ * - `tsc`: the project's own TypeScript, in watch mode.
+ * - `golar`: the project's `golar`, forwarding to TypeScript (`golar tsc`), in watch mode.
+ * - `tsz`: the project's `tsz` (or `try-tsz`). It has no watch mode, so it is re-run after every build instead.
+ * - `auto`: `golar` when the project depends on it, `tsc` otherwise (default).
+ */
+type StarsTypechecker = 'tsc' | 'golar' | 'tsz';
+interface StarsTypecheckConfig {
+  /**
+   * The `tsconfig.json` the type checker runs against, relative to {@link StarsConfig.root}.
+   * @default the build tool's tsconfig, 'src/tsconfig.json' or 'tsconfig.json'
+   */
+  tsconfig?: string;
+  /**
+   * Which type checker to run.
+   * @default 'auto'
+   */
+  checker?: StarsTypechecker | 'auto';
+}
+interface StarsTunnelConfig {
+  /**
+   * An https URL you already serve; when unset a `cloudflared` quick tunnel is opened instead.
+   */
+  url?: string;
+  /**
+   * Writes the tunnel's URL to the Discord application's `interactions_endpoint_url` when it changes.
+   *
+   * This edits a live Discord application, so it is opt-in: it needs `DISCORD_TOKEN` and `DISCORD_APPLICATION_ID`
+   * (or `APPLICATION_ID`) in the environment or the project's `.env`.
+   * @default false
+   */
+  updateEndpoint?: boolean;
+  /**
+   * The path the interactions endpoint is served on, appended to the tunnel URL.
+   * @default '/'
+   */
+  path?: string;
+}
+interface StarsDevConfig {
+  /**
+   * Extra paths to watch, relative to {@link StarsConfig.root}. Only used when
+   * the build tool is `none`; `tsdown` and `tsc` watch through their own build.
+   * @default [dirname(entry)]
+   */
+  watch?: string[];
+  /**
+   * Glob patterns or paths to ignore while watching, relative to {@link StarsConfig.root}.
+   * @default ['**\/node_modules/**', '**\/dist/**', '**\/.git/**']
+   */
+  ignore?: string[];
+  /**
+   * Milliseconds to wait after a change before restarting the bot.
+   * @default 150
+   */
+  debounce?: number;
+  /**
+   * Environment variables added to the bot process.
+   */
+  env?: Record<string, string>;
+  /**
+   * Arguments passed to `node` before the entry file.
+   * @default ['--enable-source-maps']
+   */
+  nodeArgs?: string[];
+  /**
+   * Arguments passed to the bot after the entry file.
+   * @default []
+   */
+  args?: string[];
+  /**
+   * The URL the bot listens on, shown in the dev UI's status line and used for {@link StarsDevConfig.health}.
+   *
+   * Resolved automatically, the way Vite's and Nuxt's dev servers do, from (in order) `dev.env.HTTP_PORT`, the
+   * process's `HTTP_PORT`, the project's `.env.local`/`.env` (`HTTP_PORT` or `PORT`), or `3000`. `stars dev` also
+   * resolves whether `localhost` should be shown as `127.0.0.1` instead, the same DNS-order check Vite does, so the
+   * printed URL is always the one that is actually reachable.
+   * @default `http://localhost:3000` (or whichever port is found)
+   */
+  url?: string;
+  /**
+   * A path, relative to {@link StarsDevConfig.url}, polled to report the bot's health in the dev UI.
+   * When unset the dev UI only reports process state.
+   */
+  health?: string;
+  /**
+   * Milliseconds to wait for the bot to exit after `SIGTERM` before killing it.
+   * @default 5000
+   */
+  killTimeout?: number;
+  /**
+   * Runs a type checker next to the bot and reports type errors on the dev UI's `tsc` channel, without blocking
+   * builds or restarts. `true` uses the project's own tsconfig and type checker, an object picks either
+   * ({@link StarsTypecheckConfig.checker}).
+   * @default false
+   */
+  typecheck?: boolean | StarsTypecheckConfig;
+  /**
+   * Exposes the bot's HTTP interactions endpoint publicly while `stars dev` runs, so Discord can reach it.
+   *
+   * `true` opens a `cloudflared` quick tunnel (its hostname changes on every run), a string is an https URL you
+   * already serve yourself (named tunnel, reverse proxy, …) that the CLI only checks for reachability.
+   * @default false
+   */
+  tunnel?: boolean | string | StarsTunnelConfig;
+  /**
+   * The file `stars dev` mirrors its logs into, relative to {@link StarsConfig.root}, so a session can be read back
+   * after the terminal UI is gone. `false` disables it.
+   * @default '.stars/dev.log'
+   */
+  logFile?: string | false;
+}
+interface StarsI18nCodegenConfig {
+  /**
+   * The base locale directory, relative to {@link StarsConfig.root}.
+   * @default 'src/locales/en-US'
+   */
+  locales?: string;
+  /**
+   * The generated declaration file, relative to {@link StarsConfig.root}.
+   * @default 'src/@types/i18next.d.ts'
+   */
+  output?: string;
+}
+interface StarsCodegenConfig {
+  /**
+   * i18next type generation through `@wolfstar/i18next-type-generator`.
+   * `false` disables it, an object enables it, unset auto-detects from the presence of the locales directory.
+   */
+  i18n?: StarsI18nCodegenConfig | false;
+}
+interface StarsImportsConfig {
+  /**
+   * Whether auto imports are enabled. Requires the `tsdown` build tool: the imports are injected at build time by
+   * the `autoImports()` plugin from `@wolfstar/http-framework/auto-imports`, which the other tools cannot run.
+   * @default true when the build tool is 'tsdown', false otherwise
+   */
+  enabled?: boolean;
+  /**
+   * Directories, relative to {@link StarsConfig.root}, whose exported values are auto-importable. Entries are glob
+   * path patterns: `'src/lib'` scans only the files directly inside it, `'src/lib/**'` scans recursively.
+   * @default ['src/lib/**', 'src/utils/**']
+   */
+  dirs?: string[];
+  /**
+   * Packages whose exports are auto-importable. Packages that are not installed are skipped.
+   * @default ['@wolfstar/http-framework', '@wolfstar/env-utilities']
+   */
+  presets?: string[];
+  /**
+   * Export names excluded from auto imports, e.g. to avoid clashes with project-local names.
+   * @default []
+   */
+  exclude?: string[];
+  /**
+   * The generated declaration file that types the auto imports, relative to {@link StarsConfig.root}.
+   * Include it in the project's tsconfig and add its directory to .gitignore.
+   * @default '.stars/imports.d.ts'
+   */
+  dts?: string;
+}
+/**
+ * The [Nitro preset](https://nitro.build/deploy) `stars build` targets, only reachable once
+ * {@link StarsExperimentalConfig.enableNitro} (itself gated on {@link StarsExperimentalConfig.enableVite}) is `true`
+ * — see {@link StarsExperimentalConfig}.
+ */
+interface StarsNitroConfig {
+  /**
+   * `'node-server'` (the default, runs locally with plain `node`), `'cloudflare-module'`, `'aws-lambda'`,
+   * `'vercel'`, `'netlify'`, `'bun'`, `'deno-deploy'`, and more — see Nitro's own preset list.
+   * @default 'node-server'
+   */
+  preset?: string;
+}
+/**
+ * Opt-in flags for work that is still landing, in the shape Nuxt's own `experimental` block has: every flag is a
+ * boolean, defaults to `false`, and is documented with what it changes and what it still needs. A flag stays here
+ * until the behaviour it guards is the default (or is dropped), so enabling one is a statement that breakage is
+ * acceptable in exchange for the feature.
+ *
+ * `enableExternalVite`, `enableNitro` and `nitro` build on `enableVite` (and `nitro` on `enableNitro` too): the type
+ * only accepts them once their prerequisite is `true`, so turning one on without the other is a type error here
+ * instead of a `ConfigError` at load time.
+ */
+type StarsExperimentalConfig = {
+  enableVite?: false;
+  enableExternalVite?: false;
+  enableNitro?: false;
+} | {
+  /**
+   * Uses Vite as the project's build tool, in place of `tsdown`. `build.tool` may then be set to `'vite'`
+   * (and `'auto'` detects a `vite.config.*`); the bot keeps calling `client.listen()` and running as a
+   * plain `node:http` process, restarted on every change — this only swaps the bundler.
+   */
+  enableVite: true;
+  /**
+   * Runs the bot through Vite itself, the way `nuxt dev` runs on Vite's own dev server: instead of
+   * building then restarting a child `node` process on every change, `stars dev` loads the entry through
+   * Vite's SSR module graph and serves it — through `@wolfstar/http-framework/fetch`'s
+   * `createFetchHandler` — from one long-lived process, invalidating and re-evaluating just the entry's
+   * module graph on a change instead of restarting.
+   *
+   * With this on, the entry's default export must be the `Client` instance (already `load()`ed, not
+   * `listen()`ed) rather than a script that calls `client.listen()` itself — `stars dev` owns the socket.
+   * @default false
+   */
+  enableExternalVite?: boolean;
+  enableNitro?: false;
+} | {
+  enableVite: true;
+  enableExternalVite?: boolean;
+  /**
+   * Builds the bot through [Nitro](https://nitro.build) instead of a `node:http` server, so `stars build`
+   * produces a server deployable to any of Nitro's presets (`node-server` locally, `cloudflare-module`,
+   * `aws-lambda`, `vercel`, `netlify`, `bun`, `deno-deploy`, and more) from the same
+   * `@wolfstar/http-framework/fetch` handler `enableExternalVite` already runs in dev — no per-platform
+   * adapter to maintain.
+   *
+   * Output goes to `.output/` (Nitro's own convention) instead of `build.outDir`. The entry's default
+   * export must be the `Client` instance, the same as `enableExternalVite`.
+   */
+  enableNitro: true;
+  /** Nitro-specific options, reachable only with `enableNitro: true`. */
+  nitro?: StarsNitroConfig;
+};
+interface StarsConfig {
+  /**
+   * The project root. Relative paths are resolved from the configuration file.
+   * @default dirname(configFile)
+   */
+  root?: string;
+  /**
+   * The source entry point of the bot, relative to {@link StarsConfig.root}.
+   * @default the first of 'src/main.ts', 'src/main.js', 'src/index.ts', 'src/index.js' that exists
+   */
+  entry?: string;
+  build?: StarsBuildConfig;
+  dev?: StarsDevConfig;
+  codegen?: StarsCodegenConfig;
+  /**
+   * Nuxt-style auto imports of the framework's exports and the project's own modules.
+   * `false` disables them, `true` forces them on (requires the `tsdown` build tool).
+   */
+  imports?: StarsImportsConfig | boolean;
+  /** Opt-in flags for behaviour that is still landing. */
+  experimental?: StarsExperimentalConfig;
+  /**
+   * Raw options merged into `vite.config.*`, the way `vite: {}` in a Nuxt config is merged into Nuxt's own Vite
+   * config. Only used with `build.tool: 'vite'` (see `experimental.enableVite`).
+   */
+  vite?: StarsViteConfig;
+  /**
+   * Raw options merged into `tsdown.config.*`. Only used with `build.tool: 'tsdown'`.
+   */
+  tsdown?: StarsTsdownConfig;
+}
+/**
+ * Typed helper for `stars.config.{ts,mts,cts,js,mjs,cjs}` files.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from '@wolfstar/http-framework/config';
+ *
+ * export default defineConfig({
+ * 	entry: 'src/main.ts',
+ * 	build: { tool: 'tsdown' }
+ * });
+ * ```
+ */
+declare function defineConfig(config: StarsConfig): StarsConfig;
+//#endregion
+//#region src/lib/config/resolve.d.ts
+interface PackageJsonLike {
+  name?: string;
+  version?: string;
+  main?: string;
+  type?: string;
+  scripts?: Record<string, string>;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
+interface ResolvedBuildConfig {
+  readonly tool: StarsBuildTool;
+  /** Absolute output directory. */
+  readonly outDir: string;
+  /** Absolute `tsconfig.json` used by `tsc`, `null` for the other tools. */
+  readonly tsconfig: string | null;
+  /** Absolute path of the file `node` runs, i.e. the built entry (or the entry itself when `tool` is `none`). */
+  readonly output: string;
+}
+interface ResolvedTypecheckConfig {
+  readonly enabled: boolean;
+  /** Absolute `tsconfig.json` the type checker runs against, `null` when it could not be found. */
+  readonly tsconfig: string | null;
+  /** The type checker to run, with `'auto'` already resolved. */
+  readonly checker: StarsTypechecker;
+}
+type ResolvedTunnelConfig = {
+  readonly mode: 'off';
+} |
+/** A `cloudflared` quick tunnel, whose hostname is only known once it is up. */
+{
+  readonly mode: 'quick';
+  readonly path: string;
+  readonly updateEndpoint: boolean;
+} |
+/** An https URL the user already serves. */
+{
+  readonly mode: 'url';
+  readonly url: string;
+  readonly path: string;
+  readonly updateEndpoint: boolean;
+};
+interface ResolvedDevConfig {
+  readonly watch: readonly string[];
+  readonly ignore: readonly string[];
+  readonly debounce: number;
+  readonly env: Readonly<Record<string, string>>;
+  readonly nodeArgs: readonly string[];
+  readonly args: readonly string[];
+  readonly url: string | null;
+  readonly health: string | null;
+  readonly killTimeout: number;
+  readonly typecheck: ResolvedTypecheckConfig;
+  readonly tunnel: ResolvedTunnelConfig;
+  /** Absolute path of the file the dev session's logs are mirrored into, `null` when disabled. */
+  readonly logFile: string | null;
+}
+interface ResolvedNitroConfig {
+  readonly preset: string;
+}
+interface ResolvedExperimentalConfig {
+  readonly enableVite: boolean;
+  readonly enableExternalVite: boolean;
+  readonly enableNitro: boolean;
+  readonly nitro: ResolvedNitroConfig;
+}
+interface ResolvedImportsConfig {
+  readonly enabled: boolean;
+  /** Directory glob patterns, relative to the project root (the way `unimport` scans them). */
+  readonly dirs: readonly string[];
+  readonly presets: readonly string[];
+  readonly exclude: readonly string[];
+  /** Absolute path of the generated declaration file. */
+  readonly dts: string;
+}
+interface ResolvedI18nCodegenConfig {
+  readonly locales: string;
+  readonly output: string;
+}
+interface ResolvedCodegenConfig {
+  readonly i18n: ResolvedI18nCodegenConfig | null;
+}
+interface ResolvedStarsConfig {
+  /** Absolute path of the configuration file, `null` when running on defaults. */
+  readonly configFile: string | null;
+  /** The directory the CLI was invoked from. */
+  readonly cwd: string;
+  /** Absolute project root. */
+  readonly root: string;
+  readonly packageJson: PackageJsonLike | null;
+  /** Absolute source entry. */
+  readonly entry: string;
+  readonly build: ResolvedBuildConfig;
+  readonly dev: ResolvedDevConfig;
+  readonly codegen: ResolvedCodegenConfig;
+  readonly imports: ResolvedImportsConfig;
+  readonly experimental: ResolvedExperimentalConfig;
+  /** Raw options merged into `vite.config.*`. */
+  readonly vite: Readonly<Record<string, unknown>>;
+  /** Raw options merged into `tsdown.config.*`. */
+  readonly tsdown: Readonly<Record<string, unknown>>;
+}
+interface ResolveConfigOptions {
+  cwd: string;
+  configFile: string | null;
+  config: StarsConfig;
+  env?: NodeJS.ProcessEnv;
+}
+/**
+ * Applies defaults, validates every option and resolves all paths to absolute ones.
+ *
+ * @throws {ConfigError} with an actionable `hint` on the first invalid option.
+ */
+declare function resolveStarsConfig(options: ResolveConfigOptions): ResolvedStarsConfig;
+/**
+ * Presents an absolute path relative to `root` when possible, for display purposes.
+ */
+declare function displayPath(root: string, path: string): string;
+/**
+ * Reads the project's `.env.local`/`.env` into a plain object, the way `stars dev` and `stars commands` need it:
+ * these files are only loaded into `process.env` by the bot itself once it starts (see `@wolfstar/env-utilities`),
+ * so by the time the CLI runs they are not there yet. This is a minimal line reader, not a full dotenv
+ * implementation — quoting is stripped, but expansion (`dotenv-expand`) is not. Earlier files win, matching
+ * dotenv's own precedence.
+ */
+declare function readProjectEnvFiles(root: string): Record<string, string>;
+//#endregion
+export { defineConfig as A, loadConfigFile as B, StarsImportsConfig as C, StarsTypecheckConfig as D, StarsTunnelConfig as E, CONFIG_EXTENSIONS as F, CONFIG_FILE_NAMES as I, LoadConfigFileOptions as L, loadStarsConfig as M, ConfigError as N, StarsTypechecker as O, ConfigErrorOptions as P, LoadedConfigFile as R, StarsI18nCodegenConfig as S, StarsTsdownConfig as T, StarsBuildTool as _, ResolvedDevConfig as a, StarsDevConfig as b, ResolvedImportsConfig as c, ResolvedTunnelConfig as d, ResolvedTypecheckConfig as f, StarsBuildConfig as g, resolveStarsConfig as h, ResolvedCodegenConfig as i, LoadStarsConfigOptions as j, StarsViteConfig as k, ResolvedNitroConfig as l, readProjectEnvFiles as m, ResolveConfigOptions as n, ResolvedExperimentalConfig as o, displayPath as p, ResolvedBuildConfig as r, ResolvedI18nCodegenConfig as s, PackageJsonLike as t, ResolvedStarsConfig as u, StarsCodegenConfig as v, StarsNitroConfig as w, StarsExperimentalConfig as x, StarsConfig as y, discoverConfigFile as z };
+//# sourceMappingURL=resolve-BBb7eiV0.d.ts.map

package/dist/esm/resolve-BBb7eiV0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-BBb7eiV0.d.ts","names":[],"sources":["../../src/lib/config/load.ts","../../src/lib/config/errors.ts","../../src/lib/config/index.ts","../../src/config.ts","../../src/lib/config/resolve.ts"],"mappings":";cAKa;cACA;UAEI;;EAEhB;;EAEA;;UAGgB;;EAEhB;EACA,QAAQ;;;;;iBAMO,mBAAmB;;;;;iBAab,eAAe,SAAS,wBAAwB,QAAQ;;;UCrC7D;;EAEhB;;EAEA;;EAEA;;EAEA;EACA;;;;;;;;;cAUY,oBAAoB;WAChB;WACA;WACA;WACA;EAEhB,YAAmB,iBAAiB,SAAS;;;;UCtB7B;;;;;EAKhB;;EAEA;;;;;EAKA,MAAM,OAAO;;;;;;;iBAQQ,gBAAgB,UAAS,yBAA8B,QAAQ;;;;;;;;;;;;;;;;;;;;KCLzE;UAEK;;;;;EAKhB,OAAO;;;;;EAKP;;;;;EAKA;;;;;;;KAQW,kBAAkB;;;;KAKlB,oBAAoB;;;;;;;;;KAUpB;UAEK;;;;;EAKhB;;;;;EAKA,UAAU;;UAGM;;;;EAIhB;;;;;;;;EAQA;;;;;EAKA;;UAGgB;;;;;;EAMhB;;;;;EAKA;;;;;EAKA;;;;EAIA,MAAM;;;;;EAKN;;;;;EAKA;;;;;;;;;;EAUA;;;;;EAKA;;;;;EAKA;;;;;;;EAOA,sBAAsB;;;;;;;;EAQtB,4BAA4B;;;;;;EAM5B;;UAGgB;;;;;EAKhB;;;;;EAKA;;UAGgB;;;;;EAKhB,OAAO;;UAGS;;;;;;EAMhB;;;;;;EAMA;;;;;EAKA;;;;;EAKA;;;;;;EAMA;;;;;;;UAQgB;;;;;;EAMhB;;;;;;;;;;;;KAaW;EACP;EAAoB;EAA4B;;;;;;;EAOlD;;;;;;;;;;;;EAYA;EACA;;EAGA;EACA;;;;;;;;;;;EAWA;;EAEA,QAAQ;;UAGM;;;;;EAKhB;;;;;EAKA;EACA,QAAQ;EACR,MAAM;EACN,UAAU;;;;;EAKV,UAAU;;EAEV,eAAe;;;;;EAKf,OAAO;;;;EAIP,SAAS;;;;;;;;;;;;;;;iBAgBM,aAAa,QAAQ,cAAc;;;UCpUlC;EAChB;EACA;EACA;EACA;EACA,UAAU;EACV,eAAe;EACf,kBAAkB;;UAGF;WACP,MAAM;;WAEN;;WAEA;;WAEA;;UAGO;WACP;;WAEA;;WAEA,SAAS;;KAGP;WACE;;;;WAEA;WAAwB;WAAuB;;;;WAE/C;WAAsB;WAAsB;WAAuB;;UAEhE;WACP;WACA;WACA;WACA,KAAK,SAAS;WACd;WACA;WACA;WACA;WACA;WACA,WAAW;WACX,QAAQ;;WAER;;UAGO;WACP;;UAGO;WACP;WACA;WACA;WACA,OAAO;;UAGA;WACP;;WAEA;WACA;WACA;;WAEA;;UAGO;WACP;WACA;;UAGO;WACP,MAAM;;UAGC;;WAEP;;WAEA;;WAEA;WACA,aAAa;;WAEb;WACA,OAAO;WACP,KAAK;WACL,SAAS;WACT,SAAS;WACT,cAAc;;WAEd,MAAM,SAAS;;WAEf,QAAQ,SAAS;;UAGV;EAChB;EACA;EACA,QAAQ;EACR,MAAM,OAAO;;;;;;;iBAoCE,mBAAmB,SAAS,uBAAuB;;;;iBAoCnD,YAAY,cAAc;;;;;;;;iBA8M1B,oBAAoB,eAAe"}

package/dist/esm/security-BBKStXe6.js

@@ -0,0 +1,57 @@
+import { webcrypto } from "node:crypto";
+
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/classPrivateFieldSet2.js
+function _classPrivateFieldSet2(s, a, r) {
+	return s.set(_assertClassBrand(s, a), r), r;
+}
+
+//#endregion
+//#region src/lib/utils/security.ts
+const AlgorithmName = "Ed25519";
+function headerToString(header) {
+	return typeof header === "string" ? header : header[0];
+}
+function makeKey(key) {
+	return webcrypto.subtle.importKey("raw", Buffer.from(key, "hex"), { name: AlgorithmName }, true, ["verify"]);
+}
+/**
+* Validates a payload from Discord against its signature and key.
+* @param body The request body.
+* @param signature The value of the `x-signature-ed25519` header.
+* @param signature The value of the `x-signature-timestamp` header.
+* @param key The public key from the Discord developer dashboard, generated by {@link makeKey}
+*/
+async function verifyBody(body, signature, timestamp, key) {
+	const signatureData = Buffer.from(headerToString(signature), "hex");
+	const data = Buffer.isBuffer(body) ? Buffer.concat([Buffer.from(headerToString(timestamp)), body]) : Buffer.from(`${headerToString(timestamp)}${body}`);
+	return webcrypto.subtle.verify(AlgorithmName, key, signatureData, Buffer.from(data));
+}
+
+//#endregion
+export { _assertClassBrand as a, _classPrivateFieldGet2 as i, verifyBody as n, _classPrivateFieldInitSpec as o, _classPrivateFieldSet2 as r, _checkPrivateRedeclaration as s, makeKey as t };
+//# sourceMappingURL=security-BBKStXe6.js.map

package/dist/esm/security-BBKStXe6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-BBKStXe6.js","names":[],"sources":["../../src/lib/utils/security.ts"],"sourcesContent":["import { webcrypto } from 'node:crypto';\n\nexport type HeaderValue = string | string[];\nexport type Key = webcrypto.CryptoKey;\n\nconst AlgorithmName = 'Ed25519';\n\nfunction headerToString(header: HeaderValue): string {\n\treturn typeof header === 'string' ? header : header[0];\n}\n\nexport function makeKey(key: string): Promise<Key> {\n\treturn webcrypto.subtle.importKey('raw', Buffer.from(key, 'hex'), { name: AlgorithmName }, true, ['verify']);\n}\n\n/**\n * Validates a payload from Discord against its signature and key.\n * @param body The request body.\n * @param signature The value of the `x-signature-ed25519` header.\n * @param signature The value of the `x-signature-timestamp` header.\n * @param key The public key from the Discord developer dashboard, generated by {@link makeKey}\n */\nexport async function verifyBody(body: string, signature: string | string[], timestamp: string | string[], key: Key) {\n\tconst signatureData = Buffer.from(headerToString(signature), 'hex');\n\tconst data = Buffer.isBuffer(body)\n\t\t? Buffer.concat([Buffer.from(headerToString(timestamp)), body])\n\t\t: Buffer.from(`${headerToString(timestamp)}${body}`);\n\n\treturn webcrypto.subtle.verify(AlgorithmName, key, signatureData, Buffer.from(data));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,MAAM,gBAAgB;AAEtB,SAAS,eAAe,QAA6B;CACpD,OAAO,OAAO,WAAW,WAAW,SAAS,OAAO;AACrD;AAEA,SAAgB,QAAQ,KAA2B;CAClD,OAAO,UAAU,OAAO,UAAU,OAAO,OAAO,KAAK,KAAK,KAAK,GAAG,EAAE,MAAM,cAAc,GAAG,MAAM,CAAC,QAAQ,CAAC;AAC5G;;;;;;;;AASA,eAAsB,WAAW,MAAc,WAA8B,WAA8B,KAAU;CACpH,MAAM,gBAAgB,OAAO,KAAK,eAAe,SAAS,GAAG,KAAK;CAClE,MAAM,OAAO,OAAO,SAAS,IAAI,IAC9B,OAAO,OAAO,CAAC,OAAO,KAAK,eAAe,SAAS,CAAC,GAAG,IAAI,CAAC,IAC5D,OAAO,KAAK,GAAG,eAAe,SAAS,IAAI,MAAM;CAEpD,OAAO,UAAU,OAAO,OAAO,eAAe,KAAK,eAAe,OAAO,KAAK,IAAI,CAAC;AACpF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wolfstar/http-framework",
-  "version": "3.4.0-next-20260903210435",
+  "version": "3.4.0",
   "description": "The framework for Star Network's HTTP-only bots",
   "keywords": [
     "api",
@@ -30,9 +30,29 @@
   "module": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",
   "exports": {
-    "import": {
-      "types": "./dist/esm/index.d.ts",
-      "default": "./dist/esm/index.js"
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      }
+    },
+    "./config": {
+      "import": {
+        "types": "./dist/esm/config.d.ts",
+        "default": "./dist/esm/config.js"
+      }
+    },
+    "./auto-imports": {
+      "import": {
+        "types": "./dist/esm/auto-imports.d.ts",
+        "default": "./dist/esm/auto-imports.js"
+      }
+    },
+    "./fetch": {
+      "import": {
+        "types": "./dist/esm/fetch.d.ts",
+        "default": "./dist/esm/fetch.js"
+      }
     }
   },
   "publishConfig": {
@@ -48,8 +68,11 @@
     "@sapphire/result": "^2.8.0",
     "@sapphire/utilities": "^3.18.2",
     "@vladfrangu/async_event_emitter": "^2.4.7",
+    "c12": "^3.3.4",
     "chokidar": "^4.0.3",
-    "discord-api-types": "^0.38.8"
+    "discord-api-types": "^0.38.8",
+    "mlly": "^1.8.2",
+    "unimport": "^6.4.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.1.11",