El camino a producción: pnpm, módulos, Vite y Rolldown, bundling, code splitting, lazy loading, monorepos y remote caching (Turborepo/Nx).
Cada nivel construye sobre el anterior. Sin saltos, sin huecos.
La visión aérea del camino a producción: módulos, package managers, Vite, el bundler, empaquetado, monorepos, caching y deploy. El mapa mental completo.
El problema que resuelven las build tools: módulos, compatibilidad de navegadores, TypeScript/JSX, y una breve historia de webpack a Vite.
El sistema de módulos: ESM (import/export), CommonJS (require), dynamic import, y la interoperabilidad entre ambos.
Los gestores de paquetes: npm vs yarn vs pnpm, y por qué pnpm gana con su store de contenido enlazado y su ahorro de disco.
La anatomía de package.json: dependencies vs devDependencies, scripts, semver, engines, y los campos que importan.
Cómo Node y los bundlers resuelven un import: el campo exports, conditions, subpath imports, y los mapas de resolución.
Los lockfiles (pnpm-lock.yaml): builds reproducibles, el árbol de dependencias, hoisting, y por qué NO borrarlos.
Workspaces de pnpm: varios paquetes en un repo, el protocolo workspace, --filter para tareas selectivas, y dependencias internas.
Catalogs: definir versiones de dependencias una sola vez y referenciarlas; catalogMode strict/prefer/manual; coherencia a escala.
El registro: publicar, paquetes scoped, dist-tags, provenance (procedencia firmada), y alternativas como JSR.
Qué es Vite: dev server sobre ESM nativo del navegador, arranque instantáneo, y por qué reemplazó a webpack en dev.
Cómo funciona el HMR: el grafo de módulos, aceptar actualizaciones sin recargar, preservar estado, y la API import.meta.hot.
La config de Vite: plugins, resolve.alias, server, define, css, y cómo estructurar una configuración mantenible.
El pre-bundling de dependencias con esbuild: por qué Vite convierte CJS a ESM y agrupa deps para reducir peticiones en dev.
El sistema de plugins de Vite (compatible con Rollup): hooks, transformar código, módulos virtuales, y escribir el tuyo.
La Environment API de Vite: modelar cliente, SSR y edge como entornos separados; el nuevo modelo que unifica dev y build.
Las dos naturalezas de Vite: ESM sin bundle en dev vs un bundle optimizado en build; por qué difieren y sus implicaciones.
La anatomía de un bundler: entry points, el grafo de módulos, resolución, transformación y la generación del output.
Rollup: el bundler que definió el modelo; output formats (esm, cjs, iife), plugins, y por qué Vite lo usó en build.
Rolldown 1.0 (sobre Oxc): el bundler en Rust que reemplaza a esbuild y Rollup en Vite 8; API compatible con Rollup y builds 10-30x más rápidos.
Los transformadores rápidos: esbuild (Go, bundler+transform), SWC (Rust, transform), Oxc (Rust, todo el toolchain); qué usa cada capa.
Tree shaking: análisis estático para quitar lo que no se usa; el papel de ESM, sideEffects en package.json, y sus límites.
Code splitting: dividir el código en chunks cargados bajo demanda; dynamic import, chunks compartidos, y la estrategia de división.
Lazy loading: diferir código no crítico; por ruta y por componente, prefetch/preload, y el equilibrio con el número de peticiones.
Minificar el output: terser vs esbuild vs oxc-minify, mangling, compresión, y los source maps para depurar en producción.
El pipeline de assets: importar CSS/imágenes/fuentes, hashing para cache-busting, inlining de assets pequeños, y CSS code splitting.
Publicar una librería: qué formatos ofrecer (ESM, CJS, UMD), incluir tipos de TypeScript, y qué NO empaquetar (externals).
El campo exports para librerías: dual package (ESM+CJS), conditions (import/require/types), subpaths, y el peligro del dual package hazard.
Construir la librería: Vite en lib mode, tsup (esbuild), unbuild (rollup); generar tipos con dts, y elegir herramienta.
Publicar: versionado semántico, dist-tags (latest/next), provenance firmada, empaquetar solo lo necesario (files), y npm vs JSR.
Changesets: declarar el impacto de cada cambio, versionar múltiples paquetes de forma coordinada, generar changelogs y publicar en CI.
Monorepos: un repo con muchos paquetes; ventajas (código compartido, cambios atómicos), retos (build, CI), y el panorama de herramientas.
Turborepo: el grafo de tareas, el pipeline (turbo.json), inputs/outputs, y el caching local que evita re-ejecutar lo que no cambió.
Remote caching: subir artefactos de build a una caché compartida (Vercel o self-hosted) para que otra máquina o CI reutilice el resultado.
Nx: grafo de tareas, plugins y generadores, Nx Cloud con Replay, y distributed task execution (DTE) que reparte tareas entre máquinas.
Comparar los build systems: Turborepo (simple, rápido) vs Nx (completo, plugins) vs Moon; criterios para elegir según tu equipo.
La caché por dentro: hashing de inputs (archivos, deps, env), qué invalida un hit, y la seguridad (envenenamiento de caché, el CVE CREEP).
Module Federation: compartir código entre apps en runtime; microfrontends, equipos independientes, remotes/host, y sus trade-offs.
Optimizar el output: analizar el bundle (visualizer), presupuestos de tamaño, dividir vendor, y perseguir Core Web Vitals desde el build.
La tubería a producción: instalar con caché, lint/test/build, la caché remota en CI, previews por PR, y desplegar al edge o a un CDN.
La imagen completa: arquitectar el build de un producto a escala, el toolchain unificado en Rust (VoidZero: Vite, Rolldown, Oxc), y hacia dónde va todo.
Empieza por los fundamentos y sube nivel a nivel hasta el dominio total.
Comenzar el camino →