Reactividad de grano fino: signals, efectos, memos, stores, control flow, createResource, Solid 2.0 (async first-class) y SolidStart.
Cada nivel construye sobre el anterior. Sin saltos, sin huecos.
La visión aérea de SolidJS: reactividad de grano fino, el grafo, componentes que corren una vez, stores, async y SolidStart. El mapa mental completo.
La idea central: reactividad de grano fino sin virtual DOM ni re-render. Comparación honesta con React y por qué Solid es tan rápido.
Crear un proyecto, el JSX de Solid (se compila a DOM real), y las diferencias sutiles pero críticas con el JSX de React.
El primitivo fundamental: getter/setter, lectura reactiva vs no reactiva, y por qué un signal es una función.
Efectos que se re-ejecutan cuando sus dependencias cambian: tracking automático, timing, y el primer render.
Memos: derivaciones cacheadas que solo recalculan cuando cambian sus fuentes; cuándo un memo y cuándo una función.
La diferencia mental clave: el cuerpo del componente se ejecuta UNA sola vez; la reactividad vive en el JSX y los efectos.
Las props son reactivas: por qué NO destructurarlas, mergeProps para defaults, splitProps para separar, y la reactividad que se pierde.
El helper children(): resolver y memoizar los hijos, evitar re-crearlos, y manipular el árbol de forma segura.
Manejo de eventos (delegados y nativos), binding de atributos y propiedades, classList, style, y el atributo ref.
Cómo funciona por dentro: nodos, observers y sources, propagación push/pull, y por qué no hay diffing.
El árbol de ownership: onCleanup, getOwner, runWithOwner; cómo Solid libera recursos automáticamente.
Leer sin trackear (untrack), agrupar cambios (batch), y dependencias explícitas con on() y defer.
createRoot para crear un scope reactivo manual, cuándo hace falta, y el ciclo de vida de disposición.
Igualdad personalizada (equals: false), signals sin comparación, y patrones para señales que siempre notifican.
Renderizado condicional eficiente: Show con fallback y keyed, Switch/Match, y por qué no usar ternarios crudos.
For (keyed por referencia) vs Index (por posición): cuándo cada uno, el coste de reconciliación y errores típicos.
Dynamic para componentes en runtime, Portal para renderizar fuera del árbol, y ErrorBoundary para capturar errores.
onMount y el ciclo de vida real de Solid, refs al DOM, forward refs, y cuándo el DOM está disponible.
Stores: objetos reactivos de grano fino y anidados, acceso por proxy, y por qué escalan mejor que muchos signals.
Actualizar stores: paths, funciones, arrays, y produce()/modifyMutable para un estilo mutable seguro (tipo Immer).
reconcile() para fusionar datos externos preservando referencias, unwrap() para obtener el objeto crudo, y sus usos.
Patrones de estado global sin librerías: un store en un módulo o createRoot, y cómo compartirlo entre componentes.
La API de contexto de Solid: proveer y consumir estado por el árbol, con reactividad intacta y sin prop drilling.
createMutable para un proxy de escritura directa; su potencia, sus peligros, y cuándo (casi nunca) usarlo.
Envolver librerías no reactivas: from()/observable, integrar con Web APIs, y crear tus propios primitivos reactivos.
El async first-class de Solid: createResource, estados (loading/error), refetch, y el source reactivo que lo dispara.
Suspense y SuspenseList: coordinar múltiples resources, fallbacks, y evitar cascadas de spinners.
Transiciones concurrentes: mantener la UI vieja mientras carga la nueva, useTransition y su estado pending.
Manejo de errores con async: cómo se propagan a ErrorBoundary, reset, y patrones de reintento robustos.
El nuevo modelo de datos: createAsync (Solid Router / 2.0), señales async, y hacia dónde va la reactividad async.
Patrones reales: deduplicación, cache, prefetch en navegación, mutaciones optimistas y revalidación.
SolidStart sobre Vinxi/Nitro: crear el proyecto, la estructura, y qué añade sobre Solid puro.
El enrutado por archivos de Solid Router: rutas anidadas, layouts, rutas dinámicas y route data.
Los modos de renderizado: SSR síncrono y en streaming, CSR, y prerender/SSG; cuándo cada uno.
Funciones que solo corren en el servidor con "use server": RPC type-safe, serialización, y la frontera cliente/servidor.
Actions para mutaciones, formularios con progressive enhancement, useSubmission, y estado optimista.
Cargar datos con query() y cache, preload en el router, createAsync, y revalidación tras una action.
Sesiones y auth en SolidStart, middleware de peticiones, cookies, y proteger rutas y server functions.
Cómo Solid compila JSX a DOM real y a expresiones reactivas: babel-plugin-jsx-dom-expressions, y por qué compilar gana.
Optimización extrema, el nuevo runtime reactivo (async transparente) de Solid 2.0, y benchmarks frente al ecosistema.
El modelo mental completo, arquitectar una app real de principio a fin, comparación con el ecosistema y cuándo Solid NO es la elección.
Empieza por los fundamentos y sube nivel a nivel hasta el dominio total.
Comenzar el camino →