.

7 months ago · 0426d9f46d
commit 0426d9f46d
26 changed files with 3032 additions and 0 deletions
--- a/.idea/.gitignore
+++ b/.idea/.gitignore
@ -0,0 +1,8 @@
 # Default ignored files
 /shelf/
 /workspace.xml
 # Editor-based HTTP Client requests
 /httpRequests/
 # Datasource local storage ignored files
 /dataSources/
 /dataSources.local.xml
--- a/package.json
+++ b/package.json
@ -0,0 +1,41 @@
 {
  "name": "visual-engine-configurator-information",
  "version": "1.0.0",
  "description": "",
  "main": "dist/index.js",
  "scripts": {
    "build": "tsc",
    "dev": "vite dev"
  },
  "keywords": [
    "configuration",
    "visual",
    "typescript"
  ],
  "author": "ACTIVE THING",
  "license": "EULA",
  "dependencies": {
    "svelte": "^5.53.0",
    "@tailwindcss/vite": "^4.1.18"
  },
  "devDependencies": {
    "@sveltejs/vite-plugin-svelte": "^6.2.4",
    "@tailwindcss/postcss": "^4.1.18",
    "@tsconfig/svelte": "^5.0.6",
    "@testing-library/jest-dom": "^6.9.1",
    "@testing-library/svelte": "^5.3.1",
    "@types/node": "^25.2.3",
    "jsdom": "^28.1.0",
    "ts-node": "^10.9.2",
    "autoprefixer": "^10.4.23",
    "postcss": "^8.5.6",
    "tailwindcss": "^4.1.18",
    "typescript": "^5.9.3",
    "vite": "^7.3.1",
    "vite-plugin-singlefile": "^2.3.0",
    "vitest": "^4.0.18"
  },
  "private": true
 }
--- a/postcss.config.js
+++ b/postcss.config.js
@ -0,0 +1,6 @@
 export default {
    plugins: {
        '@tailwindcss/postcss': {},
        autoprefixer: {},
    },
 }
--- a/src/ling/consts.ts
+++ b/src/ling/consts.ts
@ -0,0 +1,11 @@
 export const idPrefix = '#?';
 export const defaultISOLocale = 'es' ;
 export const maxResolveDeep = 3;
 export const loggerCategory = 'ling';
--- a/src/ling/docs/ling.md
+++ b/src/ling/docs/ling.md
@ -0,0 +1,295 @@
 # ling
 Sistema de internacionalización type-safe para TypeScript. Agnóstico de framework, sin dependencias externas.
 ---
 ## Estructura de ficheros
 ```
 ling/
 ├── index.ts              # Barrel — punto de entrada público
 ├── engine.ts        # Singleton global (wiring de schema base + factory)
 ├── instance.ts       # Factory: createLing()
 ├── types.ts         # Tipos e interfaces
 ├── translations.ts       # Traducciones base de la aplicación
 └── tests/
    └── ling.test.ts
 ```
 Cada módulo de la aplicación define sus propias traducciones y las registra en el singleton:
 ```
 auth/
 └── ling.ts               # Registra el namespace 'auth'
 checkout/
 └── ling.ts               # Registra el namespace 'checkout'
 ```
 ---
 ## Setup
 ### 1. Define las traducciones base
 Solo las claves compartidas por toda la aplicación — common, errors, etc.
 ```ts
 // translations.ts
 import type { TranslationNode } from './ling.types';
 export const translations = {
    common: {
        ok    : { es: 'Aceptar',  en: 'OK'     },
        cancel: { es: 'Cancelar', en: 'Cancel'  },
    },
    errors: {
        generic: (params: { code: number }) => ({
            es: `Ha ocurrido un error (${params.code})`,
            en: `An error occurred (${params.code})`,
        }),
    },
 } satisfies TranslationNode;
 ```
 > `es` es obligatorio en cada hoja. El resto de locales son opcionales y hacen fallback a `es` si faltan.
 ### 2. Crea el singleton
 ```ts
 // ling.engine.ts
 import { createLing } from './ling.factory';
 import { translations } from './translations';
 export const ling = createLing(translations, 'es');
 ```
 ### 3. Cada módulo registra sus traducciones
 ```ts
 // auth/ling.ts
 import { ling } from '@/ling.engine';
 export const authLing = ling.register('auth', {
    loginFailed   : { es: 'Login fallido',   en: 'Login failed'   },
    sessionExpired: { es: 'Sesión expirada',  en: 'Session expired' },
    welcome       : (params: { name: string }) => ({
        es: `Bienvenido, ${params.name}`,
        en: `Welcome, ${params.name}`,
    }),
 });
 ```
 ```ts
 // checkout/ling.ts
 import { ling } from '@/ling.engine';
 export const checkoutLing = ling.register('checkout', {
    pay  : { es: 'Pagar', en: 'Pay' },
    total: (params: { amount: number; currency: string }) => ({
        es: `Total: ${params.amount}${params.currency}`,
        en: `Total: ${params.currency}${params.amount}`,
    }),
 });
 ```
 ### 4. Uso dentro de cada módulo
 ```ts
 // auth/login.ts
 import { authLing } from './ling';
 authLing.t('auth.loginFailed')              // → "Login fallido"
 authLing.t('auth.welcome', { name: 'Ana' }) // → "Bienvenido, Ana"
 authLing.t('common.ok')                     // → "Aceptar" (base disponible)
 ```
 Cada módulo tiene **autocompletado y validación en compilación** solo de sus claves más las del schema base. No ve las claves de otros módulos.
 ---
 ## API
 ### `t(path, params?)`
 Traduce una clave del schema al locale actual.
 ```ts
 authLing.t('auth.loginFailed')
 authLing.t('auth.welcome', { name: 'Ana' })
 authLing.t('common.ok')
 ```
 - Solo acepta rutas que terminan en una traducción real — rutas intermedias como `'auth'` dan error de tipos.
 - Los params son obligatorios si la traducción los requiere, y TypeScript los infiere automáticamente.
 ### `ts(value)`
 *Translate String* — resuelve un `LingString` con el locale actual. Útil para campos de datos que pueden estar localizados o no.
 ```ts
 ts('texto fijo')                                   // → "texto fijo"  (pass-through)
 ts({ es: 'una descripción', en: 'a description' }) // → "una descripción"
 ```
 ```ts
 import type { LingString } from '@/ling';
 interface Product {
    id  : string;
    name: LingString;
 }
 const product: Product = { id: '1', name: { es: 'Silla', en: 'Chair' } };
 ling.ts(product.name) // → "Silla"
 ```
 ### `tForLocale(path, locale, params?)`
 Resuelve una clave en una locale específica sin cambiar el estado global. Útil para SSR o generación de emails.
 ```ts
 authLing.tForLocale('auth.loginFailed', 'en') // → "Login failed"
 ling.getLocale()                               // → "es" (no ha cambiado)
 ```
 ### `register(namespace, module)`
 Registra las traducciones de un módulo bajo un namespace. Devuelve una nueva instancia con los tipos extendidos que comparte el mismo estado reactivo que el singleton.
 ```ts
 export const authLing = ling.register('auth', { ... });
 ```
 - El locale se sincroniza automáticamente con el singleton — un solo `setLocale` actualiza todos los módulos.
 - Cada módulo ve sus claves tipadas más las del schema base.
 - Encadenar `register()` acumula namespaces:
 ```ts
 const full = ling
    .register('auth',     authTranslations)
    .register('checkout', checkoutTranslations);
 ```
 ### `setLocale(locale)`
 Cambia el locale del singleton y propaga el cambio a todos los módulos registrados.
 ```ts
 ling.setLocale('en')
 // authLing, checkoutLing... todos reflejan 'en' automáticamente
 ```
 ### `getLocale()`
 ```ts
 ling.getLocale() // → "es"
 ```
 ### `onLocaleChange(fn)`
 Registra un listener que se ejecuta cuando cambia el locale. Devuelve `unsubscribe`.
 ```ts
 const unsubscribe = ling.onLocaleChange((locale) => {
    console.log('Nuevo locale:', locale);
 });
 unsubscribe(); // deja de escuchar
 ```
 > `tForLocale()` no dispara los listeners.
 ---
 ## Locales soportadas
 | Código | Idioma |
 |--------|--------|
 | `es` | Español *(por defecto)* |
 | `en` | Inglés |
 | `de` | Alemán |
 | `fr` | Francés |
 | `it` | Italiano |
 | `pt` | Portugués |
 | `ca` | Catalán |
 | `eu` | Euskera |
 | `gl` | Gallego |
 Para añadir una nueva locale, edita `SupportedLocale` en `ling.types.ts`:
 ```ts
 export type SupportedLocale = DefaultLocale | 'en' | 'de' | 'fr' | ... | 'ja';
 ```
 TypeScript marcará todas las hojas del schema donde falte la nueva locale.
 ---
 ## Tipos públicos
 | Tipo | Descripción |
 |------|-------------|
 | `SupportedLocale` | Unión de todas las locales soportadas |
 | `DefaultLocale` | `'es'` — locale obligatoria en cada traducción |
 | `LocaleRecord` | `{ es: string, en?: string, ... }` |
 | `LingString` | `string \| LocaleRecord` — campos opcionalmente localizados |
 | `TranslationNode` | Tipo recursivo del árbol de traducciones |
 | `TranslationFn<P>` | Función de traducción con parámetros tipados |
 | `LingInstance<S>` | Tipo de la instancia parametrizado por el schema |
 ---
 ## Fallback
 ```
 locale actual → defaultLocale → clave como texto
 ```
 En desarrollo (`NODE_ENV === 'development'`) se emite `console.warn` cuando se usa el fallback. En producción la degradación es silenciosa.
 ---
 ## Integración con frameworks
 Conecta `setLocale` y `onLocaleChange` al sistema reactivo del framework.
 **Vue 3**
 ```ts
 import { ref } from 'vue';
 import { ling } from '@/ling.engine';
 export const locale = ref(ling.getLocale());
 ling.onLocaleChange(l => locale.value = l);
 ```
 **Svelte**
 ```ts
 import { writable } from 'svelte/store';
 import { ling } from '@/ling.engine';
 export const locale = writable(ling.getLocale());
 ling.onLocaleChange(l => locale.set(l));
 ```
 **React**
 ```ts
 import { useSyncExternalStore } from 'react';
 import { ling } from '@/ling.engine';
 export function useLocale() {
    return useSyncExternalStore(ling.onLocaleChange, ling.getLocale);
 }
 ```
 ---
 ## Tests
 ```bash
 vitest
 ```
 Los tests usan schemas propios independientes del de producción — no hay acoplamiento entre la suite y las traducciones reales.
