xonecode 0.38.44 → 0.39.4

package/dist/agent/exportarPdf.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Convertir un documento del proyecto a PDF, imprimiéndolo con un NAVEGADOR.
+ *
+ * El porqué de que esto lo haga el harness y no el agente está en `core/exportacion.ts`.
+ * Aquí está lo que toca disco, y tres decisiones que no son de forma:
+ *
+ * - **El navegador se busca en una lista CERRADA de rutas conocidas**, igual que las
+ *   herramientas de `core/dispositivos.ts`: lo que no está en la lista no se lanza. Y su RUTA
+ *   se queda en el host — por el cable viaja que hay navegador o que no, nunca dónde.
+ * - **Se imprime SIN JavaScript** (`--blink-settings=scriptEnabled=false`). Un `.md` o un
+ *   `.html` del proyecto puede traer un `<script>` dentro, y un PDF no necesita ejecutar
+ *   nada: es la misma razón por la que un artefacto se sirve en un iframe con origen opaco.
+ * - **El HTML intermedio se escribe FUERA del proyecto.** Dentro entraría en git, en el
+ *   commit de cada turno y en la siguiente subida a CloudStudio — un fichero de andamiaje en
+ *   la app del cliente.
+ */
+/**
+ * Dónde puede estar un navegador que sepa imprimir. Lista CERRADA y en este orden.
+ *
+ * Son todos Chromium por dentro, que es el que trae `--print-to-pdf`: Safari y Firefox no
+ * tienen equivalente en línea de comandos, así que no están y no es un olvido.
+ */
+export declare const NAVEGADORES_CONOCIDOS: readonly ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "/Applications/Chromium.app/Contents/MacOS/Chromium", "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge", "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser", "/usr/bin/chromium", "/usr/bin/chromium-browser", "/usr/bin/google-chrome", "/usr/bin/google-chrome-stable"];
+/**
+ * Los de WINDOWS, por sus carpetas de programas (de las variables, nunca una letra de unidad a fuego). Edge va primero: lo
+ * trae todo Windows. Medido en la máquina Windows de un usuario: con solo las rutas de macOS y Linux, el crítico de pantalla
+ * decía «no hay Chrome ni Chromium» y comparaba contra una descripción en vez de medir las cajas de la maqueta.
+ */
+export declare function navegadoresDeWindows(entorno: Readonly<Record<string, string | undefined>>): string[];
+/** El primero que exista, o AUSENTE. Ausente = aquí no se puede imprimir, y se DICE con el
+ *  remedio: no hay forma de adivinar que lo que falta es un navegador. */
+export declare function navegadorParaImprimir(existe?: (ruta: string) => boolean, plataforma?: string, entorno?: Readonly<Record<string, string | undefined>>): string | undefined;
+/** Qué decir cuando no hay ninguno. Vive aquí y no en quien llama para que las tres pieles
+ *  digan lo mismo. */
+export declare const SIN_NAVEGADOR: string;
+export type ResultadoDeExportacion = {
+    ruta: string;
+} | {
+    error: string;
+};
+/**
+ * Exporta `ruta` (relativa al proyecto) a un PDF hermano. Nunca LANZA.
+ *
+ * Las barreras son las MISMAS que usa la pestaña Ficheros y en el mismo orden: la criba de
+ * balde sobre el texto (`motivoDeRutaInaceptable`) y luego el camino REAL, porque un enlace
+ * simbólico dentro de la raíz puede apuntar fuera. No hay una segunda copia de esas reglas
+ * aquí: un segundo sitio donde decidir sobre una ruta es un segundo sitio donde el
+ * fail-closed puede dejar de estarlo.
+ */
+export declare function exportarAPdf(opciones: {
+    raiz: string;
+    ruta: string;
+    /** El binario, ya elegido. Entra por parámetro para poder probar el cableado sin un
+     *  navegador delante. */
+    navegador?: string;
+    /**
+     * Cómo se BUSCA cuando no se da uno. Por omisión, el primero conocido que exista.
+     *
+     * Entra por parámetro y no se resuelve dentro porque si no el resultado dependería de si la
+     * máquina que corre los tests tiene Chrome instalado — y un test que pasa aquí y falla en
+     * CI (o al revés) no fija nada.
+     */
+    buscarNavegador?: () => string | undefined;
+    /** Cómo se lanza. Por omisión `execFile`; los tests no abren un navegador de verdad. */
+    imprimir?: (navegador: string, argumentos: readonly string[]) => Promise<void>;
+    /** Markdown → HTML. Por omisión `marked`, que se carga PEREZOSAMENTE: exportar es raro y
+     *  no tiene por qué pesar en el arranque de cada turno. */
+    aHtml?: (markdown: string) => string | Promise<string>;
+}): Promise<ResultadoDeExportacion>;
+/** Un documento largo con tablas tarda segundos, no minutos; un navegador que no vuelve en
+ *  este plazo está colgado y no imprimiendo. */
+export declare const TOPE_DE_IMPRESION_MS: number;

