@coderline/alphatab 1.9.0-alpha.1883 → 1.9.0-alpha.1891

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /*!
-* alphaTab v1.9.0-alpha.1883 (develop, build 1883)
+* alphaTab v1.9.0-alpha.1891 (develop, build 1891)
 *
 * Copyright © 2026, Daniel Kuschny and Contributors, All rights reserved.
 *
@@ -190,9 +190,9 @@
 	* @internal
 	*/
 	var VersionInfo = class VersionInfo {
-		static version = "1.9.0-alpha.1883";
-		static date = "2026-08-02T03:44:59.527Z";
-		static commit = "a186437bb3263e5ae3f8fd373aef1fef5ebbc7e7";
+		static version = "1.9.0-alpha.1891";
+		static date = "2026-08-10T02:28:09.977Z";
+		static commit = "2a460d7c4b6d879465fe23382adc67bf6fd3196d";
 		static print(print) {
 			print(`alphaTab ${VersionInfo.version}`);
 			print(`commit: ${VersionInfo.commit}`);
@@ -3138,7 +3138,7 @@
 			this.beats.push(beat);
 		}
 		finish() {
-			if (this.beats.length > 0) this.id = `${this.beats[0].absoluteDisplayStart}_${this.beats[0].voice.index}`;
+			if (this.beats.length > 0) this.id = `${this.beats[0].voice.bar.id}_${this.beats[0].voice.index}_${this.beats[0].absoluteDisplayStart}`;
 		}
 	};
 	//#endregion
@@ -4143,6 +4143,20 @@
 			}
 			return headerFooterStyle;
 		}
+		static backfillStaffVoices(staff, targetVoiceCount) {
+			for (let bi = 0; bi < staff.bars.length - 1; bi++) {
+				const priorBar = staff.bars[bi];
+				while (priorBar.voices.length < targetVoiceCount) ModelUtils.appendPlaceholderVoice(priorBar);
+			}
+		}
+		static appendPlaceholderVoice(bar) {
+			const voice = new Voice$1();
+			bar.addVoice(voice);
+			const beat = new Beat();
+			beat.isEmpty = true;
+			beat.duration = Duration.Quarter;
+			voice.addBeat(beat);
+		}
 		/**
 		* Performs some general consolidations of inconsistencies on the given score like
 		* missing bars, beats, duplicated midi channels etc
@@ -4193,13 +4207,7 @@
 							bar.keySignature = bar.previousBar.keySignature;
 							bar.keySignatureType = bar.previousBar.keySignatureType;
 						}
-						for (let i = 0; i < voiceCount; i++) {
-							const v = new Voice$1();
-							bar.addVoice(v);
-							const emptyBeat = new Beat();
-							emptyBeat.isEmpty = true;
-							v.addBeat(emptyBeat);
-						}
+						for (let i = 0; i < voiceCount; i++) ModelUtils.appendPlaceholderVoice(bar);
 					}
 				}
 			}
@@ -4946,6 +4954,11 @@
 			const ksi = keySignature + 7;
 			return keySignatureType === KeySignatureType.Minor ? ModelUtils._minorKeySignatureTonicDegrees[ksi] : ModelUtils._majorKeySignatureTonicDegrees[ksi];
 		}
+		/** True iff the staff's first note isn't stringed. Empty staves return false. */
+		static staffNotesAreNotStringed(staff) {
+			for (const bar of staff.bars) for (const voice of bar.voices) for (const beat of voice.beats) for (const note of beat.notes) return !note.isStringed;
+			return false;
+		}
 	};
 	//#endregion
 	//#region src/model/PickStroke.ts
@@ -6336,7 +6349,10 @@
 				else realValue += this.harmonicPitch;
 				return realValue;
 			}
-			if (this.isPercussion) return this.percussionArticulation;
+			if (this.isPercussion) {
+				const art = PercussionMapper.getArticulation(this);
+				return art !== null ? art.outputMidiNumber : this.percussionArticulation;
+			}
 			if (this.isStringed) return this.fret + this.stringTuning - transpositionPitch;
 			if (this.isPiano) return this.octave * 12 + this.tone - transpositionPitch;
 			return 0;
@@ -12859,6 +12875,18 @@
 			staff.track = this;
 			this.staves.push(staff);
 		}
