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

package/dist/plugin/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Plugin de ress.js para Vite.
+ *
+ * Único punto de entrada de configuración para un proyecto:
+ *
+ * ```ts
+ * import { defineConfig } from 'vite'
+ * import { ressPlugin } from '@ressjs/vite-router/plugin'
+ *
+ * export default defineConfig({ plugins: [ressPlugin()] })
+ * ```
+ */
+import { defineEnvironments, OUT_DIR } from './environments';
+import type { VariantCatalog } from '../variants/types';
+import { type ExtensionPolicy } from '../fs/module-extensions';
+import { type SecurityOptions } from '../security';
+/**
+ * El tipo `Plugin` de Vite se declara estructuralmente en vez de importarse,
+ * para que este paquete no dependa del tipo en tiempo de compilación. Vite es
+ * una dependencia entre pares: el consumidor la aporta.
+ */
+export interface RessPlugin {
+    name: string;
+    /** Opcional: el guard de `@ressjs/config` sólo aporta `resolveId`. */
+    config?: (userConfig: unknown, env: {
+        command: string;
+        mode: string;
+    }) => Promise<unknown> | unknown;
+    resolveId?: (id: string, importer?: string, options?: unknown) => string | undefined | null;
+    load?: (id: string) => string | undefined;
+    configureServer?: (server: any) => void;
+    writeBundle?: () => Promise<void> | void;
+}
+export declare function getVariantCatalog(): VariantCatalog | undefined;
+export declare function refreshVariantCatalog(): Promise<VariantCatalog>;
+export interface RessPluginOptions {
+    security?: SecurityOptions;
+    /**
+     * Qué extensiones acepta el proyecto. Se fusiona sobre los defaults una vez al
+     * arrancar. F-008 la absorbe cuando exista el archivo de configuración.
+     */
+    extensions?: Partial<ExtensionPolicy>;
+}
+/**
+ * El plugin del framework.
+ *
+ * Devuelve dos: el propio y el guard que impide que `@ressjs/config` —valores de
+ * servidor, credenciales incluidas— termine en el paquete del navegador. El
+ * segundo no se agrega a mano justamente porque olvidarse es el modo de fallo que
+ * existe para evitar.
+ */
+export declare function ressPlugin(options?: RessPluginOptions): RessPlugin[];
+export declare function ressCorePlugin(options?: RessPluginOptions): RessPlugin;
+export { defineEnvironments, OUT_DIR };