package/dist/agent/grafo/aprendido.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { NOMBRE_APUNTAR_APRENDIZAJE, type Aprendizaje } from "../../core/aprendido.js";
+export { NOMBRE_APUNTAR_APRENDIZAJE };
+/** `.xonecode/aprendido.json` del proyecto (`core/aprendido.ts` tiene el porqué). */
+export declare function rutaDeAprendido(raiz: string): string;
+/** Lo apuntado, o una lista vacía: sin fichero, o roto, no hay nada que poner delante. */
+export declare function leerAprendido(raiz: string): Aprendizaje[];
+/** Apunta uno, sustituyendo el del mismo tema. Escritura atómica y 0600: puede llevar una contraseña. */
+export declare function apuntarAprendizaje(raiz: string, nuevo: Aprendizaje): Aprendizaje[];
+/**
+ * `apuntar_aprendizaje`: escribe lo aprendido para los encargos siguientes. **Sin aprobación**: no es un fichero de la
+ * app —vive en `.xonecode/`, que no sube ni entra en los commits— sino memoria del agente, como un plan. El mismo tema se
+ * sustituye. Un rechazo se DEVUELVE, nunca se lanza.
+ */
+export declare function crearApuntarAprendizaje(donde: {
+    raiz: string;
+    quien: string;
+    ahora?: () => Date;
+}): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    tema: z.ZodString;
+    texto: z.ZodString;
+}, z.core.$strip>, {
+    tema: string;
+    texto: string;
+}, {
+    tema: string;
+    texto: string;
+}, string, unknown, "apuntar_aprendizaje">;

package/dist/agent/grafo/arbolDeProyecto.d.ts

