@axzydev/axzy_ui_system 1.7.3 → 1.7.4

package/src/json-renderer/routing/routes.ts

@@ -0,0 +1,179 @@
+/**
+ * Contrato de rutas declarativas: un `routes.json` describe qué pantalla pinta cada
+ * dirección, con qué parámetros y query, y qué entradas aparecen en la navegación.
+ *
+ * Como el resto del motor, es entrada no confiable: no hay código ni URLs externas,
+ * solo nombres de pantalla (`page`) que el host resuelve. Las rutas con `children`
+ * son grupos (agrupan entradas de menú); solo las hojas se pueden pintar.
+ */
+
+import { issue, type JsonEngineIssue } from "../shared/errors";
+import type { SchemaValue } from "../kernel/types";
+
+/** Entrada de menú asociada a una ruta. Sin `nav`, la ruta existe pero no se muestra. */
+export interface RouteNavSchema {
+  /** Texto de la entrada; admite `{ i18n }`. */
+  label: SchemaValue;
+  /** Nombre de icono del registro del host. */
+  icon?: string;
+  /** Contador visible junto a la entrada. */
+  badge?: number | string;
+}
+
+/** Ruta tal como la escribe el JSON. */
+export interface RouteSchema {
+  /** Identificador estable: lo usa la navegación para marcar la entrada activa. */
+  id: string;
+  /**
+   * Segmentos de la ruta, relativos al padre (`usuarios`, `:id`). Los hijos sin `path`
+   * heredan el del padre. Las rutas raíz empiezan por `/`.
+   */
+  path?: string;
+  /** Pantalla JSON que pinta la ruta. Obligatoria en las hojas; prohibida en los grupos. */
+  page?: string;
+  /** Query que exige la ruta (`{ estado: "Activo" }`). Más claves = más específica. */
+  query?: Record<string, string>;
+  /** Entrada de menú. */
+  nav?: RouteNavSchema;
+  /** Rutas hijas. Si existen, la ruta es un grupo. */
+  children?: RouteSchema[];
+}
+
+/** Documento de rutas completo. */
+export interface RoutesSchema {
+  /** Identificador del formato. */
+  $schema?: "axzy/routes";
+  /** Versión del formato. */
+  version: number;
+  /** Rutas raíz. */
+  routes: RouteSchema[];
+}
+
+/** Ruta aplanada y lista para casarla: solo hojas, con su path completo. */
+export interface FlatRoute {
+  /** Identificador de la ruta. */
+  id: string;
+  /** Segmentos completos, sin barras (`["usuarios", ":id"]`). Vacío para la raíz. */
+  segments: string[];
+  /** Pantalla que pinta. */
+  page: string;
+  /** Query que exige la ruta. */
+  query: Record<string, string>;
+  /** Entrada de menú, si la tiene. */
+  nav?: RouteNavSchema;
+  /** Ids de los grupos a los que pertenece, de fuera a dentro. */
+  groups: string[];
+}
+
+/** Une un path de padre con el propio y normaliza las barras. */
+export function joinRoutePath(parent: string, own: unknown): string {
+  return [parent, typeof own === "string" ? own : ""]
+    .flatMap((part) => part.split("/"))
+    .filter((segment) => segment !== "")
+    .join("/");
+}
+
+/** Segmentos válidos: letras, dígitos, guiones, puntos o `:param`. */
+const SEGMENT = /^(:[A-Za-z][A-Za-z0-9_]*|[A-Za-z0-9_.-]+)$/;
+
+/**
+ * Valida un documento de rutas. Nunca lanza: devuelve los avisos con su código y su ruta.
+ *
+ * @example
+ * validateRoutes({ version: 1, routes: [{ id: "inicio", path: "/inicio", page: "inicio" }] }); // []
+ */
+export function validateRoutes(input: unknown): JsonEngineIssue[] {
+  const errors: JsonEngineIssue[] = [];
+  const document = input as Partial<RoutesSchema> | null | undefined;
+
+  if (!document || typeof document !== "object" || Array.isArray(document)) {
+    return [issue("JR020", "El documento de rutas debe ser un objeto.", "", { severity: "error" })];
+  }
+  if (typeof document.version !== "number") {
+    errors.push(issue("JR020", "El documento de rutas no declara `version`.", "version", { severity: "error" }));
+  }
+  if (!Array.isArray(document.routes)) {
+    errors.push(issue("JR020", "`routes` debe ser una lista.", "routes", { severity: "error" }));
+    return errors;
+  }
+
+  const seen = new Map<string, string>();
+
+  const visit = (route: RouteSchema, path: string, parentPath: string, isRoot: boolean) => {
+    if (!route || typeof route !== "object") {
+      errors.push(issue("JR021", "La ruta no es un objeto.", path, { severity: "error" }));
+      return;
+    }
+    if (typeof route.id !== "string" || route.id === "") {
+      errors.push(issue("JR021", "La ruta no declara `id`.", path, { severity: "error" }));
+    }
+    if (route.path !== undefined && route.path !== "") {
+      const parts = typeof route.path === "string" ? route.path.split("/").filter(Boolean) : [];
+      if (typeof route.path !== "string" || parts.some((segment) => !SEGMENT.test(segment))) {
+        errors.push(issue("JR021", `El path "${String(route.path)}" no es válido.`, `${path}.path`, { severity: "error", hint: "Usa segmentos con letras, dígitos, guiones o `:param`." }));
+      }
+    }
+
+    const full = joinRoutePath(parentPath, route.path);
+    if (isRoot && full === "") {
+      errors.push(issue("JR021", "Una ruta raíz necesita `path`.", `${path}.path`, { severity: "error" }));
+    }
+
+    if (route.children !== undefined) {
+      if (route.page !== undefined) {
+        errors.push(issue("JR020", "Un grupo no lleva `page`: la pantalla va en sus hijos.", path, { severity: "error" }));
+      }
+      if (!Array.isArray(route.children)) {
+        errors.push(issue("JR020", "`children` debe ser una lista.", `${path}.children`, { severity: "error" }));
+      } else {
+        route.children.forEach((child, index) => visit(child, `${path}.children[${index}]`, full, false));
+      }
+    } else {
+      if (typeof route.page !== "string" || route.page === "") {
+        errors.push(issue("JR020", "La ruta no declara `page`.", path, { severity: "error" }));
+      }
+      const key = `${full}?${JSON.stringify(Object.entries(route.query ?? {}).sort())}`;
+      if (seen.has(key)) {
+        errors.push(issue("JR020", `La ruta "${full || "/"}" se repite con la misma query (ya está en ${seen.get(key)}).`, path, { severity: "error" }));
+      } else {
+        seen.set(key, path);
+      }
+    }
+
+    const nav = route.nav as Partial<RouteNavSchema> | null | undefined;
+    if (nav !== undefined && (typeof nav !== "object" || nav === null || nav.label === undefined || nav.label === null)) {
+      errors.push(issue("JR021", "La entrada de menú no declara `label`.", `${path}.nav`, { severity: "error" }));
+    }
+  };
+
+  document.routes.forEach((route, index) => visit(route, `routes[${index}]`, "", true));
+  return errors;
+}
+
+/**
+ * Aplana las rutas en hojas con su path completo. Asume un documento válido
+ * (ver `validateRoutes`); las ramas sin `page` se descartan.
+ */
+export function flattenRoutes(routes: RouteSchema[]): FlatRoute[] {
+  const flat: FlatRoute[] = [];
+
+  const visit = (route: RouteSchema, parentPath: string, groups: string[]) => {
+    const full = joinRoutePath(parentPath, route.path);
+    if (route.children) {
+      route.children.forEach((child) => visit(child, full, [...groups, route.id]));
+      return;
+    }
+    if (typeof route.page !== "string") return;
+    flat.push({
+      id: route.id,
+      segments: full === "" ? [] : full.split("/"),
+      page: route.page,
+      query: route.query ?? {},
+      nav: route.nav,
+      groups,
+    });
+  };
+
+  routes.forEach((route) => visit(route, "", []));
+  return flat;
+}

