@hoilab/ada-cli 0.85.0 → 0.85.3

package/dist/core/carga-plugins/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Carga de plugins con import paralelo determinista + invalidación cruzada
+ * (auditoría omp B09). Consumidor real de `paralelo.ts` e `invalidacion.ts`.
+ *
+ * QUÉ AÑADE SOBRE `extensions/loader.ts` (upstream, NO se toca):
+ * 1. I/O PARALELO + REGISTRO DETERMINISTA: los imports se disparan todos a la
+ *    vez y el resultado respeta el orden de la lista (ver paralelo.ts).
+ * 2. MEMOIZACIÓN POR RUTA: recargar con las mismas rutas reusa los valores ya
+ *    cargados; solo se importan los nuevos o los fallados.
+ * 3. INVALIDACIÓN CRUZADA: cada raíz (directorio del plugin) queda registrada
+ *    en el registro de invalidadores; `invalidarRaiz(raiz)` vacía las entradas
+ *    de esa raíz —la siguiente carga re-importa—, ejecuta cualquier otro
+ *    invalidador registrado para ella y purga la caché global de fábricas de
+ *    extensión (`clearExtensionCache`, lo único que upstream expone: no hay
+ *    purga por raíz sin tocar loader.ts; sobre-invalidar es seguro porque una
+ *    caché de fábricas vacía solo fuerza re-import).
+ *
+ * El importador se inyecta: en producción será `jiti.import(ruta,
+ * { default: true })`; en tests, un loader fake. jiti real nunca es necesario
+ * para ejercitar este flujo.
+ */
+export { configurarPurgaModulos, invalidarRaiz, preloadRaices, registrarInvalidador } from "./invalidacion.ts";
+export { type ImportaResultado, importarEnParaleloDeterminista } from "./paralelo.ts";
+export interface PluginCargado<T> {
+    ruta: string;
+    /** Directorio del plugin: clave del registro de invalidadores. */
+    raiz: string;
+    valor: T;
+}
+export interface CargaPluginsResultado<T> {
+    /** Plugins en el orden exacto de `rutas` (determinismo last-wins intacto). */
+    plugins: Array<PluginCargado<T>>;
+    /** Fallos aislados por ruta; no afectan a los plugins que sí cargaron. */
+    errores: Array<{
+        ruta: string;
+        error: string;
+    }>;
+}
+/**
+ * Carga plugins desde `rutas`: importa en paralelo las que faltan en caché,
+ * registra su raíz para invalidación cruzada y devuelve TODO (cacheado y
+ * nuevo) en el orden de la lista. Un plugin que falla aparece en `errores`
+ * con su ruta y no impide a los demás; se reintentará en la próxima llamada.
+ *
+ * @param rutas rutas de plugins; el orden define el orden del resultado
+ * @param cargar importador individual inyectable (jiti en producción)
+ */
+export declare function cargarPlugins<T>(rutas: readonly string[], cargar: (ruta: string) => Promise<T>): Promise<CargaPluginsResultado<T>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/carga-plugins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/carga-plugins/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAOH,OAAO,EAAE,sBAAsB,EAAE,aAAa,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC/G,OAAO,EAAE,KAAK,gBAAgB,EAAE,8BAA8B,EAAE,MAAM,eAAe,CAAC;AAEtF,MAAM,WAAW,aAAa,CAAC,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,CAAC;CACT;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACvC,8EAA8E;IAC9E,OAAO,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IACjC,0EAA0E;IAC1E,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChD;AAmCD;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACpC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAClC,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAwBnC"}

package/dist/core/carga-plugins/index.js

