auklet 0.0.18 → 0.0.20

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026-present, chentao.arthur.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -5,47 +5,133 @@
 
 </div>
 
-<h1></h1>
+auklet is a build tool for TypeScript packages. It wraps `tsdown` for
+JavaScript output, generates CSS style entries for package/module/theme output,
+provides module CSS auto imports, and includes a Vite dev plugin for virtual
+package CSS.
 
-Build utilities for TypeScript packages and module CSS output.
+It is designed for:
 
-## Features
+- single-package TypeScript libraries;
+- single-package component libraries;
+- pnpm monorepo TypeScript libraries;
+- pnpm monorepo component packages.
 
-- Build JavaScript/TypeScript package output with the bundled tsdown config.
-- Generate package-level and module-level CSS entries.
-- Infer component style dependencies from source imports.
-- Generate theme and external style entry files.
-- Provide a Vite dev plugin for virtual package CSS entries in single-package and monorepo projects.
-- Watch source/config changes and rebuild module CSS output.
-
-## Requirements
+Requirements:
 
 - Node.js `>=22`
+- pnpm for publish and owner workflows
+
+## Quick Start
+
+`auklet.config.ts` is optional. Without it, auklet uses `src` as source,
+`dist` as output, no module output, and default JavaScript formats.
+
+For a component package, a minimal config usually looks like this:
+
+```ts
+import type { AukletConfig } from 'auklet';
+
+export const config: AukletConfig = {
+  modules: true,
+};
+```
+
+Build JavaScript and CSS output:
+
+```bash
+auk build
+```
+
+Import generated CSS entries from the package:
+
+```ts
+import '@scope/ui/style.css';
+import '@scope/ui/components/Button.css';
+```
+
+Use the Vite plugin during local development:
+
+```ts
+import { aukletStylePlugin } from 'auklet';
+
+export default {
+  plugins: [aukletStylePlugin()],
+};
+```
 
 ## CLI
 
-The package exposes both `auk` and `auklet` commands.
+The package exposes both `auk` and `auklet`.
+
+| Command                 | Description                                                           |
+| ----------------------- | --------------------------------------------------------------------- |
+| `auk dev`               | Watch JavaScript and CSS output together.                             |
+| `auk build`             | Remove configured output, then build JavaScript and CSS.              |
+| `auk build-js`          | Run tsdown with auklet's built-in config unless `--config` is passed. |
+| `auk build-js --watch`  | Pass watch mode through to tsdown.                                    |
+| `auk build-css`         | Generate CSS output only.                                             |
+| `auk build-css --watch` | Watch source/config/style files and rebuild CSS.                      |
+| `auk publish`           | Run the pnpm-based publish workflow.                                  |
+| `auk owner add <user>`  | Add npm owners through pnpm.                                          |
+
+Build and dev commands can override package config for one run:
 
 ```bash
-pnpm auk --help
-pnpm auk build
-pnpm auk build-js
-pnpm auk build-css
-pnpm auk build-css --watch
-pnpm auk dev
+auk build --source source --output build --modules
+auk build --build.formats esm,cjs
+auk build --build.target es2022
+auk build --build.platform node
+auk build --build.tsconfig tsconfig.build.json
 ```
 
-Commands:
+Supported build override flags:
+
+| Flag                          | Description                                  |
+| ----------------------------- | -------------------------------------------- |
+| `--source <dir>`              | Source directory.                            |
+| `--output <dir>`              | Output directory.                            |
+| `--modules`                   | Enable unbundled module output.              |
+| `--no-modules`                | Disable unbundled module output.             |
+| `--build.formats <formats>`   | Comma-separated `cjs`, `esm`, and/or `iife`. |
+| `--build.target <target>`     | JavaScript target passed to tsdown.          |
+| `--build.platform <platform>` | `node`, `neutral`, or `browser`.             |
+| `--build.tsconfig <file>`     | TypeScript config file.                      |
 
