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

package/dist/variants/assets.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDevAssetIndex = createDevAssetIndex;
+exports.createProdAssetIndex = createProdAssetIndex;
+const catalog_1 = require("./catalog");
+/**
+ * Artefactos en desarrollo.
+ *
+ * Vite sirve el módulo virtual directamente, así que el guion es su propia URL.
+ * Los estilos no se listan porque el módulo los importa y Vite los inyecta.
+ */
+function createDevAssetIndex(catalog, base = '/') {
+    return {
+        find(pageId, variantSuffix) {
+            const variants = catalog.variantsByPage.get(pageId);
+            if (!variants?.some((v) => v.suffix === variantSuffix))
+                return undefined;
+            // El prefijo lo agrega el framework, no Vite: el pipeline de petición lo
+            // quita antes de que Vite vea la URL, así que su propio `base` es `/`.
+            return { js: joinBase(base, '@id/' + (0, catalog_1.virtualModuleIdFor)(pageId, variantSuffix)), css: [] };
+        },
+    };
+}
+/**
+ * Artefactos en producción, tomados del manifest del cliente.
+ *
+ * El manifest se lee una vez al arrancar y se pasa a un índice por página y
+ * variante, de modo que servir una petición sea una consulta en memoria y no una
+ * búsqueda.
+ */
+function createProdAssetIndex(catalog, manifest, base = '/') {
+    const byPageAndVariant = new Map();
+    // El manifest indexa por el identificador de la entrada, que para un módulo
+    // virtual conserva el prefijo con el que se declaró.
+    const byEntryName = new Map();
+    for (const chunk of Object.values(manifest)) {
+        if (chunk.name)
+            byEntryName.set(chunk.name, chunk);
+    }
+    for (const entry of catalog.buildEntries) {
+        const entryName = (0, catalog_1.buildEntryNameFor)(entry.pageId, entry.variant.suffix);
+        const chunk = manifest[entry.virtualId] ??
+            manifest[NULL_BYTE + entry.virtualId] ??
+            byEntryName.get(entryName) ??
+            findByFilename(manifest, entryName);
+        if (!chunk)
+            continue;
+        byPageAndVariant.set(key(entry.pageId, entry.variant.suffix), {
+            js: joinBase(base, chunk.file),
+            css: (chunk.css ?? []).map((f) => joinBase(base, f)),
+        });
+    }
+    return { find: (pageId, variantSuffix) => byPageAndVariant.get(key(pageId, variantSuffix)) };
+}
+/** Prefijo con el que los empaquetadores marcan un módulo virtual resuelto. */
+const NULL_BYTE = String.fromCharCode(0);
+/**
+ * Respaldo por nombre de archivo.
+ *
+ * Los identificadores virtuales pueden aparecer saneados en el manifest según
+ * cómo el empaquetador normalice los caracteres del query, así que se busca
+ * además el artefacto cuyo nombre empiece por el de la entrada.
+ */
+function findByFilename(manifest, entryName) {
+    const target = entryName.replace(/[^a-zA-Z0-9_.-]/g, '_');
+    return Object.values(manifest).find((c) => {
+        const file = c.file.split('/').pop() ?? '';
+        return file.startsWith(target + '-') || file.startsWith(target + '.');
+    });
+}
+const key = (pageId, variantSuffix) => `${pageId} ${variantSuffix}`;
+function joinBase(base, file) {
+    // `/` ya es el prefijo absoluto; concatenarlo como `b + file` producía
+    // `//assets/...`, que el navegador interpreta como un host distinto. El
+    // mismo error rompía en desarrollo la URL `//@id/ress:entry...`.
+    const prefix = base === '/' ? '' : base.endsWith('/') ? base.slice(0, -1) : base;
+    return `${prefix}/${file.replace(/^\/+/, '')}`;
+}

package/dist/variants/catalog.d.ts

