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

package/dist/config/codegen.d.ts

@@ -1,4 +1,13 @@
 import type { PlatformConfig } from './types';
+/**
+ * Tipos generados a partir de lo que el proyecto declara.
+ *
+ * Sin esto, declarar un token de plataforma propio en `ress.config.ts` funciona
+ * en tiempo de ejecución pero el editor no lo conoce: el desarrollador escribe
+ * `'kaios'` y no recibe ni sugerencia ni error si lo escribe mal. Los archivos se
+ * generan, no se versionan, y se rehacen cuando cambia la configuración que los
+ * origina.
+ */
 /**
  * Amplía `PlatformValueMap` de `@ressjs/platform` con los tokens del proyecto.
  *
@@ -22,7 +31,7 @@ export declare function generateProjectConfigTypes(values: Record<string, unknow
  */
 export declare function writeGeneratedTypes(root: string, files: Record<string, string>): Promise<string[]>;
 /**
- * Genera `types/` para un proyecto cuya configuración ya se cargó con
+ * Genera `types/` sólo para proyectos con `tsconfig.json` cuya configuración se cargó con
  * `loadConfig`. La usan el plugin al arrancar y `ress info`, para que un
  * proyecto recién creado o un clon limpio tengan sus tipos sin levantar nada.
  */

package/dist/config/codegen.js

@@ -13,8 +13,6 @@ exports.writeProjectTypes = writeProjectTypes;
  * generan, no se versionan, y se rehacen cuando cambia la configuración que los
  * origina.
  */