-- `build` removes the configured `output` directory, builds JavaScript output, then builds CSS output.
-- `build-js` runs tsdown with the default auklet tsdown config unless a config flag is passed.
-- `build-css` generates module CSS output.
-- `build-css --watch` watches source/config files and rebuilds CSS.
-- `dev` runs JavaScript and CSS watch tasks together.
+Config precedence:
+
+```text
+CLI flags > auklet.config.ts > auklet defaults
+```
+
+`build-js` passes unknown flags through to tsdown. Auklet build override flags
+cannot be combined with tsdown custom config flags:
+
+```bash
+# not allowed
+auk build-js --source source --config tsdown.config.ts
+auk build-js --output build -c tsdown.config.ts
+auk build-js --modules --no-config
+```
+
+When `--config`, `-c`, or `--no-config` is used, tsdown owns the full build
+config. Use `auklet.config.ts` or tsdown config code directly instead of auklet
+CLI overrides.
+
+Publish controls stay on CLI flags:
+
+```bash
+auk publish --filter @scope/ui
+auk publish --version patch --dry-run
+auk publish --no-format
+```
+
+`--no-format` disables auklet's publish output formatter for that run. It is not
+configured in `package.json`.
 
 ## Configuration
 
-Create `auklet.config.ts` in the package root:
+`auklet.config.ts` is loaded from the current package root:
 
 ```ts
 import type { AukletConfig } from 'auklet';
@@ -54,7 +140,9 @@ export const config: AukletConfig = {
   source: 'src',
   output: 'dist',
   modules: true,
-  tsconfig: 'tsconfig.json',
+  build: {
+    formats: ['esm', 'cjs'],
+  },
   styles: {
     themes: {
       light: './src/themes/light.css',
@@ -65,115 +153,126 @@ export const config: AukletConfig = {
         entry: '/style.css',
         components: ['/components/**.css'],
       },
-      '@scope/theme': {
-        entry: '/style.css',
-        themes: {
-          light: '/themes/light.css',
-          dark: '/themes/dark.css',
-        },
-      },
-    },
-  },
-  build: {
-    alias: { ... },
-    globals: { ... },
-    target: 'es2020',
-    formats: ['esm', 'cjs'],
-    mainFields: ['browser', 'module', 'main'],
-    configureTsdown(config, context) {
-      if (context.kind !== 'bundle') return config;
-      return {
-        ...config,
-        sourcemap: true,
-      };
     },
   },
 };
 ```
 
-### Style Options
+Configuration reference:
+
+| Path                                  | Default                  | Description                                                                                                                 |
+| ------------------------------------- | ------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
+| `source`                              | `'src'`                  | Source directory relative to the current package root.                                                                      |
+| `output`                              | `'dist'`                 | Build output directory. `auk build` removes it before rebuilding.                                                           |
+| `modules`                             | `false`                  | Generate unbundled module JS output and module-level CSS output.                                                            |
+| `styles.themes`                       | `{}`                     | Current package theme entries, keyed by theme name. Values are paths relative to the current package root.                  |
+| `styles.dependencies`                 | `{}`                     | External package style rules, keyed by dependency package name.                                                             |
+| `styles.dependencies[pkg].entry`      | `undefined`              | Package-level style entry or entries from the dependency package.                                                           |
+| `styles.dependencies[pkg].themes`     | `undefined`              | Theme entries from the dependency package, keyed by current package theme name.                                             |
+| `styles.dependencies[pkg].components` | `undefined`              | Module CSS auto import rules. The name is historical; rules can point to paths such as `/pages/**.css` or `/blocks/**.css`. |
+| `build.formats`                       | `['cjs', 'esm', 'iife']` | Package-level bundle formats.                                                                                               |
+| `build.target`                        | `'es2020'`               | JavaScript target passed to tsdown.                                                                                         |
+| `build.platform`                      | `'neutral'`              | Runtime platform: `node`, `neutral`, or `browser`.                                                                          |
+| `build.banner`                        | generated                | Custom bundle banner.                                                                                                       |
+| `build.externals`                     | `[]`                     | Extra external package names combined with package dependencies.                                                            |
+| `build.alias`                         | `{}`                     | Path aliases passed to tsdown.                                                                                              |
+| `build.mainFields`                    | IIFE only                | Package entry field resolution order for bundle output.                                                                     |
+| `build.globals`                       | `{}`                     | Global names for IIFE externals.                                                                                            |
+| `build.tsconfig`                      | nearest `tsconfig.json`  | TypeScript config path relative to package root.                                                                            |
+| `build.configureTsdown`               | `undefined`              | Final hook for each generated tsdown config.                                                                                |
+
+Common dependency rule:
 