--- a/src/ling/engine.ts
+++ b/src/ling/engine.ts
@ -0,0 +1,266 @@
 import type {
    SupportedLocale,
    LeafPaths,
    GetTypeAtPath,
    ParamsFor,
    HasParams,
    PluralForms,
    LingRecord,
    LingString, LingInstance, LingLogger, LingNode, PluralConfig,
 } from './types.ts';
 import { LING_ERRORS } from './errors.ts';
 import {isIDLing, isLingRecord} from "@/ling/guards.ts";
 import {idPrefix, loggerCategory, maxResolveDeep} from "@/ling/consts.ts";
 // ==============================
 // HELPERS
 // ==============================
 function resolvePath(obj: any, path: string): any {
    return path.split('.').reduce((acc, key) => acc?.[key], obj);
 }
 function isDev(): boolean {
    return typeof process !== 'undefined' && process.env?.NODE_ENV === 'development';
 }
 // Logger por defecto — console puro, sin dependencias externas.
 // Se reemplaza con setLogger() una vez logr está inicializado.
 const consoleLogger: LingLogger = {
    warn : (category, message) => isDev() && console.warn (message),
    error: (category, message) => isDev() && console.error(message),
 };
 // ==============================
 // ENGINE
 // ==============================
 export function createLing<S extends LingNode>(
    schema: S,
    defaultLocale: SupportedLocale
 ): LingInstance<S> {
    let currentSchema : LingNode = schema;
    let currentLocale : SupportedLocale = defaultLocale;
    let logger        : LingLogger      = consoleLogger;
    let loggerSet     : boolean         = false;
    const listeners = new Set<(locale: SupportedLocale) => void>();
    // -------------------------------------------------------------------------
    // Logger
    // -------------------------------------------------------------------------
    /**
     * Inyecta un logger externo. Solo puede llamarse una vez.
     * En desarrollo avisa si se intenta sobreescribir.
     */
    function setLogger(external: LingLogger): void {
        if (loggerSet) {
            if (isDev()) {
                console.warn(LING_ERRORS.LOGGER_ALREADY_SET);
            }
            return;
        }
        logger    = external;
        loggerSet = true;
    }
    // -------------------------------------------------------------------------
    // Locale
    // -------------------------------------------------------------------------
    function setLocale(locale: SupportedLocale): void {
        currentLocale = locale;
        listeners.forEach(fn => fn(locale));
    }
    function getLocale(): SupportedLocale {
        return currentLocale;
    }
    function onLocaleChange(fn: (locale: SupportedLocale) => void): () => void {
        listeners.add(fn);
        return () => listeners.delete(fn);
    }
    // -------------------------------------------------------------------------
    // Resolución interna
    // -------------------------------------------------------------------------
    function tsRecord(record: LingRecord, path?: string, params?: any): string {
        const translationInLocale = record[currentLocale];
        const isMissing = translationInLocale === undefined;
        // 1. Resolución del valor (con fallback)
        let translation = translationInLocale ?? record[defaultLocale] ?? path ?? '';
        // 2. Interpolación global (aplica a la traducción final)
        if (params) {
            Object.entries(params).forEach(([key, val]) => {
                translation = translation.replace(new RegExp(`{{${key}}}`, 'g'), String(val));
            });
        }
        // 3. LOGGING: Solo si estamos en desarrollo Y falta la traducción
        if (isDev() && isMissing) {
            const msg = path
                ? LING_ERRORS.MISSING_TRANSLATION(path, currentLocale, defaultLocale)
                : LING_ERRORS.MISSING_TRANSLATION_RECORD(currentLocale, defaultLocale);
            logger.warn(loggerCategory, msg);
        }
        return translation;
    }
    /**
     * Resuelve referencias de forma recursiva con un límite de profundidad
     * para evitar bucles infinitos.
     */
    function resolveValue(value: any, args: any[], depth: number): any {
        if (depth > maxResolveDeep) {
            logger.error(loggerCategory, LING_ERRORS.CIRCULAR_REFERENCE(value));
            throw new Error("Circular reference in ling");
        }
        if (isIDLing(value)) {
            const path = value.substring(idPrefix.length);
            const resolved = resolvePath(currentSchema, path);
            return resolveValue(resolved, args, depth + 1); // recursión con depth+1
        }
        if (typeof value === 'function') {
            return value(args[0]);
        }
        return value; // LingRecord, string, lo que sea
    }
    // -------------------------------------------------------------------------
    // API pública
    // -------------------------------------------------------------------------
    /**
     * Función principal de traducción.
     * Soporta navegación por puntos (dot-notation), pluralización e interpolación.
     */
    const t: LingInstance<S>['t'] = (path: string, ...args: any[]): any => {
        // 1. Buscamos el valor en el árbol de traducciones
        const rawValue = resolvePath(currentSchema, path);
        // 2. Si no existe nada en esa ruta, devolvemos el path y logueamos error
        if (rawValue === undefined) {
            if (isDev()) {
                logger.error(loggerCategory, LING_ERRORS.KEY_NOT_FOUND(path));
            }
            return path;
        }
        let finalValue = rawValue;
        finalValue = resolveValue(rawValue, args, 0);
        // 4. LÓGICA DE EJECUCIÓN: ¿Es una función (plural) o un objeto (LingRecord)?
        // CASO A: Es una función (ej: resultado de p())
        if (typeof finalValue === 'function') {
            // Ejecutamos la función pasándole los parámetros (args[0])
            // Esto devuelve un LingRecord (ej: { es: '1 mensaje', en: '1 message' })
            const record = finalValue(args[0]);
            // Delegamos en tsRecord para elegir el idioma e interpolar {{variables}}
            return tsRecord(record, path, args[0]);
        }
        // CASO B: Es un LingRecord directo (objeto con idiomas { es: '...', en: '...' })
        if (isLingRecord(finalValue)) {
            return tsRecord(finalValue, path, args[0]);
        }
        // CASO C: Es un string simple o fallback
        // Si por algún motivo llegamos a un valor que no es objeto ni función
        return String(finalValue);
    };
    function ts(value: LingString): string {
        if (!value) return '';
        const finalValue = resolveValue(value, [], 0);
        if (isLingRecord(finalValue)) return tsRecord(finalValue);
        return typeof finalValue === 'string' ? finalValue : String(finalValue);
    }
    function tForLocale<P extends LeafPaths<S>, TType = GetTypeAtPath<S, S, P>>(
        path: P,
        locale: SupportedLocale,
        ...args: HasParams<TType> extends true ? [params: ParamsFor<TType>] : []
    ) : string   {
        const prev = currentLocale;
        currentLocale = locale;
        const result = t(path, ...(args as any));
        currentLocale = prev;
        return result;
    }
    function register<NS extends string, M extends LingNode>(
        namespace: NS,
        module: M
    ): LingInstance<S & { [K in NS]: M }> {
        currentSchema = {
            ...(currentSchema as Record<string,any>),
            [namespace]: module,
        };
        const extended = createLing(
            currentSchema as S & { [K in NS]: M },
            defaultLocale
        );
        extended.setLocale(currentLocale);
        onLocaleChange(locale => extended.setLocale(locale));
        return extended;
    }
    return { t, tForLocale, ts, setLocale, getLocale, onLocaleChange, register, setLogger };
 }
 /**
 * Helper para generar traducciones pluralizadas.
 * Mapea cada idioma a sus respectivas reglas gramaticales.
 */
 /**
 * Helper de pluralización.
 * El tipo de retorno ahora incluye '& Record<string, any>' para permitir
 * parámetros adicionales de interpolación (como {{name}}).
 */
 export const p = (config: PluralConfig) =>
    (params: { count: number } & Record<string, any>): LingRecord => {
        const result: any = {};
        for (const [locale, forms] of Object.entries(config)) {
            if (!forms) continue;
            // Seleccionamos la regla (one, other, etc.) según el idioma
            const rule = new Intl.PluralRules(locale).select(params.count);
            const typedForms = forms as PluralForms;
            // Si la regla específica no existe (ej: 'few'), usamos 'other'
            result[locale] = typedForms[rule] || typedForms.other;
        }
        return result as LingRecord;
    };
--- a/src/ling/errors.ts
+++ b/src/ling/errors.ts
@ -0,0 +1,62 @@
 import type { SupportedLocale } from './types.ts';
 // ============================================================================
 // LING ERROR & WARNING MESSAGES
 // ============================================================================
 /**
 * Mensajes de error y warning del sistema ling centralizados como constantes.
 *
 * No se usa el sistema de `Logr` para evitar dependencia cíclica —
 * `Logr` depende de `ling`, por lo que `ling` no puede depender de `Logr`.
 *
 * Estos mensajes se emiten directamente por consola solo en desarrollo
 * (`NODE_ENV === 'development'`). En producción la degradación es silenciosa.
 */
 export const LING_ERRORS = {
    /**
     * La clave de traducción no existe en el schema.
     * Se emite como `console.error` — indica un error de programación,
     * no una traducción faltante.
     *
     * @example
     * LING_ERRORS.KEY_NOT_FOUND('checkout.total')
     * // → '[ling] Translation key not found: "checkout.total"'
     */
    KEY_NOT_FOUND: (path: string): string =>
        `[ling] Translation key not found: "${path}"`,
    CIRCULAR_REFERENCE: (path: string): string =>
        `[ling] Circular reference in "${path}".`,
    /**
     * La clave existe pero no tiene traducción para el locale solicitado.
     * Se emite como `console.warn` — degradación controlada con fallback.
     *
     * @example
     * LING_ERRORS.MISSING_TRANSLATION('common.ok', 'de', 'es')
     * // → '[ling] Missing translation for "common.ok" in "de". Falling back to "es".'
     */
    MISSING_TRANSLATION: (path: string, locale: SupportedLocale, fallback: SupportedLocale): string =>
        `[ling] Missing translation for "${path}" in "${locale}". Falling back to "${fallback}".`,
    /**
     * Variante de MISSING_TRANSLATION para cuando no hay path disponible
     * — usado en `ts()` al resolver un `LocaleRecord` sin contexto de clave.
     *
     * @example
     * LING_ERRORS.MISSING_TRANSLATION_RECORD('de', 'es')
     * // → '[ling] Missing translation in "de". Falling back to "es".'
     */
    MISSING_TRANSLATION_RECORD: (locale: SupportedLocale, fallback: SupportedLocale): string =>
        `[ling] Missing translation in "${locale}". Falling back to "${fallback}".`,
    /**
     * Se intentó llamar a setLogger() más de una vez.
     * El logger solo puede inyectarse una vez — post-init es inmutable.
     */
    LOGGER_ALREADY_SET: '[ling] Logger already set. setLogger() can only be called once.',
 } as const;
--- a/src/ling/guards.ts
+++ b/src/ling/guards.ts
@ -0,0 +1,29 @@
 import type {DefaultLocale, IDLing, LingRecord} from "@/ling/types.ts";
 import {defaultISOLocale, idPrefix} from "@/ling/consts.ts";
 /**
 * Guard para identificar referencias.
 * Usamos un chequeo de longitud para evitar que "#?" vacío sea válido.
 */
 export function isIDLing(value: unknown): value is IDLing {
    return (
        typeof value === 'string' &&
        value.startsWith(idPrefix) &&
        value.length > 2
    );
 }
 /**
 * Guard para registros de idioma.
 * Valida la existencia de la DefaultLocale definida en el sistema.
 */
 export function isLingRecord(value: unknown): value is LingRecord {
    return (
        typeof value === 'object' &&
        value !== null &&
        !Array.isArray(value) &&
        defaultISOLocale in value // obligatorio según DefaultLocale
    );
 }
--- a/src/ling/index.ts
+++ b/src/ling/index.ts
@ -0,0 +1,8 @@
 export { translations } from './translations';
 export * from './types.ts';
 export * from './engine.ts';
 export * from './instance.ts';
 export * from './translations';
--- a/src/ling/instance.ts
+++ b/src/ling/instance.ts
@ -0,0 +1,12 @@
 import { createLing } from './engine.ts';
 import { translations } from './translations';
 export const ling = createLing(translations, 'es');
 // Desestructura si prefieres usar t() directamente
 export const { t, tForLocale, setLocale, getLocale, onLocaleChange } = ling;