@@ -0,0 +1,205 @@
+/**
+ * El proyecto tal como lo enseña la pestaña Ficheros de la consola web: el árbol, el
+ * contenido de un fichero y, desde el editor de la pestaña, GUARDARLO (`escribirFicheroDeProyecto`): la
+ * única escritura del cliente en un fichero del proyecto, con las MISMAS guardas que la lectura.
+ *
+ * Lo que se lista y lo que se lee es lo mismo que ve el agente, con las mismas reglas y
+ * por las mismas funciones: `puedeLeerRuta` (la barrera de las tools propias) y
+ * `esVistaAplanada` (los `.xml` que genera XOne Studio no se tocan). Reescribirlas aquí
+ * sería la segunda copia que diverge el primer día.
+ */
+/** Profundidad del árbol de la web: sin tope práctico (el del Tab es 4). */
+export declare const PROFUNDIDAD_DEL_ARBOL = 32;
+/** Entradas a partir de las cuales el árbol se recorta y lo dice. */
+export declare const TOPE_DE_ENTRADAS = 5000;
+/** Bytes de contenido que viajan como mucho: el mismo tope que el parche de Revisión. */
+export declare const TOPE_DE_FICHERO = 400000;
+/** Ventana en la que un NUL delata un binario. */
+export declare const VENTANA_DE_BINARIO = 8192;
+/**
+ * Bytes de IMAGEN que viajan como mucho. Tope propio y más alto que el del texto por dos
+ * razones: una imagen recortada no es una imagen a medias, es nada —el navegador pinta el
+ * icono roto—, así que aquí no hay término medio entre traerla entera y no traerla; y la
+ * codificación base64 infla un tercio, de modo que este tope son ~2,7 MB por el cable.
+ * Un mockup o un icono de un proyecto XOne caben de sobra; un PSD de veinte megas no, y
+ * eso se DICE en vez de colgar la pestaña.
+ */
+export declare const TOPE_DE_IMAGEN = 2000000;
+/** El MIME de una ruta si es una imagen que sabemos pintar, o `undefined`. */
+export declare function mimeDeImagen(ruta: string): string | undefined;
+export interface ArbolDeProyecto {
+    /** Relativas a la raíz, sin barra inicial, ordenadas: carpetas antes que ficheros. */
+    rutas: string[];
+    recortado: boolean;
+}
+export interface FicheroLeido {
+    /** La ruta tal como se pidió, nunca la resuelta en disco. */
+    ruta: string;
+    /** Falta si es binario o si la ruta se rechazó. */
+    texto?: string;
+    recortado: boolean;
+    binario: boolean;
+    /** Tamaño real en disco, aunque el texto vaya recortado. */
+    bytes: number;
+    codificacion?: "utf-8" | "latin1";
+    /**
+     * El tipo MIME, solo si la ruta es una imagen que el visor sabe pintar. Va aunque los
+     * bytes NO viajen: es lo que deja distinguir «una imagen demasiado grande» de «un
+     * binario cualquiera», que son dos cosas distintas que decir.
+     */
+    mime?: string;
+    /** El contenido de la imagen, si cupo en `TOPE_DE_IMAGEN`. Sin recortar nunca. */
+    base64?: string;
+    /**
+     * Solo en un MARKDOWN que enlaza imágenes del proyecto: el mismo texto con cada uno de esos
+     * enlaces apuntando a `RUTA_IMAGEN_DEL_PROYECTO`, que las sirve (`vistaDeMarkdown`). `texto`
+     * sigue siendo la fuente tal cual: «Fuente» enseña lo que hay en el fichero, no lo que se pinta.
+     */
+    vista?: string;
+    /**
+     * El sha256 de los BYTES en disco (`huellaDeContenido`), solo con el texto ENTERO —UTF-8 o
+     * latin1, que se guarda en su tabla de 8 bits—: es lo que el editor devuelve al guardar para que se
+     * sepa si el disco cambió mientras tanto. Un recortado o un binario no la llevan, y sin ella no
+     * se edita.
+     */
+    huella?: string;
+    /** El motivo del paso que falló. Sin él, la lectura fue bien. */
+    error?: string;
+}
+/**
+ * Carpetas antes que ficheros en cada nivel, y dentro alfabético sin distinguir mayúsculas.
+ * Se compara segmento a segmento: en el primero que difiere, si uno es hoja (último
+ * segmento de su ruta) y el otro carpeta, la carpeta va antes.
+ */
+export declare function ordenarRutas(rutas: readonly string[]): string[];
+export declare function arbolDeProyecto(raiz: string): ArbolDeProyecto;
+/**
+ * Por qué una ruta del cable no se acepta, o `undefined` si vale. Es la criba de balde,
+ * antes de tocar el disco: relativa, sin `.`/`..`/segmentos vacíos, y admitida por la
+ * barrera de lectura. La segunda criba —que el camino REAL siga dentro de la raíz— es de
+ * `leerFicheroDeProyecto`, porque necesita `realpath`.
+ */
+export declare function motivoDeRutaInaceptable(ruta: string): string | undefined;
+/** Una ruta del cable ya resuelta contra el disco y que ha pasado las DOS cribas. */
+export interface RutaResuelta {
+    /** El camino REAL (`realpath`): el único sobre el que se abre o se escribe. */
+    real: string;
+    /** Ese camino real relativo a la raíz real, con «/». Es el que se le da a git. */
+    relativa: string;
+    /** La ruta pedida con «/» en vez de «\». */
+    normal: string;
+}
+/**
+ * ¿Se puede ENSEÑAR esta ruta? La MISMA regla que `leerFicheroDeProyecto`, para quien enseña
+ * algo de un fichero que no es su contenido tal cual —el diff de lo pendiente de subir—:
+ * criba de texto, vista aplanada, y la segunda pasada sobre el camino REAL cuando el fichero
+ * existe (mayúsculas en un disco que no las distingue, enlaces a un fichero denegado). Un
+ * fichero que ya no existe —un borrado— solo pasa la criba de texto: no hay camino que resolver,
+ * y su contenido sale de git, no del disco.
+ */
+export declare function motivoParaNoEnsenar(raiz: string, ruta: string): Promise<string | undefined>;
+/**
+ * La ruta RELATIVA del icono de la app de un proyecto bajado, o `undefined` si no tiene uno que se
+ * pueda enseñar.
+ *
+ * El nombre sale de `app.ini` (`core/descriptoresDeApp.ts#candidatosDeIcono`) y cada candidato pasa
+ * la MISMA barrera que la pestaña Ficheros (`motivoParaNoEnsenar`: texto y `realpath`), además de
+ * ser una imagen que sabemos pintar, un fichero de verdad y caber en `TOPE_DE_IMAGEN`. Un
+ * `icon=../.env` o un `icon.png` enlazado a un fichero denegado se quedan en «sin icono», que en la
+ * barra es la carpeta de siempre. Nunca lanza: un icono es decoración y no puede tumbar un anuncio.
+ */
+export declare function iconoDelProyecto(raiz: string): Promise<string | undefined>;
+/**
+ * La cadena ENTERA de guardas de una ruta del cable, en UN sitio: la usan leer, guardar y la base
+ * de las marcas del editor (`agent/sesiones/baseDeFichero.ts`). Se extrajo de la lectura cuando
+ * apareció la escritura: copiarla habría sido la segunda copia que diverge el primer día, y en el
+ * lado que escribe un agujero ya no enseña un secreto, lo pisa.
+ */
+export declare function resolverEnProyecto(raiz: string, ruta: string): Promise<RutaResuelta | {
+    error: string;
+}>;
+export declare function leerFicheroDeProyecto(raiz: string, ruta: string): Promise<FicheroLeido>;
+/**
+ * El markdown con cada enlace a una IMAGEN del proyecto apuntando a `RUTA_IMAGEN_DEL_PROYECTO`, o
+ * `undefined` si no enlaza ninguna.
+ *
+ * **No se incrusta, y es a propósito**: el visor (`MarkdownText`) solo pinta imágenes con URL
+ * absoluta `http(s)` —una `data:` se queda en su texto alternativo—, así que tienen que llegar por
+ * HTTP. Y así abrir un documento no lee ni un byte de sus imágenes: la barrera la pone la ruta que
+ * las sirve, al pedirlas. Aquí solo se reescribe lo que ya pasa la criba de balde sobre el TEXTO
+ * (`motivoDeRutaInaceptable`) y es una imagen por su extensión: un enlace a `.env`, o que se sale
+ * del proyecto, se queda como estaba.
+ */
+export declare function vistaDeMarkdown(documento: string, texto: string): string | undefined;
+/** Cuántas imágenes y cuántos bytes se incrustan como mucho en un documento. */
+export declare const TOPE_DE_IMAGENES_INCRUSTADAS = 40;
+export declare const TOPE_DE_BYTES_INCRUSTADOS = 10000000;
+/**
+ * El documento `documento` (ruta relativa al proyecto) con sus imágenes del proyecto INCRUSTADAS.
+ *
+ * Cada imagen se lee con `leerFicheroDeProyecto` —las MISMAS barreras de la pestaña Ficheros, sobre
+ * el texto y sobre el camino real, y su tope por imagen—, así que un enlace a `.env` o a algo de
+ * fuera del proyecto no se incrusta: no pasa la barrera y se queda como estaba. No hay una segunda
+ * copia de esas reglas aquí. Lo que no se puede leer, o pasa de los topes, se deja tal cual y se
+ * CUENTA en `sinResolver`: una imagen rota se ve, una inventada no.
+ */
+export declare function conImagenesDelProyecto(raiz: string, documento: string, texto: string, leer?: (raiz: string, ruta: string) => Promise<FicheroLeido>): Promise<{
+    texto: string;
+    incrustadas: number;
+    sinResolver: number;
+}>;
+/**
+ * El CONTENIDO de un fichero cuyo camino REAL ya pasó su barrera: texto o imagen, con su
+ * tope, su codificación y las dos caras del SVG.
+ *
+ * Se extrajo de `leerFicheroDeProyecto` cuando los ARTEFACTOS de una sesión necesitaron lo
+ * mismo (`agent/grafo/artefactosEnDisco.ts`). Lo que NO se extrajo es la barrera: la de un
+ * fichero del proyecto y la de un artefacto son reglas distintas —una pregunta
+ * `puedeLeerRuta` y las vistas aplanadas, la otra que el nombre sea un segmento llano
+ * dentro de la carpeta de la sesión—, y fundirlas en un parámetro sería la clase de
+ * generalización que acaba dejando un agujero en el lado que no se estaba mirando.
+ *
+ * `real` es el camino ya resuelto con `realpath`; `ruta` es la que se enseña y viaja de
+ * vuelta, nunca la del disco. El `mime` lo decide quien llama porque cada lado lo saca de
+ * un nombre distinto, y de él dependen los dos caminos de aquí: la imagen que solo viaja
+ * entera y el SVG, que va con fuente y dibujo.
+ */
+export declare function leerContenidoDeFichero(real: string, ruta: string, mime: string | undefined): Promise<FicheroLeido>;
+/**
+ * La HUELLA de un contenido: sha256 de sus bytes. Es la concurrencia optimista del editor: viaja
+ * al leer y vuelve al guardar, y si el disco ya no coincide no se escribe nada. Un hash y no una
+ * fecha de modificación porque una fecha no distingue «lo reescribió con lo mismo» de «lo cambió»,
+ * y en una copia mudada o bajada de nuevo las fechas no dicen nada.
+ */
+export declare function huellaDeContenido(bytes: Uint8Array): string;
+/** El resultado de guardar: con `huella` se escribió; con `error`, no se tocó nada. */
+export interface FicheroGuardado {
+    ruta: string;
+    huella?: string;
+    error?: string;
+}
+/**
+ * Guarda lo que la persona editó en la pestaña Ficheros. En orden, y cualquier paso que falle
+ * DEVUELVE su motivo sin haber tocado el disco:
+ *
+ * 1. Las MISMAS guardas que leer (`resolverEnProyecto`), y además que sea un fichero normal —una
+ *    carpeta no— y que no sea una imagen, que no se edita desde aquí.
+ * 2. La huella: si lo que hay en disco no es lo que el cliente cargó, alguien (el agente, otra
+ *    pestaña, un editor de fuera) lo cambió, y escribir encima lo perdería sin avisar.
+ * 3. La codificación, la que YA tenía el fichero (sus bytes actuales) o, si es ASCII puro, la que
+ *    declara su prólogo (`codificacionParaEscribir`); un carácter que no cabe en la tabla de 8 bits
+ *    se niega con cuál y en qué línea.
+ * 4. El tope, en BYTES ya codificados: el mismo que la lectura, porque lo que no se puede leer
+ *    entero no se edita.
+ * 5. Escritura ATÓMICA sobre el camino REAL (temporal en la misma carpeta + `rename`): un corte a
+ *    mitad deja el fichero viejo, no uno truncado; y sobre el real porque renombrar encima de un
+ *    enlace lo sustituiría por un fichero normal.
+ *
+ * Lo que NO hace es comprobar que nadie trabaja en el proyecto: eso es del manejador del cable
+ * (`arranque.ts#atenderGuardarFichero`), que es quien ve las consolas vivas.
+ *
+ * El BOM: el lector decodifica con `TextDecoder`, que lo QUITA, así que el editor nunca lo ve; si
+ * el fichero lo llevaba y el texto no, se le devuelve —si no, guardar un fichero sin tocar una
+ * coma cambiaría sus bytes—.
+ */
+export declare function escribirFicheroDeProyecto(raiz: string, ruta: string, texto: string, huella: string): Promise<FicheroGuardado>;

