boosterarena-mcp 0.1.0

package/dist/nucleo.mjs

@@ -0,0 +1,2688 @@
+// ../src/insert/catalogos.ts
+var ILUS_BASE = "https://assets.boosterarena.com/ilustraciones";
+var FONDOS_BASE = "https://assets.boosterarena.com/fondos";
+var FLAG_ICONS = ["us", "gb", "mx", "ca", "es", "fr", "de", "it", "br", "jp", "cn", "kr", "in", "ru", "au", "nl", "pt", "ar", "co", "eg", "za", "sa", "tr", "gr"].map((c) => `circle-flags:${c}`);
+var ILLUS_ICONS = ["idea", "reading", "graduation-cap", "library", "planner", "calendar", "alarm-clock", "globe", "landscape", "gallery", "camera", "film", "music", "like", "rating", "sports-mode", "night-landscape", "panorama", "picture", "news", "document", "about", "conference-call", "voice-presentation"].map((n2) => `flat-color-icons:${n2}`);
+var ANIMAL_ICONS = ["dog", "cat", "mouse-face", "hamster", "rabbit-face", "fox", "bear", "panda", "koala", "tiger-face", "lion", "cow-face", "pig-face", "frog", "monkey-face", "chicken", "penguin", "bird", "turtle", "snake", "tropical-fish", "dolphin", "elephant", "horse-face", "butterfly", "unicorn", "owl"].map((n2) => `noto:${n2}`);
+var sinTildes = (s) => s.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().trim();
+var VACIAS = /* @__PURE__ */ new Set([
+  "un",
+  "una",
+  "unos",
+  "unas",
+  "el",
+  "la",
+  "lo",
+  "los",
+  "las",
+  "de",
+  "del",
+  "al",
+  "con",
+  "sin",
+  "para",
+  "por",
+  "que",
+  "y",
+  "e",
+  "o",
+  "u",
+  "en",
+  "a",
+  "mi",
+  "su",
+  "este",
+  "esta",
+  "ese",
+  "esa",
+  "the",
+  "an",
+  "of",
+  "with",
+  "for",
+  "and",
+  "or",
+  "in",
+  "on",
+  "to",
+  "my",
+  "this",
+  "that",
+  "um",
+  "uma",
+  "os",
+  "as",
+  "do",
+  "da",
+  "dos",
+  "das",
+  "com",
+  "sem",
+  "no",
+  "na",
+  "e",
+  "ou"
+]);
+var limpiarVacias = (ws) => {
+  const utiles = ws.filter((w) => !VACIAS.has(w));
+  return utiles.length ? utiles : ws;
+};
+var raiz = (w) => {
+  if (w.length <= 3) return w;
+  let r = w;
+  if (/[bcdfghjklmnpqrstvwxyz]es$/.test(r)) r = r.slice(0, -2);
+  else if (/s$/.test(r)) r = r.slice(0, -1);
+  if (r.length >= 6 && /[oa]$/.test(r)) r = r.slice(0, -1);
+  return r;
+};
+var distancia = (a, b, tope) => {
+  if (Math.abs(a.length - b.length) > tope) return tope + 1;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const fila = [i];
+    let mejorFila = i;
+    for (let j = 1; j <= b.length; j++) {
+      const coste = a[i - 1] === b[j - 1] ? 0 : 1;
+      const v = Math.min(prev[j] + 1, fila[j - 1] + 1, prev[j - 1] + coste);
+      fila.push(v);
+      if (v < mejorFila) mejorFila = v;
+    }
+    if (mejorFila > tope) return tope + 1;
+    prev = fila;
+  }
+  return prev[b.length];
+};
+var erratasQueSePerdonan = (w) => w.length >= 7 ? 2 : w.length >= 5 ? 1 : 0;
+var CAMPOS = [["bn", 100], ["bs", 60], ["bm", 45], ["bt", 30], ["bf", 12]];
+var puntuarDetalle = (e, palabras) => {
+  let total = 0, encajadas = 0;
+  for (const w of palabras) {
+    let mejor = 0;
+    for (const [campo, peso] of CAMPOS) {
+      const texto2 = e[campo];
+      if (!texto2) continue;
+      const ws = texto2.split(" ");
+      if (ws.includes(w)) {
+        mejor = Math.max(mejor, peso);
+        continue;
+      }
+      if (ws.some((x) => x.startsWith(w))) {
+        mejor = Math.max(mejor, peso * 0.8);
+        continue;
+      }
+      const tope = erratasQueSePerdonan(w);
+      if (tope && ws.some((x) => distancia(w, x, tope) <= tope)) mejor = Math.max(mejor, peso * 0.45);
+    }
+    if (mejor) {
+      encajadas++;
+      total += mejor;
+    }
+  }
+  return { total, encajadas };
+};
+var puntuar = (e, palabras) => {
+  const { total, encajadas } = puntuarDetalle(e, palabras);
+  return encajadas === palabras.length ? total : 0;
+};
+
+// ../src/canvas/robot/biblioteca.ts
+var ilus = null;
+var fondos = null;
+var cargando = null;
+function cargarBiblioteca() {
+  if (ilus && fondos) return Promise.resolve();
+  if (cargando) return cargando;
+  const pedir = (url) => fetch(url, { cache: "no-cache" }).then((r) => r.ok ? r.json() : Promise.reject(new Error(String(r.status)))).then((j) => Array.isArray(j?.elementos) ? j.elementos : []).catch(() => []);
+  cargando = Promise.all([
+    pedir(`${ILUS_BASE}/catalogo.json`),
+    pedir(`${FONDOS_BASE}/catalogo.json`)
+  ]).then(([a, b]) => {
+    ilus = a;
+    fondos = b;
+    cargando = null;
+  });
+  return cargando;
+}
+var t\u00E9rminos = (consulta) => limpiarVacias(sinTildes(consulta).split(/\s+/).filter(Boolean)).map(raiz);
+function mejorIlustracion(lista2, consulta) {
+  if (!lista2.length) return null;
+  const palabras = t\u00E9rminos(consulta);
+  if (!palabras.length) return { e: lista2[0], exacto: false, encajadas: 0, pedidas: 0 };
+  let top = null;
+  let mejorP = 0;
+  for (const e of lista2) {
+    const p = puntuar(e, palabras);
+    if (p > mejorP) {
+      mejorP = p;
+      top = e;
+    }
+  }
+  if (top) return { e: top, exacto: true, encajadas: palabras.length, pedidas: palabras.length };
+  let mejorEncajadas = 0;
+  for (const e of lista2) {
+    const p = puntuarDetalle(e, palabras);
+    const v = p.encajadas * 1e3 + p.total;
+    if (v > mejorP) {
+      mejorP = v;
+      top = e;
+      mejorEncajadas = p.encajadas;
+    }
+  }
+  return top ? { e: top, exacto: false, encajadas: mejorEncajadas, pedidas: palabras.length } : null;
+}
+function mejorFondo(lista2, consulta) {
+  if (!lista2.length) return null;
+  const palabras = t\u00E9rminos(consulta);
+  if (!palabras.length) return lista2[0];
+  let top = null;
+  let mejorP = 0;
+  for (const f of lista2) {
+    let p = 0;
+    for (const w of palabras) {
+      if (f.bn?.includes(w)) p += 100;
+      else if (f.bt?.includes(w)) p += 30;
+      else if (f.be?.includes(w)) p += 20;
+    }
+    if (p > mejorP) {
+      mejorP = p;
+      top = f;
+    }
+  }
+  return top;
+}
+function buscarDibujo(consulta) {
+  const h = mejorIlustracion(ilus ?? [], consulta);
+  if (!h) return null;
+  return {
+    src: `${ILUS_BASE}/${h.e.archivo}`,
+    nombre: h.e.nombre.es,
+    aspect: h.e.w && h.e.h ? h.e.w / h.e.h : 1,
+    exacto: h.exacto,
+    encajadas: h.encajadas,
+    pedidas: h.pedidas
+  };
+}
+function buscarFondo(consulta) {
+  const e = mejorFondo(fondos ?? [], consulta);
+  if (!e) return null;
+  return { src: `${FONDOS_BASE}/${e.archivo}`, nombre: e.nombre.es };
+}
+
+// ../src/shared/textEffects.ts
+var COLOR_EFFECTS = [
+  { id: "none", name: "Ninguno" },
+  { id: "shadow", name: "Sombra" },
+  { id: "lift", name: "Elevado" },
+  { id: "outline", name: "Contorno" },
+  { id: "neon", name: "Ne\xF3n" },
+  { id: "glow", name: "Glow" },
+  // Los cuatro que Canva tiene y aquí faltaban. Los tres primeros son `text-shadow` puro
+  // (baratos); 'fondo' es una caja detrás de las letras.
+  // El golpe de las pegatinas de póster: una copia MACIZA desplazada, sin nada de
+  // desenfoque, en un color que contrasta. Es la Sombra de Canva con el desenfoque a
+  // cero; aquí va aparte porque nuestra Sombra siempre lleva algo de difuminado y
+  // cambiarla movería lo que ya hay hecho en los proyectos guardados.
+  { id: "block", name: "Bloque" },
+  { id: "splice", name: "Empalme" },
+  { id: "echo", name: "Eco" },
+  { id: "glitch", name: "Glitch" },
+  { id: "bgbox", name: "Fondo" },
+  { id: "retro", name: "Retro" },
+  { id: "gradient", name: "Degradado" },
+  { id: "shimmer", name: "Brillo" }
+];
+var MOTION_EFFECTS = [
+  { id: "none", name: "Ninguno" },
+  { id: "float", name: "Flotar" },
+  { id: "pulse", name: "Pulso" },
+  { id: "swing", name: "Balanceo" },
+  { id: "wave", name: "Onda" },
+  { id: "sweep", name: "Barrido" },
+  // Seis más (2026-08-31), del mismo tipo que los de arriba: BUCLES de ambiente, no
+  // animaciones de entrada. Todos animan SOLO `transform`, así que combinan con los trece
+  // efectos de color sin revisar nada — que es justo la garantía de las dos categorías.
+  // Los que se mueven en horizontal miden en `em` y no en %: el % de una caja de texto es
+  // su ANCHO, y con eso un titular largo se sacudía cinco veces más que una palabra suelta.
+  // En `em` el movimiento va con el tamaño de la letra, que es lo que el ojo compara.
+  { id: "bounce", name: "Rebote" },
+  { id: "heartbeat", name: "Latido" },
+  { id: "shake", name: "Temblor" },
+  { id: "glide", name: "Vaiv\xE9n" },
+  { id: "orbit", name: "\xD3rbita" },
+  { id: "elastic", name: "El\xE1stico" }
+];
+
+// ../src/canvas/robot/catalogo.ts
+var obj = (props, req = []) => ({ type: "object", properties: props, required: req, additionalProperties: false });
+var str = (description, opts = {}) => ({ type: "string", description, ...opts.enum ? { enum: opts.enum } : {} });
+var num = (description) => ({ type: "number", description });
+var bool = (description) => ({ type: "boolean", description });
+var REF = str('Etiqueta corta que T\xDA inventas para poder referirte a esto despu\xE9s en esta misma tanda (por ejemplo al programarlo). Ej: "titulo", "boton_dia2".');
+var X = num("Borde IZQUIERDO, en % del ancho del slide (0 = pegado a la izquierda, 100 = derecha).");
+var Y = num("Borde SUPERIOR, en % del alto del slide (0 = arriba del todo, 100 = abajo).");
+var W = num("ANCHO en % del ancho del slide. No pongas alto: lo calcula el editor.");
+var CAPA = str("Deja esto vac\xEDo para poner la cosa en el slide. Si quieres que caiga DENTRO de una capa, pon aqu\xED el `ref` o el nombre de esa capa.");
+var efectosColor = COLOR_EFFECTS.map((e) => e.id);
+var efectosMov = MOTION_EFFECTS.map((e) => e.id);
+function construirCatalogo(opts) {
+  const fn = (name, description, parameters) => ({ type: "function", function: { name, description, parameters } });
+  const monedas = ["quitafondo", "magichat", "transformar"].filter((t) => opts.boosters.includes(t));
+  return [
+    // ── PONER COSAS EN EL SLIDE ───────────────────────────────────────────────
+    fn(
+      "poner_texto",
+      "Pone un texto en el slide. Es la herramienta que m\xE1s vas a usar: t\xEDtulos, enunciados, opciones de respuesta, etiquetas.",
+      obj({
+        ref: REF,
+        x: X,
+        y: Y,
+        w: W,
+        capa: CAPA,
+        texto: str("El texto que se lee. En el idioma que pida el maestro."),
+        tamano: num("Tama\xF1o de letra en p\xEDxeles sobre un alto de 1080. Referencias: t\xEDtulo grande 90, subt\xEDtulo 56, texto normal 40, letra chica 28. Si dudas, 44."),
+        color: str('Color del texto en hex, ej "#111827". Oscuro sobre fondo claro y al rev\xE9s.'),
+        efecto: str("Efecto de COLOR de las letras. Ojo: el ne\xF3n pinta las letras del color DEL EFECTO, as\xED que \xABtexto blanco con ne\xF3n\xBB es color blanco Y color_efecto blanco.", { enum: efectosColor }),
+        color_efecto: str("Color del efecto en hex: el brillo del ne\xF3n, la sombra, el borde, el bloque. Si no lo mandas, cada efecto usa el suyo."),
+        movimiento: str("Efecto de MOVIMIENTO de las letras. Se combina con el de color. Con cuentagotas: un slide entero movi\xE9ndose marea.", { enum: efectosMov }),
+        mayusculas: bool("Ponerlo TODO EN MAY\xDASCULAS sin cambiar lo que se escribi\xF3."),
+        peso: num("Grosor de la letra, de 400 (normal) a 900 (negr\xEDsima). Los t\xEDtulos piden 800."),
+        align: str("Alineaci\xF3n del p\xE1rrafo.", { enum: ["left", "center", "right", "justify"] })
+      }, ["ref", "x", "y", "w", "texto"])
+    ),
+    fn(
+      "poner_dibujo",
+      'Busca un dibujo en NUESTRA biblioteca (miles de ilustraciones con fondo transparente) y lo pone en el slide. Descr\xEDbelo en espa\xF1ol y en singular: "le\xF3n", "manzana", "ni\xF1a leyendo". No necesitas saber qu\xE9 hay: el buscador es del editor y te contesta qu\xE9 encontr\xF3.',
+      obj({
+        ref: REF,
+        x: X,
+        y: Y,
+        w: W,
+        capa: CAPA,
+        busca: str("Qu\xE9 dibujo quieres, en espa\xF1ol. Una o dos palabras funcionan mejor que una frase.")
+      }, ["ref", "x", "y", "w", "busca"])
+    ),
+    // ── Archivos de fuera ─────────────────────────────────────────────────────
+    // La puerta por la que entra lo que genera otra fábrica (imágenes, voz). Booster no genera
+    // ninguna de las dos cosas —se decidió así por costo— pero sí las recibe: para el documento,
+    // un MP3 de un TTS y un MP3 que subió un maestro son el mismo elemento con una URL de R2.
+    fn(
+      "poner_imagen",
+      "Pone una imagen que YA est\xE1 subida, por su URL. Es para lo que trae quien te llama (una ilustraci\xF3n generada, una foto del maestro). Si lo que quieres es un dibujo de NUESTRA biblioteca, usa `poner_dibujo`, que busca por palabras.",
+      obj({
+        ref: REF,
+        x: X,
+        y: Y,
+        w: W,
+        capa: CAPA,
+        url: str("La direcci\xF3n https:// del archivo ya subido."),
+        proporcion: num("Ancho dividido entre alto de la imagen (1 = cuadrada, 1.78 = apaisada 16:9). Si no la sabes, d\xE9jalo: se asume cuadrada y el maestro la ajusta.")
+      }, ["ref", "x", "y", "w", "url"])
+    ),
+    fn(
+      "poner_audio",
+      "Pone un audio que YA est\xE1 subido, por su URL: una grabaci\xF3n, una pista, una voz generada. Aparece como un chip de altavoz FUERA del slide (es un mando del maestro, no parte de la l\xE1mina). \u26A0\uFE0F Ponerlo NO hace que suene: hay que programarlo despu\xE9s.",
+      obj({
+        ref: REF,
+        url: str("La direcci\xF3n https:// del audio ya subido."),
+        nombre: str('C\xF3mo se llama, para que el maestro lo reconozca: "Listening 1", "Instrucciones".')
+      }, ["ref", "url"])
+    ),
+    fn(
+      "poner_figura",
+      "Pone una figura vectorial: globos de di\xE1logo, flechas, marcas de correcto/incorrecto, marcos, resaltadores, geometr\xEDa.",
+      obj({
+        ref: REF,
+        x: X,
+        y: Y,
+        w: W,
+        capa: CAPA,
+        forma: str("Qu\xE9 figura.", { enum: opts.formas }),
+        color: str("Color de relleno en hex. Si lo omites entra con el color que le toca por defecto (la palomita verde, la cruz roja...), que casi siempre es el bueno.")
+      }, ["ref", "x", "y", "w", "forma"])
+    ),
+    fn(
+      "poner_boton",
+      'Pone un BOT\xD3N 3D con texto, listo para programarle qu\xE9 hace al tocarlo. Para men\xFAs, "siguiente", "ver la respuesta", "volver".',
+      obj({
+        ref: REF,
+        x: X,
+        y: Y,
+        w: W,
+        capa: CAPA,
+        texto: str('Lo que dice el bot\xF3n. Corto: "Ver respuesta", "D\xEDa 2".'),
+        color: str("Color del bot\xF3n en hex."),
+        icono: str("Icono opcional dentro del bot\xF3n.", {
+          enum: ["none", "next", "back", "home", "play", "pause", "check", "star"]
+        })
+      }, ["ref", "x", "y", "w", "texto"])
+    ),
+    fn(
+      "poner_emoji",
+      "Pone un emoji grande como elemento del slide.",
+      obj(
+        { ref: REF, x: X, y: Y, w: W, capa: CAPA, emoji: str('Un solo emoji, ej "\u{1F389}".') },
+        ["ref", "x", "y", "w", "emoji"]
+      )
+    ),
+    fn(
+      "poner_zona_caliente",
+      "Pone una ZONA CALIENTE: una figura invisible en la proyecci\xF3n que captura el clic. Sirve para hacer clicable un trozo de una imagen de fondo (un pa\xEDs en un mapa, un \xF3rgano en un dibujo). Progr\xE1mala despu\xE9s con `programar`.",
+      obj({
+        ref: REF,
+        x: X,
+        y: Y,
+        w: W,
+        capa: CAPA,
+        forma: str("Forma de la zona.", { enum: ["ellipse", "rect", "triangle"] }),
+        alto: num("Alto en % del alto del slide. Aqu\xED S\xCD se pide, porque una zona se ajusta a lo que tapa.")
+      }, ["ref", "x", "y", "w", "forma"])
+    ),
+    fn(
+      "poner_fondo",
+      "Pone el FONDO del slide: o una escena de nuestra biblioteca (aula, cocina, bosque, hospital...) busc\xE1ndola por palabra, o un color liso. El fondo no es un objeto: no se mueve ni se programa.",
+      obj({
+        busca: str('Escena a buscar en la biblioteca de fondos, en espa\xF1ol: "aula", "cocina", "playa".'),
+        color: str('Color liso en hex, ej "#0f172a". Usa esto O `busca`, no los dos.')
+      }, [])
+    ),
+    fn(
+      "poner_booster",
+      "Pone un BOOSTER: una herramienta interactiva que el maestro dispara en clase (dado, ruleta, cron\xF3metro, marcador, sem\xE1foro...). Ocupa un trozo del slide y convive con lo dem\xE1s.",
+      obj({
+        ref: REF,
+        x: X,
+        y: Y,
+        w: W,
+        capa: CAPA,
+        tipo: str("Cu\xE1l booster.", { enum: opts.boosters })
+      }, ["ref", "x", "y", "w", "tipo"])
+    ),
+    ...monedas.length ? [fn(
+      "aplicar_booster",
+      "USA uno de los boosters que se ARRASTRAN sobre un objeto, y lo deja ya aplicado. Es la herramienta para \xABqu\xEDtale el fondo a esta foto\xBB (quitafondo), \xABque esta imagen salga en negro y se revele al tocarla\xBB (magichat) y \xABque al hacer clic se convierta en otra cosa\xBB (transformar). \u26A0\uFE0F Para esto NO uses `poner_booster`: eso solo deja la moneda tirada en el slide sin aplicar nada, y el maestro tendr\xEDa que arrastrarla \xE9l. Y NO uses `borrar`: quitarle el fondo a una imagen no es quitar la imagen.",
+      obj({
+        tipo: str("Cu\xE1l de las tres monedas.", { enum: monedas }),
+        objetivo: str("El `ref` o el id del objeto sobre el que se suelta. Tiene que estar en el slide (no dentro de una capa). Para quitafondo y magichat, una imagen.")
+      }, ["tipo", "objetivo"])
+    )] : [],
+    fn(
+      "poner_arena",
+      "Pone una BOOST ARENA: un juego completo que ocupa el SLIDE ENTERO (clasificaci\xF3n, carrera, memoria, rompecabezas, tragamonedas...). Como se come el slide, va siempre en un slide para ella sola: si el slide de ahora ya tiene cosas, llama antes a `nuevo_slide`. Sus preguntas y palabras las carga el maestro despu\xE9s, en el editor de la arena.",
+      obj({
+        ref: REF,
+        tipo: str("Cu\xE1l arena.", { enum: opts.arenas })
+      }, ["ref", "tipo"])
+    ),
+    // ── LLENAR LO QUE SE PONE ─────────────────────────────────────────────────
+    // Poner una arena vacía no adelanta nada: para una fábrica, LLENAR es todo el trabajo.
+    // Estas tres van juntas y en este orden: `describir` trae la forma, `configurar_*` la llena.
+    //
+    // ⚠️ El schema NO viaja en el catálogo, a posta. `functions/api/openai.ts` rechaza catálogos
+    // de más de 40.000 bytes, y ese tope ya estuvo a un 5 % de romperse (22.731 bytes medidos el
+    // 2026-09-04 contra uno de 24.000). Solo la Batalla Pirata ocupa más que varias herramientas
+    // juntas. Con `describir` el catálogo NO crece aunque se añadan veinte arenas más.
+    fn(
+      "describir",
+      "Dice QU\xC9 se le puede llenar a un booster o a una arena: sus campos, sus trampas y un ejemplo que funciona. Ll\xE1malo ANTES de `configurar_arena` o `configurar_booster` \u2014 los nombres de los campos no son los que parecen (la Batalla Pirata guarda en `pirateQs`, no en `questions`) y adivinarlos hace que el maestro se encuentre la actividad vac\xEDa en plena clase.",
+      obj({ tipo: str('El tipo del booster o de la arena: "pirate", "gameshow", "cycle"\u2026') }, ["tipo"])
+    ),
+    fn(
+      "configurar_arena",
+      "LLENA una arena que ya est\xE1 puesta: sus preguntas, sus palabras, sus parejas. Es lo que convierte una arena de muestra en la actividad de ESTA clase. Reemplaza la configuraci\xF3n entera, as\xED que manda todos los campos que quieras conservar, no solo los que cambias.",
+      obj({
+        objetivo: str("El `ref` o el id de la arena. Si acabas de ponerla en esta misma tanda, usa su `ref`. Puedes dejarlo vac\xEDo: sin \xE9l se llena la arena del slide en el que est\xE1s, que solo puede ser una."),
+        cfg: str('La configuraci\xF3n, como TEXTO JSON. La forma exacta te la da `describir(tipo)`. Ejemplo para gameshow: {"questions":[{"q":"\u2026","options":["a","b"],"answer":0}]}')
+      }, ["cfg"])
+    ),
+    fn(
+      "configurar_booster",
+      "LLENA un booster que ya est\xE1 puesto: los nombres de la ruleta, los segundos del cron\xF3metro, las etapas del Ciclo, el enlace del QR. Reemplaza la configuraci\xF3n entera.",
+      obj({
+        objetivo: str("El `ref` o el id del booster. Si acabas de ponerlo en esta misma tanda, usa su `ref`."),
+        cfg: str('La configuraci\xF3n, como TEXTO JSON. La forma exacta te la da `describir(tipo)`. Ejemplo para timer: {"seconds":90}')
+      }, ["objetivo", "cfg"])
+    ),
+    // ── ESTRUCTURA DEL CURSO ──────────────────────────────────────────────────
+    fn(
+      "nuevo_slide",
+      "Crea un slide NUEVO justo despu\xE9s del actual y se pone a trabajar en \xE9l: todo lo que pongas a partir de aqu\xED cae ah\xED. Es como pasar a la diapositiva siguiente cuando te piden varias.",
+      obj({ nombre: str('Nombre del slide, corto y descriptivo: "Vocabulario", "Pr\xE1ctica 1".') }, [])
+    ),
+    fn(
+      "nueva_capa",
+      "Crea una CAPA en el slide actual: una ventana que se abre encima del slide cuando algo la llama (la respuesta de un ejercicio, una explicaci\xF3n, una imagen ampliada). Nace vac\xEDa; para poner cosas DENTRO, p\xE1sale su `ref` en el campo `capa` de las herramientas de poner. \u26A0\uFE0F Crearla NO hace que se abra: para que se abra al tocar algo hay que `programar` ese algo con accion abrirCapa y el `ref` de esta capa.",
+      obj({ ref: REF, nombre: str('Nombre de la capa: "Respuesta 1", "Pista".') }, ["ref", "nombre"])
+    ),
+    fn(
+      "nueva_escena",
+      "Crea una ESCENA nueva (un d\xEDa de clase, un bloque del curso) con un slide vac\xEDo, y se pone a trabajar ah\xED. Solo si el maestro pide otro d\xEDa u otro bloque \u2014 no para un slide m\xE1s.",
+      obj({ nombre: str('Nombre de la escena: "D\xEDa 3", "Repaso".') }, ["nombre"])
+    ),
+    // ── PROGRAMAR (los disparadores) ──────────────────────────────────────────
+    fn(
+      "programar",
+      "Le da COMPORTAMIENTO a un objeto: cu\xE1ndo pasa algo (evento) y qu\xE9 pasa (acci\xF3n). Es lo que convierte un slide en una actividad. Puedes programar algo que acabas de poner usando su `ref`, o algo que ya estaba usando el id que te di en la lista del slide.",
+      obj({
+        objetivo: str("A qu\xE9 objeto se le pone. Su `ref` (si lo acabas de crear) o su id (si ya exist\xEDa)."),
+        evento: str(
+          "CU\xC1NDO se dispara. click = al tocarlo \xB7 hover = al pasarle por encima \xB7 slideStart = al entrar al slide \xB7 layerShown = al abrirse la capa donde vive \xB7 time = a los N segundos \xB7 clickStep = en el N-\xE9simo clic (secuencias de clic) \xB7 trayectoriaTerminada = cuando el objeto acaba de recorrer su camino (para encadenar: \xABcuando llegue, que desaparezca\xBB).",
+          { enum: ["click", "hover", "slideStart", "layerShown", "time", "clickStep", "trayectoriaTerminada"] }
+        ),
+        segundos: num('Solo con evento "time": a los cu\xE1ntos segundos.'),
+        paso: num('Solo con evento "clickStep": en qu\xE9 n\xFAmero de clic (1, 2, 3...).'),
+        accion: str(
+          "QU\xC9 pasa. abrirCapa = muestra una capa \xB7 irAEscena = salta a otra escena \xB7 irASlide = salta a un slide \xB7 cerrarCapa = cierra la capa abierta \xB7 leerEnVoz = lo lee el navegador en voz alta \xB7 abrirEnlace = abre una URL \xB7 ocultar = el objeto desaparece con una nube de humo \xB7 moverPorTrayectoria = el objeto RECORRE un camino dibujado \xB7 sonar = suena un audio que ya est\xE1 puesto en el slide o en una capa (para \xABque suene al abrirse la capa\xBB: objetivo = ese audio, evento = layerShown, destino = ese mismo audio; para \xABal tocar X\xBB: objetivo = X, destino = el audio) \xB7 reiniciarSecuencia = devuelve el slide a como empez\xF3 \xB7 quitar = le borra todo lo que tuviera programado.",
+          {
+            enum: [
+              "abrirCapa",
+              "irAEscena",
+              "irASlide",
+              "cerrarCapa",
+              "leerEnVoz",
+              "abrirEnlace",
+              "ocultar",
+              "moverPorTrayectoria",
+              "sonar",
+              "reiniciarSecuencia",
+              "quitar"
+            ]
+          }
+        ),
+        capa: str('Solo con "abrirCapa": el `ref` o el nombre de la capa que se abre.'),
+        escena: str('Solo con "irAEscena": el nombre de la escena destino.'),
+        slide: num('Solo con "irASlide": el n\xFAmero de slide dentro de la escena actual (empieza en 1).'),
+        texto: str('Solo con "leerEnVoz": qu\xE9 se lee en voz alta.'),
+        idioma: str('Solo con "leerEnVoz": "en-US" para ingl\xE9s, "es-ES" para espa\xF1ol.'),
+        url: str('Solo con "abrirEnlace": la direcci\xF3n completa (https://...).'),
+        primero: bool("Ponlo en true si esta acci\xF3n tiene que dispararse ANTES de las que el objeto ya tiene. Los disparadores de un mismo evento corren EN ORDEN, as\xED que para \xABantes de que desaparezca, que abra una capa\xBB la de abrir la capa lleva primero=true."),
+        destino: str('El objeto sobre el que RECAE la acci\xF3n, cuando no es el mismo que la dispara. Con "ocultar": el que desaparece (si lo omites, el que dispara). Con "moverPorTrayectoria": el que se mueve (si lo omites, el que dispara). Con "sonar": el AUDIO que suena \u2014 este es obligatorio, y tiene que ser uno de los audios que te listo en el slide.'),
+        trayectoria: str('Solo con "moverPorTrayectoria" o el evento "trayectoriaTerminada": el NOMBRE del camino. Si el objeto no tiene ninguno, NO pasa nada malo: p\xEDdelo igual y el editor le crea uno vac\xEDo y pone al maestro a dibujarlo ah\xED mismo, con la programaci\xF3n ya hecha. Es lo correcto \u2014 t\xFA no puedes dibujar el camino, pero s\xED dej\xE1rselo listo.')
+      }, ["objetivo", "evento", "accion"])
+    ),
+    // ── RETOCAR LO QUE YA ESTÁ ────────────────────────────────────────────────
+    // Se llamaba `mover`, y ese nombre le robaba las peticiones a `programar` con
+    // `moverPorTrayectoria`: a «quiero que al hacer clic el tarro SE MUEVA por una trayectoria»
+    // el modelo contestaba recolocando el tarro. Medido contra la API, fallaba siempre. El
+    // arreglo es el nombre, no una regla más en el prompt: aquí «mover» es de animación.
+    fn(
+      "recolocar",
+      "Cambia de SITIO o de TAMA\xD1O un objeto que ya est\xE1 en el slide, al instante y para siempre. NO es una animaci\xF3n ni un recorrido: para que un objeto se mueva en la proyecci\xF3n, usa `programar` con la acci\xF3n `moverPorTrayectoria`.",
+      obj({
+        objetivo: str("El `ref` o el id del objeto."),
+        x: num("Nuevo borde izquierdo en %. Om\xEDtelo para no moverlo en horizontal."),
+        y: num("Nuevo borde superior en %. Om\xEDtelo para no moverlo en vertical."),
+        w: num("Nuevo ancho en %. El alto se reajusta solo guardando la proporci\xF3n.")
+      }, ["objetivo"])
+    ),
+    // ── ESTILO ────────────────────────────────────────────────────────────────
+    // Sin estas dos, el robot podía CREAR bonito pero no RETOCAR: «ponlo blanco» o «pon a este
+    // sticker los mismos efectos que a la abeja» no tenían herramienta, y son de lo primero que
+    // pide cualquiera que esté componiendo un slide.
+    fn(
+      "cambiar_estilo",
+      "Cambia c\xF3mo SE VE un objeto que ya est\xE1 puesto, sin tocar su contenido ni su sitio. Manda solo lo que quieras cambiar; lo que no mandes se queda como estaba.",
+      obj({
+        objetivo: str("El `ref` o el id del objeto."),
+        color: str("Color del TEXTO en hex."),
+        relleno: str("Color de RELLENO de una figura o un bot\xF3n, en hex."),
+        tamano: num("Tama\xF1o de letra en p\xEDxeles sobre 1080."),
+        efecto: str("Efecto de COLOR de las letras. Ojo: el ne\xF3n pinta las letras del color DEL EFECTO, as\xED que \xABtexto blanco con ne\xF3n\xBB es color blanco Y color_efecto blanco.", { enum: efectosColor }),
+        color_efecto: str("Color del efecto en hex: el brillo del ne\xF3n, la sombra, el borde, el bloque. Si no lo mandas, cada efecto usa el suyo."),
+        movimiento: str("Efecto de MOVIMIENTO.", { enum: efectosMov }),
+        peso: num("Grosor de la letra, 400 a 900."),
+        mayusculas: bool("TODO EN MAY\xDASCULAS (o false para quitarlo)."),
+        align: str("Alineaci\xF3n del p\xE1rrafo.", { enum: ["left", "center", "right", "justify"] }),
+        opacidad: num("Transparencia de 0 (invisible) a 1 (opaco)."),
+        giro: num("Giro en grados. 0 = derecho.")
+      }, ["objetivo"])
+    ),
+    fn(
+      "copiar_estilo",
+      "Copia el ASPECTO de un objeto a otro: colores, tama\xF1o de letra, fuente, grosor, may\xFAsculas y los dos efectos. No copia el texto, ni el sitio, ni el tama\xF1o de la caja, ni la programaci\xF3n. Es lo que resuelve \xABponle a este sticker los mismos efectos que le pusiste a la abeja\xBB: no tienes que acordarte de qu\xE9 le pusiste, se copia y ya.",
+      obj({
+        desde: str("El `ref` o el id del objeto que ya est\xE1 como quieres."),
+        hacia: str("El `ref` o el id del objeto que tiene que quedar igual.")
+      }, ["desde", "hacia"])
+    ),
+    fn(
+      "cambiar_texto",
+      "Reescribe el texto de un objeto que ya est\xE1 en el slide.",
+      obj({
+        objetivo: str("El `ref` o el id del objeto."),
+        texto: str("El texto nuevo.")
+      }, ["objetivo", "texto"])
+    ),
+    fn(
+      "borrar",
+      "Hace DESAPARECER un objeto entero del slide. \u26A0\uFE0F DESTRUCTIVA: \xFAsala SOLO si el maestro te pide borrar, quitar o eliminar EL OBJETO con esas palabras. Nunca porque te parezca que sobra, ni para \xABlimpiar\xBB, ni al reordenar un slide. Si el mensaje no pide un borrado, usa `responder`. \u26A0\uFE0F Y quitarle a algo el FONDO, el color, el borde o la sombra NO es borrarlo: el fondo de una imagen se quita con `aplicar_booster`, y el objeto se queda donde est\xE1.",
+      obj({ objetivo: str("El `ref` o el id del objeto a quitar.") }, ["objetivo"])
+    ),
+    // ── HABLAR, QUE TAMBIÉN ES UNA RESPUESTA VÁLIDA ───────────────────────────
+    // Al robot se le OBLIGA a llamar a una herramienta (`tool_choice: 'required'`), porque sin
+    // obligarlo contestaba «voy a programar la acción… procedo a añadirla» sin llamar a nada.
+    // Pero esa obligación tiene un filo: si el maestro NO pide nada, el modelo se inventa una
+    // operación con tal de obedecer. Pasó, y de la peor forma: Antonio escribió «listo ya le
+    // agregué trayectoria» —una simple confirmación— y el robot llamó a `borrar` y le borró el
+    // dibujo. Por eso esta herramienta se describe como lo NORMAL y no como la excepción: en
+    // una conversación, la mitad de los mensajes no piden ningún cambio.
+    fn(
+      "responder",
+      "Hablarle al maestro SIN tocar el lienzo. Es una respuesta tan v\xE1lida como cualquier otra y la vas a usar mucho: el maestro te habla como a una persona. \xDAsala SIEMPRE que su mensaje no pida un cambio concreto \u2014 cuando te confirma algo (\xABlisto\xBB, \xABya lo hice\xBB, \xABya dibuj\xE9 la trayectoria\xBB), cuando te da las gracias, cuando te pregunta, o cuando te falta un dato para actuar. Ante la duda de si te est\xE1n pidiendo un cambio o solo cont\xE1ndote algo: RESPONDE, no toques nada.",
+      obj({ mensaje: str("Lo que le dices al maestro. Una o dos frases, en espa\xF1ol, en su tono.") }, ["mensaje"])
+    )
+  ];
+}
+
+// ../src/insert/shapes.ts
+var squareH = (w) => +(w * (16 / 9)).toFixed(1);
+var FORMA_DEF = {
+  rect: { anch: 24, alto: 0.667, color: "#6366f1" },
+  ellipse: { anch: 16, alto: "cuadrado", color: "#22c55e" },
+  star: { anch: 16, alto: "cuadrado", color: "#f59e0b" },
+  triangle: { anch: 18, alto: "cuadrado", color: "#8b5cf6" },
+  // Globos: apaisados, y la cola necesita sitio abajo.
+  bubble: { anch: 26, alto: 0.85, color: "#38bdf8" },
+  "bubble-r": { anch: 26, alto: 0.85, color: "#f97316" },
+  "bubble-think": { anch: 24, alto: 1.05, color: "#a855f7" },
+  "bubble-shout": { anch: 22, alto: "cuadrado", color: "#ef4444" },
+  "bubble-oval": { anch: 26, alto: 0.85, color: "#38bdf8" },
+  "bubble-round": { anch: 22, alto: "cuadrado", color: "#38bdf8" },
+  "bubble-cloud": { anch: 28, alto: 0.8, color: "#a855f7" },
+  "bubble-brain": { anch: 26, alto: 0.9, color: "#f472b6" },
+  "bubble-flower": { anch: 24, alto: "cuadrado", color: "#a855f7" },
+  "bubble-up": { anch: 26, alto: 0.85, color: "#22c55e" },
+  "bubble-heart": { anch: 22, alto: "cuadrado", color: "#f43f5e" },
+  "bubble-whisper": { anch: 22, alto: 0.9, color: "#94a3b8" },
+  "bubble-double": { anch: 28, alto: 0.95, color: "#0ea5e9" },
+  "bubble-radio": { anch: 24, alto: "cuadrado", color: "#f59e0b" },
+  "bubble-scroll": { anch: 28, alto: 0.85, color: "#d4a373" },
+  "bubble-pointer": { anch: 30, alto: 0.7, color: "#14b8a6" },
+  // Flechas: anchas y bajas, que es como apunta una flecha.
+  "arrow-block": { anch: 26, alto: 0.62, color: "#0ea5e9" },
+  "arrow-double": { anch: 26, alto: 0.62, color: "#0ea5e9" },
+  "arrow-bent": { anch: 22, alto: 0.9, color: "#0ea5e9" },
+  "arrow-curved": { anch: 22, alto: 1, color: "#0ea5e9" },
+  "arrow-circular": { anch: 18, alto: "cuadrado", color: "#0ea5e9" },
+  chevron: { anch: 14, alto: 1.1, color: "#0ea5e9" },
+  // Marcas: verde lo correcto, rojo lo incorrecto. Sale así sin tocar nada.
+  check: { anch: 14, alto: "cuadrado", color: "#22c55e" },
+  cross: { anch: 13, alto: "cuadrado", color: "#ef4444" },
+  question: { anch: 12, alto: "cuadrado", color: "#f59e0b" },
+  exclaim: { anch: 9, alto: "cuadrado", color: "#f59e0b" },
+  // Geometría: cuadradas de verdad, porque en clase se miden y se comparan.
+  diamond: { anch: 16, alto: "cuadrado", color: "#8b5cf6" },
+  pentagon: { anch: 16, alto: "cuadrado", color: "#8b5cf6" },
+  hexagon: { anch: 16, alto: "cuadrado", color: "#8b5cf6" },
+  trapezoid: { anch: 18, alto: 0.9, color: "#8b5cf6" },
+  parallelogram: { anch: 20, alto: 0.7, color: "#8b5cf6" },
+  // Marcos y cintas: anchos, que es lo que enmarcan.
+  banner: { anch: 34, alto: 0.45, color: "#f43f5e" },
+  frame: { anch: 34, alto: 1, color: "#334155" },
+  note: { anch: 20, alto: 1, color: "#fbbf24" },
+  tag: { anch: 22, alto: 0.6, color: "#14b8a6" },
+  // Resaltadores: van encima de otra cosa, así que entran grandes.
+  "circle-mark": { anch: 30, alto: 0.6, color: "#ef4444" },
+  underline: { anch: 28, alto: 0.3, color: "#facc15" },
+  blob: { anch: 26, alto: "cuadrado", color: "#c4b5fd" }
+};
+
+// ../src/registro/esquemas.ts
+var texto = (que, o = {}) => ({ tipo: "texto", que, ...o });
+var html = (que) => ({ tipo: "html", que });
+var num2 = (que, o = {}) => ({ tipo: "numero", que, entero: true, ...o });
+var bool2 = (que) => ({ tipo: "booleano", que });
+var opcion = (que, valores, o = {}) => ({ tipo: "opcion", que, valores, ...o });
+var color = (que) => ({ tipo: "color", que });
+var imagen = (que, o = {}) => ({ tipo: "archivo", medio: "imagen", que, ...o });
+var audio = (que) => ({ tipo: "archivo", medio: "audio", que });
+var lista = (que, de, o = {}) => ({ tipo: "lista", que, de, ...o });
+var objeto = (que, campos, o = {}) => ({ tipo: "objeto", que, campos, ...o });
+var indice = (que, dentroDe) => ({ tipo: "indice", que, dentroDe, obligatorio: true });
+var sinConfig = () => ({ cfgSchema: null, ejemplo: null, donde: null });
+var ESQUEMAS_BOOSTERS = {
+  dice: {
+    donde: "wcfg",
+    cfgSchema: { campos: { dice: num2("Cu\xE1ntos dados se lanzan a la vez.", { min: 1, max: 6 }) } },
+    ejemplo: { dice: 2 }
+  },
+  wheel: {
+    donde: "wcfg",
+    cfgSchema: { campos: { names: lista("Los nombres entre los que sortea.", texto("Un nombre."), { min: 2, max: 60, obligatorio: true }) } },
+    ejemplo: { names: ["Ana", "Luis", "Mar\xEDa", "Carlos"] }
+  },
+  timer: {
+    donde: "wcfg",
+    cfgSchema: { campos: { seconds: num2("Cu\xE1nto dura la cuenta atr\xE1s, en segundos.", { min: 5, max: 3600 }) } },
+    ejemplo: { seconds: 90 }
+  },
+  score: {
+    donde: "wcfg",
+    cfgSchema: { campos: { teams: lista("Los equipos que se punt\xFAan.", texto("Nombre del equipo."), { min: 2, max: 8, obligatorio: true }) } },
+    ejemplo: { teams: ["Equipo A", "Equipo B", "Equipo C"] }
+  },
+  groups: {
+    donde: "wcfg",
+    cfgSchema: {
+      campos: {
+        names: lista("Los participantes que se van a repartir.", texto("Un nombre."), { min: 2, max: 60, obligatorio: true }),
+        teamCount: num2("En cu\xE1ntos equipos se reparten.", { min: 2, max: 8 })
+      }
+    },
+    ejemplo: { names: ["Ana", "Luis", "Mar\xEDa", "Carlos", "Sof\xEDa", "Diego"], teamCount: 3 }
+  },
+  soundboard: {
+    donde: "wcfg",
+    cfgSchema: {
+      campos: {
+        sounds: lista("Los botones de la botonera.", objeto("Un bot\xF3n.", {
+          label: texto("Lo que dice el bot\xF3n.", { obligatorio: true }),
+          src: audio("El sonido que suelta.")
+        }), { max: 12 })
+      },
+      nota: "Si un bot\xF3n no trae `src`, suena el efecto de f\xE1brica que le toca por posici\xF3n."
+    },
+    ejemplo: { sounds: [{ label: "Aplausos" }, { label: "Ding" }, { label: "Buzzer" }] }
+  },
+  mystery: {
+    donde: "wcfg",
+    cfgSchema: { campos: { items: lista("Lo que sale al azar, sin repetir hasta agotarse.", texto("Una palabra o pregunta."), { min: 2, max: 60, obligatorio: true }) } },
+    ejemplo: { items: ["apple", "happy", "run", "book", "blue", "friend"] }
+  },
+  // Un botón que suena y destella. No hay nada que llenar.
+  buzzer: sinConfig(),
+  // Las tres MONEDAS-HERRAMIENTA: no se configuran, se arrastran sobre otro objeto y actúan
+  // sobre ÉL (le cambian el `src`, le ponen `magic:true`, le cuelgan la lista `morph`).
+  // Para usarlas desde una máquina está `aplicar_booster`, no `configurar_booster`.
+  quitafondo: sinConfig(),
+  magichat: sinConfig(),
+  transformar: sinConfig(),
+  instructions: {
+    donde: "wcfg.ext",
+    cfgSchema: {
+      campos: {
+        title: texto("T\xEDtulo del panel.", { max: 80 }),
+        icon: texto("Un emoji para la moneda.", { max: 4 }),
+        bodyHtml: html("El contenido, con formato. Manda sobre `body` si vienen los dos."),
+        body: texto("Legado: texto plano, una instrucci\xF3n por l\xEDnea.")
+      },
+      nota: "Escribe en `bodyHtml`. `body` solo existe para los slides viejos."
+    },
+    ejemplo: {
+      title: "Instructions",
+      icon: "\u{1F4A1}",
+      bodyHtml: "<ol><li>Read the text on the board.</li><li>Discuss it with your partner.</li><li>Write three sentences.</li></ol>"
+    }
+  },
+  magicwand: {
+    donde: "wcfg.ext",
+    cfgSchema: {
+      campos: {
+        images: lista("Las im\xE1genes que la varita saca una a una.", objeto("Una imagen.", {
+          src: imagen("La imagen.", { obligatorio: true }),
+          label: texto("R\xF3tulo que se planta debajo. Vac\xEDo = sin r\xF3tulo.")
+        }), { max: 30 })
+      }
+    },
+    ejemplo: { images: [{ src: "https://assets.boosterarena.com/u/ej/cat.webp", label: "cat" }] }
+  },
+  tombola: {
+    donde: "wcfg.ext",
+    cfgSchema: {
+      campos: {
+        kind: opcion("Qu\xE9 sortea el bombo.", ["numbers", "words", "images"], { obligatorio: true }),
+        from: num2('Primer n\xFAmero del rango. Solo con `kind: "numbers"`.', { min: 0, max: 999 }),
+        to: num2('\xDAltimo n\xFAmero del rango. Solo con `kind: "numbers"`.', { min: 1, max: 999 }),
+        words: lista("Las bolas, si son palabras.", texto("Una palabra."), { max: 60 }),
+        images: lista("Las bolas, si son dibujos.", objeto("Una bola con dibujo.", {
+          src: imagen("El dibujo.", { obligatorio: true }),
+          label: texto("Nombre del dibujo.")
+        }), { max: 40 })
+      },
+      nota: "Llena SOLO el juego que corresponde a `kind`. Los topes son 200 n\xFAmeros, 60 palabras, 40 im\xE1genes."
+    },
+    ejemplo: { kind: "words", words: ["cat", "dog", "bird", "fish", "horse"] }
+  },
+  trafficlight: {
+    donde: "wcfg.ext",
+    cfgSchema: {
+      campos: {
+        start: opcion("Luz encendida al abrir el slide.", ["red", "amber", "green"]),
+        sound: bool2("Que suene al cambiar de luz."),
+        housing: imagen("PNG de la carcasa. Sin \xE9l, se dibuja con degradado.")
+      }
+    },
+    ejemplo: { start: "green", sound: true }
+  },
+  labelit: {
+    donde: "wcfg.ext",
+    cfgSchema: {
+      campos: {
+        src: imagen("La l\xE1mina que se etiqueta (c\xE9lula, mapa, un coraz\xF3n\u2026).", { obligatorio: true }),
+        aspect: { tipo: "numero", que: "Ancho/alto de la l\xE1mina. Lo calcula el editor al subirla.", min: 0.1, max: 10 },
+        title: texto("T\xEDtulo de la actividad."),
+        mode: opcion("C\xF3mo se juega: revelar al tocar, arrastrar las palabras, o escribirlas.", ["reveal", "drag", "type"]),
+        points: lista("Los puntos clavados sobre la l\xE1mina.", objeto("Un punto.", {
+          x: { tipo: "numero", que: "Posici\xF3n horizontal, en % del ancho de la l\xE1mina.", min: 0, max: 100, obligatorio: true },
+          y: { tipo: "numero", que: "Posici\xF3n vertical, en % del alto de la l\xE1mina.", min: 0, max: 100, obligatorio: true },
+          text: texto("C\xF3mo se llama esa parte.", { obligatorio: true })
+        }), { max: 20 }),
+        shuffle: bool2("Barajar las fichas en el modo arrastrar."),
+        sound: bool2("Sonidos de acierto y error."),
+        fontScale: { tipo: "numero", que: "Tama\xF1o del texto de los r\xF3tulos (1 = normal).", min: 0.7, max: 2.6 },
+        leadLen: { tipo: "numero", que: "Largo de la barrita del r\xF3tulo al punto, en % de la imagen.", min: 4, max: 45 }
+      },
+      nota: "Sin `src` no hay actividad: la l\xE1mina la pone el maestro o la f\xE1brica, nunca sale de f\xE1brica."
+    },
+    ejemplo: {
+      src: "https://assets.boosterarena.com/u/ej/celula.webp",
+      mode: "reveal",
+      shuffle: true,
+      sound: true,
+      points: [{ x: 50, y: 42, text: "nucleus" }, { x: 22, y: 61, text: "cytoplasm" }]
+    }
+  },
+  cycle: {
+    donde: "wcfg.ext",
+    cfgSchema: {
+      campos: {
+        title: texto('T\xEDtulo del proceso: "El ciclo del agua".'),
+        stages: lista("Las etapas de la rueda, en orden.", objeto("Una etapa.", {
+          id: texto("Identificador propio de la etapa. Si lo omites, lo pone el editor."),
+          text: texto("C\xF3mo se llama la etapa.", { obligatorio: true }),
+          src: imagen("Dibujo de la etapa."),
+          body: texto("Lo que se cuenta de esa etapa en el panel del centro.")
+        }), { min: 2, max: 8, obligatorio: true }),
+        closed: bool2("El proceso se repite (rueda) o termina (cadena)."),
+        guess: bool2("Modo Adivinar: los nombres salen ocultos hasta el clic."),
+        sound: bool2("Sonido al pasar de etapa.")
+      }
+    },
+    ejemplo: {
+      title: "The water cycle",
+      closed: true,
+      guess: false,
+      sound: true,
+      stages: [
+        { text: "Evaporation", body: "The sun heats the water and it rises as vapour." },
+        { text: "Condensation", body: "The vapour cools down and forms clouds." },
+        { text: "Precipitation", body: "The water falls as rain or snow." },
+        { text: "Collection", body: "The water gathers in rivers, lakes and the sea." }
+      ]
+    }
+  },
+  fracplot: {
+    donde: "wcfg.ext",
+    cfgSchema: {
+      campos: {
+        shape: opcion("Con qu\xE9 figura se dibuja la fracci\xF3n.", ["pie", "bar"]),
+        label: bool2("Escribir la fracci\xF3n dentro de la figura."),
+        color: num2("\xCDndice del color de la pr\xF3xima figura. Rota solo al estampar.", { min: 0, max: 11 }),
+        sound: bool2("Sonido al estampar.")
+      },
+      nota: "Es una HERRAMIENTA DE AUTOR\xCDA: no guarda las fracciones, las estampa en el slide como figuras. Configurarlo solo cambia c\xF3mo sale la SIGUIENTE."
+    },
+    ejemplo: { shape: "pie", label: true, color: 0, sound: true }
+  },
+  qr: {
+    donde: "wcfg.ext",
+    cfgSchema: {
+      campos: {
+        text: texto("Lo que se codifica: el enlace o el texto.", { obligatorio: true }),
+        kind: opcion("Si lo de arriba es un enlace o texto suelto.", ["url", "text"]),
+        dark: color("Color de los m\xF3dulos. Tiene que ser el OSCURO de los dos."),
+        light: color("Color del fondo, zona muda incluida."),
+        label: texto("R\xF3tulo debajo del c\xF3digo. Vac\xEDo = sin r\xF3tulo."),
+        plate: bool2("Tarjeta blanca con esquinas redondas y sombra."),
+        sound: bool2("El sonido de la boca al comerse el enlace.")
+      },
+      nota: "El c\xF3digo es EST\xC1TICO: el enlace va grabado en el dibujo, as\xED que sigue funcionando dentro del .zip exportado. Si cambias `text`, hay que regenerarlo."
+    },
+    ejemplo: { text: "https://boosterarena.com", kind: "url", label: "Escanea aqu\xED", plate: true, sound: true }
+  },
+  plotter: {
+    donde: "wcfg.ext",
+    cfgSchema: {
+      campos: {
+        eqs: lista("Las ecuaciones que se dibujan.", objeto("Una ecuaci\xF3n.", {
+          txt: texto('La ecuaci\xF3n tal cual se escribe: "y = x^2 - 3".', { obligatorio: true }),
+          color: color("Color de la curva."),
+          on: bool2("Si sale dibujada o apagada.")
+        }), { min: 1, max: 8, obligatorio: true }),
+        mode: opcion("Estudio plano o superficie girable.", ["2d", "3d"]),
+        dark: bool2("Cuadr\xEDcula sobre fondo oscuro."),
+        piAxis: bool2("Marcar el eje X en m\xFAltiplos de \u03C0."),
+        showCuts: bool2("Marcar los cortes entre curvas con sus coordenadas.")
+      },
+      nota: "Cada letra suelta (a, b, c) de una ecuaci\xF3n se vuelve un deslizador en el Player."
+    },
+    ejemplo: { mode: "2d", dark: true, showCuts: true, eqs: [{ txt: "y = x^2 - 3", on: true }, { txt: "y = 2x + 1", on: true }] }
+  },
+  // Retirado del catálogo el 2026-08-12 (Antonio se quedó con `fracplot`), pero su código sigue
+  // cableado para que los slides que ya lo tengan puesto sigan abriendo. Ficha declarada para
+  // que el candado no lo cuente como olvidado si algún día vuelve la tarjeta.
+  fractions: {
+    donde: "wcfg.ext",
+    cfgSchema: {
+      campos: {
+        mode: opcion("Qu\xE9 operaci\xF3n se manipula.", ["add", "compare"]),
+        title: texto("T\xEDtulo del riel."),
+        a: texto('Primera fracci\xF3n, escrita "1/2".', { obligatorio: true }),
+        b: texto('Segunda fracci\xF3n, escrita "1/3".', { obligatorio: true }),
+        labels: bool2("Escribir el valor en cada pieza."),
+        sound: bool2("Sonido al cortar una regleta.")
+      },
+      nota: "\u26A0\uFE0F RETIRADO de la galer\xEDa. No lo pongas en slides nuevos \u2014 usa `fracplot`."
+    },
+    ejemplo: { mode: "add", a: "1/2", b: "1/3", labels: true, sound: true }
+  }
+};
+var ESQUEMAS_ARENAS = {
+  classification: {
+    donde: "acfg",
+    cfgSchema: {
+      campos: {
+        categories: lista("Los montones a los que se arrastra.", texto("Nombre del mont\xF3n."), { min: 2, max: 4, obligatorio: true }),
+        items: lista("Las palabras que se reparten.", objeto("Una palabra y su mont\xF3n.", {
+          text: texto("La palabra.", { obligatorio: true }),
+          cat: indice("A qu\xE9 mont\xF3n pertenece (0 = el primero de `categories`).", "/categories")
+        }), { min: 2, max: 24, obligatorio: true })
+      },
+      nota: "Reparte las palabras entre TODAS las categor\xEDas: un mont\xF3n vac\xEDo se ve como un error en clase."
+    },
+    ejemplo: {
+      categories: ["Animals", "Plants"],
+      items: [
+        { text: "cat", cat: 0 },
+        { text: "hamster", cat: 0 },
+        { text: "dog", cat: 0 },
+        { text: "daisy", cat: 1 },
+        { text: "oak tree", cat: 1 },
+        { text: "tulip", cat: 1 }
+      ]
+    }
+  },
+  gameshow: {
+    donde: "acfg",
+    cfgSchema: {
+      campos: {
+        questions: lista("Las preguntas del concurso.", objeto("Una pregunta.", {
+          q: texto("El enunciado.", { obligatorio: true }),
+          options: lista("Las respuestas que se ofrecen.", texto("Una respuesta."), { min: 2, max: 4, obligatorio: true }),
+          answer: indice("Cu\xE1l de `options` es la correcta (0 = la primera).", "options")
+        }), { min: 1, max: 30, obligatorio: true })
+      },
+      nota: "Aqu\xED las opciones son TEXTO PLANO, no objetos. La Pirata y el Escape s\xED admiten imagen; este no."
+    },
+    ejemplo: {
+      questions: [
+        { q: "Which planet is the Red Planet?", options: ["Venus", "Mars", "Jupiter", "Saturn"], answer: 1 },
+        { q: "A group of wolves is called a ___.", options: ["pack", "herd", "school", "flock"], answer: 0 }
+      ]
+    }
+  },
+  race: {
+    donde: "acfg",
+    cfgSchema: {
+      campos: {
+        track: num2("Qu\xE9 circuito se corre.", { min: 0, max: 3 }),
+        laps: num2("Cu\xE1ntas vueltas dura la carrera.", { min: 1, max: 5 }),
+        questions: lista("Las preguntas que dan nitro.", objeto("Una pregunta.", {
+          q: texto("El enunciado.", { obligatorio: true }),
+          options: lista("Las respuestas que se ofrecen.", texto("Una respuesta."), { min: 2, max: 4, obligatorio: true }),
+          answer: indice("Cu\xE1l de `options` es la correcta (0 = la primera).", "options")
+        }), { min: 1, max: 30, obligatorio: true })
+      },
+      nota: "Misma forma de pregunta que el Game Show: opciones de texto plano."
+    },
+    ejemplo: {
+      track: 0,
+      questions: [
+        { q: "A baby dog is called a ___.", options: ["kitten", "puppy", "cub", "foal"], answer: 1 },
+        { q: "Water boils at 100 degrees ___.", options: ["Fahrenheit", "Celsius", "Kelvin", "Newton"], answer: 1 }
+      ]
+    }
+  },
+  pirate: {
+    donde: "acfg",
+    cfgSchema: {
+      campos: {
+        pirateQs: lista("Las preguntas de la batalla.", objeto("Una pregunta.", {
+          q: texto("El enunciado.", { obligatorio: true }),
+          image: imagen("Dibujo del enunciado."),
+          options: lista("Las respuestas.", objeto("Una respuesta.", {
+            text: texto("Lo que dice la respuesta."),
+            image: imagen("Dibujo de la respuesta.")
+          }), { min: 2, max: 4, obligatorio: true }),
+          answer: indice("Cu\xE1l de `options` es la correcta (0 = la primera).", "options")
+        }), { min: 1, max: 30, obligatorio: true }),
+        secs: num2("Segundos para contestar cada pregunta.", { min: 5, max: 120 }),
+        chests: bool2("Que el que acierta abra un cofre y pueda quitarle oro a otro.")
+      },
+      nota: "\u26A0\uFE0F EL CAMPO ES `pirateQs`, NO `questions`. Escribir en `questions` fue el fallo que tuvo esta arena hasta el 2026-08-14: se guardaba ah\xED, se le\xEDa de `pirateQs`, y la partida jugaba siempre las tres preguntas de f\xE1brica. Y sus opciones son OBJETOS `{text, image}`, no cadenas."
+    },
+    ejemplo: {
+      secs: 20,
+      chests: true,
+      pirateQs: [
+        { q: "Which sentence is correct?", answer: 0, options: [{ text: "She goes to school." }, { text: "She go to school." }, { text: "She going to school." }] },
+        { q: "Yesterday I ___ to the market.", answer: 1, options: [{ text: "go" }, { text: "went" }, { text: "gone" }] }
+      ]
+    }
+  },
+  mole: {
+    donde: "acfg",
+    cfgSchema: {
+      campos: {
+        prompt: texto('La consigna del campo: "\xA1Aplasta los topos con la oraci\xF3n correcta!".', { obligatorio: true }),
+        secs: num2("Cu\xE1nto dura la partida, en segundos.", { min: 20, max: 180 }),
+        sets: lista("Las tandas de carteles que van saliendo.", objeto("Una tanda.", {
+          options: lista("Los carteles de la tanda.", objeto("Un cartel.", {
+            text: texto("Lo que dice el cartel."),
+            image: imagen("Dibujo del cartel.")
+          }), { min: 2, max: 6, obligatorio: true }),
+          answer: indice("Cu\xE1l de `options` es la buena (0 = el primero).", "options")
+        }), { min: 1, max: 20, obligatorio: true })
+      },
+      nota: "Las opciones son objetos `{text, image}` \u2014 el campo de imagen se llama `image`, como en la Pirata."
+    },
+    ejemplo: {
+      prompt: "\xA1Aplasta los topos con la oraci\xF3n correcta!",
+      secs: 60,
+      sets: [
+        { answer: 0, options: [{ text: "She goes to school." }, { text: "She go to school." }, { text: "She going to school." }] },
+        { answer: 1, options: [{ text: "He don't like it." }, { text: "He doesn't like it." }, { text: "He not like it." }] }
+      ]
+    }
+  },
+  jigsaw: {
+    donde: "acfg",
+    cfgSchema: {
+      campos: {
+        imgs: lista("Los dibujos que se arman, uno por ronda.", objeto("Un dibujo.", {
+          src: imagen("El dibujo.", { obligatorio: true }),
+          title: texto('C\xF3mo se llama. Se ense\xF1a al terminar: "\xA1Armaste: The Solar System!".')
+        }), { min: 1, max: 8, obligatorio: true }),
+        level: opcion("En cu\xE1ntas piezas se corta cada dibujo.", ["easy", "normal", "hard"]),
+        prompt: texto("La consigna. Comparte campo con Topos.")
+      },
+      nota: "Con una imagen basta. Cada imagen de m\xE1s es una ronda m\xE1s."
+    },
+    ejemplo: {
+      level: "normal",
+      imgs: [{ src: "https://assets.boosterarena.com/u/ej/solar-system.webp", title: "The Solar System" }]
+    }
+  },
+  memory: {
+    donde: "acfg",
+    cfgSchema: {
+      campos: {
+        pairs: lista("Las parejas que hay que juntar.", objeto("Una pareja: sus dos caras.", {
+          a: objeto("Primera carta.", {
+            text: texto("Lo que dice la carta."),
+            image: imagen("Dibujo de la carta."),
+            audio: audio("Sonido al destaparla.")
+          }, { obligatorio: true }),
+          b: objeto("Segunda carta.", {
+            text: texto("Lo que dice la carta."),
+            image: imagen("Dibujo de la carta."),
+            audio: audio("Sonido al destaparla.")
+          }, { obligatorio: true })
+        }), { min: 2, max: 12, obligatorio: true }),
+        back: texto("Id del dorso de las cartas."),
+        mode: opcion("Individual o por equipos.", ["solo", "teams"]),
+        teams: num2('Cu\xE1ntos equipos. Solo cuenta con `mode: "teams"`.', { min: 2, max: 4 })
+      },
+      nota: "Cada carta admite texto, dibujo y sonido a la vez: imagen\u2194imagen, imagen\u2194palabra o palabra\u2194definici\xF3n. Una carta sin nada de eso sale en blanco."
+    },
+    ejemplo: {
+      back: "booster",
+      mode: "solo",
+      teams: 2,
+      pairs: [
+        { a: { text: "apple" }, b: { text: "a round red or green fruit" } },
+        { a: { text: "run" }, b: { text: "to move fast on your feet" } },
+        { a: { text: "winter" }, b: { text: "the coldest season of the year" } }
+      ]
+    }
+  },
+  "booster-escape": {
+    donde: "acfg",
+    cfgSchema: {
+      campos: {
+        escapeQuestions: lista("Las preguntas del laberinto.", objeto("Una pregunta.", {
+          text: texto("El enunciado."),
+          image: imagen("Dibujo del enunciado."),
+          audio: audio("Audio del enunciado."),
+          options: lista("Las salidas entre las que elegir.", objeto("Una salida.", {
+            text: texto("Lo que dice la salida."),
+            img: imagen("Dibujo de la salida.")
+          }), { min: 2, max: 4, obligatorio: true }),
+          answer: indice("Cu\xE1l de `options` es la correcta (0 = la primera).", "options")
+        }), { min: 1, max: 20, obligatorio: true }),
+        playerNames: lista("Los dos nombres del modo Versus.", texto("Nombre del jugador."), { min: 2, max: 2 })
+      },
+      nota: "\u26A0\uFE0F EL CAMPO ES `escapeQuestions`, NO `questions`. Y aqu\xED la imagen de una opci\xF3n se llama `img` (en la Pirata y en Topos se llama `image`). Es el nombre con el que la arena ven\xEDa de we-boosters y no se cambi\xF3, para que los proyectos ya hechos no salgan vac\xEDos."
+    },
+    ejemplo: {
+      escapeQuestions: [
+        { text: 'The opposite of "hot" is\u2026', answer: 1, options: [{ text: "warm" }, { text: "cold" }, { text: "dry" }] },
+        { text: "She ___ a book every week.", answer: 0, options: [{ text: "reads" }, { text: "read" }, { text: "reading" }] }
+      ]
+    }
+  },
+  "las-vegas": {
+    donde: "acfg",
+    cfgSchema: {
+      campos: {
+        reels: lista(
+          "Los rodillos, de izquierda a derecha. Cada uno es una columna que gira.",
+          lista("Las casillas de ese rodillo.", objeto("Una casilla: palabra o dibujo.", {
+            texto: texto("La palabra de la casilla."),
+            src: imagen("El dibujo de la casilla.")
+          }), { min: 2, max: 20 }),
+          { min: 1, max: 4, obligatorio: true }
+        )
+      },
+      nota: "Los rodillos construyen una FRASE al parar: SHE \xB7 WRITTEN \xB7 A LETTER. Piensa cada rodillo como una posici\xF3n de la oraci\xF3n, no como una lista de palabras sueltas. \u26A0\uFE0F La casilla usa `texto` y `src` (en espa\xF1ol), no `text`/`image` como el resto de las arenas."
+    },
+    ejemplo: {
+      reels: [
+        [{ texto: "SHE" }, { texto: "HE" }, { texto: "THEY" }],
+        [{ texto: "HAS WRITTEN" }, { texto: "HAVE WRITTEN" }],
+        [{ texto: "A LETTER" }, { texto: "A BOOK" }, { texto: "AN EMAIL" }]
+      ]
+    }
+  },
+  "word-storm": {
+    donde: "acfg",
+    cfgSchema: {
+      campos: {
+        words: lista("El mazo de palabras que caen y hay que teclear.", texto("Una palabra."), { min: 4, max: 80, obligatorio: true })
+      },
+      nota: "Palabras que se escriban con el teclado: sin tildes raras ni espacios si el nivel es bajo. La dificultad la sube la arena sola."
+    },
+    ejemplo: { words: ["apple", "house", "friend", "water", "school", "happy", "winter", "teacher"] }
+  }
+};
+var ESQUEMAS = { ...ESQUEMAS_BOOSTERS, ...ESQUEMAS_ARENAS };
+ESQUEMAS["classification-jungle"] = {
+  ...ESQUEMAS_ARENAS.classification,
+  ejemplo: {
+    categories: ["verbs", "nouns"],
+    items: [
+      { text: "run", cat: 0 },
+      { text: "jump", cat: 0 },
+      { text: "eat", cat: 0 },
+      { text: "cat", cat: 1 },
+      { text: "house", cat: 1 },
+      { text: "tree", cat: 1 }
+    ]
+  }
+};
+ESQUEMAS_ARENAS["classification-jungle"] = ESQUEMAS["classification-jungle"];
+var menuDeCurso = (queEs, propios, ejemplo) => ({
+  donde: "acfg",
+  cfgSchema: {
+    campos: {
+      ...propios,
+      title: texto("T\xEDtulo grande de bienvenida."),
+      subtitle: texto("Subt\xEDtulo bajo el t\xEDtulo."),
+      intro: texto("P\xE1rrafo de bienvenida."),
+      footer: texto("Texto de la barra inferior."),
+      logoImage: imagen("Logo. Si no hay, se usa `logoText`."),
+      logoText: texto("Texto del logo cuando no hay imagen."),
+      items: lista(
+        "Las tarjetas del men\xFA. Cada una es un DESTINO al que se puede navegar.",
+        objeto("Una tarjeta.", {
+          id: texto("Clave estable de la tarjeta."),
+          color: color("Color de acento de la tarjeta."),
+          title: texto('T\xEDtulo corto: "CONTENIDO".', { obligatorio: true }),
+          desc: texto("Descripci\xF3n breve."),
+          icon: imagen("Icono. Admite tambi\xE9n un emoji corto, que se pinta como texto.")
+        }),
+        { min: 1, max: 8, obligatorio: true }
+      )
+    },
+    nota: queEs + " \u26A0\uFE0F Deja `id` puesto en cada tarjeta: es lo que ata el destino de navegaci\xF3n aunque el maestro reordene o renombre. Sin `id` se cae a la POSICI\xD3N, y reordenar rompe la programaci\xF3n que ya hubiera hecho."
+  },
+  ejemplo
+});
+var TARJETAS_EJ = [
+  { id: "s1", color: "#14b8a6", title: "CONTENIDO", desc: "Los temas del curso." },
+  { id: "s2", color: "#3b82f6", title: "OBJETIVOS", desc: "Qu\xE9 vas a aprender." },
+  { id: "s3", color: "#8b5cf6", title: "EVALUACI\xD3N", desc: "Pon a prueba lo aprendido." }
+];
+ESQUEMAS_ARENAS["course-menu"] = menuDeCurso(
+  "Panel diagonal a la izquierda y tarjetas a la derecha.",
+  {
+    panelColor: color("Color del panel diagonal de la izquierda."),
+    accentColor: color("Color de acento: t\xEDtulo, rayitas, logo.")
+  },
+  { title: "BIENVENIDO", intro: "Elige una secci\xF3n para empezar.", accentColor: "#14b8a6", items: TARJETAS_EJ }
+);
+ESQUEMAS_ARENAS["course-menu-kids"] = menuDeCurso(
+  "Versi\xF3n infantil: cielo, personajes a los lados y tarjetas redondas.",
+  {
+    bgImage: imagen("Fondo. Si no hay, se dibuja el cielo con `bgColor`."),
+    bgColor: color("Color del cielo."),
+    leftImage: imagen("Personaje de la izquierda."),
+    rightImage: imagen("Personaje de la derecha."),
+    accentColor: color("Color de acento.")
+  },
+  { title: "\xA1BIENVENIDO!", subtitle: "Vamos a aprender", bgColor: "#7dd3fc", items: TARJETAS_EJ }
+);
+ESQUEMAS_ARENAS["course-menu-neon"] = menuDeCurso(
+  "Est\xE9tica teen oscura, con tarjetas que respiran.",
+  {
+    bgImage: imagen("Fondo. Si no hay, se usa el oscuro con `bgColor`."),
+    bgColor: color("Color del fondo oscuro."),
+    sideImage: imagen("Imagen de la derecha (estudiantes, personaje\u2026).")
+  },
+  { title: "\xA1BIENVENIDO!", subtitle: "Empieza aqu\xED", bgColor: "#0b1220", items: TARJETAS_EJ }
+);
+ESQUEMAS_ARENAS["course-menu-sparta"] = menuDeCurso(
+  "Mitolog\xEDa griega: medallones de bronce sobre piedra.",
+  {
+    bgImage: imagen("Fondo. Si no hay, se dibuja el \xE9pico con `bgColor`."),
+    bgColor: color("Color del fondo."),
+    sideImage: imagen("Guerrero o personaje de la derecha."),
+    motto: texto("Lema grabado bajo el t\xEDtulo."),
+    accentColor: color("Dorado de acento de los medallones.")
+  },
+  { title: "BIENVENIDO", motto: "Con esfuerzo, todo", accentColor: "#c9a24b", items: TARJETAS_EJ }
+);
+ESQUEMAS_ARENAS["duck-shooting"] = {
+  donde: "acfg",
+  cfgSchema: {
+    campos: {
+      questions: lista("Las preguntas de la caseta de tiro.", objeto("Una pregunta.", {
+        q: texto("El enunciado.", { obligatorio: true }),
+        options: lista("Los patos entre los que disparar.", texto("Una respuesta."), { min: 2, max: 4, obligatorio: true }),
+        answer: indice("Cu\xE1l de `options` es la correcta (0 = la primera).", "options")
+      }), { min: 1, max: 30, obligatorio: true })
+    },
+    nota: "Opciones de TEXTO PLANO, como el Game Show. Cortas: van escritas sobre un pato en movimiento."
+  },
+  ejemplo: {
+    questions: [
+      { q: "A baby cat is called a ___.", options: ["puppy", "kitten", "cub"], answer: 1 },
+      { q: 'The opposite of "big" is ___.', options: ["small", "tall", "wide"], answer: 0 }
+    ]
+  }
+};
+ESQUEMAS_ARENAS.jenga = {
+  donde: "acfg",
+  cfgSchema: {
+    campos: {
+      questions: lista(
+        "Las preguntas. Acertar no toca la torre; fallar saca una pieza hasta derrumbarla.",
+        objeto("Una pregunta.", {
+          q: texto("El enunciado.", { obligatorio: true }),
+          options: lista("Las respuestas.", texto("Una respuesta."), { min: 2, max: 4, obligatorio: true }),
+          answer: indice("Cu\xE1l de `options` es la correcta (0 = la primera).", "options")
+        }),
+        { min: 1, max: 30, obligatorio: true }
+      )
+    },
+    nota: "La torre es 3D con derrumbe f\xEDsico: pon preguntas de sobra para que la partida dure, porque la gracia est\xE1 en ver cu\xE1nto aguanta."
+  },
+  ejemplo: {
+    questions: [
+      { q: "She ___ to school every day.", options: ["go", "goes", "going"], answer: 1 },
+      { q: "They ___ playing football now.", options: ["is", "am", "are"], answer: 2 }
+    ]
+  }
+};
+ESQUEMAS_ARENAS["we-spelling-jenga"] = {
+  donde: "acfg",
+  cfgSchema: {
+    campos: {
+      words: lista("Las palabras que hay que deletrear en orden.", texto("Una palabra."), { min: 4, max: 60, obligatorio: true }),
+      playerNames: lista("Los nombres de los jugadores.", texto("Nombre."), { min: 2, max: 4 })
+    },
+    nota: "En MAY\xDASCULAS y sin tildes ni espacios: se deletrean letra a letra. De 5 a 8 letras van bien; las largas lucen la escala autom\xE1tica."
+  },
+  ejemplo: {
+    words: ["HOUSE", "WATER", "GREEN", "MUSIC", "FRIEND", "SCHOOL"],
+    playerNames: ["Player 1", "Player 2", "Player 3", "Player 4"]
+  }
+};
+ESQUEMAS_ARENAS["cellphone-challenge"] = {
+  donde: "acfg",
+  cfgSchema: {
+    campos: {
+      normalWords: lista("Reto NORMAL (multi-tap): palabras que se teclean.", texto("Una palabra."), { max: 40 }),
+      predictiveWords: lista("Reto PREDICTIVO: palabras que se teclean; son adem\xE1s el diccionario.", texto("Una palabra."), { max: 40 }),
+      decodeWords: lista("Reto DECODE: se ense\xF1an sus N\xDAMEROS y el alumno adivina la palabra.", texto("Una palabra."), { max: 40 }),
+      conversations: lista(
+        "Reto CONVERSATION: chats guiados donde el alumno teclea sus respuestas.",
+        objeto("Una conversaci\xF3n.", {
+          turns: lista("Los turnos, en orden.", objeto("Un turno.", {
+            from: opcion("Qui\xE9n habla: el otro o el alumno.", ["them", "you"], { obligatorio: true }),
+            text: texto("Lo que se dice. Si es del alumno, es lo que tiene que teclear.", { obligatorio: true })
+          }), { min: 2, max: 12, obligatorio: true })
+        }),
+        { max: 10 }
+      )
+    },
+    nota: "Son CUATRO retos independientes: llena el que vayas a usar, no hace falta llenarlos todos. En MAY\xDASCULAS y sin signos: se teclea con el teclado num\xE9rico de un tel\xE9fono viejo."
+  },
+  ejemplo: {
+    normalWords: ["HELLO", "FRIEND", "SCHOOL"],
+    decodeWords: ["WATER", "HOUSE"],
+    conversations: [{
+      turns: [
+        { from: "them", text: "HEY WHAT ARE YOU DOING" },
+        { from: "you", text: "I AM STUDYING ENGLISH" }
+      ]
+    }]
+  }
+};
+ESQUEMAS_BOOSTERS.revealer = {
+  donde: "wcfg.ext",
+  cfgSchema: {
+    campos: {
+      label: texto('El s\xEDmbolo grande de la tapa: "?", "1", una letra\u2026', { max: 4 }),
+      hint: texto('Pista peque\xF1a bajo el s\xEDmbolo: "Tap to reveal".', { max: 40 }),
+      theme: opcion("La car\xE1tula de la tapa.", ["aurora", "sunset", "ocean", "candy", "galaxy", "gold"])
+    },
+    nota: "Se coloca ENCIMA de una respuesta escrita en el slide y, al hacer clic, explota en confeti y revela lo de atr\xE1s. La tapa NO guarda la respuesta: la tapa solo tapa."
+  },
+  ejemplo: { label: "?", hint: "Tap to reveal", theme: "aurora" }
+};
+Object.assign(ESQUEMAS, ESQUEMAS_BOOSTERS, ESQUEMAS_ARENAS);
+
+// ../src/registro/validar.ts
+var esObjeto = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var ES_COLOR = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+var ES_ARCHIVO = /^(?:https?:\/\/|data:)/i;
+function mirarCampo(campo, valor, ruta, hermanos, raiz2, fallos) {
+  const mal = (dice) => {
+    fallos.push({ ruta, dice });
+  };
+  switch (campo.tipo) {
+    case "texto":
+    case "html": {
+      if (typeof valor !== "string") return mal(`tiene que ser texto, y lleg\xF3 ${tipoDe(valor)}`);
+      if (campo.tipo === "texto" && campo.max && valor.length > campo.max) mal(`se pasa de largo (${valor.length} de ${campo.max} caracteres como mucho)`);
+      return;
+    }
+    case "numero": {
+      if (typeof valor !== "number" || Number.isNaN(valor)) return mal(`tiene que ser un n\xFAmero, y lleg\xF3 ${tipoDe(valor)}`);
+      if (campo.entero && !Number.isInteger(valor)) mal(`tiene que ser un n\xFAmero entero, y lleg\xF3 ${valor}`);
+      if (campo.min !== void 0 && valor < campo.min) mal(`se queda corto (${valor}; el m\xEDnimo es ${campo.min})`);
+      if (campo.max !== void 0 && valor > campo.max) mal(`se pasa (${valor}; el m\xE1ximo es ${campo.max})`);
+      return;
+    }
+    case "booleano":
+      if (typeof valor !== "boolean") mal(`tiene que ser true o false, y lleg\xF3 ${tipoDe(valor)}`);
+      return;
+    case "opcion":
+      if (typeof valor !== "string" || !campo.valores.includes(valor))
+        mal(`solo admite ${campo.valores.map((v) => `"${v}"`).join(", ")} \u2014 y lleg\xF3 ${JSON.stringify(valor)}`);
+      return;
+    case "color":
+      if (typeof valor !== "string" || !ES_COLOR.test(valor)) mal(`tiene que ser un color hex tipo "#0f172a", y lleg\xF3 ${JSON.stringify(valor)}`);
+      return;
+    case "archivo":
+      if (typeof valor !== "string" || !ES_ARCHIVO.test(valor))
+        mal(`tiene que ser una URL de ${campo.medio} (https:// o data:), y lleg\xF3 ${JSON.stringify(valor)}`);
+      else if (valor.startsWith("blob:"))
+        mal("es una URL `blob:`, y esas no sobreviven al guardado \u2014 sube el archivo y usa la URL que devuelve");
+      return;
+    case "lista": {
+      if (!Array.isArray(valor)) return mal(`tiene que ser una lista, y lleg\xF3 ${tipoDe(valor)}`);
+      if (campo.min !== void 0 && valor.length < campo.min) mal(`necesita al menos ${campo.min} (llegaron ${valor.length})`);
+      if (campo.max !== void 0 && valor.length > campo.max) mal(`admite ${campo.max} como mucho (llegaron ${valor.length})`);
+      valor.forEach((v, i) => mirarCampo(campo.de, v, `${ruta}[${i}]`, hermanos, raiz2, fallos));
+      return;
+    }
+    case "objeto": {
+      if (!esObjeto(valor)) return mal(`tiene que ser un objeto, y lleg\xF3 ${tipoDe(valor)}`);
+      mirarCampos(campo.campos, valor, ruta, raiz2, fallos);
+      return;
+    }
+    case "indice": {
+      if (!Number.isInteger(valor)) return mal(`tiene que ser un n\xFAmero entero, y lleg\xF3 ${tipoDe(valor)}`);
+      const desdeRaiz = campo.dentroDe.startsWith("/");
+      const nombre = desdeRaiz ? campo.dentroDe.slice(1) : campo.dentroDe;
+      const donde = desdeRaiz ? raiz2 : hermanos;
+      const listaApuntada = donde[nombre];
+      if (!Array.isArray(listaApuntada)) {
+        return;
+      }
+      const n2 = valor;
+      if (n2 < 0 || n2 >= listaApuntada.length)
+        mal(`apunta a la posici\xF3n ${n2} de \`${nombre}\`, que solo tiene ${listaApuntada.length} (las posiciones v\xE1lidas van de 0 a ${listaApuntada.length - 1})`);
+      return;
+    }
+  }
+}
+function mirarCampos(campos, valor, ruta, raiz2, fallos) {
+  const bajo = (k) => ruta ? `${ruta}.${k}` : k;
+  for (const [nombre, campo] of Object.entries(campos)) {
+    const v = valor[nombre];
+    if (v === void 0 || v === null) {
+      if (campo.obligatorio) fallos.push({ ruta: bajo(nombre), dice: `falta, y hace falta: ${campo.que}` });
+      continue;
+    }
+    mirarCampo(campo, v, bajo(nombre), valor, raiz2, fallos);
+  }
+  for (const k of Object.keys(valor)) {
+    if (k in campos) continue;
+    const parecido = Object.keys(campos).find((c) => c.toLowerCase().includes(k.toLowerCase()) || k.toLowerCase().includes(c.toLowerCase()));
+    fallos.push({
+      ruta: bajo(k),
+      dice: `este campo no existe aqu\xED${parecido ? ` \u2014 \xBFquer\xEDas decir \`${parecido}\`?` : "."} Los que hay son: ${Object.keys(campos).join(", ")}`
+    });
+  }
+}
+function validarContra(schema, cfg) {
+  if (!esObjeto(cfg)) return [{ ruta: "(ra\xEDz)", dice: `la config tiene que ser un objeto, y lleg\xF3 ${tipoDe(cfg)}` }];
+  const fallos = [];
+  mirarCampos(schema.campos, cfg, "", cfg, fallos);
+  return fallos;
+}
+function validarCfgDe(tipo, cfg) {
+  const ficha = ESQUEMAS[tipo];
+  if (!ficha) {
+    const cerca = Object.keys(ESQUEMAS).filter((t) => t.includes(tipo) || tipo.includes(t));
+    return { ok: false, fallos: [{ ruta: "(tipo)", dice: `no existe ning\xFAn booster ni arena "${tipo}"${cerca.length ? ` \u2014 \xBFera "${cerca[0]}"?` : ""}` }] };
+  }
+  if (!ficha.cfgSchema) {
+    return { ok: false, fallos: [{ ruta: "(tipo)", dice: `"${tipo}" no tiene nada que configurar` }] };
+  }
+  const fallos = validarContra(ficha.cfgSchema, cfg);
+  return { ok: fallos.length === 0, fallos };
+}
+function tipoDe(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "una lista";
+  switch (typeof v) {
+    case "string":
+      return "texto";
+    case "number":
+      return "un n\xFAmero";
+    case "boolean":
+      return "true/false";
+    case "object":
+      return "un objeto";
+    default:
+      return typeof v;
+  }
+}
+function fallosEnTexto(fallos) {
+  return fallos.map((f) => `\xB7 ${f.ruta}: ${f.dice}`).join("\n");
+}
+
+// ../src/registro/describir.ts
+function linea(nombre, campo, sangria) {
+  const marca = campo.obligatorio ? ", obligatorio" : "";
+  const salida = [];
+  switch (campo.tipo) {
+    case "lista": {
+      const cuantos = campo.min !== void 0 || campo.max !== void 0 ? ` de ${campo.min ?? 1} a ${campo.max ?? "\u2026"}` : "";
+      salida.push(`${sangria}${nombre} (lista${cuantos}${marca}) \u2014 ${campo.que}`);
+      if (campo.de.tipo === "objeto") {
+        for (const [k, c] of Object.entries(campo.de.campos)) salida.push(...linea(k, c, `${sangria}    `));
+      } else if (campo.de.tipo === "lista") {
+        salida.push(...linea("cada una", campo.de, `${sangria}    `));
+      }
+      return salida;
+    }
+    case "objeto":
+      salida.push(`${sangria}${nombre} (objeto${marca}) \u2014 ${campo.que}`);
+      for (const [k, c] of Object.entries(campo.campos)) salida.push(...linea(k, c, `${sangria}    `));
+      return salida;
+    case "opcion":
+      return [`${sangria}${nombre} (uno de: ${campo.valores.join(" | ")}${marca}) \u2014 ${campo.que}`];
+    case "numero": {
+      const rango = campo.min !== void 0 && campo.max !== void 0 ? ` ${campo.min}\u2013${campo.max}` : "";
+      return [`${sangria}${nombre} (n\xFAmero${rango}${marca}) \u2014 ${campo.que}`];
+    }
+    case "indice":
+      return [`${sangria}${nombre} (posici\xF3n dentro de \`${campo.dentroDe}\`, empezando en 0${marca}) \u2014 ${campo.que}`];
+    case "archivo":
+      return [`${sangria}${nombre} (URL de ${campo.medio}${marca}) \u2014 ${campo.que}`];
+    case "booleano":
+      return [`${sangria}${nombre} (true/false${marca}) \u2014 ${campo.que}`];
+    case "color":
+      return [`${sangria}${nombre} (color hex, "#0f172a"${marca}) \u2014 ${campo.que}`];
+    default:
+      return [`${sangria}${nombre} (texto${marca}) \u2014 ${campo.que}`];
+  }
+}
+function cuerpo(schema) {
+  const filas = [];
+  for (const [k, c] of Object.entries(schema.campos)) filas.push(...linea(k, c, "  "));
+  return filas.join("\n");
+}
+function describirTipo(tipo) {
+  const ficha = ESQUEMAS[tipo];
+  if (!ficha) {
+    const cerca = Object.keys(ESQUEMAS).filter((t) => t.includes(tipo) || tipo.includes(t)).slice(0, 3);
+    return `No existe ning\xFAn booster ni arena "${tipo}".${cerca.length ? ` \xBFEra ${cerca.map((c) => `"${c}"`).join(" o ")}?` : ""}`;
+  }
+  if (!ficha.cfgSchema) return `"${tipo}" no tiene nada que configurar: se pone y ya funciona.`;
+  const partes = [
+    `Config de "${tipo}" (se guarda en ${ficha.donde}):`,
+    cuerpo(ficha.cfgSchema)
+  ];
+  if (ficha.cfgSchema.nota) {
+    const n2 = ficha.cfgSchema.nota;
+    partes.push(n2.startsWith("\u26A0") ? `
+${n2}` : `
+\u26A0\uFE0F ${n2}`);
+  }
+  if (ficha.ejemplo) partes.push(`
+Ejemplo que funciona:
+${JSON.stringify(ficha.ejemplo, null, 2)}`);
+  return partes.join("\n");
+}
+
+// ../src/canvas/robot/ejecutor.ts
+function porQueNo(r, familia) {
+  if (r.motivo === "premium") {
+    return `\xAB${r.etiqueta}\xBB es del plan Pro y esta cuenta no lo tiene, as\xED que no lo puedo poner. D\xCDSELO con \`responder\`, sin rodeos: que se activa desde boosterarena.com. Y ofr\xE9cele seguir con ${familia === "arena" ? "otra arena de las incluidas" : "otro booster de los incluidos"}, que quedarse sin nada es peor.`;
+  }
+  if (r.motivo === "no-listo") {
+    return `\xAB${r.etiqueta}\xBB todav\xEDa no est\xE1 construido: sale en el cat\xE1logo pero no se puede usar. Elige otro y dilo con \`responder\`.`;
+  }
+  return `No existe ning${familia === "arena" ? "una arena" : "\xFAn booster"} "${r.tipo}". Mira la lista que te di y usa uno de esos.`;
+}
+var n = 0;
+var nid = (p) => `rb${p}-${Date.now().toString(36)}-${(n++).toString(36)}${Math.random().toString(36).slice(2, 5)}`;
+var num3 = (v, def) => typeof v === "number" && Number.isFinite(v) ? v : def;
+var txt = (v) => typeof v === "string" ? v : "";
+var pct = (v, def) => Math.max(-40, Math.min(140, num3(v, def)));
+function nuevoBorrador(doc, escena, slide, pedido = "") {
+  return {
+    doc: structuredClone(doc),
+    escena,
+    slide,
+    pedido,
+    alias: /* @__PURE__ */ new Map(),
+    aliasCapa: /* @__PURE__ */ new Map(),
+    creados: [],
+    tocados: [],
+    bitacora: []
+  };
+}
+var PALABRAS_DE_BORRAR = /(borr|quit|elimin|saca|remov|delete|suprim|deshaz)/i;
+var QUITAR_UN_RASGO = /(?:quit|borr|elimin|sac|remov|limpi)\w*\s+(?:(?:el|la|los|las|su|sus|ese|esa|este|esta)\s+)*(?:fondo|fondos|color|colores|borde|bordes|sombra|sombras|relleno|marco|contorno|opacidad|efecto|efectos|movimiento|animacion)/gi;
+function pidi\u00F3Borrar(pedido) {
+  const plano = pedido.normalize("NFD").replace(/[̀-ͯ]/g, "");
+  return PALABRAS_DE_BORRAR.test(plano.replace(QUITAR_UN_RASGO, " "));
+}
+function colorDelEfecto(efecto, colorEfecto, colorTexto) {
+  if (!efecto || efecto === "none") return {};
+  if (colorEfecto) return { fxColor: colorEfecto };
+  if (efecto === "neon" && colorTexto) return { fxColor: colorTexto };
+  return {};
+}
+var escenaDe = (b) => b.doc[Math.min(b.escena, b.doc.length - 1)];
+var slideDe = (b) => {
+  const sc = escenaDe(b);
+  return sc.slides[Math.min(b.slide, sc.slides.length - 1)];
+};
+function listaDestino(b, capa) {
+  const s = slideDe(b);
+  const ref = txt(capa).trim();
+  if (!ref) return { els: s.base };
+  const capaObj = capaPorNombre(b, ref) ?? crearCapa(b, ref);
+  b.capaDeTrabajo = capaObj.id;
+  return { els: capaObj.els, dentroDe: capaObj.name };
+}
+function capaPorNombre(b, ref) {
+  const s = slideDe(b);
+  const id = b.aliasCapa.get(ref);
+  return s.layers.find((l) => l.id === id) ?? s.layers.find((l) => l.name.toLowerCase() === ref.toLowerCase()) ?? s.layers.find((l) => l.name.toLowerCase().includes(ref.toLowerCase()));
+}
+function crearCapa(b, ref) {
+  const s = slideDe(b);
+  const capa = { id: nid("capa"), name: ref || `Capa ${s.layers.length + 1}`, els: [] };
+  s.layers.push(capa);
+  if (ref) b.aliasCapa.set(ref, capa.id);
+  b.capaDeTrabajo = capa.id;
+  b.bitacora.push(`\u{1F4D1} Capa \xAB${capa.name}\xBB`);
+  return capa;
+}
+function* todasLasListas(b) {
+  for (const sc of b.doc) for (const sl of sc.slides) {
+    yield sl.base;
+    for (const l of sl.layers) yield l.els;
+  }
+}
+function buscarEl(b, ref) {
+  const id = b.alias.get(ref.trim()) ?? ref.trim();
+  const s = slideDe(b);
+  const aqu\u00ED = s.base.find((e) => e.id === id) ?? s.layers.flatMap((l) => l.els).find((e) => e.id === id);
+  if (aqu\u00ED) return aqu\u00ED;
+  for (const lista2 of todasLasListas(b)) {
+    const e = lista2.find((x) => x.id === id);
+    if (e) return e;
+  }
+  return null;
+}
+function buscarCapa(b, id) {
+  for (const sc of b.doc) for (const sl of sc.slides) {
+    const l = sl.layers.find((x) => x.id === id);
+    if (l) return l;
+  }
+  return void 0;
+}
+function plantar(b, el, ref, capa) {
+  const { els, dentroDe } = listaDestino(b, capa);
+  els.push(el);
+  const r = txt(ref).trim();
+  if (r) b.alias.set(r, el.id);
+  b.creados.push(el.id);
+  b.tocados.push(el.id);
+  return { el, dentroDe };
+}
+function altoTexto(texto2, w, fontSize) {
+  const anchoPx = w / 100 * 1920;
+  const porRenglon = Math.max(1, Math.floor(anchoPx / (fontSize * 0.55)));
+  const renglones = texto2.split("\n").reduce((t, linea2) => t + Math.max(1, Math.ceil(linea2.length / porRenglon)), 0);
+  return Math.max(4, +(renglones * fontSize * 1.3 / 1080 * 100).toFixed(1));
+}
+var ALTO_MAX_DIBUJO = 58;
+function cajaImagen(w, aspect) {
+  const alto = w * (16 / 9) / (aspect || 1);
+  if (alto <= ALTO_MAX_DIBUJO) return { w, h: +alto.toFixed(1) };
+  const k = ALTO_MAX_DIBUJO / alto;
+  return { w: +(w * k).toFixed(1), h: ALTO_MAX_DIBUJO };
+}
+function encajar(el) {
+  el.w = Math.max(2, Math.min(100, el.w));
+  el.h = Math.max(2, Math.min(100, el.h));
+  el.x = +Math.max(0, Math.min(100 - el.w, el.x)).toFixed(2);
+  el.y = +Math.max(0, Math.min(100 - el.h, el.y)).toFixed(2);
+  return el;
+}
+function armarEvento(a, el) {
+  switch (txt(a.evento)) {
+    case "hover":
+      return { type: "hover" };
+    case "slideStart":
+      return { type: "slideStart" };
+    case "layerShown":
+      return { type: "layerShown" };
+    case "time":
+      return { type: "time", seconds: Math.max(0, num3(a.segundos, 3)) };
+    case "clickStep":
+      return { type: "clickStep", step: Math.max(1, Math.round(num3(a.paso, 1))) };
+    case "trayectoriaTerminada": {
+      const nombre = txt(a.trayectoria).trim().toLowerCase();
+      const suyas = el.motions ?? [];
+      const cam = (nombre ? suyas.find((m) => m.name.toLowerCase().includes(nombre)) : void 0) ?? suyas[0];
+      return cam ? { type: "motionEnd", motionId: cam.id } : { type: "click" };
+    }
+    default:
+      return { type: "click" };
+  }
+}
+function armarAccion(b, a, el) {
+  const s = slideDe(b);
+  switch (txt(a.accion)) {
+    case "cerrarCapa":
+      return { accion: { type: "closeLayer" } };
+    case "reiniciarSecuencia":
+      return { accion: { type: "resetSequence" } };
+    case "abrirCapa": {
+      const ref = txt(a.capa).trim();
+      const capa = capaPorNombre(b, ref) ?? crearCapa(b, ref);
+      return { accion: { type: "showLayer", layerId: capa.id } };
+    }
+    case "irAEscena": {
+      const q = txt(a.escena).trim().toLowerCase();
+      const sc = b.doc.find((x) => x.name.toLowerCase() === q) ?? b.doc.find((x) => x.name.toLowerCase().includes(q));
+      if (!sc) return { accion: null, fallo: `No hay ninguna escena llamada "${txt(a.escena)}". Las que hay: ${b.doc.map((x) => x.name).join(", ")}.` };
+      return { accion: { type: "goScene", sceneId: sc.id } };
+    }
+    case "irASlide": {
+      const i = Math.round(num3(a.slide, 0)) - 1;
+      const destino = escenaDe(b).slides[i];
+      if (!destino) return { accion: null, fallo: `Esta escena tiene ${escenaDe(b).slides.length} slides; no existe el n\xFAmero ${num3(a.slide, 0)}.` };
+      return { accion: { type: "goSlide", slideId: destino.id } };
+    }
+    case "leerEnVoz": {
+      const t = txt(a.texto).trim();
+      if (!t) return { accion: null, fallo: "Para leer en voz alta hace falta el texto." };
+      return { accion: { type: "speak", text: t, lang: txt(a.idioma) || "en-US" } };
+    }
+    case "abrirEnlace": {
+      const u = txt(a.url).trim();
+      if (!/^https?:\/\//i.test(u)) return { accion: null, fallo: "El enlace tiene que empezar por https://." };
+      return { accion: { type: "openUrl", url: u } };
+    }
+    case "moverPorTrayectoria": {
+      const d = txt(a.destino).trim();
+      const quien = d ? buscarEl(b, d) : null;
+      if (d && !quien) return { accion: null, fallo: `No encuentro el objeto "${d}" para moverlo.` };
+      const movido = quien ?? buscarEl(b, txt(a.objetivo));
+      if (!movido) return { accion: null, fallo: "No s\xE9 qu\xE9 objeto tiene que moverse." };
+      const nombre = txt(a.trayectoria).trim().toLowerCase();
+      const suyas = movido.motions ?? [];
+      const cam = (nombre ? suyas.find((m) => m.name.toLowerCase().includes(nombre)) : void 0) ?? suyas[0];
+      if (cam) return { accion: { type: "playMotion", targetId: movido.id, motionId: cam.id } };
+      const nuevo = { id: nid("mo"), name: txt(a.trayectoria) || "Trayectoria 1", path: [], duration: 2e3 };
+      movido.motions = [...suyas, nuevo];
+      b.tocados.push(movido.id);
+      if (!b.pedirDibujo) b.pedirDibujo = { elId: movido.id, motionId: nuevo.id };
+      b.bitacora.push(`\u270F\uFE0F ${describirEl(movido)} necesita su camino: te dejo listo para dibujarlo`);
+      return { accion: { type: "playMotion", targetId: movido.id, motionId: nuevo.id } };
+    }
+    case "sonar": {
+      const d = txt(a.destino).trim();
+      const audio2 = d ? buscarEl(b, d) : el.kind === "audio" ? el : null;
+      if (audio2 && audio2.kind === "audio" && audio2.id === el.id && txt(a.evento) === "click") {
+        return {
+          accion: null,
+          fallo: "No hace falta: un audio ya suena solo al tocarlo. Para que suene AL ABRIRSE LA CAPA, programa ese mismo audio con evento layerShown (accion sonar, destino \xE9l mismo). Para que suene al tocar OTRO objeto, el objetivo es ese objeto y el destino, el audio."
+        };
+      }
+      if (!audio2) {
+        const hay = [...s.base, ...s.layers.flatMap((l) => l.els)].filter((e) => e.kind === "audio");
+        return {
+          accion: null,
+          fallo: hay.length ? `Dime cu\xE1l audio: ${hay.map((e) => `${e.id} ("${e.name ?? "sin nombre"}")`).join(", ")}.` : "Este slide no tiene ning\xFAn audio puesto. El maestro tiene que subirlo primero con el bot\xF3n Audio."
+        };
+      }
+      if (audio2.kind !== "audio") return { accion: null, fallo: `"${d}" no es un audio.` };
+      return { accion: { type: "playSound", targetId: audio2.id } };
+    }
+    case "ocultar": {
+      const d = txt(a.destino).trim();
+      const otro = d ? buscarEl(b, d) : null;
+      if (d && !otro) return { accion: null, fallo: `No encuentro el objeto "${d}" para ocultarlo.` };
+      return { accion: { type: "hideEl", targetId: otro?.id ?? "" } };
+    }
+    default:
+      return { accion: null };
+  }
+}
+function ejecutar(b, nombre, args, fab) {
+  switch (nombre) {
+    // ── Poner cosas ──────────────────────────────────────────────────────────
+    case "poner_texto": {
+      const texto2 = txt(args.texto) || "Texto";
+      const w = pct(args.w, 40);
+      const fontSize = Math.max(10, Math.min(220, num3(args.tamano, 44)));
+      const el = encajar({
+        id: nid("txt"),
+        kind: "text",
+        x: pct(args.x, 30),
+        y: pct(args.y, 40),
+        w,
+        h: altoTexto(texto2, w, fontSize),
+        text: texto2,
+        fontSize,
+        color: txt(args.color) || "#111827",
+        align: ["left", "center", "right", "justify"].find((v) => v === args.align) ?? "center",
+        ...txt(args.efecto) && args.efecto !== "none" ? { effect: txt(args.efecto) } : {},
+        ...colorDelEfecto(txt(args.efecto), txt(args.color_efecto), txt(args.color)),
+        // `motion` se escribe SIEMPRE, aunque sea 'none': es la señal de que el elemento está
+        // en el formato nuevo de dos categorías (ver `normalizeFx` en shared/textEffects).
+        motion: txt(args.movimiento) || "none",
+        ...args.mayusculas === true ? { caps: true } : {},
+        ...num3(args.peso, 0) >= 400 ? { weight: Math.round(num3(args.peso, 400)) } : {}
+      });
+      const { dentroDe } = plantar(b, el, args.ref, args.capa);
+      b.bitacora.push(`\u{1F163} \xAB${texto2.length > 40 ? `${texto2.slice(0, 40)}\u2026` : texto2}\xBB${dentroDe ? ` en la capa \xAB${dentroDe}\xBB` : ""}`);
+      return `Texto puesto (id ${el.id}).`;
+    }
+    case "poner_dibujo": {
+      const busca = txt(args.busca);
+      const hallado = buscarDibujo(busca);
+      if (!hallado) {
+        return `La biblioteca no tiene nada parecido a "${busca}". Prueba con otra palabra m\xE1s com\xFAn y en singular, o resu\xE9lvelo con una figura o un emoji.`;
+      }
+      const pedido = pct(args.w, 20);
+      const caja = cajaImagen(pedido, hallado.aspect);
+      const el = encajar({
+        id: nid("img"),
+        kind: "image",
+        x: pct(args.x, 40),
+        y: pct(args.y, 35),
+        w: caja.w,
+        h: caja.h,
+        src: hallado.src,
+        aspect: hallado.aspect
+      });
+      const { dentroDe } = plantar(b, el, args.ref, args.capa);
+      b.bitacora.push(`\u{1F5BC}\uFE0F ${hallado.nombre}${dentroDe ? ` en la capa \xAB${dentroDe}\xBB` : ""}`);
+      const encogido = caja.w < pedido - 0.5 ? ` Es un dibujo alto, as\xED que entr\xF3 a ${caja.w}% de ancho y ${caja.h}% de alto en vez de ${pedido}%.` : "";
+      const conformado = hallado.exacto ? "" : ` \u26A0\uFE0F OJO: no hay nada que sea "${busca}" en la biblioteca. Lo m\xE1s cercano fue "${hallado.nombre}"${hallado.pedidas > 1 ? ` (encajaron ${hallado.encajadas} de ${hallado.pedidas} palabras)` : ""}. Si no te sirve, prueba otra palabra m\xE1s com\xFAn, o dile al maestro con \`responder\` que ese dibujo no lo tenemos y que lo suba \xE9l.`;
+      return `Puesto el dibujo "${hallado.nombre}" (id ${el.id}).${encogido}${conformado}`;
+    }
+    // ── Archivos que trae quien llama, no la biblioteca ──────────────────────
+    // `poner_dibujo` busca en NUESTRO catálogo. Estas dos ponen un archivo que ya está subido:
+    // es la puerta por la que entra lo que genera una fábrica de fuera (Flux para las imágenes,
+    // un TTS para la voz) sin que Booster tenga que generarlo. Un MP3 de un TTS y un MP3 que
+    // subió un maestro son el MISMO elemento con una URL de R2: el documento no los distingue.
+    case "poner_imagen": {
+      const url = txt(args.url).trim();
+      if (!/^https?:\/\//i.test(url)) {
+        return "La `url` tiene que ser una direcci\xF3n https:// de un archivo ya SUBIDO. Si el archivo est\xE1 en el disco, s\xFAbelo antes con `subir_imagen` y usa la URL que te devuelva. Una ruta local no vale: el maestro abre el proyecto en otra computadora.";
+      }
+      const pedido = pct(args.w, 25);
+      const proporcion = num3(args.proporcion, 1) || 1;
+      const caja = cajaImagen(pedido, proporcion);
+      const el = encajar({
+        id: nid("img"),
+        kind: "image",
+        x: pct(args.x, 38),
+        y: pct(args.y, 30),
+        w: caja.w,
+        h: caja.h,
+        src: url,
+        aspect: proporcion
+      });
+      const { dentroDe } = plantar(b, el, args.ref, args.capa);
+      b.bitacora.push(`\u{1F5BC}\uFE0F Imagen subida${dentroDe ? ` en la capa \xAB${dentroDe}\xBB` : ""}`);
+      return `Puesta la imagen (id ${el.id}).`;
+    }
+    case "poner_audio": {
+      const url = txt(args.url).trim();
+      if (!/^https?:\/\//i.test(url)) {
+        return "La `url` tiene que ser una direcci\xF3n https:// de un audio ya SUBIDO. S\xFAbelo antes con `subir_audio` y usa la URL que te devuelva.";
+      }
+      const el = {
+        id: nid("audio"),
+        kind: "audio",
+        x: 102,
+        y: 4 + b.creados.length % 8 * 8,
+        w: 16,
+        h: 7,
+        src: url,
+        name: txt(args.nombre) || "Audio"
+      };
+      plantar(b, el, args.ref, void 0);
+      b.bitacora.push(`\u{1F50A} Audio \xAB${el.name}\xBB`);
+      return `Puesto el audio "${el.name}" (id ${el.id}). Est\xE1 FUERA del slide, como un mando: para que suene, progr\xE1malo con \`programar\` (al hacer clic \u2192 reproducir audio) o ponlo al iniciar el slide.`;
+    }
+    case "poner_figura": {
+      const forma = txt(args.forma) || "rect";
+      const def = FORMA_DEF[forma] ?? FORMA_DEF.rect;
+      const w = pct(args.w, def.anch);
+      const el = encajar({
+        id: nid("fig"),
+        kind: "shape",
+        shape: forma,
+        x: pct(args.x, 40),
+        y: pct(args.y, 35),
+        w,
+        h: def.alto === "cuadrado" ? squareH(w) : squareH(w) * def.alto,
+        fill: txt(args.color) || def.color,
+        strokeW: 0,
+        strokeStyle: "solid",
+        ...forma === "rect" ? { radius: 0 } : {},
+        ...forma === "star" ? { spikes: 5 } : {}
+      });
+      const { dentroDe } = plantar(b, el, args.ref, args.capa);
+      b.bitacora.push(`\u25C7 Figura ${forma}${dentroDe ? ` en la capa \xAB${dentroDe}\xBB` : ""}`);
+      return `Figura puesta (id ${el.id}).`;
+    }
+    case "poner_boton": {
+      const w = pct(args.w, 26);
+      const el = encajar({
+        id: nid("btn"),
+        kind: "shape",
+        shape: "button",
+        btnShape: "pill",
+        btnIcon: txt(args.icono) || "none",
+        x: pct(args.x, 37),
+        y: pct(args.y, 42),
+        w,
+        h: 11,
+        fill: txt(args.color) || "#6366f1",
+        color: "#ffffff",
+        text: txt(args.texto) || "Bot\xF3n",
+        fontSize: 46
+      });
+      const { dentroDe } = plantar(b, el, args.ref, args.capa);
+      b.bitacora.push(`\u{1F518} Bot\xF3n \xAB${el.text}\xBB${dentroDe ? ` en la capa \xAB${dentroDe}\xBB` : ""}`);
+      return `Bot\xF3n puesto (id ${el.id}). Progr\xE1malo con \`programar\` si a\xFAn no lo hiciste.`;
+    }
+    case "poner_emoji": {
+      const w = pct(args.w, 12);
+      const el = encajar({
+        id: nid("emo"),
+        kind: "emoji",
+        x: pct(args.x, 44),
+        y: pct(args.y, 40),
+        w,
+        h: squareH(w),
+        text: txt(args.emoji) || "\u2728"
+      });
+      const { dentroDe } = plantar(b, el, args.ref, args.capa);
+      b.bitacora.push(`${el.text} Emoji${dentroDe ? ` en la capa \xAB${dentroDe}\xBB` : ""}`);
+      return `Emoji puesto (id ${el.id}).`;
+    }
+    case "poner_zona_caliente": {
+      const forma = ["ellipse", "rect", "triangle"].find((v) => v === args.forma) ?? "ellipse";
+      const w = pct(args.w, 18);
+      const el = encajar({
+        id: nid("zona"),
+        kind: "shape",
+        shape: forma,
+        hotspot: true,
+        x: pct(args.x, 40),
+        y: pct(args.y, 35),
+        w,
+        h: num3(args.alto, 0) > 0 ? pct(args.alto, 20) : squareH(w),
+        ...forma === "rect" ? { radius: 6 } : {}
+      });
+      const { dentroDe } = plantar(b, el, args.ref, args.capa);
+      b.bitacora.push(`\u{1F3AF} Zona caliente${dentroDe ? ` en la capa \xAB${dentroDe}\xBB` : ""}`);
+      return `Zona caliente puesta (id ${el.id}). Es invisible al proyectar: progr\xE1male qu\xE9 hace al tocarla.`;
+    }
+    case "poner_fondo": {
+      const color2 = txt(args.color).trim();
+      const busca = txt(args.busca).trim();
+      if (busca) {
+        const f = buscarFondo(busca);
+        if (!f) return `No hay ning\xFAn fondo parecido a "${busca}". Puedes poner un color liso.`;
+        slideDe(b).background = f.src;
+        b.bitacora.push(`\u{1F3DE}\uFE0F Fondo: ${f.nombre}`);
+        return `Fondo puesto: "${f.nombre}".`;
+      }
+      if (!color2) return "Dime un color o una escena a buscar.";
+      slideDe(b).background = color2;
+      b.bitacora.push(`\u{1F3A8} Fondo ${color2}`);
+      return "Fondo de color puesto.";
+    }
+    case "poner_booster": {
+      const tipo = txt(args.tipo);
+      const hecho = fab.nuevoWidget(tipo);
+      if (!hecho.ok) return porQueNo(hecho, "booster");
+      const base = hecho.el;
+      const w = num3(args.w, 0) > 0 ? pct(args.w, base.w) : base.w;
+      const el = encajar({
+        ...base,
+        id: nid("wdg"),
+        x: pct(args.x, base.x),
+        y: pct(args.y, base.y),
+        w,
+        h: +(base.h * (w / base.w)).toFixed(1)
+      });
+      const { dentroDe } = plantar(b, el, args.ref, args.capa);
+      b.bitacora.push(`\u2699\uFE0F Booster ${tipo}${dentroDe ? ` en la capa \xAB${dentroDe}\xBB` : ""}`);
+      return `Booster "${tipo}" puesto (id ${el.id}).`;
+    }
+    // ── USAR un booster de los que se ARRASTRAN sobre un objeto ───────────────
+    // Tres boosters no se «ponen»: se USAN encima de algo. El maestro coge la moneda y la
+    // suelta sobre la imagen. Hasta ahora el robot solo sabía dejar la moneda tirada en el
+    // slide, así que a «quítale el fondo a esta imagen» no tenía ninguna forma de obedecer
+    // — y acabó llamando a `borrar`.
+    //
+    // Aquí se hace la mitad que cabe en el documento: crear la moneda y CENTRARLA sobre el
+    // objetivo, exactamente donde la deja el maestro al soltarla. La otra mitad —el bicho
+    // comiendo, la llamada al recortador, el diálogo del Transformador— la remata el editor
+    // con `pedirSoltar`, por el mismo camino de siempre (`maybeDropCamaleon` y compañía):
+    // NO se duplica ni una regla, o el robot y el maestro acabarían haciendo cosas distintas.
+    case "aplicar_booster": {
+      const tipo = txt(args.tipo);
+      const el = buscarEl(b, txt(args.objetivo));
+      if (!el) return `No encuentro ning\xFAn objeto "${txt(args.objetivo)}".`;
+      if (b.pedirSoltar) {
+        return "Solo puedo aplicar UNA de estas monedas por tanda (cada una lanza su propia animaci\xF3n y hay que verlas de una en una). Dile al maestro que te pida la siguiente.";
+      }
+      if (!slideDe(b).base.some((x) => x.id === el.id)) {
+        return `${describirEl(el)} no est\xE1 suelto en el slide (est\xE1 dentro de una capa), y estas monedas solo se sueltan sobre lo que est\xE1 en el slide. Dile al maestro que lo saque de la capa, o que lo haga \xE9l arrastrando la moneda.`;
+      }
+      if ((tipo === "quitafondo" || tipo === "magichat") && !(el.kind === "image" && el.src)) {
+        return `El booster "${tipo}" solo funciona sobre una IMAGEN, y ${describirEl(el)} no lo es. D\xEDselo al maestro con \`responder\`.`;
+      }
+      if (tipo === "transformar" && (el.kind === "widget" || el.kind === "arena" || el.kind === "audio")) {
+        return "El Transformador va sobre una imagen, una figura o un texto, no sobre otro booster.";
+      }
+      const hecho = fab.nuevoWidget(tipo);
+      if (!hecho.ok) return porQueNo(hecho, "booster");
+      const base = hecho.el;
+      const moneda = encajar({
+        ...base,
+        id: nid("wdg"),
+        x: el.x + el.w / 2 - base.w / 2,
+        y: el.y + el.h / 2 - base.h / 2
+      });
+      slideDe(b).base.push(moneda);
+      b.tocados.push(el.id);
+      b.pedirSoltar = { tipo, moneda, objetivo: el };
+      b.bitacora.push(tipo === "quitafondo" ? `\u{1F98E} Fondo quitado: ${describirEl(el)}` : tipo === "magichat" ? `\u{1F3A9} En silueta hasta que la toquen: ${describirEl(el)}` : `\u{1F500} Transformador puesto sobre ${describirEl(el)}`);
+      return tipo === "transformar" ? `El Transformador ya est\xE1 sobre ${describirEl(el)} y el editor le abrir\xE1 al maestro el di\xE1logo para elegir en qu\xE9 se convierte. Dile que elija ah\xED las im\xE1genes.` : `Hecho: "${tipo}" aplicado sobre ${describirEl(el)} (id ${el.id}).`;
+    }
+    case "poner_arena": {
+      const tipo = txt(args.tipo);
+      const hecha = fab.nuevaArena(tipo);
+      if (!hecha.ok) return porQueNo(hecha, "arena");
+      const s = slideDe(b);
+      if (s.base.some((e) => e.kind !== "arena")) {
+        nuevoSlide(b, `Actividad \xB7 ${tipo}`);
+        b.bitacora.push("\u{1F4C4} Slide nuevo para la arena (una arena ocupa el slide entero)");
+      }
+      const destino = slideDe(b);
+      const el = { ...hecha.el, id: nid("arena") };
+      destino.base = [...destino.base.filter((e) => e.kind !== "arena"), el];
+      const refArena = txt(args.ref).trim();
+      if (refArena) b.alias.set(refArena, el.id);
+      b.creados.push(el.id);
+      b.tocados.push(el.id);
+      b.bitacora.push(`\u{1F3DF}\uFE0F Arena ${tipo}`);
+      return `Arena "${tipo}" puesta (id ${el.id}). Trae preguntas de MUESTRA, que no son las de esta clase: ll\xE1mala con \`describir("${tipo}")\` y luego \`configurar_arena\` para llenarla con el contenido de verdad. Si la dejas as\xED, el maestro se encuentra las de f\xE1brica en clase.`;
+    }
+    // ── Llenar lo que ya está puesto ─────────────────────────────────────────
+    // Poner una arena vacía no adelanta nada: LLENAR es el trabajo. Ver `src/registro/`.
+    case "describir":
+      return describirTipo(txt(args.tipo));
+    case "configurar_arena": {
+      const objetivo = txt(args.objetivo).trim();
+      const el = objetivo ? buscarEl(b, objetivo) : slideDe(b).base.find((e) => e.kind === "arena") ?? null;
+      if (!el) {
+        return objetivo ? `No encuentro ninguna arena "${objetivo}".` : "En este slide no hay ninguna arena que llenar. Ponla antes con `poner_arena`.";
+      }
+      if (el.kind !== "arena" || !el.arena) return `${describirEl(el)} no es una arena, as\xED que no tiene qu\xE9 llenarle.`;
+      const cfg = leerJson(args.cfg);
+      if ("error" in cfg) return cfg.error;
+      const r = validarCfgDe(el.arena, cfg.valor);
+      if (!r.ok) {
+        return `Esa configuraci\xF3n no vale para la arena "${el.arena}":
+${fallosEnTexto(r.fallos)}
+
+Pide \`describir("${el.arena}")\` para ver la forma exacta y vuelve a intentarlo. NO la dejes a medias.`;
+      }
+      el.acfg = cfg.valor;
+      b.tocados.push(el.id);
+      b.bitacora.push(`\u270E Arena ${el.arena} llenada`);
+      return `Arena "${el.arena}" llenada y validada (id ${el.id}).`;
+    }
+    case "configurar_booster": {
+      const el = buscarEl(b, txt(args.objetivo));
+      if (!el) return `No encuentro ning\xFAn booster "${txt(args.objetivo)}".`;
+      if (el.kind !== "widget" || !el.widget) return `${describirEl(el)} no es un booster, as\xED que no tiene qu\xE9 llenarle.`;
+      const ficha = ESQUEMAS[el.widget];
+      if (!ficha || !ficha.cfgSchema) {
+        return `El booster "${el.widget}" no tiene nada que configurar. Si quer\xEDas APLICARLO sobre otro objeto (quitafondo, magichat, transformar), esa es \`aplicar_booster\`.`;
+      }
+      const cfg = leerJson(args.cfg);
+      if ("error" in cfg) return cfg.error;
+      const r = validarCfgDe(el.widget, cfg.valor);
+      if (!r.ok) {
+        return `Esa configuraci\xF3n no vale para el booster "${el.widget}":
+${fallosEnTexto(r.fallos)}
+
+Pide \`describir("${el.widget}")\` para ver la forma exacta y vuelve a intentarlo.`;
+      }
+      el.wcfg = ficha.donde === "wcfg.ext" ? { ...el.wcfg, ext: cfg.valor } : { ...el.wcfg?.ext ? { ext: el.wcfg.ext } : {}, ...cfg.valor };
+      b.tocados.push(el.id);
+      b.bitacora.push(`\u270E Booster ${el.widget} configurado`);
+      return `Booster "${el.widget}" configurado y validado (id ${el.id}).`;
+    }
+    // ── Estructura ───────────────────────────────────────────────────────────
+    case "nuevo_slide": {
+      const nombre2 = nuevoSlide(b, txt(args.nombre));
+      b.bitacora.push(`\u{1F4C4} Slide \xAB${nombre2}\xBB`);
+      return `Slide "${nombre2}" creado. A partir de ahora todo lo que pongas cae aqu\xED.`;
+    }
+    case "nueva_capa": {
+      const r = txt(args.ref).trim();
+      const capa = crearCapa(b, txt(args.nombre) || r);
+      if (r) b.aliasCapa.set(r, capa.id);
+      return `Capa "${capa.name}" creada. Para poner cosas dentro, p\xE1sale capa="${r || capa.name}".`;
+    }
+    case "nueva_escena": {
+      const nombre2 = txt(args.nombre) || `Escena ${b.doc.length + 1}`;
+      const sl = { id: nid("slide"), name: "Slide 1", base: [], layers: [] };
+      b.doc.push({ id: nid("esc"), name: nombre2, slides: [sl] });
+      b.escena = b.doc.length - 1;
+      b.slide = 0;
+      b.bitacora.push(`\u{1F3AC} Escena \xAB${nombre2}\xBB`);
+      return `Escena "${nombre2}" creada, con un slide vac\xEDo. Ah\xED es donde est\xE1s trabajando ahora.`;
+    }
+    // ── Programar ────────────────────────────────────────────────────────────
+    case "programar": {
+      const objetivo = txt(args.objetivo);
+      const el = buscarEl(b, objetivo);
+      if (!el) return `No encuentro ning\xFAn objeto "${objetivo}" en este slide.`;
+      if (txt(args.accion) === "quitar") {
+        if (!pidi\u00F3Borrar(b.pedido)) {
+          return "NO se quit\xF3 nada: el maestro no pidi\xF3 borrar ni quitar su programaci\xF3n. Cont\xE9stale con `responder`.";
+        }
+        const n0 = (el.triggers ?? []).length;
+        el.triggers = [];
+        b.tocados.push(el.id);
+        b.bitacora.push(`\u{1F9F9} Sin programaci\xF3n: ${describirEl(el)}`);
+        return `Le quit\xE9 ${n0} disparador(es).`;
+      }
+      const { accion, fallo } = armarAccion(b, args, el);
+      if (!accion) return fallo ?? "No entend\xED qu\xE9 acci\xF3n quer\xEDas.";
+      const trig = { id: nid("trig"), event: armarEvento(args, el), action: accion };
+      el.triggers = args.primero === true ? [trig, ...el.triggers ?? []] : [...el.triggers ?? [], trig];
+      b.tocados.push(el.id);
+      b.bitacora.push(`\u26A1 ${describirEl(el)}: ${describirTrigger(trig, b)}`);
+      return "Programado.";
+    }
+    // ── Retocar ──────────────────────────────────────────────────────────────
+    case "recolocar": {
+      const el = buscarEl(b, txt(args.objetivo));
+      if (!el) return `No encuentro ning\xFAn objeto "${txt(args.objetivo)}".`;
+      if (num3(args.w, 0) > 0) {
+        const w = pct(args.w, el.w);
+        el.h = +(el.h * (w / el.w)).toFixed(1);
+        el.w = w;
+      }
+      if (typeof args.x === "number") el.x = pct(args.x, el.x);
+      if (typeof args.y === "number") el.y = pct(args.y, el.y);
+      encajar(el);
+      b.tocados.push(el.id);
+      b.bitacora.push(`\u2194\uFE0F Recolocado: ${describirEl(el)}`);
+      return "Movido.";
+    }
+    case "cambiar_estilo": {
+      const el = buscarEl(b, txt(args.objetivo));
+      if (!el) return `No encuentro ning\xFAn objeto "${txt(args.objetivo)}".`;
+      if (txt(args.color)) el.color = txt(args.color);
+      if (txt(args.relleno)) el.fill = txt(args.relleno);
+      if (num3(args.tamano, 0) > 0) {
+        el.fontSize = Math.max(10, Math.min(220, num3(args.tamano, 44)));
+        if (el.kind === "text") el.h = altoTexto(el.text ?? "", el.w, el.fontSize);
+      }
+      if (txt(args.efecto)) el.effect = txt(args.efecto) === "none" ? void 0 : txt(args.efecto);
+      Object.assign(el, colorDelEfecto(el.effect ?? "", txt(args.color_efecto), txt(args.color)));
+      if (txt(args.movimiento)) el.motion = txt(args.movimiento);
+      if (num3(args.peso, 0) >= 400) el.weight = Math.round(num3(args.peso, 400));
+      if (typeof args.mayusculas === "boolean") el.caps = args.mayusculas || void 0;
+      if (txt(args.align)) el.align = txt(args.align);
+      if (typeof args.opacidad === "number") el.opacity = Math.max(0, Math.min(1, args.opacidad));
+      if (typeof args.giro === "number") el.rot = args.giro || void 0;
+      b.tocados.push(el.id);
+      b.bitacora.push(`\u{1F3A8} Retocado: ${describirEl(el)}`);
+      return "Estilo cambiado.";
+    }
+    case "copiar_estilo": {
+      const desde = buscarEl(b, txt(args.desde));
+      const hacia = buscarEl(b, txt(args.hacia));
+      if (!desde) return `No encuentro el objeto "${txt(args.desde)}" del que copiar.`;
+      if (!hacia) return `No encuentro el objeto "${txt(args.hacia)}" al que copiar.`;
+      const copiar = (k) => {
+        const v = desde[k];
+        if (v === void 0) delete hacia[k];
+        else hacia[k] = v;
+      };
+      [
+        "color",
+        "fill",
+        "fontSize",
+        "font",
+        "weight",
+        "tracking",
+        "caps",
+        "leading",
+        "align",
+        "effect",
+        "motion",
+        "fxColor",
+        "fxColor2",
+        "fxIntensity",
+        "fxSpeed",
+        "curve",
+        "stroke",
+        "strokeW",
+        "strokeStyle",
+        "opacity"
+      ].forEach(copiar);
+      if (hacia.kind === "text") hacia.h = altoTexto(hacia.text ?? "", hacia.w, hacia.fontSize ?? 44);
+      b.tocados.push(hacia.id);
+      b.bitacora.push(`\u{1F3A8} ${describirEl(hacia)} qued\xF3 como ${describirEl(desde)}`);
+      return "Estilo copiado.";
+    }
+    case "cambiar_texto": {
+      const el = buscarEl(b, txt(args.objetivo));
+      if (!el) return `No encuentro ning\xFAn objeto "${txt(args.objetivo)}".`;
+      el.text = txt(args.texto);
+      delete el.html;
+      if (el.kind === "text") el.h = altoTexto(el.text, el.w, el.fontSize ?? 44);
+      b.tocados.push(el.id);
+      b.bitacora.push(`\u270E \xAB${el.text}\xBB`);
+      return "Texto cambiado.";
+    }
+    case "borrar": {
+      if (!pidi\u00F3Borrar(b.pedido)) {
+        return "NO se borr\xF3 nada: el maestro no pidi\xF3 borrar. Su mensaje no lleva ninguna palabra de borrado, as\xED que probablemente te est\xE1 contando algo o confirm\xE1ndote una acci\xF3n suya. Cont\xE9stale con `responder`.";
+      }
+      const el = buscarEl(b, txt(args.objetivo));
+      if (!el) return `No encuentro ning\xFAn objeto "${txt(args.objetivo)}".`;
+      for (const sc of b.doc) {
+        for (const sl of sc.slides) {
+          sl.base = sl.base.filter((e) => e.id !== el.id);
+          sl.layers.forEach((l) => {
+            l.els = l.els.filter((e) => e.id !== el.id);
+          });
+        }
+      }
+      b.bitacora.push(`\u{1F5D1} Quitado: ${describirEl(el)}`);
+      return "Borrado.";
+    }
+    default:
+      return `No existe la herramienta "${nombre}".`;
+  }
+}
+function nuevoSlide(b, nombre) {
+  const sc = escenaDe(b);
+  const sl = { id: nid("slide"), name: nombre || `Slide ${sc.slides.length + 1}`, base: [], layers: [] };
+  sc.slides.splice(b.slide + 1, 0, sl);
+  b.slide += 1;
+  return sl.name;
+}
+function leerJson(v) {
+  const t = txt(v).trim();
+  if (!t) return { error: "Me mandaste el `cfg` vac\xEDo. Tiene que ser un texto JSON con la configuraci\xF3n." };
+  try {
+    return { valor: JSON.parse(t) };
+  } catch (e) {
+    return { error: `El \`cfg\` no es JSON v\xE1lido (${e.message}). M\xE1ndalo otra vez como texto JSON, sin comas de m\xE1s ni comentarios.` };
+  }
+}
+function describirEl(el) {
+  if (el.text) return `\xAB${el.text.length > 28 ? `${el.text.slice(0, 28)}\u2026` : el.text}\xBB`;
+  if (el.kind === "image") return "el dibujo";
+  if (el.kind === "audio") return `el audio \xAB${el.name ?? "sin nombre"}\xBB`;
+  if (el.kind === "widget") return `el booster ${el.widget}`;
+  if (el.kind === "arena") return `la arena ${el.arena}`;
+  if (el.hotspot) return "la zona caliente";
+  return `la figura ${el.shape ?? ""}`.trim();
+}
+function describirTrigger(t, b) {
+  const cuando = t.event.type === "click" ? "al tocarlo" : t.event.type === "hover" ? "al pasarle por encima" : t.event.type === "slideStart" ? "al entrar al slide" : t.event.type === "layerShown" ? "al abrirse su capa" : t.event.type === "time" ? `a los ${t.event.seconds} s` : t.event.type === "clickStep" ? `en el clic n\xBA ${t.event.step}` : t.event.type === "motionEnd" ? "al terminar su trayectoria" : "al dispararse";
+  const a = t.action;
+  const nombreCapa = (id) => buscarCapa(b, id)?.name ?? "una capa";
+  const qu\u00E9 = a.type === "showLayer" ? `abre \xAB${nombreCapa(a.layerId)}\xBB` : a.type === "goScene" ? `salta a \xAB${b.doc.find((s) => s.id === a.sceneId)?.name ?? "otra escena"}\xBB` : a.type === "goSlide" ? "salta a otro slide" : a.type === "closeLayer" ? "cierra la capa" : a.type === "speak" ? `lee \xAB${a.text}\xBB en voz alta` : a.type === "openUrl" ? "abre un enlace" : a.type === "hideEl" ? "desaparece con humo" : a.type === "playMotion" ? "recorre su trayectoria" : a.type === "playSound" ? "suena el audio" : a.type === "resetSequence" ? "reinicia el slide" : "hace lo suyo";
+  return `${cuando}, ${qu\u00E9}`;
+}
+
+// ../src/canvas/appNativeArenas.ts
+var ARENAS_MUDADAS = [
+  {
+    arena: "word-storm",
+    module: "canvas/arenas/ArenaWordStorm",
+    namedExports: { DEFAULT_WORDS: "[]" },
+    motivo: "necesitaba el hub de Booster Live (2026-08-13)"
+  },
+  {
+    arena: "booster-escape",
+    module: "canvas/arenas/ArenaBoosterEscape",
+    // El puente le pide el componente por defecto y nada más (sus preguntas de ejemplo son
+    // internas), así que no hay exports con nombre que reponer.
+    namedExports: {},
+    motivo: "necesitaba el hub de Booster Live (2026-08-22)"
+  }
+];
+var APP_NATIVE_ARENAS = ARENAS_MUDADAS.map((a) => a.arena);
+
+// ../src/canvas/arenas/wordStormLive.ts
+var WORDSTORM_SAMPLE = [
+  "apple",
+  "storm",
+  "rainbow",
+  "dragon",
+  "window",
+  "jungle",
+  "pencil",
+  "rocket",
+  "summer",
+  "castle"
+];
+
+// ../src/canvas/widgets/CycleWidget.datos.ts
+var seq = 0;
+var cycleUid = () => `cs-${Date.now().toString(36)}-${seq++}`;
+
+// ../src/canvas/widgets/plot2d.ts
+var CURVE_COLORS = ["#2563eb", "#dc2626", "#16a34a", "#d97706", "#7c3aed", "#db2777", "#0891b2", "#65a30d"];
+
+// ../src/canvas/widgets/EquationPlotterWidget.datos.ts
+var DEFAULT_VIEW = { cx: 0, cy: 0, scale: 46 };
+var seq2 = 0;
+var eid = () => `eq-${Date.now().toString(36)}-${seq2++}`;
+function defaultPlotterCfg() {
+  return {
+    eqs: [{ id: eid(), src: "y = x^2", color: CURVE_COLORS[0], visible: true }],
+    mode: "2d",
+    dark: false,
+    piAxis: false,
+    showCuts: true,
+    view: { ...DEFAULT_VIEW },
+    tMin: 0,
+    tMax: Math.PI * 2,
+    range3d: 5,
+    zClamp: 8,
+    wire: false,
+    quality: "normal",
+    params: {}
+  };
+}
+
+// ../src/canvas/widgets/fractionsMath.ts
+var FRAC_DENOMS = [2, 3, 4, 5, 6, 8, 10, 12];
+
+// ../src/canvas/widgets/QrWidget.datos.ts
+var QR_DEFAULTS = {
+  // Nace con un enlace de verdad ya puesto: el maestro suelta el booster y ya tiene
+  // algo que enseñar, en vez de un hueco que hay que configurar antes de ver nada.
+  text: "https://boosterarena.com",
+  kind: "url",
+  dark: "#0f172a",
+  light: "#ffffff",
+  style: "soft",
+  ecc: "M",
+  label: "Escan\xE9ame",
+  plate: true,
+  sound: true,
+  anim: true
+};
+
+// ../packages/we-boosters/src/canvas/arenas/ArenaMenu.datos.ts
+function svgIcon(color2, inner) {
+  const svg = `<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='${color2}' stroke-width='1.6' stroke-linecap='round' stroke-linejoin='round'>${inner}</svg>`;
+  return `data:image/svg+xml,${encodeURIComponent(svg)}`;
+}
+var DEFAULT_ITEMS = [
+  { id: "s1", color: "#14b8a6", title: "CONTENIDO", desc: "Consulta los temas y subtemas del curso.", icon: svgIcon("#14b8a6", "<path d='M3 5.5c2.7-1 5.3-1 8 0v13c-2.7-1-5.3-1-8 0z'/><path d='M21 5.5c-2.7-1-5.3-1-8 0v13c2.7-1 5.3-1 8 0z'/>") },
+  { id: "s2", color: "#3b82f6", title: "OBJETIVOS", desc: "Conoce los objetivos de aprendizaje.", icon: svgIcon("#3b82f6", "<circle cx='12' cy='12' r='7'/><circle cx='12' cy='12' r='3.4'/><path d='M12 12l7-7'/><path d='M16 5h3v3'/>") },
+  { id: "s3", color: "#8b5cf6", title: "EVALUACI\xD3N", desc: "Pon a prueba tus conocimientos.", icon: svgIcon("#8b5cf6", "<rect x='6' y='4.5' width='12' height='16' rx='2'/><rect x='9' y='3' width='6' height='3.2' rx='1'/><path d='M8.6 11l1.4 1.4 2.6-2.6'/><path d='M8.6 15.6l1.4 1.4 2.6-2.6'/>") },
+  { id: "s4", color: "#84cc16", title: "RECURSOS", desc: "Accede a materiales de apoyo adicionales.", icon: svgIcon("#84cc16", "<path d='M4 20h16'/><rect x='7' y='11' width='2.6' height='6' rx='.5'/><rect x='11.7' y='8' width='2.6' height='9' rx='.5'/><rect x='16.4' y='5' width='2.6' height='12' rx='.5'/>") },
+  { id: "s5", color: "#f59e0b", title: "INFORMACI\xD3N", desc: "Detalles importantes sobre el curso.", icon: svgIcon("#f59e0b", "<circle cx='12' cy='8.5' r='3.6'/><path d='M5.5 19.5a6.5 6.5 0 0 1 13 0'/>") }
+];
+
+// ../packages/we-boosters/src/canvas/arenas/ArenaMenuNeon.datos.ts
+function svgIcon2(color2, inner) {
+  const svg = `<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='${color2}' stroke-width='1.6' stroke-linecap='round' stroke-linejoin='round'>${inner}</svg>`;
+  return `data:image/svg+xml,${encodeURIComponent(svg)}`;
+}
+var NEON_DEFAULT_ITEMS = [
+  { id: "s1", color: "#2dd4bf", title: "CONTENIDO", desc: "Consulta los temas y subtemas del curso.", icon: svgIcon2("#2dd4bf", "<path d='M3 5.5c2.7-1 5.3-1 8 0v13c-2.7-1-5.3-1-8 0z'/><path d='M21 5.5c-2.7-1-5.3-1-8 0v13c2.7-1 5.3-1 8 0z'/>") },
+  { id: "s2", color: "#3b82f6", title: "OBJETIVOS", desc: "Conoce los objetivos de aprendizaje.", icon: svgIcon2("#3b82f6", "<circle cx='12' cy='12' r='7'/><circle cx='12' cy='12' r='3.4'/><path d='M12 12l7-7'/><path d='M16 5h3v3'/>") },
+  { id: "s3", color: "#a855f7", title: "EVALUACI\xD3N", desc: "Pon a prueba tus conocimientos.", icon: svgIcon2("#a855f7", "<rect x='6' y='4.5' width='12' height='16' rx='2'/><rect x='9' y='3' width='6' height='3.2' rx='1'/><path d='M8.6 11l1.4 1.4 2.6-2.6'/><path d='M8.6 15.6l1.4 1.4 2.6-2.6'/>") },
+  { id: "s4", color: "#ec4899", title: "RECURSOS", desc: "Accede a materiales de apoyo adicionales.", icon: svgIcon2("#ec4899", "<rect x='4' y='4' width='7' height='7' rx='1.4'/><rect x='13' y='4' width='7' height='7' rx='1.4'/><rect x='4' y='13' width='7' height='7' rx='1.4'/><rect x='13' y='13' width='7' height='7' rx='1.4'/>") },
+  { id: "s5", color: "#f5b301", title: "INFORMACI\xD3N", desc: "Detalles importantes sobre el curso.", icon: svgIcon2("#f5b301", "<path d='M9 18h6'/><path d='M10 21h4'/><path d='M12 3a6 6 0 0 1 4 10.5c-.7.7-1 1.2-1 2.5H9c0-1.3-.3-1.8-1-2.5A6 6 0 0 1 12 3z'/>") }
+];
+
+// ../packages/we-boosters/src/canvas/arenas/ArenaMenuSparta.datos.ts
+function svgIcon3(color2, inner) {
+  const svg = `<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='${color2}' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'>${inner}</svg>`;
+  return `data:image/svg+xml,${encodeURIComponent(svg)}`;
+}
+var GOLD = "#c9a24b";
+var SPARTA_DEFAULT_ITEMS = [
+  // Casco
+  { id: "s1", color: GOLD, title: "CONTENIDO", desc: "Consulta los temas y subtemas del curso.", icon: svgIcon3(GOLD, "<path d='M5 13a7 7 0 0 1 13-3.5c1.6.4 2.4 1.3 2.4 2.2 0 1-.9 1.6-2 1.6'/><path d='M5 13c0 2.5 1.5 4 3.5 4H12v3'/><path d='M5 13H3.5'/><path d='M12 6V3.5'/>") },
+  // Lanzas cruzadas
+  { id: "s2", color: GOLD, title: "OBJETIVOS", desc: "Conoce los objetivos de aprendizaje.", icon: svgIcon3(GOLD, "<path d='M4 20L20 4'/><path d='M20 4l-3 .4L18.6 7z'/><path d='M20 20L4 4'/><path d='M4 4l3 .4L5.4 7z'/>") },
+  // Búho de Atenea
+  { id: "s3", color: GOLD, title: "EVALUACI\xD3N", desc: "Pon a prueba tus conocimientos.", icon: svgIcon3(GOLD, "<path d='M7 9a5 5 0 0 1 10 0v4a5 5 0 0 1-10 0z'/><circle cx='9.5' cy='10' r='1.6'/><circle cx='14.5' cy='10' r='1.6'/><path d='M12 12.5l-1 1.5h2z'/><path d='M8 5l1.5 2M16 5l-1.5 2'/><path d='M9 18l-1.5 2M15 18l1.5 2'/>") },
+  // Corona de laurel
+  { id: "s4", color: GOLD, title: "RECURSOS", desc: "Accede a materiales de apoyo adicionales.", icon: svgIcon3(GOLD, "<path d='M12 4v15'/><path d='M12 8c-2-2-5-2-6 0 1 2 4 2 6 0z'/><path d='M12 12c-2-2-5-2-6 0 1 2 4 2 6 0z'/><path d='M12 8c2-2 5-2 6 0-1 2-4 2-6 0z'/><path d='M12 12c2-2 5-2 6 0-1 2-4 2-6 0z'/>") },
+  // Templo / Partenón
+  { id: "s5", color: GOLD, title: "INFORMACI\xD3N", desc: "Detalles importantes sobre el curso.", icon: svgIcon3(GOLD, "<path d='M3 9l9-5 9 5z'/><path d='M5 9v8M9.3 9v8M14.7 9v8M19 9v8'/><path d='M3 20h18'/><path d='M4 17h16'/>") }
+];
+
+// ../packages/we-boosters/src/canvas/arenas/ArenaDuckShooting.datos.ts
+var DEFAULT_QUESTIONS = [
+  { q: 'How do you say "perro" in English?', options: ["Cat", "Dog", "Fish", "Bird"], answer: 1 },
+  { q: 'The opposite of "big" is ___.', options: ["small", "tall", "fast", "old"], answer: 0 },
+  { q: "Which one is a color?", options: ["Table", "Purple", "Run", "Loud"], answer: 1 },
+  { q: "A baby dog is called a ___.", options: ["kitten", "puppy", "calf", "chick"], answer: 1 },
+  { q: "The sun rises in the ___.", options: ["west", "north", "east", "south"], answer: 2 },
+  { q: 'The plural of "child" is ___.', options: ["childs", "children", "childes", "child"], answer: 1 },
+  { q: "How many days are in a week?", options: ["five", "six", "seven", "eight"], answer: 2 },
+  { q: "Which animal can fly?", options: ["Dog", "Bird", "Cat", "Fish"], answer: 1 }
+];
+
+// ../packages/we-boosters/src/canvas/boosters/BoosterRevealer.datos.ts
+var REVEALER_THEMES = [
+  { id: "aurora", label: "Aurora", swatch: "linear-gradient(135deg,#7c3aed,#4f46e5 60%,#2563eb)" },
+  { id: "sunset", label: "Sunset", swatch: "linear-gradient(135deg,#f97316,#e11d48)" },
+  { id: "ocean", label: "Ocean", swatch: "linear-gradient(135deg,#06b6d4,#1e40af)" },
+  { id: "candy", label: "Candy", swatch: "linear-gradient(135deg,#f472b6,#8b5cf6)" },
+  { id: "galaxy", label: "Galaxy", swatch: "linear-gradient(135deg,#1e1b4b,#312e81)" },
+  { id: "gold", label: "Gold", swatch: "linear-gradient(135deg,#fde68a,#d97706)" }
+];
+
+// ../packages/we-boosters/src/fichas.ts
+var courseMenu = {
+  type: "course-menu",
+  emoji: "\u{1F9ED}",
+  label: "Men\xFA de curso",
+  blurb: "Pantalla de inicio: bienvenida + tarjetas reemplazables. Edita logo, colores, textos y secciones (a\xF1ade/quita).",
+  premium: false,
+  ready: true,
+  defaultAcfg: {},
+  // sin datos → usa los valores por defecto del template (5 secciones)
+  // Destinos navegables = una por tarjeta. Usa el `id` estable de cada sección (o índice si
+  // falta), igual que lo que envía ArenaMenu por onNavigate. Sin datos → las 5 por defecto.
+  navSlots: (acfg) => {
+    const its = acfg?.items?.length ? acfg.items : DEFAULT_ITEMS;
+    return its.map((it, i) => ({ key: it.id ?? String(i), label: it.title || `Secci\xF3n ${i + 1}` }));
+  }
+};
+var spellingJenga = {
+  type: "we-spelling-jenga",
+  emoji: "\u{1F9F1}",
+  label: "Spelling Jenga (we-boosters)",
+  blurb: "Deletreo por orden de letras para 4 jugadores: ordena la palabra o tu torre se derrumba.",
+  premium: false,
+  ready: true,
+  defaultAcfg: {
+    words: ["HOUSE", "WATER", "GREEN", "MUSIC", "HAPPY", "TABLE", "LIGHT", "BREAD", "PHONE", "SMILE", "OCEAN", "APPLE"],
+    playerNames: ["Player 1", "Player 2", "Player 3", "Player 4"]
+  }
+};
+var courseMenuKids = {
+  type: "course-menu-kids",
+  emoji: "\u{1F9D2}",
+  label: "Men\xFA de curso (infantil)",
+  blurb: "Pantalla de inicio infantil: cielo, personajes y tarjetas circulares. Edita fondo, im\xE1genes, colores, textos y secciones.",
+  premium: false,
+  ready: true,
+  defaultAcfg: {}
+  // sin datos → usa los valores por defecto del template (5 tarjetas)
+};
+var courseMenuNeon = {
+  type: "course-menu-neon",
+  emoji: "\u{1F30C}",
+  label: "Men\xFA de curso (ne\xF3n)",
+  blurb: 'Pantalla de inicio teen sobre fondo oscuro: "\xA1BIENVENIDO!" ne\xF3n, estudiantes y tarjetas de vidrio con borde que respira. Edita fondo, im\xE1genes, colores, textos y secciones.',
+  premium: false,
+  ready: true,
+  defaultAcfg: {},
+  // sin datos → usa los valores por defecto del template (5 tarjetas)
+  // Destinos navegables = una por tarjeta (clave estable `id`, o índice si falta).
+  navSlots: (acfg) => {
+    const its = acfg?.items?.length ? acfg.items : NEON_DEFAULT_ITEMS;
+    return its.map((it, i) => ({ key: it.id ?? String(i), label: it.title || `Secci\xF3n ${i + 1}` }));
+  }
+};
+var courseMenuSparta = {
+  type: "course-menu-sparta",
+  emoji: "\u{1F3DB}\uFE0F",
+  label: "Men\xFA de curso (espartano)",
+  blurb: "Pantalla de inicio \xE9pica: est\xE9tica espartana/griega con medallones de bronce. Edita fondo, im\xE1genes, colores, textos y secciones.",
+  premium: false,
+  ready: true,
+  defaultAcfg: {},
+  // sin datos → usa los valores por defecto del template (5 medallones)
+  // Destinos navegables = uno por medallón (clave estable `id`, o índice si falta).
+  navSlots: (acfg) => {
+    const its = acfg?.items?.length ? acfg.items : SPARTA_DEFAULT_ITEMS;
+    return its.map((it, i) => ({ key: it.id ?? String(i), label: it.title || `Secci\xF3n ${i + 1}` }));
+  }
+};
+var duckShooting = {
+  type: "duck-shooting",
+  emoji: "\u{1F986}",
+  label: "Duck Shooting",
+  blurb: "Caseta de feria: dispara a los patos (uno por pregunta) y responde la pregunta que aparece. Suma puntos y consigue 3 estrellas. Edita las preguntas.",
+  premium: false,
+  ready: true,
+  defaultAcfg: { questions: DEFAULT_QUESTIONS }
+  // sin datos → preguntas de ejemplo
+};
+var jenga = {
+  type: "jenga",
+  emoji: "\u{1F9F1}",
+  label: "Jenga",
+  blurb: "Quiz con torre Jenga 3D real: acierta y la torre aguanta, falla y se saca una pieza hasta que se derrumba. Suma puntos. Edita las preguntas.",
+  premium: false,
+  ready: true,
+  defaultAcfg: {}
+  // sin datos → la arena usa sus preguntas de ejemplo internas
+};
+var cellphoneChallenge = {
+  type: "cellphone-challenge",
+  emoji: "\u{1F4F1}",
+  label: "Cellphone Challenge",
+  blurb: "Tel\xE9fono cl\xE1sico de los 2000: aprende y practica la escritura normal (multi-tap) y predictiva, decodifica n\xFAmeros y responde chats estilo SMS. Edita las palabras y las conversaciones.",
+  premium: false,
+  ready: true,
+  defaultAcfg: {}
+  // sin datos → la arena usa sus palabras y conversaciones de ejemplo internas
+};
+var boosterEscape = {
+  type: "booster-escape",
+  emoji: "\u{1F9ED}",
+  label: "Booster Escape",
+  blurb: "Laberinto de la selva con dos modos: Individual (corre por los pasillos, esquiva a los enemigos que te persiguen y llega a la respuesta correcta; 3 vidas, dificultad creciente) y Versus 1v1 (dos jugadores compiten: el primero en llegar a la respuesta correcta gana la ronda). Edita las preguntas (con imagen/audio).",
+  premium: false,
+  ready: true,
+  defaultAcfg: {}
+  // sin datos → la arena usa sus preguntas de ejemplo internas
+};
+var revealer = {
+  type: "revealer",
+  emoji: "\u{1FA84}",
+  label: "Revelador",
+  blurb: "Tapa m\xE1gica: col\xF3cala sobre una respuesta y, al hacer clic, explota en confeti y revela lo de atr\xE1s.",
+  premium: false,
+  ready: true,
+  defaultWcfg: { label: "?", hint: "Tap to reveal", theme: "aurora" },
+  defaultSize: { w: 22, h: 30 },
+  freeResize: true,
+  hint: "\u{1FA84} Revelador. Col\xF3calo sobre una respuesta y est\xEDralo para cubrirla. En el \u25B6 Player, al hacer clic explota en confeti y deja ver lo de atr\xE1s.",
+  fields: [
+    { key: "label", kind: "text", label: "S\xEDmbolo de la tapa", placeholder: "?", maxLength: 6 },
+    { key: "hint", kind: "text", label: "Texto peque\xF1o", placeholder: "Tap to reveal" },
+    { key: "theme", kind: "theme", label: "Dise\xF1o", options: REVEALER_THEMES }
+  ]
+};
+var instructions = {
+  type: "instructions",
+  emoji: "\u2753",
+  label: "Instructions",
+  blurb: 'Moneda "?" que al hacer clic abre un panel de vidrio con las instrucciones de la clase.',
+  premium: false,
+  ready: true,
+  defaultWcfg: {
+    title: "Instructions",
+    icon: "\u{1F4A1}",
+    body: "Read the text on the board.\nDiscuss it with your partner.\nWrite three sentences in your notebook."
+  },
+  defaultSize: { w: 8, h: 11 },
+  freeResize: true,
+  hint: "\u2753 Instructions. Coloca la moneda donde quieras y est\xEDrala (puede ser peque\xF1a). En el \u25B6 Player, al hacer clic se abre un panel de vidrio al 80% del slide con los pasos.",
+  fields: [
+    { key: "title", kind: "text", label: "T\xEDtulo", placeholder: "Instructions", maxLength: 40 },
+    { key: "body", kind: "text", label: "Instrucciones (una por l\xEDnea)", placeholder: "Read the text on the board." },
+    { key: "icon", kind: "text", label: "Emoji del t\xEDtulo", placeholder: "\u{1F4A1}", maxLength: 4 }
+  ]
+};
+var FICHAS_ARENAS = [courseMenu, courseMenuKids, courseMenuNeon, courseMenuSparta, duckShooting, jenga, spellingJenga, cellphoneChallenge, boosterEscape];
+var FICHAS_BOOSTERS = [revealer, instructions];
+
+// ../src/registro/capacidades.ts
+var WIDGETS = [
+  { type: "dice", emoji: "\u{1F3B2}", label: "Dado 3D", blurb: "Lanza dados con f\xEDsica real: ruedan, rebotan y se asientan solos.", premium: false, ready: true },
+  { type: "wheel", emoji: "\u{1F3A1}", label: "Ruleta de nombres", blurb: "Gira y elige un nombre al azar. Avatares + lista de nombres configurable.", premium: false, ready: true },
+  { type: "timer", emoji: "\u23F3", label: "Temporizador", blurb: "Cuenta regresiva con anillo de progreso, color y alarma final.", premium: false, ready: true },
+  { type: "score", emoji: "\u{1F3C6}", label: "Marcador de equipos", blurb: "Puntos por equipo (A vs B\u2026). Toca para sumar o restar.", premium: false, ready: true },
+  { type: "groups", emoji: "\u{1F465}", label: "Formar equipos", blurb: "Reparte a los participantes en equipos al azar, con animaci\xF3n.", premium: false, ready: true },
+  { type: "soundboard", emoji: "\u{1F50A}", label: "Soundboard", blurb: "Botonera de efectos de sonido: aplausos, ding, buzzer, redoble.", premium: false, ready: true },
+  { type: "mystery", emoji: "\u{1F381}", label: "Caja misteriosa", blurb: "Toca y revela una palabra/pregunta al azar, sin repetir hasta agotar.", premium: false, ready: true },
+  { type: "buzzer", emoji: "\u{1F514}", label: "Buzzer", blurb: "\xA1Qui\xE9n responde primero! Bot\xF3n con sonido y destello.", premium: false, ready: true },
+  // Instructions es APP-NATIVE (moneda ❓ → panel de vidrio con editor rico "hoja en blanco":
+  //  formato, imágenes, emojis, espacios en blanco, enlaces). Reemplaza al de we-boosters.
+  { type: "instructions", emoji: "\u2753", label: "Instructions", blurb: "Moneda \u2753 que al hacer clic abre un panel con las instrucciones del slide. Editor tipo hoja: texto con formato, im\xE1genes, emojis, espacios en blanco y enlaces.", premium: false, ready: true },
+  // Varita Mágica (app-native): saca imágenes una a una y, al cerrarlas, las PLANTA en el slide
+  // como objetos reales (efecto genio). Reemplaza el truco de variables+estados de Articulate.
+  { type: "magicwand", emoji: "\u{1FA84}", label: "Varita M\xE1gica", blurb: 'Carga varias im\xE1genes y, con cada clic en el \u25B6 Player, "saca" una en grande; al cerrarla se planta en el slide como objeto real y movible (animaci\xF3n genio).', premium: false, ready: true },
+  // Sombrero Mágico (app-native): NO se planta como elemento. Es una HERRAMIENTA — al elegirlo,
+  // el 🎩 sigue al cursor y al tocar una imagen la vuelve SILUETA negra (magic:true). En el ▶ Player,
+  // al hacer clic sobre esa imagen se "revela" a color con lluvia de estrellas (se re-tapa al re-entrar).
+  // Quita fondos: la MISMA mecánica del Sombrero (moneda que se arrastra sobre una imagen),
+  // porque el maestro ya la conoce y dice sola sobre qué imagen va a actuar.
+  // Premium de verdad: cada recorte gasta GPU, y el servidor lo exige (no es solo el candado
+  // de la interfaz). El precio del recorte malo es peor que el de la GPU: por eso NO hay carril
+  // barato de reserva — ver la cabecera de `quitarFondo.ts`.
+  { type: "quitafondo", emoji: "\u{1F98E}", label: "Quita Fondos", blurb: "Arr\xE1stralo sobre una imagen y el camale\xF3n se come el fondo. Recorta con el modelo grande: separa mechones de pelo, hojas y patas.", premium: true, ready: true },
+  { type: "transformar", emoji: "\u{1F500}", label: "Transformador", blurb: "Arr\xE1stralo sobre un objeto y elige en qu\xE9 se convierte. En el \u25B6 Player cada clic lo transforma en la siguiente imagen \u2014de la oruga a la mariposa\u2014 y la \xFAltima lo devuelve a como estaba.", premium: false, ready: true },
+  { type: "magichat", emoji: "\u{1F3A9}", label: "Sombrero M\xE1gico", blurb: "Arr\xE1stralo sobre una imagen (o PNG) para volverla una silueta negra. En el \u25B6 Player, al hacer clic se revela a color con una lluvia de estrellas m\xE1gicas.", premium: false, ready: true },
+  // Tómbola: bombo de bingo que gira y suelta una bola (número/palabra/imagen), sin repetir.
+  { type: "tombola", emoji: "\u{1F3B0}", label: "T\xF3mbola", blurb: "Bombo de bingo: gira y suelta una bola al azar con un n\xFAmero, palabra o imagen. Sortea sin repetir hasta vaciarse. Ideal para rifas y elegir al azar.", premium: false, ready: true },
+  // Semáforo de comportamiento: 3 luces que el maestro toca en el Player para dar feedback a la clase.
+  { type: "trafficlight", emoji: "\u{1F6A6}", label: "Sem\xE1foro", blurb: "Sem\xE1foro de comportamiento: en el Player, toca una luz (verde/\xE1mbar/rojo) para dar feedback a la clase. El rojo dispara una alerta sonora y visual.", premium: false, ready: true },
+  // Graficador de ecuaciones (app-native, rama de MATEMÁTICA): orbe → estudio 2D/3D.
+  // three.js entra por lazy() solo si el maestro pulsa 3D.
+  // Label It (app-native, rama de CIENCIAS): la lámina del maestro se vuelve actividad de etiquetar.
+  // Sirve a biología (célula, flor, corazón), pero también a geografía, anatomía o vocabulario.
+  { type: "labelit", emoji: "\u{1F3F7}\uFE0F", label: "Label It \u2014 etiquetar", blurb: "Sube cualquier l\xE1mina (c\xE9lula, flor, coraz\xF3n, mapa, una cara\u2026), toca la imagen para clavar los puntos y escribe el nombre de cada parte. En el \u25B6 Player se juega de tres formas: revelar al tocar, arrastrar las palabras a su punto, o escribirlas.", premium: false, ready: true },
+  // Ciclo (app-native, rama de CIENCIAS): una rueda de etapas reemplaza cinco slides sueltas.
+  // La rueda NO gira (gira el FOCO), así las imágenes quedan siempre derechas en la proyección.
+  // 🍕 «Fracciones manipulables» (regletas que se cortan) SE RETIRÓ del catálogo el 2026-08-12:
+  // Antonio se quedó con el Graficador de fracciones de más abajo, que es lo que él quería para
+  // armar sus láminas. El booster NO se borra —solo su tarjeta—: los slides que ya lo tengan
+  // puesto tienen que seguir abriendo y funcionando (su render, su editor y su config siguen
+  // cableados más abajo). Para devolverlo al catálogo, basta con volver a poner su entrada aquí.
+  { type: "cycle", emoji: "\u{1F504}", label: "Ciclo \u2014 rueda de etapas", blurb: "Rueda con las etapas de un proceso (metamorfosis, mitosis, ciclo del agua, fotos\xEDntesis\u2026), cada una con su imagen y su texto. En el \u25B6 Player, cada clic mueve el foco a la siguiente y el centro cuenta qu\xE9 pasa ah\xED. Puede cerrar en c\xEDrculo o ser una cadena, y los nombres pueden salir ocultos para que la clase adivine.", premium: false, ready: true },
+  // Graficador de fracciones (app-native, rama de MATEMÁTICA): HERRAMIENTA de autoría. No es una
+  // actividad para la clase: es la moneda con la que el maestro DIBUJA las fracciones de su
+  // lámina, una tras otra, sin salir a buscar imágenes fuera.
+  { type: "fracplot", emoji: "\u{1F355}", label: "Graficador de fracciones", blurb: "Escribe una fracci\xF3n en sus dos casillas \u2014abajo en cu\xE1ntos pedazos se corta, arriba cu\xE1ntos se pintan\u2014 y la dibuja al instante. Cada \xABInsertar\xBB la estampa en el slide como una figura que se mueve y se estira como cualquier imagen, y el panel se queda abierto para pedir la siguiente: 3/4, luego 2/3, luego 5/8\u2026 Pizza o barra, con la fracci\xF3n escrita debajo. Una impropia como 4/3 sale como dos pizzas.", premium: false, ready: true },
+  // QR: el puente entre el slide proyectado y el celular del alumno. Estático a
+  // propósito (el enlace va grabado en el dibujo): cero infraestructura, cero costo
+  // mensual y sigue funcionando dentro del .zip exportado a LearnPress.
+  { type: "qr", emoji: "\u{1F533}", label: "QR \u2014 el que se come el enlace", blurb: "Pon un enlace y sale un c\xF3digo QR que la clase escanea con el celular: la tarea, el formulario, un video, la sala de Booster Live. Al pulsar \xABGenerar\xBB, el c\xF3digo se COME el enlace: abre la boca y se traga a bocados unos c\xF3digos QR peque\xF1os; al cerrarla, los m\xF3dulos que faltaban caen en su sitio. Color, forma de los puntos y r\xF3tulo a tu gusto.", premium: false, ready: true },
+  { type: "plotter", emoji: "\u{1F4C8}", label: "Graficador 2D \xB7 3D", blurb: "Orbe que abre un graficador de ecuaciones. En 2D: funciones, polares, param\xE9tricas, c\xEDrculos y elipses, inecuaciones, y los CORTES entre curvas marcados con sus coordenadas. En 3D: superficies z = f(x,y) que se giran con el dedo. Cada letra suelta (a, b, c) se vuelve un deslizador.", premium: true, ready: true }
+];
+var APP_NATIVE_BOOSTERS = ["instructions", "magicwand", "magichat", "quitafondo", "transformar", "tombola", "trafficlight", "plotter", "labelit", "cycle", "fractions", "fracplot", "qr"];
+var ARENAS_APP = [
+  { type: "classification", emoji: "\u{1F6F8}", label: "Clasificaci\xF3n \xB7 Espacio", blurb: "Arrastra cada palabra a su categor\xEDa correcta. Tema espacial con OVNIs y aliens.", premium: false, ready: true },
+  { type: "classification-jungle", emoji: "\u{1F435}", label: "Clasificaci\xF3n \xB7 Selva", blurb: "Arrastra cada monito a su bungal\xF3 correcto. Tema selva con caba\xF1as de bamb\xFA.", premium: false, ready: true },
+  { type: "gameshow", emoji: "\u{1F3AD}", label: "Game Show", blurb: "Concurso de 2 estudiantes: tel\xF3n, ruleta, preguntas con tiempo y podio.", premium: true, ready: true },
+  { type: "race", emoji: "\u{1F3CE}\uFE0F", label: "Carrera de Karts", blurb: "Carrera estilo F\xF3rmula 1: hasta 4 jugadores eligen corredor, responden preguntas y ganan nitro.", premium: true, ready: true },
+  { type: "pirate", emoji: "\u{1F3F4}\u200D\u2620\uFE0F", label: "Batalla Pirata", blurb: "Concurso de preguntas para TODA la clase desde sus celulares: gana oro por contestar r\xE1pido, y el que acierta abre un cofre que puede quitarle oro a un compa\xF1ero.", premium: true, ready: true },
+  { type: "mole", emoji: "\u{1F573}\uFE0F", label: "Mole Smash", blurb: "Aplasta los topos que llevan la respuesta correcta. Cada cartel admite texto e imagen; el maestro pone la consigna y las opciones.", premium: false, ready: true },
+  { type: "jigsaw", emoji: "\u{1F9E9}", label: "Rompecabezas", blurb: "Sube UNA imagen y la arena la corta sola en piezas de rompecabezas. El alumno las arrastra desde la bandeja hasta rehacer el dibujo. Sirve para cualquier materia: un mapa, una c\xE9lula, un cuadro.", premium: false, ready: true },
+  { type: "memory", emoji: "\u{1F0CF}", label: "Memory Game", blurb: "Encuentra las parejas ocultas. Cada carta acepta imagen, audio y texto: imagen\u2194imagen con audio, imagen\u2194palabra o palabra\u2194definici\xF3n. Individual o por equipos.", premium: false, ready: true },
+  // Word Storm nació en we-boosters y se trajo app-native (ver APP_NATIVE_ARENAS): su ficha
+  // ya no viene del puente, así que vive aquí como cualquier arena de la app.
+  { type: "booster-escape", emoji: "\u{1F9ED}", label: "Booster Escape", blurb: "Laberinto a contrarreloj con dos modos: Individual (corre por los pasillos, esquiva a los enemigos y llega a la respuesta correcta; 3 vidas) y Versus 1v1. Un toque y el explorador corre solo hasta topar. Edita las preguntas (con imagen/audio).", premium: false, ready: true },
+  { type: "las-vegas", emoji: "\u{1F3B0}", label: "The Fabulous Las Vegas", blurb: "Tragamonedas para construir frases: jala la palanca, los rodillos frenan uno a uno y sale una combinaci\xF3n \u2014SHE \xB7 WRITTEN \xB7 A LETTER\u2014 que la clase dice en voz alta. De 1 a 4 rodillos, y cada casilla puede ser una palabra o un dibujo.", premium: false, ready: true },
+  { type: "word-storm", emoji: "\u2328\uFE0F", label: "Word Storm", blurb: "Lluvia de palabras: escr\xEDbelas con el teclado para destruirlas antes de que toquen la l\xEDnea de peligro. La dificultad sube solita. Edita la lista de palabras.", premium: false, ready: true }
+];
+var soloFicha = (e) => ({ type: e.type, emoji: e.emoji, label: e.label, blurb: e.blurb, premium: e.premium, ready: e.ready });
+var ALL_WIDGETS = [
+  ...WIDGETS,
+  ...FICHAS_BOOSTERS.filter((e) => !APP_NATIVE_BOOSTERS.includes(e.type)).map(soloFicha)
+];
+var ARENAS = [
+  ...ARENAS_APP,
+  ...FICHAS_ARENAS.filter((e) => !APP_NATIVE_ARENAS.includes(e.type)).map(soloFicha)
+];
+
+// ../src/nucleo/fabricas.ts
+function construirWidget(type, manos) {
+  const ext = FICHAS_BOOSTERS.find((e) => e.type === type && !APP_NATIVE_BOOSTERS.includes(e.type));
+  const meta = ext ?? WIDGETS.find((w) => w.type === type);
+  const etiqueta = meta?.label ?? type;
+  if (!meta) return { ok: false, motivo: "desconocido", tipo: type, etiqueta };
+  if (meta.premium && !manos.premium) return { ok: false, motivo: "premium", tipo: type, etiqueta };
+  if (!meta.ready) return { ok: false, motivo: "no-listo", tipo: type, etiqueta };
+  const p = manos.nextPos(46, 42);
+  const namesDefault = ["Ana", "Luis", "Mar\xEDa", "Carlos", "Sof\xEDa", "Diego", "Valeria", "Mateo"];
+  const wcfg = ext ? { ext: { ...ext.defaultWcfg } } : type === "instructions" ? { ext: { title: "Instructions", icon: "\u{1F4A1}", body: "Read the text on the board.\nDiscuss it with your partner.\nWrite three sentences in your notebook." } } : type === "magicwand" ? { ext: { images: [] } } : type === "magichat" ? { ext: {} } : type === "fracplot" ? { ext: { shape: "pie", label: true, color: 0, sound: true } } : type === "tombola" ? { ext: { kind: "numbers", from: 1, to: 30 } } : type === "trafficlight" ? { ext: { sound: true, start: "green" } } : type === "plotter" ? { ext: defaultPlotterCfg() } : type === "labelit" ? { ext: { mode: "reveal", points: [], shuffle: true, sound: true } } : type === "cycle" ? { ext: {
+    closed: true,
+    guess: false,
+    sound: true,
+    stages: Array.from({ length: 4 }, () => ({ id: cycleUid(), text: "" }))
+  } } : type === "fractions" ? { ext: { mode: "add", title: "", a: "1/2", b: "1/3", denoms: FRAC_DENOMS, labels: true, sound: true } } : type === "qr" ? { ext: { ...QR_DEFAULTS, gen: 0 } } : type === "wheel" ? { names: namesDefault } : type === "timer" ? { seconds: 60 } : type === "score" ? { teams: ["Equipo A", "Equipo B"] } : type === "groups" ? { names: namesDefault, teamCount: 2 } : type === "mystery" ? { items: ["apple", "happy", "run", "book", "blue", "friend", "school", "water"] } : { dice: 1 };
+  const sz = ext ? ext.defaultSize : type === "trafficlight" ? { w: 16, h: 42 } : type === "labelit" ? { w: 52, h: 68 } : type === "cycle" ? { w: 66, h: 64 } : type === "fractions" ? { w: 74, h: 50 } : type === "qr" ? { w: 16, h: 33 } : { w: 7, h: 12.4 };
+  const pos = sz.h > 55 ? { x: (100 - sz.w) / 2, y: (100 - sz.h) / 2 } : p;
+  return { ok: true, el: { id: manos.uid("wdg"), kind: "widget", widget: type, x: pos.x, y: pos.y, w: sz.w, h: sz.h, wcfg } };
+}
+function construirArena(type, manos) {
+  const ext = FICHAS_ARENAS.find((e) => e.type === type && !APP_NATIVE_ARENAS.includes(e.type));
+  const metaArena = ARENAS.find((a) => a.type === type);
+  const etiquetaArena = metaArena?.label ?? String(type);
+  if (!metaArena) return { ok: false, motivo: "desconocido", tipo: String(type), etiqueta: etiquetaArena };
+  if (metaArena.premium && !manos.premium) return { ok: false, motivo: "premium", tipo: String(type), etiqueta: etiquetaArena };
+  if (!metaArena.ready) return { ok: false, motivo: "no-listo", tipo: String(type), etiqueta: etiquetaArena };
+  const acfg = ext ? ext.defaultAcfg : type === "classification" ? { categories: ["Animals", "Plants"], items: [
+    { text: "cat", cat: 0 },
+    { text: "hamster", cat: 0 },
+    { text: "dog", cat: 0 },
+    { text: "daisy", cat: 1 },
+    { text: "oak tree", cat: 1 },
+    { text: "tulip", cat: 1 }
+  ] } : type === "classification-jungle" ? { categories: ["verbs", "nouns"], items: [
+    { text: "run", cat: 0 },
+    { text: "jump", cat: 0 },
+    { text: "sit", cat: 0 },
+    { text: "eat", cat: 0 },
+    { text: "cat", cat: 1 },
+    { text: "house", cat: 1 },
+    { text: "tree", cat: 1 }
+  ] } : type === "gameshow" ? { questions: [
+    { q: "The winter solstice occurs in December.", options: ["True", "False"], answer: 0 },
+    { q: "Which planet is the Red Planet?", options: ["Venus", "Mars", "Jupiter", "Saturn"], answer: 1 },
+    { q: "A group of wolves is called a ___.", options: ["pack", "herd", "school", "flock"], answer: 0 },
+    { q: "How many continents are there?", options: ["5", "6", "7", "8"], answer: 2 }
+  ] } : type === "race" ? { track: 0, questions: [
+    { q: "Which planet is the Red Planet?", options: ["Venus", "Mars", "Jupiter", "Saturn"], answer: 1 },
+    { q: "A baby dog is called a ___.", options: ["kitten", "puppy", "cub", "foal"], answer: 1 },
+    { q: "How many continents are there?", options: ["5", "6", "7", "8"], answer: 2 },
+    { q: "Water boils at 100 degrees ___.", options: ["Fahrenheit", "Celsius", "Kelvin", "Newton"], answer: 1 },
+    { q: 'The opposite of "fast" is ___.', options: ["slow", "quick", "rapid", "swift"], answer: 0 }
+  ] } : type === "memory" ? {
+    pairs: [
+      { a: { text: "apple" }, b: { text: "a round red or green fruit" } },
+      { a: { text: "run" }, b: { text: "to move fast on your feet" } },
+      { a: { text: "teacher" }, b: { text: "a person who helps you learn" } },
+      { a: { text: "winter" }, b: { text: "the coldest season of the year" } }
+    ],
+    back: "booster",
+    mode: "solo",
+    teams: 2
+  } : type === "pirate" ? { secs: 20, chests: true, pirateQs: [
+    { q: "Which sentence is correct?", answer: 0, options: [
+      { text: "She goes to school." },
+      { text: "She go to school." },
+      { text: "She going to school." },
+      { text: "She gone to school." }
+    ] },
+    { q: 'The opposite of "expensive" is\u2026', answer: 0, options: [
+      { text: "cheap" },
+      { text: "rich" },
+      { text: "costly" },
+      { text: "heavy" }
+    ] },
+    { q: "Yesterday I ___ to the market.", answer: 1, options: [
+      { text: "go" },
+      { text: "went" },
+      { text: "gone" },
+      { text: "going" }
+    ] }
+  ] } : type === "mole" ? { prompt: "\xA1Aplasta los topos con la oraci\xF3n correcta!", secs: 60, sets: [
+    { options: [{ text: "The cat is on the bed." }, { text: "The cat are on the bed." }], answer: 0 },
+    { options: [{ text: "She goes to school." }, { text: "She go to school." }], answer: 0 },
+    { options: [{ text: "My name is Sara." }, { text: "My name are Sara." }], answer: 0 },
+    { options: [{ text: "They are playing." }, { text: "They is playing." }], answer: 0 }
+  ] } : type === "jigsaw" ? { prompt: "Arma el rompecabezas", level: "normal", imgs: [] } : type === "booster-escape" ? {} : type === "las-vegas" ? {} : type === "word-storm" ? { words: [...WORDSTORM_SAMPLE] } : {};
+  return { ok: true, el: { id: manos.uid("arena"), kind: "arena", arena: type, x: 0, y: 0, w: 100, h: 100, acfg } };
+}
+export {
+  ALL_WIDGETS,
+  ARENAS,
+  ESQUEMAS,
+  FORMA_DEF,
+  buscarDibujo,
+  buscarFondo,
+  cargarBiblioteca,
+  construirArena,
+  construirCatalogo,
+  construirWidget,
+  describirTipo,
+  ejecutar,
+  fallosEnTexto,
+  nuevoBorrador,
+  validarCfgDe
+};