+		/**
+		* Returns the index of {@link articulation} in {@link percussionArticulations},
+		* appending it (deduplicated by `uniqueId`) when not yet present. Callers store the
+		* returned index in {@link Note.percussionArticulation}.
+		*/
+		getOrRegisterPercussionArticulation(articulation) {
+			const uniqueId = articulation.uniqueId;
+			for (let i = 0; i < this.percussionArticulations.length; i++) if (this.percussionArticulations[i].uniqueId === uniqueId) return i;
+			const index = this.percussionArticulations.length;
+			this.percussionArticulations.push(articulation);
+			return index;
+		}
 		finish(settings, sharedDataBag = null) {
 			if (!this.shortName) {
 				this.shortName = this.name;
@@ -18354,11 +18382,38 @@
 		readVoice(track, bar) {
 			const beatCount = IOHelper.readInt32LE(this.data);
 			if (beatCount === 0) return;
+			const currentVoiceCount = bar.index === 0 ? 1 : bar.previousBar.voices.length;
+			if (bar.voices.length === 0 || currentVoiceCount === 2) {
+				this._readAndChainVoice(track, bar, beatCount);
+				return;
+			}
+			if (beatCount === 1 && this._skipEmptyVoice()) return;
+			ModelUtils.backfillStaffVoices(bar.staff, 2);
+			this._readAndChainVoice(track, bar, beatCount);
+		}
+		_readAndChainVoice(track, bar, beatCount) {
 			const newVoice = new Voice$1();
 			bar.addVoice(newVoice);
 			this._ensureLoopBoundary(beatCount, Gp3To5Importer._maxBeatCount, "beat count");
 			for (let i = 0; i < beatCount; i++) this.readBeat(track, bar, newVoice);
 		}
+		/**
+		* Attempts to skip a fully empty voice.
+		* @returns true if we detected an empty voice, false if the beat was not empty and a full voice has to be read.
+		*/
+		_skipEmptyVoice() {
+			const startOfVoice = this.data.position;
+			const flags = this.data.readByte();
+			let isEmpty = false;
+			if ((flags & 64) !== 0) isEmpty = (this.data.readByte() & 2) === 0;
+			if (!isEmpty) {
+				this.data.position = startOfVoice;
+				return false;
+			}
+			this.data.skip(2);
+			if (this._versionNumber >= 500) this.data.skip(2);
+			return true;
+		}
 		readBeat(track, bar, voice) {
 			const newBeat = new Beat();
 			const flags = this.data.readByte();
@@ -18706,7 +18761,9 @@
 			beat.addNote(newNote);
 			if ((flags & 8) !== 0) this.readNoteEffects(track, voice, beat, newNote);
 			if (bar.staff.isPercussion) {
-				newNote.percussionArticulation = Gp3To5Importer._gp5PercussionInstrumentMap.has(newNote.fret) ? Gp3To5Importer._gp5PercussionInstrumentMap.get(newNote.fret) : newNote.fret;
+				const midi = Gp3To5Importer._gp5PercussionInstrumentMap.has(newNote.fret) ? Gp3To5Importer._gp5PercussionInstrumentMap.get(newNote.fret) : newNote.fret;
+				const knownArticulation = PercussionMapper.getArticulationById(midi);
+				if (knownArticulation !== null) newNote.percussionArticulation = bar.staff.track.getOrRegisterPercussionArticulation(knownArticulation);
 				newNote.fret = NaN;
 			}
 			if (swapAccidentals) {
@@ -19474,6 +19531,140 @@
 		rawAudioFile;
 	};
 	//#endregion
+	//#region src/model/FingeringAssigner.ts
+	/**
+	* Cost-function weights for {@link FingeringAssigner}. Defaults tuned for
+	* six-string guitar.
+	* @internal
+	*/
+	var FingeringOptions = class {
+		preferredHandPosition = 5;
+		/** Negative = prefer open strings. */
+		openStringBonus = -1;
+		highFretPenaltyWeight = .5;
+		negativeFretPenaltyWeight = 3;
+		/** Soft; heavy weight prefers distinct strings but permits collisions
+		*  for chords with more notes than strings. */
+		collisionPenalty = 100;
+		/** Negative = cluster chord notes on neighbouring strings. */
+		adjacentStringBonus = -1.5;
+		/** Negative = repeated pitches stay on the same string across beats. */
+		stringContinuityBonus = -.75;
+		/** EWMA weight for the hand-position anchor:
+		*  `hand = α·hand + (1−α)·newHand`. */
+		handPositionMomentum = .7;
+	};
+	/**
+	* Assigns (string, fret) to a stream of beats via greedy hand-position
+	* hysteresis. One instance per (staff, voice); mutates notes in place.
+	* Not thread-safe.
+	* @internal
+	*/
+	var FingeringAssigner = class FingeringAssigner {
+		static _maxStrings = 30;
+		_tuning;
+		_capo;
+		_transpositionPitch;
+		_options;
+		_handPosition;
+		_lastStringByMidi;
+		_sortedIdx;
+		/**
+		* @param tuning High-to-low MIDI pitches (matches {@link Staff.tuning}). 1..30 entries.
+		*/
+		constructor(tuning, capo, transpositionPitch, options) {
+			if (tuning.length < 1 || tuning.length > FingeringAssigner._maxStrings) throw new Error(`FingeringAssigner requires 1..${FingeringAssigner._maxStrings} strings, got tuning.length=${tuning.length}`);
+			this._tuning = tuning;
+			this._capo = capo;
+			this._transpositionPitch = transpositionPitch;
+			this._options = options ?? new FingeringOptions();
+			this._handPosition = this._options.preferredHandPosition;
+			this._lastStringByMidi = /* @__PURE__ */ new Uint8Array(128);
+			this._sortedIdx = /* @__PURE__ */ new Int32Array(16);
+		}
+		/** Reset the hand-position anchor and per-pitch continuity memory. */
+		reset() {
+			this._handPosition = this._options.preferredHandPosition;
+			this._lastStringByMidi.fill(0);
+		}
+		/** Assigns `(string, fret)` to notes that don't already carry both. */
+		assign(beat) {
+			const notes = beat.notes;
+			const K = notes.length;
+			if (K === 0) return;
+			if (this._sortedIdx.length < K) this._sortedIdx = new Int32Array(K);
+			const sortedIdx = this._sortedIdx;
+			let n = 0;
+			for (let i = 0; i < K; i++) {
+				const note = notes[i];
+				if (note.isStringed) continue;
+				if (note.isPercussion) {
+					const art = PercussionMapper.getArticulation(note);
+					if (art !== null) {
+						if (Number.isNaN(note.string)) note.string = Math.max(1, Math.min(6, 7 - art.staffLine));
+						if (Number.isNaN(note.fret)) note.fret = art.outputMidiNumber;
+					}
+					continue;
+				}
+				const tieOrigin = note.tieOrigin;
+				if (note.isTieDestination && tieOrigin !== null && tieOrigin.isStringed) {
+					note.string = tieOrigin.string;
+					note.fret = tieOrigin.fret;
+					continue;
+				}
+				let j = n;
+				const noteValue = note.realValue;
+				while (j > 0 && notes[sortedIdx[j - 1]].realValue > noteValue) {
+					sortedIdx[j] = sortedIdx[j - 1];
+					j--;
+				}
+				sortedIdx[j] = i;
+				n++;
+			}
+			if (n === 0) return;
+			const N = this._tuning.length;
+			const opts = this._options;
+			let usedStrings = 0;
+			let newHand = -1;
+			for (let k = 0; k < n; k++) {
+				const note = notes[sortedIdx[k]];
+				const realValue = note.realValue;
+				const target = realValue + this._transpositionPitch;
+				const continuityString = realValue >= 0 && realValue < 128 ? this._lastStringByMidi[realValue] : 0;
+				let bestString = 1;
+				let bestFret = 0;
+				let bestCost = Number.POSITIVE_INFINITY;
+				for (let s = 1; s <= N; s++) {
+					const fret = target - (this._capo + this._tuning[N - s]);
+					const distanceCost = Math.abs(fret - this._handPosition);
+					const openBonus = fret === 0 ? opts.openStringBonus : 0;
+					const negFretPenalty = fret < 0 ? -fret * opts.negativeFretPenaltyWeight : 0;
+					const highFretPenalty = fret > 12 ? (fret - 12) * opts.highFretPenaltyWeight : 0;
+					const collisionCost = (usedStrings & 1 << s - 1) !== 0 ? opts.collisionPenalty : 0;
+					const leftUsed = s > 1 && (usedStrings & 1 << s - 2) !== 0;
+					const rightUsed = s < N && (usedStrings & 1 << s) !== 0;
+					const adjacencyBonus = leftUsed || rightUsed ? opts.adjacentStringBonus : 0;
+					const continuityBonus = s === continuityString ? opts.stringContinuityBonus : 0;
+					const cost = distanceCost + openBonus + negFretPenalty + highFretPenalty + collisionCost + adjacencyBonus + continuityBonus;
+					if (cost < bestCost) {
+						bestCost = cost;
+						bestString = s;
+						bestFret = fret;
+					}
+				}
+				note.string = bestString;
+				note.fret = bestFret;
+				usedStrings |= 1 << bestString - 1;
+				if (realValue >= 0 && realValue < 128) this._lastStringByMidi[realValue] = bestString;
+				if (bestFret > 0 && (newHand < 0 || bestFret < newHand)) newHand = bestFret;
+			}
+			if (newHand >= 0) {
+				const alpha = opts.handPositionMomentum;
+				this._handPosition = alpha * this._handPosition + (1 - alpha) * newHand;
+			}
+		}
+	};
+	//#endregion
 	//#region src/importer/GpifParser.ts
 	/**
 	* This structure represents a duration within a gpif
@@ -19541,6 +19732,8 @@
 		_articulationByName;
 		_skipApplyLyrics = false;
 		_backingTrackPadding = 0;
+		/** Marks the input as a Guitar Pro 6 file. Also auto-detected from the GPIF header. */
+		isGp6 = false;
 		_doubleBars = /* @__PURE__ */ new Set();
 		_keySignatures = /* @__PURE__ */ new Map();
 		loadAsset;
@@ -19561,7 +19754,7 @@
 			this._rhythmById = /* @__PURE__ */ new Map();
 			this._notesOfBeat = /* @__PURE__ */ new Map();
 			this._noteById = /* @__PURE__ */ new Map();
-			this._tappedNotes = /* @__PURE__ */ new Map();
+			this._tappedNotes = /* @__PURE__ */ new Set();
 			this._lyricsByTrack = /* @__PURE__ */ new Map();
 			this._soundsByTrack = /* @__PURE__ */ new Map();
 			this._skipApplyLyrics = false;
@@ -19574,6 +19767,7 @@
 			this._parseDom(dom);
 			this._buildModel();
 			ModelUtils.consolidate(this.score);
+			if (this.isGp6) this._assignFingeringForGp6();
 			this.score.finish(settings);
 			if (!this._skipApplyLyrics && this._lyricsByTrack.size > 0) for (const [t, lyrics] of this._lyricsByTrack) this._tracksById.get(t).applyLyrics(lyrics);
 		}
@@ -19583,6 +19777,12 @@
 			if (root.localName === "GPIF") {
 				this.score = new Score();
 				for (const n of root.childElements()) switch (n.localName) {
+					case "GPVersion":
+						if (n.innerText === "6") this.isGp6 = true;
+						break;
+					case "Encoding":
+						if (n.findChildElement("EncodingDescription")?.innerText === "GP6") this.isGp6 = true;
+						break;
 					case "Score":
 						this._parseScoreNode(n);
 						break;
@@ -21077,7 +21277,7 @@
 						variation = GpifParser._parseIntSafe(c.findChildElement("Variation")?.innerText, 0);
 						break;
 					case "Tapped":
-						this._tappedNotes.set(noteId, true);
+						this._tappedNotes.add(noteId);
 						break;
 					case "HarmonicType":
 						const htype = c.findChildElement("HType");
@@ -21265,6 +21465,84 @@
 			}
 			this._rhythmById.set(rhythmId, rhythm);
 		}
+		_keyFor(trackId, base) {
+			if (!this._transposeKeySignaturePerTrack.has(trackId)) return base;
+			return [ModelUtils.transposeKey(base[0], this._transposeKeySignaturePerTrack.get(trackId)), base[1]];
+		}
+		_equalizeVoiceCount(staff, bar, staffVoiceLimits) {
+			const previousMax = staffVoiceLimits.get(staff) ?? 0;
+			const target = Math.max(previousMax, bar.voices.length, 1);
+			if (target > previousMax) {
+				staffVoiceLimits.set(staff, target);
+				ModelUtils.backfillStaffVoices(staff, target);
+			}
+			while (bar.voices.length < target) ModelUtils.appendPlaceholderVoice(bar);
+		}
+		_attachVoiceToBar(bar, voiceId, staff) {
+			const voice = this._voiceById.get(voiceId);
+			bar.addVoice(voice);
+			const beatIds = this._beatsOfVoice.get(voiceId);
+			if (!beatIds) return;
+			for (const beatId of beatIds) if (beatId !== GpifParser._invalidId) this._attachBeatToVoice(voice, beatId, staff);
+		}
+		_attachBeatToVoice(voice, beatId, staff) {
+			const beat = BeatCloner.clone(this._beatById.get(beatId));
+			voice.addBeat(beat);
+			const rhythmId = this._rhythmOfBeat.get(beatId);
+			const rhythm = this._rhythmById.get(rhythmId);
+			beat.duration = rhythm.value;
+			beat.dots = rhythm.dots;
+			beat.tupletNumerator = rhythm.tupletNumerator;
+			beat.tupletDenominator = rhythm.tupletDenominator;
+			const noteIds = this._notesOfBeat.get(beatId);
+			if (!noteIds) return;
+			for (const noteId of noteIds) if (noteId !== GpifParser._invalidId) this._attachNoteToBeat(beat, noteId, staff);
+		}
+		_attachNoteToBeat(beat, noteId, staff) {
+			const note = NoteCloner.clone(this._noteById.get(noteId));
+			if (staff.isPercussion) note.fret = NaN;
+			else note.percussionArticulation = NaN;
+			beat.addNote(note);
+			if (this._tappedNotes.has(noteId)) beat.tap = true;
+			if (staff.isPercussion && note.percussionArticulation >= 0) {
+				const trackArticulations = staff.track.percussionArticulations;
+				let known = null;
+				if (note.percussionArticulation < trackArticulations.length) known = trackArticulations[note.percussionArticulation];
+				else known = PercussionMapper.getArticulationById(note.percussionArticulation);
+				if (known !== null) note.percussionArticulation = staff.track.getOrRegisterPercussionArticulation(known);
+			}
+		}
+		_assignFingeringForGp6() {
+			for (const track of this.score.tracks) for (const staff of track.staves) {
+				const isPercussion = staff.isPercussion;
+				const isPitchedOnly = !isPercussion && staff.stringTuning.tunings.length === 0 && ModelUtils.staffNotesAreNotStringed(staff);
+				if (!isPercussion && !isPitchedOnly) continue;
+				if (isPercussion) staff.stringTuning.tunings = [
+					0,
+					0,
+					0,
+					0,
+					0,
+					0
+				];
+				else {
+					const fallback = staff.index === 0 ? Tuning.getDefaultTuningFor(6) : Tuning.getDefaultTuningFor(5);
+					if (fallback !== null) {
+						staff.stringTuning.tunings = fallback.tunings.slice();
+						staff.stringTuning.name = fallback.name;
+					}
+				}
+				const assignersByVoiceIndex = /* @__PURE__ */ new Map();
+				for (const bar of staff.bars) for (const voice of bar.voices) {
+					let assigner = assignersByVoiceIndex.get(voice.index);
+					if (assigner === void 0) {
+						assigner = new FingeringAssigner(staff.stringTuning.tunings, staff.capo, staff.transpositionPitch);
+						assignersByVoiceIndex.set(voice.index, assigner);
+					}
+					for (const beat of voice.beats) assigner.assign(beat);
+				}
+			}
+		}
 		_buildModel() {
 			for (let i = 0, j = this._masterBars.length; i < j; i++) {
 				const masterBar = this._masterBars[i];
@@ -21282,66 +21560,46 @@
 				this.score.addTrack(track);
 				trackIndexToTrackId.push(trackId);
 			}
+			const staffVoiceLimits = /* @__PURE__ */ new Map();
 			let keySignature;
 			for (const barIds of this._barsOfMasterBar) {
 				let staffIndex = 0;
 				let trackIndex = 0;
-				keySignature = [KeySignature.C, KeySignatureType.Major];
-				if (this._transposeKeySignaturePerTrack.has(trackIndexToTrackId[0])) keySignature = [ModelUtils.transposeKey(keySignature[0], this._transposeKeySignaturePerTrack.get(trackIndexToTrackId[0])), keySignature[1]];
+				keySignature = this._keyFor(trackIndexToTrackId[0], [KeySignature.C, KeySignatureType.Major]);
 				for (let barIndex = 0; barIndex < barIds.length && trackIndex < this.score.tracks.length; barIndex++) {
 					const barId = barIds[barIndex];
-					if (barId !== GpifParser._invalidId) {
-						const bar = this._barsById.get(barId);
-						const track = this.score.tracks[trackIndex];
-						const staff = track.staves[staffIndex];
-						staff.addBar(bar);
-						const masterBarIndex = staff.bars.length - 1;
-						if (this._keySignatures.has(masterBarIndex)) {
-							keySignature = this._keySignatures.get(masterBarIndex);
-							if (this._transposeKeySignaturePerTrack.has(trackIndexToTrackId[trackIndex])) keySignature = [ModelUtils.transposeKey(keySignature[0], this._transposeKeySignaturePerTrack.get(trackIndexToTrackId[trackIndex])), keySignature[1]];
-						}
-						bar.keySignature = keySignature[0];
-						bar.keySignatureType = keySignature[1];
-						if (this._doubleBars.has(bar.masterBar)) bar.barLineRight = BarLineStyle.LightLight;
-						if (this._voicesOfBar.has(barId)) for (const voiceId of this._voicesOfBar.get(barId)) if (voiceId !== GpifParser._invalidId) {
-							const voice = this._voiceById.get(voiceId);
-							bar.addVoice(voice);
-							if (this._beatsOfVoice.has(voiceId)) {
-								for (const beatId of this._beatsOfVoice.get(voiceId)) if (beatId !== GpifParser._invalidId) {
-									const beat = BeatCloner.clone(this._beatById.get(beatId));
-									voice.addBeat(beat);
-									const rhythmId = this._rhythmOfBeat.get(beatId);
-									const rhythm = this._rhythmById.get(rhythmId);
-									beat.duration = rhythm.value;
-									beat.dots = rhythm.dots;
-									beat.tupletNumerator = rhythm.tupletNumerator;
-									beat.tupletDenominator = rhythm.tupletDenominator;
-									if (this._notesOfBeat.has(beatId)) {
-										for (const noteId of this._notesOfBeat.get(beatId)) if (noteId !== GpifParser._invalidId) {
-											const note = NoteCloner.clone(this._noteById.get(noteId));
-											if (staff.isPercussion) note.fret = NaN;
-											else note.percussionArticulation = NaN;
-											beat.addNote(note);
-											if (this._tappedNotes.has(noteId)) beat.tap = true;
-										}
-									}
-								}
+					if (barId === GpifParser._invalidId) {
+						trackIndex++;
+						continue;
+					}
+					const bar = this._barsById.get(barId);
+					const track = this.score.tracks[trackIndex];
+					const staff = track.staves[staffIndex];
+					staff.addBar(bar);
+					const masterBarIndex = staff.bars.length - 1;
+					if (this._keySignatures.has(masterBarIndex)) keySignature = this._keyFor(trackIndexToTrackId[trackIndex], this._keySignatures.get(masterBarIndex));
+					bar.keySignature = keySignature[0];
+					bar.keySignatureType = keySignature[1];
+					if (this._doubleBars.has(bar.masterBar)) bar.barLineRight = BarLineStyle.LightLight;
+					const voiceIds = this._voicesOfBar.get(barId);
+					if (voiceIds) {
+						let pendingPlaceholders = 0;
+						for (const voiceId of voiceIds) if (voiceId === GpifParser._invalidId) pendingPlaceholders++;
+						else {
+							while (pendingPlaceholders > 0) {
+								ModelUtils.appendPlaceholderVoice(bar);
+								pendingPlaceholders--;
 							}
-						} else {
-							const voice = new Voice$1();
-							bar.addVoice(voice);
-							const beat = new Beat();
-							beat.isEmpty = true;
-							beat.duration = Duration.Quarter;
-							voice.addBeat(beat);
+							this._attachVoiceToBar(bar, voiceId, staff);
 						}
-						if (staffIndex === track.staves.length - 1) {
-							trackIndex++;
-							staffIndex = 0;
-						} else staffIndex++;
-						keySignature = [KeySignature.C, KeySignatureType.Major];
-						if (trackIndex < trackIndexToTrackId.length && this._transposeKeySignaturePerTrack.has(trackIndexToTrackId[trackIndex])) keySignature = [ModelUtils.transposeKey(keySignature[0], this._transposeKeySignaturePerTrack.get(trackIndexToTrackId[trackIndex])), keySignature[1]];
-					} else trackIndex++;
+					}
+					this._equalizeVoiceCount(staff, bar, staffVoiceLimits);
+					staffIndex++;
+					if (staffIndex >= track.staves.length) {
+						trackIndex++;
+						staffIndex = 0;
+					}
+					keySignature = trackIndex < trackIndexToTrackId.length ? this._keyFor(trackIndexToTrackId[trackIndex], [KeySignature.C, KeySignatureType.Major]) : [KeySignature.C, KeySignatureType.Major];
 				}
 			}
 			for (const trackId of this._tracksMapping) {
@@ -21874,6 +22132,7 @@
 			if (!xml) throw new UnsupportedFormatError("No score.gpif found in GPX");
 			Logger.debug(this.name, "Start Parsing score.gpif");
 			const gpifParser = new GpifParser();
+			gpifParser.isGp6 = true;
 			gpifParser.parseXml(xml, this.settings);
 			Logger.debug(this.name, "score.gpif parsed");
 			const score = gpifParser.score;
@@ -22211,6 +22470,16 @@
 		}
 	};
 	/**
+	* Tracks how raw MusicXML voice numbers on a staff map into alphaTab's local
+	* (dense, 0-based) voice slots. Collapses MuseScore's sparse `staff*4+local`
+	* convention (staff 2 → voices 5..8) into dense per-staff indices.
+	* @internal
+	*/
+	var StaffVoicePacking = class {
+		mapping = /* @__PURE__ */ new Map();
+		sortedRawVoices = [];
+	};
+	/**
 	* @internal
 	*/
 	var MusicXmlImporter = class MusicXmlImporter extends ScoreImporter {
@@ -22218,6 +22487,7 @@
 		_idToTrackInfo = /* @__PURE__ */ new Map();
 		_indexToTrackInfo = /* @__PURE__ */ new Map();
 		_staffToContext = /* @__PURE__ */ new Map();
+		_staffVoicePacking = /* @__PURE__ */ new Map();
 		_currentBarNumberDisplayPart;
 		_currentBarNumberDisplayBar;
 		_divisionsPerQuarterNote = 1;
@@ -23594,14 +23864,38 @@
 			}
 			return staff.bars[masterBar.index];
 		}
-		_getOrCreateVoice(bar, voiceIndex) {
-			let voicesCreated = false;
-			while (bar.voices.length <= voiceIndex) {
-				bar.addVoice(new Voice$1());
-				voicesCreated = true;
+		_resolveAndPlaceVoice(staff, rawVoice, bar) {
+			let packing;
+			if (this._staffVoicePacking.has(staff)) packing = this._staffVoicePacking.get(staff);
+			else {
+				packing = new StaffVoicePacking();
+				this._staffVoicePacking.set(staff, packing);
 			}
-			if (voicesCreated) for (const b of bar.staff.bars) while (b.voices.length <= voiceIndex) b.addVoice(new Voice$1());
-			return bar.voices[voiceIndex];
+			if (packing.mapping.has(rawVoice)) return bar.voices[packing.mapping.get(rawVoice)];
+			let newVoiceNumber = Number.parseInt(rawVoice, 10);
+			if (Number.isNaN(newVoiceNumber)) {
+				Logger.warning("MusicXML", "Voices need to be specified as numbers");
+				newVoiceNumber = 0;
+			}
+			let insertPos = packing.sortedRawVoices.length;
+			for (let i = 0; i < packing.sortedRawVoices.length; i++) {
+				const existing = Number.parseInt(packing.sortedRawVoices[i], 10);
+				if ((Number.isNaN(existing) ? 0 : existing) > newVoiceNumber) {
+					insertPos = i;
+					break;
+				}
+			}
+			packing.sortedRawVoices.splice(insertPos, 0, rawVoice);
+			for (const b of staff.bars) {
+				b.voices.splice(insertPos, 0, new Voice$1());
+				for (let i = insertPos; i < b.voices.length; i++) {
+					b.voices[i].index = i;
+					b.voices[i].bar = b;
+				}
+			}
+			packing.mapping.clear();
+			for (let i = 0; i < packing.sortedRawVoices.length; i++) packing.mapping.set(packing.sortedRawVoices[i], i);
+			return bar.voices[insertPos];
 		}
 		_parseNote(element, masterBar, track) {
 			let beat = null;
@@ -23610,7 +23904,7 @@
 			let beamMode = null;
 			let isChord = false;
 			let staffIndex = 0;
-			let voiceIndex = 0;
+			let voiceRaw = "1";
 			let durationInTicks = -1;
 			let beatDuration = null;
 			let dots = 0;
@@ -23638,7 +23932,7 @@
 					return;
 				}
 				const bar = this._getOrCreateBar(staff, masterBar);
-				const voice = this._getOrCreateVoice(bar, voiceIndex);
+				const voice = this._resolveAndPlaceVoice(staff, voiceRaw, bar);
 				const actualMusicalPosition = voice.beats.length === 0 ? 0 : voice.beats[voice.beats.length - 1].displayEnd;
 				let gap = this._musicalPosition - actualMusicalPosition;
 				if (gap > 0) {
@@ -23740,13 +24034,11 @@
 				case "instrument":
 					instrumentId = c.getAttribute("id", "");
 					break;
-				case "voice":
-					voiceIndex = Number.parseInt(c.innerText, 10);
-					if (Number.isNaN(voiceIndex)) {
-						Logger.warning("MusicXML", "Voices need to be specified as numbers");
-						voiceIndex = 0;
-					} else voiceIndex = voiceIndex - 1;
+				case "voice": {
+					const trimmed = c.innerText.trim();
+					voiceRaw = trimmed.length > 0 ? trimmed : "1";
 					break;
+				}
 				case "type":
 					beatDuration = this._parseBeatDuration(c);
 					break;
@@ -23832,7 +24124,7 @@
 			if (instrumentId !== null && trackInfo.isUnpitchedInstrument(instrumentId)) note.percussionArticulation = trackInfo.getOrCreateArticulation(instrumentId, note);
 			else if (note.beat.voice.bar.staff.isPercussion) {
 				const knownArticulation = PercussionMapper.getArticulationById(note.displayValue);
-				if (knownArticulation) note.percussionArticulation = knownArticulation.id;
+				if (knownArticulation) note.percussionArticulation = track.getOrRegisterPercussionArticulation(knownArticulation);
 			}
 		}
 		_parsePlay(element, note) {
@@ -68847,9 +69139,11 @@
 	var GpifWriter = class GpifWriter {
 		static _sampleRate = 44100;
 		_rhythmIdLookup = /* @__PURE__ */ new Map();
+		_tuningByStaff = /* @__PURE__ */ new Map();
 		writeXml(score) {
 			const xmlDocument = new XmlDocument();
 			this._rhythmIdLookup = /* @__PURE__ */ new Map();
+			this._tuningByStaff = /* @__PURE__ */ new Map();
 			this._writeDom(xmlDocument, score);
 			return xmlDocument.toFormattedString("", true);
 		}
@@ -68878,15 +69172,30 @@
 			const beats = gpif.addElement("Beats");
 			const notes = gpif.addElement("Notes");
 			const rhythms = gpif.addElement("Rhythms");
-			for (const tracks of score.tracks) for (const staff of tracks.staves) for (const bar of staff.bars) {
-				this._writeBarNode(bars, bar);
-				for (const voice of bar.voices) {
-					this._writeVoiceNode(voices, voice);
-					for (const beat of voice.beats) {
-						this._writeBeatNode(beats, beat, rhythms);
-						for (const note of beat.notes) this._writeNoteNode(notes, note);
+			for (const tracks of score.tracks) for (const staff of tracks.staves) {
+				const needsFingering = ModelUtils.staffNotesAreNotStringed(staff);
+				const assignersByVoiceIndex = needsFingering ? /* @__PURE__ */ new Map() : null;
+				const stringedTuning = needsFingering ? this._tuningByStaff.get(staff) : null;
+				const savedTunings = staff.tuning;
+				if (needsFingering && stringedTuning !== null && savedTunings.length === 0) staff.stringTuning.tunings = stringedTuning.slice();
+				for (const bar of staff.bars) {
+					const activeVoices = this._writeBarNode(bars, bar);
+					for (const voice of activeVoices) {
+						let assigner = null;
+						if (assignersByVoiceIndex !== null && stringedTuning !== null) if (assignersByVoiceIndex.has(voice.index)) assigner = assignersByVoiceIndex.get(voice.index);
+						else {
+							assigner = new FingeringAssigner(stringedTuning, staff.capo, staff.transpositionPitch);
+							assignersByVoiceIndex.set(voice.index, assigner);
+						}
+						this._writeVoiceNode(voices, voice);
+						for (const beat of voice.beats) {
+							if (assigner !== null) assigner.assign(beat);
+							this._writeBeatNode(beats, beat, rhythms);
+							for (const note of beat.notes) this._writeNoteNode(notes, note);
+						}
 					}
 				}
+				staff.stringTuning.tunings = savedTunings;
 			}
 		}
 		_writeAssets(parent, score) {
@@ -68992,13 +69301,18 @@
 			const properties = parent.addElement("Properties");
 			this._writeConcertPitch(properties, note);
 			this._writeTransposedPitch(properties, note);
-			if (note.isStringed) {
+			if (note.isPercussion) {
+				const art = PercussionMapper.getArticulation(note);
+				const midi = art !== null ? art.outputMidiNumber : 0;
+				this._writeSimplePropertyNode(properties, "String", "String", (note.string - 1).toString());
+				this._writeSimplePropertyNode(properties, "Fret", "Fret", midi.toString());
+				this._writeSimplePropertyNode(properties, "Midi", "Number", midi.toString());
+			} else if (note.isStringed) {
 				this._writeSimplePropertyNode(properties, "String", "String", (note.string - 1).toString());
 				this._writeSimplePropertyNode(properties, "Fret", "Fret", note.fret.toString());
 				this._writeSimplePropertyNode(properties, "Midi", "Number", note.realValue.toString());
 				if (note.showStringNumber) this._writeSimplePropertyNode(properties, "ShowStringNumber", "Enable", null);
 			}
-			if (note.isPercussion) this._writeSimplePropertyNode(properties, "String", "String", (note.string - 1).toString());
 			if (note.isPiano) {
 				this._writeSimplePropertyNode(properties, "Octave", "Number", note.octave.toString());
 				this._writeSimplePropertyNode(properties, "Tone", "Step", note.tone.toString());
@@ -69060,7 +69374,7 @@
 			if (slideFlags > 0) this._writeSimplePropertyNode(properties, "Slide", "Flags", slideFlags.toString());
 		}
 		_writeTransposedPitch(properties, note) {
-			if (note.isPercussion) this._writePitch(properties, "ConcertPitch", "C", "-1", "");
+			if (note.isPercussion) this._writePitch(properties, "TransposedPitch", "C", "-1", "");
 			else this._writePitchForValue(properties, "TransposedPitch", note.displayValueWithoutBend, note.accidentalMode, note.beat.voice.bar.keySignature);
 		}
 		_writeConcertPitch(properties, note) {
@@ -69465,7 +69779,7 @@
 				initialTempoAutomation.addElement("Bar").innerText = "0";
 				initialTempoAutomation.addElement("Position").innerText = "0";
 				initialTempoAutomation.addElement("Visible").innerText = "true";
-				initialTempoAutomation.addElement("Value").innerText = `${score.tempo} 2`;
+				initialTempoAutomation.addElement("Value").innerText = `${score.tempo | 0} 2`;
 				if (score.tempoLabel) initialTempoAutomation.addElement("Text").innerText = score.tempoLabel;
 			}
 			const initialSyncPoint = score.masterBars[0].syncPoints ? score.masterBars[0].syncPoints.find((p) => p.ratioPosition === 0 && p.syncPointValue.barOccurence === 0) : void 0;
@@ -69480,7 +69794,7 @@
 					tempoAutomation.addElement("Bar").innerText = mb.index.toString();
 					tempoAutomation.addElement("Position").innerText = automation.ratioPosition.toString();
 					tempoAutomation.addElement("Visible").innerText = automation.isVisible ? "true" : "false";
-					tempoAutomation.addElement("Value").innerText = `${automation.value} 2`;
+					tempoAutomation.addElement("Value").innerText = `${automation.value | 0} 2`;
 					if (automation.text) tempoAutomation.addElement("Text").innerText = automation.text;
 				}
 				if (mb.syncPoints) for (const syncPoint of mb.syncPoints) {
@@ -69616,14 +69930,35 @@
 			const properties = parent.addElement("Staff").addElement("Properties");
 			this._writeSimplePropertyNode(properties, "CapoFret", "Fret", staff.capo.toString());
 			this._writeSimplePropertyNode(properties, "FretCount", "Fret", "24");
-			if (staff.tuning.length > 0) {
+			let tuning = staff.tuning;
+			let tuningName = staff.tuningName;
+			if (tuning.length === 0) {
+				if (staff.isPercussion) {
+					tuning = [
+						0,
+						0,
+						0,
+						0,
+						0,
+						0
+					];
+					tuningName = "";
+				} else if (ModelUtils.staffNotesAreNotStringed(staff)) {
+					const staffTuning = staff.index === 0 ? Tuning.getDefaultTuningFor(6) : Tuning.getDefaultTuningFor(5);
+					tuning = staffTuning.tunings;
+					tuningName = staffTuning.name;
+				}
+			}
+			this._tuningByStaff.set(staff, tuning);
+			if (tuning.length > 0) {
 				const tuningProperty = properties.addElement("Property");
 				tuningProperty.attributes.set("name", "Tuning");
-				tuningProperty.addElement("Pitches").innerText = staff.tuning.slice().reverse().join(" ");
-				tuningProperty.addElement("Label").setCData(staff.tuningName);
-				tuningProperty.addElement("LabelVisible").innerText = staff.tuningName ? "true" : "false";
+				tuningProperty.addElement("Pitches").innerText = tuning.slice().reverse().join(" ");
+				tuningProperty.addElement("Label").setCData(tuningName);
+				tuningProperty.addElement("LabelVisible").innerText = tuningName ? "true" : "false";
 				tuningProperty.addElement("Flat");
-				switch (staff.tuning.length) {
+				if (staff.isPercussion) tuningProperty.addElement("Instrument").innerText = "Undefined";
+				else switch (tuning.length) {
 					case 3:
 						tuningProperty.addElement("Instrument").innerText = "Shamisen";
 						break;
@@ -69996,10 +70331,37 @@
 		_writeBarNode(parent, bar) {
 			const barNode = parent.addElement("Bar");
 			barNode.attributes.set("id", bar.id.toString());
-			barNode.addElement("Voices").innerText = bar.voices.map((v) => v.isEmpty ? "-1" : v.id.toString()).join(" ");
+			const activeVoices = [];
+			const slots = [
+				"-1",
+				"-1",
+				"-1",
+				"-1"
+			];
+			const overflowVoices = [];
+			for (let i = 0; i < bar.voices.length; i++) {
+				const v = bar.voices[i];
+				if (i < 4) {
+					if (!v.isEmpty) {
+						slots[i] = v.id.toString();
+						activeVoices.push(v);
+					}
+				} else if (!v.isEmpty) overflowVoices.push(v);
+			}
+			let dropped = 0;
+			for (const v of overflowVoices) {
+				const freeSlot = slots.indexOf("-1");
+				if (freeSlot >= 0) {
+					slots[freeSlot] = v.id.toString();
+					activeVoices.push(v);
+				} else dropped++;
+			}
+			if (dropped > 0) Logger.warning("GpifWriter", `Bar ${bar.id} has ${activeVoices.length + dropped} non-empty voices; Guitar Pro supports max 4. Dropping ${dropped}.`);
+			barNode.addElement("Voices").innerText = slots.join(" ");
 			barNode.addElement("Clef").innerText = Clef[bar.clef];
 			if (bar.clefOttava !== Ottavia.Regular) barNode.addElement("Ottavia").innerText = Ottavia[bar.clefOttava].substr(1);
 			if (bar.simileMark !== SimileMark.None) barNode.addElement("SimileMark").innerText = SimileMark[bar.simileMark];
+			return activeVoices;
 		}
 		_writeVoiceNode(parent, voice) {
 			if (voice.isEmpty) return;