package/dist/agent/grafo/artefactosEnDisco.d.ts

@@ -0,0 +1,35 @@
+import { type FicheroLeido } from "./arbolDeProyecto.js";
+/**
+ * Bytes que la ruta HTTP sirve como mucho.
+ *
+ * No es el tope del cable (`TOPE_DE_FICHERO`, 400 KB) y no puede serlo: por aquí pasa el
+ * documento que el iframe pinta, y medio HTML no es medio panel — es una página rota. Un
+ * panel de `artifacts-builder` con sus datos horneados dentro ronda el megabyte, así que el
+ * tope está donde deja de ser un artefacto y empieza a ser un descuido; existe para que un
+ * fichero de 800 MB no se lea entero a memoria en la máquina del usuario, no para acotar lo
+ * que el agente puede dibujar.
+ */
+export declare const TOPE_DE_ARTEFACTO = 20000000;
+/** El resultado de la lectura cruda. Discriminado, y con el motivo separado, porque la ruta
+ *  HTTP tiene que contestar un código distinto a cada cosa: 403 lo rechazado, 404 lo que no
+ *  está, 413 lo que no cabe. Fundirlos daría un 404 para todo, que es la respuesta que hace
+ *  imposible saber si el fichero existe o si el nombre estaba mal. */
+export type LecturaCruda = {
+    ok: true;
+    nombre: string;
+    datos: Buffer;
+    mime?: string;
+} | {
+    ok: false;
+    motivo: "rechazado" | "no-existe" | "demasiado-grande";
+};
+/**
+ * Para el CABLE: la misma forma con la que viaja un fichero del proyecto.
+ *
+ * La `ruta` que vuelve es la VIRTUAL (`/artefactos/<nombre>`), nunca la del disco: el cable
+ * puede ir por un túnel, y es la misma regla por la que la ruta de una herramienta se queda
+ * en el host. El error tampoco la lleva.
+ */
+export declare function leerArtefactoDeSesion(raiz: string, sesion: string, nombre: string): Promise<FicheroLeido>;
+/** Para la RUTA HTTP: los bytes, sin recortar y sin base64. Ver `TOPE_DE_ARTEFACTO`. */
+export declare function leerArtefactoCrudo(raiz: string, sesion: string, nombre: string): Promise<LecturaCruda>;

