@jterrazz/typescript 5.2.0 → 6.0.0

package/README.md

@@ -1,53 +1,75 @@
 # @jterrazz/typescript
 
-Drop-in TypeScript build tooling with zero configuration.
+The complete TypeScript toolchain — build, run, check, and document with zero configuration. Powered by tsdown, Oxlint, Oxfmt, tsgo, and Knip.
 
 ## Installation
 
 ```bash
-npm install @jterrazz/typescript
+npm install @jterrazz/typescript --save-dev
 ```
 
-## Usage
+## Setup
 
 ### 1. Choose a TypeScript configuration
 
 ```json
 // tsconfig.json - Pick one:
-{ "extends": "@jterrazz/typescript/presets/tsconfig/node" }  // Node.js projects
-{ "extends": "@jterrazz/typescript/presets/tsconfig/next" }  // Next.js projects
-{ "extends": "@jterrazz/typescript/presets/tsconfig/expo" }  // Expo/React Native
+{ "extends": "@jterrazz/typescript/tsconfig/node" }  // Node.js projects
+{ "extends": "@jterrazz/typescript/tsconfig/next" }  // Next.js projects
+{ "extends": "@jterrazz/typescript/tsconfig/expo" }  // Expo/React Native
 ```
 
-### 2. Use the CLI
+### 2. Create the lint and format configs
+
+```ts
+// oxlint.config.ts
+import { oxlint } from '@jterrazz/typescript';
+import { defineConfig } from 'oxlint';
+
+export default defineConfig({
+    extends: [oxlint.node],
+});
+```
+
+```ts
+// oxfmt.config.ts
+import { oxfmt } from '@jterrazz/typescript';
+import { defineConfig } from 'oxfmt';
+
+export default defineConfig(oxfmt);
+```
+
+### 3. Use the CLI
 
 ```bash
 npx typescript build       # Build application (ESM + types)
 npx typescript bundle      # Bundle library (ESM + CJS + types)
 npx typescript start       # Run the built application
 npx typescript dev         # Build, run, and rebuild on changes
+npx typescript docs        # Generate API reference + llms.txt
+npx typescript check       # Check types, lint, formatting, and unused code
+npx typescript fix         # Auto-fix lint and formatting issues
 ```
 
