@ressjs/config 0.6.0-experimental.0

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * La configuración del proyecto, resuelta.
+ *
+ * Un archivo por modo en `config/`, cada uno exportando por defecto un objeto:
+ * las claves que el framework reconoce —`basePath`, `redirects`, `dev`— y las
+ * del proyecto —una URL de API, una clave— en el mismo lugar. Se fusionan
+ * `default` → el modo activo → `local`.
+ *
+ * De sólo servidor. Importarlo desde código que termina en el bundle del cliente
+ * falla el build, no la petición.
+ */
+import { type ProjectConfig } from './load';
+/**
+ * La configuración resuelta.
+ *
+ * Es un `Proxy` y no una constante porque una constante no se puede reasignar:
+ * quien capturara el binding antes de la resolución se quedaría con `undefined`
+ * para siempre, y `cdnPrefix: config.CDN_URL` dentro de `ress.config.ts`
+ * fallaría en silencio. Cada lectura consulta lo ya resuelto.
+ */
+export declare const config: ProjectConfig;
+export { invalidateConfig, resolveConfig, resolved } from './load';
+export type { ProjectConfig } from './load';
+export { resolveLayers } from './layers';
+export { deepFreeze, deepMerge } from './merge';
+export { CONFIG_EXTENSIONS, layerNamesFor, RESERVED_LAYERS, reservedKeysFor } from './types';
+export type { LayerSource } from './types';
+export { configServerOnlyGuard, isConfigModule } from './vite-guard';

