vanilla-builder 0.1.0 → 0.3.0

package/src/pool.js

@@ -0,0 +1,343 @@
+// Trabajo pesado (ofuscación y terser) en hilos paralelos, con caché persistente entre compilaciones.
+// La salida no depende del orden ni del número de hilos: cada tarea es determinista (la semilla del
+// ofuscador sale del contenido), así que reutilizar un resultado guardado da exactamente lo mismo.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { createRequire } from 'node:module';
+import { Worker } from 'node:worker_threads';
+import { ensureObfuscator, obfuscateSafe } from './obfuscate.js';
+import { importOptional } from './optional.js';
+import { terserMinify } from './tersercore.js';
+import { jsImports } from './jsimports.js';
+import { L, getLang } from './i18n.js';
+
+const WORKER_URL = new URL('./worker.js', import.meta.url);
+const OWN_VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+const CACHE_FORMAT = 1;
+const CACHE_MAX_BYTES = 256 * 1024 * 1024;
+const TASKS_PER_NEW_WORKER = 4;
+
+/**
+ * Hilos por defecto: aproximadamente los núcleos físicos (la mitad de los lógicos), máximo 8.
+ * Medido: más allá de eso el ofuscador apenas escala (memoria y recolector de basura).
+ */
+export function autoWorkers() {
+  const cpus = typeof os.availableParallelism === 'function' ? os.availableParallelism() : os.cpus().length;
+  return Math.max(1, Math.min(8, Math.floor(cpus / 2)));
+}
+
+/** Versión instalada de un paquete (para invalidar la caché al actualizarlo). */
+function packageVersion(name, root) {
+  for (const base of [new URL('../package.json', import.meta.url), path.join(root ?? process.cwd(), 'package.json')]) {
+    try {
+      let dir = path.dirname(createRequire(base).resolve(name));
+      for (let i = 0; i < 6; i++, dir = path.dirname(dir)) {
+        const file = path.join(dir, 'package.json');
+        if (fs.existsSync(file)) {
+          const pkg = JSON.parse(fs.readFileSync(file, 'utf8'));
+          if (pkg.name === name) return pkg.version;
+        }
+      }
+    } catch {
+      // no instalado aquí: se prueba la siguiente ubicación
+    }
+  }
+  return 'unknown';
+}
+
+/** Carpeta de caché: node_modules/.cache/vanilla-builder más cercano, o el temporal del sistema. */
+export function defaultCacheDir(root) {
+  // BUILDER_CACHE_DIR: para CI (guardarla entre ejecuciones) o para aislar pruebas.
+  if (process.env.BUILDER_CACHE_DIR) return path.resolve(process.env.BUILDER_CACHE_DIR);
+  for (let dir = root, i = 0; i < 20; i++) {
+    const nm = path.join(dir, 'node_modules');
+    if (fs.existsSync(nm)) return path.join(nm, '.cache', 'vanilla-builder');
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const id = crypto.createHash('sha256').update(root).digest('hex').slice(0, 12);
+  return path.join(os.tmpdir(), 'vanilla-builder-cache', id);
+}
+
+const plain = (v) => (v instanceof Map ? [...v.entries()] : v);
+
+/**
+ * @param {{root: string, workers?: number, cacheDir?: string|null}} opts
+ */
+export function createHeavy({ root, workers = autoWorkers(), cacheDir = null }) {
+  const stats = { tasks: 0, cacheHits: 0, threads: 0 };
+  const versions = new Map();
+  const idle = [];
+  const all = [];
+  const queue = [];
+  const pending = new Map();
+  let nextId = 1;
+  let broken = false;
+  let inProcessTerser = null;
+
+  const versionOf = (name) => {
+    if (!versions.has(name)) versions.set(name, packageVersion(name, root));
+    return versions.get(name);
+  };
+
+  function cacheKey(kind, payload) {
+    const engine = kind === 'obfuscate' ? 'javascript-obfuscator' : kind === 'terser' ? 'terser' : 'acorn';
+    // El idioma entra en la clave: los motivos de rechazo ("no se ofuscó: …") se guardan ya traducidos.
+    const meta = JSON.stringify([CACHE_FORMAT, OWN_VERSION, kind, versionOf(engine), getLang(), payload.opts, plain(payload.opts.globals)]);
+    return crypto.createHash('sha256').update(meta).update('\0').update(payload.code).digest('hex');
+  }
+
+  // Valores pequeños (importaciones, tamaños, resultados cortos): un único índice JSON en vez de miles
+  // de archivos diminutos, que en Windows (antivirus, indexado) cuestan más que calcularlos.
+  const SMALL_FILE = cacheDir ? path.join(cacheDir, 'small-v1.json') : null;
+  const SMALL_LIMIT = 2048;
+  const SMALL_MAX_ENTRIES = 100000;
+  let small = null;
+  let smallDirty = false;
+  function smallStore() {
+    if (!small) {
+      small = new Map();
+      try {
+        for (const [k, v] of JSON.parse(fs.readFileSync(SMALL_FILE, 'utf8'))) small.set(k, v);
+      } catch {
+        // índice ausente o dañado: se empieza vacío
+      }
+    }
+    return small;
+  }
+  function saveSmall() {
+    if (!smallDirty || !SMALL_FILE) return;
+    const entries = [...small.entries()].slice(-SMALL_MAX_ENTRIES);
+    const tmp = `${SMALL_FILE}.${process.pid}.tmp`;
+    try {
+      fs.mkdirSync(cacheDir, { recursive: true });
+      fs.writeFileSync(tmp, JSON.stringify(entries));
+      fs.renameSync(tmp, SMALL_FILE);
+    } catch {
+      try {
+        fs.rmSync(tmp, { force: true });
+      } catch {
+        // la caché es opcional
+      }
+    }
+  }
+
+  function readCache(key) {
+    if (!cacheDir) return undefined;
+    const s = smallStore();
+    if (s.has(key)) {
+      // Al final del Map = usado recientemente (se conservan los últimos al recortar).
+      const v = s.get(key);
+      s.delete(key);
+      s.set(key, v);
+      smallDirty = true;
+      return v;
+    }
+    const file = path.join(cacheDir, key.slice(0, 2), `${key}.json`);
+    try {
+      const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+      const now = new Date();
+      fs.utimes(file, now, now, () => {});
+      return value;
+    } catch {
+      return undefined;
+    }
+  }
+
+  function writeCache(key, value) {
+    if (!cacheDir) return;
+    const json = JSON.stringify(value);
+    if (json.length <= SMALL_LIMIT) {
+      smallStore().set(key, value);
+      smallDirty = true;
+      return;
+    }
+    const dir = path.join(cacheDir, key.slice(0, 2));
+    const file = path.join(dir, `${key}.json`);
+    const tmp = `${file}.${process.pid}.${nextId}.tmp`;
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(tmp, json);
+      fs.renameSync(tmp, file);
+    } catch {
+      try {
+        fs.rmSync(tmp, { force: true });
+      } catch {
+        // la caché es opcional: un fallo al escribirla no afecta a la compilación
+      }
+    }
+  }
+
+  async function runInProcess(kind, payload) {
+    if (kind === 'imports') return jsImports(payload.code, payload.opts.isModule);
+    if (kind === 'obfuscate') {
+      await ensureObfuscator(root);
+      return obfuscateSafe(payload.code, payload.opts);
+    }
+    inProcessTerser ??= await importOptional('terser', root, L('para la compresión máxima', 'for maximum compression'));
+    return terserMinify(inProcessTerser, payload.code, payload.opts);
+  }
+
+  function spawn() {
+    const w = new Worker(WORKER_URL, { workerData: { root, lang: getLang() } });
+    w.on('message', ({ id, result, error }) => {
+      const p = pending.get(id);
+      pending.delete(id);
+      w.busy = null;
+      idle.push(w);
+      pump();
+      if (!p) return;
+      if (error) p.reject(new Error(error));
+      else p.resolve(result);
+    });
+    w.on('error', (err) => {
+      // Si un hilo muere, sus tareas (y las siguientes) se hacen en el hilo principal.
+      broken = true;
+      const id = w.busy;
+      if (id != null && pending.has(id)) {
+        const p = pending.get(id);
+        pending.delete(id);
+        runInProcess(p.kind, p.payload).then(p.resolve, p.reject);
+      }
+      void err;
+    });
+    all.push(w);
+    stats.threads = all.length;
+    return w;
+  }
+
+  // El hilo principal toma la primera tarea libre (no hay que esperar a que arranque nada) y solo se
+  // crean hilos cuando hay más trabajo en cola: uno por tarea pendiente, hasta el máximo. Así un proyecto
+  // pequeño nunca paga el arranque de los hilos (cargar el ofuscador cuesta ~0,5 s por hilo).
+  let mainBusy = false;
+  function runOnMain(t) {
+    mainBusy = true;
+    setImmediate(async () => {
+      try {
+        t.resolve(await runInProcess(t.kind, t.payload));
+      } catch (err) {
+        t.reject(err);
+      } finally {
+        mainBusy = false;
+        pump();
+      }
+    });
+  }
+
+  function pump() {
+    while (queue.length) {
+      if (broken) {
+        const t = queue.shift();
+        runInProcess(t.kind, t.payload).then(t.resolve, t.reject);
+        continue;
+      }
+      let w = idle.pop();
+      if (!w) {
+        if (!mainBusy) {
+          runOnMain(queue.shift());
+          continue;
+        }
+        // Un hilo nuevo solo compensa con trabajo de sobra para él: arrancarlo cuesta lo que varias tareas.
+        if (all.length >= workers || queue.length < TASKS_PER_NEW_WORKER * (all.length + 1)) return;
+        w = spawn();
+      }
+      const t = queue.shift();
+      const id = nextId++;
+      w.busy = id;
+      pending.set(id, t);
+      w.postMessage({ id, kind: t.kind, payload: t.payload });
+    }
+  }
+
+  async function run(kind, payload) {
+    const counted = kind === 'obfuscate' || kind === 'terser';
+    if (counted) stats.tasks++;
+    const key = cacheDir ? cacheKey(kind, payload) : null;
+    if (key) {
+      const hit = readCache(key);
+      if (hit !== undefined) {
+        if (counted) stats.cacheHits++;
+        return hit;
+      }
+    }
+    const result =
+      workers > 0
+        ? await new Promise((resolve, reject) => {
+            queue.push({ kind, payload, resolve, reject });
+            pump();
+          })
+        : await runInProcess(kind, payload);
+    if (key) writeCache(key, result);
+    return result;
+  }
+
+  return {
+    stats,
+    /** Ofusca y verifica (ver obfuscateSafe). */
+    obfuscate: (code, opts) => run('obfuscate', { code, opts }),
+    /** Importaciones de un JS generado, o {error} si no es válido (verificación final). */
+    imports: (code, isModule) => run('imports', { code, opts: { isModule } }),
+    /** Valor costoso guardado en la caché por clave (p. ej. tamaños comprimidos de un contenido). */
+    async memo(kind, keyData, compute) {
+      const key = cacheDir
+        ? crypto
+            .createHash('sha256')
+            .update(JSON.stringify([CACHE_FORMAT, OWN_VERSION, getLang(), kind]))
+            .update('\0')
+            .update(keyData)
+            .digest('hex')
+        : null;
+      if (key) {
+        const hit = readCache(key);
+        if (hit !== undefined) return hit;
+      }
+      const value = await compute();
+      if (key) writeCache(key, value);
+      return value;
+    },
+    /** Pasada de terser verificada (ver terserMinify). */
+    terser: (code, opts) => run('terser', { code, opts }),
+    async close() {
+      await Promise.all(all.map((w) => w.terminate()));
+      all.length = 0;
+      idle.length = 0;
+      if (cacheDir) {
+        saveSmall();
+        pruneCache(cacheDir);
+      }
+    },
+  };
+}
+
+/** Mantiene la caché por debajo del límite borrando lo usado hace más tiempo. */
+function pruneCache(dir) {
+  let entries = [];
+  try {
+    for (const sub of fs.readdirSync(dir)) {
+      if (!/^[0-9a-f]{2}$/.test(sub)) continue;
+      const d = path.join(dir, sub);
+      for (const f of fs.readdirSync(d)) {
+        const file = path.join(d, f);
+        const st = fs.statSync(file);
+        entries.push({ file, size: st.size, time: st.mtimeMs });
+      }
+    }
+  } catch {
+    return;
+  }
+  let total = entries.reduce((a, e) => a + e.size, 0);
+  if (total <= CACHE_MAX_BYTES) return;
+  entries = entries.sort((a, b) => a.time - b.time);
+  for (const e of entries) {
+    if (total <= CACHE_MAX_BYTES * 0.8) break;
+    try {
+      fs.rmSync(e.file, { force: true });
+      total -= e.size;
+    } catch {
+      // otro proceso pudo borrarlo
+    }
+  }
+}

