@wolfstar/schema 0.3.0 → 0.4.0

package/dist/esm/config-Ctpk84fx.d.ts

@@ -0,0 +1,750 @@
+import { Diagnostic } from "nostics";
+import { EventEmitter } from "node:events";
+//#region src/config/validator.d.ts
+/** Validates raw `stars.config` values, throwing a `configDiagnostics` diagnostic grounded in the configuration file. */
+declare class Validator {
+  private readonly file;
+  constructor(file: string | null);
+  private get sources();
+  error<Handle extends (params: any) => Diagnostic>(handle: Handle, params: Parameters<Handle>[0]): Diagnostic;
+  knownKeys(value: object, path: string, keys: readonly string[]): void;
+  string(value: unknown, path: string): string | undefined;
+  boolean(value: unknown, path: string): boolean | undefined;
+  /** A plain object passed through as-is (e.g. raw `vite`/`tsdown` config merged into the project's own). */
+  plainObject(value: unknown, path: string): Record<string, unknown> | undefined;
+  stringArray(value: unknown, path: string): string[] | undefined;
+  nonNegativeNumber(value: unknown, path: string): number | undefined;
+  stringRecord(value: unknown, path: string): Record<string, string> | undefined;
+  /** A generic "wrong type" diagnostic. `fix` defaults to the standard "set it or remove it" wording. */
+  typeError(path: string, expected: string, value: unknown, fix?: string): Diagnostic;
+}
+//#endregion
+//#region src/config/compatibility.d.ts
+interface ResolvedFutureConfig {
+  readonly compatibilityVersion: StarsCompatibilityVersion;
+}
+declare const LEGACY_COMPATIBILITY_VERSION = 3;
+declare const LATEST_COMPATIBILITY_VERSION = 5;
+/** The version a project without `future.compatibilityVersion` runs on: today, the latest one. */
+declare const DEFAULT_COMPATIBILITY_VERSION = 5;
+/** Versions still accepted but scheduled for removal in the next major. */
+declare const EOL_COMPATIBILITY_VERSIONS: ReadonlySet<number>;
+/** From this version on, `tsdown` is configured from `stars.config` alone and auto imports are on by default. */
+declare const STARS_CONFIG_TSDOWN_VERSION = 4;
+/** From this version on, `env` is registered automatically in the built entry. */
+declare const AUTO_ENV_VERSION = 5;
+//#endregion
+//#region src/config/env.d.ts
+interface ResolvedEnvConfig {
+  /** Whether the built entry registers the environment before any other module. */
+  readonly enabled: boolean;
+  /** The options handed to `setup()` from `@wolfstar/env-utilities`, as written by the user. */
+  readonly options: Readonly<StarsEnvSetupOptions>;
+}
+/**
+ * Resolves the `env` block. It is on by default from {@link AUTO_ENV_VERSION} on, but only when the project depends on
+ * `@wolfstar/env-utilities` (the module the built entry imports) and does not build through Nitro, whose serverless
+ * presets have no `.env` files to load. `true`, `enabled: true` or any option at all is an explicit opt-in, which
+ * does require the dependency.
+ */
+declare function resolveEnv(config: StarsConfig['env'], packageJson: PackageJsonLike | null, future: ResolvedFutureConfig, experimental: ResolvedExperimentalConfig, validator: Validator): ResolvedEnvConfig;
+//#endregion
+//#region src/config/hooks.d.ts
+type AnyHook = StarsHooks[StarsHookName];
+/** Every hook of `stars.config`, flattened to its full name, with its callbacks in declaration order. */
+type ResolvedHooksConfig = Readonly<Partial<Record<StarsHookName, readonly AnyHook[]>>>;
+declare const STARS_HOOK_NAMES: readonly ["config:resolved", "env:options", "prepare:before", "prepare:done", "builder:created", "tsdown:options", "build:before", "build:done", "dev:start", "dev:restart", "dev:close"];
+/**
+ * Flattens and validates `hooks`. `hookable`'s own `flatHooks` is not used: it would split an array of callbacks into
+ * `name:0`, `name:1` and silently drop anything that is not a function, while a typo in a hook name here should fail
+ * loudly rather than register a hook that never runs.
+ */
+declare function resolveHooks(config: StarsHooksConfig | undefined, validator: Validator): ResolvedHooksConfig;
+//#endregion
+//#region src/config/resolve.d.ts
+interface PackageJsonLike {
+  name?: string;
+  /** `tsdown` reads its options from here as well as from a `tsdown.config.*`. */
+  tsdown?: unknown;
+  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;
+  /**
+   * Absolute path of the build tool's own configuration file (`tsdown.config.*`, `vite.config.*`), `null` when the
+   * tool has none — which is always the case for `tsdown` from `future.compatibilityVersion` 4 on, where the build is
+   * configured from `stars.config` alone.
+   */
+  readonly configFile: string | null;
+}
+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 banner: readonly string[] | false | null;
+  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 [option: string]: unknown;
+  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 env: ResolvedEnvConfig;
+  /** The `hooks` block, flattened to full hook names (`build:done`). */
+  readonly hooks: ResolvedHooksConfig;
+  readonly experimental: ResolvedExperimentalConfig;
+  readonly future: ResolvedFutureConfig;
+  /** Raw options merged into `vite.config.*`. */
+  readonly vite: Readonly<Record<string, unknown>>;
+  /** The `tsdown` build's options: merged over `tsdown.config.*` at compatibility version 3, the whole build from 4 on. */
+  readonly tsdown: Readonly<Record<string, unknown>>;
+  /** Non-fatal diagnostics (e.g. an end-of-life compatibility version), for the host to report. */
+  readonly warnings: readonly Diagnostic[];
+}
+interface ResolveConfigOptions {
+  cwd: string;
+  configFile: string | null;
+  config: StarsConfig;
+  env?: NodeJS.ProcessEnv;
+  /**
+   * The variables the bot will load, when the host resolved them itself (e.g. through `varlock load`). Used instead
+   * of the project's env files for the defaults read from them, such as the `dev.url` port.
+   */
+  projectEnv?: Readonly<Record<string, string>>;
+}
+/**
+ * Applies defaults, validates every option and resolves all paths to absolute ones.
+ *
+ * @throws {Diagnostic} (from `nostics`, via {@link configDiagnostics}) with an actionable `fix` 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 environment layers from `src/.env*` and `.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, environment?: string, options?: {
+  path?: string;
+}): Record<string, string>;
+//#endregion
+//#region src/types/builder.d.ts
+type BuilderLogLevel = 'debug' | 'info' | 'success' | 'warn' | 'error';
+interface BuildOutcome {
+  ok: boolean;
+  durationMs: number;
+  /** A one-line summary, e.g. the first error. */
+  message: string | null;
+}
+interface BuilderEvents {
+  start: [];
+  /** Coarse, real lifecycle milestones, not an estimate of compiler work remaining. */
+  progress: [fraction: number, message: string];
+  success: [outcome: BuildOutcome];
+  failure: [outcome: BuildOutcome];
+  log: [level: BuilderLogLevel, text: string];
+}
+/**
+ * Turns project sources into the runnable output, once or continuously.
+ * Implementations report progress through {@link BuilderEvents}.
+ */
+interface Builder extends EventEmitter<BuilderEvents> {
+  readonly tool: StarsBuildTool;
+  /** Runs a single build. Compilation failures are reported in the outcome; dependency loading may throw. */
+  build(): Promise<BuildOutcome>;
+  /** Starts watching. Resolves once the watcher is set up; builds are reported through events. */
+  watch(): Promise<void>;
+  /** Stops watching. */
+  close(): Promise<void>;
+}
+/** Services supplied by the host; server integrations never import the CLI. */
+interface BuilderContext {
+  /** Resolve build dependencies from the consuming project and report missing dependencies. */
+  importFromProject<T>(root: string, id: string, hint: string): Promise<T>;
+  /** Create the host's entry transformation for installed plugin registrations. */
+  pluginRegistrations(config: ResolvedStarsConfig): object;
+}
+//#endregion
+//#region src/types/hooks.d.ts
+type HookResult = void | Promise<void>;
+/** Why `stars dev` (re)started the bot. */
+type StarsRestartReason = 'initial' | 'build' | 'manual' | 'crash';
+/** What `stars prepare` generated. */
+interface PrepareProjectResult {
+  /** Absolute path of the generated auto imports declaration file, `null` when auto imports are off. */
+  readonly dts: string | null;
+  readonly status: 'written' | 'up-to-date' | 'outdated' | null;
+}
+/**
+ * Lifecycle hooks of the `stars` CLI, registered through `hooks` in `stars.config` and run with
+ * [`hookable`](https://github.com/unjs/hookable). They run in the CLI process, never in the bot: use `env:options`
+ * to change what the bot receives.
+ */
+interface StarsHooks {
+  /** The configuration was loaded and validated. */
+  'config:resolved': (config: ResolvedStarsConfig) => HookResult;
+  /** The `env` options about to be written into the built entry. Mutate `options` to change them. */
+  'env:options': (options: StarsEnvSetupOptions, config: ResolvedStarsConfig) => HookResult;
+  /** Before `.stars/` is generated. */
+  'prepare:before': (config: ResolvedStarsConfig) => HookResult;
+  /** After `.stars/` is generated. */
+  'prepare:done': (config: ResolvedStarsConfig, result: PrepareProjectResult) => HookResult;
+  /** The builder for `build.tool` exists but has not built yet. */
+  'builder:created': (builder: Builder, config: ResolvedStarsConfig) => HookResult;
+  /** The options about to be handed to `tsdown.build()`. Mutate `options` to change them. */
+  'tsdown:options': (options: Record<string, unknown>, config: ResolvedStarsConfig) => HookResult;
+  /** A build (or, in `stars dev`, a rebuild) starts. */
+  'build:before': (config: ResolvedStarsConfig) => HookResult;
+  /** A build (or rebuild) finished, successfully or not — see `outcome.ok`. */
+  'build:done': (outcome: BuildOutcome, config: ResolvedStarsConfig) => HookResult;
+  /** `stars dev` is watching. */
+  'dev:start': (config: ResolvedStarsConfig) => HookResult;
+  /** `stars dev` is about to (re)start the bot. */
+  'dev:restart': (reason: StarsRestartReason, config: ResolvedStarsConfig) => HookResult;
+  /** `stars dev` is shutting down. */
+  'dev:close': (config: ResolvedStarsConfig) => HookResult;
+}
+type StarsHookName = keyof StarsHooks;
+type HookOrList<Callback> = Callback | readonly Callback[];
+type NamespaceOf<Name> = Name extends `${infer Namespace}:${string}` ? Namespace : never;
+type StarsHookNamespace = NamespaceOf<StarsHookName>;
+/**
+ * The `hooks` block of `stars.config`: each hook keyed by its full name (`'build:done'`) or nested under its namespace
+ * (`{ build: { done() {} } }`), as a function or an array of functions.
+ */
+type StarsHooksConfig = { [Name in StarsHookName]?: HookOrList<StarsHooks[Name]>; } & { [Namespace in StarsHookNamespace]?: { [Name in StarsHookName as Name extends `${Namespace}:${infer Rest}` ? Rest : never]?: HookOrList<StarsHooks[Name]>; }; };
+//#endregion
+//#region src/types/config.d.ts
+/**
+ * The build tool used to turn the project sources into runnable JavaScript.
+ *
+ * - `tsdown`: run the project's own `tsdown` programmatically, configured from {@link StarsConfig.tsdown} (and, with
+ *   {@link StarsFutureConfig.compatibilityVersion} `3`, from the project's `tsdown.config.*` too).
+ * - `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` the `tsc` and `tsdown` build tools use, 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>;
+/**
+ * Options for `tsdown`, the bundler `stars build` uses by default.
+ *
+ * From {@link StarsFutureConfig.compatibilityVersion} `4` on these replace `tsdown.config.*` outright: the build is
+ * derived from `stars.config` (the entry's directory, `build.outDir`, `build.tsconfig`) and these options are layered
+ * on top, so a project keeps one configuration file instead of two. With `3` the project's own `tsdown.config.*` is
+ * still loaded and these are merged over it, the way `vite: {}` in a Nuxt config is merged into the project's own
+ * Vite config: values here win, and `plugins` are appended rather than replaced.
+ *
+ * The options named below are the ones a bot usually reaches for. Every other `tsdown` option is accepted as-is —
+ * the framework does not depend on `tsdown`, so they stay loosely typed here and `tsdown`'s own `UserConfig` is the
+ * reference.
+ */
+interface StarsTsdownConfig {
+  /** Entry files or glob patterns, relative to the project root. Defaults to every source file next to `entry`. */
+  entry?: string | readonly string[] | Record<string, string>;
+  /** @default 'esm' */
+  format?: 'esm' | 'cjs' | 'iife' | 'umd' | readonly string[] | Record<string, unknown>;
+  /** @default 'node' */
+  platform?: 'node' | 'neutral' | 'browser';
+  target?: string | readonly string[] | false;
+  /**
+   * Emits one output file per source file instead of a single bundle, so pieces stay loadable from `dist/commands`
+   * and friends at runtime.
+   * @default true
+   */
+  unbundle?: boolean;
+  /** Rolldown plugins. Appended to the ones `stars` adds (auto imports) and to those of a `tsdown.config.*`. */
+  plugins?: readonly unknown[];
+  alias?: Record<string, string>;
+  define?: Record<string, string>;
+  external?: unknown;
+  noExternal?: unknown;
+  deps?: Record<string, unknown>;
+  /** @default () => ({ js: extname(build.output) }) */
+  outExtensions?: unknown;
+  /** @default true */
+  sourcemap?: boolean | 'inline' | 'hidden';
+  minify?: unknown;
+  /** @default false — a bot is not a library, so no declaration files are emitted. */
+  dts?: boolean | Record<string, unknown>;
+  /** @default true */
+  clean?: boolean | readonly string[];
+  treeshake?: boolean;
+  copy?: unknown;
+  hooks?: Record<string, unknown>;
+  [option: string]: unknown;
+}
+/**
+ * The build-default generation the project runs on. Version 5 is current and version 4 remains supported.
+ * Version 3 is end-of-life: it still resolves, with a warning, and is removed in the next major.
+ */
+type StarsCompatibilityVersion = 3 | 4 | 5;
+/**
+ * Nuxt-style compatibility block. New projects need not set it; version 4 stays available, and version 3 is kept only
+ * as an end-of-life migration escape hatch for projects that still use a standalone `tsdown.config.*`.
+ */
+interface StarsFutureConfig {
+  /**
+   * The major whose defaults apply.
+   *
+   * `5` is the default: everything in `4`, plus `env` registered automatically in the built entry
+   * (see {@link StarsConfig.env}) when the project depends on `@wolfstar/env-utilities`.
+   *
+   * `4`:
+   * - auto imports are on by default with the `tsdown` build tool ({@link StarsImportsConfig}), and the
+   *   `autoImports()` plugin is wired into the build by `stars` itself.
+   * - `tsdown` is configured from {@link StarsConfig.tsdown} only. A `tsdown.config.*` in the project root is
+   *   rejected rather than silently ignored, so a build never loses the plugins it declares.
+   * - `build.tool: 'auto'` resolves to `tsdown` for any TypeScript entry, without looking for a `tsdown.config.*`
+   *   or a `tsdown` dependency first.
+   * - `env` is opt-in.
+   *
+   * `3` (**end-of-life**) keeps the legacy behaviour: auto imports off unless asked for, and a `tsdown.config.*`
+   * loaded and merged with {@link StarsConfig.tsdown}. It prints a warning and is removed in the next major.
+   * @default 5
+   */
+  compatibilityVersion?: StarsCompatibilityVersion;
+}
+/**
+ * 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 {
+  /** Custom terminal wordmark (one or more lines), or `false` to hide it. Defaults to the Stars wordmark. */
+  banner?: string | readonly string[] | false;
+  /**
+   * 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 `src/.env*`/`.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/decorators', '@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 {
+  /** Additional Nitro options (routeRules, runtimeConfig, storage, publicAssets, hooks, etc.).
+   * Use `defineNitroConfig` from `@wolfstar/nitro-server` for upstream option completion.
+   * Stars owns rootDir, serverEntry, output.dir and the reserved virtual entry.
+   */
+  [option: string]: unknown;
+  /**
+   * `'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 diagnostic 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 `Client#fetch` — 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). Nitro v3 is itself a Vite plugin, so
+   * this builds through the project's own `vite.config.*`/{@link StarsConfig.vite} the same way `build.tool:
+   * 'vite'` does, with a generated server entry that wraps the entry's default export (the `Client`
+   * instance, already `load()`ed rather than `listen()`ed — `stars build`/`stars dev` own the socket) in a
+   * call to `Client#fetch` — no per-preset adapter to maintain.
+   *
+   * Output goes to `.output/` (Nitro's own convention) instead of `build.outDir`. `stars dev` rebuilds and
+   * restarts on every change, the same as the other build tools.
+   */
+  enableNitro: true;
+  /** Nitro-specific options, reachable only with `enableNitro: true`. */
+  nitro?: StarsNitroConfig;
+};
+/**
+ * The serializable subset of `@wolfstar/env-utilities`' `EnvSetupOptions`. These options are written into the built
+ * entry as JSON, which is why `path` is a string only and `processEnv` is not available. A type test in
+ * `@wolfstar/env-utilities` keeps the two in sync.
+ */
+interface StarsEnvSetupOptions {
+  /**
+   * A custom `.env` path. Kept relative: `@wolfstar/env-utilities` resolves it against the bot's working directory
+   * at runtime, so the build output does not depend on the machine it was built on.
+   * @default `src/.env*`, then `.env*`
+   */
+  path?: string;
+  /** A custom environment name, when `NODE_ENV` is not sufficient. */
+  env?: string;
+  /** Only keep the variables starting with this prefix (e.g. `BOT_`). */
+  prefix?: string;
+  /**
+   * **Experimental.** `'varlock'` resolves the environment through [varlock](https://varlock.dev) instead of dotenv.
+   * @default 'dotenv'
+   */
+  loader?: 'dotenv' | 'varlock';
+  /** Logs every file loaded and every prefix match. */
+  debug?: boolean;
+  /**
+   * The encoding of the `.env` files.
+   * @default 'utf8'
+   */
+  encoding?: string;
+}
+/**
+ * The environment `stars` registers in the built entry before any other module runs, the way a hand-written
+ * `setup()` from `@wolfstar/env-utilities` would. On by default from `future.compatibilityVersion: 5` when the project
+ * depends on `@wolfstar/env-utilities`, except with `experimental.enableNitro`.
+ */
+interface StarsEnvConfig extends StarsEnvSetupOptions {
+  /** `false` turns the automatic registration off while keeping the options (e.g. for `stars dev`'s port lookup). */
+  enabled?: boolean;
+}
+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). On by default with
+   * `future.compatibilityVersion` 4 and later.
+   */
+  imports?: StarsImportsConfig | boolean;
+  /**
+   * `@wolfstar/env-utilities` options, registered automatically before the bot's own modules run.
+   * `false` disables the automatic registration, `true` forces it on with defaults.
+   */
+  env?: StarsEnvConfig | boolean;
+  /**
+   * Lifecycle hooks of the `stars` CLI (see `StarsHooks`), keyed by full name (`'build:done'`) or nested under
+   * their namespace (`{ build: { done() {} } }`). Each value is a function or an array of functions.
+   */
+  hooks?: StarsHooksConfig;
+  /** Opt-in flags for behaviour that is still landing. */
+  experimental?: StarsExperimentalConfig;
+  /** Build-default compatibility. Omit for version 5; version 3 is end-of-life and only meant for migrating a standalone tsdown config. */
+  future?: StarsFutureConfig;
+  /**
+   * 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;
+  /**
+   * The project's `tsdown` build. Replaces `tsdown.config.*` from `future.compatibilityVersion: 4` on, and is merged
+   * over it with `3`. Only used with `build.tool: 'tsdown'`.
+   */
+  tsdown?: StarsTsdownConfig;
+}
+//#endregion
+//#region src/config.d.ts
+/**
+ * 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
+export { EOL_COMPATIBILITY_VERSIONS as $, BuilderLogLevel as A, ResolvedStarsConfig as B, StarsHooks as C, Builder as D, BuildOutcome as E, ResolvedDevConfig as F, resolveStarsConfig as G, ResolvedTypecheckConfig as H, ResolvedExperimentalConfig as I, resolveHooks as J, ResolvedHooksConfig as K, ResolvedI18nCodegenConfig as L, ResolveConfigOptions as M, ResolvedBuildConfig as N, BuilderContext as O, ResolvedCodegenConfig as P, DEFAULT_COMPATIBILITY_VERSION as Q, ResolvedImportsConfig as R, StarsHookNamespace as S, StarsRestartReason as T, displayPath as U, ResolvedTunnelConfig as V, readProjectEnvFiles as W, resolveEnv as X, ResolvedEnvConfig as Y, AUTO_ENV_VERSION as Z, StarsTypecheckConfig as _, StarsCompatibilityVersion as a, PrepareProjectResult as b, StarsEnvConfig as c, StarsFutureConfig as d, LATEST_COMPATIBILITY_VERSION as et, StarsI18nCodegenConfig as f, StarsTunnelConfig as g, StarsTsdownConfig as h, StarsCodegenConfig as i, PackageJsonLike as j, BuilderEvents as k, StarsEnvSetupOptions as l, StarsNitroConfig as m, StarsBuildConfig as n, ResolvedFutureConfig as nt, StarsConfig as o, StarsImportsConfig as p, STARS_HOOK_NAMES as q, StarsBuildTool as r, STARS_CONFIG_TSDOWN_VERSION as rt, StarsDevConfig as s, defineConfig as t, LEGACY_COMPATIBILITY_VERSION as tt, StarsExperimentalConfig as u, StarsTypechecker as v, StarsHooksConfig as w, StarsHookName as x, StarsViteConfig as y, ResolvedNitroConfig as z };
+//# sourceMappingURL=config-Ctpk84fx.d.ts.map