@ressjs/vite-router 0.5.2 → 0.6.0-rc.0

package/dist/routes/router.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildChain = buildChain;
+exports.buildRouterState = buildRouterState;
+exports.createPageRouter = createPageRouter;
+const express_1 = require("express");
+const middlewares_1 = require("../helpers/middlewares");
+const handler_1 = require("../isr/handler");
+const page_config_1 = require("../isr/page-config");
+const render_1 = require("../render");
+const dispatcher_1 = require("./dispatcher");
+const manifest_1 = require("./manifest");
+const types_1 = require("./types");
+/**
+ * La cadena de middlewares de una entrada.
+ *
+ * Es el cuerpo que estaba duplicado entre los dos constructores de router del
+ * modelo anterior: lo que hace un middleware de carpeta, `getServerSideProps` y
+ * el render, en ese orden. Tenerlo una vez es lo que garantiza que los dos
+ * caminos se comporten igual.
+ */
+async function buildChain(entry, ctx, preloaded) {
+    const pageModule = preloaded === undefined
+        ? await (0, middlewares_1.loadPageModule)(entry.sourceFile, ctx.moduleLoader)
+        : preloaded;
+    // La configuración de render se valida al armar la ruta, no al atender: una
+    // página mal configurada se informa al arrancar, nombrando archivo y campo.
+    // Esa ruta responde con su error; el resto de la aplicación sigue en pie.
+    let rendering;
+    try {
+        rendering = (0, page_config_1.resolvePageRendering)(pageModule?.pageConfig, entry.sourceFile);
+    }
+    catch (error) {
+        console.error(error.message);
+        return [(_req, _res, next) => next(error)];
+    }
+    const page = {
+        route: entry.pattern,
+        file: entry.sourceFile,
+        pageId: entry.pageId,
+        ...(pageModule?.pageConfig ? { config: pageModule.pageConfig } : {}),
+    };
+    const middlewares = await (0, middlewares_1.loadPageMiddlewares)(middlewareRouteOf(entry), ctx.moduleLoader, ctx.middlewares);
+    const render = [
+        pageModule ? (0, middlewares_1.createGetServerSidePropsMiddleware)(pageModule, entry.sourceFile) : (_req, _res, next) => next(),
+        (0, render_1.createRenderMiddleware)(page, ctx.renderOptions),
+    ];
+    return [
+        // Express reasigna `req.params` cada vez que la petición entra a un router
+        // anidado, así que los valores que extrajo el despachador se restauran acá,
+        // ya dentro de la cadena de la página.
+        (req, _res, next) => {
+            if (req.ressParams)
+                req.params = req.ressParams;
+            next();
+        },
+        // Se busca por la ubicación del archivo y no por el patrón: un grupo no
+        // aparece en la URL, así que `app/pages/(marketing)/about.tsx` tiene patrón
+        // `/about` y sus middlewares viven en `/(marketing)`. Compararlos daría
+        // siempre falso y la carpeta quedaría sin proteger.
+        //
+        // Corren también en una página ISR, con la petición real y en cada
+        // petición: la caché sólo evita obtener datos y renderizar, nunca la
+        // protección de la carpeta.
+        ...middlewares,
+        //
+        // El manejador va en toda página, no sólo en las que el export estático
+        // declara ISR: `getServerSideProps` también puede declararlo, con la misma
+        // firma. En una página SSR sólo agrega una comparación.
+        ...(ctx.isr && !ctx.renderOptions.renderFunction
+            ? [(0, handler_1.createIsrHandler)({ entry, rendering, render, runtime: ctx.isr, hasMiddlewares: middlewares.length > 0 })]
+            : render),
+    ];
+}
+/**
+ * La ruta con la que se buscan los middlewares de una entrada: la que describe
+ * dónde vive el archivo, con los grupos incluidos.
+ */
+function middlewareRouteOf(entry) {
+    const relative = entry.sourceFile
+        .replace(/\\/g, '/')
+        .replace(/^.*app\/pages\//, '')
+        .replace(/\.[^./]+$/, '')
+        .replace(/\/?index$/, '');
+    return '/' + relative;
+}
+/**
+ * Construye el estado de ruteo: el manifest más la cadena de cada entrada.
+ *
+ * Se arma entero y se devuelve entero, de modo que reemplazarlo en desarrollo
+ * sea una sola asignación y ninguna petición vea una mezcla de dos versiones.
+ */
+async function buildRouterState(manifest, ctx) {
+    const chains = new Map();
+    const accepted = [];
+    // El manifest del build trae los middlewares; el del escaneo de desarrollo
+    // no, y ahí se siguen descubriendo en el sistema de archivos.
+    if (manifest.middlewares) {
+        ctx = { ...ctx, middlewares: (0, middlewares_1.middlewaresFromManifest)(manifest.middlewares) };
+    }
+    for (const entry of manifest.entries) {
+        if (entry.kind === 'api') {
+            accepted.push(entry);
+            continue;
+        }
+        // Un renderer personalizado produce el HTML sin usar el componente de la
+        // página: en esa API la ruta puede tener sólo exports auxiliares.
+        const pageModule = ctx.renderOptions.renderFunction
+            ? undefined
+            : await (0, middlewares_1.loadPageModule)(entry.sourceFile, ctx.moduleLoader);
+        if (!ctx.renderOptions.renderFunction && !pageModule?.default) {
+            console.warn(`[ress] "${entry.sourceFile}" es ambiguo: tiene una extensión de página, ` +
+                (pageModule
+                    ? 'pero no exporta un componente por defecto ni coincide con una exclusión conocida. '
+                    : 'pero su módulo no pudo cargarse para validar el componente por defecto. ') +
+                'No se registrará como ruta; renombralo con el prefijo "_" si es un archivo auxiliar.');
+            continue;
+        }
+        accepted.push(entry);
+        chains.set(entry.pageId, await buildChain(entry, ctx, pageModule));
+    }
+    return {
+        manifest: accepted.length === manifest.entries.length
+            ? manifest
+            : (0, manifest_1.createRouteManifest)({
+                version: types_1.ROUTE_MANIFEST_VERSION,
+                entries: accepted,
+                middlewares: manifest.middlewares ? [...manifest.middlewares] : undefined,
+            }),
+        chains,
+    };
+}
+/**
+ * El router de páginas.
+ *
+ * Un solo despachador para todas las rutas y un solo manejador de errores, que
+ * sabe qué ruta falló porque el despachador lo dejó en la petición. El modelo
+ * anterior registraba un manejador por página.
+ */
+function createPageRouter(getState, ctx) {
+    const router = (0, express_1.Router)();
+    router.use((0, dispatcher_1.createDispatcher)(getState));
+    router.use((err, req, res, next) => {
+        const entry = req.ressRoute;
+        if (!entry)
+            return next(err);
+        // El mismo origen de middlewares que la cadena: los del build si están.
+        const registered = getState().manifest.middlewares;
+        const middlewares = registered ? (0, middlewares_1.middlewaresFromManifest)(registered) : undefined;
+        return (0, middlewares_1.createPageErrorHandler)(entry.sourceFile, ctx.moduleLoader, middlewares)(err, req, res, next);
+    });
+    return router;
+}

package/dist/routes/scan.d.ts

@@ -0,0 +1,26 @@
+import path from 'node:path';
+import { type RouteManifestData } from './types';
+export interface ScanOptions {
+    pagesDir?: string;
+    /** Raíz del proyecto. Los paths persistidos en el manifest son relativos a ella. */
+    root?: string;
+    /**
+     * Un conflicto en build detiene el proceso; en desarrollo avisa y sigue, para
+     * no dejar el servidor caído mientras alguien renombra un archivo.
+     */
+    strict?: boolean;
+}
+/**
+ * Qué rutas existen en el proyecto.
+ *
+ * Lee el sistema de archivos **una vez**. El modelo anterior lo globeaba en cada
+ * arranque, también en producción, donde el árbol ya no puede cambiar.
+ */
+export declare function scanRoutes(options?: ScanOptions): Promise<RouteManifestData>;
+/**
+ * Convierte cualquier resultado del glob a una identidad portable del proyecto.
+ * El manifest se publica dentro de `dist`, por lo que persistir el path absoluto
+ * filtraría la ubicación de la máquina que hizo el build y volvería el artefacto
+ * imposible de mover.
+ */
+export declare function toProjectRelativePath(file: string, root: string, pathApi?: Pick<typeof path, 'resolve' | 'relative' | 'isAbsolute' | 'sep'>): string;

package/dist/routes/scan.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanRoutes = scanRoutes;
+exports.toProjectRelativePath = toProjectRelativePath;
+const node_path_1 = __importDefault(require("node:path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const module_extensions_1 = require("../fs/module-extensions");
+const parse_1 = require("./parse");
+const rank_1 = require("./rank");
+const rank_2 = require("./rank");
+const types_1 = require("./types");
+/**
+ * Qué rutas existen en el proyecto.
+ *
+ * Lee el sistema de archivos **una vez**. El modelo anterior lo globeaba en cada
+ * arranque, también en producción, donde el árbol ya no puede cambiar.
+ */
+async function scanRoutes(options = {}) {
+    const pagesDir = options.pagesDir ?? 'app/pages';
+    const root = resolveProjectRoot(pagesDir, options.root);
+    const policy = (0, module_extensions_1.getExtensionPolicy)();
+    // Qué extensiones cuentan lo declara la política del proyecto, no este archivo.
+    const files = await (0, fast_glob_1.default)((0, module_extensions_1.pageGlob)(policy, pagesDir), { absolute: false });
+    const entries = [];
+    const byPattern = new Map();
+    const conflicts = [];
+    for (const file of files.sort()) {
+        // fast-glob devuelve separadores nativos en Windows; el parser de rutas y
+        // los identificadores del catálogo usan `/` para que el resultado sea
+        // idéntico en todos los sistemas.
+        const normalizedFile = file.replace(/\\/g, '/');
+        const sourceFile = toProjectRelativePath(normalizedFile, root);
+        const normalizedPagesDir = pagesDir.replace(/\\/g, '/');
+        if (!(0, module_extensions_1.isPageFile)(normalizedFile, policy, normalizedPagesDir))
+            continue;
+        const parsed = (0, parse_1.parseRoutePattern)(normalizedFile, normalizedPagesDir);
+        const entry = {
+            pageId: (0, parse_1.pageIdFromFile)(normalizedFile, normalizedPagesDir),
+            pattern: parsed.pattern,
+            segments: parsed.segments,
+            kind: (0, parse_1.classifyEntry)(normalizedFile, normalizedPagesDir),
+            sourceFile,
+            paramNames: parsed.paramNames,
+            groups: parsed.groups,
+            rank: (0, rank_1.computeRank)(parsed.segments),
+            server: { devId: '/' + sourceFile },
+        };
+        // Dos archivos que producen la misma URL son ambiguos: cuál gana dependería
+        // del orden en que el sistema de archivos los devolvió.
+        const clash = byPattern.get(`${entry.kind} ${entry.pattern}`);
+        if (clash) {
+            const message = `[ress] "${clash.sourceFile}" y "${sourceFile}" producen la misma ruta "${entry.pattern}". ` +
+                'Renombrá uno de los dos.';
+            if (options.strict)
+                throw new Error(message);
+            console.warn(`${message}\nPor ahora responde "${clash.sourceFile}".`);
+            conflicts.push({ pattern: entry.pattern, files: [clash.sourceFile, sourceFile] });
+            continue;
+        }
+        byPattern.set(`${entry.kind} ${entry.pattern}`, entry);
+        entries.push(entry);
+    }
+    return {
+        version: types_1.ROUTE_MANIFEST_VERSION,
+        entries: entries.sort(rank_2.compareEntries),
+        ...(conflicts.length ? { conflicts } : {}),
+    };
+}
+/**
+ * Convierte cualquier resultado del glob a una identidad portable del proyecto.
+ * El manifest se publica dentro de `dist`, por lo que persistir el path absoluto
+ * filtraría la ubicación de la máquina que hizo el build y volvería el artefacto
+ * imposible de mover.
+ */
+function toProjectRelativePath(file, root, pathApi = node_path_1.default) {
+    const absolute = pathApi.resolve(file);
+    const relative = pathApi.relative(root, absolute).replace(/\\/g, '/');
+    if (relative === '..' || relative.startsWith('../') || pathApi.isAbsolute(relative)) {
+        throw new Error(`[ress] La ruta "${file}" queda fuera de la raíz del proyecto "${root}". ` +
+            'Las entradas del manifest deben pertenecer al proyecto.');
+    }
+    return relative;
+}
+function resolveProjectRoot(pagesDir, configuredRoot) {
+    if (configuredRoot)
+        return node_path_1.default.resolve(configuredRoot);
+    if (!node_path_1.default.isAbsolute(pagesDir))
+        return process.cwd();
+    // Compatibilidad con quienes ya pasan `/proyecto/app/pages` sin `root`.
+    // Para un directorio distinto, la raíz debe declararse de forma explícita.
+    const normalized = pagesDir.replace(/\\/g, '/').replace(/\/$/, '');
+    if (normalized.endsWith('/app/pages'))
+        return node_path_1.default.resolve(pagesDir, '../..');
+    return node_path_1.default.dirname(node_path_1.default.resolve(pagesDir));
+}

package/dist/routes/types.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Qué rutas existen y cuál atiende cada URL.
+ *
+ * El modelo anterior derivaba la ruta del archivo en cada arranque, globeando el
+ * sistema de archivos también en producción, y traducía el patrón a una cadena
+ * de Express que no podía expresar ni catch-all ni grupos. Acá el conjunto de
+ * rutas es un dato: se calcula una vez, se serializa en el build y se carga.
+ */
+export type SegmentKind = 'static' | 'dynamic' | 'catchAll' | 'optionalCatchAll';
+export interface RouteSegment {
+    kind: SegmentKind;
+    /** Literal de URL para `static`; nombre del parámetro para el resto. */
+    value: string;
+}
+/** Qué es una entrada. Determina si participa del matcheo de navegación. */
+export type RouteEntryKind = 'page' | 'error' | 'api';
+/** Identificador estable de una página. La misma clave que usa el catálogo de variantes. */
+export type PageId = string;
+export interface ServerModuleRef {
+    /** Identificador que entiende el cargador de módulos en desarrollo. */
+    devId: string;
+    /**
+     * Chunk compilado, relativo a la raíz de salida del build de servidor. Lo
+     * completa el build; en desarrollo no existe.
+     */
+    buildChunk?: string;
+}
+export interface RouteEntry {
+    pageId: PageId;
+    /** Patrón canónico con notación de archivos. Ej: `/users/[id]`. */
+    pattern: string;
+    segments: RouteSegment[];
+    kind: RouteEntryKind;
+    /** Archivo fuente, relativo a la raíz del proyecto. */
+    sourceFile: string;
+    /** Nombres de parámetro, en orden de aparición. */
+    paramNames: string[];
+    /** Grupos atravesados. Informativo: no afectan la URL. */
+    groups: string[];
+    /** Clave de precedencia precalculada. */
+    rank: number[];
+    server: ServerModuleRef;
+    /** Sólo para `error`: qué código de estado atiende. */
+    statusCode?: number;
+    /** Sólo para `api`: métodos declarados. Ausente significa todos. */
+    methods?: string[];
+}
+/**
+ * Un middleware registrado por el build.
+ *
+ * Producción los lee de acá y no del sistema de archivos: un despliegue que
+ * copia sólo `dist/` no tiene `app/pages`, y globear ahí devolvía vacío, así que
+ * todas las rutas quedaban sin sus middlewares —autenticación incluida—.
+ */
+export interface MiddlewareEntry {
+    /** Archivo fuente, relativo a la raíz del proyecto. */
+    file: string;
+    /** Carpeta (o página, si es `page-specific`) a la que aplica. */
+    route: string;
+    type: 'page-specific' | 'folder-global';
+    /** Nivel de carpeta, para ordenar la cadena por jerarquía. */
+    depth: number;
+    server: ServerModuleRef;
+}
+export interface RouteMatch {
+    entry: RouteEntry;
+    params: Record<string, string | string[]>;
+}
+export interface MatchOptions {
+    /** Qué clases de entrada participan. Por defecto sólo `page`. */
+    kinds?: readonly RouteEntryKind[];
+}
+/** Dos archivos que compiten por el mismo patrón, detectados al escanear. */
+export interface RouteConflict {
+    pattern: string;
+    files: string[];
+}
+/** Lo que se serializa al disco. */
+export interface RouteManifestData {
+    /** Sube cuando el formato cambia de forma incompatible. */
+    version: number;
+    entries: RouteEntry[];
+    /**
+     * Conflictos detectados en modo no estricto (desarrollo).
+     *
+     * En modo estricto (`build`) `scanRoutes` lanza en vez de completar esta
+     * lista: un build no deja artefactos parciales publicables. F-033 (`ress
+     * info`) es quien la consume para diagnosticar sin abortar.
+     */
+    conflicts?: RouteConflict[];
+    /**
+     * Middlewares del proyecto. Obligatorio en un manifest emitido por el build;
+     * ausente en el que arma el escaneo de desarrollo, que los sigue descubriendo
+     * en el sistema de archivos.
+     */
+    middlewares?: MiddlewareEntry[];
+}
+export interface RouteManifest {
+    readonly entries: readonly RouteEntry[];
+    /** Middlewares registrados por el build. `undefined` en desarrollo. */
+    readonly middlewares?: readonly MiddlewareEntry[];
+    /** Qué entrada atiende esta URL. `undefined` si ninguna. */
+    match(pathname: string, options?: MatchOptions): RouteMatch | undefined;
+    /** Una entrada por su identificador. */
+    get(pageId: PageId): RouteEntry | undefined;
+    /** Las entradas de una clase, en orden de precedencia. */
+    byKind(kind: RouteEntryKind): readonly RouteEntry[];
+}
+/**
+ * Sube cuando el formato del manifest cambia de forma incompatible.
+ *
+ * 2: el build registra los middlewares con su chunk (F-040 PR-4).
+ */
+export declare const ROUTE_MANIFEST_VERSION = 2;

package/dist/routes/types.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Qué rutas existen y cuál atiende cada URL.
+ *
+ * El modelo anterior derivaba la ruta del archivo en cada arranque, globeando el
+ * sistema de archivos también en producción, y traducía el patrón a una cadena
+ * de Express que no podía expresar ni catch-all ni grupos. Acá el conjunto de
+ * rutas es un dato: se calcula una vez, se serializa en el build y se carga.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROUTE_MANIFEST_VERSION = void 0;
+/**
+ * Sube cuando el formato del manifest cambia de forma incompatible.
+ *
+ * 2: el build registra los middlewares con su chunk (F-040 PR-4).
+ */
+exports.ROUTE_MANIFEST_VERSION = 2;

package/dist/runtime/dev-server.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Runtime de desarrollo.
+ *
+ * Crea el servidor de Vite, resuelve el entorno de servidor y construye el cargador de
+ * módulos una sola vez, que es el que usa el resto del framework.
+ */
+import { type FetchableEnvironment, type ModuleLoader } from './module-loader';
+import type { AssetIndex, VariantCatalog } from '../variants/types';
+import type { RouteManifest } from '../routes/types';
+export interface RessRuntime {
+    /** Instancia de Vite. `null` en producción. */
+    vite: any | null;
+    /** Carga módulos de usuario. Único en dev y prod. */
+    moduleLoader: ModuleLoader;
+    templateHtml: string;
+    isProduction: boolean;
+    /** Qué variantes tiene cada página. Se arma una vez al arrancar. */
+    catalog: VariantCatalog;
+    /** Qué rutas existen y cuál atiende cada URL. */
+    routes: RouteManifest;
+    /** Artefactos por página y variante. */
+    assets: AssetIndex;
+    /** Archivos que emitió el build de cliente. Vacío en desarrollo. */
+    buildOutputs: ReadonlySet<string>;
+    /** Identificador del build en producción. Ausente en desarrollo. */
+    buildId?: string;
+    /**
+     * Registra un aviso de cambio en el código de usuario. Devuelve la función
+     * para dejar de escuchar. En producción no se invoca nunca.
+     */
+    onSourceChange(cb: (file: string) => void): () => void;
+    close(): Promise<void>;
+}
+/**
+ * Elige el entorno desde el que se cargarán los módulos de usuario.
+ *
+ * Se prefiere `ssr` por nombre; si un proyecto declaró otros entornos, se cae al
+ * primero disponible en vez de fallar. Nunca se asume que el entorno sea del
+ * tipo ejecutable: el cargador se construye sobre `fetchModule()`, presente en
+ * todos los tipos.
+ */
+export declare function resolveSsrEnvironment(server: any): FetchableEnvironment;
+export interface DevRuntimeOptions {
+    /**
+     * Plugins de Vite a aplicar, además de los que el proyecto declare en su
+     * propio `vite.config.*` si lo tiene.
+     *
+     * F-033 (la CLI) los necesita: un proyecto sin `vite.config.ts` no tiene
+     * quién le pase `ressPlugin()` a Vite si `createDevRuntime` no acepta
+     * plugins inline. Antes de esta opción, `createServer` dependía por completo
+     * de que Vite encontrara un archivo de configuración en el directorio de
+     * trabajo — que es justamente lo que la CLI existe para volver innecesario.
+     */
+    plugins?: unknown[];
+}
+export declare function createDevRuntime(base?: string, 
+/**
+ * Prefijo con el que se emiten las URL de artefactos.
+ *
+ * Va aparte del `base` de Vite porque el prefijo de ruta lo administra el
+ * framework: el pipeline de petición lo quita antes de que Vite vea la URL, así
+ * que Vite sigue viviendo en `/` y sólo lo que se escribe en el HTML lo lleva.
+ */
+assetPrefix?: string, options?: DevRuntimeOptions): Promise<RessRuntime>;

package/dist/runtime/dev-server.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Runtime de desarrollo.
+ *
+ * Crea el servidor de Vite, resuelve el entorno de servidor y construye el cargador de
+ * módulos una sola vez, que es el que usa el resto del framework.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSsrEnvironment = resolveSsrEnvironment;
+exports.createDevRuntime = createDevRuntime;
+const module_loader_1 = require("./module-loader");
+const assets_1 = require("../variants/assets");
+const manifest_1 = require("../routes/manifest");
+const scan_1 = require("../routes/scan");
+const index_1 = require("../plugin/index");
+const template_1 = require("./template");
+/**
+ * Elige el entorno desde el que se cargarán los módulos de usuario.
+ *
+ * Se prefiere `ssr` por nombre; si un proyecto declaró otros entornos, se cae al
+ * primero disponible en vez de fallar. Nunca se asume que el entorno sea del
+ * tipo ejecutable: el cargador se construye sobre `fetchModule()`, presente en
+ * todos los tipos.
+ */
+function resolveSsrEnvironment(server) {
+    const envs = server?.environments;
+    if (!envs) {
+        throw new Error('[ress] El servidor de Vite no expone environments. ' +
+            'ress.js requiere Vite 8 o superior.');
+    }
+    const env = envs.ssr ?? Object.values(envs)[0];
+    if (!env || typeof env.fetchModule !== 'function') {
+        throw new Error('[ress] No se encontró un entorno de servidor utilizable. ' +
+            `Entornos disponibles: ${Object.keys(envs).join(', ') || '(ninguno)'}`);
+    }
+    return env;
+}
+async function createDevRuntime(base = '/', 
+/**
+ * Prefijo con el que se emiten las URL de artefactos.
+ *
+ * Va aparte del `base` de Vite porque el prefijo de ruta lo administra el
+ * framework: el pipeline de petición lo quita antes de que Vite vea la URL, así
+ * que Vite sigue viviendo en `/` y sólo lo que se escribe en el HTML lo lleva.
+ */
+assetPrefix = base, options = {}) {
+    const { createServer } = await import('vite');
+    const vite = await createServer({
+        server: { middlewareMode: true },
+        appType: 'custom',
+        base,
+        plugins: options.plugins,
+    });
+    const env = resolveSsrEnvironment(vite);
+    const moduleLoader = await (0, module_loader_1.createDevModuleLoader)(env);
+    // El runner mantiene su propia caché de módulos evaluados y corre sin canal de
+    // HMR, así que nada la descarta por su cuenta. Conectar el watcher es lo que
+    // hace que editar una página o un middleware se refleje en la siguiente
+    // petición en vez de exigir reiniciar el servidor.
+    const listeners = new Set();
+    const onFileChange = (file) => {
+        moduleLoader.invalidate(file);
+        for (const cb of listeners)
+            cb(file);
+    };
+    vite.watcher.on('change', onFileChange);
+    vite.watcher.on('unlink', onFileChange);
+    const templateHtml = await (0, template_1.readTemplateHtml)();
+    // El plugin lo arma al resolver la configuración; si por algún motivo no
+    // corrió, se arma acá para no dejar el runtime sin catálogo.
+    const catalog = (0, index_1.getVariantCatalog)() ?? (await (0, index_1.refreshVariantCatalog)());
+    const routes = (0, manifest_1.createRouteManifest)(await (0, scan_1.scanRoutes)());
+    return {
+        vite,
+        moduleLoader,
+        templateHtml,
+        isProduction: false,
+        catalog,
+        routes,
+        assets: (0, assets_1.createDevAssetIndex)(catalog, assetPrefix),
+        // En desarrollo los sirve Vite, no el middleware de estáticos.
+        buildOutputs: new Set(),
+        onSourceChange: (cb) => {
+            listeners.add(cb);
+            return () => listeners.delete(cb);
+        },
+        close: async () => {
+            vite.watcher.off('change', onFileChange);
+            vite.watcher.off('unlink', onFileChange);
+            await moduleLoader.close();
+            await vite.close();
+        },
+    };
+}

package/dist/runtime/dev-styles.d.ts

@@ -0,0 +1,13 @@
+/** La URL con la que Vite sirve un archivo de estilos como hoja CSS, no como módulo. */
+export declare function directStyleUrl(prefix: string, url: string): string;
+/** Un archivo del proyecto como URL del servidor de desarrollo. */
+export declare function projectFileUrl(file: string, root?: string): string;
+/**
+ * Las hojas de estilo que importa una página en desarrollo.
+ *
+ * En desarrollo Vite inyecta el CSS desde el módulo de entrada; una página que
+ * no hidrata no carga ese módulo y quedaría sin estilos. Se recorre el grafo del
+ * entorno de servidor —que ya cargó la página para renderizarla— y se enlaza
+ * cada hoja directamente. En producción el manifest ya las lista.
+ */
+export declare function devModuleStyles(vite: unknown, pageFile: string | undefined, prefix: string): string[];

package/dist/runtime/dev-styles.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directStyleUrl = directStyleUrl;
+exports.projectFileUrl = projectFileUrl;
+exports.devModuleStyles = devModuleStyles;
+const node_path_1 = __importDefault(require("node:path"));
+const CSS_RE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+const NOT_A_STYLESHEET_RE = /[?&](inline|url|raw)\b/;
+/** La URL con la que Vite sirve un archivo de estilos como hoja CSS, no como módulo. */
+function directStyleUrl(prefix, url) {
+    const joined = `${prefix}/${url.replace(/^\/+/, '')}`;
+    return `${joined}${joined.includes('?') ? '&' : '?'}direct`;
+}
+/** Un archivo del proyecto como URL del servidor de desarrollo. */
+function projectFileUrl(file, root = process.cwd()) {
+    return '/' + node_path_1.default.relative(root, node_path_1.default.resolve(root, file)).replace(/\\/g, '/');
+}
+/**
+ * Las hojas de estilo que importa una página en desarrollo.
+ *
+ * En desarrollo Vite inyecta el CSS desde el módulo de entrada; una página que
+ * no hidrata no carga ese módulo y quedaría sin estilos. Se recorre el grafo del
+ * entorno de servidor —que ya cargó la página para renderizarla— y se enlaza
+ * cada hoja directamente. En producción el manifest ya las lista.
+ */
+function devModuleStyles(vite, pageFile, prefix) {
+    const environments = vite?.environments;
+    const graph = (environments?.ssr ?? Object.values(environments ?? {})[0])?.moduleGraph;
+    if (!graph || !pageFile)
+        return [];
+    const seen = new Set();
+    const styles = [];
+    const visit = (mod) => {
+        if (seen.has(mod))
+            return;
+        seen.add(mod);
+        if (CSS_RE.test(mod.url) && !NOT_A_STYLESHEET_RE.test(mod.url))
+            styles.push(directStyleUrl(prefix, mod.url));
+        for (const dep of mod.importedModules)
+            visit(dep);
+    };
+    // Vite guarda los archivos con barras normales, también en Windows:
+    // `path.resolve` devuelve `D:\…` y no encontraría la página en el grafo.
+    for (const mod of graph.getModulesByFile(node_path_1.default.resolve(pageFile).replace(/\\/g, '/')) ?? [])
+        visit(mod);
+    return styles;
+}