package/src/report.js

@@ -1,35 +1,31 @@
 // Informe de tamaños (original, final, gzip y brotli) por archivo y totales.
-import zlib from 'node:zlib';
 import { formatBytes } from './util.js';
+import { gzipOf, brotliOf, mapLimit } from './compress.js';
+import { L } from './i18n.js';
 
 const COMPRESSIBLE = new Set(['html', 'css', 'js', 'json', 'svg', 'text']);
 
-export function sizesOf(buf, type) {
+export async function sizesOf(buf, type) {
   const size = buf.length;
   if (!COMPRESSIBLE.has(type) || size === 0) return { size, gzip: null, brotli: null };
-  return {
-    size,
-    gzip: zlib.gzipSync(buf, { level: 9 }).length,
-    brotli: zlib.brotliCompressSync(buf, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 11 } }).length,
-  };
+  const [gz, br] = await Promise.all([gzipOf(buf), brotliOf(buf)]);
+  return { size, gzip: gz.length, brotli: br.length };
 }
 
 /** Filas del informe a partir de las salidas. */
-export function buildReport(outputs) {
-  const rows = [];
+export async function buildReport(outputs, heavy = null) {
   let compressed = 0;
+  const items = [];
   for (const [rel, o] of outputs) {
-    if (o.type === 'compressed') {
-      compressed++;
-      continue;
-    }
-    if (o.copyFrom) {
-      rows.push({ file: rel, type: o.type, action: o.action, sources: o.sources, before: o.size, size: o.size, gzip: null, brotli: null });
-      continue;
-    }
-    const s = sizesOf(o.data, o.type);
-    rows.push({ file: rel, type: o.type, action: o.action, sources: o.sources, before: o.before ?? s.size, ...s });
+    if (o.type === 'compressed') compressed++;
+    else items.push([rel, o]);
   }
+  const rows = await mapLimit(items, 64, async ([rel, o]) => {
+    if (o.copyFrom) return { file: rel, type: o.type, action: o.action, sources: o.sources, before: o.size, size: o.size, gzip: null, brotli: null };
+    const cached = heavy && COMPRESSIBLE.has(o.type) && o.data.length;
+    const s = cached ? await heavy.memo('sizes', o.data, () => sizesOf(o.data, o.type)) : await sizesOf(o.data, o.type);
+    return { file: rel, type: o.type, action: o.action, sources: o.sources, before: o.before ?? s.size, ...s };
+  });
   rows.sort((a, b) => (a.type === b.type ? a.file.localeCompare(b.file) : order(a.type) - order(b.type)));
   const totals = { before: 0, size: 0, gzip: 0, brotli: 0, files: rows.length };
   const byType = {};
@@ -56,15 +52,20 @@ export function renderReport(report, C, { verbose = false } = {}) {
   const lines = [];
   const shown = report.rows.filter((r) => verbose || r.action !== 'copy');
   const hidden = report.rows.filter((r) => !verbose && r.action === 'copy');
-  const hiddenLabel = `+ ${hidden.length} recursos copiados sin cambios`;
+  const hiddenLabel = L(`+ ${hidden.length} recursos copiados sin cambios`, `+ ${hidden.length} assets copied unchanged`);
   const w = Math.min(60, Math.max(20, ...shown.map((r) => r.file.length), hidden.length ? hiddenLabel.length : 0));
   const pad = (s, n) => (s.length > n ? `…${s.slice(-(n - 1))}` : s.padEnd(n));
   const num = (n) => (n == null ? '—' : formatBytes(n)).padStart(10);
   lines.push(
-    C.gray(`${'Archivo'.padEnd(w)}  ${'Antes'.padStart(10)}  ${'Después'.padStart(10)}  ${'gzip'.padStart(10)}  ${'brotli'.padStart(10)}  Ahorro`),
+    C.gray(
+      L(
+        `${'Archivo'.padEnd(w)}  ${'Antes'.padStart(10)}  ${'Después'.padStart(10)}  ${'gzip'.padStart(10)}  ${'brotli'.padStart(10)}  Ahorro`,
+        `${'File'.padEnd(w)}  ${'Before'.padStart(10)}  ${'After'.padStart(10)}  ${'gzip'.padStart(10)}  ${'brotli'.padStart(10)}  Saved`,
+      ),
+    ),
   );
   for (const r of shown) {
-    const src = r.sources && r.sources.length > 1 ? C.gray(` (${r.sources.length} archivos)`) : '';
+    const src = r.sources && r.sources.length > 1 ? C.gray(L(` (${r.sources.length} archivos)`, ` (${r.sources.length} files)`)) : '';
     lines.push(`${pad(r.file, w)}  ${num(r.before)}  ${num(r.size)}  ${num(r.gzip)}  ${num(r.brotli)}  ${pct(r.before, r.size).padStart(6)}${src}`);
   }
   if (hidden.length) {

package/src/server.js

@@ -2,6 +2,7 @@
 import fs from 'node:fs';
 import http from 'node:http';
 import path from 'node:path';
+import { L } from './i18n.js';
 
 const MIME = {
   '.html': 'text/html; charset=utf-8',
@@ -42,7 +43,8 @@ const MIME = {
 
 const RELOAD_SCRIPT = `<script>(()=>{const s=new EventSource('/__builder/events');let box;
 s.addEventListener('reload',()=>location.reload());
-s.addEventListener('error-build',e=>{box??=document.body.appendChild(Object.assign(document.createElement('pre'),{style:'position:fixed;inset:auto 0 0 0;max-height:50vh;overflow:auto;margin:0;padding:12px;background:#300;color:#fdd;font:12px/1.4 monospace;z-index:2147483647;white-space:pre-wrap'}));box.textContent='Builder: error al compilar\\n\\n'+JSON.parse(e.data)});
+s.addEventListener('css',()=>{for(const l of document.querySelectorAll('link[rel~="stylesheet"][href]')){const u=new URL(l.href,location.href);if(u.origin!==location.origin)continue;u.searchParams.set('vb',Date.now());const n=l.cloneNode();n.href=u.href;n.onload=n.onerror=()=>l.remove();l.after(n)}});
+s.addEventListener('error-build',e=>{box??=document.body.appendChild(Object.assign(document.createElement('pre'),{style:'position:fixed;inset:auto 0 0 0;max-height:50vh;overflow:auto;margin:0;padding:12px;background:#300;color:#fdd;font:12px/1.4 monospace;z-index:2147483647;white-space:pre-wrap'}));box.textContent=JSON.parse(e.data)});
 s.addEventListener('ok',()=>{box?.remove();box=null});})();</script>`;
 
 /**
@@ -56,7 +58,7 @@ export function startServer({ dir, port = 5173, host = '127.0.0.1', liveReload =
     try {
       pathname = decodeURIComponent(new URL(req.url, 'http://x').pathname);
     } catch {
-      res.writeHead(400).end('URL inválida');
+      res.writeHead(400).end(L('URL inválida', 'Invalid URL'));
       return;
     }
     if (liveReload && pathname === '/__builder/events') {
@@ -84,7 +86,7 @@ export function startServer({ dir, port = 5173, host = '127.0.0.1', liveReload =
     }
     fs.readFile(file, (err, data) => {
       if (err) {
-        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' }).end(`No encontrado: ${pathname}`);
+        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' }).end(L(`No encontrado: ${pathname}`, `Not found: ${pathname}`));
         return;
       }
       const ext = path.extname(file).toLowerCase();
@@ -111,7 +113,9 @@ export function startServer({ dir, port = 5173, host = '127.0.0.1', liveReload =
         url: `http://${host === '0.0.0.0' ? 'localhost' : host}:${addr.port}/`,
         port: addr.port,
         reload: () => send('reload'),
-        buildError: (msg) => send('error-build', msg),
+        // Solo cambió CSS: se recargan las hojas de estilos sin perder el estado de la página.
+        reloadCss: () => send('css'),
+        buildError: (msg) => send('error-build', `${L('Builder: error al compilar', 'Builder: build failed')}\n\n${msg}`),
         buildOk: () => send('ok'),
         close: () =>
           new Promise((r) => {

package/src/tersercore.js

@@ -0,0 +1,33 @@
+// Pasada de terser con verificación. Sin estado: se usa igual en el hilo principal y en los hilos de trabajo.
+import { compareGlobals, moduleShape } from './jsinfo.js';
+
+/**
+ * Comprime con terser y solo acepta el resultado si es más pequeño y conserva las globales (scripts)
+ * o las exportaciones/importaciones (módulos). Devuelve el código original si no compensa.
+ */
+export async function terserMinify(terser, code, { isModule, level, globals, allowPrefix = null, keepNames = false }) {
+  const ecma = Math.min(2020, Math.max(5, level ?? 2020));
+  let out;
+  try {
+    const r = await terser.minify(code, {
+      module: isModule,
+      toplevel: isModule,
+      ecma,
+      compress: { passes: 3, ecma, module: isModule, toplevel: isModule },
+      mangle: { toplevel: isModule },
+      keep_fnames: keepNames,
+      keep_classnames: keepNames,
+      format: { comments: /^!|@license|@preserve/i, ascii_only: true, ecma },
+    });
+    out = r.code;
+  } catch {
+    return code;
+  }
+  if (!out || out.length >= code.trimEnd().length) return code;
+  if (isModule) {
+    const a = moduleShape(code);
+    const b = moduleShape(out);
+    if (!a || !b || a.exports !== b.exports || a.imports !== b.imports) return code;
+  } else if (!globals || !compareGlobals(globals, out, allowPrefix).ok) return code;
+  return out;
+}

package/src/urls.js

@@ -61,6 +61,9 @@ export function resolveRef(raw, baseDir, ctx, opts = {}) {
   for (const c of candidates) {
     if (ctx.files.has(c)) return { status: 'ok', rel: c, info };
   }
+  // Convención de TypeScript: se escribe "./x.js" y el archivo es x.ts (su salida será justo x.js).
+  const ts = !isDirLike && /\.(m|c)?js$/i.test(rel) ? rel.replace(/\.(m|c)?js$/i, (_, p) => `.${p ?? ''}ts`) : null;
+  if (ts && ctx.files.has(ts)) return { status: 'ok', rel: ts, info };
   for (const c of candidates) {
     if (ctx.ignoredSet?.has(c)) return { status: 'ignored', rel: c, info };
     // Diferencia solo de mayúsculas: en Windows funciona, en un servidor Linux no.

package/src/util.js

@@ -55,7 +55,11 @@ export function stripBom(text) {
 
 export const extOf = (p) => path.posix.extname(p).toLowerCase();
 
-export const JS_EXT = new Set(['.js', '.mjs', '.cjs']);
+// TypeScript se transpila al empezar y desde ahí se trata como JavaScript (sale con extensión .js).
+export const TS_EXT = new Set(['.ts', '.mts', '.cts']);
+export const JS_EXT = new Set(['.js', '.mjs', '.cjs', ...TS_EXT]);
+/** Ruta de salida de un script: app.ts → app.js, x.mts → x.mjs, x.cts → x.cjs. */
+export const jsOutPath = (rel) => rel.replace(/\.(m|c)?ts$/i, (_, p) => `.${(p ?? '').toLowerCase()}js`);
 export const CSS_EXT = new Set(['.css']);
 export const HTML_EXT = new Set(['.html', '.htm']);
 export const JSON_EXT = new Set(['.json', '.webmanifest', '.map']);

package/src/verify.js

@@ -1,10 +1,11 @@
 // Verificación de la salida antes de publicarla: referencias, sintaxis, escritura y cobertura.
 import fs from 'node:fs';
 import path from 'node:path';
-import * as acorn from 'acorn';
-import * as walk from 'acorn-walk';
+import { jsImports } from './jsimports.js';
+import { mapLimit } from './compress.js';
 import { parseHtml } from './html.js';
 import { classifyUrl, parseSrcset } from './urls.js';
+import { L } from './i18n.js';
 
 function unescapeCss(s) {
   return s.replace(/\\([0-9a-f]{1,6}[ \t\n]?|[\s\S])/gi, (_, e) => (/^[0-9a-f]/i.test(e) ? String.fromCodePoint(parseInt(e, 16)) : e));
@@ -54,17 +55,6 @@ export function cssRefs(css) {
   return refs;
 }
 
-function jsImports(code, isModule) {
-  const ast = acorn.parse(code, { ecmaVersion: 'latest', sourceType: isModule ? 'module' : 'script', allowHashBang: true });
-  const out = [];
-  walk.full(ast, (n) => {
-    if ((n.type === 'ImportDeclaration' || n.type === 'ExportAllDeclaration' || n.type === 'ExportNamedDeclaration') && n.source)
-      out.push(n.source.value);
-    if (n.type === 'ImportExpression' && n.source.type === 'Literal' && typeof n.source.value === 'string') out.push(n.source.value);
-  });
-  return out;
-}
-
 /**
  * @param {string} staging carpeta temporal escrita
  * @param {Map<string, object>} outputs archivos generados (rel → {data|copyFrom, type, size})
@@ -93,10 +83,20 @@ export async function verifyOutput(staging, outputs, ctx) {
       const candidates = rel === '' || rel.endsWith('/') ? [`${rel}index.html`] : page ? [rel, `${rel}/index.html`, `${rel}.html`] : [rel];
       if (candidates.some(exists)) continue;
       const ci = candidates.map((c) => lower.get(c.toLowerCase())).find(Boolean);
-      errors.push(`${fromRel}: la referencia "${u}" no existe en la salida${ci ? ` (existe "${ci}" con otras mayúsculas)` : ''}.`);
+      errors.push(
+        L(
+          `${fromRel}: la referencia "${u}" no existe en la salida${ci ? ` (existe "${ci}" con otras mayúsculas)` : ''}.`,
+          `${fromRel}: the reference "${u}" does not exist in the output${ci ? ` ("${ci}" exists with different capitalization)` : ''}.`,
+        ),
+      );
     }
   };
 
+  // Parseo de los JS generados: en paralelo (hilos) y con caché por contenido; el resultado es el mismo.
+  const parse = (code, isModule) => (ctx.heavy ? ctx.heavy.imports(code, isModule) : jsImports(code, isModule));
+  const jsList = [...outputs].filter(([, o]) => o.type === 'js' && !o.copyFrom);
+  const parsed = new Map(await mapLimit(jsList, 64, async ([rel, o]) => [rel, await parse(o.data.toString('utf8'), !!o.module)]));
+
   for (const [rel, o] of outputs) {
     stats.files++;
     const dest = path.join(staging, rel);
@@ -104,11 +104,12 @@ export async function verifyOutput(staging, outputs, ctx) {
     try {
       st = fs.statSync(dest);
     } catch {
-      errors.push(`${rel}: no se escribió en disco.`);
+      errors.push(L(`${rel}: no se escribió en disco.`, `${rel}: was not written to disk.`));
       continue;
     }
     const expected = o.copyFrom ? o.size : Buffer.byteLength(o.data);
-    if (st.size !== expected) errors.push(`${rel}: tamaño en disco ${st.size} ≠ esperado ${expected}.`);
+    if (st.size !== expected)
+      errors.push(L(`${rel}: tamaño en disco ${st.size} ≠ esperado ${expected}.`, `${rel}: size on disk ${st.size} ≠ expected ${expected}.`));
     if (o.copyFrom) continue;
     const dir = path.posix.dirname(rel) === '.' ? '' : path.posix.dirname(rel);
     if (o.type === 'html') {
@@ -120,11 +121,15 @@ export async function verifyOutput(staging, outputs, ctx) {
       for (const s of model.scripts) {
         if (s.src) check(rel, s.src.value, baseDir);
         if (s.inline && s.kind === 'module') {
-          try {
-            for (const spec of jsImports(s.inline.code, true)) if (/^\.{0,2}\//.test(spec)) check(rel, spec, baseDir);
-          } catch (err) {
-            errors.push(`${rel}: un <script type="module"> inline no es JS válido (${err.message}).`);
-          }
+          const r = jsImports(s.inline.code, true);
+          if (r.error)
+            errors.push(
+              L(
+                `${rel}: un <script type="module"> inline no es JS válido (${r.error}).`,
+                `${rel}: an inline <script type="module"> is not valid JS (${r.error}).`,
+              ),
+            );
+          else for (const spec of r.imports) if (/^\.{0,2}\//.test(spec)) check(rel, spec, baseDir);
         }
       }
       for (const l of model.links) if (l.type === 'stylesheet' || l.type === 'asset' || l.type === 'preload') check(rel, l.href.value, baseDir);
@@ -134,15 +139,20 @@ export async function verifyOutput(staging, outputs, ctx) {
       for (const u of cssRefs(o.data.toString('utf8'))) check(rel, u, dir);
     } else if (o.type === 'js') {
       stats.js++;
-      try {
-        for (const spec of jsImports(o.data.toString('utf8'), !!o.module)) if (/^\.{0,2}\//.test(spec)) check(rel, spec, dir);
-      } catch (err) {
-        errors.push(`${rel}: el JavaScript generado no es válido (${err.message}).`);
-      }
+      const r = parsed.get(rel);
+      if (r.error)
+        errors.push(L(`${rel}: el JavaScript generado no es válido (${r.error}).`, `${rel}: the generated JavaScript is not valid (${r.error}).`));
+      else for (const spec of r.imports) if (/^\.{0,2}\//.test(spec)) check(rel, spec, dir);
     }
   }
 
   const missing = [...ctx.files.keys()].filter((rel) => !ctx.coverage.has(rel));
-  for (const rel of missing) errors.push(`${rel}: Builder no registró qué hizo con este archivo (no se publicaría).`);
+  for (const rel of missing)
+    errors.push(
+      L(
+        `${rel}: Builder no registró qué hizo con este archivo (no se publicaría).`,
+        `${rel}: Builder did not record what it did with this file (it would not be published).`,
+      ),
+    );
   return { errors, warnings, stats };
 }

package/src/worker.js

@@ -0,0 +1,30 @@
+// Hilo de trabajo: ofusca o comprime con terser fuera del hilo principal.
+import { parentPort, workerData } from 'node:worker_threads';
+import { ensureObfuscator, obfuscateSafe } from './obfuscate.js';
+import { importOptional } from './optional.js';
+import { terserMinify } from './tersercore.js';
+import { jsImports } from './jsimports.js';
+import { L, setLang } from './i18n.js';
+
+let terser = null;
+
+// Mismo idioma que el proceso principal (puede venir de --lang).
+setLang(workerData.lang);
+
+parentPort.on('message', async ({ id, kind, payload }) => {
+  try {
+    let result;
+    if (kind === 'obfuscate') {
+      await ensureObfuscator(workerData.root);
+      result = obfuscateSafe(payload.code, payload.opts);
+    } else if (kind === 'terser') {
+      terser ??= await importOptional('terser', workerData.root, L('para la compresión máxima', 'for maximum compression'));
+      result = await terserMinify(terser, payload.code, payload.opts);
+    } else if (kind === 'imports') {
+      result = jsImports(payload.code, payload.opts.isModule);
+    } else throw new Error(`tarea desconocida: ${kind}`);
+    parentPort.postMessage({ id, result });
+  } catch (err) {
+    parentPort.postMessage({ id, error: String(err?.message ?? err) });
+  }
+});