@@ -0,0 +1,85 @@
+/**
+ * Carga de plugins con import paralelo determinista + invalidación cruzada
+ * (auditoría omp B09). Consumidor real de `paralelo.ts` e `invalidacion.ts`.
+ *
+ * QUÉ AÑADE SOBRE `extensions/loader.ts` (upstream, NO se toca):
+ * 1. I/O PARALELO + REGISTRO DETERMINISTA: los imports se disparan todos a la
+ *    vez y el resultado respeta el orden de la lista (ver paralelo.ts).
+ * 2. MEMOIZACIÓN POR RUTA: recargar con las mismas rutas reusa los valores ya
+ *    cargados; solo se importan los nuevos o los fallados.
+ * 3. INVALIDACIÓN CRUZADA: cada raíz (directorio del plugin) queda registrada
+ *    en el registro de invalidadores; `invalidarRaiz(raiz)` vacía las entradas
+ *    de esa raíz —la siguiente carga re-importa—, ejecuta cualquier otro
+ *    invalidador registrado para ella y purga la caché global de fábricas de
+ *    extensión (`clearExtensionCache`, lo único que upstream expone: no hay
+ *    purga por raíz sin tocar loader.ts; sobre-invalidar es seguro porque una
+ *    caché de fábricas vacía solo fuerza re-import).
+ *
+ * El importador se inyecta: en producción será `jiti.import(ruta,
+ * { default: true })`; en tests, un loader fake. jiti real nunca es necesario
+ * para ejercitar este flujo.
+ */
+import { dirname } from "node:path";
+import { configurarPurgaModulos, registrarInvalidador } from "./invalidacion.js";
+import { importarEnParaleloDeterminista } from "./paralelo.js";
+export { configurarPurgaModulos, invalidarRaiz, preloadRaices, registrarInvalidador } from "./invalidacion.js";
+export { importarEnParaleloDeterminista } from "./paralelo.js";
+const cachePorRuta = {};
+const raicesConInvalidador = {};
+/**
+ * Purga cruzada: al invalidar cualquier raíz se limpia también la caché de
+ * fábricas del extension loader (global; ver cabecera). Import DINÁMICO para
+ * no arrastrar el grafo completo de extensions/loader (jiti + índice del
+ * paquete) a cada consumidor de este módulo.
+ */
+configurarPurgaModulos(() => {
+    void import("../extensions/loader.js").then((loader) => loader.clearExtensionCache());
+});
+function asegurarInvalidadorDeRaiz(raiz) {
+    if (raicesConInvalidador[raiz]) {
+        return;
+    }
+    raicesConInvalidador[raiz] = true;
+    const invalidador = () => {
+        for (const ruta of Object.keys(cachePorRuta)) {
+            if (cachePorRuta[ruta].raiz === raiz) {
+                delete cachePorRuta[ruta];
+            }
+        }
+    };
+    registrarInvalidador(raiz, invalidador);
+}
+/**
+ * Carga plugins desde `rutas`: importa en paralelo las que faltan en caché,
+ * registra su raíz para invalidación cruzada y devuelve TODO (cacheado y
+ * nuevo) en el orden de la lista. Un plugin que falla aparece en `errores`
+ * con su ruta y no impide a los demás; se reintentará en la próxima llamada.
+ *
+ * @param rutas rutas de plugins; el orden define el orden del resultado
+ * @param cargar importador individual inyectable (jiti en producción)
+ */
+export async function cargarPlugins(rutas, cargar) {
+    const pendientes = rutas.filter((ruta) => !(ruta in cachePorRuta));
+    const resultados = await importarEnParaleloDeterminista(pendientes, cargar);
+    const errores = [];
+    for (const resultado of resultados) {
+        if (resultado.ok) {
+            const raiz = dirname(resultado.ruta);
+            cachePorRuta[resultado.ruta] = { raiz, valor: resultado.valor };
+            asegurarInvalidadorDeRaiz(raiz);
+        }
+        else {
+            // Sin cachear el fallo: la próxima llamada reintenta la carga.
+            errores.push({ ruta: resultado.ruta, error: resultado.error });
+        }
+    }
+    const plugins = [];
+    for (const ruta of rutas) {
+        const entrada = cachePorRuta[ruta];
+        if (entrada) {
+            plugins.push({ ruta, raiz: entrada.raiz, valor: entrada.valor });
+        }
+    }
+    return { plugins, errores };
+}
+//# sourceMappingURL=index.js.map