package/dist/index.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * La configuración del proyecto, resuelta.
+ *
+ * Un archivo por modo en `config/`, cada uno exportando por defecto un objeto:
+ * las claves que el framework reconoce —`basePath`, `redirects`, `dev`— y las
+ * del proyecto —una URL de API, una clave— en el mismo lugar. Se fusionan
+ * `default` → el modo activo → `local`.
+ *
+ * De sólo servidor. Importarlo desde código que termina en el bundle del cliente
+ * falla el build, no la petición.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConfigModule = exports.configServerOnlyGuard = exports.reservedKeysFor = exports.RESERVED_LAYERS = exports.layerNamesFor = exports.CONFIG_EXTENSIONS = exports.deepMerge = exports.deepFreeze = exports.resolveLayers = exports.resolved = exports.resolveConfig = exports.invalidateConfig = exports.config = void 0;
+const load_1 = require("./load");
+/**
+ * La configuración resuelta.
+ *
+ * Es un `Proxy` y no una constante porque una constante no se puede reasignar:
+ * quien capturara el binding antes de la resolución se quedaría con `undefined`
+ * para siempre, y `cdnPrefix: config.CDN_URL` dentro de `ress.config.ts`
+ * fallaría en silencio. Cada lectura consulta lo ya resuelto.
+ */
+exports.config = new Proxy({}, {
+    get: (_target, key) => (0, load_1.resolved)()[key],
+    has: (_target, key) => key in (0, load_1.resolved)(),
+    ownKeys: () => Reflect.ownKeys((0, load_1.resolved)()),
+    getOwnPropertyDescriptor: (_target, key) => {
+        const descriptor = Reflect.getOwnPropertyDescriptor((0, load_1.resolved)(), key);
+        // Un proxy tiene que declarar configurable lo que su objetivo no tiene.
+        return descriptor && { ...descriptor, configurable: true };
+    },
+});
+var load_2 = require("./load");
+Object.defineProperty(exports, "invalidateConfig", { enumerable: true, get: function () { return load_2.invalidateConfig; } });
+Object.defineProperty(exports, "resolveConfig", { enumerable: true, get: function () { return load_2.resolveConfig; } });
+Object.defineProperty(exports, "resolved", { enumerable: true, get: function () { return load_2.resolved; } });
+var layers_1 = require("./layers");
+Object.defineProperty(exports, "resolveLayers", { enumerable: true, get: function () { return layers_1.resolveLayers; } });
+var merge_1 = require("./merge");
+Object.defineProperty(exports, "deepFreeze", { enumerable: true, get: function () { return merge_1.deepFreeze; } });
+Object.defineProperty(exports, "deepMerge", { enumerable: true, get: function () { return merge_1.deepMerge; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "CONFIG_EXTENSIONS", { enumerable: true, get: function () { return types_1.CONFIG_EXTENSIONS; } });
+Object.defineProperty(exports, "layerNamesFor", { enumerable: true, get: function () { return types_1.layerNamesFor; } });
+Object.defineProperty(exports, "RESERVED_LAYERS", { enumerable: true, get: function () { return types_1.RESERVED_LAYERS; } });
+Object.defineProperty(exports, "reservedKeysFor", { enumerable: true, get: function () { return types_1.reservedKeysFor; } });
+var vite_guard_1 = require("./vite-guard");
+Object.defineProperty(exports, "configServerOnlyGuard", { enumerable: true, get: function () { return vite_guard_1.configServerOnlyGuard; } });
+Object.defineProperty(exports, "isConfigModule", { enumerable: true, get: function () { return vite_guard_1.isConfigModule; } });

package/dist/layers.d.ts

@@ -0,0 +1,20 @@
+import { type LayerSource } from './types';
+/**
+ * Resuelve una superficie de configuración a partir de sus capas.
+ *
+ * Un solo motor para las dos superficies. Tener dos implementaciones —una para
+ * el comportamiento del framework y otra para los valores por entorno— habría
+ * significado dos reglas de fusión que divergen en cuanto alguien toque una.
+ *
+ * `object` y no `Record<string, unknown>`: una interfaz sin firma de índice no
+ * satisface esa restricción, y `resolveLayers<RessConfig>` no compilaría.
+ */
+export declare function resolveLayers<T extends object>(source: LayerSource): Promise<T>;
+/**
+ * El archivo de una capa, si existe.
+ *
+ * Dos archivos que compiten por la misma capa son un error: cuál gana dependería
+ * del orden en que se busque, y ese orden es una decisión interna que nadie
+ * puede ver desde afuera.
+ */
+export declare function findConfigFile(dir: string, name: string): Promise<string | undefined>;

package/dist/layers.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLayers = resolveLayers;
+exports.findConfigFile = findConfigFile;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const merge_1 = require("./merge");
+const types_1 = require("./types");
+/**
+ * Resuelve una superficie de configuración a partir de sus capas.
+ *
+ * Un solo motor para las dos superficies. Tener dos implementaciones —una para
+ * el comportamiento del framework y otra para los valores por entorno— habría
+ * significado dos reglas de fusión que divergen en cuanto alguien toque una.
+ *
+ * `object` y no `Record<string, unknown>`: una interfaz sin firma de índice no
+ * satisface esa restricción, y `resolveLayers<RessConfig>` no compilaría.
+ */
+async function resolveLayers(source) {
+    const dir = await findDirectory(source.root, source.base);
+    const file = await findConfigFile(source.root, source.base);
+    if (dir && file) {
+        throw new Error(`[ress] "${source.base}.*" y "${source.base}/" no pueden coexistir: ` +
+            'no hay forma de saber cuál gana. Dejá una sola.');
+    }
+    if (dir)
+        return (0, merge_1.deepFreeze)(await resolveFolder(dir, source));
+    if (file)
+        return (0, merge_1.deepFreeze)(await resolveSingleFile(file, source));
+    // Ninguna de las dos formas existe. La superficie entera es opcional: un
+    // proyecto sin configuración es un proyecto válido.
+    return (0, merge_1.deepFreeze)({});
+}
+/** Forma de carpeta: un archivo físico por capa. */
+async function resolveFolder(dir, source) {
+    let result = {};
+    for (const layer of source.layerNames) {
+        const layerFile = await findConfigFile(dir, layer);
+        if (!layerFile) {
+            if (layer === 'default' && source.requireDefault) {
+                throw new Error(`[ress] "${source.base}/" existe pero no tiene "${source.base}/default.*". ` +
+                    'Una carpeta con sólo las capas de un modo casi siempre es un archivo a ' +
+                    'medio renombrar.');
+            }
+            continue;
+        }
+        result = (0, merge_1.deepMerge)(result, await evaluate(layerFile));
+    }
+    return result;
+}
+/** Forma de archivo único: la raíz es `default` y cada modo es una clave anidada. */
+async function resolveSingleFile(file, source) {
+    const whole = (await evaluate(file));
+    // Se sacan del resultado **todas** las claves de capa, no sólo las del modo
+    // activo: con un trío fijo, `--mode staging` no fusionaba nada y dejaba
+    // `staging` adentro; sacando sólo las del modo activo, en desarrollo quedaba
+    // `production: { ... }` colada como si fuera una sección de configuración.
+    const reserved = (0, types_1.reservedKeysFor)(source.mode);
+    let result = Object.fromEntries(Object.entries(whole).filter(([key]) => !reserved.has(key)));
+    for (const layer of source.layerNames) {
+        if (layer === 'default')
+            continue;
+        const override = whole[layer];
+        if (override != null)
+            result = (0, merge_1.deepMerge)(result, override);
+    }
+    return result;
+}
+/**
+ * El archivo de una capa, si existe.
+ *
+ * Dos archivos que compiten por la misma capa son un error: cuál gana dependería
+ * del orden en que se busque, y ese orden es una decisión interna que nadie
+ * puede ver desde afuera.
+ */
+async function findConfigFile(dir, name) {
+    const entries = await safeReaddir(dir);
+    const matches = types_1.CONFIG_EXTENSIONS.map((ext) => name + ext).filter((f) => entries.includes(f));
+    if (matches.length > 1) {
+        throw new Error(`[ress] Hay más de un "${name}" en ${dir}: ${matches.join(', ')}. Dejá uno solo.`);
+    }
+    return matches[0] ? node_path_1.default.join(dir, matches[0]) : undefined;
+}
+async function findDirectory(root, base) {
+    const target = node_path_1.default.join(root, base);
+    const entries = await safeReaddir(root, true);
+    return entries.some((e) => e.name === base && e.isDirectory()) ? target : undefined;
+}
+async function safeReaddir(dir, withTypes) {
+    try {
+        return withTypes ? await (0, promises_1.readdir)(dir, { withFileTypes: true }) : await (0, promises_1.readdir)(dir);
+    }
+    catch {
+        // Un directorio que no existe no es un error: significa que el proyecto no
+        // usa esa forma de configuración.
+        return [];
+    }
+}
+/**
+ * Evalúa un archivo de configuración.
+ *
+ * En desarrollo el archivo cambia, así que la URL lleva una marca de tiempo: sin
+ * ella el caché de módulos de Node devuelve la versión anterior y editar la
+ * configuración no tiene ningún efecto.
+ */
+async function evaluate(file) {
+    const url = (0, node_url_1.pathToFileURL)(file).href + `?t=${Date.now()}`;
+    const module = (await import(/* @vite-ignore */ url));
+    return module.default ?? module;
+}

package/dist/load.d.ts

@@ -0,0 +1,23 @@
+/**
+ * La forma de la configuración del proyecto.
+ *
+ * Vacía a propósito: la forma la definen los archivos de `config/`, y el `.d.ts`
+ * generado la amplía para que el editor la conozca sin escribirla a mano.
+ */
+export interface ProjectConfig {
+}
+/**
+ * No es `async`: una función `async` envuelve su retorno en una promesa nueva
+ * cada vez, así que quien pidiera lo mismo dos veces recibiría dos promesas
+ * distintas aunque por dentro no se vuelva a leer nada.
+ */
+export declare function resolveConfig(root: string, mode: string): Promise<ProjectConfig>;
+/** Descarta lo resuelto. Lo usa la recarga en caliente al cambiar una capa. */
+export declare function invalidateConfig(): void;
+/**
+ * Lo ya resuelto, o un error que dice qué falta.
+ *
+ * Devolver un objeto vacío acá convertiría un error de orden de arranque en un
+ * `undefined` que aparece mucho más tarde y en otro lugar.
+ */
+export declare function resolved(): ProjectConfig;

package/dist/load.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = resolveConfig;
+exports.invalidateConfig = invalidateConfig;
+exports.resolved = resolved;
+const layers_1 = require("./layers");
+const types_1 = require("./types");
+/**
+ * Lo resuelto vive en `globalThis`, no en una variable de módulo.
+ *
+ * Los archivos de `config/` se evalúan dentro del cargador de Vite, que los
+ * empaqueta en su propio grafo: la instancia de este paquete que alcanzan puede
+ * no ser la misma que resolvió el servidor. Con estado de módulo, `config`
+ * llegaría vacío justo donde se lo lee.
+ */
+const CACHE = Symbol.for('ressjs.config.resolved');
+function store() {
+    const g = globalThis;
+    return (g[CACHE] ??= { pending: new Map() });
+}
+/**
+ * No es `async`: una función `async` envuelve su retorno en una promesa nueva
+ * cada vez, así que quien pidiera lo mismo dos veces recibiría dos promesas
+ * distintas aunque por dentro no se vuelva a leer nada.
+ */
+function resolveConfig(root, mode) {
+    // La clave incluye raíz y modo: sin ella, en un monorepo la segunda aplicación
+    // recibía los valores de la primera, y un reinicio con otro modo seguía
+    // sirviendo los del anterior.
+    const key = `${root} ${mode}`;
+    const cached = store().pending.get(key);
+    if (cached)
+        return cached;
+    const pending = (0, layers_1.resolveLayers)({
+        root,
+        base: 'config',
+        mode,
+        layerNames: (0, types_1.layerNamesFor)(mode),
+        requireDefault: false,
+    }).then((value) => {
+        store().resolved = value;
+        return value;
+    });
+    store().pending.set(key, pending);
+    return pending;
+}
+/** Descarta lo resuelto. Lo usa la recarga en caliente al cambiar una capa. */
+function invalidateConfig() {
+    const s = store();
+    s.pending.clear();
+    delete s.resolved;
+}
+/**
+ * Lo ya resuelto, o un error que dice qué falta.
+ *
+ * Devolver un objeto vacío acá convertiría un error de orden de arranque en un
+ * `undefined` que aparece mucho más tarde y en otro lugar.
+ */
+function resolved() {
+    const value = store().resolved;
+    if (!value) {
+        throw new Error('[ress] Se leyó `config` antes de que la configuración estuviera resuelta. ' +
+            'Pasa cuando un módulo que se evalúa antes de arrancar el servidor importa ' +
+            '`@ressjs/config`; movelo adentro de la función que lo necesita.');
+    }
+    return value;
+}

package/dist/merge.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Fusión de capas.
+ *
+ * Los objetos se fusionan en profundidad y los arreglos se reemplazan enteros.
+ * Fusionar arreglos no tiene una interpretación única —¿por índice, por
+ * concatenación, por identidad?— y cualquiera de las tres sorprende a alguien;
+ * reemplazar es la única regla que se puede predecir sin leer el código.
+ */
+export declare function deepMerge<T>(base: T, override: unknown): T;
+/** Congela en profundidad: el resultado se comparte entre todo el proceso. */
+export declare function deepFreeze<T>(value: T): T;

package/dist/merge.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = deepMerge;
+exports.deepFreeze = deepFreeze;
+/**
+ * Fusión de capas.
+ *
+ * Los objetos se fusionan en profundidad y los arreglos se reemplazan enteros.
+ * Fusionar arreglos no tiene una interpretación única —¿por índice, por
+ * concatenación, por identidad?— y cualquiera de las tres sorprende a alguien;
+ * reemplazar es la única regla que se puede predecir sin leer el código.
+ */
+function deepMerge(base, override) {
+    if (!isPlainObject(override))
+        return (override ?? base);
+    if (!isPlainObject(base))
+        return { ...override };
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        // `undefined` no borra: una capa que no menciona una clave no la está
+        // desactivando, simplemente no opina sobre ella. Para desactivar se declara
+        // `null` o el valor vacío que corresponda.
+        if (value === undefined)
+            continue;
+        result[key] = isPlainObject(value) ? deepMerge(result[key], value) : value;
+    }
+    return result;
+}
+/**
+ * Un objeto literal, no una instancia.
+ *
+ * Un `Date`, un `RegExp` o una clase se reemplazan enteros: fusionar sus
+ * propiedades produciría un objeto que ya no es de esa clase.
+ */
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/** Congela en profundidad: el resultado se comparte entre todo el proceso. */
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const key of Object.getOwnPropertyNames(value)) {
+            deepFreeze(value[key]);
+        }
+    }
+    return value;
+}