package/src/json-renderer/routing/routing.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it } from "vitest";
+import { validateRoutes, flattenRoutes, type RouteSchema } from "./routes";
+import { matchRoute, routeHref } from "./match";
+import { buildNavigationTree, navContainsRoute } from "./navigation";
+
+/** Documento de ejemplo con la forma del demo: grupos con sub-items y una ruta con parámetro. */
+const rutas: RouteSchema[] = [
+  { id: "inicio", path: "/inicio", page: "inicio", nav: { label: { i18n: "nav.inicio" }, icon: "home" } },
+  {
+    id: "usuarios",
+    path: "/usuarios",
+    nav: { label: { i18n: "nav.usuarios" }, icon: "users" },
+    children: [
+      { id: "u-todos", page: "usuarios", nav: { label: { i18n: "sub.todos" } } },
+      { id: "u-activos", page: "usuarios", query: { estado: "Activo" }, nav: { label: { i18n: "sub.activos" } } },
+    ],
+  },
+  { id: "usuario-nuevo", path: "/usuarios/nuevo", page: "usuario-form" },
+  { id: "usuario-detalle", path: "/usuarios/:id", page: "usuario-detalle" },
+  {
+    id: "pedidos",
+    path: "/pedidos",
+    nav: { label: { i18n: "nav.pedidos" }, icon: "cart", badge: 11 },
+    children: [{ id: "p-todos", page: "pedidos", nav: { label: { i18n: "sub.todos" } } }],
+  },
+];
+
+describe("validateRoutes", () => {
+  it("un documento correcto no tiene avisos", () => {
+    expect(validateRoutes({ version: 1, routes: rutas })).toEqual([]);
+  });
+
+  it("no lanza con entradas malformadas y devuelve avisos con código", () => {
+    expect(validateRoutes(null)[0]).toMatchObject({ code: "JR020" });
+    expect(validateRoutes({ routes: [] })[0]).toMatchObject({ code: "JR020", path: "version" });
+    expect(validateRoutes({ version: 1, routes: "x" })[0]).toMatchObject({ code: "JR020", path: "routes" });
+    expect(() => validateRoutes({ version: 1, routes: [null, { id: "x", path: 5, page: "p" }] })).not.toThrow();
+  });
+
+  it("avisa de una hoja sin page y de un grupo con page", () => {
+    const errores = validateRoutes({
+      version: 1,
+      routes: [
+        { id: "a", path: "/a" },
+        { id: "b", path: "/b", page: "b", children: [{ id: "b1", page: "b1" }] },
+      ],
+    });
+    expect(errores.map((e) => e.code)).toEqual(["JR020", "JR020"]);
+  });
+
+  it("avisa de rutas duplicadas con la misma query y permite la misma ruta con query distinta", () => {
+    const duplicadas = validateRoutes({
+      version: 1,
+      routes: [
+        { id: "a", path: "/a", page: "a" },
+        { id: "a2", path: "/a", page: "a" },
+      ],
+    });
+    expect(duplicadas[0]).toMatchObject({ code: "JR020" });
+
+    const distintas = validateRoutes({
+      version: 1,
+      routes: [
+        { id: "a", path: "/a", page: "a" },
+        { id: "a-activo", path: "/a", page: "a", query: { estado: "Activo" } },
+      ],
+    });
+    expect(distintas).toEqual([]);
+  });
+
+  it("valida segmentos, la raíz y las etiquetas de menú", () => {
+    expect(validateRoutes({ version: 1, routes: [{ id: "x", page: "x" }] })[0]).toMatchObject({ code: "JR021" });
+    expect(validateRoutes({ version: 1, routes: [{ id: "x", path: "/a b", page: "x" }] })[0]).toMatchObject({ code: "JR021" });
+    expect(validateRoutes({ version: 1, routes: [{ id: "x", path: "/x", page: "x", nav: {} }] })[0]).toMatchObject({ code: "JR021" });
+  });
+});
+
+describe("flattenRoutes", () => {
+  it("aplana solo las hojas con su path completo y su query", () => {
+    const planas = flattenRoutes(rutas);
+    const activos = planas.find((ruta) => ruta.id === "u-activos");
+    expect(planas.some((ruta) => ruta.id === "usuarios")).toBe(false);
+    expect(activos).toMatchObject({ segments: ["usuarios"], page: "usuarios", query: { estado: "Activo" }, groups: ["usuarios"] });
+  });
+});
+
+describe("matchRoute", () => {
+  const planas = flattenRoutes(rutas);
+
+  it("un segmento estático gana a un :param en la misma posición", () => {
+    expect(matchRoute(planas, ["usuarios", "nuevo"])?.route.id).toBe("usuario-nuevo");
+    expect(matchRoute(planas, ["usuarios", "42"])).toMatchObject({ route: { id: "usuario-detalle" }, params: { id: "42" } });
+  });
+
+  it("la query elige la ruta más específica y la ruta base sirve para el resto", () => {
+    expect(matchRoute(planas, ["usuarios"], { estado: "Activo" })?.route.id).toBe("u-activos");
+    expect(matchRoute(planas, ["usuarios"], { estado: "Inactivo" })?.route.id).toBe("u-todos");
+    expect(matchRoute(planas, ["usuarios"])?.route.id).toBe("u-todos");
+  });
+
+  it("devuelve null cuando nada casa", () => {
+    expect(matchRoute(planas, ["no-existe"])).toBeNull();
+    expect(matchRoute(planas, ["usuarios", "1", "extra"])).toBeNull();
+  });
+
+  it("la raíz casa con la ruta vacía", () => {
+    const raiz = flattenRoutes([{ id: "raiz", path: "/", page: "inicio" }]);
+    expect(matchRoute(raiz, [])?.route.id).toBe("raiz");
+  });
+});
+
+describe("routeHref", () => {
+  it("rellena los :param y codifica la query", () => {
+    const detalle = flattenRoutes(rutas).find((ruta) => ruta.id === "usuario-detalle")!;
+    expect(routeHref(detalle, { id: "42" })).toBe("/usuarios/42");
+    const activos = flattenRoutes(rutas).find((ruta) => ruta.id === "u-activos")!;
+    expect(routeHref(activos)).toBe("/usuarios?estado=Activo");
+  });
+});
+
+describe("buildNavigationTree", () => {
+  const arbol = buildNavigationTree(rutas);
+
+  it("solo entran las rutas con nav, y los grupos llevan a su primera hija", () => {
+    expect(arbol.map((entrada) => entrada.id)).toEqual(["inicio", "usuarios", "pedidos"]);
+    const usuarios = arbol[1];
+    expect(usuarios.href).toBe("/usuarios");
+    expect(usuarios.children?.map((hijo) => hijo.href)).toEqual(["/usuarios", "/usuarios?estado=Activo"]);
+  });
+
+  it("conserva etiqueta, icono y contador tal como los declara el JSON", () => {
+    expect(arbol[0]).toMatchObject({ label: { i18n: "nav.inicio" }, icon: "home", href: "/inicio" });
+    expect(arbol[2]).toMatchObject({ badge: 11 });
+  });
+
+  it("un grupo sin nav no aparece: sus hijos suben de nivel", () => {
+    const sinGrupo = buildNavigationTree([
+      { id: "seccion", children: [{ id: "a", path: "/a", page: "a", nav: { label: "A" } }] },
+    ]);
+    expect(sinGrupo.map((entrada) => entrada.id)).toEqual(["a"]);
+  });
+
+  it("navContainsRoute encuentra la ruta activa dentro de un grupo", () => {
+    expect(navContainsRoute(arbol[1], "u-activos")).toBe(true);
+    expect(navContainsRoute(arbol[1], "pedidos")).toBe(false);
+  });
+});