package/dist/core/carga-plugins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/carga-plugins/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAE,8BAA8B,EAAE,MAAM,eAAe,CAAC;AAE/D,OAAO,EAAE,sBAAsB,EAAE,aAAa,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC/G,OAAO,EAAyB,8BAA8B,EAAE,MAAM,eAAe,CAAC;AAqBtF,MAAM,YAAY,GAA0C,EAAE,CAAC;AAC/D,MAAM,oBAAoB,GAAyB,EAAE,CAAC;AAEtD;;;;;GAKG;AACH,sBAAsB,CAAC,GAAG,EAAE;IAC3B,KAAK,MAAM,CAAC,yBAAyB,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC,CAAC;AACvF,CAAC,CAAC,CAAC;AAEH,SAAS,yBAAyB,CAAC,IAAY;IAC9C,IAAI,oBAAoB,CAAC,IAAI,CAAC,EAAE,CAAC;QAChC,OAAO;IACR,CAAC;IACD,oBAAoB,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAClC,MAAM,WAAW,GAAgB,GAAG,EAAE;QACrC,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;YAC9C,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBACtC,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC;YAC3B,CAAC;QACF,CAAC;IACF,CAAC,CAAC;IACF,oBAAoB,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;AACzC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAClC,KAAwB,EACxB,MAAoC;IAEpC,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,YAAY,CAAC,CAAC,CAAC;IACnE,MAAM,UAAU,GAAG,MAAM,8BAA8B,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAE5E,MAAM,OAAO,GAA2C,EAAE,CAAC;IAC3D,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACpC,IAAI,SAAS,CAAC,EAAE,EAAE,CAAC;YAClB,MAAM,IAAI,GAAG,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YACrC,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,EAAE,CAAC;YAChE,yBAAyB,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC;aAAM,CAAC;YACP,+DAA+D;YAC/D,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC;QAChE,CAAC;IACF,CAAC;IAED,MAAM,OAAO,GAA4B,EAAE,CAAC;IAC5C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QAC1B,MAAM,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;QACnC,IAAI,OAAO,EAAE,CAAC;YACb,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,KAAU,EAAE,CAAC,CAAC;QACvE,CAAC;IACF,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AAC7B,CAAC"}

package/dist/core/carga-plugins/invalidacion.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Invalidación cruzada de cachés por raíz de plugin (auditoría omp B09).
+ *
+ * omp expone `registerPluginCacheInvalidator` + `preloadPluginRoots` para que
+ * consumidores síncronos (comandos, UI) encadenen la recarga de un plugin con
+ * TODAS las cachés que dependen de él. Ada no tiene equivalente: cuando
+ * cambia un plugin, cada caché (fábricas de extensión, valores ya cargados)
+ * se entera por su cuenta o no se entera.
+ *
+ * DISEÑO: registro `raíz → invalidadores`. La raíz es el directorio del
+ * plugin; todo lo cargado desde ella comparte destino en la invalidación.
+ * `invalidarRaiz` ejecuta SOLO los invalidadores de esa raíz y después purga
+ * la caché de módulos asociada vía el gancho configurable.
+ *
+ * PURGA DE MÓDULOS: `extensions/loader.ts` NO expone una purga por raíz —
+ * su `jiti` se instancia con `moduleCache: false` y la caché de fábricas se
+ * limpia en bloque con `clearExtensionCache()`. Añadir una purga fina sería
+ * tocar upstream (prohibido). Por eso el gancho es inyectable:
+ * `configurarPurgaModulos(fn)` y quien tenga una purga real la registra. Si
+ * nadie registra ninguna, `invalidarRaiz` ejecuta igualmente los
+ * invalidadores registrados (la purga es un añadido, no una condición).
+ */
+/** Callback de invalidación; puede ser asíncrono. */
+export type Invalidador = () => void | Promise<void>;
+/** Purga de caché de módulos asociada a una raíz (inyectable). */
+export type PurgaModulos = (raiz: string) => void;
+/**
+ * Registra `fn` para que se ejecute cuando se invalide `raiz`.
+ * @returns función para dar de baja el registro.
+ */
+export declare function registrarInvalidador(raiz: string, fn: Invalidador): () => void;
+/**
+ * Inyecta la purga de caché de módulos que `invalidarRaiz` aplicará tras los
+ * invalidadores. Idempotente: la última llamada gana.
+ */
+export declare function configurarPurgaModulos(fn: PurgaModulos): void;
+export interface ResultadoInvalidacion {
+    /** Invalidadores de la raíz ejecutados. */
+    ejecutados: number;
+    /** Mensajes de error de los invalidadores que fallaron (aislados entre sí). */
+    errores: string[];
+}
+/**
+ * Ejecuta los invalidadores registrados para `raiz` (y solo ellos), luego
+ * aplica la purga de módulos si hay gancho. Los errores de cada invalidador
+ * se aíslan: uno que falla no impide a los demás ni a la purga.
+ */
+export declare function invalidarRaiz(raiz: string): Promise<ResultadoInvalidacion>;
+/**
+ * Pre-calienta imports de varias raíces EN BACKGROUND: dispara todas las
+ * cargas sin esperarlas y devuelve una promesa que resuelve cuando terminan
+ * (con éxito o fallo). El fallo de un pre-calentamiento es inocuo — solo
+ * puebla la caché del loader — y nunca propaga: el consumidor puede
+ * `await`arlo al arrancar u olvidarse de él.
+ *
+ * @param raices rutas/raíces a calentar
+ * @param cargar importador individual (el mismo que usaría la carga real)
+ */
+export declare function preloadRaices(raices: readonly string[], cargar: (raiz: string) => Promise<unknown>): Promise<void>;
+//# sourceMappingURL=invalidacion.d.ts.map