package/dist/types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Qué capas componen una superficie de configuración y de dónde salen.
+ *
+ * Hay dos superficies y un solo motor: el **comportamiento** del framework
+ * (`ress.config`) y los **valores** por entorno (`config`). Las dos aceptan la
+ * forma de archivo único y la de carpeta, y las dos se resuelven igual.
+ */
+export interface LayerSource {
+    root: string;
+    /** `ress.config` o `config`. */
+    base: string;
+    mode: string;
+    /** Orden de precedencia, de menor a mayor: `['default', mode, 'local']`. */
+    layerNames: readonly string[];
+    /**
+     * Si la forma de carpeta exige su capa `default`.
+     *
+     * La superficie entera sigue siendo opcional: lo que esto declara es que, si
+     * alguien creó la carpeta, tiene que tener su base. Una carpeta con sólo
+     * `production.ts` casi siempre es un archivo a medio renombrar.
+     */
+    requireDefault: boolean;
+}
+/** Extensiones que puede tener un archivo de configuración. */
+export declare const CONFIG_EXTENSIONS: readonly [".ts", ".mts", ".js", ".mjs"];
+/**
+ * Nombres que el framework reserva como capas.
+ *
+ * Una clave con uno de estos nombres nunca es una sección de configuración, y por
+ * eso se saca del resultado aunque su modo no sea el activo: dejarla adentro
+ * colaba `production: { ... }` como si fuera una sección más, en desarrollo.
+ */
+export declare const RESERVED_LAYERS: readonly ["development", "production", "local"];
+/** Las capas de una superficie, dadas el modo activo. */
+export declare function layerNamesFor(mode: string): readonly string[];
+/** Toda clave que el motor tiene que sacar del resultado en la forma de archivo único. */
+export declare function reservedKeysFor(mode: string): ReadonlySet<string>;