--- a/src/ling/tests/ling.test.ts
+++ b/src/ling/tests/ling.test.ts
@ -0,0 +1,390 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import {createLing, ling} from '@/ling';
 import type { LingNode, LingString } from '@/ling';
 // ==============================
 // SCHEMA DE TEST
 // ==============================
 const testSchema = {
    common: {
        ok: {
            es: 'Aceptar',
            en: 'OK',
            fr: 'Accepter'
        },
        cancel: {
            es: 'Cancelar',
            en: 'Cancel'
        }
    },
    checkout: {
        pay: {
            es: 'Pagar',
            en: 'Pay'
        },
        total: (params: { amount: number; currency: string }) => ({
            es: `Total: ${params.amount}${params.currency}`,
            en: `Total: ${params.currency}${params.amount}`
        })
    },
    errors: {
        generic: (params: { code: number }) => ({
            es: `Error ${params.code}`,
            en: `Error ${params.code}`
        })
    },
    // Clave solo en español (para probar fallback)
    onlySpanish: {
        es: 'Solo en español'
    }
 } satisfies LingNode;
 // ==============================
 // TESTS
 // ==============================
 describe('createI18n', () => {
    describe('instanciación', () => {
        it('crea una instancia con el locale por defecto', () => {
            const i18n = createLing(testSchema, 'es');
            expect(i18n.getLocale()).toBe('es');
        });
        it('crea instancias independientes con distintos locales', () => {
            const i18nEs = createLing(testSchema, 'es');
            const i18nEn = createLing(testSchema, 'en');
            expect(i18nEs.getLocale()).toBe('es');
            expect(i18nEn.getLocale()).toBe('en');
            // Cambiar uno no afecta al otro
            i18nEs.setLocale('fr');
            expect(i18nEn.getLocale()).toBe('en');
        });
    });
    describe('t() — traducciones simples', () => {
        let ln: ReturnType<typeof createLing<typeof testSchema>>;
        beforeEach(() => {
            ln = createLing(testSchema, 'es');
        });
        it('devuelve la traducción en el locale actual', () => {
            expect(ln.t('common.ok')).toBe('Aceptar');
        });
        it('devuelve la traducción tras cambiar de locale', () => {
            ln.setLocale('en');
            expect(ln.t('common.ok')).toBe('OK');
        });
        it('devuelve la traducción en francés', () => {
            ln.setLocale('fr');
            expect(ln.t('common.ok')).toBe('Accepter');
        });
    });
    describe('t() — traducciones con parámetros', () => {
        let ln: ReturnType<typeof createLing<typeof testSchema>>;
        beforeEach(() => {
            ln = createLing(testSchema, 'es');
        });
        it('interpola parámetros correctamente en español', () => {
            expect(ling.t('checkout.total', { amount: 99, currency: '€' }))
                .toBe('Total: 99€');
        });
        it('interpola parámetros correctamente en inglés', () => {
            ln.setLocale('en');
            expect(ln.t('checkout.total', { amount: 99, currency: '$' }))
                .toBe('Total: $99');
        });
        it('interpola parámetros numéricos', () => {
            expect(ln.t('errors.generic', { code: 404 }))
                .toBe('Error 404');
        });
    });
    describe('t() — fallback', () => {
        let i18n: ReturnType<typeof createLing<typeof testSchema>>;
        beforeEach(() => {
            i18n = createLing(testSchema, 'es');
        });
        it('hace fallback al locale por defecto si falta la traducción', () => {
            i18n.setLocale('de'); // 'de' no existe en onlySpanish
            expect(i18n.t('onlySpanish')).toBe('Solo en español');
        });
        it('devuelve la clave si no existe en ningún locale', () => {
            // @ts-expect-error — clave inexistente a propósito
            expect(i18n.t('this.key.does.not.exist')).toBe('this.key.does.not.exist');
        });
        it('loguea un warning en desarrollo cuando hace fallback', () => {
            const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
            const originalEnv = process.env.NODE_ENV;
            process.env.NODE_ENV = 'development';
            i18n.setLocale('de');
            i18n.t('onlySpanish');
            expect(warn).toHaveBeenCalledWith(
                expect.stringContaining('Missing translation')
            );
            process.env.NODE_ENV = originalEnv;
            warn.mockRestore();
        });
        it('no loguea en producción', () => {
            const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
            const originalEnv = process.env.NODE_ENV;
            process.env.NODE_ENV = 'production';
            i18n.setLocale('de');
            i18n.t('onlySpanish');
            expect(warn).not.toHaveBeenCalled();
            process.env.NODE_ENV = originalEnv;
            warn.mockRestore();
        });
    });
    describe('tForLocale()', () => {
        it('resuelve en la locale indicada sin cambiar el estado global', () => {
            const lng = createLing(testSchema, 'es');
            const result = lng.tForLocale('common.ok', 'en');
            expect(result).toBe('OK');
            expect(lng.getLocale()).toBe('es'); // no ha cambiado
        });
        it('funciona con parámetros', () => {
            const lng = createLing(testSchema, 'es');
            const result = lng.tForLocale('checkout.total', 'en', { amount: 50, currency: '$' });
            expect(result).toBe('Total: $50');
            expect(lng.getLocale()).toBe('es');
        });
    });
    describe('setLocale() / getLocale()', () => {
        it('actualiza el locale correctamente', () => {
            const i18n = createLing(testSchema, 'es');
            i18n.setLocale('en');
            expect(i18n.getLocale()).toBe('en');
        });
    });
    describe('onLocaleChange()', () => {
        it('notifica al cambiar de locale', () => {
            const i18n = createLing(testSchema, 'es');
            const listener = vi.fn();
            i18n.onLocaleChange(listener);
            i18n.setLocale('en');
            expect(listener).toHaveBeenCalledWith('en');
            expect(listener).toHaveBeenCalledTimes(1);
        });
        it('no notifica después de hacer unsubscribe', () => {
            const i18n = createLing(testSchema, 'es');
            const listener = vi.fn();
            const unsubscribe = i18n.onLocaleChange(listener);
            unsubscribe();
            i18n.setLocale('en');
            expect(listener).not.toHaveBeenCalled();
        });
        it('soporta múltiples listeners', () => {
            const i18n = createLing(testSchema, 'es');
            const l1 = vi.fn();
            const l2 = vi.fn();
            i18n.onLocaleChange(l1);
            i18n.onLocaleChange(l2);
            i18n.setLocale('fr');
            expect(l1).toHaveBeenCalledWith('fr');
            expect(l2).toHaveBeenCalledWith('fr');
        });
        it('tForLocale no dispara los listeners', () => {
            const i18n = createLing(testSchema, 'es');
            const listener = vi.fn();
            i18n.onLocaleChange(listener);
            i18n.tForLocale('common.ok', 'en');
            expect(listener).not.toHaveBeenCalled();
        });
    });
 });
 // ==============================
 // TESTS ts()
 // ==============================
 describe('resolve()', () => {
    let i18n: ReturnType<typeof createLing<typeof testSchema>>;
    beforeEach(() => {
        i18n = createLing(testSchema, 'es');
    });
    it('devuelve el string tal cual si es un string simple', () => {
        expect(i18n.ts('texto fijo')).toBe('texto fijo');
    });
    it('devuelve el string vacío sin errores', () => {
        expect(i18n.ts('')).toBe('');
    });
    it('resuelve un LocaleRecord con el locale actual', () => {
        const desc: LingString = { es: 'una descripción', en: 'a description' };
        expect(i18n.ts(desc)).toBe('una descripción');
    });
    it('resuelve un LocaleRecord tras cambiar de locale', () => {
        const desc: LingString = { es: 'una descripción', en: 'a description' };
        i18n.setLocale('en');
        expect(i18n.ts(desc)).toBe('a description');
    });
    it('hace fallback al defaultLocale si el locale actual no existe en el record', () => {
        const desc: LingString = { es: 'solo español' };
        i18n.setLocale('de');
        expect(i18n.ts(desc)).toBe('solo español');
    });
    it('funciona con un interface que usa I18nString', () => {
        interface Producto {
            id: string;
            descripcion: LingString;
        }
        const producto: Producto = {
            id: '1',
            descripcion: { es: 'Silla de madera', en: 'Wooden chair' }
        };
        expect(i18n.ts(producto.descripcion)).toBe('Silla de madera');
        i18n.setLocale('en');
        expect(i18n.ts(producto.descripcion)).toBe('Wooden chair');
    });
    it('funciona mezclando strings simples y LocaleRecord en el mismo array', () => {
        const items: LingString[] = [
            'id-invariante',
            { es: 'nombre', en: 'name' },
            'otro-invariante'
        ];
        const resolved = items.map(i18n.ts);
        expect(resolved).toEqual(['id-invariante', 'nombre', 'otro-invariante']);
    });
 });
 // ==============================
 // TESTS register()
 // ==============================
 describe('register()', () => {
    const baseSchema = {
        common: {
            ok: { es: 'Aceptar', en: 'OK' }
        }
    } satisfies LingNode;
    it('registra traducciones de un módulo bajo un namespace', () => {
        const i18n = createLing(baseSchema, 'es');
        const extended = i18n.register('auth', {
            loginFailed: { es: 'Login fallido', en: 'Login failed' }
        });
        expect(extended.t('auth.loginFailed')).toBe('Login fallido');
    });
    it('mantiene acceso a las claves del schema base', () => {
        const i18n = createLing(baseSchema, 'es');
        const extended = i18n.register('auth', {
            loginFailed: { es: 'Login fallido', en: 'Login failed' }
        });
        expect(extended.t('common.ok')).toBe('Aceptar');
    });
    it('hereda el locale actual en el momento del registro', () => {
        const i18n = createLing(baseSchema, 'es');
        i18n.setLocale('en');
        const extended = i18n.register('auth', {
            loginFailed: { es: 'Login fallido', en: 'Login failed' }
        });
        expect(extended.t('auth.loginFailed')).toBe('Login failed');
    });
    it('se sincroniza cuando cambia el locale en la instancia base', () => {
        const i18n      = createLing(baseSchema, 'es');
        const extended  = i18n.register('auth', {
            loginFailed: { es: 'Login fallido', en: 'Login failed' }
        });
        i18n.setLocale('en');
        expect(extended.t('auth.loginFailed')).toBe('Login failed');
        expect(extended.t('common.ok')).toBe('OK');
    });
    it('múltiples módulos se acumulan correctamente', () => {
        const i18n      = createLing(baseSchema, 'es');
        const withAuth  = i18n.register('auth', {
            loginFailed: { es: 'Login fallido', en: 'Login failed' }
        });
        const withAll   = withAuth.register('checkout', {
            pay: { es: 'Pagar', en: 'Pay' }
        });
        expect(withAll.t('common.ok')).toBe('Aceptar');
        expect(withAll.t('auth.loginFailed')).toBe('Login fallido');
        expect(withAll.t('checkout.pay')).toBe('Pagar');
    });
    it('cambiar locale en base se propaga a todos los módulos registrados', () => {
        const i18n      = createLing(baseSchema, 'es');
        const withAuth  = i18n.register('auth', {
            loginFailed: { es: 'Login fallido', en: 'Login failed' }
        });
        const withAll   = withAuth.register('checkout', {
            pay: { es: 'Pagar', en: 'Pay' }
        });
        i18n.setLocale('en');
        expect(withAll.t('common.ok')).toBe('OK');
        expect(withAll.t('auth.loginFailed')).toBe('Login failed');
        expect(withAll.t('checkout.pay')).toBe('Pay');
    });
 });