package/dist/agent/grafo/atributosXone.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export declare const NOMBRE_ATRIBUTOS_XONE = "xone_atributos";
+/**
+ * Las tablas de las que sale el índice, dentro de la skill `xone-development` del PAQUETE: las de referencia de cada nodo y
+ * las de su capítulo propio, porque la skill no siempre dice lo mismo en los dos y el índice enseña los dos. `nodo` es el
+ * del fichero entero cuando su título no lo parte en secciones `## N. Nodo …`.
+ */
+export declare const REFERENCIAS_DE_ATRIBUTOS: readonly {
+    fichero: string;
+    nodo?: string;
+}[];
+/** Dónde se busca lo que el índice no trae: la skill entera, con la tool de fichero que todos tienen. */
+export declare const RUTA_DE_LA_SKILL = "/skills/xone-development/references/";
+export declare const busquedaEnLaSkill: (atributo: string) => string;
+/**
+ * `xone_atributos`: ¿existe este atributo en este nodo?, en una línea (`core/atributosXone.ts` tiene el porqué medido).
+ *
+ * Se lee de la skill del PAQUETE en cada construcción, nunca de una copia: si la referencia cambia, el índice cambia con
+ * ella. Una referencia que falta no tumba nada: la tool dice que no tiene índice y remite a la skill. Solo LEE, y lo que
+ * lee es de la skill, no del proyecto, así que no pasa por `puedeLeerRuta`.
+ */
+export declare function crearAtributosXone(raizDeSkills?: string): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    atributo: z.ZodOptional<z.ZodString>;
+    nodo: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    atributo?: string | undefined;
+    nodo?: string | undefined;
+}, {
+    atributo?: string | undefined;
+    nodo?: string | undefined;
+}, string, unknown, "xone_atributos">;

