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

package/dist/helpers/middlewares.js

@@ -1,85 +1,108 @@
 "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 };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.middlewareAppliesTo = middlewareAppliesTo;
+exports.toMiddlewareEntry = toMiddlewareEntry;
+exports.middlewaresFromManifest = middlewaresFromManifest;
 exports.getMiddlewares = getMiddlewares;
 exports.loadPageMiddlewares = loadPageMiddlewares;
 exports.loadPageModule = loadPageModule;
 exports.createGetServerSidePropsMiddleware = createGetServerSidePropsMiddleware;
 exports.createPageErrorHandler = createPageErrorHandler;
-exports.createDynamicPageMiddlewares = createDynamicPageMiddlewares;
 exports.getPagePrevMiddlewares = getPagePrevMiddlewares;
 exports.getServerSidePropsAsMiddleware = getServerSidePropsAsMiddleware;
 exports.getErrorMiddleware = getErrorMiddleware;
 const node_path_1 = __importDefault(require("node:path"));
+// En Windows una ruta absoluta (`D:\\…`) no es un especificador válido para
+// `import()`: hay que pasarla como URL `file://`. Sin esto, los middlewares no
+// cargaban en producción y la ruta quedaba sin ellos.
+const node_url_1 = require("node:url");
 const fast_glob_1 = __importDefault(require("fast-glob"));
-const pages_1 = require("../pages");
+const prod_server_1 = require("../runtime/prod-server");
+const environments_1 = require("../plugin/environments");
+const module_1 = require("../routes/module");
+const module_extensions_1 = require("../fs/module-extensions");
+const page_config_1 = require("../isr/page-config");
+const page_config_merge_1 = require("./page-config-merge");
+/**
+ * Si un middleware de carpeta con alcance `scope` aplica a `route`.
+ *
+ * Se compara por segmentos: `admin/middlewares.ts` protege `/admin` y
+ * `/admin/x`, pero no `/administrator`, que sólo comparte el prefijo de texto.
+ * La raíz aplica a todo.
+ */
+function middlewareAppliesTo(scope, route) {
+    const scopeSegments = scope.split('/').filter(Boolean);
+    const routeSegments = route.split('/').filter(Boolean);
+    if (scopeSegments.length > routeSegments.length)
+        return false;
+    return scopeSegments.every((segment, i) => routeSegments[i] === segment);
+}
+/** Los middlewares que corren para una ruta: los de carpeta que la contienen y el de la página. */
+function middlewaresFor(all, pageRoute) {
+    return all.filter((middleware) => middleware.type === 'page-specific'
+        ? middleware.route === pageRoute
+        : middlewareAppliesTo(middleware.route, pageRoute));
+}
+/** Lo que el build escribe en el manifest por cada middleware. */
+function toMiddlewareEntry(info) {
+    return {
+        file: info.file,
+        route: info.route,
+        type: info.type,
+        depth: info.depth,
+        server: { devId: info.file },
+    };
+}
+/** Los middlewares tal como los registró el build, listos para cargar. */
+function middlewaresFromManifest(entries) {
+    return entries.map((entry) => ({
+        route: entry.route,
+        file: entry.file,
+        abs: node_path_1.default.resolve(entry.file),
+        type: entry.type,
+        depth: entry.depth,
+        buildChunk: entry.server.buildChunk,
+    }));
+}
 /**
  * Busca archivos de middlewares tanto específicos por página como globales por carpeta
  */
