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

package/dist/helpers/request-handler.js

@@ -1,52 +1,102 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRequestPlatform = resolveRequestPlatform;
+exports.buildRenderServer = buildRenderServer;
 exports.processRequest = processRequest;
-const promises_1 = __importDefault(require("node:fs/promises"));
-const pages_1 = require("../pages");
 const render_1 = require("../render");
 const platform_1 = require("../platform");
 const html_generator_1 = require("./html-generator");
-async function preparePlatform(req, enablePlatformDetection = true, isProduction = false) {
+const assets_1 = require("@ressjs/assets");
+const resolve_1 = require("../variants/resolve");
+const platform_tokens_1 = require("../variants/platform-tokens");
+const security_1 = require("../security");
+const template_1 = require("../runtime/template");
+const resolve_2 = require("../head/resolve");
+const page_config_merge_1 = require("./page-config-merge");
+const dev_styles_1 = require("../runtime/dev-styles");
+function resolveRequestPlatform(req, enablePlatformDetection = true) {
     if (!enablePlatformDetection) {
         return {
             platform: 'desktop',
             platformInfo: null
         };
     }
-    const userAgent = req.headers['user-agent'] || '';
-    const platformInfo = (0, platform_1.detectPlatform)(userAgent, req.headers);
+    // R-10: la detección usa siempre el User-Agent. Es la única señal disponible
+    // para un cliente que no manda cabeceras propias ni pistas del navegador —un
+    // Safari de iPhone o un televisor Tizen sin app nativa detrás—, y no se
+    // declara en `Vary` (ver `security/headers.ts`), así que no hay nada que
+    // apagar por cacheabilidad.
+    const platformInfo = (0, platform_1.detect)({
+        userAgent: req.headers['user-agent'] || '',
+        headers: req.headers,
+    });
     const platform = (platformInfo.device === 'phone' || platformInfo.device === 'tablet') ? 'mobile' : 'desktop';
-    if (!isProduction && platformInfo) {
-        await (0, pages_1.generateTempEntries)('dist', platformInfo);
-    }
     return { platform, platformInfo };
 }
+/**
+ * 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.
+ */
+function buildRenderServer(config) {
+    const resolvedViteConfig = typeof config.viteConfig === 'function'
+        ? config.viteConfig()
+        : config.viteConfig;
+    const options = config.security ?? (0, security_1.resolveSecurityOptions)(config.securityOptions);
+    return (0, render_1.createRenderServer)({
+        ...(resolvedViteConfig.moduleLoader ? { moduleLoader: resolvedViteConfig.moduleLoader } : {}),
+        clientProps: options.clientProps,
+        isProduction: resolvedViteConfig.isProduction,
+    });
+}
 async function processRequest(context, config, renderServer) {
     const { req, res, page, next } = context;
-    // config.viteConfig can be a ViteConfig or a thunk returning it (auto mode)
+    // En modo automático el runtime llega como thunk, porque se resuelve después de crear el router.
     const resolvedViteConfig = typeof config.viteConfig === 'function'
         ? config.viteConfig()
         : config.viteConfig;
     const { enablePlatformDetection, renderFunction } = config;
     const viteConfig = resolvedViteConfig;
+    const options = config.security ?? (0, security_1.resolveSecurityOptions)(config.securityOptions);
+    // El nonce se genera una vez por petición, antes del render, y viaja hasta el
+    // documento y hasta la cabecera: así el valor del atributo y el de la política
+    // son el mismo por construcción y no por coincidencia.
+    // Por qué ejes varía esta página. Decide dos cosas que tienen que coincidir:
+    // qué se declara en `Vary` y qué del cliente puede escribirse en el documento.
+    const pageVariants = page?.pageId
+        ? (viteConfig.catalog?.variantsByPage.get(page.pageId) ?? [])
+        : [];
+    const varyBy = (0, resolve_1.varyingAxes)(pageVariants);
+    const security = {
+        isProduction: viteConfig.isProduction,
+        options,
+        route: page?.route ?? req.url ?? '',
+        varyBy,
+        ...(options.csp.enabled ? { nonce: (0, security_1.createNonce)() } : {}),
+    };
     try {
-        const platformContext = await preparePlatform(req, enablePlatformDetection, viteConfig.isProduction);
+        // La caché incremental ya la resolvió para armar su clave: volver a
+        // detectarla podría dar otra respuesta y guardar un documento bajo la
+        // plataforma equivocada.
+        const platformContext = req.ressPlatform
+            ?? resolveRequestPlatform(req, enablePlatformDetection);
+        // Lo que devolvió `getServerSideProps` gana sobre el export estático.
+        const hydrate = req.ressPageRendering?.hydrate ?? page?.config?.hydrate !== false;
         if (renderFunction) {
             const html = await renderFunction({
                 url: req.url,
                 platform: platformContext.platform,
                 req
             });
-            res.setHeader('Content-Type', 'text/html');
+            res.setHeader('Content-Type', 'text/html; charset=utf-8');
             res.send(html);
             return;
         }
         if (!renderServer) {
-            const renderOptions = viteConfig.vite ? { vite: viteConfig.vite } : {};
-            renderServer = (0, render_1.createRenderServer)(renderOptions);
+            renderServer = buildRenderServer(config);
         }
         const protocol = req.headers['x-forwarded-proto'] || (req.connection?.encrypted ? 'https' : 'http');
         const host = req.headers.host || 'localhost';
@@ -56,38 +106,125 @@ async function processRequest(context, config, renderServer) {
         if (!res.locals) {
             res.locals = {};
         }
+        // El catálogo se resolvió al arrancar. Dejamos los enlaces en el scope de
+        // esta petición para que middlewares puedan inspeccionarlos o ajustarlos,
+        // sin volver a consultar el filesystem durante el render.
+        if (!res.locals.styles && page?.pageId && viteConfig.catalog && viteConfig.assets) {
+            res.locals.styles = (0, assets_1.resolvePageAssets)(page.pageId, platformContext.platformInfo ?? platform_1.DEFAULT_PLATFORM, viteConfig.catalog, viteConfig.assets);
+        }
+        const pageLocals = { ...res.locals };
+        delete pageLocals.styles;
         const rendered = await renderServer({
             url: pathname,
             req,
             res,
-            props: res.locals.serverSideProps
+            props: res.locals.serverSideProps,
+            // `styles` pertenece al pipeline interno de assets; no se mezcla con los
+            // locals que la página recibe ni se considera estado serializable.
+            locals: pageLocals,
+            hydrate,
+            // La página ya la resolvió el despachador: buscarla de nuevo por URL sería
+            // una segunda resolución con otro criterio.
+            page,
         });
         const template = await getTemplate(req, viteConfig);
+        const pageHead = (0, resolve_2.resolvePageHead)((0, page_config_merge_1.mergePageConfig)(page?.config, res.locals?.pageConfig), rendered.head, platformContext.platformInfo);
         const html = await (0, html_generator_1.generateCompleteHTML)({
             template,
             rendered,
             page,
-            manifest: viteConfig.manifest,
             platform: platformContext.platform,
             isProduction: viteConfig.isProduction,
             platformInfo: platformContext.platformInfo,
-            // pasar solo la config segura
-            ...(res.locals?.htmlConfig ? { serverSideResult: res.locals.htmlConfig } : {})
+            catalog: viteConfig.catalog,
+            assets: viteConfig.assets,
+            styles: hydrate || viteConfig.isProduction
+                ? res.locals.styles
+                : withDevStyles(res.locals.styles, viteConfig.vite, page?.file),
+            pageHead,
+            hydrate,
+        }, security);
+        warnIfStateTooLarge(rendered.props, security);
+        // Las cabeceras van antes del cuerpo: después de la primera escritura ya no
+        // se pueden cambiar, y el intento lanza una excepción que tapa el error real.
+        (0, security_1.applySecurityHeaders)(res, options, {
+            isProduction: viteConfig.isProduction,
+            varyBy: platformContext.platformInfo ? varyBy : null,
+            edge: platform_tokens_1.defaultPlatformRegistry.edge,
+            nonce: security.nonce,
+            kind: 'html',
         });
-        res.setHeader('Content-Type', 'text/html');
+        if (pageHead.robots)
+            res.setHeader('X-Robots-Tag', pageHead.robots);
+        if (options.csp.enabled && security.nonce) {
+            const header = (0, security_1.cspHeaderName)(options.csp);
+            const existing = res.getHeader(header);
+            // Una política que escribió la aplicación se respeta: sus dominios y sus
+            // proveedores son decisión suya. Lo único que se le agrega es el nonce,
+            // sin el cual el bloque de estado no se ejecuta y la página no hidrata.
+            res.setHeader(header, existing
+                ? (0, security_1.injectNonce)(String(existing), security.nonce)
+                : (0, security_1.buildCsp)(options.csp, security.nonce, viteConfig.isProduction));
+            // `report-to` nombra un grupo: sin la cabecera que lo define, los informes
+            // de violación no llegan a ningún lado.
+            if (options.csp.reportUri && res.getHeader('Reporting-Endpoints') === undefined) {
+                res.setHeader('Reporting-Endpoints', (0, security_1.reportingEndpointsHeader)(options.csp.reportUri));
+            }
+        }
         res.send(html);
     }
     catch (error) {
-        console.error(`Error handling ${req.url}:`, error);
-        if (viteConfig.vite?.ssrFixStacktrace) {
-            viteConfig.vite.ssrFixStacktrace(error);
-        }
-        next(error);
+        const publicError = (0, security_1.sanitizeError)(error, viteConfig.isProduction);
+        (0, security_1.logServerError)(error, { method: req.method, url: req.url, statusCode: publicError.statusCode });
+        (0, security_1.applySecurityHeaders)(res, options, {
+            isProduction: viteConfig.isProduction,
+            kind: 'error',
+        });
+        next(Object.assign(new Error(publicError.message), publicError));
     }
 }
+/**
+ * Avisa cuando el estado que viaja es grande.
+ *
+ * En desarrollo, en cada petición y con las claves más pesadas —eso es lo que
+ * hace accionable el aviso—. En producción, una sola vez por ruta: un aviso por
+ * petición inunda los logs y deja de leerse.
+ */
+const warnedOversizeRoutes = new Set();
+function warnIfStateTooLarge(props, security) {
+    const { options, isProduction, route } = security;
+    const check = (0, security_1.checkStateSize)((0, security_1.serializeState)(props ?? {}), options.maxStateBytes, props);
+    if (!check.overLimit)
+        return;
+    const kib = (n) => `${(n / 1024).toFixed(1)} KiB`;
+    const detail = check.heaviest.length
+        ? ` Lo más pesado: ${check.heaviest.map((h) => `${h.key} (${kib(h.bytes)})`).join(', ')}.`
+        : '';
+    const message = `[ress] ${route}: el estado que viaja al cliente pesa ${kib(check.bytes)}, ` +
+        `sobre un límite de ${kib(options.maxStateBytes)}.${detail}`;
+    if (options.onStateOverLimit === 'error')
+        throw new Error(message);
+    if (isProduction) {
+        if (warnedOversizeRoutes.has(route))
+            return;
+        warnedOversizeRoutes.add(route);
+    }
+    console.warn(message);
+}
+/**
+ * Una página que no hidrata, en desarrollo, enlaza sus hojas directamente: el
+ * módulo que normalmente las inyecta no se carga.
+ */
+function withDevStyles(styles, vite, pageFile) {
+    if (!styles)
+        return styles;
+    const prefix = styles.js.includes('/@id/') ? styles.js.slice(0, styles.js.indexOf('/@id/')) : '';
+    const css = [...new Set([...styles.css, ...(styles.devStyles ?? []), ...(0, dev_styles_1.devModuleStyles)(vite, pageFile, prefix)])];
+    return { ...styles, css };
+}
 async function getTemplate(req, viteConfig) {
     if (!viteConfig.isProduction) {
-        const template = await promises_1.default.readFile('./index.html', 'utf-8');
+        const template = await (0, template_1.readTemplateHtml)();
         return viteConfig.vite ? await viteConfig.vite.transformIndexHtml(req.url, template) : template;
     }
     else {

package/dist/index.d.ts

@@ -1,7 +1,39 @@
-export { createViteRouter, createAutoViteServer, listDetectedPages, getPages } from './router';
-export { getViteInput, getViteSSRInput, getClientEntriesInput, generateTempEntries, resolvePlatformCSS } from './pages';
+export { createViteRouter, waitForViteRouter, getPages } from './router';
+export { getViteSSRInput } from './pages';
+export { createRouteManifest, serializeRouteManifest, loadRouteManifest } from './routes/manifest';
+export { resolveServerModule } from './routes/module';
+export type { ResolveServerModuleContext } from './routes/module';
+export { scanRoutes } from './routes/scan';
+export type { PageId, RouteEntry, RouteEntryKind, RouteManifest, RouteManifestData, RouteMatch, RouteSegment, SegmentKind, } from './routes/types';
+export { ROUTE_MANIFEST_VERSION } from './routes/types';
+export { defineEnvironments, OUT_DIR } from './plugin/environments';
+export { ressPlugin, ressCorePlugin, refreshVariantCatalog, getVariantCatalog } from './plugin/index';
+export type { RessPlugin, RessPluginOptions } from './plugin/index';
+export { createDevModuleLoader, createProdModuleLoader, } from './runtime/module-loader';
+export type { FetchableEnvironment, ModuleLoader } from './runtime/module-loader';
+export { createRuntime, resolveServerModulePath, resolveProductionModuleId, } from './runtime/prod-server';
+export { resolveSsrEnvironment } from './runtime/dev-server';
+export type { DevRuntimeOptions, RessRuntime } from './runtime/dev-server';
+export { DEFAULT_EXCLUSIONS, isPageFile, pageExclusionOf, scriptExtensionOf, SCRIPT_EXTENSIONS, } from './fs/module-extensions';
+export type { PageExclusion } from './fs/module-extensions';
+export { buildVariantCatalog, pageIdFromFile } from './variants/catalog';
+export { resolveVariant, explainResolution } from './variants/resolve';
+export { defaultPlatformRegistry } from './variants/platform-tokens';
+export type { VariantCatalog, BuildEntry, Variant, AssetIndex, PlatformRegistry } from './variants/types';
 export { createRenderServer } from './render';
 export { detectPlatform } from './platform';
 export type { PlatformInfo } from './platform';
-export type { ViteRouterOptions, AutoViteServerOptions } from './router';
+export type { ViteRouterOptions } from './router';
 export type { PageInfo } from './pages';
+export type { PageConfig, PageConfigVariant, PageHeadConfig, PageRenderingConfig, RenderingMode, RobotsConfig, } from './head/types';
+export type { ServerSideResult } from './helpers/middlewares';
+export { PublicFacingError, resolveSecurityOptions, serializeState, applySecurityHeaders, } from './security';
+export type { ClientPropsPolicy, PublicError, ResolvedSecurityOptions, SecurityOptions, } from './security';
+/**
+ * @deprecated Usá el manifest de rutas: `runtime.routes.entries`. Devuelve las
+ * páginas tal como las enumera el catálogo de variantes, que no conoce grupos ni
+ * catch-all. Se elimina cuando F-016 consuma el manifest.
+ */
+export { getPages as listDetectedPages } from './pages';
+export { defineConfig, loadConfig, createConfigMiddleware, compileRules, publicEnvDefines, withBasePath, assetPrefixFor, writeProjectTypes, } from './config';
+export type { RessConfig, ResolvedConfig, TrailingSlashMode, RessServerConfig } from './config';

package/dist/index.js

@@ -1,22 +1,91 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectPlatform = exports.createRenderServer = exports.resolvePlatformCSS = exports.generateTempEntries = exports.getClientEntriesInput = exports.getViteSSRInput = exports.getViteInput = exports.getPages = exports.listDetectedPages = exports.createAutoViteServer = exports.createViteRouter = void 0;
+exports.writeProjectTypes = exports.assetPrefixFor = exports.withBasePath = exports.publicEnvDefines = exports.compileRules = exports.createConfigMiddleware = exports.loadConfig = exports.defineConfig = exports.listDetectedPages = exports.applySecurityHeaders = exports.serializeState = exports.resolveSecurityOptions = exports.PublicFacingError = exports.detectPlatform = exports.createRenderServer = exports.defaultPlatformRegistry = exports.explainResolution = exports.resolveVariant = exports.pageIdFromFile = exports.buildVariantCatalog = exports.SCRIPT_EXTENSIONS = exports.scriptExtensionOf = exports.pageExclusionOf = exports.isPageFile = exports.DEFAULT_EXCLUSIONS = exports.resolveSsrEnvironment = exports.resolveProductionModuleId = exports.resolveServerModulePath = exports.createRuntime = exports.createProdModuleLoader = exports.createDevModuleLoader = exports.getVariantCatalog = exports.refreshVariantCatalog = exports.ressCorePlugin = exports.ressPlugin = exports.OUT_DIR = exports.defineEnvironments = exports.ROUTE_MANIFEST_VERSION = exports.scanRoutes = exports.resolveServerModule = exports.loadRouteManifest = exports.serializeRouteManifest = exports.createRouteManifest = exports.getViteSSRInput = exports.getPages = exports.waitForViteRouter = exports.createViteRouter = void 0;
 // Main API
 var router_1 = require("./router");
 Object.defineProperty(exports, "createViteRouter", { enumerable: true, get: function () { return router_1.createViteRouter; } });
-Object.defineProperty(exports, "createAutoViteServer", { enumerable: true, get: function () { return router_1.createAutoViteServer; } });
-Object.defineProperty(exports, "listDetectedPages", { enumerable: true, get: function () { return router_1.listDetectedPages; } });
+Object.defineProperty(exports, "waitForViteRouter", { enumerable: true, get: function () { return router_1.waitForViteRouter; } });
 Object.defineProperty(exports, "getPages", { enumerable: true, get: function () { return router_1.getPages; } });
-// Core functions for Vite config
+// Entradas de build del entorno de servidor
 var pages_1 = require("./pages");
-Object.defineProperty(exports, "getViteInput", { enumerable: true, get: function () { return pages_1.getViteInput; } });
 Object.defineProperty(exports, "getViteSSRInput", { enumerable: true, get: function () { return pages_1.getViteSSRInput; } });
-Object.defineProperty(exports, "getClientEntriesInput", { enumerable: true, get: function () { return pages_1.getClientEntriesInput; } });
-Object.defineProperty(exports, "generateTempEntries", { enumerable: true, get: function () { return pages_1.generateTempEntries; } });
-Object.defineProperty(exports, "resolvePlatformCSS", { enumerable: true, get: function () { return pages_1.resolvePlatformCSS; } });
+// Rutas: manifest, escaneo y tipos (F-018). Superficie que F-033 (la CLI)
+// necesita para construir la aplicación y para `ress info`, sin duplicar la
+// enumeración que ya hace el framework.
+var manifest_1 = require("./routes/manifest");
+Object.defineProperty(exports, "createRouteManifest", { enumerable: true, get: function () { return manifest_1.createRouteManifest; } });
+Object.defineProperty(exports, "serializeRouteManifest", { enumerable: true, get: function () { return manifest_1.serializeRouteManifest; } });
+Object.defineProperty(exports, "loadRouteManifest", { enumerable: true, get: function () { return manifest_1.loadRouteManifest; } });
+var module_1 = require("./routes/module");
+Object.defineProperty(exports, "resolveServerModule", { enumerable: true, get: function () { return module_1.resolveServerModule; } });
+var scan_1 = require("./routes/scan");
+Object.defineProperty(exports, "scanRoutes", { enumerable: true, get: function () { return scan_1.scanRoutes; } });
+var types_1 = require("./routes/types");
+Object.defineProperty(exports, "ROUTE_MANIFEST_VERSION", { enumerable: true, get: function () { return types_1.ROUTE_MANIFEST_VERSION; } });
+// Runtime: entornos de build y directorios de salida (F-015/F-016). La CLI los
+// usa para `ress build` y para resolver dónde quedó el build en `ress info`.
+var environments_1 = require("./plugin/environments");
+Object.defineProperty(exports, "defineEnvironments", { enumerable: true, get: function () { return environments_1.defineEnvironments; } });
+Object.defineProperty(exports, "OUT_DIR", { enumerable: true, get: function () { return environments_1.OUT_DIR; } });
+var index_1 = require("./plugin/index");
+Object.defineProperty(exports, "ressPlugin", { enumerable: true, get: function () { return index_1.ressPlugin; } });
+Object.defineProperty(exports, "ressCorePlugin", { enumerable: true, get: function () { return index_1.ressCorePlugin; } });
+Object.defineProperty(exports, "refreshVariantCatalog", { enumerable: true, get: function () { return index_1.refreshVariantCatalog; } });
+Object.defineProperty(exports, "getVariantCatalog", { enumerable: true, get: function () { return index_1.getVariantCatalog; } });
+// Cargador de módulos: la vía de escape nivel 2 de F-033 carga el archivo de
+// servidor del proyecto con el mismo mecanismo que las páginas.
+var module_loader_1 = require("./runtime/module-loader");
+Object.defineProperty(exports, "createDevModuleLoader", { enumerable: true, get: function () { return module_loader_1.createDevModuleLoader; } });
+Object.defineProperty(exports, "createProdModuleLoader", { enumerable: true, get: function () { return module_loader_1.createProdModuleLoader; } });
+var prod_server_1 = require("./runtime/prod-server");
+Object.defineProperty(exports, "createRuntime", { enumerable: true, get: function () { return prod_server_1.createRuntime; } });
+Object.defineProperty(exports, "resolveServerModulePath", { enumerable: true, get: function () { return prod_server_1.resolveServerModulePath; } });
+Object.defineProperty(exports, "resolveProductionModuleId", { enumerable: true, get: function () { return prod_server_1.resolveProductionModuleId; } });
+var dev_server_1 = require("./runtime/dev-server");
+Object.defineProperty(exports, "resolveSsrEnvironment", { enumerable: true, get: function () { return dev_server_1.resolveSsrEnvironment; } });
+// Extensiones reconocidas (F-017), para quien necesita autodetectar un archivo
+// de servidor del proyecto con la misma política que las páginas.
+var module_extensions_1 = require("./fs/module-extensions");
+Object.defineProperty(exports, "DEFAULT_EXCLUSIONS", { enumerable: true, get: function () { return module_extensions_1.DEFAULT_EXCLUSIONS; } });
+Object.defineProperty(exports, "isPageFile", { enumerable: true, get: function () { return module_extensions_1.isPageFile; } });
+Object.defineProperty(exports, "pageExclusionOf", { enumerable: true, get: function () { return module_extensions_1.pageExclusionOf; } });
+Object.defineProperty(exports, "scriptExtensionOf", { enumerable: true, get: function () { return module_extensions_1.scriptExtensionOf; } });
+Object.defineProperty(exports, "SCRIPT_EXTENSIONS", { enumerable: true, get: function () { return module_extensions_1.SCRIPT_EXTENSIONS; } });
+// Catálogo de variantes de plataforma
+var catalog_1 = require("./variants/catalog");
+Object.defineProperty(exports, "buildVariantCatalog", { enumerable: true, get: function () { return catalog_1.buildVariantCatalog; } });
+Object.defineProperty(exports, "pageIdFromFile", { enumerable: true, get: function () { return catalog_1.pageIdFromFile; } });
+var resolve_1 = require("./variants/resolve");
+Object.defineProperty(exports, "resolveVariant", { enumerable: true, get: function () { return resolve_1.resolveVariant; } });
+Object.defineProperty(exports, "explainResolution", { enumerable: true, get: function () { return resolve_1.explainResolution; } });
+var platform_tokens_1 = require("./variants/platform-tokens");
+Object.defineProperty(exports, "defaultPlatformRegistry", { enumerable: true, get: function () { return platform_tokens_1.defaultPlatformRegistry; } });
 // Render functions
 var render_1 = require("./render");
 Object.defineProperty(exports, "createRenderServer", { enumerable: true, get: function () { return render_1.createRenderServer; } });
 // Platform detection
 var platform_1 = require("./platform");
 Object.defineProperty(exports, "detectPlatform", { enumerable: true, get: function () { return platform_1.detectPlatform; } });
+// Endurecimiento del renderizado en el servidor (F-019)
+var security_1 = require("./security");
+Object.defineProperty(exports, "PublicFacingError", { enumerable: true, get: function () { return security_1.PublicFacingError; } });
+Object.defineProperty(exports, "resolveSecurityOptions", { enumerable: true, get: function () { return security_1.resolveSecurityOptions; } });
+Object.defineProperty(exports, "serializeState", { enumerable: true, get: function () { return security_1.serializeState; } });
+Object.defineProperty(exports, "applySecurityHeaders", { enumerable: true, get: function () { return security_1.applySecurityHeaders; } });
+/**
+ * @deprecated Usá el manifest de rutas: `runtime.routes.entries`. Devuelve las
+ * páginas tal como las enumera el catálogo de variantes, que no conoce grupos ni
+ * catch-all. Se elimina cuando F-016 consuma el manifest.
+ */
+var pages_2 = require("./pages");
+Object.defineProperty(exports, "listDetectedPages", { enumerable: true, get: function () { return pages_2.getPages; } });
+// Configuración del proyecto (F-008)
+var config_1 = require("./config");
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return config_1.defineConfig; } });
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "createConfigMiddleware", { enumerable: true, get: function () { return config_1.createConfigMiddleware; } });
+Object.defineProperty(exports, "compileRules", { enumerable: true, get: function () { return config_1.compileRules; } });
+Object.defineProperty(exports, "publicEnvDefines", { enumerable: true, get: function () { return config_1.publicEnvDefines; } });
+Object.defineProperty(exports, "withBasePath", { enumerable: true, get: function () { return config_1.withBasePath; } });
+Object.defineProperty(exports, "assetPrefixFor", { enumerable: true, get: function () { return config_1.assetPrefixFor; } });
+Object.defineProperty(exports, "writeProjectTypes", { enumerable: true, get: function () { return config_1.writeProjectTypes; } });

