vanilla-builder 0.1.0 → 0.2.0

package/src/js.js

@@ -4,11 +4,10 @@ import fs from 'node:fs';
 import * as esbuild from 'esbuild';
 import * as acorn from 'acorn';
 import * as walk from 'acorn-walk';
-import { analyzeJs, compareGlobals, moduleShape } from './jsinfo.js';
-import { obfuscateSafe } from './obfuscate.js';
+import { analyzeJs, compareGlobals } from './jsinfo.js';
 import { importOptional } from './optional.js';
 import { replaceWithMap } from './sourcemap.js';
-import { relFrom, toPosix, BuildError, rootPrefix, hasOwn, shortHash } from './util.js';
+import { relFrom, toPosix, BuildError, rootPrefix, hasOwn, shortHash, jsOutPath } from './util.js';
 import { classifyUrl } from './urls.js';
 import { formatMessage, esbuildErrorText } from './css.js';
 
@@ -93,7 +92,7 @@ export async function processClassic(ctx, { code, id, info, obfuscate, sourcemap
     if (!done) notes.push('se deja sin minificar para no romperlo');
   }
   if (obfuscate) {
-    const o = obfuscateSafe(out, { isModule: false, options: ctx.obfuscatorOptions, id, globals: info.top });
+    const o = await ctx.heavy.obfuscate(out, { isModule: false, options: ctx.obfuscatorOptions, id, globals: info.top });
     if (o.code) {
       out = o.code;
       map = null;
@@ -138,7 +137,7 @@ export async function processModuleStandalone(ctx, { code, id, info, obfuscate,
     }
   }
   if (obfuscate) {
-    const o = obfuscateSafe(out, { isModule: true, options: ctx.obfuscatorOptions, id });
+    const o = await ctx.heavy.obfuscate(out, { isModule: true, options: ctx.obfuscatorOptions, id });
     if (o.code) {
       out = o.code;
       map = null;
@@ -154,8 +153,8 @@ export async function processModuleStandalone(ctx, { code, id, info, obfuscate,
 }
 
 /** Ofusca un módulo ya generado (paquete, chunk o worker). */
-export function obfuscateModule(ctx, code, id) {
-  const o = obfuscateSafe(code, { isModule: true, options: ctx.obfuscatorOptions, id });
+export async function obfuscateModule(ctx, code, id) {
+  const o = await ctx.heavy.obfuscate(code, { isModule: true, options: ctx.obfuscatorOptions, id });
   return o.code ? { code: o.code } : { code, note: `no se ofuscó: ${o.reason}` };
 }
 
@@ -196,6 +195,14 @@ export function mapSpecifier(ctx, importMap, spec, importerDir) {
 
 const EXTERNAL_SPEC = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
 
+function isFile(abs) {
+  try {
+    return fs.statSync(abs).isFile();
+  } catch {
+    return false;
+  }
+}
+
 function modulePlugin(ctx, group, state) {
   const isDepPath = (abs) => {
     if (!abs) return false;
@@ -245,6 +252,11 @@ function modulePlugin(ctx, group, state) {
         if (!state.vendor || a.pluginData?.vbInner || r?.external || r?.errors) return r;
         if (a.namespace !== 'vb-inline' && isDepPath(a.importer)) return r;
         let abs = r?.path;
+        // Ruta relativa a un archivo que existe: se resuelve aquí, sin otro viaje de ida y vuelta a esbuild.
+        if (!abs && /^\.\.?\//.test(a.path) && a.namespace !== 'vb-inline' && a.resolveDir) {
+          const direct = path.resolve(a.resolveDir, a.path);
+          if (path.extname(direct) && isFile(direct)) abs = direct;
+        }
         if (!abs) {
           const res = await b.resolve(a.path, {
             kind: a.kind,
@@ -290,9 +302,12 @@ function modulePlugin(ctx, group, state) {
         }
         return undefined;
       };
-      b.onLoad({ filter: /\.(?:m?js|cjs)$/i }, (a) => {
+      b.onLoad({ filter: /\.(?:m?js|cjs|m?ts|cts)$/i }, (a) => {
         const rel = relFrom(ctx.root, a.path);
         const local = rel != null && !/(^|\/)node_modules\//.test(rel) && ctx.files.has(rel);
+        // Los .ts propios llegan ya transpilados (readText); los de node_modules los transpila esbuild.
+        const isTs = /\.(?:m?ts|cts)$/i.test(a.path);
+        if (!local && isTs) return { contents: fs.readFileSync(a.path, 'utf8'), loader: 'ts' };
         const code = local ? ctx.readText(rel, { kind: 'js' }).text : fs.readFileSync(a.path, 'utf8');
         if (local) state.consumed.add(rel);
         return { contents: prepare(code, local ? rel : toPosix(a.path), local ? path.posix.dirname(rel) : '', local), loader: 'js' };
@@ -319,30 +334,7 @@ export async function ensureTerser(projectRoot) {
 export async function terserPass(ctx, code, { isModule, level, globals }) {
   const js = ctx.cfg.js;
   if (!terser || js.minifier !== 'terser' || !js.minify || ctx.cfg.sourcemap) return code;
-  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: js.keepNames,
-      keep_classnames: js.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).ok) return code;
-  return out;
+  return ctx.heavy.terser(code, { isModule, level, globals: isModule ? undefined : globals, keepNames: js.keepNames });
 }
 
 /** Bytes de origen que aportaron código a una salida (incluye paquetes de node_modules). */
@@ -552,7 +544,7 @@ export async function buildModuleGroup(ctx, group) {
 export async function buildModuleWorker(ctx, rel) {
   const group = { importMap: null, virtual: new Map(), entries: new Set([rel]) };
   const state = newState('scan');
-  const outfile = path.join(ctx.root, '__vb_out__', rel);
+  const outfile = path.join(ctx.root, '__vb_out__', jsOutPath(rel));
   const run = (st, extra) =>
     esbuild.build({
       absWorkingDir: ctx.root,
@@ -584,7 +576,7 @@ export async function buildModuleWorker(ctx, rel) {
       if (f.path.endsWith('.map')) map = f.text;
       else code = f.text.replace(/\n\/\/# sourceMappingURL=.*\n?$/, '\n');
     }
-    ({ code, map } = finalizeMarkers(code, map, rel));
+    ({ code, map } = finalizeMarkers(code, map, jsOutPath(rel)));
     return { code, map, consumed: emit.consumed };
   } catch (err) {
     return { error: esbuildErrorText(err, ctx.root) };

package/src/jsimports.js

@@ -0,0 +1,54 @@
+// Rutas importadas por un JS ya generado (para verificar que existen en la salida).
+import * as acorn from 'acorn';
+import * as walk from 'acorn-walk';
+
+/**
+ * Reescribe los imports relativos de un archivo TypeScript ya transpilado para que funcionen en el navegador:
+ * "./x.ts" → "./x.js" (tras compilar existe con extensión .js) y "./x" → "./x.js" o "./x/index.js"
+ * según `complete(spec)`, que devuelve la ruta completa o null. Si el código no se puede leer, se devuelve igual.
+ */
+export function rewriteTsImports(code, complete = () => null) {
+  let ast;
+  try {
+    ast = acorn.parse(code, { ecmaVersion: 'latest', sourceType: 'module', allowHashBang: true });
+  } catch {
+    return code;
+  }
+  const edits = [];
+  const consider = (src) => {
+    if (src?.type !== 'Literal' || typeof src.value !== 'string' || !/^\.{1,2}\//.test(src.value)) return;
+    let spec = src.value;
+    if (/\.(m|c)?ts$/i.test(spec)) spec = spec.replace(/\.(m|c)?ts$/i, (_, p) => `.${(p ?? '').toLowerCase()}js`);
+    else if (!/\.[a-z0-9]+$/i.test(spec.split('/').pop())) spec = complete(spec) ?? spec;
+    if (spec !== src.value) edits.push({ start: src.start, end: src.end, text: JSON.stringify(spec) });
+  };
+  const isImportMetaUrl = (m) =>
+    m?.type === 'MemberExpression' && m.object.type === 'MetaProperty' && m.object.meta.name === 'import' && m.property.name === 'url';
+  walk.full(ast, (n) => {
+    if (n.type === 'ImportDeclaration' || n.type === 'ExportAllDeclaration' || n.type === 'ExportNamedDeclaration') consider(n.source);
+    else if (n.type === 'ImportExpression') consider(n.source);
+    // new URL('./worker.ts', import.meta.url): workers y recursos cargados por ruta.
+    else if (n.type === 'NewExpression' && n.callee.type === 'Identifier' && n.callee.name === 'URL' && isImportMetaUrl(n.arguments[1]))
+      consider(n.arguments[0]);
+  });
+  let out = code;
+  for (const e of edits.sort((a, b) => b.start - a.start)) out = out.slice(0, e.start) + e.text + out.slice(e.end);
+  return out;
+}
+
+/** Devuelve {imports} o {error} si el código no es JavaScript válido. */
+export function jsImports(code, isModule) {
+  let ast;
+  try {
+    ast = acorn.parse(code, { ecmaVersion: 'latest', sourceType: isModule ? 'module' : 'script', allowHashBang: true });
+  } catch (err) {
+    return { error: err.message };
+  }
+  const imports = [];
+  walk.full(ast, (n) => {
+    if ((n.type === 'ImportDeclaration' || n.type === 'ExportAllDeclaration' || n.type === 'ExportNamedDeclaration') && n.source)
+      imports.push(n.source.value);
+    if (n.type === 'ImportExpression' && n.source.type === 'Literal' && typeof n.source.value === 'string') imports.push(n.source.value);
+  });
+  return { imports };
+}

package/src/jsinfo.js

@@ -124,7 +124,6 @@ export function analyzeJs(code, opts = {}) {
   const info = {
     ok: true,
     isModule,
-    level: detectLevel(code, sourceType),
     strict,
     top: isModule ? new Map() : globalBindings(ast, strict),
     imports: [],
@@ -139,6 +138,12 @@ export function analyzeJs(code, opts = {}) {
     hasImportMeta: false,
     hasModuleSyntax: false,
   };
+  // El nivel ES cuesta varios parseos: solo se calcula si alguien lo pide (la mayoría de análisis no lo necesitan).
+  let level;
+  Object.defineProperty(info, 'level', {
+    enumerable: true,
+    get: () => (level === undefined ? (level = detectLevel(code, sourceType)) : level),
+  });
   const addWorker = (arg, kind, optsNode) => {
     if (!arg) return;
     let spec = null;
@@ -249,8 +254,19 @@ export function checkSyntax(code, isModule) {
  * `allowPrefix` permite nombres nuevos con ese prefijo (los que añade el ofuscador).
  */
 export function compareGlobals(before, afterCode, allowPrefix = null) {
-  const after = analyzeJs(afterCode, { module: false });
-  if (!after.ok) return { ok: false, reason: `el resultado no es JS válido (${after.error})` };
+  // Solo hacen falta las globales: un parseo y un recorrido, sin el análisis completo.
+  let ast;
+  try {
+    ast = parse(afterCode, 'script', LATEST);
+  } catch (err) {
+    return { ok: false, reason: `el resultado no es JS válido (${err.message})` };
+  }
+  const after = {
+    top: globalBindings(
+      ast,
+      ast.body.some((s) => s.directive === 'use strict'),
+    ),
+  };
   for (const [name, kind] of before) {
     if (!after.top.has(name)) return { ok: false, reason: `desaparece la global "${name}"` };
     if (after.top.get(name) !== kind) return { ok: false, reason: `la global "${name}" cambia de tipo (${kind} → ${after.top.get(name)})` };

package/src/pool.js

@@ -0,0 +1,341 @@
+// 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';
+
+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';
+    const meta = JSON.stringify([CACHE_FORMAT, OWN_VERSION, kind, versionOf(engine), 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, 'para la compresión máxima');
+    return terserMinify(inProcessTerser, payload.code, payload.opts);
+  }
+
+  function spawn() {
+    const w = new Worker(WORKER_URL, { workerData: { root } });
+    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, 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,30 @@
 // 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';
 
 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 = {};

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, 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).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']);