package/dist/core/carga-plugins/invalidacion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidacion.d.ts","sourceRoot":"","sources":["../../../src/core/carga-plugins/invalidacion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,qDAAqD;AACrD,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAErD,kEAAkE;AAClE,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;AAMlD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,WAAW,GAAG,MAAM,IAAI,CAiB9E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAE7D;AAED,MAAM,WAAW,qBAAqB;IACrC,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,+EAA+E;IAC/E,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAgBhF;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAClC,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GACxC,OAAO,CAAC,IAAI,CAAC,CASf"}

package/dist/core/carga-plugins/invalidacion.js

@@ -0,0 +1,94 @@
+/**
+ * Invalidación cruzada de cachés por raíz de plugin (auditoría omp B09).
+ *
+ * omp expone `registerPluginCacheInvalidator` + `preloadPluginRoots` para que
+ * consumidores síncronos (comandos, UI) encadenen la recarga de un plugin con
+ * TODAS las cachés que dependen de él. Ada no tiene equivalente: cuando
+ * cambia un plugin, cada caché (fábricas de extensión, valores ya cargados)
+ * se entera por su cuenta o no se entera.
+ *
+ * DISEÑO: registro `raíz → invalidadores`. La raíz es el directorio del
+ * plugin; todo lo cargado desde ella comparte destino en la invalidación.
+ * `invalidarRaiz` ejecuta SOLO los invalidadores de esa raíz y después purga
+ * la caché de módulos asociada vía el gancho configurable.
+ *
+ * PURGA DE MÓDULOS: `extensions/loader.ts` NO expone una purga por raíz —
+ * su `jiti` se instancia con `moduleCache: false` y la caché de fábricas se
+ * limpia en bloque con `clearExtensionCache()`. Añadir una purga fina sería
+ * tocar upstream (prohibido). Por eso el gancho es inyectable:
+ * `configurarPurgaModulos(fn)` y quien tenga una purga real la registra. Si
+ * nadie registra ninguna, `invalidarRaiz` ejecuta igualmente los
+ * invalidadores registrados (la purga es un añadido, no una condición).
+ */
+const invalidadores = {};
+let purgaModulos;
+/**
+ * Registra `fn` para que se ejecute cuando se invalide `raiz`.
+ * @returns función para dar de baja el registro.
+ */
+export function registrarInvalidador(raiz, fn) {
+    const lista = invalidadores[raiz];
+    if (lista) {
+        lista.push(fn);
+    }
+    else {
+        invalidadores[raiz] = [fn];
+    }
+    return () => {
+        const actual = invalidadores[raiz];
+        if (!actual) {
+            return;
+        }
+        const indice = actual.indexOf(fn);
+        if (indice >= 0) {
+            actual.splice(indice, 1);
+        }
+    };
+}
+/**
+ * Inyecta la purga de caché de módulos que `invalidarRaiz` aplicará tras los
+ * invalidadores. Idempotente: la última llamada gana.
+ */
+export function configurarPurgaModulos(fn) {
+    purgaModulos = fn;
+}
+/**
+ * Ejecuta los invalidadores registrados para `raiz` (y solo ellos), luego
+ * aplica la purga de módulos si hay gancho. Los errores de cada invalidador
+ * se aíslan: uno que falla no impide a los demás ni a la purga.
+ */
+export async function invalidarRaiz(raiz) {
+    const lista = invalidadores[raiz];
+    let ejecutados = 0;
+    const errores = [];
+    if (lista) {
+        for (const fn of [...lista]) {
+            ejecutados++;
+            try {
+                await fn();
+            }
+            catch (err) {
+                errores.push(err instanceof Error ? err.message : String(err));
+            }
+        }
+    }
+    purgaModulos?.(raiz);
+    return { ejecutados, errores };
+}
+/**
+ * Pre-calienta imports de varias raíces EN BACKGROUND: dispara todas las
+ * cargas sin esperarlas y devuelve una promesa que resuelve cuando terminan
+ * (con éxito o fallo). El fallo de un pre-calentamiento es inocuo — solo
+ * puebla la caché del loader — y nunca propaga: el consumidor puede
+ * `await`arlo al arrancar u olvidarse de él.
+ *
+ * @param raices rutas/raíces a calentar
+ * @param cargar importador individual (el mismo que usaría la carga real)
+ */
+export async function preloadRaices(raices, cargar) {
+    await Promise.all(raices.map((raiz) => cargar(raiz).catch(() => {
+        // Pre-calentamiento best-effort: el fallo se re-detectará (con
+        // reporte) en la carga real.
+    })));
+}
+//# sourceMappingURL=invalidacion.js.map

