mandioca-tabs-mcp 0.2.17 → 0.2.18

package/index.mjs

@@ -12336,12 +12336,13 @@ function migrarMarcasPorGrado(guardadas, pintarGradosViejo) {
   }
   return salida;
 }
-var DocumentoTabs;
+var CLAVE_DE_LA_SESION, DocumentoTabs;
 var init_documento = __esm({
   "packages/model/src/documento.ts"() {
     init_yjs();
     init_src();
     init_tipos();
+    CLAVE_DE_LA_SESION = "sesion";
     DocumentoTabs = class {
       doc;
       cabecera;
@@ -16458,6 +16459,13 @@ var init_moverNotas = __esm({
 });
 
 // packages/editor/src/atajos.ts
+function comoSeLee(combinacion) {
+  const partes = combinacion.split("+");
+  if (combinacion === "+") return "+";
+  const ultima = partes.pop() ?? "";
+  const legible = COMO_SE_LEE[ultima] ?? (ultima.length === 1 ? ultima.toUpperCase() : ultima);
+  return [...partes.map((m) => MODIFICADORAS[m] ?? m), legible].join(" + ");
+}
 function combinacionesDeLasTablas() {
   return [
     ...Object.keys(MOVIMIENTOS_POR_TECLA),
@@ -16465,7 +16473,7 @@ function combinacionesDeLasTablas() {
     ...Object.keys(ACCIONES_CON_MAYUSCULAS).map(conMayusculas)
   ];
 }
-var conMayusculas, COMANDOS_DE_MENU, COMANDOS_DE_AUDIO, NOMBRE_DE_LA_FIGURA, ATAJOS;
+var conMayusculas, COMANDOS_DE_MENU, COMANDOS_DE_AUDIO, NOMBRE_DE_LA_FIGURA, ATAJOS, COMO_SE_LEE, MODIFICADORAS;
 var init_atajos = __esm({
   "packages/editor/src/atajos.ts"() {
     init_efectos();
@@ -16496,6 +16504,16 @@ var init_atajos = __esm({
       { id: "voz-3", nombre: "Escribir en la voz 3", grupo: "Escribir notas" },
       { id: "voz-4", nombre: "Escribir en la voz 4", grupo: "Escribir notas" },
       { id: "voz-siguiente", nombre: "Pasar a la voz siguiente", grupo: "Escribir notas" },
+      // ★ Las dos puertas a las paletas que NO piden sostener nada (informe «Navegación de paletas
+      //   con teclado», 2026-11-11). Sin tecla de fábrica: el informe pide un comando reasignable,
+      //   y cualquier tecla libre que se eligiera acá le quitaría una a quien ya la usa para otra cosa.
+      //   · `paleta-con-teclado` deja ENGANCHADO el modo del Tab sostenido: para quien no puede
+      //     sostener teclas (temblor, una mano, teclado en pantalla). Sticky Keys de Windows sólo
+      //     engancha modificadores, y Tab no lo es. Se sale con Esc o con el mismo comando.
+      //   · `buscar-en-paletas` es la búsqueda de las siete a la vez: un combobox estándar, que es
+      //     además el camino principal para un lector de pantalla.
+      { id: "paleta-con-teclado", nombre: "Elegir en la paleta con el teclado, sin sostener Tab", grupo: "Escribir notas" },
+      { id: "buscar-en-paletas", nombre: "Buscar en las paletas\u2026", grupo: "Escribir notas" },
       // ── ⛔⛔ EL MENÚ DE LA LÍNEA DIVISORIA, que faltaba (2026-09-01) ───────────────
       //
       // Estas cuatro se construyeron el 2026-09-01 con su menú, su modelo y sus cuatro
@@ -16519,6 +16537,12 @@ var init_atajos = __esm({
       // ★ La sección (2026-09-13): el menú Compás la abre desde el cursor, y entra al catálogo el
       //   mismo día —asignable, sin tecla de fábrica—, que es la regla de toda acción nueva.
       { id: "compas-seccion", nombre: "Secci\xF3n en un comp\xE1s\u2026", grupo: "Compases" },
+      // ★ Repeticiones, casillas y saltos a mano (2026-11-11, función 3 de la competencia). Entran
+      //   el mismo día que el menú, sin tecla de fábrica y asignables. Los nombres llevan las
+      //   palabras que se buscan («casilla», «coda», «segno», «fine»): el buscador lee el nombre.
+      { id: "compas-repeticion", nombre: "Barras de repetici\xF3n en un comp\xE1s o pasaje\u2026", grupo: "Compases" },
+      { id: "compas-casillas", nombre: "Casillas de repetici\xF3n (1.\xAA, 2.\xAA\u2026)\u2026", grupo: "Compases" },
+      { id: "compas-saltos", nombre: "Saltos y destinos: D.C., D.S., Segno, Coda, Fine\u2026", grupo: "Compases" },
       { id: "borrar-compases-desde", nombre: "Borrar de un comp\xE1s en adelante", grupo: "Compases" },
       { id: "borrar-compases-hasta", nombre: "Borrar de un comp\xE1s para atr\xE1s", grupo: "Compases" },
       // ── EL ASPECTO DE LA OBRA (2026-09-01) ────────────────────────────
@@ -16657,11 +16681,29 @@ var init_atajos = __esm({
       //   teclado (ver `accionDe`).
       { id: "paleta-siguiente", nombre: "Pasar a la siguiente paleta (abre el panel de edici\xF3n si est\xE1 cerrado)", grupo: "Escribir notas", teclas: ["Tab"], reasignable: true },
       // ★ 2026-11-03. Tab tocado pasa de paleta; Tab SOSTENIDO en la de acordes le da las flechas.
+      {
+        // ★ Desde el 2026-11-11, en las siete paletas y con la misma gramática. Ver
+        //   `paletasConTeclado.ts`.
+        id: "paleta-con-tab",
+        nombre: "Con Tab sostenido en cualquier paleta: \u2190 \u2192 elegir, \u2193 o Intro escribir, \u2191 quitar, letras para buscar, Esc para salir",
+        grupo: "Escribir notas",
+        teclas: ["Tab + \u2190 \u2192", "Tab + \u2193", "Tab + \u2191", "Tab + letras", "Tab + Esc"],
+        reasignable: false,
+        porQueNo: "Va con las flechas, que marcan la direcci\xF3n; Tab se reasigna en \xABPasar a la siguiente paleta\xBB."
+      },
+      {
+        id: "paleta-con-tab-posicion",
+        nombre: "Con Tab sostenido en Figura o Matiz: 1 a 9 eligen la ficha por su lugar",
+        grupo: "Escribir notas",
+        teclas: ["Tab + 1 \u2026 9"],
+        reasignable: false,
+        porQueNo: "Los d\xEDgitos son la posici\xF3n de la ficha, como sin Tab son el traste."
+      },
       {
         id: "acorde-con-tab",
-        nombre: "Con Tab sostenido en la paleta de acordes: \u2190 \u2192 elegir, \u2193 o Intro escribirlo (Ctrl: s\xF3lo las notas), \u2191 quitarlo",
+        nombre: "Con Tab sostenido en la paleta de acordes: Ctrl + \u2193 escribe s\xF3lo las notas",
         grupo: "Escribir notas",
-        teclas: ["Tab + \u2190 \u2192", "Tab + \u2193", "Tab + Ctrl + \u2193", "Tab + \u2191"],
+        teclas: ["Tab + Ctrl + \u2193"],
         reasignable: false,
         porQueNo: "Va con las flechas, que marcan la direcci\xF3n; Tab se reasigna en \xABPasar a la siguiente paleta\xBB."
       },
@@ -16790,6 +16832,20 @@ var init_atajos = __esm({
       //   toda la ventana— y por eso todavía no se reasigna.
       { id: "info", nombre: "Mostrar u ocultar la ventana de info", grupo: "Vista y pistas", teclas: ["?"], reasignable: false, porQueNo: "Responde en toda la ventana, tambi\xE9n fuera del pliego: cambiarlo es otro trabajo." }
     ];
+    COMO_SE_LEE = {
+      " ": "Espacio",
+      ArrowUp: "\u2191",
+      ArrowDown: "\u2193",
+      ArrowLeft: "\u2190",
+      ArrowRight: "\u2192",
+      Delete: "Supr",
+      Backspace: "Retroceso",
+      Home: "Inicio",
+      End: "Fin",
+      Enter: "Entrar",
+      Escape: "Esc"
+    };
+    MODIFICADORAS = { Shift: "May" };
   }
 });
 
@@ -20612,9 +20668,207 @@ var init_acordes = __esm({
 });
 
 // packages/editor/src/miraDeAcordes.ts
+var MIRA_DEDUCIR;
 var init_miraDeAcordes = __esm({
   "packages/editor/src/miraDeAcordes.ts"() {
     init_acordes();
+    MIRA_DEDUCIR = "+deducir";
+  }
+});
+
+// packages/editor/src/paletasConTeclado.ts
+function fichasFijas(familia) {
+  switch (familia) {
+    case "figura":
+      return [
+        ...FIGURAS.map((f) => ({ id: `figura-${f.valor}`, nombre: f.nombre, atajo: `figura-${f.valor}` })),
+        { id: "puntillo", nombre: "puntillo", atajo: "puntillo" },
+        { id: "silencio", nombre: "silencio", atajo: "silencio" }
+      ].map(conSinonimos);
+    case "tecnica":
+      return [
+        ...EFECTOS_EN_ORDEN.map((e) => ({ id: `efecto-${e}`, nombre: EFECTOS[e].nombre, atajo: `efecto-${e}` })),
+        ...FORMAS_EN_ORDEN.map((f) => ({
+          id: `bend-${f}`,
+          nombre: FORMAS_DE_BEND[f].nombre,
+          ...f === "bend" ? { atajo: "bend" } : {}
+        })),
+        ...ALTURAS_DE_BEND.map((a) => ({ id: `sube-${a.cuartos}`, nombre: `sube ${a.nombre.toLowerCase()}` })),
+        { id: "curva", nombre: "curva propia" }
+      ].map(conSinonimos);
+    case "signo":
+      return GRUPOS_EN_ORDEN.flatMap(
+        (g) => signosDelGrupo(g).map((s) => ({ id: `signo-${s.clave}`, nombre: s.nombre, atajo: `signo-${s.clave}` }))
+      ).map(conSinonimos);
+    case "matiz":
+      return MATICES.map((m) => {
+        const [italiano = "", resto = ""] = m.detalle.split("\u2014");
+        const castellano = resto.split(".")[0] ?? "";
+        return {
+          id: `matiz-${m.nombre}`,
+          nombre: m.nombre,
+          sinonimos: [italiano.trim(), castellano.trim()].filter(Boolean),
+          atajo: `comando-matiz-${m.nombre}`
+        };
+      });
+    case "kit":
+      return KIT.map((p) => conSinonimos({ id: `kit-${p.indice}`, nombre: p.nombre }));
+    case "acorde":
+    case "seccion":
+      return [];
+  }
+}
+function fichasDeAcordes(usados) {
+  return [
+    { id: MIRA_DEDUCIR, nombre: "+ acorde", sinonimos: ["a\xF1adir", "deducir", "el del golpe"] },
+    ...usados.map((a) => ({ id: a.clave, nombre: a.letra ? `${a.nombre} ${a.letra}` : a.nombre }))
+  ];
+}
+function fichasDeSecciones(nombres) {
+  const vistos = /* @__PURE__ */ new Set();
+  const unicos = [];
+  for (const n of nombres) {
+    const limpio = n.trim();
+    if (limpio && !vistos.has(limpio)) {
+      vistos.add(limpio);
+      unicos.push(limpio);
+    }
+  }
+  return [
+    { id: SECCION_NUEVA, nombre: "nombre nuevo", sinonimos: ["escribir", "otra"] },
+    ...unicos.map((n) => ({ id: `seccion:${n}`, nombre: n }))
+  ];
+}
+function normalizarBusqueda(texto4) {
+  return texto4.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/\s+/g, " ").trim();
+}
+function puntajeDeBusqueda(ficha, texto4) {
+  const q = normalizarBusqueda(texto4);
+  if (!q) return null;
+  const nombre = normalizarBusqueda(ficha.nombre);
+  const otros = (ficha.sinonimos ?? []).map(normalizarBusqueda);
+  if (nombre === q) return -1;
+  if (nombre.startsWith(q)) return 0;
+  if (otros.some((s) => s.startsWith(q))) return 1;
+  const palabras = [nombre, ...otros].flatMap((t) => t.split(/[\s(),/-]+/));
+  if (palabras.some((p) => p.startsWith(q))) return 2;
+  if (nombre.includes(q) || otros.some((s) => s.includes(q))) return 3;
+  return null;
+}
+function buscarEnLasPaletas(paletas, texto4, limite = 12) {
+  if (!normalizarBusqueda(texto4)) return [];
+  const todos = [];
+  let orden = 0;
+  for (const { familia, fichas } of paletas) {
+    for (const ficha of fichas) {
+      const p = puntajeDeBusqueda(ficha, texto4);
+      if (p !== null) todos.push({ familia, ficha, puntaje: p, orden });
+      orden++;
+    }
+  }
+  return todos.sort((a, b) => a.puntaje - b.puntaje || a.orden - b.orden).slice(0, limite).map(({ familia, ficha, puntaje: p }) => ({ familia, ficha, puntaje: p }));
+}
+var NOMBRE_DE_LA_FAMILIA, SINONIMOS, conSinonimos, FIGURAS, SECCION_NUEVA;
+var init_paletasConTeclado = __esm({
+  "packages/editor/src/paletasConTeclado.ts"() {
+    init_efectos();
+    init_bend();
+    init_variantes();
+    init_signos();
+    init_dinamicas();
+    init_miraDeAcordes();
+    init_src2();
+    NOMBRE_DE_LA_FAMILIA = {
+      figura: "Figura",
+      tecnica: "T\xE9cnica",
+      signo: "Signo",
+      acorde: "Acorde",
+      kit: "Bater\xEDa",
+      matiz: "Matiz",
+      seccion: "Secci\xF3n"
+    };
+    SINONIMOS = {
+      // Figuras
+      "figura-1": ["entera", "whole"],
+      "figura-2": ["mitad", "half"],
+      "figura-4": ["cuarto", "quarter"],
+      "figura-8": ["octavo", "eighth"],
+      "figura-16": ["dieciseisavo", "sixteenth"],
+      "figura-32": ["treintaidosavo", "thirty-second"],
+      "figura-64": ["sesentaicuatroavo", "sixty-fourth"],
+      puntillo: ["punto", "dot"],
+      silencio: ["pausa", "rest"],
+      // Técnicas
+      "efecto-martillo": ["ligado", "hammer", "hammer-on", "pull-off"],
+      "efecto-deslizamiento": ["slide", "glissando", "arrastre"],
+      "efecto-muerta": ["apagada", "dead note", "muted"],
+      "efecto-palmMute": ["muteado", "apagado con la palma", "pm"],
+      "efecto-letRing": ["dejar sonar", "que suene"],
+      "efecto-vibrato": ["temblor"],
+      "efecto-fantasma": ["ghost", "nota fantasma"],
+      "efecto-armonico": ["harmonic", "flageolet"],
+      "efecto-staccato": ["staccato", "corto"],
+      "efecto-ligadaAAnterior": ["ligadura de prolongaci\xF3n", "tie", "prolongar"],
+      "bend-bend": ["estirar", "estirada", "bending"],
+      "bend-bendVuelta": ["release", "estirar y soltar"],
+      "bend-prebend": ["pre bend", "ya estirada"],
+      "bend-prebendVuelta": ["pre bend release"],
+      curva: ["curva de bend", "dibujar"],
+      // Signos
+      "signo-acento": ["accent", "marcato"],
+      "signo-ligaduraDeExpresion": ["ligado", "slur", "legato"],
+      "signo-calderon": ["fermata", "corona"],
+      "signo-pedal": ["sustain", "pedal"],
+      "signo-anchoDeVibrato": ["vibrato"],
+      "signo-vibratoDePalanca": ["whammy", "tremolo bar", "palanca"],
+      "signo-tappingIzquierda": ["tap"],
+      "signo-dedoIzquierda": ["digitacion", "dedo", "fingering"],
+      "signo-cejilla": ["barre", "cejuela", "capo"],
+      "signo-puaDireccion": ["pick", "plectro", "downstroke", "upstroke", "direccion"],
+      "signo-rasgueo": ["arpegio", "strum", "brush"],
+      "signo-rasgueado": ["flamenco"],
+      "signo-slap": ["bajo"],
+      "signo-pop": ["bajo"],
+      "signo-tapping": ["tap"],
+      "signo-slapMuerto": ["dead slap"],
+      "signo-golpeEnLaTapa": ["percusion", "tapa"],
+      "signo-dedoDerecha": ["pima", "digitacion", "dedo"],
+      "signo-adorno": ["grace", "appoggiatura", "acciaccatura", "mordente"],
+      "signo-tremolo": ["tremolo picking", "tremolo"],
+      "signo-trino": ["trill"],
+      "signo-regulador": ["crescendo", "decrescendo", "hairpin"],
+      "signo-fundido": ["fade", "volume swell"],
+      "signo-wah": ["wah"],
+      "signo-alteracion": ["sostenido", "bemol", "becuadro", "accidental"],
+      "signo-muestraCuerda": ["cuerda", "string"],
+      "signo-barraOblicua": ["slash", "ritmo"],
+      "signo-plicaInvertida": ["plica", "stem"],
+      "signo-barrado": ["beam", "corchete"],
+      // Batería
+      "kit-0": ["kick", "bass drum"],
+      "kit-1": ["snare", "redoblante", "tarola"],
+      "kit-2": ["rimshot", "aro"],
+      "kit-3": ["tom", "high tom"],
+      "kit-4": ["tom", "mid tom"],
+      "kit-5": ["floor tom", "tom de pie"],
+      "kit-6": ["hi-hat", "hihat", "contratiempo", "hh"],
+      "kit-7": ["hi-hat abierto", "hihat abierto"],
+      "kit-8": ["hi-hat pedal", "pie"],
+      "kit-9": ["platillo", "crash"],
+      "kit-10": ["platillo", "ride"],
+      "kit-11": ["bell", "campana"]
+    };
+    conSinonimos = (f) => SINONIMOS[f.id] ? { ...f, sinonimos: SINONIMOS[f.id] } : f;
+    FIGURAS = [
+      { valor: 1, nombre: "redonda" },
+      { valor: 2, nombre: "blanca" },
+      { valor: 4, nombre: "negra" },
+      { valor: 8, nombre: "corchea" },
+      { valor: 16, nombre: "semicorchea" },
+      { valor: 32, nombre: "fusa" },
+      { valor: 64, nombre: "semifusa" }
+    ];
+    SECCION_NUEVA = "+nueva";
   }
 });
 
@@ -20823,9 +21077,11 @@ var init_instrumentos = __esm({
         programaMidi: PROGRAMAS.guitarraNylon
       },
       // ── Teclados ──
+      // ★ (2026-11-11) Los tres en DOS pentagramas bajo una llave, como se escriben: el órgano también
+      //   (antes salía en uno, sin llave). Ver `verificar-llave-del-piano`.
       { clave: "piano", nombre: "Piano", nombreCorto: "pno", grupo: "Teclados", tipo: "altura", afinacion: [], programaMidi: PROGRAMAS.piano, pentagramas: 2 },
       { clave: "piano-electrico", nombre: "Piano el\xE9ctrico", nombreCorto: "e.pno", grupo: "Teclados", tipo: "altura", afinacion: [], programaMidi: PROGRAMAS.pianoElectrico, pentagramas: 2 },
-      { clave: "organo", nombre: "\xD3rgano", nombreCorto: "org", grupo: "Teclados", tipo: "altura", afinacion: [], programaMidi: PROGRAMAS.organo },
+      { clave: "organo", nombre: "\xD3rgano", nombreCorto: "org", grupo: "Teclados", tipo: "altura", afinacion: [], programaMidi: PROGRAMAS.organo, pentagramas: 2 },
       // ── Vientos ──
       { clave: "trompeta", nombre: "Trompeta", nombreCorto: "tpt", grupo: "Vientos", tipo: "altura", afinacion: [], programaMidi: PROGRAMAS.trompeta },
       { clave: "trombon", nombre: "Tromb\xF3n", nombreCorto: "tbn", grupo: "Vientos", tipo: "altura", afinacion: [], programaMidi: PROGRAMAS.trombon },
@@ -21301,6 +21557,18 @@ var init_menus = __esm({
         principiante: "Borra la nota que est\xE1 bajo el cursor. El tiempo que ocupaba queda en su lugar, como silencio, as\xED que el comp\xE1s no se corre.",
         profesional: "Borra la nota; el golpe queda."
       },
+      "menu-buscar-en-paletas": {
+        nombre: "Buscar en las paletas\u2026",
+        accion: "comando-buscar-en-paletas",
+        principiante: "Abre un buscador que mira las siete paletas a la vez. Escribe el nombre de un signo, una t\xE9cnica, una figura o un matiz, y elige con las flechas. Sirve cuando no sabes en qu\xE9 paleta est\xE1 algo.",
+        profesional: "B\xFAsqueda global de paletas."
+      },
+      "menu-paleta-con-teclado": {
+        nombre: "Paleta con el teclado, sin sostener Tab",
+        accion: "comando-paleta-con-teclado",
+        principiante: "Hace lo mismo que mantener Tab apretado, pero sin tener que sostenerlo: las flechas eligen en la paleta, \u2193 escribe, \u2191 quita y las letras buscan. Sirve si sostener una tecla te cuesta. Para salir, Esc o este mismo comando.",
+        profesional: "Modo fijo del Tab sostenido; Esc o el mismo comando salen."
+      },
       "menu-borrar-figura": {
         nombre: "Borrar la figura entera",
         accion: "borrar-figura",
@@ -21383,6 +21651,24 @@ var init_menus = __esm({
         principiante: "Le pone un nombre a la parte que empieza en el comp\xE1s del cursor: Intro, Estrofa, Coro, el que quieras. Si ah\xED ya empieza una secci\xF3n, puedes cambiarle el nombre o borrarlo.",
         profesional: "Marca de secci\xF3n en el comp\xE1s del cursor."
       },
+      "menu-repeticion": {
+        nombre: "Repetici\xF3n\u2026",
+        accion: "comando-compas-repeticion",
+        principiante: "Pone las barras de repetici\xF3n. Con un pasaje marcado, abre en su primer comp\xE1s y cierra en el \xFAltimo. Sin pasaje, va en el comp\xE1s del cursor. Eliges cu\xE1ntas veces se toca. Desmarca las barras para quitarlas.",
+        profesional: "Barras de inicio y fin de repetici\xF3n, con n\xFAmero de veces."
+      },
+      "menu-casillas": {
+        nombre: "Casillas\u2026",
+        accion: "comando-compas-casillas",
+        principiante: "Pone una casilla de repetici\xF3n, la 1.\xAA o la 2.\xAA: el comp\xE1s se toca s\xF3lo en esas vueltas. Con un pasaje marcado, la casilla abarca todo el pasaje. Necesita una barra de cierre para hacer algo.",
+        profesional: "Casillas 1.\xAA, 2.\xAA\u2026 del comp\xE1s o del pasaje."
+      },
+      "menu-saltos": {
+        nombre: "D.C., D.S. y Coda\u2026",
+        accion: "comando-compas-saltos",
+        principiante: "Pone en el comp\xE1s del cursor un salto (D.C., D.S., To Coda) o un destino (Segno, Coda, Fine). Un D.S. al Coda necesita tres marcas: el Segno, el To Coda y la Coda. La ventana te avisa si falta alguna.",
+        profesional: "Segno, Coda, Fine y los saltos del comp\xE1s del cursor."
+      },
       // ── Nota ────────────────────────────────────────────────────────────────────
       "menu-duplicar": {
         nombre: "Repetir la nota anterior",
@@ -21651,6 +21937,12 @@ var init_barra = __esm({
         principiante: "Ajustes para practicar: un comp\xE1s de cuenta antes de que entre la m\xFAsica, y que la velocidad suba sola cada tantas vueltas del bucle hasta la que elijas. De f\xE1brica todo apagado.",
         profesional: "Count-in y speed trainer del bucle."
       },
+      // ★ Sólo existe con el teléfono parado (2026-11-11): la de escritorio vive en el panel de audio.
+      "barra.velocidad": {
+        nombre: "Velocidad",
+        principiante: "La obra suena m\xE1s lenta o m\xE1s r\xE1pida, de \xD70,25 a \xD71,5. La afinaci\xF3n no cambia. Sirve para sacar un pasaje dif\xEDcil de a poco.",
+        profesional: "Velocidad del transporte, \xD70,25 a \xD71,5, con el tono intacto."
+      },
       "barra.voz": {
         nombre: "Voz",
         principiante: "En qu\xE9 voz escribes. Una voz es una l\xEDnea mel\xF3dica dentro del mismo pentagrama: por ejemplo, el bajo en la voz 1 y la melod\xEDa en la voz 2, cada una con sus propias figuras. Lo que teclees va a la voz marcada.",
@@ -21711,7 +22003,7 @@ function fichaDeSigno(s) {
     profesional: s.ayuda.length <= 120 && (s.ayuda.match(/[.!?](\s|$)/g) ?? []).length <= 2 ? s.ayuda : `${s.nombre}.`
   };
 }
-var FICHAS_DE_SIGNOS, FIGURAS, FICHAS_DE_FIGURAS, FICHAS_DE_MATICES, FICHAS_DE_LA_PALETA;
+var FICHAS_DE_SIGNOS, FIGURAS2, FICHAS_DE_FIGURAS, FICHAS_DE_MATICES, FICHAS_DE_LA_PALETA;
 var init_paleta = __esm({
   "packages/editor/src/info/fichas/paleta.ts"() {
     init_signos();
@@ -21719,7 +22011,7 @@ var init_paleta = __esm({
     FICHAS_DE_SIGNOS = Object.fromEntries(
       SIGNOS.map((s) => [`signo.${s.clave}`, fichaDeSigno(s)])
     );
-    FIGURAS = [
+    FIGURAS2 = [
       { valor: 1, nombre: "Redonda", dura: "cuatro tiempos en un comp\xE1s de 4/4" },
       { valor: 2, nombre: "Blanca", dura: "dos tiempos" },
       { valor: 4, nombre: "Negra", dura: "un tiempo" },
@@ -21729,7 +22021,7 @@ var init_paleta = __esm({
       { valor: 64, nombre: "Semifusa", dura: "un dieciseisavo de tiempo" }
     ];
     FICHAS_DE_FIGURAS = Object.fromEntries(
-      FIGURAS.map((f) => [
+      FIGURAS2.map((f) => [
         `figura.${f.valor}`,
         {
           nombre: f.nombre,
@@ -21898,6 +22190,19 @@ var init_paleta = __esm({
         principiante: "Borra el nombre del acorde del golpe del cursor. Las notas no se tocan.",
         profesional: "Quita el cifrado del golpe."
       },
+      // ── Sección ─────────────────────────────────────────────────────────────────
+      "seccion.usada": {
+        nombre: "Secci\xF3n de la obra",
+        principiante: "Un nombre de secci\xF3n que ya usaste en esta obra, como Coro o Verso. Un clic lo pone en el comp\xE1s del cursor. Para uno nuevo, escribe en el campo.",
+        profesional: "Reutiliza un r\xF3tulo de secci\xF3n de la obra."
+      },
+      // ── El teclado en las paletas (2026-11-11) ──────────────────────────────────
+      "paleta.busqueda": {
+        nombre: "Buscar en las paletas",
+        accion: "comando-buscar-en-paletas",
+        principiante: "Escribe el nombre de lo que quieres poner \u2014acento, martillo, corchea, ff\u2014 y busca en las siete paletas a la vez. Acepta otros nombres, como hammer o fermata. Cada resultado dice en qu\xE9 paleta est\xE1 y su tecla, para que la pr\xF3xima vez vayas directo. Las flechas eligen, Intro lo pone y Esc cierra.",
+        profesional: "B\xFAsqueda en todas las paletas, con sin\xF3nimos y la tecla de cada resultado."
+      },
       // ── Batería ─────────────────────────────────────────────────────────────────
       "kit.pieza": {
         nombre: "Pieza de la bater\xEDa",
@@ -22265,6 +22570,21 @@ var init_paneles = __esm({
         principiante: "Pone una armadura nueva desde el comp\xE1s que empieza en esta l\xEDnea, hasta el pr\xF3ximo cambio.",
         profesional: "Cambio de armadura desde este comp\xE1s."
       },
+      "linea.repeticion": {
+        nombre: "Repetici\xF3n",
+        principiante: "Pone las barras de repetici\xF3n en el comp\xE1s que empieza en esta l\xEDnea. Si ese comp\xE1s est\xE1 dentro de un pasaje marcado, las pone en todo el pasaje.",
+        profesional: "Barras de repetici\xF3n aqu\xED o en el pasaje."
+      },
+      "linea.casillas": {
+        nombre: "Casillas",
+        principiante: "Pone una casilla 1.\xAA, 2.\xAA\u2026 en el comp\xE1s que empieza en esta l\xEDnea, o en todo el pasaje marcado si est\xE1 adentro.",
+        profesional: "Casillas aqu\xED o en el pasaje."
+      },
+      "linea.saltos": {
+        nombre: "D.C., D.S. y Coda",
+        principiante: "Pone un salto o un destino \u2014Segno, Coda, Fine, D.S. al Coda\u2014 en el comp\xE1s que empieza en esta l\xEDnea.",
+        profesional: "Saltos y destinos de este comp\xE1s."
+      },
       "linea.insertar-izquierda": {
         nombre: "Insertar comp\xE1s a la izquierda",
         principiante: "Mete un comp\xE1s vac\xEDo ANTES del comp\xE1s que empieza en esta l\xEDnea. Sirve tambi\xE9n para agregar uno al principio de la obra.",
@@ -22489,6 +22809,37 @@ var init_dialogos = __esm({
         principiante: "Escribe c\xF3mo se llama la parte \u2014Intro, Coro, Puente\u2014. Vac\xEDo, saca la secci\xF3n que hab\xEDa.",
         profesional: "Texto de la secci\xF3n; vac\xEDo la quita."
       },
+      // ── Repeticiones, casillas y saltos (2026-11-11) ────────────────────────────
+      "repeticion.abre": {
+        nombre: "Barra de inicio",
+        principiante: "La barra con dos puntos que marca d\xF3nde empieza lo que se repite. Desm\xE1rcala para quitarla.",
+        profesional: "Barra de inicio de repetici\xF3n."
+      },
+      "repeticion.cierra": {
+        nombre: "Barra de fin",
+        principiante: "La barra con dos puntos donde la m\xFAsica vuelve al inicio de la repetici\xF3n. Desm\xE1rcala para quitarla.",
+        profesional: "Barra de fin de repetici\xF3n."
+      },
+      "repeticion.veces": {
+        nombre: "Veces",
+        principiante: "Cu\xE1ntas veces se toca el pasaje en total, contando la primera. 2 es lo normal y no se escribe en el pliego; desde 3 aparece \xABx3\xBB.",
+        profesional: "Pasadas totales (2\u201364)."
+      },
+      "casillas.vuelta": {
+        nombre: "Vuelta",
+        principiante: "En qu\xE9 vuelta de la repetici\xF3n se toca este comp\xE1s. Puedes marcar m\xE1s de una, como \xAB1. 2.\xBB. Sin ninguna marcada, se quita la casilla.",
+        profesional: "Vueltas en que suena; ninguna la quita."
+      },
+      "saltos.destino": {
+        nombre: "Destino",
+        principiante: "Un lugar al que otro comp\xE1s salta: el Segno para un D.S., la Coda para un \xABal Coda\xBB, el Fine para un \xABal Fine\xBB.",
+        profesional: "Marca de destino (Segno, Coda, Fine)."
+      },
+      "saltos.salto": {
+        nombre: "Salto",
+        principiante: "Manda la m\xFAsica a otro lugar al terminar el comp\xE1s. D.C. vuelve al principio y D.S. al Segno. To Coda marca d\xF3nde se salta a la Coda en la segunda pasada.",
+        profesional: "Salto (D.C., D.S., To Coda\u2026)."
+      },
       "golpe.letra": {
         nombre: "S\xEDlaba",
         principiante: "La s\xEDlaba de la letra que se canta en este golpe. Vac\xEDa, saca la que hab\xEDa.",
@@ -23029,6 +23380,7 @@ var init_src3 = __esm({
     init_silabas();
     init_acordes();
     init_miraDeAcordes();
+    init_paletasConTeclado();
     init_alinearLetra();
     init_diapason();
     init_video();
@@ -87649,6 +88001,151 @@ var init_alphaTab = __esm({
   }
 });
 
+// packages/io/src/manosDelPiano.ts
+function repartirManos(notas, P = PARAMETROS_DE_MANOS) {
+  const derecha = [];
+  const izquierda = [];
+  const orden = notas.map((_, i3) => i3).sort((a, b) => notas[a].ini - notas[b].ini || notas[a].altura - notas[b].altura);
+  let centroD = P.centroDerecha;
+  let centroI = P.centroIzquierda;
+  let sostieneD = [];
+  let sostieneI = [];
+  let ultimaD = null;
+  let ultimaI = null;
+  let i2 = 0;
+  while (i2 < orden.length) {
+    const ini = notas[orden[i2]].ini;
+    const golpe = [];
+    while (i2 < orden.length && notas[orden[i2]].ini === ini) golpe.push(orden[i2++]);
+    sostieneD = sostieneD.filter((j) => notas[j].fin > ini);
+    sostieneI = sostieneI.filter((j) => notas[j].fin > ini);
+    const techoI = sostieneI.length ? Math.max(...sostieneI.map((j) => notas[j].altura)) : -Infinity;
+    const pisoD = sostieneD.length ? Math.min(...sostieneD.map((j) => notas[j].altura)) : Infinity;
+    let mejor = { corte: 0, costo: Infinity, distanciaAlDo: Infinity };
+    for (let corte = 0; corte <= golpe.length; corte++) {
+      const abajo = golpe.slice(0, corte).map((j) => notas[j].altura);
+      const arriba = golpe.slice(corte).map((j) => notas[j].altura);
+      let costo = 0;
+      for (const a of abajo) costo += Math.abs(a - centroI) + (a >= DO_CENTRAL ? P.costoLadoDelDo : 0);
+      for (const a of arriba) costo += Math.abs(a - centroD) + (a < DO_CENTRAL ? P.costoLadoDelDo : 0);
+      const manoI = [...abajo, ...abajo.length ? sostieneI.map((j) => notas[j].altura) : []];
+      const manoD = [...arriba, ...arriba.length ? sostieneD.map((j) => notas[j].altura) : []];
+      for (const mano of [manoI, manoD]) {
+        if (mano.length < 2) continue;
+        const abre = Math.max(...mano) - Math.min(...mano);
+        if (abre > P.abertura) costo += P.costoAbertura + (abre - P.abertura) * 4;
+      }
+      for (const a of arriba) if (a < techoI) costo += P.costoCruce;
+      for (const a of abajo) if (a > pisoD) costo += P.costoCruce;
+      if (golpe.length === 1) {
+        const a = notas[golpe[0]].altura;
+        if (abajo.length && ultimaI !== null && Math.abs(a - ultimaI) <= P.continuidadCerca) costo -= P.premioContinuidad;
+        if (arriba.length && ultimaD !== null && Math.abs(a - ultimaD) <= P.continuidadCerca) costo -= P.premioContinuidad;
+      }
+      const delDo = Math.abs(corte - golpe.filter((j) => notas[j].altura < DO_CENTRAL).length);
+      if (costo < mejor.costo - 1e-9 || Math.abs(costo - mejor.costo) <= 1e-9 && delDo < mejor.distanciaAlDo)
+        mejor = { corte, costo, distanciaAlDo: delDo };
+    }
+    const deI = golpe.slice(0, mejor.corte);
+    const deD = golpe.slice(mejor.corte);
+    izquierda.push(...deI);
+    derecha.push(...deD);
+    sostieneI.push(...deI);
+    sostieneD.push(...deD);
+    const media = (js) => js.reduce((s, j) => s + notas[j].altura, 0) / js.length;
+    if (deI.length) {
+      centroI = centroI * (1 - P.seguimiento) + media(deI) * P.seguimiento;
+      ultimaI = notas[deI[deI.length - 1]].altura;
+    } else centroI += (P.centroIzquierda - centroI) * P.regreso;
+    if (deD.length) {
+      centroD = centroD * (1 - P.seguimiento) + media(deD) * P.seguimiento;
+      ultimaD = notas[deD[0]].altura;
+    } else centroD += (P.centroDerecha - centroD) * P.regreso;
+  }
+  return { derecha, izquierda };
+}
+function baseDeLasManos(nombreDerecha, nombreIzquierda) {
+  const d = DERECHA.exec(nombreDerecha.trim());
+  const i2 = IZQUIERDA.exec(nombreIzquierda.trim());
+  if (!d || !i2) return null;
+  const base = (s) => s.trim().replace(/[\s\-_.:,(]+$/, "").trim();
+  const bd = base(d[1]);
+  const bi = base(i2[1]);
+  if (bd.toLocaleLowerCase("es") !== bi.toLocaleLowerCase("es")) return null;
+  return bd || "Piano";
+}
+function juntarManosDelPiano(documento) {
+  const enOrden = documento.pistasEnOrden().map((p) => p.id);
+  const parejas = [];
+  for (let i2 = 0; i2 + 1 < enOrden.length; i2++) {
+    const d = documento.pistas.get(enOrden[i2]);
+    const iz = documento.pistas.get(enOrden[i2 + 1]);
+    const mismoInstrumento = d.get("tipo") === "altura" && iz.get("tipo") === "altura" && (d.get("pentagramas") ?? 1) === 1 && (iz.get("pentagramas") ?? 1) === 1 && d.get("programaMidi") === iz.get("programaMidi");
+    if (!mismoInstrumento) continue;
+    const porNombre = baseDeLasManos(String(d.get("nombre") ?? ""), String(iz.get("nombre") ?? ""));
+    const porCorto = baseDeLasManos(String(d.get("nombreCorto") ?? ""), String(iz.get("nombreCorto") ?? ""));
+    const base = porNombre ?? (porCorto !== null ? String(d.get("nombre") ?? "").trim() || porCorto : null);
+    if (!base) continue;
+    parejas.push({ derecha: enOrden[i2], izquierda: enOrden[i2 + 1], indiceIzquierda: i2 + 1, base });
+    i2++;
+  }
+  if (parejas.length === 0) return 0;
+  documento.doc.transact(() => {
+    for (const { derecha, izquierda, base } of parejas) {
+      const d = documento.pistas.get(derecha);
+      const corto = String(d.get("nombreCorto") ?? "");
+      d.set("pentagramas", 2);
+      d.set("nombre", base);
+      d.set("nombreCorto", corto.replace(/[\s\-_.:,(]*(mano\s+derecha|right\s+hand|r\.?\s?h\.?|m\.?\s?d\.?|rh|md)\)?\s*$/i, "").trim() || base);
+      for (const compas of documento.compases.values()) {
+        if (compas.get("pistaId") !== izquierda) continue;
+        compas.set("pistaId", derecha);
+        compas.set("pentagrama", 1);
+      }
+      documento.pistas.delete(izquierda);
+    }
+    const sesion = documento.ajustes.get(CLAVE_DE_LA_SESION);
+    if (sesion && typeof sesion === "object" && !Array.isArray(sesion)) {
+      const quitadas = new Set(parejas.map((p) => p.izquierda));
+      const nueva = { ...sesion };
+      for (const clave of ["mezcla", "volumenEnSolo", "notacionPorPista"]) {
+        const v = nueva[clave];
+        if (!v || typeof v !== "object" || Array.isArray(v)) continue;
+        nueva[clave] = Object.fromEntries(Object.entries(v).filter(([id2]) => !quitadas.has(id2)));
+      }
+      if (Array.isArray(nueva.pistasConOjo)) {
+        let lista2 = nueva.pistasConOjo.filter((n) => typeof n === "number");
+        for (const quitado of parejas.map((p) => p.indiceIzquierda).sort((x2, y) => y - x2))
+          lista2 = lista2.filter((n) => n !== quitado).map((n) => n > quitado ? n - 1 : n);
+        nueva.pistasConOjo = lista2;
+      }
+      documento.ajustes.set(CLAVE_DE_LA_SESION, nueva);
+    }
+  });
+  return parejas.length;
+}
+var DO_CENTRAL, PARAMETROS_DE_MANOS, DERECHA, IZQUIERDA;
+var init_manosDelPiano = __esm({
+  "packages/io/src/manosDelPiano.ts"() {
+    init_src2();
+    DO_CENTRAL = 60;
+    PARAMETROS_DE_MANOS = {
+      centroDerecha: 72,
+      centroIzquierda: 52,
+      abertura: 12,
+      costoAbertura: 20,
+      costoCruce: 25,
+      continuidadCerca: 7,
+      premioContinuidad: 12,
+      costoLadoDelDo: 1.5,
+      seguimiento: 0.3,
+      regreso: 0.1
+    };
+    DERECHA = /^(.*?)[\s\-_.:,(]*\b(mano\s+derecha|m\.?\s?d\.?|right\s+hand|r\.?\s?h\.?|rh|md|derecha|right|treble)\)?\s*$/i;
+    IZQUIERDA = /^(.*?)[\s\-_.:,(]*\b(mano\s+izquierda|m\.?\s?i\.?|left\s+hand|l\.?\s?h\.?|lh|mi|izquierda|left|bass)\)?\s*$/i;
+  }
+});
+
 // node_modules/fflate/esm/index.mjs
 import { createRequire } from "module";
 function deflateSync(data, opts) {
@@ -88630,484 +89127,1048 @@ var init_esm = __esm({
   }
 });
 
-// packages/io/src/musicxmlEntrada.ts
-function textoMusicXml(bytes) {
-  if (bytes.length > 4 && bytes[0] === 80 && bytes[1] === 75) {
-    let archivos;
-    try {
-      archivos = unzipSync(bytes);
-    } catch {
-      return null;
-    }
-    const contenedor = archivos["META-INF/container.xml"];
-    if (!contenedor) return null;
-    const ruta = /<rootfile\b[^>]*full-path="([^"]+)"/.exec(strFromU8(contenedor))?.[1];
-    const raiz = ruta ? archivos[ruta] : void 0;
-    return raiz ? decodificar(raiz) : null;
-  }
-  const texto4 = decodificar(bytes.subarray(0, Math.min(bytes.length, 4096)));
-  if (!/<score-(partwise|timewise)\b/.test(texto4) && !/<!DOCTYPE\s+score-/.test(texto4)) return null;
-  return decodificar(bytes);
+// packages/io/src/musicxml.ts
+function escapar(texto4) {
+  return texto4.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-function decodificar(bytes) {
-  if (bytes[0] === 255 && bytes[1] === 254) return new TextDecoder("utf-16le").decode(bytes);
-  if (bytes[0] === 254 && bytes[1] === 255) return new TextDecoder("utf-16be").decode(bytes);
-  return new TextDecoder("utf-8").decode(bytes);
+function elemento(nombre, texto4) {
+  if (texto4 === null || texto4 === void 0 || texto4 === "") return [];
+  return [`<${nombre}>${escapar(String(texto4))}</${nombre}>`];
 }
-function prepararMusicXml(xml) {
-  const correcciones = [];
-  let atributosMovidos = 0;
-  let acordesSeparados = 0;
-  let saltosMovidos = 0;
-  let salida = xml.replace(/<part\b[^>]*>[\s\S]*?<\/part>/g, (parteOriginal) => {
-    const movidos = moverAtributosDeFinDeCompas(parteOriginal);
-    atributosMovidos += movidos.cuantos;
-    const separados = separarAcordesEntrePentagramas(movidos.texto);
-    acordesSeparados += separados.cuantos;
-    const saltos = sacarSaltosDeLaIndicacion(separados.texto);
-    saltosMovidos += saltos.cuantos;
-    const { texto: texto4, cambio } = compactarVoces(saltos.texto);
-    if (cambio) correcciones.push(cambio);
-    return texto4;
-  });
-  if (atributosMovidos) {
-    correcciones.push(
-      `${atributosMovidos} cambios de clave, armadura o comp\xE1s escritos entre las notas se pusieron al principio del comp\xE1s donde rigen.`
-    );
+function alturaMusicXml(midi, fifths, modo = 0) {
+  const octavaAlphaTab = Math.floor(midi / 12);
+  const clase = midi - octavaAlphaTab * 12;
+  const octava = octavaAlphaTab - 1;
+  const pedida = ALTERACION_POR_MODO[modo];
+  if (pedida !== void 0) {
+    const sinAlterar = clase - pedida;
+    const vueltas = Math.floor(sinAlterar / 12);
+    const paso = PASOS.find((p) => p.semitonos === sinAlterar - vueltas * 12);
+    if (paso) return { paso: paso.paso, alteracion: pedida, octava: octava + vueltas };
   }
-  if (acordesSeparados) {
-    correcciones.push(`${acordesSeparados} notas de acordes repartidos entre los dos pentagramas se pusieron en el suyo.`);
+  const natural = PASOS.find((p) => p.semitonos === clase);
+  if (natural) return { paso: natural.paso, alteracion: 0, octava };
+  if (fifths < 0) {
+    const arriba = PASOS.find((p) => p.semitonos === clase + 1);
+    if (arriba) return { paso: arriba.paso, alteracion: -1, octava };
   }
-  if (saltosMovidos) correcciones.push(`${saltosMovidos} saltos (D.C., D.S., Coda, Fine, Segno) se leyeron de su indicaci\xF3n.`);
-  let juntados = 0;
-  salida = salida.replace(/<direction\b[^>]*>[\s\S]*?<\/direction>/g, (dir) => {
-    const palabras = [...dir.matchAll(/<words\b[^>]*>([\s\S]*?)<\/words>/g)];
-    if (palabras.length < 2) return dir;
-    juntados++;
-    const todo = palabras.map((p) => p[1].trim()).filter(Boolean).join("\n");
-    let primero = true;
-    return dir.replace(/<words\b([^>]*)>[\s\S]*?<\/words>/g, (_m, attrs) => {
-      if (!primero) return "";
-      primero = false;
-      return `<words${attrs}>${todo}</words>`;
-    });
-  });
-  if (juntados) correcciones.push(`${juntados} indicaciones de texto en varios renglones se juntaron en una.`);
-  let silabas2 = 0;
-  salida = salida.replace(/<lyric\b[^>]*>[\s\S]*?<\/lyric>/g, (lyric) => {
-    const tipo = /<syllabic>\s*(\w+)\s*<\/syllabic>/.exec(lyric)?.[1];
-    if (tipo !== "begin" && tipo !== "middle") return lyric;
-    return lyric.replace(/(<text\b[^>]*>)([\s\S]*?)(<\/text>)/, (m, a, texto4, b) => {
-      if (texto4.trimEnd().endsWith("-")) return m;
-      silabas2++;
-      return `${a}${texto4.trimEnd()}-${b}`;
-    });
-  });
-  if (silabas2) correcciones.push(`${silabas2} s\xEDlabas unidas de la letra se marcaron con su guion.`);
-  let tempos = 0;
-  salida = salida.replace(/<metronome\b[^>]*>[\s\S]*?<\/metronome>/g, (met) => {
-    const unidad = /<beat-unit>\s*([\w-]+)\s*<\/beat-unit>/.exec(met)?.[1];
-    const porMinuto = /<per-minute>\s*([\d.]+)\s*<\/per-minute>/.exec(met)?.[1];
-    const negras = unidad ? NEGRAS_POR_FIGURA[unidad] : void 0;
-    if (!unidad || !porMinuto || negras === void 0 || /<beat-unit>[\s\S]*<beat-unit>/.test(met)) return met;
-    const puntillos = (met.match(/<beat-unit-dot\s*\/>/g) ?? []).length;
-    const factor = negras * (puntillos === 0 ? 1 : puntillos === 1 ? 1.5 : 1.75);
-    if (factor === 1) return met;
-    tempos++;
-    const bpm = Math.round(Number.parseFloat(porMinuto) * factor * 100) / 100;
-    return met.replace(/<beat-unit>[\s\S]*?<\/beat-unit>/, "<beat-unit>quarter</beat-unit>").replace(/<beat-unit-dot\s*\/>/g, "").replace(/<per-minute>[\s\S]*?<\/per-minute>/, `<per-minute>${bpm}</per-minute>`);
-  });
-  if (tempos) correcciones.push(`${tempos} indicaciones de tempo se pasaron a negras (mismo pulso).`);
-  return { xml: salida, bytes: new TextEncoder().encode(salida), correcciones };
+  const abajo = PASOS.find((p) => p.semitonos === clase - 1);
+  if (abajo) return { paso: abajo.paso, alteracion: 1, octava };
+  throw new Error(`altura MIDI no representable: ${midi}`);
 }
-function compasesDe(parte) {
-  return [...parte.matchAll(/(<measure\b[^>]*>)([\s\S]*?)<\/measure>/g)].map((m) => ({
-    inicio: m.index,
-    fin: m.index + m[0].length,
-    apertura: m[1],
-    contenido: m[2]
-  }));
+function claveDelPentagrama(staff, bar) {
+  if (staff.isPercussion) return { signo: "percussion", linea: 2, lineas: 5, conAfinacion: false };
+  if (staff.showTablature && staff.tuning.length > 0)
+    return { signo: "TAB", linea: 5, lineas: staff.tuning.length, conAfinacion: true };
+  switch (bar.clef) {
+    case _barrel_exports$4.Clef.C3:
+      return { signo: "C", linea: 3, lineas: 5, conAfinacion: false };
+    case _barrel_exports$4.Clef.C4:
+      return { signo: "C", linea: 4, lineas: 5, conAfinacion: false };
+    case _barrel_exports$4.Clef.F4:
+      return { signo: "F", linea: 4, lineas: 5, conAfinacion: false };
+    case _barrel_exports$4.Clef.Neutral:
+      return { signo: "percussion", linea: 2, lineas: 5, conAfinacion: false };
+    default:
+      return { signo: "G", linea: 2, lineas: 5, conAfinacion: false };
+  }
 }
-function rearmar(parte, compases, nuevos) {
-  let salida = "";
-  let cursor = 0;
-  compases.forEach((c, i2) => {
-    salida += parte.slice(cursor, c.inicio) + c.apertura + nuevos[i2] + "</measure>";
-    cursor = c.fin;
-  });
-  return salida + parte.slice(cursor);
+function gruposDeTresillo(beats) {
+  const abren = /* @__PURE__ */ new Set();
+  const cierran = /* @__PURE__ */ new Set();
+  let i2 = 0;
+  while (i2 < beats.length) {
+    const b = beats[i2];
+    if (b.tupletNumerator <= 0 || b.tupletDenominator <= 0) {
+      i2++;
+      continue;
+    }
+    let j = i2;
+    while (j + 1 < beats.length && beats[j + 1].tupletNumerator === b.tupletNumerator && beats[j + 1].tupletDenominator === b.tupletDenominator && (b.tupletGroup === null || beats[j + 1].tupletGroup === b.tupletGroup))
+      j++;
+    abren.add(i2);
+    cierran.add(j);
+    i2 = j + 1;
+  }
+  return { abren, cierran };
 }
-function tiempoAl(pedazo) {
-  let t = 0;
-  for (const m of pedazo.matchAll(/<(note|backup|forward)\b[\s\S]*?<\/\1>/g)) {
-    const dur = entero(m[0], /<duration>\s*(\d+)\s*<\/duration>/) ?? 0;
-    if (m[1] === "backup") t -= dur;
-    else if (m[1] === "forward") t += dur;
-    else if (!/<chord\s*\/>/.test(m[0]) && !/<grace\b/.test(m[0])) t += dur;
+function direccionDeLasPalabras(texto4) {
+  return SALTO_POR_CLAVE.get(claveDeSalto(texto4)) ?? null;
+}
+function saltosDelCompas(master) {
+  const s = [];
+  for (const [direccion, salto] of SALTOS) {
+    if (!master?.directions?.has(direccion)) continue;
+    s.push('<direction placement="above">', "<direction-type>");
+    s.push(salto.simbolo ? `<${salto.simbolo}/>` : `<words>${escapar(salto.texto ?? "")}</words>`);
+    s.push("</direction-type>", `<sound ${salto.sonido}/>`, "</direction>");
   }
-  return t;
+  return s;
 }
-function moverAtributosDeFinDeCompas(parte) {
-  const compases = compasesDe(parte);
-  let cuantos = 0;
-  let arrastre = "";
-  const nuevos = compases.map((c) => {
-    let contenido = c.contenido;
-    const primeraNota = contenido.search(/<note\b/);
-    if (primeraNota >= 0) {
-      let llevar = "";
-      let alPrincipio = "";
-      const despues = contenido.slice(primeraNota);
-      contenido = contenido.slice(0, primeraNota) + despues.replace(/<attributes\b[^>]*>([\s\S]*?)<\/attributes>/g, (bloque, adentro, donde) => {
-        const hijos = adentro.match(HIJO_QUE_SE_MUEVE);
-        if (!hijos) return bloque;
-        cuantos += hijos.length;
-        if (tiempoAl(despues.slice(0, donde)) <= 0) alPrincipio += hijos.join("");
-        else llevar += hijos.join("");
-        const resto = adentro.replace(HIJO_QUE_SE_MUEVE, "");
-        return resto.trim() ? `<attributes>${resto}</attributes>` : "";
-      });
-      const entra2 = arrastre + alPrincipio;
-      arrastre = llevar;
-      return (entra2 ? `<attributes>${entra2}</attributes>` : "") + contenido;
-    }
-    const entra = arrastre;
-    arrastre = "";
-    return (entra ? `<attributes>${entra}</attributes>` : "") + contenido;
-  });
-  return cuantos ? { texto: rearmar(parte, compases, nuevos), cuantos } : { texto: parte, cuantos: 0 };
+function nombreDeFigura(duracion) {
+  return NOMBRE_DE_LA_FIGURA2.get(duracion) ?? "quarter";
 }
-function separarAcordesEntrePentagramas(parte) {
-  const compases = compasesDe(parte);
-  let cuantos = 0;
-  const nuevos = compases.map((c) => {
-    const notas = [...c.contenido.matchAll(/<note\b[\s\S]*?<\/note>/g)];
-    if (notas.length < 2) return c.contenido;
-    let salida = "";
-    let cursor = 0;
-    let i2 = 0;
-    while (i2 < notas.length) {
-      const grupo = [notas[i2]];
-      let j = i2 + 1;
-      while (j < notas.length) {
-        const anterior = notas[j - 1];
-        const entre = c.contenido.slice(anterior.index + anterior[0].length, notas[j].index);
-        if (entre.trim() || !/<chord\s*\/>/.test(notas[j][0])) break;
-        grupo.push(notas[j]);
-        j++;
-      }
-      i2 = j;
-      const pent = (n) => entero(n[0], /<staff>\s*(\d+)\s*<\/staff>/) ?? 1;
-      const cabeza = grupo[0];
-      const pentDeCabeza = pent(cabeza);
-      const ajenas = grupo.filter((n) => pent(n) !== pentDeCabeza);
-      const durCabeza = entero(cabeza[0], /<duration>\s*(\d+)\s*<\/duration>/);
-      if (ajenas.length === 0 || /<chord\s*\/>/.test(cabeza[0]) || grupo.some((n) => /<grace\b|<cue\s*\/>/.test(n[0])) || durCabeza === null) {
-        continue;
-      }
-      cuantos += ajenas.length;
-      const propias = grupo.filter((n) => pent(n) === pentDeCabeza).map((n) => n[0]);
-      let texto4 = propias.join("");
-      const porPentagrama = /* @__PURE__ */ new Map();
-      for (const n of ajenas) porPentagrama.set(pent(n), [...porPentagrama.get(pent(n)) ?? [], n[0]]);
-      for (const notasDelPent of porPentagrama.values()) {
-        const primera = notasDelPent[0].replace(/<chord\s*\/>\s*/, "");
-        const durPrimera = entero(primera, /<duration>\s*(\d+)\s*<\/duration>/) ?? durCabeza;
-        texto4 += `<backup><duration>${durCabeza}</duration></backup>` + primera + notasDelPent.slice(1).join("");
-        const delta = durCabeza - durPrimera;
-        if (delta > 0) texto4 += `<forward><duration>${delta}</duration></forward>`;
-        else if (delta < 0) texto4 += `<backup><duration>${-delta}</duration></backup>`;
-      }
-      const ultimo = grupo[grupo.length - 1];
-      salida += c.contenido.slice(cursor, cabeza.index) + texto4;
-      cursor = ultimo.index + ultimo[0].length;
-    }
-    return salida + c.contenido.slice(cursor);
-  });
-  return cuantos ? { texto: rearmar(parte, compases, nuevos), cuantos } : { texto: parte, cuantos: 0 };
+function instrumentosDePercusion(track) {
+  const usadas = /* @__PURE__ */ new Set();
+  for (const staff of track.staves)
+    for (const bar of staff.bars)
+      for (const voice of bar.voices)
+        for (const beat of voice.beats)
+          for (const note of beat.notes)
+            if (note.percussionArticulation >= 0) usadas.add(note.percussionArticulation);
+  const ids = /* @__PURE__ */ new Map();
+  for (const art of [...usadas].sort((a, b) => a - b))
+    ids.set(art, `P${track.index + 1}-I${art + 1}`);
+  return ids;
 }
-function sacarSaltosDeLaIndicacion(parte) {
-  let cuantos = 0;
-  const texto4 = parte.replace(/<direction\b[^>]*>[\s\S]*?<\/direction>/g, (dir, desde, todo) => {
-    const sonido = /<sound\b([^>]*?)\/?>/.exec(dir)?.[1];
-    if (!sonido) return dir;
-    const atributos = ATRIBUTOS_DE_SALTO.map((a) => new RegExp(`\\b${a}="([^"]*)"`).exec(sonido)?.[0]).filter((a) => a !== void 0);
-    if (atributos.length === 0) return dir;
-    const copia = `<sound ${atributos.join(" ")}/>`;
-    if (todo.slice(desde + dir.length).trimStart().startsWith(copia)) return dir;
-    cuantos++;
-    return dir + copia;
-  });
-  return { texto: texto4, cuantos };
+function posicionDePercusion(staffLine) {
+  const indiceDeB = 6;
+  const bruto = indiceDeB + (5 - staffLine);
+  const paso = PASOS[(bruto % 7 + 7) % 7].paso;
+  return { paso, octava: 4 + Math.floor(bruto / 7) };
 }
-function compactarVoces(parte) {
-  const porPentagrama = /* @__PURE__ */ new Map();
-  const pentagramaDeVoz = /* @__PURE__ */ new Map();
-  for (const m of parte.matchAll(/<note\b[\s\S]*?<\/note>/g)) {
-    const voz = entero(m[0], /<voice>\s*(\d+)\s*<\/voice>/);
-    if (voz === null) continue;
-    const pent = entero(m[0], /<staff>\s*(\d+)\s*<\/staff>/) ?? 1;
-    const lista2 = porPentagrama.get(pent) ?? [];
-    if (!lista2.includes(voz)) lista2.push(voz);
-    porPentagrama.set(pent, lista2);
-    if (!pentagramaDeVoz.has(voz)) pentagramaDeVoz.set(voz, pent);
+function escribirNota(note, beat, staff, opciones) {
+  const s = ["<note>"];
+  const esAdorno = beat.graceType !== _barrel_exports$4.GraceType.None;
+  if (esAdorno) s.push(beat.graceType === _barrel_exports$4.GraceType.BeforeBeat ? "<grace/>" : '<grace slash="yes"/>');
+  if (opciones.esAcorde) s.push("<chord/>");
+  const esGolpeDeKit = staff.isPercussion && note.percussionArticulation >= 0;
+  if (esGolpeDeKit) {
+    const art = staff.track.percussionArticulations[note.percussionArticulation];
+    const { paso, octava } = posicionDePercusion(art?.staffLine ?? 5);
+    s.push("<unpitched>");
+    s.push(`<display-step>${paso}</display-step>`);
+    s.push(`<display-octave>${octava}</display-octave>`);
+    s.push("</unpitched>");
+  } else {
+    const { paso, alteracion, octava } = alturaMusicXml(
+      note.calculateRealValue(false, false),
+      opciones.fifths,
+      note.accidentalMode
+    );
+    s.push("<pitch>");
+    s.push(`<step>${paso}</step>`);
+    if (alteracion !== 0) s.push(`<alter>${alteracion}</alter>`);
+    s.push(`<octave>${octava}</octave>`);
+    s.push("</pitch>");
   }
-  const nueva = /* @__PURE__ */ new Map();
-  let hayCambio = false;
-  for (const [pent, voces] of porPentagrama) {
-    ;
-    [...voces].sort((a, b) => a - b).forEach((voz, i2) => {
-      nueva.set(`${pent}|${voz}`, i2 + 1);
-      if (voz !== i2 + 1) hayCambio = true;
-    });
+  if (!esAdorno) s.push(`<duration>${opciones.duracion}</duration>`);
+  if (note.isTieDestination) s.push('<tie type="stop"/>');
+  if (note.isTieOrigin) s.push('<tie type="start"/>');
+  const idDeInstrumento = opciones.instrumentos.get(note.percussionArticulation);
+  if (esGolpeDeKit && idDeInstrumento) s.push(`<instrument id="${idDeInstrumento}"/>`);
+  s.push(`<voice>${opciones.numeroDeVoz}</voice>`);
+  s.push(...elemento("type", nombreDeFigura(beat.duration)));
+  for (let d = 0; d < beat.dots; d++) s.push("<dot/>");
+  if (beat.tupletNumerator > 0 && beat.tupletDenominator > 0) {
+    s.push("<time-modification>");
+    s.push(`<actual-notes>${beat.tupletNumerator}</actual-notes>`);
+    s.push(`<normal-notes>${beat.tupletDenominator}</normal-notes>`);
+    s.push("</time-modification>");
   }
-  if (!hayCambio) return { texto: parte, cambio: null };
-  const renumerar = (bloque, pentPorOmision) => {
-    const voz = entero(bloque, /<voice>\s*(\d+)\s*<\/voice>/);
-    if (voz === null) return bloque;
-    const pent = entero(bloque, /<staff>\s*(\d+)\s*<\/staff>/) ?? pentPorOmision(voz);
-    const n = nueva.get(`${pent}|${voz}`);
-    return n === void 0 ? bloque : bloque.replace(/<voice>\s*\d+\s*<\/voice>/, `<voice>${n}</voice>`);
-  };
-  const texto4 = parte.replace(/<note\b[\s\S]*?<\/note>/g, (b) => renumerar(b, () => 1)).replace(/<forward\b[\s\S]*?<\/forward>/g, (b) => renumerar(b, (v) => pentagramaDeVoz.get(v) ?? 1));
-  const id2 = /<part\b[^>]*\bid="([^"]*)"/.exec(parte)?.[1] ?? "?";
-  const detalle = [...porPentagrama].map(([p, vs]) => `pentagrama ${p}: voces ${[...vs].sort((a, b) => a - b).join(", ")}`).join("; ");
-  return { texto: texto4, cambio: `Parte ${id2}: las voces se renumeraron por pentagrama (${detalle}).` };
+  if (note.isDead) s.push("<notehead>x</notehead>");
+  else if (esGolpeDeKit) {
+    const art = staff.track.percussionArticulations[note.percussionArticulation];
+    if (art?.noteHeadDefault === _barrel_exports$4.MusicFontSymbol.NoteheadXBlack)
+      s.push("<notehead>x</notehead>");
+  } else if (note.isGhost) s.push('<notehead parentheses="yes">normal</notehead>');
+  if (opciones.numeroDePentagrama !== null) s.push(`<staff>${opciones.numeroDePentagrama}</staff>`);
+  const notaciones = [];
+  if (note.isTieDestination) notaciones.push('<tied type="stop"/>');
+  if (note.isTieOrigin) notaciones.push('<tied type="start"/>');
+  if (opciones.abreTresillo) notaciones.push('<tuplet type="start" number="1"/>');
+  if (opciones.cierraTresillo) notaciones.push('<tuplet type="stop" number="1"/>');
+  const tecnica = [];
+  if (note.string > 0 && staff.tuning.length > 0) {
+    tecnica.push(`<string>${staff.tuning.length - note.string + 1}</string>`);
+    tecnica.push(`<fret>${note.fret}</fret>`);
+  }
+  const ligado = (desde, hasta) => hasta >= desde ? "hammer-on" : "pull-off";
+  const origen = note.hammerPullOrigin;
+  if (origen !== null) {
+    const nombre = ligado(origen.fret, note.fret);
+    tecnica.push(`<${nombre} type="stop"/>`);
+  }
+  const destino = note.hammerPullDestination;
+  if (note.isHammerPullOrigin && destino) {
+    const nombre = ligado(note.fret, destino.fret);
+    tecnica.push(`<${nombre} type="start">${nombre === "hammer-on" ? "H" : "P"}</${nombre}>`);
+  }
+  if (note.harmonicType !== _barrel_exports$4.HarmonicType.None) tecnica.push("<harmonic/>");
+  if (beat.isPalmMute) tecnica.push("<other-technical>palm-mute</other-technical>");
+  if (beat.isLetRing) tecnica.push("<other-technical>let-ring</other-technical>");
+  if (tecnica.length > 0) notaciones.push("<technical>", ...tecnica, "</technical>");
+  const articulaciones = [];
+  if (note.accentuated === _barrel_exports$4.AccentuationType.Normal) articulaciones.push("<accent/>");
+  else if (note.accentuated === _barrel_exports$4.AccentuationType.Heavy)
+    articulaciones.push("<strong-accent/>");
+  else if (note.accentuated === _barrel_exports$4.AccentuationType.Tenuto)
+    articulaciones.push("<tenuto/>");
+  if (note.isStaccato) articulaciones.push("<staccato/>");
+  if (articulaciones.length > 0)
+    notaciones.push("<articulations>", ...articulaciones, "</articulations>");
+  if (notaciones.length > 0) s.push("<notations>", ...notaciones, "</notations>");
+  if (!opciones.esAcorde) s.push(...letraDelGolpe(beat));
+  s.push("</note>");
+  return s;
 }
-function leerOrtografia(xml) {
-  return leerDelArchivo(xml).ortografia;
+function letraDelGolpe(beat) {
+  if (!beat.lyrics) return [];
+  const s = [];
+  beat.lyrics.forEach((verso, i2) => {
+    if (!verso) return;
+    const sigue = verso.endsWith("-") && verso.length > 1;
+    let anterior = beat.previousBeat;
+    while (anterior && !anterior.lyrics?.[i2]) anterior = anterior.previousBeat;
+    const viene = !!anterior?.lyrics?.[i2]?.endsWith("-");
+    const silabico = sigue ? viene ? "middle" : "begin" : viene ? "end" : "single";
+    s.push(`<lyric number="${i2 + 1}">`);
+    s.push(`<syllabic>${silabico}</syllabic>`);
+    s.push(...elemento("text", sigue ? verso.slice(0, -1) : verso));
+    s.push("</lyric>");
+  });
+  return s;
 }
-function leerDelArchivo(xml) {
-  const ortografia = /* @__PURE__ */ new Map();
-  const bajos = /* @__PURE__ */ new Map();
-  const matices = /* @__PURE__ */ new Map();
-  let iParte = -1;
-  for (const parte of xml.matchAll(/<part\b[^>]*>([\s\S]*?)<\/part>/g)) {
-    iParte++;
-    let divisiones = 1;
-    let transposicion = 0;
-    let iCompas = -1;
-    for (const compas of parte[1].matchAll(/<measure\b[^>]*>([\s\S]*?)<\/measure>/g)) {
-      iCompas++;
-      let tic = 0;
-      let ticAnterior = 0;
-      let bajoPendiente = null;
-      for (const el of compas[1].matchAll(/<(note|backup|forward|attributes|harmony|direction)\b[\s\S]*?<\/\1>/g)) {
-        const bloque = el[0];
-        const tipo = el[1];
-        if (tipo === "direction") {
-          const nombre = /<dynamics\b[^>]*>\s*<([a-z]+)\s*\/>/.exec(bloque)?.[1];
-          if (nombre) {
-            const pent2 = (entero(bloque, /<staff>\s*(\d+)\s*<\/staff>/) ?? 1) - 1;
-            const clave2 = `${iParte}|${pent2}`;
-            const lista2 = matices.get(clave2) ?? [];
-            lista2.push({ compas: iCompas, tic: Math.round(tic * TICS_POR_NEGRA2 / divisiones), nombre });
-            matices.set(clave2, lista2);
-          }
-          continue;
-        }
-        if (tipo === "attributes") {
-          divisiones = entero(bloque, /<divisions>\s*(\d+)\s*<\/divisions>/) ?? divisiones;
-          const transponer2 = /<transpose\b[^>]*>([\s\S]*?)<\/transpose>/.exec(bloque)?.[1];
-          if (transponer2 !== void 0) {
-            transposicion = (entero(transponer2, /<chromatic>\s*(-?\d+)\s*<\/chromatic>/) ?? 0) + 12 * (entero(transponer2, /<octave-change>\s*(-?\d+)\s*<\/octave-change>/) ?? 0);
-          }
-          continue;
-        }
-        if (tipo === "harmony") {
-          const bajo = /<bass>([\s\S]*?)<\/bass>/.exec(bloque)?.[1];
-          const paso2 = bajo ? /<bass-step>\s*([A-G])\s*<\/bass-step>/.exec(bajo)?.[1] : void 0;
-          if (bajoPendiente === null) {
-            const alter2 = bajo ? entero(bajo, /<bass-alter>\s*(-?\d+)\s*<\/bass-alter>/) ?? 0 : 0;
-            bajoPendiente = paso2 ? `/${paso2}${alter2 === -2 ? "bb" : alter2 === -1 ? "b" : alter2 === 1 ? "#" : alter2 === 2 ? "x" : ""}` : "";
-          }
-          continue;
-        }
-        const dur = entero(bloque, /<duration>\s*(\d+)\s*<\/duration>/) ?? 0;
-        if (tipo === "backup") {
-          tic -= dur;
-          continue;
-        }
-        if (tipo === "forward") {
-          tic += dur;
-          continue;
-        }
-        if (/<grace\b/.test(bloque) || /<cue\s*\/>/.test(bloque)) continue;
-        const acorde = /<chord\s*\/>/.test(bloque);
-        const inicio = acorde ? ticAnterior : tic;
-        if (!acorde) {
-          ticAnterior = tic;
-          tic += dur;
+function escribirSilencio2(beat, duracion, numeroDeVoz, numeroDePentagrama) {
+  const s = ["<note>", "<rest/>", `<duration>${duracion}</duration>`];
+  s.push(`<voice>${numeroDeVoz}</voice>`);
+  s.push(...elemento("type", nombreDeFigura(beat.duration)));
+  for (let d = 0; d < beat.dots; d++) s.push("<dot/>");
+  if (beat.tupletNumerator > 0 && beat.tupletDenominator > 0) {
+    s.push("<time-modification>");
+    s.push(`<actual-notes>${beat.tupletNumerator}</actual-notes>`);
+    s.push(`<normal-notes>${beat.tupletDenominator}</normal-notes>`);
+    s.push("</time-modification>");
+  }
+  if (numeroDePentagrama !== null) s.push(`<staff>${numeroDePentagrama}</staff>`);
+  s.push(...letraDelGolpe(beat));
+  s.push("</note>");
+  return s;
+}
+function exportarMusicXml(score) {
+  const l = [];
+  l.push('<?xml version="1.0" encoding="UTF-8"?>');
+  l.push('<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 4.0 Partwise//EN"');
+  l.push('                                "http://www.musicxml.org/dtds/partwise.dtd">');
+  l.push('<score-partwise version="4.0">');
+  if (score.title) l.push("<work>", ...elemento("work-title", score.title), "</work>");
+  l.push(...elemento("movement-title", score.subTitle));
+  l.push("<identification>");
+  if (score.music) l.push(`<creator type="composer">${escapar(score.music)}</creator>`);
+  else if (score.artist) l.push(`<creator type="composer">${escapar(score.artist)}</creator>`);
+  if (score.words) l.push(`<creator type="lyricist">${escapar(score.words)}</creator>`);
+  l.push(...elemento("rights", score.copyright));
+  l.push("<encoding>", "<software>Mandioca Tabs</software>", "</encoding>");
+  l.push("</identification>");
+  const instrumentosPorPista = /* @__PURE__ */ new Map();
+  l.push("<part-list>");
+  for (const track of score.tracks) {
+    const id2 = `P${track.index + 1}`;
+    l.push(`<score-part id="${id2}">`);
+    l.push(...elemento("part-name", track.name || `Pista ${track.index + 1}`));
+    l.push(...elemento("part-abbreviation", track.shortName));
+    const esPercusion = track.staves.some((st) => st.isPercussion);
+    const instrumentos = esPercusion ? instrumentosDePercusion(track) : /* @__PURE__ */ new Map();
+    instrumentosPorPista.set(track.index, instrumentos);
+    if (esPercusion) {
+      for (const [art, idInstrumento] of instrumentos) {
+        const a = track.percussionArticulations[art];
+        l.push(`<score-instrument id="${idInstrumento}">`);
+        l.push(...elemento("instrument-name", `Percusi\xF3n ${art + 1}`));
+        l.push("</score-instrument>");
+        l.push(`<midi-instrument id="${idInstrumento}">`);
+        l.push("<midi-channel>10</midi-channel>");
+        l.push(`<midi-unpitched>${(a?.outputMidiNumber ?? 36) + 1}</midi-unpitched>`);
+        l.push("</midi-instrument>");
+      }
+    } else {
+      l.push(`<score-instrument id="${id2}-I1">`);
+      l.push(...elemento("instrument-name", track.name || `Pista ${track.index + 1}`));
+      l.push("</score-instrument>");
+      l.push(`<midi-instrument id="${id2}-I1">`);
+      l.push(`<midi-channel>${track.playbackInfo.primaryChannel + 1}</midi-channel>`);
+      l.push(`<midi-program>${track.playbackInfo.program + 1}</midi-program>`);
+      l.push(`<volume>${Math.round(track.playbackInfo.volume / 16 * 100)}</volume>`);
+      l.push(`<pan>${Math.round((track.playbackInfo.balance - 8) / 8 * 90)}</pan>`);
+      l.push("</midi-instrument>");
+    }
+    l.push("</score-part>");
+  }
+  l.push("</part-list>");
+  for (const track of score.tracks) {
+    const instrumentos = instrumentosPorPista.get(track.index) ?? /* @__PURE__ */ new Map();
+    l.push(`<part id="P${track.index + 1}">`);
+    const pentagramas = track.staves;
+    if (pentagramas.length === 0) {
+      l.push("</part>");
+      continue;
+    }
+    let armaduraAnterior = null;
+    let compasAnterior = null;
+    let clavesAnteriores = null;
+    const cantidadDeCompases = Math.max(...pentagramas.map((st) => st.bars.length));
+    for (let indiceDeCompas2 = 0; indiceDeCompas2 < cantidadDeCompases; indiceDeCompas2++) {
+      const master = score.masterBars[indiceDeCompas2];
+      l.push(`<measure number="${indiceDeCompas2 + 1}">`);
+      const fifths = (pentagramas[0]?.bars[indiceDeCompas2] ?? pentagramas[0]?.bars[0])?.keySignature ?? master?.keySignature ?? 0;
+      const modo = master?.keySignatureType === _barrel_exports$4.KeySignatureType.Minor ? "minor" : "major";
+      const armadura = `${fifths}/${modo}`;
+      const numerador = master?.timeSignatureNumerator ?? 4;
+      const denominador = master?.timeSignatureDenominator ?? 4;
+      const compas = `${numerador}/${denominador}`;
+      const claves = pentagramas.map((st, k) => {
+        const bar = st.bars[indiceDeCompas2] ?? st.bars[0];
+        return { pentagrama: st, numero: k + 1, ...claveDelPentagrama(st, bar) };
+      });
+      const firmaDeClaves = claves.map((c) => `${c.signo}${c.linea}`).join(",");
+      const cambios = [];
+      if (indiceDeCompas2 === 0) cambios.push(`<divisions>${DIVISIONES_POR_NEGRA}</divisions>`);
+      if (armadura !== armaduraAnterior) {
+        cambios.push("<key>");
+        cambios.push(`<fifths>${fifths}</fifths>`);
+        cambios.push(`<mode>${modo}</mode>`);
+        cambios.push("</key>");
+        armaduraAnterior = armadura;
+      }
+      if (compas !== compasAnterior) {
+        cambios.push("<time>");
+        cambios.push(`<beats>${numerador}</beats>`);
+        cambios.push(`<beat-type>${denominador}</beat-type>`);
+        cambios.push("</time>");
+        compasAnterior = compas;
+      }
+      if (firmaDeClaves !== clavesAnteriores) {
+        if (pentagramas.length > 1 && clavesAnteriores === null)
+          cambios.push(`<staves>${pentagramas.length}</staves>`);
+        const num = (clave) => pentagramas.length > 1 ? ` number="${clave.numero}"` : "";
+        for (const clave of claves) {
+          cambios.push(`<clef${num(clave)}>`);
+          cambios.push(`<sign>${clave.signo}</sign>`);
+          cambios.push(`<line>${clave.linea}</line>`);
+          cambios.push("</clef>");
         }
-        const pent = (entero(bloque, /<staff>\s*(\d+)\s*<\/staff>/) ?? 1) - 1;
-        const ticAlphaTab = Math.round(inicio * TICS_POR_NEGRA2 / divisiones);
-        if (!acorde && bajoPendiente !== null) {
-          if (bajoPendiente) bajos.set(`${iParte}|${pent}|${iCompas}|${ticAlphaTab}`, bajoPendiente);
-          bajoPendiente = null;
+        for (const clave of claves) {
+          cambios.push(`<staff-details${num(clave)}>`);
+          cambios.push(`<staff-lines>${clave.lineas}</staff-lines>`);
+          if (clave.conAfinacion)
+            clave.pentagrama.tuning.forEach((midi, i2) => {
+              const linea = clave.pentagrama.tuning.length - i2;
+              const { paso, alteracion, octava } = alturaMusicXml(midi, fifths);
+              cambios.push(`<staff-tuning line="${linea}">`);
+              cambios.push(`<tuning-step>${paso}</tuning-step>`);
+              if (alteracion !== 0) cambios.push(`<tuning-alter>${alteracion}</tuning-alter>`);
+              cambios.push(`<tuning-octave>${octava}</tuning-octave>`);
+              cambios.push("</staff-tuning>");
+            });
+          cambios.push("</staff-details>");
         }
-        const altura = /<pitch>([\s\S]*?)<\/pitch>/.exec(bloque)?.[1];
-        if (!altura) continue;
-        const paso = /<step>\s*([A-G])\s*<\/step>/.exec(altura)?.[1];
-        const octava = entero(altura, /<octave>\s*(-?\d+)\s*<\/octave>/);
-        const alterTexto = /<alter>\s*(-?[\d.]+)\s*<\/alter>/.exec(altura)?.[1];
-        const alter = alterTexto === void 0 ? 0 : Number.parseFloat(alterTexto);
-        if (!paso || octava === null || !Number.isInteger(alter)) continue;
-        const modo = MODO_POR_ALTER.get(alter);
-        if (modo === void 0) continue;
-        const midi = (octava + 1) * 12 + SEMITONOS[paso] + alter + transposicion;
-        const clave = `${iParte}|${pent}|${iCompas}|${ticAlphaTab}|${midi}`;
-        if (!ortografia.has(clave)) ortografia.set(clave, modo);
+        clavesAnteriores = firmaDeClaves;
+      }
+      if (cambios.length > 0) l.push("<attributes>", ...cambios, "</attributes>");
+      const casilla = master?.alternateEndings ?? 0;
+      const casillaAntes = score.masterBars[indiceDeCompas2 - 1]?.alternateEndings ?? 0;
+      const casillaDespues = score.masterBars[indiceDeCompas2 + 1]?.alternateEndings ?? 0;
+      const numerosDeCasilla = [0, 1, 2, 3, 4, 5, 6, 7].filter((b) => casilla & 1 << b).map((b) => b + 1).join(", ");
+      if (master?.isRepeatStart || casilla && casilla !== casillaAntes) {
+        l.push('<barline location="left">');
+        if (master?.isRepeatStart) l.push("<bar-style>heavy-light</bar-style>");
+        if (casilla && casilla !== casillaAntes) l.push(`<ending number="${numerosDeCasilla}" type="start"/>`);
+        if (master?.isRepeatStart) l.push('<repeat direction="forward"/>');
+        l.push("</barline>");
+      }
+      if (master?.section?.text || master?.section?.marker)
+        l.push(
+          '<direction placement="above">',
+          "<direction-type>",
+          `<rehearsal>${escapar(master.section.marker || master.section.text)}</rehearsal>`,
+          "</direction-type>",
+          "</direction>"
+        );
+      l.push(...saltosDelCompas(master));
+      const ticsDelCompas = DIVISIONES_POR_NEGRA * 4 * numerador / denominador;
+      const tempos = (master?.tempoAutomations ?? []).map((a) => ({ bpm: a.value, desde: a.ratioPosition }));
+      if (indiceDeCompas2 === 0 && score.tempo && !tempos.some((t) => t.desde <= 1e-6))
+        tempos.unshift({ bpm: score.tempo, desde: 0 });
+      for (const t of tempos) {
+        const bpm = Math.round(t.bpm);
+        const offset = Math.round(t.desde * ticsDelCompas);
+        l.push(
+          '<direction placement="above">',
+          "<direction-type>",
+          "<metronome>",
+          "<beat-unit>quarter</beat-unit>",
+          `<per-minute>${bpm}</per-minute>`,
+          "</metronome>",
+          "</direction-type>",
+          ...offset > 0 ? [`<offset>${offset}</offset>`] : [],
+          `<sound tempo="${bpm}"/>`,
+          "</direction>"
+        );
+      }
+      let ultimoAvance = 0;
+      let hayAlgoEscrito = false;
+      for (const { pentagrama, numero: numero2 } of claves) {
+        const bar = pentagrama.bars[indiceDeCompas2];
+        if (!bar) continue;
+        bar.voices.forEach((voice, indiceDeVoz) => {
+          if (voice.beats.length === 0 || voice.isEmpty) return;
+          if (hayAlgoEscrito && ultimoAvance > 0)
+            l.push("<backup>", `<duration>${ultimoAvance}</duration>`, "</backup>");
+          const { abren, cierran } = gruposDeTresillo(voice.beats);
+          const numeroDePentagrama = pentagramas.length > 1 ? numero2 : null;
+          let avance = 0;
+          voice.beats.forEach((beat, i2) => {
+            const duracion = beat.displayDuration;
+            if (beat.graceType === _barrel_exports$4.GraceType.None) avance += duracion;
+            if (beat.isRest || beat.notes.length === 0) {
+              l.push(...escribirSilencio2(beat, duracion, indiceDeVoz + 1, numeroDePentagrama));
+              return;
+            }
+            beat.notes.forEach((note, k) => {
+              l.push(
+                ...escribirNota(note, beat, pentagrama, {
+                  esAcorde: k > 0,
+                  fifths,
+                  duracion,
+                  // ★ La marca de tresillo va en la PRIMERA nota del golpe: es una marca del
+                  //   golpe, no de cada cuerda que suena en él.
+                  abreTresillo: k === 0 && abren.has(i2),
+                  cierraTresillo: k === 0 && cierran.has(i2),
+                  instrumentos,
+                  numeroDeVoz: indiceDeVoz + 1,
+                  numeroDePentagrama
+                })
+              );
+            });
+          });
+          ultimoAvance = avance;
+          hayAlgoEscrito = true;
+        });
+      }
+      const cierraCasilla = casilla !== 0 && casilla !== casillaDespues;
+      if (master?.isRepeatEnd || master?.isDoubleBar || cierraCasilla) {
+        l.push('<barline location="right">');
+        if (master?.isRepeatEnd || master?.isDoubleBar)
+          l.push(`<bar-style>${master.isRepeatEnd ? "light-heavy" : "light-light"}</bar-style>`);
+        if (cierraCasilla)
+          l.push(`<ending number="${numerosDeCasilla}" type="${master?.isRepeatEnd ? "stop" : "discontinue"}"/>`);
+        if (master?.isRepeatEnd)
+          l.push(`<repeat direction="backward" times="${Math.max(2, master.repeatCount)}"/>`);
+        l.push("</barline>");
       }
+      l.push("</measure>");
     }
+    l.push("</part>");
   }
-  return { ortografia, bajos, matices };
+  l.push("</score-partwise>");
+  return sangrar(l);
 }
-var MODO_DE_ALTERACION, MODO_POR_ALTER, SEMITONOS, TICS_POR_NEGRA2, entero, HIJO_QUE_SE_MUEVE, ATRIBUTOS_DE_SALTO, NEGRAS_POR_FIGURA;
-var init_musicxmlEntrada = __esm({
-  "packages/io/src/musicxmlEntrada.ts"() {
+function sangrar(lineas) {
+  const salida = [];
+  let nivel = 0;
+  for (const linea of lineas) {
+    const cierra = linea.startsWith("</");
+    if (cierra) nivel = Math.max(0, nivel - 1);
+    salida.push("  ".repeat(nivel) + linea);
+    const abre = /^<[^/?!]/.test(linea) && !linea.endsWith("/>") && !/<\/[^>]+>$/.test(linea);
+    if (abre) nivel++;
+  }
+  return salida.join("\n") + "\n";
+}
+function exportarMusicXmlComprimido(score) {
+  const xml = exportarMusicXml(score);
+  const contenedor = `<?xml version="1.0" encoding="UTF-8"?>
+<container>
+  <rootfiles>
+    <rootfile full-path="partitura.musicxml" media-type="application/vnd.recordare.musicxml+xml"/>
+  </rootfiles>
+</container>
+`;
+  const codificador = new TextEncoder();
+  return zipSync(
+    {
+      "META-INF/container.xml": [codificador.encode(contenedor), { level: 0 }],
+      "partitura.musicxml": codificador.encode(xml)
+    },
+    // ⚠️ Fecha FIJA, no la de hoy: dos exportaciones iguales tienen que dar dos archivos
+    //    iguales byte a byte, o no hay prueba que pueda compararlos ni `diff` de git que
+    //    sirva. El porqué del valor concreto está en la constante — se tardó dos rojos en
+    //    encontrarlo, y ninguno de los dos era el que yo esperaba.
+    { mtime: FECHA_FIJA_DEL_ZIP }
+  );
+}
+var DIVISIONES_POR_NEGRA, FECHA_FIJA_DEL_ZIP, PASOS, NOMBRE_DE_LA_FIGURA2, ALTERACION_POR_MODO, D, SALTOS, claveDeSalto, SALTO_POR_CLAVE;
+var init_musicxml = __esm({
+  "packages/io/src/musicxml.ts"() {
+    init_alphaTab();
     init_esm();
-    MODO_DE_ALTERACION = {
-      porDefecto: 0,
-      natural: 2,
-      sostenido: 3,
-      dobleSostenido: 4,
-      bemol: 5,
-      dobleBemol: 6
-    };
-    MODO_POR_ALTER = /* @__PURE__ */ new Map([
-      [-2, MODO_DE_ALTERACION.dobleBemol],
-      [-1, MODO_DE_ALTERACION.bemol],
-      [0, MODO_DE_ALTERACION.natural],
-      [1, MODO_DE_ALTERACION.sostenido],
-      [2, MODO_DE_ALTERACION.dobleSostenido]
+    DIVISIONES_POR_NEGRA = 960;
+    FECHA_FIJA_DEL_ZIP = 946728e6;
+    PASOS = [
+      { paso: "C", semitonos: 0 },
+      { paso: "D", semitonos: 2 },
+      { paso: "E", semitonos: 4 },
+      { paso: "F", semitonos: 5 },
+      { paso: "G", semitonos: 7 },
+      { paso: "A", semitonos: 9 },
+      { paso: "B", semitonos: 11 }
+    ];
+    NOMBRE_DE_LA_FIGURA2 = /* @__PURE__ */ new Map([
+      [-4, "long"],
+      [-2, "breve"],
+      [1, "whole"],
+      [2, "half"],
+      [4, "quarter"],
+      [8, "eighth"],
+      [16, "16th"],
+      [32, "32nd"],
+      [64, "64th"],
+      [128, "128th"],
+      [256, "256th"]
     ]);
-    SEMITONOS = { C: 0, D: 2, E: 4, F: 5, G: 7, A: 9, B: 11 };
-    TICS_POR_NEGRA2 = 960;
-    entero = (texto4, re) => {
-      const m = re.exec(texto4);
-      return m ? Number.parseInt(m[1], 10) : null;
-    };
-    HIJO_QUE_SE_MUEVE = /<(clef|key|time|transpose|staff-details)\b[^>]*?(?:\/>|>[\s\S]*?<\/\1>)/g;
-    ATRIBUTOS_DE_SALTO = ["coda", "tocoda", "dacapo", "dalsegno", "fine", "segno"];
-    NEGRAS_POR_FIGURA = {
-      breve: 8,
-      whole: 4,
-      half: 2,
-      quarter: 1,
-      eighth: 0.5,
-      "16th": 0.25,
-      "32nd": 0.125
-    };
+    ALTERACION_POR_MODO = { 2: 0, 3: 1, 4: 2, 5: -1, 6: -2 };
+    D = _barrel_exports$4.Direction;
+    SALTOS = [
+      [D.TargetSegno, { simbolo: "segno", sonido: 'segno="segno"' }],
+      [D.TargetSegnoSegno, { simbolo: "segno", sonido: 'segno="segno2"' }],
+      [D.TargetCoda, { simbolo: "coda", sonido: 'coda="coda"' }],
+      [D.TargetDoubleCoda, { simbolo: "coda", sonido: 'coda="coda2"' }],
+      [D.TargetFine, { texto: "Fine", sonido: 'fine="yes"' }],
+      [D.JumpDaCapo, { texto: "D.C.", sonido: 'dacapo="yes"' }],
+      [D.JumpDaCapoAlCoda, { texto: "D.C. al Coda", sonido: 'dacapo="yes"' }],
+      [D.JumpDaCapoAlDoubleCoda, { texto: "D.C. al Coda 2", sonido: 'dacapo="yes"' }],
+      [D.JumpDaCapoAlFine, { texto: "D.C. al Fine", sonido: 'dacapo="yes"' }],
+      [D.JumpDalSegno, { texto: "D.S.", sonido: 'dalsegno="segno"' }],
+      [D.JumpDalSegnoAlCoda, { texto: "D.S. al Coda", sonido: 'dalsegno="segno"' }],
+      [D.JumpDalSegnoAlDoubleCoda, { texto: "D.S. al Coda 2", sonido: 'dalsegno="segno"' }],
+      [D.JumpDalSegnoAlFine, { texto: "D.S. al Fine", sonido: 'dalsegno="segno"' }],
+      [D.JumpDalSegnoSegno, { texto: "D.S.S.", sonido: 'dalsegno="segno2"' }],
+      [D.JumpDalSegnoSegnoAlCoda, { texto: "D.S.S. al Coda", sonido: 'dalsegno="segno2"' }],
+      [D.JumpDalSegnoSegnoAlDoubleCoda, { texto: "D.S.S. al Coda 2", sonido: 'dalsegno="segno2"' }],
+      [D.JumpDalSegnoSegnoAlFine, { texto: "D.S.S. al Fine", sonido: 'dalsegno="segno2"' }],
+      [D.JumpDaCoda, { texto: "To Coda", sonido: 'tocoda="coda"' }],
+      [D.JumpDaDoubleCoda, { texto: "To Coda 2", sonido: 'tocoda="coda2"' }]
+    ];
+    claveDeSalto = (texto4) => texto4.toLowerCase().replace(/double\s*coda/g, "coda 2").replace(/dal\s*segno\s*segno/g, "dss").replace(/dal\s*segno/g, "ds").replace(/da\s*capo/g, "dc").replace(/[^a-z0-9]/g, "");
+    SALTO_POR_CLAVE = new Map(
+      SALTOS.filter(([, s]) => s.texto).map(([d, s]) => [
+        claveDeSalto(s.texto),
+        _barrel_exports$4.Direction[d]
+      ])
+    );
   }
 });
 
-// packages/io/src/importarGp.ts
-function piezaDeBateria(pista, numero2) {
-  if (numero2 < 0) return null;
-  const delArchivo = pista.percussionArticulations ?? [];
-  const midi = numero2 < delArchivo.length ? delArchivo[numero2].outputMidiNumber : SALIDA_DE_ID_GP[numero2] ?? numero2;
-  const buscada = PARIENTE_GM[midi] ?? midi;
-  return KIT.find((p) => p.midi === buscada)?.indice ?? null;
-}
-function importarGp(bytes, opciones = {}) {
-  const xml = textoMusicXml(bytes);
-  if (xml === null) {
-    const score2 = _barrel_exports$1.ScoreLoader.loadScoreFromBytes(bytes);
-    return importarScore(score2, opciones);
+// packages/io/src/musicxmlEntrada.ts
+function textoMusicXml(bytes) {
+  if (bytes.length > 4 && bytes[0] === 80 && bytes[1] === 75) {
+    let archivos;
+    try {
+      archivos = unzipSync(bytes);
+    } catch {
+      return null;
+    }
+    const contenedor = archivos["META-INF/container.xml"];
+    if (!contenedor) return null;
+    const ruta = /<rootfile\b[^>]*full-path="([^"]+)"/.exec(strFromU8(contenedor))?.[1];
+    const raiz = ruta ? archivos[ruta] : void 0;
+    return raiz ? decodificar(raiz) : null;
   }
-  const preparado = prepararMusicXml(xml);
-  const score = _barrel_exports$1.ScoreLoader.loadScoreFromBytes(preparado.bytes);
-  const leido = leerDelArchivo(preparado.xml);
-  const resultado = importarScore(score, opciones, { ortografia: leido.ortografia, bajos: leido.bajos, matices: leido.matices });
-  resultado.avisos.push(...preparado.correcciones);
-  return resultado;
+  const texto4 = decodificar(bytes.subarray(0, Math.min(bytes.length, 4096)));
+  if (!/<score-(partwise|timewise)\b/.test(texto4) && !/<!DOCTYPE\s+score-/.test(texto4)) return null;
+  return decodificar(bytes);
 }
-function prepararParaAlphaTab(bytes) {
-  const xml = textoMusicXml(bytes);
-  return xml === null ? bytes : prepararMusicXml(xml).bytes;
+function decodificar(bytes) {
+  if (bytes[0] === 255 && bytes[1] === 254) return new TextDecoder("utf-16le").decode(bytes);
+  if (bytes[0] === 254 && bytes[1] === 255) return new TextDecoder("utf-16be").decode(bytes);
+  return new TextDecoder("utf-8").decode(bytes);
 }
-function importarScore(score, opciones = {}, datos = {}) {
-  const avisos = [];
-  const documento = crearDocumento({ clienteId: opciones.clienteId });
-  documento.ponerCabecera({
-    titulo: score.title ?? "",
-    artista: score.artist ?? "",
-    album: score.album ?? "",
-    tempo: score.tempo ?? 0,
-    mostrarMatices: !score.stylesheet.hideDynamics
+function prepararMusicXml(xml) {
+  const correcciones = [];
+  let atributosMovidos = 0;
+  let acordesSeparados = 0;
+  let saltosMovidos = 0;
+  let salida = xml.replace(/<part\b[^>]*>[\s\S]*?<\/part>/g, (parteOriginal) => {
+    const movidos = moverAtributosDeFinDeCompas(parteOriginal);
+    atributosMovidos += movidos.cuantos;
+    const separados = separarAcordesEntrePentagramas(movidos.texto);
+    acordesSeparados += separados.cuantos;
+    const saltos = sacarSaltosDeLaIndicacion(separados.texto);
+    saltosMovidos += saltos.cuantos;
+    const { texto: texto4, cambio } = compactarVoces(saltos.texto);
+    if (cambio) correcciones.push(cambio);
+    return texto4;
   });
-  avisos.push(
-    'Las preferencias de dibujo del archivo (el "stylesheet" de Guitar Pro) no se importan, salvo si se muestran los matices. La m\xFAsica no cambia; el aspecto s\xED.'
-  );
-  if (opciones.autoria) {
-    documento.ponerAutoria(opciones.autoria);
-  } else {
-    documento.ponerAutoria({
-      escritaPor: "",
-      origen: "transcripcion",
-      obraTitulo: score.title ?? "",
-      obraAutores: score.artist ?? "",
-      obraEditora: ""
-    });
-    avisos.push(
-      "La autor\xEDa qued\xF3 sin completar: se import\xF3 como transcripci\xF3n con los datos del archivo. Hay que confirmarla antes de publicar o compartir el documento."
+  if (atributosMovidos) {
+    correcciones.push(
+      `${atributosMovidos} cambios de clave, armadura o comp\xE1s escritos entre las notas se pusieron al principio del comp\xE1s donde rigen.`
     );
   }
-  const saltosEscritos = saltosDelTexto(score);
-  const idsDeCompasMaestro = score.masterBars.map(
-    (maestro) => documento.agregarCompasMaestro(normalizarCompasMaestro({
-      numerador: maestro.timeSignatureNumerator,
-      denominador: maestro.timeSignatureDenominator,
-      tonalidad: numeroDeTonalidad(tonalidadDeConcierto(score, maestro.index)),
-      // ⚠️ El ensayo de un MusicXML (`<rehearsal>A</rehearsal>`) llena sólo `section.marker`;
-      //    `text` queda vacío y las letras A, B, C… se perdían todas. Un `.gp` trae las dos y
-      //    manda el texto, como siempre.
-      seccion: maestro.section?.text || maestro.section?.marker || "",
-      // El cambio de tempo que arranca EN este compás. Los que caen a mitad van a su figura
-      // (ver `temposAMitad` abajo).
-      // ⛔ (2026-11-10) Antes era `tempoAutomations[0]` sin mirar dónde caía: un 140 a mitad
-      //    del compás 2 se aplicaba desde su principio y la primera mitad sonaba a 140.
-      tempo: maestro.tempoAutomations?.find((a) => a.ratioPosition <= 1e-6)?.value ?? null,
-      repiteDesdeAca: maestro.isRepeatStart,
-      repiteVeces: maestro.repeatCount,
-      // ⚠️ Novena pérdida silenciosa de la misma familia: 2 de los 15 `.gp` de Daniel
-      // declaran una anacruza y el modelo la descartaba.
-      esAnacruza: maestro.isAnacrusis,
-      // ── Los signos de compás de Guitar Pro ────────────────────────────────
-      casillas: maestro.alternateEndings,
-      dobleBarra: maestro.isDoubleBar,
-      tiempoLibre: maestro.isFreeTime,
-      swing: maestro.tripletFeel,
-      // ⚠️ `simileMark` es del compás DE LA PISTA en alphaTab (`Bar.simileMark`), no del
-      //    maestro. Se lee más abajo, al recorrer los compases de cada pentagrama, y se
-      //    escribe acá arriba porque en el modelo la repetición de compás es de la obra:
-      //    un «igual que el anterior» que valiera para la guitarra y no para el bajo
-      //    dejaría los dos instrumentos diciendo cosas distintas sobre el mismo compás.
-      repiteAnterior: 0,
-      // ⚠️ `directions` es un `Set` o `null`, no una lista. Un `?? []` sobre un Set daría
-      //    el Set, y `.map` no existe ahí: hay que expandirlo.
-      //
-      // ⚠️⚠️ Y se guarda el NOMBRE, no el número. `String(d)` daba `"1"` —el valor del enum
-      //    convertido a texto— y la proyección buscaba `Direction["1"]`, que en un enum con
-      //    mapeo inverso devuelve el *nombre* y no un número: la guarda lo descartaba y **las
-      //    direcciones se perdían enteras, en silencio**. Lo cazó la prueba de ida y vuelta
-      //    con signos, que es exactamente para lo que existe.
-      //
-      // ★ El nombre y no el número, además, porque acá es una LISTA y se lee: un
-      //   `["JumpDalSegnoAlCoda"]` en el documento dice algo; un `[10]` no.
-      direcciones: maestro.directions ? [...saltosEscritos.precisos.get(maestro.index) ?? maestro.directions].map(
-        (d) => _barrel_exports$4.Direction[d] ?? String(d)
-      ) : []
-    }))
-  );
-  const saltos = /* @__PURE__ */ new Set();
-  for (const pista of score.tracks) for (const i2 of pista.lineBreaks ?? []) saltos.add(i2);
-  for (const i2 of saltos) {
-    const id2 = idsDeCompasMaestro[i2];
-    if (id2 !== void 0 && i2 > 0) documento.ponerSaltoDeRenglon(id2, true);
+  if (acordesSeparados) {
+    correcciones.push(`${acordesSeparados} notas de acordes repartidos entre los dos pentagramas se pusieron en el suyo.`);
   }
-  const letrasDobles = { cuantas: 0, versosDeMas: 0 };
-  const tipoDelPentagrama = (p) => p.isPercussion ? "percusion" : p.tuning.length === 0 ? "altura" : "trastes";
+  if (saltosMovidos) correcciones.push(`${saltosMovidos} saltos (D.C., D.S., Coda, Fine, Segno) se leyeron de su indicaci\xF3n.`);
+  let juntados = 0;
+  salida = salida.replace(/<direction\b[^>]*>[\s\S]*?<\/direction>/g, (dir) => {
+    const palabras = [...dir.matchAll(/<words\b[^>]*>([\s\S]*?)<\/words>/g)];
+    if (palabras.length < 2) return dir;
+    juntados++;
+    const todo = palabras.map((p) => p[1].trim()).filter(Boolean).join("\n");
+    let primero = true;
+    return dir.replace(/<words\b([^>]*)>[\s\S]*?<\/words>/g, (_m, attrs) => {
+      if (!primero) return "";
+      primero = false;
+      return `<words${attrs}>${todo}</words>`;
+    });
+  });
+  if (juntados) correcciones.push(`${juntados} indicaciones de texto en varios renglones se juntaron en una.`);
+  let silabas2 = 0;
+  salida = salida.replace(/<lyric\b[^>]*>[\s\S]*?<\/lyric>/g, (lyric) => {
+    const tipo = /<syllabic>\s*(\w+)\s*<\/syllabic>/.exec(lyric)?.[1];
+    if (tipo !== "begin" && tipo !== "middle") return lyric;
+    return lyric.replace(/(<text\b[^>]*>)([\s\S]*?)(<\/text>)/, (m, a, texto4, b) => {
+      if (texto4.trimEnd().endsWith("-")) return m;
+      silabas2++;
+      return `${a}${texto4.trimEnd()}-${b}`;
+    });
+  });
+  if (silabas2) correcciones.push(`${silabas2} s\xEDlabas unidas de la letra se marcaron con su guion.`);
+  let tempos = 0;
+  salida = salida.replace(/<metronome\b[^>]*>[\s\S]*?<\/metronome>/g, (met) => {
+    const unidad = /<beat-unit>\s*([\w-]+)\s*<\/beat-unit>/.exec(met)?.[1];
+    const porMinuto = /<per-minute>\s*([\d.]+)\s*<\/per-minute>/.exec(met)?.[1];
+    const negras = unidad ? NEGRAS_POR_FIGURA[unidad] : void 0;
+    if (!unidad || !porMinuto || negras === void 0 || /<beat-unit>[\s\S]*<beat-unit>/.test(met)) return met;
+    const puntillos = (met.match(/<beat-unit-dot\s*\/>/g) ?? []).length;
+    const factor = negras * (puntillos === 0 ? 1 : puntillos === 1 ? 1.5 : 1.75);
+    if (factor === 1) return met;
+    tempos++;
+    const bpm = Math.round(Number.parseFloat(porMinuto) * factor * 100) / 100;
+    return met.replace(/<beat-unit>[\s\S]*?<\/beat-unit>/, "<beat-unit>quarter</beat-unit>").replace(/<beat-unit-dot\s*\/>/g, "").replace(/<per-minute>[\s\S]*?<\/per-minute>/, `<per-minute>${bpm}</per-minute>`);
+  });
+  if (tempos) correcciones.push(`${tempos} indicaciones de tempo se pasaron a negras (mismo pulso).`);
+  return { xml: salida, bytes: new TextEncoder().encode(salida), correcciones };
+}
+function compasesDe(parte) {
+  return [...parte.matchAll(/(<measure\b[^>]*>)([\s\S]*?)<\/measure>/g)].map((m) => ({
+    inicio: m.index,
+    fin: m.index + m[0].length,
+    apertura: m[1],
+    contenido: m[2]
+  }));
+}
+function rearmar(parte, compases, nuevos) {
+  let salida = "";
+  let cursor = 0;
+  compases.forEach((c, i2) => {
+    salida += parte.slice(cursor, c.inicio) + c.apertura + nuevos[i2] + "</measure>";
+    cursor = c.fin;
+  });
+  return salida + parte.slice(cursor);
+}
+function tiempoAl(pedazo) {
+  let t = 0;
+  for (const m of pedazo.matchAll(/<(note|backup|forward)\b[\s\S]*?<\/\1>/g)) {
+    const dur = entero(m[0], /<duration>\s*(\d+)\s*<\/duration>/) ?? 0;
+    if (m[1] === "backup") t -= dur;
+    else if (m[1] === "forward") t += dur;
+    else if (!/<chord\s*\/>/.test(m[0]) && !/<grace\b/.test(m[0])) t += dur;
+  }
+  return t;
+}
+function moverAtributosDeFinDeCompas(parte) {
+  const compases = compasesDe(parte);
+  let cuantos = 0;
+  let arrastre = "";
+  const nuevos = compases.map((c) => {
+    let contenido = c.contenido;
+    const primeraNota = contenido.search(/<note\b/);
+    if (primeraNota >= 0) {
+      let llevar = "";
+      let alPrincipio = "";
+      const despues = contenido.slice(primeraNota);
+      contenido = contenido.slice(0, primeraNota) + despues.replace(/<attributes\b[^>]*>([\s\S]*?)<\/attributes>/g, (bloque, adentro, donde) => {
+        const hijos = adentro.match(HIJO_QUE_SE_MUEVE);
+        if (!hijos) return bloque;
+        cuantos += hijos.length;
+        if (tiempoAl(despues.slice(0, donde)) <= 0) alPrincipio += hijos.join("");
+        else llevar += hijos.join("");
+        const resto = adentro.replace(HIJO_QUE_SE_MUEVE, "");
+        return resto.trim() ? `<attributes>${resto}</attributes>` : "";
+      });
+      const entra2 = arrastre + alPrincipio;
+      arrastre = llevar;
+      return (entra2 ? `<attributes>${entra2}</attributes>` : "") + contenido;
+    }
+    const entra = arrastre;
+    arrastre = "";
+    return (entra ? `<attributes>${entra}</attributes>` : "") + contenido;
+  });
+  return cuantos ? { texto: rearmar(parte, compases, nuevos), cuantos } : { texto: parte, cuantos: 0 };
+}
+function separarAcordesEntrePentagramas(parte) {
+  const compases = compasesDe(parte);
+  let cuantos = 0;
+  const nuevos = compases.map((c) => {
+    const notas = [...c.contenido.matchAll(/<note\b[\s\S]*?<\/note>/g)];
+    if (notas.length < 2) return c.contenido;
+    let salida = "";
+    let cursor = 0;
+    let i2 = 0;
+    while (i2 < notas.length) {
+      const grupo = [notas[i2]];
+      let j = i2 + 1;
+      while (j < notas.length) {
+        const anterior = notas[j - 1];
+        const entre = c.contenido.slice(anterior.index + anterior[0].length, notas[j].index);
+        if (entre.trim() || !/<chord\s*\/>/.test(notas[j][0])) break;
+        grupo.push(notas[j]);
+        j++;
+      }
+      i2 = j;
+      const pent = (n) => entero(n[0], /<staff>\s*(\d+)\s*<\/staff>/) ?? 1;
+      const cabeza = grupo[0];
+      const pentDeCabeza = pent(cabeza);
+      const ajenas = grupo.filter((n) => pent(n) !== pentDeCabeza);
+      const durCabeza = entero(cabeza[0], /<duration>\s*(\d+)\s*<\/duration>/);
+      if (ajenas.length === 0 || /<chord\s*\/>/.test(cabeza[0]) || grupo.some((n) => /<grace\b|<cue\s*\/>/.test(n[0])) || durCabeza === null) {
+        continue;
+      }
+      cuantos += ajenas.length;
+      const propias = grupo.filter((n) => pent(n) === pentDeCabeza).map((n) => n[0]);
+      let texto4 = propias.join("");
+      const porPentagrama = /* @__PURE__ */ new Map();
+      for (const n of ajenas) porPentagrama.set(pent(n), [...porPentagrama.get(pent(n)) ?? [], n[0]]);
+      for (const notasDelPent of porPentagrama.values()) {
+        const primera = notasDelPent[0].replace(/<chord\s*\/>\s*/, "");
+        const durPrimera = entero(primera, /<duration>\s*(\d+)\s*<\/duration>/) ?? durCabeza;
+        texto4 += `<backup><duration>${durCabeza}</duration></backup>` + primera + notasDelPent.slice(1).join("");
+        const delta = durCabeza - durPrimera;
+        if (delta > 0) texto4 += `<forward><duration>${delta}</duration></forward>`;
+        else if (delta < 0) texto4 += `<backup><duration>${-delta}</duration></backup>`;
+      }
+      const ultimo = grupo[grupo.length - 1];
+      salida += c.contenido.slice(cursor, cabeza.index) + texto4;
+      cursor = ultimo.index + ultimo[0].length;
+    }
+    return salida + c.contenido.slice(cursor);
+  });
+  return cuantos ? { texto: rearmar(parte, compases, nuevos), cuantos } : { texto: parte, cuantos: 0 };
+}
+function sacarSaltosDeLaIndicacion(parte) {
+  let cuantos = 0;
+  const texto4 = parte.replace(/<direction\b[^>]*>[\s\S]*?<\/direction>/g, (dir, desde, todo) => {
+    const sonido = /<sound\b([^>]*?)\/?>/.exec(dir)?.[1];
+    if (!sonido) return dir;
+    const atributos = ATRIBUTOS_DE_SALTO.map((a) => new RegExp(`\\b${a}="([^"]*)"`).exec(sonido)?.[0]).filter((a) => a !== void 0);
+    if (atributos.length === 0) return dir;
+    const copia = `<sound ${atributos.join(" ")}/>`;
+    if (todo.slice(desde + dir.length).trimStart().startsWith(copia)) return dir;
+    cuantos++;
+    return dir + copia;
+  });
+  return { texto: texto4, cuantos };
+}
+function compactarVoces(parte) {
+  const porPentagrama = /* @__PURE__ */ new Map();
+  const pentagramaDeVoz = /* @__PURE__ */ new Map();
+  for (const m of parte.matchAll(/<note\b[\s\S]*?<\/note>/g)) {
+    const voz = entero(m[0], /<voice>\s*(\d+)\s*<\/voice>/);
+    if (voz === null) continue;
+    const pent = entero(m[0], /<staff>\s*(\d+)\s*<\/staff>/) ?? 1;
+    const lista2 = porPentagrama.get(pent) ?? [];
+    if (!lista2.includes(voz)) lista2.push(voz);
+    porPentagrama.set(pent, lista2);
+    if (!pentagramaDeVoz.has(voz)) pentagramaDeVoz.set(voz, pent);
+  }
+  const nueva = /* @__PURE__ */ new Map();
+  let hayCambio = false;
+  for (const [pent, voces] of porPentagrama) {
+    ;
+    [...voces].sort((a, b) => a - b).forEach((voz, i2) => {
+      nueva.set(`${pent}|${voz}`, i2 + 1);
+      if (voz !== i2 + 1) hayCambio = true;
+    });
+  }
+  if (!hayCambio) return { texto: parte, cambio: null };
+  const renumerar = (bloque, pentPorOmision) => {
+    const voz = entero(bloque, /<voice>\s*(\d+)\s*<\/voice>/);
+    if (voz === null) return bloque;
+    const pent = entero(bloque, /<staff>\s*(\d+)\s*<\/staff>/) ?? pentPorOmision(voz);
+    const n = nueva.get(`${pent}|${voz}`);
+    return n === void 0 ? bloque : bloque.replace(/<voice>\s*\d+\s*<\/voice>/, `<voice>${n}</voice>`);
+  };
+  const texto4 = parte.replace(/<note\b[\s\S]*?<\/note>/g, (b) => renumerar(b, () => 1)).replace(/<forward\b[\s\S]*?<\/forward>/g, (b) => renumerar(b, (v) => pentagramaDeVoz.get(v) ?? 1));
+  const id2 = /<part\b[^>]*\bid="([^"]*)"/.exec(parte)?.[1] ?? "?";
+  const detalle = [...porPentagrama].map(([p, vs]) => `pentagrama ${p}: voces ${[...vs].sort((a, b) => a - b).join(", ")}`).join("; ");
+  return { texto: texto4, cambio: `Parte ${id2}: las voces se renumeraron por pentagrama (${detalle}).` };
+}
+function leerOrtografia(xml) {
+  return leerDelArchivo(xml).ortografia;
+}
+function direccionesDeLaIndicacion(bloque) {
+  const sonido = /<sound\b([^>]*?)\/?>/.exec(bloque)?.[1] ?? "";
+  const atributo = (n) => new RegExp(`(?:^|\\s)${n}="([^"]*)"`).exec(sonido)?.[1];
+  const palabras = [...bloque.matchAll(/<words\b[^>]*>([\s\S]*?)<\/words>/g)].map((m) => m[1]).join(" ").trim();
+  const dicho = palabras ? direccionDeLasPalabras(palabras) : null;
+  const salida = /* @__PURE__ */ new Set();
+  const segno = atributo("segno");
+  if (/<segno\b/.test(bloque) || segno !== void 0) salida.add(segno === "segno2" ? "TargetSegnoSegno" : "TargetSegno");
+  const coda = atributo("coda");
+  if (/<coda\b/.test(bloque) || coda !== void 0) salida.add(coda === "coda2" ? "TargetDoubleCoda" : "TargetCoda");
+  if (atributo("fine") !== void 0) salida.add("TargetFine");
+  const tocoda = atributo("tocoda");
+  if (tocoda !== void 0) salida.add(tocoda === "coda2" ? "JumpDaDoubleCoda" : "JumpDaCoda");
+  if (atributo("dacapo") !== void 0) salida.add(dicho?.startsWith("JumpDaCapo") ? dicho : "JumpDaCapo");
+  const dalsegno = atributo("dalsegno");
+  if (dalsegno !== void 0) {
+    const familia = dalsegno === "segno2" ? "JumpDalSegnoSegno" : "JumpDalSegno";
+    const delaFamilia = dicho !== null && dicho.startsWith(familia) && (familia === "JumpDalSegnoSegno" || !dicho.startsWith("JumpDalSegnoSegno"));
+    salida.add(delaFamilia ? dicho : familia);
+  }
+  return [...salida];
+}
+function leerDelArchivo(xml) {
+  const ortografia = /* @__PURE__ */ new Map();
+  const bajos = /* @__PURE__ */ new Map();
+  const matices = /* @__PURE__ */ new Map();
+  const saltos = /* @__PURE__ */ new Map();
+  let iParte = -1;
+  for (const parte of xml.matchAll(/<part\b[^>]*>([\s\S]*?)<\/part>/g)) {
+    iParte++;
+    let divisiones = 1;
+    let transposicion = 0;
+    let iCompas = -1;
+    for (const compas of parte[1].matchAll(/<measure\b[^>]*>([\s\S]*?)<\/measure>/g)) {
+      iCompas++;
+      let tic = 0;
+      let ticAnterior = 0;
+      let bajoPendiente = null;
+      for (const el of compas[1].matchAll(/<(note|backup|forward|attributes|harmony|direction)\b[\s\S]*?<\/\1>/g)) {
+        const bloque = el[0];
+        const tipo = el[1];
+        if (tipo === "direction") {
+          if (iParte === 0) {
+            const aca = direccionesDeLaIndicacion(bloque);
+            if (aca.length > 0) saltos.set(iCompas, [.../* @__PURE__ */ new Set([...saltos.get(iCompas) ?? [], ...aca])]);
+          }
+          const nombre = /<dynamics\b[^>]*>\s*<([a-z]+)\s*\/>/.exec(bloque)?.[1];
+          if (nombre) {
+            const pent2 = (entero(bloque, /<staff>\s*(\d+)\s*<\/staff>/) ?? 1) - 1;
+            const clave2 = `${iParte}|${pent2}`;
+            const lista2 = matices.get(clave2) ?? [];
+            lista2.push({ compas: iCompas, tic: Math.round(tic * TICS_POR_NEGRA2 / divisiones), nombre });
+            matices.set(clave2, lista2);
+          }
+          continue;
+        }
+        if (tipo === "attributes") {
+          divisiones = entero(bloque, /<divisions>\s*(\d+)\s*<\/divisions>/) ?? divisiones;
+          const transponer2 = /<transpose\b[^>]*>([\s\S]*?)<\/transpose>/.exec(bloque)?.[1];
+          if (transponer2 !== void 0) {
+            transposicion = (entero(transponer2, /<chromatic>\s*(-?\d+)\s*<\/chromatic>/) ?? 0) + 12 * (entero(transponer2, /<octave-change>\s*(-?\d+)\s*<\/octave-change>/) ?? 0);
+          }
+          continue;
+        }
+        if (tipo === "harmony") {
+          const bajo = /<bass>([\s\S]*?)<\/bass>/.exec(bloque)?.[1];
+          const paso2 = bajo ? /<bass-step>\s*([A-G])\s*<\/bass-step>/.exec(bajo)?.[1] : void 0;
+          if (bajoPendiente === null) {
+            const alter2 = bajo ? entero(bajo, /<bass-alter>\s*(-?\d+)\s*<\/bass-alter>/) ?? 0 : 0;
+            bajoPendiente = paso2 ? `/${paso2}${alter2 === -2 ? "bb" : alter2 === -1 ? "b" : alter2 === 1 ? "#" : alter2 === 2 ? "x" : ""}` : "";
+          }
+          continue;
+        }
+        const dur = entero(bloque, /<duration>\s*(\d+)\s*<\/duration>/) ?? 0;
+        if (tipo === "backup") {
+          tic -= dur;
+          continue;
+        }
+        if (tipo === "forward") {
+          tic += dur;
+          continue;
+        }
+        if (/<grace\b/.test(bloque) || /<cue\s*\/>/.test(bloque)) continue;
+        const acorde = /<chord\s*\/>/.test(bloque);
+        const inicio = acorde ? ticAnterior : tic;
+        if (!acorde) {
+          ticAnterior = tic;
+          tic += dur;
+        }
+        const pent = (entero(bloque, /<staff>\s*(\d+)\s*<\/staff>/) ?? 1) - 1;
+        const ticAlphaTab = Math.round(inicio * TICS_POR_NEGRA2 / divisiones);
+        if (!acorde && bajoPendiente !== null) {
+          if (bajoPendiente) bajos.set(`${iParte}|${pent}|${iCompas}|${ticAlphaTab}`, bajoPendiente);
+          bajoPendiente = null;
+        }
+        const altura = /<pitch>([\s\S]*?)<\/pitch>/.exec(bloque)?.[1];
+        if (!altura) continue;
+        const paso = /<step>\s*([A-G])\s*<\/step>/.exec(altura)?.[1];
+        const octava = entero(altura, /<octave>\s*(-?\d+)\s*<\/octave>/);
+        const alterTexto = /<alter>\s*(-?[\d.]+)\s*<\/alter>/.exec(altura)?.[1];
+        const alter = alterTexto === void 0 ? 0 : Number.parseFloat(alterTexto);
+        if (!paso || octava === null || !Number.isInteger(alter)) continue;
+        const modo = MODO_POR_ALTER.get(alter);
+        if (modo === void 0) continue;
+        const midi = (octava + 1) * 12 + SEMITONOS[paso] + alter + transposicion;
+        const clave = `${iParte}|${pent}|${iCompas}|${ticAlphaTab}|${midi}`;
+        if (!ortografia.has(clave)) ortografia.set(clave, modo);
+      }
+    }
+  }
+  return { ortografia, bajos, matices, saltos };
+}
+var MODO_DE_ALTERACION, MODO_POR_ALTER, SEMITONOS, TICS_POR_NEGRA2, entero, HIJO_QUE_SE_MUEVE, ATRIBUTOS_DE_SALTO, NEGRAS_POR_FIGURA;
+var init_musicxmlEntrada = __esm({
+  "packages/io/src/musicxmlEntrada.ts"() {
+    init_esm();
+    init_musicxml();
+    MODO_DE_ALTERACION = {
+      porDefecto: 0,
+      natural: 2,
+      sostenido: 3,
+      dobleSostenido: 4,
+      bemol: 5,
+      dobleBemol: 6
+    };
+    MODO_POR_ALTER = /* @__PURE__ */ new Map([
+      [-2, MODO_DE_ALTERACION.dobleBemol],
+      [-1, MODO_DE_ALTERACION.bemol],
+      [0, MODO_DE_ALTERACION.natural],
+      [1, MODO_DE_ALTERACION.sostenido],
+      [2, MODO_DE_ALTERACION.dobleSostenido]
+    ]);
+    SEMITONOS = { C: 0, D: 2, E: 4, F: 5, G: 7, A: 9, B: 11 };
+    TICS_POR_NEGRA2 = 960;
+    entero = (texto4, re) => {
+      const m = re.exec(texto4);
+      return m ? Number.parseInt(m[1], 10) : null;
+    };
+    HIJO_QUE_SE_MUEVE = /<(clef|key|time|transpose|staff-details)\b[^>]*?(?:\/>|>[\s\S]*?<\/\1>)/g;
+    ATRIBUTOS_DE_SALTO = ["coda", "tocoda", "dacapo", "dalsegno", "fine", "segno"];
+    NEGRAS_POR_FIGURA = {
+      breve: 8,
+      whole: 4,
+      half: 2,
+      quarter: 1,
+      eighth: 0.5,
+      "16th": 0.25,
+      "32nd": 0.125
+    };
+  }
+});
+
+// packages/io/src/importarGp.ts
+function piezaDeBateria(pista, numero2) {
+  if (numero2 < 0) return null;
+  const delArchivo = pista.percussionArticulations ?? [];
+  const midi = numero2 < delArchivo.length ? delArchivo[numero2].outputMidiNumber : SALIDA_DE_ID_GP[numero2] ?? numero2;
+  const buscada = PARIENTE_GM[midi] ?? midi;
+  return KIT.find((p) => p.midi === buscada)?.indice ?? null;
+}
+function importarGp(bytes, opciones = {}) {
+  const xml = textoMusicXml(bytes);
+  if (xml === null) {
+    const score2 = _barrel_exports$1.ScoreLoader.loadScoreFromBytes(bytes);
+    return importarScore(score2, opciones);
+  }
+  const preparado = prepararMusicXml(xml);
+  const score = _barrel_exports$1.ScoreLoader.loadScoreFromBytes(preparado.bytes);
+  const leido = leerDelArchivo(preparado.xml);
+  const resultado = importarScore(score, opciones, { ortografia: leido.ortografia, bajos: leido.bajos, matices: leido.matices, saltos: leido.saltos });
+  resultado.avisos.push(...preparado.correcciones);
+  return resultado;
+}
+function prepararParaAlphaTab(bytes) {
+  const xml = textoMusicXml(bytes);
+  return xml === null ? bytes : prepararMusicXml(xml).bytes;
+}
+function importarScore(score, opciones = {}, datos = {}) {
+  const avisos = [];
+  const documento = crearDocumento({ clienteId: opciones.clienteId });
+  documento.ponerCabecera({
+    titulo: score.title ?? "",
+    artista: score.artist ?? "",
+    album: score.album ?? "",
+    tempo: score.tempo ?? 0,
+    mostrarMatices: !score.stylesheet.hideDynamics
+  });
+  avisos.push(
+    'Las preferencias de dibujo del archivo (el "stylesheet" de Guitar Pro) no se importan, salvo si se muestran los matices. La m\xFAsica no cambia; el aspecto s\xED.'
+  );
+  if (opciones.autoria) {
+    documento.ponerAutoria(opciones.autoria);
+  } else {
+    documento.ponerAutoria({
+      escritaPor: "",
+      origen: "transcripcion",
+      obraTitulo: score.title ?? "",
+      obraAutores: score.artist ?? "",
+      obraEditora: ""
+    });
+    avisos.push(
+      "La autor\xEDa qued\xF3 sin completar: se import\xF3 como transcripci\xF3n con los datos del archivo. Hay que confirmarla antes de publicar o compartir el documento."
+    );
+  }
+  const saltosEscritos = saltosDelTexto(score);
+  const idsDeCompasMaestro = score.masterBars.map(
+    (maestro) => documento.agregarCompasMaestro(normalizarCompasMaestro({
+      numerador: maestro.timeSignatureNumerator,
+      denominador: maestro.timeSignatureDenominator,
+      tonalidad: numeroDeTonalidad(tonalidadDeConcierto(score, maestro.index)),
+      // ⚠️ El ensayo de un MusicXML (`<rehearsal>A</rehearsal>`) llena sólo `section.marker`;
+      //    `text` queda vacío y las letras A, B, C… se perdían todas. Un `.gp` trae las dos y
+      //    manda el texto, como siempre.
+      seccion: maestro.section?.text || maestro.section?.marker || "",
+      // El cambio de tempo que arranca EN este compás. Los que caen a mitad van a su figura
+      // (ver `temposAMitad` abajo).
+      // ⛔ (2026-11-10) Antes era `tempoAutomations[0]` sin mirar dónde caía: un 140 a mitad
+      //    del compás 2 se aplicaba desde su principio y la primera mitad sonaba a 140.
+      tempo: maestro.tempoAutomations?.find((a) => a.ratioPosition <= 1e-6)?.value ?? null,
+      repiteDesdeAca: maestro.isRepeatStart,
+      repiteVeces: maestro.repeatCount,
+      // ⚠️ Novena pérdida silenciosa de la misma familia: 2 de los 15 `.gp` de Daniel
+      // declaran una anacruza y el modelo la descartaba.
+      esAnacruza: maestro.isAnacrusis,
+      // ── Los signos de compás de Guitar Pro ────────────────────────────────
+      casillas: maestro.alternateEndings,
+      dobleBarra: maestro.isDoubleBar,
+      tiempoLibre: maestro.isFreeTime,
+      swing: maestro.tripletFeel,
+      // ⚠️ `simileMark` es del compás DE LA PISTA en alphaTab (`Bar.simileMark`), no del
+      //    maestro. Se lee más abajo, al recorrer los compases de cada pentagrama, y se
+      //    escribe acá arriba porque en el modelo la repetición de compás es de la obra:
+      //    un «igual que el anterior» que valiera para la guitarra y no para el bajo
+      //    dejaría los dos instrumentos diciendo cosas distintas sobre el mismo compás.
+      repiteAnterior: 0,
+      // ⚠️ `directions` es un `Set` o `null`, no una lista. Un `?? []` sobre un Set daría
+      //    el Set, y `.map` no existe ahí: hay que expandirlo.
+      //
+      // ⚠️⚠️ Y se guarda el NOMBRE, no el número. `String(d)` daba `"1"` —el valor del enum
+      //    convertido a texto— y la proyección buscaba `Direction["1"]`, que en un enum con
+      //    mapeo inverso devuelve el *nombre* y no un número: la guarda lo descartaba y **las
+      //    direcciones se perdían enteras, en silencio**. Lo cazó la prueba de ida y vuelta
+      //    con signos, que es exactamente para lo que existe.
+      //
+      // ★ El nombre y no el número, además, porque acá es una LISTA y se lee: un
+      //   `["JumpDalSegnoAlCoda"]` en el documento dice algo; un `[10]` no.
+      //
+      // ⛔ (2026-11-11) De un MusicXML mandan las que se leyeron del archivo (`datos.saltos`):
+      //    alphaTab 1.8.4 confunde Segno Segno con Segno, Double Coda con Coda, y en un compás
+      //    vacío pierde todos los «al Coda» y «al Fine». Ver `LoQueSeLeeDelArchivo.saltos`.
+      direcciones: datos.saltos?.get(maestro.index) ? [...datos.saltos.get(maestro.index)] : maestro.directions ? [...saltosEscritos.precisos.get(maestro.index) ?? maestro.directions].map(
+        (d) => _barrel_exports$4.Direction[d] ?? String(d)
+      ) : []
+    }))
+  );
+  const saltos = /* @__PURE__ */ new Set();
+  for (const pista of score.tracks) for (const i2 of pista.lineBreaks ?? []) saltos.add(i2);
+  for (const i2 of saltos) {
+    const id2 = idsDeCompasMaestro[i2];
+    if (id2 !== void 0 && i2 > 0) documento.ponerSaltoDeRenglon(id2, true);
+  }
+  const letrasDobles = { cuantas: 0, versosDeMas: 0 };
+  const tipoDelPentagrama = (p) => p.isPercussion ? "percusion" : p.tuning.length === 0 ? "altura" : "trastes";
   for (const pista of score.tracks) {
     if (pista.staves.length === 0) {
       avisos.push(`La pista "${pista.name}" no tiene pentagramas y se salte\xF3 entera.`);
@@ -89358,7 +90419,12 @@ function importarScore(score, opciones = {}, datos = {}) {
     );
   }
   const audioEmbebido = importarAudioYSync(score, documento, idsDeCompasMaestro, avisos);
-  return { documento, avisos, ...audioEmbebido ? { audioEmbebido } : {} };
+  const manosJuntadas = juntarManosDelPiano(documento);
+  if (manosJuntadas > 0)
+    avisos.push(
+      manosJuntadas === 1 ? "El piano ven\xEDa con una pista por mano: se junt\xF3 en un solo instrumento, con su llave." : `${manosJuntadas} pianos ven\xEDan con una pista por mano: se juntaron, cada uno con su llave.`
+    );
+  return { documento, avisos, manosJuntadas, ...audioEmbebido ? { audioEmbebido } : {} };
 }
 function importarAudioYSync(score, documento, idsDeCompasMaestro, avisos) {
   const puntos = score.exportFlatSyncPoints();
@@ -89475,13 +90541,15 @@ function ortografiaDe(ortografia, parte, pentagrama, compas, tic, nota) {
   const base = `${parte}|${pentagrama}|${compas}|${tic}|`;
   return ortografia.get(base + nota.calculateRealValue(false, false)) ?? ortografia.get(base + (nota.octave * 12 + nota.tone));
 }
-var SALIDA_DE_ID_GP, PARIENTE_GM, DIR, SALTO_POR_TEXTO, claveDeSalto;
+var SALIDA_DE_ID_GP, PARIENTE_GM, DIR, SALTO_POR_TEXTO;
 var init_importarGp = __esm({
   "packages/io/src/importarGp.ts"() {
     init_alphaTab();
     init_src2();
     init_src2();
+    init_manosDelPiano();
     init_musicxmlEntrada();
+    init_musicxml();
     SALIDA_DE_ID_GP = {
       31: 40,
       83: 53,
@@ -89546,6 +90614,7 @@ var init_importarGp = __esm({
       dsalfine: [DIR.JumpDalSegno, DIR.JumpDalSegnoAlFine],
       dssalcoda: [DIR.JumpDalSegno, DIR.JumpDalSegnoSegnoAlCoda],
       dssalfine: [DIR.JumpDalSegno, DIR.JumpDalSegnoSegnoAlFine],
+      dssalcoda2: [DIR.JumpDalSegno, DIR.JumpDalSegnoSegnoAlDoubleCoda],
       dss: [DIR.JumpDalSegno, DIR.JumpDalSegnoSegno],
       dcalcoda: [DIR.JumpDaCapo, DIR.JumpDaCapoAlCoda],
       dcalcoda2: [DIR.JumpDaCapo, DIR.JumpDaCapoAlDoubleCoda],
@@ -89556,7 +90625,6 @@ var init_importarGp = __esm({
       tocoda2: [DIR.JumpDaCoda, DIR.JumpDaDoubleCoda],
       fine: [DIR.TargetFine, DIR.TargetFine]
     };
-    claveDeSalto = (texto4) => texto4.toLowerCase().replace(/dals*segno/g, "ds").replace(/das*capo/g, "dc").replace(/[^a-z0-9]/g, "");
   }
 });
 
@@ -90054,7 +91122,7 @@ function claseDe(g) {
   if (g.esBateria) return "bateria";
   if (g.programa >= 24 && g.programa <= 31) return "guitarra";
   if (g.programa >= 32 && g.programa <= 39) return "bajo";
-  if (g.programa <= 7) return "piano";
+  if (g.programa <= 7 || g.programa >= 16 && g.programa <= 20) return "piano";
   return "altura";
 }
 function digitar(alturas, afinacion, ocupadas) {
@@ -90166,9 +91234,32 @@ function figurasQueLlenan(ini, fin, ventana) {
   }
   return salida;
 }
+function juntarPistasDeManos(grupos, avisos) {
+  const salida = [];
+  for (let i2 = 0; i2 < grupos.length; i2++) {
+    const a = grupos[i2];
+    const b = grupos[i2 + 1];
+    const base = b && claseDe(a) === "piano" && claseDe(b) === "piano" ? baseDeLasManos(a.nombre, b.nombre) : null;
+    if (!b || base === null) {
+      salida.push(a);
+      continue;
+    }
+    salida.push({
+      ...a,
+      nombre: base,
+      canales: [.../* @__PURE__ */ new Set([...a.canales, ...b.canales])],
+      notas: [...a.notas.map((n) => ({ ...n, mano: 0 })), ...b.notas.map((n) => ({ ...n, mano: 1 }))].sort(
+        (x2, y) => x2.ini - y.ini || x2.altura - y.altura
+      )
+    });
+    avisos.decir(`\xAB${a.nombre}\xBB y \xAB${b.nombre}\xBB son las dos manos de un piano: se abrieron como un solo instrumento.`);
+    i2++;
+  }
+  return salida;
+}
 function armarScore(leido, opciones, avisos) {
   const rejilla = rejillaDe(opciones.cuantizacion);
-  const grupos = leido.grupos.filter((g) => g.notas.length > 0);
+  const grupos = juntarPistasDeManos(leido.grupos.filter((g) => g.notas.length > 0), avisos);
   if (grupos.length === 0) {
     avisos.decir("El archivo no trae ninguna nota: se abri\xF3 una obra vac\xEDa con un piano.");
   }
@@ -90199,13 +91290,13 @@ function armarScore(leido, opciones, avisos) {
       if (fin <= ini) fin = ini + pasoEn(ventanas, ini);
       if (Math.abs(ini - cruda.ini) > 2) redondeadas++;
       else if (Math.abs(fin - cruda.fin) > 2 && clase !== "bateria") avisos.contar("duracion-ajustada");
-      notas.push({ ini, fin: Math.min(fin, finDeLaObra2), altura: cruda.altura, cuerda: 0 });
+      notas.push({ ini, fin: Math.min(fin, finDeLaObra2), altura: cruda.altura, cuerda: 0, ...cruda.mano !== void 0 ? { mano: cruda.mano } : {} });
     }
     notas.sort((a, b) => a.altura - b.altura || a.ini - b.ini || b.fin - a.fin);
     const limpias = [];
     for (const n of notas) {
       const anterior = limpias[limpias.length - 1];
-      if (anterior && anterior.altura === n.altura) {
+      if (anterior && anterior.altura === n.altura && anterior.mano === n.mano) {
         if (anterior.ini === n.ini) {
           avisos.contar("repetidas");
           continue;
@@ -90248,8 +91339,16 @@ function armarScore(leido, opciones, avisos) {
       const voces = repartirEnVoces(enRegistro, ventanas, avisos, (alturas, ocupadas) => digitar(alturas, afinacion, ocupadas));
       pista.pentagramas.push({ voces, clave: clase === "guitarra" ? _barrel_exports$4.Clef.G2 : _barrel_exports$4.Clef.F4 });
     } else if (clase === "piano") {
-      const derecha = notas.filter((n) => n.altura >= 60);
-      const izquierda = notas.filter((n) => n.altura < 60);
+      let derecha;
+      let izquierda;
+      if (notas.some((n) => n.mano !== void 0)) {
+        derecha = notas.filter((n) => n.mano !== 1);
+        izquierda = notas.filter((n) => n.mano === 1);
+      } else {
+        const manos = repartirManos(notas);
+        derecha = manos.derecha.map((i2) => notas[i2]).sort((a, b) => a.ini - b.ini || a.altura - b.altura);
+        izquierda = manos.izquierda.map((i2) => notas[i2]).sort((a, b) => a.ini - b.ini || a.altura - b.altura);
+      }
       pista.pentagramas.push({ voces: repartirEnVoces(derecha, ventanas, avisos, null), clave: _barrel_exports$4.Clef.G2 });
       pista.pentagramas.push({ voces: repartirEnVoces(izquierda, ventanas, avisos, null), clave: _barrel_exports$4.Clef.F4 });
     } else {
@@ -90515,6 +91614,7 @@ var init_importarMidi = __esm({
   "packages/io/src/importarMidi.ts"() {
     init_alphaTab();
     init_src2();
+    init_manosDelPiano();
     init_importarGp();
     MidiIlegible = class extends Error {
       constructor(mensaje) {
@@ -90805,818 +91905,298 @@ function desempaquetar(bytes) {
   }
   if (!Number.isFinite(manifiesto.formato) || manifiesto.formato > VERSION_DEL_FORMATO) {
     throw new ArchivoIlegible(
-      `Este archivo se guard\xF3 con una versi\xF3n m\xE1s nueva de Mandioca Tabs (formato ${manifiesto.formato}; esta versi\xF3n entiende hasta el ${VERSION_DEL_FORMATO}). Abrirlo igual podr\xEDa borrarte lo que esa versi\xF3n guard\xF3.`
-    );
-  }
-  const doc = entradas[DOCUMENTO];
-  if (!doc) throw new ArchivoIlegible("El archivo no trae el documento.");
-  let documento;
-  try {
-    documento = abrirDocumento(doc);
-  } catch {
-    throw new ArchivoIlegible("El documento que trae el archivo est\xE1 da\xF1ado.");
-  }
-  const grabaciones = [];
-  const fuentes = [];
-  for (const [nombre, contenido] of Object.entries(entradas)) {
-    if (nombre.startsWith(CARPETA_DE_AUDIO)) {
-      const fuenteId = nombre.slice(CARPETA_DE_AUDIO.length);
-      if (fuenteId) grabaciones.push({ fuenteId, bytes: contenido });
-      continue;
-    }
-    if (nombre.startsWith(CARPETA_DE_FUENTES)) {
-      const tipografiaId = nombre.slice(CARPETA_DE_FUENTES.length);
-      if (tipografiaId) fuentes.push({ tipografiaId, bytes: contenido });
-    }
-  }
-  return { documento, manifiesto, grabaciones, fuentes };
-}
-var VERSION_DEL_FORMATO, MANIFIESTO, DOCUMENTO, CARPETA_DE_AUDIO, CARPETA_DE_FUENTES, ArchivoIlegible;
-var init_archivoMtabs = __esm({
-  "packages/io/src/archivoMtabs.ts"() {
-    init_esm();
-    init_src2();
-    VERSION_DEL_FORMATO = 6;
-    MANIFIESTO = "mandioca.json";
-    DOCUMENTO = "documento.ydoc";
-    CARPETA_DE_AUDIO = "audio/";
-    CARPETA_DE_FUENTES = "fuentes/";
-    ArchivoIlegible = class extends Error {
-      constructor(mensaje) {
-        super(mensaje);
-        this.name = "ArchivoIlegible";
-      }
-    };
-  }
-});
-
-// packages/io/src/recorridoDeRepeticiones.ts
-function instalarRecorridoDeRepeticiones() {
-  const version2 = String(VersionInfo?.VersionInfo?.version ?? VersionInfo?.version ?? "");
-  const Generador = _barrel_exports$3.MidiFileGenerator;
-  if (!Generador || typeof Generador._playThroughSong !== "function") return false;
-  if (Generador.__recorridoDe19) return true;
-  if (version2 && !version2.startsWith("1.8.")) return false;
-  Generador._playThroughSong = function(score, syncPoints, createNewSyncPoints, generateMasterBar, generateTracks, finish) {
-    const controller = new RecorridoDeCompases(score);
-    const playContext = {
-      synthTick: 0,
-      synthTime: 0,
-      currentTempo: score.tempo,
-      automationToSyncPoint: /* @__PURE__ */ new Map(),
-      syncPoints,
-      createNewSyncPoints
-    };
-    let previousMasterBar = null;
-    const barOccurence = /* @__PURE__ */ new Map();
-    while (!controller.finished) {
-      const index = controller.index;
-      const bar = score.masterBars[index];
-      const currentTick = controller.currentTick;
-      controller.processCurrent();
-      if (controller.shouldPlay) {
-        let occurence = barOccurence.has(index) ? barOccurence.get(index) : -1;
-        occurence++;
-        barOccurence.set(index, occurence);
-        generateMasterBar(bar, previousMasterBar, currentTick, playContext.currentTempo, occurence);
-        generateTracks(index, currentTick, bar.tempoAutomations.length > 0 ? bar.tempoAutomations[0].value : playContext.currentTempo);
-        playContext.synthTick = currentTick;
-        Generador._processBarTime(bar, occurence, playContext);
-      }
-      controller.moveNext();
-      previousMasterBar = bar;
-    }
-    if (syncPoints.length > 0) {
-      const lastSyncPoint = syncPoints[syncPoints.length - 1];
-      const remainingTicks = controller.currentTick - lastSyncPoint.synthTick;
-      if (remainingTicks > 0) {
-        const p = new _barrel_exports$7.BackingTrackSyncPoint();
-        p.masterBarIndex = previousMasterBar.index;
-        p.masterBarOccurence = barOccurence.get(previousMasterBar.index) - 1;
-        p.synthTick = controller.currentTick;
-        p.synthBpm = playContext.currentTempo;
-        if (playContext.createNewSyncPoints) {
-          p.syncBpm = lastSyncPoint.synthBpm;
-          p.synthBpm = lastSyncPoint.synthBpm;
-        } else if (syncPoints.length === 1) p.syncBpm = lastSyncPoint.synthBpm;
-        else p.syncBpm = syncPoints[syncPoints.length - 2].syncBpm;
-        p.synthTime = lastSyncPoint.synthTime + ticksAMs(remainingTicks, lastSyncPoint.synthBpm);
-        p.syncTime = lastSyncPoint.syncTime + ticksAMs(remainingTicks, p.syncBpm);
-        if (!playContext.createNewSyncPoints) lastSyncPoint.updateSyncBpm(p.synthTime, p.syncTime);
-        syncPoints.push(p);
-      }
-    }
-    finish(controller.currentTick);
-    return playContext;
-  };
-  Generador.__recorridoDe19 = true;
-  return true;
-}
-var D, Repeticion, RecorridoDeCompases, ticksAMs;
-var init_recorridoDeRepeticiones = __esm({
-  "packages/io/src/recorridoDeRepeticiones.ts"() {
-    init_alphaTab();
-    D = {
-      TargetFine: 0,
-      TargetSegno: 1,
-      TargetSegnoSegno: 2,
-      TargetCoda: 3,
-      TargetDoubleCoda: 4,
-      JumpDaCoda: 17,
-      JumpDaDoubleCoda: 18
-    };
-    Repeticion = class {
-      group;
-      /** Con casillas, cada cierre termina la pasada y todos comparten el contador. */
-      conCasillas;
-      /** La pasada actual (desde 0): elige qué casillas suenan. */
-      pasada = 0;
-      /** Las repeticiones hechas por cierre (sólo sin casillas). */
-      iteraciones;
-      /** Las casillas del último compás que las tenía: los que no tienen, las continúan. */
-      casillasActuales = 0;
-      /** @param pasadaFinal si se toca como última pasada (después de un salto): sólo la última casilla. */
-      constructor(group, pasadaFinal) {
-        this.group = group;
-        this.conCasillas = group.masterBars.some((m) => m.alternateEndings !== 0);
-        this.iteraciones = group.closings.map((c) => pasadaFinal ? Math.max(0, c.repeatCount - 1) : 0);
-        if (pasadaFinal) for (const i2 of this.iteraciones) this.pasada = Math.max(this.pasada, i2);
-      }
-      suena(compas) {
-        let casillas = compas.alternateEndings;
-        if (casillas === 0) casillas = this.casillasActuales;
-        else this.casillasActuales = casillas;
-        return casillas === 0 || (casillas & 1 << this.pasada) !== 0;
-      }
-      /** 0 = seguir, 1 = volver al comienzo de la repetición, 2 = terminó. */
-      alCerrar(cierre, sono) {
-        const cierres = this.group.closings;
-        const esElUltimo = cierre === cierres[cierres.length - 1];
-        if (this.conCasillas) {
-          if (!sono && !esElUltimo) return 0;
-          if (this.pasada < cierre.repeatCount - 1) {
-            this.pasada++;
-            this.casillasActuales = 0;
-            return 1;
-          }
-          return esElUltimo ? 2 : 0;
-        }
-        const i2 = cierres.indexOf(cierre);
-        if (i2 === -1) return 0;
-        if (this.iteraciones[i2] < cierre.repeatCount - 1) {
-          this.iteraciones[i2]++;
-          for (let j = 0; j < i2; j++) this.iteraciones[j] = 0;
-          this.casillasActuales = 0;
-          return 1;
-        }
-        return esElUltimo ? 2 : 0;
-      }
-      /** Si algún cierre todavía va a volver por encima de este compás. */
-      vaAVolver(compas) {
-        const cierres = this.group.closings;
-        for (let i2 = 0; i2 < cierres.length; i2++) {
-          const cierre = cierres[i2];
-          if (cierre.index >= compas.index) {
-            if ((this.conCasillas ? this.pasada : this.iteraciones[i2]) < cierre.repeatCount - 1) return true;
-          }
-        }
-        return false;
-      }
-    };
-    RecorridoDeCompases = class _RecorridoDeCompases {
-      /** Los saltos en el orden en que se revisan si un compás tiene varios. */
-      static SALTOS = [
-        { jump: 5, target: null, playUntil: null, continueAt: null },
-        { jump: 6, target: null, playUntil: D.JumpDaCoda, continueAt: D.TargetCoda },
-        { jump: 7, target: null, playUntil: D.JumpDaDoubleCoda, continueAt: D.TargetDoubleCoda },
-        { jump: 8, target: null, playUntil: D.TargetFine, continueAt: null },
-        { jump: 9, target: D.TargetSegno, playUntil: null, continueAt: null },
-        { jump: 10, target: D.TargetSegno, playUntil: D.JumpDaCoda, continueAt: D.TargetCoda },
-        { jump: 11, target: D.TargetSegno, playUntil: D.JumpDaDoubleCoda, continueAt: D.TargetDoubleCoda },
-        { jump: 12, target: D.TargetSegno, playUntil: D.TargetFine, continueAt: null },
-        { jump: 13, target: D.TargetSegnoSegno, playUntil: null, continueAt: null },
-        { jump: 14, target: D.TargetSegnoSegno, playUntil: D.JumpDaCoda, continueAt: D.TargetCoda },
-        { jump: 15, target: D.TargetSegnoSegno, playUntil: D.JumpDaDoubleCoda, continueAt: D.TargetDoubleCoda },
-        { jump: 16, target: D.TargetSegnoSegno, playUntil: D.TargetFine, continueAt: null }
-      ];
-      score;
-      pila = [];
-      /** El D.C./D.S. que se siguió; null si se toca normal (antes del salto o después de la coda). */
-      saltoActivo = null;
-      /** Los compases cuyo salto ya se tomó: cada salto se toma una sola vez. */
-      saltosTomados = /* @__PURE__ */ new Set();
-      shouldPlay = true;
-      index = 0;
-      currentTick = 0;
-      constructor(score) {
-        this.score = score;
-      }
-      get finished() {
-        return this.index >= this.score.masterBars.length;
-      }
-      processCurrent() {
-        const compas = this.score.masterBars[this.index];
-        this.entrarARepeticion(compas);
-        const rep = this.pila.length > 0 ? this.pila[this.pila.length - 1] : null;
-        this.shouldPlay = rep === null || rep.suena(compas);
-        if (this.shouldPlay) this.currentTick += compas.calculateDuration();
-      }
-      moveNext() {
-        if (this.moverConSaltos()) return;
-        const compas = this.score.masterBars[this.index];
-        if (this.pila.length > 0 && compas.repeatCount > 1) {
-          const rep = this.pila[this.pila.length - 1];
-          switch (rep.alCerrar(compas, this.shouldPlay)) {
-            case 1:
-              this.index = rep.group.opening.index;
-              return;
-            case 2:
-              this.pila.pop();
-          }
-        }
-        this.index++;
-      }
-      /** Empieza la repetición del compás si hace falta: al llegar a su apertura, o tras un salto que cayó adentro. */
-      entrarARepeticion(compas) {
-        const group = compas.repeatGroup;
-        if (!group.isClosed || this.pila.some((r) => r.group === group)) return;
-        const adentro = compas.index <= group.closings[group.closings.length - 1].index;
-        if (compas === group.opening || this.saltoActivo !== null && adentro) {
-          this.pila.push(new Repeticion(group, this.saltoActivo !== null));
-        }
-      }
-      moverConSaltos() {
-        const compas = this.score.masterBars[this.index];
-        const dir = compas.directions;
-        if (!this.shouldPlay || dir === null || dir === void 0 || dir.size === 0) return false;
-        if (this.saltoActivo === null) return this.tomarSalto(compas, dir);
-        const hasta = this.saltoActivo.playUntil;
-        if (hasta !== null && dir.has(hasta)) return this.seguirTrasElSalto(this.saltoActivo.continueAt);
-        return false;
-      }
-      tomarSalto(compas, dir) {
-        if (this.saltosTomados.has(compas) || this.pila.some((r) => r.vaAVolver(compas))) return false;
-        for (const salto of _RecorridoDeCompases.SALTOS) {
-          if (!dir.has(salto.jump)) continue;
-          const destino = salto.target === null ? 0 : this.buscar(salto.target, true);
-          if (destino === -1) continue;
-          this.saltosTomados.add(compas);
-          this.saltoActivo = salto;
-          this.pila = [];
-          this.index = destino;
-          return true;
-        }
-        return false;
-      }
-      seguirTrasElSalto(seguirEn) {
-        if (seguirEn === null) {
-          this.index = this.score.masterBars.length;
-          return true;
-        }
-        const coda = this.buscar(seguirEn, false);
-        if (coda === -1) return false;
-        this.saltoActivo = null;
-        this.pila = [];
-        this.index = coda;
-        return true;
-      }
-      buscar(direccion, primeroAtras) {
-        const paso = primeroAtras ? -1 : 1;
-        const i2 = this.buscarHacia(direccion, paso);
-        return i2 !== -1 ? i2 : this.buscarHacia(direccion, -paso);
-      }
-      buscarHacia(direccion, paso) {
-        const compases = this.score.masterBars;
-        for (let i2 = this.index; i2 >= 0 && i2 < compases.length; i2 += paso) {
-          const d = compases[i2].directions;
-          if (d !== null && d !== void 0 && d.has(direccion)) return i2;
-        }
-        return -1;
-      }
-    };
-    ticksAMs = (ticks, tempo) => ticks * (6e4 / (tempo * 960)) | 0;
-  }
-});
-
-// packages/io/src/musicxml.ts
-function escapar(texto4) {
-  return texto4.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function elemento(nombre, texto4) {
-  if (texto4 === null || texto4 === void 0 || texto4 === "") return [];
-  return [`<${nombre}>${escapar(String(texto4))}</${nombre}>`];
-}
-function alturaMusicXml(midi, fifths, modo = 0) {
-  const octavaAlphaTab = Math.floor(midi / 12);
-  const clase = midi - octavaAlphaTab * 12;
-  const octava = octavaAlphaTab - 1;
-  const pedida = ALTERACION_POR_MODO[modo];
-  if (pedida !== void 0) {
-    const sinAlterar = clase - pedida;
-    const vueltas = Math.floor(sinAlterar / 12);
-    const paso = PASOS.find((p) => p.semitonos === sinAlterar - vueltas * 12);
-    if (paso) return { paso: paso.paso, alteracion: pedida, octava: octava + vueltas };
-  }
-  const natural = PASOS.find((p) => p.semitonos === clase);
-  if (natural) return { paso: natural.paso, alteracion: 0, octava };
-  if (fifths < 0) {
-    const arriba = PASOS.find((p) => p.semitonos === clase + 1);
-    if (arriba) return { paso: arriba.paso, alteracion: -1, octava };
-  }
-  const abajo = PASOS.find((p) => p.semitonos === clase - 1);
-  if (abajo) return { paso: abajo.paso, alteracion: 1, octava };
-  throw new Error(`altura MIDI no representable: ${midi}`);
-}
-function claveDelPentagrama(staff, bar) {
-  if (staff.isPercussion) return { signo: "percussion", linea: 2, lineas: 5, conAfinacion: false };
-  if (staff.showTablature && staff.tuning.length > 0)
-    return { signo: "TAB", linea: 5, lineas: staff.tuning.length, conAfinacion: true };
-  switch (bar.clef) {
-    case _barrel_exports$4.Clef.C3:
-      return { signo: "C", linea: 3, lineas: 5, conAfinacion: false };
-    case _barrel_exports$4.Clef.C4:
-      return { signo: "C", linea: 4, lineas: 5, conAfinacion: false };
-    case _barrel_exports$4.Clef.F4:
-      return { signo: "F", linea: 4, lineas: 5, conAfinacion: false };
-    case _barrel_exports$4.Clef.Neutral:
-      return { signo: "percussion", linea: 2, lineas: 5, conAfinacion: false };
-    default:
-      return { signo: "G", linea: 2, lineas: 5, conAfinacion: false };
-  }
-}
-function gruposDeTresillo(beats) {
-  const abren = /* @__PURE__ */ new Set();
-  const cierran = /* @__PURE__ */ new Set();
-  let i2 = 0;
-  while (i2 < beats.length) {
-    const b = beats[i2];
-    if (b.tupletNumerator <= 0 || b.tupletDenominator <= 0) {
-      i2++;
-      continue;
-    }
-    let j = i2;
-    while (j + 1 < beats.length && beats[j + 1].tupletNumerator === b.tupletNumerator && beats[j + 1].tupletDenominator === b.tupletDenominator && (b.tupletGroup === null || beats[j + 1].tupletGroup === b.tupletGroup))
-      j++;
-    abren.add(i2);
-    cierran.add(j);
-    i2 = j + 1;
-  }
-  return { abren, cierran };
-}
-function saltosDelCompas(master) {
-  const s = [];
-  for (const [direccion, salto] of SALTOS) {
-    if (!master?.directions?.has(direccion)) continue;
-    s.push('<direction placement="above">', "<direction-type>");
-    s.push(salto.simbolo ? `<${salto.simbolo}/>` : `<words>${escapar(salto.texto ?? "")}</words>`);
-    s.push("</direction-type>", `<sound ${salto.sonido}/>`, "</direction>");
-  }
-  return s;
-}
-function nombreDeFigura(duracion) {
-  return NOMBRE_DE_LA_FIGURA2.get(duracion) ?? "quarter";
-}
-function instrumentosDePercusion(track) {
-  const usadas = /* @__PURE__ */ new Set();
-  for (const staff of track.staves)
-    for (const bar of staff.bars)
-      for (const voice of bar.voices)
-        for (const beat of voice.beats)
-          for (const note of beat.notes)
-            if (note.percussionArticulation >= 0) usadas.add(note.percussionArticulation);
-  const ids = /* @__PURE__ */ new Map();
-  for (const art of [...usadas].sort((a, b) => a - b))
-    ids.set(art, `P${track.index + 1}-I${art + 1}`);
-  return ids;
-}
-function posicionDePercusion(staffLine) {
-  const indiceDeB = 6;
-  const bruto = indiceDeB + (5 - staffLine);
-  const paso = PASOS[(bruto % 7 + 7) % 7].paso;
-  return { paso, octava: 4 + Math.floor(bruto / 7) };
-}
-function escribirNota(note, beat, staff, opciones) {
-  const s = ["<note>"];
-  const esAdorno = beat.graceType !== _barrel_exports$4.GraceType.None;
-  if (esAdorno) s.push(beat.graceType === _barrel_exports$4.GraceType.BeforeBeat ? "<grace/>" : '<grace slash="yes"/>');
-  if (opciones.esAcorde) s.push("<chord/>");
-  const esGolpeDeKit = staff.isPercussion && note.percussionArticulation >= 0;
-  if (esGolpeDeKit) {
-    const art = staff.track.percussionArticulations[note.percussionArticulation];
-    const { paso, octava } = posicionDePercusion(art?.staffLine ?? 5);
-    s.push("<unpitched>");
-    s.push(`<display-step>${paso}</display-step>`);
-    s.push(`<display-octave>${octava}</display-octave>`);
-    s.push("</unpitched>");
-  } else {
-    const { paso, alteracion, octava } = alturaMusicXml(
-      note.calculateRealValue(false, false),
-      opciones.fifths,
-      note.accidentalMode
-    );
-    s.push("<pitch>");
-    s.push(`<step>${paso}</step>`);
-    if (alteracion !== 0) s.push(`<alter>${alteracion}</alter>`);
-    s.push(`<octave>${octava}</octave>`);
-    s.push("</pitch>");
-  }
-  if (!esAdorno) s.push(`<duration>${opciones.duracion}</duration>`);
-  if (note.isTieDestination) s.push('<tie type="stop"/>');
-  if (note.isTieOrigin) s.push('<tie type="start"/>');
-  const idDeInstrumento = opciones.instrumentos.get(note.percussionArticulation);
-  if (esGolpeDeKit && idDeInstrumento) s.push(`<instrument id="${idDeInstrumento}"/>`);
-  s.push(`<voice>${opciones.numeroDeVoz}</voice>`);
-  s.push(...elemento("type", nombreDeFigura(beat.duration)));
-  for (let d = 0; d < beat.dots; d++) s.push("<dot/>");
-  if (beat.tupletNumerator > 0 && beat.tupletDenominator > 0) {
-    s.push("<time-modification>");
-    s.push(`<actual-notes>${beat.tupletNumerator}</actual-notes>`);
-    s.push(`<normal-notes>${beat.tupletDenominator}</normal-notes>`);
-    s.push("</time-modification>");
-  }
-  if (note.isDead) s.push("<notehead>x</notehead>");
-  else if (esGolpeDeKit) {
-    const art = staff.track.percussionArticulations[note.percussionArticulation];
-    if (art?.noteHeadDefault === _barrel_exports$4.MusicFontSymbol.NoteheadXBlack)
-      s.push("<notehead>x</notehead>");
-  } else if (note.isGhost) s.push('<notehead parentheses="yes">normal</notehead>');
-  if (opciones.numeroDePentagrama !== null) s.push(`<staff>${opciones.numeroDePentagrama}</staff>`);
-  const notaciones = [];
-  if (note.isTieDestination) notaciones.push('<tied type="stop"/>');
-  if (note.isTieOrigin) notaciones.push('<tied type="start"/>');
-  if (opciones.abreTresillo) notaciones.push('<tuplet type="start" number="1"/>');
-  if (opciones.cierraTresillo) notaciones.push('<tuplet type="stop" number="1"/>');
-  const tecnica = [];
-  if (note.string > 0 && staff.tuning.length > 0) {
-    tecnica.push(`<string>${staff.tuning.length - note.string + 1}</string>`);
-    tecnica.push(`<fret>${note.fret}</fret>`);
-  }
-  const ligado = (desde, hasta) => hasta >= desde ? "hammer-on" : "pull-off";
-  const origen = note.hammerPullOrigin;
-  if (origen !== null) {
-    const nombre = ligado(origen.fret, note.fret);
-    tecnica.push(`<${nombre} type="stop"/>`);
-  }
-  const destino = note.hammerPullDestination;
-  if (note.isHammerPullOrigin && destino) {
-    const nombre = ligado(note.fret, destino.fret);
-    tecnica.push(`<${nombre} type="start">${nombre === "hammer-on" ? "H" : "P"}</${nombre}>`);
-  }
-  if (note.harmonicType !== _barrel_exports$4.HarmonicType.None) tecnica.push("<harmonic/>");
-  if (beat.isPalmMute) tecnica.push("<other-technical>palm-mute</other-technical>");
-  if (beat.isLetRing) tecnica.push("<other-technical>let-ring</other-technical>");
-  if (tecnica.length > 0) notaciones.push("<technical>", ...tecnica, "</technical>");
-  const articulaciones = [];
-  if (note.accentuated === _barrel_exports$4.AccentuationType.Normal) articulaciones.push("<accent/>");
-  else if (note.accentuated === _barrel_exports$4.AccentuationType.Heavy)
-    articulaciones.push("<strong-accent/>");
-  else if (note.accentuated === _barrel_exports$4.AccentuationType.Tenuto)
-    articulaciones.push("<tenuto/>");
-  if (note.isStaccato) articulaciones.push("<staccato/>");
-  if (articulaciones.length > 0)
-    notaciones.push("<articulations>", ...articulaciones, "</articulations>");
-  if (notaciones.length > 0) s.push("<notations>", ...notaciones, "</notations>");
-  if (!opciones.esAcorde) s.push(...letraDelGolpe(beat));
-  s.push("</note>");
-  return s;
-}
-function letraDelGolpe(beat) {
-  if (!beat.lyrics) return [];
-  const s = [];
-  beat.lyrics.forEach((verso, i2) => {
-    if (!verso) return;
-    const sigue = verso.endsWith("-") && verso.length > 1;
-    let anterior = beat.previousBeat;
-    while (anterior && !anterior.lyrics?.[i2]) anterior = anterior.previousBeat;
-    const viene = !!anterior?.lyrics?.[i2]?.endsWith("-");
-    const silabico = sigue ? viene ? "middle" : "begin" : viene ? "end" : "single";
-    s.push(`<lyric number="${i2 + 1}">`);
-    s.push(`<syllabic>${silabico}</syllabic>`);
-    s.push(...elemento("text", sigue ? verso.slice(0, -1) : verso));
-    s.push("</lyric>");
-  });
-  return s;
-}
-function escribirSilencio2(beat, duracion, numeroDeVoz, numeroDePentagrama) {
-  const s = ["<note>", "<rest/>", `<duration>${duracion}</duration>`];
-  s.push(`<voice>${numeroDeVoz}</voice>`);
-  s.push(...elemento("type", nombreDeFigura(beat.duration)));
-  for (let d = 0; d < beat.dots; d++) s.push("<dot/>");
-  if (beat.tupletNumerator > 0 && beat.tupletDenominator > 0) {
-    s.push("<time-modification>");
-    s.push(`<actual-notes>${beat.tupletNumerator}</actual-notes>`);
-    s.push(`<normal-notes>${beat.tupletDenominator}</normal-notes>`);
-    s.push("</time-modification>");
-  }
-  if (numeroDePentagrama !== null) s.push(`<staff>${numeroDePentagrama}</staff>`);
-  s.push(...letraDelGolpe(beat));
-  s.push("</note>");
-  return s;
-}
-function exportarMusicXml(score) {
-  const l = [];
-  l.push('<?xml version="1.0" encoding="UTF-8"?>');
-  l.push('<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 4.0 Partwise//EN"');
-  l.push('                                "http://www.musicxml.org/dtds/partwise.dtd">');
-  l.push('<score-partwise version="4.0">');
-  if (score.title) l.push("<work>", ...elemento("work-title", score.title), "</work>");
-  l.push(...elemento("movement-title", score.subTitle));
-  l.push("<identification>");
-  if (score.music) l.push(`<creator type="composer">${escapar(score.music)}</creator>`);
-  else if (score.artist) l.push(`<creator type="composer">${escapar(score.artist)}</creator>`);
-  if (score.words) l.push(`<creator type="lyricist">${escapar(score.words)}</creator>`);
-  l.push(...elemento("rights", score.copyright));
-  l.push("<encoding>", "<software>Mandioca Tabs</software>", "</encoding>");
-  l.push("</identification>");
-  const instrumentosPorPista = /* @__PURE__ */ new Map();
-  l.push("<part-list>");
-  for (const track of score.tracks) {
-    const id2 = `P${track.index + 1}`;
-    l.push(`<score-part id="${id2}">`);
-    l.push(...elemento("part-name", track.name || `Pista ${track.index + 1}`));
-    l.push(...elemento("part-abbreviation", track.shortName));
-    const esPercusion = track.staves.some((st) => st.isPercussion);
-    const instrumentos = esPercusion ? instrumentosDePercusion(track) : /* @__PURE__ */ new Map();
-    instrumentosPorPista.set(track.index, instrumentos);
-    if (esPercusion) {
-      for (const [art, idInstrumento] of instrumentos) {
-        const a = track.percussionArticulations[art];
-        l.push(`<score-instrument id="${idInstrumento}">`);
-        l.push(...elemento("instrument-name", `Percusi\xF3n ${art + 1}`));
-        l.push("</score-instrument>");
-        l.push(`<midi-instrument id="${idInstrumento}">`);
-        l.push("<midi-channel>10</midi-channel>");
-        l.push(`<midi-unpitched>${(a?.outputMidiNumber ?? 36) + 1}</midi-unpitched>`);
-        l.push("</midi-instrument>");
-      }
-    } else {
-      l.push(`<score-instrument id="${id2}-I1">`);
-      l.push(...elemento("instrument-name", track.name || `Pista ${track.index + 1}`));
-      l.push("</score-instrument>");
-      l.push(`<midi-instrument id="${id2}-I1">`);
-      l.push(`<midi-channel>${track.playbackInfo.primaryChannel + 1}</midi-channel>`);
-      l.push(`<midi-program>${track.playbackInfo.program + 1}</midi-program>`);
-      l.push(`<volume>${Math.round(track.playbackInfo.volume / 16 * 100)}</volume>`);
-      l.push(`<pan>${Math.round((track.playbackInfo.balance - 8) / 8 * 90)}</pan>`);
-      l.push("</midi-instrument>");
-    }
-    l.push("</score-part>");
+      `Este archivo se guard\xF3 con una versi\xF3n m\xE1s nueva de Mandioca Tabs (formato ${manifiesto.formato}; esta versi\xF3n entiende hasta el ${VERSION_DEL_FORMATO}). Abrirlo igual podr\xEDa borrarte lo que esa versi\xF3n guard\xF3.`
+    );
   }
-  l.push("</part-list>");
-  for (const track of score.tracks) {
-    const instrumentos = instrumentosPorPista.get(track.index) ?? /* @__PURE__ */ new Map();
-    l.push(`<part id="P${track.index + 1}">`);
-    const pentagramas = track.staves;
-    if (pentagramas.length === 0) {
-      l.push("</part>");
+  const doc = entradas[DOCUMENTO];
+  if (!doc) throw new ArchivoIlegible("El archivo no trae el documento.");
+  let documento;
+  try {
+    documento = abrirDocumento(doc);
+  } catch {
+    throw new ArchivoIlegible("El documento que trae el archivo est\xE1 da\xF1ado.");
+  }
+  const grabaciones = [];
+  const fuentes = [];
+  for (const [nombre, contenido] of Object.entries(entradas)) {
+    if (nombre.startsWith(CARPETA_DE_AUDIO)) {
+      const fuenteId = nombre.slice(CARPETA_DE_AUDIO.length);
+      if (fuenteId) grabaciones.push({ fuenteId, bytes: contenido });
       continue;
     }
-    let armaduraAnterior = null;
-    let compasAnterior = null;
-    let clavesAnteriores = null;
-    const cantidadDeCompases = Math.max(...pentagramas.map((st) => st.bars.length));
-    for (let indiceDeCompas2 = 0; indiceDeCompas2 < cantidadDeCompases; indiceDeCompas2++) {
-      const master = score.masterBars[indiceDeCompas2];
-      l.push(`<measure number="${indiceDeCompas2 + 1}">`);
-      const fifths = (pentagramas[0]?.bars[indiceDeCompas2] ?? pentagramas[0]?.bars[0])?.keySignature ?? master?.keySignature ?? 0;
-      const modo = master?.keySignatureType === _barrel_exports$4.KeySignatureType.Minor ? "minor" : "major";
-      const armadura = `${fifths}/${modo}`;
-      const numerador = master?.timeSignatureNumerator ?? 4;
-      const denominador = master?.timeSignatureDenominator ?? 4;
-      const compas = `${numerador}/${denominador}`;
-      const claves = pentagramas.map((st, k) => {
-        const bar = st.bars[indiceDeCompas2] ?? st.bars[0];
-        return { pentagrama: st, numero: k + 1, ...claveDelPentagrama(st, bar) };
-      });
-      const firmaDeClaves = claves.map((c) => `${c.signo}${c.linea}`).join(",");
-      const cambios = [];
-      if (indiceDeCompas2 === 0) cambios.push(`<divisions>${DIVISIONES_POR_NEGRA}</divisions>`);
-      if (armadura !== armaduraAnterior) {
-        cambios.push("<key>");
-        cambios.push(`<fifths>${fifths}</fifths>`);
-        cambios.push(`<mode>${modo}</mode>`);
-        cambios.push("</key>");
-        armaduraAnterior = armadura;
+    if (nombre.startsWith(CARPETA_DE_FUENTES)) {
+      const tipografiaId = nombre.slice(CARPETA_DE_FUENTES.length);
+      if (tipografiaId) fuentes.push({ tipografiaId, bytes: contenido });
+    }
+  }
+  const manosJuntadas = juntarManosDelPiano(documento);
+  return { documento, manifiesto, grabaciones, fuentes, manosJuntadas };
+}
+var VERSION_DEL_FORMATO, MANIFIESTO, DOCUMENTO, CARPETA_DE_AUDIO, CARPETA_DE_FUENTES, ArchivoIlegible;
+var init_archivoMtabs = __esm({
+  "packages/io/src/archivoMtabs.ts"() {
+    init_esm();
+    init_src2();
+    init_manosDelPiano();
+    VERSION_DEL_FORMATO = 6;
+    MANIFIESTO = "mandioca.json";
+    DOCUMENTO = "documento.ydoc";
+    CARPETA_DE_AUDIO = "audio/";
+    CARPETA_DE_FUENTES = "fuentes/";
+    ArchivoIlegible = class extends Error {
+      constructor(mensaje) {
+        super(mensaje);
+        this.name = "ArchivoIlegible";
       }
-      if (compas !== compasAnterior) {
-        cambios.push("<time>");
-        cambios.push(`<beats>${numerador}</beats>`);
-        cambios.push(`<beat-type>${denominador}</beat-type>`);
-        cambios.push("</time>");
-        compasAnterior = compas;
+    };
+  }
+});
+
+// packages/io/src/recorridoDeRepeticiones.ts
+function instalarRecorridoDeRepeticiones() {
+  const version2 = String(VersionInfo?.VersionInfo?.version ?? VersionInfo?.version ?? "");
+  const Generador = _barrel_exports$3.MidiFileGenerator;
+  if (!Generador || typeof Generador._playThroughSong !== "function") return false;
+  if (Generador.__recorridoDe19) return true;
+  if (version2 && !version2.startsWith("1.8.")) return false;
+  Generador._playThroughSong = function(score, syncPoints, createNewSyncPoints, generateMasterBar, generateTracks, finish) {
+    const controller = new RecorridoDeCompases(score);
+    const playContext = {
+      synthTick: 0,
+      synthTime: 0,
+      currentTempo: score.tempo,
+      automationToSyncPoint: /* @__PURE__ */ new Map(),
+      syncPoints,
+      createNewSyncPoints
+    };
+    let previousMasterBar = null;
+    const barOccurence = /* @__PURE__ */ new Map();
+    while (!controller.finished) {
+      const index = controller.index;
+      const bar = score.masterBars[index];
+      const currentTick = controller.currentTick;
+      controller.processCurrent();
+      if (controller.shouldPlay) {
+        let occurence = barOccurence.has(index) ? barOccurence.get(index) : -1;
+        occurence++;
+        barOccurence.set(index, occurence);
+        generateMasterBar(bar, previousMasterBar, currentTick, playContext.currentTempo, occurence);
+        generateTracks(index, currentTick, bar.tempoAutomations.length > 0 ? bar.tempoAutomations[0].value : playContext.currentTempo);
+        playContext.synthTick = currentTick;
+        Generador._processBarTime(bar, occurence, playContext);
       }
-      if (firmaDeClaves !== clavesAnteriores) {
-        if (pentagramas.length > 1 && clavesAnteriores === null)
-          cambios.push(`<staves>${pentagramas.length}</staves>`);
-        const num = (clave) => pentagramas.length > 1 ? ` number="${clave.numero}"` : "";
-        for (const clave of claves) {
-          cambios.push(`<clef${num(clave)}>`);
-          cambios.push(`<sign>${clave.signo}</sign>`);
-          cambios.push(`<line>${clave.linea}</line>`);
-          cambios.push("</clef>");
+      controller.moveNext();
+      previousMasterBar = bar;
+    }
+    if (syncPoints.length > 0) {
+      const lastSyncPoint = syncPoints[syncPoints.length - 1];
+      const remainingTicks = controller.currentTick - lastSyncPoint.synthTick;
+      if (remainingTicks > 0) {
+        const p = new _barrel_exports$7.BackingTrackSyncPoint();
+        p.masterBarIndex = previousMasterBar.index;
+        p.masterBarOccurence = barOccurence.get(previousMasterBar.index) - 1;
+        p.synthTick = controller.currentTick;
+        p.synthBpm = playContext.currentTempo;
+        if (playContext.createNewSyncPoints) {
+          p.syncBpm = lastSyncPoint.synthBpm;
+          p.synthBpm = lastSyncPoint.synthBpm;
+        } else if (syncPoints.length === 1) p.syncBpm = lastSyncPoint.synthBpm;
+        else p.syncBpm = syncPoints[syncPoints.length - 2].syncBpm;
+        p.synthTime = lastSyncPoint.synthTime + ticksAMs(remainingTicks, lastSyncPoint.synthBpm);
+        p.syncTime = lastSyncPoint.syncTime + ticksAMs(remainingTicks, p.syncBpm);
+        if (!playContext.createNewSyncPoints) lastSyncPoint.updateSyncBpm(p.synthTime, p.syncTime);
+        syncPoints.push(p);
+      }
+    }
+    finish(controller.currentTick);
+    return playContext;
+  };
+  Generador.__recorridoDe19 = true;
+  return true;
+}
+var D2, Repeticion, RecorridoDeCompases, ticksAMs;
+var init_recorridoDeRepeticiones = __esm({
+  "packages/io/src/recorridoDeRepeticiones.ts"() {
+    init_alphaTab();
+    D2 = {
+      TargetFine: 0,
+      TargetSegno: 1,
+      TargetSegnoSegno: 2,
+      TargetCoda: 3,
+      TargetDoubleCoda: 4,
+      JumpDaCoda: 17,
+      JumpDaDoubleCoda: 18
+    };
+    Repeticion = class {
+      group;
+      /** Con casillas, cada cierre termina la pasada y todos comparten el contador. */
+      conCasillas;
+      /** La pasada actual (desde 0): elige qué casillas suenan. */
+      pasada = 0;
+      /** Las repeticiones hechas por cierre (sólo sin casillas). */
+      iteraciones;
+      /** Las casillas del último compás que las tenía: los que no tienen, las continúan. */
+      casillasActuales = 0;
+      /** @param pasadaFinal si se toca como última pasada (después de un salto): sólo la última casilla. */
+      constructor(group, pasadaFinal) {
+        this.group = group;
+        this.conCasillas = group.masterBars.some((m) => m.alternateEndings !== 0);
+        this.iteraciones = group.closings.map((c) => pasadaFinal ? Math.max(0, c.repeatCount - 1) : 0);
+        if (pasadaFinal) for (const i2 of this.iteraciones) this.pasada = Math.max(this.pasada, i2);
+      }
+      suena(compas) {
+        let casillas = compas.alternateEndings;
+        if (casillas === 0) casillas = this.casillasActuales;
+        else this.casillasActuales = casillas;
+        return casillas === 0 || (casillas & 1 << this.pasada) !== 0;
+      }
+      /** 0 = seguir, 1 = volver al comienzo de la repetición, 2 = terminó. */
+      alCerrar(cierre, sono) {
+        const cierres = this.group.closings;
+        const esElUltimo = cierre === cierres[cierres.length - 1];
+        if (this.conCasillas) {
+          if (!sono && !esElUltimo) return 0;
+          if (this.pasada < cierre.repeatCount - 1) {
+            this.pasada++;
+            this.casillasActuales = 0;
+            return 1;
+          }
+          return esElUltimo ? 2 : 0;
         }
-        for (const clave of claves) {
-          cambios.push(`<staff-details${num(clave)}>`);
-          cambios.push(`<staff-lines>${clave.lineas}</staff-lines>`);
-          if (clave.conAfinacion)
-            clave.pentagrama.tuning.forEach((midi, i2) => {
-              const linea = clave.pentagrama.tuning.length - i2;
-              const { paso, alteracion, octava } = alturaMusicXml(midi, fifths);
-              cambios.push(`<staff-tuning line="${linea}">`);
-              cambios.push(`<tuning-step>${paso}</tuning-step>`);
-              if (alteracion !== 0) cambios.push(`<tuning-alter>${alteracion}</tuning-alter>`);
-              cambios.push(`<tuning-octave>${octava}</tuning-octave>`);
-              cambios.push("</staff-tuning>");
-            });
-          cambios.push("</staff-details>");
+        const i2 = cierres.indexOf(cierre);
+        if (i2 === -1) return 0;
+        if (this.iteraciones[i2] < cierre.repeatCount - 1) {
+          this.iteraciones[i2]++;
+          for (let j = 0; j < i2; j++) this.iteraciones[j] = 0;
+          this.casillasActuales = 0;
+          return 1;
         }
-        clavesAnteriores = firmaDeClaves;
+        return esElUltimo ? 2 : 0;
       }
-      if (cambios.length > 0) l.push("<attributes>", ...cambios, "</attributes>");
-      const casilla = master?.alternateEndings ?? 0;
-      const casillaAntes = score.masterBars[indiceDeCompas2 - 1]?.alternateEndings ?? 0;
-      const casillaDespues = score.masterBars[indiceDeCompas2 + 1]?.alternateEndings ?? 0;
-      const numerosDeCasilla = [0, 1, 2, 3, 4, 5, 6, 7].filter((b) => casilla & 1 << b).map((b) => b + 1).join(", ");
-      if (master?.isRepeatStart || casilla && casilla !== casillaAntes) {
-        l.push('<barline location="left">');
-        if (master?.isRepeatStart) l.push("<bar-style>heavy-light</bar-style>");
-        if (casilla && casilla !== casillaAntes) l.push(`<ending number="${numerosDeCasilla}" type="start"/>`);
-        if (master?.isRepeatStart) l.push('<repeat direction="forward"/>');
-        l.push("</barline>");
+      /** Si algún cierre todavía va a volver por encima de este compás. */
+      vaAVolver(compas) {
+        const cierres = this.group.closings;
+        for (let i2 = 0; i2 < cierres.length; i2++) {
+          const cierre = cierres[i2];
+          if (cierre.index >= compas.index) {
+            if ((this.conCasillas ? this.pasada : this.iteraciones[i2]) < cierre.repeatCount - 1) return true;
+          }
+        }
+        return false;
       }
-      if (master?.section?.text || master?.section?.marker)
-        l.push(
-          '<direction placement="above">',
-          "<direction-type>",
-          `<rehearsal>${escapar(master.section.marker || master.section.text)}</rehearsal>`,
-          "</direction-type>",
-          "</direction>"
-        );
-      l.push(...saltosDelCompas(master));
-      const ticsDelCompas = DIVISIONES_POR_NEGRA * 4 * numerador / denominador;
-      const tempos = (master?.tempoAutomations ?? []).map((a) => ({ bpm: a.value, desde: a.ratioPosition }));
-      if (indiceDeCompas2 === 0 && score.tempo && !tempos.some((t) => t.desde <= 1e-6))
-        tempos.unshift({ bpm: score.tempo, desde: 0 });
-      for (const t of tempos) {
-        const bpm = Math.round(t.bpm);
-        const offset = Math.round(t.desde * ticsDelCompas);
-        l.push(
-          '<direction placement="above">',
-          "<direction-type>",
-          "<metronome>",
-          "<beat-unit>quarter</beat-unit>",
-          `<per-minute>${bpm}</per-minute>`,
-          "</metronome>",
-          "</direction-type>",
-          ...offset > 0 ? [`<offset>${offset}</offset>`] : [],
-          `<sound tempo="${bpm}"/>`,
-          "</direction>"
-        );
+    };
+    RecorridoDeCompases = class _RecorridoDeCompases {
+      /** Los saltos en el orden en que se revisan si un compás tiene varios. */
+      static SALTOS = [
+        { jump: 5, target: null, playUntil: null, continueAt: null },
+        { jump: 6, target: null, playUntil: D2.JumpDaCoda, continueAt: D2.TargetCoda },
+        { jump: 7, target: null, playUntil: D2.JumpDaDoubleCoda, continueAt: D2.TargetDoubleCoda },
+        { jump: 8, target: null, playUntil: D2.TargetFine, continueAt: null },
+        { jump: 9, target: D2.TargetSegno, playUntil: null, continueAt: null },
+        { jump: 10, target: D2.TargetSegno, playUntil: D2.JumpDaCoda, continueAt: D2.TargetCoda },
+        { jump: 11, target: D2.TargetSegno, playUntil: D2.JumpDaDoubleCoda, continueAt: D2.TargetDoubleCoda },
+        { jump: 12, target: D2.TargetSegno, playUntil: D2.TargetFine, continueAt: null },
+        { jump: 13, target: D2.TargetSegnoSegno, playUntil: null, continueAt: null },
+        { jump: 14, target: D2.TargetSegnoSegno, playUntil: D2.JumpDaCoda, continueAt: D2.TargetCoda },
+        { jump: 15, target: D2.TargetSegnoSegno, playUntil: D2.JumpDaDoubleCoda, continueAt: D2.TargetDoubleCoda },
+        { jump: 16, target: D2.TargetSegnoSegno, playUntil: D2.TargetFine, continueAt: null }
+      ];
+      score;
+      pila = [];
+      /** El D.C./D.S. que se siguió; null si se toca normal (antes del salto o después de la coda). */
+      saltoActivo = null;
+      /** Los compases cuyo salto ya se tomó: cada salto se toma una sola vez. */
+      saltosTomados = /* @__PURE__ */ new Set();
+      shouldPlay = true;
+      index = 0;
+      currentTick = 0;
+      constructor(score) {
+        this.score = score;
       }
-      let ultimoAvance = 0;
-      let hayAlgoEscrito = false;
-      for (const { pentagrama, numero: numero2 } of claves) {
-        const bar = pentagrama.bars[indiceDeCompas2];
-        if (!bar) continue;
-        bar.voices.forEach((voice, indiceDeVoz) => {
-          if (voice.beats.length === 0 || voice.isEmpty) return;
-          if (hayAlgoEscrito && ultimoAvance > 0)
-            l.push("<backup>", `<duration>${ultimoAvance}</duration>`, "</backup>");
-          const { abren, cierran } = gruposDeTresillo(voice.beats);
-          const numeroDePentagrama = pentagramas.length > 1 ? numero2 : null;
-          let avance = 0;
-          voice.beats.forEach((beat, i2) => {
-            const duracion = beat.displayDuration;
-            if (beat.graceType === _barrel_exports$4.GraceType.None) avance += duracion;
-            if (beat.isRest || beat.notes.length === 0) {
-              l.push(...escribirSilencio2(beat, duracion, indiceDeVoz + 1, numeroDePentagrama));
+      get finished() {
+        return this.index >= this.score.masterBars.length;
+      }
+      processCurrent() {
+        const compas = this.score.masterBars[this.index];
+        this.entrarARepeticion(compas);
+        const rep = this.pila.length > 0 ? this.pila[this.pila.length - 1] : null;
+        this.shouldPlay = rep === null || rep.suena(compas);
+        if (this.shouldPlay) this.currentTick += compas.calculateDuration();
+      }
+      moveNext() {
+        if (this.moverConSaltos()) return;
+        const compas = this.score.masterBars[this.index];
+        if (this.pila.length > 0 && compas.repeatCount > 1) {
+          const rep = this.pila[this.pila.length - 1];
+          switch (rep.alCerrar(compas, this.shouldPlay)) {
+            case 1:
+              this.index = rep.group.opening.index;
               return;
-            }
-            beat.notes.forEach((note, k) => {
-              l.push(
-                ...escribirNota(note, beat, pentagrama, {
-                  esAcorde: k > 0,
-                  fifths,
-                  duracion,
-                  // ★ La marca de tresillo va en la PRIMERA nota del golpe: es una marca del
-                  //   golpe, no de cada cuerda que suena en él.
-                  abreTresillo: k === 0 && abren.has(i2),
-                  cierraTresillo: k === 0 && cierran.has(i2),
-                  instrumentos,
-                  numeroDeVoz: indiceDeVoz + 1,
-                  numeroDePentagrama
-                })
-              );
-            });
-          });
-          ultimoAvance = avance;
-          hayAlgoEscrito = true;
-        });
+            case 2:
+              this.pila.pop();
+          }
+        }
+        this.index++;
       }
-      const cierraCasilla = casilla !== 0 && casilla !== casillaDespues;
-      if (master?.isRepeatEnd || master?.isDoubleBar || cierraCasilla) {
-        l.push('<barline location="right">');
-        if (master?.isRepeatEnd || master?.isDoubleBar)
-          l.push(`<bar-style>${master.isRepeatEnd ? "light-heavy" : "light-light"}</bar-style>`);
-        if (cierraCasilla)
-          l.push(`<ending number="${numerosDeCasilla}" type="${master?.isRepeatEnd ? "stop" : "discontinue"}"/>`);
-        if (master?.isRepeatEnd)
-          l.push(`<repeat direction="backward" times="${Math.max(2, master.repeatCount)}"/>`);
-        l.push("</barline>");
+      /** Empieza la repetición del compás si hace falta: al llegar a su apertura, o tras un salto que cayó adentro. */
+      entrarARepeticion(compas) {
+        const group = compas.repeatGroup;
+        if (!group.isClosed || this.pila.some((r) => r.group === group)) return;
+        const adentro = compas.index <= group.closings[group.closings.length - 1].index;
+        if (compas === group.opening || this.saltoActivo !== null && adentro) {
+          this.pila.push(new Repeticion(group, this.saltoActivo !== null));
+        }
       }
-      l.push("</measure>");
-    }
-    l.push("</part>");
-  }
-  l.push("</score-partwise>");
-  return sangrar(l);
-}
-function sangrar(lineas) {
-  const salida = [];
-  let nivel = 0;
-  for (const linea of lineas) {
-    const cierra = linea.startsWith("</");
-    if (cierra) nivel = Math.max(0, nivel - 1);
-    salida.push("  ".repeat(nivel) + linea);
-    const abre = /^<[^/?!]/.test(linea) && !linea.endsWith("/>") && !/<\/[^>]+>$/.test(linea);
-    if (abre) nivel++;
-  }
-  return salida.join("\n") + "\n";
-}
-function exportarMusicXmlComprimido(score) {
-  const xml = exportarMusicXml(score);
-  const contenedor = `<?xml version="1.0" encoding="UTF-8"?>
-<container>
-  <rootfiles>
-    <rootfile full-path="partitura.musicxml" media-type="application/vnd.recordare.musicxml+xml"/>
-  </rootfiles>
-</container>
-`;
-  const codificador = new TextEncoder();
-  return zipSync(
-    {
-      "META-INF/container.xml": [codificador.encode(contenedor), { level: 0 }],
-      "partitura.musicxml": codificador.encode(xml)
-    },
-    // ⚠️ Fecha FIJA, no la de hoy: dos exportaciones iguales tienen que dar dos archivos
-    //    iguales byte a byte, o no hay prueba que pueda compararlos ni `diff` de git que
-    //    sirva. El porqué del valor concreto está en la constante — se tardó dos rojos en
-    //    encontrarlo, y ninguno de los dos era el que yo esperaba.
-    { mtime: FECHA_FIJA_DEL_ZIP }
-  );
-}
-var DIVISIONES_POR_NEGRA, FECHA_FIJA_DEL_ZIP, PASOS, NOMBRE_DE_LA_FIGURA2, ALTERACION_POR_MODO, D2, SALTOS;
-var init_musicxml = __esm({
-  "packages/io/src/musicxml.ts"() {
-    init_alphaTab();
-    init_esm();
-    DIVISIONES_POR_NEGRA = 960;
-    FECHA_FIJA_DEL_ZIP = 946728e6;
-    PASOS = [
-      { paso: "C", semitonos: 0 },
-      { paso: "D", semitonos: 2 },
-      { paso: "E", semitonos: 4 },
-      { paso: "F", semitonos: 5 },
-      { paso: "G", semitonos: 7 },
-      { paso: "A", semitonos: 9 },
-      { paso: "B", semitonos: 11 }
-    ];
-    NOMBRE_DE_LA_FIGURA2 = /* @__PURE__ */ new Map([
-      [-4, "long"],
-      [-2, "breve"],
-      [1, "whole"],
-      [2, "half"],
-      [4, "quarter"],
-      [8, "eighth"],
-      [16, "16th"],
-      [32, "32nd"],
-      [64, "64th"],
-      [128, "128th"],
-      [256, "256th"]
-    ]);
-    ALTERACION_POR_MODO = { 2: 0, 3: 1, 4: 2, 5: -1, 6: -2 };
-    D2 = _barrel_exports$4.Direction;
-    SALTOS = [
-      [D2.TargetSegno, { simbolo: "segno", sonido: 'segno="segno"' }],
-      [D2.TargetSegnoSegno, { simbolo: "segno", sonido: 'segno="segno2"' }],
-      [D2.TargetCoda, { simbolo: "coda", sonido: 'coda="coda"' }],
-      [D2.TargetDoubleCoda, { simbolo: "coda", sonido: 'coda="coda2"' }],
-      [D2.TargetFine, { texto: "Fine", sonido: 'fine="yes"' }],
-      [D2.JumpDaCapo, { texto: "D.C.", sonido: 'dacapo="yes"' }],
-      [D2.JumpDaCapoAlCoda, { texto: "D.C. al Coda", sonido: 'dacapo="yes"' }],
-      [D2.JumpDaCapoAlDoubleCoda, { texto: "D.C. al Coda 2", sonido: 'dacapo="yes"' }],
-      [D2.JumpDaCapoAlFine, { texto: "D.C. al Fine", sonido: 'dacapo="yes"' }],
-      [D2.JumpDalSegno, { texto: "D.S.", sonido: 'dalsegno="segno"' }],
-      [D2.JumpDalSegnoAlCoda, { texto: "D.S. al Coda", sonido: 'dalsegno="segno"' }],
-      [D2.JumpDalSegnoAlDoubleCoda, { texto: "D.S. al Coda 2", sonido: 'dalsegno="segno"' }],
-      [D2.JumpDalSegnoAlFine, { texto: "D.S. al Fine", sonido: 'dalsegno="segno"' }],
-      [D2.JumpDalSegnoSegno, { texto: "D.S.S.", sonido: 'dalsegno="segno2"' }],
-      [D2.JumpDalSegnoSegnoAlCoda, { texto: "D.S.S. al Coda", sonido: 'dalsegno="segno2"' }],
-      [D2.JumpDalSegnoSegnoAlDoubleCoda, { texto: "D.S.S. al Coda 2", sonido: 'dalsegno="segno2"' }],
-      [D2.JumpDalSegnoSegnoAlFine, { texto: "D.S.S. al Fine", sonido: 'dalsegno="segno2"' }],
-      [D2.JumpDaCoda, { texto: "To Coda", sonido: 'tocoda="coda"' }],
-      [D2.JumpDaDoubleCoda, { texto: "To Coda 2", sonido: 'tocoda="coda2"' }]
-    ];
+      moverConSaltos() {
+        const compas = this.score.masterBars[this.index];
+        const dir = compas.directions;
+        if (!this.shouldPlay || dir === null || dir === void 0 || dir.size === 0) return false;
+        if (this.saltoActivo === null) return this.tomarSalto(compas, dir);
+        const hasta = this.saltoActivo.playUntil;
+        if (hasta !== null && dir.has(hasta)) return this.seguirTrasElSalto(this.saltoActivo.continueAt);
+        return false;
+      }
+      tomarSalto(compas, dir) {
+        if (this.saltosTomados.has(compas) || this.pila.some((r) => r.vaAVolver(compas))) return false;
+        for (const salto of _RecorridoDeCompases.SALTOS) {
+          if (!dir.has(salto.jump)) continue;
+          const destino = salto.target === null ? 0 : this.buscar(salto.target, true);
+          if (destino === -1) continue;
+          this.saltosTomados.add(compas);
+          this.saltoActivo = salto;
+          this.pila = [];
+          this.index = destino;
+          return true;
+        }
+        return false;
+      }
+      seguirTrasElSalto(seguirEn) {
+        if (seguirEn === null) {
+          this.index = this.score.masterBars.length;
+          return true;
+        }
+        const coda = this.buscar(seguirEn, false);
+        if (coda === -1) return false;
+        this.saltoActivo = null;
+        this.pila = [];
+        this.index = coda;
+        return true;
+      }
+      buscar(direccion, primeroAtras) {
+        const paso = primeroAtras ? -1 : 1;
+        const i2 = this.buscarHacia(direccion, paso);
+        return i2 !== -1 ? i2 : this.buscarHacia(direccion, -paso);
+      }
+      buscarHacia(direccion, paso) {
+        const compases = this.score.masterBars;
+        for (let i2 = this.index; i2 >= 0 && i2 < compases.length; i2 += paso) {
+          const d = compases[i2].directions;
+          if (d !== null && d !== void 0 && d.has(direccion)) return i2;
+        }
+        return -1;
+      }
+    };
+    ticksAMs = (ticks, tempo) => ticks * (6e4 / (tempo * 960)) | 0;
   }
 });
 
@@ -91796,7 +92376,9 @@ async function abrirDeArchivo(ruta) {
     abierta = {
       documento: archivo.documento,
       origen: { clase: "archivo", ruta },
-      avisos: [],
+      // ★ (2026-11-11) Una obra vieja con el piano en dos pistas vuelve junta: se dice, para que
+      //   la IA no busque la «mano izquierda» como pista aparte.
+      avisos: archivo.manosJuntadas > 0 ? ["El piano estaba guardado en dos pistas (una por mano): ahora es un solo instrumento con dos pentagramas."] : [],
       grabaciones: archivo.grabaciones,
       grabacionesEnEspera: [],
       fuentes: archivo.fuentes
@@ -91980,7 +92562,7 @@ var VERSION_DEL_CONECTOR;
 var init_version = __esm({
   "apps/mcp/src/version.ts"() {
     "use strict";
-    VERSION_DEL_CONECTOR = true ? "0.2.17" : null;
+    VERSION_DEL_CONECTOR = true ? "0.2.18" : null;
   }
 });
 
@@ -124605,6 +125187,7 @@ var LEEN = /* @__PURE__ */ new Set([
   "ajustes_de_video",
   "atajos_del_programa",
   "audios_rechazados_por_largos",
+  "buscar_en_las_paletas",
   "captura",
   "direcciones_disponibles",
   "efectos_disponibles",
@@ -128446,6 +129029,94 @@ function registrarHerramientasDeArchivo(servidor2) {
   );
 }
 
+// apps/mcp/src/herramientas/paletas.ts
+init_src2();
+init_src3();
+init_obra();
+var FAMILIAS = ["figura", "tecnica", "signo", "acorde", "kit", "matiz", "seccion"];
+function herramientaDeLaFicha(familia, ficha) {
+  const id2 = ficha.id;
+  switch (familia) {
+    case "figura":
+      if (id2 === "puntillo") return { herramienta: "alternar_puntillo", argumentos: {} };
+      if (id2 === "silencio") return { herramienta: "escribir_silencio", argumentos: {} };
+      return { herramienta: "cambiar_duracion", argumentos: { figura: Number(id2.slice("figura-".length)) } };
+    case "tecnica":
+      if (id2.startsWith("efecto-")) return { herramienta: "poner_efecto", argumentos: { clave: id2.slice("efecto-".length) } };
+      if (id2.startsWith("bend-")) return { herramienta: "poner_bend", argumentos: { forma: id2.slice("bend-".length) } };
+      if (id2.startsWith("sube-")) return { herramienta: "poner_bend", argumentos: { cuartos: Number(id2.slice("sube-".length)) } };
+      return { herramienta: "escribir_curva_de_bend", argumentos: {} };
+    case "signo":
+      return { herramienta: "poner_signo", argumentos: { clave: id2.slice("signo-".length) } };
+    case "matiz":
+      return { herramienta: "poner_dinamica", argumentos: { matiz: id2.slice("matiz-".length) } };
+    case "kit": {
+      const pieza = KIT[Number(id2.slice("kit-".length))];
+      return pieza ? { herramienta: "escribir_notas", argumentos: { notas: [{ pieza: pieza.nombre }] } } : null;
+    }
+    case "acorde":
+      if (id2 === MIRA_DEDUCIR) return { herramienta: "acorde_en_el_cursor", argumentos: {} };
+      {
+        const [nombre, letra] = ficha.nombre.split(" ");
+        return { herramienta: "poner_acorde", argumentos: { nombre, ...letra ? { forma: letra } : {} } };
+      }
+    case "seccion":
+      if (id2 === SECCION_NUEVA) return null;
+      return { herramienta: "poner_seccion", argumentos: { nombre: id2.slice("seccion:".length) } };
+  }
+}
+function paletasParaBuscar() {
+  let acordes = [];
+  let secciones = [];
+  try {
+    const indice = indexar(obraAbierta().documento);
+    acordes = fichasDeAcordes(acordesUsados(indice)).filter((f) => f.id !== MIRA_DEDUCIR);
+    const nombres = [];
+    for (let i2 = 0; i2 < indice.cantidadDeCompases; i2++) {
+      nombres.push(String(indice.compasMaestro(i2)?.datos.seccion ?? ""));
+    }
+    secciones = fichasDeSecciones(nombres).filter((f) => f.id !== SECCION_NUEVA);
+  } catch {
+  }
+  return FAMILIAS.map((familia) => ({
+    familia,
+    fichas: familia === "acorde" ? acordes : familia === "seccion" ? secciones : fichasFijas(familia)
+  }));
+}
+function registrarHerramientasDePaletas(servidor2) {
+  servidor2.registerTool(
+    "buscar_en_las_paletas",
+    {
+      title: "Buscar en las paletas",
+      description: "Busca por nombre en las siete paletas del programa a la vez \u2014figuras, t\xE9cnicas, signos, acordes, bater\xEDa, matices y secciones\u2014 y dice qu\xE9 es cada resultado, en qu\xE9 paleta est\xE1, su tecla de f\xE1brica y **qu\xE9 herramienta lo escribe, con qu\xE9 argumentos**. Acepta sin\xF3nimos en espa\xF1ol y los nombres en ingl\xE9s de los programas: \xABligado\xBB, \xABhammer\xBB, \xABfermata\xBB, \xABhi-hat\xBB. Es la misma b\xFAsqueda de \xABEditar \u25B8 Buscar en las paletas\u2026\xBB. Sirve cuando no sabes la clave de algo: b\xFAscalo ac\xE1 y usa la herramienta que te indica, agregando d\xF3nde (comp\xE1s, golpe, pista\u2026).",
+      inputSchema: {
+        texto: external_exports.string().min(1).max(60).describe("Lo que se busca: \xABacento\xBB, \xABmartillo\xBB, \xABcorchea\xBB, \xABff\xBB\u2026"),
+        limite: external_exports.number().int().min(1).max(30).optional().describe("Cu\xE1ntos resultados, como mucho. Por omisi\xF3n 12.")
+      }
+    },
+    ({ texto: buscado, limite }) => {
+      const paletas = paletasParaBuscar();
+      const hayObra = paletas.some((p) => (p.familia === "acorde" || p.familia === "seccion") && p.fichas.length > 0);
+      const resultados = buscarEnLasPaletas(paletas, buscado, limite ?? 12).map((r) => {
+        const tecla = r.ficha.atajo ? ATAJOS.find((a) => a.id === r.ficha.atajo)?.teclas[0] : void 0;
+        return {
+          nombre: r.ficha.nombre,
+          paleta: NOMBRE_DE_LA_FAMILIA[r.familia],
+          ...tecla ? { teclaDeFabrica: comoSeLee(tecla) } : {},
+          ...herramientaDeLaFicha(r.familia, r.ficha) ?? {}
+        };
+      });
+      return texto2({
+        resultados,
+        // ⚠️ Un cero se tiene que poder leer como «no existe» y no como «no busqué».
+        ...resultados.length === 0 ? { nota: `nada se llama \xAB${buscado}\xBB en las paletas` } : {},
+        ...hayObra ? {} : { sinObra: "los acordes y las secciones salen de la obra: sin una abierta, no se buscan" },
+        teclas: "las teclas son las de f\xE1brica: el m\xFAsico pudo haberlas reasignado en su navegador"
+      });
+    }
+  );
+}
+
 // apps/mcp/src/servidor.ts
 var NOMBRE = "mandioca-tabs";
 var VERSION = VERSION_DEL_CONECTOR ?? "0.0.0";
@@ -128503,6 +129174,7 @@ function crearServidor() {
   registrarHerramientasDeBend(servidor2);
   registrarHerramientasDePistas(servidor2);
   registrarHerramientasDeArchivo(servidor2);
+  registrarHerramientasDePaletas(servidor2);
   return servidor2;
 }