package/dist/types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESERVED_LAYERS = exports.CONFIG_EXTENSIONS = void 0;
+exports.layerNamesFor = layerNamesFor;
+exports.reservedKeysFor = reservedKeysFor;
+/** Extensiones que puede tener un archivo de configuración. */
+exports.CONFIG_EXTENSIONS = ['.ts', '.mts', '.js', '.mjs'];
+/**
+ * Nombres que el framework reserva como capas.
+ *
+ * Una clave con uno de estos nombres nunca es una sección de configuración, y por
+ * eso se saca del resultado aunque su modo no sea el activo: dejarla adentro
+ * colaba `production: { ... }` como si fuera una sección más, en desarrollo.
+ */
+exports.RESERVED_LAYERS = ['development', 'production', 'local'];
+/** Las capas de una superficie, dadas el modo activo. */
+function layerNamesFor(mode) {
+    return ['default', mode, 'local'];
+}
+/** Toda clave que el motor tiene que sacar del resultado en la forma de archivo único. */
+function reservedKeysFor(mode) {
+    return new Set([...exports.RESERVED_LAYERS, mode]);
+}

package/dist/vite-guard.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Impide que los valores de servidor lleguen al bundle del cliente.
+ *
+ * Este paquete lee archivos que pueden tener credenciales. Si un componente lo
+ * importa —aunque sea sin querer, a través de un módulo compartido— esos valores
+ * terminan en un archivo que cualquiera puede descargar.
+ *
+ * El corte se hace al resolver el módulo: es el único momento en que se puede
+ * impedir que entre al grafo del cliente.
+ */
+/** Forma estructural del plugin, para no depender del tipo de Vite. */
+export interface GuardPlugin {
+    name: string;
+    /**
+     * Antes que el resolvedor de Vite.
+     *
+     * Sin esto el hook no llegaba a correr: el resolvedor incorporado atiende los
+     * especificadores desnudos y devuelve un resultado, y un `resolveId` posterior
+     * ya no se consulta. El guard quedaba registrado y mudo, que es la peor forma
+     * de tener una comprobación de seguridad.
+     */
+    enforce: 'pre';
+    resolveId: (this: {
+        /** El entorno que está resolviendo. Es como Vite 6+ lo expone al plugin. */
+        environment?: {
+            name?: string;
+        };
+        resolve: (source: string, importer?: string, options?: unknown) => Promise<{
+            id: string;
+        } | null>;
+    }, source: string, importer: string | undefined, options?: {
+        environment?: {
+            name?: string;
+        };
+    }) => Promise<null>;
+}
+/**
+ * Reconoce el paquete por su especificador **y** por el archivo al que resuelve.
+ *
+ * Comparar sólo el especificador exacto dejaba pasar un subpath
+ * (`@ressjs/config/load`), un barrel de la aplicación que lo reexporta, o una
+ * ruta relativa hacia adentro del paquete en un monorepo.
+ */
+export declare function isConfigModule(source: string, resolvedId?: string): boolean;
+export declare function configServerOnlyGuard(): GuardPlugin;