--- a/src/ling/tests/ling2.test.ts
+++ b/src/ling/tests/ling2.test.ts
@ -0,0 +1,132 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createLing } from '@/ling';
 import type { LingNode, LingString } from '@/ling';
 // ==============================
 // SCHEMA DE TEST ACTUALIZADO
 // ==============================
 const testSchema = {
    common: {
        save: { es: 'Guardar', en: 'Save' },
        cancel: { es: 'Cancelar', en: 'Cancel' }
    },
    checkout: {
        total: (params: { amount: number; currency: string }) => ({
            es: `Total: ${params.amount}${params.currency}`,
            en: `Total: ${params.currency}${params.amount}`
        })
    },
    // --- SECCIÓN DE ALIAS (#?) ---
    shortcuts: {
        // Alias simple
        confirm: '#?common.save',
        // Alias recursivo (doble salto)
        mainAction: '#?shortcuts.confirm',
        // Alias a función con parámetros
        invoice: '#?checkout.total'
    },
    danger: {
        // Referencia circular para test de seguridad
        loopA: '#?danger.loopB',
        loopB: '#?danger.loopA'
    }
 } satisfies LingNode;
 describe('Ling Library', () => {
    describe('Sistema de Referencias (#?)', () => {
        let ling: ReturnType<typeof createLing<typeof testSchema>>;
        beforeEach(() => {
            ling = createLing(testSchema, 'es');
        });
        it('debería resolver un alias simple mediante t()', () => {
            // shortcuts.confirm -> common.save
            expect(ling.t('shortcuts.confirm')).toBe('Guardar');
            ling.setLocale('en');
            expect(ling.t('shortcuts.confirm')).toBe('Save');
        });
        it('debería resolver alias recursivos (saltos múltiples)', () => {
            // shortcuts.mainAction -> shortcuts.confirm -> common.save
            expect(ling.t('shortcuts.mainAction')).toBe('Guardar');
        });
        it('debería resolver alias que apuntan a funciones con parámetros', () => {
            // shortcuts.invoice apunta a checkout.total
            const result = ling.t('shortcuts.invoice', { amount: 100, currency: '€' });
            expect(result).toBe('Total: 100€');
            ling.setLocale('en');
            expect(ling.t('shortcuts.invoice', { amount: 100, currency: '$' })).toBe('Total: $100');
        });
        it('debería manejar referencias circulares lanzando un error (depth limit)', () => {
            // Envolvemos la llamada en una función (arrow function)
            // para que Vitest pueda capturar la excepción en lugar de crashear.
            expect(() => {
                ling.t('danger.loopA');
            }).toThrow("Circular reference in ling"); // Verificamos que el mensaje del error sea el correcto
        });
    });
    describe('ts() — Resolutor de LingString', () => {
        let ling: ReturnType<typeof createLing<typeof testSchema>>;
        beforeEach(() => {
            ling = createLing(testSchema, 'es');
        });
        it('debería resolver una referencia #? pasada como LingString', () => {
            const externalRef: LingString = '#?common.save';
            expect(ling.ts(externalRef)).toBe('Guardar');
        });
        it('debería resolver un LingRecord manual', () => {
            const record: LingString = { es: 'Hola', en: 'Hello' };
            expect(ling.ts(record)).toBe('Hola');
        });
        it('debería devolver el string tal cual si es texto plano', () => {
            expect(ling.ts('Texto fijo')).toBe('Texto fijo');
        });
    });
    describe('t() — Funcionalidades Core (Legacy check)', () => {
        let ling: ReturnType<typeof createLing<typeof testSchema>>;
        beforeEach(() => {
            ling = createLing(testSchema, 'es');
        });
        it('debería cambiar de idioma y afectar a todas las resoluciones', () => {
            expect(ling.t('common.save')).toBe('Guardar');
            ling.setLocale('en');
            expect(ling.t('common.save')).toBe('Save');
        });
        it('tForLocale() no debería alterar el idioma global', () => {
            const res = ling.tForLocale('common.save', 'en');
            expect(res).toBe('Save');
            expect(ling.getLocale()).toBe('es');
        });
    });
    describe('register() — Extensibilidad', () => {
        it('debería permitir registrar nuevos módulos y usar alias hacia la base', () => {
            const ling = createLing(testSchema, 'es');
            const extended = ling.register('admin', {
                title: { es: 'Panel', en: 'Panel' },
                saveBtn: '#?common.save' // Alias hacia el schema padre
            });
            expect(extended.t('admin.title')).toBe('Panel');
            expect(extended.t('admin.saveBtn')).toBe('Guardar');
        });
    });
 });// ling2.test.ts
--- a/src/ling/tests/plural.test.ts
+++ b/src/ling/tests/plural.test.ts
@ -0,0 +1,55 @@
 import { describe, it, expect } from 'vitest';
 import { createLing, p } from '@/ling';
 describe('Pluralización con helper p()', () => {
    const translations = {
        cart: {
            // Usamos el helper para definir las reglas
            items: p({
                es: { one: 'tienes {{count}} producto', other: 'tienes {{count}} productos' },
                en: { one: 'you have {{count}} item', other: 'you have {{count}} items' }
            })
        }
    } as const;
    it('debería pluralizar correctamente en español (Singular)', () => {
        const ling = createLing(translations, 'es');
        // El tipado detectará que 'cart.items' requiere { count: number }
        expect(ling.t('cart.items', { count: 1 })).toBe('tienes 1 producto');
    });
    it('debería pluralizar correctamente en español (Plural)', () => {
        const ling = createLing(translations, 'es');
        expect(ling.t('cart.items', { count: 5 })).toBe('tienes 5 productos');
    });
    it('debería pluralizar correctamente en inglés (Singular)', () => {
        const ling = createLing(translations, 'en');
        expect(ling.t('cart.items', { count: 1 })).toBe('you have 1 item');
    });
    it('debería pluralizar correctamente en inglés (Plural)', () => {
        const ling = createLing(translations, 'en');
        expect(ling.t('cart.items', { count: 2 })).toBe('you have 2 items');
    });
    it('debería manejar el caso de "cero" según las reglas del idioma (en ES/EN es plural)', () => {
        const ling = createLing(translations, 'es');
        // Intl.PluralRules en español devuelve 'other' para 0
        expect(ling.t('cart.items', { count: 0 })).toBe('tienes 0 productos');
    });
    it('debería ser compatible con otros parámetros adicionales', () => {
        const transWithUser = {
            greet: p({
                es: { one: 'Hola {{name}}, tienes {{count}} mensaje', other: 'Hola {{name}}, tienes {{count}} mensajes' },
                en: { one: 'Hi {{name}}, you have {{count}} message', other: 'Hi {{name}}, you have {{count}} messages' }
            })
        } as const;
        const ling = createLing(transWithUser, 'es');
        expect(ling.t('greet', { count: 10, name: 'Alex' }))
            .toBe('Hola Alex, tienes 10 mensajes');
    });
 });
--- a/src/ling/translations.ts
+++ b/src/ling/translations.ts
@ -0,0 +1,46 @@
 import type { LingNode  } from './types.ts';
 /**
 * MEJORA: `satisfies TranslationNode` en lugar de `satisfies Record<string, any>`.
 * Ahora TypeScript valida que cada hoja sea un LocaleRecord válido o una función tipada.
 * Si añades una clave malformada (ej: { es: 123 }), obtendrás un error en tiempo de compilación.
 */
 export const translations  = {
    checkout: {
        pay: {
            es: "Pagar",
            en: "Pay"
        },
        total: (params: { amount: number; currency: string }) => ({
            es: `Total: ${params.amount}${params.currency}`,
            en: `Total: ${params.currency}${params.amount}`
        })
    },
    common: {
        ok: {
            es: "Aceptar",
            en: "OK"
        },
        cancel: {
            es: "Cancelar",
            en: "Cancel"
        }
    },
    errors: {
        notFound: {
            es: "Página no encontrada",
            en: "Page not found"
        },
        generic: (params: { code: number }) => ({
            es: `Ha ocurrido un error (${params.code})`,
            en: `An error occurred (${params.code})`
        })
    }
 } satisfies LingNode;
 export type TranslationSchema = typeof translations;
--- a/src/ling/types.ts
+++ b/src/ling/types.ts
@ -0,0 +1,235 @@
 // ==============================
 // LOCALES
 // ==============================
 import {idPrefix} from "@/ling/consts.ts";
 /**
 * Referencia interna: #?path.del.schema
 */
 export type IDLing = `${typeof idPrefix}${string}`;
 export type DefaultLocale = 'es';
 export type SupportedLocale =
    | DefaultLocale
    | 'en'
    | 'de'
    | 'fr'
    | 'it'
    | 'pt'
    | 'ca'
    | 'eu'
    | 'gl';
 // ==============================
 // LOCALIZED TYPES
 // ==============================
 /**
 * Un registro de traducciones donde `es` es obligatorio
 * y el resto de locales son opcionales.
 */
 export type LingRecord = {
    [K in SupportedLocale]?: string;
 } & {
    [K in DefaultLocale]: string;
 };
 /**
 * Params tipado con un genérico en lugar de `any`,
 * así las funciones de traducción con parámetros son completamente type-safe.
 */
 export type LingFn<P extends Record<string, unknown>> = (params: P) => LingRecord;
 export type LingValue =
    | LingRecord
    | ((...args: any[]) => any)
    | IDLing;
 /**
 * LING NODE: Es el tipo recursivo.
 * Un nodo puede ser un valor final (LingValue)
 * o un objeto que contiene más LingNodes.
 */
 export type LingNode =
    | LingValue
    | { [key: string]: LingNode };
 /**
 * Un valor que puede ser un string simple (invariante de locale)
 * o un LocaleRecord con traducciones por locale.
 * Útil para campos de datos que pueden o no estar localizados.
 *
 * @example
 * interface Product {
 *     id: string;
 *     description: LingString;
 * }
 *
 * const product: Product = {
 *     id: '1',
 *     description: { es: 'una descripción', en: 'a description' }
 * };
 *
 * // o también válido:
 * const product2: Product = {
 *     id: '2',
 *     description: 'fixed string'
 * };
 */
 export type LingString =
    string |
    LingRecord |
    IDLing;
 // ==============================
 // TYPE UTILITIES
 // ==============================
 type Prev = [never, 0, 1, 2, 3, 4, 5, 6];
 /**
 * `LeafPaths` solo expone las rutas que terminan en una hoja
 * (LocaleRecord o función), no las rutas intermedias (namespaces).
 */
 export type LeafPaths<T, D extends number = 6> =
    [D] extends [never]
        ? never
        : T extends LingValue
            ? ''
            : T extends object
                ? {
                    [K in keyof T & string]:
                    T[K] extends LingValue
                        ? K
                        : `${K}.${LeafPaths<T[K], Prev[D]> & string}`
                }[keyof T & string]
                : never;
 export type GetTypeAtPath<
    Root,
    Current,
    P extends string
 > =
    P extends `${infer K}.${infer Rest}`
        ? K extends keyof Current
            ? GetTypeAtPath<Root, Current[K], Rest>
            : never
        : P extends keyof Current
            ? Current[P] extends `#?${infer AliasPath}`
                ? GetTypeAtPath<Root, Root, AliasPath> // 🔍 Salto cuántico: reiniciamos desde el Root
                : Current[P]
            : never;
 export type ParamsFor<T> =
    T extends (params: infer P) => any
        ? P
        : never;
 export type HasParams<T> =
    T extends (params: any) => any
        ? true
        : false;
 /** * Define las formas posibles según el estándar Unicode (zero, one, two, few, many, other)
 */
 export type PluralForms = Partial<Record<Intl.LDMLPluralRule, string>> & { other: string };
 export type PluralConfig = {
    [K in SupportedLocale]?: PluralForms;
 } & {
    [K in DefaultLocale]: PluralForms;
 };
 // ==============================
 // INSTANCE TYPE
 // ==============================
 /**
 * Tipo de la instancia de ling parametrizado por el schema S.
 * Usar este tipo en lugar de `ReturnType<typeof createLing>`
 * para preservar la información del schema y tener t() tipado correctamente.
 *
 * @example
 * function useTranslations(ling: LingInstance<typeof mySchema>) {
 *     ling.t('my.key') // ✅ tipado contra mySchema
 * }
 */
 export type LingInstance<S extends LingNode = LingNode> = {
    // Fíjate en el GetTypeAtPath<S, S, P> (pasamos la S dos veces: como Root y como Current)
    t: <P extends LeafPaths<S>, TType = GetTypeAtPath<S, S, P>>(
        path: P,
        ...args: HasParams<TType> extends true ? [params: ParamsFor<TType>] : []
    ) => string;
    ts          : (value: LingString) => string;
    tForLocale: <P extends LeafPaths<S>, TType = GetTypeAtPath<S, S, P>>(
        path: P,
        locale: SupportedLocale,
        ...args: HasParams<TType> extends true ? [params: ParamsFor<TType>] : []
    ) => string;
    setLocale   : (locale: SupportedLocale) => void;
    getLocale   : () => SupportedLocale;
    onLocaleChange: (fn: (locale: SupportedLocale) => void) => () => void;
    register    : <NS extends string, M extends LingNode>(
        namespace: NS,
        module: M
    ) => LingInstance<S & { [K in NS]: M }>;
    /**
     * Inyecta un logger externo que reemplaza el comportamiento por defecto (console).
     * Solo puede llamarse una vez — una vez inyectado no se puede reemplazar.
     * En desarrollo emite un warning si se intenta llamar más de una vez.
     *
     * Diseñado para romper la dependencia cíclica ling ↔ logr:
     * ling arranca con console, logr se inicializa con ling,
     * y entonces ling adopta logr como logger definitivo.
     *
     * @example
     * const ling = createLing(translations, "es");  // usa console
     * const logr = createLogr(ling, options);        // logr listo
     * ling.setLogger(logr);                          // ling adopta logr
     */
    setLogger   : (logger: LingLogger) => void;
 };
 // ==============================
 // LING LOGGER INTERFACE
 // ==============================
 /**
 * Interfaz mínima estructural que ling necesita de un logger.
 * Intencionalmente no es `Logr` completo para evitar dependencia
 * de compilación entre ling y logr.
 *
 * Cualquier objeto que tenga `warn` y `error` con esta firma es válido.
 *
 * @example
 * // Logr satisface esta interfaz automáticamente
 * ling.setLogger(logr);
 *
 * // También un logger custom
 * ling.setLogger({ warn: console.warn, error: console.error });
 */
 export interface LingLogger {
    warn : (category: string, message: string) => void;
    error: (category: string, message: string) => void;
 }