package/src/json-renderer/seguridad.test.tsx

@@ -0,0 +1,299 @@
+/**
+ * Batería de seguridad y adversaria del motor.
+ *
+ * Cada caso de la tabla de `docs/json-renderer/SEGURIDAD.md` tiene su prueba aquí. Lo que
+ * el esquema intenta (inyectar HTML, pedir red, montar componentes arbitrarios, colgar
+ * una acción, romper el stream) tiene que quedar contenido: la pantalla sigue viva y el
+ * aviso aparece con su código.
+ */
+
+import React from "react";
+import { describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen as testingScreen, waitFor } from "@testing-library/react";
+import { ITSchemaRenderer } from "./kernel/SchemaRenderer";
+import type { JsonEngineIssue } from "./shared/errors";
+import type { NodeSchema, ScreenSchema } from "./kernel/types";
+import { parsePartialSchema } from "./stream/tolerantParse";
+import { validateSchema } from "./validation/validate";
+
+/** Esquema mínimo con el contenido indicado. */
+const pantalla = (content: unknown, extra: Partial<ScreenSchema> = {}): ScreenSchema =>
+  ({ version: 1, id: "seguridad", content, ...extra }) as ScreenSchema;
+
+/** Acumula los avisos del renderizador. */
+function avisos() {
+  const lista: JsonEngineIssue[] = [];
+  return { lista, onIssue: (aviso: JsonEngineIssue) => lista.push(aviso) };
+}
+
+/** Códigos de los avisos recibidos. */
+const codigos = (lista: JsonEngineIssue[]) => lista.map((aviso) => aviso.code);
+
+describe("capacidades: requires se evalúa y se deniega por defecto", () => {
+  it("un nodo que exige una capacidad no concedida no se pinta y avisa con JR060", () => {
+    const { lista, onIssue } = avisos();
+    render(
+      <ITSchemaRenderer
+        schema={pantalla([
+          { type: "ITText", text: "secreto", requires: "usuarios.leer" },
+          { type: "ITText", text: "publico" },
+        ])}
+        onIssue={onIssue}
+      />
+    );
+    expect(testingScreen.queryByText("secreto")).toBeNull();
+    expect(testingScreen.getByText("publico")).toBeTruthy();
+    expect(codigos(lista)).toContain("JR060");
+  });
+
+  it("con la capacidad concedida, el nodo se pinta", () => {
+    render(
+      <ITSchemaRenderer
+        schema={pantalla([{ type: "ITText", text: "secreto", requires: ["usuarios.leer"] }])}
+        capabilities={["usuarios.leer"]}
+      />
+    );
+    expect(testingScreen.getByText("secreto")).toBeTruthy();
+  });
+
+  it("sin capabilities, cualquier requires se deniega aunque el nombre sea razonable", () => {
+    render(<ITSchemaRenderer schema={pantalla([{ type: "ITText", text: "x", requires: "admin" }])} />);
+    expect(testingScreen.queryByText("x")).toBeNull();
+  });
+
+  it("un nodo denegado con fallback pinta el fallback en su lugar", () => {
+    render(
+      <ITSchemaRenderer
+        schema={pantalla([
+          {
+            type: "ITText",
+            text: "privado",
+            requires: "admin",
+            fallback: { type: "ITText", text: "sin permiso" },
+          } as NodeSchema,
+        ])}
+      />
+    );
+    expect(testingScreen.queryByText("privado")).toBeNull();
+    expect(testingScreen.getByText("sin permiso")).toBeTruthy();
+  });
+
+  it("una pantalla que exige una capacidad no concedida no se pinta y avisa en la raíz", () => {
+    const { lista, onIssue } = avisos();
+    const { container } = render(
+      <ITSchemaRenderer
+        schema={pantalla({ type: "ITText", text: "contenido" }, { requires: "admin" })}
+        onIssue={onIssue}
+      />
+    );
+    expect(container.textContent).toBe("");
+    expect(lista.find((aviso) => aviso.code === "JR060")?.path).toBe("requires");
+  });
+
+  it("requires con valores basura no rompe ni concede nada", () => {
+    render(<ITSchemaRenderer schema={pantalla([{ type: "ITText", text: "x", requires: 42 as never }])} />);
+    expect(testingScreen.queryByText("x")).toBeNull();
+  });
+});
+
+describe("acciones sin handler: JR040 en vez de no hacer nada en silencio", () => {
+  it("un botón con una acción no registrada avisa con JR040 y no rompe", () => {
+    const { lista, onIssue } = avisos();
+    render(
+      <ITSchemaRenderer
+        schema={pantalla({ type: "ITButton", props: { label: "Ir", onClick: { action: "no-existe" } } })}
+        resolveAction={() => undefined}
+        onIssue={onIssue}
+      />
+    );
+    expect(testingScreen.getByRole("button", { name: "Ir" })).toBeTruthy();
+    expect(lista.some((aviso) => aviso.code === "JR040" && aviso.message.includes("no-existe"))).toBe(true);
+  });
+
+  it("un formulario cuyo onSubmit no está registrado avisa con JR040", () => {
+    const { lista, onIssue } = avisos();
+    render(
+      <ITSchemaRenderer
+        schema={pantalla({
+          type: "form",
+          props: { fields: [{ name: "a" }], onSubmit: { action: "enviar-nada" } },
+        })}
+        resolveAction={() => undefined}
+        onIssue={onIssue}
+      />
+    );
+    expect(codigos(lista)).toContain("JR040");
+  });
+});
+
+describe("fuentes de datos: nunca pedir red", () => {
+  it("una fuente que declara url se rechaza con JR031 y no llama a ningún handler", async () => {
+    const handler = vi.fn(() => []);
+    const { lista, onIssue } = avisos();
+    const esquema = pantalla(
+      {
+        type: "ITDataTable",
+        props: {
+          columns: [{ key: "a", label: "A", type: "string" }],
+          fetchData: { $source: "remota" },
+        },
+      },
+      { data: { remota: { handler: "lista", url: "https://evil.example/datos" } as never } }
+    );
+
+    render(<ITSchemaRenderer schema={esquema} dataHandlers={{ lista: handler }} onIssue={onIssue} />);
+
+    await waitFor(() => expect(lista.some((aviso) => aviso.code === "JR031")).toBe(true));
+    expect(handler).not.toHaveBeenCalled();
+  });
+});
+
+describe("acciones colgadas: JR041 y onError", () => {
+  it("una acción que no responde en el tiempo límite cuenta como fallida: onError y JR041", async () => {
+    const toast = vi.fn();
+    const { lista, onIssue } = avisos();
+    const colgada = () => new Promise<void>(() => undefined);
+
+    render(
+      <ITSchemaRenderer
+        schema={pantalla({
+          type: "ITButton",
+          props: {
+            label: "Guardar",
+            onClick: {
+              action: "guardar",
+              onError: { toast: { variant: "error", message: "Tiempo agotado" } },
+            },
+          },
+        })}
+        resolveAction={() => colgada}
+        effects={{ toast }}
+        limits={{ actionTimeoutMs: 20 }}
+        onIssue={onIssue}
+      />
+    );
+
+    fireEvent.click(testingScreen.getByRole("button", { name: "Guardar" }));
+
+    await waitFor(() => expect(toast).toHaveBeenCalledWith({ variant: "error", message: "Tiempo agotado" }));
+    await waitFor(() => expect(codigos(lista)).toContain("JR041"));
+  });
+});
+
+describe("batería adversaria: lo que el esquema intenta, contenido", () => {
+  it("un tipo fuera del catálogo avisa con JR010 y el resto de la pantalla se pinta", () => {
+    const { lista, onIssue } = avisos();
+    render(
+      <ITSchemaRenderer
+        schema={pantalla([
+          { type: "ITComponenteInventado", text: "x" },
+          { type: "ITText", text: "resto" },
+        ])}
+        onIssue={onIssue}
+      />
+    );
+    expect(codigos(lista)).toContain("JR010");
+    expect(testingScreen.getByText("resto")).toBeTruthy();
+  });
+
+  it("dangerouslySetInnerHTML se descarta con JR011 y nunca llega al DOM como HTML", () => {
+    const { lista, onIssue } = avisos();
+    const { container } = render(
+      <ITSchemaRenderer
+        schema={pantalla({
+          type: "ITText",
+          text: "seguro",
+          props: { dangerouslySetInnerHTML: { __html: "<img src=x onerror=alert(1)>" } },
+        })}
+        onIssue={onIssue}
+      />
+    );
+    expect(container.querySelector("img")).toBeNull();
+    expect(codigos(lista)).toContain("JR011");
+  });
+
+  it("HTML dentro de un texto se muestra como texto, no se interpreta", () => {
+    const { container } = render(
+      <ITSchemaRenderer schema={pantalla({ type: "ITText", text: "<img src=x onerror=alert(1)>" })} />
+    );
+    expect(container.querySelector("img")).toBeNull();
+    expect(container.textContent).toContain("<img src=x onerror=alert(1)>");
+  });
+
+  it("una expresión en un texto no se ejecuta", () => {
+    render(<ITSchemaRenderer schema={pantalla({ type: "ITText", text: "{{7*7}}" })} />);
+    expect(testingScreen.getByText("{{7*7}}")).toBeTruthy();
+  });
+
+  it("un esquema que supera el presupuesto de nodos se recorta con JR013", () => {
+    const { lista, onIssue } = avisos();
+    const muchos = Array.from({ length: 200 }, (_, index) => ({ type: "ITText", text: `n${index}` }));
+    render(<ITSchemaRenderer schema={pantalla(muchos)} limits={{ maxNodes: 50 }} onIssue={onIssue} />);
+    expect(codigos(lista)).toContain("JR013");
+    expect(testingScreen.queryByText("n199")).toBeNull();
+  });
+
+  it("un handler de datos que lanza no tumba la pantalla", async () => {
+    const { lista, onIssue } = avisos();
+    const roto = () => {
+      throw new Error("boom");
+    };
+    render(
+      <ITSchemaRenderer
+        schema={pantalla(
+          { type: "ITText", text: "sigue viva" },
+          { data: { x: { handler: "roto" } } }
+        )}
+        dataHandlers={{ roto }}
+        onIssue={onIssue}
+      />
+    );
+    expect(testingScreen.getByText("sigue viva")).toBeTruthy();
+    expect(lista).toEqual(expect.any(Array));
+  });
+
+  it("un slot que lanza queda aislado con JR012 y el resto sigue", () => {
+    const { lista, onIssue } = avisos();
+    const Roto = () => {
+      throw new Error("slot roto");
+    };
+    const errorConsola = vi.spyOn(console, "error").mockImplementation(() => undefined);
+    render(
+      <ITSchemaRenderer
+        schema={pantalla([
+          { type: "slot", props: { name: "roto" } },
+          { type: "ITText", text: "resto" },
+        ])}
+        slots={{ roto: Roto }}
+        onIssue={onIssue}
+      />
+    );
+    expect(testingScreen.getByText("resto")).toBeTruthy();
+    expect(codigos(lista)).toContain("JR012");
+    errorConsola.mockRestore();
+  });
+});
+
+describe("streams adversarios: JSON a medias o con basura", () => {
+  it("un stream cortado a la mitad devuelve un árbol pintable y veredicto partial", () => {
+    const { tree } = parsePartialSchema('{"version":1,"id":"x","content":{"type":"ITText","text":"hola"');
+    expect(() => validateSchema(tree)).not.toThrow();
+    expect(validateSchema(tree).verdict).toBe("partial");
+  });
+
+  it("basura intercalada no lanza y conserva lo que sí es válido", () => {
+    expect(() =>
+      parsePartialSchema('{"version":1,"id":"x","content":[{"type":"ITText","text":"a"}, @@@ basura {{ , {"type":"ITText","text":"b"}]}')
+    ).not.toThrow();
+  });
+
+  it("un stream que nunca cierra no bloquea y deja la pantalla en partial", () => {
+    const { tree } = parsePartialSchema('{"version":1,"id":"x","content":{"type":"ITText","text":"ho');
+    expect(validateSchema(tree).verdict).not.toBe("invalid");
+  });
+
+  it("texto vacío o basura pura devuelven un árbol vacío sin lanzar", () => {
+    expect(() => parsePartialSchema("")).not.toThrow();
+    expect(() => parsePartialSchema("}}}]]]")).not.toThrow();
+  });
+});

