susee 2.0.4 → 2.1.0

package/README.md

@@ -9,508 +9,240 @@
 
 [![NPM][nodei_img]][nodei_url]
 
-[![npm version][npm_v_img]][npm_v_url] [![license][license_img]](LICENSE)[![OpenSSF Baseline](https://www.bestpractices.dev/projects/13115/baseline)](https://www.bestpractices.dev/projects/13115) [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/13115/badge)](https://www.bestpractices.dev/projects/13115)
+[![npm version][npm_v_img]][npm_v_url] [![license][license_img]](LICENSE) [![OpenSSF Baseline](https://www.bestpractices.dev/projects/13115/baseline)](https://www.bestpractices.dev/projects/13115) [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/13115/badge)](https://www.bestpractices.dev/projects/13115)
 
 ## Overview
 
-`susee` is a **TypeScript-first bundler** specialized for library packages.Unlike general-purpose bundlers, `susee` focuses on consolidating a package's local TypeScript dependency tree into consolidated source units and compiling them into dual-format artifacts (ESM and CommonJS) using a high-performance `Rust` core.
-
-> [!NOTE]
->
-> - Starting with **v2.0.0**, Susee's core is written in **Rust** and compiled to a native Node.js addon via **N-API** (`@napi-rs/cli`). The compiler, bundler, and minifier all run in native code for maximum performance.
-> - The output JavaScript is minified with the **[oxc](https://oxc.rs) minifier** when `minify` is enabled.
-> - Config files use the **JSONC** format (`susee.config.jsonc`).
-
----
+`susee` is a **TypeScript-first bundler** powered by `oxc`, specialized for library packages. Unlike general-purpose bundlers, `susee` focuses on consolidating a package's local TypeScript dependency tree into consolidated source units and compiling them into dual-format artifacts (ESM and CommonJS).
 
 ## Key Features
 
-✅ **Native Performance via N-API and Rust** — Key native components: Bundler , Compiler, Minifier, N-API Bridge
-
-✅ **Dual-Format Module Output** — Generate both ESM and CommonJS formats automatically
-
-✅ **Duplicate Declaration Detection** — Fails fast when bundled files contain conflicting top-level declarations
-
-✅ **Fast Builds** — Optimized for library packages with minimal overhead
-
-✅ **Built-in Minification** — Minify output JavaScript with the oxc minifier
-
-✅ **Package.json Management** — Automatic updates to package.json fields based on the build results
-
-✅ **CLI & Programmatic API** — Use as a CLI tool or integrate directly
-
----
+- **TypeScript-first build flow** — built around library development, not application bundling. Preserves a package-oriented workflow with declaration output and clean library artifacts.
+- **Dual output support** — produces both ESM and CommonJS from the same entry definition, so packages work with modern `import` and legacy `require` ecosystems.
+- **Duplicate declaration validation** — when source consolidation produces conflicting top-level declarations, the build fails with file and location output instead of silently renaming.
+- **Fast, low-overhead builds** — a lean pipeline that fits package development and release workflows without app-level complexity.
+- **Package metadata update** — can update `package.json` `exports`, `main`, `module`, and `types` fields after build output is generated.
+- **Built-in minification** — runs the `oxc-minify` minifier over emitted JavaScript when enabled.
+- **CLI and programmatic API** — use the CLI for local development/CI, or call the build API for custom scripting.
+- **JSX support** — detects JSX in bundled output and validates the JSX runtime (React or a configured `jsxImportSource`) before compiling.
 
-## Installation and Quick Start
+## Install
 
-### Installation Methods
-
-#### Local Development Dependency (Recommended)
-
-Install `susee` as a development dependency in your project:
-
-```bash
+```sh
 npm i -D susee
 ```
 
-This method is recommended for library projects as it ensures the bundler version is locked to the project and available for CI/CD pipelines.
-
-#### Global Installation
-
-For system-wide availability of the `susee` CLI:
-
-```bash
-npm install -g susee
-```
-
-Global installation enables running `susee` directly from any directory without the `npx` prefix.
+Verify the installation:
 
-#### Installation Verification
-
-After installation, verify the package is available by checking the version command:
-
-```bash
+```sh
 npx susee --version
 ```
 
----
-
-### Quick Start
+## Quick Start
 
-### Using config file
+### 1. Create a config file
 
-The easiest way to start is using the built-in initialization command which generates a configuration template at your project root. This command creates a `susee.config.jsonc` file.
+Generate a starter `susee.config.{ts,js,mjs}` in your project root:
 
-```bash
+```sh
 npx susee init
 ```
 
-Build your project by running:
-
-```bash
-npx susee
-```
-
-### Using Programmatic API (Node.js)
-
-You can trigger the build process within a JavaScript/TypeScript script using the `suseeBuild()` N-API function.
-
-```typescript
-import { suseeBuild } from "susee";
-
-suseeBuild({
-  entryPoints: [
-    {
-      entry: "src/index.ts",
-      exportPath: ".",
-      format: ["esm", "commonjs"],
-    },
-  ],
-  outDir: "dist",
-  allowUpdatePackageJson: true,
-  minify: true,
-});
-```
-
-### Using CLI (Direct Build)
+The interactive prompt asks whether your project is TypeScript. For TS projects it writes `susee.config.ts`; for JS projects it writes `susee.config.js` (ESM) or `susee.config.mjs` (CommonJS) based on your `package.json#type`.
 
-Build a single entry directly without a config file. This method uses default values for options not explicitly provided.
-
-```bash
-npx susee build src/index.ts --outdir dist --format esm --minify
-```
-
-### Contributor Setup (Repository)
-
-When contributing to this repository, use `npm` to keep installs aligned with `package-lock.json` and npm-based scripts.
-
-```bash
-npm install
-npm run hooks:install
-```
-
-This installs project dependencies and configures local git hooks for commit workflow checks.
-
----
-
-## Security
-
-Please report vulnerabilities privately and follow the disclosure process in [SECURITY.md](./SECURITY.md).
-
-Do not open public issues for security reports.
-
----
-
-## N-API (Node.js) Exports
-
-Susee's Rust core is exposed to Node.js via N-API (`@napi-rs/cli`). The following functions and types are available:
-
-### `suseeBuild(config?)`
-
-Build from the provided config object or from a discovered `susee.config.jsonc` file. If neither exists, Susee logs an error and exits with code `1`.
+### 2. Define your entries
 
 ```ts
-import { suseeBuild, type SuSeeConfig } from "susee";
+// susee.config.ts
+import type { SuSeeConfig } from "susee";
 
-// Build from an explicit config object
-suseeBuild({
+const config: SuSeeConfig = {
   entryPoints: [
     {
-      entry: "src/index.ts",
-      exportPath: ".",
-      format: ["esm", "commonjs"],
+      entry: "src/index.ts",   // required — entry file path
+      exportPath: ".",         // required — "." for main export, or "./foo"
+      format: ["esm"],         // optional, default ["esm"]
+      tsconfigFilePath: undefined, // optional, custom tsconfig
+      checks: {                // optional, all default false
+        checkAnonymous: false,
+        checkDefaultExports: false,
+        checkNpmInstalled: false,
+      },
+      minify: false,           // optional: true | { options: MinifyOptions }
     },
   ],
-  outDir: "dist",
-  allowUpdatePackageJson: false,
-  minify: true,
-});
-
-// Build from susee.config.jsonc (config omitted)
-suseeBuild();
-```
-
-| Parameter | Type                       | Required | Default | Description                                   |
-| --------- | -------------------------- | -------- | ------- | --------------------------------------------- |
-| `config`  | `SuSeeConfig \| undefined` | No       | —       | Build options. If omitted, loads config file. |
-
-### `cliBuild(args)`
-
-Run the CLI dispatcher programmatically. Pass `process.argv.slice(2)` from the JavaScript side.
-
-```ts
-import { cliBuild } from "susee";
+  outDir: "dist",              // optional, default "dist"
+  allowUpdatePackageJson: false, // optional, default false
+};
 
-cliBuild(process.argv.slice(2));
+export default config;
 ```
 
-| Parameter | Type       | Required | Description                                        |
-| --------- | ---------- | -------- | -------------------------------------------------- |
-| `args`    | `string[]` | Yes      | CLI arguments (typically `process.argv.slice(2)`). |
+### 3. Build
 
-### `suseeBundler(entry)`
-
-Bundle a single entry and return the merged source string. This export does not expose plugin or warning options.
-
-```ts
-import { suseeBundler } from "susee";
-
-const bundled = suseeBundler("src/index.ts");
-console.log(bundled);
+```sh
+npx susee build
 ```
 
-| Parameter | Type     | Required | Description                               |
-| --------- | -------- | -------- | ----------------------------------------- |
-| `entry`   | `string` | Yes      | Entry file path relative to project root. |
-
-**Returns:** `string` — the bundled source code.
-
-### `OutputFormat` (enum)
-
-N-API enum representing the output module format.
-
-```ts
-enum OutputFormat {
-  Esm = "esm",
-  Commonjs = "commonjs",
-}
-```
+Susee reads your config, bundles each entry point, compiles to ESM and/or CommonJS, and writes output to `dist` by default.
 
-### `SuSeeConfig` (object)
+## CLI
 
-```ts
-interface SuSeeConfig {
-  entryPoints: EntryPoint[];
-  outDir?: string; // default: "dist"
-  allowUpdatePackageJson?: boolean; // default: false
-  minify?: boolean; // default: false
-}
 ```
-
-### `EntryPoint` (object)
-
-```ts
-interface EntryPoint {
-  entry: string;
-  exportPath: string; // "." or "./sub/path"
-  format?: OutputFormat[]; // default: ["esm"]
-  tsconfigFilePath?: string | null; // default: null
-  warning?: boolean; // default: false
-}
+susee build                           Build using susee.config.{ts,js,mjs}
+susee init                            Generate susee.config.{ts,js,mjs}
+susee --version / -v                  Print version
+susee --help / -h                     Show help
+susee build <entry> [options]         Build from a single entry file
 ```
 
----
-
-## Rust API
-
-The Rust core library exposes the following public functions and types via the `susee` crate:
-
-### `core::build(config: Option<&SuSeeConfig>)`
+### Build Flags
 
-Top-level build entry point. When `config` is `None`, the config is loaded from `susee.config.jsonc` in the current directory.
+| Flag | Type | Default | Description |
+|------|------|---------|-------------|
+| `--entry <path>` | string | — | Entry file (optional if given positionally) |
+| `--outdir <path>` | string | `dist` | Output directory |
+| `--format` | `cjs\|commonjs\|esm` | `esm` | Output module format |
+| `--tsconfig <path>` | string | `undefined` | Custom tsconfig path |
+| `--allow-update[=true\|false]` | boolean | `false` | Allow `package.json` updates |
+| `--minify[=true\|false]` | boolean | `false` | Minify output JS |
+| `--check[=true\|false]` | boolean | `false` | Run bundler lint checks |
 
-```rust
-use susee::{SuSeeConfig,susee_build};
+Flags accept both `--flag=value` and `--flag value` syntax.
 
-// Build from config file
-core::build(None);
+### Examples
 
-// Build from explicit config
-let config = SuSeeConfig {
-    entry_points: vec![susee::core::EntryPoint {
-        entry: "src/index.ts".to_string(),
-        export_path: ".".to_string(),
-        format: Some(vec![susee::core::OutputFormat::Esm]),
-        tsconfig_file_path: None,
-        warning: Some(false),
-    }],
-    out_dir: Some("dist".to_string()),
-    allow_update_package_json: Some(false),
-    minify: Some(true),
-};
-susee_build(Some(&config));
+```sh
+npx susee build src/index.ts --outdir dist
+npx susee build src/index.ts --format commonjs
+npx susee build --entry src/index.ts --format esm --tsconfig tsconfig.build.json
+npx susee build src/index.ts --minify
 ```
 
-### `core::susee_build(config: &SuSeeConfig) -> Result<(), String>`
-
-Build from a config reference. Returns `Ok(())` on success or an error string on failure.
+## Programmatic API
 
-```rust
-use susee::{susee_build, SuSeeConfig, EntryPoint, OutputFormat};
+```ts
+import { build, type SuSeeConfig } from "susee";
 
-let config = SuSeeConfig {
-    entry_points: vec![EntryPoint {
-        entry: "src/index.ts".to_string(),
-        export_path: ".".to_string(),
-        format: Some(vec![OutputFormat::Esm, OutputFormat::Commonjs]),
-        tsconfig_file_path: None,
-        warning: Some(false),
-    }],
-    out_dir: Some("dist".to_string()),
-    allow_update_package_json: Some(false),
-    minify: Some(true),
+const config: SuSeeConfig = {
+  entryPoints: [
+    { entry: "src/index.ts", exportPath: "." },
+  ],
+  outDir: "dist",
+  allowUpdatePackageJson: true,
 };
 
-susee_build(&config).expect("build failed");
+await build(config);
 ```
 
-### `core::bundler(entry: &str, cwd: &str) -> std::io::Result<BundleResult>`
-
-Bundle a single entry and return the merged source string along with project type metadata.
-
-```rust
-use susee::core::bundler;
-
-let result = bundler("src/index.ts", ".")?;
-println!("{}", result.bundled_code);
+`build()` resolves options from the argument first, then from a root config file. If neither is available it logs an error and exits with code 1.
+
+## How It Works
+
+```mermaid
+flowchart TD
+    A[CLI / Programmatic API] --> B["build()"]
+    B --> C{options provided?}
+    C -->|yes| D[generateBuildOptions]
+    C -->|no| E[finalSuseeConfig]
+    E -->|no config| F[Error + exit 1]
+    E -->|found| D
+    D --> G[Compiler]
+    G --> H[For each entry point]
+    H --> I["bundler() — suseeBundler (oxc)"]
+    I --> J[Bundled source string]
+    J --> K{format}
+    K -->|commonjs| L["_commonjs()"]
+    K -->|esm| M["_esm()"]
+    L --> N["suseeCompiler — ts6 in-memory host"]
+    M --> N
+    N --> O["getCompilerOptions — tsconfig → per-format"]
+    O --> P["ts6.createProgram + emit"]
+    P --> Q{minify?}
+    Q -->|yes| R[oxcMinify]
+    Q -->|no| S["Write .cjs/.mjs + .d.* + .map"]
+    R --> S
+    S --> T{update package?}
+    T -->|yes| U["files.writePackageJson"]
 ```
 
-### `core::susee_cli_build_with_args(args: Vec<String>)`
-
-CLI dispatcher with explicit args. Reads `std::env::args_os().skip(1)` for the standalone binary, or accepts args passed from the N-API layer.
+The pipeline bundles each entry point's local dependency tree into a single source string, compiles it in-memory with the TypeScript compiler (`@suseejs/ts6`), optionally minifies with `oxc-minify`, and writes dual-format artifacts with declaration and source-map files.
 
-```rust
-use susee::core::susee_cli_build_with_args;
+## Source Architecture
 
-susee_cli_build_with_args(vec!["build".to_string(), "src/index.ts".to_string()]);
 ```
-
-### Rust Types
-
-#### `SuSeeConfig`
-
-```rust
-pub struct SuSeeConfig {
-    pub entry_points: Vec<EntryPoint>,
-    pub out_dir: Option<String>,
-    pub allow_update_package_json: Option<bool>,
-    pub minify: Option<bool>,
-}
+src/
+├── index.ts            # Public API — re-exports build + SuSeeConfig
+├── build.ts            # Build orchestrator — resolves config, runs Compiler
+├── bundler.ts          # Wrapper around @suseejs/susee_bundler (oxc)
+├── cli/
+│   ├── index.ts        # CLI entrypoint & command dispatch
+│   ├── parse_args.ts   # Parses CLI flags into SuSeeConfig
+│   ├── init.ts         # `susee init` — scaffolds config file
+│   └── print_help.ts   # `susee --help` output
+├── compiler/
+│   ├── index.ts        # Compiler class — bundles + emits CJS/ESM + types
+│   ├── suseeCompiler.ts# In-memory TypeScript compilation host
+│   └── tsoptions.ts    # Resolves tsconfig.json into per-format options
+├── config/
+│   └── index.ts        # Config types, validation, and normalization
+└── helpers/
+    ├── files.ts        # File system namespace + package.json writer
+    └── minify.ts       # oxc-minify wrapper
 ```
 
-#### `EntryPoint`
+See [`src/README.md`](src/README.md) for detailed module documentation.
 
-```rust
-pub struct EntryPoint {
-    pub entry: String,
-    pub export_path: String,
-    pub format: Option<Vec<OutputFormat>>,
-    pub tsconfig_file_path: Option<String>,
-    pub warning: Option<bool>,
-}
-```
+## Configuration Reference
 
-#### `OutputFormat`
+### `SuSeeConfig`
 
-```rust
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum OutputFormat {
-    Commonjs, // serialized as "commonjs"
-    Esm,      // serialized as "esm"
-}
-```
-
-#### `BuildOptions` (internal)
+| Field | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `entryPoints` | `EntryPoint[]` | yes | — | Array of entry point definitions |
+| `outDir` | `string` | no | `dist` | Output directory |
+| `allowUpdatePackageJson` | `boolean` | no | `false` | Allow susee to update `package.json` |
 
-```rust
-pub struct BuildOptions {
-    pub build_entry_points: Vec<BuildEntryPoint>,
-    pub update_package: bool,
-    pub out_dir: String,
-    pub minify: bool,
-}
-```
+### `EntryPoint`
 
-### Cargo.toml
+| Field | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `entry` | `string` | yes | — | Entry file path |
+| `exportPath` | `"." \| "./${string}"` | yes | — | Export path for this entry |
+| `format` | `("commonjs" \| "esm")[]` | no | `["esm"]` | Output module formats |
+| `tsconfigFilePath` | `string` | no | `undefined` | Custom tsconfig path |
+| `checks` | `CheckOptions` | no | all `false` | Bundler lint checks |
+| `minify` | `boolean \| { options: MinifyOptions }` | no | `false` | Minify output |
 
-```toml
-[dependencies]
-susee = "2"
-```
+### `CheckOptions`
 
----
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `checkAnonymous` | `boolean` | `false` | Check for anonymous declarations |
+| `checkDefaultExports` | `boolean` | `false` | Check default exports |
+| `checkNpmInstalled` | `boolean` | `false` | Check that npm deps are installed |
 
-## CLI Usage
+### TSConfig Resolution Priority
 
-```txt
-Susee CLI.
+For each entry point, compiler options resolve in this order:
 
-Usage:
-  susee                                 Build using susee.config.jsonc
-  susee init                            Generate susee.config.jsonc
-  susee --version | -v                  Check susee version
-  susee --help | -h                     Show this message
-  susee build <entry> [options]         Build from a single entry file
-```
+1. Custom `tsconfigFilePath` on the entry point
+2. `tsconfig.json` at the project root
+3. Susee defaults (`module: ES2020` for ESM, `module: CommonJS` for CJS, `target: Latest`)
 
-### CLI Build Options
+## Development
 
-```txt
---entry <path>                Entry file (optional if provided as positional <entry>)
---outdir <path>               Output directory (default: dist)
---format <cjs|commonjs|esm>   Output format (default: esm)
---tsconfig <path>             Custom tsconfig path
---allow-update[=true|false]   Allow package.json updates (default: false)
---warning[=true|false]        Treat dependency graph warnings as fatal (default: false)
---minify[=true|false]         Minify output JavaScript code (default: false)
+```sh
+npm run build    # compile src/ via oxnode build.ts
+npm run lint     # oxlint
+npm run fmt      # oxfmt
 ```
 
-### CLI Examples
-
-```bash
-npx susee build src/index.ts --outdir dist
-npx susee build src/index.ts --format commonjs
-npx susee build --entry src/index.ts --format esm
-```
-
-Notes:
-
-1. `susee build` accepts either a positional `<entry>` or `--entry <path>`.
-2. `--profile` is also accepted on plain `susee` config-driven builds.
-3. `--minify` enables the oxc minifier on the emitted JavaScript output.
-4. The CLI clears the target `outDir` before writing new output.
-
----
-
-## Config File
-
-The config file uses the **JSONC** format (JSON with comments) and must be named:
-
-- `susee.config.jsonc`
-
-### `susee.config.jsonc` example
-
-```jsonc
-{
-  // Entry points to bundle
-  "entryPoints": [
-    {
-      "entry": "src/index.ts",
-      "exportPath": ".",
-      "format": ["esm", "commonjs"],
-      "tsconfigFilePath": null,
-      "warning": false,
-    },
-  ],
-  // Output directory (default: "dist")
-  "outDir": "dist",
-  // Update package.json fields from build output (default: false)
-  "allowUpdatePackageJson": false,
-  // Minify output JS with the oxc minifier (default: false)
-  "minify": true,
-}
-```
-
-### Config schema
-
-| Field                            | Type           | Required | Default   | Description                              |
-| -------------------------------- | -------------- | -------- | --------- | ---------------------------------------- |
-| `entryPoints`                    | `EntryPoint[]` | Yes      | —         | List of entry points to build.           |
-| `outDir`                         | `string`       | No       | `"dist"`  | Root output directory.                   |
-| `allowUpdatePackageJson`         | `boolean`      | No       | `false`   | Update package.json from build output.   |
-| `minify`                         | `boolean`      | No       | `false`   | Minify emitted JS with the oxc minifier. |
-| `entryPoints[].entry`            | `string`       | Yes      | —         | Entry file path.                         |
-| `entryPoints[].exportPath`       | `string`       | Yes      | —         | Package export path (`.` or `./sub`).    |
-| `entryPoints[].format`           | `string[]`     | No       | `["esm"]` | Output formats: `"esm"`, `"commonjs"`.   |
-| `entryPoints[].tsconfigFilePath` | `string\|null` | No       | `null`    | Custom tsconfig path.                    |
-| `entryPoints[].warning`          | `boolean`      | No       | `false`   | Treat dependency warnings as fatal.      |
-
----
-
-## Output Notes
-
-For an entry like `src/index.ts` with both formats enabled, output includes:
-
-1. ESM: `dist/index.mjs`
-2. CommonJS: `dist/index.cjs`
-3. Type declarations: `dist/index.d.mts` and `dist/index.d.cts`
-4. Sourcemaps: `dist/index.mjs.map` and `dist/index.cjs.map`
-
-When `minify` is enabled, the ESM and CommonJS output files are minified using the **oxc** minifier.
-
-Declaration files are emitted by the compiler when available.
-
-## Build Output Matrix
-
-| Input                                        | Output Directory Rule | ESM Files                                   | CommonJS Files                              |
-| -------------------------------------------- | --------------------- | ------------------------------------------- | ------------------------------------------- |
-| `entry: "src/index.ts"`, `exportPath: "."`   | `<outDir>`            | `index.mjs`, `index.mjs.map`, `index.d.mts` | `index.cjs`, `index.cjs.map`, `index.d.cts` |
-| `entry: "src/foo.ts"`, `exportPath: "./foo"` | `<outDir>/foo`        | `foo.mjs`, `foo.mjs.map`, `foo.d.mts`       | `foo.cjs`, `foo.cjs.map`, `foo.d.cts`       |
-
-Notes:
-
-1. Default `outDir` is `dist` when not set.
-2. For subpath exports, output directory is computed as `outDir + exportPath.slice(1)`.
-3. Declarations (`.d.mts` / `.d.cts`) are emitted when provided by the underlying compiler result.
-
-## Package.json Update Matrix
-
-When `allowUpdatePackageJson` (config) or `--allow-update` (CLI build) is enabled, Susee rewrites package metadata from the emitted file paths.
-
-1. Main export build with `exportPath: "."` and CommonJS output: updates `main` to the generated `.cjs` file.
-2. Main export build with `exportPath: "."` and ESM output: updates `module` to the generated `.mjs` file.
-3. Main export build with `exportPath: "."` and declarations: updates `types` to the generated declaration file.
-4. Any export build with generated import or require declarations: creates or merges `exports` entries for that export path.
-5. Any package update: forces `type` to `"module"`.
-
-Notes:
-
-1. Package update requires a `package.json` file in the project root.
-2. For subpath exports, Susee merges the generated entry into existing `exports` when that field is an object.
-3. For the main export path `.`, Susee replaces `exports` with the generated root mapping.
-
-## Validation Rules
-
-From config validation logic:
-
-1. At least one `entryPoints` item is required.
-2. Duplicate `exportPath` values are rejected.
-3. Each `entry` path must exist.
-4. Duplicate top-level declarations across bundled files fail the build during dependency analysis.
-5. CommonJS modules in the dependency tree fail the build unless you handle them with `@suseejs/commonjs-plugin`.
+## Key Dependencies
 
-Violations print an error and exit with code `1`.
+- [`@suseejs/susee_bundler`](https://www.npmjs.com/package/@suseejs/susee_bundler) — oxc-powered bundling engine
+- [`@suseejs/ts6`](https://www.npmjs.com/package/@suseejs/ts6) — TypeScript compiler fork for type-checking and declaration emit
+- [`oxc-minify`](https://www.npmjs.com/package/oxc-minify) — JavaScript minification
 
 ## License
 

package/dist/cli/index.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map