mandioca-tabs-mcp 0.2.16 → 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();
@@ -16490,6 +16498,22 @@ var init_atajos = __esm({
       { id: "multipista", nombre: "Ver todas las pistas", grupo: "Vista y pistas" },
       { id: "una-pista", nombre: "Ver una sola pista", grupo: "Vista y pistas" },
       { id: "anacruza", nombre: "Anacruza ac\xE1", grupo: "Compases" },
+      // ★ La voz del cursor (2026-11-10). Sin tecla de fábrica: Alt+número está inerte a propósito.
+      { id: "voz-1", nombre: "Escribir en la voz 1", grupo: "Escribir notas" },
+      { id: "voz-2", nombre: "Escribir en la voz 2", grupo: "Escribir notas" },
+      { 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
@@ -16513,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) ────────────────────────────
@@ -16598,6 +16628,9 @@ var init_atajos = __esm({
       // ★ Agregado el 2026-09-03. Va en «Audio y mezcla» y no en un grupo propio porque es lo que
       //   uno prende para sincronizar a oído, junto al imán y a «oír el tramo».
       { id: "metronomo", nombre: "Metr\xF3nomo: marcar el pulso al reproducir", grupo: "Audio y mezcla" },
+      // ★ Agregados el 2026-11-10 (práctica). Sin tecla de fábrica: cada uno se la pone.
+      { id: "bucle", nombre: "Bucle: repetir el pasaje marcado o el comp\xE1s del cursor", grupo: "Audio y mezcla" },
+      { id: "cuenta-previa", nombre: "Cuenta previa: un comp\xE1s de clics antes de entrar", grupo: "Audio y mezcla" },
       { id: "oir-tramo", nombre: "O\xEDr la grabaci\xF3n desde el comp\xE1s del cursor", grupo: "Audio y mezcla" },
       { id: "anclar", nombre: "Anclar el comp\xE1s del cursor a la grabaci\xF3n", grupo: "Audio y mezcla" },
       { id: "desanclar", nombre: "Soltar el comp\xE1s del cursor de la grabaci\xF3n", grupo: "Audio y mezcla" },
@@ -16648,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."
       },
@@ -16781,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" };
   }
 });
 
@@ -20603,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";
   }
 });
 