--- a/src/logr/docs/logr.md
+++ b/src/logr/docs/logr.md
@ -0,0 +1,304 @@
 # Logr
 Sistema de logging estructurado con soporte nativo para mensajes localizados y sistema de transports extensible. Depende de `@/libs/i18n` para la resolución de mensajes al locale activo.
 ---
 ## Estructura de ficheros
 ```
 logr/
 ├── index.ts                # Barrel — punto de entrada público
 ├── logr.engine.ts          # Factory: createLogr()
 ├── logr.transports.ts      # Transports built-in
 ├── logr.types.ts           # Tipos e interfaces
 ├── logr.test.ts            # Tests del engine
 └── logr.transports.test.ts # Tests de los transports
 ```
 ---
 ## Setup
 ```ts
 // logr/index.ts — instancia global
 import { createLogr, LogLevel, consoleTransport, httpTransport } from './logr.engine';
 import { i18n } from '@/libs/i18n/i18n.engine';
 export const logr = createLogr(i18n, {
    level     : LogLevel.WARN,
    transports: [
        consoleTransport(),
        httpTransport({
            url    : 'https://logs.myapp.com/ingest',
            headers: { 'Authorization': 'Bearer my-token' },
            level  : LogLevel.ERROR, // solo errores al servidor
        }),
    ]
 });
 ```
 ```ts
 // Configuración por entorno
 if (import.meta.env.DEV) {
    logr.setLevel(LogLevel.DEBUG);
    logr.setMaxLogs(5000);
 }
 ```
 > Si no se especifican transports, usa `consoleTransport()` por defecto.
 ---
 ## API
 ### `debug / info / warn / error`
 Los cuatro métodos de log comparten la misma firma:
 ```ts
 logr.debug(category, message, context?)
 logr.info (category, message, context?)
 logr.warn (category, message, context?)
 logr.error(category, message, context?)
 ```
 | Parámetro  | Tipo                      | Descripción |
 |------------|---------------------------|-------------|
 | `category` | `string`                  | Dominio funcional — `'auth'`, `'db'`, `'render'`... |
 | `message`  | `I18nString`              | String simple o `LocaleRecord` con traducciones |
 | `context`  | `Record<string, unknown>` | Datos adicionales opcionales para diagnóstico |
 ```ts
 // String simple
 logr.warn('db', 'Connection timeout', { host: 'db.prod', ms: 3000 });
 // LocaleRecord — se resuelve al locale activo automáticamente
 logr.error('auth', { es: 'Login fallido', en: 'Login failed' });
 ```
 Un log solo se procesa si su nivel es **mayor o igual** al nivel configurado:
 ```
 DEBUG(0) < INFO(1) < WARN(2) < ERROR(3) < NONE(4)
 ```
 ### `getLogs(filters?)`
 Devuelve las entradas del historial en memoria. Los filtros son opcionales y se combinan con AND.
 ```ts
 logr.getLogs()                                   // todas las entradas
 logr.getLogs({ level: LogLevel.ERROR })          // solo errores
 logr.getLogs({ category: 'auth' })               // solo entradas de 'auth'
 logr.getLogs({ since: new Date('2024-01-01') })  // desde una fecha
 logr.getLogs({ category: 'auth', level: LogLevel.WARN }) // combinados
 ```
 > Los mensajes se devuelven como `I18nString` sin resolver.
 ### `serialize()`
 Exporta el historial como JSON. Los mensajes se resuelven al locale activo **en el momento de la llamada**.
 ```ts
 const json = logr.serialize();
 // [
 //   {
 //     "timestamp": "2024-01-01T00:00:00.000Z",
 //     "level": 2,
 //     "category": "auth",
 //     "message": "Login failed",
 //     "locale": "en"
 //   }
 // ]
 ```
 ### `clear()`
 ```ts
 logr.clear();
 logr.getLogs(); // → []
 ```
 ### `setLevel(level)`
 ```ts
 logr.setLevel(LogLevel.DEBUG) // activa todos los niveles
 logr.setLevel(LogLevel.NONE)  // silencia todos los logs — útil en tests
 ```
 ### `setMaxLogs(max)`
 ```ts
 logr.setMaxLogs(5000) // desarrollo
 logr.setMaxLogs(500)  // producción
 ```
 ---
 ## Transports
 Un transport es un destino de salida para las entradas de log. El engine emite cada entrada a todos los transports registrados, con el mensaje ya resuelto al locale activo.
 ### `consoleTransport(options?)`
 Emite los logs a la consola usando el método apropiado según el nivel.
 ```ts
 consoleTransport()                              // con timestamp y prefijo
 consoleTransport({ timestamp: false })          // sin timestamp
 consoleTransport({ prefix: false })             // sin prefijo [category]
 consoleTransport({ timestamp: false, prefix: false }) // solo el mensaje
 ```
 | Opción      | Tipo      | Default | Descripción |
 |-------------|-----------|---------|-------------|
 | `timestamp` | `boolean` | `true`  | Incluye el ISO timestamp en el output |
 | `prefix`    | `boolean` | `true`  | Incluye el prefijo `[category]` |
 ### `httpTransport(options)`
 Envía las entradas a un endpoint HTTP remoto via POST. Fire-and-forget — los errores de red no interrumpen la aplicación.
 ```ts
 httpTransport({
    url    : 'https://logs.myapp.com/ingest',
    headers: { 'Authorization': 'Bearer token' },
    level  : LogLevel.ERROR  // nivel mínimo independiente del logger
 })
 ```
 | Opción    | Tipo          | Default         | Descripción |
 |-----------|---------------|-----------------|-------------|
 | `url`     | `string`      | —               | Endpoint que recibe los logs |
 | `headers` | `Record<string, string>` | `{}` | Headers adicionales |
 | `level`   | `LogLevel`    | `LogLevel.ERROR` | Nivel mínimo para enviar al servidor |
 El body enviado tiene la forma:
 ```json
 {
    "timestamp": "2024-01-01T00:00:00.000Z",
    "level"    : 3,
    "category" : "auth",
    "message"  : "Login failed",
    "context"  : { "userId": 42 }
 }
 ```
 ### `callbackTransport(fn)`
 Invoca una función por cada entrada. El transport más flexible — útil para integraciones custom, Sentry, o capturar logs en tests sin output a consola.
 ```ts
 // Integración con Sentry
 callbackTransport((entry, message) => {
    if (entry.level >= LogLevel.ERROR) {
        Sentry.captureMessage(message, { extra: entry.context });
    }
 })
 // Captura en tests — sin output a consola
 const captured: string[] = [];
 const logr = createLogr(i18n, {
    level     : LogLevel.DEBUG,
    transports: [ callbackTransport((_, msg) => captured.push(msg)) ]
 });
 ```
 ### Transport custom
 Cualquier objeto que implemente la interfaz `Transport` es válido:
 ```ts
 import type { Transport } from '@/libs/logr';
 const myTransport: Transport = {
    write(entry, resolvedMessage) {
        myService.send({
            level  : entry.level,
            message: resolvedMessage,
            context: entry.context,
        });
    }
 };
 ```
 ---
 ## Niveles
 | Nivel   | Valor | Uso recomendado |
 |---------|-------|-----------------|
 | `DEBUG` | 0     | Diagnóstico detallado en desarrollo |
 | `INFO`  | 1     | Eventos relevantes del flujo normal |
 | `WARN`  | 2     | Situaciones inesperadas no críticas |
 | `ERROR` | 3     | Errores que requieren atención |
 | `NONE`  | 4     | Desactiva todos los logs |
 ---
 ## Integración con i18n
 `Logr` no gestiona el locale internamente — lo delega al sistema i18n. Cuando cambia el locale, los mensajes siguientes se resuelven automáticamente sin ninguna reconfiguración:
 ```ts
 logr.warn('auth', { es: 'Sesión expirada', en: 'Session expired' });
 // output → "[auth] Sesión expirada"
 i18n.setLocale('en');
 logr.warn('auth', { es: 'Sesión expirada', en: 'Session expired' });
 // output → "[auth] Session expired"
 ```
 El mensaje se resuelve **una sola vez** por entrada y se pasa ya resuelto a todos los transports.
 > El mensaje se almacena como `I18nString` sin resolver. La resolución al locale ocurre en el momento del output, y en `serialize()` en el momento de la llamada.
 ---
 ## Configuración por entorno
 ```ts
 export function setupDevelopmentLogging(): void {
    logr.setLevel(LogLevel.DEBUG);
    logr.setMaxLogs(5000);
 }
 export function setupProductionLogging(): void {
    logr.setLevel(LogLevel.ERROR);
    logr.setMaxLogs(500);
 }
 export function setupTestLogging(): void {
    logr.setLevel(LogLevel.NONE);
 }
 ```
 ---
 ## Tipos públicos
 | Tipo                    | Descripción |
 |-------------------------|-------------|
 | `LogLevel`              | Enum de niveles de severidad |
 | `MessageCategory`       | `string` — dominio funcional del log |
 | `LogEntry`              | Entrada individual del historial |
 | `LogrOptions`           | Opciones de configuración de `createLogr` |
 | `LogFilters`            | Filtros para `getLogs()` |
 | `Transport`             | Interfaz que deben implementar los transports |
 | `ConsoleTransportOptions` | Opciones de `consoleTransport()` |
 | `HttpTransportOptions`  | Opciones de `httpTransport()` |
 | `Logr`                  | Tipo de la instancia |
 ---
 ## Tests
 ```bash
 vitest
 ```
 Los tests usan un schema de i18n propio independiente del de producción. Los transports se testean de forma aislada usando `callbackTransport` para capturar los mensajes sin output a consola.
