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

package/dist/alphaTab.core.mjs

@@ -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.
 *
@@ -186,9 +186,9 @@ class AlphaTabError extends Error {
 * @internal
 */
 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}`);
@@ -3134,7 +3134,7 @@ class GraceGroup {
 		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
@@ -4139,6 +4139,20 @@ class ModelUtils {
 		}
 		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
@@ -4189,13 +4203,7 @@ class ModelUtils {
 						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);
 				}
 			}
 		}
@@ -4942,6 +4950,11 @@ class ModelUtils {
 		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
@@ -6332,7 +6345,10 @@ class Note {
 			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;
@@ -12855,6 +12871,18 @@ class Track {
 		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;
@@ -18350,11 +18378,38 @@ class Gp3To5Importer extends ScoreImporter {
 	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();
@@ -18702,7 +18757,9 @@ class Gp3To5Importer extends ScoreImporter {
 		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) {
@@ -19470,6 +19527,140 @@ class BackingTrack {
 	rawAudioFile;
 }
 //#endregion
+//#region src/model/FingeringAssigner.ts
+/**
+* Cost-function weights for {@link FingeringAssigner}. Defaults tuned for
+* six-string guitar.
+* @internal
+*/
+class FingeringOptions {
+	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
+*/
+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
@@ -19537,6 +19728,8 @@ class GpifParser {
 	_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;
@@ -19557,7 +19750,7 @@ class GpifParser {
 		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;
@@ -19570,6 +19763,7 @@ class GpifParser {
 		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);
 	}
@@ -19579,6 +19773,12 @@ class GpifParser {
 		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;
@@ -21078,7 +21278,7 @@ class GpifParser {
 					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");
@@ -21266,6 +21466,84 @@ class GpifParser {
 		}
 		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];
@@ -21283,66 +21561,46 @@ class GpifParser {
 			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) {
@@ -21875,6 +22133,7 @@ class GpxImporter extends ScoreImporter {
 		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;
@@ -22212,6 +22471,16 @@ class TrackInfo {
 	}
 }
 /**
+* 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
+*/
+class StaffVoicePacking {
+	mapping = /* @__PURE__ */ new Map();
+	sortedRawVoices = [];
+}
+/**
 * @internal
 */
 class MusicXmlImporter extends ScoreImporter {
@@ -22219,6 +22488,7 @@ class MusicXmlImporter extends ScoreImporter {
 	_idToTrackInfo = /* @__PURE__ */ new Map();
 	_indexToTrackInfo = /* @__PURE__ */ new Map();
 	_staffToContext = /* @__PURE__ */ new Map();
+	_staffVoicePacking = /* @__PURE__ */ new Map();
 	_currentBarNumberDisplayPart;
 	_currentBarNumberDisplayBar;
 	_divisionsPerQuarterNote = 1;
@@ -23595,14 +23865,38 @@ class MusicXmlImporter extends ScoreImporter {
 		}
 		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;
@@ -23611,7 +23905,7 @@ class MusicXmlImporter extends ScoreImporter {
 		let beamMode = null;
 		let isChord = false;
 		let staffIndex = 0;
-		let voiceIndex = 0;
+		let voiceRaw = "1";
 		let durationInTicks = -1;
 		let beatDuration = null;
 		let dots = 0;
@@ -23639,7 +23933,7 @@ class MusicXmlImporter extends ScoreImporter {
 				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) {
@@ -23741,13 +24035,11 @@ class MusicXmlImporter extends ScoreImporter {
 			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;
@@ -23833,7 +24125,7 @@ class MusicXmlImporter extends ScoreImporter {
 		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) {
@@ -68852,9 +69144,11 @@ class GpifSoundMapper {
 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);
 	}
@@ -68883,15 +69177,30 @@ class GpifWriter {
 		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) {
@@ -68997,13 +69306,18 @@ class GpifWriter {
 		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());
@@ -69065,7 +69379,7 @@ class GpifWriter {
 		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) {
@@ -69470,7 +69784,7 @@ class GpifWriter {
 			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;
@@ -69485,7 +69799,7 @@ class GpifWriter {
 				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) {
@@ -69621,14 +69935,35 @@ class GpifWriter {
 		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;
@@ -70001,10 +70336,37 @@ class GpifWriter {
 	_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;