mandioca-tabs-mcp 0.2.18 → 0.2.19

package/index.mjs

@@ -13731,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" },
@@ -14164,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;
@@ -14554,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;
 }
@@ -14570,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 });
     }
@@ -14750,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);
@@ -14866,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: [
       {
@@ -15162,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;
@@ -16449,12 +16485,14 @@ 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();
   }
 });
 
@@ -16481,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" },
@@ -16815,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.
@@ -16893,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);
@@ -16906,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;
@@ -16937,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 = [];
@@ -20494,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;
@@ -20524,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(" ");
@@ -20621,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));
       }
     }
@@ -21420,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: ?"
       }
     };
@@ -21455,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",
@@ -21470,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: {
@@ -21481,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",
@@ -21601,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",
@@ -21616,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."
@@ -21778,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": {
@@ -22253,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": {
@@ -22349,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.",
@@ -22475,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": {
@@ -88086,6 +88148,9 @@ function juntarManosDelPiano(documento) {
     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++;
   }
@@ -88124,7 +88189,7 @@ function juntarManosDelPiano(documento) {
   });
   return parejas.length;
 }
-var DO_CENTRAL, PARAMETROS_DE_MANOS, DERECHA, IZQUIERDA;
+var DO_CENTRAL, PARAMETROS_DE_MANOS, DERECHA, IZQUIERDA, MANO_EXPLICITA, esTeclado;
 var init_manosDelPiano = __esm({
   "packages/io/src/manosDelPiano.ts"() {
     init_src2();
@@ -88143,6 +88208,8 @@ var init_manosDelPiano = __esm({
     };
     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);
   }
 });
 
@@ -89156,6 +89223,19 @@ function alturaMusicXml(midi, fifths, modo = 0) {
   if (abajo) return { paso: abajo.paso, alteracion: 1, octava };
   throw new Error(`altura MIDI no representable: ${midi}`);
 }
+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 claveDelPentagrama(staff, bar) {
   if (staff.isPercussion) return { signo: "percussion", linea: 2, lineas: 5, conAfinacion: false };
   if (staff.showTablature && staff.tuning.length > 0)
@@ -89242,7 +89322,7 @@ function escribirNota(note, beat, staff, opciones) {
     s.push("</unpitched>");
   } else {
     const { paso, alteracion, octava } = alturaMusicXml(
-      note.calculateRealValue(false, false),
+      note.calculateRealValue(false, false) - staff.displayTranspositionPitch,
       opciones.fifths,
       note.accidentalMode
     );
@@ -89276,6 +89356,11 @@ function escribirNota(note, beat, staff, opciones) {
   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 = [];
@@ -89374,8 +89459,11 @@ function exportarMusicXml(score) {
       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(...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>`);
@@ -89464,6 +89552,13 @@ function exportarMusicXml(score) {
         }
         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;
@@ -89597,7 +89692,7 @@ function exportarMusicXmlComprimido(score) {
     { mtime: FECHA_FIJA_DEL_ZIP }
   );
 }
-var DIVISIONES_POR_NEGRA, FECHA_FIJA_DEL_ZIP, PASOS, NOMBRE_DE_LA_FIGURA2, ALTERACION_POR_MODO, D, SALTOS, claveDeSalto, SALTO_POR_CLAVE;
+var 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();
@@ -89627,6 +89722,7 @@ var init_musicxml = __esm({
       [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"' }],
@@ -89701,11 +89797,13 @@ function prepararMusicXml(xml) {
   });
   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.`
+      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} notas de acordes repartidos entre los dos pentagramas se pusieron en el suyo.`);
+    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;
@@ -89732,7 +89830,10 @@ function prepararMusicXml(xml) {
       return `${a}${texto4.trimEnd()}-${b}`;
     });
   });
-  if (silabas2) correcciones.push(`${silabas2} s\xEDlabas unidas de la letra se marcaron con su guion.`);
+  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];
@@ -90066,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) {
@@ -90111,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,
@@ -90168,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) {
@@ -90233,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 ?? []) {
@@ -90367,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,
@@ -90418,6 +90546,17 @@ 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);
   const manosJuntadas = juntarManosDelPiano(documento);
   if (manosJuntadas > 0)
@@ -90515,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;
@@ -91136,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 };
@@ -91376,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).`);
@@ -91585,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);
@@ -91767,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)",
@@ -91855,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 = {}) {
@@ -91903,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.`
     );
@@ -92360,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 {
@@ -92499,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) {
@@ -92562,7 +92773,7 @@ var VERSION_DEL_CONECTOR;
 var init_version = __esm({
   "apps/mcp/src/version.ts"() {
     "use strict";
-    VERSION_DEL_CONECTOR = true ? "0.2.18" : null;
+    VERSION_DEL_CONECTOR = true ? "0.2.19" : null;
   }
 });
 
@@ -92577,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,
@@ -92592,6 +92805,7 @@ __export(puente_exports, {
   pesta\u00F1asAhora: () => pesta\u00F1asAhora,
   puenteAbierto: () => puenteAbierto,
   reservarArchivo: () => reservarArchivo,
+  retirarArchivo: () => retirarArchivo,
   soltarReserva: () => soltarReserva
 });
 import { createServer } from "node:http";
@@ -92654,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() {
@@ -92689,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);
@@ -92701,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();
@@ -92764,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") {
@@ -92774,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;
@@ -92921,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.
@@ -92959,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);
@@ -92977,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);
@@ -93158,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";
@@ -93188,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])
@@ -100707,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 }]);
@@ -100932,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;
@@ -100975,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) {
@@ -101007,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;
 }
@@ -101048,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();
@@ -101059,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();
   }
 });
@@ -125207,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",
@@ -125237,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();
@@ -125260,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);
@@ -125272,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) {
@@ -125337,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);
@@ -125377,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();
@@ -125796,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 });
     }
@@ -125853,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();
@@ -125871,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)."
       });
     }
   );
@@ -125883,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);
@@ -125930,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({
@@ -125988,6 +126265,7 @@ function registrarHerramientasDelPuente(servidor2) {
       inputSchema: {}
     },
     async () => {
+      soltarLaObraDeLaPesta\u00F1a();
       await cerrarPuente();
       return texto3({ desconectado: true });
     }
@@ -125996,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"))
@@ -126199,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"))
@@ -126602,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."
@@ -126614,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",
@@ -126637,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(
@@ -126715,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(
@@ -126739,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);
+      }
     }
   );
 }
@@ -126800,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(
@@ -126815,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(
@@ -126847,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) {
@@ -126866,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,
@@ -126886,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({
@@ -126919,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) {
@@ -126933,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 };
@@ -127549,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."),
@@ -127850,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(
@@ -127860,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 {
@@ -127868,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)
     )
   };
 }
@@ -127878,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(
@@ -127886,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);
@@ -127917,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.")
@@ -127999,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) => {
@@ -128040,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 }) => {
@@ -128209,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()
       }
@@ -128236,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()
       }
     },
@@ -128527,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 }) => {
@@ -128579,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 }) => {
@@ -128616,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) {
@@ -128830,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
@@ -128887,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."),
@@ -128933,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(
@@ -128963,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) {
@@ -128983,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."),
@@ -129003,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,
@@ -129015,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,
@@ -129158,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);