vanilla-builder 0.1.0 → 0.3.0

package/src/files.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import picomatch from 'picomatch';
 import { CONFIG_FILES } from './config.js';
 import { relFrom, toPosix, extOf } from './util.js';
+import { L } from './i18n.js';
 
 /** Archivos de desarrollo que nunca deberían publicarse. Se desactiva con defaultIgnore:false. */
 export const DEFAULT_IGNORE = [
@@ -33,9 +34,16 @@ export const DEFAULT_IGNORE = [
   '**/eslint.config.*',
   '**/prettier.config.*',
   'tsconfig.json',
+  'tsconfig.*.json',
   'jsconfig.json',
+  // Declaraciones de tipos: no contienen código ejecutable.
+  '**/*.d.ts',
+  '**/*.d.mts',
+  '**/*.d.cts',
   '**/*.test.js',
   '**/*.spec.js',
+  '**/*.test.ts',
+  '**/*.spec.ts',
   '**/__tests__/**',
   '**/*.map',
 ];
@@ -78,7 +86,7 @@ export function scanProject(cfg) {
     try {
       entries = fs.readdirSync(dir, { withFileTypes: true });
     } catch (err) {
-      ignored.push({ rel: relFrom(root, dir) || '.', reason: `no se pudo leer (${err.code})` });
+      ignored.push({ rel: relFrom(root, dir) || '.', reason: L(`no se pudo leer (${err.code})`, `could not be read (${err.code})`) });
       return;
     }
     entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
@@ -93,9 +101,10 @@ export function scanProject(cfg) {
           const st = fs.statSync(abs);
           isFile = st.isFile();
           isDir = false;
-          if (st.isDirectory()) ignored.push({ rel, reason: 'enlace simbólico a carpeta (no se sigue)' });
+          if (st.isDirectory())
+            ignored.push({ rel, reason: L('enlace simbólico a carpeta (no se sigue)', 'symbolic link to a folder (not followed)') });
         } catch {
-          ignored.push({ rel, reason: 'enlace simbólico roto' });
+          ignored.push({ rel, reason: L('enlace simbólico roto', 'broken symbolic link') });
           continue;
         }
       }
@@ -106,7 +115,10 @@ export function scanProject(cfg) {
         const byUser = isUser(rel) || isUser(probe);
         const wanted = cfg.include.some((p) => normalizePattern(p).startsWith(`${rel}/`) || p.startsWith('**'));
         if ((byUser || isDefault(probe)) && !wanted) {
-          ignored.push({ rel: `${rel}/`, reason: byUser ? 'ignore (configuración)' : 'excluido por defecto' });
+          ignored.push({
+            rel: `${rel}/`,
+            reason: byUser ? L('ignore (configuración)', 'ignore (configuration)') : L('excluido por defecto', 'excluded by default'),
+          });
           continue;
         }
         walk(abs);
@@ -116,9 +128,9 @@ export function scanProject(cfg) {
       const forced = isIncluded(rel);
       let reason = null;
       if (!forced) {
-        if (isSecret(rel)) reason = 'posible secreto (excluido por seguridad)';
-        else if (isUser(rel)) reason = 'ignore (configuración)';
-        else if (isDefault(rel)) reason = 'excluido por defecto';
+        if (isSecret(rel)) reason = L('posible secreto (excluido por seguridad)', 'possible secret (excluded for safety)');
+        else if (isUser(rel)) reason = L('ignore (configuración)', 'ignore (configuration)');
+        else if (isDefault(rel)) reason = L('excluido por defecto', 'excluded by default');
       }
       if (reason) {
         ignored.push({ rel, reason });

package/src/html.js

@@ -1,5 +1,6 @@
 // HTML: extrae referencias con su posición exacta, aplica ediciones puntuales y minifica con verificación.
 import { parse } from 'parse5';
+import { L } from './i18n.js';
 
 const JS_TYPES = new Set([
   '',
@@ -215,7 +216,7 @@ export function applyEdits(text, edits) {
   let out = text;
   let limit = Infinity;
   for (const e of sorted) {
-    if (e.end > limit) throw new Error(`Ediciones superpuestas en la posición ${e.start}`);
+    if (e.end > limit) throw new Error(L(`Ediciones superpuestas en la posición ${e.start}`, `Overlapping edits at position ${e.start}`));
     out = out.slice(0, e.start) + e.text + out.slice(e.end);
     limit = e.start;
   }
@@ -324,7 +325,7 @@ export async function minifyHtml(text, { removeComments, collapseWhitespace }) {
   try {
     out = applyEdits(text, minifyEdits(text, { removeComments, collapseWhitespace }));
   } catch (err) {
-    return { code: text, note: `no se pudo minificar el HTML (${err.message})` };
+    return { code: text, note: L(`no se pudo minificar el HTML (${err.message})`, `could not minify the HTML (${err.message})`) };
   }
   const before = htmlSignature(text);
   const after = htmlSignature(out);
@@ -332,7 +333,13 @@ export async function minifyHtml(text, { removeComments, collapseWhitespace }) {
     let i = 0;
     while (i < before.length && before[i] === after[i]) i++;
     const near = before.slice(Math.max(0, i - 40), i + 40).replace(/\s+/g, ' ');
-    return { code: text, note: `la minificación cambiaba la estructura cerca de «${near}»; se deja sin minificar` };
+    return {
+      code: text,
+      note: L(
+        `la minificación cambiaba la estructura cerca de «${near}»; se deja sin minificar`,
+        `minification changed the structure near «${near}»; left unminified`,
+      ),
+    };
   }
   return { code: out };
 }

package/src/i18n.js

@@ -0,0 +1,33 @@
+// Idioma de los mensajes: inglés o español.
+// Prioridad: --lang / setLang() > BUILDER_LANG > LC_ALL / LC_MESSAGES / LANG > idioma del sistema > inglés.
+// Los campos de --json, la configuración y los nombres de fase no se traducen nunca.
+
+function detect() {
+  const env = process.env;
+  const explicit = env.BUILDER_LANG;
+  if (explicit) return /^es/i.test(explicit) ? 'es' : 'en';
+  const posix = env.LC_ALL || env.LC_MESSAGES || env.LANG;
+  // "C" y "POSIX" no dicen nada del idioma de la persona: se mira el del sistema.
+  if (posix && !/^(C|POSIX)(\.|$)/i.test(posix)) return /^es/i.test(posix) ? 'es' : 'en';
+  try {
+    return /^es\b/i.test(Intl.DateTimeFormat().resolvedOptions().locale) ? 'es' : 'en';
+  } catch {
+    return 'en';
+  }
+}
+
+let lang = detect();
+
+/** Cambia el idioma ('en' o 'es'). */
+export function setLang(value) {
+  lang = /^es/i.test(String(value)) ? 'es' : 'en';
+}
+
+export function getLang() {
+  return lang;
+}
+
+/** Devuelve el texto en el idioma activo. Ambos textos se escriben juntos en el código. */
+export function L(es, en) {
+  return lang === 'es' ? es : en;
+}

package/src/images.js

@@ -0,0 +1,61 @@
+// Optimización de imágenes con sharp (dependencia opcional). Mismo formato y mismo nombre: no cambia ninguna referencia.
+// - PNG: recompresión sin pérdida, comprobada píxel a píxel.
+// - JPEG y WebP: se recodifican con la calidad indicada (con pérdida, visualmente equivalente).
+// Se conservan los metadatos (orientación EXIF, perfil de color). Si el resultado no es más pequeño, se deja el original.
+import { importOptional } from './optional.js';
+import { L } from './i18n.js';
+
+export const IMAGE_EXT = new Set(['.png', '.jpg', '.jpeg', '.webp']);
+
+let sharpMod = null;
+
+export async function ensureSharp(root) {
+  if (!sharpMod) {
+    const mod = await importOptional('sharp', root, L('para optimizar imágenes (--images)', 'to optimize images (--images)'));
+    sharpMod = mod.default ?? mod;
+  }
+  return sharpMod;
+}
+
+/** Opciones normalizadas de "images": false, true o { quality }. */
+export function imageOptions(setting) {
+  if (!setting) return null;
+  const quality = typeof setting === 'object' && Number.isInteger(setting.quality) ? setting.quality : 80;
+  return { quality };
+}
+
+async function samePixels(sharp, a, b) {
+  const [ra, rb] = await Promise.all([
+    sharp(a).ensureAlpha().raw().toBuffer({ resolveWithObject: true }),
+    sharp(b).ensureAlpha().raw().toBuffer({ resolveWithObject: true }),
+  ]);
+  return ra.info.width === rb.info.width && ra.info.height === rb.info.height && ra.data.equals(rb.data);
+}
+
+/**
+ * @returns {Promise<{data: Buffer} | {skip: string}>} la imagen optimizada, o el motivo para dejar la original.
+ */
+export async function optimizeImage(sharp, buf, ext, { quality }) {
+  let meta;
+  try {
+    meta = await sharp(buf).metadata();
+  } catch (err) {
+    return { skip: L(`no se pudo leer la imagen (${err.message})`, `could not read the image (${err.message})`) };
+  }
+  if ((meta.pages ?? 1) > 1) return { skip: L('imagen animada', 'animated image') };
+  const base = () => sharp(buf).keepMetadata();
+  let out;
+  try {
+    if (ext === '.png') out = await base().png({ compressionLevel: 9, effort: 10, palette: false, adaptiveFiltering: true }).toBuffer();
+    else if (ext === '.webp') out = await base().webp({ quality, effort: 6 }).toBuffer();
+    else out = await base().jpeg({ quality, mozjpeg: true }).toBuffer();
+  } catch (err) {
+    return { skip: L(`sharp falló (${err.message})`, `sharp failed (${err.message})`) };
+  }
+  if (out.length >= buf.length) return { skip: L('ya estaba optimizada', 'already optimized') };
+  const after = await sharp(out).metadata();
+  if (after.width !== meta.width || after.height !== meta.height || after.format !== meta.format)
+    return { skip: L('el resultado no conserva tamaño o formato', 'the result does not keep size or format') };
+  if (ext === '.png' && !(await samePixels(sharp, buf, out))) return { skip: L('los píxeles no coinciden', 'pixels do not match') };
+  return { data: out };
+}

package/src/js.js

@@ -4,13 +4,13 @@ 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, isolateTempGlobals } 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';
+import { L } from './i18n.js';
 
 /** Marcador de "raíz de salida" que se sustituye por la ruta relativa real de cada archivo generado. */
 export const MARK = '__VB_ROOT__';
@@ -56,50 +56,75 @@ export async function processClassic(ctx, { code, id, info, obfuscate, sourcemap
   const notes = [];
   let out = code;
   let map = null;
+  let allowPrefix = null;
   if (js.minify) {
     const auto = await targetForLevel(info.level);
-    const attempts = [{ target: js.target === 'auto' ? auto : js.target, keepNames: js.keepNames, label: 'completa' }];
-    if (js.target !== 'auto' || js.keepNames) attempts.push({ target: auto, keepNames: false, label: 'sin transpilar' });
-    attempts.push({ target: auto, keepNames: false, whitespace: true, label: 'solo espacios' });
+    const attempts = [{ target: js.target === 'auto' ? auto : js.target, keepNames: js.keepNames, label: L('completa', 'full') }];
+    if (js.target !== 'auto' || js.keepNames) attempts.push({ target: auto, keepNames: false, label: L('sin transpilar', 'without transpiling') });
+    attempts.push({ target: auto, keepNames: false, whitespace: true, label: L('solo espacios', 'whitespace only') });
     let done = false;
+    // Mismo prefijo que usa el ofuscador para sus nombres: las comprobaciones posteriores ya lo aceptan.
+    const tempPrefix = `_${shortHash(id, 6)}`;
+    const transform = (input, a, extra = {}) =>
+      esbuild.transform(input, {
+        loader: 'js',
+        target: a.target,
+        charset: 'ascii',
+        supported: SUPPORTED,
+        legalComments: js.legalComments,
+        drop: js.drop,
+        define: js.define,
+        keepNames: a.keepNames,
+        sourcemap: sourcemap ? 'external' : false,
+        sourcefile: id,
+        ...(a.whitespace ? { minifyWhitespace: true } : { minify: true }),
+        logLevel: 'silent',
+        ...extra,
+      });
     for (const a of attempts) {
       try {
-        const r = await esbuild.transform(code, {
-          loader: 'js',
-          target: a.target,
-          charset: 'ascii',
-          supported: SUPPORTED,
-          legalComments: js.legalComments,
-          drop: js.drop,
-          define: js.define,
-          keepNames: a.keepNames,
-          sourcemap: sourcemap ? 'external' : false,
-          sourcefile: id,
-          ...(a.whitespace ? { minifyWhitespace: true } : { minify: true }),
-          logLevel: 'silent',
-        });
-        const cmp = compareGlobals(info.top, r.code);
+        const r = await transform(code, a);
+        let candidate = r.code;
+        let cmp = compareGlobals(info.top, candidate);
+        let isolated = false;
+        if (!cmp.ok && !a.whitespace && a.target !== auto) {
+          // Al adaptar la sintaxis, esbuild declara temporales globales (var _a). Se adapta sin minificar
+          // (nombres reconocibles), se aíslan con un prefijo propio del archivo y después se minifica:
+          // la minificación no renombra globales de un script clásico ni crea temporales nuevas.
+          const lowered = await transform(code, a, { minify: false, minifyWhitespace: false, sourcemap: false });
+          const iso = isolateTempGlobals(lowered.code, info.top, tempPrefix);
+          if (iso) {
+            const r2 = await transform(iso, a, { sourcemap: false });
+            const cmp2 = compareGlobals(info.top, r2.code, tempPrefix);
+            if (cmp2.ok) {
+              candidate = r2.code;
+              cmp = cmp2;
+              isolated = true;
+            }
+          }
+        }
         if (cmp.ok) {
-          out = r.code;
-          map = r.map || null;
+          out = candidate;
+          map = isolated ? null : r.map || null;
+          if (isolated) allowPrefix = tempPrefix;
           done = true;
           break;
         }
-        notes.push(`minificación ${a.label} descartada: ${cmp.reason}`);
+        notes.push(L(`minificación ${a.label} descartada: ${cmp.reason}`, `${a.label} minification discarded: ${cmp.reason}`));
       } catch (err) {
-        notes.push(`minificación ${a.label} falló: ${firstLine(err)}`);
+        notes.push(L(`minificación ${a.label} falló: ${firstLine(err)}`, `${a.label} minification failed: ${firstLine(err)}`));
       }
     }
-    if (!done) notes.push('se deja sin minificar para no romperlo');
+    if (!done) notes.push(L('se deja sin minificar para no romperlo', 'left unminified so it does not break'));
   }
   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;
-    } else notes.push(`no se ofuscó: ${o.reason}`);
+    } else notes.push(L(`no se ofuscó: ${o.reason}`, `not obfuscated: ${o.reason}`));
   } else if (out !== code) {
-    const t = await terserPass(ctx, out, { isModule: false, level: info.level, globals: info.top });
+    const t = await terserPass(ctx, out, { isModule: false, level: info.level, globals: info.top, allowPrefix });
     if (t !== out) {
       out = t;
       map = null;
@@ -134,15 +159,15 @@ export async function processModuleStandalone(ctx, { code, id, info, obfuscate,
       out = r.code;
       map = r.map || null;
     } catch (err) {
-      notes.push(`no se pudo minificar: ${firstLine(err)}`);
+      notes.push(L(`no se pudo minificar: ${firstLine(err)}`, `could not minify: ${firstLine(err)}`));
     }
   }
   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;
-    } else notes.push(`no se ofuscó: ${o.reason}`);
+    } else notes.push(L(`no se ofuscó: ${o.reason}`, `not obfuscated: ${o.reason}`));
   } else if (out !== code) {
     const t = await terserPass(ctx, out, { isModule: true, level: info.level });
     if (t !== out) {
@@ -154,9 +179,9 @@ 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 });
-  return o.code ? { code: o.code } : { code, note: `no se ofuscó: ${o.reason}` };
+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: L(`no se ofuscó: ${o.reason}`, `not obfuscated: ${o.reason}`) };
 }
 
 /** Aplica un import map (solo "imports"; con "scopes" se usa el modo sin empaquetar). */
@@ -196,6 +221,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;
@@ -212,8 +245,10 @@ function modulePlugin(ctx, group, state) {
     if (!info.ok) return code;
     state.levels.push(info.level ?? 9999);
     if (!local) return code;
-    for (const u of info.unsafeUrls) state.unsafe.push(`new URL(variable, import.meta.url) en ${id}: ${u}`);
-    for (const u of info.unsafeImports) state.unsafe.push(`import() con una ruta calculada en ${id}: ${u}`);
+    for (const u of info.unsafeUrls)
+      state.unsafe.push(L(`new URL(variable, import.meta.url) en ${id}: ${u}`, `new URL(variable, import.meta.url) in ${id}: ${u}`));
+    for (const u of info.unsafeImports)
+      state.unsafe.push(L(`import() con una ruta calculada en ${id}: ${u}`, `import() with a computed path in ${id}: ${u}`));
     if (state.mode === 'scan') ctx.noteJsInfo(id, info, baseDir, { module: true });
     if (!info.urls.length) return code;
     let out = '';
@@ -245,6 +280,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,
@@ -275,24 +315,39 @@ function modulePlugin(ctx, group, state) {
             ctx.reportBroken(importer, spec, r);
             return { path: spec, external: true };
           }
-          ctx.requireStandalone(r.rel, `importado como CSS desde ${importer}`);
+          ctx.requireStandalone(r.rel, L(`importado como CSS desde ${importer}`, `imported as CSS from ${importer}`));
           return { path: `${MARK}/${r.rel}`, external: true };
         }
         const mapped = mapSpecifier(ctx, group.importMap, spec, baseDir);
         if (mapped?.external) return { path: spec, external: true };
         if (mapped?.rel) return { path: ctx.abs(mapped.rel) };
         if (mapped?.abs) return { path: mapped.abs };
-        if (mapped?.broken) return { errors: [{ text: `El import map de la página apunta "${spec}" a "${mapped.target}", que no existe.` }] };
+        if (mapped?.broken)
+          return {
+            errors: [
+              {
+                text: L(
+                  `El import map de la página apunta "${spec}" a "${mapped.target}", que no existe.`,
+                  `The page import map points "${spec}" to "${mapped.target}", which does not exist.`,
+                ),
+              },
+            ],
+          };
         if (spec.startsWith('/')) {
           const r = ctx.resolve(spec, baseDir);
           if (r.status === 'ok') return { path: ctx.abs(r.rel) };
-          return { errors: [{ text: `No existe "${spec}" (importado desde ${importer}).` }] };
+          return {
+            errors: [{ text: L(`No existe "${spec}" (importado desde ${importer}).`, `"${spec}" does not exist (imported from ${importer}).`) }],
+          };
         }
         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' };
@@ -309,40 +364,21 @@ let terser = null;
 
 /** Carga terser (opcional) para la compresión máxima. */
 export async function ensureTerser(projectRoot) {
-  terser = await importOptional('terser', projectRoot, 'para la compresión máxima (js.minifier: "terser")');
+  terser = await importOptional(
+    'terser',
+    projectRoot,
+    L('para la compresión máxima (js.minifier: "terser")', 'for maximum compression (js.minifier: "terser")'),
+  );
 }
 
 /**
  * Segunda pasada con terser (varias pasadas de compresión). Solo se acepta si el resultado
  * es más pequeño y conserva globales (scripts) o exportaciones/importaciones (módulos).
  */
-export async function terserPass(ctx, code, { isModule, level, globals }) {
+export async function terserPass(ctx, code, { isModule, level, globals, allowPrefix = null }) {
   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, allowPrefix, keepNames: js.keepNames });
 }
 
 /** Bytes de origen que aportaron código a una salida (incluye paquetes de node_modules). */
@@ -470,16 +506,23 @@ export async function buildModuleGroup(ctx, group) {
   try {
     scan = await esbuild.build({ ...common, target: 'esnext', plugins: [modulePlugin(ctx, group, scanState)] });
   } catch (err) {
-    throw new BuildError('No se pudieron empaquetar los módulos JavaScript:', esbuildErrorText(err, ctx.root).split('\n'));
+    throw new BuildError(
+      L('No se pudieron empaquetar los módulos JavaScript:', 'Could not bundle the JavaScript modules:'),
+      esbuildErrorText(err, ctx.root).split('\n'),
+    );
   }
   const inputs = Object.keys(scan.metafile.inputs)
     .map((p) => relFrom(ctx.root, path.resolve(ctx.root, p)))
     .filter((rel) => rel && ctx.files.has(rel));
   const dynamicWarnings = scan.warnings.filter((w) => w.id === 'unsupported-dynamic-import');
   let reason = null;
-  if (!cfg.js.bundle) reason = 'js.bundle está desactivado';
+  if (!cfg.js.bundle) reason = L('js.bundle está desactivado', 'js.bundle is disabled');
   else if (group.forcePerFile) reason = group.forcePerFile;
-  else if (dynamicWarnings.length) reason = `hay import() con rutas que no se pueden seguir (${formatMessage(dynamicWarnings[0], ctx.root)})`;
+  else if (dynamicWarnings.length)
+    reason = L(
+      `hay import() con rutas que no se pueden seguir (${formatMessage(dynamicWarnings[0], ctx.root)})`,
+      `there are import() calls with paths that cannot be followed (${formatMessage(dynamicWarnings[0], ctx.root)})`,
+    );
   else if (scanState.unsafe.length) reason = scanState.unsafe[0];
   if (reason) return { mode: 'per-file', reason, inputs, consumed: new Set() };
   for (const w of scan.warnings) ctx.warn(`JS: ${formatMessage(w, ctx.root)}`);
@@ -494,7 +537,10 @@ export async function buildModuleGroup(ctx, group) {
       emitState.vendorOut = vendor.outByAbs;
     } catch (err) {
       ctx.warn(
-        `no se pudieron separar las dependencias en archivos vendor (${esbuildErrorText(err, ctx.root).split('\n')[0]}); van dentro del paquete y se ofuscarán con él`,
+        L(
+          `no se pudieron separar las dependencias en archivos vendor (${esbuildErrorText(err, ctx.root).split('\n')[0]}); van dentro del paquete y se ofuscarán con él`,
+          `could not split dependencies into vendor files (${esbuildErrorText(err, ctx.root).split('\n')[0]}); they stay in the bundle and will be obfuscated with it`,
+        ),
       );
     }
   }
@@ -510,7 +556,10 @@ export async function buildModuleGroup(ctx, group) {
       plugins: [modulePlugin(ctx, group, emitState)],
     });
   } catch (err) {
-    throw new BuildError('No se pudieron empaquetar los módulos JavaScript:', esbuildErrorText(err, ctx.root).split('\n'));
+    throw new BuildError(
+      L('No se pudieron empaquetar los módulos JavaScript:', 'Could not bundle the JavaScript modules:'),
+      esbuildErrorText(err, ctx.root).split('\n'),
+    );
   }
   const maps = new Map();
   const files = [];
@@ -552,7 +601,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 +633,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 };
+}