package/dist/vite-guard.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Impide que los valores de servidor lleguen al bundle del cliente.
+ *
+ * Este paquete lee archivos que pueden tener credenciales. Si un componente lo
+ * importa —aunque sea sin querer, a través de un módulo compartido— esos valores
+ * terminan en un archivo que cualquiera puede descargar.
+ *
+ * El corte se hace al resolver el módulo: es el único momento en que se puede
+ * impedir que entre al grafo del cliente.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConfigModule = isConfigModule;
+exports.configServerOnlyGuard = configServerOnlyGuard;
+const PACKAGE = '@ressjs/config';
+/**
+ * Reconoce el paquete por su especificador **y** por el archivo al que resuelve.
+ *
+ * Comparar sólo el especificador exacto dejaba pasar un subpath
+ * (`@ressjs/config/load`), un barrel de la aplicación que lo reexporta, o una
+ * ruta relativa hacia adentro del paquete en un monorepo.
+ */
+function isConfigModule(source, resolvedId) {
+    if (source === PACKAGE || source.startsWith(`${PACKAGE}/`))
+        return true;
+    const id = resolvedId?.replace(/\\/g, '/');
+    return Boolean(id && /\/packages\/config\/|\/@ressjs\/config\//.test(id));
+}
+function configServerOnlyGuard() {
+    return {
+        name: 'ress:config-server-only',
+        enforce: 'pre',
+        async resolveId(source, importer, options) {
+            // El entorno viaja en el contexto del plugin, no en las opciones del
+            // hook. Leerlo sólo de las opciones dejaba al guard sin disparar nunca:
+            // devolvía `null` en todas las resoluciones, incluidas las del cliente.
+            const environment = this?.environment?.name ?? options?.environment?.name;
+            if (environment !== 'client')
+                return null;
+            const resolved = await this.resolve(source, importer, { skipSelf: true });
+            if (!isConfigModule(source, resolved?.id))
+                return null;
+            throw new Error(`[ress] "${PACKAGE}" es de sólo servidor y lo importa ${importer ?? 'el punto de entrada'}, ` +
+                'que forma parte del bundle de cliente.\n' +
+                'Los valores que el navegador necesita se declaran en `publicEnv`.');
+        },
+    };
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@ressjs/config",
+  "version": "0.6.0-experimental.0",
+  "description": "Valores de configuración por entorno para ress.js. Sólo servidor, sin dependencias.",
+  "types": "dist/index.d.ts",
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js"
+    },
+    "./layers": {
+      "types": "./dist/layers.d.ts",
+      "require": "./dist/layers.js",
+      "import": "./dist/layers.js"
+    },
+    "./vite-guard": {
+      "types": "./dist/vite-guard.d.ts",
+      "require": "./dist/vite-guard.js",
+      "import": "./dist/vite-guard.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "config",
+    "environment",
+    "ressjs"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}