-const BANNER = '// Generado por ress.js a partir de la configuración del proyecto.\n' +
-    '// No editar a mano ni versionar: se rehace en cada arranque.\n';
 /**
  * Amplía `PlatformValueMap` de `@ressjs/platform` con los tokens del proyecto.
  *
@@ -34,14 +32,13 @@ function generatePlatformTypes(platform) {
     if (byAxis.size === 0) {
         // Un archivo vacío igual se escribe: si el proyecto quitó sus tokens, dejar
         // el anterior mantendría en el autocompletado valores que ya no existen.
-        return BANNER + 'export {}\n';
+        return 'export {}\n';
     }
     const fields = [...byAxis.entries()]
         .sort(([a], [b]) => a.localeCompare(b))
         .map(([axis, tokens]) => `    ${axis}: ${tokens.map(quote).join(' | ')}`)
         .join('\n');
-    return (BANNER +
-        "declare module '@ressjs/platform' {\n" +
+    return ("declare module '@ressjs/platform' {\n" +
         '  interface PlatformValueMap {\n' +
         fields +
         '\n  }\n}\n\nexport {}\n');
@@ -55,10 +52,9 @@ function generatePlatformTypes(platform) {
 function generateProjectConfigTypes(values) {
     const keys = Object.keys(values).sort();
     if (keys.length === 0)
-        return BANNER + 'export {}\n';
+        return 'export {}\n';
     const fields = keys.map((key) => `    ${propertyName(key)}: ${typeOf(values[key])}`).join('\n');
-    return (BANNER +
-        "declare module '@ressjs/config' {\n" +
+    return ("declare module '@ressjs/config' {\n" +
         '  interface ProjectConfig {\n' +
         fields +
         '\n  }\n}\n\nexport {}\n');
@@ -118,11 +114,21 @@ async function writeGeneratedTypes(root, files) {
     return written;
 }
 /**
- * Genera `types/` para un proyecto cuya configuración ya se cargó con
+ * Genera `types/` sólo para proyectos con `tsconfig.json` cuya configuración se cargó con
  * `loadConfig`. La usan el plugin al arrancar y `ress info`, para que un
  * proyecto recién creado o un clon limpio tengan sus tipos sin levantar nada.
  */
 async function writeProjectTypes(root, platform) {
+    const { access } = await import('node:fs/promises');
+    const { join } = await import('node:path');
+    try {
+        await access(join(root, 'tsconfig.json'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
     const { resolved } = await import('@ressjs/config');
     return writeGeneratedTypes(root, {
         'ress-platform.d.ts': generatePlatformTypes(platform),

package/dist/config/env.d.ts

@@ -13,6 +13,8 @@ export interface PublicEnvOptions {
     env?: Record<string, string | undefined>;
     /** Si faltar una variable detiene el arranque. En build, sí. */
     strict?: boolean;
+    /** Dónde se informa una variable ausente cuando `strict` es falso. Por defecto, la consola. */
+    warn?: (message: string) => void;
 }
 export declare function publicEnvDefines(publicEnv: readonly string[], options?: PublicEnvOptions): Record<string, string>;
 /** Los valores publicados, para inspeccionarlos o serializarlos. */

package/dist/config/env.js

@@ -20,11 +20,14 @@ function publicEnvDefines(publicEnv, options = {}) {
         defines[`process.env.${name}`] = literal;
         defines[`import.meta.env.${name}`] = literal;
     }
-    if (missing.length && options.strict !== false) {
-        throw new Error(`[ress] \`publicEnv\` declara ${missing.length === 1 ? 'una variable que no existe' : 'variables que no existen'}: ` +
+    if (missing.length) {
+        const message = `[ress] \`publicEnv\` declara ${missing.length === 1 ? 'una variable que no existe' : 'variables que no existen'}: ` +
             missing.join(', ') +
             '. Exponer una variable inexistente es casi siempre un error de tipeo, y ' +
-            'el navegador recibiría el nombre sin valor.');
+            'el navegador recibiría el nombre sin valor.';
+        if (options.strict !== false)
+            throw new Error(message);
+        (options.warn ?? console.warn)(message);
     }
     return defines;
 }

package/dist/config/index.d.ts

@@ -13,6 +13,6 @@ export type { CompiledRule, CompiledRules } from './rules';
 export { createConfigMiddleware } from './middleware';
 export { publicEnvDefines, publicEnvValues } from './env';
 export { generateProjectConfigTypes, generatePlatformTypes, writeGeneratedTypes, writeProjectTypes } from './codegen';
-export { changedKeys, isConfigLayer, restartReason, watchConfig, HOT_KEYS, RESTART_REASONS } from './watch';
+export { changedKeys, isConfigLayer, restartReason, watchConfig, onConfigReload, HOT_KEYS, RESTART_REASONS } from './watch';
 export { validateConfig, validateRules } from './validate';
 export type { AssetsConfig, IsrConfig, ResolvedIsrConfig, HeaderRule, ModeOverrides, PlatformConfig, RedirectRule, ResolvedConfig, RessConfig, RessServerConfig, RewriteRule, TrailingSlashMode, } from './types';

package/dist/config/index.js

@@ -7,7 +7,7 @@
  * resueltas por el mismo motor, y sólo la primera la lee el router.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateRules = exports.validateConfig = exports.RESTART_REASONS = exports.HOT_KEYS = exports.watchConfig = exports.restartReason = exports.isConfigLayer = exports.changedKeys = exports.writeProjectTypes = exports.writeGeneratedTypes = exports.generatePlatformTypes = exports.generateProjectConfigTypes = exports.publicEnvValues = exports.publicEnvDefines = exports.createConfigMiddleware = exports.parseRulePattern = exports.matchRule = exports.compileRules = exports.applyParams = exports.withBasePath = exports.stripBasePath = exports.canonicalTrailingSlash = exports.assetPrefixFor = exports.defineConfig = exports.resolveIsrConfig = exports.normalizeBasePath = exports.loadConfig = void 0;
+exports.validateRules = exports.validateConfig = exports.RESTART_REASONS = exports.HOT_KEYS = exports.onConfigReload = exports.watchConfig = exports.restartReason = exports.isConfigLayer = exports.changedKeys = exports.writeProjectTypes = exports.writeGeneratedTypes = exports.generatePlatformTypes = exports.generateProjectConfigTypes = exports.publicEnvValues = exports.publicEnvDefines = exports.createConfigMiddleware = exports.parseRulePattern = exports.matchRule = exports.compileRules = exports.applyParams = exports.withBasePath = exports.stripBasePath = exports.canonicalTrailingSlash = exports.assetPrefixFor = exports.defineConfig = exports.resolveIsrConfig = exports.normalizeBasePath = exports.loadConfig = void 0;
 var load_1 = require("./load");
 Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return load_1.loadConfig; } });
 Object.defineProperty(exports, "normalizeBasePath", { enumerable: true, get: function () { return load_1.normalizeBasePath; } });
@@ -39,6 +39,7 @@ Object.defineProperty(exports, "changedKeys", { enumerable: true, get: function
 Object.defineProperty(exports, "isConfigLayer", { enumerable: true, get: function () { return watch_1.isConfigLayer; } });
 Object.defineProperty(exports, "restartReason", { enumerable: true, get: function () { return watch_1.restartReason; } });
 Object.defineProperty(exports, "watchConfig", { enumerable: true, get: function () { return watch_1.watchConfig; } });
+Object.defineProperty(exports, "onConfigReload", { enumerable: true, get: function () { return watch_1.onConfigReload; } });
 Object.defineProperty(exports, "HOT_KEYS", { enumerable: true, get: function () { return watch_1.HOT_KEYS; } });
 Object.defineProperty(exports, "RESTART_REASONS", { enumerable: true, get: function () { return watch_1.RESTART_REASONS; } });
 var validate_1 = require("./validate");

package/dist/config/load.d.ts

@@ -8,7 +8,6 @@ import type { IsrConfig, ResolvedConfig, ResolvedIsrConfig } from './types';
  * config/default.js       ← lo común, opcional
  * config/development.js
  * config/production.js
- * config/test.js
  * config/local.js         ← esta máquina; no se sube
  * ```
  *

package/dist/config/load.js

@@ -14,7 +14,6 @@ const validate_1 = require("./validate");
  * config/default.js       ← lo común, opcional
  * config/development.js
  * config/production.js
- * config/test.js
  * config/local.js         ← esta máquina; no se sube
  * ```
  *
@@ -47,6 +46,8 @@ async function resolve(declared) {
         // obliga a recordar si ya está en cada concatenación.
         basePath: normalizeBasePath(declared.basePath ?? ''),
         trailingSlash: declared.trailingSlash ?? 'ignore',
+        // Sin barra inicial ni final: se compara contra rutas del proyecto.
+        shared: (declared.shared ?? []).map((entry) => entry.trim().replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '')),
         // Las tres son funciones para que el proyecto pueda leer un archivo o
         // consultar algo al arrancar. Se invocan una vez, acá.
         redirects: (await declared.redirects?.()) ?? [],

package/dist/config/types.d.ts

@@ -29,6 +29,13 @@ export interface RessConfig {
     basePath?: string;
     /** Qué hacer con la barra final de una URL. */
     trailingSlash?: TrailingSlashMode;
+    /**
+     * Carpetas cuyo código carga Node una sola vez y comparten tu entrada de servidor
+     * (`server.js`, `api/`) y las páginas, relativas a la raíz del proyecto
+     * (`['app/services']`). Sin esto, un archivo importado por las dos partes se
+     * carga dos veces, y cada copia tiene su propio estado.
+     */
+    shared?: string[];
     redirects?: () => RedirectRule[] | Promise<RedirectRule[]>;
     rewrites?: () => RewriteRule[] | Promise<RewriteRule[]>;
     headers?: () => HeaderRule[] | Promise<HeaderRule[]>;
@@ -143,11 +150,6 @@ export interface PlatformConfig {
     }>;
     /** Plataformas para las que se prepara el proyecto generado. F-033. */
     targets?: string[];
-    /**
-     * Intención declarativa de usar clientes completos forkeables. Las plantillas
-     * y sus runtimes pertenecen a F-028 (React Native) y F-029 (Electron).
-     */
-    forkedClients?: string[];
 }
 export interface RedirectRule {
     source: string;
@@ -176,6 +178,7 @@ export interface HeaderRule {
 export interface ResolvedConfig {
     basePath: string;
     trailingSlash: TrailingSlashMode;
+    shared: string[];
     redirects: RedirectRule[];
     rewrites: RewriteRule[];
     headers: HeaderRule[];

package/dist/config/validate.js

@@ -16,16 +16,26 @@ function validateConfig(config) {
     const problems = [];
     checkBasePath(config, problems);
     checkTrailingSlash(config, problems);
+    checkShared(config, problems);
     checkPublicEnv(config, problems);
     checkCallable(config, problems);
     checkAssets(config, problems);
     checkDev(config, problems);
     checkIsr(config, problems);
+    checkSecurity(config, problems);
+    checkPlatform(config, problems);
     if (problems.length === 0)
         return;
     throw new Error(`[ress] La configuración tiene ${problems.length === 1 ? 'un problema' : `${problems.length} problemas`}:\n` +
         problems.map((p) => `  · ${p}`).join('\n'));
 }
+function checkPlatform({ platform }, problems) {
+    if (platform && Object.hasOwn(platform, 'forkedClients')) {
+        problems.push('`platform.forkedClients` se retiró en 0.6.0 porque no tenía efecto. ' +
+            'Sacá esta clave; los clientes nativos viven en repositorios aparte. ' +
+            '`platform.targets` y las cabeceras de plataforma siguen funcionando.');
+    }
+}
 function checkBasePath({ basePath }, problems) {
     if (basePath === undefined)
         return;
@@ -40,6 +50,21 @@ function checkBasePath({ basePath }, problems) {
             'otro dominio está `assets.cdnPrefix`.');
     }
 }
+function checkShared({ shared }, problems) {
+    if (shared === undefined)
+        return;
+    if (!Array.isArray(shared)) {
+        return void problems.push('`shared` tiene que ser una lista de carpetas del proyecto (`[\'app/services\']`).');
+    }
+    for (const entry of shared) {
+        if (typeof entry !== 'string' || !entry.trim()) {
+            problems.push('`shared` sólo admite carpetas como cadenas no vacías.');
+        }
+        else if (/^([a-zA-Z]:)?[\\/]/.test(entry.trim()) || entry.split(/[\\/]/).includes('..')) {
+            problems.push(`\`shared\` lleva rutas relativas a la raíz del proyecto y dentro de ella; "${entry}" no lo es.`);
+        }
+    }
+}
 function checkTrailingSlash({ trailingSlash }, problems) {
     const valid = ['always', 'never', 'ignore'];
     if (trailingSlash !== undefined && !valid.includes(trailingSlash)) {
@@ -78,6 +103,48 @@ function checkAssets({ assets }, problems) {
             'los artefactos se sirven desde otro origen.');
     }
 }
+/**
+ * `security` se resuelve después, con sus valores por defecto, pero un valor de
+ * tipo equivocado no tiene que llegar hasta ahí: una cabecera con `undefined`
+ * o un límite negativo falla en cada petición en vez de al arrancar.
+ */
+function checkSecurity({ security }, problems) {
+    if (security === undefined)
+        return;
+    if (typeof security !== 'object' || security === null) {
+        return void problems.push('`security` tiene que ser un objeto.');
+    }
+    const s = security;
+    const object = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+    const isBoolean = (v) => typeof v === 'boolean';
+    const isString = (v) => typeof v === 'string';
+    const isNonNegativeInteger = (v) => Number.isInteger(v) && v >= 0;
+    const isStringList = (v) => Array.isArray(v) && v.every((item) => typeof item === 'string');
+    const oneOf = (...values) => (v) => values.includes(v);
+    const orFalse = (check) => (v) => v === false || check(v);
+    const rules = [
+        ['security.maxStateBytes', s.maxStateBytes, isNonNegativeInteger, 'un entero no negativo'],
+        ['security.onStateOverLimit', s.onStateOverLimit, oneOf('warn', 'error'), "'warn' o 'error'"],
+        ['security.serializePlatform', s.serializePlatform, oneOf('auto', 'always', 'never'), "'auto', 'always' o 'never'"],
+    ];
+    const groups = ['headers', 'cache', 'csp', 'head', 'dev'];
+    for (const group of groups) {
+        if (s[group] !== undefined && !object(s[group])) {
+            problems.push(`\`security.${group}\` tiene que ser un objeto.`);
+            continue;
+        }
+    }
+    const h = object(s.headers) ? s.headers : {};
+    const c = object(s.cache) ? s.cache : {};
+    const csp = object(s.csp) ? s.csp : {};
+    const head = object(s.head) ? s.head : {};
+    const dev = object(s.dev) ? s.dev : {};
+    rules.push(['security.headers.contentTypeOptions', h.contentTypeOptions, isBoolean, 'un booleano'], ['security.headers.referrerPolicy', h.referrerPolicy, orFalse(isString), 'una cadena o false'], ['security.headers.frameOptions', h.frameOptions, orFalse(oneOf('DENY', 'SAMEORIGIN')), "'DENY', 'SAMEORIGIN' o false"], ['security.headers.hsts', h.hsts, orFalse((v) => object(v) && isNonNegativeInteger(v.maxAge)), 'false o un objeto con `maxAge` entero'], ['security.cache.html', c.html, isString, 'una cadena'], ['security.cache.immutableMaxAge', c.immutableMaxAge, isNonNegativeInteger, 'un entero no negativo'], ['security.cache.staticMaxAge', c.staticMaxAge, isNonNegativeInteger, 'un entero no negativo'], ['security.csp.enabled', csp.enabled, isBoolean, 'un booleano'], ['security.csp.reportOnly', csp.reportOnly, isBoolean, 'un booleano'], ['security.csp.reportUri', csp.reportUri, isString, 'una cadena'], ['security.csp.directives', csp.directives, (v) => object(v) && Object.values(v).every(orFalse(isStringList)), 'un objeto cuyos valores son listas de cadenas o false'], ['security.head.allowScriptTags', head.allowScriptTags, isBoolean, 'un booleano'], ['security.head.extraTagAllowlist', head.extraTagAllowlist, isStringList, 'una lista de cadenas'], ['security.dev.allowedHosts', dev.allowedHosts, isStringList, 'una lista de cadenas'], ['security.dev.allowedOrigins', dev.allowedOrigins, orFalse(isStringList), 'false o una lista de cadenas']);
+    for (const [key, value, valid, expected] of rules) {
+        if (value !== undefined && !valid(value))
+            problems.push(`\`${key}\` tiene que ser ${expected}.`);
+    }
+}
 function checkIsr({ isr }, problems) {
     if (isr === undefined)
         return;

package/dist/config/watch.d.ts

@@ -36,6 +36,21 @@ export declare function changedKeys(previous: ResolvedConfig, next: ResolvedConf
 export declare function manualRestartReason(changed: readonly string[]): string | undefined;
 /** El motivo del reinicio, o nada si todo lo que cambió se aplica en caliente. */
 export declare function restartReason(changed: readonly string[]): string | undefined;
+/**
+ * Espera a que un archivo deje de cambiar.
+ *
+ * Guardar es truncar y escribir, y el sistema puede avisar entre un paso y el otro
+ * (Windows lo hace, y no siempre vuelve a avisar al terminar). Leer en ese momento
+ * da un archivo vacío: la configuración sale por defecto, no hay diferencias ni
+ * error, y el cambio se pierde. Se mira el tamaño y la fecha hasta que dos
+ * lecturas seguidas coinciden. Un archivo vacío cuenta como «todavía no
+ * terminó»: casi siempre es el paso intermedio de una escritura. Si de verdad
+ * está vacío, se lo lee igual cuando se agotan los intentos.
+ */
+export declare function settled(file: string, { interval, attempts }?: {
+    interval?: number | undefined;
+    attempts?: number | undefined;
+}): Promise<void>;
 /** ¿Este archivo es una capa de configuración del proyecto? */
 export declare function isConfigLayer(file: string, root: string): boolean;
 export interface WatchConfigOptions {
@@ -49,5 +64,12 @@ export interface WatchConfigOptions {
     onRestart?: (reason: string) => void;
     log?: (message: string) => void;
 }
+/**
+ * Quien arma el pipeline de petición (el router) se entera acá de una recarga en
+ * caliente. El plugin de Vite y el router viven en objetos distintos: sin este
+ * aviso, la configuración nueva llegaba al plugin y las peticiones seguían
+ * usando las reglas con las que arrancó el servidor. Devuelve la baja.
+ */
+export declare function onConfigReload(listener: (config: ResolvedConfig) => void): () => void;
 /** Conecta el observador de Vite con la carpeta de configuración. */
 export declare function watchConfig(server: any, options: WatchConfigOptions): void;

package/dist/config/watch.js

@@ -4,9 +4,13 @@ exports.MANUAL_RESTART_KEYS = exports.RESTART_REASONS = exports.HOT_KEYS = void
 exports.changedKeys = changedKeys;
 exports.manualRestartReason = manualRestartReason;
 exports.restartReason = restartReason;
+exports.settled = settled;
 exports.isConfigLayer = isConfigLayer;
+exports.onConfigReload = onConfigReload;
 exports.watchConfig = watchConfig;
+const promises_1 = require("node:fs/promises");
 const config_1 = require("@ressjs/config");
+const codegen_1 = require("./codegen");
 const load_1 = require("./load");
 /**
  * Recarga de la configuración en desarrollo.
@@ -33,6 +37,7 @@ exports.HOT_KEYS = ['redirects', 'rewrites', 'headers', 'trailingSlash'];
  */
 exports.RESTART_REASONS = {
     basePath: 'cambia la URL bajo la que se sirve todo, incluidos los artefactos ya emitidos',
+    shared: 'Node carga esas carpetas una sola vez, al arrancar, y las comparten tu entrada de servidor y las páginas',
     extensions: 'cambia qué archivos son páginas, y eso redefine el catálogo de entradas',
     platform: 'redefine los ejes de plataforma, y con ellos las variantes que se construyen',
     publicEnv: 'las variables se reemplazan en tiempo de build, no al atender una petición',
@@ -55,6 +60,7 @@ exports.RESTART_REASONS = {
  */
 exports.MANUAL_RESTART_KEYS = new Set([
     'basePath',
+    'shared',
     'assets',
     'security',
     'isr',
@@ -110,6 +116,36 @@ function restartReason(changed) {
     }
     return undefined;
 }
+/**
+ * Espera a que un archivo deje de cambiar.
+ *
+ * Guardar es truncar y escribir, y el sistema puede avisar entre un paso y el otro
+ * (Windows lo hace, y no siempre vuelve a avisar al terminar). Leer en ese momento
+ * da un archivo vacío: la configuración sale por defecto, no hay diferencias ni
+ * error, y el cambio se pierde. Se mira el tamaño y la fecha hasta que dos
+ * lecturas seguidas coinciden. Un archivo vacío cuenta como «todavía no
+ * terminó»: casi siempre es el paso intermedio de una escritura. Si de verdad
+ * está vacío, se lo lee igual cuando se agotan los intentos.
+ */
+async function settled(file, { interval = 30, attempts = 30 } = {}) {
+    const signature = async () => {
+        try {
+            const { size, mtimeMs } = await (0, promises_1.stat)(file);
+            return `${size}:${mtimeMs}`;
+        }
+        catch {
+            return 'ausente';
+        }
+    };
+    let previous = await signature();
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, interval));
+        const current = await signature();
+        if (current === previous && !current.startsWith('0:'))
+            return;
+        previous = current;
+    }
+}
 /** ¿Este archivo es una capa de configuración del proyecto? */
 function isConfigLayer(file, root) {
     const normalized = file.replace(/\\/g, '/');
@@ -119,6 +155,17 @@ function isConfigLayer(file, root) {
     const relative = normalized.slice(base.length + 1);
     return /^config\/[^/]+$/.test(relative) || /^config\.[^/]+$/.test(relative);
 }
+const reloadListeners = new Set();
+/**
+ * Quien arma el pipeline de petición (el router) se entera acá de una recarga en
+ * caliente. El plugin de Vite y el router viven en objetos distintos: sin este
+ * aviso, la configuración nueva llegaba al plugin y las peticiones seguían
+ * usando las reglas con las que arrancó el servidor. Devuelve la baja.
+ */
+function onConfigReload(listener) {
+    reloadListeners.add(listener);
+    return () => void reloadListeners.delete(listener);
+}
 /** Conecta el observador de Vite con la carpeta de configuración. */
 function watchConfig(server, options) {
     const log = options.log ?? ((message) => console.log(message));
@@ -130,6 +177,8 @@ function watchConfig(server, options) {
     const onChange = async (file) => {
         if (!isConfigLayer(file, options.root))
             return;
+        // Se lee el archivo terminado, no el que se está escribiendo.
+        await settled(file);
         // Lo resuelto se descarta entero: la fusión depende de todas las capas, así
         // que un cambio en cualquiera de ellas invalida el resultado.
         (0, config_1.invalidateConfig)();
@@ -143,6 +192,12 @@ function watchConfig(server, options) {
             log(`[ress] La configuración no se pudo cargar: ${error.message}`);
             return;
         }
+        // Los tipos de `config.X` salen de lo resuelto, valores propios incluidos, y
+        // un valor propio nuevo no figura en `changedKeys` (sólo compara las claves
+        // del framework): se regeneran con cada cambio de capa.
+        await (0, codegen_1.writeProjectTypes)(options.root, next.platform).catch((error) => {
+            log(`[ress] No se pudieron regenerar los tipos de la configuración: ${error.message}`);
+        });
         const changed = changedKeys(options.current(), next);
         if (changed.length === 0)
             return;
@@ -155,6 +210,8 @@ function watchConfig(server, options) {
         if (reason)
             return restart(reason);
         options.onReload(next);
+        for (const listener of reloadListeners)
+            listener(next);
         log(`[ress] Configuración recargada: ${changed.join(', ')}`);
     };
     for (const event of ['add', 'change', 'unlink']) {

package/dist/fs/canonical-path.d.ts

@@ -0,0 +1,12 @@
+/**
+ * La ruta real de un archivo o directorio, sin enlaces simbólicos.
+ *
+ * El bundler informa cada módulo con su ruta real. Si la raíz del proyecto se
+ * toma tal como la escribió el usuario —a través de un enlace, como `/tmp` en
+ * macOS—, comparar una ruta con la otra falla sin decir por qué. La raíz se
+ * canoniza una vez, donde se resuelve, y todo lo que se derive de ella coincide.
+ *
+ * Una ruta que no existe se devuelve resuelta pero sin canonizar: el error de
+ * que no existe le corresponde a quien la use.
+ */
+export declare function canonicalPath(target: string): string;

package/dist/fs/canonical-path.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalPath = canonicalPath;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * La ruta real de un archivo o directorio, sin enlaces simbólicos.
+ *
+ * El bundler informa cada módulo con su ruta real. Si la raíz del proyecto se
+ * toma tal como la escribió el usuario —a través de un enlace, como `/tmp` en
+ * macOS—, comparar una ruta con la otra falla sin decir por qué. La raíz se
+ * canoniza una vez, donde se resuelve, y todo lo que se derive de ella coincide.
+ *
+ * Una ruta que no existe se devuelve resuelta pero sin canonizar: el error de
+ * que no existe le corresponde a quien la use.
+ */
+function canonicalPath(target) {
+    const absolute = node_path_1.default.resolve(target);
+    try {
+        return node_fs_1.realpathSync.native(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}

package/dist/fs/shared-modules.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Carpetas compartidas con Node (`shared` en la config).
+ *
+ * Un archivo importado por la entrada de servidor (`server.js`, `api/`) y por las
+ * páginas se carga dos veces si cada parte lo carga por su cuenta: Node, y el runner
+ * de Vite en desarrollo o el bundle compilado en producción. Cada copia tiene su
+ * propio estado. Los archivos de estas carpetas los carga siempre Node, así que hay
+ * una sola.
+ */
+/** ¿Este archivo cae dentro de una carpeta compartida? `root` es la raíz del proyecto. */
+export declare function isSharedModule(id: string, root: string, shared: readonly string[]): boolean;
+/** Marca con la que el build deja un import compartido hasta que se conoce la ubicación del chunk. */
+export declare const SHARED_PREFIX = "ress-shared:";
+/**
+ * Reescribe los marcadores de un chunk por la ruta relativa real al archivo.
+ *
+ * Se hace al terminar de armar el chunk porque sólo entonces se sabe dónde queda: la
+ * ruta «relativa» que calcula el bundler parte de la fuente de la entrada, no del
+ * archivo de salida. La app se despliega con `dist/` y las carpetas compartidas
+ * lado a lado, así que la ruta relativa sigue valiendo al moverla de lugar.
+ */
+export declare function resolveSharedMarkers(code: string, chunkFile: string, root: string): string;

package/dist/fs/shared-modules.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHARED_PREFIX = void 0;
+exports.isSharedModule = isSharedModule;
+exports.resolveSharedMarkers = resolveSharedMarkers;
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Carpetas compartidas con Node (`shared` en la config).
+ *
+ * Un archivo importado por la entrada de servidor (`server.js`, `api/`) y por las
+ * páginas se carga dos veces si cada parte lo carga por su cuenta: Node, y el runner
+ * de Vite en desarrollo o el bundle compilado en producción. Cada copia tiene su
+ * propio estado. Los archivos de estas carpetas los carga siempre Node, así que hay
+ * una sola.
+ */
+/** ¿Este archivo cae dentro de una carpeta compartida? `root` es la raíz del proyecto. */
+function isSharedModule(id, root, shared) {
+    const file = id.split('?')[0].replace(/\\/g, '/');
+    const base = root.replace(/\\/g, '/').replace(/\/+$/, '');
+    return shared.some((entry) => file.startsWith(`${base}/${entry}/`));
+}
+/** Marca con la que el build deja un import compartido hasta que se conoce la ubicación del chunk. */
+exports.SHARED_PREFIX = 'ress-shared:';
+/**
+ * Reescribe los marcadores de un chunk por la ruta relativa real al archivo.
+ *
+ * Se hace al terminar de armar el chunk porque sólo entonces se sabe dónde queda: la
+ * ruta «relativa» que calcula el bundler parte de la fuente de la entrada, no del
+ * archivo de salida. La app se despliega con `dist/` y las carpetas compartidas
+ * lado a lado, así que la ruta relativa sigue valiendo al moverla de lugar.
+ */
+function resolveSharedMarkers(code, chunkFile, root) {
+    if (!code.includes(exports.SHARED_PREFIX))
+        return code;
+    return code.replace(new RegExp(`${exports.SHARED_PREFIX}([^"'\`\\s)]+)`, 'g'), (_match, rel) => {
+        const relative = node_path_1.default
+            .relative(node_path_1.default.dirname(chunkFile), node_path_1.default.join(root, rel))
+            .replace(/\\/g, '/');
+        return relative.startsWith('.') ? relative : `./${relative}`;
+    });
+}

package/dist/helpers/request-handler.js

@@ -45,11 +45,8 @@ 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) {
@@ -112,16 +109,11 @@ async function processRequest(context, config, renderServer) {
         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,
-            // `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.

package/dist/index.d.ts

@@ -3,7 +3,7 @@ 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 { scanRoutes, RouteConflictError } 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';
@@ -14,26 +14,27 @@ 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 { DEFAULT_EXCLUSIONS, DEFAULT_EXTENSION_POLICY, isPageFile, pageExclusionOf, scriptExtensionOf, SCRIPT_EXTENSIONS, setExtensionPolicy, } 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 { canonicalPath } from './fs/canonical-path';
 export { detectPlatform } from './platform';
 export type { PlatformInfo } from './platform';
 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';
+export { resolveSecurityOptions, serializeState, applySecurityHeaders, } from './security';
+export type { 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 { defineConfig, loadConfig, normalizeBasePath, validateConfig, createConfigMiddleware, compileRules, publicEnvDefines, withBasePath, assetPrefixFor, writeProjectTypes, } from './config';
 export type { RessConfig, ResolvedConfig, TrailingSlashMode, RessServerConfig } from './config';