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

package/dist/config/rules.d.ts

@@ -0,0 +1,59 @@
+import type { RouteSegment } from '../routes/types';
+import type { HeaderRule, RedirectRule, ResolvedConfig, RewriteRule } from './types';
+/**
+ * Redirecciones, reescrituras y cabeceras declaradas por el proyecto.
+ *
+ * Las tres comparten patrón, y el patrón es **el mismo analizador de rutas** que
+ * usa el manifest: `matchSegments()` recorre segmento a segmento y exige consumir
+ * la URL entera. Una segunda implementación de coincidencia acá significaría que
+ * `/docs/:seccion` puede querer decir dos cosas distintas según quién la lea.
+ *
+ * Notación de un patrón:
+ *
+ * | Escrito | Coincide con |
+ * |---|---|
+ * | `/precios` | exactamente `/precios` |
+ * | `/blog/:slug` | un segmento, disponible como `:slug` en el destino |
+ * | `/docs/:...resto` | uno o más segmentos |
+ * | `/docs/:...resto?` | cero o más segmentos |
+ */
+export interface CompiledRule<T> {
+    rule: T;
+    source: string;
+    segments: RouteSegment[];
+    paramNames: string[];
+}
+export interface CompiledRules {
+    redirects: CompiledRule<RedirectRule>[];
+    rewrites: CompiledRule<RewriteRule>[];
+    headers: CompiledRule<HeaderRule>[];
+}
+export declare function parseRulePattern(source: string, label: string): {
+    segments: RouteSegment[];
+    paramNames: string[];
+};
+/**
+ * Compila las tres listas y comprueba lo que sólo se puede comprobar con los
+ * patrones ya analizados: parámetros que el destino usa sin que el origen los
+ * declare, cabeceras reservadas, y ciclos de redirección.
+ */
+export declare function compileRules(config: ResolvedConfig): CompiledRules;
+export interface RuleMatch<T> {
+    compiled: CompiledRule<T>;
+    params: Record<string, string | string[]>;
+}
+/** La primera regla que atiende esta ruta, en el orden en que se declararon. */
+export declare function matchRule<T>(rules: readonly CompiledRule<T>[], pathname: string): RuleMatch<T> | undefined;
+/**
+ * Traslada los parámetros que capturó el origen al destino.
+ *
+ * `matchSegments()` entrega los valores ya decodificados (R-8): un segmento
+ * como `%2F%2Fevil.example` llega acá como `//evil.example`. Si se pegara tal
+ * cual, `/old/:p` con ese pedido armaría el destino `//evil.example`, que
+ * `absolute()` (en `middleware.ts`) lee como una URL absoluta y termina en un
+ * `Location` que saca al visitante del origen — un open redirect. Por eso cada
+ * segmento se vuelve a codificar con `encodeURIComponent`: una barra decodificada
+ * nunca sobrevive para armar un segmento nuevo, y un catch-all de varios
+ * segmentos se preserva uniendo cada uno ya codificado con `/`.
+ */
+export declare function applyParams(destination: string, params: Record<string, string | string[]>): string;