--- a/src/logr/engine.ts
+++ b/src/logr/engine.ts
@ -0,0 +1,148 @@
 import type {
    LingInstance,
    LingString
 } from '@/ling';
 import type {
    LogrOptions,
    LogEntry,
    MessageCategory,
    LogFilters,
    Logr,
    Transport
 } from './types.ts';
 import { LogLevel } from './types.ts';
 import { consoleTransport } from './transports.ts';
 // ============================================================================
 // ENGINE
 // ============================================================================
 /**
 * Crea una instancia de `Logr` vinculada a una instancia de i18n.
 *
 * El logger no gestiona el locale internamente — lo delega al sistema i18n.
 * Cuando cambia el locale en i18n, los mensajes siguientes se resuelven
 * automáticamente al nuevo locale sin ninguna reconfiguración.
 *
 * Cada entrada se emite a todos los transports registrados.
 * Si no se especifican transports, usa `consoleTransport()` por defecto.
 *
 * @param ling    - Instancia de i18n para resolución de mensajes localizados
 * @param options - Configuración de nivel, historial y transports
 *
 * @example
 * export const logr = createLogr(i18n, {
 *     level     : LogLevel.WARN,
 *     transports: [
 *         consoleTransport(),
 *         httpTransport({ url: 'https://logs.myapp.com', level: LogLevel.ERROR }),
 *     ]
 * });
 */
 export function createLogr(ling: LingInstance, options: LogrOptions = {}): Logr {
    let level      : LogLevel    = options.level      ?? LogLevel.WARN;
    let maxLogs    : number      = options.maxLogs    ?? 1000;
    let transports : Transport[] = options.transports ?? [consoleTransport()];
    let entries    : LogEntry[]  = [];
    // -------------------------------------------------------------------------
    // Configuración
    // -------------------------------------------------------------------------
    function setLevel(l: LogLevel): void {
        level = l;
    }
    function setMaxLogs(max: number): void {
        maxLogs = max;
    }
    // -------------------------------------------------------------------------
    // Core interno
    // -------------------------------------------------------------------------
    /**
     * Centraliza el procesamiento de todos los niveles.
     * Aplica el filtro de nivel, construye la entrada, gestiona el historial
     * y emite a todos los transports.
     */
    function log(
        lvl     : LogLevel,
        category: MessageCategory,
        message : LingString,
        context?: Record<string, unknown>
    ): void {
        if (lvl < level) return;
        const entry: LogEntry = {
            timestamp: new Date(),
            level    : lvl,
            category,
            message,
            context,
        };
        // Historial en memoria
        entries.push(entry);
        if (entries.length > maxLogs) entries.shift();
        // Resuelve el mensaje una sola vez y lo emite a todos los transports
        const resolvedMessage = ling.ts(entry.message);
        transports.forEach(t => t.write(entry, resolvedMessage));
    }
    // -------------------------------------------------------------------------
    // API pública
    // -------------------------------------------------------------------------
    function debug(category: MessageCategory, message: LingString, context?: Record<string, unknown>): void {
        log(LogLevel.DEBUG, category, message, context);
    }
    function info(category: MessageCategory, message: LingString, context?: Record<string, unknown>): void {
        log(LogLevel.INFO, category, message, context);
    }
    function warn(category: MessageCategory, message: LingString, context?: Record<string, unknown>): void {
        log(LogLevel.WARN, category, message, context);
    }
    function error(category: MessageCategory, message: LingString, context?: Record<string, unknown>): void {
        log(LogLevel.ERROR, category, message, context);
    }
    function getLogs(filters?: LogFilters): LogEntry[] {
        let result = entries;
        if (filters?.level    !== undefined) result = result.filter(e => e.level    === filters.level);
        if (filters?.category !== undefined) result = result.filter(e => e.category === filters.category);
        if (filters?.since    !== undefined) result = result.filter(e => e.timestamp >= filters.since!);
        return result;
    }
    function clear(): void {
        entries = [];
    }
    /**
     * Los mensajes se resuelven al locale activo en el momento
     * de llamar a serialize(), no al momento en que se registraron.
     */
    function serialize(): string {
        return JSON.stringify(
            entries.map(e => ({
                ...e,
                message  : ling.ts(e.message),
                locale   : ling.getLocale(),
                timestamp: e.timestamp.toISOString(),
            })),
            null,
            2
        );
    }
    return { debug, info, warn, error, getLogs, clear, serialize, setLevel, setMaxLogs };
 }
--- a/src/logr/index.ts
+++ b/src/logr/index.ts
@ -0,0 +1,4 @@
 export * from './engine.ts';
 export * from './transports.ts';
 export * from './types.ts';
--- a/src/logr/tests/logr.test.ts
+++ b/src/logr/tests/logr.test.ts
@ -0,0 +1,288 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createLogr, LogLevel } from '@/logr';
 import { createLing } from '@/ling';
 import type { TranslationNode, SupportedLocale } from '@/ling';
 // ============================================================================
 // SCHEMA Y I18N DE TEST
 // ============================================================================
 const schema = {
    auth: {
        loginFailed  : { es: 'Login fallido',   en: 'Login failed'   },
        sessionExpired: { es: 'Sesión expirada', en: 'Session expired' },
    },
    db: {
        connectionError: { es: 'Error de conexión', en: 'Connection error' },
    },
 } satisfies TranslationNode;
 function makeI18n(locale: SupportedLocale = 'es') {
    const i18n = createLing(schema, 'es');
    i18n.setLocale(locale);
    return i18n;
 }
 // ============================================================================
 // TESTS
 // ============================================================================
 describe('createLogger', () => {
    describe('instanciación', () => {
        it('crea una instancia con nivel WARN por defecto', () => {
            const i18n   = makeI18n();
            const logger = createLogr(i18n);
            const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
            const debug = vi.spyOn(console, 'debug').mockImplementation(() => {});
            logger.warn('auth', { es: 'aviso' });
            logger.debug('auth', { es: 'debug' });
            expect(warn).toHaveBeenCalledTimes(1);
            expect(debug).not.toHaveBeenCalled();
            warn.mockRestore();
            debug.mockRestore();
        });
        it('respeta el nivel configurado en options', () => {
            const i18n   = makeI18n();
            const logger = createLogr(i18n, { level: LogLevel.DEBUG });
            const debug  = vi.spyOn(console, 'debug').mockImplementation(() => {});
            logger.debug('auth', { es: 'debug msg' });
            expect(debug).toHaveBeenCalledTimes(1);
            debug.mockRestore();
        });
        it('instancias son independientes entre sí', () => {
            const i18n = makeI18n();
            const l1   = createLogr(i18n, { level: LogLevel.DEBUG });
            const l2   = createLogr(i18n, { level: LogLevel.ERROR });
            l1.setLevel(LogLevel.NONE);
            expect(l2.getLogs()).toHaveLength(0); // no se contaminan
        });
    });
    describe('niveles de log', () => {
        let i18n: ReturnType<typeof makeI18n>;
        let logger: ReturnType<typeof createLogr>;
        beforeEach(() => {
            i18n   = makeI18n();
            logger = createLogr(i18n, { level: LogLevel.DEBUG });
        });
        it('debug llama a console.debug', () => {
            const spy = vi.spyOn(console, 'debug').mockImplementation(() => {});
            logger.debug('auth', { es: 'msg debug' });
            expect(spy).toHaveBeenCalledTimes(1);
            spy.mockRestore();
        });
        it('info llama a console.info', () => {
            const spy = vi.spyOn(console, 'info').mockImplementation(() => {});
            logger.info('auth', { es: 'msg info' });
            expect(spy).toHaveBeenCalledTimes(1);
            spy.mockRestore();
        });
        it('warn llama a console.warn', () => {
            const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
            logger.warn('auth', { es: 'msg warn' });
            expect(spy).toHaveBeenCalledTimes(1);
            spy.mockRestore();
        });
        it('error llama a console.error', () => {
            const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
            logger.error('auth', { es: 'msg error' });
            expect(spy).toHaveBeenCalledTimes(1);
            spy.mockRestore();
        });
        it('no loguea si el nivel es inferior al configurado', () => {
            const logger = createLogr(i18n, { level: LogLevel.ERROR });
            const spy    = vi.spyOn(console, 'warn').mockImplementation(() => {});
            logger.warn('auth', { es: 'esto no debe salir' });
            expect(spy).not.toHaveBeenCalled();
            spy.mockRestore();
        });
    });
    describe('resolución i18n', () => {
        it('resuelve el mensaje con el locale actual del i18n', () => {
            const i18n   = makeI18n('en');
            const logger = createLogr(i18n, { level: LogLevel.DEBUG });
            const spy    = vi.spyOn(console, 'debug').mockImplementation(() => {});
            logger.debug('auth', schema.auth.loginFailed);
            expect(spy).toHaveBeenCalledWith(
                expect.any(String),
                '[auth]',
                'Login failed',
                ''
            );
            spy.mockRestore();
        });
        it('resuelve en español cuando el locale es es', () => {
            const i18n   = makeI18n('es');
            const logger = createLogr(i18n, { level: LogLevel.DEBUG });
            const spy    = vi.spyOn(console, 'debug').mockImplementation(() => {});
            logger.debug('auth', schema.auth.loginFailed);
            expect(spy).toHaveBeenCalledWith(
                expect.any(String),
                '[auth]',
                'Login fallido',
                ''
            );
            spy.mockRestore();
        });
        it('refleja el cambio de locale automáticamente sin reconfigurar el logger', () => {
            const i18n   = makeI18n('es');
            const logger = createLogr(i18n, { level: LogLevel.DEBUG });
            const spy    = vi.spyOn(console, 'debug').mockImplementation(() => {});
            logger.debug('auth', schema.auth.loginFailed);
            expect(spy).toHaveBeenLastCalledWith(expect.any(String), '[auth]', 'Login fallido', '');
            // Cambiamos locale en i18n — el logger lo recoge automáticamente
            i18n.setLocale('en');
            logger.debug('auth', schema.auth.loginFailed);
            expect(spy).toHaveBeenLastCalledWith(expect.any(String), '[auth]', 'Login failed', '');
            spy.mockRestore();
        });
        it('acepta I18nString como string simple (pass-through)', () => {
            const i18n   = makeI18n();
            const logger = createLogr(i18n, { level: LogLevel.DEBUG });
            const spy    = vi.spyOn(console, 'debug').mockImplementation(() => {});
            logger.debug('auth', 'mensaje fijo');
            expect(spy).toHaveBeenCalledWith(
                expect.any(String),
                '[auth]',
                'mensaje fijo',
                ''
            );
            spy.mockRestore();
        });
    });
    describe('getLogs()', () => {
        let i18n: ReturnType<typeof makeI18n>;
        let logger: ReturnType<typeof createLogr>;
        beforeEach(() => {
            i18n   = makeI18n();
            logger = createLogr(i18n, { level: LogLevel.DEBUG });
            vi.spyOn(console, 'debug').mockImplementation(() => {});
            vi.spyOn(console, 'warn').mockImplementation(() => {});
            vi.spyOn(console, 'error').mockImplementation(() => {});
        });
        it('retorna todos los logs sin filtros', () => {
            logger.debug('auth', { es: 'a' });
            logger.warn ('auth', { es: 'b' });
            logger.error('db',   { es: 'c' });
            expect(logger.getLogs()).toHaveLength(3);
        });
        it('filtra por nivel', () => {
            logger.debug('auth', { es: 'a' });
            logger.warn ('auth', { es: 'b' });
            logger.error('db',   { es: 'c' });
            expect(logger.getLogs({ level: LogLevel.WARN })).toHaveLength(1);
        });
        it('filtra por categoría', () => {
            logger.debug('auth', { es: 'a' });
            logger.warn ('auth', { es: 'b' });
            logger.error('db',   { es: 'c' });
            expect(logger.getLogs({ category: 'auth' })).toHaveLength(2);
        });
        it('filtra por fecha', async () => {
            logger.debug('auth', { es: 'antes' });
            await new Promise(r => setTimeout(r, 10));
            const since = new Date();
            await new Promise(r => setTimeout(r, 10));
            logger.warn('auth', { es: 'después' });
            expect(logger.getLogs({ since })).toHaveLength(1);
        });
    });
    describe('maxLogs', () => {
        it('respeta el límite de entradas', () => {
            const i18n   = makeI18n();
            const logger = createLogr(i18n, { level: LogLevel.DEBUG, maxLogs: 3 });
            vi.spyOn(console, 'debug').mockImplementation(() => {});
            for (let i = 0; i < 5; i++) {
                logger.debug('auth', { es: `msg ${i}` });
            }
            expect(logger.getLogs()).toHaveLength(3);
        });
        it('descarta los más antiguos cuando supera el límite', () => {
            const i18n   = makeI18n();
            const logger = createLogr(i18n, { level: LogLevel.DEBUG, maxLogs: 2 });
            vi.spyOn(console, 'debug').mockImplementation(() => {});
            logger.debug('auth', { es: 'primero' });
            logger.debug('auth', { es: 'segundo' });
            logger.debug('auth', { es: 'tercero' });
            const logs = logger.getLogs();
            expect(logs[0].message).toEqual({ es: 'segundo' });
            expect(logs[1].message).toEqual({ es: 'tercero' });
        });
    });
    describe('clear()', () => {
        it('vacía el historial', () => {
            const i18n   = makeI18n();
            const logger = createLogr(i18n, { level: LogLevel.DEBUG });
            vi.spyOn(console, 'debug').mockImplementation(() => {});
            logger.debug('auth', { es: 'msg' });
            logger.clear();
            expect(logger.getLogs()).toHaveLength(0);
        });
    });
    describe('serialize()', () => {
        it('exporta los logs como JSON con mensajes resueltos', () => {
            const i18n   = makeI18n('en');
            const logger = createLogr(i18n, { level: LogLevel.DEBUG });
            vi.spyOn(console, 'debug').mockImplementation(() => {});
            logger.debug('auth', schema.auth.loginFailed);
            const parsed = JSON.parse(logger.serialize());
            expect(parsed[0].message).toBe('Login failed');
            expect(parsed[0].locale).toBe('en');
        });
    });
 });