package/dist/agent/grafo/buscarIcono.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { NOMBRE_BUSCAR_ICONO, recibeBuscarIcono } from "../../core/iconos.js";
+import type { IconosPort } from "../../core/ports.js";
+export { NOMBRE_BUSCAR_ICONO, recibeBuscarIcono };
+export declare function crearBuscarIcono(iconos: IconosPort): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    operacion: z.ZodEnum<{
+        buscar: "buscar";
+        obtener: "obtener";
+    }>;
+    consulta: z.ZodOptional<z.ZodString>;
+    prefijo: z.ZodOptional<z.ZodString>;
+    limite: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    id: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    tamano: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>, {
+    operacion: "buscar" | "obtener";
+    consulta?: string | undefined;
+    prefijo?: string | undefined;
+    limite?: number | undefined;
+    id?: string | undefined;
+    color?: string | undefined;
+    tamano?: number | undefined;
+}, {
+    operacion: "buscar" | "obtener";
+    consulta?: string | undefined;
+    prefijo?: string | undefined;
+    limite?: unknown;
+    id?: string | undefined;
+    color?: string | undefined;
+    tamano?: unknown;
+}, string, unknown, "buscar_icono">;

package/dist/agent/grafo/busquedaRegex.d.ts

@@ -0,0 +1,56 @@
+import type { FilesystemBackend } from "deepagents";
+import { z } from "zod";
+/**
+ * El nombre de esta tool, en UN sitio.
+ *
+ * Existe porque `xone_navegacion` manda aquí cuando no sabe contestar, y una sugerencia que
+ * nombre una tool que ya no se llama así manda al modelo a llamar a algo que no existe —
+ * gasta un viaje y devuelve un error. Es la lección del token `HANDOFF DE ANÁLISIS`: lo que se
+ * nombra desde otro sitio no se escribe dos veces.
+ */
+export declare const NOMBRE_BUSQUEDA_REGEX = "regex_search";
+/**
+ * La llamada EXACTA a `regex_search` que busca un término como texto, lista para copiar.
+ *
+ * Se devuelve la llamada entera y no un consejo en prosa («busca con regex_search») por lo
+ * mismo que `porQueNo` dice la ruta buena en vez de solo negarse: un modelo al que se le dice
+ * qué hacer sin decirle cómo se inventa los argumentos, y aquí inventarlos cuesta un viaje y
+ * un error de esquema. Se comprueba contra el esquema REAL de la tool en su test.
+ */
+export declare function llamadaDeBusqueda(termino: string, glob?: string): string;
+/** Límites defensivos: la regex es una ayuda de localización, no un lector masivo. */
+export declare const LIMITES_REGEX: {
+    readonly archivos: 50;
+    readonly bytesPorArchivo: number;
+    readonly coincidencias: 100;
+    readonly caracteresPorLinea: 1000;
+};
+type BackendDeBusqueda = Pick<FilesystemBackend, "glob" | "readRaw">;
+/**
+ * Búsqueda regex confinada al backend virtual del proyecto.
+ *
+ * DeepAgents ofrece `grep` literal, que es preferible para la mayoría de
+ * búsquedas y usa ripgrep. Esta tool cubre patrones estructurales de XOne/ES5
+ * (funciones, atributos y eventos) sin conceder `execute` ni usar una shell.
+ * La coincidencia es por línea, como grep: no sirve para regex multilínea.
+ */
+export declare function crearBusquedaRegex(backend: BackendDeBusqueda): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodDefault<z.ZodString>;
+    glob: z.ZodDefault<z.ZodString>;
+    flags: z.ZodDefault<z.ZodString>;
+    max_count: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>, {
+    pattern: string;
+    path: string;
+    glob: string;
+    flags: string;
+    max_count: number;
+}, {
+    pattern: string;
+    path?: string | undefined;
+    glob?: string | undefined;
+    flags?: string | undefined;
+    max_count?: unknown;
+}, string, unknown, "regex_search">;
+export {};

package/dist/agent/grafo/codificacionDelProyecto.d.ts