@@ -0,0 +1,33 @@
+import type { PageInfo } from '../pages';
+import type { VariantCatalog, PlatformRegistry } from './types';
+export interface CatalogOptions {
+    pages: PageInfo[];
+    registry?: PlatformRegistry;
+}
+/**
+ * Identificador estable de una página, compartido con el manifest de rutas.
+ *
+ * Los separadores y los corchetes de parámetro se sanean porque el identificador
+ * termina siendo el nombre de una entrada de build.
+ */
+export declare function pageIdFromFile(pageFile: string): string;
+/** Identificador del módulo virtual que hidrata esta página en esta variante. */
+export declare function virtualModuleIdFor(pageId: string, suffix: string): string;
+/**
+ * Nombre de la entrada de build de una página en una variante.
+ *
+ * El sufijo se une con `--` y sus puntos internos se vuelven guiones porque el
+ * empaquetador interpreta el ultimo punto del nombre de una entrada como su
+ * extension: con `page1__index.webview.android`, el artefacto de estilos sale
+ * como `page1__index.webview.css` y pierde el eje que lo distingue.
+ */
+export declare function buildEntryNameFor(pageId: string, suffix: string): string;
+/**
+ * Arma el catálogo: recorre las páginas y averigua qué variantes declara cada una.
+ *
+ * Corre **una sola vez** —al arrancar el servidor de desarrollo y al construir— y
+ * nunca durante una petición. Qué variantes existen lo deciden los archivos del
+ * proyecto, así que dos ejecuciones sobre el mismo árbol producen el mismo
+ * catálogo, y el build no depende de qué clientes visitaron el sitio antes.
+ */
+export declare function buildVariantCatalog(opts: CatalogOptions): Promise<VariantCatalog>;

