webanvil 0.0.6 → 0.0.7

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/cli.mjs

@@ -0,0 +1,30 @@
+import { build_default, check_default, clean_default, dev_default, format_default, lint_default, logger, preview_default, test_default, typecheck_default } from "./_chunks/commands.mjs";
+import { execute } from "cmdore";
+import { fileURLToPath } from "node:url";
+import { readPackageJSON } from "pkg-types";
+const main = async (...varargs) => {
+	const packageJson = await readPackageJSON(fileURLToPath(new URL("..", import.meta.url)));
+	return execute([
+		build_default,
+		check_default,
+		clean_default,
+		dev_default,
+		format_default,
+		lint_default,
+		preview_default,
+		test_default,
+		typecheck_default
+	], {
+		argv: varargs,
+		metadata: {
+			name: packageJson.name ?? "webanvil",
+			version: packageJson.version
+		},
+		onError: "throw"
+	});
+};
+main(...process.argv.slice(2)).then((code) => process.exit(code)).catch((error) => {
+	logger.error(error instanceof Error ? error.message : String(error));
+	process.exit(1);
+});
+export {};

package/dist/index.d.mts

@@ -0,0 +1,646 @@
+import { rename } from "node:fs/promises";
+import { z } from "zod";
+import { TsconfigJson } from "get-tsconfig";
+import { InlineConfig, PluginOption, UserConfig as UserConfig$1 } from "vite";
+import { OxfmtConfig } from "oxfmt";
+import { OxlintConfig } from "oxlint";
+import { InputOptions, OutputOptions, Plugin } from "rolldown";
+import { TestUserConfig } from "vitest/config";
+import { IsolatedDeclarationsOptions } from "rolldown/experimental";
+declare const entry$1: {
+  readonly name: "entry";
+  readonly description: "Web entry or Node public root; unbundled Node builds emit its reachable graph with preserveModules.";
+};
+declare const filters: {
+  readonly name: "filters";
+  readonly description: "Test files or names to run.";
+  readonly variadic: true;
+};
+declare const paths: {
+  readonly name: "paths";
+  readonly description: "Files or directories to check.";
+  readonly variadic: true;
+};
+type WebAnvilUnplugin<Options> = {
+  rolldown: (options: Options) => Plugin | Plugin[];
+  vite: (options: Options) => PluginOption;
+};
+type UnpluginAdapter = {
+  rolldown: () => Plugin | Plugin[];
+  vite: () => PluginOption;
+};
+type WebAnvilPlugin = PluginOption | UnpluginAdapter;
+declare const definePlugin: <Options>(plugin: WebAnvilUnplugin<Options>, options: Options) => UnpluginAdapter;
+declare const isUnpluginAdapter: (plugin: unknown) => plugin is UnpluginAdapter;
+declare const isWebAnvilPlugin: (plugin: unknown) => plugin is WebAnvilPlugin;
+declare const resolveRolldownPlugins: (plugins: WebAnvilPlugin[]) => Plugin[];
+declare const resolveVitePlugins: (plugins: WebAnvilPlugin[]) => PluginOption[];
+type ToolName = "vite" | "vitest" | "rolldown" | "oxlint" | "oxfmt" | "typescript" | "typescript-native";
+type ToolSource = "project" | "webanvil";
+type ResolvedTool = {
+  name: ToolName;
+  packageName: string;
+  version: string;
+  source: ToolSource;
+  packageRoot: string;
+  import<T>(subpath?: string): Promise<T>;
+  executable?: string;
+};
+declare class Toolchain {
+  #private;
+  readonly cwd: string;
+  constructor(cwd?: string);
+  resolve(name: ToolName): Promise<ResolvedTool>;
+}
+type DeclarationLogger = {
+  info: (...arguments_: unknown[]) => void;
+  warn: (...arguments_: unknown[]) => void;
+  error: (...arguments_: unknown[]) => void;
+};
+type DeclarationVolarPlugin = {
+  extensionPatterns: RegExp[];
+  tsFileExtensionInfos?: Array<{
+    extension: string;
+    isMixedContent: boolean;
+    scriptKind?: number;
+  }>;
+  volarTypeScript?: object;
+  create?: (...arguments_: never[]) => unknown;
+  toTsFilename?: (id: string) => string;
+};
+type DeclarationConfig = {
+  generator?: "tsc" | "oxc" | "tsgo";
+  dtsInput?: boolean;
+  tsconfig?: string | boolean;
+  tsconfigRaw?: Omit<TsconfigJson, "compilerOptions">;
+  compilerOptions?: TsconfigJson.CompilerOptions;
+  sourcemap?: boolean;
+  resolver?: "oxc" | "tsc";
+  cjsDefault?: boolean;
+  sideEffects?: boolean;
+  logger?: DeclarationLogger;
+  build?: boolean;
+  incremental?: boolean;
+  vue?: boolean;
+  eager?: boolean;
+  newContext?: boolean;
+  emitJs?: boolean;
+  oxc?: boolean | Omit<IsolatedDeclarationsOptions, "sourcemap">;
+  tsgo?: boolean | {
+    path?: string;
+  };
+  volarPlugins?: DeclarationVolarPlugin[];
+};
+declare const copyMappingSchema: z.ZodObject<{
+  from: z.ZodString;
+  to: z.ZodString;
+}, z.core.$strict>;
+type SyntaxTarget = string | string[];
+declare const assertSyntaxTarget: (target: SyntaxTarget | undefined) => void;
+declare const syntaxTargetSchema: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+declare const buildConfigSchema: z.ZodObject<{
+  bundle: z.ZodOptional<z.ZodBoolean>;
+  mode: z.ZodOptional<z.ZodEnum<{
+    web: "web";
+    node: "node";
+  }>>;
+  entry: z.ZodOptional<z.ZodString>;
+  entries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  outDir: z.ZodOptional<z.ZodString>;
+  declaration: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCustom<DeclarationConfig, DeclarationConfig>]>>;
+  sourcemap: z.ZodOptional<z.ZodBoolean>;
+  minify: z.ZodOptional<z.ZodBoolean>;
+  copy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+  }, z.core.$strict>>>;
+  formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+    esm: "esm";
+    cjs: "cjs";
+  }>>>;
+  platform: z.ZodOptional<z.ZodEnum<{
+    node: "node";
+    browser: "browser";
+    neutral: "neutral";
+  }>>;
+  target: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strict>;
+type RolldownConfig = {
+  input?: Omit<InputOptions, "cwd" | "input">;
+  output?: Partial<Record<"esm" | "cjs", Omit<OutputOptions, "cleanDir" | "dir" | "format" | "preserveModules" | "preserveModulesRoot">>>;
+};
+type LintConfig = Omit<OxlintConfig, "extends"> & {
+  extends?: Array<OxlintConfig | string>;
+};
+declare const formatConfigSchema: z.ZodCustom<OxfmtConfig, OxfmtConfig>;
+declare const lintConfigSchema: z.ZodCustom<LintConfig, LintConfig>;
+declare const rolldownConfigSchema: z.ZodCustom<RolldownConfig, RolldownConfig>;
+declare const testConfigSchema: z.ZodCustom<TestUserConfig, TestUserConfig>;
+declare const viteConfigSchema: z.ZodCustom<UserConfig$1, UserConfig$1>;
+declare const userConfigSchema: z.ZodObject<{
+  build: z.ZodOptional<z.ZodObject<{
+    bundle: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodEnum<{
+      web: "web";
+      node: "node";
+    }>>;
+    entry: z.ZodOptional<z.ZodString>;
+    entries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    outDir: z.ZodOptional<z.ZodString>;
+    declaration: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCustom<DeclarationConfig, DeclarationConfig>]>>;
+    sourcemap: z.ZodOptional<z.ZodBoolean>;
+    minify: z.ZodOptional<z.ZodBoolean>;
+    copy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      from: z.ZodString;
+      to: z.ZodString;
+    }, z.core.$strict>>>;
+    formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+      esm: "esm";
+      cjs: "cjs";
+    }>>>;
+    platform: z.ZodOptional<z.ZodEnum<{
+      node: "node";
+      browser: "browser";
+      neutral: "neutral";
+    }>>;
+    target: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+  }, z.core.$strict>>;
+  format: z.ZodOptional<z.ZodCustom<OxfmtConfig, OxfmtConfig>>;
+  lint: z.ZodOptional<z.ZodCustom<LintConfig, LintConfig>>;
+  rolldown: z.ZodOptional<z.ZodCustom<RolldownConfig, RolldownConfig>>;
+  test: z.ZodOptional<z.ZodCustom<TestUserConfig, TestUserConfig>>;
+  vite: z.ZodOptional<z.ZodCustom<UserConfig$1, UserConfig$1>>;
+  plugins: z.ZodOptional<z.ZodArray<z.ZodCustom<WebAnvilPlugin, WebAnvilPlugin>>>;
+}, z.core.$strict>;
+declare const effectiveUserConfigSchema: z.ZodObject<{
+  build: z.ZodOptional<z.ZodObject<{
+    bundle: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodEnum<{
+      web: "web";
+      node: "node";
+    }>>;
+    entry: z.ZodOptional<z.ZodString>;
+    entries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    outDir: z.ZodOptional<z.ZodString>;
+    declaration: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCustom<DeclarationConfig, DeclarationConfig>]>>;
+    sourcemap: z.ZodOptional<z.ZodBoolean>;
+    minify: z.ZodOptional<z.ZodBoolean>;
+    copy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      from: z.ZodString;
+      to: z.ZodString;
+    }, z.core.$strict>>>;
+    formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+      esm: "esm";
+      cjs: "cjs";
+    }>>>;
+    platform: z.ZodOptional<z.ZodEnum<{
+      node: "node";
+      browser: "browser";
+      neutral: "neutral";
+    }>>;
+    target: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+  }, z.core.$strict>>;
+  format: z.ZodOptional<z.ZodCustom<OxfmtConfig, OxfmtConfig>>;
+  lint: z.ZodOptional<z.ZodCustom<LintConfig, LintConfig>>;
+  rolldown: z.ZodOptional<z.ZodCustom<RolldownConfig, RolldownConfig>>;
+  test: z.ZodOptional<z.ZodCustom<TestUserConfig, TestUserConfig>>;
+  vite: z.ZodOptional<z.ZodCustom<UserConfig$1, UserConfig$1>>;
+  plugins: z.ZodOptional<z.ZodArray<z.ZodCustom<WebAnvilPlugin, WebAnvilPlugin>>>;
+}, z.core.$strict>;
+type BuildConfig = z.infer<typeof buildConfigSchema>;
+type CopyMapping = z.infer<typeof copyMappingSchema>;
+type FormatConfig = OxfmtConfig;
+type TestConfig = TestUserConfig;
+type ViteConfig = UserConfig$1;
+type UserConfig = z.infer<typeof userConfigSchema>;
+type UserConfigFactory = () => UserConfig | Promise<UserConfig>;
+type ConfigExport = UserConfig | UserConfigFactory;
+type ResolvedConfig = {
+  config: UserConfig;
+  configFile?: string;
+};
+type CommandArguments = Record<string, unknown>;
+type ConfigSection = BuildConfig | FormatConfig | LintConfig | TestConfig;
+type ResolvedArguments<TArguments extends CommandArguments> = { [TKey in keyof TArguments]-?: Exclude<TArguments[TKey], undefined>; };
+declare const defaultConfig: {
+  build: {
+    mode: "node";
+    entry: string;
+    outDir: string;
+  };
+  test: {
+    environment: "node";
+  };
+};
+declare const loadConfig: (cwd?: string) => Promise<ResolvedConfig>;
+declare const resolveEffectiveBuildConfig: (config: UserConfig, overrides: BuildConfig, explicitEntry: boolean) => BuildConfig;
+declare const withConfig: <TConfig extends ConfigSection, TArguments extends CommandArguments, TResult>(select: (config: UserConfig) => TConfig | undefined, run: (arguments_: ResolvedArguments<TArguments>, config: TConfig, resolvedConfig: UserConfig, explicitArguments: TArguments) => TResult | Promise<TResult>) => (arguments_: TArguments) => Promise<TResult>;
+type NodeBuildOptions = Pick<BuildConfig, "bundle" | "copy" | "declaration" | "entries" | "formats" | "minify" | "platform" | "sourcemap" | "target">;
+type BuildOptions = NodeBuildOptions;
+type ViteApi = typeof import("vite");
+type ExplicitWebBuild = Partial<BuildOptions> & {
+  entry?: string;
+  outDir?: string;
+};
+type WebBuild = {
+  config: InlineConfig;
+  emptyOutDir: boolean;
+  outDir: string;
+  publicDir?: string;
+  vite: ViteApi;
+};
+declare const build: {
+  (mode: "web" | "node", entry: string, outDir: string, options?: BuildOptions, plugins?: WebAnvilPlugin[], viteConfig?: UserConfig$1, rolldownConfig?: RolldownConfig, toolchain?: Toolchain, explicit?: ExplicitWebBuild): Promise<void>;
+  webConfig(entry: string, outDir: string, options: BuildOptions, plugins: WebAnvilPlugin[], viteConfig?: UserConfig$1, toolchain?: Toolchain, explicit?: ExplicitWebBuild): Promise<WebBuild>;
+  publicOutputFiles({ outDir, publicDir }: WebBuild): Promise<string[]>;
+  web(web: WebBuild): Promise<string[]>;
+};
+declare const _default: import("cmdore").Command<readonly [{
+  readonly name: "mode";
+  readonly description: "Build mode: web uses Vite and node uses Rolldown.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodEnum<{
+    web: "web";
+    node: "node";
+  }>;
+}, {
+  readonly name: "out-dir";
+  readonly description: "Directory where the build output is written.";
+  readonly arity: 1;
+}, {
+  readonly name: "bundle";
+  readonly description: "Bundle the Node public roots; without it, emit their reachable graph with preserveModules.";
+  readonly arity: 0;
+}, {
+  readonly name: "no-bundle";
+  readonly description: "Emit the reachable Node graph with preserveModules, overriding configuration that enables bundling.";
+  readonly arity: 0;
+}, {
+  readonly name: "copy";
+  readonly description: "Copy source=destination mappings after the build.";
+  readonly schema: import("zod").ZodPipe<import("zod").ZodArray<import("zod").ZodString>, import("zod").ZodTransform<{
+    from: string;
+    to: string;
+  }[], string[]>>;
+}, {
+  readonly name: "declaration";
+  readonly description: "Emit TypeScript declarations for a Node build.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodPipe<import("zod").ZodEnum<{
+    true: "true";
+    false: "false";
+  }>, import("zod").ZodTransform<boolean, "true" | "false">>;
+}, {
+  readonly name: "sourcemap";
+  readonly description: "Generate source maps: true or false.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodPipe<import("zod").ZodEnum<{
+    true: "true";
+    false: "false";
+  }>, import("zod").ZodTransform<boolean, "true" | "false">>;
+}, {
+  readonly name: "minify";
+  readonly description: "Minify the build output: true or false.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodPipe<import("zod").ZodEnum<{
+    true: "true";
+    false: "false";
+  }>, import("zod").ZodTransform<boolean, "true" | "false">>;
+}, {
+  readonly name: "formats";
+  readonly description: "Comma-separated Node output formats: esm,cjs.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodPipe<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string[], string>>, import("zod").ZodArray<import("zod").ZodEnum<{
+    esm: "esm";
+    cjs: "cjs";
+  }>>>;
+}, {
+  readonly name: "platform";
+  readonly description: "Node build platform: node, browser, or neutral.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodEnum<{
+    node: "node";
+    browser: "browser";
+    neutral: "neutral";
+  }>;
+}, {
+  readonly name: "target";
+  readonly description: "Production syntax target, or comma-separated targets.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodPipe<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string | string[], string>>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
+}], readonly [{
+  readonly name: "entry";
+  readonly description: "Web entry or Node public root; unbundled Node builds emit its reachable graph with preserveModules.";
+}]>;
+type CheckConfig = Pick<UserConfig, "format" | "lint">;
+declare const checkProject: (fixFiles?: boolean, config?: CheckConfig) => Promise<void>;
+declare const _default$1: import("cmdore").Command<readonly [{
+  readonly name: "fix";
+  readonly description: "Format files and apply safe lint fixes.";
+  readonly arity: 0;
+}], readonly import("cmdore").Argument[]>;
+declare const clean: () => Promise<void>;
+declare const _default$2: import("cmdore").Command<readonly import("cmdore").Option[], readonly import("cmdore").Argument[]>;
+declare const dev: {
+  (mode: "web" | "node", entry: string, outDir: string, host?: string, port?: number, plugins?: WebAnvilPlugin[], options?: NodeBuildOptions, viteConfig?: UserConfig$1, rolldownConfig?: RolldownConfig, toolchain?: Toolchain): Promise<void>;
+  web(host?: string, port?: number, plugins?: WebAnvilPlugin[], waitForTermination?: () => Promise<void>, viteConfig?: UserConfig$1, toolchain?: Toolchain): Promise<void>;
+  node(entry: string, outDir: string, plugins?: WebAnvilPlugin[], waitForTermination?: () => Promise<void>, options?: NodeBuildOptions, rolldownConfig?: RolldownConfig, toolchain?: Toolchain): Promise<void>;
+};
+declare const _default$3: import("cmdore").Command<readonly [{
+  readonly name: "mode";
+  readonly description: "Build mode: web uses Vite and node uses Rolldown.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodEnum<{
+    web: "web";
+    node: "node";
+  }>;
+}, {
+  readonly name: "out-dir";
+  readonly description: "Directory where the build output is written.";
+  readonly arity: 1;
+}, {
+  readonly name: "host";
+  readonly description: "Host interface for the web server.";
+  readonly arity: 1;
+}, {
+  readonly name: "port";
+  readonly description: "Port for the web server.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodCoercedNumber<unknown>;
+}, {
+  readonly name: "bundle";
+  readonly description: "Bundle the Node public roots; without it, emit their reachable graph with preserveModules.";
+  readonly arity: 0;
+}, {
+  readonly name: "no-bundle";
+  readonly description: "Emit the reachable Node graph with preserveModules, overriding configuration that enables bundling.";
+  readonly arity: 0;
+}, {
+  readonly name: "copy";
+  readonly description: "Copy source=destination mappings after the build.";
+  readonly schema: import("zod").ZodPipe<import("zod").ZodArray<import("zod").ZodString>, import("zod").ZodTransform<{
+    from: string;
+    to: string;
+  }[], string[]>>;
+}, {
+  readonly name: "declaration";
+  readonly description: "Emit TypeScript declarations for a Node build.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodPipe<import("zod").ZodEnum<{
+    true: "true";
+    false: "false";
+  }>, import("zod").ZodTransform<boolean, "true" | "false">>;
+}, {
+  readonly name: "sourcemap";
+  readonly description: "Generate source maps: true or false.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodPipe<import("zod").ZodEnum<{
+    true: "true";
+    false: "false";
+  }>, import("zod").ZodTransform<boolean, "true" | "false">>;
+}, {
+  readonly name: "minify";
+  readonly description: "Minify the build output: true or false.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodPipe<import("zod").ZodEnum<{
+    true: "true";
+    false: "false";
+  }>, import("zod").ZodTransform<boolean, "true" | "false">>;
+}, {
+  readonly name: "formats";
+  readonly description: "Comma-separated Node output formats: esm,cjs.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodPipe<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string[], string>>, import("zod").ZodArray<import("zod").ZodEnum<{
+    esm: "esm";
+    cjs: "cjs";
+  }>>>;
+}, {
+  readonly name: "platform";
+  readonly description: "Node build platform: node, browser, or neutral.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodEnum<{
+    node: "node";
+    browser: "browser";
+    neutral: "neutral";
+  }>;
+}, {
+  readonly name: "target";
+  readonly description: "Production syntax target, or comma-separated targets.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodPipe<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string | string[], string>>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
+}], readonly [{
+  readonly name: "entry";
+  readonly description: "Web entry or Node public root; unbundled Node builds emit its reachable graph with preserveModules.";
+}]>;
+declare const format: (paths: string[], check?: boolean, config?: FormatConfig) => Promise<void>;
+declare const _default$4: import("cmdore").Command<readonly [{
+  readonly name: "check";
+  readonly description: "Check formatting without writing files.";
+  readonly arity: 0;
+}], readonly [{
+  readonly name: "paths";
+  readonly description: "Files or directories to check.";
+  readonly variadic: true;
+}]>;
+declare const lint: (paths: string[], fix?: boolean, config?: LintConfig) => Promise<void>;
+declare const _default$5: import("cmdore").Command<readonly [{
+  readonly name: "fix";
+  readonly description: "Apply safe lint fixes.";
+  readonly arity: 0;
+}], readonly [{
+  readonly name: "paths";
+  readonly description: "Files or directories to check.";
+  readonly variadic: true;
+}]>;
+declare const preview: (outDir: string, host?: string, port?: number, useOutDir?: boolean, waitForTermination?: () => Promise<void>, openBrowser?: boolean, viteConfig?: UserConfig$1) => Promise<void>;
+declare const _default$6: import("cmdore").Command<readonly [{
+  readonly name: "out-dir";
+  readonly description: "Directory where the build output is written.";
+  readonly arity: 1;
+}, {
+  readonly name: "host";
+  readonly description: "Host interface for the web server.";
+  readonly arity: 1;
+}, {
+  readonly name: "port";
+  readonly description: "Port for the web server.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodCoercedNumber<unknown>;
+}, {
+  readonly name: "open";
+  readonly description: "Open the preview in the browser.";
+  readonly arity: 0;
+}], readonly import("cmdore").Argument[]>;
+declare const test: (filters: string[], config?: TestConfig, options?: {
+  coverage?: boolean;
+  environment?: TestConfig["environment"];
+  ui?: boolean;
+  uiPort?: number;
+  watch?: boolean;
+}, waitForTermination?: () => Promise<void>) => Promise<void>;
+declare const _default$7: import("cmdore").Command<readonly [{
+  readonly name: "environment";
+  readonly description: "Vitest environment to use for this run.";
+  readonly arity: 1;
+}, {
+  readonly name: "watch";
+  readonly description: "Watch test files and rerun affected tests.";
+  readonly arity: 0;
+}, {
+  readonly name: "coverage";
+  readonly description: "Collect test coverage with V8.";
+  readonly arity: 0;
+}, {
+  readonly name: "ui";
+  readonly description: "Start the Vitest user interface.";
+  readonly arity: 0;
+}, {
+  readonly name: "ui-port";
+  readonly description: "Port for the Vitest user interface.";
+  readonly arity: 1;
+  readonly schema: import("zod").ZodCoercedNumber<unknown>;
+}], readonly [{
+  readonly name: "filters";
+  readonly description: "Test files or names to run.";
+  readonly variadic: true;
+}]>;
+declare const typecheck: (paths: string[]) => Promise<void>;
+declare const _default$8: import("cmdore").Command<readonly import("cmdore").Option[], readonly [{
+  readonly name: "paths";
+  readonly description: "Files or directories to check.";
+  readonly variadic: true;
+}]>;
+declare const bundle$1: {
+  readonly name: "bundle";
+  readonly description: "Bundle the Node public roots; without it, emit their reachable graph with preserveModules.";
+  readonly arity: 0;
+};
+declare const check: {
+  readonly name: "check";
+  readonly description: "Check formatting without writing files.";
+  readonly arity: 0;
+};
+declare const copy: {
+  readonly name: "copy";
+  readonly description: "Copy source=destination mappings after the build.";
+  readonly schema: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<{
+    from: string;
+    to: string;
+  }[], string[]>>;
+};
+declare const coverage: {
+  readonly name: "coverage";
+  readonly description: "Collect test coverage with V8.";
+  readonly arity: 0;
+};
+declare const declaration: {
+  readonly name: "declaration";
+  readonly description: "Emit TypeScript declarations for a Node build.";
+  readonly arity: 1;
+  readonly schema: z.ZodPipe<z.ZodEnum<{
+    true: "true";
+    false: "false";
+  }>, z.ZodTransform<boolean, "true" | "false">>;
+};
+declare const environment: {
+  readonly name: "environment";
+  readonly description: "Vitest environment to use for this run.";
+  readonly arity: 1;
+};
+declare const formats$1: {
+  readonly name: "formats";
+  readonly description: "Comma-separated Node output formats: esm,cjs.";
+  readonly arity: 1;
+  readonly schema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>, z.ZodArray<z.ZodEnum<{
+    esm: "esm";
+    cjs: "cjs";
+  }>>>;
+};
+declare const fix: {
+  readonly name: "fix";
+  readonly description: "Apply safe lint fixes.";
+  readonly arity: 0;
+};
+declare const host: {
+  readonly name: "host";
+  readonly description: "Host interface for the web server.";
+  readonly arity: 1;
+};
+declare const minify$1: {
+  readonly name: "minify";
+  readonly description: "Minify the build output: true or false.";
+  readonly arity: 1;
+  readonly schema: z.ZodPipe<z.ZodEnum<{
+    true: "true";
+    false: "false";
+  }>, z.ZodTransform<boolean, "true" | "false">>;
+};
+declare const mode: {
+  readonly name: "mode";
+  readonly description: "Build mode: web uses Vite and node uses Rolldown.";
+  readonly arity: 1;
+  readonly schema: z.ZodEnum<{
+    web: "web";
+    node: "node";
+  }>;
+};
+declare const open: {
+  readonly name: "open";
+  readonly description: "Open the preview in the browser.";
+  readonly arity: 0;
+};
+declare const outDir$1: {
+  readonly name: "out-dir";
+  readonly description: "Directory where the build output is written.";
+  readonly arity: 1;
+};
+declare const platform$1: {
+  readonly name: "platform";
+  readonly description: "Node build platform: node, browser, or neutral.";
+  readonly arity: 1;
+  readonly schema: z.ZodEnum<{
+    node: "node";
+    browser: "browser";
+    neutral: "neutral";
+  }>;
+};
+declare const port: {
+  readonly name: "port";
+  readonly description: "Port for the web server.";
+  readonly arity: 1;
+  readonly schema: z.ZodCoercedNumber<unknown>;
+};
+declare const sourcemap$1: {
+  readonly name: "sourcemap";
+  readonly description: "Generate source maps: true or false.";
+  readonly arity: 1;
+  readonly schema: z.ZodPipe<z.ZodEnum<{
+    true: "true";
+    false: "false";
+  }>, z.ZodTransform<boolean, "true" | "false">>;
+};
+declare const target$1: {
+  readonly name: "target";
+  readonly description: "Production syntax target, or comma-separated targets.";
+  readonly arity: 1;
+  readonly schema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string | string[], string>>, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+};
+declare const ui: {
+  readonly name: "ui";
+  readonly description: "Start the Vitest user interface.";
+  readonly arity: 0;
+};
+declare const uiPort: {
+  readonly name: "ui-port";
+  readonly description: "Port for the Vitest user interface.";
+  readonly arity: 1;
+  readonly schema: z.ZodCoercedNumber<unknown>;
+};
+declare const watch: {
+  readonly name: "watch";
+  readonly description: "Watch test files and rerun affected tests.";
+  readonly arity: 0;
+};
+declare function defineConfig(config: UserConfig): UserConfig;
+declare function defineConfig(config: UserConfigFactory): UserConfigFactory;
+export { BuildConfig, ConfigExport, CopyMapping, FormatConfig, LintConfig, ResolvedConfig, RolldownConfig, SyntaxTarget, TestConfig, UnpluginAdapter, UserConfig, UserConfigFactory, ViteConfig, WebAnvilPlugin, WebAnvilUnplugin, assertSyntaxTarget, build, _default as buildCommand, buildConfigSchema, bundle$1 as bundle, check, _default$1 as checkCommand, checkProject, clean, _default$2 as cleanCommand, copy, copyMappingSchema, coverage, declaration, defaultConfig, defineConfig, definePlugin, dev, _default$3 as devCommand, effectiveUserConfigSchema, entry$1 as entry, environment, filters, fix, format, _default$4 as formatCommand, formatConfigSchema, formats$1 as formats, host, isUnpluginAdapter, isWebAnvilPlugin, lint, _default$5 as lintCommand, lintConfigSchema, loadConfig, minify$1 as minify, mode, open, outDir$1 as outDir, paths, platform$1 as platform, port, preview, _default$6 as previewCommand, resolveEffectiveBuildConfig, resolveRolldownPlugins, resolveVitePlugins, rolldownConfigSchema, sourcemap$1 as sourcemap, syntaxTargetSchema, target$1 as target, test, _default$7 as testCommand, testConfigSchema, typecheck, _default$8 as typecheckCommand, ui, uiPort, userConfigSchema, viteConfigSchema, watch, withConfig };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { assertSyntaxTarget, build, buildConfigSchema, build_default, bundle, check, checkProject, check_default, clean, clean_default, copy, copyMappingSchema, coverage, declaration, defaultConfig, defineConfig as defineConfig$1, definePlugin, dev, dev_default, effectiveUserConfigSchema, entry, environment, filters, fix, format, formatConfigSchema, format_default, formats, host, isUnpluginAdapter, isWebAnvilPlugin, lint, lintConfigSchema, lint_default, loadConfig, minify, mode, open, outDir, paths, platform, port, preview, preview_default, resolveEffectiveBuildConfig, resolveRolldownPlugins, resolveVitePlugins, rolldownConfigSchema, sourcemap, syntaxTargetSchema, target, test, testConfigSchema, test_default, typecheck, typecheck_default, ui, uiPort, userConfigSchema, viteConfigSchema, watch, withConfig } from "./_chunks/commands.mjs";
+function defineConfig(config) {
+	return defineConfig$1(config);
+}
+export { assertSyntaxTarget, build, build_default as buildCommand, buildConfigSchema, bundle, check, check_default as checkCommand, checkProject, clean, clean_default as cleanCommand, copy, copyMappingSchema, coverage, declaration, defaultConfig, defineConfig, definePlugin, dev, dev_default as devCommand, effectiveUserConfigSchema, entry, environment, filters, fix, format, format_default as formatCommand, formatConfigSchema, formats, host, isUnpluginAdapter, isWebAnvilPlugin, lint, lint_default as lintCommand, lintConfigSchema, loadConfig, minify, mode, open, outDir, paths, platform, port, preview, preview_default as previewCommand, resolveEffectiveBuildConfig, resolveRolldownPlugins, resolveVitePlugins, rolldownConfigSchema, sourcemap, syntaxTargetSchema, target, test, test_default as testCommand, testConfigSchema, typecheck, typecheck_default as typecheckCommand, ui, uiPort, userConfigSchema, viteConfigSchema, watch, withConfig };