package/src/json-renderer/shared/errors.ts

@@ -22,6 +22,7 @@ export type JsonEngineCode =
   | "JR021" // nodo inválido (forma o `type` ausente)
   | "JR030" // fuente de datos sin handler registrado
   | "JR031" // el esquema intenta provocar red (prohibido)
+  | "JR032" // referencia sin valor o operador de binding no soportado todavía
   | "JR040" // acción no registrada
   | "JR041" // acción excedió su timeout
   | "JR042" // encadenado de efectos demasiado profundo

package/src/json-renderer/stream/tolerantParse.ts

@@ -15,6 +15,7 @@
  */
 
 import type { NodeSchema, NodeStatus, ScreenSchema } from "../kernel/types";
+import type { JsonEngineIssue } from "../shared/errors";
 
 /** Resultado de parsear un texto posiblemente incompleto. */
 export interface PartialParseResult {
@@ -441,6 +442,10 @@ export interface StreamState {
   pendingNodes: number;
   /** `true` cuando el emisor está activo. */
   streaming: boolean;
+  /** Texto acumulado hasta ahora. */
+  text: string;
+  /** Avisos del stream (`JR080`: falló, o terminó sin cerrar el JSON). */
+  issues: JsonEngineIssue[];
 }
 
 /** `true` cuando un nodo está pendiente según el parser. */