package/dist/config/rules.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRulePattern = parseRulePattern;
+exports.compileRules = compileRules;
+exports.matchRule = matchRule;
+exports.applyParams = applyParams;
+const match_1 = require("../routes/match");
+/** Cabeceras que administra el framework: declararlas desde el proyecto las rompe. */
+const RESERVED_HEADERS = new Set(['vary', 'content-type', 'content-length', 'transfer-encoding']);
+function parseRulePattern(source, label) {
+    if (!source.startsWith('/')) {
+        throw new Error(`[ress] ${label}: el patrón "${source}" tiene que empezar con "/". ` +
+            'Es una ruta de esta aplicación, no una URL relativa.');
+    }
+    const segments = [];
+    const paramNames = [];
+    // El patrón se parte a mano y no con `splitPath()`: esa función descarta la
+    // consulta a partir del `?`, que acá es la marca de catch-all opcional.
+    for (const raw of source.split('/').filter(Boolean)) {
+        const previous = segments[segments.length - 1];
+        if (previous && (previous.kind === 'catchAll' || previous.kind === 'optionalCatchAll')) {
+            throw new Error(`[ress] ${label}: "${source}" pone un segmento después de un catch-all, ` +
+                'que ya consume el resto de la URL.');
+        }
+        if (!raw.startsWith(':')) {
+            segments.push({ kind: 'static', value: raw });
+            continue;
+        }
+        const optional = raw.endsWith('?');
+        const body = optional ? raw.slice(1, -1) : raw.slice(1);
+        const catchAll = body.startsWith('...');
+        const name = catchAll ? body.slice(3) : body;
+        if (!name) {
+            throw new Error(`[ress] ${label}: "${source}" declara un parámetro sin nombre.`);
+        }
+        if (optional && !catchAll) {
+            throw new Error(`[ress] ${label}: "${source}" marca ":${name}" como opcional. ` +
+                'Sólo un catch-all puede serlo: ":...' + name + '?".');
+        }
+        if (paramNames.includes(name)) {
+            throw new Error(`[ress] ${label}: "${source}" usa el parámetro ":${name}" dos veces.`);
+        }
+        paramNames.push(name);
+        segments.push({
+            kind: catchAll ? (optional ? 'optionalCatchAll' : 'catchAll') : 'dynamic',
+            value: name,
+        });
+    }
+    return { segments, paramNames };
+}
+/**
+ * Compila las tres listas y comprueba lo que sólo se puede comprobar con los
+ * patrones ya analizados: parámetros que el destino usa sin que el origen los
+ * declare, cabeceras reservadas, y ciclos de redirección.
+ */
+function compileRules(config) {
+    const compiled = {
+        redirects: compileList(config.redirects, 'redirects'),
+        rewrites: compileList(config.rewrites, 'rewrites'),
+        headers: compileList(config.headers, 'headers'),
+    };
+    const problems = [];
+    for (const [index, entry] of compiled.redirects.entries()) {
+        checkDestination(entry, entry.rule.destination, `redirects[${index}]`, problems);
+    }
+    for (const [index, entry] of compiled.rewrites.entries()) {
+        checkDestination(entry, entry.rule.destination, `rewrites[${index}]`, problems);
+    }
+    for (const [index, entry] of compiled.headers.entries()) {
+        for (const header of entry.rule.headers) {
+            if (RESERVED_HEADERS.has(header.key.toLowerCase())) {
+                problems.push(`headers[${index}]: "${header.key}" la administra el framework y no se puede declarar acá.`);
+            }
+        }
+    }
+    const cycle = findRedirectCycle(compiled.redirects);
+    if (cycle) {
+        problems.push(`redirects: las reglas ${cycle.join(' → ')} forman un ciclo. ` +
+            'Un ciclo deja al navegador saltando hasta que se rinde.');
+    }
+    if (problems.length) {
+        throw new Error('[ress] La configuración tiene reglas inválidas:\n' +
+            problems.map((p) => `  · ${p}`).join('\n'));
+    }
+    return compiled;
+}
+function compileList(rules, label) {
+    return rules.map((rule, index) => {
+        const { segments, paramNames } = parseRulePattern(rule.source, `${label}[${index}]`);
+        return { rule, source: rule.source, segments, paramNames };
+    });
+}
+/** Todo `:param` del destino tiene que estar declarado en el origen. */
+function checkDestination(entry, destination, label, problems) {
+    for (const used of destination.matchAll(/:(\.{3})?([A-Za-z0-9_]+)/g)) {
+        const name = used[2];
+        if (!entry.paramNames.includes(name)) {
+            problems.push(`${label}.destination: usa ":${name}", que "${entry.source}" no declara. ` +
+                `Declarados: ${entry.paramNames.map((p) => ':' + p).join(', ') || 'ninguno'}.`);
+        }
+    }
+}
+/**
+ * Un ciclo de redirecciones.
+ *
+ * Se sigue la cadena desde cada regla: se toma su destino, se busca qué regla lo
+ * atendería, y así. Volver a pisar una regla ya visitada en la misma cadena es un
+ * ciclo. Sólo se puede seguir un destino sin parámetros sin inventar valores, así
+ * que la comprobación es de los ciclos que se pueden demostrar.
+ */
+function findRedirectCycle(redirects) {
+    for (const start of redirects) {
+        const seen = [start.source];
+        let current = start;
+        for (let step = 0; step < redirects.length; step++) {
+            const destination = current.rule.destination;
+            if (destination.includes(':'))
+                break;
+            const next = matchRule(redirects, destination);
+            if (!next)
+                break;
+            if (seen.includes(next.compiled.source)) {
+                return [...seen, next.compiled.source];
+            }
+            seen.push(next.compiled.source);
+            current = next.compiled;
+        }
+    }
+    return undefined;
+}
+/** La primera regla que atiende esta ruta, en el orden en que se declararon. */
+function matchRule(rules, pathname) {
+    const parts = (0, match_1.splitPath)(pathname);
+    for (const compiled of rules) {
+        const params = (0, match_1.matchSegments)(compiled.segments, parts);
+        if (params)
+            return { compiled, params };
+    }
+    return undefined;
+}
+/**
+ * Traslada los parámetros que capturó el origen al destino.
+ *
+ * `matchSegments()` entrega los valores ya decodificados (R-8): un segmento
+ * como `%2F%2Fevil.example` llega acá como `//evil.example`. Si se pegara tal
+ * cual, `/old/:p` con ese pedido armaría el destino `//evil.example`, que
+ * `absolute()` (en `middleware.ts`) lee como una URL absoluta y termina en un
+ * `Location` que saca al visitante del origen — un open redirect. Por eso cada
+ * segmento se vuelve a codificar con `encodeURIComponent`: una barra decodificada
+ * nunca sobrevive para armar un segmento nuevo, y un catch-all de varios
+ * segmentos se preserva uniendo cada uno ya codificado con `/`.
+ */
+function applyParams(destination, params) {
+    return destination.replace(/:(\.{3})?([A-Za-z0-9_]+)/g, (whole, _spread, name) => {
+        const value = params[name];
+        if (value === undefined)
+            return whole;
+        return Array.isArray(value)
+            ? value.map((segment) => encodeURIComponent(segment)).join('/')
+            : encodeURIComponent(value);
+    });
+}

