mandioca-tabs-mcp 0.2.14 → 0.2.15

package/index.mjs

@@ -12308,6 +12308,10 @@ function ordenar(mapa) {
   return salida;
 }
 function ticsDeFigura(figura) {
+  return Math.round(ticsExactosDeFigura(figura));
+}
+function ticsExactosDeFigura(figura) {
+  if (figura.adorno) return 0;
   let tics = TICS_POR_NEGRA * 4 / figura.valor;
   let agregado = tics;
   for (let i2 = 0; i2 < figura.puntillos; i2++) {
@@ -12317,7 +12321,7 @@ function ticsDeFigura(figura) {
   if (figura.tupletNumerador > 0 && figura.tupletDenominador > 0) {
     tics = tics * figura.tupletDenominador / figura.tupletNumerador;
   }
-  return Math.round(tics);
+  return tics;
 }
 function migrarMarcasPorGrado(guardadas, pintarGradosViejo) {
   const salida = {};
@@ -13297,6 +13301,7 @@ function normalizarNota(crudo) {
     deslizamientoEntrada: numero(crudo.deslizamientoEntrada, 0),
     deslizamientoSalida: numero(crudo.deslizamientoSalida, 0),
     armonico: numero(crudo.armonico, 0),
+    armonicoValor: numero(crudo.armonicoValor, 0),
     bend: lista(crudo.bend),
     // ── Los signos de Guitar Pro. Ausente = no lo tenía. ────────────────────
     acento: numero(crudo.acento, 0),
@@ -13790,7 +13795,7 @@ function volcar(documento) {
         const notas = [...notasPorFigura.get(id2) ?? []].sort((a, b) => a.cuerda - b.cuerda);
         totalNotasPista += notas.length;
         return {
-          voz: datos.voz,
+          voz: datos.voz + 1,
           tiempo: datos.tiempo,
           duracion: nombreDeDuracion(datos),
           tics: ticsDeFigura(datos),
@@ -14156,6 +14161,25 @@ var init_enBlanco = __esm({
   }
 });
 
+// packages/model/src/armadura.ts
+function armaduraEscrita(concierto, transposicion) {
+  if (!transposicion) return concierto;
+  return normalizar(concierto - 7 * transposicion);
+}
+function armaduraDeConcierto(escrita, transposicion) {
+  if (!transposicion) return escrita;
+  return normalizar(escrita + 7 * transposicion);
+}
+var normalizar;
+var init_armadura = __esm({
+  "packages/model/src/armadura.ts"() {
+    normalizar = (quintas) => {
+      const k = (quintas % 12 + 12) % 12;
+      return k > 6 ? k - 12 : k;
+    };
+  }
+});
+
 // packages/model/src/index.ts
 var init_src2 = __esm({
   "packages/model/src/index.ts"() {
@@ -14168,6 +14192,7 @@ var init_src2 = __esm({
     init_migrar();
     init_kit();
     init_tipos();
+    init_armadura();
   }
 });
 
@@ -14184,7 +14209,7 @@ function posicionesEscribibles(indice, cursor) {
 }
 function cursorInicial(indice, pistaId) {
   const pista = pistaId !== void 0 ? indice.pista(pistaId) : indice.pistas[0];
-  return normalizar(indice, {
+  return normalizar2(indice, {
     pistaId: pista?.id ?? "",
     compas: 0,
     voz: 0,
@@ -14192,7 +14217,7 @@ function cursorInicial(indice, pistaId) {
     cuerda: 1
   });
 }
-function normalizar(indice, cursor) {
+function normalizar2(indice, cursor) {
   const pista = indice.pista(cursor.pistaId) ?? indice.pistas[0];
   const cuerdas = pista?.datos.afinacion.length ?? 6;
   const ultimoCompas = Math.max(0, indice.cantidadDeCompases - 1);
@@ -14345,6 +14370,50 @@ var init_dinamicas = __esm({
   }
 });
 
+// packages/editor/src/ligaduras.ts
+function repararLigaduras(documento, pistas, modo) {
+  const indice = indexar(documento);
+  let tocadas = 0;
+  for (const pistaId of new Set(pistas)) {
+    if (indice.pista(pistaId)?.datos.tipo !== "trastes") continue;
+    const ultimas = /* @__PURE__ */ new Map();
+    for (let c = 0; c < indice.cantidadDeCompases; c++) {
+      const figuras = [...indice.figuras(indice.compasId(pistaId, c))].sort(
+        (a, b) => a.datos.voz - b.datos.voz || a.datos.tiempo - b.datos.tiempo
+      );
+      for (const figura of figuras) {
+        for (const nota of indice.notas(figura.id)) {
+          const clave = `${figura.datos.voz}|${nota.datos.cuerda}`;
+          const origen = ultimas.get(clave);
+          const mapa = documento.notas.get(nota.id);
+          let traste = nota.datos.traste;
+          if (nota.datos.ligadaAAnterior && mapa) {
+            if (origen === void 0) {
+              mapa.set("ligadaAAnterior", false);
+              tocadas++;
+            } else if (origen !== traste) {
+              if (modo === "seguir") {
+                mapa.set("traste", origen);
+                traste = origen;
+              } else {
+                mapa.set("ligadaAAnterior", false);
+              }
+              tocadas++;
+            }
+          }
+          ultimas.set(clave, traste);
+        }
+      }
+    }
+  }
+  return tocadas;
+}
+var init_ligaduras = __esm({
+  "packages/editor/src/ligaduras.ts"() {
+    init_src2();
+  }
+});
+
 // packages/editor/src/comandos.ts
 function masLarga(duracion) {
   const i2 = VALORES.indexOf(duracion.valor);
@@ -14384,7 +14453,12 @@ function escribirEnLaCuerda(documento, indice, cursor, cuerda, resolverTraste, d
     let notaId;
     if (notaExistente && figuraExistente && figuraId === figuraExistente.id) {
       notaId = notaExistente.id;
-      documento.notas.get(notaId)?.set("traste", traste);
+      const mapa = documento.notas.get(notaId);
+      mapa?.set("traste", traste);
+      if (traste !== notaExistente.datos.traste) {
+        if (notaExistente.datos.ligadaAAnterior) mapa?.set("ligadaAAnterior", false);
+        repararLigaduras(documento, [cursor.pistaId], "seguir");
+      }
     } else {
       notaId = documento.agregarNota(notaNueva(figuraId, cuerda, traste));
     }
@@ -14457,6 +14531,9 @@ function borrarPercusion(documento, indice, cursor, articulacion) {
 function escribirTraste(documento, indice, cursor, cuerda, traste, opciones = {}) {
   const tope = opciones.maxTraste ?? MAX_TRASTE;
   const acotado = Math.max(0, Math.min(tope, Math.round(traste)));
+  const pista = indice.pista(cursor.pistaId);
+  const cuerdas = pista?.datos.afinacion.length ?? 0;
+  if (pista?.datos.tipo === "trastes" && (cuerda < 1 || cuerda > cuerdas || !Number.isInteger(cuerda))) return null;
   return escribirEnLaCuerda(
     documento,
     indice,
@@ -14514,7 +14591,7 @@ function cambiarDuracion(documento, indice, cursor, duracion, seleccion) {
 function retejerLosCompasesDe(documento, golpes) {
   const compases = /* @__PURE__ */ new Map();
   for (const g of golpes) compases.set(`${g.compasId} ${g.voz}`, g);
-  for (const { compasId, voz } of compases.values()) retejerVoz(documento, compasId, voz);
+  retejerVoces(documento, compases.values());
 }
 function escalarDuracion(documento, indice, cursor, direccion, seleccion) {
   const golpes = golpesAlcanzados(indice, cursor, seleccion);
@@ -14554,17 +14631,31 @@ function duracionesAlcanzadas(indice, cursor, seleccion) {
   }
   return [...vistas.values()].sort((a, b) => a.valor - b.valor || a.puntillos - b.puntillos);
 }
-function retejerVoz(documento, compasId, voz) {
-  const figuras = [];
+function retejerVoces(documento, voces) {
+  const pedidas = /* @__PURE__ */ new Map();
+  for (const v of voces) {
+    const clave = `${v.compasId} ${v.voz}`;
+    const ya = pedidas.get(clave);
+    if (!ya) pedidas.set(clave, { desde: v.desde, figuras: [] });
+    else if (v.desde !== void 0) ya.desde = ya.desde === void 0 ? v.desde : Math.min(ya.desde, v.desde);
+  }
+  if (pedidas.size === 0) return;
   for (const [id2, entidad] of documento.figuras.entries()) {
-    const datos = entidad.toJSON();
-    if (datos.compasId === compasId && datos.voz === voz) figuras.push({ id: id2, datos });
+    const compasId = entidad.get("compasId");
+    const voz = entidad.get("voz");
+    const pedida = pedidas.get(`${compasId} ${voz}`);
+    if (pedida) pedida.figuras.push({ id: id2, datos: entidad.toJSON() });
   }
-  figuras.sort((a, b) => a.datos.tiempo - b.datos.tiempo);
-  let tiempo = figuras[0]?.datos.tiempo ?? 0;
-  for (const { id: id2, datos } of figuras) {
-    if (datos.tiempo !== tiempo) documento.figuras.get(id2)?.set("tiempo", tiempo);
-    tiempo += ticsDeFigura(datos);
+  for (const { desde, figuras } of pedidas.values()) {
+    figuras.sort((a, b) => a.datos.tiempo - b.datos.tiempo);
+    const primera = figuras.findIndex((f) => desde === void 0 || f.datos.tiempo >= desde);
+    if (primera < 0) continue;
+    let exacto = desde ?? figuras[primera].datos.tiempo;
+    for (const { id: id2, datos } of figuras.slice(primera)) {
+      const tiempo = Math.round(exacto);
+      if (datos.tiempo !== tiempo) documento.figuras.get(id2)?.set("tiempo", tiempo);
+      exacto += ticsExactosDeFigura(datos);
+    }
   }
 }
 function figuraNueva(compasId, cursor, duracion) {
@@ -14610,6 +14701,7 @@ var init_comandos = __esm({
   "packages/editor/src/comandos.ts"() {
     init_dinamicas();
     init_src2();
+    init_ligaduras();
     init_seleccion();
     DURACION_INICIAL = { valor: 4, puntillos: 0 };
     VALORES = [1, 2, 4, 8, 16, 32, 64];
@@ -14626,6 +14718,14 @@ var init_comandos = __esm({
 });
 
 // packages/editor/src/pasajes.ts
+function rellenarConSilencios(documento, compasId, voz, desde, hasta) {
+  let t = desde;
+  while (hasta - t >= ticsDeFigura({ valor: 64, puntillos: 0, tupletNumerador: 0, tupletDenominador: 0 })) {
+    const valor = VALORES.find((v) => ticsDeFigura({ valor: v, puntillos: 0, tupletNumerador: 0, tupletDenominador: 0 }) <= hasta - t);
+    documento.agregarFigura(normalizarFigura({ compasId, voz, tiempo: t, valor, puntillos: 0, esSilencio: true }));
+    t += ticsDeFigura({ valor, puntillos: 0, tupletNumerador: 0, tupletDenominador: 0 });
+  }
+}
 function copiar(indice, seleccion) {
   const figuras = figurasDelPasaje(indice, seleccion);
   if (figuras.length === 0) return null;
@@ -14684,6 +14784,7 @@ function pegar(documento, indice, cursor, portapapeles2) {
     }
   }
   const aBorrar = [];
+  const restos = [];
   for (const [compasDelTramo, tramo] of tramos) {
     const compasId = indice.compasId(cursor.pistaId, compasDelTramo, cursor.pentagrama);
     for (const figura of indice.figuras(compasId, cursor.voz)) {
@@ -14691,6 +14792,8 @@ function pegar(documento, indice, cursor, portapapeles2) {
       const fin = inicio + ticsDeFigura(figura.datos);
       if (inicio < tramo.hasta && fin > tramo.desde) {
         aBorrar.push({ figuraId: figura.id, notas: indice.notas(figura.id).map((n) => n.id) });
+        if (inicio < tramo.desde) restos.push({ compas: compasDelTramo, desde: inicio, hasta: tramo.desde });
+        if (fin > tramo.hasta) restos.push({ compas: compasDelTramo, desde: tramo.hasta, hasta: fin });
       }
     }
   }
@@ -14729,9 +14832,15 @@ function pegar(documento, indice, cursor, portapapeles2) {
       });
       for (const nota of notas) documento.agregarNota({ ...nota, figuraId });
     }
-    for (const compasId of compasesDestino.values()) {
-      if (compasId) retejerVoz(documento, compasId, cursor.voz);
+    for (const resto of restos) {
+      const compasId = compasesDestino.get(resto.compas);
+      if (compasId) rellenarConSilencios(documento, compasId, cursor.voz, resto.desde, resto.hasta);
     }
+    retejerVoces(
+      documento,
+      [...compasesDestino.values()].flatMap((compasId) => compasId ? [{ compasId, voz: cursor.voz }] : [])
+    );
+    repararLigaduras(documento, [cursor.pistaId], "soltar");
   });
   return true;
 }
@@ -14775,9 +14884,45 @@ function duplicarUltima(documento, indice, cursor, opciones = {}) {
   };
   return pegar(documento, indice, cursor, portapapeles2);
 }
+function origenEnElPasaje(indice, pistaId, notaId, enElPasaje) {
+  const datos = enElPasaje.get(notaId);
+  if (!datos) return false;
+  const nota = { datos };
+  const enOrden = [];
+  for (let c = 0; c < indice.cantidadDeCompases; c++)
+    for (const f of [...indice.figuras(indice.compasId(pistaId, c))].sort((a, b) => a.datos.tiempo - b.datos.tiempo))
+      enOrden.push({ id: f.id, voz: f.datos.voz });
+  const donde = enOrden.findIndex((f) => f.id === nota.datos.figuraId);
+  for (let k = donde - 1; k >= 0; k--) {
+    if (enOrden[k].voz !== enOrden[donde].voz) continue;
+    const anterior = indice.notaEnCuerda(enOrden[k].id, nota.datos.cuerda);
+    if (anterior) return enElPasaje.has(anterior.id);
+  }
+  return false;
+}
 function transponer(documento, indice, seleccion, trastes, maxTraste = MAX_TRASTE) {
   const figuras = figurasDelPasaje(indice, seleccion);
+  const tipo = indice.pista(seleccion.pistaId)?.datos.tipo;
+  if (tipo === "percusion") return { hecho: false, motivo: "no-se-transpone" };
+  if (tipo === "altura") {
+    const alturas = [];
+    for (const figura of figuras) {
+      for (const nota of indice.notas(figura.id)) {
+        if (nota.datos.altura === null || nota.datos.altura === void 0) continue;
+        const nueva = nota.datos.altura + trastes;
+        if (nueva < 0 || nueva > 127) return { hecho: false, motivo: "fuera-del-rango" };
+        alturas.push({ notaId: nota.id, altura: nueva });
+      }
+    }
+    if (alturas.length === 0) return { hecho: false, motivo: "sin-notas" };
+    documento.doc.transact(() => {
+      for (const c of alturas) documento.notas.get(c.notaId)?.set("altura", c.altura);
+    });
+    return { hecho: true, notas: alturas.length };
+  }
   const cambios = [];
+  const enElPasaje = /* @__PURE__ */ new Map();
+  for (const figura of figuras) for (const nota of indice.notas(figura.id)) enElPasaje.set(nota.id, nota.datos);
   for (const figura of figuras) {
     for (const nota of indice.notas(figura.id)) {
       const nuevo = nota.datos.traste + trastes;
@@ -14788,6 +14933,12 @@ function transponer(documento, indice, seleccion, trastes, maxTraste = MAX_TRAST
   if (cambios.length === 0) return { hecho: false, motivo: "sin-notas" };
   documento.doc.transact(() => {
     for (const cambio of cambios) documento.notas.get(cambio.notaId)?.set("traste", cambio.traste);
+    for (const cambio of cambios) {
+      const nota = documento.notas.get(cambio.notaId);
+      if (nota?.get("ligadaAAnterior") && !origenEnElPasaje(indice, seleccion.pistaId, cambio.notaId, enElPasaje))
+        nota.set("ligadaAAnterior", false);
+    }
+    repararLigaduras(documento, [seleccion.pistaId], "seguir");
   });
   return { hecho: true, notas: cambios.length };
 }
@@ -14798,17 +14949,18 @@ function borrarPasaje(documento, indice, seleccion) {
     id: f.id,
     notas: indice.notas(f.id).map((n) => n.id)
   }));
-  const compases = new Set(
-    figuras.map((f) => indice.compasId(seleccion.pistaId, f.compas, seleccion.pentagrama)).filter(Boolean)
-  );
+  const desdeEn = /* @__PURE__ */ new Map();
+  for (const f of figuras) {
+    const compasId = indice.compasId(seleccion.pistaId, f.compas, seleccion.pentagrama);
+    if (compasId) desdeEn.set(compasId, Math.min(desdeEn.get(compasId) ?? Infinity, f.tiempo));
+  }
   documento.doc.transact(() => {
     for (const figura of aBorrar) {
       for (const notaId of figura.notas) documento.notas.delete(notaId);
       documento.figuras.delete(figura.id);
     }
-    for (const compasId of compases) {
-      if (compasId) retejerVoz(documento, compasId, seleccion.voz);
-    }
+    retejerVoces(documento, [...desdeEn].map(([compasId, desde]) => ({ compasId, voz: seleccion.voz, desde })));
+    repararLigaduras(documento, [seleccion.pistaId], "soltar");
   });
   return aBorrar.length;
 }
@@ -14896,6 +15048,7 @@ function borrarCompas(documento, indice, compas) {
     }
     for (const compasId of compases) documento.compases.delete(compasId);
     documento.compasesMaestros.delete(maestro.id);
+    repararLigaduras(documento, indice.pistas.map((p) => p.id), "soltar");
   });
   return true;
 }
@@ -14950,6 +15103,7 @@ function borrarRango(documento, indice, desde, hasta) {
     }
     for (const compasId of compases) documento.compases.delete(compasId);
     for (const id2 of maestros) documento.compasesMaestros.delete(id2);
+    repararLigaduras(documento, indice.pistas.map((p) => p.id), "soltar");
   });
   return maestros.length;
 }
@@ -14974,6 +15128,7 @@ var init_pasajes = __esm({
   "packages/editor/src/pasajes.ts"() {
     init_src2();
     init_comandos();
+    init_ligaduras();
     init_seleccion();
   }
 });
@@ -20780,7 +20935,7 @@ function notasDeLaPista(indice, pistaId) {
     if (!compasId) continue;
     for (const figura of indice.figuras(compasId)) {
       for (const nota of indice.notas(figura.id)) {
-        salida.push({ id: nota.id, cuerda: nota.datos.cuerda });
+        salida.push({ id: nota.id, cuerda: nota.datos.cuerda, figuraId: figura.id });
       }
     }
   }
@@ -20817,11 +20972,15 @@ function quitarCuerda(documento, indice, pistaId, donde) {
   const todas = notasDeLaPista(indice, pistaId);
   const aBorrar = todas.filter((n) => n.cuerda === cuerdaQueSeVa);
   const aRenumerar = donde === "grave" ? todas.filter((n) => n.cuerda > 1) : [];
+  const quedan = /* @__PURE__ */ new Map();
+  for (const n of todas) quedan.set(n.figuraId, (quedan.get(n.figuraId) ?? 0) + (n.cuerda === cuerdaQueSeVa ? 0 : 1));
   documento.doc.transact(() => {
     for (const nota of aBorrar) documento.notas.delete(nota.id);
     for (const nota of aRenumerar) {
       documento.notas.get(nota.id)?.set("cuerda", nota.cuerda - 1);
     }
+    for (const [figuraId, cuantas] of quedan)
+      if (cuantas === 0) documento.figuras.get(figuraId)?.set("esSilencio", true);
     documento.pistas.get(pistaId)?.set("afinacion", nuevaAfinacion);
   });
   return { hecho: true, cuerdas: nuevaAfinacion.length, notasBorradas: aBorrar.length };
@@ -88453,7 +88612,7 @@ function prepararMusicXml(xml) {
   });
   if (atributosMovidos) {
     correcciones.push(
-      `${atributosMovidos} cambios de clave, armadura o comp\xE1s escritos antes de la barra pasaron al comp\xE1s siguiente.`
+      `${atributosMovidos} cambios de clave, armadura o comp\xE1s escritos entre las notas se pusieron al principio del comp\xE1s donde rigen.`
     );
   }
   if (acordesSeparados) {
@@ -88474,6 +88633,17 @@ function prepararMusicXml(xml) {
     });
   });
   if (juntados) correcciones.push(`${juntados} indicaciones de texto en varios renglones se juntaron en una.`);
+  let silabas2 = 0;
+  salida = salida.replace(/<lyric\b[^>]*>[\s\S]*?<\/lyric>/g, (lyric) => {
+    const tipo = /<syllabic>\s*(\w+)\s*<\/syllabic>/.exec(lyric)?.[1];
+    if (tipo !== "begin" && tipo !== "middle") return lyric;
+    return lyric.replace(/(<text\b[^>]*>)([\s\S]*?)(<\/text>)/, (m, a, texto4, b) => {
+      if (texto4.trimEnd().endsWith("-")) return m;
+      silabas2++;
+      return `${a}${texto4.trimEnd()}-${b}`;
+    });
+  });
+  if (silabas2) correcciones.push(`${silabas2} s\xEDlabas unidas de la letra se marcaron con su guion.`);
   let tempos = 0;
   salida = salida.replace(/<metronome\b[^>]*>[\s\S]*?<\/metronome>/g, (met) => {
     const unidad = /<beat-unit>\s*([\w-]+)\s*<\/beat-unit>/.exec(met)?.[1];
@@ -88507,6 +88677,16 @@ function rearmar(parte, compases, nuevos) {
   });
   return salida + parte.slice(cursor);
 }
+function tiempoAl(pedazo) {
+  let t = 0;
+  for (const m of pedazo.matchAll(/<(note|backup|forward)\b[\s\S]*?<\/\1>/g)) {
+    const dur = entero(m[0], /<duration>\s*(\d+)\s*<\/duration>/) ?? 0;
+    if (m[1] === "backup") t -= dur;
+    else if (m[1] === "forward") t += dur;
+    else if (!/<chord\s*\/>/.test(m[0]) && !/<grace\b/.test(m[0])) t += dur;
+  }
+  return t;
+}
 function moverAtributosDeFinDeCompas(parte) {
   const compases = compasesDe(parte);
   let cuantos = 0;
@@ -88516,15 +88696,18 @@ function moverAtributosDeFinDeCompas(parte) {
     const primeraNota = contenido.search(/<note\b/);
     if (primeraNota >= 0) {
       let llevar = "";
-      contenido = contenido.slice(0, primeraNota) + contenido.slice(primeraNota).replace(/<attributes\b[^>]*>([\s\S]*?)<\/attributes>/g, (bloque, adentro) => {
+      let alPrincipio = "";
+      const despues = contenido.slice(primeraNota);
+      contenido = contenido.slice(0, primeraNota) + despues.replace(/<attributes\b[^>]*>([\s\S]*?)<\/attributes>/g, (bloque, adentro, donde) => {
         const hijos = adentro.match(HIJO_QUE_SE_MUEVE);
         if (!hijos) return bloque;
         cuantos += hijos.length;
-        llevar += hijos.join("");
+        if (tiempoAl(despues.slice(0, donde)) <= 0) alPrincipio += hijos.join("");
+        else llevar += hijos.join("");
         const resto = adentro.replace(HIJO_QUE_SE_MUEVE, "");
         return resto.trim() ? `<attributes>${resto}</attributes>` : "";
       });
-      const entra2 = arrastre;
+      const entra2 = arrastre + alPrincipio;
       arrastre = llevar;
       return (entra2 ? `<attributes>${entra2}</attributes>` : "") + contenido;
     }
@@ -88759,6 +88942,13 @@ var init_musicxmlEntrada = __esm({
 });
 
 // packages/io/src/importarGp.ts
+function piezaDeBateria(pista, numero2) {
+  if (numero2 < 0) return null;
+  const delArchivo = pista.percussionArticulations ?? [];
+  const midi = numero2 < delArchivo.length ? delArchivo[numero2].outputMidiNumber : SALIDA_DE_ID_GP[numero2] ?? numero2;
+  const buscada = PARIENTE_GM[midi] ?? midi;
+  return KIT.find((p) => p.midi === buscada)?.indice ?? null;
+}
 function importarGp(bytes, opciones = {}) {
   const xml = textoMusicXml(bytes);
   if (xml === null) {
@@ -88803,18 +88993,21 @@ function importarScore(score, opciones = {}, datos = {}) {
       "La autor\xEDa qued\xF3 sin completar: se import\xF3 como transcripci\xF3n con los datos del archivo. Hay que confirmarla antes de publicar o compartir el documento."
     );
   }
+  const saltosEscritos = saltosDelTexto(score);
   const idsDeCompasMaestro = score.masterBars.map(
     (maestro) => documento.agregarCompasMaestro(normalizarCompasMaestro({
       numerador: maestro.timeSignatureNumerator,
       denominador: maestro.timeSignatureDenominator,
-      tonalidad: numeroDeTonalidad(maestro.keySignature),
+      tonalidad: numeroDeTonalidad(tonalidadDeConcierto(score, maestro.index)),
       // ⚠️ El ensayo de un MusicXML (`<rehearsal>A</rehearsal>`) llena sólo `section.marker`;
       //    `text` queda vacío y las letras A, B, C… se perdían todas. Un `.gp` trae las dos y
       //    manda el texto, como siempre.
       seccion: maestro.section?.text || maestro.section?.marker || "",
-      // Solo interesa el cambio de tempo que arranca en este compás; los que caen
-      // en el medio son F02 y todavía no tienen dónde ir.
-      tempo: maestro.tempoAutomations?.[0]?.value ?? null,
+      // El cambio de tempo que arranca EN este compás. Los que caen a mitad van a su figura
+      // (ver `temposAMitad` abajo).
+      // ⛔ (2026-11-10) Antes era `tempoAutomations[0]` sin mirar dónde caía: un 140 a mitad
+      //    del compás 2 se aplicaba desde su principio y la primera mitad sonaba a 140.
+      tempo: maestro.tempoAutomations?.find((a) => a.ratioPosition <= 1e-6)?.value ?? null,
       repiteDesdeAca: maestro.isRepeatStart,
       repiteVeces: maestro.repeatCount,
       // ⚠️ Novena pérdida silenciosa de la misma familia: 2 de los 15 `.gp` de Daniel
@@ -88842,7 +89035,7 @@ function importarScore(score, opciones = {}, datos = {}) {
       //
       // ★ El nombre y no el número, además, porque acá es una LISTA y se lee: un
       //   `["JumpDalSegnoAlCoda"]` en el documento dice algo; un `[10]` no.
-      direcciones: maestro.directions ? [...maestro.directions].map(
+      direcciones: maestro.directions ? [...saltosEscritos.precisos.get(maestro.index) ?? maestro.directions].map(
         (d) => _barrel_exports$4.Direction[d] ?? String(d)
       ) : []
     }))
@@ -88853,7 +89046,7 @@ function importarScore(score, opciones = {}, datos = {}) {
     const id2 = idsDeCompasMaestro[i2];
     if (id2 !== void 0 && i2 > 0) documento.ponerSaltoDeRenglon(id2, true);
   }
-  const letrasDobles = { cuantas: 0 };
+  const letrasDobles = { cuantas: 0, versosDeMas: 0 };
   const tipoDelPentagrama = (p) => p.isPercussion ? "percusion" : p.tuning.length === 0 ? "altura" : "trastes";
   for (const pista of score.tracks) {
     if (pista.staves.length === 0) {
@@ -88868,6 +89061,8 @@ function importarScore(score, opciones = {}, datos = {}) {
       const nombreCortoDePista = variosPentagramas ? `${pista.shortName ?? ""} ${numeroDePentagrama + 1}`.trim() : pista.shortName ?? "";
       const pentagramaEnLaPista = unInstrumento ? numeroDePentagrama : 0;
       const tipo = tipoDelPentagrama(pentagrama);
+      const sinPieza = /* @__PURE__ */ new Map();
+      const articulacionDe = (n) => piezaDeBateria(pista, n.percussionArticulation);
       const idPista = unInstrumento && idDelInstrumento || documento.agregarPista({
         tipo,
         nombre: nombreDePista,
@@ -88945,7 +89140,7 @@ function importarScore(score, opciones = {}, datos = {}) {
                 // ★ Acá viene la letra. En la canción de Daniel cada sílaba está escrita
                 //   como texto del golpe, que es como se hace en la práctica en Guitar Pro.
                 //   Sin este campo, importar y exportar la borraba sin decir nada.
-                texto: textoDelGolpe(golpe, letrasDobles),
+                texto: saltosEscritos.textos.has(golpe) ? "" : textoDelGolpe(golpe, letrasDobles),
                 // ═══════════════════════════════════════════════════════════════════
                 // ⛔⛔ LOS CIFRADOS DE ACORDE SE PERDÍAN TODOS (2026-11-09)
                 // ═══════════════════════════════════════════════════════════════════
@@ -89003,6 +89198,11 @@ function importarScore(score, opciones = {}, datos = {}) {
               })
             );
             for (const nota of golpe.notes) {
+              if (tipo === "percusion" && articulacionDe(nota) === null) {
+                const n = nota.percussionArticulation;
+                sinPieza.set(n, (sinPieza.get(n) ?? 0) + 1);
+                continue;
+              }
               documento.agregarNota(
                 normalizarNota({
                   figuraId: idFigura,
@@ -89025,7 +89225,7 @@ function importarScore(score, opciones = {}, datos = {}) {
                   //   `percussionArticulation`, que es lo que `proyectar` le pone. Así la ida y la
                   //   vuelta son simétricas: lo que se exporta se vuelve a importar idéntico.
                   altura: tipo === "altura" ? nota.calculateRealValue(false, false) : null,
-                  articulacion: tipo === "percusion" ? nota.percussionArticulation : null,
+                  articulacion: tipo === "percusion" ? articulacionDe(nota) : null,
                   ligadaAAnterior: nota.isTieDestination,
                   muerta: nota.isDead,
                   fantasma: nota.isGhost,
@@ -89042,6 +89242,8 @@ function importarScore(score, opciones = {}, datos = {}) {
                   deslizamientoEntrada: nota.slideInType,
                   deslizamientoSalida: nota.slideOutType,
                   armonico: nota.harmonicType,
+                  // El natural se recalcula del traste al proyectar: se guarda sólo si es otro.
+                  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,
@@ -89077,6 +89279,12 @@ function importarScore(score, opciones = {}, datos = {}) {
           }
         }
       }
+      if (sinPieza.size > 0) {
+        const total = [...sinPieza.values()].reduce((a, b) => a + b, 0);
+        avisos.push(
+          `La bater\xEDa "${pista.name}" trae ${total} golpe(s) de piezas que el kit todav\xEDa no tiene (n\xFAmeros ${[...sinPieza.keys()].join(", ")}): no se importaron, para no cambiarlas por otra pieza.`
+        );
+      }
     }
   }
   if (letrasDobles.cuantas > 0) {
@@ -89084,6 +89292,11 @@ function importarScore(score, opciones = {}, datos = {}) {
       `${letrasDobles.cuantas} golpe(s) tra\xEDan letra Y un texto libre: se guard\xF3 la letra. Tabs lleva un solo texto por golpe.`
     );
   }
+  if (letrasDobles.versosDeMas > 0) {
+    avisos.push(
+      `${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 audioEmbebido = importarAudioYSync(score, documento, idsDeCompasMaestro, avisos);
   return { documento, avisos, ...audioEmbebido ? { audioEmbebido } : {} };
 }
@@ -89128,11 +89341,43 @@ function importarAudioYSync(score, documento, idsDeCompasMaestro, avisos) {
   }
   return { fuenteId, bytes };
 }
+function saltosDelTexto(score) {
+  const precisos = /* @__PURE__ */ new Map();
+  const textos = /* @__PURE__ */ new Set();
+  for (const pista of score.tracks)
+    for (const pentagrama of pista.staves)
+      for (const barra of pentagrama.bars) {
+        const maestro = score.masterBars[barra.index];
+        if (!maestro?.directions) continue;
+        for (const voz of barra.voices)
+          for (const golpe of voz.beats) {
+            const regla = golpe.text ? SALTO_POR_TEXTO[claveDeSalto(golpe.text)] : void 0;
+            if (!regla) continue;
+            const actuales = precisos.get(maestro.index) ?? new Set(maestro.directions);
+            if (!actuales.has(regla[0]) && !actuales.has(regla[1])) continue;
+            actuales.delete(regla[0]);
+            actuales.add(regla[1]);
+            precisos.set(maestro.index, actuales);
+            textos.add(golpe);
+          }
+      }
+  return { precisos, textos };
+}
+function tonalidadDeConcierto(score, indice) {
+  const pentagramas = score.tracks.flatMap((t) => t.staves).filter((s) => !s.isPercussion);
+  const llano = pentagramas.find((s) => !s.displayTranspositionPitch && s.bars[indice]);
+  if (llano) return llano.bars[indice].keySignature;
+  const primero = pentagramas.find((s) => s.bars[indice]);
+  if (!primero) return score.masterBars[indice]?.keySignature ?? 0;
+  return armaduraDeConcierto(primero.bars[indice].keySignature, primero.displayTranspositionPitch);
+}
 function numeroDeTonalidad(armadura) {
   return armadura;
 }
 function textoDelGolpe(golpe, letrasDobles) {
-  const letra = (golpe.lyrics ?? []).find((l) => l && l.trim()) ?? "";
+  const versos = golpe.lyrics ?? [];
+  const letra = versos[0]?.trim() ? versos[0] : "";
+  if (versos.slice(1).some((v) => v && v.trim())) letrasDobles.versosDeMas++;
   const libre = golpe.text ?? "";
   if (letra && libre && letra !== libre) letrasDobles.cuantas++;
   return letra || libre;
@@ -89170,24 +89415,107 @@ function ortografiaDe(ortografia, parte, pentagrama, compas, tic, nota) {
   const base = `${parte}|${pentagrama}|${compas}|${tic}|`;
   return ortografia.get(base + nota.calculateRealValue(false, false)) ?? ortografia.get(base + (nota.octave * 12 + nota.tone));
 }
+var SALIDA_DE_ID_GP, PARIENTE_GM, DIR, SALTO_POR_TEXTO, claveDeSalto;
 var init_importarGp = __esm({
   "packages/io/src/importarGp.ts"() {
     init_alphaTab();
     init_src2();
+    init_src2();
     init_musicxmlEntrada();
+    SALIDA_DE_ID_GP = {
+      31: 40,
+      83: 53,
+      84: 53,
+      91: 38,
+      92: 46,
+      93: 51,
+      94: 51,
+      95: 55,
+      96: 52,
+      97: 49,
+      98: 57,
+      99: 56,
+      100: 56,
+      101: 56,
+      102: 56,
+      103: 56,
+      104: 60,
+      105: 60,
+      106: 61,
+      107: 61,
+      108: 64,
+      109: 64,
+      110: 63,
+      111: 54,
+      112: 54,
+      113: 54,
+      114: 43,
+      115: 49,
+      116: 49,
+      117: 69,
+      118: 70,
+      119: 70,
+      120: 70,
+      122: 82,
+      123: 53,
+      124: 62,
+      125: 62,
+      126: 59,
+      127: 59
+    };
+    PARIENTE_GM = {
+      35: 36,
+      // bombo acústico → bombo
+      40: 38,
+      // caja eléctrica → caja
+      43: 41,
+      // tom de piso agudo → tom de piso
+      47: 45,
+      // tom medio grave → tom medio
+      50: 48,
+      // tom muy agudo → tom agudo
+      57: 49,
+      // crash 2 → crash
+      59: 51
+      // ride 2 → ride
+    };
+    DIR = _barrel_exports$4.Direction;
+    SALTO_POR_TEXTO = {
+      dsalcoda: [DIR.JumpDalSegno, DIR.JumpDalSegnoAlCoda],
+      dsalcoda2: [DIR.JumpDalSegno, DIR.JumpDalSegnoAlDoubleCoda],
+      dsalfine: [DIR.JumpDalSegno, DIR.JumpDalSegnoAlFine],
+      dssalcoda: [DIR.JumpDalSegno, DIR.JumpDalSegnoSegnoAlCoda],
+      dssalfine: [DIR.JumpDalSegno, DIR.JumpDalSegnoSegnoAlFine],
+      dss: [DIR.JumpDalSegno, DIR.JumpDalSegnoSegno],
+      dcalcoda: [DIR.JumpDaCapo, DIR.JumpDaCapoAlCoda],
+      dcalcoda2: [DIR.JumpDaCapo, DIR.JumpDaCapoAlDoubleCoda],
+      dcalfine: [DIR.JumpDaCapo, DIR.JumpDaCapoAlFine],
+      ds: [DIR.JumpDalSegno, DIR.JumpDalSegno],
+      dc: [DIR.JumpDaCapo, DIR.JumpDaCapo],
+      tocoda: [DIR.JumpDaCoda, DIR.JumpDaCoda],
+      tocoda2: [DIR.JumpDaCoda, DIR.JumpDaDoubleCoda],
+      fine: [DIR.TargetFine, DIR.TargetFine]
+    };
+    claveDeSalto = (texto4) => texto4.toLowerCase().replace(/dals*segno/g, "ds").replace(/das*capo/g, "dc").replace(/[^a-z0-9]/g, "");
   }
 });
 
 // packages/io/src/archivoMtabs.ts
 function formatoQueNecesita(documento) {
   for (const pista of documento.pistas.values()) {
-    const pentagramas = pista.get("pentagramas");
-    if (typeof pentagramas === "number" && pentagramas > 1) return 5;
     const transposicion = pista.get("transposicion");
-    if (typeof transposicion === "number" && transposicion !== 0) return 5;
+    if (typeof transposicion === "number" && transposicion !== 0) return 6;
+  }
+  for (const nota of documento.notas.values()) {
+    const v = nota.get("armonicoValor");
+    if (typeof v === "number" && v !== 0) return 6;
   }
   for (const figura of documento.figuras.values()) {
-    if (figura.get("octava") !== void 0 || figura.get("tempo") !== void 0) return 5;
+    if (figura.get("octava") !== void 0 || figura.get("tempo") !== void 0) return 6;
+  }
+  for (const pista of documento.pistas.values()) {
+    const pentagramas = pista.get("pentagramas");
+    if (typeof pentagramas === "number" && pentagramas > 1) return 5;
   }
   return 4;
 }
@@ -89234,6 +89562,9 @@ function desempaquetar(bytes) {
   } catch {
     throw new ArchivoIlegible("El manifiesto del archivo est\xE1 da\xF1ado.");
   }
+  if (!manifiesto || typeof manifiesto !== "object") {
+    throw new ArchivoIlegible("El manifiesto del archivo est\xE1 da\xF1ado.");
+  }
   if (!Number.isFinite(manifiesto.formato) || manifiesto.formato > VERSION_DEL_FORMATO) {
     throw new ArchivoIlegible(
       `Este archivo se guard\xF3 con una versi\xF3n m\xE1s nueva de Mandioca Tabs (formato ${manifiesto.formato}; esta versi\xF3n entiende hasta el ${VERSION_DEL_FORMATO}). Abrirlo igual podr\xEDa borrarte lo que esa versi\xF3n guard\xF3.`
@@ -89267,7 +89598,7 @@ var init_archivoMtabs = __esm({
   "packages/io/src/archivoMtabs.ts"() {
     init_esm();
     init_src2();
-    VERSION_DEL_FORMATO = 5;
+    VERSION_DEL_FORMATO = 6;
     MANIFIESTO = "mandioca.json";
     DOCUMENTO = "documento.ydoc";
     CARPETA_DE_AUDIO = "audio/";
@@ -89338,7 +89669,7 @@ function gruposDeTresillo(beats) {
       continue;
     }
     let j = i2;
-    while (j + 1 < beats.length && beats[j + 1].tupletNumerator === b.tupletNumerator && beats[j + 1].tupletDenominator === b.tupletDenominator)
+    while (j + 1 < beats.length && beats[j + 1].tupletNumerator === b.tupletNumerator && beats[j + 1].tupletDenominator === b.tupletDenominator && (b.tupletGroup === null || beats[j + 1].tupletGroup === b.tupletGroup))
       j++;
     abren.add(i2);
     cierran.add(j);
@@ -89346,6 +89677,16 @@ function gruposDeTresillo(beats) {
   }
   return { abren, cierran };
 }
+function saltosDelCompas(master) {
+  const s = [];
+  for (const [direccion, salto] of SALTOS) {
+    if (!master?.directions?.has(direccion)) continue;
+    s.push('<direction placement="above">', "<direction-type>");
+    s.push(salto.simbolo ? `<${salto.simbolo}/>` : `<words>${escapar(salto.texto ?? "")}</words>`);
+    s.push("</direction-type>", `<sound ${salto.sonido}/>`, "</direction>");
+  }
+  return s;
+}
 function nombreDeFigura(duracion) {
   return NOMBRE_DE_LA_FIGURA2.get(duracion) ?? "quarter";
 }
@@ -89370,6 +89711,8 @@ function posicionDePercusion(staffLine) {
 }
 function escribirNota(note, beat, staff, opciones) {
   const s = ["<note>"];
+  const esAdorno = beat.graceType !== _barrel_exports$4.GraceType.None;
+  if (esAdorno) s.push(beat.graceType === _barrel_exports$4.GraceType.BeforeBeat ? "<grace/>" : '<grace slash="yes"/>');
   if (opciones.esAcorde) s.push("<chord/>");
   const esGolpeDeKit = staff.isPercussion && note.percussionArticulation >= 0;
   if (esGolpeDeKit) {
@@ -89391,7 +89734,7 @@ function escribirNota(note, beat, staff, opciones) {
     s.push(`<octave>${octava}</octave>`);
     s.push("</pitch>");
   }
-  s.push(`<duration>${opciones.duracion}</duration>`);
+  if (!esAdorno) s.push(`<duration>${opciones.duracion}</duration>`);
   if (note.isTieDestination) s.push('<tie type="stop"/>');
   if (note.isTieOrigin) s.push('<tie type="start"/>');
   const idDeInstrumento = opciones.instrumentos.get(note.percussionArticulation);
@@ -89422,8 +89765,17 @@ function escribirNota(note, beat, staff, opciones) {
     tecnica.push(`<string>${staff.tuning.length - note.string + 1}</string>`);
     tecnica.push(`<fret>${note.fret}</fret>`);
   }
-  if (note.isHammerPullOrigin) tecnica.push('<hammer-on type="start">H</hammer-on>');
-  if (note.hammerPullOrigin !== null) tecnica.push('<pull-off type="stop">P</pull-off>');
+  const ligado = (desde, hasta) => hasta >= desde ? "hammer-on" : "pull-off";
+  const origen = note.hammerPullOrigin;
+  if (origen !== null) {
+    const nombre = ligado(origen.fret, note.fret);
+    tecnica.push(`<${nombre} type="stop"/>`);
+  }
+  const destino = note.hammerPullDestination;
+  if (note.isHammerPullOrigin && destino) {
+    const nombre = ligado(note.fret, destino.fret);
+    tecnica.push(`<${nombre} type="start">${nombre === "hammer-on" ? "H" : "P"}</${nombre}>`);
+  }
   if (note.harmonicType !== _barrel_exports$4.HarmonicType.None) tecnica.push("<harmonic/>");
   if (beat.isPalmMute) tecnica.push("<other-technical>palm-mute</other-technical>");
   if (beat.isLetRing) tecnica.push("<other-technical>let-ring</other-technical>");
@@ -89447,9 +89799,14 @@ function letraDelGolpe(beat) {
   const s = [];
   beat.lyrics.forEach((verso, i2) => {
     if (!verso) return;
+    const sigue = verso.endsWith("-") && verso.length > 1;
+    let anterior = beat.previousBeat;
+    while (anterior && !anterior.lyrics?.[i2]) anterior = anterior.previousBeat;
+    const viene = !!anterior?.lyrics?.[i2]?.endsWith("-");
+    const silabico = sigue ? viene ? "middle" : "begin" : viene ? "end" : "single";
     s.push(`<lyric number="${i2 + 1}">`);
-    s.push("<syllabic>single</syllabic>");
-    s.push(...elemento("text", verso));
+    s.push(`<syllabic>${silabico}</syllabic>`);
+    s.push(...elemento("text", sigue ? verso.slice(0, -1) : verso));
     s.push("</lyric>");
   });
   return s;
@@ -89535,7 +89892,7 @@ function exportarMusicXml(score) {
     for (let indiceDeCompas2 = 0; indiceDeCompas2 < cantidadDeCompases; indiceDeCompas2++) {
       const master = score.masterBars[indiceDeCompas2];
       l.push(`<measure number="${indiceDeCompas2 + 1}">`);
-      const fifths = master?.keySignature ?? 0;
+      const fifths = (pentagramas[0]?.bars[indiceDeCompas2] ?? pentagramas[0]?.bars[0])?.keySignature ?? master?.keySignature ?? 0;
       const modo = master?.keySignatureType === _barrel_exports$4.KeySignatureType.Minor ? "minor" : "major";
       const armadura = `${fifths}/${modo}`;
       const numerador = master?.timeSignatureNumerator ?? 4;
@@ -89590,10 +89947,15 @@ function exportarMusicXml(score) {
         clavesAnteriores = firmaDeClaves;
       }
       if (cambios.length > 0) l.push("<attributes>", ...cambios, "</attributes>");
-      if (master?.isRepeatStart) {
+      const casilla = master?.alternateEndings ?? 0;
+      const casillaAntes = score.masterBars[indiceDeCompas2 - 1]?.alternateEndings ?? 0;
+      const casillaDespues = score.masterBars[indiceDeCompas2 + 1]?.alternateEndings ?? 0;
+      const numerosDeCasilla = [0, 1, 2, 3, 4, 5, 6, 7].filter((b) => casilla & 1 << b).map((b) => b + 1).join(", ");
+      if (master?.isRepeatStart || casilla && casilla !== casillaAntes) {
         l.push('<barline location="left">');
-        l.push("<bar-style>heavy-light</bar-style>");
-        l.push('<repeat direction="forward"/>');
+        if (master?.isRepeatStart) l.push("<bar-style>heavy-light</bar-style>");
+        if (casilla && casilla !== casillaAntes) l.push(`<ending number="${numerosDeCasilla}" type="start"/>`);
+        if (master?.isRepeatStart) l.push('<repeat direction="forward"/>');
         l.push("</barline>");
       }
       if (master?.section?.text || master?.section?.marker)
@@ -89604,8 +89966,14 @@ function exportarMusicXml(score) {
           "</direction-type>",
           "</direction>"
         );
-      if (indiceDeCompas2 === 0 && score.tempo) {
-        const bpm = Math.round(score.tempo);
+      l.push(...saltosDelCompas(master));
+      const ticsDelCompas = DIVISIONES_POR_NEGRA * 4 * numerador / denominador;
+      const tempos = (master?.tempoAutomations ?? []).map((a) => ({ bpm: a.value, desde: a.ratioPosition }));
+      if (indiceDeCompas2 === 0 && score.tempo && !tempos.some((t) => t.desde <= 1e-6))
+        tempos.unshift({ bpm: score.tempo, desde: 0 });
+      for (const t of tempos) {
+        const bpm = Math.round(t.bpm);
+        const offset = Math.round(t.desde * ticsDelCompas);
         l.push(
           '<direction placement="above">',
           "<direction-type>",
@@ -89614,6 +89982,7 @@ function exportarMusicXml(score) {
           `<per-minute>${bpm}</per-minute>`,
           "</metronome>",
           "</direction-type>",
+          ...offset > 0 ? [`<offset>${offset}</offset>`] : [],
           `<sound tempo="${bpm}"/>`,
           "</direction>"
         );
@@ -89632,7 +90001,7 @@ function exportarMusicXml(score) {
           let avance = 0;
           voice.beats.forEach((beat, i2) => {
             const duracion = beat.displayDuration;
-            avance += duracion;
+            if (beat.graceType === _barrel_exports$4.GraceType.None) avance += duracion;
             if (beat.isRest || beat.notes.length === 0) {
               l.push(...escribirSilencio2(beat, duracion, indiceDeVoz + 1, numeroDePentagrama));
               return;
@@ -89658,10 +90027,14 @@ function exportarMusicXml(score) {
           hayAlgoEscrito = true;
         });
       }
-      if (master?.isRepeatEnd || master?.isDoubleBar) {
+      const cierraCasilla = casilla !== 0 && casilla !== casillaDespues;
+      if (master?.isRepeatEnd || master?.isDoubleBar || cierraCasilla) {
         l.push('<barline location="right">');
-        l.push(`<bar-style>${master.isRepeatEnd ? "light-heavy" : "light-light"}</bar-style>`);
-        if (master.isRepeatEnd)
+        if (master?.isRepeatEnd || master?.isDoubleBar)
+          l.push(`<bar-style>${master.isRepeatEnd ? "light-heavy" : "light-light"}</bar-style>`);
+        if (cierraCasilla)
+          l.push(`<ending number="${numerosDeCasilla}" type="${master?.isRepeatEnd ? "stop" : "discontinue"}"/>`);
+        if (master?.isRepeatEnd)
           l.push(`<repeat direction="backward" times="${Math.max(2, master.repeatCount)}"/>`);
         l.push("</barline>");
       }
@@ -89706,7 +90079,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;
+var DIVISIONES_POR_NEGRA, FECHA_FIJA_DEL_ZIP, PASOS, NOMBRE_DE_LA_FIGURA2, ALTERACION_POR_MODO, D, SALTOS;
 var init_musicxml = __esm({
   "packages/io/src/musicxml.ts"() {
     init_alphaTab();
@@ -89736,6 +90109,28 @@ var init_musicxml = __esm({
       [256, "256th"]
     ]);
     ALTERACION_POR_MODO = { 2: 0, 3: 1, 4: 2, 5: -1, 6: -2 };
+    D = _barrel_exports$4.Direction;
+    SALTOS = [
+      [D.TargetSegno, { simbolo: "segno", sonido: 'segno="segno"' }],
+      [D.TargetSegnoSegno, { simbolo: "segno", sonido: 'segno="segno2"' }],
+      [D.TargetCoda, { simbolo: "coda", sonido: 'coda="coda"' }],
+      [D.TargetDoubleCoda, { simbolo: "coda", sonido: 'coda="coda2"' }],
+      [D.TargetFine, { texto: "Fine", sonido: 'fine="yes"' }],
+      [D.JumpDaCapo, { texto: "D.C.", sonido: 'dacapo="yes"' }],
+      [D.JumpDaCapoAlCoda, { texto: "D.C. al Coda", sonido: 'dacapo="yes"' }],
+      [D.JumpDaCapoAlDoubleCoda, { texto: "D.C. al Coda 2", sonido: 'dacapo="yes"' }],
+      [D.JumpDaCapoAlFine, { texto: "D.C. al Fine", sonido: 'dacapo="yes"' }],
+      [D.JumpDalSegno, { texto: "D.S.", sonido: 'dalsegno="segno"' }],
+      [D.JumpDalSegnoAlCoda, { texto: "D.S. al Coda", sonido: 'dalsegno="segno"' }],
+      [D.JumpDalSegnoAlDoubleCoda, { texto: "D.S. al Coda 2", sonido: 'dalsegno="segno"' }],
+      [D.JumpDalSegnoAlFine, { texto: "D.S. al Fine", sonido: 'dalsegno="segno"' }],
+      [D.JumpDalSegnoSegno, { texto: "D.S.S.", sonido: 'dalsegno="segno2"' }],
+      [D.JumpDalSegnoSegnoAlCoda, { texto: "D.S.S. al Coda", sonido: 'dalsegno="segno2"' }],
+      [D.JumpDalSegnoSegnoAlDoubleCoda, { texto: "D.S.S. al Coda 2", sonido: 'dalsegno="segno2"' }],
+      [D.JumpDalSegnoSegnoAlFine, { texto: "D.S.S. al Fine", sonido: 'dalsegno="segno2"' }],
+      [D.JumpDaCoda, { texto: "To Coda", sonido: 'tocoda="coda"' }],
+      [D.JumpDaDoubleCoda, { texto: "To Coda 2", sonido: 'tocoda="coda2"' }]
+    ];
   }
 });
 
@@ -89849,7 +90244,7 @@ var init_src4 = __esm({
 });
 
 // apps/mcp/src/obra.ts
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile, rename, writeFile } from "node:fs/promises";
 import { extname, basename } from "node:path";
 function reconciliarGrabaciones(obra) {
   const fichas = new Set(obra.documento.fuentesDeAudioEnOrden().map((f) => f.id));
@@ -89992,7 +90387,9 @@ async function guardar(rutaPedida) {
     fuentes: obra.fuentes,
     guardado: (/* @__PURE__ */ new Date()).toISOString()
   });
-  await writeFile(ruta, paquete);
+  const parcial = `${ruta}.guardando`;
+  await writeFile(parcial, paquete);
+  await rename(parcial, ruta);
   const fichas = new Set(obra.documento.fuentesDeAudioEnOrden().map((f) => f.id));
   const conBytes = new Set(obra.grabaciones.map((g) => g.fuenteId));
   const mudas = [...fichas].filter((id2) => !conBytes.has(id2)).length;
@@ -90072,7 +90469,7 @@ var VERSION_DEL_CONECTOR;
 var init_version = __esm({
   "apps/mcp/src/version.ts"() {
     "use strict";
-    VERSION_DEL_CONECTOR = true ? "0.2.14" : null;
+    VERSION_DEL_CONECTOR = true ? "0.2.15" : null;
   }
 });
 
@@ -90424,7 +90821,13 @@ function abrirDeVerdad(puerto) {
       );
     });
     servidor2.on("connection", (conexion, peticion) => {
-      const pedida = decodeURIComponent((peticion.url ?? "").replace(/^\/+/, "").split("?")[0] ?? "");
+      let pedida;
+      try {
+        pedida = decodeURIComponent((peticion.url ?? "").replace(/^\/+/, "").split("?")[0] ?? "");
+      } catch {
+        conexion.close(1008, "sala mal escrita");
+        return;
+      }
       const sala = salaValida(pedida) ? pedida : SALA_DE_LA_OBRA;
       const doc = docDeLaSala(sala);
       if (esDeObra(sala) && deLaSala(sala).length > 0) {
@@ -90574,7 +90977,7 @@ async function pedirALaPesta\u00F1a(herramienta, argumentos = {}, msDelAcuse = E
   const p = exigirPesta\u00F1a();
   const canal = await canalDePedidos(p, herramienta);
   const mapa = canal.getMap("pedidos");
-  const id2 = `p${siguienteId += 1}`;
+  const id2 = `p${INSTANCIA}-${siguienteId += 1}`;
   try {
     return await new Promise((resolver, rechazar) => {
       let acusado = false;
@@ -90632,7 +91035,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, puente, reclamado, ESPERA_POR_LA_PESTA\u00D1A, mostrador, casillero, TIPOS, abriendo, siguienteId, ESPERA_DEL_ACUSE_MS, LATIDO_MS, LATIDO_DEL_PUENTE_MS, AUSENCIA_PARA_DARLA_POR_IDA_MS, MARGEN_PARA_QUE_ENTRE_MS;
+var envoltoriosPorDoc, SINCRONIZAR, PRESENCIA, SALA_DE_LA_OBRA, SALA_DE_PEDIDOS, PUERTO_POR_OMISION, ORIGENES_DE_TABS, 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, MARGEN_PARA_QUE_ENTRE_MS;
 var init_puente = __esm({
   "apps/mcp/src/puente.ts"() {
     "use strict";
@@ -90666,6 +91069,7 @@ var init_puente = __esm({
     );
     abriendo = null;
     siguienteId = 0;
+    INSTANCIA = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
     ESPERA_DEL_ACUSE_MS = Number(process.env["MANDIOCA_TABS_ACUSE_MS"] ?? 5e3);
     LATIDO_MS = 250;
     LATIDO_DEL_PUENTE_MS = 1e4;
@@ -97994,6 +98398,48 @@ var init_estilo = __esm({
 });
 
 // packages/projection/src/proyectar.ts
+function silenciosQueLlenan(tics) {
+  const valores = [];
+  let quedan = tics;
+  for (const valor of [1, 2, 4, 8, 16, 32, 64]) {
+    const dura = 3840 / valor;
+    while (quedan >= dura) {
+      valores.push(valor);
+      quedan -= dura;
+    }
+  }
+  return valores;
+}
+function valorDeArmonicoNatural(traste) {
+  switch (traste) {
+    case 2:
+      return 2.4;
+    case 3:
+      return 3.2;
+    case 4:
+    case 5:
+    case 7:
+    case 9:
+    case 12:
+    case 16:
+    case 17:
+    case 19:
+    case 24:
+      return traste;
+    case 8:
+      return 8.2;
+    case 10:
+      return 9.6;
+    case 14:
+    case 15:
+      return 14.7;
+    case 21:
+    case 22:
+      return 21.7;
+    default:
+      return 12;
+  }
+}
 function canalesDeLasPistas(tipos) {
   const libres = Array.from({ length: 16 }, (_, i2) => i2).filter((c) => c !== 9);
   const conAltura = tipos.filter((t) => t !== "percusion").length;
@@ -98147,20 +98593,24 @@ function proyectar(documento, opciones = {}) {
           cantidadDeVoces = Math.max(cantidadDeVoces, datos2.voz + 1);
         }
       }
+      const deLaPista = [...compasesPorPista.entries()].filter(([clave]) => clave.startsWith(`${idPista}|`)).map(([, mapa]) => mapa);
       const acordesEscritos = [];
       maestros.forEach((m, indiceDeCompas2) => {
-        const id2 = porMaestro.get(m.id);
-        for (const { datos: f } of id2 ? figurasPorCompas.get(id2) ?? [] : []) {
-          if (f.acorde) {
-            acordesEscritos.push({ compas: indiceDeCompas2, tiempo: f.tiempo, nombre: f.acorde });
+        for (const mapa of deLaPista) {
+          const id2 = mapa.get(m.id);
+          for (const { datos: f } of id2 ? figurasPorCompas.get(id2) ?? [] : []) {
+            if (f.acorde) {
+              acordesEscritos.push({ compas: indiceDeCompas2, tiempo: f.tiempo, nombre: f.acorde });
+            }
           }
         }
       });
+      acordesEscritos.sort((a, b) => a.compas - b.compas || a.tiempo - b.tiempo);
       const acordeVigente = buscadorDeAcorde(acordesEscritos);
       maestros.forEach((maestro, indiceDeCompas2) => {
         const barra = new _barrel_exports$4.Bar();
         pentagrama.addBar(barra);
-        barra.keySignature = maestro.datos.tonalidad;
+        barra.keySignature = armaduraEscrita(maestro.datos.tonalidad, pista.transposicion ?? 0);
         barra.simileMark = maestro.datos.repiteAnterior;
         const idCompas = porMaestro.get(maestro.id);
         const figuras = idCompas ? figurasPorCompas.get(idCompas) ?? [] : [];
@@ -98170,8 +98620,8 @@ function proyectar(documento, opciones = {}) {
           barra.clefOttava = datosDelCompas.claveOctava;
         }
         const ticsDelCompas = 960 * 4 * maestro.datos.numerador / maestro.datos.denominador;
-        for (const { datos: figura } of figuras) {
-          if (!figura.pedal) continue;
+        const conPedal = figuras.map((f) => f.datos).filter((f) => f.pedal).sort((a, b) => a.tiempo - b.tiempo).filter((f, k, todas) => k === 0 || todas[k - 1].tiempo !== f.tiempo);
+        for (const figura of conPedal) {
           const marcador = new _barrel_exports$4.SustainPedalMarker();
           marcador.ratioPosition = ticsDelCompas > 0 ? figura.tiempo / ticsDelCompas : 0;
           marcador.pedalType = figura.pedal - 1;
@@ -98181,7 +98631,17 @@ function proyectar(documento, opciones = {}) {
           const voz = new _barrel_exports$4.Voice();
           barra.addVoice(voz);
           const deEstaVoz = figuras.filter((f) => f.datos.voz === indiceDeVoz).sort((a, b) => a.datos.tiempo - b.datos.tiempo);
+          let posicion = 0;
           for (const { id: idFigura, datos: figura } of deEstaVoz) {
+            if (!figura.adorno && figura.tiempo - posicion >= 30) {
+              for (const valor of silenciosQueLlenan(figura.tiempo - Math.round(posicion))) {
+                const silencio = new _barrel_exports$4.Beat();
+                silencio.duration = valor;
+                voz.addBeat(silencio);
+              }
+              posicion = figura.tiempo;
+            }
+            posicion += figura.adorno ? 0 : ticsExactosDeFigura(figura);
             const golpe = new _barrel_exports$4.Beat();
             golpe.duration = figura.valor;
             golpe.dots = figura.puntillos;
@@ -98270,6 +98730,8 @@ function proyectar(documento, opciones = {}) {
               notaAlphaTab.slideInType = nota.deslizamientoEntrada;
               notaAlphaTab.slideOutType = nota.deslizamientoSalida;
               notaAlphaTab.harmonicType = nota.armonico;
+              if (nota.armonico)
+                notaAlphaTab.harmonicValue = nota.armonicoValor || (nota.armonico === _barrel_exports$4.HarmonicType.Natural ? valorDeArmonicoNatural(nota.traste) : 12);
               notaAlphaTab.vibrato = nota.anchoDeVibrato;
               notaAlphaTab.accentuated = nota.acento;
               notaAlphaTab.isLeftHandTapped = nota.tappingIzquierda;
@@ -122593,7 +123055,16 @@ function duracionDesde(figura, puntillos) {
   return { valor: figura, puntillos: puntillos ?? 0 };
 }
 function ticsDelGolpe(indice, pistaId, compas, voz, golpe, tics, pentagrama = 0) {
-  if (tics !== void 0) return tics;
+  if (tics !== void 0) {
+    const maestro = indice.compasMaestro(compas);
+    const largo = maestro ? 3840 * maestro.datos.numerador / maestro.datos.denominador : 3840;
+    if (!Number.isInteger(tics) || tics < 0 || tics >= largo) {
+      throw new ProblemaConLaObra(
+        `${tics} tics queda fuera del comp\xE1s ${compas + 1}, que mide ${largo} (de 0 a ${largo - 1}; 960 por negra).`
+      );
+    }
+    return tics;
+  }
   if (golpe === void 0) return 0;
   const compasId = indice.compasId(pistaId, compas, pentagrama);
   const figuras = indice.figuras(compasId, voz);
@@ -122642,7 +123113,7 @@ function segundaParaLeer(texto4, marcas) {
 // apps/mcp/src/herramientas/documento.ts
 var unaNota = {
   compas: external_exports.number().int().min(1).max(9999),
-  cuerda: external_exports.number().int().min(1).max(24, { error: (i2) => `\xAB${i2.input}\xBB no es una cuerda: van de 1 (la m\xE1s grave) a 24.` }).optional().describe("La cuerda, numerada desde la M\xC1S GRAVE empezando en 1. En una guitarra est\xE1ndar, 1 es el mi grave y 6 el mi agudo. Solo en pistas de tablatura."),
+  cuerda: external_exports.number().int().min(1).max(24, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB no es una cuerda: van de 1 (la m\xE1s grave) a 24.` }).optional().describe("La cuerda, numerada desde la M\xC1S GRAVE empezando en 1. En una guitarra est\xE1ndar, 1 es el mi grave y 6 el mi agudo. Solo en pistas de tablatura."),
   altura: external_exports.number().int().min(0).max(127).optional().describe("La altura en n\xFAmero MIDI: 60 es el Do central. Solo en pistas de altura (piano, vientos, cuerdas frotadas, voz)."),
   pieza: external_exports.string().optional().describe("La pieza del kit: \xABBombo\xBB, \xABCaja\xBB, \xABCharles cerrado\xBB\u2026 Solo en pistas de percusi\xF3n. La lista entera la da `piezas_de_bateria`."),
   golpe: external_exports.number().int().min(1).max(999).optional(),
@@ -122917,7 +123388,7 @@ function registrarHerramientasDelDocumento(servidor2) {
       title: "Leer un pasaje",
       description: "La m\xFAsica de un rango de compases: cada golpe con su duraci\xF3n, y cada nota con su cuerda, su traste, su altura MIDI y sus efectos.",
       inputSchema: {
-        desde: external_exports.number().int().min(1).max(9999, { error: (i2) => `\xAB${i2.input}\xBB se pasa: va de 1 a 9999.` }).describe("Primer comp\xE1s, como lo lee el m\xFAsico."),
+        desde: external_exports.number().int().min(1).max(9999, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se pasa: va de 1 a 9999.` }).describe("Primer comp\xE1s, como lo lee el m\xFAsico."),
         hasta: external_exports.number().int().min(1).max(9999).optional().describe("\xDAltimo comp\xE1s, incluido. Por omisi\xF3n, el mismo que `desde`."),
         pista: external_exports.number().int().min(1).max(999).optional().describe("Cu\xE1l pista. Por omisi\xF3n, todas.")
       }
@@ -122974,7 +123445,7 @@ function registrarHerramientasDelDocumento(servidor2) {
       description: "Escribe notas en el golpe que se le diga. **C\xF3mo se nombra cada nota depende del tipo de la pista**: en una de tablatura (guitarra, bajo) se dan `cuerda` y `traste`; en una de altura (piano, vientos, voz) se da `altura`, el n\xFAmero MIDI. Varias notas en el mismo comp\xE1s y el mismo golpe forman un acorde. Es exactamente lo que hace el m\xFAsico en el pliego: usa el mismo comando del editor, as\xED que respeta el retejido de la voz y entra en el deshacer.",
       inputSchema: {
         pista: external_exports.number().int().min(1).max(999).optional(),
-        figura: external_exports.number().int().min(1).max(64, { error: (i2) => `\xAB${i2.input}\xBB no es una figura: 1 redonda, 2 blanca, 4 negra, 8 corchea, 16, 32, 64.` }).optional().describe("La duraci\xF3n: 1 redonda, 2 blanca, 4 negra, 8 corchea, 16 semicorchea, 32, 64. Por omisi\xF3n, negra."),
+        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("La duraci\xF3n: 1 redonda, 2 blanca, 4 negra, 8 corchea, 16 semicorchea, 32, 64. Por omisi\xF3n, negra."),
         puntillos: external_exports.number().int().min(0).max(2).optional(),
         notas: external_exports.array(external_exports.object({ ...unaNota, traste: external_exports.number().int().min(0).max(24).optional().describe("El traste. 0 es la cuerda al aire. Solo en pistas de tablatura.") })).min(1).describe("Las notas a escribir, en orden.")
       }
@@ -122984,62 +123455,69 @@ function registrarHerramientasDelDocumento(servidor2) {
       empezarUnPaso();
       const duracion = duracionDesde(figura, puntillos);
       const escritas = [];
-      for (const nota of notas) {
-        const indice = indexar(documento);
-        const volcado = volcar(documento);
-        const laPista = pistaDelMusico(pista ?? 1, volcado, documento);
-        const pistaId = laPista.id;
-        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 = comoSeEscribeLaNota(laPista.tipo, laPista.nombre, pista ?? 1, nota);
-        if (nombrada.clase === "altura") {
-          const resultado2 = escribirAltura(
-            documento,
-            indice,
-            cursorEn(indice, pistaId, compas, voz, tiempo, 1, pentagrama),
-            nombrada.altura,
-            duracion ? { duracion } : {}
-          );
-          if (!resultado2) {
-            throw new ProblemaConLaObra(
-              `No se pudo escribir la altura ${nombrada.altura} en el comp\xE1s ${nota.compas} de la pista ${pista ?? 1} \xAB${laPista.nombre}\xBB.`
+      const laPista = pistaDelMusico(pista ?? 1, volcar(documento), documento);
+      const pistaId = laPista.id;
+      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 = comoSeEscribeLaNota(laPista.tipo, laPista.nombre, pista ?? 1, nota);
+          if (nombrada.clase === "altura") {
+            const resultado2 = escribirAltura(
+              documento,
+              indice,
+              cursorEn(indice, pistaId, compas, voz, tiempo, 1, pentagrama),
+              nombrada.altura,
+              duracion ? { duracion } : {}
             );
+            if (!resultado2) {
+              throw new ProblemaConLaObra(
+                `No se pudo escribir la altura ${nombrada.altura} en el comp\xE1s ${nota.compas} de la pista ${pista ?? 1} \xAB${laPista.nombre}\xBB.`
+              );
+            }
+            escritas.push(`c${nota.compas} altura ${nombrada.altura}`);
+            continue;
           }
-          escritas.push(`c${nota.compas} altura ${nombrada.altura}`);
-          continue;
-        }
-        if (nombrada.clase === "percusion") {
-          const resultado2 = escribirPercusion(
+          if (nombrada.clase === "percusion") {
+            const resultado2 = escribirPercusion(
+              documento,
+              indice,
+              cursorEn(indice, pistaId, compas, voz, tiempo, 1, pentagrama),
+              nombrada.articulacion,
+              duracion ? { duracion } : {}
+            );
+            if (!resultado2) {
+              throw new ProblemaConLaObra(
+                `No se pudo escribir \xAB${nombrada.nombre}\xBB en el comp\xE1s ${nota.compas} de la pista ${pista ?? 1} \xAB${laPista.nombre}\xBB.`
+              );
+            }
+            escritas.push(`c${nota.compas} ${nombrada.nombre}`);
+            continue;
+          }
+          const resultado = escribirTraste(
             documento,
             indice,
-            cursorEn(indice, pistaId, compas, voz, tiempo, 1, pentagrama),
-            nombrada.articulacion,
+            cursorEn(indice, pistaId, compas, voz, tiempo, nombrada.cuerda, pentagrama),
+            nombrada.cuerda,
+            nombrada.traste,
             duracion ? { duracion } : {}
           );
-          if (!resultado2) {
+          if (!resultado) {
             throw new ProblemaConLaObra(
-              `No se pudo escribir \xAB${nombrada.nombre}\xBB en el comp\xE1s ${nota.compas} de la pista ${pista ?? 1} \xAB${laPista.nombre}\xBB.`
+              `No se pudo escribir el traste ${nombrada.traste} en la cuerda ${nombrada.cuerda} del comp\xE1s ${nota.compas}. La cuerda ${nombrada.cuerda} puede no existir en esa pista.`
             );
           }
-          escritas.push(`c${nota.compas} ${nombrada.nombre}`);
-          continue;
+          escritas.push(`c${nota.compas} cuerda ${nombrada.cuerda} traste ${nombrada.traste}`);
         }
-        const resultado = escribirTraste(
-          documento,
-          indice,
-          cursorEn(indice, pistaId, compas, voz, tiempo, nombrada.cuerda, pentagrama),
-          nombrada.cuerda,
-          nombrada.traste,
-          duracion ? { duracion } : {}
+      } catch (e) {
+        if (escritas.length > 0) documento.historial().undo();
+        const motivo = e instanceof Error ? e.message : String(e);
+        throw new ProblemaConLaObra(
+          escritas.length > 0 ? `${motivo} No se escribi\xF3 ninguna nota de esta tanda: las ${escritas.length} anteriores se deshicieron.` : motivo
         );
-        if (!resultado) {
-          throw new ProblemaConLaObra(
-            `No se pudo escribir el traste ${nombrada.traste} en la cuerda ${nombrada.cuerda} del comp\xE1s ${nota.compas}. La cuerda ${nombrada.cuerda} puede no existir en esa pista.`
-          );
-        }
-        escritas.push(`c${nota.compas} cuerda ${nombrada.cuerda} traste ${nombrada.traste}`);
       }
       return texto2({ escritas: escritas.length, detalle: escritas });
     }
@@ -123058,11 +123536,10 @@ function registrarHerramientasDelDocumento(servidor2) {
       const { documento } = obraAbierta();
       empezarUnPaso();
       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 volcado = volcar(documento);
-        const laPista = pistaDelMusico(pista ?? 1, volcado, documento);
-        const pistaId = laPista.id;
         const compas = indiceDeCompas(nota.compas, indice);
         const voz = (nota.voz ?? 1) - 1;
         const pentagrama = pentagramaDelMusico(nota.pentagrama, indice, pistaId, pista ?? 1);
@@ -123323,8 +123800,8 @@ function registrarHerramientasDelPuente(servidor2) {
       title: "Cambiar c\xF3mo se ve la partitura",
       description: "Renglones, horizontal o en hoja, y ver una pista o todas. Sirve para se\xF1alarle algo al m\xFAsico en la maqueta donde se ve mejor.",
       inputSchema: {
-        vista: external_exports.enum(["renglones", "horizontal", "hoja"], { error: (i2) => `\xAB${i2.input}\xBB no es una vista: renglones, horizontal u hoja.` }).optional(),
-        pistas: external_exports.enum(["una", "todas"], { error: (i2) => `\xAB${i2.input}\xBB no dice cu\xE1ntas pistas: una o todas.` }).optional(),
+        vista: external_exports.enum(["renglones", "horizontal", "hoja"], { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB no es una vista: renglones, horizontal u hoja.` }).optional(),
+        pistas: external_exports.enum(["una", "todas"], { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB no dice cu\xE1ntas pistas: una o todas.` }).optional(),
         /**
          * ★ Los valores son EXACTAMENTE los que ofrece el menú: «los que entren» (−1) y 1, 2,
          *   3, 4, 5, 6, 8, 10, 12. No es una lista caprichosa, es la que el músico puede
@@ -123396,7 +123873,7 @@ function registrarHerramientasDelPuente(servidor2) {
         compas: external_exports.number().int().min(1).max(9999).describe("El primer comp\xE1s, contando desde 1."),
         hasta: external_exports.number().int().min(1).max(9999).optional().describe("El \xFAltimo comp\xE1s, incluido."),
         golpe: external_exports.number().int().min(1).optional().describe("Empezar en un golpe concreto del primer comp\xE1s, en vez de en su comienzo."),
-        cuerda: external_exports.number().int().min(1).max(24, { error: (i2) => `\xAB${i2.input}\xBB no es una cuerda: van de 1 (la m\xE1s grave) a 24.` }).optional().describe("La cuerda, desde la m\xE1s grave.")
+        cuerda: external_exports.number().int().min(1).max(24, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB no es una cuerda: van de 1 (la m\xE1s grave) a 24.` }).optional().describe("La cuerda, desde la m\xE1s grave.")
       }
     },
     async (args2) => texto3(await pedirALaPesta\u00F1a("seleccionar", args2))
@@ -123476,7 +123953,7 @@ function registrarHerramientasDelPuente(servidor2) {
       description: "Marca el pulso mientras suena la tablatura. \u2605 Para qu\xE9 sirve: es lo que se prende para **sincronizar a o\xEDdo** \u2014 con el click puesto se escucha enseguida si la grabaci\xF3n entra antes o despu\xE9s del comp\xE1s. \u26A0\uFE0F Suena con el sintetizador de la obra, no con el audio: existe con o sin grabaci\xF3n cargada. \u26A0\uFE0F El pulso lo marca el DENOMINADOR del comp\xE1s: en 6/8 son seis clicks, no dos. \u2605 Mientras est\xE1 puesto aparece como una fila m\xE1s del mezclador, con su volumen. Sin `puesto` ni `volumen`, alterna; con s\xF3lo `volumen`, cambia el volumen y deja el metr\xF3nomo como estaba.",
       inputSchema: {
         puesto: external_exports.boolean().optional().describe("true lo pone, false lo saca. Sin esto, alterna."),
-        volumen: external_exports.number().int().min(0).max(16, { error: (i2) => `\xAB${i2.input}\xBB se sale de la escala del volumen, que va de 0 a 16. No es un porcentaje.` }).optional().describe(
+        volumen: external_exports.number().int().min(0).max(16, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se sale de la escala del volumen, que va de 0 a 16. No es un porcentaje.` }).optional().describe(
           "El volumen del click, de 0 a 16 \u2014la misma escala que `volumen_general`\u2014. Se recuerda aunque se lo saque, y no se guarda en la obra: es de quien escucha."
         )
       }
@@ -123569,7 +124046,7 @@ function registrarHerramientasDelPuente(servidor2) {
         silenciada: external_exports.boolean().optional(),
         enSolo: external_exports.boolean().optional(),
         visible: external_exports.boolean().optional().describe("Mostrarla u ocultarla en el pliego."),
-        volumen: external_exports.number().int().min(0).max(32, { error: (i2) => `\xAB${i2.input}\xBB se sale de la escala del volumen, que va de 0 a 32 (16 = como est\xE1 escrito, 32 \u2248 +6 dB). No es un porcentaje.` }).optional().describe("De 0 a 32. 16 = como est\xE1 escrito (0 dB); 32 \u2248 +6 dB."),
+        volumen: external_exports.number().int().min(0).max(32, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se sale de la escala del volumen, que va de 0 a 32 (16 = como est\xE1 escrito, 32 \u2248 +6 dB). No es un porcentaje.` }).optional().describe("De 0 a 32. 16 = como est\xE1 escrito (0 dB); 32 \u2248 +6 dB."),
         balance: external_exports.number().int().min(0).max(16).optional().describe("El paneo, de 0 a 16. **8 es el centro**, 0 todo a la izquierda y 16 todo a la derecha.")
       }
     },
@@ -123787,7 +124264,7 @@ function registrarHerramientasDelPuente(servidor2) {
       title: "El volumen general de la escucha",
       description: "El master del mezclador: sube o baja TODO junto, la tablatura y la grabaci\xF3n de referencia. \u26A0\uFE0F **No se guarda en la obra.** Es de quien est\xE1 escuchando ahora, igual que silenciar y el solo \u2014 subir el master no es una decisi\xF3n musical, es el volumen del cuarto. Al cerrar vuelve a su valor de arranque. \u26A0\uFE0F Va de **0 a 16**, la misma escala que el volumen de una pista: compartirla evita una tabla de traducci\xF3n, que es donde se cuela el error de conversi\xF3n.",
       inputSchema: {
-        volumen: external_exports.number().int().min(0).max(16, { error: (i2) => `\xAB${i2.input}\xBB se sale de la escala del volumen, que va de 0 a 16 (16 = como est\xE1 escrito). No es un porcentaje.` }).describe("De 0 a 16. 0 es mudo.")
+        volumen: external_exports.number().int().min(0).max(16, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se sale de la escala del volumen, que va de 0 a 16 (16 = como est\xE1 escrito). No es un porcentaje.` }).describe("De 0 a 16. 0 es mudo.")
       }
     },
     async (args2) => texto3(await pedirALaPesta\u00F1a("volumen_general", args2))
@@ -124107,7 +124584,7 @@ function registrarHerramientasDeSignos(servidor2) {
       description: "Los signos que ya est\xE1n puestos en una nota o en un golpe. Sirve para comprobar lo que se escribi\xF3 sin tener que mirar el pliego.",
       inputSchema: {
         compas: external_exports.number().int().min(1).max(9999),
-        cuerda: external_exports.number().int().min(1).max(24, { error: (i2) => `\xAB${i2.input}\xBB no es una cuerda: van de 1 (la m\xE1s grave) a 24.` }).describe("La cuerda, desde la m\xE1s grave empezando en 1."),
+        cuerda: external_exports.number().int().min(1).max(24, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB no es una cuerda: van de 1 (la m\xE1s grave) a 24.` }).describe("La cuerda, desde la m\xE1s grave empezando en 1."),
         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(),
@@ -124209,7 +124686,7 @@ function registrarHerramientasDeDuraciones(servidor2) {
       description: "Sube o baja la figura de lo escrito un escal\xF3n: de negra a blanca, de corchea a negra. Es lo que hacen las teclas + y \u2212 en el programa.",
       inputSchema: {
         ...DONDE,
-        direccion: external_exports.enum(["mas-larga", "mas-corta"], { error: (i2) => `\xAB${i2.input}\xBB no es una direcci\xF3n: mas-larga o mas-corta.` })
+        direccion: external_exports.enum(["mas-larga", "mas-corta"], { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB no es una direcci\xF3n: mas-larga o mas-corta.` })
       }
     },
     ({ direccion, ...donde }) => {
@@ -124664,7 +125141,7 @@ function registrarHerramientasDeEstructura(servidor2) {
     {
       title: "Agregar compases al final",
       description: "Alarga la obra. Los compases nuevos heredan la cifra de comp\xE1s del \xFAltimo.",
-      inputSchema: { cuantos: external_exports.number().int().min(1).max(500, { error: (i2) => `\xAB${i2.input}\xBB son demasiados compases de una vez: van de 1 a 500.` }) }
+      inputSchema: { cuantos: external_exports.number().int().min(1).max(500, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB son demasiados compases de una vez: van de 1 a 500.` }) }
     },
     ({ cuantos }) => {
       const { documento } = obraAbierta();
@@ -124678,8 +125155,8 @@ function registrarHerramientasDeEstructura(servidor2) {
       title: "Insertar un comp\xE1s",
       description: "Mete un comp\xE1s vac\xEDo al lado del que se diga, y corre el resto. \u26A0\uFE0F Hay que decir UNO de los dos: `despuesDel` o `antesDel`. \u2605 `antesDel: 1` mete un comp\xE1s **al principio de la obra**, que es lo que hace falta cuando la grabaci\xF3n entra tarde y hay que dejarle espacio antes de lo ya escrito. El comp\xE1s nuevo hereda la m\xE9trica y la armadura de su vecino, y nunca su secci\xF3n ni sus repeticiones.",
       inputSchema: {
-        despuesDel: external_exports.number().int().min(1).max(9999, { error: (i2) => `\xAB${i2.input}\xBB se pasa: los compases van de 1 a 9999.` }).optional().describe("El comp\xE1s despu\xE9s del cual insertar, como lo lee el m\xFAsico."),
-        antesDel: external_exports.number().int().min(1).max(9999, { error: (i2) => `\xAB${i2.input}\xBB se pasa: los compases van de 1 a 9999.` }).optional().describe("El comp\xE1s antes del cual insertar. Con 1, al principio de la obra.")
+        despuesDel: external_exports.number().int().min(1).max(9999, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se pasa: los compases van de 1 a 9999.` }).optional().describe("El comp\xE1s despu\xE9s del cual insertar, como lo lee el m\xFAsico."),
+        antesDel: external_exports.number().int().min(1).max(9999, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se pasa: los compases van de 1 a 9999.` }).optional().describe("El comp\xE1s antes del cual insertar. Con 1, al principio de la obra.")
       }
     },
     ({ despuesDel, antesDel }) => {
@@ -125230,7 +125707,7 @@ function registrarHerramientasDeMusica(servidor2) {
       inputSchema: {
         ...RANGO,
         hasta: external_exports.number().int().min(1).max(9999),
-        semitonos: external_exports.number().int().min(-24).max(24, { error: (i2) => `\xAB${i2.input}\xBB se pasa: se transpone entre -24 y 24 semitonos, o sea dos octavas para cada lado.` })
+        semitonos: external_exports.number().int().min(-24).max(24, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se pasa: se transpone entre -24 y 24 semitonos, o sea dos octavas para cada lado.` })
       }
     },
     ({ semitonos, ...donde }) => {
@@ -125250,7 +125727,7 @@ function registrarHerramientasDeMusica(servidor2) {
     {
       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.",
-      inputSchema: { pasos: external_exports.number().int().min(1).max(50, { error: (i2) => `\xAB${i2.input}\xBB son demasiados pasos de una vez: van de 1 a 50.` }).optional() }
+      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 }) => {
       const { documento } = obraAbierta();
@@ -125269,7 +125746,7 @@ function registrarHerramientasDeMusica(servidor2) {
     {
       title: "Rehacer",
       description: "Vuelve adelante lo que se deshizo.",
-      inputSchema: { pasos: external_exports.number().int().min(1).max(50, { error: (i2) => `\xAB${i2.input}\xBB son demasiados pasos de una vez: van de 1 a 50.` }).optional() }
+      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 }) => {
       const { documento } = obraAbierta();
@@ -125418,7 +125895,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(),
-        figura: external_exports.number().int().min(1).max(64, { error: (i2) => `\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."),
+        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()
       }
     },
@@ -125503,8 +125980,8 @@ function registrarHerramientasDeMusica(servidor2) {
       description: "\u26A0\uFE0F CONSERVA EL TRASTE, NO LA ALTURA: un 5 en la 3\xAA pasa a ser un 5 en la 4\xAA, as\xED que SUENA DISTINTO. Es para cuando uno se equivoc\xF3 de cuerda y quiso escribir esos n\xFAmeros en la otra \u2014 no para pasar la misma melod\xEDa a otra posici\xF3n del m\xE1stil. Para que suene igual hay que reescribir los trastes. O se mueven todas las notas o no se mueve ninguna: si una sola no entra, no pasa nada.",
       inputSchema: {
         ...RANGO,
-        cuerda: external_exports.number().int().min(1).max(24, { error: (i2) => `\xAB${i2.input}\xBB no es una cuerda: van de 1 (la m\xE1s grave) a 24.` }).optional(),
-        hacia: external_exports.enum(["arriba", "abajo"], { error: (i2) => `\xAB${i2.input}\xBB no es una direcci\xF3n: arriba o abajo.` })
+        cuerda: external_exports.number().int().min(1).max(24, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB no es una cuerda: van de 1 (la m\xE1s grave) a 24.` }).optional(),
+        hacia: external_exports.enum(["arriba", "abajo"], { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB no es una direcci\xF3n: arriba o abajo.` })
       }
     },
     ({ hacia, ...donde }) => {
@@ -125572,7 +126049,7 @@ function registrarHerramientasDeMusica(servidor2) {
       title: "La letra alineada contra la grabaci\xF3n",
       description: "Las s\xEDlabas tal como quedaron despu\xE9s de sincronizar, con **el segundo en que cada una se canta**. Numeradas desde 1: ese n\xFAmero es el que piden `refinar_silaba`, `dividir_silaba` y `quitar_silaba`. \u26A0\uFE0F `confianza` es de la m\xE1quina: 0 quiere decir que la puso una persona y no hay duda; cuanto m\xE1s alta, m\xE1s dudosa es la hip\xF3tesis del alineador.",
       inputSchema: {
-        desde: external_exports.number().int().min(1).max(9999, { error: (i2) => `\xAB${i2.input}\xBB se pasa: va de 1 a 9999.` }).optional().describe("Desde qu\xE9 s\xEDlaba. Por omisi\xF3n, la 1."),
+        desde: external_exports.number().int().min(1).max(9999, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se pasa: va de 1 a 9999.` }).optional().describe("Desde qu\xE9 s\xEDlaba. Por omisi\xF3n, la 1."),
         cuantas: external_exports.number().int().min(1).max(999).optional().describe("Cu\xE1ntas traer. Por omisi\xF3n, 50: una canci\xF3n tiene entre 300 y 900.")
       }
     },
@@ -125600,7 +126077,7 @@ function registrarHerramientasDeMusica(servidor2) {
       title: "Corregir una s\xEDlaba de la letra sincronizada",
       description: "Le cambia el texto, el tiempo, o las dos cosas; con `restablecer` la devuelve a donde la hab\xEDa puesto el alineador. \u26A0\uFE0F Cambiar el texto **no toca el tiempo** \u2014corregir \xABgran\xBB por \xABgrande\xBB no cambia cu\xE1ndo se canta\u2014 y mover el tiempo no toca el texto. \u2605 Tocarla a mano le pone la confianza en 0: deja de ser una hip\xF3tesis de la m\xE1quina, y queda como puesta por una persona.",
       inputSchema: {
-        silaba: external_exports.number().int().min(1).max(9999, { error: (i2) => `\xAB${i2.input}\xBB se pasa: las s\xEDlabas van de 1 a 9999.` }).describe("Su n\xFAmero, de `letra_sincronizada`."),
+        silaba: external_exports.number().int().min(1).max(9999, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se pasa: las s\xEDlabas van de 1 a 9999.` }).describe("Su n\xFAmero, de `letra_sincronizada`."),
         texto: external_exports.string().optional(),
         desde: external_exports.number().optional().describe("En qu\xE9 segundo empieza a cantarse."),
         hasta: external_exports.number().optional().describe("En qu\xE9 segundo termina."),
@@ -125643,7 +126120,7 @@ function registrarHerramientasDeMusica(servidor2) {
       title: "Copiar una s\xEDlaba a otro instante",
       description: "Para un coro o una palabra que se repite y el alineador no vio: la original se queda donde est\xE1 y la copia entra en su lugar por tiempo, as\xED que los n\xFAmeros de las siguientes se corren. Es arrastrar la s\xEDlaba con Alt.",
       inputSchema: {
-        silaba: external_exports.number().int().min(1).max(9999, { error: (i2) => `\xAB${i2.input}\xBB se pasa: las s\xEDlabas van de 1 a 9999.` }),
+        silaba: external_exports.number().int().min(1).max(9999, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se pasa: las s\xEDlabas van de 1 a 9999.` }),
         desde: external_exports.number().describe("En qu\xE9 segundo empieza la copia."),
         hasta: external_exports.number().optional().describe("En qu\xE9 segundo termina. Por omisi\xF3n, dura lo mismo que la original.")
       }
@@ -125668,7 +126145,7 @@ function registrarHerramientasDeMusica(servidor2) {
       title: "Partir una s\xEDlaba en dos",
       description: "Cuando el alineador dej\xF3 dos s\xEDlabas pegadas en una. La nueva queda justo despu\xE9s, y el tiempo de la original se reparte entre las dos por la mitad.",
       inputSchema: {
-        silaba: external_exports.number().int().min(1).max(9999, { error: (i2) => `\xAB${i2.input}\xBB se pasa: las s\xEDlabas van de 1 a 9999.` }).describe("Su n\xFAmero, de `letra_sincronizada`."),
+        silaba: external_exports.number().int().min(1).max(9999, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se pasa: las s\xEDlabas van de 1 a 9999.` }).describe("Su n\xFAmero, de `letra_sincronizada`."),
         izquierda: external_exports.string().describe("El texto que queda en la primera."),
         derecha: external_exports.string().describe("El texto de la nueva.")
       }
@@ -125688,8 +126165,8 @@ function registrarHerramientasDeMusica(servidor2) {
       title: "Sacar una s\xEDlaba de la letra sincronizada",
       description: "Cuando el alineador invent\xF3 una que no se canta. \u26A0\uFE0F Saca la s\xEDlaba de la ALINEACI\xD3N, no la letra escrita en el pliego: para eso est\xE1 `poner_silaba`. Con `hasta` saca el tramo entero, de un solo paso de deshacer.",
       inputSchema: {
-        silaba: external_exports.number().int().min(1).max(9999, { error: (i2) => `\xAB${i2.input}\xBB se pasa: las s\xEDlabas van de 1 a 9999.` }).describe("Su n\xFAmero, de `letra_sincronizada`."),
-        hasta: external_exports.number().int().min(1).max(9999, { error: (i2) => `\xAB${i2.input}\xBB se pasa: las s\xEDlabas van de 1 a 9999.` }).optional().describe("La \xFAltima del tramo, incluida.")
+        silaba: external_exports.number().int().min(1).max(9999, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se pasa: las s\xEDlabas van de 1 a 9999.` }).describe("Su n\xFAmero, de `letra_sincronizada`."),
+        hasta: external_exports.number().int().min(1).max(9999, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB se pasa: las s\xEDlabas van de 1 a 9999.` }).optional().describe("La \xFAltima del tramo, incluida.")
       }
     },
     ({ silaba, hasta }) => {
@@ -125732,7 +126209,7 @@ function registrarHerramientasDeMusica(servidor2) {
         campo: external_exports.string().describe(`Cu\xE1l: ${Object.keys(VARIANTES).join(", ")}. De \`variantes_disponibles\`.`),
         variante: external_exports.string().describe("El nombre de la variante, de `variantes_disponibles`."),
         compas: external_exports.number().int().min(1).max(9999),
-        cuerda: external_exports.number().int().min(1).max(24, { error: (i2) => `\xAB${i2.input}\xBB no es una cuerda: van de 1 (la m\xE1s grave) a 24.` }),
+        cuerda: external_exports.number().int().min(1).max(24, { error: (i2) => i2.input === void 0 ? "Falta este dato." : `\xAB${i2.input}\xBB no es una cuerda: van de 1 (la m\xE1s grave) a 24.` }),
         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(),