@@ -0,0 +1,7 @@
+import { type Tabla8Bits } from "../../core/codificacion.js";
+export declare function conCodificacionDelFichero<T extends object>(backend: T): T;
+/**
+ * Lo que el agente lee cuando su texto no cabe. Le dice qué hacer en lugar de solo «no»: en un XML
+ * la entidad numérica es el mismo carácter para XOne; en JavaScript, el escape `\u`; en CSS, `\XX `.
+ */
+export declare function motivoDeNoRepresentable(ruta: string, caracter: string, linea: number, tabla?: Tabla8Bits): string;

package/dist/agent/grafo/compararCapturas.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { type ImagenReferida } from "../../core/referenciasDeImagen.js";
+export declare const NOMBRE_COMPARAR_CAPTURAS = "comparar_capturas";
+export interface DependenciasDeComparacion {
+    /** Los bytes de un artefacto, por su ruta RELATIVA. Quien la monta sabe dónde está la carpeta. */
+    leerArtefacto: (nombre: string) => Promise<Buffer>;
+    /**
+     * Lee una MAQUETA de donde esté (`core/referenciasDeImagen.ts`). Ausente, la referencia solo puede
+     * venir de `/artefactos/`, que es lo que hacía antes y lo que sigue haciendo el motor legacy.
+     */
+    leerReferencia?: (imagen: ImagenReferida) => Promise<Buffer>;
+}
+export declare function crearCompararCapturas(deps: DependenciasDeComparacion): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    referencia: z.ZodString;
+    captura: z.ZodString;
+}, z.core.$strip>, {
+    referencia: string;
+    captura: string;
+}, {
+    referencia: string;
+    captura: string;
+}, string, unknown, "comparar_capturas">;

package/dist/agent/grafo/copiarArtefacto.d.ts

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { type QuienDecidePermisos } from "./perfiles.js";
+/**
+ * Traer un artefacto AL proyecto, que es la única forma sancionada de cruzar ese muro.
+ *
+ * ## Por qué es una tool y no algo que el agente pueda hacer solo
+ *
+ * Las tools de fichero son de TEXTO —`write_file` recibe una cadena, y el propio backend
+ * declara `write(filePath, content: string)`—, así que un PNG no sobrevive a un
+ * `read_file` + `write_file`: se copiaría corrupto y nadie se enteraría hasta abrir el
+ * manual. La otra vía sería una shell, y dársela al que documenta es justo lo contrario de
+ * lo que lo hace inofensivo. Es el mismo reparto que el PDF: lo hace el harness porque el
+ * agente no puede, y concederle la capacidad habría sido peor que el problema.
+ *
+ * ## Por qué esto NO es un agujero en la guarda de artefactos
+ *
+ * `artefactoFueraDeSitio` existe para que un artefacto no acabe dentro del proyecto, y esa
+ * regla se hizo cuando colarse dentro era SIEMPRE un descuido. Documentar es el primer caso
+ * donde meterlo dentro es lo correcto: un manual en `doc/` con sus capturas al lado viaja
+ * con el proyecto, entra en git y sube a CloudStudio, que es lo que lo hace un manual y no
+ * una salida de usar y tirar.
+ *
+ * La diferencia entre un agujero y una puerta es que la puerta tiene guarda, y aquí son
+ * tres, todas reaplicadas A MANO: **una tool propia no pasa por el middleware de permisos**
+ * —ya lo hacen `regex_search` y `xone_navegacion` con `puedeLeerRuta`, y una que ESCRIBE
+ * tiene el mismo deber con más consecuencias—. Sin `puedeEscribirRuta`, esto sería
+ * exactamente la puerta trasera por la que un agente de solo lectura mete ficheros en el
+ * proyecto.
+ *
+ * ## Las guardas, y por qué cada una
+ *
+ * 1. **El ORIGEN es un artefacto de verdad** (`esRutaDeArtefacto`, lista BLANCA de forma y
+ *    no un `startsWith`): sin esto el «origen» podría ser `/artefactos/../.env`.
+ * 2. **El DESTINO lo puede escribir ESTE agente** (`puedeEscribirRuta`), que es lo que hace
+ *    que la tool no conceda nada que el perfil no tuviera ya.
+ * 3. **El destino no es un sitio equivocado de artefacto** (`artefactoFueraDeSitio`): copiar
+ *    a `/artifacts/x.png` sería recrear dentro del proyecto justo lo que esa guarda impide.
+ *
+ * Y las dos rutas se comprueban **dos veces**, por TEXTO y por `realpath`, como en
+ * `arbolDeProyecto.ts` y en las escrituras de los motores externos: en APFS `.ENV` abre
+ * `.env`, y un enlace dentro de la raíz puede apuntar fuera. Lo que no se pueda comprobar
+ * se deniega.
+ */
+export declare const NOMBRE_COPIAR_ARTEFACTO = "copiar_artefacto";
+export interface DondeCopiar {
+    /** La raíz REAL del proyecto en disco. */
+    raiz: string;
+    /** La carpeta REAL de artefactos de esta sesión. */
+    carpetaDeArtefactos: string;
+    /** De quién son los permisos que hay que reaplicar. */
+    perfil: QuienDecidePermisos;
+}
+export declare function crearCopiarArtefacto(donde: DondeCopiar): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    artefacto: z.ZodString;
+    destino: z.ZodString;
+}, z.core.$strip>, {
+    artefacto: string;
+    destino: string;
+}, {
+    artefacto: string;
+    destino: string;
+}, string, unknown, "copiar_artefacto">;
+/** Para los tests: la ruta real que le tocaría a un destino virtual. */
+export declare function rutaRealDeDestino(raiz: string, destinoVirtual: string): string;