package/dist/config/types.d.ts

@@ -0,0 +1,189 @@
+import type { ExtensionPolicy } from '../fs/module-extensions';
+import type { SecurityOptions } from '../security';
+/**
+ * La configuración del proyecto: un objeto por archivo de `config/`.
+ *
+ * ```js
+ * // config/production.js
+ * export default {
+ *   basePath: '/app',
+ *   redirects: () => [{ source: '/viejo', destination: '/nuevo', permanent: true }],
+ *   security: { csp: { enabled: true } },
+ *
+ *   // Y las claves propias del proyecto, que conviven con las del framework.
+ *   API_URL: 'https://api.example.com',
+ * }
+ * ```
+ *
+ * Las claves que el framework reconoce están declaradas abajo; cualquier otra es
+ * del proyecto y se lee con `import { config } from '@ressjs/config'`. No hay un
+ * segundo archivo para eso: un solo lugar donde buscar de dónde sale un valor.
+ *
+ * Cada spec que necesita configuración aporta su propia interfaz y la enchufa
+ * como una clave. Esta spec aporta el continente, la carga, la fusión y la
+ * validación; no el contenido de cada sección.
+ */
+export type TrailingSlashMode = 'always' | 'never' | 'ignore';
+export interface RessConfig {
+    /** Prefijo bajo el que se sirve la aplicación. Sin barra final. */
+    basePath?: string;
+    /** Qué hacer con la barra final de una URL. */
+    trailingSlash?: TrailingSlashMode;
+    redirects?: () => RedirectRule[] | Promise<RedirectRule[]>;
+    rewrites?: () => RewriteRule[] | Promise<RewriteRule[]>;
+    headers?: () => HeaderRule[] | Promise<HeaderRule[]>;
+    /**
+     * Variables de entorno que llegan al navegador.
+     *
+     * Lista explícita y no un prefijo: un prefijo publica lo que alguien agregue
+     * después sin que nadie lo decida.
+     */
+    publicEnv?: string[];
+    /** Extensiones reconocidas como código de usuario. F-017. */
+    extensions?: Partial<ExtensionPolicy>;
+    /** Tokens de plataforma propios del proyecto. Alimenta sólo los tipos generados; F-024. */
+    platform?: PlatformConfig;
+    /**
+     * Cabeceras, política de contenido y límites.
+     *
+     * Se carga, se fusiona y se valida como el resto de la configuración.
+     * `createViteRouter`/`ressCorePlugin` la leen después de `loadConfig` para
+     * completar los defaults de seguridad: sólo se pisa si quien arma el router
+     * o el plugin aportó `security`/`securityOptions` explícito. F-019.
+     */
+    security?: SecurityOptions;
+    /** Prefijo de CDN para archivos estáticos. Consumido por F-006. */
+    assets?: AssetsConfig;
+    /** Caché incremental de páginas `renderingMode: 'isr'`. F-011. */
+    isr?: IsrConfig;
+    /**
+     * Vía de escape nivel 1 (F-033): extender la aplicación de servidor sin
+     * salir de los comandos de la CLI.
+     */
+    server?: RessServerConfig;
+    /**
+     * Capas por modo, sólo en la forma de archivo único (`config.js` en vez de la
+     * carpeta). La forma de carpeta las expresa con un archivo por modo, que es la
+     * que conviene cuando la configuración crece.
+     */
+    development?: ModeOverrides;
+    production?: ModeOverrides;
+    local?: ModeOverrides;
+    /**
+     * Los valores propios del proyecto: una URL de API, una clave, un feature
+     * flag. Conviven con las claves del framework en el mismo objeto y se leen con
+     * `import { config } from '@ressjs/config'`.
+     */
+    [key: string]: unknown;
+}
+/** Una capa de modo no puede contener otras capas. */
+export type ModeOverrides = Omit<RessConfig, 'development' | 'production' | 'local'>;
+export interface AssetsConfig {
+    /** Prefijo absoluto desde el que se sirven los artefactos. */
+    cdnPrefix?: string;
+}
+export interface IsrConfig {
+    /** Máximo de entradas en memoria. Por defecto 500. */
+    maxEntries?: number;
+    /** Máximo de bytes de HTML en memoria. Por defecto 50 MiB. */
+    maxBytes?: number;
+    /** Tiempo máximo de una generación, en milisegundos. Por defecto 30 000. */
+    generationTimeoutMs?: number;
+    /**
+     * Usar la caché real en `ress dev`. Por defecto `false`: en desarrollo la
+     * página se renderiza en cada petición, bajo el mismo contrato público.
+     */
+    dev?: boolean;
+    /**
+     * Cuándo se le dice a una CDN que puede guardar una página ISR
+     * (`Cache-Control: public, s-maxage=…`).
+     *
+     * - `auto` (por defecto): sólo en rutas sin middlewares. Una CDN no corre
+     *   los middlewares de ress.js: si uno protege la ruta, la CDN serviría a
+     *   cualquiera la respuesta que guardó de alguien autorizado.
+     * - `always`: en toda página ISR. Para quien sabe que sus middlewares no
+     *   deciden quién ve la página (logs, métricas, cabeceras).
+     * - `never`: nunca. La caché de ress.js sigue funcionando igual.
+     */
+    sharedCache?: 'auto' | 'always' | 'never';
+    /**
+     * Secreto de vista previa: con él, la cabecera `x-ress-preview` o la cookie
+     * `__ress_preview` renderizan la página con la petición completa, sin tocar
+     * la caché. Sin valor, la vista previa no existe.
+     */
+    previewSecret?: string;
+}
+export type ResolvedIsrConfig = Required<Omit<IsrConfig, 'previewSecret'>> & Pick<IsrConfig, 'previewSecret'>;
+/**
+ * Vía de escape nivel 1: extender la aplicación de servidor desde la
+ * configuración, sin dejar de usar `ress dev` / `ress build` / `ress start`.
+ *
+ * Las funciones reciben el `Express` que construye `createRessApp` (F-033).
+ * `beforeRouter` corre antes de montar el enrutador del framework y gana ante
+ * sus rutas; `afterRouter` corre después y no puede pisarlas.
+ */
+export interface RessServerConfig {
+    /** Se ejecuta antes de montar el enrutador del framework. Gana ante rutas del framework. */
+    beforeRouter?: (app: import('express').Express) => void | Promise<void>;
+    /** Se ejecuta después. No puede pisar rutas del framework. */
+    afterRouter?: (app: import('express').Express) => void | Promise<void>;
+}
+/**
+ * Tokens de plataforma propios del proyecto, para el autocompletado.
+ *
+ * `detect`, `axisPrecedence` y `edge` no están acá: el motor de detección los
+ * lee de `defaultPlatformRegistry`, no de esta configuración. Declararlos aquí
+ * sin que nada los consuma es la clase de clave que promete algo que no hace.
+ */
+export interface PlatformConfig {
+    values?: Array<{
+        token: string;
+        axis: string;
+        label?: string;
+    }>;
+    /** 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;
+    destination: string;
+    /** Permanente emite 308; temporal, 307. */
+    permanent?: boolean;
+}
+export interface RewriteRule {
+    source: string;
+    destination: string;
+}
+export interface HeaderRule {
+    source: string;
+    headers: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+/**
+ * La configuración ya resuelta.
+ *
+ * Todas las claves que el framework consulta existen, así que nadie tiene que
+ * escribir `config.security ?? {}` en cada uso. Las capas de modo desaparecen:
+ * ya se fusionaron.
+ */
+export interface ResolvedConfig {
+    basePath: string;
+    trailingSlash: TrailingSlashMode;
+    redirects: RedirectRule[];
+    rewrites: RewriteRule[];
+    headers: HeaderRule[];
+    publicEnv: string[];
+    extensions: Partial<ExtensionPolicy>;
+    platform: PlatformConfig;
+    security: SecurityOptions;
+    assets: Required<AssetsConfig> | AssetsConfig;
+    isr: ResolvedIsrConfig;
+    server: RessServerConfig;
+}

package/dist/config/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/validate.d.ts

@@ -0,0 +1,19 @@
+import type { HeaderRule, RedirectRule, RessConfig, RewriteRule } from './types';
+/**
+ * Comprueba la configuración al arrancar.
+ *
+ * Un valor mal escrito acá se manifiesta como una petición que responde raro
+ * mucho después y en otro lugar. Fallar al arrancar, nombrando la clave, es la
+ * diferencia entre corregir un error en un minuto y buscarlo durante una tarde.
+ *
+ * Se acumulan todos los problemas antes de fallar: arreglar de a uno, reiniciar,
+ * y encontrar el siguiente es una forma lenta de perder la tarde.
+ */
+export declare function validateConfig(config: RessConfig): void;
+/**
+ * Comprueba las reglas que devolvieron `redirects`, `rewrites` y `headers`.
+ *
+ * Se hace después de invocarlas, no en `validateConfig`, porque hasta ese momento
+ * son funciones sin ejecutar.
+ */
+export declare function validateRules(redirects: RedirectRule[], rewrites: RewriteRule[], headers: HeaderRule[]): void;

package/dist/config/validate.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = validateConfig;
+exports.validateRules = validateRules;
+/**
+ * Comprueba la configuración al arrancar.
+ *
+ * Un valor mal escrito acá se manifiesta como una petición que responde raro
+ * mucho después y en otro lugar. Fallar al arrancar, nombrando la clave, es la
+ * diferencia entre corregir un error en un minuto y buscarlo durante una tarde.
+ *
+ * Se acumulan todos los problemas antes de fallar: arreglar de a uno, reiniciar,
+ * y encontrar el siguiente es una forma lenta de perder la tarde.
+ */
+function validateConfig(config) {
+    const problems = [];
+    checkBasePath(config, problems);
+    checkTrailingSlash(config, problems);
+    checkPublicEnv(config, problems);
+    checkCallable(config, problems);
+    checkAssets(config, problems);
+    checkDev(config, problems);
+    checkIsr(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 checkBasePath({ basePath }, problems) {
+    if (basePath === undefined)
+        return;
+    if (typeof basePath !== 'string') {
+        return void problems.push('`basePath` tiene que ser una cadena.');
+    }
+    if (/[?#]/.test(basePath)) {
+        problems.push('`basePath` es un prefijo de ruta: no puede llevar `?` ni `#`.');
+    }
+    if (/^https?:\/\//i.test(basePath)) {
+        problems.push('`basePath` es un prefijo de ruta, no una URL completa. Para servir desde ' +
+            'otro dominio está `assets.cdnPrefix`.');
+    }
+}
+function checkTrailingSlash({ trailingSlash }, problems) {
+    const valid = ['always', 'never', 'ignore'];
+    if (trailingSlash !== undefined && !valid.includes(trailingSlash)) {
+        problems.push(`\`trailingSlash\` sólo acepta ${valid.join(', ')}; se recibió "${trailingSlash}".`);
+    }
+}
+function checkPublicEnv({ publicEnv }, problems) {
+    if (publicEnv === undefined)
+        return;
+    if (!Array.isArray(publicEnv)) {
+        return void problems.push('`publicEnv` tiene que ser una lista de nombres de variable.');
+    }
+    for (const name of publicEnv) {
+        if (typeof name !== 'string' || !name.trim()) {
+            problems.push('`publicEnv` sólo admite nombres de variable no vacíos.');
+            break;
+        }
+    }
+}
+/** Las tres son funciones para que el proyecto pueda calcularlas al arrancar. */
+function checkCallable(config, problems) {
+    for (const key of ['redirects', 'rewrites', 'headers']) {
+        const value = config[key];
+        if (value !== undefined && typeof value !== 'function') {
+            problems.push(`\`${key}\` tiene que ser una función que devuelve la lista, no la lista. ` +
+                'Así el proyecto puede calcularla al arrancar.');
+        }
+    }
+}
+function checkAssets({ assets }, problems) {
+    const prefix = assets?.cdnPrefix;
+    if (prefix === undefined)
+        return;
+    if (typeof prefix !== 'string' || !/^(https?:)?\/\//.test(prefix)) {
+        problems.push('`assets.cdnPrefix` tiene que ser una URL absoluta o empezar con `//`: ' +
+            'los artefactos se sirven desde otro origen.');
+    }
+}
+function checkIsr({ isr }, problems) {
+    if (isr === undefined)
+        return;
+    if (typeof isr !== 'object' || isr === null) {
+        return void problems.push('`isr` tiene que ser un objeto.');
+    }
+    for (const key of ['maxEntries', 'maxBytes', 'generationTimeoutMs']) {
+        const value = isr[key];
+        if (value !== undefined && !(Number.isInteger(value) && value > 0)) {
+            problems.push(`\`isr.${key}\` tiene que ser un entero mayor que cero.`);
+        }
+    }
+    if (isr.sharedCache !== undefined && !['auto', 'always', 'never'].includes(isr.sharedCache)) {
+        problems.push("`isr.sharedCache` sólo acepta 'auto', 'always' o 'never'.");
+    }
+    if (isr.dev !== undefined && typeof isr.dev !== 'boolean') {
+        problems.push('`isr.dev` tiene que ser un booleano.');
+    }
+    // Un secreto corto se adivina: la vista previa renderiza con cookies y
+    // credenciales, así que es una puerta hacia contenido no público.
+    if (isr.previewSecret !== undefined && (typeof isr.previewSecret !== 'string' || isr.previewSecret.length < 16)) {
+        problems.push('`isr.previewSecret` tiene que ser una cadena de al menos 16 caracteres.');
+    }
+}
+/**
+ * `dev` ya no es una clave que el framework consulte: `dev.hmr` y
+ * `dev.prettyErrors` no tenían ningún efecto (R-12) y se retiraron. Declararla
+ * falla al arrancar en vez de quedar leída y descartada en silencio.
+ */
+function checkDev({ dev }, problems) {
+    if (dev === undefined)
+        return;
+    problems.push('`dev` ya no es una clave reconocida por el framework: `dev.hmr` y ' +
+        '`dev.prettyErrors` no tenían efecto y se retiraron. Sacá esta clave de ' +
+        'tu configuración.');
+}
+/**
+ * Comprueba las reglas que devolvieron `redirects`, `rewrites` y `headers`.
+ *
+ * Se hace después de invocarlas, no en `validateConfig`, porque hasta ese momento
+ * son funciones sin ejecutar.
+ */
+function validateRules(redirects, rewrites, headers) {
+    const problems = [];
+    for (const [index, rule] of redirects.entries()) {
+        if (!rule?.source || !rule?.destination) {
+            problems.push(`La redirección #${index + 1} necesita \`source\` y \`destination\`.`);
+        }
+    }
+    for (const [index, rule] of rewrites.entries()) {
+        if (!rule?.source || !rule?.destination) {
+            problems.push(`La reescritura #${index + 1} necesita \`source\` y \`destination\`.`);
+        }
+    }
+    for (const [index, rule] of headers.entries()) {
+        if (!rule?.source || !Array.isArray(rule?.headers)) {
+            problems.push(`La regla de cabeceras #${index + 1} necesita \`source\` y \`headers\`.`);
+        }
+    }
+    if (problems.length) {
+        throw new Error(`[ress] La configuración tiene reglas inválidas:\n` + problems.map((p) => `  · ${p}`).join('\n'));
+    }
+}

package/dist/config/watch.d.ts

@@ -0,0 +1,53 @@
+import type { ResolvedConfig } from './types';
+/**
+ * Recarga de la configuración en desarrollo.
+ *
+ * Se observa la carpeta `config/`: cualquiera de sus capas, no sólo la del modo
+ * activo, porque `default` y `local` también participan de la fusión.
+ */
+/**
+ * Claves que se pueden aplicar sin reiniciar.
+ *
+ * Todas se consultan al atender una petición, así que la siguiente ya ve el
+ * valor nuevo.
+ */
+export declare const HOT_KEYS: readonly ["redirects", "rewrites", "headers", "trailingSlash"];
+/**
+ * Claves que exigen reiniciar, y por qué.
+ *
+ * El framework lo dice nombrando la clave en vez de aplicar la mitad de la
+ * configuración: media configuración aplicada es un estado que nadie declaró y
+ * que produce errores que no se corresponden con ningún archivo.
+ */
+export declare const RESTART_REASONS: Record<string, string>;
+/**
+ * Claves que se leen al construir la aplicación de servidor de ress —el
+ * router, la caché incremental, los middlewares de la vía de escape—, no el
+ * servidor de Vite.
+ *
+ * Reiniciar Vite no las aplica: la CLI arma esa aplicación una sola vez, fuera
+ * de Vite. Para ellas no se reinicia nada ni se dice que se reinició: se pide
+ * detener y volver a arrancar `ress dev`.
+ */
+export declare const MANUAL_RESTART_KEYS: ReadonlySet<string>;
+/** Qué claves de primer nivel cambiaron entre dos configuraciones resueltas. */
+export declare function changedKeys(previous: ResolvedConfig, next: ResolvedConfig): string[];
+/** Si alguna de las claves cambiadas exige volver a arrancar `ress dev` a mano. */
+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;
+/** ¿Este archivo es una capa de configuración del proyecto? */
+export declare function isConfigLayer(file: string, root: string): boolean;
+export interface WatchConfigOptions {
+    root: string;
+    mode: string;
+    /** La configuración vigente, para comparar contra la nueva. */
+    current: () => ResolvedConfig;
+    /** Qué hacer con la configuración nueva cuando se puede aplicar en caliente. */
+    onReload: (config: ResolvedConfig) => void;
+    /** Qué hacer cuando hace falta reiniciar. Por defecto, pedírselo a Vite. */
+    onRestart?: (reason: string) => void;
+    log?: (message: string) => void;
+}
+/** Conecta el observador de Vite con la carpeta de configuración. */
+export declare function watchConfig(server: any, options: WatchConfigOptions): void;