@@ -20814,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 },
@@ -21292,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",
@@ -21374,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",
@@ -21631,6 +21926,28 @@ var init_barra = __esm({
         principiante: "Prende o apaga un clic que marca el pulso mientras suena la obra. Prendido, aparece tambi\xE9n en el mezclador con su propio volumen.",
         profesional: "Clic de metr\xF3nomo; volumen propio en el mezclador."
       },
+      "barra.bucle": {
+        nombre: "Bucle",
+        accion: "audio-bucle",
+        principiante: "Repite una y otra vez el pasaje que marcaste, o el comp\xE1s del cursor si no marcaste nada. Al lado del bot\xF3n se ven los compases que se repiten.",
+        profesional: "Loop del pasaje marcado o del comp\xE1s del cursor."
+      },
+      "barra.practica": {
+        nombre: "Pr\xE1ctica",
+        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.",
+        profesional: "Voz del cursor (1\u20134)."
+      },
       "barra.selector-sigue": {
         nombre: "El selector sigue a la reproducci\xF3n",
         principiante: "Prendido, el cursor de escritura acompa\xF1a a la m\xFAsica mientras suena. Apagado, el cursor se queda donde lo pusiste, y cada vez que aprietas play vuelve a sonar el mismo pasaje: sirve para practicar una parte.",
@@ -21686,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();
@@ -21694,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" },
@@ -21704,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,
@@ -21873,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",
@@ -22240,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.",
@@ -22464,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.",
@@ -22637,6 +23013,11 @@ var init_aspecto2 = __esm({
         principiante: "Marcado, la partitura muestra al principio la afinaci\xF3n de cada cuerda.",
         profesional: "Afinaci\xF3n en el pliego."
       },
+      "aspecto.diagramas": {
+        nombre: "Diagramas de acordes",
+        principiante: "Adem\xE1s del nombre (Am, G7\u2026), un cuadrito con los trastes de cada acorde: sobre la partitura o en una lista al comienzo. Salen de las notas que escribiste; si un nombre no est\xE1 escrito con notas en ning\xFAn lado, queda solo el nombre. De f\xE1brica, apagado.",
+        profesional: "Chord diagrams: en la partitura o arriba. Forma tomada de lo escrito."
+      },
       "aspecto.restablecer": {
         nombre: "Restablecer",
         principiante: "Devuelve esta secci\xF3n a como ven\xEDa de f\xE1brica. Las dem\xE1s secciones no se tocan.",
@@ -22999,6 +23380,7 @@ var init_src3 = __esm({
     init_silabas();
     init_acordes();
     init_miraDeAcordes();
+    init_paletasConTeclado();
     init_alinearLetra();
     init_diapason();
     init_video();
@@ -23080,7 +23462,7 @@ function _usingCtx() {
     }
   };
 }
-var __defProp2, __exportAll, ResizeObserverPolyfill, IntersectionObserverPolyfill, AlphaTabErrorType, AlphaTabError, VersionInfo, DynamicValue, MidiUtils, AutomationType, SyncPointData, Automation, BendPoint, BendStyle, BendType, BrushType, CrescendoType, Duration, GraceType, AccentuationType, Fingers, HarmonicType, NoteAccidentalMode, Ottavia, SlideInType, SlideOutType, Slur, SlurSegmentKind, VibratoType, TabRhythmMode, FingeringMode, NotationMode, NotationElement, NotationSettings, Lazy, LogLevel, ConsoleLogger, Logger, AccidentalType, Clef, SimileMark, ElementStyle, KeySignature, KeySignatureType, SustainPedalMarkerType, SustainPedalMarker, BarSubElement, BarStyle, BarLineStyle, Bar, TripletFeel, BeamingRules, MasterBar, BracketExtendMode, TrackNamePolicy, TrackNameMode, TrackNameOrientation, BarNumberDisplay, RenderStylesheet, RepeatGroup, GraceGroup, VoiceSubElement, VoiceStyle, Voice$1, TextAlign, TextBaseline, MeasuredText, CanvasHelper, ScoreSubElement, HeaderFooterStyle, ScoreStyle, Score, SynthConstants, TuningParseResult, TuningParseResultTone, ModelUtils, PickStroke, MusicFontSymbol, MusicFontSymbolLookup, TechniqueSymbolPlacement, InstrumentArticulation, PercussionMapper, NoteOrnament, NoteIdBag, NoteSubElement, NoteStyle, Note3, TupletGroup, WhammyType, GolpeType, FadeType, WahPedal, BarreShape, Rasgueado, TremoloPickingStyle, TremoloPickingEffect, BeatBeamingMode, BeatSubElement, BeatStyle, Beat, BendPointCloner, NoteCloner, SyncPointDataCloner, AutomationCloner, TremoloPickingEffectCloner, BeatCloner, AlphaTex1EnumMappings, AlphaTex1LanguageDefinitions, AlphaTexNodeType, AlphaTexDiagnosticsSeverity, AlphaTexDiagnosticCode, AlphaTexDiagnosticBag, AlphaTexAccidentalMode, AlphaTexVoiceMode, AlphaTexStaffNoteKind, ArgumentListParseTypesMode, TypeConversions, IOHelper, AlphaTexLexer, AlphaTexParseMode, AlphaTexParser, Atnf, AlphaTex1MetaDataReader, ApplyNodeResult, ApplyStructuralMetaDataResult, GeneralMidi, Chord3, FormatError, Color, FermataType, Fermata, Lyrics, Section, Tuning, Staff, PlaybackInformation, TrackSubElement, TrackStyle, Track, BeamDirection, AlphaTex1LanguageHandler, EndOfReaderError, OverflowError, ThrowingReadable, ScoreImporter, UnsupportedFormatError, ByteBuffer, AlphaTexErrorWithDiagnostics, AlphaTexImportState, AlphaTexImporter, Huffman$1, Found, NeedBit, NeedBits, HuffTools, InflateWindow, Inflate, ZipEntry, ZipReader, XmlNodeType, XmlNode, XmlError, XmlParser, XmlWriter, XmlDocument, DrawObject, TextDrawObject, GuitarDrawObject, SlurDrawObject, WavyLineDrawObject, TupletBracketDrawObject, WedgeDrawObject, VoltaDrawObject, OctaveClefDrawObject, TrillDrawObject, StaffLayout, Bracket, CapellaVoiceState, CapellaParser, CapellaImporter, Direction, Gp3To5Importer, GpBinaryHelpers, MixTableChange, Bounds, BinaryStylesheet, BackingTrack, GpifRhythm, GpifSound, GpifParser, PartConfigurationScoreView, PartConfigurationTrackViewGroup, PartConfiguration, LayoutConfigurationScoreView, LayoutConfigurationTrackViewGroup, LayoutConfiguration, Gp7To8Importer, BitReader, GpxFile, GpxFileSystem, GpxImporter, BeatSteps, AccidentalHelper, StaffContext, InstrumentArticulationWithPlaybackInfo, TrackInfo, MusicXmlImporter, LayoutMode, EventEmitter, EventEmitterOfT, AlphaSynthWebAudioSynthOutputDevice, WebAudioHelper, AlphaSynthWebAudioOutputBase, FileLoadError, EngravingSettingsCloner, JsonHelper, EngravingStemInfo, EngravingSettings, FontParserToken, FontParser, FontStyle, FontWeight, Font, RenderingResources, StaveProfile, SystemsLayoutMode, DisplaySettings, ImporterSettings, ScrollMode, VibratoPlaybackSettings, SlidePlaybackSettings, PlayerOutputMode, PlayerMode, PlayerSettings, CoreSettingsSerializer, EngravingStemInfoSerializer, EngravingSettingsSerializer, RenderingResourcesSerializer, DisplaySettingsSerializer, NotationSettingsSerializer, ImporterSettingsSerializer, VibratoPlaybackSettingsSerializer, SlidePlaybackSettingsSerializer, PlayerSettingsSerializer, ExporterSettingsSerializer, SettingsSerializer, ExporterSettings, Settings, ScoreLoader, BrowserMouseEventArgs, HtmlElementContainer, WebPlatform, FontSizeDefinition, FontSizes, FontLoadingChecker, CircularSampleBuffer, AlphaSynthScriptProcessorOutput, BeamingRulesSerializer, SectionSerializer, SyncPointDataSerializer, AutomationSerializer, FermataSerializer, MasterBarSerializer, BendPointSerializer, NoteStyleSerializer, NoteSerializer, TremoloPickingEffectSerializer, BeatStyleSerializer, BeatSerializer, VoiceStyleSerializer, VoiceSerializer, SustainPedalMarkerSerializer, BarStyleSerializer, BarSerializer, ChordSerializer, TuningSerializer, StaffSerializer, PlaybackInformationSerializer, InstrumentArticulationSerializer, TrackStyleSerializer, TrackSerializer, RenderStylesheetSerializer, BackingTrackSerializer, HeaderFooterStyleSerializer, ScoreStyleSerializer, ScoreSerializer, MidiFileFormat, MidiTrack, MidiFile, MidiEventType, MidiEvent, TimeSignatureEvent, AlphaTabSysExEvent, AlphaTabMetronomeEvent, AlphaTabRestEvent, NoteEvent, NoteOnEvent, NoteOffEvent, ControlChangeEvent, ProgramChangeEvent, TempoChangeEvent, PitchBendEvent, NoteBendEvent, EndOfTrackEvent, JsonConverter, MidiEventsPlayedEventArgs, PlaybackRangeChangedEventArgs, PlayerState, PlayerStateChangedEventArgs, PositionChangedEventArgs, AlphaSynthWebWorkerApi, BarBounds, BeatBounds, MasterBarBounds, NoteBounds, StaffSystemBounds, BoundsLookup, AlphaTabWorkerScoreRenderer, Cursors, ScalableHtmlElementContainer, AudioElementBackingTrackSynthOutput, QueueItem, Queue, AudioExportOptions, AudioExportChunk, SynthEvent, BackingTrackSyncPoint, MidiFileSequencerTempoChange, MidiSequencerState, MidiFileSequencer, RiffChunk, OggPacket, OggReader, VorbisStream, IntBitReaderReadResult, IntBitReader, VorbisSetupHeader, VorbisUtils, FastListArray, FastRange, VorbisCodebook, HuffmanListNode, Huffman, VorbisTimeDomainTransform, VorbisFloorData0, VorbisFloor0, VorbisFloor1Data, VorbisFloor1, VorbisFloor, VorbisResidue0, VorbisResidue1, VorbisResidue2, VorbisResidue, VorbisMapping, VorbisModeOverlapInfo, VorbisModePacketInfo, VorbisReadNextPacketResult, VorbisMode, MdctImpl, Mdct, VorbisStreamDecoder, DecodeNextPacketInfo, VorbisStreamReader, VorbisFile, Hydra, HydraIbag, HydraImod, HydraIgen, HydraInst, HydraPbag, HydraPgen, HydraPhdr, HydraPmod, HydraShdr, HydraGenAmount, Channel, Channels, LoopMode, OutputMode, Preset, SynthHelper, Envelope, Region, VoiceEnvelopeSegment, VoiceEnvelope, VoiceLfo, VoiceLowPass, Voice, ControllerType, TinySoundFont, AlphaSynthBase, AlphaSynth, AlphaSynthAudioExporter, BackingTrackAudioSynthesizer, BackingTrackPlayer, AlphaSynthAudioExporterWorkerApi, RenderFinishedEventArgs, ScoreRenderer, BrowserUiFacade, AlphaSynthWebWorklet, AlphaSynthAudioWorkletOutput, Html5Canvas, AlphaSynthMidiFileHandler, Repeat, MidiPlaybackController, BeatTickLookupItem, BeatTickLookup, MasterBarTickLookupTempoChange, MasterBarTickLookup, PlaybackRange, MidiTickLookupFindBeatResultCursorMode, MidiTickLookupFindBeatResult, TrackLookupBeatVisibilityChecker, MidiTickLookup, MidiNoteDuration, TripletFeelDurations, RasgueadoInfo, PlayThroughContext, MidiFileGenerator, ToNextBeatAnimatingCursorHandler, NonAnimatingCursorHandler, BeatXPosition, Glyph, BeatContainerGlyphBase, BeatContainerGlyph, ScoreRendererWrapper, ResizeEventArgs, BasicScrollHandler, VerticalContinuousScrollHandler, VerticalOffScreenScrollHandler, VerticalSmoothScrollHandler, HorizontalContinuousScrollHandler, HorizontalOffScreenScrollHandler, HorizontalSmoothScrollHandler, ActiveBeatsChangedEventArgs, AlphaSynthWrapper, ExternalMediaSynthOutput, ExternalMediaPlayer, BoundsLookupVisibilityChecker, AlphaTabApiBase, ProgressEventArgs, AlphaTabApi, JQueryAlphaTab, SkiaCanvas, SvgCanvas, CssFontSvgCanvas, AlphaSynthWorkerSynthOutput, AlphaSynthWebWorker, AlphaTabWebWorker, EffectBandMode, BarRendererFactory, EffectBarGlyphSizing, EffectGlyph, AlternateEndingsGlyph, EffectInfo, AlternateEndingsEffectInfo, GroupedEffectGlyph, LineRangedGlyph, BeatBarreEffectInfo, BeatTimerGlyph, BeatTimerEffectInfo, TextGlyph, CapoEffectInfo, ChordDiagramGlyph, ChordsEffectInfo, CrescendoGlyph, CrescendoEffectInfo, TargetDirectionGlyph, JumpDirectionGlyph, DirectionsContainerGlyph, DirectionsEffectInfo, MusicFontGlyph, MusicFontTextGlyph, DynamicsGlyph, DynamicsEffectInfo, FadeGlyph, FadeEffectInfo, FermataGlyph, FermataEffectInfo, GlyphGroup, ElementStyleHelper, ElementStyleScope, FingeringInfo, FingeringGroupGlyph, FingeringEffectInfo, FreeTimeEffectInfo, GuitarGolpeGlyph, GolpeEffectInfo, NoteEffectInfoBase, HarmonicsEffectInfo, LeftHandTapGlyph, LeftHandTapEffectInfo, LetRingEffectInfo, LyricsGlyph, LyricsEffectInfo, MarkerEffectInfo, NoteOrnamentGlyph, NoteOrnamentEffectInfo, AccidentalGlyph, NumberedKeySignatureGlyph, NumberedBarKeySignatureEffectInfo, OttavaGlyph, OttaviaEffectInfo, PalmMuteEffectInfo, PickSlideEffectInfo, PickStrokeGlyph, PickStrokeEffectInfo, RasgueadoEffectInfo, EffectBand, EffectBandSlotShared, EffectBandSlot, EffectBandSizingInfo, EffectBandContainer, LeftToRightLayoutingGlyphGroup, MultiVoiceContainerGlyph, TieGlyph, NoteTieGlyph, ContinuationTieGlyph, NumberGlyph, MultiBarRestGlyph, MultiBarRestBeatContainerGlyph, BeamingHelperDrawInfo, BeamingHelper, ReservedLayoutAreaSlot, ReservedLayoutArea, BarCollisionHelper, BeamingRuleLookup, BarHelpers, NoteYPosition, NoteXPosition, BarRendererBase, VibratoGlyphBase, NoteVibratoGlyph, TabBendRenderPoint, TabBendGlyph, TabWhammyBarGlyph, SimpleDipWhammyBarEffectInfo, BeatVibratoGlyph, SlightBeatVibratoEffectInfo, SlightNoteVibratoEffectInfo, SustainPedalGlyph, SustainPedalEffectInfo, TabWhammyEffectInfo, TapEffectInfo, BarTempoGlyph, TempoEffectInfo, TextEffectInfo, TrillGlyph, TrillEffectInfo, TripletFeelGlyph, TripletFeelEffectInfo, WahPedalGlyph, WahPedalEffectInfo, WhammyBarEffectInfo, WideBeatVibratoEffectInfo, WideNoteVibratoEffectInfo, RowGlyphContainer, RowContainerGlyph, ChordDiagramContainerGlyph, TuningContainerGlyph, TuningGlyph, SlurRegistry, RenderStaff, Spring, BarLayoutingInfo, MasterBarsRenderers, StaffTrackGroup, SystemBracket, SingleTrackSystemBracket, SimilarInstrumentSystemBracket, StaffSystem, ScoreLayout, HorizontalScreenLayoutPartialInfo, HorizontalScreenLayout, VerticalLayoutBase, PageViewLayout, ParchmentLayout, BarLineGlyphBase, BarLineLightGlyph, BarLineDottedGlyph, BarLineDashedGlyph, BarLineHeavyGlyph, BarLineRepeatDotsGlyph, BarLineShortGlyph, BarLineTickGlyph, BarLineGlyph, BarNumberGlyph, NumberedTieGlyph, AccidentalColumnInfo, AccidentalGroupGlyph, AugmentationDotGlyph, BeatGlyphBase, BeatOnNoteGlyphBase, DeadSlappedBeatGlyph, NumberedNoteHeadGlyph, SpacingGlyph, NumberedBeatPreNotesGlyph, NumberedBeatGlyph, TabTieGlyph, TieGlyphLabels, TabSlurGlyph, NumberedSlurGlyph, NumberedBeatContainerGlyph, NumberedNoteBeatContainerGlyphBase, NumberedDashBeatContainerGlyph, GhostParenthesisGlyph, TimeSignatureGlyph, ScoreTimeSignatureGlyph, FlagGlyph, RepeatCountGlyph, LineBarRenderer, NumberedBarRenderer, NumberedBarRendererFactory, ClefGlyph, KeySignatureGlyph, AccentuationGlyph, ArticStaccatoAboveGlyph, NoteHeadGlyphBase, NoteHeadGlyph, DeadNoteHeadGlyph, DiamondNoteHeadGlyph, GhostNoteInfo, GhostNoteContainerGlyph, PercussionNoteHeadGlyph, PictEdgeOfCymbalGlyph, ScoreChordNoteHeadInfo, ScoreNoteChordGlyphBase, TremoloPickingGlyph, ScoreNoteChordGlyph, ScoreRestGlyph, BendNoteHeadGroupGlyph, ScoreHelperNotesBaseGlyph, ScoreWhammyBarGlyph, SlashNoteHeadGlyph, StringNumberContainerGlyph, ScoreBeatGlyph, ScoreBrushGlyph, ScoreBeatPreNotesGlyph, ScoreBendGlyph, ScoreLegatoGlyph, ScoreSlideLineGlyph, ScoreTieGlyph, ScoreSlurGlyph, ScoreBeatContainerGlyph, ScoreBarRenderer, ScoreBarRendererFactory, SlashRestGlyph, SlashBeatGlyph, SlashTieGlyph, SlashBeatContainerGlyph, SlashBarRenderer, SlashBarRendererFactory, NoteNumberGlyph, TabNoteChordGlyph, TabRestGlyph, TabBeatGlyph, TabBrushGlyph, TabBeatPreNotesGlyph, TabSlideLineGlyph, TabBeatContainerGlyph, TabClefGlyph, TabTimeSignatureGlyph, TabBarRenderer, TabBarRendererFactory, LayoutEngineFactory, RenderEngineFactory, Environment, FontFileFormat, CoreSettings, _barrel_exports$8, _barrel_exports$1, ScoreExporter, AlphaTexWriter, AlphaTexPrinter, AlphaTexExporter, GpifMidiProgramInfo, GpifInstrumentSet, GpifInstrumentElement, GpifInstrumentArticulation, GpifSoundMapper, GpifWriter, Crc32, DeflaterConstants, Tree, DeflaterHuffman, DeflaterEngine, PendingBuffer, Deflater, ZipCentralDirectoryHeader, ZipWriter, Gp7Exporter, _barrel_exports, DeprecatedMidiEvent, MetaEventType, MetaEvent, MetaDataEvent, MetaNumberEvent, Midi20PerNotePitchBendEvent, SystemCommonType, SystemCommonEvent, AlphaTabSystemExclusiveEvents, SystemExclusiveEvent, _barrel_exports$3, _barrel_exports$4;
+var __defProp2, __exportAll, ResizeObserverPolyfill, IntersectionObserverPolyfill, AlphaTabErrorType, AlphaTabError, VersionInfo, DynamicValue, MidiUtils, AutomationType, SyncPointData, Automation, BendPoint, BendStyle, BendType, BrushType, CrescendoType, Duration, GraceType, AccentuationType, Fingers, HarmonicType, NoteAccidentalMode, Ottavia, SlideInType, SlideOutType, Slur, SlurSegmentKind, VibratoType, TabRhythmMode, FingeringMode, NotationMode, NotationElement, NotationSettings, Lazy, LogLevel, ConsoleLogger, Logger, AccidentalType, Clef, SimileMark, ElementStyle, KeySignature, KeySignatureType, SustainPedalMarkerType, SustainPedalMarker, BarSubElement, BarStyle, BarLineStyle, Bar, TripletFeel, BeamingRules, MasterBar, BracketExtendMode, TrackNamePolicy, TrackNameMode, TrackNameOrientation, BarNumberDisplay, RenderStylesheet, RepeatGroup, GraceGroup, VoiceSubElement, VoiceStyle, Voice$1, TextAlign, TextBaseline, MeasuredText, CanvasHelper, ScoreSubElement, HeaderFooterStyle, ScoreStyle, Score, SynthConstants, TuningParseResult, TuningParseResultTone, ModelUtils, PickStroke, MusicFontSymbol, MusicFontSymbolLookup, TechniqueSymbolPlacement, InstrumentArticulation, PercussionMapper, NoteOrnament, NoteIdBag, NoteSubElement, NoteStyle, Note3, TupletGroup, WhammyType, GolpeType, FadeType, WahPedal, BarreShape, Rasgueado, TremoloPickingStyle, TremoloPickingEffect, BeatBeamingMode, BeatSubElement, BeatStyle, Beat, BendPointCloner, NoteCloner, SyncPointDataCloner, AutomationCloner, TremoloPickingEffectCloner, BeatCloner, AlphaTex1EnumMappings, AlphaTex1LanguageDefinitions, AlphaTexNodeType, AlphaTexDiagnosticsSeverity, AlphaTexDiagnosticCode, AlphaTexDiagnosticBag, AlphaTexAccidentalMode, AlphaTexVoiceMode, AlphaTexStaffNoteKind, ArgumentListParseTypesMode, TypeConversions, IOHelper, AlphaTexLexer, AlphaTexParseMode, AlphaTexParser, Atnf, AlphaTex1MetaDataReader, ApplyNodeResult, ApplyStructuralMetaDataResult, GeneralMidi, Chord3, FormatError, Color, FermataType, Fermata, Lyrics, Section, Tuning, Staff, PlaybackInformation, TrackSubElement, TrackStyle, Track, BeamDirection, AlphaTex1LanguageHandler, EndOfReaderError, OverflowError, ThrowingReadable, ScoreImporter, UnsupportedFormatError, ByteBuffer, AlphaTexErrorWithDiagnostics, AlphaTexImportState, AlphaTexImporter, Huffman$1, Found, NeedBit, NeedBits, HuffTools, InflateWindow, Inflate, ZipEntry, ZipReader, XmlNodeType, XmlNode, XmlError, XmlParser, XmlWriter, XmlDocument, DrawObject, TextDrawObject, GuitarDrawObject, SlurDrawObject, WavyLineDrawObject, TupletBracketDrawObject, WedgeDrawObject, VoltaDrawObject, OctaveClefDrawObject, TrillDrawObject, StaffLayout, Bracket, CapellaVoiceState, CapellaParser, CapellaImporter, Direction, Gp3To5Importer, GpBinaryHelpers, MixTableChange, Bounds, BinaryStylesheet, BackingTrack, GpifRhythm, GpifSound, GpifParser, PartConfigurationScoreView, PartConfigurationTrackViewGroup, PartConfiguration, LayoutConfigurationScoreView, LayoutConfigurationTrackViewGroup, LayoutConfiguration, Gp7To8Importer, BitReader, GpxFile, GpxFileSystem, GpxImporter, BeatSteps, AccidentalHelper, StaffContext, InstrumentArticulationWithPlaybackInfo, TrackInfo, MusicXmlImporter, LayoutMode, EventEmitter, EventEmitterOfT, AlphaSynthWebAudioSynthOutputDevice, WebAudioHelper, AlphaSynthWebAudioOutputBase, FileLoadError, EngravingSettingsCloner, JsonHelper, EngravingStemInfo, EngravingSettings, FontParserToken, FontParser, FontStyle, FontWeight, Font, RenderingResources, StaveProfile, SystemsLayoutMode, DisplaySettings, ImporterSettings, ScrollMode, VibratoPlaybackSettings, SlidePlaybackSettings, PlayerOutputMode, PlayerMode, PlayerSettings, CoreSettingsSerializer, EngravingStemInfoSerializer, EngravingSettingsSerializer, RenderingResourcesSerializer, DisplaySettingsSerializer, NotationSettingsSerializer, ImporterSettingsSerializer, VibratoPlaybackSettingsSerializer, SlidePlaybackSettingsSerializer, PlayerSettingsSerializer, ExporterSettingsSerializer, SettingsSerializer, ExporterSettings, Settings, ScoreLoader, BrowserMouseEventArgs, HtmlElementContainer, WebPlatform, FontSizeDefinition, FontSizes, FontLoadingChecker, CircularSampleBuffer, AlphaSynthScriptProcessorOutput, BeamingRulesSerializer, SectionSerializer, SyncPointDataSerializer, AutomationSerializer, FermataSerializer, MasterBarSerializer, BendPointSerializer, NoteStyleSerializer, NoteSerializer, TremoloPickingEffectSerializer, BeatStyleSerializer, BeatSerializer, VoiceStyleSerializer, VoiceSerializer, SustainPedalMarkerSerializer, BarStyleSerializer, BarSerializer, ChordSerializer, TuningSerializer, StaffSerializer, PlaybackInformationSerializer, InstrumentArticulationSerializer, TrackStyleSerializer, TrackSerializer, RenderStylesheetSerializer, BackingTrackSerializer, HeaderFooterStyleSerializer, ScoreStyleSerializer, ScoreSerializer, MidiFileFormat, MidiTrack, MidiFile, MidiEventType, MidiEvent, TimeSignatureEvent, AlphaTabSysExEvent, AlphaTabMetronomeEvent, AlphaTabRestEvent, NoteEvent, NoteOnEvent, NoteOffEvent, ControlChangeEvent, ProgramChangeEvent, TempoChangeEvent, PitchBendEvent, NoteBendEvent, EndOfTrackEvent, JsonConverter, MidiEventsPlayedEventArgs, PlaybackRangeChangedEventArgs, PlayerState, PlayerStateChangedEventArgs, PositionChangedEventArgs, AlphaSynthWebWorkerApi, BarBounds, BeatBounds, MasterBarBounds, NoteBounds, StaffSystemBounds, BoundsLookup, AlphaTabWorkerScoreRenderer, Cursors, ScalableHtmlElementContainer, AudioElementBackingTrackSynthOutput, QueueItem, Queue, AudioExportOptions, AudioExportChunk, SynthEvent, BackingTrackSyncPoint, MidiFileSequencerTempoChange, MidiSequencerState, MidiFileSequencer, RiffChunk, OggPacket, OggReader, VorbisStream, IntBitReaderReadResult, IntBitReader, VorbisSetupHeader, VorbisUtils, FastListArray, FastRange, VorbisCodebook, HuffmanListNode, Huffman, VorbisTimeDomainTransform, VorbisFloorData0, VorbisFloor0, VorbisFloor1Data, VorbisFloor1, VorbisFloor, VorbisResidue0, VorbisResidue1, VorbisResidue2, VorbisResidue, VorbisMapping, VorbisModeOverlapInfo, VorbisModePacketInfo, VorbisReadNextPacketResult, VorbisMode, MdctImpl, Mdct, VorbisStreamDecoder, DecodeNextPacketInfo, VorbisStreamReader, VorbisFile, Hydra, HydraIbag, HydraImod, HydraIgen, HydraInst, HydraPbag, HydraPgen, HydraPhdr, HydraPmod, HydraShdr, HydraGenAmount, Channel, Channels, LoopMode, OutputMode, Preset, SynthHelper, Envelope, Region, VoiceEnvelopeSegment, VoiceEnvelope, VoiceLfo, VoiceLowPass, Voice, ControllerType, TinySoundFont, AlphaSynthBase, AlphaSynth, AlphaSynthAudioExporter, BackingTrackAudioSynthesizer, BackingTrackPlayer, AlphaSynthAudioExporterWorkerApi, RenderFinishedEventArgs, ScoreRenderer, BrowserUiFacade, AlphaSynthWebWorklet, AlphaSynthAudioWorkletOutput, Html5Canvas, AlphaSynthMidiFileHandler, Repeat, MidiPlaybackController, BeatTickLookupItem, BeatTickLookup, MasterBarTickLookupTempoChange, MasterBarTickLookup, PlaybackRange, MidiTickLookupFindBeatResultCursorMode, MidiTickLookupFindBeatResult, TrackLookupBeatVisibilityChecker, MidiTickLookup, MidiNoteDuration, TripletFeelDurations, RasgueadoInfo, PlayThroughContext, MidiFileGenerator, ToNextBeatAnimatingCursorHandler, NonAnimatingCursorHandler, BeatXPosition, Glyph, BeatContainerGlyphBase, BeatContainerGlyph, ScoreRendererWrapper, ResizeEventArgs, BasicScrollHandler, VerticalContinuousScrollHandler, VerticalOffScreenScrollHandler, VerticalSmoothScrollHandler, HorizontalContinuousScrollHandler, HorizontalOffScreenScrollHandler, HorizontalSmoothScrollHandler, ActiveBeatsChangedEventArgs, AlphaSynthWrapper, ExternalMediaSynthOutput, ExternalMediaPlayer, BoundsLookupVisibilityChecker, AlphaTabApiBase, ProgressEventArgs, AlphaTabApi, JQueryAlphaTab, SkiaCanvas, SvgCanvas, CssFontSvgCanvas, AlphaSynthWorkerSynthOutput, AlphaSynthWebWorker, AlphaTabWebWorker, EffectBandMode, BarRendererFactory, EffectBarGlyphSizing, EffectGlyph, AlternateEndingsGlyph, EffectInfo, AlternateEndingsEffectInfo, GroupedEffectGlyph, LineRangedGlyph, BeatBarreEffectInfo, BeatTimerGlyph, BeatTimerEffectInfo, TextGlyph, CapoEffectInfo, ChordDiagramGlyph, ChordsEffectInfo, CrescendoGlyph, CrescendoEffectInfo, TargetDirectionGlyph, JumpDirectionGlyph, DirectionsContainerGlyph, DirectionsEffectInfo, MusicFontGlyph, MusicFontTextGlyph, DynamicsGlyph, DynamicsEffectInfo, FadeGlyph, FadeEffectInfo, FermataGlyph, FermataEffectInfo, GlyphGroup, ElementStyleHelper, ElementStyleScope, FingeringInfo, FingeringGroupGlyph, FingeringEffectInfo, FreeTimeEffectInfo, GuitarGolpeGlyph, GolpeEffectInfo, NoteEffectInfoBase, HarmonicsEffectInfo, LeftHandTapGlyph, LeftHandTapEffectInfo, LetRingEffectInfo, LyricsGlyph, LyricsEffectInfo, MarkerEffectInfo, NoteOrnamentGlyph, NoteOrnamentEffectInfo, AccidentalGlyph, NumberedKeySignatureGlyph, NumberedBarKeySignatureEffectInfo, OttavaGlyph, OttaviaEffectInfo, PalmMuteEffectInfo, PickSlideEffectInfo, PickStrokeGlyph, PickStrokeEffectInfo, RasgueadoEffectInfo, EffectBand, EffectBandSlotShared, EffectBandSlot, EffectBandSizingInfo, EffectBandContainer, LeftToRightLayoutingGlyphGroup, MultiVoiceContainerGlyph, TieGlyph, NoteTieGlyph, ContinuationTieGlyph, NumberGlyph, MultiBarRestGlyph, MultiBarRestBeatContainerGlyph, BeamingHelperDrawInfo, BeamingHelper, ReservedLayoutAreaSlot, ReservedLayoutArea, BarCollisionHelper, BeamingRuleLookup, BarHelpers, NoteYPosition, NoteXPosition, BarRendererBase, VibratoGlyphBase, NoteVibratoGlyph, TabBendRenderPoint, TabBendGlyph, TabWhammyBarGlyph, SimpleDipWhammyBarEffectInfo, BeatVibratoGlyph, SlightBeatVibratoEffectInfo, SlightNoteVibratoEffectInfo, SustainPedalGlyph, SustainPedalEffectInfo, TabWhammyEffectInfo, TapEffectInfo, BarTempoGlyph, TempoEffectInfo, TextEffectInfo, TrillGlyph, TrillEffectInfo, TripletFeelGlyph, TripletFeelEffectInfo, WahPedalGlyph, WahPedalEffectInfo, WhammyBarEffectInfo, WideBeatVibratoEffectInfo, WideNoteVibratoEffectInfo, RowGlyphContainer, RowContainerGlyph, ChordDiagramContainerGlyph, TuningContainerGlyph, TuningGlyph, SlurRegistry, RenderStaff, Spring, BarLayoutingInfo, MasterBarsRenderers, StaffTrackGroup, SystemBracket, SingleTrackSystemBracket, SimilarInstrumentSystemBracket, StaffSystem, ScoreLayout, HorizontalScreenLayoutPartialInfo, HorizontalScreenLayout, VerticalLayoutBase, PageViewLayout, ParchmentLayout, BarLineGlyphBase, BarLineLightGlyph, BarLineDottedGlyph, BarLineDashedGlyph, BarLineHeavyGlyph, BarLineRepeatDotsGlyph, BarLineShortGlyph, BarLineTickGlyph, BarLineGlyph, BarNumberGlyph, NumberedTieGlyph, AccidentalColumnInfo, AccidentalGroupGlyph, AugmentationDotGlyph, BeatGlyphBase, BeatOnNoteGlyphBase, DeadSlappedBeatGlyph, NumberedNoteHeadGlyph, SpacingGlyph, NumberedBeatPreNotesGlyph, NumberedBeatGlyph, TabTieGlyph, TieGlyphLabels, TabSlurGlyph, NumberedSlurGlyph, NumberedBeatContainerGlyph, NumberedNoteBeatContainerGlyphBase, NumberedDashBeatContainerGlyph, GhostParenthesisGlyph, TimeSignatureGlyph, ScoreTimeSignatureGlyph, FlagGlyph, RepeatCountGlyph, LineBarRenderer, NumberedBarRenderer, NumberedBarRendererFactory, ClefGlyph, KeySignatureGlyph, AccentuationGlyph, ArticStaccatoAboveGlyph, NoteHeadGlyphBase, NoteHeadGlyph, DeadNoteHeadGlyph, DiamondNoteHeadGlyph, GhostNoteInfo, GhostNoteContainerGlyph, PercussionNoteHeadGlyph, PictEdgeOfCymbalGlyph, ScoreChordNoteHeadInfo, ScoreNoteChordGlyphBase, TremoloPickingGlyph, ScoreNoteChordGlyph, ScoreRestGlyph, BendNoteHeadGroupGlyph, ScoreHelperNotesBaseGlyph, ScoreWhammyBarGlyph, SlashNoteHeadGlyph, StringNumberContainerGlyph, ScoreBeatGlyph, ScoreBrushGlyph, ScoreBeatPreNotesGlyph, ScoreBendGlyph, ScoreLegatoGlyph, ScoreSlideLineGlyph, ScoreTieGlyph, ScoreSlurGlyph, ScoreBeatContainerGlyph, ScoreBarRenderer, ScoreBarRendererFactory, SlashRestGlyph, SlashBeatGlyph, SlashTieGlyph, SlashBeatContainerGlyph, SlashBarRenderer, SlashBarRendererFactory, NoteNumberGlyph, TabNoteChordGlyph, TabRestGlyph, TabBeatGlyph, TabBrushGlyph, TabBeatPreNotesGlyph, TabSlideLineGlyph, TabBeatContainerGlyph, TabClefGlyph, TabTimeSignatureGlyph, TabBarRenderer, TabBarRendererFactory, LayoutEngineFactory, RenderEngineFactory, Environment, FontFileFormat, CoreSettings, _barrel_exports$8, _barrel_exports$1, ScoreExporter, AlphaTexWriter, AlphaTexPrinter, AlphaTexExporter, GpifMidiProgramInfo, GpifInstrumentSet, GpifInstrumentElement, GpifInstrumentArticulation, GpifSoundMapper, GpifWriter, Crc32, DeflaterConstants, Tree, DeflaterHuffman, DeflaterEngine, PendingBuffer, Deflater, ZipCentralDirectoryHeader, ZipWriter, Gp7Exporter, _barrel_exports, DeprecatedMidiEvent, MetaEventType, MetaEvent, MetaDataEvent, MetaNumberEvent, Midi20PerNotePitchBendEvent, SystemCommonType, SystemCommonEvent, AlphaTabSystemExclusiveEvents, SystemExclusiveEvent, _barrel_exports$3, _barrel_exports$4, _barrel_exports$7;
 var init_alphaTab_core = __esm({
   "node_modules/@coderline/alphatab/dist/alphaTab.core.mjs"() {
     __defProp2 = Object.defineProperty;
@@ -87539,6 +87921,25 @@ ${AlphaTex1MetaDataReader.generateSignatures(signatures)}`,
       WahPedal: () => WahPedal,
       WhammyType: () => WhammyType
     });
+    _barrel_exports$7 = /* @__PURE__ */ __exportAll({
+      ActiveBeatsChangedEventArgs: () => ActiveBeatsChangedEventArgs,
+      AlphaSynth: () => AlphaSynth,
+      AlphaSynthAudioWorkletOutput: () => AlphaSynthAudioWorkletOutput,
+      AlphaSynthBase: () => AlphaSynthBase,
+      AlphaSynthScriptProcessorOutput: () => AlphaSynthScriptProcessorOutput,
+      AlphaSynthWebAudioOutputBase: () => AlphaSynthWebAudioOutputBase,
+      AlphaSynthWebWorkerApi: () => AlphaSynthWebWorkerApi,
+      AudioExportChunk: () => AudioExportChunk,
+      AudioExportOptions: () => AudioExportOptions,
+      BackingTrackSyncPoint: () => BackingTrackSyncPoint,
+      CircularSampleBuffer: () => CircularSampleBuffer,
+      MidiEventsPlayedEventArgs: () => MidiEventsPlayedEventArgs,
+      PlaybackRange: () => PlaybackRange,
+      PlaybackRangeChangedEventArgs: () => PlaybackRangeChangedEventArgs,
+      PlayerState: () => PlayerState,
+      PlayerStateChangedEventArgs: () => PlayerStateChangedEventArgs,
+      PositionChangedEventArgs: () => PositionChangedEventArgs
+    });
   }
 });
 
@@ -87600,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) {
@@ -88581,280 +89127,839 @@ 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);
-          }
+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>");
+        }
+        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>");
+        }
+        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>");
+  }
+  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, D, SALTOS, claveDeSalto, SALTO_POR_CLAVE;
+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 };
+    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/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);
+}
+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 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.`
+    );
+  }
+  if (acordesSeparados) {
+    correcciones.push(`${acordesSeparados} notas de acordes repartidos entre los dos pentagramas se pusieron en el suyo.`);
+  }
+  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") {
@@ -88911,12 +90016,13 @@ function leerDelArchivo(xml) {
       }
     }
   }
-  return { ortografia, bajos, matices };
+  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,
@@ -88969,7 +90075,7 @@ function importarGp(bytes, 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 });
+  const resultado = importarScore(score, opciones, { ortografia: leido.ortografia, bajos: leido.bajos, matices: leido.matices, saltos: leido.saltos });
   resultado.avisos.push(...preparado.correcciones);
   return resultado;
 }
@@ -89046,7 +90152,11 @@ function importarScore(score, opciones = {}, datos = {}) {
       //
       // ★ 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(
+      //
+      // ⛔ (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)
       ) : []
     }))
