mandioca-tabs-mcp 0.2.16 → 0.2.17

package/index.mjs

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