package/dist/variants/catalog.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pageIdFromFile = pageIdFromFile;
+exports.virtualModuleIdFor = virtualModuleIdFor;
+exports.buildEntryNameFor = buildEntryNameFor;
+exports.buildVariantCatalog = buildVariantCatalog;
+const module_extensions_1 = require("../fs/module-extensions");
+const platform_tokens_1 = require("./platform-tokens");
+const assets_1 = require("@ressjs/assets");
+/**
+ * Identificador estable de una página, compartido con el manifest de rutas.
+ *
+ * Los separadores y los corchetes de parámetro se sanean porque el identificador
+ * termina siendo el nombre de una entrada de build.
+ */
+function pageIdFromFile(pageFile) {
+    return pageFile
+        .replace(/^app\/pages\//, '')
+        .replace(/\.[^./]+$/, '')
+        .replace(/\//g, '__')
+        .replace(/\[([^\]]+)\]/g, '_$1_');
+}
+/** Identificador del módulo virtual que hidrata esta página en esta variante. */
+function virtualModuleIdFor(pageId, suffix) {
+    return `ress:entry?page=${pageId}&variant=${encodeURIComponent(suffix)}`;
+}
+/**
+ * Nombre de la entrada de build de una página en una variante.
+ *
+ * El sufijo se une con `--` y sus puntos internos se vuelven guiones porque el
+ * empaquetador interpreta el ultimo punto del nombre de una entrada como su
+ * extension: con `page1__index.webview.android`, el artefacto de estilos sale
+ * como `page1__index.webview.css` y pierde el eje que lo distingue.
+ */
+function buildEntryNameFor(pageId, suffix) {
+    return suffix ? `${pageId}--${suffix.replace(/\./g, '-')}` : pageId;
+}
+/**
+ * Arma el catálogo: recorre las páginas y averigua qué variantes declara cada una.
+ *
+ * Corre **una sola vez** —al arrancar el servidor de desarrollo y al construir— y
+ * nunca durante una petición. Qué variantes existen lo deciden los archivos del
+ * proyecto, así que dos ejecuciones sobre el mismo árbol producen el mismo
+ * catálogo, y el build no depende de qué clientes visitaron el sitio antes.
+ */
+async function buildVariantCatalog(opts) {
+    const registry = opts.registry ?? platform_tokens_1.defaultPlatformRegistry;
+    const buildEntries = [];
+    const variantsByPage = new Map();
+    const pagesById = new Map();
+    for (const page of opts.pages) {
+        const pageId = pageIdFromFile(page.file);
+        // La extensión la recorta el módulo canónico: los archivos de estilos de una
+        // página `.jsx` se descubren igual que los de una `.tsx`.
+        const base = (0, module_extensions_1.stripScriptExtension)(page.file);
+        const variants = (await (0, assets_1.discoverStyleVariants)(base, registry)).map((variant) => ({
+            suffix: variant.suffix,
+            tags: variant.tags,
+            styleFile: variant.sourceFile,
+        }));
+        variantsByPage.set(pageId, variants);
+        pagesById.set(pageId, { route: page.route, pageFile: page.file });
+        for (const variant of variants) {
+            buildEntries.push({
+                pageId,
+                route: page.route,
+                pageFile: page.file,
+                variant,
+                virtualId: virtualModuleIdFor(pageId, variant.suffix),
+            });
+        }
+    }
+    // Orden estable: el resultado no debe depender de cómo el sistema de archivos
+    // devuelva los nombres.
+    buildEntries.sort((a, b) => a.pageId === b.pageId
+        ? a.variant.suffix.localeCompare(b.variant.suffix)
+        : a.pageId.localeCompare(b.pageId));
+    return { buildEntries, variantsByPage, pagesById };
+}

package/dist/variants/platform-tokens.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Qué tokens de plataforma son válidos y a qué eje pertenece cada uno.
+ *
+ * El vocabulario vive en `@ressjs/platform`, que no depende del router: es la
+ * misma autoridad que consultan el puente del WebView, el cliente y la
+ * detección por petición. Tener una lista propia acá significaría que el router
+ * puede discrepar con el resto del framework sobre qué es una plataforma.
+ */
+export { createPlatformRegistry, defaultPlatformRegistry, DEFAULT_AXIS_PRECEDENCE as AXIS_PRECEDENCE, } from '@ressjs/platform';

package/dist/variants/platform-tokens.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AXIS_PRECEDENCE = exports.defaultPlatformRegistry = exports.createPlatformRegistry = void 0;
+/**
+ * Qué tokens de plataforma son válidos y a qué eje pertenece cada uno.
+ *
+ * El vocabulario vive en `@ressjs/platform`, que no depende del router: es la
+ * misma autoridad que consultan el puente del WebView, el cliente y la
+ * detección por petición. Tener una lista propia acá significaría que el router
+ * puede discrepar con el resto del framework sobre qué es una plataforma.
+ */
+var platform_1 = require("@ressjs/platform");
+Object.defineProperty(exports, "createPlatformRegistry", { enumerable: true, get: function () { return platform_1.createPlatformRegistry; } });
+Object.defineProperty(exports, "defaultPlatformRegistry", { enumerable: true, get: function () { return platform_1.defaultPlatformRegistry; } });
+Object.defineProperty(exports, "AXIS_PRECEDENCE", { enumerable: true, get: function () { return platform_1.DEFAULT_AXIS_PRECEDENCE; } });

package/dist/variants/resolve.d.ts

@@ -0,0 +1,40 @@
+import type { PlatformInfo } from '../platform';
+import type { Axis, PlatformRegistry, Variant } from './types';
+/**
+ * De todas las variantes que una página declara, cuál le toca a esta plataforma.
+ *
+ * Gana la que describe la situación con más precisión, entre las que le aplican.
+ * Para un teléfono Android dentro de un WebView, con las variantes `base`,
+ * `mobile` y `webview.android` declaradas, gana `webview.android`: las tres
+ * aplican, y esa es la que dice más sobre el cliente.
+ *
+ * Es la **única** implementación de esta decisión en el framework: la usan tanto
+ * el servidor por petición como el build. Que sea una sola es lo que impide que
+ * se construya una variante con un nombre y se busque con otro.
+ *
+ * El criterio es de especificidad y no una lista de prioridades fija, porque una
+ * lista no escala: agregar televisores o escritorio nativo obligaría a
+ * reescribirla entera y a decidir a mano dónde entra cada combinación nueva.
+ */
+export declare function resolveVariant(platform: PlatformInfo, available: Variant[], registry: PlatformRegistry): Variant;
+/**
+ * Devuelve la resolución con su explicación, para el diagnóstico de F-034 y el
+ * explorador de F-035. Un resultado inesperado sin el porqué deja en el mismo
+ * lugar que no tener nada.
+ */
+export declare function explainResolution(platform: PlatformInfo, available: Variant[], registry: PlatformRegistry): {
+    selected: Variant;
+    candidates: Array<{
+        suffix: string;
+        applies: boolean;
+        specificity: number;
+    }>;
+};
+/**
+ * Por qué ejes varía una página.
+ *
+ * Es lo que su respuesta declara en `Vary`: si todas sus variantes son la base,
+ * el documento es el mismo para cualquier cliente y no varía por nada. Si sólo
+ * distingue televisores, varía por el dispositivo y por nada más.
+ */
+export declare function varyingAxes(available: readonly Variant[]): Axis[];

package/dist/variants/resolve.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVariant = resolveVariant;
+exports.explainResolution = explainResolution;
+exports.varyingAxes = varyingAxes;
+/**
+ * De todas las variantes que una página declara, cuál le toca a esta plataforma.
+ *
+ * Gana la que describe la situación con más precisión, entre las que le aplican.
+ * Para un teléfono Android dentro de un WebView, con las variantes `base`,
+ * `mobile` y `webview.android` declaradas, gana `webview.android`: las tres
+ * aplican, y esa es la que dice más sobre el cliente.
+ *
+ * Es la **única** implementación de esta decisión en el framework: la usan tanto
+ * el servidor por petición como el build. Que sea una sola es lo que impide que
+ * se construya una variante con un nombre y se busque con otro.
+ *
+ * El criterio es de especificidad y no una lista de prioridades fija, porque una
+ * lista no escala: agregar televisores o escritorio nativo obligaría a
+ * reescribirla entera y a decidir a mano dónde entra cada combinación nueva.
+ */
+function resolveVariant(platform, available, registry) {
+    const base = available.find((v) => v.suffix === '');
+    // 1. Aplican las variantes cuyos tags matchean todos. La base no tiene tags,
+    //    así que aplica siempre.
+    const applicable = available.filter((v) => v.tags.every((tag) => registry.matches(tag, platform)));
+    if (applicable.length === 0) {
+        if (!base) {
+            throw new Error('[ress] Ninguna variante aplica y no hay variante base. ' +
+                'Toda página necesita una variante sin sufijo como respaldo.');
+        }
+        return base;
+    }
+    // 2. Gana la que describe la situación más precisa: más tags, más específica.
+    // 3. A igual cantidad, decide el eje más significativo que cada una declara.
+    return applicable.reduce((best, candidate) => compare(candidate, best, registry) > 0 ? candidate : best);
+}
+/** Positivo si `a` es más específica que `b`. */
+function compare(a, b, registry) {
+    if (a.tags.length !== b.tags.length)
+        return a.tags.length - b.tags.length;
+    // Empate de especificidad: gana la que declara el eje más significativo.
+    // `category` cambia la página más profundamente que `device`, porque un
+    // WebView embebido difiere de un navegador más de lo que un teléfono difiere
+    // de una tablet.
+    const rankA = topAxisRank(a, registry);
+    const rankB = topAxisRank(b, registry);
+    if (rankA !== rankB)
+        return rankB - rankA;
+    // Sin criterio que las distinga, el orden alfabético del sufijo mantiene el
+    // resultado estable entre ejecuciones.
+    return b.suffix.localeCompare(a.suffix);
+}
+/** Posición del eje más significativo que declara la variante. Menor es mejor. */
+function topAxisRank(v, registry) {
+    if (v.tags.length === 0)
+        return registry.axisPrecedence.length;
+    return Math.min(...v.tags.map((t) => registry.axisPrecedence.indexOf(t.axis)));
+}
+/**
+ * Devuelve la resolución con su explicación, para el diagnóstico de F-034 y el
+ * explorador de F-035. Un resultado inesperado sin el porqué deja en el mismo
+ * lugar que no tener nada.
+ */
+function explainResolution(platform, available, registry) {
+    const selected = resolveVariant(platform, available, registry);
+    return {
+        selected,
+        candidates: available.map((v) => ({
+            suffix: v.suffix,
+            applies: v.tags.every((tag) => registry.matches(tag, platform)),
+            specificity: v.tags.length,
+        })),
+    };
+}
+/**
+ * Por qué ejes varía una página.
+ *
+ * Es lo que su respuesta declara en `Vary`: si todas sus variantes son la base,
+ * el documento es el mismo para cualquier cliente y no varía por nada. Si sólo
+ * distingue televisores, varía por el dispositivo y por nada más.
+ */
+function varyingAxes(available) {
+    const axes = new Set();
+    for (const variant of available) {
+        for (const tag of variant.tags)
+            axes.add(tag.axis);
+    }
+    return [...axes];
+}

package/dist/variants/suffix.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Convierte el sufijo de un archivo de variante en tags clasificados.
+ *
+ * La implementación vive en `@ressjs/platform` junto al registro que la
+ * alimenta: separarlas dejaría que el parseo aceptara tokens que el registro no
+ * reconoce, o al revés.
+ */
+export { parseVariantSuffix } from '@ressjs/platform';

package/dist/variants/suffix.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVariantSuffix = void 0;
+/**
+ * Convierte el sufijo de un archivo de variante en tags clasificados.
+ *
+ * La implementación vive en `@ressjs/platform` junto al registro que la
+ * alimenta: separarlas dejaría que el parseo aceptara tokens que el registro no
+ * reconoce, o al revés.
+ */
+var platform_1 = require("@ressjs/platform");
+Object.defineProperty(exports, "parseVariantSuffix", { enumerable: true, get: function () { return platform_1.parseVariantSuffix; } });

package/dist/variants/types.d.ts

@@ -0,0 +1,69 @@
+import type { PlatformInfo } from '../platform';
+/**
+ * Vocabulario de este módulo, de arriba hacia abajo:
+ *
+ * - Una **página** puede existir en varias **variantes**: versiones de la misma
+ *   página dirigidas a plataformas distintas. El proyecto las declara creando
+ *   archivos con un sufijo (`index.tv.scss` declara la variante `tv`).
+ * - El **catálogo** es la lista completa de páginas con sus variantes. Se arma
+ *   una sola vez, al arrancar y al construir.
+ * - Cada par página + variante es una **entrada de build**, que produce su
+ *   propio guion y su propia hoja de estilos.
+ * - Servir una petición es elegir una variante para la plataforma que pide, y
+ *   buscar en el **índice de artefactos** qué archivos le corresponden.
+ *
+ * Qué tokens existen y cómo se decide si uno aplica a un cliente no se define
+ * acá: es el modelo de plataforma, y vive en `@ressjs/platform`.
+ */
+export type { Axis, PlatformRegistry, VariantTag } from '@ressjs/platform';
+import type { VariantTag } from '@ressjs/platform';
+/** Una versión de una página dirigida a un subconjunto de plataformas. */
+export interface Variant {
+    /** Sufijo canónico. Cadena vacía para la base. */
+    suffix: string;
+    /** Vacío en la base, que por eso aplica siempre. */
+    tags: VariantTag[];
+    /** Archivo de estilos que la declara. Ausente si la página no tiene estilos. */
+    styleFile?: string;
+}
+/** Una página en una de sus variantes: lo que el empaquetador construye. */
+export interface BuildEntry {
+    pageId: string;
+    route: string;
+    pageFile: string;
+    variant: Variant;
+    /** Módulo virtual que el empaquetador usa como entrada de build. */
+    virtualId: string;
+}
+/**
+ * Qué variantes tiene cada página del proyecto.
+ *
+ * Es la fuente única de la que salen tanto las entradas que se construyen como
+ * las que se resuelven por petición. Que sean la misma es lo que garantiza que
+ * el servidor nunca pida un artefacto que el build no produjo.
+ */
+export interface VariantCatalog {
+    /** Todas las combinaciones página + variante, en orden estable. */
+    buildEntries: BuildEntry[];
+    /** Variantes de cada página, para resolver sin recorrer todo el catálogo. */
+    variantsByPage: Map<string, Variant[]>;
+    /** Datos de la página, indexados por su identificador. */
+    pagesById: Map<string, {
+        route: string;
+        pageFile: string;
+    }>;
+}
+/**
+ * Qué archivos servir para una página y una variante.
+ *
+ * Tiene la misma forma en desarrollo y en producción, de modo que quien lo
+ * consulta no necesite saber en cuál corre. Devuelve `undefined` cuando esa
+ * combinación no se construyó.
+ */
+export interface AssetIndex {
+    find(pageId: string, variantSuffix: string): {
+        js: string;
+        css: string[];
+    } | undefined;
+}
+export type { PlatformInfo };

package/dist/variants/types.js

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

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@ressjs/vite-router",
-  "version": "0.5.0",
+  "version": "0.6.0-experimental.0",
   "description": "Express router factory for ress.js with automatic page detection, SSR and dynamic routes support",
-  "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "publishConfig": {
     "access": "public"
@@ -12,6 +11,16 @@
       "types": "./dist/index.d.ts",
       "require": "./dist/index.js",
       "import": "./dist/index.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin/index.d.ts",
+      "require": "./dist/plugin/index.js",
+      "import": "./dist/plugin/index.js"
+    },
+    "./client": {
+      "types": "./dist/client/entry.d.mts",
+      "require": "./dist/client/index.js",
+      "import": "./dist/client/entry.mjs"
     }
   },
   "files": [
@@ -36,26 +45,29 @@
   "author": "ressjs team",
   "license": "MIT",
   "devDependencies": {
-    "@jest/globals": "^29.7.0",
     "@types/compression": "^1.7.5",
     "@types/express": "^5.0.3",
-    "@types/jest": "^30.0.0",
     "@types/node": "^22.17.2",
     "axios": "^1.11.0",
     "express": "^5.1.0",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.4.1",
-    "typescript": "~5.7.3",
+    "typescript": "~5.9.0",
     "vitest": "^3.2.4"
   },
   "dependencies": {
+    "@ressjs/assets": "0.6.0-experimental.0",
+    "@ressjs/config": "0.6.0-experimental.0",
+    "@ressjs/platform": "0.6.0-experimental.0",
     "compression": "^1.8.0",
     "fast-glob": "^3.3.3",
     "sirv": "^3.0.1"
   },
   "peerDependencies": {
-    "vite": "^6.0.0",
     "react": "^19.0.0",
-    "react-dom": "^19.0.0"
-  }
+    "react-dom": "^19.0.0",
+    "vite": "^8.0.0"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "main": "dist/index.js"
 }

