vanilla-builder 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,74 @@
+// Informe de tamaños (original, final, gzip y brotli) por archivo y totales.
+import { formatBytes } from './util.js';
+import { gzipOf, brotliOf, mapLimit } from './compress.js';
+
+const COMPRESSIBLE = new Set(['html', 'css', 'js', 'json', 'svg', 'text']);
+
+export async function sizesOf(buf, type) {
+  const size = buf.length;
+  if (!COMPRESSIBLE.has(type) || size === 0) return { size, gzip: null, brotli: null };
+  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 async function buildReport(outputs, heavy = null) {
+  let compressed = 0;
+  const items = [];
+  for (const [rel, o] of outputs) {
+    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 = {};
+  for (const r of rows) {
+    totals.before += r.before;
+    totals.size += r.size;
+    totals.gzip += r.gzip ?? r.size;
+    totals.brotli += r.brotli ?? r.size;
+    const t = (byType[r.type] ??= { files: 0, before: 0, size: 0 });
+    t.files++;
+    t.before += r.before;
+    t.size += r.size;
+  }
+  return { rows, totals, byType, compressed };
+}
+
+const ORDER = ['html', 'js', 'css', 'json', 'svg', 'text', 'asset'];
+const order = (t) => (ORDER.includes(t) ? ORDER.indexOf(t) : ORDER.length);
+
+const pct = (before, after) => (before > 0 ? `${(((before - after) / before) * 100).toFixed(1)}%` : '—');
+
+/** Tabla para la terminal. Los recursos copiados sin cambios se resumen en una línea. */
+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 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`),
+  );
+  for (const r of shown) {
+    const src = r.sources && r.sources.length > 1 ? C.gray(` (${r.sources.length} archivos)`) : '';
+    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) {
+    const size = hidden.reduce((a, r) => a + r.size, 0);
+    lines.push(C.gray(`${pad(hiddenLabel, w)}  ${num(size)}  ${num(size)}`));
+  }
+  const t = report.totals;
+  lines.push(
+    C.bold(`${'Total'.padEnd(w)}  ${num(t.before)}  ${num(t.size)}  ${num(t.gzip)}  ${num(t.brotli)}  ${pct(t.before, t.size).padStart(6)}`),
+  );
+  return lines.join('\n');
+}

package/src/server.js

@@ -0,0 +1,124 @@
+// Servidor estático para probar la salida, con recarga automática opcional (modo dev).
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+
+const MIME = {
+  '.html': 'text/html; charset=utf-8',
+  '.htm': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.mjs': 'text/javascript; charset=utf-8',
+  '.cjs': 'text/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.map': 'application/json; charset=utf-8',
+  '.webmanifest': 'application/manifest+json; charset=utf-8',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.avif': 'image/avif',
+  '.ico': 'image/x-icon',
+  '.bmp': 'image/bmp',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.otf': 'font/otf',
+  '.eot': 'application/vnd.ms-fontobject',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+  '.vtt': 'text/vtt; charset=utf-8',
+  '.txt': 'text/plain; charset=utf-8',
+  '.xml': 'application/xml; charset=utf-8',
+  '.pdf': 'application/pdf',
+  '.wasm': 'application/wasm',
+  '.zip': 'application/zip',
+};
+
+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('ok',()=>{box?.remove();box=null});})();</script>`;
+
+/**
+ * @param {{dir: string, port?: number, host?: string, liveReload?: boolean}} opts
+ */
+export function startServer({ dir, port = 5173, host = '127.0.0.1', liveReload = false }) {
+  const clients = new Set();
+  const root = path.resolve(dir);
+  const server = http.createServer((req, res) => {
+    let pathname;
+    try {
+      pathname = decodeURIComponent(new URL(req.url, 'http://x').pathname);
+    } catch {
+      res.writeHead(400).end('URL inválida');
+      return;
+    }
+    if (liveReload && pathname === '/__builder/events') {
+      res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-store', Connection: 'keep-alive' });
+      res.write(': ok\n\n');
+      clients.add(res);
+      req.on('close', () => clients.delete(res));
+      return;
+    }
+    let file = path.join(root, pathname);
+    if (path.relative(root, file).startsWith('..')) {
+      res.writeHead(403).end('Prohibido');
+      return;
+    }
+    try {
+      if (fs.statSync(file).isDirectory()) {
+        if (!pathname.endsWith('/')) {
+          res.writeHead(301, { Location: `${pathname}/` }).end();
+          return;
+        }
+        file = path.join(file, 'index.html');
+      }
+    } catch {
+      /* se maneja abajo */
+    }
+    fs.readFile(file, (err, data) => {
+      if (err) {
+        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' }).end(`No encontrado: ${pathname}`);
+        return;
+      }
+      const ext = path.extname(file).toLowerCase();
+      const type = MIME[ext] ?? 'application/octet-stream';
+      let body = data;
+      if (liveReload && ext.startsWith('.htm')) {
+        const html = data.toString('utf8');
+        const i = html.toLowerCase().lastIndexOf('</body>');
+        body = Buffer.from(i === -1 ? html + RELOAD_SCRIPT : html.slice(0, i) + RELOAD_SCRIPT + html.slice(i));
+      }
+      const headers = { 'Content-Type': type, 'Cache-Control': 'no-store' };
+      if (path.basename(file).match(/^sw\.js$|service-?worker/i)) headers['Service-Worker-Allowed'] = '/';
+      res.writeHead(200, headers).end(body);
+    });
+  });
+  const send = (event, data = '') => {
+    for (const c of clients) c.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+  };
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(port, host, () => {
+      const addr = server.address();
+      resolve({
+        url: `http://${host === '0.0.0.0' ? 'localhost' : host}:${addr.port}/`,
+        port: addr.port,
+        reload: () => send('reload'),
+        buildError: (msg) => send('error-build', msg),
+        buildOk: () => send('ok'),
+        close: () =>
+          new Promise((r) => {
+            for (const c of clients) c.end();
+            server.close(() => r());
+          }),
+      });
+    });
+  });
+}