package/dist/core/carga-plugins/invalidacion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidacion.js","sourceRoot":"","sources":["../../../src/core/carga-plugins/invalidacion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAQH,MAAM,aAAa,GAAkC,EAAE,CAAC;AAExD,IAAI,YAAsC,CAAC;AAE3C;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAY,EAAE,EAAe;IACjE,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,KAAK,EAAE,CAAC;QACX,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAChB,CAAC;SAAM,CAAC;QACP,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,GAAG,EAAE;QACX,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;QACnC,IAAI,CAAC,MAAM,EAAE,CAAC;YACb,OAAO;QACR,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAClC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;YACjB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAC1B,CAAC;IACF,CAAC,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAAC,EAAgB;IACtD,YAAY,GAAG,EAAE,CAAC;AACnB,CAAC;AASD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,IAAY;IAC/C,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,IAAI,KAAK,EAAE,CAAC;QACX,KAAK,MAAM,EAAE,IAAI,CAAC,GAAG,KAAK,CAAC,EAAE,CAAC;YAC7B,UAAU,EAAE,CAAC;YACb,IAAI,CAAC;gBACJ,MAAM,EAAE,EAAE,CAAC;YACZ,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACd,OAAO,CAAC,IAAI,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YAChE,CAAC;QACF,CAAC;IACF,CAAC;IACD,YAAY,EAAE,CAAC,IAAI,CAAC,CAAC;IACrB,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC;AAChC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAClC,MAAyB,EACzB,MAA0C;IAE1C,MAAM,OAAO,CAAC,GAAG,CAChB,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACnB,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE;QACvB,+DAA+D;QAC/D,6BAA6B;IAC9B,CAAC,CAAC,CACF,CACD,CAAC;AACH,CAAC"}

package/dist/core/carga-plugins/paralelo.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Import paralelo determinista de plugins (auditoría omp B09).
+ *
+ * EL PROBLEMA: `extensions/loader.ts` (upstream, presupuesto de fork agotado —
+ * 3 hunks, NO se toca) importa extensiones SECUENCIALMENTE en
+ * `loadExtensionsInternal`: cada `jiti.import` espera al anterior antes de
+ * disparar el siguiente. Con N plugins el coste de arranque es la SUMA de los
+ * tiempos de compilación/carga, cuando son I/O+transpile independientes que
+ * podrían solaparse.
+ *
+ * POR QUÉ NO SE PARALELIZA EN SITIO: el orden de REGISTRO es parte del
+ * contrato observable de las extensiones (última registra gana: comandos,
+ * tools y flags con el mismo nombre se pisan por orden de carga). Un
+ * `Promise.all` ingenuo mantiene el orden del ARRAY de promesas, pero si el
+ * consumidor resuelve "a medida que llegan" (reduce con await dentro del
+ * bucle sobre promesas ya disparadas, callbacks, etc.) el orden de llegada
+ * del I/O se filtraría al registro y el arranque sería no determinista.
+ *
+ * ESTE MÓDULO fija el patrón correcto: TODOS los imports se disparan en
+ * paralelo (el loader arranca para todas las rutas antes de que el primero
+ * termine) PERO los resultados se resuelven EN EL ORDEN DE LA LISTA, porque
+ * `Promise.all` conserva posiciones. El llamador itera el resultado ya
+ * ordenado y el registro es determinista pase lo que pase con el I/O.
+ *
+ * ERRORES AISLADOS: un plugin que falla al importar no tumba a los demás.
+ * Cada promesa captura su propio error y lo reporta junto a su ruta; nunca
+ * hay rechazo agregado.
+ */
+/** Resultado por ruta: exactamente uno de éxito o fallo con su mensaje. */
+export type ImportaResultado<T> = {
+    ruta: string;
+    ok: true;
+    valor: T;
+} | {
+    ruta: string;
+    ok: false;
+    error: string;
+};
+/**
+ * Dispara `cargar` para TODAS las rutas en paralelo y devuelve los resultados
+ * en el orden de `rutas`, independientemente del orden de resolución.
+ *
+ * @param rutas rutas de plugins a importar (el orden define el de registro)
+ * @param cargar importador individual (p. ej. `jiti.import(ruta)`); se llama
+ *   una vez por ruta, todas las llamadas sin esperar entre sí
+ */
+export declare function importarEnParaleloDeterminista<T>(rutas: readonly string[], cargar: (ruta: string) => Promise<T>): Promise<Array<ImportaResultado<T>>>;
+//# sourceMappingURL=paralelo.d.ts.map

