@ressjs/vite-router 0.5.0 → 0.6.0-experimental.0

package/dist/helpers/html-generator.js

@@ -1,130 +1,93 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateClientScript = generateClientScript;
-exports.generateClientCSS = generateClientCSS;
+exports.resolvePageAssets = void 0;
 exports.generateCompleteHTML = generateCompleteHTML;
-const promises_1 = __importDefault(require("node:fs/promises"));
-async function generateClientScript(pageFile, platformInfo, manifest, isProduction) {
-    // Sanitizar nombre: convertir [id] a _id_ para nombres de archivo (igual que en pages.ts)
-    const rel = pageFile
-        .replace(/^app\/pages\//, '')
-        .replace(/\.tsx$|\.jsx$/, '')
-        .replace(/\//g, '__')
-        .replace(/\[([^\]]+)\]/g, '_$1_');
-    let entryKey = `${rel}__entry-client.tsx`;
-    if (platformInfo && platformInfo.device !== 'desktop') {
-        // Priority order (from highest to lowest):
-        const priorities = [
-            // 1. Specific: device.os.tsx
-            `${rel}__entry-client.${platformInfo.device}.${platformInfo.os}.tsx`,
-            // 2. DeviceType: device.tsx
-            `${rel}__entry-client.${platformInfo.device}.tsx`,
-            // 3. Mobile Fallback: mobile.tsx (only for phone/tablet)
-            ...(platformInfo.device === 'phone' || platformInfo.device === 'tablet'
-                ? [`${rel}__entry-client.mobile.tsx`]
-                : []),
-            // 4. OS General: os.tsx
-            `${rel}__entry-client.${platformInfo.os}.tsx`
-        ];
-        // Find first existing entry following priority order
-        for (const candidate of priorities) {
-            if (isProduction) {
-                // In production, check manifest
-                const manifestKey = `dist/.entries/${candidate}`;
-                if (manifest[manifestKey]) {
-                    entryKey = candidate;
-                    break;
-                }
-            }
-            else {
-                // In development, check if physical file exists
-                try {
-                    await promises_1.default.access(`dist/.entries/${candidate}`);
-                    entryKey = candidate;
-                    break;
-                }
-                catch {
-                    // File doesn't exist, continue to next priority
-                }
-            }
-        }
-    }
-    if (!isProduction) {
-        return `/dist/.entries/${entryKey}`;
-    }
-    else {
-        const chunk = manifest[`dist/.entries/${entryKey}`];
-        return chunk ? `/${chunk.file}` : null;
-    }
+const platform_1 = require("../platform");
+const security_1 = require("../security");
+const assets_1 = require("@ressjs/assets");
+var assets_2 = require("@ressjs/assets");
+Object.defineProperty(exports, "resolvePageAssets", { enumerable: true, get: function () { return assets_2.resolvePageAssets; } });
+/**
+ * Plataforma que se asume cuando la detección está desactivada.
+ *
+ * Es la misma que produce el pipeline cuando nadie declaró nada, de modo que
+ * apagar la detección y recibir una petición anónima den el mismo resultado.
+ */
+function fallbackPlatform() {
+    return platform_1.DEFAULT_PLATFORM;
 }
-function generateClientCSS(pageFile, platformInfo, manifest, isProduction) {
-    if (!isProduction || !pageFile) {
-        return '';
-    }
-    // Sanitizar nombre: convertir [id] a _id_ para nombres de archivo (igual que en pages.ts)
-    const rel = pageFile
-        .replace(/^app\/pages\//, '')
-        .replace(/\.tsx$|\.jsx$/, '')
-        .replace(/\//g, '__')
-        .replace(/\[([^\]]+)\]/g, '_$1_');
-    let entryKey = `dist/.entries/${rel}__entry-client.tsx`;
-    if (platformInfo && platformInfo.device !== 'desktop') {
-        // Priority order (from highest to lowest):
-        const priorities = [
-            // 1. Specific: device.os.tsx
-            `dist/.entries/${rel}__entry-client.${platformInfo.device}.${platformInfo.os}.tsx`,
-            // 2. DeviceType: device.tsx
-            `dist/.entries/${rel}__entry-client.${platformInfo.device}.tsx`,
-            // 3. Mobile Fallback: mobile.tsx (only for phone/tablet)
-            ...(platformInfo.device === 'phone' || platformInfo.device === 'tablet'
-                ? [`dist/.entries/${rel}__entry-client.mobile.tsx`]
-                : []),
-            // 4. OS General: os.tsx
-            `dist/.entries/${rel}__entry-client.${platformInfo.os}.tsx`
-        ];
-        // Find first existing entry following priority order
-        for (const candidate of priorities) {
-            if (manifest[candidate]) {
-                entryKey = candidate;
-                break;
-            }
-        }
-    }
-    const entryChunk = manifest[entryKey];
-    if (entryChunk && entryChunk.css) {
-        return entryChunk.css.map((cssFile) => `<link rel="stylesheet" href="/${cssFile}">`).join('');
-    }
-    return '';
-}
-async function generateCompleteHTML(context) {
-    const { template, rendered, page, manifest, isProduction, platformInfo, serverSideResult } = context;
-    const scriptSrc = await generateClientScript(page.file, platformInfo, manifest, isProduction);
-    const scriptTag = scriptSrc ? `<script type="module" src="${scriptSrc}"></script>` : '';
-    const cssLinks = page?.file ? generateClientCSS(page.file, platformInfo, manifest, isProduction) : '';
-    // Construir contenido HEAD extra y atributos desde serverSideResult
+async function generateCompleteHTML(context, security) {
+    const { template, rendered, page, platformInfo, serverSideResult, catalog, assets } = context;
+    const ctx = security ?? {
+        isProduction: context.isProduction,
+        options: (0, security_1.resolveSecurityOptions)(),
+        route: page?.route ?? '',
+    };
+    const escapeCtx = { where: '', isProduction: ctx.isProduction, route: ctx.route };
+    const nonce = ctx.nonce;
+    const platform = platformInfo ?? fallbackPlatform();
+    const resolved = context.styles ?? (catalog && assets && page?.pageId
+        ? (0, assets_1.resolvePageAssets)(page.pageId, platform, catalog, assets)
+        : { js: '', css: [] });
+    const scriptTag = resolved.js
+        ? `<script type="module"${nonceAttr(nonce)} src="${(0, security_1.escapeAttrValue)(resolved.js)}"></script>`
+        : '';
+    const cssLinks = resolved.css
+        .map((href) => `<link rel="stylesheet" href="${(0, security_1.escapeAttrValue)(href)}">`)
+        .join('');
     let headContent = cssLinks;
     let htmlAttributes = '';
     let bodyAttributes = '';
     let pageTitle = '';
     if (serverSideResult?.html) {
         if (serverSideResult.html.head?.attributes) {
-            htmlAttributes = Object.entries(serverSideResult.html.head.attributes)
-                .map(([k, v]) => `${k}="${v}"`).join(' ');
+            htmlAttributes = (0, security_1.renderAttrs)(serverSideResult.html.head.attributes, {
+                ...escapeCtx,
+                where: '<html>',
+            });
         }
         if (serverSideResult.html.body?.attributes) {
-            bodyAttributes = Object.entries(serverSideResult.html.body.attributes)
-                .map(([k, v]) => `${k}="${v}"`).join(' ');
+            bodyAttributes = (0, security_1.renderAttrs)(serverSideResult.html.body.attributes, {
+                ...escapeCtx,
+                where: '<body>',
+            });
         }
         if (serverSideResult.html.head?.extraTags) {
-            headContent += '\n' + serverSideResult.html.head.extraTags.join('\n');
-        }
-        if (serverSideResult.title || serverSideResult.html.head?.title) {
-            pageTitle = `<title>${serverSideResult.title || serverSideResult.html.head?.title}</title>`;
+            headContent +=
+                '\n' +
+                    (0, security_1.renderHeadTags)(normalizeHeadTags(serverSideResult.html.head.extraTags), escapeCtx, {
+                        allowScriptTags: ctx.options.head.allowScriptTags,
+                        extraAllowlist: ctx.options.head.extraTagAllowlist,
+                        nonce,
+                    });
         }
+        const title = serverSideResult.title || serverSideResult.html.head?.title;
+        if (title)
+            pageTitle = `<title>${(0, security_1.escapeHtmlText)(title)}</title>`;
     }
+    // La plataforma sólo se escribe si la página varía por algo. Si no varía, el
+    // documento tiene que ser idéntico para todos —es lo que lo hace cacheable— y
+    // el cliente la detecta por su cuenta.
+    const varies = (ctx.varyBy?.length ?? 0) > 0;
+    const platformTravels = ctx.options.serializePlatform === 'always' ||
+        (ctx.options.serializePlatform === 'auto' && varies);
+    // El estado que viaja. `__RESS_PAGE__` sólo en desarrollo: es una ruta del
+    // sistema de archivos del proyecto y no le aporta nada al cliente.
+    const blocks = [
+        ...(platformTravels ? [{ varName: '__RESS_PLATFORM__', value: platform }] : []),
+        { varName: '__RESS_PROPS__', value: rendered.props || {} },
+        { varName: '__RESS_ROUTE__', value: page?.route ?? '' },
+        // Alias del modelo anterior. Se emiten una versión más para no romper a
+        // quien los lea hoy.
+        { varName: '__INITIAL_PROPS__', value: rendered.props || {} },
+        { varName: '__PAGE_ROUTE__', value: page?.route ?? '' },
+        ...(ctx.isProduction
+            ? []
+            : [
+                { varName: '__RESS_PAGE__', value: page?.file ?? '' },
+                { varName: '__PAGE_FILE__', value: page?.file ?? '' },
+            ]),
+    ];
     let html = template;
     if (htmlAttributes)
         html = html.replace('<html', `<html ${htmlAttributes}`);
@@ -132,15 +95,21 @@ async function generateCompleteHTML(context) {
         html = html.replace('<body', `<body ${bodyAttributes}`);
     if (pageTitle)
         html = html.replace(/<title>.*?<\/title>/i, pageTitle);
-    html = html
+    return html
         .replace('<!--app-head-->', headContent)
         .replace('<!--app-html-->', rendered.html)
-        .replace('</body>', `<script>
-        window.__INITIAL_PROPS__=${JSON.stringify(rendered.props || {})};
-        window.__PAGE_ROUTE__=${JSON.stringify(page.route)};
-        window.__PAGE_FILE__=${JSON.stringify(page.file)};
-      </script>
-      ${scriptTag}
-      </body>`);
-    return html;
+        .replace('</body>', `${(0, security_1.renderStateScript)(blocks, nonce)}${scriptTag}</body>`);
+}
+const nonceAttr = (nonce) => (nonce ? ` nonce="${(0, security_1.escapeAttrValue)(nonce)}"` : '');
+/**
+ * Acepta la forma estructurada y descarta el string de HTML crudo.
+ *
+ * Un array de strings no se puede filtrar sin analizar HTML, y analizarlo para
+ * decidir si es seguro es exactamente el problema que la lista de etiquetas
+ * admitidas evita. F-004 ya produce la forma estructurada.
+ */
+function normalizeHeadTags(tags) {
+    if (!Array.isArray(tags))
+        return [];
+    return tags.filter((t) => typeof t === 'object' && t !== null && typeof t.tag === 'string');
 }

package/dist/helpers/middlewares.d.ts

@@ -1,4 +1,5 @@
 import { Request, RequestHandler, Response } from 'express';
+import type { ModuleLoader } from '../runtime/module-loader';
 export interface MiddlewareInfo {
     route: string;
     file: string;
@@ -32,11 +33,11 @@ export declare function getMiddlewares(): MiddlewareInfo[];
 /**
  * Carga middlewares para una página específica y los convierte en middlewares de Express
  */
-export declare function loadPageMiddlewares(pageRoute: string, vite?: any): Promise<RequestHandler[]>;
+export declare function loadPageMiddlewares(pageRoute: string, loader?: ModuleLoader): Promise<RequestHandler[]>;
 /**
  * Carga el módulo completo de una página
  */
-export declare function loadPageModule(pageFile: string, vite?: any): Promise<PageModule | null>;
+export declare function loadPageModule(pageFile: string, loader?: ModuleLoader): Promise<PageModule | null>;
 /**
  * Convierte getServerSideProps en un middleware de Express
  */
@@ -45,21 +46,20 @@ export declare function createGetServerSidePropsMiddleware(pageModule: PageModul
  * Creates a unified error handler for a specific page route
  * This replaces the old createPageErrorMiddleware with a more useful approach
  */
-export declare function createPageErrorHandler(pageFile: string, vite?: any): (err: any, req: any, res: any, next: any) => Promise<void>;
+export declare function createPageErrorHandler(pageFile: string, loader?: ModuleLoader): (err: any, req: any, res: any, next: any) => Promise<void>;
 /**
  * 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
  */
-export declare function createDynamicPageMiddlewares(pageRoute: string, pageFile: string, vite?: any): RequestHandler;
 /**
  * 1. Resuelve middlewares previos al getServerSideProps
  */
-export declare function getPagePrevMiddlewares(pageRoute: string, vite?: any): Promise<RequestHandler[]>;
+export declare function getPagePrevMiddlewares(pageRoute: string, loader?: ModuleLoader): Promise<RequestHandler[]>;
 /**
  * 2. Convierte getServerSideProps a middleware
  */
-export declare function getServerSidePropsAsMiddleware(pageFile: string, vite?: any): Promise<RequestHandler>;
+export declare function getServerSidePropsAsMiddleware(pageFile: string, loader?: ModuleLoader): Promise<RequestHandler>;
 /**
  * 3. Error middleware con fallback automático y jerarquía
  * Orden de prioridad (el más específico gana):
@@ -69,4 +69,4 @@ export declare function getServerSidePropsAsMiddleware(pageFile: string, vite?:
  * 4. errorMiddleware en root middlewares.ts (más general)
  * 5. defaultErrorMiddleware (fallback)
  */
-export declare function getErrorMiddleware(pageFile: string, vite?: any): Promise<any>;
+export declare function getErrorMiddleware(pageFile: string, loader?: ModuleLoader): Promise<any>;

package/dist/helpers/middlewares.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 };
 };
@@ -41,25 +8,29 @@ 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"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
-const pages_1 = require("../pages");
+const prod_server_1 = require("../runtime/prod-server");
+const module_extensions_1 = require("../fs/module-extensions");
 /**
  * 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}');
+    // 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);
+    const globalFiles = fast_glob_1.default.sync(globalGlob);
     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({
@@ -72,8 +43,7 @@ function getMiddlewares() {
     }
     // 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({
@@ -89,7 +59,7 @@ function getMiddlewares() {
 /**
  * Carga middlewares para una página específica y los convierte en middlewares de Express
  */
-async function loadPageMiddlewares(pageRoute, vite) {
+async function loadPageMiddlewares(pageRoute, loader) {
     const allMiddlewares = getMiddlewares();
     // Filtrar middlewares relevantes para esta página usando jerarquía
     const relevantMiddlewares = allMiddlewares.filter(middleware => {
@@ -121,7 +91,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') {
@@ -138,7 +108,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 +117,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 */ moduleUrl);
         }
         const result = pageModule;
         // Only cache in production mode
@@ -217,9 +180,9 @@ function createGetServerSidePropsMiddleware(pageModule) {
  * 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) {
     return async (err, req, res, next) => {
-        const errorMiddleware = await getErrorMiddleware(pageFile, vite);
+        const errorMiddleware = await getErrorMiddleware(pageFile, loader);
         errorMiddleware(err, req, res, next);
     };
 }
@@ -238,41 +201,17 @@ const defaultErrorMiddleware = (err, _req, res, _next) => {
  * 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);
+async function getServerSidePropsAsMiddleware(pageFile, loader) {
+    const pageModule = await loadPageModule(pageFile, loader);
     return pageModule ? createGetServerSidePropsMiddleware(pageModule) : (_req, _res, next) => next();
 }
 /**
@@ -284,14 +223,14 @@ async function getServerSidePropsAsMiddleware(pageFile, vite) {
  * 4. errorMiddleware en root middlewares.ts (más general)
  * 5. defaultErrorMiddleware (fallback)
  */
-async function getErrorMiddleware(pageFile, vite) {
-    const pageModule = await loadPageModule(pageFile, vite);
+async function getErrorMiddleware(pageFile, loader) {
+    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);
     if (errorMiddleware) {
         return errorMiddleware;
     }
@@ -302,11 +241,20 @@ async function getErrorMiddleware(pageFile, vite) {
  * 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) {
     // Obtener todos los middlewares que podrían aplicar a esta página
     const allMiddlewares = 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
@@ -336,7 +284,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 +295,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,16 +311,15 @@ async function loadMiddlewareModule(middlewareInfo, vite) {
         return middlewareModuleCache.get(cacheKey);
     }
     let moduleToLoad;
-    if (!isProduction && vite) {
-        moduleToLoad = await vite.ssrLoadModule(middlewareInfo.file);
+    if (!isProduction && loader) {
+        moduleToLoad = await loader.load(middlewareInfo.file);
     }
     else {
-        // En producción, usar archivos compilados
-        const compiledPath = middlewareInfo.file
-            .replace(/^app\/pages\//, 'dist/server/')
-            .replace(/\.ts$/, '.js');
-        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 */ moduleUrl);
     }
     // Only cache in production mode
     if (isProduction) {

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

@@ -1,4 +1,4 @@
-import { ViteConfig } from './vite-config';
+import type { RessRuntime } from '../runtime/dev-server';
 export interface RequestContext {
     req: any;
     res: any;
@@ -12,6 +12,6 @@ export interface RouterConfig {
         platform: string;
         req: any;
     }) => Promise<string>;
-    viteConfig: ViteConfig;
+    viteConfig: RessRuntime;
 }
 export declare function processRequest(context: RequestContext, config: RouterConfig, renderServer?: any): Promise<void>;