-- `source`: source directory relative to the package root. Defaults to `src`.
-- `output`: build output directory relative to the package root. Defaults to `dist`. `auk build` removes this directory before writing JavaScript and CSS output.
-- `styles.themes`: package theme style entries. Defaults to `{}`.
-- `styles.dependencies`: external package style dependencies. Defaults to `{}`.
+```ts
+{
+  entry: '/style.css',
+  components: ['/pages/**.css', '/components/**.css'],
+  themes: {
+    dark: '/themes/dark.css',
+    light: '/themes/light.css',
+  },
+}
+```
 
-Each `styles.dependencies` entry may define:
+`configureTsdown` receives the generated tsdown config and a context:
 
-- `entry`: package-level style dependency.
-- `themes`: theme style dependency map.
-- `components`: glob-like component style rules used to infer style imports from source imports.
+```ts
+type ConfigureTsdownContext = {
+  kind: 'bundle' | 'module';
+  format: 'cjs' | 'esm' | 'iife';
+  packageRoot: string;
+  output: string;
+  packageName?: string;
+};
+```
 
-Component style inference only scans source `.tsx` files. Component imports or
-re-exports in `.ts` files are ignored for CSS auto import, so component barrel
-files that should drive component CSS must be `.tsx`.
+## CSS Conventions And Limits
 
-Same-package component style inference resolves relative imports,
-`package.json#imports` mappings, and `tsconfig.json` `compilerOptions.paths`.
-For `package.json#imports`, the `source` condition is preferred when present.
-Only aliases that resolve into the current package source directory are treated
-as same-package CSS dependencies.
+CSS auto import only scans `.tsx` files. `.ts` and `.d.ts` files do not
+participate.
 
-Supported value forms include named imports, named re-exports, and local
-re-exports that can be traced back to an import binding:
+Supported source syntax:
 
 ```tsx
 import { Button } from '@scope/ui';
+import { Card as UICard } from '@scope/ui';
+import { Dialog } from '@scope/ui/components/Dialog';
+
+export { Button } from '@scope/ui';
 export { Card } from '@scope/ui/components/Card';
 
 import { Dialog as BaseDialog } from '@scope/ui';
 export { BaseDialog as Dialog };
 ```
 
-`export * from '...'` is intentionally not supported for CSS auto import because
-the exported component names cannot be inferred reliably.
-
-Style configuration should use the grouped `styles` field.
+Unsupported:
 
 ```ts
-export const config: AukletConfig = {
-  styles: {
-    dependencies: {
-      '@scope/ui': {
-        entry: '/style.css',
-        components: ['/components/**.css'],
-      },
-    },
-  },
-};
+export * from '@scope/ui/components/Button';
 ```
 
-### Build Options
+`export *` is intentionally unsupported because auklet cannot reliably infer the
+final exported component names, so it cannot infer CSS paths safely.
 
-- `modules`: whether to generate unbundled `dist/es` and `dist/lib` output. Defaults to `false`. CSS module style entries also follow this flag.
-- `build.formats`: package bundle formats: `esm`, `cjs`, or `iife`. Defaults to `['cjs', 'esm', 'iife']`.
-- `build.target`: JavaScript compilation target passed to tsdown. Defaults to `es2020` and is shared by bundle, global, and module output.
-- `build.platform`: build target runtime platform: `neutral`, `node`, or `browser`. Defaults to `neutral`.
-- `build.banner`: custom bundle banner. Defaults to a package name/version banner.
-- `build.externals`: additional external packages. Defaults to `[]`.
-- `build.alias`: path aliases passed to tsdown `alias`. Defaults to `{}`.
-- `build.mainFields`: bundle package entry resolution order passed to rolldown `resolve.mainFields`. When omitted, auklet only sets `['browser', 'module', 'main']` for IIFE bundles.
-- `build.globals`: IIFE external global names passed to tsdown `output.globals`. Values override auklet's generated global names.
-- `build.configureTsdown`: final customization hook for each generated tsdown config. It receives `(config, context)` and should return a tsdown config.
-- `build.tsconfig`: TypeScript config path relative to the package root. Defaults to the nearest `tsconfig.json` found from the package root upward.
+Inference rules:
 