package/dist/core/carga-plugins/paralelo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paralelo.d.ts","sourceRoot":"","sources":["../../../src/core/carga-plugins/paralelo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpH;;;;;;;GAOG;AACH,wBAAsB,8BAA8B,CAAC,CAAC,EACrD,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAClC,OAAO,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAcrC"}

package/dist/core/carga-plugins/paralelo.js

@@ -0,0 +1,47 @@
+/**
+ * Import paralelo determinista de plugins (auditoría omp B09).
+ *
+ * EL PROBLEMA: `extensions/loader.ts` (upstream, presupuesto de fork agotado —
+ * 3 hunks, NO se toca) importa extensiones SECUENCIALMENTE en
+ * `loadExtensionsInternal`: cada `jiti.import` espera al anterior antes de
+ * disparar el siguiente. Con N plugins el coste de arranque es la SUMA de los
+ * tiempos de compilación/carga, cuando son I/O+transpile independientes que
+ * podrían solaparse.
+ *
+ * POR QUÉ NO SE PARALELIZA EN SITIO: el orden de REGISTRO es parte del
+ * contrato observable de las extensiones (última registra gana: comandos,
+ * tools y flags con el mismo nombre se pisan por orden de carga). Un
+ * `Promise.all` ingenuo mantiene el orden del ARRAY de promesas, pero si el
+ * consumidor resuelve "a medida que llegan" (reduce con await dentro del
+ * bucle sobre promesas ya disparadas, callbacks, etc.) el orden de llegada
+ * del I/O se filtraría al registro y el arranque sería no determinista.
+ *
+ * ESTE MÓDULO fija el patrón correcto: TODOS los imports se disparan en
+ * paralelo (el loader arranca para todas las rutas antes de que el primero
+ * termine) PERO los resultados se resuelven EN EL ORDEN DE LA LISTA, porque
+ * `Promise.all` conserva posiciones. El llamador itera el resultado ya
+ * ordenado y el registro es determinista pase lo que pase con el I/O.
+ *
+ * ERRORES AISLADOS: un plugin que falla al importar no tumba a los demás.
+ * Cada promesa captura su propio error y lo reporta junto a su ruta; nunca
+ * hay rechazo agregado.
+ */
+/**
+ * Dispara `cargar` para TODAS las rutas en paralelo y devuelve los resultados
+ * en el orden de `rutas`, independientemente del orden de resolución.
+ *
+ * @param rutas rutas de plugins a importar (el orden define el de registro)
+ * @param cargar importador individual (p. ej. `jiti.import(ruta)`); se llama
+ *   una vez por ruta, todas las llamadas sin esperar entre sí
+ */
+export async function importarEnParaleloDeterminista(rutas, cargar) {
+    // El map dispara todos los imports AHORA; then/await aísla el error de cada
+    // uno; Promise.all resuelve posicionalmente (determinismo last-wins intacto).
+    const pendientes = rutas.map((ruta) => cargar(ruta).then((valor) => ({ ruta, ok: true, valor }), (err) => ({
+        ruta,
+        ok: false,
+        error: err instanceof Error ? err.message : String(err),
+    })));
+    return Promise.all(pendientes);
+}
+//# sourceMappingURL=paralelo.js.map

package/dist/core/carga-plugins/paralelo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paralelo.js","sourceRoot":"","sources":["../../../src/core/carga-plugins/paralelo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAKH;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,8BAA8B,CACnD,KAAwB,EACxB,MAAoC;IAEpC,4EAA4E;IAC5E,8EAA8E;IAC9E,MAAM,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACrC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAChB,CAAC,KAAK,EAAuB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAC3D,CAAC,GAAY,EAAuB,EAAE,CAAC,CAAC;QACvC,IAAI;QACJ,EAAE,EAAE,KAAK;QACT,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;KACvD,CAAC,CACF,CACD,CAAC;IACF,OAAO,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;AAChC,CAAC"}