-function getMiddlewares() {
-    // Busca archivos .middlewares.ts y middlewares.ts
-    const files = fast_glob_1.default.sync('app/pages/**/*.middlewares.{ts,js}');
-    const globalFiles = fast_glob_1.default.sync('app/pages/**/middlewares.{ts,js}');
+function getMiddlewares(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    // Las dos formas: `algo.middlewares.<ext>` para una página, `middlewares.<ext>`
+    // para una carpeta. Qué extensiones cuentan lo declara la política, no este archivo.
+    const [globalGlob, pageGlobPattern] = (0, module_extensions_1.middlewareGlobs)((0, module_extensions_1.getExtensionPolicy)());
+    const files = fast_glob_1.default.sync(pageGlobPattern, { cwd }).sort();
+    const globalFiles = fast_glob_1.default.sync(globalGlob, { cwd }).sort();
     const middlewares = [];
     // Procesar archivos específicos de página: page.middlewares.ts
     for (const file of files) {
-        let route = file.replace(/^app\/pages/, '').replace(/\.middlewares\.(ts|js)$/, '');
-        route = route.replace(/\/index$/, '') || '/';
+        // La derivación recorta cualquier extensión reconocida: antes sólo quitaba
+        // `.ts` y `.js`, así que un `.middlewares.tsx` producía una ruta con la
+        // extensión adentro, no coincidía con ninguna página y no corría nunca.
+        let route = (0, module_extensions_1.middlewareRoute)(file).replace(/\/index$/, '') || '/';
         // Calcular depth: contar slashes en la ruta del archivo
         const depth = (file.match(/\//g) || []).length;
         middlewares.push({
             route,
             file,
-            abs: node_path_1.default.resolve(file),
+            abs: node_path_1.default.resolve(cwd, file),
             type: 'page-specific',
             depth
         });
     }
     // Procesar archivos globales: middlewares.ts
     for (const file of globalFiles) {
-        let route = file.replace(/^app\/pages/, '').replace(/\/middlewares\.(ts|js)$/, '');
-        route = route || '/';
+        let route = (0, module_extensions_1.middlewareRoute)(file) || '/';
         // Calcular depth: contar slashes en la ruta del archivo
         const depth = (file.match(/\//g) || []).length;
         middlewares.push({
             route,
             file,
-            abs: node_path_1.default.resolve(file),
+            abs: node_path_1.default.resolve(cwd, file),
             type: 'folder-global',
             depth
         });
@@ -89,21 +112,9 @@ function getMiddlewares() {
 /**
  * Carga middlewares para una página específica y los convierte en middlewares de Express
  */
-async function loadPageMiddlewares(pageRoute, vite) {
-    const allMiddlewares = getMiddlewares();
-    // Filtrar middlewares relevantes para esta página usando jerarquía
-    const relevantMiddlewares = allMiddlewares.filter(middleware => {
-        if (middleware.type === 'folder-global') {
-            // Un middleware global aplica si la página está dentro de su carpeta
-            // ej: middleware en "/pokedex" aplica a "/pokedex" y "/pokedex/detail"
-            return pageRoute.startsWith(middleware.route) || middleware.route === '/';
-        }
-        if (middleware.type === 'page-specific') {
-            // Un middleware específico aplica solo a esa página exacta por ruta
-            return middleware.route === pageRoute;
-        }
-        return false;
-    });
+async function loadPageMiddlewares(pageRoute, loader, middlewares) {
+    // Los que registró el build, si están; si no (desarrollo), el sistema de archivos.
+    const relevantMiddlewares = middlewaresFor(middlewares ?? getMiddlewares(), pageRoute);
     // Ordenar por jerarquía: depth menor primero, luego por tipo
     relevantMiddlewares.sort((a, b) => {
         // Primero por depth (carpetas más arriba en la jerarquía van primero)
@@ -121,7 +132,7 @@ async function loadPageMiddlewares(pageRoute, vite) {
     // Cargar middlewares de archivos .middlewares.ts
     for (const middlewareFile of relevantMiddlewares) {
         try {
-            const moduleToLoad = await loadMiddlewareModule(middlewareFile, vite);
+            const moduleToLoad = await loadMiddlewareModule(middlewareFile, loader);
             const handlers = moduleToLoad.default || [];
             for (const handler of handlers) {
                 if (typeof handler === 'function') {
@@ -130,7 +141,15 @@ async function loadPageMiddlewares(pageRoute, vite) {
             }
         }
         catch (error) {
-            console.error(`Error loading middleware ${middlewareFile.file}:`, error);
+            // Fallo cerrado: un middleware que no carga no desaparece de la cadena,
+            // porque si protegía la ruta la dejaría abierta. En producción no se
+            // arranca; en desarrollo la ruta responde con error hasta que cargue.
+            const failure = new Error(`[ress] No se pudo cargar el middleware "${middlewareFile.file}": ` +
+                (error instanceof Error ? error.message : String(error)), { cause: error });
+            if (process.env.NODE_ENV === 'production')
+                throw failure;
+            console.error(failure.message);
+            expressMiddlewares.push((_req, _res, next) => next(failure));
         }
     }
     return expressMiddlewares;
@@ -138,7 +157,7 @@ async function loadPageMiddlewares(pageRoute, vite) {
 /**
  * Carga el módulo completo de una página
  */
-async function loadPageModule(pageFile, vite) {
+async function loadPageModule(pageFile, loader) {
     const isProduction = process.env.NODE_ENV === 'production';
     const cacheKey = `${pageFile}-${process.env.NODE_ENV || 'development'}`;
     // Only use cache in production mode to allow HMR in development
@@ -147,19 +166,12 @@ async function loadPageModule(pageFile, vite) {
     }
     try {
         let pageModule;
-        if (vite) {
-            const modulePath = `/${pageFile}`;
-            pageModule = await vite.ssrLoadModule(modulePath);
+        if (loader) {
+            pageModule = await loader.load(`/${pageFile}`);
         }
         else {
-            if (pageFile.endsWith('.tsx')) {
-                const moduleUrl = (0, pages_1.getCompiledProdPage)(pageFile);
-                pageModule = await Promise.resolve(`${moduleUrl}`).then(s => __importStar(require(s)));
-            }
-            else {
-                const moduleUrl = node_path_1.default.resolve(pageFile);
-                pageModule = await Promise.resolve(`${moduleUrl}`).then(s => __importStar(require(s)));
-            }
+            const moduleUrl = (0, prod_server_1.resolveServerModulePath)(pageFile);
+            pageModule = await import(/* @vite-ignore */ (0, node_url_1.pathToFileURL)(moduleUrl).href);
         }
         const result = pageModule;
         // Only cache in production mode
@@ -180,7 +192,10 @@ async function loadPageModule(pageFile, vite) {
 /**
  * Convierte getServerSideProps en un middleware de Express
  */
-function createGetServerSidePropsMiddleware(pageModule) {
+function createGetServerSidePropsMiddleware(pageModule, file = 'la página') {
+    // Se declara acá afuera, no dentro del handler: tiene que sobrevivir entre
+    // requests para que el aviso salga una sola vez por página y no en cada hit.
+    let warnedAboutLegacyHeadApi = false;
     return async (req, res, next) => {
         if (!pageModule.getServerSideProps) {
             next();
@@ -190,13 +205,30 @@ function createGetServerSidePropsMiddleware(pageModule) {
             const result = await pageModule.getServerSideProps(req, res);
             // Manejar ServerSideResult
             if (result && typeof result === 'object') {
-                // SEPARAR: Configuración HTML se queda en servidor, props van al cliente
-                // Configuración HTML → solo para el servidor (NO va al cliente)
-                if (result.title || result.html) {
-                    res.locals.htmlConfig = {
-                        title: result.title,
-                        html: result.html
-                    };
+                // `title` y `html` eran la forma en la que F-004 devolvía el head antes
+                // de `pageConfig` (ver PR #44). Se reemplazaron sin dejar rastro: una
+                // página que todavía las devuelve no rompe, simplemente deja de tener
+                // efecto en silencio. Un aviso en desarrollo es la única señal de que
+                // hace falta migrar.
+                if (!warnedAboutLegacyHeadApi && ('title' in result || 'html' in result) && process.env.NODE_ENV !== 'production') {
+                    warnedAboutLegacyHeadApi = true;
+                    console.warn(`[ress] getServerSideProps de "${req.path}" devuelve "title" y/o "html", ` +
+                        'una API de F-004 anterior a pageConfig que ya no se interpreta. ' +
+                        'Usá pageConfig.head para title/meta/link/script, y htmlAttributes / ' +
+                        'bodyAttributes para los atributos de <html> y <body>.');
+                }
+                if (result.pageConfig) {
+                    const { document, rendering } = splitPageConfig(result.pageConfig);
+                    // La configuración del documento sólo existe durante este request y no
+                    // se serializa junto con las props de hidratación.
+                    res.locals.pageConfig = document;
+                    // La de render tiene la misma firma que el export estático y se
+                    // combina con él: lo devuelto acá gana. Viaja en la petición, que
+                    // nunca se serializa, y la leen el render (hidratación) y la caché
+                    // (plazos de esta entrada y modo de la ruta).
+                    if (Object.keys(rendering).length) {
+                        req.ressPageRendering = (0, page_config_1.resolvePageRendering)({ ...renderingOf(pageModule.pageConfig), ...rendering }, file);
+                    }
                 }
                 // Props → solo en un bucket claro (serverSideProps)
                 if (result.props) {
@@ -213,67 +245,54 @@ function createGetServerSidePropsMiddleware(pageModule) {
         }
     };
 }
+/** Separa lo que describe el documento de lo que decide cómo se renderiza. */
+function splitPageConfig(config) {
+    const document = { ...config };
+    for (const field of page_config_merge_1.RENDERING_FIELDS)
+        delete document[field];
+    return { document, rendering: renderingOf(config) };
+}
+function renderingOf(config) {
+    const rendering = {};
+    for (const field of page_config_merge_1.RENDERING_FIELDS) {
+        if (config?.[field] !== undefined)
+            rendering[field] = config[field];
+    }
+    return rendering;
+}
 /**
  * Creates a unified error handler for a specific page route
  * This replaces the old createPageErrorMiddleware with a more useful approach
  */
-function createPageErrorHandler(pageFile, vite) {
+function createPageErrorHandler(pageFile, loader, middlewares) {
     return async (err, req, res, next) => {
-        const errorMiddleware = await getErrorMiddleware(pageFile, vite);
+        const errorMiddleware = await getErrorMiddleware(pageFile, loader, middlewares);
+        // Sin errorMiddleware propio (ni en la página ni en la jerarquía de
+        // middlewares), la responsabilidad sigue hasta Express —o hasta un error
+        // handler que la aplicación haya montado después del router—, que no
+        // reproduce err.message en producción.
+        if (!errorMiddleware)
+            return next(err);
         errorMiddleware(err, req, res, next);
     };
 }
-/**
- * Error middleware por defecto
- */
-const defaultErrorMiddleware = (err, _req, res, _next) => {
-    console.error(err);
-    if (process.env.NODE_ENV !== 'production') {
-        console.warn('No custom error handler configured. Add errorMiddleware export to your page or middleware file.');
-    }
-    res.status(500).send(err.message || 'Internal Server Error');
-};
 /**
  * Creates a dynamic middleware handler that reloads middlewares on each request in development
  * This enables HMR for middlewares
  * I FUCKING HATE THIS FUNCTION BUT IT SEEMS TO WORK
  */
-function createDynamicPageMiddlewares(pageRoute, pageFile, vite) {
-    return async (req, res, next) => {
-        try {
-            const middlewares = [
-                ...(await loadPageMiddlewares(pageRoute, vite)),
-                await getServerSidePropsAsMiddleware(pageFile, vite)
-            ];
-            // Execute middlewares sequentially
-            let currentIndex = 0;
-            const executeNext = (err) => {
-                if (err)
-                    return next(err);
-                const currentMiddleware = middlewares[currentIndex++];
-                if (!currentMiddleware)
-                    return next();
-                currentMiddleware(req, res, executeNext);
-            };
-            executeNext();
-        }
-        catch (error) {
-            next(error);
-        }
-    };
-}
 /**
  * 1. Resuelve middlewares previos al getServerSideProps
  */
-async function getPagePrevMiddlewares(pageRoute, vite) {
-    return await loadPageMiddlewares(pageRoute, vite);
+async function getPagePrevMiddlewares(pageRoute, loader) {
+    return await loadPageMiddlewares(pageRoute, loader);
 }
 /**
  * 2. Convierte getServerSideProps a middleware
  */
-async function getServerSidePropsAsMiddleware(pageFile, vite) {
-    const pageModule = await loadPageModule(pageFile, vite);
-    return pageModule ? createGetServerSidePropsMiddleware(pageModule) : (_req, _res, next) => next();
+async function getServerSidePropsAsMiddleware(pageFile, loader) {
+    const pageModule = await loadPageModule(pageFile, loader);
+    return pageModule ? createGetServerSidePropsMiddleware(pageModule, pageFile) : (_req, _res, next) => next();
 }
 /**
  * 3. Error middleware con fallback automático y jerarquía
@@ -282,46 +301,44 @@ async function getServerSidePropsAsMiddleware(pageFile, vite) {
  * 2. errorMiddleware en [page].middlewares.ts
  * 3. errorMiddleware en carpeta/middlewares.ts
  * 4. errorMiddleware en root middlewares.ts (más general)
- * 5. defaultErrorMiddleware (fallback)
+ * 5. ninguno: null, para que el llamador delegue con next(err)
  */
-async function getErrorMiddleware(pageFile, vite) {
-    const pageModule = await loadPageModule(pageFile, vite);
+async function getErrorMiddleware(pageFile, loader, middlewares) {
+    const pageModule = await loadPageModule(pageFile, loader);
     // 1. Prioridad máxima: errorMiddleware en la página
     if (pageModule?.errorMiddleware) {
         return pageModule.errorMiddleware;
     }
     // 2-4. Buscar errorMiddleware en middlewares siguiendo jerarquía
-    const errorMiddleware = await findErrorMiddlewareInHierarchy(pageFile, vite);
+    const errorMiddleware = await findErrorMiddlewareInHierarchy(pageFile, loader, middlewares);
     if (errorMiddleware) {
         return errorMiddleware;
     }
-    // 5. Fallback al default
-    return defaultErrorMiddleware;
+    // 5. No hay ninguno declarado: que siga hasta Express
+    return null;
 }
 /**
  * Busca errorMiddleware en la jerarquía de middlewares
  * Desde el más específico (página) hasta el más general (root)
  */
-async function findErrorMiddlewareInHierarchy(pageFile, vite) {
+async function findErrorMiddlewareInHierarchy(pageFile, loader, middlewares) {
     // Obtener todos los middlewares que podrían aplicar a esta página
-    const allMiddlewares = getMiddlewares();
+    const allMiddlewares = middlewares ?? getMiddlewares();
     // Convertir pageFile a route para matching
-    let pageRoute = pageFile.replace(/^app\/pages/, '').replace(/\.(tsx|ts|jsx|js)$/, '');
+    // Sin `try` esto lanzaría desde el camino de error —el que atiende cuando algo
+    // ya falló—, y una página que no se pudo renderizar terminaría en una
+    // excepción sin manejar en vez de en la página de error.
+    let pageRoute;
+    try {
+        pageRoute = '/' + (0, module_extensions_1.pageIdOf)(pageFile);
+    }
+    catch {
+        pageRoute = '/' + pageFile.replace(/^app\/pages\//, '').replace(/\.[^./]+$/, '');
+    }
     pageRoute = pageRoute.replace(/\/index$/, '') || '/';
     // Filtrar middlewares relevantes para esta página
-    const relevantMiddlewares = allMiddlewares
-        .filter(mw => {
-        // Para page-specific middlewares: debe coincidir exactamente con la ruta
-        if (mw.type === 'page-specific') {
-            return mw.route === pageRoute;
-        }
-        // Para folder-global middlewares: la página debe estar en esa carpeta o subcarpeta
-        if (mw.route === '/')
-            return true; // root middleware applies to all
-        // Si el middleware está en una carpeta, debe aplicar a todas las páginas de esa carpeta
-        // Ejemplo: /error-test/middlewares.ts aplica a /error-test/index, /error-test/sub, etc.
-        return pageRoute.startsWith(mw.route + '/') || pageRoute === mw.route;
-    })
+    // El mismo alcance que la cadena: por segmentos, la raíz aplica a todo.
+    const relevantMiddlewares = middlewaresFor(allMiddlewares, pageRoute)
         .sort((a, b) => {
         // Ordenar por especificidad: mayor depth = más específico
         if (a.depth !== b.depth)
@@ -336,7 +353,7 @@ async function findErrorMiddlewareInHierarchy(pageFile, vite) {
     // Buscar errorMiddleware en orden de especificidad
     for (const middlewareInfo of relevantMiddlewares) {
         try {
-            const middlewareModule = await loadMiddlewareModule(middlewareInfo, vite);
+            const middlewareModule = await loadMiddlewareModule(middlewareInfo, loader);
             if (middlewareModule?.errorMiddleware) {
                 return middlewareModule.errorMiddleware;
             }
@@ -347,14 +364,15 @@ async function findErrorMiddlewareInHierarchy(pageFile, vite) {
     }
     return null;
 }
-// Cache for loaded middleware modules to avoid multiple ssrLoadModule calls
+// Caché de módulos de middleware. Sólo activa en producción: en desarrollo
+// cada rearmado del router debe volver a leerlos para reflejar los cambios.
 const middlewareModuleCache = new Map();
-// Cache for loaded page modules to avoid multiple ssrLoadModule calls
+// Caché de módulos de página. Sólo activa en producción, por el mismo motivo.
 const pageModuleCache = new Map();
 /**
  * Cargar un módulo de middleware específico
  */
-async function loadMiddlewareModule(middlewareInfo, vite) {
+async function loadMiddlewareModule(middlewareInfo, loader) {
     const isProduction = process.env.NODE_ENV === 'production';
     const cacheKey = `${middlewareInfo.file}-${process.env.NODE_ENV || 'development'}`;
     // Only use cache in production mode to allow HMR in development
@@ -362,18 +380,22 @@ async function loadMiddlewareModule(middlewareInfo, vite) {
         return middlewareModuleCache.get(cacheKey);
     }
     let moduleToLoad;
-    if (!isProduction && vite) {
-        moduleToLoad = await vite.ssrLoadModule(middlewareInfo.file);
+    if (isProduction && middlewareInfo.buildChunk) {
+        // El chunk que registró el build, no un nombre derivado de la fuente.
+        const moduleUrl = (0, module_1.resolveServerModule)({ pageId: middlewareInfo.file, server: { devId: middlewareInfo.file, buildChunk: middlewareInfo.buildChunk } }, { root: process.cwd(), isProduction: true, serverOutDir: environments_1.OUT_DIR.ssr });
+        // `resolveServerModule` devuelve una ruta absoluta: en Windows sólo se
+        // puede importar como URL `file://`.
+        moduleToLoad = await import(/* @vite-ignore */ (0, node_url_1.pathToFileURL)(moduleUrl).href);
+    }
+    else if (!isProduction && loader) {
+        moduleToLoad = await loader.load(middlewareInfo.file);
     }
     else {
-        // En producción, usar archivos compilados
-        // Vite transforms [param] to _param_ in compiled filenames
-        const compiledPath = middlewareInfo.file
-            .replace(/^app\/pages\//, 'dist/server/')
-            .replace(/\.ts$/, '.js')
-            .replace(/\[(\w+)\]/g, '_$1_'); // [photocardId] -> _photocardId_
-        const moduleUrl = node_path_1.default.resolve(compiledPath);
-        moduleToLoad = await Promise.resolve(`${moduleUrl}`).then(s => __importStar(require(s)));
+        // En producción se importa el artefacto compilado. La traducción del nombre
+        // es la misma que usa el resto del framework: antes esta copia sólo recortaba
+        // `.ts`, así que un middleware `.js` cargaba un archivo inexistente.
+        const moduleUrl = (0, prod_server_1.resolveServerModulePath)(middlewareInfo.file);
+        moduleToLoad = await import(/* @vite-ignore */ (0, node_url_1.pathToFileURL)(moduleUrl).href);
     }
     // Only cache in production mode
     if (isProduction) {

package/dist/helpers/page-config-merge.d.ts

@@ -0,0 +1,11 @@
+import type { PageConfig } from '../head/types';
+/**
+ * El documento de una petición: el `pageConfig` estático de la página como base
+ * y lo que devolvió `getServerSideProps` encima.
+ *
+ * Los campos de render no participan: se decidieron al armar la ruta y no son
+ * parte del documento.
+ */
+export declare function mergePageConfig(staticConfig: PageConfig | undefined, dynamicConfig: PageConfig | undefined): PageConfig | undefined;
+/** Los campos de render que alguien intentó fijar por petición. */
+export declare const RENDERING_FIELDS: readonly ["renderingMode", "revalidate", "expire", "hydrate", "searchParams"];

package/dist/helpers/page-config-merge.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RENDERING_FIELDS = void 0;
+exports.mergePageConfig = mergePageConfig;
+/** Qué hace que dos `<meta>` sean la misma declaración. */
+function metaIdentity(meta) {
+    for (const key of ['name', 'property', 'httpEquiv', 'http-equiv', 'charset', 'itemProp']) {
+        const value = meta[key];
+        if (value !== undefined)
+            return `${key === 'http-equiv' ? 'httpEquiv' : key}:${String(value).toLowerCase()}`;
+    }
+    return undefined;
+}
+function mergeHead(base, over) {
+    if (!base)
+        return over;
+    if (!over)
+        return base;
+    // Una `description` estática y otra calculada no son dos descripciones: la
+    // calculada reemplaza a la estática.
+    const replaced = new Set((over.meta ?? []).map(metaIdentity).filter(Boolean));
+    const concat = (a, b) => (a || b ? [...(a ?? []), ...(b ?? [])] : undefined);
+    const merged = {
+        ...base,
+        ...over,
+        meta: concat((base.meta ?? []).filter((m) => !replaced.has(metaIdentity(m))), over.meta),
+        link: concat(base.link, over.link),
+        script: concat(base.script, over.script),
+        style: concat(base.style, over.style),
+        noscript: concat(base.noscript, over.noscript),
+    };
+    for (const key of Object.keys(merged)) {
+        if (merged[key] === undefined)
+            delete merged[key];
+    }
+    return merged;
+}
+function mergeVariant(base, over) {
+    const merged = { ...base, ...over };
+    const head = mergeHead(base.head, over.head);
+    if (head)
+        merged.head = head;
+    if (base.htmlAttributes || over.htmlAttributes) {
+        merged.htmlAttributes = { ...base.htmlAttributes, ...over.htmlAttributes };
+    }
+    if (base.bodyAttributes || over.bodyAttributes) {
+        merged.bodyAttributes = { ...base.bodyAttributes, ...over.bodyAttributes };
+    }
+    return merged;
+}
+/**
+ * El documento de una petición: el `pageConfig` estático de la página como base
+ * y lo que devolvió `getServerSideProps` encima.
+ *
+ * Los campos de render no participan: se decidieron al armar la ruta y no son
+ * parte del documento.
+ */
+function mergePageConfig(staticConfig, dynamicConfig) {
+    const base = documentOf(staticConfig);
+    const over = documentOf(dynamicConfig);
+    if (!base)
+        return over;
+    if (!over)
+        return base;
+    const merged = mergeVariant(base, over);
+    if (base.variants || over.variants) {
+        const variants = { ...base.variants };
+        for (const [name, variant] of Object.entries(over.variants ?? {})) {
+            variants[name] = variants[name] ? mergeVariant(variants[name], variant) : variant;
+        }
+        merged.variants = variants;
+    }
+    return merged;
+}
+/** Los campos de render que alguien intentó fijar por petición. */
+exports.RENDERING_FIELDS = ['renderingMode', 'revalidate', 'expire', 'hydrate', 'searchParams'];
+function documentOf(config) {
+    if (!config)
+        return undefined;
+    const document = { ...config };
+    for (const field of exports.RENDERING_FIELDS)
+        delete document[field];
+    return document;
+}

package/dist/helpers/request-handler.d.ts

@@ -1,4 +1,5 @@
-import { ViteConfig } from './vite-config';
+import type { RessRuntime } from '../runtime/dev-server';
+import type { RequestPlatform } from '../isr/key';
 export interface RequestContext {
     req: any;
     res: any;
@@ -12,6 +13,18 @@ export interface RouterConfig {
         platform: string;
         req: any;
     }) => Promise<string>;
-    viteConfig: ViteConfig;
+    viteConfig: RessRuntime;
 }
+type PlatformContext = RequestPlatform;
+export declare function resolveRequestPlatform(req: any, enablePlatformDetection?: boolean): PlatformContext;
+/**
+ * Arma el render server a partir de la config de la ruta.
+ *
+ * `viteConfig` puede llegar como thunk (modo automático: el runtime se
+ * resuelve después de crear el router), por eso se resuelve acá y no al
+ * armar `RouterConfig`. Se llama una sola vez por middleware: quien la usa
+ * cachea el resultado en su propio closure.
+ */
+export declare function buildRenderServer(config: RouterConfig): any;
 export declare function processRequest(context: RequestContext, config: RouterConfig, renderServer?: any): Promise<void>;
+export {};