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

package/dist/render.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -40,15 +7,36 @@ exports.createRenderMiddleware = createRenderMiddleware;
 exports.createRenderServer = createRenderServer;
 const react_1 = __importDefault(require("react"));
 const server_1 = require("react-dom/server");
-const pages_1 = require("./pages");
+const node_url_1 = require("node:url");
 const request_handler_1 = require("./helpers/request-handler");
+const prod_server_1 = require("./runtime/prod-server");
+const security_1 = require("./security");
+const assets_1 = require("@ressjs/assets");
 /**
  * RENDER MIDDLEWARE PARA EL ROUTER
+ *
+ * El render server se arma una sola vez por ruta, en la primera petición, y
+ * se reusa en las siguientes. Antes se creaba en cada `processRequest` sin
+ * `renderServer`, y `createRenderServer` barría `app/pages` con `fast-glob`
+ * en cada request: cien peticiones, cien globs síncronos contra el
+ * filesystem en producción.
+ *
+ * La primera petición espera a que `viteConfig` (que puede llegar como thunk
+ * en modo automático) esté resuelto, así que armar el render server recién
+ * ahí, y no al declarar el middleware, es lo que garantiza que ya tenga el
+ * `moduleLoader` correcto.
  */
 function createRenderMiddleware(page, options) {
+    let renderServer;
     return async (req, res, next) => {
         try {
-            await (0, request_handler_1.processRequest)({ req, res, page, next }, options);
+            // Con `renderFunction` el pipeline de render propio no corre: armar el
+            // render server igual sería trabajo tirado (y, en tests, un moduleLoader
+            // que no llegó a resolverse).
+            if (!renderServer && !options.renderFunction) {
+                renderServer = (0, request_handler_1.buildRenderServer)(options);
+            }
+            await (0, request_handler_1.processRequest)({ req, res, page, next }, options, renderServer);
         }
         catch (error) {
             next(error);
@@ -56,49 +44,29 @@ function createRenderMiddleware(page, options) {
     };
 }
 function createRenderServer(options = {}) {
-    const pages = (0, pages_1.getPages)();
-    const { vite } = options;
+    const { moduleLoader } = options;
+    const policy = options.clientProps ?? (0, security_1.resolveSecurityOptions)().clientProps;
+    const isProduction = options.isProduction ?? process.env.NODE_ENV === 'production';
     return async (renderOptions) => {
-        const { url, props = {} } = renderOptions;
-        // Encuentra la página que coincide con la URL
-        // Función helper para hacer matching de rutas dinámicas
-        const matchRoute = (pageRoute, url) => {
-            if (pageRoute === '/')
-                return url === '/' || url === '';
-            // Si no tiene parámetros dinámicos, hacer matching exacto
-            if (!pageRoute.includes('[')) {
-                return url === pageRoute || url.startsWith(pageRoute + '/');
-            }
-            // Convertir ruta de página a regex para matching dinámico
-            // Ejemplo: /photocard/[id] → /^\/photocard\/([^\/]+)$/
-            const regexPattern = pageRoute
-                .replace(/\[([^\]]+)\]/g, '([^/]+)') // [id] → ([^/]+)
-                .replace(/\//g, '\\/'); // escapar slashes
-            const regex = new RegExp(`^${regexPattern}$`);
-            return regex.test(url);
-        };
-        const matchedPage = pages.find(page => matchRoute(page.route, url));
-        if (!matchedPage) {
-            throw new Error(`Page not found for URL: ${url}`);
+        const { url, props = {}, locals = {}, page, hydrate = true } = renderOptions;
+        // La página la resuelve el despachador antes de llegar acá (route groups,
+        // catch-all, etc.); volver a buscarla por URL con un criterio propio sería
+        // una segunda resolución que no conoce esos casos y puede discrepar con
+        // la primera.
+        if (!page) {
+            throw new Error(`createRenderServer: falta \`page\` para la URL "${url}". El despachador tiene ` +
+                'que resolverla antes de invocar el render; no se busca más por glob.');
         }
+        const matchedPage = page;
         try {
-            // Import dinámico de la página usando vite.ssrLoadModule si está disponible
             let pageModule;
-            if (vite) {
-                // En desarrollo: usar vite.ssrLoadModule para manejar .tsx
-                const modulePath = `/${matchedPage.file}`;
-                pageModule = await vite.ssrLoadModule(modulePath);
+            if (moduleLoader) {
+                pageModule = await moduleLoader.load(`/${matchedPage.file}`);
             }
             else {
-                // En producción: usar import directo del archivo compilado
-                const moduleUrl = (0, pages_1.getCompiledProdPage)(matchedPage.abs);
-                try {
-                    pageModule = await Promise.resolve(`${moduleUrl}`).then(s => __importStar(require(s)));
-                }
-                catch (importError) {
-                    console.error('Error loading module:', importError);
-                    throw importError;
-                }
+                // Ruta absoluta: en Windows sólo se puede importar como URL `file://`.
+                const moduleUrl = (0, prod_server_1.resolveServerModulePath)(matchedPage.abs ?? matchedPage.file);
+                pageModule = await import(/* @vite-ignore */ (0, node_url_1.pathToFileURL)(moduleUrl).href);
             }
             const PageComponent = pageModule.default;
             if (!PageComponent) {
@@ -111,14 +79,26 @@ function createRenderServer(options = {}) {
                 ...props,
                 ...(props.serverSideProps || {})
             };
-            // Renderiza el componente con las props finales
-            const html = (0, server_1.renderToString)(react_1.default.createElement(PageComponent, finalProps));
-            // Evitar mandar htmlConfig al cliente
-            const { htmlConfig, serverSideProps, ...rest } = finalProps;
-            const clientProps = serverSideProps || rest;
+            // El collector vive en este árbol, no en un singleton. Dos requests que
+            // renderizan a la vez nunca pueden mezclar sus títulos o metadatos.
+            const head = [];
+            const tree = react_1.default.createElement(assets_1.HeadCollectorProvider, { collector: head }, react_1.default.createElement(PageComponent, finalProps));
+            const html = (0, server_1.renderToString)(tree);
+            // El componente ya recibió todo arriba. Lo que viaja al cliente es sólo
+            // lo que la política declara: enumerar lo que se excluye deja expuesta
+            // cada clave que un middleware agregue después.
+            //
+            // `serverSideProps` es lo que la página pidió explícitamente para el
+            // cliente; el resto de `res.locals` es estado del servidor y no viaja
+            // salvo que se declare.
+            const exposable = { ...locals, serverSideProps: props };
+            const clientProps = hydrate ? (0, security_1.pickClientProps)(exposable, policy) : {};
+            if (hydrate && !isProduction)
+                warnWithheld(matchedPage.route, exposable, clientProps);
             return {
                 html,
                 props: clientProps,
+                head,
                 route: matchedPage.route,
                 page: matchedPage.file
             };
@@ -129,3 +109,21 @@ function createRenderServer(options = {}) {
         }
     };
 }
+/**
+ * Avisa, una vez por ruta, qué quedó fuera del cliente.
+ *
+ * Una página que renderiza en el servidor con datos que el cliente no tiene
+ * hidrata distinto, y ese desajuste no dice de dónde viene. El aviso lo nombra.
+ */
+const warnedRoutes = new Set();
+function warnWithheld(route, serverProps, clientProps) {
+    if (warnedRoutes.has(route))
+        return;
+    const withheld = (0, security_1.withheldKeys)(serverProps, clientProps);
+    if (withheld.length === 0)
+        return;
+    warnedRoutes.add(route);
+    console.warn(`[ress] ${route}: estas claves existen en el servidor y no viajan al cliente: ` +
+        `${withheld.join(', ')}.\n` +
+        'Si la página las usa al hidratar, declaralas en `security.clientProps.expose`.');
+}

package/dist/router.d.ts

@@ -1,27 +1,46 @@
 import { Router } from 'express';
+import type { RessRuntime } from './runtime/dev-server';
+import type { ModuleLoader } from './runtime/module-loader';
+import { type ResolvedSecurityOptions, type SecurityOptions } from './security';
+import { type ResolvedConfig } from './config';
+/** Espera a que el runtime, el manifest y las cadenas de middleware estén listos. */
+export declare function waitForViteRouter(router: Router): Promise<void>;
 export interface ViteRouterOptions {
     enablePlatformDetection?: boolean;
     isProduction?: boolean;
-    pagesDirectory?: string;
     basePath?: string;
-    vite?: any;
+    /** Runtime ya construido, para quien lo arma por su cuenta. */
+    runtime?: RessRuntime;
+    /** Cargador de módulos, para quien arma su propio servidor. */
+    moduleLoader?: ModuleLoader;
     templateHtml?: string;
     renderFunction?: (options: {
         url: string;
         platform: string;
         req: any;
     }) => Promise<string>;
+    /** Opciones de seguridad ya resueltas. F-008 las tomará de `ress.config.ts`. */
+    security?: ResolvedSecurityOptions;
+    /** Opciones de seguridad sin resolver; se completan con los defaults. */
+    securityOptions?: SecurityOptions;
+    /**
+     * Configuración del proyecto ya resuelta. Si no se aporta, se carga de
+     * `ress.config` al arrancar: es el archivo que el proyecto ya declara, y
+     * exigir pasarla a mano deja al servidor y al build leyendo cosas distintas.
+     */
+    config?: ResolvedConfig;
+    /** Raíz del proyecto, para leer la configuración. */
+    root?: string;
+    /** Modo con el que se resuelven las capas de configuración. */
+    mode?: string;
 }
-export interface AutoViteServerOptions {
-    port?: number;
-    base?: string;
-    enablePlatformDetection?: boolean;
-}
-export declare function createAutoViteServer(options?: AutoViteServerOptions): Promise<{
-    app: import("express-serve-static-core").Express;
-    vite: any;
-    start: () => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
-}>;
+/**
+ * El router de ress.js.
+ *
+ * Antes había dos constructores con el 90 % del cuerpo repetido, uno para quien
+ * deja que el framework arme el runtime y otro para quien lo aporta. La
+ * diferencia real entre los dos es de dónde sale el runtime, así que eso es lo
+ * único que se decide acá; el resto del camino es uno solo.
+ */
 export declare function createViteRouter(options?: ViteRouterOptions): Router;
-export declare function listDetectedPages(): import("./pages").PageInfo[];
 export { getPages } from './pages';

package/dist/router.js

@@ -1,161 +1,195 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPages = void 0;
-exports.createAutoViteServer = createAutoViteServer;
+exports.waitForViteRouter = waitForViteRouter;
 exports.createViteRouter = createViteRouter;
-exports.listDetectedPages = listDetectedPages;
 const express_1 = require("express");
-const pages_1 = require("./pages");
-const express_2 = __importDefault(require("express"));
-const vite_config_1 = require("./helpers/vite-config");
-const middlewares_1 = require("./helpers/middlewares");
-const render_1 = require("./render");
-async function createAutoViteServer(options = {}) {
-    const { port = 5173, base = '/', enablePlatformDetection = true } = options;
-    const isProduction = process.env.NODE_ENV === 'production';
-    const app = (0, express_2.default)();
-    const viteConfig = await (0, vite_config_1.setupVite)(isProduction, base);
-    if (!isProduction) {
-        app.use(viteConfig.vite.middlewares);
-        app.use('/dist/.entries', express_2.default.static('dist/.entries'));
-    }
-    else {
-        const prodFactory = (0, vite_config_1.createProdMiddleware)();
-        const prodMiddleware = await prodFactory();
-        app.use(prodMiddleware);
-    }
-    const viteRouter = createViteRouter({
-        enablePlatformDetection,
-        vite: viteConfig.vite,
-        templateHtml: viteConfig.templateHtml,
-        isProduction
-    });
-    app.use('/', viteRouter);
-    app.use(express_2.default.static('public'));
-    const start = () => {
-        return app.listen(port, () => {
-            if (process.env.NODE_ENV !== 'production') {
-                const pages = (0, pages_1.getPages)();
-                console.log(`🚀 Auto Vite Server started at http://localhost:${port}`);
-                console.log(`📄 Auto-detected routes:`);
-                pages.forEach(page => {
-                    const expressDisplay = page.route !== page.expressRoute ? ` (Express: ${page.expressRoute})` : '';
-                    console.log(`   ${page.route}${expressDisplay} -> ${page.file}`);
-                });
-            }
-        });
-    };
-    return { app, vite: viteConfig.vite, start };
+const prod_server_1 = require("./runtime/prod-server");
+const security_1 = require("./security");
+const router_1 = require("./routes/router");
+const manifest_1 = require("./routes/manifest");
+const scan_1 = require("./routes/scan");
+const config_1 = require("./config");
+const store_1 = require("./isr/store");
+const request_handler_1 = require("./helpers/request-handler");
+const routerReadiness = new WeakMap();
+/** Espera a que el runtime, el manifest y las cadenas de middleware estén listos. */
+function waitForViteRouter(router) {
+    return routerReadiness.get(router) ?? Promise.resolve();
 }
+/**
+ * El router de ress.js.
+ *
+ * Antes había dos constructores con el 90 % del cuerpo repetido, uno para quien
+ * deja que el framework arme el runtime y otro para quien lo aporta. La
+ * diferencia real entre los dos es de dónde sale el runtime, así que eso es lo
+ * único que se decide acá; el resto del camino es uno solo.
+ */
 function createViteRouter(options = {}) {
-    const needsAutoConfig = !options.vite && !options.templateHtml && options.isProduction !== true;
-    if (needsAutoConfig) {
-        return createAutoRouter(options);
-    }
-    return createManualRouter(options);
-}
-function createAutoRouter(options) {
     const { renderFunction, enablePlatformDetection = true } = options;
-    const isProduction = process.env.NODE_ENV === 'production';
-    let viteConfig = null;
-    let initialized = false;
+    // Se resuelve recién dentro de `setup()`, después de cargar la
+    // configuración: `config.security` tiene que poder completar los defaults,
+    // y acá todavía no se leyó `ress.config`.
+    let security = options.security ?? (0, security_1.resolveSecurityOptions)(options.securityOptions);
+    const providesOwnRuntime = Boolean(options.moduleLoader || options.templateHtml);
+    const isProduction = options.isProduction ?? process.env.NODE_ENV === 'production';
     const mainRouter = (0, express_1.Router)();
-    const initializeIfNeeded = async () => {
-        if (initialized)
-            return viteConfig;
-        const basePath = process.env.BASE || '/';
-        viteConfig = await (0, vite_config_1.setupVite)(isProduction, basePath);
-        if (!isProduction) {
-            mainRouter.use(viteConfig.vite.middlewares);
+    let runtime = null;
+    /**
+     * El manifest vigente.
+     *
+     * Se guarda acá y no se lee del runtime en cada rearmado: en desarrollo hay
+     * que volver a escanear cuando aparece o desaparece un archivo, y el runtime
+     * lo construyó una sola vez al arrancar.
+     */
+    let routes = null;
+    let state = null;
+    let pageRouter = null;
+    let assetMiddleware = null;
+    let configMiddleware = null;
+    let stale = false;
+    let rescan = false;
+    /** La caché incremental: se crea con la configuración, una por router. */
+    let isr;
+    const markRescan = () => {
+        stale = true;
+        rescan = true;
+        isr?.store.clear();
+    };
+    const chainContext = () => ({
+        moduleLoader: runtime?.moduleLoader,
+        renderOptions: {
+            enablePlatformDetection,
+            renderFunction,
+            security,
+            viteConfig: () => runtime,
+        },
+        isr,
+    });
+    const rebuild = async (rescan = false) => {
+        stale = false;
+        if (rescan || !routes)
+            routes = (0, manifest_1.createRouteManifest)(await (0, scan_1.scanRoutes)());
+        state = await (0, router_1.buildRouterState)(routes, chainContext());
+    };
+    const setup = async () => {
+        // La configuración primero: de ella salen el prefijo de ruta, el prefijo de
+        // artefactos y las reglas del pipeline, y las tres se necesitan antes de
+        // armar el runtime.
+        const config = options.config ??
+            (await (0, config_1.loadConfig)(options.root ?? process.cwd(), options.mode ?? (isProduction ? 'production' : 'development')));
+        // `config.security` es el que declara el proyecto en `ress.config`; sólo
+        // se pisa si quien arma el router aportó algo explícito.
+        security = options.security ?? (0, security_1.resolveSecurityOptions)(options.securityOptions ?? config.security);
+        configMiddleware = (0, config_1.createConfigMiddleware)(config);
+        const assetPrefix = (0, config_1.assetPrefixFor)({
+            basePath: config.basePath,
+            cdnPrefix: config.assets?.cdnPrefix,
+        });
+        if (options.runtime) {
+            runtime = options.runtime;
+            routes = runtime.routes;
+            assetMiddleware = isProduction
+                ? await (0, prod_server_1.createProdAssetMiddleware)(undefined, { security, buildOutputs: runtime.buildOutputs })
+                : runtime.vite.middlewares;
         }
-        else {
-            const prodFactory = (0, vite_config_1.createProdMiddleware)();
-            const prodMiddleware = await prodFactory();
-            mainRouter.use(prodMiddleware);
+        else if (providesOwnRuntime) {
+            // Quien aporta su propio cargador de módulos no tiene runtime del
+            // framework, así que se arma uno mínimo con lo que declaró.
+            runtime = {
+                vite: null,
+                moduleLoader: options.moduleLoader,
+                templateHtml: options.templateHtml ?? '',
+                isProduction,
+                buildOutputs: new Set(),
+                close: async () => { },
+            };
         }
-        initialized = true;
-        return viteConfig;
-    };
-    const pages = (0, pages_1.getPages)();
-    // Initialize Vite ONCE before setting up any routes
-    const setupRoutes = async () => {
-        if (!viteConfig)
-            await initializeIfNeeded();
-        // Process pages sequentially to avoid race conditions
-        for (const page of pages) {
-            // Dynamic middleware loading for HMR support
-            const HMRMiddleware = await (0, middlewares_1.createDynamicPageMiddlewares)(page.route, page.file, viteConfig?.vite);
-            // Productive middlewares
-            const prevMiddlewares = await (0, middlewares_1.loadPageMiddlewares)(page.route, viteConfig?.vite);
-            const serverSidePropsMiddleware = await (0, middlewares_1.getServerSidePropsAsMiddleware)(page.file, viteConfig?.vite);
-            const renderMiddleware = (0, render_1.createRenderMiddleware)(page, {
-                enablePlatformDetection,
-                renderFunction,
-                viteConfig: () => viteConfig // pasar por función para evitar capturar null
-            });
-            const pageMiddlewares = isProduction ? [
-                ...prevMiddlewares,
-                serverSidePropsMiddleware,
-                renderMiddleware
-            ] : [
-                HMRMiddleware,
-                renderMiddleware
-            ];
-            mainRouter.get(page.expressRoute, ...pageMiddlewares);
-            // Error middleware separado
-            mainRouter.use(page.expressRoute, (0, middlewares_1.createPageErrorHandler)(page.file, viteConfig?.vite));
+        else {
+            // El `base` de Vite se queda en `/`: el prefijo de ruta lo quita el
+            // pipeline de petición, y lo que se escribe en el HTML lo lleva por el
+            // prefijo de artefactos.
+            runtime = await (0, prod_server_1.createRuntime)(isProduction, options.basePath ?? process.env.BASE ?? '/', assetPrefix);
+            routes = runtime.routes;
+            // Los estáticos se atienden antes que las páginas: un pedido de artefacto
+            // no tiene que recorrer el manifest de rutas, y una ruta que capture todo
+            // no debe interceptarlos.
+            assetMiddleware = isProduction
+                ? await (0, prod_server_1.createProdAssetMiddleware)(undefined, { security, buildOutputs: runtime.buildOutputs })
+                : runtime.vite.middlewares;
         }
+        const isrOptions = config.isr ?? (0, config_1.resolveIsrConfig)();
+        isr = {
+            store: new store_1.MemoryIsrStore({
+                maxEntries: isrOptions.maxEntries,
+                maxBytes: isrOptions.maxBytes,
+                timeoutMs: isrOptions.generationTimeoutMs,
+            }),
+            options: isrOptions,
+            // En desarrollo la página se genera en cada petición, bajo el mismo
+            // contrato público: los datos se ven frescos y lo que funciona acá
+            // funciona igual en producción.
+            cacheEnabled: isProduction || isrOptions.dev,
+            buildId: runtime.buildId ?? 'dev',
+            usesNonce: security.csp.enabled,
+            isProduction,
+            // Una entrada ISR que no puede compartirse vuelve a este valor: nunca
+            // puede ser público, aunque `security.cache.html` lo sea.
+            htmlCacheControl: (0, security_1.privateCacheControl)(security.cache.html),
+            resolvePlatform: (req) => (0, request_handler_1.resolveRequestPlatform)(req, enablePlatformDetection),
+        };
+        await rebuild();
+        pageRouter = (0, router_1.createPageRouter)(() => state, chainContext());
+        // Se marca y se rearma en la petición siguiente, no acá: el watcher avisa
+        // antes de que Vite termine de invalidar su grafo, y rearmar en ese instante
+        // volvería a leer la versión anterior del archivo.
+        runtime.onSourceChange?.(() => {
+            stale = true;
+            isr?.store.clear();
+        });
+        // Crear o borrar una página cambia el conjunto de rutas, no sólo el
+        // contenido de un módulo: hay que volver a escanear.
+        runtime.vite?.watcher?.on('add', markRescan);
+        runtime.vite?.watcher?.on('unlink', markRescan);
     };
-    // Setup routes asynchronously but don't block router creation
-    setupRoutes().catch(console.error);
+    // El armado es asíncrono y una petición puede llegar antes de que termine. Se
+    // espera la promesa en vez de responder como si la ruta no existiera.
+    const ready = setup();
+    routerReadiness.set(mainRouter, ready);
+    mainRouter.use((req, res, next) => {
+        ready.then(() => {
+            const serve = () => {
+                // Se lee acá y no antes: la marca la pone el pipeline de configuración,
+                // que corre después de este callback.
+                const outside = req.ressOutsideBasePath === true;
+                // Después de la configuración, los artefactos: un pedido de artefacto no
+                // tiene que recorrer el manifest de rutas. Se registra acá y no con
+                // `use()` porque los dos middlewares se resuelven dentro del armado
+                // asíncrono, y registrarlos después dejaría al despachador por delante.
+                // Fuera del prefijo no hay páginas: declarar un prefijo y seguir
+                // sirviendo el sitio entero por la raíz es exactamente lo que un prefijo
+                // existe para evitar. Los artefactos sí se intentan igual, porque las
+                // rutas internas del servidor de desarrollo de Vite —`/@vite/client`,
+                // `/@fs/`— viven en la raíz y no bajo el prefijo de la aplicación.
+                const after = (err) => err ? next(err) : outside ? next() : dispatch(req, res, next);
+                if (!assetMiddleware)
+                    return after();
+                assetMiddleware(req, res, after);
+            };
+            // Barra final, prefijo de ruta, redirecciones y reescrituras: todo lo que
+            // decide *qué* URL se está atendiendo va antes que quien la atiende.
+            if (!configMiddleware)
+                return serve();
+            configMiddleware(req, res, ((err) => (err ? next(err) : serve())));
+        }, next);
+    });
+    function dispatch(req, res, next) {
+        const run = () => (pageRouter ? pageRouter(req, res, next) : next());
+        if (!stale)
+            return run();
+        rebuild(rescan).then(() => { rescan = false; run(); }, next);
+    }
     return mainRouter;
 }
-function createManualRouter(options) {
-    const { vite, renderFunction, enablePlatformDetection = true } = options;
-    const router = (0, express_1.Router)();
-    const pages = (0, pages_1.getPages)();
-    // Crear viteConfig para processRequest
-    const viteConfig = {
-        vite,
-        templateHtml: options.templateHtml || '',
-        isProduction: options.isProduction || false,
-        manifest: null
-    };
-    // Process pages sequentially to avoid race conditions
-    const setupRoutes = async () => {
-        for (const page of pages) {
-            // Dynamic middleware loading for HMR support(only in dev)
-            const HMRMiddleware = await (0, middlewares_1.createDynamicPageMiddlewares)(page.route, page.file, vite);
-            // Productive middlewares
-            const prevMiddlewares = await (0, middlewares_1.loadPageMiddlewares)(page.route, vite);
-            const serverSidePropsMiddleware = await (0, middlewares_1.getServerSidePropsAsMiddleware)(page.file, vite);
-            const renderMiddleware = (0, render_1.createRenderMiddleware)(page, {
-                enablePlatformDetection,
-                renderFunction,
-                viteConfig
-            });
-            const pageMiddlewares = options.isProduction ? [
-                ...prevMiddlewares,
-                serverSidePropsMiddleware,
-                renderMiddleware
-            ] : [
-                HMRMiddleware,
-                renderMiddleware
-            ];
-            router.get(page.expressRoute, ...pageMiddlewares);
-            // Error middleware separado  
-            router.use(page.expressRoute, (0, middlewares_1.createPageErrorHandler)(page.file, vite));
-        }
-    };
-    // Setup routes asynchronously but don't block router creation
-    setupRoutes().catch(console.error);
-    return router;
-}
-function listDetectedPages() {
-    return (0, pages_1.getPages)();
-}
-var pages_2 = require("./pages");
-Object.defineProperty(exports, "getPages", { enumerable: true, get: function () { return pages_2.getPages; } });
+var pages_1 = require("./pages");
+Object.defineProperty(exports, "getPages", { enumerable: true, get: function () { return pages_1.getPages; } });

package/dist/routes/dispatcher.d.ts

@@ -0,0 +1,58 @@
+import type { NextFunction, Request, RequestHandler, Response } from 'express';
+import type { RequestPlatform } from '../isr/key';
+import type { ResolvedPageRendering } from '../isr/types';
+import type { RouteEntry, RouteManifest } from './types';
+declare global {
+    namespace Express {
+        interface Request {
+            /** La ruta que atendió esta petición. La usa el manejador de errores. */
+            ressRoute?: RouteEntry;
+            /**
+             * Los parámetros de la URL.
+             *
+             * Express reasigna `req.params` al entrar a cada router anidado, así que
+             * los valores que el despachador extrajo se perderían en el camino. Acá
+             * quedan en un campo propio, y `req.params` se mantiene por compatibilidad
+             * con quien ya lo lee.
+             */
+            ressParams?: Record<string, string | string[]>;
+            /**
+             * La plataforma ya resuelta. La deja la caché incremental: la plataforma
+             * de la clave y la del documento tienen que ser la misma por construcción.
+             */
+            ressPlatform?: RequestPlatform;
+            /**
+             * La configuración de render efectiva de esta petición: el export
+             * estático combinado con lo que devolvió `getServerSideProps`. Sólo
+             * existe si `getServerSideProps` devolvió campos de render.
+             */
+            ressPageRendering?: ResolvedPageRendering;
+        }
+    }
+}
+/** Cómo se arma la cadena de middlewares de una entrada. */
+export type ChainBuilder = (entry: RouteEntry) => Promise<RequestHandler[]>;
+/**
+ * Un único punto de entrada para todas las rutas.
+ *
+ * El modelo anterior registraba una ruta de Express por página, lo que obligaba
+ * a traducir cada patrón a la sintaxis de Express —que no puede expresar un
+ * catch-all opcional ni un grupo— y dejaba la precedencia en manos del orden de
+ * registro. Acá el manifest decide, y Express sólo ve un middleware.
+ *
+ * Las cadenas se construyen una vez, no por petición. `chains` se reemplaza
+ * entero cuando el manifest cambia en desarrollo, de modo que una petición nunca
+ * ve una mezcla de dos versiones.
+ */
+export declare function createDispatcher(getState: () => {
+    manifest: RouteManifest;
+    chains: Map<string, RequestHandler[]>;
+}): RequestHandler;
+/**
+ * Ejecuta la cadena respetando el contrato de Express.
+ *
+ * Cada middleware decide si sigue: `next()` avanza, `next(error)` corta y
+ * propaga. Un throw síncrono se convierte en `next(error)` para que no quede una
+ * petición colgada.
+ */
+export declare function runMiddlewareChain(chain: readonly RequestHandler[], req: Request, res: Response, done: NextFunction): void;