package/dist/core/colaboracion/autoresearch.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Bucle autoresearch mínimo — EVAL-02 (Fase 4).
+ *
+ * Referencia omp: autoresearch/{storage,state,helpers}.ts (sesiones/runs en
+ * SQLite, parseo METRIC/ASI, keep=commit / discard=revert, reinyección de
+ * estado). La versión mínima que cierra el hueco "goal-engine sin protocolo
+ * experimental auditable":
+ *
+ *   hipótesis → ejecuta banco (ejecutor INYECTABLE: los tests corren sin
+ *   gastar una sola llamada, el uso real pasa un ejecutor que corre el banco
+ *   de fiabilidad de core/banco) → parsea líneas `METRIC nombre=valor` →
+ *   registra hipótesis Y resultado en el journal arbolado (reusado) →
+ *   decide keep/discard sobre la métrica principal.
+ *
+ * Keep/discard en el árbol: keep deja la leaf en el resultado (la siguiente
+ * hipótesis parte del mejor estado); discard hace fork hacia atrás, al
+ * último resultado conservado — exactamente la semántica revert de omp,
+ * pero con ramas de árbol en vez de git. Toda decisión queda registrada:
+ * el journal ES la evidencia auditable.
+ */
+import type { JournalTree } from "../sesion/journal-tree.ts";
+export interface RegistroRun {
+    readonly idHipotesis: string;
+    readonly idResultado: string;
+    readonly enunciado: string;
+    readonly metricas: Record<string, number>;
+    /** Valor de la métrica principal (undefined si la salida no la trajo). */
+    readonly valorPrincipal?: number;
+    readonly decision: "keep" | "discard";
+}
+export interface SalidaExperimento {
+    salida: string;
+}
+export interface EjecutorExperimento {
+    ejecutar(enunciado: string): Promise<SalidaExperimento>;
+}
+export interface OpcionesBucle {
+    /** Métrica a optimizar; por defecto la primera que aparezca. */
+    metrica?: string;
+    /** Dirección de optimización. Por defecto maximizar (p. ej. precisión). */
+    maximizar?: boolean;
+}
+/** Parsea las líneas `METRIC nombre=valor` de la salida del experimento. */
+export declare function parsearMetricas(salida: string): Record<string, number>;
+export declare class BucleAutoresearch {
+    private readonly journal;
+    private readonly opciones;
+    constructor(journal: JournalTree, opciones?: OpcionesBucle);
+    ejecutar(hipotesis: readonly string[], ejecutor: EjecutorExperimento): Promise<RegistroRun[]>;
+    /** Half de lectura: los runs registrados, en orden de inserción. */
+    runs(): Array<{
+        tipo: string;
+        data: unknown;
+    }>;
+}
+//# sourceMappingURL=autoresearch.d.ts.map

package/dist/core/colaboracion/autoresearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoresearch.d.ts","sourceRoot":"","sources":["../../../src/core/colaboracion/autoresearch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,0EAA0E;IAC1E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACxD;AAED,MAAM,WAAW,aAAa;IAC7B,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAID,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAOtE;AAED,qBAAa,iBAAiB;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;gBAC7B,OAAO,EAAE,WAAW,EAAE,QAAQ,GAAE,aAAkB;IAKxD,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,EAAE,QAAQ,EAAE,mBAAmB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAkDnG,oEAAoE;IACpE,IAAI,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC;CAM9C"}

package/dist/core/colaboracion/autoresearch.js