-### Build Constants
+- Package-root named imports use the imported name. For example, `Button` from
+  `@scope/ui` tries `@scope/ui/components/Button.css`.
+- Local aliases do not affect package-root inference. `Button as UIButton`
+  still uses `Button`.
+- Deep imports use the import path. `@scope/ui/components/Button` tries
+  `@scope/ui/components/Button.css`.
+- Missing inferred CSS files are skipped.
+- Duplicate imports inferred from JS and handwritten source CSS are deduped.
 
-`auk build` injects these compile-time constants into bundled output:
+Same-package source imports can be resolved through:
 
-- `__DEV__`: `true` when `process.env.NODE_ENV !== 'production'`, otherwise `false`.
-- `__TEST__`: always `false` in package builds.
-- `__VERSION__`: current package version from `package.json`.
+- relative paths such as `../Button`;
+- `package.json#imports`, preferring the `source` condition;
+- `tsconfig.json` `compilerOptions.paths`.
+
+Only candidates resolved into the current package `source` directory are treated
+as same-package CSS dependencies.
+
+`build-css` handles CSS entry generation and simple `@import` expansion. It does
+not aim to replace a full CSS toolchain. In particular, keep these boundaries in
+mind:
 
-Vitest uses the same names with test-friendly values: `__DEV__` is `true`, `__TEST__` is `true`, and `__VERSION__` is `'unknown'`.
+- It does not process preprocessors such as Sass or Less.
+- It does not implement CSS Modules.
+- It does not perform URL rebasing.
+- It does not evaluate conditional CSS import semantics beyond auklet's style
+  entry rules.
+- It expects source CSS files and package/style paths to exist on disk.
 
 ## CSS Output
 
-`build-css` always generates the package-level `index.css` when source styles exist.
+`build-css` generates package-level `index.css` when source styles exist.
 
-Module style entries under `dist/es` and `dist/lib` are generated only when `modules` is `true`, matching the JavaScript module output.
+When `modules: true` is enabled, auklet also generates module-level CSS output
+under `dist/es` and `dist/lib`, aligned with JavaScript module output.
 
-Typical module output includes:
+Typical output structure:
 
 ```text
 dist/
@@ -194,18 +293,27 @@ dist/
     ...
 ```
 
-Important entry semantics:
+Entry semantics:
 
 - `index.css`: package-level aggregate CSS.
-- `style/index.css`: package style entry for a specific output format.
-- `style/module.css`: current package module styles.
-- `style/external.css`: external style entries.
-- `components/*/style/index.css`: component-level style entry.
+- `style/index.css`: style entry for the current format.
+- `style/module.css`: module styles from the current package.
+- `style/external.css`: external style entry.
 - `themes/*.css`: theme style entry.
+- `components/*/style/index.css`: module-level style entry. `components/` is a
+  common output path, not a restriction that the internal model only supports
+  components.
+
+If a generated CSS file is empty, auklet writes a placeholder comment so the
+output is not a completely empty file.
 
 ## Vite Plugin
 
-Use `aukletStylePlugin` in Vite dev mode to load virtual package CSS entries.
+`aukletStylePlugin` is the Vite dev entry point. It turns package CSS imports
+into virtual CSS modules. It only applies to the Vite dev server; production
+builds still use `auk build` or `auk build-css`.
+
+Single-package mode is the default:
 
 ```ts
 import { aukletStylePlugin } from 'auklet';
@@ -215,12 +323,8 @@ export default {
 };
 ```
 
-The plugin defaults to `mode: 'package'`, where Vite root is treated as the
-current package root. This is the expected setup for a single-package component
-library.
-
-For a workspace demo or app that imports CSS from packages under
-`packages/*`, enable monorepo mode:
+Use monorepo mode when a workspace demo/app needs to work with multiple
+workspace packages:
 
 ```ts
 import { aukletStylePlugin } from 'auklet';
@@ -230,96 +334,73 @@ export default {
 };
 ```
 