-## What you get
+## Building
 
 - **Blazing fast** — Powered by [tsdown](https://tsdown.dev) / [Rolldown](https://rolldown.rs) (Rust)
 - **Zero configuration** — Works out of the box
 - **Multiple outputs** — ESM + CommonJS + TypeScript declarations
 - **Source maps** — Full debugging support
 
-### Build outputs
-
-| Command             | Output            | Description             |
-| ------------------- | ----------------- | ----------------------- |
-| `typescript build`  | `dist/index.js`   | ESM bundle              |
-|                     | `dist/index.d.ts` | TypeScript declarations |
-| `typescript bundle` | `dist/index.js`   | ESM bundle              |
-|                     | `dist/index.cjs`  | CommonJS bundle         |
-|                     | `dist/index.d.ts` | TypeScript declarations |
-| `typescript start`  | —                 | Runs `dist/index.js`    |
-| `typescript dev`    | `dist/index.js`   | Watch + rebuild + run   |
+| Command             | Output            | Description              |
+| ------------------- | ----------------- | ------------------------ |
+| `typescript build`  | `dist/index.js`   | ESM bundle               |
+|                     | `dist/index.d.ts` | TypeScript declarations  |
+| `typescript bundle` | `dist/index.js`   | ESM bundle               |
+|                     | `dist/index.cjs`  | CommonJS bundle          |
+|                     | `dist/index.d.ts` | TypeScript declarations  |
+| `typescript start`  | —                 | Runs `dist/index.js`     |
+| `typescript dev`    | `dist/index.js`   | Watch + rebuild + run    |
+| `typescript docs`   | `.docs/`          | API reference + llms.txt |
 
-## Project structure
+### Project structure
 
 ```
 your-project/
@@ -58,15 +80,89 @@ your-project/
 └── tsconfig.json          # Extends this package
 ```
 
-## How it works
+## Quality checks
+
+`typescript check` runs four tools in parallel:
+
+| Tool   | Purpose              |
+| ------ | -------------------- |
+| tsgo   | Type checking        |
+| oxlint | Linting              |
+| oxfmt  | Formatting           |
+| knip   | Unused code analysis |
+
+`typescript fix` runs tsgo, oxlint (with `--fix`), and oxfmt in parallel (knip excluded).
+
+### Lint presets
+
+| Preset        | Use Case                          |
+| ------------- | --------------------------------- |
+| `oxlint.node` | Node.js (requires .js extensions) |
+| `oxlint.expo` | Expo / React Native               |
+| `oxlint.next` | Next.js                           |
+
+### Architecture enforcement
+
+Enforce hexagonal architecture boundaries with the additive `oxlint.hexagonal` preset:
 
-The package uses a fully compiled toolchain — no JavaScript in the hot path:
+```ts
+import { oxlint } from '@jterrazz/typescript';
+import { defineConfig } from 'oxlint';
+
+export default defineConfig({
+    extends: [oxlint.node, oxlint.hexagonal],
+});
+```
+
+Rules enforced:
+
+- `domain/` cannot import from other layers
+- `application/` cannot import infrastructure
+- `presentation/ui/` cannot import navigation
+- `features/` cannot import other features
+
+### Unused code detection
+
+`typescript check` runs [Knip](https://knip.dev/) to detect unused files, exports, and dependencies. A base config is automatically merged with any project-local `knip.json`, handling common ecosystem patterns:
+
+- `@jterrazz/*` packages auto-ignored
+- Published libraries: `exports`/`types`/`files` rules auto-disabled
+- Convention paths (`fixtures/`, `expected/`, `docs/`) auto-ignored
+- Plugin dependencies (`*-plugin-*`, `@scope/*`) auto-ignored
+
+For fine-tuning, create a `knip.json` with only project-specific overrides.
+
+## API docs generation
+
+`typescript docs` reads TSDoc from `src/index.ts` and generates:
+
+- **Typedoc markdown** — Full API reference under `.docs/`
+- **`llms.txt`** — Structured index following the [llms.txt standard](https://llmstxt.org/)
+- **`llms-full.txt`** — Complete reference in one file for LLM context windows
+
+No `typedoc.json` needed. Pair with the shared CI workflow to auto-deploy:
+
+```yaml
+# .github/workflows/docs.yaml
+jobs:
+    docs:
+        uses: jterrazz/jterrazz-actions/.github/workflows/docs.yaml@main
+```
+
+## How it works
 
-| Step         | Tool                                  | Language |
-| ------------ | ------------------------------------- | -------- |
-| Transpile    | [Oxc](https://oxc.rs) (via tsdown)    | Rust     |
-| Bundle       | [Rolldown](https://rolldown.rs)       | Rust     |
-| Declarations | [tsdown](https://tsdown.dev) built-in | Rust     |
+The toolchain is fully compiled — no JavaScript in the hot path:
+
+| Step         | Tool                                               | Language |
+| ------------ | -------------------------------------------------- | -------- |
+| Transpile    | [Oxc](https://oxc.rs) (via tsdown)                 | Rust     |
+| Bundle       | [Rolldown](https://rolldown.rs)                    | Rust     |
+| Declarations | [tsdown](https://tsdown.dev) built-in              | Rust     |
+| Type check   | [tsgo](https://github.com/microsoft/typescript-go) | Go       |
+| Lint         | [Oxlint](https://oxc.rs/docs/guide/usage/linter)   | Rust     |
+| Format       | [Oxfmt](https://oxc.rs/docs/guide/usage/formatter) | Rust     |
+| Unused code  | [Knip](https://knip.dev)                           | Node     |
+| API docs     | [Typedoc](https://typedoc.org)                     | Node     |
 
 ## License
 

package/bin/commands/check.sh

@@ -0,0 +1,164 @@
+#!/bin/bash
+# Quality checks: runs tsgo, oxlint, oxfmt, and knip in parallel.
+# Called by: typescript check | typescript fix
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+CYAN_BG='\033[46m'
+BRIGHT_WHITE='\033[1;30m'
+NC='\033[0m'
+
+# Resolve symlinks to get the real script location
+SOURCE="${BASH_SOURCE[0]}"
+while [ -L "$SOURCE" ]; do
+    DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+    SOURCE="$(readlink "$SOURCE")"
+    [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
+done
+SCRIPT_DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+PACKAGE_ROOT="$SCRIPT_DIR/../.."
+
+# Find bin directory
+if [ -x "$PACKAGE_ROOT/../../.bin/oxlint" ]; then
+    BIN_DIR="$PACKAGE_ROOT/../../.bin"
+elif [ -x "$PACKAGE_ROOT/node_modules/.bin/oxlint" ]; then
+    BIN_DIR="$PACKAGE_ROOT/node_modules/.bin"
+else
+    BIN_DIR="$(npm bin 2>/dev/null)"
+fi
+
+# Parse command and args
+COMMAND=""
+LINT_ARGS=()
+
+if [[ "${1:-}" == -* ]] || [ -z "${1:-}" ]; then
+    # No command, everything is args
+    true
+else
+    COMMAND="$1"
+    shift
+fi
+
+# Parse remaining args
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --ignore-pattern)
+            LINT_ARGS+=("$1" "$2")
+            shift 2
+            ;;
+        *)
+            shift
+            ;;
+    esac
+done
+
+# Create a temporary directory for log files
+tmp_dir=$(mktemp -d)
+cleanup() { rm -rf "$tmp_dir"; }
+trap cleanup EXIT
+
+run_checks() {
+    local FIX_MODE="$1"
+    local LABEL
+
+    if [ "$FIX_MODE" = true ]; then
+        LABEL="Running quality fixes"
+    else
+        LABEL="Running quality checks"
+    fi
+
+    printf "${CYAN_BG}${BRIGHT_WHITE} START ${NC} ${LABEL}\n"
+
+    # Run all tools in parallel
+    "$BIN_DIR/tsgo" --noEmit > "$tmp_dir/type.log" 2>&1 &
+    local type_pid=$!
+
+    if [ "$FIX_MODE" = true ]; then
+        "$BIN_DIR/oxlint" --fix "${LINT_ARGS[@]}" > "$tmp_dir/lint.log" 2>&1 &
+    else
+        "$BIN_DIR/oxlint" "${LINT_ARGS[@]}" > "$tmp_dir/lint.log" 2>&1 &
+    fi
+    local lint_pid=$!
+
+    if [ "$FIX_MODE" = true ]; then
+        "$BIN_DIR/oxfmt" > "$tmp_dir/format.log" 2>&1 &
+    else
+        "$BIN_DIR/oxfmt" --check > "$tmp_dir/format.log" 2>&1 &
+    fi
+    local format_pid=$!
+
+    # Knip: only run in check mode (fix mode is destructive)
+    # Merge base config (from this package) with optional project-local knip.json
+    local knip_pid=""
+    local knip_status=0
+    if [ "$FIX_MODE" = false ]; then
+        local knip_base="$PACKAGE_ROOT/presets/knip/base.json"
+        local knip_project=""
+        [ -f "knip.json" ] && knip_project="knip.json"
+        [ -f "knip.jsonc" ] && knip_project="knip.jsonc"
+
+        node "$PACKAGE_ROOT/bin/merge-knip-config.js" "$knip_base" $knip_project > "$tmp_dir/knip-merged.json"
+        "$BIN_DIR/knip" --no-progress --no-config-hints --config "$tmp_dir/knip-merged.json" > "$tmp_dir/knip.log" 2>&1 &
+        knip_pid=$!
+    fi
+
+    # Wait and collect statuses
+    wait $type_pid;   local type_status=$?
+    wait $lint_pid;   local lint_status=$?
+    wait $format_pid; local format_status=$?
+    [ -n "$knip_pid" ] && { wait $knip_pid; knip_status=$?; }
+
+    # Print results
+    printf "\n${CYAN_BG}${BRIGHT_WHITE} RUN ${NC} TypeScript Check\n\n"
+    [ -s "$tmp_dir/type.log" ] && cat "$tmp_dir/type.log"
+    [ $type_status -ne 0 ] && printf "${RED}✗ Failed with exit code %d${NC}\n" $type_status || printf "${GREEN}✓ Passed${NC}\n"
+
+    local lint_label="Oxlint Check"
+    [ "$FIX_MODE" = true ] && lint_label="Oxlint Fix"
+    printf "\n${CYAN_BG}${BRIGHT_WHITE} RUN ${NC} ${lint_label}\n\n"
+    [ -s "$tmp_dir/lint.log" ] && cat "$tmp_dir/lint.log"
+    [ $lint_status -ne 0 ] && printf "${RED}✗ Failed with exit code %d${NC}\n" $lint_status || printf "${GREEN}✓ Passed${NC}\n"
+
+    local format_label="Oxfmt Check"
+    [ "$FIX_MODE" = true ] && format_label="Oxfmt Format"
+    printf "\n${CYAN_BG}${BRIGHT_WHITE} RUN ${NC} ${format_label}\n\n"
+    [ -s "$tmp_dir/format.log" ] && cat "$tmp_dir/format.log"
+    [ $format_status -ne 0 ] && printf "${RED}✗ Failed with exit code %d${NC}\n" $format_status || printf "${GREEN}✓ Passed${NC}\n"
+
+    if [ "$FIX_MODE" = false ]; then
+        printf "\n${CYAN_BG}${BRIGHT_WHITE} RUN ${NC} Knip (unused code)\n\n"
+        [ -s "$tmp_dir/knip.log" ] && cat "$tmp_dir/knip.log"
+        [ $knip_status -ne 0 ] && printf "${RED}✗ Failed with exit code %d${NC}\n" $knip_status || printf "${GREEN}✓ Passed${NC}\n"
+    fi
+
+    # Summary
+    if [ "$FIX_MODE" = true ]; then
+        printf "\n${CYAN_BG}${BRIGHT_WHITE} END ${NC} Finalizing quality fixes\n\n"
+    else
+        printf "\n${CYAN_BG}${BRIGHT_WHITE} END ${NC} Finalizing quality checks\n\n"
+    fi
+
+    if [ $type_status -eq 0 ] && [ $lint_status -eq 0 ] && [ $format_status -eq 0 ] && [ $knip_status -eq 0 ]; then
+        printf "${GREEN}✓ All checks passed${NC}\n"
+        exit 0
+    else
+        printf "${RED}✗ Some checks failed${NC}\n"
+        exit 1
+    fi
+}
+
+case "$COMMAND" in
+    check)
+        run_checks false
+        ;;
+
+    fix)
+        run_checks true
+        ;;
+
+    *)
+        printf "Usage: check.sh <check|fix> [--ignore-pattern <pattern>]\n"
+        exit 1
+        ;;
+esac

package/bin/commands/docs.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+# Generate API reference + llms.txt from TypeScript source.
+# Called by: typescript docs
+#
+# Runs typedoc with sensible defaults (no typedoc.json needed),
+# then generates llms.txt (index) and llms-full.txt (full reference).
+
+set -e
+
+PROJECT_ROOT="$1"
+PACKAGE_ROOT="$2"
+OUT_DIR="$PROJECT_ROOT/.docs"
+
+TYPEDOC=$(
+    if [ -x "$PACKAGE_ROOT/node_modules/.bin/typedoc" ]; then
+        echo "$PACKAGE_ROOT/node_modules/.bin/typedoc"
+    elif [ -x "$PROJECT_ROOT/node_modules/.bin/typedoc" ]; then
+        echo "$PROJECT_ROOT/node_modules/.bin/typedoc"
+    else
+        echo "typedoc"
+    fi
+)
+
+# ── Step 1: Run typedoc ──
+
+"$TYPEDOC" \
+    --entryPoints "$PROJECT_ROOT/src/index.ts" \
+    --plugin typedoc-plugin-markdown \
+    --out "$OUT_DIR" \
+    --readme none \
+    --entryFileName index.md \
+    --hideBreadcrumbs true \
+    --hidePageHeader true \
+    --outputFileStrategy members \
+    --useCodeBlocks true \
+    --excludeInternal true \
+    --excludePrivate true \
+    --excludeProtected true \
+    --githubPages false \
+    --indexFormat table \
+    --parametersFormat table \
+    --enumMembersFormat table \
+    --typeDeclarationFormat table \
+    --tsconfig "$PROJECT_ROOT/tsconfig.json"
+
+# ── Step 2: Read package name ──
+
+PKG_NAME=$(node -e "console.log(require('$PROJECT_ROOT/package.json').name)")
+PKG_DESC=$(node -e "console.log(require('$PROJECT_ROOT/package.json').description || '')")
+
+# ── Step 3: Generate llms.txt ──
+
+{
+    echo "# $PKG_NAME"
+    echo ""
+    if [ -n "$PKG_DESC" ]; then
+        echo "> $PKG_DESC"
+        echo ""
+    fi
+    echo "## API Reference"
+    echo ""
+    sed -n '/^## /,$ p' "$OUT_DIR/index.md"
+} > "$OUT_DIR/llms.txt"
+
+# ── Step 4: Generate llms-full.txt ──
+
+{
+    echo "# $PKG_NAME — Full API Reference"
+    echo ""
+    if [ -n "$PKG_DESC" ]; then
+        echo "> $PKG_DESC"
+        echo ""
+    fi
+
+    for f in "$OUT_DIR"/index.md \
+             "$OUT_DIR"/functions/*.md \
+             "$OUT_DIR"/classes/*.md \
+             "$OUT_DIR"/interfaces/*.md \
+             "$OUT_DIR"/type-aliases/*.md \
+             "$OUT_DIR"/variables/*.md; do
+        [ -f "$f" ] || continue
+        echo "---"
+        echo ""
+        cat "$f"
+        echo ""
+    done
+} > "$OUT_DIR/llms-full.txt"
+
+echo "Generated $OUT_DIR/llms.txt and $OUT_DIR/llms-full.txt"

package/bin/merge-knip-config.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+
+/**
+ * Merges the base knip config with an optional project-local knip.json,
+ * then applies dynamic detection rules based on the project's package.json and file structure.
+ *
+ * Usage: node merge-knip-config.js <base.json> [project-knip.json]
+ *
+ * Merge rules:
+ *   - Arrays (ignoreDependencies, ignoreBinaries, ignore): concatenated and deduplicated
+ *   - Objects (rules, vitest, etc.): project values override base
+ *   - Scalars (project, entry): project value wins
+ *   - $schema is always stripped from output
+ *
+ * Dynamic detection:
+ *   - Published library (main/exports/publishConfig) → disable exports/types/files rules
+ *   - Auto-ignore docs/**, fixtures/**, expected/** convention paths
+ *   - Vitest workspace workaround → explicit vitest config when vitest is a dependency
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+
+const basePath = process.argv[2];
+const projectPath = process.argv[3];
+
+const base = JSON.parse(readFileSync(basePath, 'utf8'));
+
+let project = {};
+if (projectPath) {
+    project = JSON.parse(readFileSync(projectPath, 'utf8'));
+}
+
+const ARRAY_KEYS = new Set(['ignore', 'ignoreBinaries', 'ignoreDependencies', 'entry', 'project']);
+
+const merged = {};
+const allKeys = new Set([...Object.keys(base), ...Object.keys(project)]);
+
+for (const key of allKeys) {
+    if (key === '$schema') {
+        continue;
+    }
+
+    const bVal = base[key];
+    const pVal = project[key];
+
+    if (pVal === undefined) {
+        merged[key] = bVal;
+    } else if (bVal === undefined) {
+        merged[key] = pVal;
+    } else if (ARRAY_KEYS.has(key) && Array.isArray(bVal) && Array.isArray(pVal)) {
+        merged[key] = [...new Set([...bVal, ...pVal])];
+    } else if (typeof bVal === 'object' && typeof pVal === 'object' && !Array.isArray(bVal)) {
+        merged[key] = { ...bVal, ...pVal };
+    } else {
+        merged[key] = pVal;
+    }
+}
+
+// --- Dynamic detection ---
+
+let pkg = {};
+if (existsSync('package.json')) {
+    pkg = JSON.parse(readFileSync('package.json', 'utf8'));
+}
+
+// 1. Published library → disable exports/types/files rules
+if (pkg.main || pkg.exports || pkg.publishConfig) {
+    merged.rules = { exports: 'off', files: 'off', types: 'off', ...merged.rules };
+}
+
+// 2. Auto-ignore convention paths that exist on disk
+const conventionIgnores = [];
+if (existsSync('docs')) {
+    conventionIgnores.push('docs/**');
+}
+
+// Scan for fixtures/** and expected/** directories anywhere in the tree (up to 3 levels)
+const scanDirs = ['tests', 'test', 'src'];
+for (const root of scanDirs) {
+    if (!existsSync(root)) {
+        continue;
+    }
+    findConventionDirs(root, 0);
+}
+
+function findConventionDirs(dir, depth) {
+    if (depth > 3) {
+        return;
+    }
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        if (entry.name === 'fixtures' || entry.name === 'expected') {
+            conventionIgnores.push(`${dir}/${entry.name}/**`);
+        } else if (entry.name !== 'node_modules') {
+            findConventionDirs(`${dir}/${entry.name}`, depth + 1);
+        }
+    }
+}
+
+if (conventionIgnores.length > 0) {
+    const existing = merged.ignore || [];
+    merged.ignore = [...new Set([...existing, ...conventionIgnores])];
+}
+
+// 3. Vitest workspace workaround — knip crashes on vitest.workspace.ts
+//    If vitest is a dependency, explicitly set the vitest config to avoid the workspace file
+const allDeps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
+if (allDeps.vitest && !merged.vitest) {
+    if (existsSync('vitest.config.ts')) {
+        merged.vitest = { config: ['vitest.config.ts'] };
+    } else if (existsSync('vitest.config.js')) {
+        merged.vitest = { config: ['vitest.config.js'] };
+    } else if (existsSync('vitest.workspace.ts')) {
+        merged.vitest = { config: ['vitest.workspace.ts'] };
+    } else if (existsSync('vitest.workspace.js')) {
+        merged.vitest = { config: ['vitest.workspace.js'] };
+    }
+}
+
+// Also ignore vitest.workspace.ts if it exists (knip can't parse it)
+if (existsSync('vitest.workspace.ts') || existsSync('vitest.workspace.js')) {
+    const existing = merged.ignore || [];
+    const wsFile = existsSync('vitest.workspace.ts')
+        ? 'vitest.workspace.ts'
+        : 'vitest.workspace.js';
+    merged.ignore = [...new Set([...existing, wsFile])];
+}
+
+// 4. Playwright at non-standard paths + string-referenced global hooks.
+//    Knip auto-discovers `playwright.config.ts` at the repo root, but
+//    Projects that keep their browser tests under a dedicated subdir
+//    (e.g. `web/playwright.config.ts`, `e2e/playwright.config.ts`,
+//    `tests/playwright.config.ts`) need an explicit entry. The global
+//    Setup/teardown files next to that config are referenced as plain
+//    Strings from `playwright.config.ts`, so knip can't trace them —
+//    Add them as entries when they exist.
+if (allDeps['@playwright/test'] || allDeps.playwright) {
+    const playwrightSearchPaths = [
+        'web/playwright.config.ts',
+        'web/playwright.config.js',
+        'e2e/playwright.config.ts',
+        'e2e/playwright.config.js',
+        'tests/playwright.config.ts',
+        'tests/playwright.config.js',
+    ];
+    const playwrightEntries = [];
+    for (const configPath of playwrightSearchPaths) {
+        if (!existsSync(configPath)) {
+            continue;
+        }
+        playwrightEntries.push(configPath);
+        const configDir = configPath.slice(0, configPath.lastIndexOf('/'));
+        for (const hook of [
+            `${configDir}/setup/global-setup.ts`,
+            `${configDir}/setup/global-teardown.ts`,
+            `${configDir}/setup/global-setup.js`,
+            `${configDir}/setup/global-teardown.js`,
+        ]) {
+            if (existsSync(hook)) {
+                playwrightEntries.push(hook);
+            }
+        }
+    }
+    if (playwrightEntries.length > 0) {
+        const existing = merged.entry || [];
+        merged.entry = [...new Set([...existing, ...playwrightEntries])];
+    }
+}
+
+// 5. Auto-ignore plugin/addon dependencies for known parent packages
+const prodDeps = Object.keys(pkg.dependencies || {});
+const devDeps = Object.keys(pkg.devDependencies || {});
+const peerDeps = Object.keys(pkg.peerDependencies || {});
+const allDepNames = Object.keys(allDeps);
+const autoIgnoreDeps = [];
+
+// DevDependencies that are also peerDependencies (installed locally for testing)
+for (const dep of devDeps) {
+    if (peerDeps.includes(dep)) {
+        autoIgnoreDeps.push(dep);
+    }
+}
+
+for (const dep of [...prodDeps, ...devDeps]) {
+    // @scope/sub-package when the unscoped root is a peer or dependency
+    // E.g. @hono/node-server → hono
+    const scopeMatch = dep.match(/^@(?<scope>[^/]+)\//);
+    if (
+        scopeMatch &&
+        (peerDeps.includes(scopeMatch.groups.scope) ||
+            allDepNames.includes(scopeMatch.groups.scope))
+    ) {
+        autoIgnoreDeps.push(dep);
+        continue;
+    }
+
+    // <parent>-plugin-* or <parent>-preset-* when <parent> is installed
+    // E.g. vitepress-plugin-llms → vitepress
+    const pluginMatch = dep.match(/^(?<parent>.+?)-(?:plugin|preset|transformer|loader)-/);
+    if (pluginMatch && allDepNames.includes(pluginMatch.groups.parent)) {
+        autoIgnoreDeps.push(dep);
+        continue;
+    }
+
+    // eslint-plugin-* — always a runtime plugin loaded by config, never imported
+    if (dep.startsWith('eslint-plugin-')) {
+        autoIgnoreDeps.push(dep);
+    }
+}
+
+// 5. Auto-ignore production dependencies that provide binaries
+//    When a binary-only tool is in "dependencies", it's shipped for consumers (e.g. @jterrazz/typescript ships oxlint)
+for (const dep of prodDeps) {
+    if (autoIgnoreDeps.includes(dep)) {
+        continue;
+    }
+    try {
+        const depPkg = JSON.parse(readFileSync(`node_modules/${dep}/package.json`, 'utf8'));
+        if (depPkg.bin && Object.keys(depPkg.bin).length > 0) {
+            autoIgnoreDeps.push(dep);
+        }
+    } catch {
+        // Dep not installed locally — skip
+    }
+}
+
+if (autoIgnoreDeps.length > 0) {
+    const existing = merged.ignoreDependencies || [];
+    merged.ignoreDependencies = [...new Set([...existing, ...autoIgnoreDeps])];
+}
+
+process.stdout.write(JSON.stringify(merged));