package/src/sourcemap.js

@@ -0,0 +1,77 @@
+// Ajuste mínimo de source maps v3 cuando se reemplaza texto en el código generado.
+const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const B64_INDEX = Object.fromEntries([...B64].map((c, i) => [c, i]));
+
+function decodeVlq(str) {
+  const out = [];
+  let value = 0;
+  let shift = 0;
+  for (const ch of str) {
+    const digit = B64_INDEX[ch];
+    value += (digit & 31) << shift;
+    if (digit & 32) shift += 5;
+    else {
+      out.push(value & 1 ? -(value >>> 1) : value >>> 1);
+      value = 0;
+      shift = 0;
+    }
+  }
+  return out;
+}
+
+function encodeVlq(n) {
+  let v = n < 0 ? (-n << 1) | 1 : n << 1;
+  let out = '';
+  do {
+    let digit = v & 31;
+    v >>>= 5;
+    if (v > 0) digit |= 32;
+    out += B64[digit];
+  } while (v > 0);
+  return out;
+}
+
+/**
+ * Reemplaza todas las apariciones de `search` por `replacement` y desplaza las columnas
+ * del source map para que sigan apuntando al mismo código.
+ */
+export function replaceWithMap(code, map, search, replacement) {
+  if (!code.includes(search)) return { code, map };
+  const delta = replacement.length - search.length;
+  // columnas (por línea) donde hubo reemplazos
+  const edits = new Map();
+  const lines = code.split('\n');
+  const newLines = lines.map((line, i) => {
+    if (!line.includes(search)) return line;
+    const cols = [];
+    let idx = line.indexOf(search);
+    while (idx !== -1) {
+      cols.push(idx);
+      idx = line.indexOf(search, idx + search.length);
+    }
+    edits.set(i, cols);
+    return line.split(search).join(replacement);
+  });
+  const newCode = newLines.join('\n');
+  if (!map || delta === 0) return { code: newCode, map };
+  const json = JSON.parse(map);
+  const mapLines = json.mappings.split(';');
+  for (const [lineNo, cols] of edits) {
+    if (lineNo >= mapLines.length || !mapLines[lineNo]) continue;
+    let prevIn = 0;
+    let prevOut = 0;
+    const segs = mapLines[lineNo].split(',').map((seg) => {
+      const fields = decodeVlq(seg);
+      const col = prevIn + fields[0];
+      prevIn = col;
+      const shift = cols.filter((c) => c < col).length * delta;
+      const newCol = col + shift;
+      fields[0] = newCol - prevOut;
+      prevOut = newCol;
+      return fields.map(encodeVlq).join('');
+    });
+    mapLines[lineNo] = segs.join(',');
+  }
+  json.mappings = mapLines.join(';');
+  return { code: newCode, map: JSON.stringify(json) };
+}

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;
+}