package/dist/plugin/index.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Plugin de ress.js para Vite.
+ *
+ * Único punto de entrada de configuración para un proyecto:
+ *
+ * ```ts
+ * import { defineConfig } from 'vite'
+ * import { ressPlugin } from '@ressjs/vite-router/plugin'
+ *
+ * export default defineConfig({ plugins: [ressPlugin()] })
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUT_DIR = exports.defineEnvironments = void 0;
+exports.getVariantCatalog = getVariantCatalog;
+exports.refreshVariantCatalog = refreshVariantCatalog;
+exports.ressPlugin = ressPlugin;
+exports.ressCorePlugin = ressCorePlugin;
+const environments_1 = require("./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; } });
+const pages_1 = require("../pages");
+const catalog_1 = require("../variants/catalog");
+const virtual_entries_1 = require("./virtual-entries");
+const scan_1 = require("../routes/scan");
+const module_extensions_1 = require("../fs/module-extensions");
+const manifest_1 = require("../routes/manifest");
+const security_1 = require("../security");
+const config_1 = require("@ressjs/config");
+const config_2 = require("../config");
+/**
+ * Catálogo vigente del proceso.
+ *
+ * Se arma una vez y lo comparten el build y el servidor: es lo que garantiza que
+ * las entradas que se construyen y las que se resuelven por petición salgan de la
+ * misma fuente.
+ */
+let current;
+function getVariantCatalog() {
+    return current;
+}
+async function refreshVariantCatalog() {
+    current = await (0, catalog_1.buildVariantCatalog)({ pages: (0, pages_1.getPages)() });
+    return current;
+}
+async function resolveInputs() {
+    const catalog = await refreshVariantCatalog();
+    return {
+        client: (0, virtual_entries_1.clientBuildInputs)(catalog),
+        ssr: (0, pages_1.getViteSSRInput)(),
+    };
+}
+/**
+ * El plugin del framework.
+ *
+ * Devuelve dos: el propio y el guard que impide que `@ressjs/config` —valores de
+ * servidor, credenciales incluidas— termine en el paquete del navegador. El
+ * segundo no se agrega a mano justamente porque olvidarse es el modo de fallo que
+ * existe para evitar.
+ */
+function ressPlugin(options = {}) {
+    return [ressCorePlugin(options), (0, config_1.configServerOnlyGuard)()];
+}
+function ressCorePlugin(options = {}) {
+    const security = (0, security_1.resolveSecurityOptions)(options.security);
+    /** Raíz del proyecto según Vite; puede no ser el directorio de trabajo. */
+    let root = process.cwd();
+    let manifestWritten = false;
+    let extensions = { ...module_extensions_1.DEFAULT_EXTENSION_POLICY, ...options.extensions };
+    /** La configuración del proyecto, vigente desde el hook `config`. */
+    let config;
+    return {
+        name: 'ress',
+        /**
+         * Se aporta desde `config` y no desde `configResolved` para que la
+         * configuración del usuario se fusione encima siguiendo las reglas normales
+         * de Vite, en vez de ser sobrescrita por el framework.
+         */
+        async config(userConfig, env) {
+            // Se verifica acá, con la configuración del proyecto ya visible y antes de
+            // que el servidor escuche. Un aviso en la consola de un servidor de
+            // desarrollo no lo lee nadie; un error de arranque sí.
+            root = userConfig?.root ?? process.cwd();
+            // La configuración del proyecto se lee antes que nada: declara qué
+            // extensiones son código de usuario, bajo qué prefijo se sirve todo y qué
+            // variables llegan al navegador, y las tres decisiones condicionan lo que
+            // este hook devuelve.
+            config = await (0, config_2.loadConfig)(root, env?.mode ?? 'development');
+            extensions = { ...extensions, ...config.extensions };
+            await (0, config_2.writeGeneratedTypes)(root, {
+                'ress-platform.d.ts': (0, config_2.generatePlatformTypes)(config.platform),
+                'ress-config.d.ts': (0, config_2.generateProjectConfigTypes)((await import('@ressjs/config')).resolved()),
+            });
+            // Se fija acá y no al construir el plugin: `current` es estado global del
+            // proceso, así que crear un objeto de plugin —dos configuraciones en un
+            // mismo proceso, un test que lo importa— reescribiría la política que leen
+            // el descubrimiento y el escaneo de rutas.
+            (0, module_extensions_1.setExtensionPolicy)(extensions);
+            if (env?.command === 'serve')
+                (0, security_1.assertDevServerHardening)(userConfig);
+            return {
+                ...(0, environments_1.defineEnvironments)(await resolveInputs()),
+                // Sólo al construir: en desarrollo el prefijo lo quita el pipeline de
+                // petición antes de que Vite vea la URL, así que su `base` sigue siendo
+                // `/`. Al construir sí tiene que quedar escrito en las referencias que
+                // los artefactos hacen entre sí.
+                ...(config.basePath && env?.command === 'build'
+                    ? { base: config.basePath + '/' }
+                    : {}),
+                // Sólo lo declarado en `publicEnv`. Lo demás no queda como `undefined`
+                // en el navegador: queda como código que nunca se generó.
+                ...(config.publicEnv.length
+                    ? { define: (0, config_2.publicEnvDefines)(config.publicEnv, { strict: env?.command === 'build' }) }
+                    : {}),
+                ...(env?.command === 'serve'
+                    ? { server: (0, security_1.devServerDefaults)(security.dev.allowedOrigins) }
+                    : {}),
+            };
+        },
+        /**
+         * Emite el manifest de rutas junto al build.
+         *
+         * Cargarlo en producción es lo que evita volver a recorrer el sistema de
+         * archivos en cada arranque para deducir algo que ya no puede cambiar.
+         *
+         * El hook corre una vez por entorno —cliente y servidor— y el manifest es
+         * el mismo para los dos, así que se escribe una sola vez.
+         */
+        async writeBundle() {
+            if (manifestWritten)
+                return;
+            manifestWritten = true;
+            const { writeFile, mkdir } = await import('node:fs/promises');
+            const path = await import('node:path');
+            const data = await (0, scan_1.scanRoutes)({ strict: true, pagesDir: path.join(root, 'app/pages') });
+            const target = path.resolve(root, environments_1.OUT_DIR.base);
+            await mkdir(target, { recursive: true });
+            await writeFile(path.join(target, 'route-manifest.json'), (0, manifest_1.serializeRouteManifest)(data), 'utf-8');
+        },
+        resolveId(id) {
+            return (0, virtual_entries_1.resolveEntryId)(id);
+        },
+        load(id) {
+            const parsed = (0, virtual_entries_1.parseEntryId)(id);
+            if (!parsed || !current)
+                return undefined;
+            return (0, virtual_entries_1.generateEntryModule)(current, parsed.pageId, parsed.suffix);
+        },
+        /**
+         * Rearma el catálogo cuando cambia el **conjunto** de archivos, no su
+         * contenido: agregar o borrar una hoja de estilos cambia qué variantes
+         * declara una página, y eso tiene que reflejarse sin reiniciar. Los cambios
+         * de contenido los maneja la recarga en caliente de Vite.
+         */
+        configureServer(server) {
+            const declaresVariants = (file) => file.includes('app/pages/') || file.includes('app\\pages\\');
+            const rebuild = (file) => {
+                if (declaresVariants(file))
+                    void refreshVariantCatalog();
+            };
+            server.watcher?.on('add', rebuild);
+            server.watcher?.on('unlink', rebuild);
+            // Las dos superficies de configuración. Observar sólo `ress.config` dejaba
+            // mudo el cambio de una capa de `config/`.
+            if (config) {
+                (0, config_2.watchConfig)(server, {
+                    root,
+                    mode: server.config?.mode ?? 'development',
+                    current: () => config,
+                    onReload: (next) => {
+                        config = next;
+                    },
+                });
+            }
+        },
+    };
+}

package/dist/plugin/virtual-entries.d.ts

@@ -0,0 +1,26 @@
+import type { VariantCatalog } from '../variants/types';
+declare const PREFIX = "ress:entry";
+declare const RESOLVED: string;
+/** ¿Es el identificador de una entrada de build del catálogo? */
+export declare function isEntryId(id: string): boolean;
+export declare function resolveEntryId(id: string): string | undefined;
+/** Extrae página y variante del identificador. */
+export declare function parseEntryId(id: string): {
+    pageId: string;
+    suffix: string;
+} | undefined;
+/**
+ * Genera el módulo de hidratación de una página en una variante.
+ *
+ * Se escribe con `createElement` y no con JSX a propósito: así el módulo no
+ * depende de la transformación JSX ni de una extensión concreta, que es lo que
+ * permite que una página escrita en JavaScript se hidrate con el mismo código
+ * que una escrita en TypeScript.
+ */
+export declare function generateEntryModule(catalog: VariantCatalog, pageId: string, variantSuffix: string): string;
+/**
+ * Qué le pasa el framework al empaquetador como entradas del entorno de cliente:
+ * una por página y variante, cada una apuntando a su módulo virtual.
+ */
+export declare function clientBuildInputs(catalog: VariantCatalog): Record<string, string>;
+export { PREFIX as ENTRY_PREFIX, RESOLVED as ENTRY_RESOLVED_PREFIX };

package/dist/plugin/virtual-entries.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTRY_RESOLVED_PREFIX = exports.ENTRY_PREFIX = void 0;
+exports.isEntryId = isEntryId;
+exports.resolveEntryId = resolveEntryId;
+exports.parseEntryId = parseEntryId;
+exports.generateEntryModule = generateEntryModule;
+exports.clientBuildInputs = clientBuildInputs;
+const node_path_1 = __importDefault(require("node:path"));
+const catalog_1 = require("../variants/catalog");
+const PREFIX = 'ress:entry';
+exports.ENTRY_PREFIX = PREFIX;
+const RESOLVED = '\0' + PREFIX;
+exports.ENTRY_RESOLVED_PREFIX = RESOLVED;
+/** ¿Es el identificador de una entrada de build del catálogo? */
+function isEntryId(id) {
+    return id.startsWith(PREFIX) || id.startsWith(RESOLVED);
+}
+function resolveEntryId(id) {
+    return id.startsWith(PREFIX) ? '\0' + id : undefined;
+}
+/** Extrae página y variante del identificador. */
+function parseEntryId(id) {
+    if (!id.startsWith(RESOLVED))
+        return undefined;
+    const query = id.slice(RESOLVED.length + 1); // salta el '?'
+    const params = new URLSearchParams(query);
+    const pageId = params.get('page');
+    if (!pageId)
+        return undefined;
+    return { pageId, suffix: params.get('variant') ?? '' };
+}
+/**
+ * Genera el módulo de hidratación de una página en una variante.
+ *
+ * Se escribe con `createElement` y no con JSX a propósito: así el módulo no
+ * depende de la transformación JSX ni de una extensión concreta, que es lo que
+ * permite que una página escrita en JavaScript se hidrate con el mismo código
+ * que una escrita en TypeScript.
+ */
+function generateEntryModule(catalog, pageId, variantSuffix) {
+    const page = catalog.pagesById.get(pageId);
+    if (!page) {
+        throw new Error(`[ress] No hay ninguna página con el identificador "${pageId}".`);
+    }
+    const variant = catalog.variantsByPage
+        .get(pageId)
+        ?.find((v) => v.suffix === variantSuffix);
+    if (!variant) {
+        throw new Error(`[ress] La página "${pageId}" no declara la variante "${variantSuffix || '(base)'}".`);
+    }
+    const pageAbs = node_path_1.default.resolve(page.pageFile).replace(/\\/g, '/');
+    const styleImport = variant.styleFile
+        ? `import ${JSON.stringify(node_path_1.default.resolve(variant.styleFile).replace(/\\/g, '/'))};\n`
+        : '';
+    return `${styleImport}import { hydrateRoot } from "react-dom/client";
+import { StrictMode, createElement } from "react";
+import Page from ${JSON.stringify(pageAbs)};
+
+const props = window.__RESS_PROPS__ || window.__INITIAL_PROPS__ || {};
+const root = document.getElementById("root");
+
+if (root) {
+  hydrateRoot(root, createElement(StrictMode, null, createElement(Page, props)));
+}
+`;
+}
+/**
+ * Qué le pasa el framework al empaquetador como entradas del entorno de cliente:
+ * una por página y variante, cada una apuntando a su módulo virtual.
+ */
+function clientBuildInputs(catalog) {
+    return Object.fromEntries(catalog.buildEntries.map((entry) => [
+        (0, catalog_1.buildEntryNameFor)(entry.pageId, entry.variant.suffix),
+        entry.virtualId,
+    ]));
+}

package/dist/render.d.ts

@@ -1,18 +1,39 @@
 import { RequestHandler } from 'express';
+import type { ModuleLoader } from './runtime/module-loader';
+import type { ClientPropsPolicy } from './security';
 /**
  * RENDER MIDDLEWARE PARA EL ROUTER
  */
 export declare function createRenderMiddleware(page: any, options: any): RequestHandler;
 export interface RenderOptions {
     url: string;
+    /**
+     * La página que el despachador ya resolvió.
+     *
+     * Sin esto el render vuelve a buscarla por URL, con un criterio propio que no
+     * conoce grupos ni catch-all: dos resoluciones distintas para la misma
+     * pregunta, que es el defecto que esta spec elimina.
+     */
+    page?: {
+        route: string;
+        file: string;
+        pageId?: string;
+        abs?: string;
+    };
     props?: any;
+    /** Estado que dejaron los middlewares. Sólo viaja al cliente lo que la política declara. */
+    locals?: Record<string, unknown>;
 }
 export interface CreateRenderServerOptions {
-    vite?: any;
+    /** Cargador de módulos. Ausente en producción: se importa el artefacto compilado. */
+    moduleLoader?: ModuleLoader;
+    /** Qué claves del estado del servidor viajan al cliente. */
+    clientProps?: ClientPropsPolicy;
+    isProduction?: boolean;
 }
 export declare function createRenderServer(options?: CreateRenderServerOptions): (renderOptions: RenderOptions) => Promise<{
     html: string;
-    props: any;
+    props: Record<string, unknown>;
     route: string;
     page: string;
 }>;

package/dist/render.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -42,6 +9,8 @@ const react_1 = __importDefault(require("react"));
 const server_1 = require("react-dom/server");
 const pages_1 = require("./pages");
 const request_handler_1 = require("./helpers/request-handler");
+const prod_server_1 = require("./runtime/prod-server");
+const security_1 = require("./security");
 /**
  * RENDER MIDDLEWARE PARA EL ROUTER
  */
@@ -57,9 +26,11 @@ function createRenderMiddleware(page, options) {
 }
 function createRenderServer(options = {}) {
     const pages = (0, pages_1.getPages)();
-    const { vite } = options;
+    const { moduleLoader } = options;
+    const policy = options.clientProps ?? (0, security_1.resolveSecurityOptions)().clientProps;
+    const isProduction = options.isProduction ?? process.env.NODE_ENV === 'production';
     return async (renderOptions) => {
-        const { url, props = {} } = renderOptions;
+        const { url, props = {}, locals = {}, page } = renderOptions;
         // Encuentra la página que coincide con la URL
         // Función helper para hacer matching de rutas dinámicas
         const matchRoute = (pageRoute, url) => {
@@ -77,28 +48,18 @@ function createRenderServer(options = {}) {
             const regex = new RegExp(`^${regexPattern}$`);
             return regex.test(url);
         };
-        const matchedPage = pages.find(page => matchRoute(page.route, url));
+        const matchedPage = page ?? pages.find(p => matchRoute(p.route, url));
         if (!matchedPage) {
             throw new Error(`Page not found for URL: ${url}`);
         }
         try {
-            // Import dinámico de la página usando vite.ssrLoadModule si está disponible
             let pageModule;
-            if (vite) {
-                // En desarrollo: usar vite.ssrLoadModule para manejar .tsx
-                const modulePath = `/${matchedPage.file}`;
-                pageModule = await vite.ssrLoadModule(modulePath);
+            if (moduleLoader) {
+                pageModule = await moduleLoader.load(`/${matchedPage.file}`);
             }
             else {
-                // En producción: usar import directo del archivo compilado
-                const moduleUrl = (0, pages_1.getCompiledProdPage)(matchedPage.abs);
-                try {
-                    pageModule = await Promise.resolve(`${moduleUrl}`).then(s => __importStar(require(s)));
-                }
-                catch (importError) {
-                    console.error('Error loading module:', importError);
-                    throw importError;
-                }
+                const moduleUrl = (0, prod_server_1.resolveServerModulePath)(matchedPage.abs ?? matchedPage.file);
+                pageModule = await import(/* @vite-ignore */ moduleUrl);
             }
             const PageComponent = pageModule.default;
             if (!PageComponent) {
@@ -113,9 +74,17 @@ function createRenderServer(options = {}) {
             };
             // Renderiza el componente con las props finales
             const html = (0, server_1.renderToString)(react_1.default.createElement(PageComponent, finalProps));
-            // Evitar mandar htmlConfig al cliente
-            const { htmlConfig, serverSideProps, ...rest } = finalProps;
-            const clientProps = serverSideProps || rest;
+            // El componente ya recibió todo arriba. Lo que viaja al cliente es sólo
+            // lo que la política declara: enumerar lo que se excluye deja expuesta
+            // cada clave que un middleware agregue después.
+            //
+            // `serverSideProps` es lo que la página pidió explícitamente para el
+            // cliente; el resto de `res.locals` es estado del servidor y no viaja
+            // salvo que se declare.
+            const exposable = { ...locals, serverSideProps: props };
+            const clientProps = (0, security_1.pickClientProps)(exposable, policy);
+            if (!isProduction)
+                warnWithheld(matchedPage.route, exposable, clientProps);
             return {
                 html,
                 props: clientProps,
@@ -129,3 +98,21 @@ function createRenderServer(options = {}) {
         }
     };
 }
+/**
+ * Avisa, una vez por ruta, qué quedó fuera del cliente.
+ *
+ * Una página que renderiza en el servidor con datos que el cliente no tiene
+ * hidrata distinto, y ese desajuste no dice de dónde viene. El aviso lo nombra.
+ */
+const warnedRoutes = new Set();
+function warnWithheld(route, serverProps, clientProps) {
+    if (warnedRoutes.has(route))
+        return;
+    const withheld = (0, security_1.withheldKeys)(serverProps, clientProps);
+    if (withheld.length === 0)
+        return;
+    warnedRoutes.add(route);
+    console.warn(`[ress] ${route}: estas claves existen en el servidor y no viajan al cliente: ` +
+        `${withheld.join(', ')}.\n` +
+        'Si la página las usa al hidratar, declaralas en `security.clientProps.expose`.');
+}

package/dist/router.d.ts

@@ -1,27 +1,46 @@
 import { Router } from 'express';
+import type { RessRuntime } from './runtime/dev-server';
+import type { ModuleLoader } from './runtime/module-loader';
+import { type ResolvedSecurityOptions, type SecurityOptions } from './security';
+import { type ResolvedConfig } from './config';
+/** Espera a que el runtime, el manifest y las cadenas de middleware estén listos. */
+export declare function waitForViteRouter(router: Router): Promise<void>;
 export interface ViteRouterOptions {
     enablePlatformDetection?: boolean;
     isProduction?: boolean;
-    pagesDirectory?: string;
     basePath?: string;
-    vite?: any;
+    /** Runtime ya construido, para quien lo arma por su cuenta. */
+    runtime?: RessRuntime;
+    /** Cargador de módulos, para quien arma su propio servidor. */
+    moduleLoader?: ModuleLoader;
     templateHtml?: string;
     renderFunction?: (options: {
         url: string;
         platform: string;
         req: any;
     }) => Promise<string>;
+    /** Opciones de seguridad ya resueltas. F-008 las tomará de `ress.config.ts`. */
+    security?: ResolvedSecurityOptions;
+    /** Opciones de seguridad sin resolver; se completan con los defaults. */
+    securityOptions?: SecurityOptions;
+    /**
+     * Configuración del proyecto ya resuelta. Si no se aporta, se carga de
+     * `ress.config` al arrancar: es el archivo que el proyecto ya declara, y
+     * exigir pasarla a mano deja al servidor y al build leyendo cosas distintas.
+     */
+    config?: ResolvedConfig;
+    /** Raíz del proyecto, para leer la configuración. */
+    root?: string;
+    /** Modo con el que se resuelven las capas de configuración. */
+    mode?: string;
 }
-export interface AutoViteServerOptions {
-    port?: number;
-    base?: string;
-    enablePlatformDetection?: boolean;
-}
-export declare function createAutoViteServer(options?: AutoViteServerOptions): Promise<{
-    app: import("express-serve-static-core").Express;
-    vite: any;
-    start: () => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
-}>;
+/**
+ * El router de ress.js.
+ *
+ * Antes había dos constructores con el 90 % del cuerpo repetido, uno para quien
+ * deja que el framework arme el runtime y otro para quien lo aporta. La
+ * diferencia real entre los dos es de dónde sale el runtime, así que eso es lo
+ * único que se decide acá; el resto del camino es uno solo.
+ */
 export declare function createViteRouter(options?: ViteRouterOptions): Router;
-export declare function listDetectedPages(): import("./pages").PageInfo[];
 export { getPages } from './pages';