--- a/src/logr/tests/logr_transports.test.ts
+++ b/src/logr/tests/logr_transports.test.ts
@ -0,0 +1,253 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import {callbackTransport, consoleTransport, createLogr, httpTransport, type LogEntry, LogLevel} from '@/logr';
 import { createLing } from '@/ling';
 import type { TranslationNode, SupportedLocale } from '@/ling';
 // ============================================================================
 // HELPERS
 // ============================================================================
 const schema = {
    auth: {
        loginFailed: { es: 'Login fallido', en: 'Login failed' },
    }
 } satisfies TranslationNode;
 function makeI18n(locale: SupportedLocale = 'es') {
    const i18n = createLing(schema, 'es');
    i18n.setLocale(locale);
    return i18n;
 }
 function makeEntry(overrides: Partial<LogEntry> = {}): LogEntry {
    return {
        timestamp: new Date(),
        level    : LogLevel.WARN,
        category : 'auth',
        message  : { es: 'Login fallido', en: 'Login failed' },
        ...overrides,
    };
 }
 // ============================================================================
 // consoleTransport
 // ============================================================================
 describe('consoleTransport', () => {
    it('usa console.debug para nivel DEBUG', () => {
        const spy   = vi.spyOn(console, 'debug').mockImplementation(() => {});
        const t     = consoleTransport();
        t.write(makeEntry({ level: LogLevel.DEBUG }), 'msg debug');
        expect(spy).toHaveBeenCalledTimes(1);
        spy.mockRestore();
    });
    it('usa console.info para nivel INFO', () => {
        const spy = vi.spyOn(console, 'info').mockImplementation(() => {});
        const t   = consoleTransport();
        t.write(makeEntry({ level: LogLevel.INFO }), 'msg info');
        expect(spy).toHaveBeenCalledTimes(1);
        spy.mockRestore();
    });
    it('usa console.warn para nivel WARN', () => {
        const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
        const t   = consoleTransport();
        t.write(makeEntry({ level: LogLevel.WARN }), 'msg warn');
        expect(spy).toHaveBeenCalledTimes(1);
        spy.mockRestore();
    });
    it('usa console.error para nivel ERROR', () => {
        const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
        const t   = consoleTransport();
        t.write(makeEntry({ level: LogLevel.ERROR }), 'msg error');
        expect(spy).toHaveBeenCalledTimes(1);
        spy.mockRestore();
    });
    it('incluye timestamp y prefijo por defecto', () => {
        const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
        const t   = consoleTransport();
        t.write(makeEntry({ category: 'auth' }), 'mensaje');
        expect(spy).toHaveBeenCalledWith(
            expect.stringMatching(/^\d{4}-\d{2}-\d{2}/), // ISO timestamp
            '[auth]',
            'mensaje',
            ''
        );
        spy.mockRestore();
    });
    it('omite timestamp si timestamp: false', () => {
        const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
        const t   = consoleTransport({ timestamp: false });
        t.write(makeEntry({ category: 'auth' }), 'mensaje');
        expect(spy).toHaveBeenCalledWith('[auth]', 'mensaje', '');
        spy.mockRestore();
    });
    it('omite prefijo si prefix: false', () => {
        const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
        const t   = consoleTransport({ prefix: false });
        t.write(makeEntry(), 'mensaje');
        const args = spy.mock.calls[0];
        expect(args).not.toContain('[auth]');
        spy.mockRestore();
    });
    it('incluye el contexto en el output', () => {
        const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
        const t   = consoleTransport();
        t.write(makeEntry({ context: { userId: 42 } }), 'msg');
        const args = spy.mock.calls[0];
        expect(args).toContainEqual(expect.objectContaining({ userId: 42 }));
        spy.mockRestore();
    });
 });
 // ============================================================================
 // httpTransport
 // ============================================================================
 describe('httpTransport', () => {
    beforeEach(() => {
        global.fetch = vi.fn().mockResolvedValue({ ok: true });
    });
    it('envía un POST al endpoint configurado', async () => {
        const t = httpTransport({ url: 'https://logs.example.com', level: LogLevel.ERROR });
        t.write(makeEntry({ level: LogLevel.ERROR }), 'Login failed');
        expect(fetch).toHaveBeenCalledWith(
            'https://logs.example.com',
            expect.objectContaining({ method: 'POST' })
        );
    });
    it('incluye el mensaje resuelto en el body', async () => {
        const t = httpTransport({ url: 'https://logs.example.com', level: LogLevel.ERROR });
        t.write(makeEntry({ level: LogLevel.ERROR }), 'Login failed');
        const body = JSON.parse((fetch as any).mock.calls[0][1].body);
        expect(body.message).toBe('Login failed');
    });
    it('incluye headers custom', () => {
        const t = httpTransport({
            url    : 'https://logs.example.com',
            headers: { 'Authorization': 'Bearer token' },
            level  : LogLevel.ERROR
        });
        t.write(makeEntry({ level: LogLevel.ERROR }), 'msg');
        const headers = (fetch as any).mock.calls[0][1].headers;
        expect(headers['Authorization']).toBe('Bearer token');
    });
    it('no envía si el nivel es inferior al mínimo configurado', () => {
        const t = httpTransport({ url: 'https://logs.example.com', level: LogLevel.ERROR });
        t.write(makeEntry({ level: LogLevel.WARN }), 'msg');
        expect(fetch).not.toHaveBeenCalled();
    });
    it('usa ERROR como nivel mínimo por defecto', () => {
        const t = httpTransport({ url: 'https://logs.example.com' });
        t.write(makeEntry({ level: LogLevel.WARN }), 'msg');
        expect(fetch).not.toHaveBeenCalled();
        t.write(makeEntry({ level: LogLevel.ERROR }), 'msg');
        expect(fetch).toHaveBeenCalledTimes(1);
    });
    it('no lanza si fetch falla — fire and forget', () => {
        global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
        const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
        const t   = httpTransport({ url: 'https://logs.example.com', level: LogLevel.ERROR });
        expect(() => t.write(makeEntry({ level: LogLevel.ERROR }), 'msg')).not.toThrow();
        spy.mockRestore();
    });
 });
 // ============================================================================
 // callbackTransport
 // ============================================================================
 describe('callbackTransport', () => {
    it('invoca el callback con la entrada y el mensaje resuelto', () => {
        const fn      = vi.fn();
        const t       = callbackTransport(fn);
        const entry   = makeEntry();
        t.write(entry, 'Login fallido');
        expect(fn).toHaveBeenCalledWith(entry, 'Login fallido');
    });
    it('se puede usar para capturar logs en tests', () => {
        const i18n    = makeI18n('en');
        const captured: string[] = [];
        const logr    = createLogr(i18n, {
            level     : LogLevel.DEBUG,
            transports: [ callbackTransport((_, msg) => captured.push(msg)) ]
        });
        logr.debug('auth', schema.auth.loginFailed);
        logr.warn ('auth', 'custom message');
        expect(captured).toEqual(['Login failed', 'custom message']);
    });
 });
 // ============================================================================
 // Integración — múltiples transports
 // ============================================================================
 describe('múltiples transports', () => {
    it('emite a todos los transports registrados', () => {
        const i18n  = makeI18n();
        const fn1   = vi.fn();
        const fn2   = vi.fn();
        const logr  = createLogr(i18n, {
            level     : LogLevel.DEBUG,
            transports: [ callbackTransport(fn1), callbackTransport(fn2) ]
        });
        logr.warn('auth', { es: 'aviso' });
        expect(fn1).toHaveBeenCalledTimes(1);
        expect(fn2).toHaveBeenCalledTimes(1);
    });
    it('el mensaje se resuelve una sola vez y se comparte entre transports', () => {
        const i18n      = makeI18n('en');
        const messages: string[] = [];
        const logr      = createLogr(i18n, {
            level     : LogLevel.DEBUG,
            transports: [
                callbackTransport((_, msg) => messages.push(msg)),
                callbackTransport((_, msg) => messages.push(msg)),
            ]
        });
        logr.debug('auth', schema.auth.loginFailed);
        expect(messages).toEqual(['Login failed', 'Login failed']);
    });
    it('un transport que falla no afecta a los demás', () => {
        const i18n  = makeI18n();
        const fn    = vi.fn();
        const logr  = createLogr(i18n, {
            level     : LogLevel.DEBUG,
            transports: [
                callbackTransport(() => { throw new Error('transport error'); }),
                callbackTransport(fn),
            ]
        });
        // El segundo transport sí debería ejecutarse aunque el primero falle
        // Este test documenta el comportamiento actual — si se quiere
        // aislamiento habría que añadir try/catch en el engine
        expect(() => logr.warn('auth', { es: 'msg' })).toThrow();
    });
 });
--- a/src/logr/transports.ts
+++ b/src/logr/transports.ts
@ -0,0 +1,123 @@
 import type { Transport, ConsoleTransportOptions, HttpTransportOptions, LogEntry, LogLevel } from './types.ts';
 // ============================================================================
 // CONSOLE TRANSPORT
 // ============================================================================
 /**
 * Transport que emite los logs a la consola del navegador/Node.
 * Es el transport por defecto si no se especifica ninguno en `LogrOptions`.
 *
 * Usa el método de consola apropiado según el nivel:
 * DEBUG → console.debug, INFO → console.info, WARN → console.warn, ERROR → console.error
 *
 * @example
 * createLogr(i18n, {
 *     transports: [ consoleTransport() ]
 * })
 *
 * @example
 * // Sin timestamp ni prefijo
 * consoleTransport({ timestamp: false, prefix: false })
 */
 export function consoleTransport(options: ConsoleTransportOptions = {}): Transport {
    const { timestamp: showTimestamp = true, prefix: showPrefix = true } = options;
    return {
        write(entry: LogEntry, resolvedMessage: string): void {
            const parts: string[] = [];
            if (showTimestamp) parts.push(entry.timestamp.toISOString());
            if (showPrefix)    parts.push(`[${entry.category}]`);
            parts.push(resolvedMessage);
            const ctx = entry.context ?? '';
            switch (entry.level) {
                case 0: console.debug(...parts, ctx); break; // DEBUG
                case 1: console.info (...parts, ctx); break; // INFO
                case 2: console.warn (...parts, ctx); break; // WARN
                case 3: console.error(...parts, ctx); break; // ERROR
            }
        }
    };
 }
 // ============================================================================
 // HTTP TRANSPORT
 // ============================================================================
 /**
 * Transport que envía las entradas de log a un endpoint HTTP remoto via POST.
 * Útil para servicios de logging centralizados (Datadog, Logtail, custom APIs...).
 *
 * El envío es fire-and-forget — los errores de red se loguean en consola
 * pero no interrumpen el flujo de la aplicación.
 *
 * @example
 * httpTransport({
 *     url    : 'https://logs.myapp.com/ingest',
 *     headers: { 'Authorization': 'Bearer my-token' },
 *     level  : LogLevel.ERROR  // solo envía errores al servidor
 * })
 */
 export function httpTransport(options: HttpTransportOptions): Transport {
    const minLevel = options.level ?? 3; // ERROR por defecto
    return {
        write(entry: LogEntry, resolvedMessage: string): void {
            if (entry.level < minLevel) return;
            const payload = {
                timestamp: entry.timestamp.toISOString(),
                level    : entry.level,
                category : entry.category,
                message  : resolvedMessage,
                context  : entry.context,
            };
            // Fire-and-forget — no bloqueamos el hilo principal
            fetch(options.url, {
                method : 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    ...options.headers,
                },
                body: JSON.stringify(payload),
            }).catch(err => {
                console.error('[logr:httpTransport] Failed to send log:', err);
            });
        }
    };
 }
 // ============================================================================
 // CALLBACK TRANSPORT
 // ============================================================================
 /**
 * Transport que invoca una función callback por cada entrada de log.
 * Es el transport más flexible — ideal para integraciones custom,
 * tests, o cuando necesitas lógica de routing entre destinos.
 *
 * @example
 * // Integración con Sentry
 * callbackTransport((entry, message) => {
 *     if (entry.level >= LogLevel.ERROR) {
 *         Sentry.captureMessage(message, { extra: entry.context });
 *     }
 * })
 *
 * @example
 * // En tests — captura los logs sin output a consola
 * const captured: string[] = [];
 * callbackTransport((entry, message) => captured.push(message))
 */
 export function callbackTransport(
    fn: (entry: LogEntry, resolvedMessage: string) => void
 ): Transport {
    return {
        write: fn
    };
 }
