mandioca-tabs-mcp 0.2.17 → 0.2.19

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;
@@ -13730,7 +13731,7 @@ var init_kit = __esm({
     KIT = [
       { indice: 0, nombre: "Bombo", midi: 36, linea: 9, cabeza: "normal", grupo: "Parches" },
       { indice: 1, nombre: "Caja", midi: 38, linea: 5, cabeza: "normal", grupo: "Parches" },
-      { indice: 2, nombre: "Aro (rimshot)", midi: 37, linea: 5, cabeza: "x", grupo: "Parches" },
+      { indice: 2, nombre: "Aro (side stick)", midi: 37, linea: 5, cabeza: "x", grupo: "Parches" },
       { indice: 3, nombre: "Tom agudo", midi: 48, linea: 3, cabeza: "normal", grupo: "Parches" },
       { indice: 4, nombre: "Tom medio", midi: 45, linea: 4, cabeza: "normal", grupo: "Parches" },
       { indice: 5, nombre: "Tom de piso", midi: 41, linea: 7, cabeza: "normal", grupo: "Parches" },
@@ -14163,11 +14164,11 @@ var init_enBlanco = __esm({
 
 // packages/model/src/armadura.ts
 function armaduraEscrita(concierto, transposicion) {
-  if (!transposicion) return concierto;
+  if (!transposicion || transposicion % 12 === 0) return concierto;
   return normalizar(concierto - 7 * transposicion);
 }
 function armaduraDeConcierto(escrita, transposicion) {
-  if (!transposicion) return escrita;
+  if (!transposicion || transposicion % 12 === 0) return escrita;
   return normalizar(escrita + 7 * transposicion);
 }
 var normalizar;
@@ -14553,6 +14554,7 @@ function borrarNotaDeCuerda(documento, indice, cursor, cuerda) {
   documento.doc.transact(() => {
     documento.notas.delete(nota.id);
     if (quedan === 0) documento.figuras.get(figura.id)?.set("esSilencio", true);
+    repararLigaduras(documento, [cursor.pistaId], "soltar");
   });
   return true;
 }
@@ -14569,6 +14571,7 @@ function escribirSilencio(documento, indice, cursor, duracion = DURACION_INICIAL
       id2 = figuraExistente.id;
       for (const nota of notas) documento.notas.delete(nota.id);
       documento.figuras.get(id2)?.set("esSilencio", true);
+      if (notas.length > 0) repararLigaduras(documento, [cursor.pistaId], "soltar");
     } else {
       id2 = documento.agregarFigura({ ...figuraNueva(compasId, cursor, duracion), esSilencio: true });
     }
@@ -14749,32 +14752,61 @@ function copiar(indice, seleccion) {
   }
   const ultima = copiadas[copiadas.length - 1];
   const ultimaFigura = figuras[figuras.length - 1];
+  const tipo = indice.pista(seleccion.pistaId)?.datos.tipo;
   return {
     figuras: copiadas,
-    tics: ultima && ultimaFigura ? ultima.desplazamiento + ultimaFigura.tics : 0
+    tics: ultima && ultimaFigura ? ultima.desplazamiento + ultimaFigura.tics : 0,
+    ...tipo ? { tipo } : {}
   };
 }
+function tipoDeNota(nota) {
+  if (nota.articulacion !== null && nota.articulacion !== void 0) return "percusion";
+  if (nota.altura !== null && nota.altura !== void 0) return "altura";
+  return "trastes";
+}
+function porQueNoSePuedePegar(indice, cursor, portapapeles2) {
+  const destino = indice.pista(cursor.pistaId)?.datos;
+  if (!destino) return "Esa pista no existe.";
+  const notas = portapapeles2.figuras.flatMap((f) => f.notas);
+  if (notas.length === 0) return null;
+  const origen = portapapeles2.tipo;
+  if (origen ? origen !== destino.tipo : notas.some((n) => tipoDeNota(n) !== destino.tipo)) {
+    return "Lo copiado es de otro tipo de instrumento.";
+  }
+  if (destino.tipo === "trastes") {
+    const cuerdas = destino.afinacion.length;
+    const fuera = notas.find((n) => n.cuerda < 1 || n.cuerda > cuerdas);
+    if (fuera) return `Esta pista no tiene cuerda ${fuera.cuerda}.`;
+  }
+  return null;
+}
 function pegar(documento, indice, cursor, portapapeles2) {
   if (portapapeles2.figuras.length === 0) return false;
   if (!indice.pista(cursor.pistaId)) return false;
+  if (porQueNoSePuedePegar(indice, cursor, portapapeles2)) return false;
   const destinos = [];
   let compas = cursor.compas;
-  let tiempo = cursor.tiempo;
+  let exacto = cursor.tiempo;
   for (const figura of portapapeles2.figuras) {
     let maestro = indice.compasMaestro(compas);
     if (!maestro) return false;
-    while (tiempo >= ticsDeCompas(maestro.datos)) {
-      tiempo -= ticsDeCompas(maestro.datos);
+    while (Math.round(exacto) >= ticsDeCompas(maestro.datos)) {
+      exacto -= ticsDeCompas(maestro.datos);
       compas += 1;
       maestro = indice.compasMaestro(compas);
       if (!maestro) return false;
     }
-    destinos.push({ compas, tiempo, figura });
-    tiempo += ticsDeFigura({ ...figura, tupletNumerador: figura.tupletNumerador, tupletDenominador: figura.tupletDenominador });
+    const tiempo = Math.round(exacto);
+    exacto += ticsExactosDeFigura(figura);
+    destinos.push({ compas, tiempo, fin: Math.round(exacto), figura });
+    if (Math.round(exacto) > ticsDeCompas(maestro.datos)) {
+      compas += 1;
+      exacto = 0;
+    }
   }
   const tramos = /* @__PURE__ */ new Map();
   for (const d of destinos) {
-    const fin = d.tiempo + ticsDeFigura(d.figura);
+    const fin = d.fin;
     const tramo = tramos.get(d.compas);
     if (tramo) {
       tramo.desde = Math.min(tramo.desde, d.tiempo);
@@ -14865,7 +14897,9 @@ function duplicarUltima(documento, indice, cursor, opciones = {}) {
   } = anterior.datos;
   if (!opciones.sinAcorde && acordeSegundaTipografia !== void 0)
     Object.assign(golpe, { acordeSegundaTipografia });
+  const tipo = indice.pista(cursor.pistaId)?.datos.tipo;
   const portapapeles2 = {
+    ...tipo ? { tipo } : {},
     tics: ticsDeFigura(anterior.datos),
     figuras: [
       {
@@ -15161,14 +15195,17 @@ function ponerSilabaEnElGolpe(documento, indice, cursor, texto4, marcas) {
   });
   return true;
 }
-function escribirLetraEnLosGolpes(documento, indice, pistaId, voz, desdeCompas, silabas2) {
+function escribirLetraEnLosGolpes(documento, indice, pistaId, voz, desdeCompas, silabas2, pentagrama = 0) {
   let escritas = 0;
   documento.doc.transact(() => {
     for (let compas = desdeCompas; compas < indice.cantidadDeCompases; compas++) {
       if (escritas >= silabas2.length) break;
-      const compasId = indice.compasId(pistaId, compas);
+      const compasId = indice.compasId(pistaId, compas, pentagrama);
       for (const figura of indice.figuras(compasId, voz)) {
         if (escritas >= silabas2.length) break;
+        const notas = indice.notas(figura.id);
+        const seAtaca = !figura.datos.esSilencio && notas.length > 0 && notas.some((n) => !n.datos.ligadaAAnterior);
+        if (!seAtaca) continue;
         const palabra = silabas2[escritas].trim();
         escritas += 1;
         if (palabra === "") continue;
@@ -16448,16 +16485,25 @@ function moverNotasDeCuerda(documento, indice, cursor, seleccion, hacia) {
   }
   documento.doc.transact(() => {
     for (const { id: id2, cuerda } of destinos) documento.notas.get(id2)?.set("cuerda", cuerda);
+    repararLigaduras(documento, [cursor.pistaId], "soltar");
   });
   return { hecho: true, movidas: destinos.length };
 }
 var init_moverNotas = __esm({
   "packages/editor/src/moverNotas.ts"() {
     init_efectos();
+    init_ligaduras();
   }
 });
 
 // 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 +16511,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();
@@ -16473,7 +16519,7 @@ var init_atajos = __esm({
     init_teclasDeFabrica();
     init_comandos();
     init_teclado();
-    conMayusculas = (tecla) => `Shift+${tecla}`;
+    conMayusculas = (tecla) => `Ctrl+Shift+${tecla}`;
     COMANDOS_DE_MENU = [
       { id: "nuevo", nombre: "Nuevo archivo\u2026", grupo: "Archivo y salida" },
       { id: "abrir", nombre: "Abrir\u2026", grupo: "Archivo y salida" },
@@ -16496,6 +16542,16 @@ var init_atajos = __esm({
       { id: "voz-3", nombre: "Escribir en la voz 3", grupo: "Escribir notas" },
       { id: "voz-4", nombre: "Escribir en la voz 4", grupo: "Escribir notas" },
       { id: "voz-siguiente", nombre: "Pasar a la voz siguiente", grupo: "Escribir notas" },
+      // ★ Las dos puertas a las paletas que NO piden sostener nada (informe «Navegación de paletas
+      //   con teclado», 2026-11-11). Sin tecla de fábrica: el informe pide un comando reasignable,
+      //   y cualquier tecla libre que se eligiera acá le quitaría una a quien ya la usa para otra cosa.
+      //   · `paleta-con-teclado` deja ENGANCHADO el modo del Tab sostenido: para quien no puede
+      //     sostener teclas (temblor, una mano, teclado en pantalla). Sticky Keys de Windows sólo
+      //     engancha modificadores, y Tab no lo es. Se sale con Esc o con el mismo comando.
+      //   · `buscar-en-paletas` es la búsqueda de las siete a la vez: un combobox estándar, que es
+      //     además el camino principal para un lector de pantalla.
+      { id: "paleta-con-teclado", nombre: "Elegir en la paleta con el teclado, sin sostener Tab", grupo: "Escribir notas" },
+      { id: "buscar-en-paletas", nombre: "Buscar en las paletas\u2026", grupo: "Escribir notas" },
       // ── ⛔⛔ EL MENÚ DE LA LÍNEA DIVISORIA, que faltaba (2026-09-01) ───────────────
       //
       // Estas cuatro se construyeron el 2026-09-01 con su menú, su modelo y sus cuatro
@@ -16519,6 +16575,12 @@ var init_atajos = __esm({
       // ★ La sección (2026-09-13): el menú Compás la abre desde el cursor, y entra al catálogo el
       //   mismo día —asignable, sin tecla de fábrica—, que es la regla de toda acción nueva.
       { id: "compas-seccion", nombre: "Secci\xF3n en un comp\xE1s\u2026", grupo: "Compases" },
+      // ★ Repeticiones, casillas y saltos a mano (2026-11-11, función 3 de la competencia). Entran
+      //   el mismo día que el menú, sin tecla de fábrica y asignables. Los nombres llevan las
+      //   palabras que se buscan («casilla», «coda», «segno», «fine»): el buscador lee el nombre.
+      { id: "compas-repeticion", nombre: "Barras de repetici\xF3n en un comp\xE1s o pasaje\u2026", grupo: "Compases" },
+      { id: "compas-casillas", nombre: "Casillas de repetici\xF3n (1.\xAA, 2.\xAA\u2026)\u2026", grupo: "Compases" },
+      { id: "compas-saltos", nombre: "Saltos y destinos: D.C., D.S., Segno, Coda, Fine\u2026", grupo: "Compases" },
       { id: "borrar-compases-desde", nombre: "Borrar de un comp\xE1s en adelante", grupo: "Compases" },
       { id: "borrar-compases-hasta", nombre: "Borrar de un comp\xE1s para atr\xE1s", grupo: "Compases" },
       // ── EL ASPECTO DE LA OBRA (2026-09-01) ────────────────────────────
@@ -16657,11 +16719,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."
       },
@@ -16773,7 +16853,10 @@ var init_atajos = __esm({
       })),
       // ── Compases ──────────────────────────────────────────────────────────────
       { id: "insertar-compas", nombre: "Insertar un comp\xE1s", grupo: "Compases", teclas: ["Ctrl+Enter"], reasignable: true },
-      { id: "borrar-compas", nombre: "Borrar el comp\xE1s", grupo: "Compases", teclas: ["Shift+Delete", "Shift+Backspace"], reasignable: true },
+      // ⛔ (2026-11-11, C7) Decía «Shift+Delete»: la pantalla mostraba «May + Supr», y May + Supr
+      //    borra la NOTA (la tabla general no mira las Mayúsculas). La tecla que de verdad borra el
+      //    compás es Ctrl + May + Supr. Si se cambia de combinación es decisión de Daniel.
+      { id: "borrar-compas", nombre: "Borrar el comp\xE1s", grupo: "Compases", teclas: ["Ctrl+Shift+Delete", "Ctrl+Shift+Backspace"], reasignable: true },
       // ── Reproducción ──────────────────────────────────────────────────────────
       { id: "reproducir", nombre: "Reproducir o pausar", grupo: "Reproducci\xF3n", teclas: [" "], reasignable: true },
       // ★ «Desde el principio» (2026-10-15): Mayús + Espacio, como el «Play from Start» de Guitar Pro.
@@ -16790,6 +16873,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" };
   }
 });
 
@@ -16837,7 +16934,8 @@ function haceDiptongo(a, b) {
   if (esDebilAtona(a) && esDebilAtona(b)) return a !== b;
   return true;
 }
-function silabas(palabra, idioma = "es") {
+function silabas(palabraTalCual, idioma = "es") {
+  const palabra = palabraTalCual.normalize("NFC");
   if (!palabra) return [];
   if (idioma !== "es") return [palabra];
   const unidades = enUnidades(palabra);
@@ -16850,8 +16948,16 @@ function silabas(palabra, idioma = "es") {
       continue;
     }
     let fin = i2;
-    while (fin + 1 < unidades.length && unidades[fin + 1].vocal && haceDiptongo(unidades[fin].texto.toLowerCase(), unidades[fin + 1].texto.toLowerCase())) {
-      fin++;
+    for (; ; ) {
+      if (fin + 1 < unidades.length && unidades[fin + 1].vocal && haceDiptongo(unidades[fin].texto.toLowerCase(), unidades[fin + 1].texto.toLowerCase())) {
+        fin++;
+        continue;
+      }
+      if (fin + 2 < unidades.length && unidades[fin + 1].texto.toLowerCase() === "h" && unidades[fin + 2].vocal && haceDiptongo(unidades[fin].texto.toLowerCase(), unidades[fin + 2].texto.toLowerCase())) {
+        fin += 2;
+        continue;
+      }
+      break;
     }
     nucleos.push({ desde: i2, hasta: fin });
     i2 = fin + 1;
@@ -16881,7 +16987,7 @@ function silabas(palabra, idioma = "es") {
 }
 function leerLetra(texto4, idioma = "es") {
   const salida = [];
-  for (const cruda of texto4.split(/\r?\n/)) {
+  for (const cruda of texto4.normalize("NFC").split(/\r?\n/)) {
     const linea = cruda.trim();
     if (!linea) continue;
     const palabras = [];
@@ -20438,6 +20544,11 @@ function nombreLegible(deteccion) {
   const limpio = acorde.type === "major" && acorde.tonic ? acorde.tonic : cuerpo;
   return bajo ? `${limpio}/${bajo}` : limpio;
 }
+function afinacionQueSuena(pista) {
+  if (!pista) return [];
+  const capo = Number.isInteger(pista.capo) && pista.capo > 0 ? pista.capo : 0;
+  return pista.afinacion.map((n) => n + capo);
+}
 function notaMidi(cuerda, traste, afinacion) {
   const alAire = afinacion[cuerda - 1];
   return alAire === void 0 ? null : alAire + traste;
@@ -20468,10 +20579,10 @@ function acordeEnElCursor(indice, cursor) {
   const compasId = indice.compasId(cursor.pistaId, cursor.compas, cursor.pentagrama);
   const figura = compasId ? indice.figuraEn(compasId, cursor.voz, cursor.tiempo) : void 0;
   if (!figura) return null;
-  const afinacion = indice.pista(cursor.pistaId)?.datos.afinacion;
-  if (!afinacion) return null;
+  const pista = indice.pista(cursor.pistaId)?.datos;
+  if (!pista) return null;
   const notas = indice.notas(figura.id).map((n) => n.datos);
-  return acordeDeNotas(notas, afinacion);
+  return acordeDeNotas(notas, afinacionQueSuena(pista));
 }
 function claveDeForma(forma) {
   return [...forma].sort((a, b) => a.cuerda - b.cuerda).map((n) => `${n.cuerda}:${n.traste}`).join(" ");
@@ -20565,15 +20676,17 @@ function ponerAcorde(documento, indice, cursor, nombre, duracion = DURACION_INIC
     return null;
   }
   const yaTieneNotas = figura ? indice.notas(figura.id).length > 0 : false;
-  if (sinNombre && (yaTieneNotas || forma.length === 0)) return null;
+  const pista = indice.pista(cursor.pistaId)?.datos;
+  const formaQueEntra = pista?.tipo === "trastes" && forma.every((n) => n.cuerda >= 1 && n.cuerda <= pista.afinacion.length) ? forma : [];
+  if (sinNombre && (yaTieneNotas || formaQueEntra.length === 0)) return null;
   documento.doc.transact(() => {
     const compasId = compasExistente ?? documento.agregarCompas(normalizarCompas({ pistaId: cursor.pistaId, compasMaestroId: maestro.id, pentagrama: cursor.pentagrama }));
     const id2 = figura?.id ?? documento.agregarFigura({ ...figuraNueva(compasId, cursor, duracion), esSilencio: true });
     const mapa = documento.figuras.get(id2);
     if (mapa && !sinNombre) escribirConMarcas(mapa, "acorde", nombre ?? "", marcas, { recortar: true });
-    if (!yaTieneNotas && forma.length > 0) {
+    if (!yaTieneNotas && formaQueEntra.length > 0) {
       documento.figuras.get(id2)?.set("esSilencio", false);
-      for (const { cuerda, traste } of forma) {
+      for (const { cuerda, traste } of formaQueEntra) {
         documento.agregarNota(notaNueva(id2, cuerda, traste));
       }
     }
@@ -20612,9 +20725,207 @@ var init_acordes = __esm({
 });
 
 // packages/editor/src/miraDeAcordes.ts
+var MIRA_DEDUCIR;
 var init_miraDeAcordes = __esm({
   "packages/editor/src/miraDeAcordes.ts"() {
     init_acordes();
+    MIRA_DEDUCIR = "+deducir";
+  }
+});
+
+// packages/editor/src/paletasConTeclado.ts
+function fichasFijas(familia) {
+  switch (familia) {
+    case "figura":
+      return [
+        ...FIGURAS.map((f) => ({ id: `figura-${f.valor}`, nombre: f.nombre, atajo: `figura-${f.valor}` })),
+        { id: "puntillo", nombre: "puntillo", atajo: "puntillo" },
+        { id: "silencio", nombre: "silencio", atajo: "silencio" }
+      ].map(conSinonimos);
+    case "tecnica":
+      return [
+        ...EFECTOS_EN_ORDEN.map((e) => ({ id: `efecto-${e}`, nombre: EFECTOS[e].nombre, atajo: `efecto-${e}` })),
+        ...FORMAS_EN_ORDEN.map((f) => ({
+          id: `bend-${f}`,
+          nombre: FORMAS_DE_BEND[f].nombre,
+          ...f === "bend" ? { atajo: "bend" } : {}
+        })),
+        ...ALTURAS_DE_BEND.map((a) => ({ id: `sube-${a.cuartos}`, nombre: `sube ${a.nombre.toLowerCase()}` })),
+        { id: "curva", nombre: "curva propia" }
+      ].map(conSinonimos);
+    case "signo":
+      return GRUPOS_EN_ORDEN.flatMap(
+        (g) => signosDelGrupo(g).map((s) => ({ id: `signo-${s.clave}`, nombre: s.nombre, atajo: `signo-${s.clave}` }))
+      ).map(conSinonimos);
+    case "matiz":
+      return MATICES.map((m) => {
+        const [italiano = "", resto = ""] = m.detalle.split("\u2014");
+        const castellano = resto.split(".")[0] ?? "";
+        return {
+          id: `matiz-${m.nombre}`,
+          nombre: m.nombre,
+          sinonimos: [italiano.trim(), castellano.trim()].filter(Boolean),
+          atajo: `comando-matiz-${m.nombre}`
+        };
+      });
+    case "kit":
+      return KIT.map((p) => conSinonimos({ id: `kit-${p.indice}`, nombre: p.nombre }));
+    case "acorde":
+    case "seccion":
+      return [];
+  }
+}
+function fichasDeAcordes(usados) {
+  return [
+    { id: MIRA_DEDUCIR, nombre: "+ acorde", sinonimos: ["a\xF1adir", "deducir", "el del golpe"] },
+    ...usados.map((a) => ({ id: a.clave, nombre: a.letra ? `${a.nombre} ${a.letra}` : a.nombre }))
+  ];
+}
+function fichasDeSecciones(nombres) {
+  const vistos = /* @__PURE__ */ new Set();
+  const unicos = [];
+  for (const n of nombres) {
+    const limpio = n.trim();
+    if (limpio && !vistos.has(limpio)) {
+      vistos.add(limpio);
+      unicos.push(limpio);
+    }
+  }
+  return [
+    { id: SECCION_NUEVA, nombre: "nombre nuevo", sinonimos: ["escribir", "otra"] },
+    ...unicos.map((n) => ({ id: `seccion:${n}`, nombre: n }))
+  ];
+}
+function normalizarBusqueda(texto4) {
+  return texto4.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/\s+/g, " ").trim();
+}
+function puntajeDeBusqueda(ficha, texto4) {
+  const q = normalizarBusqueda(texto4);
+  if (!q) return null;
+  const nombre = normalizarBusqueda(ficha.nombre);
+  const otros = (ficha.sinonimos ?? []).map(normalizarBusqueda);
+  if (nombre === q) return -1;
+  if (nombre.startsWith(q)) return 0;
+  if (otros.some((s) => s.startsWith(q))) return 1;
+  const palabras = [nombre, ...otros].flatMap((t) => t.split(/[\s(),/-]+/));
+  if (palabras.some((p) => p.startsWith(q))) return 2;
+  if (nombre.includes(q) || otros.some((s) => s.includes(q))) return 3;
+  return null;
+}
+function buscarEnLasPaletas(paletas, texto4, limite = 12) {
+  if (!normalizarBusqueda(texto4)) return [];
+  const todos = [];
+  let orden = 0;
+  for (const { familia, fichas } of paletas) {
+    for (const ficha of fichas) {
+      const p = puntajeDeBusqueda(ficha, texto4);
+      if (p !== null) todos.push({ familia, ficha, puntaje: p, orden });
+      orden++;
+    }
+  }
+  return todos.sort((a, b) => a.puntaje - b.puntaje || a.orden - b.orden).slice(0, limite).map(({ familia, ficha, puntaje: p }) => ({ familia, ficha, puntaje: p }));
+}
+var NOMBRE_DE_LA_FAMILIA, SINONIMOS, conSinonimos, FIGURAS, SECCION_NUEVA;
+var init_paletasConTeclado = __esm({
+  "packages/editor/src/paletasConTeclado.ts"() {
+    init_efectos();
+    init_bend();
+    init_variantes();
+    init_signos();
+    init_dinamicas();
+    init_miraDeAcordes();
+    init_src2();
+    NOMBRE_DE_LA_FAMILIA = {
+      figura: "Figura",
+      tecnica: "T\xE9cnica",
+      signo: "Signo",
+      acorde: "Acorde",
+      kit: "Bater\xEDa",
+      matiz: "Matiz",
+      seccion: "Secci\xF3n"
+    };
+    SINONIMOS = {
+      // Figuras
+      "figura-1": ["entera", "whole"],
+      "figura-2": ["mitad", "half"],
+      "figura-4": ["cuarto", "quarter"],
+      "figura-8": ["octavo", "eighth"],
+      "figura-16": ["dieciseisavo", "sixteenth"],
+      "figura-32": ["treintaidosavo", "thirty-second"],
+      "figura-64": ["sesentaicuatroavo", "sixty-fourth"],
+      puntillo: ["punto", "dot"],
+      silencio: ["pausa", "rest"],
+      // Técnicas
+      "efecto-martillo": ["ligado", "hammer", "hammer-on", "pull-off"],
+      "efecto-deslizamiento": ["slide", "glissando", "arrastre"],
+      "efecto-muerta": ["apagada", "dead note", "muted"],
+      "efecto-palmMute": ["muteado", "apagado con la palma", "pm"],
+      "efecto-letRing": ["dejar sonar", "que suene"],
+      "efecto-vibrato": ["temblor"],
+      "efecto-fantasma": ["ghost", "nota fantasma"],
+      "efecto-armonico": ["harmonic", "flageolet"],
+      "efecto-staccato": ["staccato", "corto"],
+      "efecto-ligadaAAnterior": ["ligadura de prolongaci\xF3n", "tie", "prolongar"],
+      "bend-bend": ["estirar", "estirada", "bending"],
+      "bend-bendVuelta": ["release", "estirar y soltar"],
+      "bend-prebend": ["pre bend", "ya estirada"],
+      "bend-prebendVuelta": ["pre bend release"],
+      curva: ["curva de bend", "dibujar"],
+      // Signos
+      "signo-acento": ["accent", "marcato"],
+      "signo-ligaduraDeExpresion": ["ligado", "slur", "legato"],
+      "signo-calderon": ["fermata", "corona"],
+      "signo-pedal": ["sustain", "pedal"],
+      "signo-anchoDeVibrato": ["vibrato"],
+      "signo-vibratoDePalanca": ["whammy", "tremolo bar", "palanca"],
+      "signo-tappingIzquierda": ["tap"],
+      "signo-dedoIzquierda": ["digitacion", "dedo", "fingering"],
+      "signo-cejilla": ["barre", "cejuela", "capo"],
+      "signo-puaDireccion": ["pick", "plectro", "downstroke", "upstroke", "direccion"],
+      "signo-rasgueo": ["arpegio", "strum", "brush"],
+      "signo-rasgueado": ["flamenco"],
+      "signo-slap": ["bajo"],
+      "signo-pop": ["bajo"],
+      "signo-tapping": ["tap"],
+      "signo-slapMuerto": ["dead slap"],
+      "signo-golpeEnLaTapa": ["percusion", "tapa"],
+      "signo-dedoDerecha": ["pima", "digitacion", "dedo"],
+      "signo-adorno": ["grace", "appoggiatura", "acciaccatura", "mordente"],
+      "signo-tremolo": ["tremolo picking", "tremolo"],
+      "signo-trino": ["trill"],
+      "signo-regulador": ["crescendo", "decrescendo", "hairpin"],
+      "signo-fundido": ["fade", "volume swell"],
+      "signo-wah": ["wah"],
+      "signo-alteracion": ["sostenido", "bemol", "becuadro", "accidental"],
+      "signo-muestraCuerda": ["cuerda", "string"],
+      "signo-barraOblicua": ["slash", "ritmo"],
+      "signo-plicaInvertida": ["plica", "stem"],
+      "signo-barrado": ["beam", "corchete"],
+      // Batería
+      "kit-0": ["kick", "bass drum"],
+      "kit-1": ["snare", "redoblante", "tarola"],
+      "kit-2": ["rimshot", "aro"],
+      "kit-3": ["tom", "high tom"],
+      "kit-4": ["tom", "mid tom"],
+      "kit-5": ["floor tom", "tom de pie"],
+      "kit-6": ["hi-hat", "hihat", "contratiempo", "hh"],
+      "kit-7": ["hi-hat abierto", "hihat abierto"],
+      "kit-8": ["hi-hat pedal", "pie"],
+      "kit-9": ["platillo", "crash"],
+      "kit-10": ["platillo", "ride"],
+      "kit-11": ["bell", "campana"]
+    };
+    conSinonimos = (f) => SINONIMOS[f.id] ? { ...f, sinonimos: SINONIMOS[f.id] } : f;
+    FIGURAS = [
+      { valor: 1, nombre: "redonda" },
+      { valor: 2, nombre: "blanca" },
+      { valor: 4, nombre: "negra" },
+      { valor: 8, nombre: "corchea" },
+      { valor: 16, nombre: "semicorchea" },
+      { valor: 32, nombre: "fusa" },
+      { valor: 64, nombre: "semifusa" }
+    ];
+    SECCION_NUEVA = "+nueva";
   }
 });
 
@@ -20823,9 +21134,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 },
@@ -21164,7 +21477,7 @@ var init_estado = __esm({
       "estado.info": {
         nombre: "Panel de info",
         accion: "info",
-        principiante: "Muestra u oculta el panel de arriba a la derecha, que explica lo que est\xE1 bajo el puntero. Cuando el c\xEDrculo est\xE1 amarillo, el panel est\xE1 a la vista; gris, est\xE1 oculto. Tambi\xE9n se prende y se apaga con la tecla de signo de pregunta.",
+        principiante: "Muestra u oculta la franja de debajo de las herramientas, que explica lo que est\xE1 bajo el puntero. Cuando el c\xEDrculo est\xE1 amarillo, el panel est\xE1 a la vista; gris, est\xE1 oculto. Tambi\xE9n se prende y se apaga con la tecla de signo de pregunta.",
         profesional: "Muestra u oculta el panel de info. Tecla: ?"
       }
     };
@@ -21199,8 +21512,8 @@ var init_menus = __esm({
       },
       "menu-compas": {
         nombre: "Men\xFA Comp\xE1s",
-        principiante: "Lo que se hace con el comp\xE1s donde est\xE1 el cursor: insertar uno nuevo, borrarlo, cambiarle el tempo, la m\xE9trica o la tonalidad desde ah\xED, marcarlo como anacruza o ponerle el nombre de una secci\xF3n.",
-        profesional: "Estructura del comp\xE1s del cursor: insertar, borrar, tempo, m\xE9trica, tonalidad, anacruza y secci\xF3n."
+        principiante: "Lo que se hace con el comp\xE1s donde est\xE1 el cursor: insertar uno nuevo, borrarlo, cambiarle el tempo, la m\xE9trica o la tonalidad desde ah\xED, marcarlo como anacruza o ponerle el nombre de una secci\xF3n. Tambi\xE9n pone repeticiones, casillas, D.C., D.S. y Coda.",
+        profesional: "Comp\xE1s del cursor: insertar, borrar, tempo, m\xE9trica, tonalidad, anacruza, secci\xF3n, repetici\xF3n, casillas y saltos."
       },
       "menu-nota": {
         nombre: "Men\xFA Nota",
@@ -21214,8 +21527,8 @@ var init_menus = __esm({
       },
       "menu-configuracion": {
         nombre: "Men\xFA Configuraci\xF3n",
-        principiante: "Los ajustes del programa que son tuyos y no de la obra: las teclas de cada acci\xF3n y c\xF3mo se sincroniza la letra.",
-        profesional: "Atajos de teclado y sincronizaci\xF3n de letra."
+        principiante: "Los ajustes del programa que son tuyos y no de la obra: las teclas de cada acci\xF3n, c\xF3mo se sincroniza la letra, c\xF3mo se escribe y tu privacidad.",
+        profesional: "Atajos, sincronizaci\xF3n de letra, escritura y privacidad."
       },
       // ── Archivo ─────────────────────────────────────────────────────────────────
       nuevo: {
@@ -21225,8 +21538,8 @@ var init_menus = __esm({
       },
       abrir: {
         nombre: "Abrir\u2026",
-        principiante: "Abre una obra que est\xE1 en tu computadora: un proyecto de Mandioca Tabs (.mtabs) o un archivo de Guitar Pro, MusicXML y otros formatos de tablatura. Si hay cambios sin guardar, te pregunta antes.",
-        profesional: "Abre .mtabs, .gp y MusicXML."
+        principiante: "Abre una obra que est\xE1 en tu computadora: un proyecto de Mandioca Tabs (.mtabs) o un archivo de Guitar Pro, MusicXML, MIDI y otros formatos de tablatura. Si hay cambios sin guardar, te pregunta antes.",
+        profesional: "Abre .mtabs, .gp, MusicXML y MIDI."
       },
       "menu-recientes": {
         nombre: "Abrir reciente",
@@ -21301,6 +21614,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",
@@ -21333,7 +21658,7 @@ var init_menus = __esm({
         nombre: "Insertar un comp\xE1s",
         accion: "insertar-compas",
         principiante: "Agrega un comp\xE1s vac\xEDo justo despu\xE9s del comp\xE1s donde est\xE1 el cursor. Para meterlo antes de uno en particular, haz clic derecho sobre su l\xEDnea divisoria.",
-        profesional: "Inserta un comp\xE1s despu\xE9s del del cursor."
+        profesional: "Inserta un comp\xE1s despu\xE9s del comp\xE1s del cursor."
       },
       "menu-borrar-compas": {
         nombre: "Borrar el comp\xE1s",
@@ -21348,7 +21673,7 @@ var init_menus = __esm({
         profesional: "Borra del comp\xE1s del cursor al final."
       },
       "menu-borrar-hasta": {
-        nombre: "Borrar para atr\xE1s",
+        nombre: "Borrar los compases antes",
         accion: "comando-borrar-compases-hasta",
         principiante: "Borra todos los compases que est\xE1n antes del cursor, desde el principio de la obra. El comp\xE1s del cursor pasa a ser el primero.",
         profesional: "Borra del principio al comp\xE1s anterior al cursor."
@@ -21383,6 +21708,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",
@@ -21492,12 +21835,12 @@ var init_menus = __esm({
       },
       "menu-compases-por-linea": {
         nombre: "Compases por l\xEDnea",
-        principiante: "Cu\xE1ntos compases entran en cada rengl\xF3n. En vista horizontal, cu\xE1ntos se ven a la vez en la ventana. Con \xABLos que entren\xBB el programa los acomoda seg\xFAn su contenido.",
+        principiante: "Cu\xE1ntos compases entran en cada rengl\xF3n. En vista horizontal, cu\xE1ntos se ven a la vez en la ventana. Con \xABLos que entren\xBB el programa pone los que quepan en el ancho, seg\xFAn lo que lleve cada uno.",
         profesional: "Compases por sistema."
       },
       "menu-cpl": {
         nombre: "Compases por l\xEDnea",
-        principiante: "Pone esta cantidad de compases en cada rengl\xF3n. \xABLos que entren\xBB deja que el programa decida seg\xFAn el ancho de la pantalla.",
+        principiante: "Pone esta cantidad de compases en cada rengl\xF3n. \xABLos que entren\xBB pone los que quepan en el ancho, seg\xFAn lo que lleve cada uno.",
         profesional: "Fija los compases por sistema."
       },
       "menu-ritmo": {
@@ -21651,6 +21994,12 @@ var init_barra = __esm({
         principiante: "Ajustes para practicar: un comp\xE1s de cuenta antes de que entre la m\xFAsica, y que la velocidad suba sola cada tantas vueltas del bucle hasta la que elijas. De f\xE1brica todo apagado.",
         profesional: "Count-in y speed trainer del bucle."
       },
+      // ★ Sólo existe con el teléfono parado (2026-11-11): la de escritorio vive en el panel de audio.
+      "barra.velocidad": {
+        nombre: "Velocidad",
+        principiante: "La obra suena m\xE1s lenta o m\xE1s r\xE1pida, de \xD70,25 a \xD71,5. La afinaci\xF3n no cambia. Sirve para sacar un pasaje dif\xEDcil de a poco.",
+        profesional: "Velocidad del transporte, \xD70,25 a \xD71,5, con el tono intacto."
+      },
       "barra.voz": {
         nombre: "Voz",
         principiante: "En qu\xE9 voz escribes. Una voz es una l\xEDnea mel\xF3dica dentro del mismo pentagrama: por ejemplo, el bajo en la voz 1 y la melod\xEDa en la voz 2, cada una con sus propias figuras. Lo que teclees va a la voz marcada.",
@@ -21711,7 +22060,7 @@ function fichaDeSigno(s) {
     profesional: s.ayuda.length <= 120 && (s.ayuda.match(/[.!?](\s|$)/g) ?? []).length <= 2 ? s.ayuda : `${s.nombre}.`
   };
 }
-var FICHAS_DE_SIGNOS, FIGURAS, FICHAS_DE_FIGURAS, FICHAS_DE_MATICES, FICHAS_DE_LA_PALETA;
+var FICHAS_DE_SIGNOS, FIGURAS2, FICHAS_DE_FIGURAS, FICHAS_DE_MATICES, FICHAS_DE_LA_PALETA;
 var init_paleta = __esm({
   "packages/editor/src/info/fichas/paleta.ts"() {
     init_signos();
@@ -21719,7 +22068,7 @@ var init_paleta = __esm({
     FICHAS_DE_SIGNOS = Object.fromEntries(
       SIGNOS.map((s) => [`signo.${s.clave}`, fichaDeSigno(s)])
     );
-    FIGURAS = [
+    FIGURAS2 = [
       { valor: 1, nombre: "Redonda", dura: "cuatro tiempos en un comp\xE1s de 4/4" },
       { valor: 2, nombre: "Blanca", dura: "dos tiempos" },
       { valor: 4, nombre: "Negra", dura: "un tiempo" },
@@ -21729,7 +22078,7 @@ var init_paleta = __esm({
       { valor: 64, nombre: "Semifusa", dura: "un dieciseisavo de tiempo" }
     ];
     FICHAS_DE_FIGURAS = Object.fromEntries(
-      FIGURAS.map((f) => [
+      FIGURAS2.map((f) => [
         `figura.${f.valor}`,
         {
           nombre: f.nombre,
@@ -21898,6 +22247,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",
@@ -21948,7 +22310,7 @@ var init_paneles = __esm({
       },
       "mezcla.volumen": {
         nombre: "Volumen de la pista",
-        principiante: "Cu\xE1nto suena esta pista, en decibeles. 0 dB es el m\xE1ximo; los n\xFAmeros negativos bajan. Se cambia arrastrando, con las flechas o escribiendo.",
+        principiante: "Cu\xE1nto suena esta pista, en decibeles. Llega hasta +6 dB; los n\xFAmeros negativos bajan. Se cambia arrastrando, con las flechas o escribiendo.",
         profesional: "Volumen de la pista, en dB."
       },
       "mezcla.paneo": {
@@ -22044,6 +22406,11 @@ var init_paneles = __esm({
         principiante: "Empieza la separaci\xF3n con la cantidad elegida. Las partes aparecen como grabaciones nuevas de la obra.",
         profesional: "Lanza la separaci\xF3n."
       },
+      "audio.stems-cancelar": {
+        nombre: "Cancelar la separaci\xF3n",
+        principiante: "Detiene la separaci\xF3n. No se agrega ninguna pista a la obra.",
+        profesional: "Aborta la separaci\xF3n sin escribir."
+      },
       "audio.letra-cerrar": {
         nombre: "Cerrar la letra",
         principiante: "Cierra el panel de la letra y vuelve a la partitura. Lo escrito se queda.",
@@ -22170,7 +22537,7 @@ var init_paneles = __esm({
       },
       "inicio.abrir": {
         nombre: "Abrir un archivo",
-        principiante: "Abre un proyecto o un archivo de Guitar Pro o MusicXML que est\xE9 en tu computadora.",
+        principiante: "Abre un proyecto o un archivo de Guitar Pro, MusicXML o MIDI que est\xE9 en tu computadora.",
         profesional: "Abre un archivo."
       },
       "inicio.reciente": {
@@ -22265,6 +22632,21 @@ var init_paneles = __esm({
         principiante: "Pone una armadura nueva desde el comp\xE1s que empieza en esta l\xEDnea, hasta el pr\xF3ximo cambio.",
         profesional: "Cambio de armadura desde este comp\xE1s."
       },
+      "linea.repeticion": {
+        nombre: "Repetici\xF3n",
+        principiante: "Pone las barras de repetici\xF3n en el comp\xE1s que empieza en esta l\xEDnea. Si ese comp\xE1s est\xE1 dentro de un pasaje marcado, las pone en todo el pasaje.",
+        profesional: "Barras de repetici\xF3n aqu\xED o en el pasaje."
+      },
+      "linea.casillas": {
+        nombre: "Casillas",
+        principiante: "Pone una casilla 1.\xAA, 2.\xAA\u2026 en el comp\xE1s que empieza en esta l\xEDnea, o en todo el pasaje marcado si est\xE1 adentro.",
+        profesional: "Casillas aqu\xED o en el pasaje."
+      },
+      "linea.saltos": {
+        nombre: "D.C., D.S. y Coda",
+        principiante: "Pone un salto o un destino \u2014Segno, Coda, Fine, D.S. al Coda\u2014 en el comp\xE1s que empieza en esta l\xEDnea.",
+        profesional: "Saltos y destinos de este comp\xE1s."
+      },
       "linea.insertar-izquierda": {
         nombre: "Insertar comp\xE1s a la izquierda",
         principiante: "Mete un comp\xE1s vac\xEDo ANTES del comp\xE1s que empieza en esta l\xEDnea. Sirve tambi\xE9n para agregar uno al principio de la obra.",
@@ -22489,6 +22871,37 @@ var init_dialogos = __esm({
         principiante: "Escribe c\xF3mo se llama la parte \u2014Intro, Coro, Puente\u2014. Vac\xEDo, saca la secci\xF3n que hab\xEDa.",
         profesional: "Texto de la secci\xF3n; vac\xEDo la quita."
       },
+      // ── Repeticiones, casillas y saltos (2026-11-11) ────────────────────────────
+      "repeticion.abre": {
+        nombre: "Barra de inicio",
+        principiante: "La barra con dos puntos que marca d\xF3nde empieza lo que se repite. Desm\xE1rcala para quitarla.",
+        profesional: "Barra de inicio de repetici\xF3n."
+      },
+      "repeticion.cierra": {
+        nombre: "Barra de fin",
+        principiante: "La barra con dos puntos donde la m\xFAsica vuelve al inicio de la repetici\xF3n. Desm\xE1rcala para quitarla.",
+        profesional: "Barra de fin de repetici\xF3n."
+      },
+      "repeticion.veces": {
+        nombre: "Veces",
+        principiante: "Cu\xE1ntas veces se toca el pasaje en total, contando la primera. 2 es lo normal y no se escribe en el pliego; desde 3 aparece \xABx3\xBB.",
+        profesional: "Pasadas totales (2\u201364)."
+      },
+      "casillas.vuelta": {
+        nombre: "Vuelta",
+        principiante: "En qu\xE9 vuelta de la repetici\xF3n se toca este comp\xE1s. Puedes marcar m\xE1s de una, como \xAB1. 2.\xBB. Sin ninguna marcada, se quita la casilla.",
+        profesional: "Vueltas en que suena; ninguna la quita."
+      },
+      "saltos.destino": {
+        nombre: "Destino",
+        principiante: "Un lugar al que otro comp\xE1s salta: el Segno para un D.S., la Coda para un \xABal Coda\xBB, el Fine para un \xABal Fine\xBB.",
+        profesional: "Marca de destino (Segno, Coda, Fine)."
+      },
+      "saltos.salto": {
+        nombre: "Salto",
+        principiante: "Manda la m\xFAsica a otro lugar al terminar el comp\xE1s. D.C. vuelve al principio y D.S. al Segno. To Coda marca d\xF3nde se salta a la Coda en la segunda pasada.",
+        profesional: "Salto (D.C., D.S., To Coda\u2026)."
+      },
       "golpe.letra": {
         nombre: "S\xEDlaba",
         principiante: "La s\xEDlaba de la letra que se canta en este golpe. Vac\xEDa, saca la que hab\xEDa.",
@@ -23029,6 +23442,7 @@ var init_src3 = __esm({
     init_silabas();
     init_acordes();
     init_miraDeAcordes();
+    init_paletasConTeclado();
     init_alinearLetra();
     init_diapason();
     init_video();
@@ -87649,6 +88063,156 @@ 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;
+    const clave = porNombre !== null ? "nombre" : "nombreCorto";
+    const explicitas = MANO_EXPLICITA.test(String(d.get(clave) ?? "").trim()) && MANO_EXPLICITA.test(String(iz.get(clave) ?? "").trim());
+    if (!esTeclado(d.get("programaMidi")) && !explicitas) 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, MANO_EXPLICITA, esTeclado;
+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;
+    MANO_EXPLICITA = /\b(mano\s+(derecha|izquierda)|(right|left)\s+hand|m\.?\s?[di]\.?|[rl]\.?\s?h\.?|md|mi|rh|lh)\)?\s*$/i;
+    esTeclado = (programa) => typeof programa === "number" && (programa <= 7 || programa >= 16 && programa <= 20);
+  }
+});
+
 // node_modules/fflate/esm/index.mjs
 import { createRequire } from "module";
 function deflateSync(data, opts) {
@@ -88630,272 +89194,865 @@ 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 };
-}
-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]
-  }));
+  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 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 elementoTranspose(semitonos, numero2) {
+  if (!semitonos) return [];
+  const octavas = Math.trunc(semitonos / 12);
+  const resto = semitonos - octavas * 12;
+  const diatonico = Math.sign(resto) * PASOS_POR_SEMITONOS[Math.abs(resto)];
+  return [
+    numero2 === null ? "<transpose>" : `<transpose number="${numero2}">`,
+    `<diatonic>${diatonico}</diatonic>`,
+    `<chromatic>${resto}</chromatic>`,
+    ...octavas ? [`<octave-change>${octavas}</octave-change>`] : [],
+    "</transpose>"
+  ];
 }
-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 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 };
   }
-  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;
+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 entra = arrastre;
-    arrastre = "";
-    return (entra ? `<attributes>${entra}</attributes>` : "") + contenido;
-  });
-  return cuantos ? { texto: rearmar(parte, compases, nuevos), cuantos } : { texto: parte, cuantos: 0 };
+    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 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 direccionDeLasPalabras(texto4) {
+  return SALTO_POR_CLAVE.get(claveDeSalto(texto4)) ?? null;
 }
-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 saltosDelCompas(master) {
+  const s = [];
+  for (const [direccion, salto] of SALTOS) {
+    if (!master?.directions?.has(direccion)) continue;
+    s.push('<direction placement="above">', "<direction-type>");
+    s.push(salto.simbolo ? `<${salto.simbolo}/>` : `<words>${escapar(salto.texto ?? "")}</words>`);
+    s.push("</direction-type>", `<sound ${salto.sonido}/>`, "</direction>");
+  }
+  return s;
 }
-function 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 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) - staff.displayTranspositionPitch,
+      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.esAcorde) {
+    const n = opciones.numeroDeVoz;
+    if (beat.isLegatoOrigin && !beat.isLegatoDestination) notaciones.push(`<slur type="start" number="${n}"/>`);
+    if (beat.isLegatoDestination && !beat.isLegatoOrigin) notaciones.push(`<slur type="stop" number="${n}"/>`);
+  }
+  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;
+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", a?.elementType || `Percusi\xF3n ${art + 1}`));
+        l.push("</score-instrument>");
+      }
+      for (const [art, idInstrumento] of instrumentos) {
+        const a = track.percussionArticulations[art];
+        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 (indiceDeCompas2 === 0) {
+        const distintas = new Set(pentagramas.map((st) => st.displayTranspositionPitch)).size > 1;
+        pentagramas.forEach((st, k) => {
+          if (k > 0 && !distintas) return;
+          cambios.push(...elementoTranspose(st.displayTranspositionPitch, distintas ? k + 1 : null));
+        });
+      }
+      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, PASOS_POR_SEMITONOS, 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 };
+    PASOS_POR_SEMITONOS = [0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6];
+    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 === 1 ? "1 cambio de clave, armadura o comp\xE1s escrito entre las notas se puso al principio del comp\xE1s donde rige." : `${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 === 1 ? "1 nota de un acorde repartido entre los dos pentagramas se puso en el suyo." : `${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 === 1 ? "1 s\xEDlaba unida de la letra se marc\xF3 con su guion." : `${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;
@@ -88960,12 +90117,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,
@@ -89009,6 +90167,28 @@ function piezaDeBateria(pista, numero2) {
   const buscada = PARIENTE_GM[midi] ?? midi;
   return KIT.find((p) => p.midi === buscada)?.indice ?? null;
 }
+function golpesEnLigadura(score) {
+  const marcados = /* @__PURE__ */ new Set();
+  for (const track of score.tracks)
+    for (const staff of track.staves)
+      for (const bar of staff.bars)
+        for (const voice of bar.voices)
+          for (const beat of voice.beats) {
+            if (beat.isLegatoOrigin) marcados.add(beat);
+            for (const nota of beat.notes) {
+              const llegada = nota.slurDestination?.beat;
+              if (!llegada) continue;
+              const camino = [];
+              let b = beat;
+              while (b && b !== llegada && camino.length < 1e4) {
+                camino.push(b);
+                b = b.nextBeat;
+              }
+              if (b === llegada) for (const g of camino) marcados.add(g);
+            }
+          }
+  return marcados;
+}
 function importarGp(bytes, opciones = {}) {
   const xml = textoMusicXml(bytes);
   if (xml === null) {
@@ -89018,7 +90198,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;
 }
@@ -89054,6 +90234,7 @@ function importarScore(score, opciones = {}, datos = {}) {
     );
   }
   const saltosEscritos = saltosDelTexto(score);
+  const enLigadura = golpesEnLigadura(score);
   const idsDeCompasMaestro = score.masterBars.map(
     (maestro) => documento.agregarCompasMaestro(normalizarCompasMaestro({
       numerador: maestro.timeSignatureNumerator,
@@ -89095,7 +90276,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)
       ) : []
     }))
@@ -89107,6 +90292,7 @@ function importarScore(score, opciones = {}, datos = {}) {
     if (id2 !== void 0 && i2 > 0) documento.ponerSaltoDeRenglon(id2, true);
   }
   const letrasDobles = { cuantas: 0, versosDeMas: 0 };
+  const temposCorridos = { movidos: [], perdidos: [] };
   const tipoDelPentagrama = (p) => p.isPercussion ? "percusion" : p.tuning.length === 0 ? "altura" : "trastes";
   for (const pista of score.tracks) {
     if (pista.staves.length === 0) {
@@ -89172,6 +90358,7 @@ function importarScore(score, opciones = {}, datos = {}) {
           for (const a of maestroDelCompas?.tempoAutomations ?? []) {
             if (a.ratioPosition > 0) temposAMitad.set(Math.round(a.ratioPosition * ticsDelCompas), a.value);
           }
+          moverTemposAGolpes(temposAMitad, compasDeAlphaTab.voices[0], indice + 1, temposCorridos);
         }
         const pedalesDelCompas = /* @__PURE__ */ new Map();
         for (const marcador of compasDeAlphaTab.sustainPedals ?? []) {
@@ -89306,7 +90493,9 @@ function importarScore(score, opciones = {}, datos = {}) {
                   armonicoValor: nota.harmonicType !== _barrel_exports$4.HarmonicType.None && nota.harmonicType !== _barrel_exports$4.HarmonicType.Natural ? nota.harmonicValue : 0,
                   // ── Los signos de Guitar Pro, a nivel de nota ──────────────────
                   acento: nota.accentuated,
-                  ligaduraDeExpresion: nota.isSlurDestination || nota.slurDestination !== null,
+                  // ⛔ (D1) Antes: `isSlurDestination || slurDestination !== null`, que marcaba la nota
+                  //    de LLEGADA (donde la curva termina) y nunca leía el `<Legato>` de un `.gp`.
+                  ligaduraDeExpresion: enLigadura.has(golpe),
                   vibratoDePalanca: 0,
                   // ★ La anchura del vibrato: el campo viejo `vibrato` solo decía si había.
                   anchoDeVibrato: nota.vibrato,
@@ -89357,8 +90546,24 @@ function importarScore(score, opciones = {}, datos = {}) {
       `${letrasDobles.versosDeMas} golpe(s) tra\xEDan letra de un segundo verso o m\xE1s: se guard\xF3 el primero. Tabs lleva un rengl\xF3n de letra.`
     );
   }
+  const enCompases = (lista2) => `${lista2.length === 1 ? "comp\xE1s" : "compases"} ${lista2.join(", ")}`;
+  if (temposCorridos.movidos.length > 0) {
+    avisos.push(
+      `Un cambio de tempo ca\xEDa a mitad de una figura (${enCompases(temposCorridos.movidos)}). Se movi\xF3 al golpe m\xE1s cercano.`
+    );
+  }
+  if (temposCorridos.perdidos.length > 0) {
+    avisos.push(
+      `Un cambio de tempo ca\xEDa a mitad de una figura, sin otro golpe en el comp\xE1s (${enCompases(temposCorridos.perdidos)}). No se import\xF3.`
+    );
+  }
   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();
@@ -89449,6 +90654,25 @@ function acordeDelGolpe(golpe, pentagrama, bajos, parte, numeroDePentagrama, com
   const bajo = bajos?.get(`${parte}|${numeroDePentagrama}|${compas}|${golpe.displayStart}`) ?? "";
   return bajo && !nombre.endsWith(bajo) ? nombre + bajo : nombre;
 }
+function moverTemposAGolpes(tempos, voz, compas, corridos) {
+  if (tempos.size === 0) return;
+  const comienzos = new Set(
+    (voz?.isEmpty ? [] : voz?.beats ?? []).filter((g) => !g.isEmpty && g.graceType === _barrel_exports$4.GraceType.None && g.displayStart > 0).map((g) => g.displayStart)
+  );
+  const ordenados = [...tempos.entries()].sort((a, b) => a[0] - b[0]);
+  tempos.clear();
+  for (const [tic, bpm] of ordenados) {
+    if (comienzos.has(tic)) {
+      tempos.set(tic, bpm);
+      continue;
+    }
+    let mejor = null;
+    for (const c of comienzos) if (mejor === null || Math.abs(c - tic) < Math.abs(mejor - tic) || Math.abs(c - tic) === Math.abs(mejor - tic) && c > mejor) mejor = c;
+    const lista2 = mejor === null ? corridos.perdidos : corridos.movidos;
+    if (!lista2.includes(compas)) lista2.push(compas);
+    if (mejor !== null) tempos.set(mejor, bpm);
+  }
+}
 function tempoDelGolpe(golpe, delMaestro) {
   if (golpe.displayStart === 0) return void 0;
   const propio = golpe.automations?.find((a) => a.type === _barrel_exports$4.AutomationType.Tempo)?.value;
@@ -89475,13 +90699,15 @@ function ortografiaDe(ortografia, parte, pentagrama, compas, tic, nota) {
   const base = `${parte}|${pentagrama}|${compas}|${tic}|`;
   return ortografia.get(base + nota.calculateRealValue(false, false)) ?? ortografia.get(base + (nota.octave * 12 + nota.tone));
 }
-var SALIDA_DE_ID_GP, PARIENTE_GM, DIR, SALTO_POR_TEXTO, claveDeSalto;
+var SALIDA_DE_ID_GP, PARIENTE_GM, DIR, SALTO_POR_TEXTO;
 var init_importarGp = __esm({
   "packages/io/src/importarGp.ts"() {
     init_alphaTab();
     init_src2();
     init_src2();
+    init_manosDelPiano();
     init_musicxmlEntrada();
+    init_musicxml();
     SALIDA_DE_ID_GP = {
       31: 40,
       83: 53,
@@ -89546,6 +90772,7 @@ var init_importarGp = __esm({
       dsalfine: [DIR.JumpDalSegno, DIR.JumpDalSegnoAlFine],
       dssalcoda: [DIR.JumpDalSegno, DIR.JumpDalSegnoSegnoAlCoda],
       dssalfine: [DIR.JumpDalSegno, DIR.JumpDalSegnoSegnoAlFine],
+      dssalcoda2: [DIR.JumpDalSegno, DIR.JumpDalSegnoSegnoAlDoubleCoda],
       dss: [DIR.JumpDalSegno, DIR.JumpDalSegnoSegno],
       dcalcoda: [DIR.JumpDaCapo, DIR.JumpDaCapoAlCoda],
       dcalcoda2: [DIR.JumpDaCapo, DIR.JumpDaCapoAlDoubleCoda],
@@ -89556,7 +90783,6 @@ var init_importarGp = __esm({
       tocoda2: [DIR.JumpDaCoda, DIR.JumpDaDoubleCoda],
       fine: [DIR.TargetFine, DIR.TargetFine]
     };
-    claveDeSalto = (texto4) => texto4.toLowerCase().replace(/dals*segno/g, "ds").replace(/das*capo/g, "dc").replace(/[^a-z0-9]/g, "");
   }
 });
 
@@ -90054,7 +91280,7 @@ function claseDe(g) {
   if (g.esBateria) return "bateria";
   if (g.programa >= 24 && g.programa <= 31) return "guitarra";
   if (g.programa >= 32 && g.programa <= 39) return "bajo";
-  if (g.programa <= 7) return "piano";
+  if (g.programa <= 7 || g.programa >= 16 && g.programa <= 20) return "piano";
   return "altura";
 }
 function digitar(alturas, afinacion, ocupadas) {
@@ -90068,7 +91294,36 @@ function mejorDigitacion(alturas, afinacion, prohibidas) {
   let mejor = null;
   const actual = [];
   const usadas = /* @__PURE__ */ new Set();
+  const cuerdasLibres = afinacion.length - [...prohibidas].filter((c) => c >= 1 && c <= afinacion.length).length;
+  const puedeMejorar = (i2, colocadas, maximo, suma) => {
+    if (!mejor) return true;
+    const libres = cuerdasLibres - usadas.size;
+    const tope = colocadas + Math.min(alturas.length - i2, libres);
+    if (tope < mejor.colocadas) return false;
+    if (tope > mejor.colocadas) return true;
+    if (maximo > mejor.maximo) return false;
+    const faltan = mejor.colocadas - colocadas;
+    if (faltan <= 0) return maximo < mejor.maximo || suma < mejor.suma;
+    const minimos = [];
+    for (let k = i2; k < alturas.length; k++) {
+      let menor = Infinity;
+      for (let cuerda = 1; cuerda <= afinacion.length; cuerda++) {
+        if (usadas.has(cuerda) || prohibidas.has(cuerda)) continue;
+        const traste = alturas[k] - afinacion[cuerda - 1];
+        if (traste >= 0 && traste <= TRASTES && traste < menor) menor = traste;
+      }
+      if (menor !== Infinity) minimos.push(menor);
+    }
+    if (minimos.length < faltan) return false;
+    minimos.sort((a, b) => a - b);
+    const maximoPosible = Math.max(maximo, minimos[faltan - 1]);
+    if (maximoPosible > mejor.maximo) return false;
+    let sumaPosible = suma;
+    for (let k = 0; k < faltan; k++) sumaPosible += minimos[k];
+    return maximoPosible < mejor.maximo || sumaPosible < mejor.suma;
+  };
   const probar = (i2, colocadas, maximo, suma) => {
+    if (!puedeMejorar(i2, colocadas, maximo, suma)) return;
     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 };
@@ -90166,9 +91421,32 @@ function figurasQueLlenan(ini, fin, ventana) {
   }
   return salida;
 }
+function juntarPistasDeManos(grupos, avisos) {
+  const salida = [];
+  for (let i2 = 0; i2 < grupos.length; i2++) {
+    const a = grupos[i2];
+    const b = grupos[i2 + 1];
+    const base = b && claseDe(a) === "piano" && claseDe(b) === "piano" ? baseDeLasManos(a.nombre, b.nombre) : null;
+    if (!b || base === null) {
+      salida.push(a);
+      continue;
+    }
+    salida.push({
+      ...a,
+      nombre: base,
+      canales: [.../* @__PURE__ */ new Set([...a.canales, ...b.canales])],
+      notas: [...a.notas.map((n) => ({ ...n, mano: 0 })), ...b.notas.map((n) => ({ ...n, mano: 1 }))].sort(
+        (x2, y) => x2.ini - y.ini || x2.altura - y.altura
+      )
+    });
+    avisos.decir(`\xAB${a.nombre}\xBB y \xAB${b.nombre}\xBB son las dos manos de un piano: se abrieron como un solo instrumento.`);
+    i2++;
+  }
+  return salida;
+}
 function armarScore(leido, opciones, avisos) {
   const rejilla = rejillaDe(opciones.cuantizacion);
-  const grupos = leido.grupos.filter((g) => g.notas.length > 0);
+  const grupos = juntarPistasDeManos(leido.grupos.filter((g) => g.notas.length > 0), avisos);
   if (grupos.length === 0) {
     avisos.decir("El archivo no trae ninguna nota: se abri\xF3 una obra vac\xEDa con un piano.");
   }
@@ -90199,13 +91477,13 @@ function armarScore(leido, opciones, avisos) {
       if (fin <= ini) fin = ini + pasoEn(ventanas, ini);
       if (Math.abs(ini - cruda.ini) > 2) redondeadas++;
       else if (Math.abs(fin - cruda.fin) > 2 && clase !== "bateria") avisos.contar("duracion-ajustada");
-      notas.push({ ini, fin: Math.min(fin, finDeLaObra2), altura: cruda.altura, cuerda: 0 });
+      notas.push({ ini, fin: Math.min(fin, finDeLaObra2), altura: cruda.altura, cuerda: 0, ...cruda.mano !== void 0 ? { mano: cruda.mano } : {} });
     }
     notas.sort((a, b) => a.altura - b.altura || a.ini - b.ini || b.fin - a.fin);
     const limpias = [];
     for (const n of notas) {
       const anterior = limpias[limpias.length - 1];
-      if (anterior && anterior.altura === n.altura) {
+      if (anterior && anterior.altura === n.altura && anterior.mano === n.mano) {
         if (anterior.ini === n.ini) {
           avisos.contar("repetidas");
           continue;
@@ -90248,8 +91526,16 @@ function armarScore(leido, opciones, avisos) {
       const voces = repartirEnVoces(enRegistro, ventanas, avisos, (alturas, ocupadas) => digitar(alturas, afinacion, ocupadas));
       pista.pentagramas.push({ voces, clave: clase === "guitarra" ? _barrel_exports$4.Clef.G2 : _barrel_exports$4.Clef.F4 });
     } else if (clase === "piano") {
-      const derecha = notas.filter((n) => n.altura >= 60);
-      const izquierda = notas.filter((n) => n.altura < 60);
+      let derecha;
+      let izquierda;
+      if (notas.some((n) => n.mano !== void 0)) {
+        derecha = notas.filter((n) => n.mano !== 1);
+        izquierda = notas.filter((n) => n.mano === 1);
+      } else {
+        const manos = repartirManos(notas);
+        derecha = manos.derecha.map((i2) => notas[i2]).sort((a, b) => a.ini - b.ini || a.altura - b.altura);
+        izquierda = manos.izquierda.map((i2) => notas[i2]).sort((a, b) => a.ini - b.ini || a.altura - b.altura);
+      }
       pista.pentagramas.push({ voces: repartirEnVoces(derecha, ventanas, avisos, null), clave: _barrel_exports$4.Clef.G2 });
       pista.pentagramas.push({ voces: repartirEnVoces(izquierda, ventanas, avisos, null), clave: _barrel_exports$4.Clef.F4 });
     } else {
@@ -90277,7 +91563,8 @@ function armarScore(leido, opciones, avisos) {
     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.`);
+    const n = avisos.cuantas("sin-voz");
+    avisos.decir(`${n === 1 ? "Se descart\xF3 1 nota" : `Se descartaron ${n} notas`} 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).`);
@@ -90486,7 +91773,8 @@ function llenarVoz(voice, eventos, compas, indiceDeVoz, pista, cortesDeTresillo,
           beat.tupletNumerator = 3;
           beat.tupletDenominator = 2;
         }
-        for (const n of tramo.notas ?? []) {
+        const sinGolpe = pista.clase === "bateria" && (!primera || tramo.continua);
+        for (const n of sinGolpe ? [] : tramo.notas ?? []) {
           const note = new _barrel_exports$4.Note();
           if (pista.clase === "bateria") {
             note.percussionArticulation = indiceDeTecla.get(n.altura);
@@ -90515,6 +91803,7 @@ var init_importarMidi = __esm({
   "packages/io/src/importarMidi.ts"() {
     init_alphaTab();
     init_src2();
+    init_manosDelPiano();
     init_importarGp();
     MidiIlegible = class extends Error {
       constructor(mensaje) {
@@ -90667,7 +91956,7 @@ var init_importarMidi = __esm({
       "Sintetizador (sierra)",
       "Sintetizador (cal\xEDope)",
       "Sintetizador (chiff)",
-      "Sintetizador (charango)",
+      "Sintetizador (charang)",
       "Sintetizador (voz)",
       "Sintetizador (quintas)",
       "Sintetizador (bajo y melod\xEDa)",
@@ -90755,6 +92044,16 @@ function formatoQueNecesita(documento) {
     const pentagramas = pista.get("pentagramas");
     if (typeof pentagramas === "number" && pentagramas > 1) return 5;
   }
+  const conMarcas2 = (mapa) => {
+    let hay = false;
+    mapa.forEach((valor, clave) => {
+      if (clave.endsWith(SUFIJO_SEGUNDA) && typeof valor === "string" && valor.includes("1")) hay = true;
+    });
+    return hay;
+  };
+  if (conMarcas2(documento.cabecera)) return 5;
+  for (const grupo of [documento.compasesMaestros, documento.pistas, documento.figuras])
+    for (const entidad of grupo.values()) if (conMarcas2(entidad)) return 5;
   return 4;
 }
 function empaquetar(documento, opciones = {}) {
@@ -90803,7 +92102,12 @@ function desempaquetar(bytes) {
   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) {
+  if (typeof manifiesto.formato !== "number" || !Number.isFinite(manifiesto.formato)) {
+    throw new ArchivoIlegible(
+      "El manifiesto del archivo no dice de qu\xE9 versi\xF3n es. Abrirlo podr\xEDa borrarte lo que guard\xF3."
+    );
+  }
+  if (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.`
     );
@@ -90829,13 +92133,15 @@ function desempaquetar(bytes) {
       if (tipografiaId) fuentes.push({ tipografiaId, bytes: contenido });
     }
   }
-  return { documento, manifiesto, grabaciones, fuentes };
+  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";
@@ -90900,723 +92206,201 @@ function instalarRecorridoDeRepeticiones() {
           p.synthBpm = lastSyncPoint.synthBpm;
         } else if (syncPoints.length === 1) p.syncBpm = lastSyncPoint.synthBpm;
         else p.syncBpm = syncPoints[syncPoints.length - 2].syncBpm;
-        p.synthTime = lastSyncPoint.synthTime + ticksAMs(remainingTicks, lastSyncPoint.synthBpm);
-        p.syncTime = lastSyncPoint.syncTime + ticksAMs(remainingTicks, p.syncBpm);
-        if (!playContext.createNewSyncPoints) lastSyncPoint.updateSyncBpm(p.synthTime, p.syncTime);
-        syncPoints.push(p);
-      }
-    }
-    finish(controller.currentTick);
-    return playContext;
-  };
-  Generador.__recorridoDe19 = true;
-  return true;
-}
-var D, Repeticion, RecorridoDeCompases, ticksAMs;
-var init_recorridoDeRepeticiones = __esm({
-  "packages/io/src/recorridoDeRepeticiones.ts"() {
-    init_alphaTab();
-    D = {
-      TargetFine: 0,
-      TargetSegno: 1,
-      TargetSegnoSegno: 2,
-      TargetCoda: 3,
-      TargetDoubleCoda: 4,
-      JumpDaCoda: 17,
-      JumpDaDoubleCoda: 18
-    };
-    Repeticion = class {
-      group;
-      /** Con casillas, cada cierre termina la pasada y todos comparten el contador. */
-      conCasillas;
-      /** La pasada actual (desde 0): elige qué casillas suenan. */
-      pasada = 0;
-      /** Las repeticiones hechas por cierre (sólo sin casillas). */
-      iteraciones;
-      /** Las casillas del último compás que las tenía: los que no tienen, las continúan. */
-      casillasActuales = 0;
-      /** @param pasadaFinal si se toca como última pasada (después de un salto): sólo la última casilla. */
-      constructor(group, pasadaFinal) {
-        this.group = group;
-        this.conCasillas = group.masterBars.some((m) => m.alternateEndings !== 0);
-        this.iteraciones = group.closings.map((c) => pasadaFinal ? Math.max(0, c.repeatCount - 1) : 0);
-        if (pasadaFinal) for (const i2 of this.iteraciones) this.pasada = Math.max(this.pasada, i2);
-      }
-      suena(compas) {
-        let casillas = compas.alternateEndings;
-        if (casillas === 0) casillas = this.casillasActuales;
-        else this.casillasActuales = casillas;
-        return casillas === 0 || (casillas & 1 << this.pasada) !== 0;
-      }
-      /** 0 = seguir, 1 = volver al comienzo de la repetición, 2 = terminó. */
-      alCerrar(cierre, sono) {
-        const cierres = this.group.closings;
-        const esElUltimo = cierre === cierres[cierres.length - 1];
-        if (this.conCasillas) {
-          if (!sono && !esElUltimo) return 0;
-          if (this.pasada < cierre.repeatCount - 1) {
-            this.pasada++;
-            this.casillasActuales = 0;
-            return 1;
-          }
-          return esElUltimo ? 2 : 0;
-        }
-        const i2 = cierres.indexOf(cierre);
-        if (i2 === -1) return 0;
-        if (this.iteraciones[i2] < cierre.repeatCount - 1) {
-          this.iteraciones[i2]++;
-          for (let j = 0; j < i2; j++) this.iteraciones[j] = 0;
-          this.casillasActuales = 0;
-          return 1;
-        }
-        return esElUltimo ? 2 : 0;
-      }
-      /** Si algún cierre todavía va a volver por encima de este compás. */
-      vaAVolver(compas) {
-        const cierres = this.group.closings;
-        for (let i2 = 0; i2 < cierres.length; i2++) {
-          const cierre = cierres[i2];
-          if (cierre.index >= compas.index) {
-            if ((this.conCasillas ? this.pasada : this.iteraciones[i2]) < cierre.repeatCount - 1) return true;
-          }
-        }
-        return false;
-      }
-    };
-    RecorridoDeCompases = class _RecorridoDeCompases {
-      /** Los saltos en el orden en que se revisan si un compás tiene varios. */
-      static SALTOS = [
-        { jump: 5, target: null, playUntil: null, continueAt: null },
-        { jump: 6, target: null, playUntil: D.JumpDaCoda, continueAt: D.TargetCoda },
-        { jump: 7, target: null, playUntil: D.JumpDaDoubleCoda, continueAt: D.TargetDoubleCoda },
-        { jump: 8, target: null, playUntil: D.TargetFine, continueAt: null },
-        { jump: 9, target: D.TargetSegno, playUntil: null, continueAt: null },
-        { jump: 10, target: D.TargetSegno, playUntil: D.JumpDaCoda, continueAt: D.TargetCoda },
-        { jump: 11, target: D.TargetSegno, playUntil: D.JumpDaDoubleCoda, continueAt: D.TargetDoubleCoda },
-        { jump: 12, target: D.TargetSegno, playUntil: D.TargetFine, continueAt: null },
-        { jump: 13, target: D.TargetSegnoSegno, playUntil: null, continueAt: null },
-        { jump: 14, target: D.TargetSegnoSegno, playUntil: D.JumpDaCoda, continueAt: D.TargetCoda },
-        { jump: 15, target: D.TargetSegnoSegno, playUntil: D.JumpDaDoubleCoda, continueAt: D.TargetDoubleCoda },
-        { jump: 16, target: D.TargetSegnoSegno, playUntil: D.TargetFine, continueAt: null }
-      ];
-      score;
-      pila = [];
-      /** El D.C./D.S. que se siguió; null si se toca normal (antes del salto o después de la coda). */
-      saltoActivo = null;
-      /** Los compases cuyo salto ya se tomó: cada salto se toma una sola vez. */
-      saltosTomados = /* @__PURE__ */ new Set();
-      shouldPlay = true;
-      index = 0;
-      currentTick = 0;
-      constructor(score) {
-        this.score = score;
-      }
-      get finished() {
-        return this.index >= this.score.masterBars.length;
-      }
-      processCurrent() {
-        const compas = this.score.masterBars[this.index];
-        this.entrarARepeticion(compas);
-        const rep = this.pila.length > 0 ? this.pila[this.pila.length - 1] : null;
-        this.shouldPlay = rep === null || rep.suena(compas);
-        if (this.shouldPlay) this.currentTick += compas.calculateDuration();
-      }
-      moveNext() {
-        if (this.moverConSaltos()) return;
-        const compas = this.score.masterBars[this.index];
-        if (this.pila.length > 0 && compas.repeatCount > 1) {
-          const rep = this.pila[this.pila.length - 1];
-          switch (rep.alCerrar(compas, this.shouldPlay)) {
-            case 1:
-              this.index = rep.group.opening.index;
-              return;
-            case 2:
-              this.pila.pop();
-          }
-        }
-        this.index++;
-      }
-      /** Empieza la repetición del compás si hace falta: al llegar a su apertura, o tras un salto que cayó adentro. */
-      entrarARepeticion(compas) {
-        const group = compas.repeatGroup;
-        if (!group.isClosed || this.pila.some((r) => r.group === group)) return;
-        const adentro = compas.index <= group.closings[group.closings.length - 1].index;
-        if (compas === group.opening || this.saltoActivo !== null && adentro) {
-          this.pila.push(new Repeticion(group, this.saltoActivo !== null));
-        }
-      }
-      moverConSaltos() {
-        const compas = this.score.masterBars[this.index];
-        const dir = compas.directions;
-        if (!this.shouldPlay || dir === null || dir === void 0 || dir.size === 0) return false;
-        if (this.saltoActivo === null) return this.tomarSalto(compas, dir);
-        const hasta = this.saltoActivo.playUntil;
-        if (hasta !== null && dir.has(hasta)) return this.seguirTrasElSalto(this.saltoActivo.continueAt);
-        return false;
-      }
-      tomarSalto(compas, dir) {
-        if (this.saltosTomados.has(compas) || this.pila.some((r) => r.vaAVolver(compas))) return false;
-        for (const salto of _RecorridoDeCompases.SALTOS) {
-          if (!dir.has(salto.jump)) continue;
-          const destino = salto.target === null ? 0 : this.buscar(salto.target, true);
-          if (destino === -1) continue;
-          this.saltosTomados.add(compas);
-          this.saltoActivo = salto;
-          this.pila = [];
-          this.index = destino;
-          return true;
-        }
-        return false;
-      }
-      seguirTrasElSalto(seguirEn) {
-        if (seguirEn === null) {
-          this.index = this.score.masterBars.length;
-          return true;
-        }
-        const coda = this.buscar(seguirEn, false);
-        if (coda === -1) return false;
-        this.saltoActivo = null;
-        this.pila = [];
-        this.index = coda;
-        return true;
-      }
-      buscar(direccion, primeroAtras) {
-        const paso = primeroAtras ? -1 : 1;
-        const i2 = this.buscarHacia(direccion, paso);
-        return i2 !== -1 ? i2 : this.buscarHacia(direccion, -paso);
-      }
-      buscarHacia(direccion, paso) {
-        const compases = this.score.masterBars;
-        for (let i2 = this.index; i2 >= 0 && i2 < compases.length; i2 += paso) {
-          const d = compases[i2].directions;
-          if (d !== null && d !== void 0 && d.has(direccion)) return i2;
-        }
-        return -1;
-      }
-    };
-    ticksAMs = (ticks, tempo) => ticks * (6e4 / (tempo * 960)) | 0;
-  }
-});
-
-// packages/io/src/musicxml.ts
-function escapar(texto4) {
-  return texto4.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function elemento(nombre, texto4) {
-  if (texto4 === null || texto4 === void 0 || texto4 === "") return [];
-  return [`<${nombre}>${escapar(String(texto4))}</${nombre}>`];
-}
-function alturaMusicXml(midi, fifths, modo = 0) {
-  const octavaAlphaTab = Math.floor(midi / 12);
-  const clase = midi - octavaAlphaTab * 12;
-  const octava = octavaAlphaTab - 1;
-  const pedida = ALTERACION_POR_MODO[modo];
-  if (pedida !== void 0) {
-    const sinAlterar = clase - pedida;
-    const vueltas = Math.floor(sinAlterar / 12);
-    const paso = PASOS.find((p) => p.semitonos === sinAlterar - vueltas * 12);
-    if (paso) return { paso: paso.paso, alteracion: pedida, octava: octava + vueltas };
-  }
-  const natural = PASOS.find((p) => p.semitonos === clase);
-  if (natural) return { paso: natural.paso, alteracion: 0, octava };
-  if (fifths < 0) {
-    const arriba = PASOS.find((p) => p.semitonos === clase + 1);
-    if (arriba) return { paso: arriba.paso, alteracion: -1, octava };
-  }
-  const abajo = PASOS.find((p) => p.semitonos === clase - 1);
-  if (abajo) return { paso: abajo.paso, alteracion: 1, octava };
-  throw new Error(`altura MIDI no representable: ${midi}`);
-}
-function claveDelPentagrama(staff, bar) {
-  if (staff.isPercussion) return { signo: "percussion", linea: 2, lineas: 5, conAfinacion: false };
-  if (staff.showTablature && staff.tuning.length > 0)
-    return { signo: "TAB", linea: 5, lineas: staff.tuning.length, conAfinacion: true };
-  switch (bar.clef) {
-    case _barrel_exports$4.Clef.C3:
-      return { signo: "C", linea: 3, lineas: 5, conAfinacion: false };
-    case _barrel_exports$4.Clef.C4:
-      return { signo: "C", linea: 4, lineas: 5, conAfinacion: false };
-    case _barrel_exports$4.Clef.F4:
-      return { signo: "F", linea: 4, lineas: 5, conAfinacion: false };
-    case _barrel_exports$4.Clef.Neutral:
-      return { signo: "percussion", linea: 2, lineas: 5, conAfinacion: false };
-    default:
-      return { signo: "G", linea: 2, lineas: 5, conAfinacion: false };
-  }
-}
-function gruposDeTresillo(beats) {
-  const abren = /* @__PURE__ */ new Set();
-  const cierran = /* @__PURE__ */ new Set();
-  let i2 = 0;
-  while (i2 < beats.length) {
-    const b = beats[i2];
-    if (b.tupletNumerator <= 0 || b.tupletDenominator <= 0) {
-      i2++;
-      continue;
-    }
-    let j = i2;
-    while (j + 1 < beats.length && beats[j + 1].tupletNumerator === b.tupletNumerator && beats[j + 1].tupletDenominator === b.tupletDenominator && (b.tupletGroup === null || beats[j + 1].tupletGroup === b.tupletGroup))
-      j++;
-    abren.add(i2);
-    cierran.add(j);
-    i2 = j + 1;
-  }
-  return { abren, cierran };
-}
-function saltosDelCompas(master) {
-  const s = [];
-  for (const [direccion, salto] of SALTOS) {
-    if (!master?.directions?.has(direccion)) continue;
-    s.push('<direction placement="above">', "<direction-type>");
-    s.push(salto.simbolo ? `<${salto.simbolo}/>` : `<words>${escapar(salto.texto ?? "")}</words>`);
-    s.push("</direction-type>", `<sound ${salto.sonido}/>`, "</direction>");
-  }
-  return s;
-}
-function nombreDeFigura(duracion) {
-  return NOMBRE_DE_LA_FIGURA2.get(duracion) ?? "quarter";
-}
-function instrumentosDePercusion(track) {
-  const usadas = /* @__PURE__ */ new Set();
-  for (const staff of track.staves)
-    for (const bar of staff.bars)
-      for (const voice of bar.voices)
-        for (const beat of voice.beats)
-          for (const note of beat.notes)
-            if (note.percussionArticulation >= 0) usadas.add(note.percussionArticulation);
-  const ids = /* @__PURE__ */ new Map();
-  for (const art of [...usadas].sort((a, b) => a - b))
-    ids.set(art, `P${track.index + 1}-I${art + 1}`);
-  return ids;
-}
-function posicionDePercusion(staffLine) {
-  const indiceDeB = 6;
-  const bruto = indiceDeB + (5 - staffLine);
-  const paso = PASOS[(bruto % 7 + 7) % 7].paso;
-  return { paso, octava: 4 + Math.floor(bruto / 7) };
-}
-function escribirNota(note, beat, staff, opciones) {
-  const s = ["<note>"];
-  const esAdorno = beat.graceType !== _barrel_exports$4.GraceType.None;
-  if (esAdorno) s.push(beat.graceType === _barrel_exports$4.GraceType.BeforeBeat ? "<grace/>" : '<grace slash="yes"/>');
-  if (opciones.esAcorde) s.push("<chord/>");
-  const esGolpeDeKit = staff.isPercussion && note.percussionArticulation >= 0;
-  if (esGolpeDeKit) {
-    const art = staff.track.percussionArticulations[note.percussionArticulation];
-    const { paso, octava } = posicionDePercusion(art?.staffLine ?? 5);
-    s.push("<unpitched>");
-    s.push(`<display-step>${paso}</display-step>`);
-    s.push(`<display-octave>${octava}</display-octave>`);
-    s.push("</unpitched>");
-  } else {
-    const { paso, alteracion, octava } = alturaMusicXml(
-      note.calculateRealValue(false, false),
-      opciones.fifths,
-      note.accidentalMode
-    );
-    s.push("<pitch>");
-    s.push(`<step>${paso}</step>`);
-    if (alteracion !== 0) s.push(`<alter>${alteracion}</alter>`);
-    s.push(`<octave>${octava}</octave>`);
-    s.push("</pitch>");
-  }
-  if (!esAdorno) s.push(`<duration>${opciones.duracion}</duration>`);
-  if (note.isTieDestination) s.push('<tie type="stop"/>');
-  if (note.isTieOrigin) s.push('<tie type="start"/>');
-  const idDeInstrumento = opciones.instrumentos.get(note.percussionArticulation);
-  if (esGolpeDeKit && idDeInstrumento) s.push(`<instrument id="${idDeInstrumento}"/>`);
-  s.push(`<voice>${opciones.numeroDeVoz}</voice>`);
-  s.push(...elemento("type", nombreDeFigura(beat.duration)));
-  for (let d = 0; d < beat.dots; d++) s.push("<dot/>");
-  if (beat.tupletNumerator > 0 && beat.tupletDenominator > 0) {
-    s.push("<time-modification>");
-    s.push(`<actual-notes>${beat.tupletNumerator}</actual-notes>`);
-    s.push(`<normal-notes>${beat.tupletDenominator}</normal-notes>`);
-    s.push("</time-modification>");
-  }
-  if (note.isDead) s.push("<notehead>x</notehead>");
-  else if (esGolpeDeKit) {
-    const art = staff.track.percussionArticulations[note.percussionArticulation];
-    if (art?.noteHeadDefault === _barrel_exports$4.MusicFontSymbol.NoteheadXBlack)
-      s.push("<notehead>x</notehead>");
-  } else if (note.isGhost) s.push('<notehead parentheses="yes">normal</notehead>');
-  if (opciones.numeroDePentagrama !== null) s.push(`<staff>${opciones.numeroDePentagrama}</staff>`);
-  const notaciones = [];
-  if (note.isTieDestination) notaciones.push('<tied type="stop"/>');
-  if (note.isTieOrigin) notaciones.push('<tied type="start"/>');
-  if (opciones.abreTresillo) notaciones.push('<tuplet type="start" number="1"/>');
-  if (opciones.cierraTresillo) notaciones.push('<tuplet type="stop" number="1"/>');
-  const tecnica = [];
-  if (note.string > 0 && staff.tuning.length > 0) {
-    tecnica.push(`<string>${staff.tuning.length - note.string + 1}</string>`);
-    tecnica.push(`<fret>${note.fret}</fret>`);
-  }
-  const ligado = (desde, hasta) => hasta >= desde ? "hammer-on" : "pull-off";
-  const origen = note.hammerPullOrigin;
-  if (origen !== null) {
-    const nombre = ligado(origen.fret, note.fret);
-    tecnica.push(`<${nombre} type="stop"/>`);
-  }
-  const destino = note.hammerPullDestination;
-  if (note.isHammerPullOrigin && destino) {
-    const nombre = ligado(note.fret, destino.fret);
-    tecnica.push(`<${nombre} type="start">${nombre === "hammer-on" ? "H" : "P"}</${nombre}>`);
-  }
-  if (note.harmonicType !== _barrel_exports$4.HarmonicType.None) tecnica.push("<harmonic/>");
-  if (beat.isPalmMute) tecnica.push("<other-technical>palm-mute</other-technical>");
-  if (beat.isLetRing) tecnica.push("<other-technical>let-ring</other-technical>");
-  if (tecnica.length > 0) notaciones.push("<technical>", ...tecnica, "</technical>");
-  const articulaciones = [];
-  if (note.accentuated === _barrel_exports$4.AccentuationType.Normal) articulaciones.push("<accent/>");
-  else if (note.accentuated === _barrel_exports$4.AccentuationType.Heavy)
-    articulaciones.push("<strong-accent/>");
-  else if (note.accentuated === _barrel_exports$4.AccentuationType.Tenuto)
-    articulaciones.push("<tenuto/>");
-  if (note.isStaccato) articulaciones.push("<staccato/>");
-  if (articulaciones.length > 0)
-    notaciones.push("<articulations>", ...articulaciones, "</articulations>");
-  if (notaciones.length > 0) s.push("<notations>", ...notaciones, "</notations>");
-  if (!opciones.esAcorde) s.push(...letraDelGolpe(beat));
-  s.push("</note>");
-  return s;
-}
-function letraDelGolpe(beat) {
-  if (!beat.lyrics) return [];
-  const s = [];
-  beat.lyrics.forEach((verso, i2) => {
-    if (!verso) return;
-    const sigue = verso.endsWith("-") && verso.length > 1;
-    let anterior = beat.previousBeat;
-    while (anterior && !anterior.lyrics?.[i2]) anterior = anterior.previousBeat;
-    const viene = !!anterior?.lyrics?.[i2]?.endsWith("-");
-    const silabico = sigue ? viene ? "middle" : "begin" : viene ? "end" : "single";
-    s.push(`<lyric number="${i2 + 1}">`);
-    s.push(`<syllabic>${silabico}</syllabic>`);
-    s.push(...elemento("text", sigue ? verso.slice(0, -1) : verso));
-    s.push("</lyric>");
-  });
-  return s;
-}
-function escribirSilencio2(beat, duracion, numeroDeVoz, numeroDePentagrama) {
-  const s = ["<note>", "<rest/>", `<duration>${duracion}</duration>`];
-  s.push(`<voice>${numeroDeVoz}</voice>`);
-  s.push(...elemento("type", nombreDeFigura(beat.duration)));
-  for (let d = 0; d < beat.dots; d++) s.push("<dot/>");
-  if (beat.tupletNumerator > 0 && beat.tupletDenominator > 0) {
-    s.push("<time-modification>");
-    s.push(`<actual-notes>${beat.tupletNumerator}</actual-notes>`);
-    s.push(`<normal-notes>${beat.tupletDenominator}</normal-notes>`);
-    s.push("</time-modification>");
-  }
-  if (numeroDePentagrama !== null) s.push(`<staff>${numeroDePentagrama}</staff>`);
-  s.push(...letraDelGolpe(beat));
-  s.push("</note>");
-  return s;
-}
-function exportarMusicXml(score) {
-  const l = [];
-  l.push('<?xml version="1.0" encoding="UTF-8"?>');
-  l.push('<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 4.0 Partwise//EN"');
-  l.push('                                "http://www.musicxml.org/dtds/partwise.dtd">');
-  l.push('<score-partwise version="4.0">');
-  if (score.title) l.push("<work>", ...elemento("work-title", score.title), "</work>");
-  l.push(...elemento("movement-title", score.subTitle));
-  l.push("<identification>");
-  if (score.music) l.push(`<creator type="composer">${escapar(score.music)}</creator>`);
-  else if (score.artist) l.push(`<creator type="composer">${escapar(score.artist)}</creator>`);
-  if (score.words) l.push(`<creator type="lyricist">${escapar(score.words)}</creator>`);
-  l.push(...elemento("rights", score.copyright));
-  l.push("<encoding>", "<software>Mandioca Tabs</software>", "</encoding>");
-  l.push("</identification>");
-  const instrumentosPorPista = /* @__PURE__ */ new Map();
-  l.push("<part-list>");
-  for (const track of score.tracks) {
-    const id2 = `P${track.index + 1}`;
-    l.push(`<score-part id="${id2}">`);
-    l.push(...elemento("part-name", track.name || `Pista ${track.index + 1}`));
-    l.push(...elemento("part-abbreviation", track.shortName));
-    const esPercusion = track.staves.some((st) => st.isPercussion);
-    const instrumentos = esPercusion ? instrumentosDePercusion(track) : /* @__PURE__ */ new Map();
-    instrumentosPorPista.set(track.index, instrumentos);
-    if (esPercusion) {
-      for (const [art, idInstrumento] of instrumentos) {
-        const a = track.percussionArticulations[art];
-        l.push(`<score-instrument id="${idInstrumento}">`);
-        l.push(...elemento("instrument-name", `Percusi\xF3n ${art + 1}`));
-        l.push("</score-instrument>");
-        l.push(`<midi-instrument id="${idInstrumento}">`);
-        l.push("<midi-channel>10</midi-channel>");
-        l.push(`<midi-unpitched>${(a?.outputMidiNumber ?? 36) + 1}</midi-unpitched>`);
-        l.push("</midi-instrument>");
-      }
-    } else {
-      l.push(`<score-instrument id="${id2}-I1">`);
-      l.push(...elemento("instrument-name", track.name || `Pista ${track.index + 1}`));
-      l.push("</score-instrument>");
-      l.push(`<midi-instrument id="${id2}-I1">`);
-      l.push(`<midi-channel>${track.playbackInfo.primaryChannel + 1}</midi-channel>`);
-      l.push(`<midi-program>${track.playbackInfo.program + 1}</midi-program>`);
-      l.push(`<volume>${Math.round(track.playbackInfo.volume / 16 * 100)}</volume>`);
-      l.push(`<pan>${Math.round((track.playbackInfo.balance - 8) / 8 * 90)}</pan>`);
-      l.push("</midi-instrument>");
-    }
-    l.push("</score-part>");
-  }
-  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;
+        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);
+      }
     }
-    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;
+    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);
       }
-      if (compas !== compasAnterior) {
-        cambios.push("<time>");
-        cambios.push(`<beats>${numerador}</beats>`);
-        cambios.push(`<beat-type>${denominador}</beat-type>`);
-        cambios.push("</time>");
-        compasAnterior = compas;
+      suena(compas) {
+        let casillas = compas.alternateEndings;
+        if (casillas === 0) casillas = this.casillasActuales;
+        else this.casillasActuales = casillas;
+        return casillas === 0 || (casillas & 1 << this.pasada) !== 0;
       }
-      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>");
+      /** 0 = seguir, 1 = volver al comienzo de la repetición, 2 = terminó. */
+      alCerrar(cierre, sono) {
+        const cierres = this.group.closings;
+        const esElUltimo = cierre === cierres[cierres.length - 1];
+        if (this.conCasillas) {
+          if (!sono && !esElUltimo) return 0;
+          if (this.pasada < cierre.repeatCount - 1) {
+            this.pasada++;
+            this.casillasActuales = 0;
+            return 1;
+          }
+          return esElUltimo ? 2 : 0;
         }
-        for (const clave of claves) {
-          cambios.push(`<staff-details${num(clave)}>`);
-          cambios.push(`<staff-lines>${clave.lineas}</staff-lines>`);
-          if (clave.conAfinacion)
-            clave.pentagrama.tuning.forEach((midi, i2) => {
-              const linea = clave.pentagrama.tuning.length - i2;
-              const { paso, alteracion, octava } = alturaMusicXml(midi, fifths);
-              cambios.push(`<staff-tuning line="${linea}">`);
-              cambios.push(`<tuning-step>${paso}</tuning-step>`);
-              if (alteracion !== 0) cambios.push(`<tuning-alter>${alteracion}</tuning-alter>`);
-              cambios.push(`<tuning-octave>${octava}</tuning-octave>`);
-              cambios.push("</staff-tuning>");
-            });
-          cambios.push("</staff-details>");
+        const i2 = cierres.indexOf(cierre);
+        if (i2 === -1) return 0;
+        if (this.iteraciones[i2] < cierre.repeatCount - 1) {
+          this.iteraciones[i2]++;
+          for (let j = 0; j < i2; j++) this.iteraciones[j] = 0;
+          this.casillasActuales = 0;
+          return 1;
         }
-        clavesAnteriores = firmaDeClaves;
+        return esElUltimo ? 2 : 0;
       }
-      if (cambios.length > 0) l.push("<attributes>", ...cambios, "</attributes>");
-      const casilla = master?.alternateEndings ?? 0;
-      const casillaAntes = score.masterBars[indiceDeCompas2 - 1]?.alternateEndings ?? 0;
-      const casillaDespues = score.masterBars[indiceDeCompas2 + 1]?.alternateEndings ?? 0;
-      const numerosDeCasilla = [0, 1, 2, 3, 4, 5, 6, 7].filter((b) => casilla & 1 << b).map((b) => b + 1).join(", ");
-      if (master?.isRepeatStart || casilla && casilla !== casillaAntes) {
-        l.push('<barline location="left">');
-        if (master?.isRepeatStart) l.push("<bar-style>heavy-light</bar-style>");
-        if (casilla && casilla !== casillaAntes) l.push(`<ending number="${numerosDeCasilla}" type="start"/>`);
-        if (master?.isRepeatStart) l.push('<repeat direction="forward"/>');
-        l.push("</barline>");
+      /** Si algún cierre todavía va a volver por encima de este compás. */
+      vaAVolver(compas) {
+        const cierres = this.group.closings;
+        for (let i2 = 0; i2 < cierres.length; i2++) {
+          const cierre = cierres[i2];
+          if (cierre.index >= compas.index) {
+            if ((this.conCasillas ? this.pasada : this.iteraciones[i2]) < cierre.repeatCount - 1) return true;
+          }
+        }
+        return false;
       }
-      if (master?.section?.text || master?.section?.marker)
-        l.push(
-          '<direction placement="above">',
-          "<direction-type>",
-          `<rehearsal>${escapar(master.section.marker || master.section.text)}</rehearsal>`,
-          "</direction-type>",
-          "</direction>"
-        );
-      l.push(...saltosDelCompas(master));
-      const ticsDelCompas = DIVISIONES_POR_NEGRA * 4 * numerador / denominador;
-      const tempos = (master?.tempoAutomations ?? []).map((a) => ({ bpm: a.value, desde: a.ratioPosition }));
-      if (indiceDeCompas2 === 0 && score.tempo && !tempos.some((t) => t.desde <= 1e-6))
-        tempos.unshift({ bpm: score.tempo, desde: 0 });
-      for (const t of tempos) {
-        const bpm = Math.round(t.bpm);
-        const offset = Math.round(t.desde * ticsDelCompas);
-        l.push(
-          '<direction placement="above">',
-          "<direction-type>",
-          "<metronome>",
-          "<beat-unit>quarter</beat-unit>",
-          `<per-minute>${bpm}</per-minute>`,
-          "</metronome>",
-          "</direction-type>",
-          ...offset > 0 ? [`<offset>${offset}</offset>`] : [],
-          `<sound tempo="${bpm}"/>`,
-          "</direction>"
-        );
+    };
+    RecorridoDeCompases = class _RecorridoDeCompases {
+      /** Los saltos en el orden en que se revisan si un compás tiene varios. */
+      static SALTOS = [
+        { jump: 5, target: null, playUntil: null, continueAt: null },
+        { jump: 6, target: null, playUntil: D2.JumpDaCoda, continueAt: D2.TargetCoda },
+        { jump: 7, target: null, playUntil: D2.JumpDaDoubleCoda, continueAt: D2.TargetDoubleCoda },
+        { jump: 8, target: null, playUntil: D2.TargetFine, continueAt: null },
+        { jump: 9, target: D2.TargetSegno, playUntil: null, continueAt: null },
+        { jump: 10, target: D2.TargetSegno, playUntil: D2.JumpDaCoda, continueAt: D2.TargetCoda },
+        { jump: 11, target: D2.TargetSegno, playUntil: D2.JumpDaDoubleCoda, continueAt: D2.TargetDoubleCoda },
+        { jump: 12, target: D2.TargetSegno, playUntil: D2.TargetFine, continueAt: null },
+        { jump: 13, target: D2.TargetSegnoSegno, playUntil: null, continueAt: null },
+        { jump: 14, target: D2.TargetSegnoSegno, playUntil: D2.JumpDaCoda, continueAt: D2.TargetCoda },
+        { jump: 15, target: D2.TargetSegnoSegno, playUntil: D2.JumpDaDoubleCoda, continueAt: D2.TargetDoubleCoda },
+        { jump: 16, target: D2.TargetSegnoSegno, playUntil: D2.TargetFine, continueAt: null }
+      ];
+      score;
+      pila = [];
+      /** El D.C./D.S. que se siguió; null si se toca normal (antes del salto o después de la coda). */
+      saltoActivo = null;
+      /** Los compases cuyo salto ya se tomó: cada salto se toma una sola vez. */
+      saltosTomados = /* @__PURE__ */ new Set();
+      shouldPlay = true;
+      index = 0;
+      currentTick = 0;
+      constructor(score) {
+        this.score = score;
       }
-      let ultimoAvance = 0;
-      let hayAlgoEscrito = false;
-      for (const { pentagrama, numero: numero2 } of claves) {
-        const bar = pentagrama.bars[indiceDeCompas2];
-        if (!bar) continue;
-        bar.voices.forEach((voice, indiceDeVoz) => {
-          if (voice.beats.length === 0 || voice.isEmpty) return;
-          if (hayAlgoEscrito && ultimoAvance > 0)
-            l.push("<backup>", `<duration>${ultimoAvance}</duration>`, "</backup>");
-          const { abren, cierran } = gruposDeTresillo(voice.beats);
-          const numeroDePentagrama = pentagramas.length > 1 ? numero2 : null;
-          let avance = 0;
-          voice.beats.forEach((beat, i2) => {
-            const duracion = beat.displayDuration;
-            if (beat.graceType === _barrel_exports$4.GraceType.None) avance += duracion;
-            if (beat.isRest || beat.notes.length === 0) {
-              l.push(...escribirSilencio2(beat, duracion, indiceDeVoz + 1, numeroDePentagrama));
+      get finished() {
+        return this.index >= this.score.masterBars.length;
+      }
+      processCurrent() {
+        const compas = this.score.masterBars[this.index];
+        this.entrarARepeticion(compas);
+        const rep = this.pila.length > 0 ? this.pila[this.pila.length - 1] : null;
+        this.shouldPlay = rep === null || rep.suena(compas);
+        if (this.shouldPlay) this.currentTick += compas.calculateDuration();
+      }
+      moveNext() {
+        if (this.moverConSaltos()) return;
+        const compas = this.score.masterBars[this.index];
+        if (this.pila.length > 0 && compas.repeatCount > 1) {
+          const rep = this.pila[this.pila.length - 1];
+          switch (rep.alCerrar(compas, this.shouldPlay)) {
+            case 1:
+              this.index = rep.group.opening.index;
               return;
-            }
-            beat.notes.forEach((note, k) => {
-              l.push(
-                ...escribirNota(note, beat, pentagrama, {
-                  esAcorde: k > 0,
-                  fifths,
-                  duracion,
-                  // ★ La marca de tresillo va en la PRIMERA nota del golpe: es una marca del
-                  //   golpe, no de cada cuerda que suena en él.
-                  abreTresillo: k === 0 && abren.has(i2),
-                  cierraTresillo: k === 0 && cierran.has(i2),
-                  instrumentos,
-                  numeroDeVoz: indiceDeVoz + 1,
-                  numeroDePentagrama
-                })
-              );
-            });
-          });
-          ultimoAvance = avance;
-          hayAlgoEscrito = true;
-        });
+            case 2:
+              this.pila.pop();
+          }
+        }
+        this.index++;
       }
-      const cierraCasilla = casilla !== 0 && casilla !== casillaDespues;
-      if (master?.isRepeatEnd || master?.isDoubleBar || cierraCasilla) {
-        l.push('<barline location="right">');
-        if (master?.isRepeatEnd || master?.isDoubleBar)
-          l.push(`<bar-style>${master.isRepeatEnd ? "light-heavy" : "light-light"}</bar-style>`);
-        if (cierraCasilla)
-          l.push(`<ending number="${numerosDeCasilla}" type="${master?.isRepeatEnd ? "stop" : "discontinue"}"/>`);
-        if (master?.isRepeatEnd)
-          l.push(`<repeat direction="backward" times="${Math.max(2, master.repeatCount)}"/>`);
-        l.push("</barline>");
+      /** Empieza la repetición del compás si hace falta: al llegar a su apertura, o tras un salto que cayó adentro. */
+      entrarARepeticion(compas) {
+        const group = compas.repeatGroup;
+        if (!group.isClosed || this.pila.some((r) => r.group === group)) return;
+        const adentro = compas.index <= group.closings[group.closings.length - 1].index;
+        if (compas === group.opening || this.saltoActivo !== null && adentro) {
+          this.pila.push(new Repeticion(group, this.saltoActivo !== null));
+        }
       }
-      l.push("</measure>");
-    }
-    l.push("</part>");
-  }
-  l.push("</score-partwise>");
-  return sangrar(l);
-}
-function sangrar(lineas) {
-  const salida = [];
-  let nivel = 0;
-  for (const linea of lineas) {
-    const cierra = linea.startsWith("</");
-    if (cierra) nivel = Math.max(0, nivel - 1);
-    salida.push("  ".repeat(nivel) + linea);
-    const abre = /^<[^/?!]/.test(linea) && !linea.endsWith("/>") && !/<\/[^>]+>$/.test(linea);
-    if (abre) nivel++;
-  }
-  return salida.join("\n") + "\n";
-}
-function exportarMusicXmlComprimido(score) {
-  const xml = exportarMusicXml(score);
-  const contenedor = `<?xml version="1.0" encoding="UTF-8"?>
-<container>
-  <rootfiles>
-    <rootfile full-path="partitura.musicxml" media-type="application/vnd.recordare.musicxml+xml"/>
-  </rootfiles>
-</container>
-`;
-  const codificador = new TextEncoder();
-  return zipSync(
-    {
-      "META-INF/container.xml": [codificador.encode(contenedor), { level: 0 }],
-      "partitura.musicxml": codificador.encode(xml)
-    },
-    // ⚠️ Fecha FIJA, no la de hoy: dos exportaciones iguales tienen que dar dos archivos
-    //    iguales byte a byte, o no hay prueba que pueda compararlos ni `diff` de git que
-    //    sirva. El porqué del valor concreto está en la constante — se tardó dos rojos en
-    //    encontrarlo, y ninguno de los dos era el que yo esperaba.
-    { mtime: FECHA_FIJA_DEL_ZIP }
-  );
-}
-var DIVISIONES_POR_NEGRA, FECHA_FIJA_DEL_ZIP, PASOS, NOMBRE_DE_LA_FIGURA2, ALTERACION_POR_MODO, D2, SALTOS;
-var init_musicxml = __esm({
-  "packages/io/src/musicxml.ts"() {
-    init_alphaTab();
-    init_esm();
-    DIVISIONES_POR_NEGRA = 960;
-    FECHA_FIJA_DEL_ZIP = 946728e6;
-    PASOS = [
-      { paso: "C", semitonos: 0 },
-      { paso: "D", semitonos: 2 },
-      { paso: "E", semitonos: 4 },
-      { paso: "F", semitonos: 5 },
-      { paso: "G", semitonos: 7 },
-      { paso: "A", semitonos: 9 },
-      { paso: "B", semitonos: 11 }
-    ];
-    NOMBRE_DE_LA_FIGURA2 = /* @__PURE__ */ new Map([
-      [-4, "long"],
-      [-2, "breve"],
-      [1, "whole"],
-      [2, "half"],
-      [4, "quarter"],
-      [8, "eighth"],
-      [16, "16th"],
-      [32, "32nd"],
-      [64, "64th"],
-      [128, "128th"],
-      [256, "256th"]
-    ]);
-    ALTERACION_POR_MODO = { 2: 0, 3: 1, 4: 2, 5: -1, 6: -2 };
-    D2 = _barrel_exports$4.Direction;
-    SALTOS = [
-      [D2.TargetSegno, { simbolo: "segno", sonido: 'segno="segno"' }],
-      [D2.TargetSegnoSegno, { simbolo: "segno", sonido: 'segno="segno2"' }],
-      [D2.TargetCoda, { simbolo: "coda", sonido: 'coda="coda"' }],
-      [D2.TargetDoubleCoda, { simbolo: "coda", sonido: 'coda="coda2"' }],
-      [D2.TargetFine, { texto: "Fine", sonido: 'fine="yes"' }],
-      [D2.JumpDaCapo, { texto: "D.C.", sonido: 'dacapo="yes"' }],
-      [D2.JumpDaCapoAlCoda, { texto: "D.C. al Coda", sonido: 'dacapo="yes"' }],
-      [D2.JumpDaCapoAlDoubleCoda, { texto: "D.C. al Coda 2", sonido: 'dacapo="yes"' }],
-      [D2.JumpDaCapoAlFine, { texto: "D.C. al Fine", sonido: 'dacapo="yes"' }],
-      [D2.JumpDalSegno, { texto: "D.S.", sonido: 'dalsegno="segno"' }],
-      [D2.JumpDalSegnoAlCoda, { texto: "D.S. al Coda", sonido: 'dalsegno="segno"' }],
-      [D2.JumpDalSegnoAlDoubleCoda, { texto: "D.S. al Coda 2", sonido: 'dalsegno="segno"' }],
-      [D2.JumpDalSegnoAlFine, { texto: "D.S. al Fine", sonido: 'dalsegno="segno"' }],
-      [D2.JumpDalSegnoSegno, { texto: "D.S.S.", sonido: 'dalsegno="segno2"' }],
-      [D2.JumpDalSegnoSegnoAlCoda, { texto: "D.S.S. al Coda", sonido: 'dalsegno="segno2"' }],
-      [D2.JumpDalSegnoSegnoAlDoubleCoda, { texto: "D.S.S. al Coda 2", sonido: 'dalsegno="segno2"' }],
-      [D2.JumpDalSegnoSegnoAlFine, { texto: "D.S.S. al Fine", sonido: 'dalsegno="segno2"' }],
-      [D2.JumpDaCoda, { texto: "To Coda", sonido: 'tocoda="coda"' }],
-      [D2.JumpDaDoubleCoda, { texto: "To Coda 2", sonido: 'tocoda="coda2"' }]
-    ];
+      moverConSaltos() {
+        const compas = this.score.masterBars[this.index];
+        const dir = compas.directions;
+        if (!this.shouldPlay || dir === null || dir === void 0 || dir.size === 0) return false;
+        if (this.saltoActivo === null) return this.tomarSalto(compas, dir);
+        const hasta = this.saltoActivo.playUntil;
+        if (hasta !== null && dir.has(hasta)) return this.seguirTrasElSalto(this.saltoActivo.continueAt);
+        return false;
+      }
+      tomarSalto(compas, dir) {
+        if (this.saltosTomados.has(compas) || this.pila.some((r) => r.vaAVolver(compas))) return false;
+        for (const salto of _RecorridoDeCompases.SALTOS) {
+          if (!dir.has(salto.jump)) continue;
+          const destino = salto.target === null ? 0 : this.buscar(salto.target, true);
+          if (destino === -1) continue;
+          this.saltosTomados.add(compas);
+          this.saltoActivo = salto;
+          this.pila = [];
+          this.index = destino;
+          return true;
+        }
+        return false;
+      }
+      seguirTrasElSalto(seguirEn) {
+        if (seguirEn === null) {
+          this.index = this.score.masterBars.length;
+          return true;
+        }
+        const coda = this.buscar(seguirEn, false);
+        if (coda === -1) return false;
+        this.saltoActivo = null;
+        this.pila = [];
+        this.index = coda;
+        return true;
+      }
+      buscar(direccion, primeroAtras) {
+        const paso = primeroAtras ? -1 : 1;
+        const i2 = this.buscarHacia(direccion, paso);
+        return i2 !== -1 ? i2 : this.buscarHacia(direccion, -paso);
+      }
+      buscarHacia(direccion, paso) {
+        const compases = this.score.masterBars;
+        for (let i2 = this.index; i2 >= 0 && i2 < compases.length; i2 += paso) {
+          const d = compases[i2].directions;
+          if (d !== null && d !== void 0 && d.has(direccion)) return i2;
+        }
+        return -1;
+      }
+    };
+    ticksAMs = (ticks, tempo) => ticks * (6e4 / (tempo * 960)) | 0;
   }
 });
 
@@ -91780,6 +92564,13 @@ function obraAbierta() {
   }
   return abierta;
 }
+function olvidarLaObra() {
+  abierta = null;
+  sigueViva = null;
+}
+function soltarLaObraDeLaPesta\u00F1a() {
+  if (abierta?.origen.clase === "pesta\xF1a") olvidarLaObra();
+}
 async function abrirDeArchivo(ruta) {
   let bytes;
   try {
@@ -91796,7 +92587,9 @@ async function abrirDeArchivo(ruta) {
     abierta = {
       documento: archivo.documento,
       origen: { clase: "archivo", ruta },
-      avisos: [],
+      // ★ (2026-11-11) Una obra vieja con el piano en dos pistas vuelve junta: se dice, para que
+      //   la IA no busque la «mano izquierda» como pista aparte.
+      avisos: archivo.manosJuntadas > 0 ? ["El piano estaba guardado en dos pistas (una por mano): ahora es un solo instrumento con dos pentagramas."] : [],
       grabaciones: archivo.grabaciones,
       grabacionesEnEspera: [],
       fuentes: archivo.fuentes
@@ -91917,7 +92710,7 @@ function avisoDeLoQueNoSuena(mudas, huerfanas) {
   const partes = [];
   if (mudas > 0) {
     partes.push(
-      `${mudas} grabaci\xF3n(es) viajaron con su onda pero sin audio: no est\xE1n cargadas en esta sesi\xF3n. El archivo las conserva como fichas.`
+      mudas === 1 ? "1 grabaci\xF3n viaj\xF3 con su onda pero sin audio: no est\xE1 cargada en esta sesi\xF3n. El archivo la conserva como ficha." : `${mudas} grabaciones viajaron con su onda pero sin audio: no est\xE1n cargadas en esta sesi\xF3n. El archivo las conserva como fichas.`
     );
   }
   if (huerfanas > 0) {
@@ -91980,7 +92773,7 @@ var VERSION_DEL_CONECTOR;
 var init_version = __esm({
   "apps/mcp/src/version.ts"() {
     "use strict";
-    VERSION_DEL_CONECTOR = true ? "0.2.17" : null;
+    VERSION_DEL_CONECTOR = true ? "0.2.19" : null;
   }
 });
 
@@ -91995,9 +92788,11 @@ __export(puente_exports, {
   SALA_DE_LA_OBRA: () => SALA_DE_LA_OBRA,
   SALA_DE_PEDIDOS: () => SALA_DE_PEDIDOS,
   SALA_OCIOSA_MS: () => SALA_OCIOSA_MS,
+  VENCIMIENTO_DEL_OFRECIDO_MS: () => VENCIMIENTO_DEL_OFRECIDO_MS,
   abrirPuente: () => abrirPuente,
   buscarLaPesta\u00F1a: () => buscarLaPesta\u00F1a,
   cerrarPuente: () => cerrarPuente,
+  cuantosArchivosOfrecidos: () => cuantosArchivosOfrecidos,
   elegirLaObra: () => elegirLaObra,
   exigirPesta\u00F1a: () => exigirPesta\u00F1a,
   obraDeLaEtiqueta: () => obraDeLaEtiqueta,
@@ -92010,6 +92805,7 @@ __export(puente_exports, {
   pesta\u00F1asAhora: () => pesta\u00F1asAhora,
   puenteAbierto: () => puenteAbierto,
   reservarArchivo: () => reservarArchivo,
+  retirarArchivo: () => retirarArchivo,
   soltarReserva: () => soltarReserva
 });
 import { createServer } from "node:http";
@@ -92072,30 +92868,31 @@ function obraDeLaEtiqueta(etiqueta) {
   const buscada = etiqueta.trim().toUpperCase();
   return puenteAbierto().obras().find((o) => o.etiqueta === buscada) ?? null;
 }
-function puenteAbierto() {
+function puenteAbierto(reclamar = true) {
   if (!puente) {
     throw new ProblemaConLaObra(
       "El puente con la aplicaci\xF3n no est\xE1 abierto. Usa `conectar_con_la_app` primero."
     );
   }
-  reclamado = true;
+  if (reclamar) reclamado = true;
   return puente;
 }
 async function pedirQueLoSuelte(puerto) {
   try {
     const r = await fetch(`http://127.0.0.1:${puerto}/soltar`, { method: "POST" });
-    if (!r.ok) return false;
+    if (r.status === 409) return "lo-usa-otra-ia";
+    if (!r.ok) return "no-es-un-conector";
     for (let i2 = 0; i2 < 40; i2++) {
       try {
         await fetch(`http://127.0.0.1:${puerto}/version`);
       } catch {
-        return true;
+        return "soltado";
       }
       await new Promise((listo) => setTimeout(listo, 50));
     }
-    return false;
+    return "no-es-un-conector";
   } catch {
-    return false;
+    return "no-es-un-conector";
   }
 }
 function exigirPesta\u00F1a() {
@@ -92107,7 +92904,7 @@ function exigirPesta\u00F1a() {
   }
   return p;
 }
-function ofrecerArchivo(ruta) {
+function ofrecerArchivo(ruta, venceEnMs = VENCIMIENTO_DEL_OFRECIDO_MS) {
   let tama\u00F1o;
   try {
     const datos = statSync(ruta);
@@ -92119,8 +92916,15 @@ function ofrecerArchivo(ruta) {
   const ficha = randomUUID();
   const ofrecido = { ruta, nombre: basename2(ruta), bytes: tama\u00F1o };
   mostrador.set(ficha, ofrecido);
+  setTimeout(() => mostrador.delete(ficha), venceEnMs).unref?.();
   return { ...ofrecido, ficha };
 }
+function retirarArchivo(ficha) {
+  mostrador.delete(ficha);
+}
+function cuantosArchivosOfrecidos() {
+  return mostrador.size;
+}
 function olvidarArchivosOfrecidos() {
   mostrador.clear();
   casillero.clear();
@@ -92182,7 +92986,7 @@ function recibirEnElCasillero(ficha, pedido, respuesta) {
   });
   pedido.pipe(salida);
 }
-function atenderElMostrador(pedido, respuesta) {
+function atenderElMostrador(pedido, respuesta, puerto) {
   respuesta.setHeader("Access-Control-Allow-Origin", "*");
   const ruta = new URL(pedido.url ?? "", "http://127.0.0.1").pathname;
   if (pedido.method === "OPTIONS") {
@@ -92192,6 +92996,12 @@ function atenderElMostrador(pedido, respuesta) {
     return;
   }
   if (ruta === "/version") {
+    respuesta.removeHeader("Access-Control-Allow-Origin");
+    const origen = pedido.headers.origin;
+    if (origen !== void 0 && origenPermitido(origen, puerto)) {
+      respuesta.setHeader("Access-Control-Allow-Origin", origen);
+    }
+    respuesta.setHeader("Vary", "Origin");
     respuesta.writeHead(200, { "Content-Type": "application/json" });
     respuesta.end(JSON.stringify({ version: VERSION_DEL_CONECTOR }));
     return;
@@ -92339,7 +93149,7 @@ function abrirDeVerdad(puerto) {
   };
   for (const [sala, doc] of docs) escuchar(sala, doc);
   return new Promise((resolver, rechazar) => {
-    const http = createServer(atenderElMostrador);
+    const http = createServer((pedido, respuesta) => atenderElMostrador(pedido, respuesta, puerto));
     const servidor2 = new import_websocket_server.default({
       server: http,
       // Ver `origenPermitido`: una página de otro sitio recibe un 401 y no llega a la obra.
@@ -92377,6 +93187,13 @@ function abrirDeVerdad(puerto) {
       writeSyncStep1(saludo, doc);
       conexion.send(toUint8Array(saludo));
       conexion.on("message", (crudo) => {
+        try {
+          atenderElMensaje(crudo);
+        } catch {
+          conexion.close(1003, "mensaje ilegible");
+        }
+      });
+      const atenderElMensaje = (crudo) => {
         const bytes = new Uint8Array(crudo instanceof ArrayBuffer ? crudo : crudo);
         const lector = createDecoder(bytes);
         const tipo = readVarUint(lector);
@@ -92395,7 +93212,7 @@ function abrirDeVerdad(puerto) {
             if (otra !== conexion && otra.readyState === import_websocket.default.OPEN) otra.send(bytes);
           }
         }
-      });
+      };
       conexion.on("close", () => {
         conexiones.delete(conexion);
         olvidarSiQuedoVacia(sala);
@@ -92576,7 +93393,7 @@ async function pedirALaPesta\u00F1a(herramienta, argumentos = {}, msDelAcuse = E
     canal.transact(() => mapa.delete(id2));
   }
 }
-var envoltoriosPorDoc, SINCRONIZAR, PRESENCIA, SALA_DE_LA_OBRA, SALA_DE_PEDIDOS, PUERTO_POR_OMISION, ORIGENES_DE_TABS, PUERTOS_LOCALES_DE_TABS, PUERTO_DEL_CONECTOR, puente, reclamado, ESPERA_POR_LA_PESTA\u00D1A, mostrador, casillero, TIPOS, abriendo, siguienteId, INSTANCIA, ESPERA_DEL_ACUSE_MS, LATIDO_MS, LATIDO_DEL_PUENTE_MS, AUSENCIA_PARA_DARLA_POR_IDA_MS, SALA_OCIOSA_MS, MARGEN_PARA_QUE_ENTRE_MS;
+var envoltoriosPorDoc, SINCRONIZAR, PRESENCIA, SALA_DE_LA_OBRA, SALA_DE_PEDIDOS, PUERTO_POR_OMISION, ORIGENES_DE_TABS, PUERTOS_LOCALES_DE_TABS, PUERTO_DEL_CONECTOR, puente, reclamado, ESPERA_POR_LA_PESTA\u00D1A, mostrador, VENCIMIENTO_DEL_OFRECIDO_MS, casillero, TIPOS, abriendo, siguienteId, INSTANCIA, ESPERA_DEL_ACUSE_MS, LATIDO_MS, LATIDO_DEL_PUENTE_MS, AUSENCIA_PARA_DARLA_POR_IDA_MS, SALA_OCIOSA_MS, MARGEN_PARA_QUE_ENTRE_MS;
 var init_puente = __esm({
   "apps/mcp/src/puente.ts"() {
     "use strict";
@@ -92606,6 +93423,7 @@ var init_puente = __esm({
     reclamado = false;
     ESPERA_POR_LA_PESTA\u00D1A = 3500;
     mostrador = /* @__PURE__ */ new Map();
+    VENCIMIENTO_DEL_OFRECIDO_MS = 10 * 6e4;
     casillero = /* @__PURE__ */ new Map();
     TIPOS = Object.fromEntries(
       FORMATOS_DE_GRABACION.map((f) => [f.extension, f.mime])
@@ -100125,6 +100943,9 @@ function proyectar(documento, opciones = {}) {
   const figurasPorCompas = /* @__PURE__ */ new Map();
   for (const [id2, entidad] of documento.figuras.entries()) {
     const figura = normalizarFigura(entidad.toJSON());
+    if (!Number.isInteger(figura.voz) || figura.voz < 0 || figura.voz >= VOCES_MAXIMAS) continue;
+    if (figura.tiempo < 0 || figura.tiempo > TIEMPO_MAXIMO) continue;
+    if (figura.puntillos > PUNTILLOS_MAXIMOS) continue;
     const lista2 = figurasPorCompas.get(figura.compasId);
     if (lista2) lista2.push({ id: id2, datos: figura });
     else figurasPorCompas.set(figura.compasId, [{ id: id2, datos: figura }]);
@@ -100350,7 +101171,6 @@ function proyectar(documento, opciones = {}) {
               notaAlphaTab.trillValue = nota.trino;
               notaAlphaTab.trillSpeed = nota.velocidadDeTrino;
               notaAlphaTab.accidentalMode = nota.alteracion;
-              if (nota.ligaduraDeExpresion) notaAlphaTab.isEffectSlurOrigin = true;
               if (nota.bend.length > 0) {
                 notaAlphaTab.bendType = _barrel_exports$4.BendType.Custom;
                 notaAlphaTab.bendStyle = _barrel_exports$4.BendStyle.Default;
@@ -100393,6 +101213,7 @@ function proyectar(documento, opciones = {}) {
               if (marca.subrayar) anotarSubrayado(notaAlphaTab, marca.subrayar);
               golpe.addNote(notaAlphaTab);
             }
+            if (notasDelGolpe2.some((n) => n.ligaduraDeExpresion)) golpe.isLegatoOrigin = true;
             voz.addBeat(golpe);
           }
           if (voz.beats.length === 0) {
@@ -100425,6 +101246,12 @@ function proyectar(documento, opciones = {}) {
     });
   }
   score.finish(ajustes);
+  for (const track of score.tracks)
+    for (const staff of track.staves)
+      for (const bar of staff.bars)
+        for (const voice of bar.voices)
+          for (const beat of voice.beats)
+            if (beat.isLegatoOrigin && (!beat.nextBeat || beat.nextBeat.isRest)) beat.isLegatoOrigin = false;
   aplicarSync(score, documento);
   return score;
 }
@@ -100466,7 +101293,7 @@ function pasarLetraALaFila(score) {
             golpe.text = null;
           }
 }
-var VOCES_POR_COMPAS, volumenDeMezcla;
+var VOCES_POR_COMPAS, VOCES_MAXIMAS, TIEMPO_MAXIMO, PUNTILLOS_MAXIMOS, volumenDeMezcla;
 var init_proyectar = __esm({
   "packages/projection/src/proyectar.ts"() {
     init_alphaTab();
@@ -100477,6 +101304,9 @@ var init_proyectar = __esm({
     init_src2();
     init_src2();
     VOCES_POR_COMPAS = 4;
+    VOCES_MAXIMAS = 16;
+    TIEMPO_MAXIMO = 960 * 4 * 64;
+    PUNTILLOS_MAXIMOS = 8;
     volumenDeMezcla = /* @__PURE__ */ new WeakMap();
   }
 });
@@ -124605,6 +125435,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",
@@ -124624,7 +125455,7 @@ var LEEN = /* @__PURE__ */ new Set([
   "obras_conectadas",
   "obras_recientes",
   "piezas_de_bateria",
-  "precision_del_alineador",
+  // ⛔ (E10) `precision_del_alineador` ya NO está acá: con `precision` cambia un ajuste.
   "que_hace_un_control",
   "secciones_de_la_obra",
   "signos_de_una_nota",
@@ -124654,11 +125485,15 @@ var BORRAN = /* @__PURE__ */ new Set([
   "exportar_pdf",
   "exportar_video"
 ]);
+var BAJAN_MODELOS = /* @__PURE__ */ new Set(["separar_en_stems", "regenerar_stems", "sincronizar_letra"]);
 function anotacionesDe(nombre) {
   if (LEEN.has(nombre)) return { readOnlyHint: true, openWorldHint: false };
-  return { readOnlyHint: false, destructiveHint: BORRAN.has(nombre), openWorldHint: false };
+  return { readOnlyHint: false, destructiveHint: BORRAN.has(nombre), openWorldHint: BAJAN_MODELOS.has(nombre) };
 }
 
+// apps/mcp/src/servidor.ts
+init_obra();
+
 // apps/mcp/src/herramientas/documento.ts
 init_src2();
 init_src3();
@@ -124677,7 +125512,7 @@ function texto2(cosa) {
 function empezarUnPaso() {
   obraAbierta().documento.historial().stopCapturing();
 }
-function situarse(pista, compasDelMusico, voz) {
+function situarse(pista, compasDelMusico, voz, pentagrama) {
   const { documento } = obraAbierta();
   documento.historial().stopCapturing();
   const indice = indexar(documento);
@@ -124689,7 +125524,11 @@ function situarse(pista, compasDelMusico, voz) {
     volcado,
     pistaId,
     compas: indiceDeCompas(compasDelMusico, indice),
-    voz: (voz ?? 1) - 1
+    voz: (voz ?? 1) - 1,
+    // ⛔ (E7, 2026-11-11) El pentagrama, desde 0 y comprobado contra la pista. Sin esto, a la
+    //    mano izquierda del piano sólo llegaban `escribir_notas` y `borrar_notas`: una
+    //    duración, un signo o una sílaba pedidos ahí caían en la derecha.
+    pentagrama: pentagramaDelMusico(pentagrama, indice, pistaId, pista ?? 1)
   };
 }
 function indiceDeCompas(numeroDelMusico, indice) {
@@ -124754,6 +125593,7 @@ function ticsDelGolpe(indice, pistaId, compas, voz, golpe, tics, pentagrama = 0)
 function cursorEn(indice, pistaId, compas, voz, tiempo, cuerda, pentagrama = 0) {
   return { ...cursorInicial(indice, pistaId), compas, voz, tiempo, cuerda, ...pentagrama > 0 ? { pentagrama } : {} };
 }
+var campoDePentagrama = external_exports.number().int().min(1).max(4).optional().describe("En qu\xE9 pentagrama de la pista, desde 1. S\xF3lo el piano tiene dos: 1 la mano derecha (arriba), 2 la izquierda. Por omisi\xF3n el 1.");
 function pentagramaDelMusico(pedido, indice, pistaId, numeroDePista) {
   if (pedido === void 0) return 0;
   const tiene = indice.pentagramasDe(pistaId);
@@ -124794,7 +125634,7 @@ var unaNota = {
   golpe: external_exports.number().int().min(1).max(999).optional(),
   tics: external_exports.number().int().min(0).max(99999).optional(),
   voz: external_exports.number().int().min(1).max(4).optional(),
-  pentagrama: external_exports.number().int().min(1).max(4).optional().describe("En qu\xE9 pentagrama de la pista, desde 1. S\xF3lo el piano tiene dos: 1 la mano derecha (arriba), 2 la izquierda. Por omisi\xF3n el 1.")
+  pentagrama: campoDePentagrama
 };
 function piezaPorNombre(nombre) {
   const plano = (t) => t.normalize("NFD").replace(/[̀-ͯ]/g, "").trim().toLowerCase();
@@ -125213,16 +126053,24 @@ function registrarHerramientasDelDocumento(servidor2) {
       let borradas = 0;
       const laPista = pistaDelMusico(pista ?? 1, volcar(documento), documento);
       const pistaId = laPista.id;
-      for (const nota of notas) {
-        const indice = indexar(documento);
-        const compas = indiceDeCompas(nota.compas, indice);
-        const voz = (nota.voz ?? 1) - 1;
-        const pentagrama = pentagramaDelMusico(nota.pentagrama, indice, pistaId, pista ?? 1);
-        const tiempo = ticsDelGolpe(indice, pistaId, compas, voz, nota.golpe, nota.tics, pentagrama);
-        const nombrada = comoSeNombraLaNota(laPista.tipo, laPista.nombre, pista ?? 1, nota);
-        const cursor = cursorEn(indice, pistaId, compas, voz, tiempo, nombrada.clase === "trastes" ? nombrada.cuerda : 1, pentagrama);
-        const salio = nombrada.clase === "altura" ? borrarAltura(documento, indice, cursor, nombrada.altura) : nombrada.clase === "percusion" ? borrarPercusion(documento, indice, cursor, nombrada.articulacion) : borrarNotaDeCuerda(documento, indice, cursor, nombrada.cuerda);
-        if (salio) borradas += 1;
+      try {
+        for (const nota of notas) {
+          const indice = indexar(documento);
+          const compas = indiceDeCompas(nota.compas, indice);
+          const voz = (nota.voz ?? 1) - 1;
+          const pentagrama = pentagramaDelMusico(nota.pentagrama, indice, pistaId, pista ?? 1);
+          const tiempo = ticsDelGolpe(indice, pistaId, compas, voz, nota.golpe, nota.tics, pentagrama);
+          const nombrada = comoSeNombraLaNota(laPista.tipo, laPista.nombre, pista ?? 1, nota);
+          const cursor = cursorEn(indice, pistaId, compas, voz, tiempo, nombrada.clase === "trastes" ? nombrada.cuerda : 1, pentagrama);
+          const salio = nombrada.clase === "altura" ? borrarAltura(documento, indice, cursor, nombrada.altura) : nombrada.clase === "percusion" ? borrarPercusion(documento, indice, cursor, nombrada.articulacion) : borrarNotaDeCuerda(documento, indice, cursor, nombrada.cuerda);
+          if (salio) borradas += 1;
+        }
+      } catch (e) {
+        if (borradas > 0) documento.historial().undo();
+        const motivo = e instanceof Error ? e.message : String(e);
+        throw new ProblemaConLaObra(
+          borradas > 0 ? `${motivo} No se borr\xF3 ninguna nota de esta tanda: las ${borradas} anteriores volvieron.` : motivo
+        );
       }
       return texto2({ pedidas: notas.length, borradas });
     }
@@ -125270,11 +126118,23 @@ function registrarHerramientasDelPuente(servidor2) {
     },
     async ({ puerto }) => {
       const elPuerto = puerto ?? PUERTO_POR_OMISION;
+      let abierto;
       try {
-        await abrirPuente(elPuerto);
+        abierto = await abrirPuente(elPuerto);
       } catch (causa) {
-        if (!await pedirQueLoSuelte(elPuerto)) throw causa;
-        await abrirPuente(elPuerto);
+        const respuesta = await pedirQueLoSuelte(elPuerto);
+        if (respuesta === "lo-usa-otra-ia") {
+          throw new ProblemaConLaObra(
+            `El puerto ${elPuerto} lo est\xE1 usando otra IA conectada a Mandioca Tabs (otra sesi\xF3n o ventana). Que el m\xFAsico la desconecte desde ah\xED con \`desconectar_de_la_app\`, o la cierre, y vuelve a intentarlo.`
+          );
+        }
+        if (respuesta !== "soltado") throw causa;
+        abierto = await abrirPuente(elPuerto);
+      }
+      if (puerto !== void 0 && abierto.puerto !== puerto) {
+        throw new ProblemaConLaObra(
+          `El puente ya est\xE1 abierto en el puerto ${abierto.puerto}, no en el ${puerto}. Para cambiar de puerto, primero \`desconectar_de_la_app\`.`
+        );
       }
       const p = await buscarLaPesta\u00F1a() ?? puenteAbierto();
       const conectadas = p.obras();
@@ -125288,7 +126148,7 @@ function registrarHerramientasDelPuente(servidor2) {
         pesta\u00F1asConectadas: p.pesta\u00F1as(),
         // ⚠️ Se dice lo que falta, sin adornarlo. Si no hay pestaña, el asistente tiene que
         //    saberlo ANTES de prometerle algo al músico — no descubrirlo al primer fallo.
-        siguiente: conectadas.length > 1 ? `Hay ${conectadas.length} obras abiertas. Mira \`obras_conectadas\` y elige una con \`elegir_obra\`, por su letra, antes de escribir nada.` : p.pesta\u00F1as() > 0 ? "Ya hay una pesta\xF1a conectada: la obra que se lee y se escribe es la suya." : "Todav\xEDa no hay ninguna pesta\xF1a. P\xEDdele que abra Mandioca Tabs y active P\xEDdele que apriete \xABConectar IA\xBB, el bot\xF3n de la barra de estado (abajo del todo, dice \xABConectar IA\xBB)."
+        siguiente: conectadas.length > 1 ? `Hay ${conectadas.length} obras abiertas. Mira \`obras_conectadas\` y elige una con \`elegir_obra\`, por su letra, antes de escribir nada.` : p.pesta\u00F1as() > 0 ? "Ya hay una pesta\xF1a conectada: la obra que se lee y se escribe es la suya." : "Todav\xEDa no hay ninguna pesta\xF1a. P\xEDdele que abra Mandioca Tabs y apriete \xABConectar IA\xBB, el bot\xF3n de la barra de estado (abajo del todo)."
       });
     }
   );
@@ -125300,7 +126160,7 @@ function registrarHerramientasDelPuente(servidor2) {
       inputSchema: {}
     },
     () => {
-      const p = puenteAbierto();
+      const p = puenteAbierto(false);
       const conectadas = p.obras();
       const idActivo = idDeLaObraActiva();
       const idDeLaActiva = idActivo ?? (conectadas.length === 1 ? conectadas[0].id : null);
@@ -125347,7 +126207,7 @@ function registrarHerramientasDelPuente(servidor2) {
       inputSchema: {}
     },
     () => {
-      const p = puenteAbierto();
+      const p = puenteAbierto(false);
       const pesta\u00F1as = p.pesta\u00F1as();
       if (pesta\u00F1as === 0) {
         return texto3({
@@ -125405,6 +126265,7 @@ function registrarHerramientasDelPuente(servidor2) {
       inputSchema: {}
     },
     async () => {
+      soltarLaObraDeLaPesta\u00F1a();
       await cerrarPuente();
       return texto3({ desconectado: true });
     }
@@ -125413,7 +126274,7 @@ function registrarHerramientasDelPuente(servidor2) {
     "sonar",
     {
       title: "Reproducir",
-      description: "Le pide a la aplicaci\xF3n que reproduzca la obra desde donde est\xE1 el cursor. Necesita la pesta\xF1a conectada: el sonido s\xF3lo existe en el navegador. \u26A0\uFE0F Si el sonido de alg\xFAn instrumento todav\xEDa se est\xE1 cargando, NO suena y contesta con un error que nombra la pista que falta: esper\xE1 unos segundos y vuelve a pedirlo. Nunca suena a medias.",
+      description: "Le pide a la aplicaci\xF3n que reproduzca la obra desde donde est\xE1 el cursor. Necesita la pesta\xF1a conectada: el sonido s\xF3lo existe en el navegador. \u26A0\uFE0F Si el sonido de alg\xFAn instrumento todav\xEDa se est\xE1 cargando, NO suena y contesta con un error que nombra la pista que falta: espera unos segundos y vuelve a pedirlo. Nunca suena a medias.",
       inputSchema: {}
     },
     async () => texto3(await pedirALaPesta\u00F1a("sonar"))
@@ -125616,7 +126477,7 @@ function registrarHerramientasDelPuente(servidor2) {
     "quitar_grabacion",
     {
       title: "Sacar la grabaci\xF3n de la sesi\xF3n",
-      description: "Deja de sonar la grabaci\xF3n de referencia. \u26A0\uFE0F **NO toca el documento**: los puntos de sincronizaci\xF3n y la onda guardada siguen donde estaban. Es \xABno quiero o\xEDr esto ahora\xBB, no \xABborr\xE1 mi trabajo\xBB.",
+      description: "Deja de sonar la grabaci\xF3n de referencia. \u26A0\uFE0F **NO toca el documento**: los puntos de sincronizaci\xF3n y la onda guardada siguen donde estaban. Es \xABno quiero o\xEDr esto ahora\xBB, no \xABborra mi trabajo\xBB.",
       inputSchema: {}
     },
     async () => texto3(await pedirALaPesta\u00F1a("quitar_grabacion"))
@@ -126019,7 +126880,7 @@ function registrarHerramientasDelPuente(servidor2) {
     "sincronizar_letra",
     {
       title: "Alinear una letra contra la grabaci\xF3n",
-      description: "Pega cada s\xEDlaba de la letra al instante en que se canta, aline\xE1ndola contra la grabaci\xF3n **elegida**. Es F04. \u26A0\uFE0F\u26A0\uFE0F **TARDA MINUTOS** \u2014medido: unos 0,85 s por segundo de audio, o sea ~3 min para un tema de 3:30\u2014 y baja un modelo la primera vez. \u26A0\uFE0F Se alinea contra la grabaci\xF3n que est\xE9 ELEGIDA: conviene poner el stem de voz con `elegir_grabacion` antes, porque el modelo est\xE1 entrenado con habla y la mezcla completa lo confunde. \u26A0\uFE0F Esto NO es `poner_letra`: aquello escribe la s\xEDlaba en el pliego y no necesita audio; esto le pone milisegundos. Son dos letras distintas. \u26A0\uFE0F Tampoco es `guardar_letra`, que deja el texto puesto sin alinear nada y no tarda nada: si lo que se quiere es dejarle la letra lista al m\xFAsico, es aqu\xE9lla.",
+      description: "Pega cada s\xEDlaba de la letra al instante en que se canta, aline\xE1ndola contra la grabaci\xF3n **elegida**. \u26A0\uFE0F\u26A0\uFE0F **TARDA MINUTOS** \u2014medido: unos 0,85 s por segundo de audio, o sea ~3 min para un tema de 3:30\u2014 y baja un modelo la primera vez. \u26A0\uFE0F Se alinea contra la grabaci\xF3n que est\xE9 ELEGIDA: conviene poner el stem de voz con `elegir_grabacion` antes, porque el modelo est\xE1 entrenado con habla y la mezcla completa lo confunde. \u26A0\uFE0F Esto NO es `poner_letra`: aquello escribe la s\xEDlaba en el pliego y no necesita audio; esto le pone milisegundos. Son dos letras distintas. \u26A0\uFE0F Tampoco es `guardar_letra`, que deja el texto puesto sin alinear nada y no tarda nada: si lo que se quiere es dejarle la letra lista al m\xFAsico, es aqu\xE9lla.",
       inputSchema: {
         texto: external_exports.string().min(1).optional().describe(
           "La letra completa. Se parte en s\xEDlabas sola; `silabificar` sirve para verla antes. \u26A0\uFE0F **Si se omite, se usa la letra ESTACIONADA en la obra** (`guardar_letra`), que es la que el m\xFAsico tiene escrita en su cuadro. Mandarla ac\xE1 igual sirve para alinear otra cosa, pero entonces el resultado no va a coincidir con lo que \xE9l est\xE1 viendo."
@@ -126031,7 +126892,20 @@ function registrarHerramientasDelPuente(servidor2) {
         hasta: external_exports.number().optional().describe("En qu\xE9 segundo de la grabaci\xF3n termina el tramo.")
       }
     },
-    async (args2) => texto3(await pedirALaPesta\u00F1a("sincronizar_letra", args2))
+    async (args2) => {
+      const { desde, hasta } = args2;
+      if (desde === void 0 !== (hasta === void 0)) {
+        throw new ProblemaConLaObra(
+          "Un tramo va con `desde` y `hasta` juntos. Para la grabaci\xF3n entera, sin ninguno de los dos."
+        );
+      }
+      if (desde !== void 0 && hasta !== void 0 && hasta <= desde) {
+        throw new ProblemaConLaObra(
+          `El tramo va al rev\xE9s o est\xE1 vac\xEDo: empieza en el segundo ${desde} y termina en el ${hasta}.`
+        );
+      }
+      return texto3(await pedirALaPesta\u00F1a("sincronizar_letra", args2));
+    }
   );
   servidor2.registerTool(
     "audios_rechazados_por_largos",
@@ -126054,14 +126928,18 @@ function registrarHerramientasDelPuente(servidor2) {
     async ({ ruta }) => {
       exigirPesta\u00F1a();
       const ofrecido = ofrecerArchivo(ruta);
-      return texto3(
-        await pedirALaPesta\u00F1a("cargar_tipografia", {
-          nombre: ofrecido.nombre,
-          ruta,
-          bytes: ofrecido.bytes,
-          desde: `http://127.0.0.1:${puenteAbierto().puerto}/archivo/${ofrecido.ficha}`
-        })
-      );
+      try {
+        return texto3(
+          await pedirALaPesta\u00F1a("cargar_tipografia", {
+            nombre: ofrecido.nombre,
+            ruta,
+            bytes: ofrecido.bytes,
+            desde: `http://127.0.0.1:${puenteAbierto().puerto}/archivo/${ofrecido.ficha}`
+          })
+        );
+      } finally {
+        retirarArchivo(ofrecido.ficha);
+      }
     }
   );
   servidor2.registerTool(
@@ -126132,16 +127010,20 @@ function registrarHerramientasDelPuente(servidor2) {
     async ({ ruta }) => {
       exigirPesta\u00F1a();
       const ofrecido = ofrecerArchivo(ruta);
-      return texto3(
-        await pedirALaPesta\u00F1a("abrir_grabacion", {
-          nombre: ofrecido.nombre,
-          ruta,
-          bytes: ofrecido.bytes,
-          // ★ La pestaña recibe una DIRECCIÓN, no los bytes. Los bytes viajan por HTTP, en
-          //   trozos, y sólo si el músico acepta.
-          desde: `http://127.0.0.1:${puenteAbierto().puerto}/archivo/${ofrecido.ficha}`
-        })
-      );
+      try {
+        return texto3(
+          await pedirALaPesta\u00F1a("abrir_grabacion", {
+            nombre: ofrecido.nombre,
+            ruta,
+            bytes: ofrecido.bytes,
+            // ★ La pestaña recibe una DIRECCIÓN, no los bytes. Los bytes viajan por HTTP, en
+            //   trozos, y sólo si el músico acepta.
+            desde: `http://127.0.0.1:${puenteAbierto().puerto}/archivo/${ofrecido.ficha}`
+          })
+        );
+      } finally {
+        retirarArchivo(ofrecido.ficha);
+      }
     }
   );
   servidor2.registerTool(
@@ -126156,13 +127038,17 @@ function registrarHerramientasDelPuente(servidor2) {
     async ({ ruta }) => {
       exigirPesta\u00F1a();
       const ofrecido = ofrecerArchivo(ruta);
-      return texto3(
-        await pedirALaPesta\u00F1a("abrir_en_la_app", {
-          nombre: ofrecido.nombre,
-          ruta,
-          desde: `http://127.0.0.1:${puenteAbierto().puerto}/archivo/${ofrecido.ficha}`
-        })
-      );
+      try {
+        return texto3(
+          await pedirALaPesta\u00F1a("abrir_en_la_app", {
+            nombre: ofrecido.nombre,
+            ruta,
+            desde: `http://127.0.0.1:${puenteAbierto().puerto}/archivo/${ofrecido.ficha}`
+          })
+        );
+      } finally {
+        retirarArchivo(ofrecido.ficha);
+      }
     }
   );
 }
@@ -126217,10 +127103,11 @@ function registrarHerramientasDeSignos(servidor2) {
         tics: external_exports.number().int().min(0).max(99999).optional(),
         pista: external_exports.number().int().min(1).max(999).optional(),
         voz: external_exports.number().int().min(1).max(4).optional(),
+        pentagrama: campoDePentagrama,
         valor: external_exports.number().optional().describe("Para los signos que tienen grados (digitaci\xF3n, tipo de arm\xF3nico\u2026). Sin esto, alterna.")
       }
     },
-    ({ clave, compas, cuerda, golpe, tics, pista, voz, valor }) => {
+    ({ clave, compas, cuerda, golpe, tics, pista, voz, pentagrama, valor }) => {
       const elegido = signo(clave);
       if (!elegido) {
         throw new ProblemaConLaObra(
@@ -126232,9 +127119,9 @@ function registrarHerramientasDeSignos(servidor2) {
           `\xAB${elegido.nombre}\xBB es un signo de NOTA: vive en una cuerda concreta, as\xED que hay que decir cu\xE1l. Los signos del golpe entero \u2014acentos, palm mute\u2014 no la necesitan.`
         );
       }
-      const sitio = situarse(pista, compas, voz);
-      const tiempo = ticsDelGolpe(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, golpe, tics);
-      const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, cuerda ?? 1);
+      const sitio = situarse(pista, compas, voz, pentagrama);
+      const tiempo = ticsDelGolpe(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, golpe, tics, sitio.pentagrama);
+      const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, cuerda ?? 1, sitio.pentagrama);
       const resultado = aplicarSigno(sitio.documento, sitio.indice, cursor, clave, valor);
       if (!resultado.hecho) {
         throw new ProblemaConLaObra(
@@ -126264,18 +127151,19 @@ function registrarHerramientasDeSignos(servidor2) {
         tics: external_exports.number().int().min(0).max(99999).optional(),
         pista: external_exports.number().int().min(1).max(999).optional(),
         voz: external_exports.number().int().min(1).max(4).optional(),
+        pentagrama: campoDePentagrama,
         color: external_exports.string().regex(/^#[0-9a-fA-F]{6}$/, { error: (i2) => `\xAB${String(i2.input)}\xBB no es un color: va como #rrggbb, por ejemplo #c62026.` }).optional().describe("El color como #rrggbb. Obligatorio salvo para quitar."),
         como: external_exports.enum(["pintar", "subrayar"]).optional().describe("Pintar la nota (por omisi\xF3n) o subrayarla."),
         quitar: external_exports.boolean().optional().describe("true = quitarle la marca a la nota.")
       }
     },
-    ({ compas, cuerda, golpe, tics, pista, voz, color, como, quitar }) => {
+    ({ compas, cuerda, golpe, tics, pista, voz, pentagrama, color, como, quitar }) => {
       if (!quitar && !color) {
         throw new ProblemaConLaObra("Falta el color (#rrggbb). Para sacar la marca, `quitar: true`.");
       }
-      const sitio = situarse(pista, compas, voz);
-      const tiempo = ticsDelGolpe(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, golpe, tics);
-      const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, cuerda);
+      const sitio = situarse(pista, compas, voz, pentagrama);
+      const tiempo = ticsDelGolpe(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, golpe, tics, sitio.pentagrama);
+      const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, cuerda, sitio.pentagrama);
       const marca = quitar ? null : { color, subrayada: como === "subrayar" };
       const tocadas = ponerMarcaDeColor(sitio.documento, sitio.indice, cursor, marca);
       if (tocadas === 0) {
@@ -126283,7 +127171,7 @@ function registrarHerramientasDeSignos(servidor2) {
           `No hay nota en el comp\xE1s ${compas}, cuerda ${cuerda}. La marca va sobre una nota escrita: si ah\xED no hay nada, primero hay que escribirla.`
         );
       }
-      const leida = marcaDeColorDeLasNotas(situarse(pista, compas, voz).indice, cursor);
+      const leida = marcaDeColorDeLasNotas(situarse(pista, compas, voz, pentagrama).indice, cursor);
       return texto2({
         compas,
         cuerda,
@@ -126303,13 +127191,14 @@ function registrarHerramientasDeSignos(servidor2) {
         golpe: external_exports.number().int().min(1).max(999).optional(),
         tics: external_exports.number().int().min(0).max(99999).optional(),
         pista: external_exports.number().int().min(1).max(999).optional(),
-        voz: external_exports.number().int().min(1).max(4).optional()
+        voz: external_exports.number().int().min(1).max(4).optional(),
+        pentagrama: campoDePentagrama
       }
     },
-    ({ compas, cuerda, golpe, tics, pista, voz }) => {
-      const sitio = situarse(pista, compas, voz);
-      const tiempo = ticsDelGolpe(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, golpe, tics);
-      const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, cuerda);
+    ({ compas, cuerda, golpe, tics, pista, voz, pentagrama }) => {
+      const sitio = situarse(pista, compas, voz, pentagrama);
+      const tiempo = ticsDelGolpe(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, golpe, tics, sitio.pentagrama);
+      const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, cuerda, sitio.pentagrama);
       const puestos = signosPuestos(sitio.indice, cursor);
       const marca = marcaDeColorDeLasNotas(sitio.indice, cursor).comun;
       return texto2({
@@ -126336,12 +127225,13 @@ var DONDE = {
   golpe: external_exports.number().int().min(1).max(999).optional(),
   tics: external_exports.number().int().min(0).max(99999).optional(),
   pista: external_exports.number().int().min(1).max(999).optional(),
-  voz: external_exports.number().int().min(1).max(4).optional()
+  voz: external_exports.number().int().min(1).max(4).optional(),
+  pentagrama: campoDePentagrama
 };
 function ubicar(donde) {
-  const sitio = situarse(donde.pista, donde.compas, donde.voz);
-  const tiempo = ticsDelGolpe(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, donde.golpe, donde.tics);
-  const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, 1);
+  const sitio = situarse(donde.pista, donde.compas, donde.voz, donde.pentagrama);
+  const tiempo = ticsDelGolpe(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, donde.golpe, donde.tics, sitio.pentagrama);
+  const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, 1, sitio.pentagrama);
   let seleccion;
   if (donde.hasta !== void 0) {
     if (donde.hasta < donde.compas) {
@@ -126350,12 +127240,12 @@ function ubicar(donde) {
       );
     }
     const ultimo = indiceDeCompas(donde.hasta, sitio.indice);
-    const compasId = sitio.indice.compasId(sitio.pistaId, ultimo);
+    const compasId = sitio.indice.compasId(sitio.pistaId, ultimo, sitio.pentagrama);
     const golpes = sitio.indice.figuras(compasId, sitio.voz);
     const finDelUltimo = golpes.length > 0 ? golpes[golpes.length - 1].datos.tiempo : 0;
     seleccion = extenderHasta(
       seleccionDesde(cursor),
-      cursorEn(sitio.indice, sitio.pistaId, ultimo, sitio.voz, finDelUltimo, 1)
+      cursorEn(sitio.indice, sitio.pistaId, ultimo, sitio.voz, finDelUltimo, 1, sitio.pentagrama)
     );
   }
   return { ...sitio, cursor, seleccion };
@@ -126966,7 +127856,11 @@ function registrarHerramientasDeEstructura(servidor2) {
     "cambiar_metrica_del_compas",
     {
       title: "Cambiar la m\xE9trica de un comp\xE1s",
-      description: "Le cambia el comp\xE1s de amalgama a un comp\xE1s: 6/8, 3/4, 7/8\u2026 Vale de ah\xED en adelante hasta que otro comp\xE1s la vuelva a cambiar. \u26A0\uFE0F El denominador dice qu\xE9 figura lleva el pulso, as\xED que tiene que ser potencia de dos: no existe un comp\xE1s de x/5.",
+      description: (
+        // ⛔ (E14, 2026-11-11) Decía «vale de ahí en adelante», y `cambiarMetricaDelCompas`
+        //    cambia UN compás, como está decidido. El texto dice lo que hace.
+        "Le cambia la m\xE9trica a UN comp\xE1s: 6/8, 3/4, 7/8\u2026 S\xF3lo a \xE9se: los que siguen quedan como estaban. Para cambiar varios, se llama una vez por comp\xE1s. \u26A0\uFE0F El denominador dice qu\xE9 figura lleva el pulso, as\xED que tiene que ser potencia de dos: no existe un comp\xE1s de x/5."
+      ),
       inputSchema: {
         compas: external_exports.number().int().min(1).max(9999),
         numerador: external_exports.number().int().min(1).max(32).describe("Cu\xE1ntos pulsos entran: el 6 de 6/8."),
@@ -127267,9 +128161,9 @@ init_src3();
 init_obra();
 var portapapeles = null;
 function ubicar2(donde) {
-  const sitio = situarse(donde.pista, donde.compas, donde.voz);
-  const tiempo = ticsDelGolpe(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, donde.golpe, donde.tics);
-  const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, donde.cuerda ?? 1);
+  const sitio = situarse(donde.pista, donde.compas, donde.voz, donde.pentagrama);
+  const tiempo = ticsDelGolpe(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, donde.golpe, donde.tics, sitio.pentagrama);
+  const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, donde.cuerda ?? 1, sitio.pentagrama);
   if (donde.hasta === void 0) return { ...sitio, cursor, seleccion: void 0 };
   if (donde.hasta < donde.compas) {
     throw new ProblemaConLaObra(
@@ -127277,7 +128171,7 @@ function ubicar2(donde) {
     );
   }
   const ultimo = indiceDeCompas(donde.hasta, sitio.indice);
-  const compasId = sitio.indice.compasId(sitio.pistaId, ultimo);
+  const compasId = sitio.indice.compasId(sitio.pistaId, ultimo, sitio.pentagrama);
   const golpes = sitio.indice.figuras(compasId, sitio.voz);
   const fin = golpes.length > 0 ? golpes[golpes.length - 1].datos.tiempo : 0;
   return {
@@ -127285,7 +128179,7 @@ function ubicar2(donde) {
     cursor,
     seleccion: extenderHasta(
       seleccionDesde(cursor),
-      cursorEn(sitio.indice, sitio.pistaId, ultimo, sitio.voz, fin, donde.cuerda ?? 1)
+      cursorEn(sitio.indice, sitio.pistaId, ultimo, sitio.voz, fin, donde.cuerda ?? 1, sitio.pentagrama)
     )
   };
 }
@@ -127295,7 +128189,8 @@ var RANGO = {
   golpe: external_exports.number().int().min(1).max(999).optional(),
   tics: external_exports.number().int().min(0).max(99999).optional(),
   pista: external_exports.number().int().min(1).max(999).optional(),
-  voz: external_exports.number().int().min(1).max(4).optional()
+  voz: external_exports.number().int().min(1).max(4).optional(),
+  pentagrama: campoDePentagrama
 };
 function registrarHerramientasDeMusica(servidor2) {
   servidor2.registerTool(
@@ -127303,7 +128198,7 @@ function registrarHerramientasDeMusica(servidor2) {
     {
       title: "Qu\xE9 acorde forman estas notas",
       description: "Deduce el cifrado de las notas que suenan juntas en una posici\xF3n, con Tonal.js. Sirve para saber qu\xE9 se escribi\xF3 sin tener que leerlo nota por nota.",
-      inputSchema: { compas: external_exports.number().int().min(1).max(9999), golpe: external_exports.number().int().min(1).max(999).optional(), tics: external_exports.number().int().min(0).max(99999).optional(), pista: external_exports.number().int().min(1).max(999).optional(), voz: external_exports.number().int().min(1).max(4).optional() }
+      inputSchema: { compas: external_exports.number().int().min(1).max(9999), golpe: external_exports.number().int().min(1).max(999).optional(), tics: external_exports.number().int().min(0).max(99999).optional(), pista: external_exports.number().int().min(1).max(999).optional(), voz: external_exports.number().int().min(1).max(4).optional(), pentagrama: campoDePentagrama }
     },
     (donde) => {
       const sitio = ubicar2(donde);
@@ -127334,6 +128229,7 @@ function registrarHerramientasDeMusica(servidor2) {
         tics: external_exports.number().int().min(0).max(99999).optional(),
         pista: external_exports.number().int().min(1).max(999).optional(),
         voz: external_exports.number().int().min(1).max(4).optional(),
+        pentagrama: campoDePentagrama,
         forma: external_exports.string().optional().describe("La letra de la digitaci\xF3n \u2014\xABA\xBB, \xABB\xBB, \xABC\xBB\u2026\u2014 tal como la informa `acordes_de_la_obra`. Si ese acorde se toca de una sola manera, su letra es \xABA\xBB."),
         segundaTipografia: campoDeSegundaTipografia,
         sinNombre: external_exports.boolean().optional().describe("true escribe s\xF3lo las notas de `forma`, sin el cifrado arriba: el Ctrl + clic de la paleta. Pide `forma` y un golpe sin notas.")
@@ -127416,7 +128312,8 @@ function registrarHerramientasDeMusica(servidor2) {
         golpe: external_exports.number().int().min(1).max(999).optional(),
         tics: external_exports.number().int().min(0).max(99999).optional(),
         pista: external_exports.number().int().min(1).max(999).optional(),
-        voz: external_exports.number().int().min(1).max(4).optional()
+        voz: external_exports.number().int().min(1).max(4).optional(),
+        pentagrama: campoDePentagrama
       }
     },
     (donde) => {
@@ -127457,7 +128354,13 @@ function registrarHerramientasDeMusica(servidor2) {
     "deshacer",
     {
       title: "Deshacer",
-      description: "Vuelve atr\xE1s un paso. Es el MISMO historial que el Ctrl+Z del m\xFAsico: si \xE9l escribi\xF3 lo \xFAltimo, esto deshace lo suyo.",
+      description: (
+        // ⛔ (E3, 2026-11-11) Decía que compartía el Ctrl+Z del músico, y no: el historial
+        //    sólo graba los cambios hechos desde este conector (`historial()` en
+        //    `documento.ts` acota por origen). Lo que el músico escribe llega por el puente
+        //    con otro origen y queda afuera.
+        "Vuelve atr\xE1s un paso de lo que hizo la IA: cada herramienta que escribe es un paso. No deshace lo que escribi\xF3 el m\xFAsico; eso lo deshace \xE9l con su Ctrl+Z."
+      ),
       inputSchema: { pasos: external_exports.number().int().min(1).max(50, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB son demasiados pasos de una vez: van de 1 a 50.` }).optional() }
     },
     ({ pasos }) => {
@@ -127626,6 +128529,7 @@ function registrarHerramientasDeMusica(servidor2) {
         golpe: external_exports.number().int().min(1).max(999).optional(),
         pista: external_exports.number().int().min(1).max(999).optional(),
         voz: external_exports.number().int().min(1).max(4).optional(),
+        pentagrama: campoDePentagrama,
         figura: external_exports.number().int().min(1).max(64, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB no es una figura: 1 redonda, 2 blanca, 4 negra, 8 corchea, 16, 32, 64.` }).optional().describe("1 redonda, 2 blanca, 4 negra\u2026 Por omisi\xF3n, negra."),
         puntillos: external_exports.number().int().min(0).max(2).optional()
       }
@@ -127653,6 +128557,7 @@ function registrarHerramientasDeMusica(servidor2) {
         golpe: external_exports.number().int().min(1).max(999).optional(),
         pista: external_exports.number().int().min(1).max(999).optional(),
         voz: external_exports.number().int().min(1).max(4).optional(),
+        pentagrama: campoDePentagrama,
         sinAcorde: external_exports.boolean().optional()
       }
     },
@@ -127944,7 +128849,8 @@ function registrarHerramientasDeMusica(servidor2) {
         golpe: external_exports.number().int().min(1).max(999).optional(),
         tics: external_exports.number().int().min(0).max(99999).optional(),
         pista: external_exports.number().int().min(1).max(999).optional(),
-        voz: external_exports.number().int().min(1).max(4).optional()
+        voz: external_exports.number().int().min(1).max(4).optional(),
+        pentagrama: campoDePentagrama
       }
     },
     ({ campo, variante, cuerda, ...donde }) => {
@@ -127996,7 +128902,8 @@ function registrarHerramientasDeMusica(servidor2) {
         golpe: external_exports.number().int().min(1).max(999).optional(),
         tics: external_exports.number().int().min(0).max(99999).optional(),
         pista: external_exports.number().int().min(1).max(999).optional(),
-        voz: external_exports.number().int().min(1).max(4).optional()
+        voz: external_exports.number().int().min(1).max(4).optional(),
+        pentagrama: campoDePentagrama
       }
     },
     ({ matiz, ...donde }) => {
@@ -128033,12 +128940,13 @@ var DONDE2 = {
   tics: external_exports.number().int().min(0).max(99999).optional(),
   pista: external_exports.number().int().min(1).max(999).optional(),
   voz: external_exports.number().int().min(1).max(4).optional(),
-  cuerda: external_exports.number().int().min(1).optional().describe("La cuerda donde est\xE1 la nota, desde la M\xC1S GRAVE empezando en 1.")
+  cuerda: external_exports.number().int().min(1).optional().describe("La cuerda donde est\xE1 la nota, desde la M\xC1S GRAVE empezando en 1."),
+  pentagrama: campoDePentagrama
 };
 function ubicarNota(donde) {
-  const sitio = situarse(donde.pista, donde.compas, donde.voz);
-  const tiempo = ticsDelGolpe(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, donde.golpe, donde.tics);
-  const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, donde.cuerda ?? 1);
+  const sitio = situarse(donde.pista, donde.compas, donde.voz, donde.pentagrama);
+  const tiempo = ticsDelGolpe(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, donde.golpe, donde.tics, sitio.pentagrama);
+  const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, donde.cuerda ?? 1, sitio.pentagrama);
   return { ...sitio, cursor, seleccion: void 0 };
 }
 function registrarHerramientasDeBend(servidor2) {
@@ -128247,7 +129155,9 @@ function registrarHerramientasDePistas(servidor2) {
         afinacion: external_exports.array(external_exports.number().int().min(0).max(127)).optional().describe(
           "Las notas al aire en n\xFAmeros MIDI, de la M\xC1S GRAVE a la m\xE1s aguda. Tiene que traer tantas como cuerdas tenga la pista. Ver `afinaciones_disponibles`."
         ),
-        capo: external_exports.number().int().min(0).optional().describe("Traste de la cejilla. 0 = sin cejilla."),
+        // ⛔ (E8, 2026-11-11) Sin tope, `capo: 500` se aceptaba y la cuerda quedaba en MIDI 543.
+        //    El tope es el mismo traste máximo del editor (`MAX_TRASTE`).
+        capo: external_exports.number().int().min(0).max(MAX_TRASTE, { error: (i2) => `\xAB${String(i2.input)}\xBB no es un traste para la cejilla: van de 0 a ${MAX_TRASTE}.` }).optional().describe(`Traste de la cejilla, de 0 a ${MAX_TRASTE}. 0 = sin cejilla.`),
         programaMidi: external_exports.number().int().min(0).max(127).optional().describe("El sonido, en General MIDI."),
         nombreSegundaTipografia: campoDeSegundaTipografia,
         nombreCortoSegundaTipografia: campoDeSegundaTipografia
@@ -128304,7 +129214,7 @@ function registrarHerramientasDePistas(servidor2) {
     "poner_letra",
     {
       title: "Escribir la letra sobre los golpes",
-      description: "Escribe una s\xEDlaba por golpe a partir de un comp\xE1s, que es como se escribe una letra en una tablatura. \u26A0\uFE0F **No crea golpes**: escribe sobre los que ya hay y devuelve cu\xE1ntas s\xEDlabas sobraron. Crear golpes para alojar palabras inventar\xEDa ritmo que nadie toc\xF3. \u26A0\uFE0F Una s\xEDlaba vac\xEDa en la lista SALTA ese golpe, que es c\xF3mo se dice \xABac\xE1 no va letra\xBB sin desalinear lo que sigue. \u26A0\uFE0F Esto NO es la letra sincronizada con el audio (F04): es el texto que se dibuja en el pliego, y no necesita ninguna grabaci\xF3n. Para partir un texto, `silabificar`.",
+      description: "Escribe una s\xEDlaba por golpe a partir de un comp\xE1s, que es como se escribe una letra en una tablatura. \u26A0\uFE0F **No crea golpes**: escribe sobre los que ya hay y devuelve cu\xE1ntas s\xEDlabas sobraron. Crear golpes para alojar palabras inventar\xEDa ritmo que nadie toc\xF3. \u26A0\uFE0F Una s\xEDlaba vac\xEDa en la lista SALTA ese golpe, que es c\xF3mo se dice \xABac\xE1 no va letra\xBB sin desalinear lo que sigue. \u26A0\uFE0F Esto NO es la letra sincronizada con el audio: es el texto que se dibuja en el pliego, y no necesita ninguna grabaci\xF3n. Para partir un texto, `silabificar`.",
       inputSchema: {
         silabas: external_exports.array(external_exports.string()).describe("Las s\xEDlabas, en orden. Una vac\xEDa salta un golpe."),
         compas: external_exports.number().int().min(1).max(9999).default(1).describe("Desde qu\xE9 comp\xE1s empezar."),
@@ -128350,21 +129260,23 @@ function registrarHerramientasDePistas(servidor2) {
         tics: external_exports.number().int().min(0).max(99999).optional(),
         pista: external_exports.number().int().min(1).max(999).optional(),
         voz: external_exports.number().int().min(1).max(4).optional(),
+        pentagrama: campoDePentagrama,
         segundaTipografia: campoDeSegundaTipografia
       }
     },
     ({ silaba, segundaTipografia, ...donde }) => {
       empezarUnPaso();
-      const sitio = situarse(donde.pista, donde.compas, donde.voz);
+      const sitio = situarse(donde.pista, donde.compas, donde.voz, donde.pentagrama);
       const tiempo = ticsDelGolpe(
         sitio.indice,
         sitio.pistaId,
         sitio.compas,
         sitio.voz,
         donde.golpe,
-        donde.tics
+        donde.tics,
+        sitio.pentagrama
       );
-      const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, 1);
+      const cursor = cursorEn(sitio.indice, sitio.pistaId, sitio.compas, sitio.voz, tiempo, 1, sitio.pentagrama);
       const marcas = silaba ? marcasPedidas(silaba, segundaTipografia) : void 0;
       if (!ponerSilabaEnElGolpe(sitio.documento, sitio.indice, cursor, silaba, marcas)) {
         throw new ProblemaConLaObra(
@@ -128380,7 +129292,7 @@ function contarNotasDe(documento, numero2) {
 }
 
 // apps/mcp/src/herramientas/archivo.ts
-import { writeFile as writeFile2, access } from "node:fs/promises";
+import { writeFile as writeFile2, access, rename as rename2, rm } from "node:fs/promises";
 import { extname as extname3 } from "node:path";
 init_obra();
 function registrarHerramientasDeArchivo(servidor2) {
@@ -128400,7 +129312,7 @@ function registrarHerramientasDeArchivo(servidor2) {
     "exportar",
     {
       title: "Exportar la obra",
-      description: "Escribe la obra en otro formato. La ruta va completa y con su extensi\xF3n. \u26A0\uFE0F No pisa un archivo que ya exista salvo que se pida expl\xEDcitamente.",
+      description: "Escribe la obra en otro formato. La ruta va completa y con la extensi\xF3n del formato. No escribe un .mtabs: eso es `guardar_obra`. \u26A0\uFE0F No pisa un archivo que ya exista salvo que se pida expl\xEDcitamente.",
       inputSchema: {
         ruta: external_exports.string().describe("Ruta completa del archivo a escribir, con extensi\xF3n."),
         formato: external_exports.string().optional().describe("gp \xB7 musicxml \xB7 mxl \xB7 mid \xB7 alphatex. Por omisi\xF3n, se deduce de la extensi\xF3n."),
@@ -128420,6 +129332,17 @@ function registrarHerramientasDeArchivo(servidor2) {
           `No s\xE9 exportar a \xAB${formato ?? (extname3(ruta) || "(sin extensi\xF3n)")}\xBB. Los formatos son: ${claves.join(", ")}. Mira \`formatos_de_exportacion\`.`
         );
       }
+      if (extension2 === "mtabs") {
+        throw new ProblemaConLaObra(
+          `\xAB${ruta}\xBB es un .mtabs: exportar no escribe la obra. Para guardarla est\xE1 \`guardar_obra\`.`
+        );
+      }
+      const detalleElegido = FORMATOS_DE_EXPORTACION2.find((f) => f.clave === elegido);
+      if (extension2 !== detalleElegido.extension) {
+        throw new ProblemaConLaObra(
+          `El formato ${elegido} se escribe con la extensi\xF3n .${detalleElegido.extension}, y \xAB${ruta}\xBB tiene ${extension2 ? `.${extension2}` : "ninguna"}. Cambia la ruta o el formato.`
+        );
+      }
       if (!pisar) {
         const yaEsta = await access(ruta).then(
           () => true,
@@ -128432,7 +129355,15 @@ function registrarHerramientasDeArchivo(servidor2) {
         }
       }
       const bytes = exportarComo2(proyectar2(documento), elegido);
-      await writeFile2(ruta, bytes);
+      const parcial = `${ruta}.parcial`;
+      try {
+        await writeFile2(parcial, bytes);
+        await rename2(parcial, ruta);
+      } catch (e) {
+        await rm(parcial, { force: true }).catch(() => {
+        });
+        throw new ProblemaConLaObra(`No se pudo escribir \xAB${ruta}\xBB: ${e.message}`);
+      }
       const detalle = FORMATOS_DE_EXPORTACION2.find((f) => f.clave === elegido);
       return texto2({
         escrito: ruta,
@@ -128446,6 +129377,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";
@@ -128487,13 +129506,30 @@ DOS MANERAS DE LLEGAR A LA OBRA:
     aparece en su pantalla al instante, y lo que \xE9l escriba lo ves t\xFA.
 Si el m\xFAsico habla de "mi partitura" mientras tiene el programa abierto, quiere la segunda.
 `.trim();
+function cerrarElPaso() {
+  try {
+    obraAbierta().documento.historial().stopCapturing();
+  } catch {
+  }
+}
 function crearServidor() {
   const servidor2 = new McpServer(
     { name: NOMBRE, version: VERSION },
     { instructions: INSTRUCCIONES }
   );
   const registrar = servidor2.registerTool.bind(servidor2);
-  servidor2.registerTool = ((nombre, config2, cb) => registrar(nombre, { ...config2, annotations: { ...anotacionesDe(nombre), ...config2.annotations } }, cb));
+  servidor2.registerTool = ((nombre, config2, cb) => registrar(
+    nombre,
+    { ...config2, annotations: { ...anotacionesDe(nombre), ...config2.annotations } },
+    LEEN.has(nombre) ? cb : async (...a) => {
+      cerrarElPaso();
+      try {
+        return await cb(...a);
+      } finally {
+        cerrarElPaso();
+      }
+    }
+  ));
   registrarHerramientasDelDocumento(servidor2);
   registrarHerramientasDelPuente(servidor2);
   registrarHerramientasDeSignos(servidor2);
@@ -128503,6 +129539,7 @@ function crearServidor() {
   registrarHerramientasDeBend(servidor2);
   registrarHerramientasDePistas(servidor2);
   registrarHerramientasDeArchivo(servidor2);
+  registrarHerramientasDePaletas(servidor2);
   return servidor2;
 }