@@ -0,0 +1,95 @@
+/**
+ * Bucle autoresearch mínimo — EVAL-02 (Fase 4).
+ *
+ * Referencia omp: autoresearch/{storage,state,helpers}.ts (sesiones/runs en
+ * SQLite, parseo METRIC/ASI, keep=commit / discard=revert, reinyección de
+ * estado). La versión mínima que cierra el hueco "goal-engine sin protocolo
+ * experimental auditable":
+ *
+ *   hipótesis → ejecuta banco (ejecutor INYECTABLE: los tests corren sin
+ *   gastar una sola llamada, el uso real pasa un ejecutor que corre el banco
+ *   de fiabilidad de core/banco) → parsea líneas `METRIC nombre=valor` →
+ *   registra hipótesis Y resultado en el journal arbolado (reusado) →
+ *   decide keep/discard sobre la métrica principal.
+ *
+ * Keep/discard en el árbol: keep deja la leaf en el resultado (la siguiente
+ * hipótesis parte del mejor estado); discard hace fork hacia atrás, al
+ * último resultado conservado — exactamente la semántica revert de omp,
+ * pero con ramas de árbol en vez de git. Toda decisión queda registrada:
+ * el journal ES la evidencia auditable.
+ */
+import { randomUUID } from "node:crypto";
+const RE_METRIC = /^\s*METRIC\s+([A-Za-z_]\w*)\s*=\s*(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\s*$/gm;
+/** Parsea las líneas `METRIC nombre=valor` de la salida del experimento. */
+export function parsearMetricas(salida) {
+    const out = {};
+    RE_METRIC.lastIndex = 0;
+    for (let m = RE_METRIC.exec(salida); m !== null; m = RE_METRIC.exec(salida)) {
+        out[m[1]] = Number(m[2]);
+    }
+    return out;
+}
+export class BucleAutoresearch {
+    journal;
+    opciones;
+    constructor(journal, opciones = {}) {
+        this.journal = journal;
+        this.opciones = opciones;
+    }
+    async ejecutar(hipotesis, ejecutor) {
+        if (hipotesis.length === 0)
+            throw new Error("autoresearch: se necesita al menos una hipótesis");
+        const registros = [];
+        let anclaMejor = this.journal.getLeaf()?.id ?? null;
+        let mejorValor;
+        for (const enunciado of hipotesis) {
+            const sufijo = randomUUID().slice(0, 8);
+            const idHipotesis = `ar-h-${sufijo}`;
+            this.journal.append({
+                id: idHipotesis,
+                parentId: this.journal.getLeaf()?.id ?? anclaMejor,
+                type: "autoresearch-hipotesis",
+                data: { enunciado },
+            });
+            const res = await ejecutor.ejecutar(enunciado);
+            const metricas = parsearMetricas(res.salida);
+            const clave = this.opciones.metrica ?? Object.keys(metricas)[0];
+            const valorPrincipal = clave === undefined ? undefined : metricas[clave];
+            let decision;
+            if (valorPrincipal === undefined || mejorValor === undefined) {
+                // Sin métrica comparable no hay base para descartar: se conserva.
+                decision = "keep";
+            }
+            else if (this.opciones.maximizar === false) {
+                decision = valorPrincipal < mejorValor ? "keep" : "discard";
+            }
+            else {
+                decision = valorPrincipal > mejorValor ? "keep" : "discard";
+            }
+            const idResultado = `ar-r-${sufijo}`;
+            this.journal.append({
+                id: idResultado,
+                parentId: idHipotesis,
+                type: "autoresearch-resultado",
+                data: { enunciado, metricas, decision },
+            });
+            registros.push({ idHipotesis, idResultado, enunciado, metricas, valorPrincipal, decision });
+            if (decision === "keep") {
+                mejorValor = valorPrincipal;
+                anclaMejor = this.journal.getLeaf()?.id ?? idResultado;
+            }
+            else if (anclaMejor !== null) {
+                this.journal.fork(anclaMejor);
+            }
+        }
+        return registros;
+    }
+    /** Half de lectura: los runs registrados, en orden de inserción. */
+    runs() {
+        return this.journal
+            .entries()
+            .filter((e) => e.type.startsWith("autoresearch-"))
+            .map((e) => ({ tipo: e.type, data: e.data }));
+    }
+}
+//# sourceMappingURL=autoresearch.js.map

package/dist/core/colaboracion/autoresearch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoresearch.js","sourceRoot":"","sources":["../../../src/core/colaboracion/autoresearch.ts"],"names":[],"mappings":"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"}

package/dist/core/colaboracion/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Barrel de colaboración — CO1/EVAL (Fase 4).
+ */
+export type { EjecutorExperimento, OpcionesBucle, RegistroRun, SalidaExperimento, } from "./autoresearch.ts";
+export { BucleAutoresearch, parsearMetricas } from "./autoresearch.ts";
+export type { LenguajeKernel, ResultadoCelda } from "./kernels.ts";
+export { KernelJs, PoolKernels } from "./kernels.ts";
+export type { ResultadoSincronizacion } from "./sesion-colaborativa.ts";
+export { RAIZ_COLABORACION, SesionColaborativa } from "./sesion-colaborativa.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/colaboracion/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/colaboracion/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,YAAY,EACX,mBAAmB,EACnB,aAAa,EACb,WAAW,EACX,iBAAiB,GACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACvE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/core/colaboracion/index.js

@@ -0,0 +1,7 @@
+/**
+ * Barrel de colaboración — CO1/EVAL (Fase 4).
+ */
+export { BucleAutoresearch, parsearMetricas } from "./autoresearch.js";
+export { KernelJs, PoolKernels } from "./kernels.js";
+export { RAIZ_COLABORACION, SesionColaborativa } from "./sesion-colaborativa.js";
+//# sourceMappingURL=index.js.map

package/dist/core/colaboracion/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/colaboracion/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC"}