package/dist/helpers/vite-config.d.ts

@@ -1,10 +0,0 @@
-export interface ViteConfig {
-    vite?: any;
-    manifest: any;
-    templateHtml: string;
-    isProduction: boolean;
-}
-export declare function setupDev(base?: string): Promise<ViteConfig>;
-export declare function setupProd(): Promise<ViteConfig>;
-export declare function createProdMiddleware(): () => Promise<import("express-serve-static-core").Router>;
-export declare function setupVite(isProduction: boolean, base?: string): Promise<ViteConfig>;

package/dist/helpers/vite-config.js

@@ -1,90 +0,0 @@
-"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 };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupDev = setupDev;
-exports.setupProd = setupProd;
-exports.createProdMiddleware = createProdMiddleware;
-exports.setupVite = setupVite;
-const promises_1 = __importDefault(require("node:fs/promises"));
-const express_1 = __importDefault(require("express"));
-const pages_1 = require("../pages");
-async function setupDev(base = '/') {
-    const vite = await Promise.resolve().then(() => __importStar(require('vite'))).then(m => m.createServer({
-        server: { middlewareMode: true },
-        appType: 'custom',
-        base
-    }));
-    let manifest = {};
-    try {
-        manifest = JSON.parse(await promises_1.default.readFile('./dist/client/.vite/manifest.json', 'utf-8'));
-    }
-    catch {
-        // Expected in dev if no build yet
-    }
-    await (0, pages_1.generateTempEntries)();
-    const templateHtml = await promises_1.default.readFile('./index.html', 'utf-8');
-    return { vite, manifest, templateHtml, isProduction: false };
-}
-async function setupProd() {
-    const manifest = JSON.parse(await promises_1.default.readFile('./dist/client/.vite/manifest.json', 'utf-8'));
-    const templateHtml = await promises_1.default.readFile('./index.html', 'utf-8');
-    return {
-        vite: null,
-        manifest,
-        templateHtml,
-        isProduction: true
-    };
-}
-function createProdMiddleware() {
-    const middlewares = express_1.default.Router();
-    return async () => {
-        const compression = (await Promise.resolve().then(() => __importStar(require('compression')))).default;
-        const sirv = (await Promise.resolve().then(() => __importStar(require('sirv')))).default;
-        middlewares.use(compression());
-        middlewares.use(sirv('./dist/client', { extensions: [] }));
-        return middlewares;
-    };
-}
-async function setupVite(isProduction, base = '/') {
-    if (isProduction) {
-        return await setupProd();
-    }
-    else {
-        return await setupDev(base);
-    }
-}