xonecode 0.8.26 → 0.8.36

package/skills/xone-hotswap/scripts/xone-captura-android

@@ -2,7 +2,7 @@
 /**
  * Una captura de la pantalla del aparato, POR LA VÍA NATIVA, a la carpeta de artefactos.
  *
- * POR QUÉ EXISTE, si el canal ya sabe capturar. `xone-hotswap '{"command":"getScreenshot"}'`
+ * POR QUÉ EXISTE, si el canal ya sabe capturar. `xone-hotswap shot`
  * es la vía buena —la pide la app host, así que sale lo que la app pinta— pero necesita el
  * túnel y la app viva. Cuando eso no está, lo único que queda es `adb exec-out screencap`, y
  * medido: el modelo la compone él y redirige la salida a un fichero, que en el `cwd` de la
@@ -35,7 +35,7 @@ if (args.includes("--help") || args.includes("-h")) {
   xone-captura-android --serie <id>           con varios aparatos conectados
 
 Es la vía de RESPALDO: si el túnel y la app host están vivos, la buena es
-\`xone-hotswap '{"command":"getScreenshot"}'\`, que captura lo que la app pinta.
+\`xone-hotswap shot\`, que captura lo que la app pinta.
 Nunca redirijas \`adb exec-out screencap\` a un fichero: el \`cwd\` es la raíz del
 proyecto del usuario y ahí no se escribe.`);
   process.exit(0);
@@ -58,7 +58,21 @@ const serie = opcion("serie");
 // `basename` y no la cadena tal cual: el nombre lo elige el modelo, y un `../` aquí escribiría
 // fuera de la carpeta de la sesión. Misma regla que `esRutaDeArtefacto` en el host.
 const pedido = opcion("nombre");
-const nombre = pedido === undefined ? `captura-${Date.now()}.png` : basename(pedido);
+/**
+ * **La EXTENSIÓN se pone si falta, y no es cosmética.**
+ *
+ * Medido en una sesión: el agente pidió `--nombre arranque_error` y el fichero quedó sin
+ * extensión. Lo que hizo después es el coste: **tres comandos más** —`file` para averiguar
+ * qué había bajado, `sips` para sus dimensiones y un `python3 -c "from PIL import Image…"`
+ * para intentar abrirlo—. Un artefacto sin extensión tampoco se sabe pintar: `mimeDeArtefacto`
+ * decide por la extensión y sin ella no afirma nada, así que la tarjeta del chat no lo enseña
+ * y el revisor visual no lo acepta.
+ *
+ * Se AÑADE en vez de rechazar: lo que el modelo quería está claro y un «no» aquí cuesta otro
+ * viaje para lo mismo.
+ */
+const conExtension = (n) => (/\.[A-Za-z0-9]{2,4}$/.test(n) ? n : `${n}.png`);
+const nombre = pedido === undefined ? `captura-${Date.now()}.png` : conExtension(basename(pedido));
 if (nombre === "" || nombre === "." || nombre === "..") {
   console.error("ese nombre no vale para un fichero.");
   process.exit(1);
@@ -82,6 +96,80 @@ if (bytes.length === 0) {
   process.exit(1);
 }
 
+/**
+ * **Si XOne ha reventado, el LOG basta y la captura sobra.**
+ *
+ * Visto tres veces en sesiones reales: la app no arranca, y quien diagnostica fotografía el
+ * diálogo de error. La foto es legítima —el diálogo ES el error— pero **lo mismo está en el
+ * log en texto**, con fichero, línea, columna y la línea culpable, y cuesta unas 50 fichas
+ * contra las **3.375** que cuesta una captura de 1080×2400 en el revisor visual. Setenta veces
+ * más por saber lo mismo.
+ *
+ * Así que no se captura: se enseña la excepción y se dice por qué. Con `--igualmente` se
+ * captura de todos modos, que para una comprobación VISUAL —algo cortado, algo tapado— sigue
+ * siendo la herramienta buena aunque haya una excepción por ahí.
+ *
+ * Se mira acotado al PROCESO (`--pid`) y no a las últimas N líneas del aparato: 600 líneas de
+ * todo son un par de minutos aquí, y la excepción se sale de esa ventana — el mismo fallo que
+ * tenía `xone-desplegar-android`.
+ */
+if (!args.includes("--igualmente")) {
+  let roto;
+  try {
+    const enElAparato = (...partes) =>
+      execFileSync("adb", [...(serie ? ["-s", serie] : []), ...partes], {
+        encoding: "utf8",
+        maxBuffer: 64 * 1024 * 1024,
+      });
+    const pid = enElAparato("shell", "pidof", "com.xone.android.framework").trim().split(/\s+/)[0];
+    if (pid) {
+      const log = enElAparato("logcat", "-d", "--pid", pid, "-t", "600");
+      const filas = log.split("\n");
+      const i = filas.findIndex((l) => l.includes("XOneJavascriptException"));
+      if (i >= 0) {
+        roto = filas
+          .slice(i, i + 12)
+          .map((l) => l.replace(/^.*?\bSystem\.err:\s?/, "").trim())
+          .filter((l) => l !== "" && !l.startsWith("at "))
+          .slice(0, 6)
+          .join("\n");
+      }
+    }
+  } catch {
+    // Sin log no hay nada que objetar: se captura.
+  }
+  /**
+   * **Y si NO hay error, se dice también.** Es la otra mitad de la misma regla: si el log no
+   * da excepción y la app contesta en qué colección está, no hay nada que diagnosticar en una
+   * foto — y capturar «por si acaso» es el caso que más se repite. No se BLOQUEA, porque
+   * comprobar algo VISUAL sobre una app sana es legítimo y es para lo que la captura sirve;
+   * lo que se hace es decirle a quien la pidió lo que ya se sabe, para que no la pida por
+   * costumbre.
+   */
+  if (roto === undefined) {
+    try {
+      const cliente = join(import.meta.dirname, "xone-hotswap");
+      const donde = execFileSync("node", [cliente, "screen"], { encoding: "utf8" }).trim();
+      const m = /\\"collection\\":\\"([^\\"]+)/.exec(donde);
+      if (m) {
+        console.log(`(el log no da error y la app responde en «${m[1]}»: si buscabas un fallo,`);
+        console.log(" no lo hay. Capturo igual, que para lo VISUAL es la herramienta buena.)");
+      }
+    } catch {
+      // Sin canal no se puede decir nada del estado: se captura y ya.
+    }
+  }
+  if (roto !== undefined) {
+    console.log("NO capturo: XOne reventó al cargar y eso ya está en el log, en texto:");
+    console.log("");
+    console.log(roto);
+    console.log("");
+    console.log("Ahí tienes fichero, línea y columna. Una captura del diálogo diría lo mismo");
+    console.log("y cuesta ~3.375 fichas. Si de verdad quieres la imagen: --igualmente.");
+    process.exit(0);
+  }
+}
+
 const destino = join(ARTEFACTOS, nombre);
 try {
   writeFileSync(destino, bytes);

package/skills/xone-hotswap/scripts/xone-desplegar-android

@@ -236,6 +236,26 @@ function concederPermisos() {
     console.log("    no se pudo leer qué permisos pide; sigo");
     return;
   }
+  /**
+   * **El de dibujar sobre otras apps NO se concede con `pm grant`, y sin él el arranque es una
+   * carrera contra el foco.**
+   *
+   * `SYSTEM_ALERT_WINDOW` es un appop, no un permiso de ejecución, así que el bucle de abajo lo
+   * intenta y falla en silencio con los demás. Y lo que concede no es cosmético: Android 10 y
+   * superiores BLOQUEAN que una app en segundo plano arranque una actividad, y ese permiso es la
+   * exención que reconocen. El framework se va a segundo plano con solo apagarse la pantalla, o
+   * en cuanto se cierra la app — así que sin esto `launchApplication` contesta
+   * «Cannot launch app while the framework is in the background» y el despliegue parece que
+   * funcionó sin que arrancara nada. Es buena parte del síntoma que teníamos apuntado como
+   * «`result:true` significa aceptado, no arrancó».
+   *
+   * Idempotente, y su fallo no para nada: en un aparato donde no aplique, se sigue.
+   */
+  try {
+    adbCallado("shell", "appops", "set", PAQUETE, "SYSTEM_ALERT_WINDOW", "allow");
+  } catch {
+    // Aparato que no lo admite. El despliegue sigue; lo que se pierde es la garantía de foco.
+  }
   let dados = 0;
   for (const permiso of declaradas) {
     try {
@@ -260,7 +280,24 @@ function concederPermisos() {
 function excepcionDeXOne() {
   let log;
   try {
-    log = adbCallado("logcat", "-d", "-t", "600");
+    /**
+     * **Acotado al PROCESO, no a las últimas N líneas del aparato.** Era `-t 600` a secas, y
+     * eso no es «lo último de la app»: son 600 líneas de TODO —Chromium, el sistema, lo que
+     * haya—, que en este emulador son un par de minutos. La excepción de XOne se salía de esa
+     * ventana enseguida, el despliegue no la veía y no contaba nada.
+     *
+     * Y lo que pasa después es el motivo de arreglarlo: sin el texto, a quien diagnostica solo
+     * le queda **fotografiar el diálogo de error** —visto en una sesión real—, que cuesta 3.375
+     * tokens y dice exactamente lo mismo que estas seis líneas.
+     *
+     * Con `--pid`, 600 líneas son 600 líneas DE LA APP. Es como ya leía `xone-log-android`;
+     * que dos sitios miraran el mismo log de forma distinta era la razón de que uno lo
+     * encontrara y el otro no.
+     */
+    const pid = adbCallado("shell", "pidof", PAQUETE).trim().split(/\s+/)[0];
+    log = pid
+      ? adbCallado("logcat", "-d", "--pid", pid, "-t", "600")
+      : adbCallado("logcat", "-d", "-t", "600");
   } catch {
     return undefined;
   }
@@ -340,8 +377,27 @@ function exigirAparato() {
 
   console.log("5/5 esperando al canal, lanzando y comprobando que está VIVA");
   const cliente = join(import.meta.dirname, "xone-hotswap");
-  const mandar = (comando) =>
-    execFileSync("node", [cliente, JSON.stringify(comando)], { encoding: "utf8" }).trim();
+  /**
+   * **En `clave=valor`, que es lo único que el cliente entiende.**
+   *
+   * Esto mandaba `JSON.stringify(comando)` y se rompió ENTERO el día que el cliente dejó de
+   * aceptar JSON: el objeto se metía como NOMBRE del comando, el aparato contestaba
+   * `Unknown command: {…}` y el despliegue no lanzaba nada. Lanzar la app, pedir el árbol y
+   * capturar —las tres cosas que hace este paso— pasaban por aquí, así que se cayeron las
+   * tres a la vez, y en silencio: el script reintenta diez veces y acaba diciendo que el
+   * canal no levantó, que manda a mirar el puerto y el paquete en vez de al cliente.
+   *
+   * La conversión es la misma que hace el cliente al revés: cada campo que no es `command`
+   * sale como `clave=valor`, y un objeto o un array se serializan porque el tipado del
+   * cliente los reconoce por la forma.
+   */
+  const mandar = (comando) => {
+    const { command, ...resto } = comando;
+    const pares = Object.entries(resto).map(([k, v]) =>
+      `${k}=${typeof v === "object" && v !== null ? JSON.stringify(v) : String(v)}`,
+    );
+    return execFileSync("node", [cliente, command, ...pares], { encoding: "utf8" }).trim();
+  };
   const esperar = (segundos) => execFileSync("sleep", [String(segundos)]);
 
   /**
@@ -380,18 +436,37 @@ function exigirAparato() {
        * hay que volver a preguntar. Tres órdenes encadenadas por el modelo son tres viajes;
        * ésta es una.
        */
-      if (args.includes("--captura")) {
+      /**
+       * **El log ANTES que la captura, y por un fallo visto en vivo.**
+       *
+       * El orden era al revés y producía una foto que engaña: la app contesta el árbol, se
+       * cae mientras se pide la captura, y lo que sale fotografiado es la **pantalla del
+       * propio servidor hotswap** —«Applications / MyAllXOne / Explore / Delete», con
+       * «Awaiting connection…» abajo—. Eso no es la app, y quien lo mire después no tiene
+       * forma de saberlo: parece una app en blanco. Ocurrió con un `--captura` real y el
+       * usuario lo cazó mirando el artefacto.
+       *
+       * Cuando XOne ha reventado al cargar, la respuesta entera está en el LOG y la captura
+       * solo añade ruido —y 3.375 tokens si alguien se la enseña al revisor visual—. Así que
+       * primero se mira el log; si reventó, se cuenta y NO se captura.
+       */
+      const roto = excepcionDeXOne();
+      if (args.includes("--captura") && roto === undefined) {
         try {
           console.log(mandar({ command: "getScreenshot" }));
         } catch {
           console.error("la app arrancó pero la captura falló; el árbol de arriba sí es bueno.");
         }
+      } else if (args.includes("--captura")) {
+        console.error(
+          "NO capturo: XOne reventó al cargar y lo que saldría en la foto es la pantalla del " +
+            "host, no tu app. Lo que pasó está en el log de aquí abajo.",
+        );
       }
       // **Estar VIVA no es estar BIEN.** Una app que revienta al cargar la configuración se
       // queda con su diálogo de error delante, y el canal contesta igual: el árbol llega, la
       // captura sale, y todo parece haber ido bien. Quien lo cuenta es el log, y no pedirlo
       // aquí obliga a que alguien se acuerde de hacerlo — que es justo lo que no pasa.
-      const roto = excepcionDeXOne();
       if (roto !== undefined) {
         console.error("");
         console.error("La app ARRANCÓ pero XOne lanzó una excepción al cargar:");

package/skills/xone-hotswap/scripts/xone-hotswap

@@ -95,9 +95,18 @@ if (pedidos.length === 0 || pedidos.includes("--help") || pedidos.includes("-h")
   // un viaje y deja al modelo adivinando argumentos.
   console.error(`xone-hotswap — manda comandos al servidor hotswap de la app (WebSocket).
 
-  xone-hotswap '{"command":"getAllElements","format":"xone"}'
-  xone-hotswap '{"command":"getScreenshot"}'           la captura va a $XONECODE_ARTEFACTOS
-  xone-hotswap '{"command":"click","name":"MAP_BT"}'   varios comandos, en orden, si pasas varios
+  xone-hotswap click name=MAP_BT
+  xone-hotswap waitForElement name=BTN_OK timeout=5000 -- click name=BTN_OK
+  xone-hotswap screen                        en qué pantalla estás (barato)
+  xone-hotswap elements                      el árbol de controles (va a $XONECODE_HOTSWAP)
+  xone-hotswap shot                          la captura va a $XONECODE_ARTEFACTOS
+  xone-hotswap shot name=MAP_ACEPTAR scale=0.5 quality=40     recortada a un control
+  xone-hotswap sql MiApp "SELECT * FROM CLIENTES LIMIT 20"
+
+Cada comando es "<nombre> clave=valor ..."; con -- se encadenan varios por la MISMA
+conexion, que es lo que hay que hacer (el servidor admite una sola y cierra la anterior).
+Los valores se tipan solos: número, true/false y {...}/[...] como JSON.
+Con --dry-run se imprime lo que se enviaría, sin conectar.
 
 Antes, en Android, hace falta el túnel: adb forward tcp:8443 tcp:8443
 Una respuesta larga no se imprime: una IMAGEN va a $XONECODE_ARTEFACTOS (y sale en el chat),
@@ -107,13 +116,124 @@ El catálogo entero de comandos está en el SKILL.md de xone-hotswap.`);
   process.exit(pedidos.length === 0 ? 1 : 0);
 }
 
+/**
+ * De `clave=valor` a los objetos del protocolo, con `--` separando comandos.
+ *
+ * **POR QUÉ SE FUE EL JSON.** Antes cada comando era un objeto JSON entre comillas
+ * (`'{"command":"click","name":"BTN_OK"}'`). Medido sobre cinco comandos típicos, esta
+ * sintaxis los escribe en un **38 % menos de caracteres** —un `click` pasa de 37 a 17— y
+ * quita el escapado, que es donde un modelo se equivoca y gasta un viaje en volver a
+ * intentarlo. No se aceptan las dos: una capa de compatibilidad es deuda desde el primer día,
+ * y el JSON solo se escribía dentro de esta misma skill.
+ *
+ * Los valores se TIPAN solos —número, `true`/`false`, y `{…}`/`[…]` como JSON— porque el
+ * protocolo distingue `timeout=5000` de `"5000"` y `where={"ID":"7"}` es un objeto. Lo que no
+ * encaje en ninguno se queda como cadena, que es lo que casi todo es.
+ */
+function valorTipado(bruto) {
+  if (bruto === "true") return true;
+  if (bruto === "false") return false;
+  if (bruto !== "" && !Number.isNaN(Number(bruto))) return Number(bruto);
+  if (/^[{[]/.test(bruto)) {
+    try {
+      return JSON.parse(bruto);
+    } catch {
+      salir(`«${bruto.slice(0, 60)}» empieza como JSON pero no lo es`);
+    }
+  }
+  return bruto;
+}
+
+/**
+ * Los ATAJOS, que existen para lo que si no cuesta dos viajes o un base64 a mano.
+ *
+ * Cada uno es exactamente un comando del protocolo con sus campos ya puestos: no añaden
+ * capacidades, quitan la parte que se escribe mal. `shot` es el que más se nota — decodifica
+ * el JPEG y lo deja donde el harness lo anuncia.
+ */
+const ATAJOS = {
+  elements: (resto) => ({ command: "getAllElements", format: resto[0] ?? "xone" }),
+  screen: () => ({ command: "getCurrentScreen" }),
+  shot: (resto) => aplicarPares({ command: "getScreenshot" }, resto),
+  tables: (resto) => ({ command: "getDatabaseTableNames", appName: resto[0] }),
+  sql: (resto) => ({ command: "runSql", appName: resto[0], sql: resto.slice(1).join(" ") }),
+};
+
+function aplicarPares(json, pares) {
+  for (const par of pares) {
+    const corte = par.indexOf("=");
+    if (corte <= 0) salir(`«${par}» no es clave=valor`);
+    json[par.slice(0, corte)] = valorTipado(par.slice(corte + 1));
+  }
+  return json;
+}
+
+/**
+ * `--dry-run`: imprime lo que se enviaría y no conecta.
+ *
+ * No es comodidad: es lo que hace comprobable el tipado de los valores sin un aparato
+ * delante —`timeout=5000` tiene que salir como número y `where={...}` como objeto, y si salen
+ * como cadena el servidor los rechaza sin decir por qué—. También deja probar un comando
+ * escrito a mano antes de gastarle un viaje al canal.
+ */
+const seco = pedidos.includes("--dry-run");
+const utiles = pedidos.filter((a) => a !== "--dry-run");
+
 const comandos = [];
-for (const arg of pedidos) {
-  try {
-    comandos.push(JSON.parse(arg));
-  } catch {
-    salir(`no es JSON válido: ${arg.slice(0, 80)}`);
+for (const trozo of partirPorSeparador(utiles)) {
+  const [cabeza, ...resto] = trozo;
+  /**
+   * **El JSON viejo se RECHAZA con la forma buena escrita, nunca se acepta a medias.**
+   *
+   * Al quitar el JSON, una llamada con la sintaxis de antes no fallaba: metía el objeto
+   * ENTERO como nombre del comando y mandaba
+   * `{"command":"{\"command\":\"getAllElements\",…}"}`. El aparato contestaba
+   * `Unknown command: {"command":"getAllElements","format":"xone"}` —visto en pantalla— y
+   * quien lo leyera no tenía forma de saber que el problema era la sintaxis del cliente y no
+   * el comando: parecía que el framework no conocía `getAllElements`. Un fallo que miente
+   * sobre dónde está invita a reintentar, y reintentar es lo que cuesta.
+   *
+   * No se ACEPTA —eso era la capa de compatibilidad que se decidió no tener— pero tampoco se
+   * traga: se dice qué escribir, que es el patrón de `porQueNo` y el de `xone_navegacion`
+   * cuando no sabe contestar.
+   */
+  if (cabeza.startsWith("{")) {
+    let comoJson;
+    try {
+      comoJson = JSON.parse(cabeza);
+    } catch {
+      comoJson = undefined;
+    }
+    const nombre = typeof comoJson?.command === "string" ? comoJson.command : undefined;
+    const pares = nombre
+      ? Object.entries(comoJson)
+          .filter(([k]) => k !== "command")
+          .map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : String(v)}`)
+          .join(" ")
+      : "";
+    salir(
+      `este cliente ya NO recibe JSON. Escríbelo como "<comando> clave=valor".` +
+        (nombre ? `\n  Lo que querías es:  xone-hotswap ${nombre}${pares ? ` ${pares}` : ""}` : "") +
+        `\n  Y con -- se encadenan varios por la misma conexión. Mira --help.`,
+    );
   }
+  const atajo = ATAJOS[cabeza];
+  comandos.push(atajo ? atajo(resto) : aplicarPares({ command: cabeza }, resto));
+}
+
+if (seco) {
+  for (const c of comandos) console.log(JSON.stringify(c));
+  process.exit(0);
+}
+
+/** Parte `a x=1 -- b y=2` en `[["a","x=1"],["b","y=2"]]`. Un `--` suelto no abre comando. */
+function partirPorSeparador(args) {
+  const trozos = [[]];
+  for (const a of args) {
+    if (a === "--") trozos.push([]);
+    else trozos[trozos.length - 1].push(a);
+  }
+  return trozos.filter((t) => t.length > 0);
 }
 
 
@@ -230,6 +350,29 @@ ws.onmessage = (ev) => {
     siguiente();
     return;
   }
+  /**
+   * **Las tramas PUSH no son la respuesta de nadie, y tragárselas DESINCRONIZA el canal.**
+   *
+   * El protocolo **no correla peticiones con respuestas**: no hay identificador de comando,
+   * así que se emparejan por ORDEN —se manda de uno en uno y se toma la siguiente trama que
+   * no sea un push—. Eso lo documenta el cliente del equipo del framework
+   * (`pack_ia/scripts/hotswap-cli.mjs`), y aquí solo se filtraba el saludo.
+   *
+   * La consecuencia de que falten las otras dos no es perder una línea: es que **el push se
+   * cuenta como la respuesta del comando pendiente y TODO lo que viene después va
+   * desfasado** — cada comando recibe la contestación del anterior. Y no falla siempre, solo
+   * cuando llega un push en medio, que es lo que lo hace difícil de ver.
+   *
+   * Las dos que faltaban:
+   *  - `logger: true` — una línea de log que el aparato empuja. Las produce cualquier cosa
+   *    que encienda el registro, o sea justo lo que se hace para diagnosticar.
+   *  - `state` — el progreso de una descarga.
+   */
+  if (mensaje.logger === true || mensaje.state !== undefined || mensaje.command === "server_hello") {
+    // No se imprime: quien pidió un comando no pidió esto, y meterlo en la salida es meterlo
+    // en el contexto del agente. Lo que se conserva es el ORDEN.
+    return;
+  }
   console.log(JSON.stringify({ comando: pendiente?.command, ...sinBinarios(mensaje) }));
   pendiente = undefined;
   siguiente();

package/skills/xone-project-generator/references/fases-10-12-readmes-y-validacion.md

@@ -66,14 +66,22 @@ Las tablas deben tener el prefijo `gen_` y estar en minúsculas (ej: `gen_empres
 
 | Tipo XOne | SQLite | Descripción |
 |-----------|--------|-------------|
-| T, L, TL, X, PH | TEXT | Texto |
-| D, DT | TEXT | Fechas |
-| IMG, VD, F, M | TEXT | Rutas |
+| T, L, TL, THTML, X | TEXT | Texto |
+| TN, TN2-TN6 | TEXT | Número almacenado como texto |
+| D, DT, TT | TEXT | Fechas y horas |
+| IMG, PH, VD, DR, AT, WEB | TEXT | Rutas a fichero o URL |
 | N | INTEGER | Entero |
-| NC, R | INTEGER | Boolean |
-| N1-N6 | REAL | Decimales |
-| C | TEXT | Combo |
-| B, Z, L, S, P, O | NO SE CREA | UI |
+| NC | INTEGER | Booleano (0/1) |
+| N2-N6 | REAL | Decimales |
+| B, Z, O | NO SE CREA | No persisten |
+
+> Los tipos de esta tabla son los 30 de la **lista autoritativa** de
+> `xone-help-docs` (`topics/02b-xml-prop-tipos.md`). Ojo con los que NO existen y
+> parecen tipos: **no hay `C` (combo), `M` (mapa), `A` (autocomplete), `F`, `S`, `P`,
+> `R` ni `N1`**. Un combo es `type="T"` (o `"N"`) con `mapcol` y `mapfld`; un mapa es
+> `type="Z" viewmode="mapview"`; los sliders y las barras de progreso son
+> **viewmodes** sobre `T`, `N` o `Z`. Si el modelo trae uno de esos nombres, el
+> arreglo es cambiar el tipo en el `.xne`, no crear una columna para él.
 
 ### 11.4 Tarea 2: Insertar Datos Iniciales