@@ -89309,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();
@@ -89426,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,
@@ -89497,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],
@@ -89507,644 +90625,1581 @@ 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, "");
   }
 });
 
-// packages/io/src/archivoMtabs.ts
-function formatoQueNecesita(documento) {
-  for (const pista of documento.pistas.values()) {
-    const transposicion = pista.get("transposicion");
-    if (typeof transposicion === "number" && transposicion !== 0) return 6;
-  }
-  for (const nota of documento.notas.values()) {
-    const v = nota.get("armonicoValor");
-    if (typeof v === "number" && v !== 0) return 6;
-  }
-  for (const figura of documento.figuras.values()) {
-    if (figura.get("octava") !== void 0 || figura.get("tempo") !== void 0) return 6;
-  }
-  for (const pista of documento.pistas.values()) {
-    const pentagramas = pista.get("pentagramas");
-    if (typeof pentagramas === "number" && pentagramas > 1) return 5;
-  }
-  return 4;
+// packages/io/src/importarMidi.ts
+function esMidi(bytes) {
+  return firmaEn(bytes, 0, "MThd") || firmaEn(bytes, 0, "RIFF") && firmaEn(bytes, 8, "RMID");
+}
+function importarMidi(bytes, opciones = {}) {
+  const smf = leerSmf(bytes);
+  const avisos = new Avisos();
+  const leido = recolectar(smf, avisos);
+  const score = armarScore(leido, opciones, avisos);
+  const resultado = importarScore(score, opciones);
+  resultado.avisos = resultado.avisos.filter((a) => !a.startsWith("Las preferencias de dibujo del archivo"));
+  resultado.avisos.push(...avisos.lista());
+  return resultado;
 }
-function empaquetar(documento, opciones = {}) {
-  const grabaciones = opciones.grabaciones ?? [];
-  const fuentes = opciones.fuentes ?? [];
-  const manifiesto = {
-    formato: formatoQueNecesita(documento),
-    aplicacion: opciones.aplicacion ?? "Mandioca Tabs",
-    guardado: opciones.guardado ?? "",
-    titulo: documento.cabecera.get("titulo") ?? "",
-    artista: documento.cabecera.get("artista") ?? "",
-    audios: grabaciones.map((g) => g.fuenteId),
-    fuentes: fuentes.map((f) => f.tipografiaId)
+function firmaEn(bytes, desde, firma) {
+  if (bytes.length < desde + firma.length) return false;
+  for (let i2 = 0; i2 < firma.length; i2++) if (bytes[desde + i2] !== firma.charCodeAt(i2)) return false;
+  return true;
+}
+function desenvolverRmid(bytes) {
+  if (!(firmaEn(bytes, 0, "RIFF") && firmaEn(bytes, 8, "RMID"))) return bytes;
+  const vista = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let pos = 12;
+  while (pos + 8 <= bytes.length) {
+    const largo = vista.getUint32(pos + 4, true);
+    if (firmaEn(bytes, pos, "data")) {
+      if (pos + 8 + largo > bytes.length) throw truncado("el bloque \xABdata\xBB del RMID");
+      return bytes.subarray(pos + 8, pos + 8 + largo);
+    }
+    pos += 8 + largo + largo % 2;
+  }
+  throw new MidiIlegible("El archivo RMID no tiene adentro un bloque de datos MIDI.");
+}
+function leerSmf(entrada) {
+  const bytes = desenvolverRmid(entrada);
+  if (!firmaEn(bytes, 0, "MThd")) {
+    throw new MidiIlegible("El archivo no es un MIDI: no empieza con la firma \xABMThd\xBB.");
+  }
+  if (bytes.length < 14) throw truncado("la cabecera");
+  const vista = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const largoDeCabecera = vista.getUint32(4);
+  if (largoDeCabecera < 6) throw new MidiIlegible("La cabecera del MIDI es m\xE1s corta de lo que manda el formato.");
+  if (8 + largoDeCabecera > bytes.length) throw truncado("la cabecera");
+  const formato = vista.getUint16(8);
+  const declaradas = vista.getUint16(10);
+  const division = vista.getUint16(12);
+  let smpte = null;
+  if (division & 32768) {
+    const cuadros = -(division >> 8 << 24 >> 24);
+    smpte = { cuadrosPorSegundo: cuadros === 29 ? 29.97 : cuadros, ticsPorCuadro: division & 255 };
+    if (smpte.cuadrosPorSegundo <= 0 || smpte.ticsPorCuadro === 0) {
+      throw new MidiIlegible("La cabecera del MIDI declara una divisi\xF3n de tiempo imposible.");
+    }
+  } else if (division === 0) {
+    throw new MidiIlegible("La cabecera del MIDI declara 0 tics por negra.");
+  }
+  const pistas = [];
+  let pos = 8 + largoDeCabecera;
+  while (pistas.length < declaradas) {
+    if (pos + 8 > bytes.length) {
+      throw truncado(`la cabecera anuncia ${declaradas} pista(s) y s\xF3lo hay ${pistas.length}`);
+    }
+    const largo = vista.getUint32(pos + 4);
+    const esPista = firmaEn(bytes, pos, "MTrk");
+    pos += 8;
+    if (pos + largo > bytes.length) throw truncado(`la pista ${pistas.length + 1}`);
+    if (esPista) pistas.push(leerPista(bytes.subarray(pos, pos + largo), pistas.length + 1));
+    pos += largo;
+  }
+  return { formato, division, smpte, pistas };
+}
+function leerPista(datos, numero2) {
+  let p = 0;
+  let tic = 0;
+  let estado = 0;
+  const eventos = [];
+  const byte = () => {
+    if (p >= datos.length) throw truncado(`un evento a medias en la pista ${numero2}`);
+    return datos[p++];
   };
-  const entradas = {
-    [MANIFIESTO]: new TextEncoder().encode(JSON.stringify(manifiesto, null, 2)),
-    [DOCUMENTO]: documento.aBytes()
+  const largoVariable = () => {
+    let valor = 0;
+    for (let i2 = 0; i2 < 4; i2++) {
+      const b = byte();
+      valor = valor * 128 + (b & 127);
+      if (!(b & 128)) return valor;
+    }
+    throw new MidiIlegible(`La pista ${numero2} trae un n\xFAmero de m\xE1s de 4 bytes: el archivo est\xE1 da\xF1ado.`);
   };
-  for (const g of grabaciones) {
-    entradas[`${CARPETA_DE_AUDIO}${g.fuenteId}`] = g.bytes;
-  }
-  for (const f of fuentes) {
-    entradas[`${CARPETA_DE_FUENTES}${f.tipografiaId}`] = f.bytes;
+  const tomar = (n) => {
+    if (p + n > datos.length) throw truncado(`un evento a medias en la pista ${numero2}`);
+    const trozo = datos.subarray(p, p + n);
+    p += n;
+    return trozo;
+  };
+  while (p < datos.length) {
+    tic += largoVariable();
+    let b = byte();
+    if (b === 255) {
+      const meta3 = byte();
+      const contenido = tomar(largoVariable());
+      if (meta3 === 47) break;
+      eventos.push({ tipo: "meta", tic, meta: meta3, datos: contenido });
+      continue;
+    }
+    if (b === 240 || b === 247) {
+      tomar(largoVariable());
+      eventos.push({ tipo: "sysex", tic });
+      continue;
+    }
+    let dato1;
+    if (b < 128) {
+      if (!estado) throw new MidiIlegible(`La pista ${numero2} trae datos sin un evento que los explique: el archivo est\xE1 da\xF1ado.`);
+      dato1 = b;
+      b = estado;
+    } else {
+      if (b >= 240) throw new MidiIlegible(`La pista ${numero2} trae un mensaje de sistema que no puede ir en un archivo (0x${b.toString(16)}).`);
+      estado = b;
+      dato1 = byte();
+    }
+    const canal = b & 15;
+    switch (b & 240) {
+      case 128:
+        byte();
+        eventos.push({ tipo: "nota", tic, canal, altura: dato1 & 127, velocidad: 0 });
+        break;
+      case 144:
+        eventos.push({ tipo: "nota", tic, canal, altura: dato1 & 127, velocidad: byte() & 127 });
+        break;
+      case 160:
+        byte();
+        eventos.push({ tipo: "presion", tic, canal });
+        break;
+      case 176:
+        eventos.push({ tipo: "control", tic, canal, control: dato1, valor: byte() });
+        break;
+      case 192:
+        eventos.push({ tipo: "programa", tic, canal, programa: dato1 & 127 });
+        break;
+      case 208:
+        eventos.push({ tipo: "presion", tic, canal });
+        break;
+      case 224:
+        eventos.push({ tipo: "bend", tic, canal, valor: dato1 | byte() << 7 });
+        break;
+    }
   }
-  return zipSync(entradas, { level: 0 });
+  return { eventos, fin: tic };
 }
-function desempaquetar(bytes) {
-  let entradas;
-  try {
-    entradas = unzipSync(bytes);
-  } catch {
-    throw new ArchivoIlegible("Esto no parece un archivo .mtabs: no se pudo abrir el contenedor.");
-  }
-  const crudo = entradas[MANIFIESTO];
-  if (!crudo) {
-    throw new ArchivoIlegible(
-      "El archivo no trae su manifiesto, as\xED que no se puede saber ni de qu\xE9 versi\xF3n es."
-    );
-  }
-  let manifiesto;
+function textoDe(datos) {
   try {
-    manifiesto = JSON.parse(new TextDecoder().decode(crudo));
+    return new TextDecoder("utf-8", { fatal: true }).decode(datos).trim();
   } catch {
-    throw new ArchivoIlegible("El manifiesto del archivo est\xE1 da\xF1ado.");
-  }
-  if (!manifiesto || typeof manifiesto !== "object") {
-    throw new ArchivoIlegible("El manifiesto del archivo est\xE1 da\xF1ado.");
+    return new TextDecoder("latin1").decode(datos).trim();
   }
-  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.`
+}
+function recolectar(smf, avisos) {
+  if (smf.formato === 2) {
+    avisos.decir(
+      "El archivo es MIDI de formato 2 (secuencias independientes): se ley\xF3 como si todas las pistas sonaran a la vez, que es lo que hacen casi todos los programas."
     );
   }
-  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 temposCrudos = [];
+  for (const pista of smf.pistas)
+    for (const e of pista.eventos)
+      if (e.tipo === "meta" && e.meta === 81 && e.datos.length >= 3) {
+        const us = e.datos[0] << 16 | e.datos[1] << 8 | e.datos[2];
+        if (us > 0) temposCrudos.push({ tic: e.tic, microsegundos: us });
+      }
+  temposCrudos.sort((a, b) => a.tic - b.tic);
+  const reloj = armarReloj(smf, temposCrudos);
+  const tempos = temposCrudos.map((t) => ({
+    tic: reloj(t.tic),
+    // ★ Redondeado a centésimas: 60 000 000 / 428 571 da 140,0002, y ese 0,0002 no lo escribió
+    //   nadie — es el redondeo del propio formato, que guarda microsegundos enteros.
+    bpm: Math.round(6e7 / t.microsegundos * 100) / 100
+  }));
+  const metricas = [];
+  const tonalidades = [];
+  const marcadores = [];
+  const nombres = /* @__PURE__ */ new Map();
+  const instrumentos = /* @__PURE__ */ new Map();
+  let letras = 0;
+  let textos = 0;
+  for (const [indice, pista] of smf.pistas.entries()) {
+    for (const e of pista.eventos) {
+      if (e.tipo !== "meta") continue;
+      const tic = reloj(e.tic);
+      switch (e.meta) {
+        case 88:
+          if (e.datos.length >= 2) {
+            const numerador = e.datos[0];
+            const potencia = e.datos[1];
+            const denominador = 2 ** potencia;
+            if (numerador >= 1 && numerador <= 32 && denominador >= 1 && denominador <= 32) {
+              metricas.push({ tic, numerador, denominador });
+            } else {
+              avisos.contar("metrica-imposible");
+            }
+          }
+          break;
+        case 89:
+          if (e.datos.length >= 2) {
+            const alteraciones = e.datos[0] << 24 >> 24;
+            if (alteraciones >= -7 && alteraciones <= 7) tonalidades.push({ tic, alteraciones, menor: e.datos[1] === 1 });
+          }
+          break;
+        case 3:
+          if (!nombres.has(indice)) nombres.set(indice, textoDe(e.datos));
+          break;
+        case 4:
+          if (!instrumentos.has(indice)) instrumentos.set(indice, textoDe(e.datos));
+          break;
+        case 6: {
+          const texto4 = textoDe(e.datos);
+          if (texto4) marcadores.push({ tic, texto: texto4 });
+          break;
+        }
+        case 5:
+          letras++;
+          break;
+        case 1:
+        case 2:
+        case 7:
+          textos++;
+          break;
+      }
+    }
   }
-  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;
+  metricas.sort((a, b) => a.tic - b.tic);
+  tonalidades.sort((a, b) => a.tic - b.tic);
+  marcadores.sort((a, b) => a.tic - b.tic);
+  if (avisos.cuantas("metrica-imposible") > 0) {
+    avisos.decir(`${avisos.cuantas("metrica-imposible")} cambio(s) de m\xE9trica con valores imposibles se ignoraron.`);
+  }
+  if (letras > 0) {
+    avisos.decir(`El archivo trae ${letras} s\xEDlaba(s) de letra: todav\xEDa no se importan desde MIDI.`);
+  }
+  if (textos > 0) {
+    avisos.decir(`El archivo trae ${textos} texto(s) sueltos (comentarios, derechos, indicaciones): no se importaron.`);
+  }
+  const porPista = [];
+  const programas = [];
+  const controles = [];
+  let sinCerrar = 0;
+  let pedal = 0;
+  let bends = 0;
+  let presiones = 0;
+  let otrosControles = 0;
+  let sysex = 0;
+  for (const [indice, pista] of smf.pistas.entries()) {
+    const notas = [];
+    const abiertas = /* @__PURE__ */ new Map();
+    for (const e of pista.eventos) {
+      switch (e.tipo) {
+        case "nota": {
+          const clave = e.canal * 128 + e.altura;
+          if (e.velocidad > 0) {
+            const cola = abiertas.get(clave) ?? [];
+            cola.push({ tic: e.tic, velocidad: e.velocidad });
+            abiertas.set(clave, cola);
+          } else {
+            const abierta2 = abiertas.get(clave)?.shift();
+            if (abierta2) notas.push({ ini: reloj(abierta2.tic), fin: reloj(e.tic), altura: e.altura, velocidad: abierta2.velocidad, canal: e.canal });
+          }
+          break;
+        }
+        case "programa":
+          programas.push({ pista: indice, canal: e.canal, tic: e.tic, programa: e.programa });
+          break;
+        case "control":
+          if (e.control === 7 || e.control === 10) controles.push({ pista: indice, canal: e.canal, tic: e.tic, control: e.control, valor: e.valor });
+          else if (e.control === 64) {
+            if (e.valor >= 64) pedal++;
+          } else if (!CONTROLES_QUE_NO_SON_MUSICA.has(e.control) && e.control < 120 && !(e.control === 1 && e.valor === 0) && !(e.control === 11 && e.valor === 127)) otrosControles++;
+          break;
+        case "bend":
+          if (e.valor !== 8192) bends++;
+          break;
+        case "presion":
+          presiones++;
+          break;
+        case "sysex":
+          sysex++;
+          break;
+      }
     }
-    if (nombre.startsWith(CARPETA_DE_FUENTES)) {
-      const tipografiaId = nombre.slice(CARPETA_DE_FUENTES.length);
-      if (tipografiaId) fuentes.push({ tipografiaId, bytes: contenido });
+    for (const [clave, cola] of abiertas)
+      for (const abierta2 of cola) {
+        sinCerrar++;
+        notas.push({ ini: reloj(abierta2.tic), fin: reloj(pista.fin), altura: clave % 128, velocidad: abierta2.velocidad, canal: Math.floor(clave / 128) });
+      }
+    porPista.push(notas);
+  }
+  if (sinCerrar > 0) avisos.decir(`${sinCerrar} nota(s) no se apagaban nunca: se cortaron donde termina su pista.`);
+  if (pedal > 0) avisos.decir("El archivo usa el pedal de resonancia: no se importa desde MIDI, y las notas duran lo que dura la tecla apretada.");
+  if (bends > 0) avisos.decir(`El archivo trae ${bends} movimiento(s) de pitch bend (bends, vibratos, glissandos): no se importan.`);
+  if (presiones > 0) avisos.decir(`El archivo trae ${presiones} evento(s) de presi\xF3n (aftertouch): no se importan.`);
+  if (otrosControles > 0) avisos.decir(`El archivo trae ${otrosControles} cambio(s) de controladores (expresi\xF3n, modulaci\xF3n\u2026): no se importan; s\xED el volumen y el paneo iniciales.`);
+  if (sysex > 0) avisos.decir(`El archivo trae ${sysex} mensaje(s) de sistema exclusivo, propios de un sintetizador: no se importan.`);
+  const programaEn = (pista, canal, tic) => {
+    let deLaPista = null;
+    let deCualquiera = null;
+    for (const p of programas) {
+      if (p.canal !== canal || p.tic > tic) continue;
+      if (p.pista === pista) deLaPista = p.programa;
+      else deCualquiera = p.programa;
+    }
+    return deLaPista ?? deCualquiera ?? 0;
+  };
+  const controlInicial = (pista, canal, control, hasta) => {
+    let valor = null;
+    for (const c of controles) {
+      if (c.canal !== canal || c.control !== control || c.tic > hasta) continue;
+      if (c.pista === pista || valor === null) valor = c.valor;
     }
-  }
-  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";
+    return valor;
+  };
+  const grupos = [];
+  for (const [indice, notas] of porPista.entries()) {
+    const porCanal = /* @__PURE__ */ new Map();
+    for (const n of notas) {
+      const lista2 = porCanal.get(n.canal) ?? [];
+      lista2.push(n);
+      porCanal.set(n.canal, lista2);
+    }
+    const deEstaPista = [];
+    for (const canal of [...porCanal.keys()].sort((a, b) => a - b)) {
+      const lista2 = porCanal.get(canal);
+      let ticCrudoDeLaPrimera = Infinity;
+      for (const e of smf.pistas[indice].eventos) {
+        if (e.tipo === "nota" && e.canal === canal && e.velocidad > 0) {
+          ticCrudoDeLaPrimera = e.tic;
+          break;
+        }
       }
-    };
-  }
-});
-
-// 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;
+      const esBateria = canal === 9;
+      const programa = esBateria ? 0 : programaEn(indice, canal, ticCrudoDeLaPrimera);
+      const cambia = !esBateria && programas.some((p) => p.canal === canal && p.pista === indice && p.tic > ticCrudoDeLaPrimera && p.programa !== programa);
+      if (cambia) avisos.contar("cambio-de-programa");
+      const existente = smf.formato !== 0 && !esBateria ? deEstaPista.find((g) => !g.esBateria && g.programa === programa) : void 0;
+      const volumen = controlInicial(indice, canal, 7, ticCrudoDeLaPrimera);
+      const paneo = controlInicial(indice, canal, 10, ticCrudoDeLaPrimera);
+      if (existente) {
+        existente.canales.push(canal);
+        existente.notas.push(...lista2);
+        continue;
+      }
+      deEstaPista.push({ pista: indice, canales: [canal], esBateria, programa, nombre: "", volumen, paneo, notas: [...lista2] });
     }
-    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>");
+    const nombreDeLaPista = smf.formato === 0 ? "" : nombres.get(indice) || instrumentos.get(indice) || "";
+    for (const g of deEstaPista) {
+      const delPrograma = g.esBateria ? "Bater\xEDa" : NOMBRES_GM[g.programa];
+      g.nombre = nombreDeLaPista ? deEstaPista.length > 1 ? `${nombreDeLaPista} (${delPrograma})` : nombreDeLaPista : delPrograma;
+    }
+    grupos.push(...deEstaPista);
   }
-  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
+  if (avisos.cuantas("cambio-de-programa") > 0) {
+    avisos.decir(
+      `${avisos.cuantas("cambio-de-programa")} pista(s) cambian de instrumento a mitad de la obra: se us\xF3 el primero. Tabs lleva un instrumento por pista.`
     );
-    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;
+  const repetidos = /* @__PURE__ */ new Map();
+  for (const g of grupos) repetidos.set(g.nombre, (repetidos.get(g.nombre) ?? 0) + 1);
+  const vistos = /* @__PURE__ */ new Map();
+  for (const g of grupos) {
+    if ((repetidos.get(g.nombre) ?? 0) < 2) continue;
+    const n = (vistos.get(g.nombre) ?? 0) + 1;
+    vistos.set(g.nombre, n);
+    g.nombre = `${g.nombre} ${n}`;
+  }
+  let titulo = "";
+  if (smf.formato === 0) titulo = nombres.get(0) ?? "";
+  else {
+    const director = porPista.findIndex((n, i2) => n.length === 0 && (nombres.get(i2) ?? "") !== "");
+    if (director >= 0) titulo = nombres.get(director) ?? "";
+  }
+  for (const g of grupos) {
+    g.volumen = g.volumen === null ? null : Math.round(g.volumen / 127 * 16);
+    g.paneo = g.paneo === null ? null : Math.round(g.paneo / 127 * 16);
+  }
+  return { titulo, grupos, tempos, metricas, tonalidades, marcadores };
+}
+function armarReloj(smf, tempos) {
+  if (!smf.smpte) return (tic) => tic * TICS_POR_NEGRA3 / smf.division;
+  const porSegundo = smf.smpte.cuadrosPorSegundo * smf.smpte.ticsPorCuadro;
+  const puntos = [{ segundo: 0, negras: 0, usPorNegra: 5e5 }];
+  for (const t of tempos) {
+    const anterior = puntos[puntos.length - 1];
+    const segundo = t.tic / porSegundo;
+    const negras = anterior.negras + (segundo - anterior.segundo) * 1e6 / anterior.usPorNegra;
+    if (segundo === anterior.segundo) puntos[puntos.length - 1] = { segundo, negras: anterior.negras, usPorNegra: t.microsegundos };
+    else puntos.push({ segundo, negras, usPorNegra: t.microsegundos });
+  }
+  return (tic) => {
+    const segundo = tic / porSegundo;
+    let punto = puntos[0];
+    for (const p of puntos) if (p.segundo <= segundo) punto = p;
+    return (punto.negras + (segundo - punto.segundo) * 1e6 / punto.usPorNegra) * TICS_POR_NEGRA3;
+  };
 }
-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>");
+function armarCompases(leido, hasta, avisos) {
+  const compases = [];
+  let numerador = 4;
+  let denominador = 4;
+  let cursor = 0;
+  let siguiente = 0;
+  let corridos = 0;
+  while (compases.length === 0 || cursor < hasta) {
+    const largo = TICS_POR_NEGRA3 * 4 * numerador / denominador;
+    while (siguiente < leido.metricas.length && leido.metricas[siguiente].tic < cursor + largo - 0.5) {
+      const m = leido.metricas[siguiente];
+      if (m.tic > cursor + 0.5 && (m.numerador !== numerador || m.denominador !== denominador)) {
+        corridos++;
+        break;
       }
-    } 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;
+      numerador = m.numerador;
+      denominador = m.denominador;
+      siguiente++;
+    }
+    const largoFinal = TICS_POR_NEGRA3 * 4 * numerador / denominador;
+    compases.push({ inicio: cursor, fin: cursor + largoFinal, numerador, denominador });
+    cursor += largoFinal;
+    if (siguiente < leido.metricas.length && leido.metricas[siguiente].tic < cursor) {
+      const m = leido.metricas[siguiente];
+      numerador = m.numerador;
+      denominador = m.denominador;
+      siguiente++;
+    }
+    if (compases.length > 2e4) break;
+  }
+  if (corridos > 0) {
+    avisos.decir(`${corridos} cambio(s) de m\xE9trica ca\xEDan a mitad de comp\xE1s: se aplicaron en la barra siguiente.`);
+  }
+  return compases;
+}
+function rejillaDe(c) {
+  const figura = c?.rejilla ?? 16;
+  const recta = TICS_POR_NEGRA3 * 4 / figura;
+  const conTresillos = c?.tresillos ?? true;
+  const nombre = figura === 8 ? "la corchea" : figura === 32 ? "la fusa" : "la semicorchea";
+  if (figura === 8 || !conTresillos) return { recta, tresillo: null, nombre, nombreTresillo: "" };
+  return { recta, tresillo: recta * 4 / 3, nombre, nombreTresillo: figura === 32 ? "al tresillo de semicorchea" : "al tresillo de corchea" };
+}
+function decidirVentanas(compases, comienzos, rejilla) {
+  const ventanas = [];
+  const ordenados = [...comienzos].sort((a, b) => a - b);
+  let k = 0;
+  for (const compas of compases) {
+    for (let inicio = compas.inicio; inicio < compas.fin - 0.5; inicio += TICS_POR_NEGRA3) {
+      const fin = Math.min(inicio + TICS_POR_NEGRA3, compas.fin);
+      let tresillo = false;
+      if (rejilla.tresillo !== null && fin - inicio === TICS_POR_NEGRA3) {
+        while (k < ordenados.length && ordenados[k] < inicio) k++;
+        let errorRecto = 0;
+        let errorTresillo = 0;
+        let fueraDeLaRecta = false;
+        for (let j = k; j < ordenados.length && ordenados[j] < fin; j++) {
+          const desde = ordenados[j] - inicio;
+          errorRecto += Math.abs(desde - Math.round(desde / rejilla.recta) * rejilla.recta);
+          const enTresillo = Math.round(desde / rejilla.tresillo) * rejilla.tresillo;
+          errorTresillo += Math.abs(desde - enTresillo);
+          if (enTresillo % rejilla.recta !== 0) fueraDeLaRecta = true;
+        }
+        tresillo = fueraDeLaRecta && errorTresillo < errorRecto * 0.5;
+      }
+      ventanas.push({ inicio, fin, paso: tresillo ? rejilla.tresillo : rejilla.recta, tresillo });
+    }
+  }
+  return ventanas;
+}
+function ventanaEn(ventanas, tic) {
+  let bajo = 0;
+  let alto = ventanas.length - 1;
+  while (bajo < alto) {
+    const medio = bajo + alto + 1 >> 1;
+    if (ventanas[medio].inicio <= tic) bajo = medio;
+    else alto = medio - 1;
+  }
+  return ventanas[bajo];
+}
+function cuantizar(ventanas, tic) {
+  const v = ventanaEn(ventanas, tic);
+  const punto = v.inicio + Math.round((tic - v.inicio) / v.paso) * v.paso;
+  return Math.min(Math.max(punto, v.inicio), v.fin);
+}
+function pasoEn(ventanas, tic) {
+  const v = ventanaEn(ventanas, tic);
+  return Math.min(v.paso, v.fin - tic);
+}
+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 || g.programa >= 16 && g.programa <= 20) return "piano";
+  return "altura";
+}
+function digitar(alturas, afinacion, ocupadas) {
+  const conOcupadas = mejorDigitacion(alturas, afinacion, ocupadas);
+  const colocadas = (d) => d.filter((c) => c !== null).length;
+  if (ocupadas.size === 0 || colocadas(conOcupadas) === alturas.length) return conOcupadas;
+  const sinOcupadas = mejorDigitacion(alturas, afinacion, /* @__PURE__ */ new Set());
+  return colocadas(sinOcupadas) > colocadas(conOcupadas) ? sinOcupadas : conOcupadas;
+}
+function mejorDigitacion(alturas, afinacion, prohibidas) {
+  let mejor = null;
+  const actual = [];
+  const usadas = /* @__PURE__ */ new Set();
+  const probar = (i2, colocadas, maximo, suma) => {
+    if (i2 === alturas.length) {
+      if (!mejor || colocadas > mejor.colocadas || colocadas === mejor.colocadas && (maximo < mejor.maximo || maximo === mejor.maximo && suma < mejor.suma)) {
+        mejor = { cuerdas: [...actual], colocadas, maximo, suma };
       }
-      if (compas !== compasAnterior) {
-        cambios.push("<time>");
-        cambios.push(`<beats>${numerador}</beats>`);
-        cambios.push(`<beat-type>${denominador}</beat-type>`);
-        cambios.push("</time>");
-        compasAnterior = compas;
+      return;
+    }
+    for (let cuerda = 1; cuerda <= afinacion.length; cuerda++) {
+      if (usadas.has(cuerda) || prohibidas.has(cuerda)) continue;
+      const traste = alturas[i2] - afinacion[cuerda - 1];
+      if (traste < 0 || traste > TRASTES) continue;
+      usadas.add(cuerda);
+      actual.push(cuerda);
+      probar(i2 + 1, colocadas + 1, Math.max(maximo, traste), suma + traste);
+      actual.pop();
+      usadas.delete(cuerda);
+    }
+    actual.push(null);
+    probar(i2 + 1, colocadas, maximo, suma);
+    actual.pop();
+  };
+  probar(0, 0, 0, 0);
+  return mejor.cuerdas;
+}
+function repartirEnVoces(notas, ventanas, avisos, digitarEn) {
+  const voces = [];
+  const porComienzo = /* @__PURE__ */ new Map();
+  for (const n of notas) {
+    const lista2 = porComienzo.get(n.ini) ?? [];
+    lista2.push(n);
+    porComienzo.set(n.ini, lista2);
+  }
+  for (const ini of [...porComienzo.keys()].sort((a, b) => a - b)) {
+    let juntas = porComienzo.get(ini);
+    const paso = pasoEn(ventanas, ini);
+    if (digitarEn) {
+      const ocupadas = /* @__PURE__ */ new Set();
+      for (const voz of voces) {
+        const ultimo = voz[voz.length - 1];
+        if (ultimo && ultimo.fin > ini) for (const n of ultimo.notas) ocupadas.add(n.cuerda);
+      }
+      juntas = [...juntas].sort((a, b) => b.altura - a.altura);
+      const cuerdas = digitarEn(juntas.map((n) => n.altura), ocupadas);
+      const entran = [];
+      juntas.forEach((n, i2) => {
+        const cuerda = cuerdas[i2];
+        if (cuerda === null || cuerda === void 0) avisos.contar("sin-cuerda");
+        else entran.push({ ...n, cuerda });
+      });
+      juntas = entran;
+      if (juntas.length === 0) continue;
+    }
+    const subgrupos = [];
+    for (const n of [...juntas].sort((a, b) => b.fin - a.fin)) {
+      const cerca = subgrupos.find((s) => Math.abs(s.fin - n.fin) <= paso);
+      if (cerca) {
+        if (cerca.fin !== n.fin) avisos.contar("duracion-ajustada");
+        cerca.notas.push(n);
+      } else subgrupos.push({ fin: n.fin, notas: [n] });
+    }
+    subgrupos.sort((a, b) => Math.max(...b.notas.map((n) => n.altura)) - Math.max(...a.notas.map((n) => n.altura)));
+    for (const s of subgrupos) {
+      const libreDesde = (v) => v[v.length - 1]?.fin ?? 0;
+      let voz = voces.find((v) => libreDesde(v) <= ini);
+      if (!voz) {
+        const recortable = voces.filter((v) => libreDesde(v) - ini <= paso && v[v.length - 1].ini < ini).sort((a, b) => libreDesde(a) - libreDesde(b))[0];
+        if (recortable) {
+          const anterior = recortable[recortable.length - 1];
+          avisos.contar("acortadas", anterior.notas.length);
+          anterior.fin = ini;
+          voz = recortable;
+        }
+      }
+      if (!voz && voces.length < MAXIMO_DE_VOCES) {
+        voz = [];
+        voces.push(voz);
+      }
+      if (!voz) {
+        avisos.contar("sin-voz", s.notas.length);
+        continue;
       }
-      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>");
+      voz.push({ ini, fin: s.fin, notas: s.notas.map((n) => ({ ...n, fin: s.fin })) });
+    }
+  }
+  return voces.length > 0 ? voces : [[]];
+}
+function figurasQueLlenan(ini, fin, ventana) {
+  const salida = [];
+  let resto = Math.round(fin - ini);
+  const tresillo = ventana.tresillo && !(ini === ventana.inicio && fin === ventana.fin);
+  const catalogo = tresillo ? FIGURAS_DE_TRESILLO : FIGURAS_RECTAS;
+  while (resto > 0) {
+    const f = catalogo.find((c) => c.largo <= resto + 1e-6) ?? FIGURAS_RECTAS[FIGURAS_RECTAS.length - 1];
+    salida.push(f);
+    resto -= f.largo;
+  }
+  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 = 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.");
+  }
+  const medioPasoMaximo = Math.max(rejilla.recta, rejilla.tresillo ?? 0) / 2;
+  let hasta = 0;
+  for (const g of grupos)
+    for (const n of g.notas) hasta = Math.max(hasta, n.fin, n.ini + medioPasoMaximo + 1);
+  const compases = armarCompases(leido, hasta, avisos);
+  const finDeLaObra2 = compases[compases.length - 1].fin;
+  const compasEn = (tic) => {
+    let i2 = 0;
+    while (i2 + 1 < compases.length && compases[i2 + 1].inicio <= tic) i2++;
+    return i2;
+  };
+  let redondeadas = 0;
+  let hayTresillos = false;
+  const velocidades = /* @__PURE__ */ new Set();
+  const pistas = [];
+  for (const grupo of grupos) {
+    const clase = claseDe(grupo);
+    const ventanas = decidirVentanas(compases, grupo.notas.map((n) => n.ini), rejilla);
+    if (ventanas.some((v) => v.tresillo)) hayTresillos = true;
+    let notas = [];
+    for (const cruda of grupo.notas) {
+      velocidades.add(cruda.velocidad);
+      const ini = Math.min(cuantizar(ventanas, cruda.ini), finDeLaObra2 - pasoEn(ventanas, finDeLaObra2 - 1));
+      let fin = cuantizar(ventanas, cruda.fin);
+      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, ...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 && anterior.mano === n.mano) {
+        if (anterior.ini === n.ini) {
+          avisos.contar("repetidas");
+          continue;
         }
-        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>");
+        if (anterior.fin > n.ini) {
+          anterior.fin = n.ini;
+          avisos.contar("acortadas");
         }
-        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>");
+      limpias.push(n);
+    }
+    notas = limpias;
+    const pista = { grupo, clase, ventanas, pentagramas: [], teclasDeBateria: [] };
+    if (clase === "bateria") {
+      pista.teclasDeBateria = [...new Set(notas.map((n) => n.altura))].sort((a, b) => a - b);
+      const porComienzo = /* @__PURE__ */ new Map();
+      for (const n of notas) {
+        const lista2 = porComienzo.get(n.ini) ?? [];
+        lista2.push(n);
+        porComienzo.set(n.ini, lista2);
       }
-      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>"
+      const comienzos = [...porComienzo.keys()].sort((a, b) => a - b);
+      const eventos = comienzos.map((ini, i2) => {
+        const finDelCompas = compases[compasEn(ini)].fin;
+        const fin = Math.min(comienzos[i2 + 1] ?? finDelCompas, finDelCompas);
+        return { ini, fin, notas: porComienzo.get(ini).map((n) => ({ ...n, fin })) };
+      });
+      pista.pentagramas.push({ voces: [eventos], clave: _barrel_exports$4.Clef.Neutral });
+    } else if (clase === "guitarra" || clase === "bajo") {
+      const afinacion = clase === "guitarra" ? AFINACION_GUITARRA : AFINACION_BAJO;
+      const grave = afinacion[0];
+      const aguda = afinacion[afinacion.length - 1] + TRASTES;
+      const enRegistro = notas.filter((n) => n.altura >= grave && n.altura <= aguda);
+      const fuera = notas.length - enRegistro.length;
+      if (fuera > 0) {
+        avisos.decir(
+          `Se descartaron ${fuera} nota(s) fuera del registro ${clase === "guitarra" ? "de la guitarra" : "del bajo"} \xAB${grupo.nombre}\xBB (de ${nombreDeAltura(grave)} a ${nombreDeAltura(aguda)} con ${TRASTES} trastes).`
         );
       }
-      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 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") {
+      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);
       }
-      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>");
+      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 {
+      const ordenadas = notas.map((n) => n.altura).sort((a, b) => a - b);
+      const mediana = ordenadas[Math.floor(ordenadas.length / 2)] ?? 60;
+      pista.pentagramas.push({
+        voces: repartirEnVoces(notas, ventanas, avisos, null),
+        clave: mediana < 55 ? _barrel_exports$4.Clef.F4 : _barrel_exports$4.Clef.G2
+      });
+    }
+    pistas.push(pista);
+  }
+  if (redondeadas > 0) {
+    avisos.decir(
+      `Se redondearon ${redondeadas} nota(s) a ${rejilla.nombre}` + (hayTresillos ? ` o ${rejilla.nombreTresillo}` : "") + ": no ca\xEDan justo en la rejilla."
+    );
+  }
+  if (avisos.cuantas("duracion-ajustada") > 0) {
+    avisos.decir(`Se ajust\xF3 la duraci\xF3n de ${avisos.cuantas("duracion-ajustada")} nota(s) a la rejilla.`);
+  }
+  if (avisos.cuantas("acortadas") > 0) {
+    avisos.decir(`Se acortaron ${avisos.cuantas("acortadas")} nota(s) que se pisaban con la siguiente.`);
+  }
+  if (avisos.cuantas("repetidas") > 0) {
+    avisos.decir(`Se juntaron ${avisos.cuantas("repetidas")} nota(s) repetidas: la misma tecla dos veces en el mismo instante.`);
+  }
+  if (avisos.cuantas("sin-voz") > 0) {
+    avisos.decir(`Se descartaron ${avisos.cuantas("sin-voz")} nota(s) porque sonaban m\xE1s de ${MAXIMO_DE_VOCES} voces a la vez en el mismo pentagrama.`);
+  }
+  if (avisos.cuantas("sin-cuerda") > 0) {
+    avisos.decir(`Se descartaron ${avisos.cuantas("sin-cuerda")} nota(s) que no cab\xEDan en las cuerdas (dos notas en la misma cuerda a la vez).`);
+  }
+  if (velocidades.size > 1) {
+    avisos.decir("La intensidad de cada nota (velocity) no se importa: todas quedan con el mismo matiz.");
+  }
+  const score = new _barrel_exports$4.Score();
+  score.title = leido.titulo || opciones.titulo || "";
+  score.stylesheet.hideDynamics = true;
+  const rejillaDelTempo = pistas[0]?.ventanas ?? decidirVentanas(compases, [], rejilla);
+  const temposPorTic = /* @__PURE__ */ new Map();
+  for (const t of leido.tempos) {
+    const tic = t.tic < finDeLaObra2 ? cuantizar(rejillaDelTempo, t.tic) : finDeLaObra2;
+    if (tic < finDeLaObra2) temposPorTic.set(tic, t.bpm);
+  }
+  if (!temposPorTic.has(0)) temposPorTic.set(0, leido.tempos.find((t) => t.tic <= 0)?.bpm ?? 120);
+  const cambiosDeTempo = [];
+  for (const tic of [...temposPorTic.keys()].sort((a, b) => a - b)) {
+    const bpm = temposPorTic.get(tic);
+    if (cambiosDeTempo.length > 0 && cambiosDeTempo[cambiosDeTempo.length - 1].bpm === bpm) continue;
+    cambiosDeTempo.push({ tic, bpm });
+  }
+  const tonalidadPorCompas = [];
+  {
+    let vigente = { alteraciones: 0, menor: false };
+    let j = 0;
+    let corridas = 0;
+    for (const compas of compases) {
+      while (j < leido.tonalidades.length && leido.tonalidades[j].tic < compas.fin - 0.5) {
+        const t = leido.tonalidades[j];
+        if (t.tic > compas.inicio + 0.5 && t.alteraciones !== vigente.alteraciones) {
+          corridas++;
+          break;
+        }
+        vigente = { alteraciones: t.alteraciones, menor: t.menor };
+        j++;
       }
-      l.push("</measure>");
+      tonalidadPorCompas.push(vigente);
     }
-    l.push("</part>");
+    if (corridas > 0) avisos.decir(`${corridas} cambio(s) de armadura ca\xEDan a mitad de comp\xE1s: se escribieron en la barra siguiente.`);
   }
-  l.push("</score-partwise>");
-  return sangrar(l);
+  const seccionPorCompas = /* @__PURE__ */ new Map();
+  let marcadoresDeMas = 0;
+  for (const m of leido.marcadores) {
+    const i2 = compasEn(m.tic);
+    if (seccionPorCompas.has(i2)) marcadoresDeMas++;
+    else seccionPorCompas.set(i2, m.texto);
+  }
+  if (marcadoresDeMas > 0) avisos.decir(`${marcadoresDeMas} marcador(es) ca\xEDan en un comp\xE1s que ya ten\xEDa uno: se guard\xF3 el primero.`);
+  for (const [i2, compas] of compases.entries()) {
+    const maestro = new _barrel_exports$4.MasterBar();
+    maestro.timeSignatureNumerator = compas.numerador;
+    maestro.timeSignatureDenominator = compas.denominador;
+    const seccion = seccionPorCompas.get(i2);
+    if (seccion) {
+      maestro.section = new _barrel_exports$4.Section();
+      maestro.section.text = seccion;
+      maestro.section.marker = "";
+    }
+    for (const cambio of cambiosDeTempo) {
+      if (cambio.tic < compas.inicio || cambio.tic >= compas.fin) continue;
+      const automatizacion = new _barrel_exports$4.Automation();
+      automatizacion.isLinear = false;
+      automatizacion.type = _barrel_exports$4.AutomationType.Tempo;
+      automatizacion.value = cambio.bpm;
+      automatizacion.ratioPosition = (cambio.tic - compas.inicio) / (compas.fin - compas.inicio);
+      maestro.tempoAutomations.push(automatizacion);
+    }
+    score.addMasterBar(maestro);
+  }
+  if (pistas.length === 0) {
+    pistas.push({
+      grupo: { pista: 0, canales: [0], esBateria: false, programa: 0, nombre: NOMBRES_GM[0], volumen: null, paneo: null, notas: [] },
+      clase: "piano",
+      ventanas: decidirVentanas(compases, [], rejilla),
+      pentagramas: [{ voces: [[]], clave: _barrel_exports$4.Clef.G2 }, { voces: [[]], clave: _barrel_exports$4.Clef.F4 }],
+      teclasDeBateria: []
+    });
+  }
+  const cortesDeTempo = cambiosDeTempo.map((c) => c.tic).filter((t) => t > 0);
+  const piezasQueFaltan = /* @__PURE__ */ new Map();
+  for (const [indiceDePista, pista] of pistas.entries()) {
+    const track = new _barrel_exports$4.Track();
+    track.name = pista.grupo.nombre;
+    track.shortName = pista.clase === "bateria" ? "bat" : NOMBRES_CORTOS_GM[Math.floor(pista.grupo.programa / 8)];
+    track.playbackInfo.program = pista.grupo.programa;
+    track.playbackInfo.volume = pista.grupo.volumen ?? 16;
+    track.playbackInfo.balance = pista.grupo.paneo ?? 8;
+    const canal = pista.clase === "bateria" ? 9 : pista.grupo.canales[0];
+    track.playbackInfo.primaryChannel = canal;
+    track.playbackInfo.secondaryChannel = canal;
+    score.addTrack(track);
+    const indiceDeTecla = /* @__PURE__ */ new Map();
+    if (pista.clase === "bateria") {
+      track.percussionArticulations = pista.teclasDeBateria.map((tecla, indice) => {
+        const art = new _barrel_exports$4.InstrumentArticulation();
+        art.elementType = `midi ${tecla}`;
+        art.id = indice;
+        art.outputMidiNumber = tecla;
+        indiceDeTecla.set(tecla, indice);
+        return art;
+      });
+      for (const [tecla, indice] of indiceDeTecla) {
+        const pieza = piezaDeBateria(track, indice);
+        const art = track.percussionArticulations[indice];
+        if (pieza === null) {
+          indiceDeTecla.delete(tecla);
+          continue;
+        }
+        const delKit = KIT[pieza];
+        art.staffLine = delKit.linea;
+        art.noteHeadDefault = delKit.cabeza === "x" ? _barrel_exports$4.MusicFontSymbol.NoteheadXBlack : _barrel_exports$4.MusicFontSymbol.NoteheadBlack;
+        art.noteHeadHalf = art.noteHeadDefault;
+        art.noteHeadWhole = art.noteHeadDefault;
+      }
+      for (const voz of pista.pentagramas[0].voces)
+        for (const evento of voz) {
+          const quedan = evento.notas.filter((n) => indiceDeTecla.has(n.altura));
+          for (const n of evento.notas)
+            if (!indiceDeTecla.has(n.altura)) piezasQueFaltan.set(n.altura, (piezasQueFaltan.get(n.altura) ?? 0) + 1);
+          evento.notas = quedan;
+        }
+    }
+    for (const [numeroDePentagrama, datos] of pista.pentagramas.entries()) {
+      const staff = new _barrel_exports$4.Staff();
+      const esDeTrastes = pista.clase === "guitarra" || pista.clase === "bajo";
+      const afinacion = pista.clase === "guitarra" ? AFINACION_GUITARRA : pista.clase === "bajo" ? AFINACION_BAJO : [];
+      const descendente = [...afinacion].reverse();
+      staff.stringTuning = _barrel_exports$4.Tuning.findTuning(descendente) ?? new _barrel_exports$4.Tuning("", descendente, false);
+      staff.showTablature = esDeTrastes;
+      staff.showStandardNotation = true;
+      staff.isPercussion = pista.clase === "bateria";
+      if (esDeTrastes) staff.displayTranspositionPitch = -12;
+      track.addStaff(staff);
+      const cortesDeEstaVoz0 = indiceDePista === 0 && numeroDePentagrama === 0 ? cortesDeTempo : [];
+      const cortesDeTresillo = [];
+      for (const v of pista.ventanas) if (v.tresillo) cortesDeTresillo.push(v.inicio, v.fin);
+      for (const [indiceDeCompas2, compas] of compases.entries()) {
+        const bar = new _barrel_exports$4.Bar();
+        staff.addBar(bar);
+        bar.clef = datos.clave;
+        bar.clefOttava = _barrel_exports$4.Ottavia.Regular;
+        if (!staff.isPercussion) {
+          bar.keySignature = tonalidadPorCompas[indiceDeCompas2].alteraciones;
+          bar.keySignatureType = tonalidadPorCompas[indiceDeCompas2].menor ? _barrel_exports$4.KeySignatureType.Minor : _barrel_exports$4.KeySignatureType.Major;
+        }
+        for (const [indiceDeVoz, eventos] of datos.voces.entries()) {
+          const voice = new _barrel_exports$4.Voice();
+          bar.addVoice(voice);
+          llenarVoz(voice, eventos, compas, indiceDeVoz, pista, cortesDeTresillo, indiceDeVoz === 0 ? cortesDeEstaVoz0 : [], indiceDeTecla);
+        }
+      }
+    }
+  }
+  if (piezasQueFaltan.size > 0) {
+    const total = [...piezasQueFaltan.values()].reduce((a, b) => a + b, 0);
+    avisos.decir(
+      `Se descartaron ${total} golpe(s) de bater\xEDa de piezas que el kit de Tabs todav\xEDa no tiene (notas MIDI ${[...piezasQueFaltan.keys()].sort((a, b) => a - b).join(", ")}).`
+    );
+  }
+  score.finish(new Settings());
+  return score;
 }
-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++;
+function llenarVoz(voice, eventos, compas, indiceDeVoz, pista, cortesDeTresillo, cortesForzados, indiceDeTecla) {
+  const tramos = [];
+  for (const e of eventos) {
+    if (e.fin <= compas.inicio || e.ini >= compas.fin) continue;
+    if (e.notas.length === 0) continue;
+    tramos.push({
+      ini: Math.max(e.ini, compas.inicio),
+      fin: Math.min(e.fin, compas.fin),
+      notas: e.notas,
+      // ★ Empezó en un compás anterior: lo de acá es la continuación, ligada.
+      continua: e.ini < compas.inicio
+    });
+  }
+  if (tramos.length === 0 && indiceDeVoz > 0) {
+    const vacio = new _barrel_exports$4.Beat();
+    vacio.isEmpty = true;
+    voice.addBeat(vacio);
+    return;
+  }
+  const conSilencios = [];
+  let cursor = compas.inicio;
+  for (const t of tramos) {
+    if (t.ini > cursor) conSilencios.push({ ini: cursor, fin: t.ini, notas: null, continua: false });
+    conSilencios.push(t);
+    cursor = t.fin;
+  }
+  if (cursor < compas.fin) conSilencios.push({ ini: cursor, fin: compas.fin, notas: null, continua: false });
+  const cortes = [...cortesDeTresillo, ...cortesForzados].filter((c) => c > compas.inicio && c < compas.fin);
+  for (const tramo of conSilencios) {
+    const puntos = [tramo.ini, ...cortes.filter((c) => c > tramo.ini && c < tramo.fin).sort((a, b) => a - b), tramo.fin];
+    let primera = true;
+    for (let k = 0; k + 1 < puntos.length; k++) {
+      const desde = puntos[k];
+      const hastaTic = puntos[k + 1];
+      if (hastaTic - desde < 0.5) continue;
+      const ventana = ventanaEn(pista.ventanas, desde);
+      for (const figura of figurasQueLlenan(desde, hastaTic, ventana)) {
+        const beat = new _barrel_exports$4.Beat();
+        beat.duration = figura.valor;
+        beat.dots = figura.puntillos;
+        if (figura.tresillo) {
+          beat.tupletNumerator = 3;
+          beat.tupletDenominator = 2;
+        }
+        for (const n of tramo.notas ?? []) {
+          const note = new _barrel_exports$4.Note();
+          if (pista.clase === "bateria") {
+            note.percussionArticulation = indiceDeTecla.get(n.altura);
+          } else if (pista.clase === "guitarra" || pista.clase === "bajo") {
+            const afinacion = pista.clase === "guitarra" ? AFINACION_GUITARRA : AFINACION_BAJO;
+            note.string = n.cuerda;
+            note.fret = n.altura - afinacion[n.cuerda - 1];
+          } else {
+            note.octave = Math.floor(n.altura / 12);
+            note.tone = n.altura % 12;
+          }
+          note.isTieDestination = pista.clase !== "bateria" && (!primera || tramo.continua);
+          beat.addNote(note);
+        }
+        voice.addBeat(beat);
+        primera = false;
+      }
+    }
   }
-  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 }
-  );
+function nombreDeAltura(altura) {
+  return `${NOMBRES_DE_NOTA2[altura % 12]}${Math.floor(altura / 12) - 1}`;
 }
-var DIVISIONES_POR_NEGRA, FECHA_FIJA_DEL_ZIP, PASOS, NOMBRE_DE_LA_FIGURA2, ALTERACION_POR_MODO, D, SALTOS;
-var init_musicxml = __esm({
-  "packages/io/src/musicxml.ts"() {
+var MidiIlegible, truncado, TICS_POR_NEGRA3, Avisos, CONTROLES_QUE_NO_SON_MUSICA, AFINACION_GUITARRA, AFINACION_BAJO, TRASTES, MAXIMO_DE_VOCES, FIGURAS_RECTAS, FIGURAS_DE_TRESILLO, NOMBRES_DE_NOTA2, NOMBRES_GM, NOMBRES_CORTOS_GM;
+var init_importarMidi = __esm({
+  "packages/io/src/importarMidi.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 }
+    init_src2();
+    init_manosDelPiano();
+    init_importarGp();
+    MidiIlegible = class extends Error {
+      constructor(mensaje) {
+        super(mensaje);
+        this.name = "MidiIlegible";
+      }
+    };
+    truncado = (donde) => new MidiIlegible(`El archivo MIDI est\xE1 cortado o da\xF1ado (${donde}). Puede que no se haya terminado de descargar.`);
+    TICS_POR_NEGRA3 = 960;
+    Avisos = class {
+      cuentas = /* @__PURE__ */ new Map();
+      sueltos = [];
+      contar(clave, cuantas = 1) {
+        this.cuentas.set(clave, (this.cuentas.get(clave) ?? 0) + cuantas);
+      }
+      cuantas(clave) {
+        return this.cuentas.get(clave) ?? 0;
+      }
+      decir(texto4) {
+        if (!this.sueltos.includes(texto4)) this.sueltos.push(texto4);
+      }
+      lista() {
+        return this.sueltos;
+      }
+    };
+    CONTROLES_QUE_NO_SON_MUSICA = /* @__PURE__ */ new Set([0, 32, 6, 38, 96, 97, 98, 99, 100, 101]);
+    AFINACION_GUITARRA = [40, 45, 50, 55, 59, 64];
+    AFINACION_BAJO = [28, 33, 38, 43];
+    TRASTES = 24;
+    MAXIMO_DE_VOCES = 4;
+    FIGURAS_RECTAS = [
+      [1, 0],
+      [2, 1],
+      [2, 0],
+      [4, 1],
+      [4, 0],
+      [8, 1],
+      [8, 0],
+      [16, 1],
+      [16, 0],
+      [32, 1],
+      [32, 0],
+      [64, 1],
+      [64, 0],
+      [128, 0]
+    ].map(([valor, puntillos]) => {
+      const base = TICS_POR_NEGRA3 * 4 / valor;
+      return { valor, puntillos, tresillo: false, largo: puntillos ? base * 1.5 : base };
+    });
+    FIGURAS_DE_TRESILLO = [4, 8, 16, 32].map((valor) => ({
+      valor,
+      puntillos: 0,
+      tresillo: true,
+      largo: TICS_POR_NEGRA3 * 4 / valor * (2 / 3)
+    }));
+    NOMBRES_DE_NOTA2 = ["do", "do\u266F", "re", "re\u266F", "mi", "fa", "fa\u266F", "sol", "sol\u266F", "la", "la\u266F", "si"];
+    NOMBRES_GM = [
+      // Pianos
+      "Piano de cola",
+      "Piano brillante",
+      "Piano el\xE9ctrico de cola",
+      "Piano de cantina",
+      "Piano el\xE9ctrico",
+      "Piano el\xE9ctrico 2",
+      "Clavec\xEDn",
+      "Clavinet",
+      // Percusión afinada
+      "Celesta",
+      "Glockenspiel",
+      "Caja de m\xFAsica",
+      "Vibr\xE1fono",
+      "Marimba",
+      "Xil\xF3fono",
+      "Campanas tubulares",
+      "Dulc\xE9mele",
+      // Órganos
+      "\xD3rgano Hammond",
+      "\xD3rgano percusivo",
+      "\xD3rgano de rock",
+      "\xD3rgano de iglesia",
+      "Armonio",
+      "Acorde\xF3n",
+      "Arm\xF3nica",
+      "Bandone\xF3n",
+      // Guitarras
+      "Guitarra de nailon",
+      "Guitarra ac\xFAstica",
+      "Guitarra el\xE9ctrica de jazz",
+      "Guitarra el\xE9ctrica limpia",
+      "Guitarra el\xE9ctrica apagada",
+      "Guitarra saturada",
+      "Guitarra distorsionada",
+      "Arm\xF3nicos de guitarra",
+      // Bajos
+      "Bajo ac\xFAstico",
+      "Bajo el\xE9ctrico",
+      "Bajo con p\xFAa",
+      "Bajo sin trastes",
+      "Bajo slap",
+      "Bajo slap 2",
+      "Bajo sintetizado",
+      "Bajo sintetizado 2",
+      // Cuerdas
+      "Viol\xEDn",
+      "Viola",
+      "Violonchelo",
+      "Contrabajo",
+      "Cuerdas en tr\xE9molo",
+      "Cuerdas en pizzicato",
+      "Arpa",
+      "Timbales",
+      // Conjuntos
+      "Cuerdas",
+      "Cuerdas 2",
+      "Cuerdas sintetizadas",
+      "Cuerdas sintetizadas 2",
+      "Coro",
+      "Voz",
+      "Voz sintetizada",
+      "Golpe de orquesta",
+      // Metales
+      "Trompeta",
+      "Tromb\xF3n",
+      "Tuba",
+      "Trompeta con sordina",
+      "Corno franc\xE9s",
+      "Secci\xF3n de metales",
+      "Metales sintetizados",
+      "Metales sintetizados 2",
+      // Lengüetas
+      "Saxo soprano",
+      "Saxo alto",
+      "Saxo tenor",
+      "Saxo bar\xEDtono",
+      "Oboe",
+      "Corno ingl\xE9s",
+      "Fagot",
+      "Clarinete",
+      // Flautas
+      "Flaut\xEDn",
+      "Flauta",
+      "Flauta dulce",
+      "Flauta de pan",
+      "Botella soplada",
+      "Shakuhachi",
+      "Silbido",
+      "Ocarina",
+      // Sintetizador solista
+      "Sintetizador (cuadrada)",
+      "Sintetizador (sierra)",
+      "Sintetizador (cal\xEDope)",
+      "Sintetizador (chiff)",
+      "Sintetizador (charango)",
+      "Sintetizador (voz)",
+      "Sintetizador (quintas)",
+      "Sintetizador (bajo y melod\xEDa)",
+      // Colchones
+      "Colch\xF3n new age",
+      "Colch\xF3n c\xE1lido",
+      "Colch\xF3n polif\xF3nico",
+      "Colch\xF3n de coro",
+      "Colch\xF3n de arco",
+      "Colch\xF3n met\xE1lico",
+      "Colch\xF3n halo",
+      "Colch\xF3n de barrido",
+      // Efectos de sintetizador
+      "Efecto lluvia",
+      "Efecto banda sonora",
+      "Efecto cristal",
+      "Efecto atm\xF3sfera",
+      "Efecto brillo",
+      "Efecto duendes",
+      "Efecto ecos",
+      "Efecto ciencia ficci\xF3n",
+      // Étnicos
+      "Sitar",
+      "Banjo",
+      "Shamisen",
+      "Koto",
+      "Kalimba",
+      "Gaita",
+      "Viol\xEDn folcl\xF3rico",
+      "Shehnai",
+      // Percusivos
+      "Campanillas",
+      "Agog\xF3",
+      "Steel drum",
+      "Caja china",
+      "Taiko",
+      "Tom mel\xF3dico",
+      "Tambor sintetizado",
+      "Platillo al rev\xE9s",
+      // Efectos de sonido
+      "Ruido de traste",
+      "Respiraci\xF3n",
+      "Olas",
+      "P\xE1jaros",
+      "Tel\xE9fono",
+      "Helic\xF3ptero",
+      "Aplausos",
+      "Disparo"
     ];
-    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 };
-    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"' }]
+    NOMBRES_CORTOS_GM = [
+      "pno",
+      "perc",
+      "\xF3rg",
+      "gtr",
+      "bajo",
+      "cuer",
+      "cuer",
+      "met",
+      "saxo",
+      "fl",
+      "sint",
+      "sint",
+      "sint",
+      "\xE9tn",
+      "perc",
+      "efec"
     ];
   }
 });
 
+// packages/io/src/archivoMtabs.ts
+function formatoQueNecesita(documento) {
+  for (const pista of documento.pistas.values()) {
+    const transposicion = pista.get("transposicion");
+    if (typeof transposicion === "number" && transposicion !== 0) return 6;
+  }
+  for (const nota of documento.notas.values()) {
+    const v = nota.get("armonicoValor");
+    if (typeof v === "number" && v !== 0) return 6;
+  }
+  for (const figura of documento.figuras.values()) {
+    if (figura.get("octava") !== void 0 || figura.get("tempo") !== void 0) return 6;
+  }
+  for (const pista of documento.pistas.values()) {
+    const pentagramas = pista.get("pentagramas");
+    if (typeof pentagramas === "number" && pentagramas > 1) return 5;
+  }
+  return 4;
+}
+function empaquetar(documento, opciones = {}) {
+  const grabaciones = opciones.grabaciones ?? [];
+  const fuentes = opciones.fuentes ?? [];
+  const manifiesto = {
+    formato: formatoQueNecesita(documento),
+    aplicacion: opciones.aplicacion ?? "Mandioca Tabs",
+    guardado: opciones.guardado ?? "",
+    titulo: documento.cabecera.get("titulo") ?? "",
+    artista: documento.cabecera.get("artista") ?? "",
+    audios: grabaciones.map((g) => g.fuenteId),
+    fuentes: fuentes.map((f) => f.tipografiaId)
+  };
+  const entradas = {
+    [MANIFIESTO]: new TextEncoder().encode(JSON.stringify(manifiesto, null, 2)),
+    [DOCUMENTO]: documento.aBytes()
+  };
+  for (const g of grabaciones) {
+    entradas[`${CARPETA_DE_AUDIO}${g.fuenteId}`] = g.bytes;
+  }
+  for (const f of fuentes) {
+    entradas[`${CARPETA_DE_FUENTES}${f.tipografiaId}`] = f.bytes;
+  }
+  return zipSync(entradas, { level: 0 });
+}
+function desempaquetar(bytes) {
+  let entradas;
+  try {
+    entradas = unzipSync(bytes);
+  } catch {
+    throw new ArchivoIlegible("Esto no parece un archivo .mtabs: no se pudo abrir el contenedor.");
+  }
+  const crudo = entradas[MANIFIESTO];
+  if (!crudo) {
+    throw new ArchivoIlegible(
+      "El archivo no trae su manifiesto, as\xED que no se puede saber ni de qu\xE9 versi\xF3n es."
+    );
+  }
+  let manifiesto;
+  try {
+    manifiesto = JSON.parse(new TextDecoder().decode(crudo));
+  } catch {
+    throw new ArchivoIlegible("El manifiesto del archivo est\xE1 da\xF1ado.");
+  }
+  if (!manifiesto || typeof manifiesto !== "object") {
+    throw new ArchivoIlegible("El manifiesto del archivo est\xE1 da\xF1ado.");
+  }
+  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 });
+    }
+  }
+  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";
+      }
+    };
+  }
+});
+
+// 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 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;
+        }
+        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: 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;
+      }
+      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/exportar.ts
 function formatoDeExportacion(clave) {
   return FORMATOS_DE_EXPORTACION.find((f) => f.clave === clave);
@@ -90159,6 +92214,7 @@ function exportarMidi(score) {
   const archivo = new _barrel_exports$3.MidiFile();
   archivo.format = _barrel_exports$3.MidiFileFormat.MultiTrack;
   const manejador = new _barrel_exports$3.AlphaSynthMidiFileHandler(archivo, true);
+  instalarRecorridoDeRepeticiones();
   new _barrel_exports$3.MidiFileGenerator(score, null, manejador).generate();
   return archivo.toBinary();
 }
@@ -90180,6 +92236,7 @@ var FORMATOS_DE_EXPORTACION;
 var init_exportar = __esm({
   "packages/io/src/exportar.ts"() {
     init_alphaTab();
+    init_recorridoDeRepeticiones();
     init_musicxml();
     FORMATOS_DE_EXPORTACION = [
       {
@@ -90226,9 +92283,11 @@ var src_exports = {};
 __export(src_exports, {
   ArchivoIlegible: () => ArchivoIlegible,
   FORMATOS_DE_EXPORTACION: () => FORMATOS_DE_EXPORTACION,
+  MidiIlegible: () => MidiIlegible,
   VERSION_DEL_FORMATO: () => VERSION_DEL_FORMATO,
   desempaquetar: () => desempaquetar,
   empaquetar: () => empaquetar,
+  esMidi: () => esMidi,
   exportarAlphaTex: () => exportarAlphaTex,
   exportarComo: () => exportarComo,
   exportarGp7: () => exportarGp7,
@@ -90238,7 +92297,9 @@ __export(src_exports, {
   formatoDeExportacion: () => formatoDeExportacion,
   formatoQueNecesita: () => formatoQueNecesita,
   importarGp: () => importarGp,
+  importarMidi: () => importarMidi,
   importarScore: () => importarScore,
+  instalarRecorridoDeRepeticiones: () => instalarRecorridoDeRepeticiones,
   leerOrtografia: () => leerOrtografia,
   prepararMusicXml: () => prepararMusicXml,
   prepararParaAlphaTab: () => prepararParaAlphaTab,
@@ -90247,10 +92308,12 @@ __export(src_exports, {
 var init_src4 = __esm({
   "packages/io/src/index.ts"() {
     init_importarGp();
+    init_importarMidi();
     init_musicxmlEntrada();
     init_archivoMtabs();
     init_exportar();
     init_musicxml();
+    init_recorridoDeRepeticiones();
   }
 });
 
@@ -90313,13 +92376,28 @@ 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
     };
     return alAbrirLaObra(abierta);
   }
+  if (EXTENSIONES_MIDI.has(extension2)) {
+    const { importarMidi: importarMidi2 } = await Promise.resolve().then(() => (init_src4(), src_exports));
+    const resultado = importarMidi2(bytes, { titulo: basename(ruta).replace(/.[^.]+$/, "") });
+    abierta = {
+      documento: resultado.documento,
+      origen: { clase: "archivo", ruta },
+      avisos: resultado.avisos,
+      grabaciones: [],
+      grabacionesEnEspera: [],
+      fuentes: []
+    };
+    return alAbrirLaObra(abierta);
+  }
   if (EXTENSIONES_IMPORTABLES.has(extension2)) {
     const { importarGp: importarGp2 } = await Promise.resolve().then(() => (init_src4(), src_exports));
     const resultado = importarGp2(bytes);
@@ -90336,7 +92414,7 @@ async function abrirDeArchivo(ruta) {
     return alAbrirLaObra(abierta);
   }
   throw new ProblemaConLaObra(
-    `No s\xE9 abrir \xAB${basename(ruta)}\xBB: la extensi\xF3n \xAB${extension2 || "(ninguna)"}\xBB no est\xE1 soportada. Se puede abrir .mtabs (el formato de Mandioca Tabs), Guitar Pro (.gp, .gpx, .gp5, .gp4, .gp3) y MusicXML (.musicxml, .xml, .mxl).`
+    `No s\xE9 abrir \xAB${basename(ruta)}\xBB: la extensi\xF3n \xAB${extension2 || "(ninguna)"}\xBB no est\xE1 soportada. Se puede abrir .mtabs (el formato de Mandioca Tabs), Guitar Pro (.gp, .gpx, .gp5, .gp4, .gp3), MusicXML (.musicxml, .xml, .mxl) y MIDI (.mid, .midi).`
   );
 }
 function abrirEnBlanco(opciones = {}) {
@@ -90464,7 +92542,7 @@ function reciboDeLaPesta\u00F1a(respuesta, ruta) {
     ...avisoDeLoQueNoSuena(mudas, 0)
   };
 }
-var ProblemaConLaObra, abierta, sigueViva, EXTENSIONES_IMPORTABLES;
+var ProblemaConLaObra, abierta, sigueViva, EXTENSIONES_IMPORTABLES, EXTENSIONES_MIDI;
 var init_obra = __esm({
   "apps/mcp/src/obra.ts"() {
     "use strict";
@@ -90475,6 +92553,7 @@ var init_obra = __esm({
     abierta = null;
     sigueViva = null;
     EXTENSIONES_IMPORTABLES = /* @__PURE__ */ new Set([".gp", ".gpx", ".gp5", ".gp4", ".gp3", ".musicxml", ".xml", ".mxl"]);
+    EXTENSIONES_MIDI = /* @__PURE__ */ new Set([".mid", ".midi", ".kar", ".rmi"]);
   }
 });
 
@@ -90483,7 +92562,7 @@ var VERSION_DEL_CONECTOR;
 var init_version = __esm({
   "apps/mcp/src/version.ts"() {
     "use strict";
-    VERSION_DEL_CONECTOR = true ? "0.2.16" : null;
+    VERSION_DEL_CONECTOR = true ? "0.2.18" : null;
   }
 });
 
@@ -98346,6 +100425,51 @@ var init_marcas = __esm({
   }
 });
 
+// packages/projection/src/diagramas.ts
+function diagramasValidos(v) {
+  return DIAGRAMAS_POSIBLES.includes(v) ? v : "no";
+}
+function claveDeLaForma(forma) {
+  return [...forma].sort((a, b) => a.cuerda - b.cuerda).map((n) => `${n.cuerda}:${n.traste}`).join(" ");
+}
+function formaDibujable(forma) {
+  if (forma.length < 2) return false;
+  return new Set(forma.map((n) => n.cuerda)).size === forma.length;
+}
+function formasDeLaPista(golpes) {
+  const cuentas = /* @__PURE__ */ new Map();
+  golpes.forEach(({ nombre, forma }, orden) => {
+    if (!formaDibujable(forma)) return;
+    const deEste = cuentas.get(nombre) ?? /* @__PURE__ */ new Map();
+    cuentas.set(nombre, deEste);
+    const clave = claveDeLaForma(forma);
+    const previa = deEste.get(clave);
+    if (previa) previa.veces += 1;
+    else deEste.set(clave, { forma, veces: 1, orden });
+  });
+  const elegidas = /* @__PURE__ */ new Map();
+  for (const [nombre, formas] of cuentas) {
+    const mejor = [...formas.values()].sort((a, b) => b.veces - a.veces || a.orden - b.orden)[0];
+    if (mejor) elegidas.set(nombre, mejor.forma);
+  }
+  return elegidas;
+}
+function cuerdasDelDiagrama(forma, cuerdas) {
+  const porCuerda = new Map(forma.map((n) => [n.cuerda, n.traste]));
+  const strings = [];
+  for (let c = cuerdas; c >= 1; c--) strings.push(porCuerda.get(c) ?? -1);
+  const pisados = forma.map((n) => n.traste).filter((t) => t > 0);
+  const maximo = pisados.length ? Math.max(...pisados) : 0;
+  const firstFret = maximo <= 5 ? 1 : Math.min(...pisados);
+  return { strings, firstFret };
+}
+var DIAGRAMAS_POSIBLES;
+var init_diagramas = __esm({
+  "packages/projection/src/diagramas.ts"() {
+    DIAGRAMAS_POSIBLES = ["no", "arriba", "partitura"];
+  }
+});
+
 // packages/projection/src/estilo.ts
 function comoLoEscribeCss(fuente) {
   const partes = [];
@@ -98510,6 +100634,9 @@ function proyectar(documento, opciones = {}) {
   score.album = marcado(cabecera.get("album") ?? "", marcasDe(cabecera, "album"));
   const tempoDeCabecera = documento.cabecera.get("tempo") || 120;
   score.stylesheet.hideDynamics = documento.cabecera.get("mostrarMatices") === false;
+  const diagramas = diagramasValidos(documento.cabecera.get("diagramasDeAcordes"));
+  score.stylesheet.globalDisplayChordDiagramsOnTop = diagramas === "arriba";
+  score.stylesheet.globalDisplayChordDiagramsInScore = diagramas === "partitura";
   score.stylesheet.barNumberDisplay = _barrel_exports$4.BarNumberDisplay.AllBars;
   const estiloDeLaObra = documento.leerEstilo();
   aplicarEstiloAlDibujo(score, ajustes, estiloDeLaObra);
@@ -98654,6 +100781,15 @@ function proyectar(documento, opciones = {}) {
       });
       acordesEscritos.sort((a, b) => a.compas - b.compas || a.tiempo - b.tiempo);
       const acordeVigente = buscadorDeAcorde(acordesEscritos);
+      const formaDelGolpe = (idFigura) => (notasPorFigura.get(idFigura) ?? []).map((n) => ({ cuerda: n.cuerda, traste: n.traste }));
+      const formasConNombre = diagramas !== "no" && pista.tipo === "trastes" ? formasDeLaPista(
+        maestros.flatMap(
+          (m) => deLaPista.flatMap((mapa) => {
+            const id2 = mapa.get(m.id);
+            return (id2 ? figurasPorCompas.get(id2) ?? [] : []).filter(({ datos: f }) => f.acorde).sort((a, b) => a.datos.tiempo - b.datos.tiempo).map(({ id: idFigura, datos: f }) => ({ nombre: f.acorde, forma: formaDelGolpe(idFigura) }));
+          })
+        )
+      ) : null;
       maestros.forEach((maestro, indiceDeCompas2) => {
         const barra = new _barrel_exports$4.Bar();
         pentagrama.addBar(barra);
@@ -98701,15 +100837,23 @@ function proyectar(documento, opciones = {}) {
             if (figura.texto) golpe.lyrics = [marcado(figura.texto, figura.textoSegundaTipografia)];
             if (figura.acorde) {
               const nombre = marcado(figura.acorde, figura.acordeSegundaTipografia);
-              if (!pentagrama.chords?.has(nombre)) {
+              const propia = formasConNombre ? formaDelGolpe(idFigura) : [];
+              const forma = formasConNombre ? formaDibujable(propia) ? propia : formasConNombre.get(figura.acorde) : void 0;
+              const id2 = forma ? `${nombre}|${claveDeLaForma(forma)}` : nombre;
+              if (!pentagrama.chords?.has(id2)) {
                 const acorde = new _barrel_exports$4.Chord();
                 acorde.name = nombre;
                 acorde.showName = true;
-                acorde.showDiagram = false;
+                acorde.showDiagram = forma !== void 0;
+                if (forma) {
+                  const { strings, firstFret } = cuerdasDelDiagrama(forma, pista.afinacion.length);
+                  acorde.strings = strings;
+                  acorde.firstFret = firstFret;
+                }
                 acorde.staff = pentagrama;
-                pentagrama.addChord(nombre, acorde);
+                pentagrama.addChord(id2, acorde);
               }
-              golpe.chordId = nombre;
+              golpe.chordId = id2;
             }
             golpe.dynamics = figura.dinamica;
             golpe.pickStroke = figura.puaDireccion;
@@ -98908,6 +101052,7 @@ var VOCES_POR_COMPAS, volumenDeMezcla;
 var init_proyectar = __esm({
   "packages/projection/src/proyectar.ts"() {
     init_alphaTab();
+    init_diagramas();
     init_estilo();
     init_src3();
     init_marcas();
@@ -98921,6 +101066,7 @@ var init_proyectar = __esm({
 // packages/projection/src/index.ts
 var src_exports2 = {};
 __export(src_exports2, {
+  DIAGRAMAS_POSIBLES: () => DIAGRAMAS_POSIBLES,
   ELEMENTOS_QUE_DIBUJA_EL_PROGRAMA: () => ELEMENTOS_QUE_DIBUJA_EL_PROGRAMA,
   ELEMENTOS_QUE_NO_SE_DIBUJAN: () => ELEMENTOS_QUE_NO_SE_DIBUJAN,
   MARCA_DE_BANDA: () => MARCA_DE_BANDA,
@@ -98928,6 +101074,7 @@ __export(src_exports2, {
   aplicarColoresAlDibujo: () => aplicarColoresAlDibujo,
   aplicarEstiloAlDibujo: () => aplicarEstiloAlDibujo,
   aplicarFuentesAlDibujo: () => aplicarFuentesAlDibujo,
+  diagramasValidos: () => diagramasValidos,
   fuentePropiaDe: () => fuentePropiaDe,
   pasarLetraALaFila: () => pasarLetraALaFila,
   presentarPistas: () => presentarPistas,
@@ -98938,6 +101085,7 @@ __export(src_exports2, {
 var init_src5 = __esm({
   "packages/projection/src/index.ts"() {
     init_marcas();
+    init_diagramas();
     init_proyectar();
     init_estilo();
   }
@@ -123039,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",
@@ -123313,9 +125462,9 @@ function registrarHerramientasDelDocumento(servidor2) {
     "abrir_obra",
     {
       title: "Abrir una obra",
-      description: "Abre un archivo de partitura del disco y lo deja como la obra sobre la que trabajan las dem\xE1s herramientas. Entiende .mtabs (el formato de Mandioca Tabs), Guitar Pro (.gp, .gpx, .gp5, .gp4, .gp3) y MusicXML (.musicxml, .xml, .mxl). \u26A0\uFE0F **Si el m\xFAsico ya tiene el programa abierto y esperando, esto NO es lo que \xE9l ve**: un archivo abierto ac\xE1 es un documento aparte. Se comprueba antes y se avisa; para trabajar sobre su pantalla, `conectar_con_la_app`.",
+      description: "Abre un archivo de partitura del disco y lo deja como la obra sobre la que trabajan las dem\xE1s herramientas. Entiende .mtabs (el formato de Mandioca Tabs), Guitar Pro (.gp, .gpx, .gp5, .gp4, .gp3), MusicXML (.musicxml, .xml, .mxl) y MIDI (.mid, .midi). \u26A0\uFE0F **Si el m\xFAsico ya tiene el programa abierto y esperando, esto NO es lo que \xE9l ve**: un archivo abierto ac\xE1 es un documento aparte. Se comprueba antes y se avisa; para trabajar sobre su pantalla, `conectar_con_la_app`.",
       inputSchema: {
-        ruta: external_exports.string().describe("La ruta completa del archivo: .mtabs, Guitar Pro (.gp, .gpx, .gp5\u2026) o MusicXML (.musicxml, .xml, .mxl)"),
+        ruta: external_exports.string().describe("La ruta completa del archivo: .mtabs, Guitar Pro (.gp, .gpx, .gp5\u2026), MusicXML (.musicxml, .xml, .mxl) o MIDI (.mid)"),
         igual: external_exports.boolean().optional().describe(
           "Abrir el archivo aunque el m\xFAsico tenga el programa abierto. Sirve para trabajar sobre un archivo del disco a prop\xF3sito, sin tocar lo que \xE9l est\xE1 mirando."
         )
@@ -124069,6 +126218,46 @@ function registrarHerramientasDelPuente(servidor2) {
     },
     async (args2) => texto3(await pedirALaPesta\u00F1a("metronomo", args2))
   );
+  servidor2.registerTool(
+    "elegir_voz",
+    {
+      title: "Elegir en qu\xE9 voz escribe el m\xFAsico",
+      description: "Cambia la voz del cursor en la pantalla (1 a 4): lo que el m\xFAsico teclee despu\xE9s cae en esa voz. Es el selector \xABVoz\xBB de la barra. Las herramientas que escriben ya reciben su propia `voz`; \xE9sta es para dejarle la pantalla lista. Sin decir cu\xE1l, pasa a la siguiente. Contesta la voz y d\xF3nde qued\xF3 el cursor.",
+      inputSchema: {
+        voz: external_exports.number().int().min(1).max(4).optional().describe("De 1 a 4. Sin esto, la siguiente.")
+      }
+    },
+    async (args2) => texto3(await pedirALaPesta\u00F1a("elegir_voz", args2))
+  );
+  servidor2.registerTool(
+    "bucle",
+    {
+      title: "Repetir un pasaje en bucle",
+      description: "Pone o saca el bucle: la reproducci\xF3n repite esos compases una y otra vez. Con `compas` (y `hasta`) repite esos; sin ellos, el pasaje marcado en pantalla o el comp\xE1s del cursor. Sin decir nada, alterna. No se guarda en la obra. La cuenta previa y la velocidad que sube se ajustan con `practica`.",
+      inputSchema: {
+        puesto: external_exports.boolean().optional().describe("true lo pone, false lo saca. Sin esto, alterna."),
+        compas: external_exports.number().int().min(1).max(9999).optional().describe("Primer comp\xE1s del tramo, desde 1."),
+        hasta: external_exports.number().int().min(1).max(9999).optional().describe("\xDAltimo comp\xE1s del tramo, incluido.")
+      }
+    },
+    async (args2) => texto3(await pedirALaPesta\u00F1a("bucle", args2))
+  );
+  servidor2.registerTool(
+    "practica",
+    {
+      title: "Ajustes de pr\xE1ctica",
+      description: "C\xF3mo se practica con el bucle: `cuentaPrevia` toca un comp\xE1s de clicks antes de que entre la m\xFAsica (en cada play); `subirVelocidad` hace que, con el bucle puesto, la velocidad arranque en `desde` y suba `paso` cada `cadaVueltas` vueltas hasta `hasta`. De f\xE1brica todo apagado. Es de quien toca, no de la obra. Sin nada, contesta c\xF3mo est\xE1.",
+      inputSchema: {
+        cuentaPrevia: external_exports.boolean().optional(),
+        subirVelocidad: external_exports.boolean().optional(),
+        desde: external_exports.number().min(0.25).max(1.5).optional().describe("Velocidad de la primera vuelta; 1 es la normal."),
+        hasta: external_exports.number().min(0.25).max(1.5).optional().describe("De ah\xED no pasa."),
+        paso: external_exports.number().min(0.01).max(0.25).optional().describe("Cu\xE1nto sube cada vez: 0,05 es 5 %."),
+        cadaVueltas: external_exports.number().int().min(1).max(16).optional()
+      }
+    },
+    async (args2) => texto3(await pedirALaPesta\u00F1a("practica", args2))
+  );
   servidor2.registerTool(
     "avanzar_al_escribir",
     {
@@ -124544,7 +126733,7 @@ function registrarHerramientasDelPuente(servidor2) {
       title: "Abrir una obra en la pantalla del m\xFAsico",
       description: "Abre un `.mtabs` o un `.gp` del disco **en la pesta\xF1a que el m\xFAsico tiene delante**. \u26A0\uFE0F Esto NO es `abrir_obra`: aqu\xE9lla abre el archivo como un documento aparte, que el m\xFAsico no ve. \xC9sta se lo pone en pantalla. \u26A0\uFE0F Y no es `abrir_reciente`, que s\xF3lo alcanza los de su lista: ac\xE1 va cualquier ruta. \u2605 Funciona tambi\xE9n con la pantalla de inicio abierta y ninguna obra cargada, que es para lo que se hizo. \u26A0\uFE0F\u26A0\uFE0F **Falla si hay trabajo sin guardar**, y dice cu\xE1l: abrir otra cosa encima lo perder\xEDa, y \xE9sa no es una decisi\xF3n que se tome por el m\xFAsico.",
       inputSchema: {
-        ruta: external_exports.string().min(1).describe("La ruta completa en el disco: .mtabs, Guitar Pro (.gp, .gpx, .gp5\u2026) o MusicXML (.musicxml, .xml, .mxl)")
+        ruta: external_exports.string().min(1).describe("La ruta completa en el disco: .mtabs, Guitar Pro (.gp, .gpx, .gp5\u2026), MusicXML (.musicxml, .xml, .mxl) o MIDI (.mid)")
       }
     },
     async ({ ruta }) => {
@@ -125010,6 +127199,22 @@ function registrarHerramientasDeEstructura(servidor2) {
       });
     }
   );
+  servidor2.registerTool(
+    "diagramas_de_acordes",
+    {
+      title: "Diagramas de acordes",
+      description: "Si los nombres de acorde llevan su cuadrito de trastes: `no` (s\xF3lo el nombre, de f\xE1brica), `partitura` (sobre cada acorde) o `arriba` (una lista al comienzo). Se guarda en la obra. \u26A0\uFE0F El diagrama sale de lo ESCRITO: las notas del golpe, o la forma con que ese acorde est\xE1 escrito en otro lugar de la pista. Un nombre sin notas en ning\xFAn lado queda sin diagrama: el programa no inventa digitaciones. Sin decir nada, contesta c\xF3mo est\xE1.",
+      inputSchema: {
+        donde: external_exports.enum(["no", "partitura", "arriba"]).optional()
+      }
+    },
+    ({ donde }) => {
+      const { documento } = obraAbierta();
+      if (donde !== void 0) documento.doc.transact(() => documento.cabecera.set("diagramasDeAcordes", donde));
+      const actual = documento.cabecera.get("diagramasDeAcordes");
+      return texto2({ diagramasDeAcordes: actual === "partitura" || actual === "arriba" ? actual : "no" });
+    }
+  );
   servidor2.registerTool(
     "estilo_de_la_obra",
     {
@@ -126824,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";
@@ -126881,6 +129174,7 @@ function crearServidor() {
   registrarHerramientasDeBend(servidor2);
   registrarHerramientasDePistas(servidor2);
   registrarHerramientasDeArchivo(servidor2);
+  registrarHerramientasDePaletas(servidor2);
   return servidor2;
 }