package/dist/agent/grafo/criticaVisual.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { type ImagenReferida } from "../../core/referenciasDeImagen.js";
+import { type MaquetaMedida } from "../../core/geometriaDePantalla.js";
+import { type PantallaDescrita } from "../../core/descripcionDePantalla.js";
+import type { ImagenRgba } from "../../core/compararCapturas.js";
+import { type CapturaDePantalla, type InvocarVisual } from "../dispositivos/juezVisual.js";
+export interface DependenciasDeCritica {
+    /** Los bytes de un artefacto, por su NOMBRE. Quien la monta sabe dónde está la carpeta. */
+    leerArtefacto: (nombre: string) => Promise<Buffer>;
+    invocar: InvocarVisual;
+    /**
+     * Lee la MAQUETA de donde esté: `/artefactos/`, `/adjuntos/` o el proyecto
+     * (`core/referenciasDeImagen.ts`). Ausente, la referencia solo puede venir de `/artefactos/`, como
+     * antes. La maqueta de un encargo casi nunca está ahí: la trae la persona en el chat o vive en
+     * `/diseno/`, y sin esto el crítico corría a ciegas y su verde significaba solo «nada roto».
+     */
+    leerReferencia?: (imagen: ImagenReferida) => Promise<Buffer>;
+    /**
+     * La GEOMETRÍA guardada con la captura (`<captura>.geometria.json`, que deja `xone-captura-android`
+     * o `xone-hotswap shot` en `/hotswap/` en el MISMO momento): el árbol de controles y las barras del
+     * sistema. `undefined` = no hay. Ausente la dependencia, el crítico trabaja como antes.
+     */
+    leerGeometria?: (nombreDeCaptura: string) => Promise<unknown>;
+    /**
+     * Las cajas de la maqueta, si trae `code.html` al lado (la de Stitch): `undefined` = no hay HTML (una
+     * maqueta que es solo un PNG); `{motivo}` = lo hay y no se pudo medir.
+     */
+    cajasDeMaqueta?: (imagen: ImagenReferida, bytes: Buffer) => Promise<MaquetaMedida | {
+        motivo: string;
+    } | undefined>;
+    /**
+     * Una pantalla DESCRITA por el modelo mirándola SOLA, primero su geometría y después el estilo de cada control,
+     * con el MISMO esquema para la maqueta y para la captura (`core/descripcionDePantalla.ts`,
+     * `juezVisual.ts#describirPantalla`). A la captura se le pasan los controles que existen, del árbol.
+     * `undefined` = no se entendió. Ausente la dependencia, el crítico trabaja como antes.
+     */
+    describirPantalla?: (imagen: CapturaDePantalla, controlesQueExisten?: readonly string[]) => Promise<PantallaDescrita | undefined>;
+    /**
+     * Saca los píxeles de un PNG o un JPEG (`decodificarImagen`). Con ella, el estilo de cada control se MIDE en su
+     * caja (`core/estiloMedido.ts`) en vez de pedírselo a un modelo. Ausente, no hay comparación control a control.
+     */
+    decodificar?: (bytes: Buffer) => ImagenRgba;
+    /** Guarda el informe junto a la captura (`<captura>.critica.txt` en `/hotswap/`), para poder auditar qué se dijo. */
+    guardarInforme?: (nombreDeCaptura: string, informe: string) => Promise<void>;
+}
+/** La tabla de traducción de Tailwind a XOne de la skill, por su ruta virtual. */
+export declare const TABLA_DE_TRADUCCION = "`read_file /skills/xone-development/references/css/de-una-maqueta-a-xone.md`";
+export declare function crearCriticaVisual(deps: DependenciasDeCritica): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    captura: z.ZodString;
+    pantalla: z.ZodString;
+    referencia: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    captura: string;
+    pantalla: string;
+    referencia?: string | undefined;
+}, {
+    captura: string;
+    pantalla: string;
+    referencia?: string | undefined;
+}, string, unknown, "xone_critica_visual">;