package/dist/isr/capture.d.ts

@@ -0,0 +1,79 @@
+import { EventEmitter } from 'node:events';
+import type { Request, RequestHandler, Response } from 'express';
+import type { CapturedResponse, HeaderValue } from './types';
+type Headers = Record<string, HeaderValue>;
+/**
+ * Una respuesta sin socket.
+ *
+ * Implementa la parte de `express.Response` que usan el pipeline de render y
+ * `getServerSideProps`, y nada la conecta con la respuesta real: una generación
+ * en segundo plano no puede escribirle a un cliente que ya recibió su documento.
+ * La compresión tampoco la toca, así que lo que queda capturado es el HTML tal
+ * como lo produjo la página.
+ */
+export declare class CaptureResponse extends EventEmitter {
+    #private;
+    readonly req: Request;
+    private readonly onEnd?;
+    statusCode: number;
+    statusMessage: string;
+    locals: Record<string, unknown>;
+    constructor(req: Request, seed?: Headers, onEnd?: ((res: CaptureResponse) => void) | undefined);
+    get headersSent(): boolean;
+    get writableEnded(): boolean;
+    get finished(): boolean;
+    setHeader(name: string, value: unknown): this;
+    getHeader(name: string): HeaderValue | undefined;
+    getHeaders(): Headers;
+    getHeaderNames(): string[];
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    set(field: string | Record<string, unknown>, value?: unknown): this;
+    header(field: string | Record<string, unknown>, value?: unknown): this;
+    get(name: string): HeaderValue | undefined;
+    append(name: string, value: unknown): this;
+    vary(field: string): this;
+    status(code: number): this;
+    sendStatus(code: number): this;
+    type(value: string): this;
+    contentType(value: string): this;
+    location(url: string): this;
+    redirect(statusOrUrl: number | string, maybeUrl?: string): void;
+    cookie(name: string, value: unknown, options?: {
+        path?: string;
+        maxAge?: number;
+        httpOnly?: boolean;
+        secure?: boolean;
+        sameSite?: string;
+    }): this;
+    clearCookie(name: string, options?: {
+        path?: string;
+    }): this;
+    writeHead(status: number, headers?: Record<string, unknown>): this;
+    flushHeaders(): void;
+    write(chunk: unknown): boolean;
+    end(chunk?: unknown): this;
+    send(body?: unknown): this;
+    json(body: unknown): this;
+    /** Lo que se escribió, sin las cabeceras de transporte. */
+    snapshot(): CapturedResponse;
+}
+/**
+ * Ejecuta la cadena de render contra una respuesta sintética.
+ *
+ * Resuelve con lo capturado; con `null` si la cadena terminó sin responder
+ * (la ruta la atiende otro); rechaza con el error que la cadena propagó.
+ */
+export declare function runCaptured(chain: readonly RequestHandler[], req: Request, seed: Headers): Promise<CapturedResponse | null>;
+/**
+ * Lo que la generación agregó o cambió respecto de la semilla.
+ *
+ * La semilla son las cabeceras que la respuesta real ya tenía —las de los
+ * middlewares—, y esas se recalculan en cada petición: guardarlas congelaría las
+ * de un visitante para todos. De `Vary` se guardan sólo los campos nuevos.
+ */
+export declare function headerDelta(seed: Headers, produced: Headers): Headers;
+export declare function varyFields(value: HeaderValue | undefined): string[];
+/** Las cabeceras de la respuesta real, normalizadas, sin cookies. */
+export declare function seedFrom(res: Response): Headers;
+export {};