-`mode: 'monorepo'` automatically walks upward from Vite root to find
-`pnpm-workspace.yaml`. A custom graph root can be passed with `root` when the
-workspace root cannot be inferred.
+Primary options:
+
+| Option | Default     | Description                                                                                                                                         |
+| ------ | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mode` | `'package'` | `'package'` treats Vite root as the package root. `'monorepo'` finds `pnpm-workspace.yaml` upward from Vite root and reads pnpm workspace packages. |
+| `root` | inferred    | Custom graph root. Usually unnecessary.                                                                                                             |
 
-The plugin resolves package CSS ids such as:
+Supported dev CSS imports:
 
 ```ts
 import '@scope/app/style.css';
+import '@scope/app/external.css';
+import '@scope/app/module.css';
 import '@scope/app/components/Button.css';
 import '@scope/app/themes/light.css';
 ```
 
 In dev mode, workspace package style dependencies keep using auklet virtual CSS
-entries so changes can be tracked recursively. Third-party CSS dependencies are
-resolved from the package that declares the dependency and emitted as Vite
-`/@fs/...` imports, so packages such as `katex/dist/katex.min.css` do not need
-to be installed by the consuming app.
+recursion so style changes across packages can be tracked. Third-party CSS
+dependencies are resolved from the package root that declares them and emitted
+as Vite `/@fs/...` imports.
 
-## Examples
+## Build Constants
 
-The repository includes runnable examples for the supported project shapes:
+`auk build` injects these compile-time constants into bundles:
 
-- `examples/components`: monorepo component packages.
-- `examples/libs`: monorepo TypeScript libraries without CSS output.
-- `examples/single-package`: single-package component library with Vite dev mode.
-- `examples/single-lib`: single-package TypeScript library without CSS output.
-
-Useful commands:
+- `__DEV__`: `true` when `process.env.NODE_ENV !== 'production'`, otherwise
+  `false`.
+- `__TEST__`: always `false` in package builds.
+- `__VERSION__`: current package version.
 
-```bash
-pnpm run build:examples
-pnpm run test:examples
-pnpm run dev:examples
-```
+Vitest uses test-friendly values with the same names: `__DEV__` is `true`,
+`__TEST__` is `true`, and `__VERSION__` is `'unknown'`.
 
 ## Programmatic API
 
-```ts
-import {
-  ModuleStyleBuilder,
-  ModuleStyleWatcher,
-  aukletStylePlugin,
-  loadAukletConfig,
-  runTsdown,
-} from 'auklet';
-
-const aukletConfig = await loadAukletConfig(process.cwd());
-
-await new ModuleStyleBuilder({
-  packageRoot: process.cwd(),
-  aukletConfig,
-}).build();
-```
+The root package entry exposes the Vite plugin, configuration helpers, and a
+small set of build helpers used by projects that need to compose auklet
+programmatically. Publish and owner workflows remain CLI/internal implementation
+details.
 
 Public exports include:
 
-- `ModuleStyleBuilder`
-- `ModuleStyleWatcher`
 - `aukletStylePlugin`
 - `loadAukletConfig`
-- `resolveAukletConfigModule`
-- `createTsdownArgs`
 - `runTsdown`
-- related TypeScript types
+- `defineKernelPackageConfigFromFile`
+- `defineKernelPackageConfigFromOptions`
+- `runAukletCli`
+- `AukletStylePluginOptions`
+- `AukletConfig`
+- `PackageBuildOptions`
+- `StyleOptions`
+- related user-facing TypeScript types
 
 ## Development
 
 ```bash
 pnpm i
