vanilla-builder 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to this project are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses [Semantic Versioning](https://semver.org/).
 
+## [0.2.0] - 2026-11-09
+
+### Added
+
+- **TypeScript**: `.ts`, `.mts` and `.cts` files are transpiled with esbuild (using `tsconfig.json`) and published as `.js`; the HTML is rewritten to the output. Extensionless, directory and `.ts` imports, and `new URL('./worker.ts', import.meta.url)`, keep working even without bundling. `.d.ts` and `*.test.ts` are not published.
+- **`builder deps`**: lists which JS files are third-party libraries (and why) and which are yours; `builder deps add|own|reset <pattern…>` edits `builder.config.json` safely.
+- Mark dependencies without config: `data-builder="dependency|own"` on a `<script>`, or `/* @builder-dependency */` / `/* @builder-own */` at the top of the file.
+- New detection signals: UMD/AMD wrappers and files named like a package in `package.json` `dependencies`.
+- **Worker threads** for obfuscation, terser and the final syntax check (`workers`, `--workers`), with the main thread helping while they start.
+- **Persistent cache** of slow results by content (`cache`, `--no-cache`, `BUILDER_CACHE_DIR`); output is byte-identical with or without it.
+- `perf` in the result and in `--json`: tasks, threads, cache hits and milliseconds per phase.
+- `npm run bench`: reproducible benchmark on a generated site.
+
+### Changed
+
+- Independent files (classic scripts, standalone files, CSS, module outputs, compression) are processed concurrently and registered in the original order.
+- gzip/brotli sizes for the report are computed asynchronously, once, and shared with `--compress`.
+- The ES level of each file is computed only when needed; global-variable checks use a single parse.
+
 ## [0.1.0] - 2026-11-08
 
 First public release.
@@ -18,4 +37,5 @@ First public release.
 - Projects opened through a symlink or junction (e.g. macOS `/tmp`) now build; the root is resolved to its real path.
 - MIT license, CI on Node 16–24 (Linux, Windows, macOS) and browser equivalence tests in Chrome.
 
+[0.2.0]: https://github.com/MarioACo/vanilla-builder/releases/tag/v0.2.0
 [0.1.0]: https://github.com/MarioACo/vanilla-builder/releases/tag/v0.1.0

package/README.es.md

@@ -9,8 +9,11 @@ Detecta solo las dependencias de cada página, verifica la salida antes de publi
 
 - **Cero configuración**: apúntalo a una carpeta con `.html` y listo.
 - **Sin pérdida**: cada archivo del proyecto termina con un destino conocido (procesado, empaquetado, copiado u omitido a propósito) y la salida se verifica antes de reemplazar `dist/`.
-- **Ligero**: 57 KB propios; la instalación base son 8 paquetes (el grueso es el binario de esbuild). El ofuscador y terser se instalan solo si los usas.
-- **Node 16 o superior** (probado en 16, 18, 20, 22 y 24).
+- **Rápido**: la ofuscación y terser van en hilos paralelos, y una caché persistente hace casi gratis recompilar lo que no cambió (sitio de prueba de 40 páginas ofuscado: 11–18 s en 0.1.0 → 7 s la primera vez, 1,8 s al recompilar). Ver [Velocidad](#velocidad).
+- **Tú decides qué es una librería**: el código de terceros se detecta y nunca se ofusca; lo corriges desde el HTML, el propio archivo o `builder deps`. Ver [Dependencias](#dependencias-de-terceros-y-ofuscación).
+- **TypeScript incluido**: `<script src="app.ts">` funciona tal cual; la salida es `.js`.
+- **Ligero**: la instalación base son 8 paquetes (el grueso es el binario de esbuild). El ofuscador y terser se instalan solo si los usas.
+- **Node 16 o superior** (probado en 16, 18, 20, 22 y 24, en Linux, Windows y macOS).
 
 ## Instalación
 
@@ -29,6 +32,7 @@ npm install --save-dev terser                   # solo si quieres la compresión
 builder build mi-sitio                  # compila en mi-sitio/dist
 builder build mi-sitio --obfuscate      # además ofusca tu JavaScript (nivel medium)
 builder analyze mi-sitio                # muestra qué pasará con cada archivo, sin escribir nada
+builder deps mi-sitio                   # qué JS son librerías (no se ofuscan) y cuáles son tuyos
 builder init mi-sitio                   # crea builder.config.json con lo detectado
 builder dev mi-sitio                    # compila, vigila cambios y sirve dist/ con recarga automática
 builder serve mi-sitio                  # sirve dist/ para probarlo
@@ -48,7 +52,9 @@ Opciones frecuentes de `build` (todas tienen equivalente en la configuración):
 | `--target es2018` | Transpila a un nivel concreto (por defecto: el del propio código). |
 | `--drop-console` | Quita `console.*` y `debugger`. |
 | `--entry`, `--include`, `--ignore` | Entradas explícitas, archivos forzados y excluidos (repetibles). |
-| `--json` | Resultado en JSON para CI (código de salida 1 si algo falla). |
+| `--workers <n\|auto>` | Hilos para ofuscar/terser (`0` = sin hilos). |
+| `--no-cache` | No usa la caché de compilaciones anteriores. |
+| `--json` | Resultado en JSON para CI (código de salida 1 si algo falla), con el tiempo de cada fase. |
 
 ## Qué detecta solo
 
@@ -83,13 +89,41 @@ La batería de pruebas abre cada sitio de ejemplo **original y compilado en Chro
 
 ## Dependencias de terceros y ofuscación
 
-Ofuscar jQuery, Bootstrap o un paquete de npm no protege nada tuyo, los hace más lentos y puede incumplir su licencia. Por eso, al ofuscar:
+Ofuscar jQuery, Bootstrap o un paquete de npm no protege nada tuyo, los hace más lentos y puede incumplir su licencia. Por eso, al ofuscar, esto se detecta como dependencia y no se toca:
 
-- Se detectan como dependencia los archivos en `vendor/`, `node_modules/`, `third-party/`…, los nombres de librerías conocidas (`jquery-3.7.1.min.js`, `bootstrap.bundle.js`…), los `.min.js`/`.umd.js`, el código ya minificado y las cabeceras de licencia con versión (`/*! Foo v1.2.0 */`).
+- Archivos en `vendor/`, `node_modules/`, `third-party/`…
+- Nombres de librerías conocidas (`jquery-3.7.1.min.js`, `bootstrap.bundle.js`…) y versiones compiladas (`.min.js`, `.umd.js`).
+- Archivos que se llaman como un paquete de las `dependencies` de tu `package.json` (`js/chart.umd.js` si dependes de `chart.js`).
+- Envoltorios UMD/AMD (el formato en que se publican las librerías), cabeceras de licencia con versión (`/*! Foo v1.2.0 */`) y código ya minificado.
 - Los paquetes de npm que importa tu código de módulos se separan en `assets/vendor/` (sin ofuscar y con su estado compartido intacto).
-- `builder analyze` lista qué detectó y por qué.
 
-Para corregirlo a mano:
+Para ver qué se detectó y por qué:
+
+```bash
+builder deps mi-sitio
+```
+
+¿Algo mal? Hay tres formas de corregirlo; usa la que te resulte más cómoda:
+
+```html
+<!-- 1. En el HTML -->
+<script src="js/mi-lib.js" data-builder="dependency"></script>
+<script src="js/app.min.js" data-builder="own"></script>
+```
+
+```js
+/* 2. Al principio del propio archivo */
+/* @builder-dependency */   // o: /* @builder-own */
+```
+
+```bash
+# 3. Desde la terminal (edita builder.config.json por ti y conserva el resto)
+builder deps add "js/libs/**"     # son librerías: no ofuscar
+builder deps own js/app.min.js    # es mi código: ofuscarlo
+builder deps reset js/app.min.js  # volver a la detección automática
+```
+
+La configuración tiene la última palabra sobre las marcas, y las marcas sobre la detección automática:
 
 ```json
 {
@@ -106,6 +140,37 @@ Para corregirlo a mano:
 
 Niveles: `low` (casi sin coste), `medium` (recomendado), `high` y `max` (además se defiende de ser formateado o modificado; más pesado y lento). Las opciones que cambian el comportamiento (`debugProtection`, `disableConsoleOutput`, `renameGlobals`) nunca se activan solas; puedes pasarlas con un objeto: `"obfuscate": { "preset": "high", "debugProtection": true }`. Tus comentarios de licencia (`/*! … */`, `@license`) se conservan.
 
+## TypeScript
+
+Apunta tu HTML a archivos `.ts` (o al nombre `.js`, como recomienda el propio TypeScript) y compila:
+
+```html
+<script type="module" src="js/main.ts"></script>
+```
+
+- Cada `.ts`/`.mts`/`.cts` se transpila con esbuild usando tu `tsconfig.json` (se quitan los tipos, el nivel de sintaxis no cambia) y luego pasa por el mismo proceso que el JavaScript: empaquetado, ofuscación y verificación.
+- La salida es `.js` (`.mjs`/`.cjs`) y el HTML se reescribe para apuntar a ella. Siguen funcionando `import './x.ts'`, `import './x'`, `import './carpeta'` y `new URL('./worker.ts', import.meta.url)`.
+- Los `.d.ts` y los `*.test.ts` no se publican.
+- Builder no comprueba tipos: para eso, ejecuta `tsc --noEmit` en tu CI.
+
+## Velocidad
+
+Medido con `npm run bench` (un sitio generado con 40 páginas, 240 módulos, 120 scripts clásicos, 30 CSS y 200 imágenes; mediana de 3 ejecuciones en un i7-11700F, Node 24, Windows):
+
+| Compilación | 0.1.0 | 0.2.0, primera vez | 0.2.0, recompilar (caché) |
+| --- | ---: | ---: | ---: |
+| Por defecto | 3,7 s | 1,9 s | 1,4 s |
+| `--obfuscate` | 11,5–17,9 s | 7,0 s | 1,8 s |
+| `--hash --compress` | 2,6–3,8 s | 2,1 s | 1,1 s |
+| `--minifier terser` | 5,6–6,0 s | 3,7 s | 1,6 s |
+
+Cómo:
+
+- **Hilos**: la ofuscación, terser y la comprobación final de sintaxis van en hilos de trabajo (`workers: "auto"` ≈ núcleos físicos, máximo 8). El hilo principal también trabaja, y los hilos solo arrancan cuando hay suficiente trabajo en cola para compensar su arranque, así que un proyecto pequeño nunca va más lento.
+- **Caché persistente**: los resultados se guardan por contenido en `node_modules/.cache/vanilla-builder` (o en el temporal del sistema). Misma entrada + mismas opciones + mismas versiones = misma salida, byte a byte; las pruebas lo comprueban. Con `BUILDER_CACHE_DIR` puedes conservarla entre ejecuciones de CI. `--no-cache` o `"cache": false` la desactivan.
+- **En paralelo y en orden**: los archivos independientes se procesan a la vez, pero se registran en el orden original, así que la salida no depende de los tiempos.
+- `--json` incluye `perf.phases` (milisegundos por fase) para ver dónde se va el tiempo en tu proyecto.
+
 ## Configuración (`builder.config.json`)
 
 ```json
@@ -120,6 +185,8 @@ Niveles: `low` (casi sin coste), `medium` (recomendado), `high` y `max` (además
   "hash": false,
   "sourcemap": false,
   "compress": false,
+  "cache": true,
+  "workers": "auto",
   "base": "/",
   "sri": "auto",
   "html": { "minify": true, "removeComments": true, "collapseWhitespace": "auto" },
@@ -146,6 +213,7 @@ console.log(result.report.totals, result.warnings);
 
 ```bash
 npm test               # unitarias + integración (Node 18+; en Node 16: npm run test:node16)
+npm run bench          # velocidad sobre un sitio generado, primera vez y con caché
 npm run test:browser   # equivalencia real en Chromium (busca Chrome/Edge o usa BUILDER_CHROMIUM)
 BUILDER_NODE=/ruta/node16 npm run test:browser   # compila con otro Node y verifica en el navegador
 ```
@@ -156,6 +224,7 @@ BUILDER_NODE=/ruta/node16 npm run test:browser   # compila con otro Node y verif
 - Con `hash: true`, los JS/CSS cambian de nombre; si tu código los pide por texto, Builder publica también la ruta original y lo avisa.
 - Colapsar espacios en HTML cambia `textContent` (no lo que se ve). Para conservarlo byte a byte: `"html": { "collapseWhitespace": false }`.
 - `import()` con rutas calculadas sin prefijo fijo hace que ese grupo de módulos se minifique archivo por archivo en su sitio (sin empaquetar), para no romper rutas.
+- TypeScript: no se comprueban tipos, no hay `.tsx`/JSX, y los source maps apuntan al JavaScript ya sin tipos, no a las líneas del `.ts`.
 
 ## Licencia
 

package/README.md

@@ -9,8 +9,11 @@ It follows the real dependencies of every page, verifies the output before publi
 
 - **Zero config**: point it at a folder with `.html` files and you are done.
 - **Lossless**: every project file ends up with a known fate (processed, bundled, copied or deliberately skipped), and the output is verified before it replaces `dist/`.
-- **Lightweight**: 57 KB of its own code; the base install is 8 packages (most of it is the esbuild binary). The obfuscator and terser are only installed if you use them.
-- **Node 16 or newer** (tested on 16, 18, 20, 22 and 24).
+- **Fast**: obfuscation and terser run in parallel threads, and a persistent cache makes rebuilds of unchanged files almost free (obfuscated 40-page test site: 11–18 s in 0.1.0 → 7 s first build, 1.8 s rebuild). See [Speed](#speed).
+- **You decide what is a library**: third-party code is detected and never obfuscated; correct it from the HTML, the file itself or `builder deps`. See [Dependencies](#third-party-dependencies-and-obfuscation).
+- **TypeScript included**: `<script src="app.ts">` just works; the output is `.js`.
+- **Lightweight**: the base install is 8 packages (most of it is the esbuild binary). The obfuscator and terser are only installed if you use them.
+- **Node 16 or newer** (tested on 16, 18, 20, 22 and 24, on Linux, Windows and macOS).
 
 ## Install
 
@@ -29,6 +32,7 @@ npm install --save-dev terser                   # only if you want maximum compr
 npx builder build my-site                  # builds into my-site/dist
 npx builder build my-site --obfuscate      # also obfuscates your JavaScript (medium level)
 npx builder analyze my-site                # shows what will happen to each file, writes nothing
+npx builder deps my-site                   # which JS files are libraries (not obfuscated) and which are yours
 npx builder init my-site                   # creates builder.config.json from what it detected
 npx builder dev my-site                    # builds, watches and serves dist/ with live reload
 npx builder serve my-site                  # serves dist/ to try it out
@@ -48,7 +52,9 @@ Common `build` options (all of them have a config equivalent):
 | `--target es2018` | Transpile to a specific level (default: whatever your own code already uses). |
 | `--drop-console` | Removes `console.*` and `debugger`. |
 | `--entry`, `--include`, `--ignore` | Explicit entries, forced files and exclusions (repeatable). |
-| `--json` | JSON output for CI (exit code 1 if anything fails). |
+| `--workers <n\|auto>` | Threads for obfuscation/terser (`0` = no threads). |
+| `--no-cache` | Ignore the cache from previous builds. |
+| `--json` | JSON output for CI (exit code 1 if anything fails), including time per phase. |
 
 Run `npx builder help` for the full list.
 
@@ -85,13 +91,41 @@ The test suite opens every example site **original and built in Chromium** and r
 
 ## Third-party dependencies and obfuscation
 
-Obfuscating jQuery, Bootstrap or an npm package protects nothing of yours, makes them slower and may violate their license. So when obfuscating:
+Obfuscating jQuery, Bootstrap or an npm package protects nothing of yours, makes them slower and may violate their license. So when obfuscating, these are detected as dependencies and left untouched:
 
-- Files in `vendor/`, `node_modules/`, `third-party/`…, well-known library names (`jquery-3.7.1.min.js`, `bootstrap.bundle.js`…), `.min.js`/`.umd.js` files, already-minified code and license headers with a version (`/*! Foo v1.2.0 */`) are detected as dependencies.
+- Files in `vendor/`, `node_modules/`, `third-party/`…
+- Well-known library names (`jquery-3.7.1.min.js`, `bootstrap.bundle.js`…) and compiled builds (`.min.js`, `.umd.js`).
+- Files named like a package in your `package.json` `dependencies` (`js/chart.umd.js` when you depend on `chart.js`).
+- UMD/AMD wrappers (the format libraries are published in), license headers with a version (`/*! Foo v1.2.0 */`) and already-minified code.
 - npm packages imported by your module code are split into `assets/vendor/` (not obfuscated, with their shared state intact).
-- `builder analyze` lists what it detected and why.
 
-To correct it by hand:
+See what was detected and why:
+
+```bash
+npx builder deps my-site
+```
+
+Something wrong? There are three ways to fix it, pick the one that suits you:
+
+```html
+<!-- 1. In the HTML -->
+<script src="js/my-lib.js" data-builder="dependency"></script>
+<script src="js/app.min.js" data-builder="own"></script>
+```
+
+```js
+/* 2. At the top of the file itself */
+/* @builder-dependency */   // or: /* @builder-own */
+```
+
+```bash
+# 3. From the terminal (edits builder.config.json for you, keeps the rest of it)
+npx builder deps add "js/libs/**"     # these are libraries: don't obfuscate
+npx builder deps own js/app.min.js    # this is my code: obfuscate it
+npx builder deps reset js/app.min.js  # back to automatic detection
+```
+
+The config file has the last word over the marks, and the marks over the automatic detection:
 
 ```json
 {
@@ -108,6 +142,37 @@ To correct it by hand:
 
 Levels: `low` (almost free), `medium` (recommended), `high` and `max` (also defends against being reformatted or tampered with; heavier and slower). Options that change behavior (`debugProtection`, `disableConsoleOutput`, `renameGlobals`) are never turned on automatically; pass them with an object: `"obfuscate": { "preset": "high", "debugProtection": true }`. Your license comments (`/*! … */`, `@license`) are kept.
 
+## TypeScript
+
+Point your HTML at `.ts` files (or at the `.js` name, as TypeScript itself recommends) and build:
+
+```html
+<script type="module" src="js/main.ts"></script>
+```
+
+- Each `.ts`/`.mts`/`.cts` is transpiled with esbuild using your `tsconfig.json` (types removed, syntax level untouched), then goes through the same pipeline as JavaScript: bundling, obfuscation, verification.
+- The output is `.js` (`.mjs`/`.cjs`) and the HTML is rewritten to point to it. `import './x.ts'`, `import './x'`, `import './dir'` and `new URL('./worker.ts', import.meta.url)` keep working.
+- `.d.ts` files and `*.test.ts` are not published.
+- Builder does not type-check: run `tsc --noEmit` in your CI for that.
+
+## Speed
+
+Measured with `npm run bench` (a generated site with 40 pages, 240 modules, 120 classic scripts, 30 CSS files and 200 images; median of 3 runs on an i7-11700F, Node 24, Windows):
+
+| Build | 0.1.0 | 0.2.0, first build | 0.2.0, rebuild (cache) |
+| --- | ---: | ---: | ---: |
+| Default | 3.7 s | 1.9 s | 1.4 s |
+| `--obfuscate` | 11.5–17.9 s | 7.0 s | 1.8 s |
+| `--hash --compress` | 2.6–3.8 s | 2.1 s | 1.1 s |
+| `--minifier terser` | 5.6–6.0 s | 3.7 s | 1.6 s |
+
+How:
+
+- **Threads**: obfuscation, terser and the final syntax check run in worker threads (`workers: "auto"` ≈ physical cores, max 8). The main thread works too, and threads are only started when there is enough queued work to pay for their startup, so small projects are never slower.
+- **Persistent cache**: results are stored by content in `node_modules/.cache/vanilla-builder` (or the system temp folder). Same input + same options + same tool versions = same output, byte for byte; the test suite checks it. Set `BUILDER_CACHE_DIR` to keep it between CI runs. `--no-cache` or `"cache": false` turns it off.
+- **Parallel and in order**: independent files are processed at the same time but registered in the original order, so the output does not depend on timing.
+- `--json` includes `perf.phases` (milliseconds per phase) to see where the time goes in your project.
+
 ## Configuration (`builder.config.json`)
 
 ```json
@@ -122,6 +187,8 @@ Levels: `low` (almost free), `medium` (recommended), `high` and `max` (also defe
   "hash": false,
   "sourcemap": false,
   "compress": false,
+  "cache": true,
+  "workers": "auto",
   "base": "/",
   "sri": "auto",
   "html": { "minify": true, "removeComments": true, "collapseWhitespace": "auto" },
@@ -148,6 +215,7 @@ console.log(result.report.totals, result.warnings);
 
 ```bash
 npm test               # unit + integration (Node 18+; on Node 16: npm run test:node16)
+npm run bench          # speed on a generated site, first build and with cache
 npm run test:browser   # real equivalence in Chromium (finds Chrome/Edge or uses BUILDER_CHROMIUM)
 BUILDER_NODE=/path/to/node16 npm run test:browser   # build with another Node and verify in the browser
 ```
@@ -158,6 +226,7 @@ BUILDER_NODE=/path/to/node16 npm run test:browser   # build with another Node an
 - With `hash: true`, JS/CSS files are renamed; if your code requests them by string, the original path is also published and you get a warning.
 - Collapsing HTML whitespace changes `textContent` (not what you see). To keep it byte for byte: `"html": { "collapseWhitespace": false }`.
 - `import()` with computed paths and no fixed prefix makes that group of modules minify file by file in place (without bundling), so paths do not break.
+- TypeScript: no type checking, no `.tsx`/JSX, and source maps point to the type-stripped JavaScript, not to the `.ts` lines.
 
 ## License
 

package/bin/builder.js

@@ -8,7 +8,8 @@ import { runPipeline, VERSION } from '../src/builder.js';
 import { renderReport } from '../src/report.js';
 import { startServer } from '../src/server.js';
 import { watchTree } from '../src/watch.js';
-import { BuildError, formatBytes, relFrom, isInside } from '../src/util.js';
+import { BuildError, formatBytes, relFrom, isInside, JS_EXT, extOf, toPosix } from '../src/util.js';
+import { globMatcher } from '../src/files.js';
 
 const tty = process.stdout.isTTY && !process.env.NO_COLOR;
 const color = (code) => (text) => (tty ? `\x1b[${code}m${text}\x1b[0m` : String(text));
@@ -20,9 +21,16 @@ Uso:
   builder build   [carpeta] [opciones]   Compila el proyecto en dist/ (por defecto)
   builder analyze [carpeta] [--json]     Muestra dependencias detectadas y la salida prevista, sin escribir
   builder init    [carpeta] [--force]    Crea builder.config.json con lo detectado
+  builder deps    [carpeta]              Lista qué JS son librerías de terceros (no se ofuscan) y cuáles son tuyos
+  builder deps add|own|reset <patrón…>   Marca librerías (add), tu código (own) o vuelve a lo automático (reset)
   builder dev     [carpeta] [--port N]   Compila, vigila cambios y sirve dist/ con recarga automática
   builder serve   [carpeta] [--port N]   Sirve la carpeta de salida para probarla
 
+Marcar dependencias sin configuración:
+  En el HTML:        <script src="js/lib.js" data-builder="dependency"></script>   (o "own")
+  En el archivo:     /* @builder-dependency */  al principio                       (o @builder-own)
+  Con deps:          builder deps add "js/libs/**"   (en otra carpeta: --dir <carpeta>)
+
 Opciones de build:
   --out <carpeta>          Carpeta de salida (por defecto dist)
   --config <archivo>       Archivo de configuración (por defecto builder.config.json)
@@ -44,6 +52,8 @@ Opciones de build:
   --no-merge               No une scripts clásicos consecutivos
   --unreferenced <modo>    Archivos no referenciados: process | copy | skip (por defecto process)
   --base <ruta>            Ruta base del sitio para URLs absolutas (por defecto /)
+  --workers <n|auto>       Hilos para ofuscar/comprimir en paralelo (0 = sin hilos; por defecto auto)
+  --no-cache               No usa la caché de compilaciones anteriores
   --no-verify              Omite la verificación final (no recomendado)
   --force                  Permite vaciar una carpeta de salida que no creó Builder
   --keep-failed            Conserva la carpeta temporal si la verificación falla
@@ -68,6 +78,8 @@ function parseArgs(argv) {
     'dep',
     'not-dep',
     'minifier',
+    'workers',
+    'dir',
   ]);
   const optionalValue = { obfuscate: ['low', 'medium', 'high', 'max'], sourcemap: ['linked', 'hidden', 'inline'], compress: ['gzip', 'brotli'] };
   for (let i = 0; i < argv.length; i++) {
@@ -104,6 +116,12 @@ function overridesFrom(args) {
   if (args.base) o.base = args.base;
   if (args.verify === false) o.verify = false;
   if (args.compress !== undefined) o.compress = args.compress;
+  if (args.cache === false) o.cache = false;
+  if (args.workers !== undefined) {
+    const n = Number(args.workers);
+    if (args.workers !== 'auto' && !(Number.isInteger(n) && n >= 0)) throw new BuildError('--workers debe ser "auto" o un número (0 = sin hilos).');
+    o.workers = args.workers === 'auto' ? 'auto' : n;
+  }
   const deps = {};
   if (args.dep.length) deps.include = args.dep;
   if (args['not-dep'].length) deps.exclude = args['not-dep'];
@@ -151,6 +169,7 @@ function jsonResult(result) {
     warnings: result.warnings,
     notes: result.notes,
     verify: result.verify && { errors: result.verify.errors, stats: result.verify.stats },
+    perf: result.perf,
   };
 }
 
@@ -167,6 +186,18 @@ function printSummary(result, args) {
   }
   console.log(`${C.green('✔')} Cobertura: ${result.coverage.size}/${result.coverage.size} archivos de origen con destino conocido`);
   if (r.compressed) console.log(`${C.green('✔')} ${r.compressed} archivos precomprimidos (.gz/.br)`);
+  const p = result.perf;
+  if (p?.tasks) {
+    const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+    const where = p.threads ? `en el hilo principal y ${plural(p.threads, 'hilo', 'hilos')} más` : 'en el hilo principal';
+    const all = p.cacheHits === p.tasks;
+    const detail = all
+      ? p.tasks === 1
+        ? 'reutilizado de la caché'
+        : 'todos reutilizados de la caché'
+      : `${where}${p.cacheHits ? `, ${p.cacheHits} de la caché` : ''}`;
+    console.log(`${C.green('✔')} Ofuscación/terser: ${plural(p.tasks, 'archivo', 'archivos')}, ${detail}`);
+  }
   if (result.obfuscated) {
     const deps = [
       ...result.dependencies.map((d) => `${d.rel} — ${d.reason}`),
@@ -272,6 +303,79 @@ async function cmdInit(dir, args) {
   console.log(C.gray('  En "dependencies.include" marcas a mano librerías; en "dependencies.exclude" corriges una detección.'));
 }
 
+/** builder deps [carpeta] — lista; builder deps add|own|reset <patrón…> — edita builder.config.json. */
+async function cmdDeps(_dir, args) {
+  const sub = args._[1];
+  if (['add', 'own', 'reset'].includes(sub)) return editDeps(sub, args._.slice(2), args);
+  const dir = args.dir ?? sub ?? '.';
+  const cfg = await loadConfig({ dir, config: args.config, overrides: overridesFrom(args) });
+  const result = await runPipeline(cfg, { mode: 'analyze' });
+  const deps = new Map(result.dependencies.map((d) => [d.rel, d.reason]));
+  const own = [...result.coverage.keys()].filter((rel) => JS_EXT.has(extOf(rel)) && !deps.has(rel)).sort();
+  if (args.json) {
+    console.log(JSON.stringify({ dependencies: result.dependencies, own }, null, 2));
+    return;
+  }
+  console.log(`${C.bold(`Builder ${VERSION} — dependencias`)}  ${cfg.root}`);
+  printList(
+    'Librerías de terceros (no se ofuscan)',
+    [...deps].map(([rel, why]) => `${rel} ${C.gray(`— ${why}`)}`),
+    C.cyan,
+    200,
+  );
+  printList('Tu código (se ofusca con --obfuscate)', own, C.green, 200);
+  if (!deps.size && !own.length) console.log('\nNo hay archivos JavaScript en el proyecto.');
+  console.log(C.gray('\n¿Algo mal clasificado?'));
+  console.log(C.gray('  builder deps add <patrón>     es una librería: no se ofusca'));
+  console.log(C.gray('  builder deps own <patrón>     es tu código: sí se ofusca'));
+  console.log(C.gray('  builder deps reset <patrón>   vuelve a la detección automática'));
+  console.log(C.gray('  También: data-builder="dependency" en el <script>, o /* @builder-dependency */ al inicio del archivo.'));
+}
+
+async function editDeps(sub, rawPatterns, args) {
+  if (!rawPatterns.length) throw new BuildError(`Indica uno o más archivos o patrones: builder deps ${sub} "js/vendor/**"`);
+  const projectDir = path.resolve(args.dir ?? '.');
+  const file = args.config ? path.resolve(args.config) : (findConfigFile(projectDir) ?? path.join(projectDir, 'builder.config.json'));
+  if (!file.endsWith('.json'))
+    throw new BuildError(`La configuración está en ${path.basename(file)} (JavaScript); añade los patrones a mano en "dependencies".`);
+  const config = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8').replace(/^/, '')) : {};
+  if (config.dependencies === false || config.dependencies === true || config.dependencies == null) config.dependencies = {};
+  const d = config.dependencies;
+  const include = new Set(d.include ?? []);
+  const exclude = new Set(d.exclude ?? []);
+  const patterns = rawPatterns.map((p) => toPosix(p).replace(/^\.\//, ''));
+  for (const p of patterns) {
+    if (sub === 'add') {
+      include.add(p);
+      exclude.delete(p);
+    } else if (sub === 'own') {
+      exclude.add(p);
+      include.delete(p);
+    } else {
+      include.delete(p);
+      exclude.delete(p);
+    }
+  }
+  d.include = [...include];
+  d.exclude = [...exclude];
+  // Se valida antes de escribir: nunca deja un builder.config.json roto.
+  const cfg = await loadConfig({ dir: projectDir, config: args.config, overrides: { dependencies: { include: d.include, exclude: d.exclude } } });
+  const existed = fs.existsSync(file);
+  fs.writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+  const result = await runPipeline(cfg, { mode: 'analyze' });
+  const deps = new Map(result.dependencies.map((x) => [x.rel, x.reason]));
+  const jsFiles = [...result.coverage.keys()].filter((rel) => JS_EXT.has(extOf(rel)));
+  console.log(`${C.green('✔')} ${existed ? 'Actualizado' : 'Creado'} ${file}`);
+  for (const p of patterns) {
+    const hits = jsFiles.filter(globMatcher([p]));
+    if (!hits.length) {
+      console.log(C.yellow(`  ! "${p}" no coincide con ningún archivo JavaScript del proyecto (queda guardado igualmente)`));
+      continue;
+    }
+    for (const rel of hits) console.log(`  ${rel}  ${deps.has(rel) ? C.cyan(`librería — ${deps.get(rel)}`) : C.green('tu código — se ofusca')}`);
+  }
+}
+
 async function cmdServe(dir, args) {
   const cfg = await loadConfig({ dir, config: args.config, overrides: overridesFrom(args) });
   const target = fs.existsSync(cfg.outDir) ? cfg.outDir : null;
@@ -349,7 +453,7 @@ async function main() {
   if (args.version || args.v) return console.log(VERSION);
   const [command = 'help', dir = '.'] = args._;
   if (args.help || args.h || command === 'help') return console.log(HELP);
-  const commands = { build: cmdBuild, analyze: cmdAnalyze, init: cmdInit, serve: cmdServe, dev: cmdDev };
+  const commands = { build: cmdBuild, analyze: cmdAnalyze, init: cmdInit, serve: cmdServe, dev: cmdDev, deps: cmdDeps };
   if (!commands[command]) throw new BuildError(`Comando desconocido "${command}". Usa "builder help".`);
   await commands[command](dir, args);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vanilla-builder",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Zero-config bundler, minifier and obfuscator for vanilla HTML, CSS and JavaScript sites. Detects every dependency, verifies the output and never loses a file.",
   "type": "module",
   "main": "src/index.js",
@@ -24,7 +24,8 @@
     "test:browser": "node --test test/browser.test.js",
     "test:node16": "node test/unit.test.js && node test/build.test.js",
     "check": "node --test test/unit.test.js test/build.test.js test/browser.test.js",
-    "prepublishOnly": "npm test"
+    "prepublishOnly": "npm test",
+    "bench": "node bench/run.mjs"
   },
   "keywords": [
     "bundler",
@@ -36,7 +37,10 @@
     "css",
     "javascript",
     "build",
-    "esbuild"
+    "esbuild",
+    "typescript",
+    "obfuscation",
+    "minifier"
   ],
   "author": "MarioACo",
   "license": "MIT",