--- a/src/logr/types.ts
+++ b/src/logr/types.ts
@ -0,0 +1,226 @@
 import type { LingString } from '@/ling';
 // ============================================================================
 // LOG LEVEL
 // ============================================================================
 /**
 * Niveles de severidad del log, ordenados de menor a mayor.
 * Un logger configurado con un nivel X solo procesa entradas
 * con nivel >= X.
 *
 * @example
 * const logr = createLogr(i18n, { level: LogLevel.WARN });
 * logr.debug('auth', 'msg'); // ignorado — DEBUG < WARN
 * logr.error('auth', 'msg'); // procesado — ERROR >= WARN
 */
 export enum LogLevel {
    /** Información detallada para diagnóstico en desarrollo */
    DEBUG = 0,
    /** Eventos relevantes del flujo normal de la aplicación */
    INFO  = 1,
    /** Situaciones inesperadas que no interrumpen la ejecución */
    WARN  = 2,
    /** Errores que requieren atención inmediata */
    ERROR = 3,
    /** Desactiva todos los logs — útil en tests */
    NONE  = 4
 }
 // ============================================================================
 // CORE TYPES
 // ============================================================================
 /**
 * Agrupa los logs por dominio funcional.
 * Se usa como prefijo en consola `[auth]` y como filtro en `getLogs()`.
 *
 * @example
 * 'auth' | 'checkout' | 'db' | 'render'
 */
 export type MessageCategory = string;
 /**
 * Entrada individual del historial de logs.
 * El mensaje se almacena como `I18nString` sin resolver —
 * la resolución al locale actual ocurre en el momento del output.
 */
 export interface LogEntry {
    /** Momento exacto en que se registró el log */
    timestamp : Date;
    /** Nivel de severidad */
    level     : LogLevel;
    /** Dominio funcional — ej: 'auth', 'checkout' */
    category  : MessageCategory;
    /**
     * Mensaje del log. Puede ser un string simple o un `LocaleRecord`.
     * Se resuelve al locale activo del sistema i18n en el momento del output.
     */
    message   : LingString;
    /** Datos adicionales de contexto para facilitar el diagnóstico */
    context?  : Record<string, unknown>;
 }
 /**
 * Filtros para consultar el historial de logs con `getLogs()`.
 * Todos los campos son opcionales y se combinan con AND.
 *
 * @example
 * logr.getLogs({ category: 'auth', level: LogLevel.ERROR })
 * logr.getLogs({ since: new Date('2024-01-01') })
 */
 export interface LogFilters {
    /** Filtra por nivel exacto de severidad */
    level?   : LogLevel;
    /** Filtra por categoría exacta */
    category?: MessageCategory;
    /** Filtra entradas con timestamp >= since */
    since?   : Date;
 }
 // ============================================================================
 // TRANSPORTS
 // ============================================================================
 /**
 * Un transport es un destino de salida para las entradas de log.
 * El engine emite cada entrada a todos los transports registrados.
 *
 * Recibe tanto la entrada original (`LogEntry`) como el mensaje
 * ya resuelto al locale activo (`resolvedMessage`), para que el
 * transport no necesite conocer el sistema i18n.
 *
 * @example
 * // Transport custom
 * const myTransport: Transport = {
 *     write: (entry, message) => {
 *         myExternalService.send({ level: entry.level, message });
 *     }
 * };
 */
 export interface Transport {
    /**
     * Recibe una entrada de log para procesarla.
     * @param entry           - Entrada original con mensaje sin resolver
     * @param resolvedMessage - Mensaje ya traducido al locale activo
     */
    write: (entry: LogEntry, resolvedMessage: string) => void;
 }
 /**
 * Opciones para el transport de consola.
 */
 export interface ConsoleTransportOptions {
    /**
     * Incluye el timestamp en el output.
     * @default true
     */
    timestamp?: boolean;
    /**
     * Incluye el prefijo de categoría `[category]` en el output.
     * @default true
     */
    prefix?: boolean;
 }
 /**
 * Opciones para el transport HTTP.
 */
 export interface HttpTransportOptions {
    /** URL del endpoint que recibe los logs */
    url     : string;
    /** Headers adicionales — útil para autenticación */
    headers?: Record<string, string>;
    /**
     * Nivel mínimo para enviar al servidor.
     * Permite enviar solo errores al servidor aunque el logger esté en DEBUG.
     * @default LogLevel.ERROR
     */
    level?  : LogLevel;
 }
 // ============================================================================
 // OPTIONS
 // ============================================================================
 /**
 * Opciones de configuración al crear una instancia de `Logr`.
 *
 * @example
 * createLogr(i18n, {
 *     level     : LogLevel.DEBUG,
 *     maxLogs   : 5000,
 *     transports: [ consoleTransport(), httpTransport({ url: '...' }) ]
 * })
 */
 export interface LogrOptions {
    /**
     * Nivel mínimo de severidad a procesar.
     * @default LogLevel.WARN
     */
    level?      : LogLevel;
    /**
     * Número máximo de entradas a retener en el historial en memoria.
     * Cuando se supera, se descartan las entradas más antiguas.
     * @default 1000
     */
    maxLogs?    : number;
    /**
     * Lista de transports a los que se emitirá cada entrada.
     * Si no se especifica, usa `consoleTransport()` por defecto.
     *
     * @default [consoleTransport()]
     */
    transports? : Transport[];
 }
 // ============================================================================
 // INSTANCE TYPE
 // ============================================================================
 /**
 * Interfaz pública de una instancia de Logr.
 * Creada mediante `createLogr(i18n, options)`.
 *
 * Los mensajes se aceptan como `I18nString` — pueden ser strings simples
 * o `LocaleRecord`, y se resuelven automáticamente al locale activo
 * del sistema i18n en el momento de hacer output.
 *
 * @example
 * const logr = createLogr(i18n, {
 *     level     : LogLevel.DEBUG,
 *     transports: [ consoleTransport(), httpTransport({ url: 'https://logs.myapp.com' }) ]
 * });
 *
 * logr.debug('auth', { es: 'Iniciando sesión', en: 'Logging in' });
 * logr.warn('db',    { es: 'Conexión lenta',   en: 'Slow connection' }, { ms: 2000 });
 * logr.error('auth', 'Unexpected error');
 */
 export type Logr = {
    /** Registra un mensaje de nivel DEBUG */
    debug     : (category: MessageCategory, message: LingString, context?: Record<string, unknown>) => void;
    /** Registra un mensaje de nivel INFO */
    info      : (category: MessageCategory, message: LingString, context?: Record<string, unknown>) => void;
    /** Registra un mensaje de nivel WARN */
    warn      : (category: MessageCategory, message: LingString, context?: Record<string, unknown>) => void;
    /** Registra un mensaje de nivel ERROR */
    error     : (category: MessageCategory, message: LingString, context?: Record<string, unknown>) => void;
    /**
     * Devuelve las entradas del historial en memoria, opcionalmente filtradas.
     * Los mensajes se devuelven sin resolver — como `I18nString`.
     */
    getLogs   : (filters?: LogFilters) => LogEntry[];
    /** Vacía el historial en memoria */
    clear     : () => void;
    /**
     * Exporta el historial como JSON con mensajes resueltos al locale activo.
     * Incluye el campo `locale` para trazabilidad.
     */
    serialize : () => string;
    /** Cambia el nivel mínimo de severidad en tiempo de ejecución */
    setLevel  : (level: LogLevel) => void;
    /** Cambia el número máximo de entradas a retener en memoria */
    setMaxLogs: (max: number) => void;
 };
--- a/svelte.config.js
+++ b/svelte.config.js
@ -0,0 +1,8 @@
 import { vitePreprocess } from '@sveltejs/vite-plugin-svelte'
 /** @type {import("@sveltejs/vite-plugin-svelte").SvelteConfig} */
 export default {
  // Consult https://svelte.dev/docs#compile-time-svelte-preprocess
  // for more information about preprocessors
  preprocess: vitePreprocess(),
 }
--- a/tsconfig.app.json
+++ b/tsconfig.app.json
@ -0,0 +1,21 @@
 {
  "extends": "@tsconfig/svelte/tsconfig.json",
  "compilerOptions": {
    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
    "target": "ES2022",
    "useDefineForClassFields": true,
    "module": "ESNext",
    "types": ["svelte", "vite/client"],
    "noEmit": true,
    /**
     * Typecheck JS in `.svelte` and `.js` files by default.
     * Disable checkJs if you'd like to use dynamic types in JS.
     * Note that setting allowJs false does not prevent the use
     * of JS in `.svelte` files.
     */
    "allowJs": true,
    "checkJs": true,
    "moduleDetection": "force"
  },
  "include": ["src/**/*.ts", "src/**/*.js", "src/**/*.svelte"]
 }
--- a/tsconfig.json
+++ b/tsconfig.json
@ -0,0 +1,30 @@
 {
  "compilerOptions": {
    "rootDir": "./src",
    "outDir": "./dist",
    "baseUrl": "./src",
    "paths": {
      "@/ling/*"      : ["ling/*"],
      "@/logr/*"      : ["logr/*"],
      "@/veci/*"      : ["veci/*"],
      "@/adapters/*"  : ["adapters/*"],
      "@/svelte/*"    : ["adapters/svelte/*"],
      "@/editor/*"    : ["editor/*"],
      "@/*"           : ["*"]
    },
    // ✅ Opciones CRÍTICAS para usar .ts en imports:
    "allowImportingTsExtensions": true,
    "noEmit": true,                // Obligatorio con la opción anterior
    "module": "esnext",            // Cambiado de nodenext a esnext
    "moduleResolution": "bundler", // Permite resoluciones modernas tipo Vite/Bun
    "target": "esnext",
    "strict": true,
    "verbatimModuleSyntax": true,
    "isolatedModules": true,
    "skipLibCheck": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
 }
--- a/vite.config.ts
+++ b/vite.config.ts
@ -0,0 +1,31 @@
 import { defineConfig } from 'vitest/config';
 import { resolve } from 'path';
 import { svelte } from '@sveltejs/vite-plugin-svelte';
 import tailwindcss from "@tailwindcss/vite";
 export default defineConfig({
    base: './',
    plugins: [svelte(),tailwindcss()],
    test: {
        globals: true,
        environment: 'node',
        coverage: {
            provider: 'v8',
            reporter: ['text', 'json', 'html'],
            include: [
                'src/**/*.ts',
                'src/ling/**/*.ts',
                'src/logr/**/*.ts',
                'src/veci/**/*.ts',
            ],
            exclude: [
                'src/**/*.test.ts',
                'src/**/*.d.ts']
        }
    },
    resolve: {
        alias: {
            '@': resolve(__dirname, './src')
        }
    }
 });