-pnpm run test
-pnpm run typecheck
-pnpm run build
+pnpm test
+pnpm typecheck
+pnpm build
 pnpm run format
 ```
 
 Notes:
 
-- `pnpm run build` rewrites `dist`.
-- `pnpm run format` formats `bin`, `src`, and `dist`.
-- `TESTING.md` defines the testing architecture and style rules for future changes.
-
-## Testing
-
-Tests are organized into:
-
-- `src/__tests__/e2e`: project-level output structure and dependency-chain tests.
-- `src/__tests__/css`: module/API tests for CSS and style logic.
-- `src/__tests__/fixtures`: shared virtual project and style structure helpers.
-- `src/__tests__/build`: tsdown/build config tests.
-
-Temporary test projects are created under `src/__tests__/.tmp/` and ignored by git.
-
-Read `TESTING.md` before adding or changing tests.
+- `pnpm build` rewrites `dist`.
+- `pnpm run format` formats `bin`, `src`, `dist`, `examples`, and related files.
+- Read `TESTING.md` before changing tests.

package/bin/entry.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runAukletCli } from '../dist/index.js';
+
+await runAukletCli();

package/dist/build/bundleConfig.js

@@ -47,7 +47,7 @@ export function createBundleConfigs(context, formats) {
             : undefined;
         return configureTsdown(context, {
             ...createCommonConfig(context, deps),
-            entry: getBundleEntry(context.packageRoot),
+            entry: getBundleEntry(context.packageRoot, context.source),
             format,
             globalName: context.globalName,
             outDir: context.output,

package/dist/build/cliOverrides.d.ts

@@ -0,0 +1,22 @@
+import type { AukletConfig } from '#auklet/types';
+export declare const aukletCliConfigOverridesEnv = "AUKLET_CONFIG_OVERRIDES";
+export declare function encodeAukletCliConfigOverrides(config: AukletConfig): string;
+export declare function readAukletCliConfigOverrides(): AukletConfig;
+export declare function mergeAukletConfigOverrides(config: AukletConfig, overrides: AukletConfig): {
+    build: {
+        formats?: Array<import("#auklet/types").PackageBuildFormat>;
+        target?: import("#auklet/types").PackageBuildTarget;
+        platform?: import("#auklet/types").PackageBuildPlatform;
+        banner?: string;
+        externals?: Array<string>;
+        alias?: Record<string, string>;
+        mainFields?: Array<string>;
+        globals?: Record<string, string>;
+        configureTsdown?: import("#auklet/types").ConfigureTsdown;
+        tsconfig?: string;
+    } | undefined;
+    source?: string;
+    output?: string;
+    modules?: boolean;
+    styles?: import("#auklet/types").StyleOptions;
+};

package/dist/build/cliOverrides.js

@@ -0,0 +1,22 @@
+export const aukletCliConfigOverridesEnv = 'AUKLET_CONFIG_OVERRIDES';
+export function encodeAukletCliConfigOverrides(config) {
+    return JSON.stringify(config);
+}
+export function readAukletCliConfigOverrides() {
+    const rawConfig = process.env[aukletCliConfigOverridesEnv];
+    if (!rawConfig)
+        return {};
+    return JSON.parse(rawConfig);
+}
+export function mergeAukletConfigOverrides(config, overrides) {
+    return {
+        ...config,
+        ...overrides,
+        build: config.build || overrides.build
+            ? {
+                ...config.build,
+                ...overrides.build,
+            }
+            : undefined,
+    };
+}

package/dist/build/moduleConfig.js

@@ -19,7 +19,7 @@ export function createModuleConfigs(context) {
     const commonConfig = createCommonConfig(context, {
         neverBundle: context.packageExternal,
     });
-    const entry = getModuleEntries(context.packageRoot);
+    const entry = getModuleEntries(context.packageRoot, context.source);
     return [
         createModuleConfig(context, commonConfig, entry, 'esm', path.join(context.output, 'es')),
         createModuleConfig(context, commonConfig, entry, 'cjs', path.join(context.output, 'lib')),

package/dist/build/runTsdown.d.ts

@@ -1,5 +1,7 @@
+export declare function hasTsdownConfigArg(args: Array<string>): boolean;
 export type RunTsdownOptions = {
     cwd?: string;
+    env?: Record<string, string>;
 };
 export declare function createTsdownArgs(args: Array<string>): string[];
 export declare function runTsdown(args: Array<string>, options?: RunTsdownOptions): Promise<number>;