@coderline/alphatab 1.8.0-alpha.1660 → 1.8.0-alpha.1667

package/dist/alphaTab.core.mjs

@@ -1,7 +1,7 @@
 /*!
- * alphaTab v1.8.0-alpha.1660 (develop, build 1660)
+ * alphaTab v1.8.0-alpha.1667 (develop, build 1667)
  *
- * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
+ * Copyright © 2026, Daniel Kuschny and Contributors, All rights reserved.
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -203,9 +203,9 @@ class AlphaTabError extends Error {
  * @internal
  */
 class VersionInfo {
-    static version = '1.8.0-alpha.1660';
-    static date = '2025-12-30T02:22:19.477Z';
-    static commit = 'adca157f6f531fbf0e712c814f0c9c627bf33b74';
+    static version = '1.8.0-alpha.1667';
+    static date = '2026-01-06T02:24:13.312Z';
+    static commit = '52bfad1512fe6b0ca977ecefc2e3b5943729385d';
     static print(print) {
         print(`alphaTab ${VersionInfo.version}`);
         print(`commit: ${VersionInfo.commit}`);
@@ -4640,9 +4640,12 @@ var MusicFontSymbol;
     MusicFontSymbol[MusicFontSymbol["TextTupletBracketStartLongStem"] = 57857] = "TextTupletBracketStartLongStem";
     MusicFontSymbol[MusicFontSymbol["TextTuplet3LongStem"] = 57858] = "TextTuplet3LongStem";
     MusicFontSymbol[MusicFontSymbol["TextTupletBracketEndLongStem"] = 57859] = "TextTupletBracketEndLongStem";
-    MusicFontSymbol[MusicFontSymbol["Tremolo3"] = 57890] = "Tremolo3";
-    MusicFontSymbol[MusicFontSymbol["Tremolo2"] = 57889] = "Tremolo2";
     MusicFontSymbol[MusicFontSymbol["Tremolo1"] = 57888] = "Tremolo1";
+    MusicFontSymbol[MusicFontSymbol["Tremolo2"] = 57889] = "Tremolo2";
+    MusicFontSymbol[MusicFontSymbol["Tremolo3"] = 57890] = "Tremolo3";
+    MusicFontSymbol[MusicFontSymbol["Tremolo4"] = 57891] = "Tremolo4";
+    MusicFontSymbol[MusicFontSymbol["Tremolo5"] = 57892] = "Tremolo5";
+    MusicFontSymbol[MusicFontSymbol["BuzzRoll"] = 57898] = "BuzzRoll";
     MusicFontSymbol[MusicFontSymbol["Flag8thUp"] = 57920] = "Flag8thUp";
     MusicFontSymbol[MusicFontSymbol["Flag8thDown"] = 57921] = "Flag8thDown";
     MusicFontSymbol[MusicFontSymbol["Flag16thUp"] = 57922] = "Flag16thUp";
@@ -6949,6 +6952,61 @@ var Rasgueado;
     Rasgueado[Rasgueado["Peami"] = 18] = "Peami";
 })(Rasgueado || (Rasgueado = {}));
 
+/**
+ * The style of tremolo affecting mainly the display of the effect.
+ * @public
+ */
+var TremoloPickingStyle;
+(function (TremoloPickingStyle) {
+    /**
+     * A classic tremolo expressed by diagonal bars on the stem.
+     */
+    TremoloPickingStyle[TremoloPickingStyle["Default"] = 0] = "Default";
+    /**
+     * A buzz roll tremolo expressed by a 'z' shaped symbol.
+     */
+    TremoloPickingStyle[TremoloPickingStyle["BuzzRoll"] = 1] = "BuzzRoll";
+})(TremoloPickingStyle || (TremoloPickingStyle = {}));
+/**
+ * Describes a tremolo picking effect.
+ * @json
+ * @json_strict
+ * @cloneable
+ * @public
+ */
+class TremoloPickingEffect {
+    /**
+     * The minimum number of marks for the tremolo picking effect to be valid.
+     */
+    static minMarks = 0;
+    /**
+     * The max number of marks for the tremolo picking effect to be valid.
+     */
+    static maxMarks = 5;
+    /**
+     * The number of marks for the tremolo.
+     * A mark is equal to a single bar shown for a default tremolos.
+     */
+    marks = 0;
+    /**
+     * The style of the tremolo picking.
+     */
+    style = TremoloPickingStyle.Default;
+    /**
+     * The number of marks define the note value of the note repetition.
+     * e.g. a single mark is an 8th note.
+     */
+    get duration() {
+        let marks = this.marks;
+        if (marks < 1) {
+            marks = 1;
+        }
+        const baseDuration = Duration.Eighth;
+        const actualDuration = baseDuration * Math.pow(2, marks);
+        return actualDuration;
+    }
+}
+
 /**
  * Lists the different modes on how beaming for a beat should be done.
  * @public
@@ -7371,13 +7429,59 @@ class Beat {
      * Gets or sets the pickstroke applied on this beat.
      */
     pickStroke = PickStroke.None;
+    /**
+     * Whether this beat has a tremolo picking effect.
+     */
     get isTremolo() {
-        return !!this.tremoloSpeed;
+        return this.tremoloPicking !== undefined;
+    }
+    /**
+     * The tremolo picking effect.
+     */
+    tremoloPicking;
+    /**
+     * The speed of the tremolo.
+     * @deprecated Set {@link tremoloPicking} instead.
+     */
+    get tremoloSpeed() {
+        const tremolo = this.tremoloPicking;
+        if (tremolo) {
+            return tremolo.duration;
+        }
+        return null;
     }
     /**
-     * Gets or sets the speed of the tremolo effect.
+     * The speed of the tremolo.
+     * @deprecated Set {@link tremoloPicking} instead.
      */
-    tremoloSpeed = null;
+    set tremoloSpeed(value) {
+        if (value === null) {
+            this.tremoloPicking = undefined;
+            return;
+        }
+        let effect = this.tremoloPicking;
+        if (effect === undefined) {
+            effect = new TremoloPickingEffect();
+            this.tremoloPicking = effect;
+        }
+        switch (value) {
+            case Duration.Eighth:
+                effect.marks = 1;
+                break;
+            case Duration.Sixteenth:
+                effect.marks = 2;
+                break;
+            case Duration.ThirtySecond:
+                effect.marks = 3;
+                break;
+            case Duration.SixtyFourth:
+                effect.marks = 4;
+                break;
+            case Duration.OneHundredTwentyEighth:
+                effect.marks = 5;
+                break;
+        }
+    }
     /**
      * Gets or sets whether a crescendo/decrescendo is applied on this beat.
      */
@@ -7672,6 +7776,12 @@ class Beat {
         if (this.brushType === BrushType.None) {
             this.brushDuration = 0;
         }
+        const tremolo = this.tremoloPicking;
+        if (tremolo !== undefined) {
+            if (tremolo.marks < TremoloPickingEffect.minMarks || tremolo.marks > TremoloPickingEffect.maxMarks) {
+                this.tremoloPicking = undefined;
+            }
+        }
         const displayMode = !settings ? NotationMode.GuitarPro : settings.notation.notationMode;
         let isGradual = this.text === 'grad' || this.text === 'grad.';
         if (isGradual && displayMode === NotationMode.SongBook) {
@@ -8080,6 +8190,23 @@ class AutomationCloner {
     }
 }
 
+// <auto-generated>
+// This code was auto-generated.
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+// </auto-generated>
+/**
+ * @internal
+ */
+class TremoloPickingEffectCloner {
+    static clone(original) {
+        const clone = new TremoloPickingEffect();
+        clone.marks = original.marks;
+        clone.style = original.style;
+        return clone;
+    }
+}
+
 // <auto-generated>
 // This code was auto-generated.
 // Changes to this file may cause incorrect behavior and will be lost if
@@ -8132,7 +8259,7 @@ class BeatCloner {
         clone.chordId = original.chordId;
         clone.graceType = original.graceType;
         clone.pickStroke = original.pickStroke;
-        clone.tremoloSpeed = original.tremoloSpeed;
+        clone.tremoloPicking = original.tremoloPicking ? TremoloPickingEffectCloner.clone(original.tremoloPicking) : undefined;
         clone.crescendo = original.crescendo;
         clone.displayStart = original.displayStart;
         clone.playbackStart = original.playbackStart;
@@ -8515,6 +8642,11 @@ class AlphaTex1EnumMappings {
         ['dadoublecoda', 18]
     ]);
     static directionReversed = AlphaTex1EnumMappings._reverse(AlphaTex1EnumMappings.direction);
+    static tremoloPickingStyle = new Map([
+        ['default', 0],
+        ['buzzroll', 1]
+    ]);
+    static tremoloPickingStyleReversed = AlphaTex1EnumMappings._reverse(AlphaTex1EnumMappings.tremoloPickingStyle);
     static keySignaturesMinorReversed = new Map([
         [-7, 'abminor'],
         [-6, 'ebminor'],
@@ -9275,7 +9407,15 @@ class AlphaTex1LanguageDefinitions {
         ],
         ['volume', [[[[16], 0]]]],
         ['balance', [[[[16], 0]]]],
-        ['tp', [[[[16], 0, ['8', '16', '32']]]]],
+        [
+            'tp',
+            [
+                [
+                    [[16], 0],
+                    [[10, 17], 1, ['default', 'buzzroll']]
+                ]
+            ]
+        ],
         [
             'barre',
             [
@@ -15193,28 +15333,45 @@ class AlphaTex1LanguageHandler {
                 beat.automations.push(balanceAutomation);
                 return ApplyNodeResult.Applied;
             case 'tp':
-                beat.tremoloSpeed = Duration.Eighth;
+                const tremolo = new TremoloPickingEffect();
+                beat.tremoloPicking = tremolo;
                 if (p.arguments && p.arguments.arguments.length > 0) {
-                    const tremoloSpeedValue = p.arguments.arguments[0].value;
-                    switch (tremoloSpeedValue) {
-                        case 8:
-                            beat.tremoloSpeed = Duration.Eighth;
-                            break;
-                        case 16:
-                            beat.tremoloSpeed = Duration.Sixteenth;
-                            break;
-                        case 32:
-                            beat.tremoloSpeed = Duration.ThirtySecond;
-                            break;
-                        default:
-                            importer.addSemanticDiagnostic({
-                                code: AlphaTexDiagnosticCode.AT209,
-                                message: `Unexpected tremolo speed value '${tremoloSpeedValue}, expected: 8, 16 or 32`,
-                                severity: AlphaTexDiagnosticsSeverity.Error,
-                                start: p.arguments.arguments[0].start,
-                                end: p.arguments.arguments[0].end
-                            });
+                    if (p.arguments.arguments.length > 0) {
+                        const tremoloMarks = p.arguments.arguments[0].value;
+                        if (tremoloMarks >= TremoloPickingEffect.minMarks &&
+                            tremoloMarks <= TremoloPickingEffect.maxMarks) {
+                            tremolo.marks = tremoloMarks;
+                        }
+                        else {
+                            switch (tremoloMarks) {
+                                // backwards compatibility
+                                case 8:
+                                    tremolo.marks = 1;
+                                    break;
+                                case 16:
+                                    tremolo.marks = 2;
+                                    break;
+                                case 32:
+                                    tremolo.marks = 3;
+                                    break;
+                                default:
+                                    importer.addSemanticDiagnostic({
+                                        code: AlphaTexDiagnosticCode.AT209,
+                                        message: `Unexpected tremolo marks value '${tremoloMarks}, expected: ${TremoloPickingEffect.minMarks}-${TremoloPickingEffect.maxMarks}, or legacy: 8, 16 or 32`,
+                                        severity: AlphaTexDiagnosticsSeverity.Error,
+                                        start: p.arguments.arguments[0].start,
+                                        end: p.arguments.arguments[0].end
+                                    });
+                                    return ApplyNodeResult.NotAppliedSemanticError;
+                            }
+                        }
+                    }
+                    if (p.arguments.arguments.length > 1) {
+                        const tremoloStyle = AlphaTex1LanguageHandler._parseEnumValue(importer, p.arguments, 'tremolo picking style', AlphaTex1EnumMappings.tremoloPickingStyle, 1);
+                        if (tremoloStyle === undefined) {
                             return ApplyNodeResult.NotAppliedSemanticError;
+                        }
+                        tremolo.style = tremoloStyle;
                     }
                 }
                 return ApplyNodeResult.Applied;
@@ -16421,7 +16578,11 @@ class AlphaTex1LanguageHandler {
                 : Atnf.identValue(AlphaTex1EnumMappings.graceTypeReversed.get(beat.graceType)));
         }
         if (beat.isTremolo) {
-            Atnf.prop(properties, 'tp', Atnf.numberValue(beat.tremoloSpeed));
+            const values = [Atnf.number(beat.tremoloPicking.marks)];
+            if (beat.tremoloPicking.style !== TremoloPickingStyle.Default) {
+                values.push(Atnf.ident(TremoloPickingStyle[beat.tremoloPicking.style]));
+            }
+            Atnf.prop(properties, 'tp', Atnf.args(values));
         }
         switch (beat.crescendo) {
             case CrescendoType.Crescendo:
@@ -16822,9 +16983,6 @@ class AlphaTexImporter extends ScoreImporter {
         // even start translating when we have parser errors
         // as long we have some nodes, we can already start semantically
         // validating and using them
-        if (scoreNode.bars.length === 0) {
-            throw new UnsupportedFormatError('No alphaTex data found');
-        }
         this._bars(scoreNode);
         if (this.semanticDiagnostics.hasErrors) {
             if (this._state.hasAnyProperData) {
@@ -21445,18 +21603,9 @@ class Gp3To5Importer extends ScoreImporter {
         graceBeat.addNote(graceNote);
     }
     readTremoloPicking(beat) {
-        const speed = this.data.readByte();
-        switch (speed) {
-            case 1:
-                beat.tremoloSpeed = Duration.Eighth;
-                break;
-            case 2:
-                beat.tremoloSpeed = Duration.Sixteenth;
-                break;
-            case 3:
-                beat.tremoloSpeed = Duration.ThirtySecond;
-                break;
-        }
+        const effect = new TremoloPickingEffect();
+        beat.tremoloPicking = effect;
+        effect.marks = this.data.readByte();
     }
     readSlide(note) {
         if (this._versionNumber >= 500) {
@@ -23703,15 +23852,17 @@ class GpifParser {
                     }
                     break;
                 case 'Tremolo':
+                    const tremolo = new TremoloPickingEffect();
+                    beat.tremoloPicking = tremolo;
                     switch (c.innerText) {
                         case '1/2':
-                            beat.tremoloSpeed = Duration.Eighth;
+                            tremolo.marks = 1;
                             break;
                         case '1/4':
-                            beat.tremoloSpeed = Duration.Sixteenth;
+                            tremolo.marks = 2;
                             break;
                         case '1/8':
-                            beat.tremoloSpeed = Duration.ThirtySecond;
+                            tremolo.marks = 3;
                             break;
                     }
                     break;
@@ -28779,16 +28930,12 @@ class MusicXmlImporter extends ScoreImporter {
                     break;
                 // case 'schleifer': Not supported
                 case 'tremolo':
-                    switch (c.innerText) {
-                        case '1':
-                            note.beat.tremoloSpeed = Duration.Eighth;
-                            break;
-                        case '2':
-                            note.beat.tremoloSpeed = Duration.Sixteenth;
-                            break;
-                        case '3':
-                            note.beat.tremoloSpeed = Duration.ThirtySecond;
-                            break;
+                    const tremolo = new TremoloPickingEffect();
+                    note.beat.tremoloPicking = tremolo;
+                    tremolo.marks = Number.parseInt(c.innerText, 10);
+                    if ((c.getAttribute('type', '') === 'unmeasured' && tremolo.marks === 0) ||
+                        c.getAttribute('smufl', '') === 'buzzRoll') {
+                        tremolo.style = TremoloPickingStyle.BuzzRoll;
                     }
                     break;
                 // case 'haydn': Not supported
@@ -37899,6 +38046,38 @@ class NoteSerializer {
     }
 }
 
+/**
+ * @internal
+ */
+class TremoloPickingEffectSerializer {
+    static fromJson(obj, m) {
+        if (!m) {
+            return;
+        }
+        JsonHelper.forEach(m, (v, k) => TremoloPickingEffectSerializer.setProperty(obj, k, v));
+    }
+    static toJson(obj) {
+        if (!obj) {
+            return null;
+        }
+        const o = new Map();
+        o.set("marks", obj.marks);
+        o.set("style", obj.style);
+        return o;
+    }
+    static setProperty(obj, property, v) {
+        switch (property) {
+            case "marks":
+                obj.marks = v;
+                return true;
+            case "style":
+                obj.style = JsonHelper.parseEnum(v, TremoloPickingStyle);
+                return true;
+        }
+        return false;
+    }
+}
+
 /**
  * @internal
  */
@@ -37981,7 +38160,9 @@ class BeatSerializer {
         o.set("chordid", obj.chordId);
         o.set("gracetype", obj.graceType);
         o.set("pickstroke", obj.pickStroke);
-        o.set("tremolospeed", obj.tremoloSpeed);
+        if (obj.tremoloPicking) {
+            o.set("tremolopicking", TremoloPickingEffectSerializer.toJson(obj.tremoloPicking));
+        }
         o.set("crescendo", obj.crescendo);
         o.set("displaystart", obj.displayStart);
         o.set("playbackstart", obj.playbackStart);
@@ -38107,8 +38288,14 @@ class BeatSerializer {
             case "pickstroke":
                 obj.pickStroke = JsonHelper.parseEnum(v, PickStroke);
                 return true;
-            case "tremolospeed":
-                obj.tremoloSpeed = JsonHelper.parseEnum(v, Duration) ?? null;
+            case "tremolopicking":
+                if (v) {
+                    obj.tremoloPicking = new TremoloPickingEffect();
+                    TremoloPickingEffectSerializer.fromJson(obj.tremoloPicking, v);
+                }
+                else {
+                    obj.tremoloPicking = undefined;
+                }
                 return true;
             case "crescendo":
                 obj.crescendo = JsonHelper.parseEnum(v, CrescendoType);
@@ -39422,6 +39609,7 @@ class EngravingSettingsCloner {
         clone.tuningGlyphStringRowPadding = original.tuningGlyphStringRowPadding;
         clone.directionsScale = original.directionsScale;
         clone.multiVoiceDisplacedNoteHeadSpacing = original.multiVoiceDisplacedNoteHeadSpacing;
+        clone.stemFlagHeight = new Map(original.stemFlagHeight);
         return clone;
     }
 }
@@ -39733,6 +39921,20 @@ class EngravingSettings {
         this.stemFlagOffsets.set(Duration.SixtyFourth, 0);
         this.stemFlagOffsets.set(Duration.OneHundredTwentyEighth, 0);
         this.stemFlagOffsets.set(Duration.TwoHundredFiftySixth, 0);
+        // Workaround for: https://github.com/w3c/smufl/issues/203
+        // There is no clear anchor for the height of flags on the stem side yet.
+        // These aproximations are tested with bravura
+        this.stemFlagHeight.set(Duration.QuadrupleWhole, 0);
+        this.stemFlagHeight.set(Duration.DoubleWhole, 0);
+        this.stemFlagHeight.set(Duration.Whole, 0);
+        this.stemFlagHeight.set(Duration.Half, 0);
+        this.stemFlagHeight.set(Duration.Quarter, 0);
+        this.stemFlagHeight.set(Duration.Eighth, 1 * this.oneStaffSpace);
+        this.stemFlagHeight.set(Duration.Sixteenth, 1.5 * this.oneStaffSpace);
+        this.stemFlagHeight.set(Duration.ThirtySecond, 2 * this.oneStaffSpace);
+        this.stemFlagHeight.set(Duration.SixtyFourth, 3 * this.oneStaffSpace);
+        this.stemFlagHeight.set(Duration.OneHundredTwentyEighth, 3.5 * this.oneStaffSpace);
+        this.stemFlagHeight.set(Duration.TwoHundredFiftySixth, 4.2 * this.oneStaffSpace);
         for (const [g, v] of Object.entries(smufl.glyphsWithAnchors)) {
             const symbol = EngravingSettings._smuflNameToMusicFontSymbol(g);
             if (symbol) {
@@ -40079,6 +40281,19 @@ class EngravingSettings {
      * in case of multi-voice note head overlaps.
      */
     multiVoiceDisplacedNoteHeadSpacing = 0;
+    /**
+     * Calculates the stem height for a note of the given duration.
+     * @param duration The duration to calculate the height respecting flag sizes.
+     * @param hasFlag True if we need to respect flags, false if we have beams.
+     * @returns The total stem height
+     */
+    getStemLength(duration, hasFlag) {
+        return this.standardStemLength + (hasFlag ? this.stemFlagOffsets.get(duration) : 0);
+    }
+    /**
+     * The space needed by flags on the stem-side from top to bottom to place.
+     */
+    stemFlagHeight = new Map();
     // Idea: maybe we can encode and pack this large metadata into a more compact format (e.g. BSON or a custom binary blob?)
     // This metadata below is updated automatically from the bravura_metadata.json via npm script
     static bravuraMetadata = 
@@ -40211,6 +40426,10 @@ class EngravingSettings {
                 bBoxNE: [1.876, 1.18],
                 bBoxSW: [0, 0]
             },
+            buzzRoll: {
+                bBoxNE: [0.624, 0.464],
+                bBoxSW: [-0.62, -0.464]
+            },
             cClef: {
                 bBoxNE: [2.796, 2.024],
                 bBoxSW: [0, -2.024]
@@ -41167,6 +41386,14 @@ class EngravingSettings {
                 bBoxNE: [0.6, 1.112],
                 bBoxSW: [-0.6, -1.12]
             },
+            tremolo4: {
+                bBoxNE: [0.6, 1.496],
+                bBoxSW: [-0.6, -1.48]
+            },
+            tremolo5: {
+                bBoxNE: [0.6, 1.88],
+                bBoxSW: [-0.604, -1.84]
+            },
             tuplet0: {
                 bBoxNE: [1.2731041262817027, 1.5],
                 bBoxSW: [-0.001204330173715796, -0.032]
@@ -41814,6 +42041,13 @@ class EngravingSettingsSerializer {
         o.set("tuningglyphstringrowpadding", obj.tuningGlyphStringRowPadding);
         o.set("directionsscale", obj.directionsScale);
         o.set("multivoicedisplacednoteheadspacing", obj.multiVoiceDisplacedNoteHeadSpacing);
+        {
+            const m = new Map();
+            o.set("stemflagheight", m);
+            for (const [k, v] of obj.stemFlagHeight) {
+                m.set(k.toString(), v);
+            }
+        }
         return o;
     }
     static setProperty(obj, property, v) {
@@ -42095,6 +42329,12 @@ class EngravingSettingsSerializer {
             case "multivoicedisplacednoteheadspacing":
                 obj.multiVoiceDisplacedNoteHeadSpacing = v;
                 return true;
+            case "stemflagheight":
+                obj.stemFlagHeight = new Map();
+                JsonHelper.forEach(v, (v, k) => {
+                    obj.stemFlagHeight.set(JsonHelper.parseEnum(k, Duration), v);
+                });
+                return true;
         }
         return false;
     }
@@ -48316,7 +48556,12 @@ class MidiFileGenerator {
     }
     _generateTremoloPicking(note, noteStart, noteDuration, noteKey, dynamicValue, channel) {
         const track = note.beat.voice.bar.staff.track;
-        let tpLength = MidiUtils.toTicks(note.beat.tremoloSpeed);
+        const marks = note.beat.tremoloPicking.marks;
+        if (marks === 0) {
+            return;
+        }
+        // the marks represent the duration
+        let tpLength = MidiUtils.toTicks(note.beat.tremoloPicking.duration);
         let tick = noteStart;
         const end = noteStart + noteDuration.untilTieOrSlideEnd;
         while (tick + 10 < end) {
@@ -48742,6 +48987,12 @@ class BeatContainerGlyph extends BeatContainerGlyphBase {
     beat;
     preNotes;
     onNotes;
+    getLowestNoteY(requestedPosition) {
+        return this.onNotes.getLowestNoteY(requestedPosition);
+    }
+    getHighestNoteY(requestedPosition) {
+        return this.onNotes.getHighestNoteY(requestedPosition);
+    }
     get beatId() {
         return this.beat.id;
     }
@@ -48805,7 +49056,7 @@ class BeatContainerGlyph extends BeatContainerGlyphBase {
         return helper.hasFlag(false, undefined);
     }
     get postBeatStretch() {
-        return (this.onNotes.computedWidth + this._tieWidth) - this.onNotes.onTimeX;
+        return this.onNotes.computedWidth + this._tieWidth - this.onNotes.onTimeX;
     }
     registerLayoutingInfo(layoutings) {
         const preBeatStretch = this.preNotes.computedWidth + this.onNotes.onTimeX;
@@ -60015,16 +60266,22 @@ class EffectBandContainer {
             return false;
         }
         let y = 0;
+        // TODO. activate padding
+        // const paddingTop = this._isTopContainer ? 0 : this._renderer.settings.display.effectBandPaddingBottom;
+        // const paddingBottom = this._isTopContainer ? this._renderer.settings.display.effectBandPaddingBottom : 0;
+        const paddingTop = 0;
+        const paddingBottom = this._renderer.settings.display.effectBandPaddingBottom;
         for (const slot of this._effectBandSizingInfo.slots) {
             slot.shared.y = y;
             for (const band of slot.bands) {
+                y += paddingTop;
                 band.y = y;
                 if (finalize) {
                     band.finalizeBand();
                 }
                 band.height = slot.shared.height;
             }
-            y += slot.shared.height + this._renderer.settings.display.effectBandPaddingBottom;
+            y += slot.shared.height + paddingBottom;
         }
         y = Math.ceil(y);
         if (y !== this.height) {
@@ -60254,6 +60511,20 @@ class MultiVoiceContainerGlyph extends Glyph {
         }
         return 0;
     }
+    getLowestNoteY(beat, position) {
+        const container = this.getBeatContainer(beat);
+        if (container) {
+            return container.y + container.getLowestNoteY(position);
+        }
+        return 0;
+    }
+    getHighestNoteY(beat, position) {
+        const container = this.getBeatContainer(beat);
+        if (container) {
+            return container.y + container.getHighestNoteY(position);
+        }
+        return 0;
+    }
     getNoteX(note, requestedPosition) {
         const container = this.getBeatContainer(note.beat);
         if (container) {
@@ -60266,14 +60537,14 @@ class MultiVoiceContainerGlyph extends Glyph {
         if (beat) {
             return beat.y + beat.getNoteY(note, requestedPosition);
         }
-        return Number.NaN;
+        return 0;
     }
     getRestY(beat, requestedPosition) {
         const container = this.getBeatContainer(beat);
         if (container) {
             return container.y + container.getRestY(requestedPosition);
         }
-        return Number.NaN;
+        return 0;
     }
     getBeatContainer(beat) {
         if (!this._beatGlyphLookup.has(beat.id)) {
@@ -60943,16 +61214,18 @@ class MultiBarRestBeatContainerGlyph extends BeatContainerGlyphBase {
         const g = this._glyph;
         if (g) {
             switch (requestedPosition) {
-                case NoteYPosition.TopWithStem:
                 case NoteYPosition.Top:
                     return g.y;
+                case NoteYPosition.TopWithStem:
+                    return g.y - this.renderer.smuflMetrics.getStemLength(Duration.Quarter, true);
                 case NoteYPosition.Center:
                 case NoteYPosition.StemUp:
                 case NoteYPosition.StemDown:
                     return g.y + g.height / 2;
                 case NoteYPosition.Bottom:
-                case NoteYPosition.BottomWithStem:
                     return g.y + g.height;
+                case NoteYPosition.BottomWithStem:
+                    return g.y + g.height + this.renderer.smuflMetrics.getStemLength(Duration.Quarter, true);
             }
         }
         return 0;
@@ -60960,6 +61233,12 @@ class MultiBarRestBeatContainerGlyph extends BeatContainerGlyphBase {
     getNoteY(_note, requestedPosition) {
         return this.getRestY(requestedPosition);
     }
+    getHighestNoteY(position) {
+        return this.getRestY(position);
+    }
+    getLowestNoteY(position) {
+        return this.getRestY(position);
+    }
     getNoteX(_note, requestedPosition) {
         const g = this._glyph;
         if (g) {
@@ -61054,7 +61333,6 @@ class BeamingHelper {
     voice = null;
     beats = [];
     shortestDuration = Duration.QuadrupleWhole;
-    tremoloDuration;
     /**
      * an indicator whether any beat has a tuplet on it.
      */
@@ -61097,43 +61375,9 @@ class BeamingHelper {
             this.drawingInfos.clear();
         }
     }
-    direction = BeamDirection.Up;
     finish() {
-        this.direction = this._calculateDirection();
         this._renderer.completeBeamingHelper(this);
     }
-    _calculateDirection() {
-        // no proper voice (should not happen usually)
-        if (!this.voice) {
-            return BeamDirection.Up;
-        }
-        // we have a preferred direction
-        if (this.preferredBeamDirection !== null) {
-            return this.preferredBeamDirection;
-        }
-        // on multi-voice setups secondary voices are always down
-        if (this.voice.index > 0) {
-            return this._invert(BeamDirection.Down);
-        }
-        // on multi-voice setups primary voices are always up
-        if (this.voice.bar.isMultiVoice) {
-            return this._invert(BeamDirection.Up);
-        }
-        // grace notes are always up
-        if (this.beats[0].graceType !== GraceType.None) {
-            return this._invert(BeamDirection.Up);
-        }
-        // the average line is used for determination
-        //      key lowerequal than middle line -> up
-        //      key higher than middle line -> down
-        if (this.highestNoteInHelper && this.lowestNoteInHelper) {
-            const highestNotePosition = this._renderer.getNoteY(this.highestNoteInHelper, NoteYPosition.Center);
-            const lowestNotePosition = this._renderer.getNoteY(this.lowestNoteInHelper, NoteYPosition.Center);
-            const avg = (highestNotePosition + lowestNotePosition) / 2;
-            return this._invert(this._renderer.middleYPosition < avg ? BeamDirection.Up : BeamDirection.Down);
-        }
-        return this._invert(BeamDirection.Up);
-    }
     static computeLineHeightsForRest(duration) {
         switch (duration) {
             case Duration.QuadrupleWhole:
@@ -61161,18 +61405,6 @@ class BeamingHelper {
         }
         return [0, 0];
     }
-    _invert(direction) {
-        if (!this.invertBeamDirection) {
-            return direction;
-        }
-        switch (direction) {
-            case BeamDirection.Down:
-                return BeamDirection.Up;
-            // case BeamDirection.Up:
-            default:
-                return BeamDirection.Down;
-        }
-    }
     checkBeat(beat) {
         if (beat.invertBeamDirection) {
             this.invertBeamDirection = true;
@@ -61206,11 +61438,6 @@ class BeamingHelper {
             if (beat.hasTuplet) {
                 this.hasTuplet = true;
             }
-            if (beat.isTremolo) {
-                if (!this.tremoloDuration || this.tremoloDuration < beat.tremoloSpeed) {
-                    this.tremoloDuration = beat.tremoloSpeed;
-                }
-            }
             if (beat.graceType !== GraceType.None) {
                 this.graceType = beat.graceType;
             }
@@ -62109,9 +62336,6 @@ class BarRendererBase {
     }
     completeBeamingHelper(_helper) {
     }
-    getBeatDirection(beat) {
-        return this.helpers.getBeamingHelperForBeat(beat)?.direction ?? BeamDirection.Up;
-    }
 }
 
 /**
@@ -67194,11 +67418,11 @@ class NumberedBeatGlyph extends BeatOnNoteGlyphBase {
             beatBounds.addNote(noteBounds);
         }
     }
-    getLowestNoteY() {
-        return this._internalGetNoteY(NoteYPosition.Center);
+    getLowestNoteY(requestedPosition) {
+        return this._internalGetNoteY(requestedPosition);
     }
-    getHighestNoteY() {
-        return this._internalGetNoteY(NoteYPosition.Center);
+    getHighestNoteY(requestedPosition) {
+        return this._internalGetNoteY(requestedPosition);
     }
     getNoteY(_note, requestedPosition) {
         return this._internalGetNoteY(requestedPosition);
@@ -67647,6 +67871,12 @@ class NumberedDashBeatContainerGlyph extends BeatContainerGlyphBase {
     get isLastOfVoice() {
         return false;
     }
+    getLowestNoteY(_requestedPosition) {
+        return 0;
+    }
+    getHighestNoteY(_requestedPosition) {
+        return 0;
+    }
     getNoteY(_note, _requestedPosition) {
         return 0;
     }
@@ -67798,6 +68028,11 @@ class FlagGlyph extends MusicFontGlyph {
     constructor(x, y, duration, direction, isGrace) {
         super(x, y, isGrace ? EngravingSettings.GraceScale : 1, FlagGlyph.getSymbol(duration, direction, isGrace));
     }
+    paint(cx, cy, canvas) {
+        const c = canvas.color;
+        super.paint(cx, cy, canvas);
+        canvas.color = c;
+    }
     static getSymbol(duration, direction, isGrace) {
         if (isGrace) {
             duration = Duration.Eighth;
@@ -68002,9 +68237,17 @@ class LineBarRenderer extends BarRendererBase {
             }
         }
     }
+    getBeatDirection(beat) {
+        const helper = this.helpers.getBeamingHelperForBeat(beat);
+        return helper ? this.getBeamDirection(helper) : BeamDirection.Up;
+    }
     getTupletBeamDirection(helper) {
         return this.getBeamDirection(helper);
     }
+    calculateBeamYWithDirection(h, x, direction) {
+        this.ensureBeamDrawingInfo(h, direction);
+        return h.drawingInfos.get(direction).calcY(x);
+    }
     _paintTupletHelper(cx, cy, canvas, h, beatElement, bracketsAsArcs) {
         const res = this.resources;
         const oldAlign = canvas.textAlign;
@@ -68313,26 +68556,6 @@ class LineBarRenderer extends BarRendererBase {
             }
         }
     }
-    getFlagStemSize(duration, forceMinStem = false) {
-        let size = 0;
-        switch (duration) {
-            case Duration.QuadrupleWhole:
-            case Duration.Half:
-            case Duration.Quarter:
-            case Duration.Eighth:
-            case Duration.Sixteenth:
-            case Duration.ThirtySecond:
-            case Duration.SixtyFourth:
-            case Duration.OneHundredTwentyEighth:
-            case Duration.TwoHundredFiftySixth:
-                size = this.smuflMetrics.standardStemLength + this.smuflMetrics.stemFlagOffsets.get(duration);
-                break;
-            default:
-                size = forceMinStem ? this.smuflMetrics.standardStemLength : 0;
-                break;
-        }
-        return size;
-    }
     recreatePreBeatGlyphs() {
         this._startSpacing = false;
         super.recreatePreBeatGlyphs();
@@ -68344,6 +68567,9 @@ class LineBarRenderer extends BarRendererBase {
         super.createPreBeatGlyphs();
         this.addPreBeatGlyph(new BarLineGlyph(false, this.bar.staff.track.score.stylesheet.extendBarLines));
         this.createLinePreBeatGlyphs();
+        if (this.index === 0) {
+            this.createStartSpacing();
+        }
         this.addPreBeatGlyph(new BarNumberGlyph(0, this.getLineHeight(-0.5), this.bar.index + 1));
     }
     createPostBeatGlyphs() {
@@ -68370,7 +68596,13 @@ class LineBarRenderer extends BarRendererBase {
                 continue;
             }
             const beatLineX = this.getBeatX(beat, BeatXPosition.Stem);
-            const y1 = cy + this.y + this.getBarLineStart(beat, direction);
+            let y1 = cy + this.y;
+            if (direction === BeamDirection.Up) {
+                y1 += this.getFlagBottomY(beat, direction);
+            }
+            else {
+                y1 += this.getFlagTopY(beat, direction);
+            }
             // ensure we are pixel aligned on the end of the stem to avoid anti-aliasing artifacts
             // when combining stems and beams on sub-pixel level
             const y2 = (cy + this.y + this.calculateBeamY(h, beatLineX)) | 0;
@@ -68476,21 +68708,22 @@ class LineBarRenderer extends BarRendererBase {
     calculateBeamingOverflows(rendererTop, rendererBottom) {
         let maxNoteY = 0;
         let minNoteY = 0;
-        const noteOverflowPadding = this.getLineHeight(0.5);
         for (const v of this.helpers.beamHelpers) {
             for (const h of v) {
                 if (!this.shouldPaintBeamingHelper(h)) ;
                 else if (h.beats.length === 1 && h.beats[0].duration >= Duration.Half) {
                     const tupletDirection = this.getTupletBeamDirection(h);
-                    if (h.direction === BeamDirection.Up) {
-                        let topY = this.getFlagTopY(h.beats[0], h.direction);
-                        if (h.hasTuplet && tupletDirection === h.direction) {
+                    const direction = this.getBeamDirection(h);
+                    const flagOverflow = this.smuflMetrics.stemFlagOffsets.get(h.beats[0].duration);
+                    if (direction === BeamDirection.Up) {
+                        let topY = this.getFlagTopY(h.beats[0], direction) - flagOverflow;
+                        if (h.hasTuplet && tupletDirection === direction) {
                             topY -= this.tupletSize + this.tupletOffset;
                         }
                         if (topY < maxNoteY) {
                             maxNoteY = topY;
                         }
-                        if (h.hasTuplet && tupletDirection !== h.direction) {
+                        if (h.hasTuplet && tupletDirection !== direction) {
                             let bottomY = this.getFlagBottomY(h.beats[0], tupletDirection);
                             bottomY += this.tupletSize + this.tupletOffset;
                             if (bottomY > minNoteY) {
@@ -68499,14 +68732,14 @@ class LineBarRenderer extends BarRendererBase {
                         }
                     }
                     else {
-                        let bottomY = this.getFlagBottomY(h.beats[0], h.direction);
-                        if (h.hasTuplet && tupletDirection === h.direction) {
+                        let bottomY = this.getFlagBottomY(h.beats[0], direction) + flagOverflow;
+                        if (h.hasTuplet && tupletDirection === direction) {
                             bottomY += this.tupletSize + this.tupletOffset;
                         }
                         if (bottomY > minNoteY) {
                             minNoteY = bottomY;
                         }
-                        if (h.hasTuplet && tupletDirection !== h.direction) {
+                        if (h.hasTuplet && tupletDirection !== direction) {
                             let topY = this.getFlagTopY(h.beats[0], tupletDirection);
                             topY -= this.tupletSize + this.tupletOffset;
                             if (topY < maxNoteY) {
@@ -68516,19 +68749,20 @@ class LineBarRenderer extends BarRendererBase {
                     }
                 }
                 else {
-                    this.ensureBeamDrawingInfo(h, h.direction);
-                    const drawingInfo = h.drawingInfos.get(h.direction);
+                    const direction = this.getBeamDirection(h);
+                    this.ensureBeamDrawingInfo(h, direction);
+                    const drawingInfo = h.drawingInfos.get(direction);
                     const tupletDirection = this.getTupletBeamDirection(h);
-                    if (h.direction === BeamDirection.Up) {
+                    if (direction === BeamDirection.Up) {
                         let topY = Math.min(drawingInfo.startY, drawingInfo.endY);
-                        if (h.hasTuplet && tupletDirection === h.direction) {
+                        if (h.hasTuplet && tupletDirection === direction) {
                             topY -= this.tupletSize + this.tupletOffset;
                         }
                         if (topY < maxNoteY) {
                             maxNoteY = topY;
                         }
-                        let bottomY = this.getBarLineStart(h.beatOfLowestNote, h.direction) + noteOverflowPadding;
-                        if (h.hasTuplet && tupletDirection !== h.direction) {
+                        let bottomY = this.voiceContainer.getLowestNoteY(h.beatOfLowestNote, NoteYPosition.Bottom);
+                        if (h.hasTuplet && tupletDirection !== direction) {
                             bottomY += this.tupletSize + this.tupletOffset;
                         }
                         if (bottomY > minNoteY) {
@@ -68537,14 +68771,14 @@ class LineBarRenderer extends BarRendererBase {
                     }
                     else {
                         let bottomY = Math.max(drawingInfo.startY, drawingInfo.endY);
-                        if (h.hasTuplet && tupletDirection === h.direction) {
+                        if (h.hasTuplet && tupletDirection === direction) {
                             bottomY += this.tupletSize + this.tupletOffset;
                         }
                         if (bottomY > minNoteY) {
                             minNoteY = bottomY;
                         }
-                        let topY = this.getBarLineStart(h.beatOfHighestNote, h.direction) - noteOverflowPadding;
-                        if (h.hasTuplet && tupletDirection !== h.direction) {
+                        let topY = this.voiceContainer.getHighestNoteY(h.beatOfHighestNote, NoteYPosition.Top);
+                        if (h.hasTuplet && tupletDirection !== direction) {
                             topY -= this.tupletSize + this.tupletOffset;
                         }
                         if (topY < maxNoteY) {
@@ -68621,38 +68855,11 @@ class LineBarRenderer extends BarRendererBase {
         // 3. any middle elements (notes or rests) shift this diagonal line up/down to avoid overlaps
         const drawingInfo = this.initializeBeamDrawingInfo(h, direction);
         h.drawingInfos.set(direction, drawingInfo);
-        const isRest = h.isRestBeamHelper;
-        const scale = h.graceType !== GraceType.None ? EngravingSettings.GraceScale : 1;
         const barCount = ModelUtils.getIndex(h.shortestDuration) - 2;
         // 3. adjust beam drawing order
         // we can only draw up to 2 beams towards the noteheads, then we have to grow to the other side
         // here we shift accordingly
-        let barDrawingShift = 0;
-        if (barCount > 2 && !isRest) {
-            const beamSpacing = this.beamSpacing * scale;
-            const beamThickness = this.beamThickness * scale;
-            const totalBarsHeight = barCount * beamThickness + (barCount - 1) * beamSpacing;
-            if (direction === BeamDirection.Up) {
-                const bottomBarY = drawingInfo.startY + 2 * beamThickness + beamSpacing;
-                const barTopY = bottomBarY - totalBarsHeight;
-                const diff = drawingInfo.startY - barTopY;
-                if (diff > 0) {
-                    barDrawingShift = diff * -1;
-                    drawingInfo.startY -= diff;
-                    drawingInfo.endY -= diff;
-                }
-            }
-            else {
-                const topBarY = drawingInfo.startY - 2 * beamThickness + beamSpacing;
-                const barBottomY = topBarY + totalBarsHeight;
-                const diff = barBottomY - drawingInfo.startY;
-                if (diff > 0) {
-                    barDrawingShift = diff;
-                    drawingInfo.startY += diff;
-                    drawingInfo.endY += diff;
-                }
-            }
-        }
+        const barDrawingShift = this.applyBarShift(h, direction, drawingInfo, barCount);
         // 4. let middle elements shift up/down
         if (h.beats.length > 1) {
             // check if highest note shifts bar up or down
@@ -68708,9 +68915,9 @@ class LineBarRenderer extends BarRendererBase {
             if (h.slashBeats.length > 0) {
                 for (const b of h.slashBeats) {
                     const yGivenByCurrentValues = drawingInfo.calcY(this.getBeatX(b, BeatXPosition.Stem));
-                    const yNeededForSlash = h.direction === BeamDirection.Up
-                        ? this.getFlagTopY(b, h.direction)
-                        : this.getFlagBottomY(b, h.direction);
+                    const yNeededForSlash = direction === BeamDirection.Up
+                        ? this.getFlagTopY(b, direction)
+                        : this.getFlagBottomY(b, direction);
                     const diff = yNeededForSlash - yGivenByCurrentValues;
                     if (diff > 0) {
                         drawingInfo.startY += diff;
@@ -68720,6 +68927,37 @@ class LineBarRenderer extends BarRendererBase {
             }
         }
     }
+    applyBarShift(h, direction, drawingInfo, barCount) {
+        let barDrawingShift = 0;
+        const isRest = h.isRestBeamHelper;
+        const scale = h.graceType !== GraceType.None ? EngravingSettings.GraceScale : 1;
+        if (barCount > 2 && !isRest) {
+            const beamSpacing = this.beamSpacing * scale;
+            const beamThickness = this.beamThickness * scale;
+            const totalBarsHeight = barCount * beamThickness + (barCount - 1) * beamSpacing;
+            if (direction === BeamDirection.Up) {
+                const bottomBarY = drawingInfo.startY + 2 * beamThickness + beamSpacing;
+                const barTopY = bottomBarY - totalBarsHeight;
+                const diff = drawingInfo.startY - barTopY;
+                if (diff > 0) {
+                    barDrawingShift = diff * -1;
+                    drawingInfo.startY -= diff;
+                    drawingInfo.endY -= diff;
+                }
+            }
+            else {
+                const topBarY = drawingInfo.startY - 2 * beamThickness + beamSpacing;
+                const barBottomY = topBarY + totalBarsHeight;
+                const diff = barBottomY - drawingInfo.startY;
+                if (diff > 0) {
+                    barDrawingShift = diff;
+                    drawingInfo.startY += diff;
+                    drawingInfo.endY += diff;
+                }
+            }
+        }
+        return barDrawingShift;
+    }
     getMinLineOfBeat(_beat) {
         return 0;
     }
@@ -68823,7 +69061,9 @@ class NumberedBarRenderer extends LineBarRenderer {
                     for (const additionalNumber of container.iterateAdditionalNumbers()) {
                         barCount = additionalNumber.barCount;
                         beatLineX =
-                            this.beatGlyphsStart + additionalNumber.x + additionalNumber.getBeatX(BeatXPosition.PreNotes, false);
+                            this.beatGlyphsStart +
+                                additionalNumber.x +
+                                additionalNumber.getBeatX(BeatXPosition.PreNotes, false);
                         for (let barIndex = 0; barIndex < barCount; barIndex++) {
                             const barY = barStart + barIndex * barSpacing;
                             const additionalBarEndX = this.beatGlyphsStart +
@@ -68888,44 +69128,12 @@ class NumberedBarRenderer extends LineBarRenderer {
         }
         return this.getLineY(0);
     }
-    completeBeamingHelper(helper) {
-        super.completeBeamingHelper(helper);
-        helper.direction = BeamDirection.Down;
-    }
     getBeamDirection(_helper) {
         return BeamDirection.Down;
     }
     getTupletBeamDirection(_helper) {
         return BeamDirection.Up;
     }
-    getNoteY(note, requestedPosition) {
-        let y = super.getNoteY(note, requestedPosition);
-        if (Number.isNaN(y)) {
-            y = this.getLineY(0);
-        }
-        return y;
-    }
-    calculateBeamYWithDirection(h, _x, direction) {
-        if (h.beats.length === 0) {
-            return this.getLineY(0);
-        }
-        this.ensureBeamDrawingInfo(h, direction);
-        const info = h.drawingInfos.get(direction);
-        if (direction === BeamDirection.Up) {
-            return Math.min(info.startY, info.endY);
-        }
-        else {
-            return Math.max(info.startY, info.endY);
-        }
-    }
-    getBarLineStart(beat, _direction) {
-        // NOTE: this is only for the overflow calculation, this renderer has a custom bar drawing logic
-        const container = this.voiceContainer.getBeatContainer(beat);
-        if (!container) {
-            return this.voiceContainer.getBoundingBoxTop();
-        }
-        return container.getBoundingBoxTop();
-    }
     createPreBeatGlyphs() {
         this.wasFirstOfStaff = this.isFirstOfStaff;
         if (this.index === 0 || (this.bar.masterBar.isRepeatStart && this._isOnlyNumbered)) {
@@ -69008,6 +69216,19 @@ class NumberedBarRenderer extends LineBarRenderer {
             super.paintBeamHelper(cx, cy, canvas, h, flagsElement, beamsElement);
         }
     }
+    applyBarShift(_h, _direction, _drawingInfo, _barCount) {
+        return 0;
+    }
+    calculateBeamYWithDirection(h, _x, direction) {
+        this.ensureBeamDrawingInfo(h, direction);
+        const info = h.drawingInfos.get(direction);
+        if (direction === BeamDirection.Up) {
+            return Math.min(info.startY, info.endY);
+        }
+        else {
+            return Math.max(info.startY, info.endY);
+        }
+    }
 }
 
 /**
@@ -69176,132 +69397,6 @@ class KeySignatureGlyph extends LeftToRightLayoutingGlyphGroup {
     }
 }
 
-/**
- * @internal
- */
-class NoteHeadGlyphBase extends MusicFontGlyph {
-    centerOnStem = false;
-    constructor(x, y, isGrace, symbol) {
-        super(x, y, isGrace ? EngravingSettings.GraceScale : 1, symbol);
-    }
-    paint(cx, cy, canvas) {
-        if (this.centerOnStem) {
-            this.center = true;
-        }
-        super.paint(cx, cy, canvas);
-    }
-}
-/**
- * @internal
- */
-class NoteHeadGlyph extends NoteHeadGlyphBase {
-    constructor(x, y, duration, isGrace) {
-        super(x, y, isGrace, NoteHeadGlyph.getSymbol(duration));
-    }
-    static getSymbol(duration) {
-        switch (duration) {
-            case Duration.QuadrupleWhole:
-                return MusicFontSymbol.NoteheadDoubleWholeSquare;
-            case Duration.DoubleWhole:
-                return MusicFontSymbol.NoteheadDoubleWhole;
-            case Duration.Whole:
-                return MusicFontSymbol.NoteheadWhole;
-            case Duration.Half:
-                return MusicFontSymbol.NoteheadHalf;
-            default:
-                return MusicFontSymbol.NoteheadBlack;
-        }
-    }
-}
-
-/**
- * @internal
- */
-class SlashNoteHeadGlyph extends NoteHeadGlyphBase {
-    beatEffects = new Map();
-    noteHeadElement = NoteSubElement.SlashNoteHead;
-    effectElement = BeatSubElement.SlashEffects;
-    _symbol;
-    stemX = 0;
-    constructor(x, y, duration, isGrace, beat) {
-        super(x, y, isGrace, SlashNoteHeadGlyph.getSymbol(duration));
-        this._symbol = SlashNoteHeadGlyph.getSymbol(duration);
-        this.beat = beat;
-    }
-    paint(cx, cy, canvas) {
-        const _ = this.beat.notes.length === 0
-            ? undefined
-            : ElementStyleHelper.note(canvas, this.noteHeadElement, this.beat.notes[0]);
-        try {
-            super.paint(cx, cy, canvas);
-            this._paintEffects(cx, cy, canvas);
-        }
-        finally {
-            _?.[Symbol.dispose]?.();
-        }
-    }
-    _paintEffects(cx, cy, canvas) {
-        const _ = ElementStyleHelper.beat(canvas, this.effectElement, this.beat);
-        try {
-            for (const g of this.beatEffects.values()) {
-                g.paint(cx + this.x, cy + this.y, canvas);
-            }
-        }
-        finally {
-            _?.[Symbol.dispose]?.();
-        }
-    }
-    doLayout() {
-        super.doLayout();
-        const effectSpacing = this.renderer.smuflMetrics.onNoteEffectPadding;
-        let effectY = this.renderer.smuflMetrics.glyphHeights.get(this._symbol);
-        let minEffectY = Number.NaN;
-        let maxEffectY = Number.NaN;
-        for (const g of this.beatEffects.values()) {
-            g.y += effectY;
-            g.x += this.width / 2;
-            g.renderer = this.renderer;
-            effectY += g.height + effectSpacing;
-            g.doLayout();
-            if (Number.isNaN(minEffectY) || minEffectY > effectY) {
-                minEffectY = effectY;
-            }
-            if (Number.isNaN(maxEffectY) || maxEffectY < effectY) {
-                maxEffectY = effectY;
-            }
-        }
-        if (!Number.isNaN(minEffectY)) {
-            this.renderer.registerBeatEffectOverflows(minEffectY, maxEffectY);
-        }
-        const direction = this.renderer.getBeatDirection(this.beat);
-        const symbol = this._symbol;
-        if (direction === BeamDirection.Up) {
-            const stemInfoUp = this.renderer.smuflMetrics.stemUp.has(symbol)
-                ? this.renderer.smuflMetrics.stemUp.get(symbol).x
-                : 0;
-            this.stemX = stemInfoUp;
-        }
-        else {
-            const stemInfoDown = this.renderer.smuflMetrics.stemDown.has(symbol)
-                ? this.renderer.smuflMetrics.stemDown.get(symbol).x
-                : 0;
-            this.stemX = stemInfoDown;
-        }
-    }
-    static getSymbol(duration) {
-        switch (duration) {
-            case Duration.QuadrupleWhole:
-            case Duration.DoubleWhole:
-            case Duration.Whole:
-                return MusicFontSymbol.NoteheadSlashWhiteWhole;
-            case Duration.Half:
-                return MusicFontSymbol.NoteheadSlashWhiteHalf;
-            default:
-                return MusicFontSymbol.NoteheadSlashHorizontalEnds;
-        }
-    }
-}
-
 /**
  * @internal
  */
@@ -69351,6 +69446,44 @@ class ArticStaccatoAboveGlyph extends MusicFontGlyph {
     }
 }
 
+/**
+ * @internal
+ */
+class NoteHeadGlyphBase extends MusicFontGlyph {
+    centerOnStem = false;
+    constructor(x, y, isGrace, symbol) {
+        super(x, y, isGrace ? EngravingSettings.GraceScale : 1, symbol);
+    }
+    paint(cx, cy, canvas) {
+        if (this.centerOnStem) {
+            this.center = true;
+        }
+        super.paint(cx, cy, canvas);
+    }
+}
+/**
+ * @internal
+ */
+class NoteHeadGlyph extends NoteHeadGlyphBase {
+    constructor(x, y, duration, isGrace) {
+        super(x, y, isGrace, NoteHeadGlyph.getSymbol(duration));
+    }
+    static getSymbol(duration) {
+        switch (duration) {
+            case Duration.QuadrupleWhole:
+                return MusicFontSymbol.NoteheadDoubleWholeSquare;
+            case Duration.DoubleWhole:
+                return MusicFontSymbol.NoteheadDoubleWhole;
+            case Duration.Whole:
+                return MusicFontSymbol.NoteheadWhole;
+            case Duration.Half:
+                return MusicFontSymbol.NoteheadHalf;
+            default:
+                return MusicFontSymbol.NoteheadBlack;
+        }
+    }
+}
+
 /**
  * @internal
  */
@@ -69714,8 +69847,8 @@ class ScoreNoteChordGlyphBase extends Glyph {
     _infos = [];
     _noteHeadInfo;
     noteGroup;
-    minNote = null;
-    maxNote = null;
+    minStepsNote = null;
+    maxStepsNote = null;
     get stemX() {
         if (!this.noteGroup) {
             return 0;
@@ -69728,25 +69861,19 @@ class ScoreNoteChordGlyphBase extends Glyph {
         super(0, 0);
     }
     getBoundingBoxTop() {
-        return this.minNote ? this.minNote.glyph.getBoundingBoxTop() : this.y;
+        return this.minStepsNote ? this.minStepsNote.glyph.getBoundingBoxTop() : this.y;
     }
     getBoundingBoxBottom() {
-        return this.maxNote ? this.maxNote.glyph.getBoundingBoxBottom() : this.y + this.height;
-    }
-    getLowestNoteY() {
-        return this.maxNote ? this.renderer.getScoreY(this.maxNote.steps) : 0;
-    }
-    getHighestNoteY() {
-        return this.minNote ? this.renderer.getScoreY(this.minNote.steps) : 0;
+        return this.maxStepsNote ? this.maxStepsNote.glyph.getBoundingBoxBottom() : this.y + this.height;
     }
     add(noteGlyph, noteSteps) {
         const info = { glyph: noteGlyph, steps: noteSteps };
         this._infos.push(info);
-        if (!this.minNote || this.minNote.steps > info.steps) {
-            this.minNote = info;
+        if (!this.minStepsNote || this.minStepsNote.steps > info.steps) {
+            this.minStepsNote = info;
         }
-        if (!this.maxNote || this.maxNote.steps < info.steps) {
-            this.maxNote = info;
+        if (!this.maxStepsNote || this.maxStepsNote.steps < info.steps) {
+            this.maxStepsNote = info;
         }
     }
     _prepareForLayout(info) {
@@ -69982,7 +70109,7 @@ class ScoreNoteChordGlyphBase extends Glyph {
         }
     }
     _paintLedgerLines(cx, cy, canvas) {
-        if (!this.minNote) {
+        if (!this.minStepsNote) {
             return;
         }
         const scoreRenderer = this.renderer;
@@ -69994,8 +70121,8 @@ class ScoreNoteChordGlyphBase extends Glyph {
             const lineSpacing = scoreRenderer.getLineHeight(1);
             const firstTopLedgerY = scoreRenderer.getLineY(-1);
             const firstBottomLedgerY = scoreRenderer.getLineY(scoreRenderer.drawnLineCount);
-            const minNoteLineY = scoreRenderer.getLineY(this.minNote.steps / 2);
-            const maxNoteLineY = scoreRenderer.getLineY(this.maxNote.steps / 2);
+            const minNoteLineY = scoreRenderer.getLineY(this.minStepsNote.steps / 2);
+            const maxNoteLineY = scoreRenderer.getLineY(this.maxStepsNote.steps / 2);
             const lineYOffset = (this.renderer.smuflMetrics.legerLineThickness * scale) / 2;
             let y = firstTopLedgerY;
             while (y >= minNoteLineY) {
@@ -70018,21 +70145,87 @@ class ScoreNoteChordGlyphBase extends Glyph {
  * @internal
  */
 class TremoloPickingGlyph extends MusicFontGlyph {
-    constructor(x, y, duration) {
-        super(x, y, 1, TremoloPickingGlyph._getSymbol(duration));
+    constructor(x, y, effect) {
+        super(x, y, 1, TremoloPickingGlyph._getSymbol(effect));
     }
-    static _getSymbol(duration) {
-        switch (duration) {
-            case Duration.ThirtySecond:
-                return MusicFontSymbol.Tremolo3;
-            case Duration.Sixteenth:
-                return MusicFontSymbol.Tremolo2;
-            case Duration.Eighth:
-                return MusicFontSymbol.Tremolo1;
-            default:
-                return MusicFontSymbol.None;
+    static _getSymbol(effect) {
+        if (effect.style === TremoloPickingStyle.BuzzRoll) {
+            return MusicFontSymbol.BuzzRoll;
+        }
+        else {
+            switch (effect.marks) {
+                case 1:
+                    return MusicFontSymbol.Tremolo1;
+                case 2:
+                    return MusicFontSymbol.Tremolo2;
+                case 3:
+                    return MusicFontSymbol.Tremolo3;
+                case 4:
+                    return MusicFontSymbol.Tremolo4;
+                case 5:
+                    return MusicFontSymbol.Tremolo5;
+                default:
+                    return MusicFontSymbol.None;
+            }
         }
     }
+    stemExtensionHeight = 0;
+    alignTremoloPickingGlyph(direction, flagEnd, firstNoteY, duration) {
+        const lr = this.renderer;
+        const smufl = lr.smuflMetrics;
+        let tremoloY = 0;
+        const tremoloOverlap = smufl.glyphHeights.get(MusicFontSymbol.Tremolo1) / 2;
+        const tremoloCenterOffset = this.height / 2;
+        // whether the center or top bar should be aligned with a staff line
+        const forceAlignWithStaffLine = this.symbol === MusicFontSymbol.Tremolo1;
+        const lineSpacing = lr.lineSpacing;
+        const spacing = forceAlignWithStaffLine ? lineSpacing : lineSpacing / 2;
+        if (direction === BeamDirection.Up) {
+            // start at note
+            let flagBottom = flagEnd;
+            // to bottom of stem
+            flagBottom += smufl.stemFlagHeight.get(duration);
+            flagBottom -= smufl.stemFlagOffsets.get(duration);
+            // align with closest step line
+            tremoloY = spacing * Math.ceil(flagBottom / spacing);
+            // ensure at least 1 staff space distance between note and tremolo bottom bar
+            const tremoloBottomY = tremoloY + tremoloCenterOffset;
+            const minSpacingY = firstNoteY - lineSpacing;
+            if (minSpacingY < tremoloBottomY) {
+                tremoloY = minSpacingY - tremoloCenterOffset;
+            }
+            // reserve the additional space needed in the stem height
+            flagBottom += tremoloOverlap;
+            const tremoloTop = tremoloY - tremoloCenterOffset;
+            if (flagBottom > tremoloTop) {
+                this.stemExtensionHeight = flagBottom - tremoloTop;
+            }
+            else {
+                this.stemExtensionHeight = 0;
+            }
+        }
+        else {
+            // same logic as above but inverted
+            let flagTop = flagEnd;
+            flagTop -= smufl.stemFlagHeight.get(duration);
+            flagTop += smufl.stemFlagOffsets.get(duration);
+            tremoloY = spacing * Math.floor(flagTop / spacing);
+            const tremoloTopY = tremoloY - tremoloCenterOffset;
+            const minSpacingY = firstNoteY + lineSpacing;
+            if (minSpacingY > tremoloTopY) {
+                tremoloY = minSpacingY + tremoloCenterOffset;
+            }
+            flagTop -= tremoloOverlap;
+            const tremoloBottom = tremoloY + tremoloCenterOffset;
+            if (flagTop < tremoloBottom) {
+                this.stemExtensionHeight = tremoloBottom - flagTop;
+            }
+            else {
+                this.stemExtensionHeight = 0;
+            }
+        }
+        this.y = tremoloY;
+    }
 }
 
 /**
@@ -70043,6 +70236,7 @@ class ScoreNoteChordGlyph extends ScoreNoteChordGlyphBase {
     _notes = [];
     _deadSlapped = null;
     _tremoloPicking = null;
+    _stemLengthExtension = 0;
     aboveBeatEffects = new Map();
     belowBeatEffects = new Map();
     beat;
@@ -70064,7 +70258,7 @@ class ScoreNoteChordGlyph extends ScoreNoteChordGlyphBase {
             return new ScoreChordNoteHeadInfo(this.direction);
         }
         const staff = this.beat.voice.bar.staff;
-        const key = `score.noteheads.${staff.track.index}.${staff.index}.${this.beat.absoluteDisplayStart}`;
+        const key = `score.noteheads.${staff.track.index}.${staff.index}.${this.beat.voice.bar.index}.${this.beat.absoluteDisplayStart}`;
         let existing = this.renderer.staff.getSharedLayoutData(key, undefined);
         if (!existing) {
             existing = new ScoreChordNoteHeadInfo(this.direction);
@@ -70097,19 +70291,26 @@ class ScoreNoteChordGlyph extends ScoreNoteChordGlyphBase {
         }
         return 0;
     }
+    getLowestNoteY(requestedPosition) {
+        return this.maxStepsNote ? this._internalGetNoteY(this.maxStepsNote.glyph, requestedPosition) : 0;
+    }
+    getHighestNoteY(requestedPosition) {
+        return this.minStepsNote ? this._internalGetNoteY(this.minStepsNote.glyph, requestedPosition) : 0;
+    }
     _internalGetNoteY(n, requestedPosition) {
         let pos = this.y + n.y;
+        const sr = this.renderer;
         const scale = this.beat.graceType !== GraceType.None ? EngravingSettings.GraceScale : 1;
         switch (requestedPosition) {
             case NoteYPosition.TopWithStem:
                 // stem start
                 pos -=
-                    (this.renderer.smuflMetrics.stemUp.has(n.symbol)
-                        ? this.renderer.smuflMetrics.stemUp.get(n.symbol).bottomY
-                        : 0) * scale;
+                    (sr.smuflMetrics.stemUp.has(n.symbol) ? sr.smuflMetrics.stemUp.get(n.symbol).bottomY : 0) * scale;
                 // stem size according to duration
-                pos -= this.renderer.smuflMetrics.standardStemLength * scale;
-                const topCenterY = this.renderer.centerStaffStemY(this.direction);
+                pos -= sr.smuflMetrics.getStemLength(this.beat.duration, sr.hasFlag(this.beat)) * scale;
+                pos -= this._stemLengthExtension;
+                let topCenterY = sr.centerStaffStemY(this.direction);
+                topCenterY -= this._stemLengthExtension;
                 return Math.min(topCenterY, pos);
             case NoteYPosition.Top:
                 pos -= n.height / 2;
@@ -70125,20 +70326,20 @@ class ScoreNoteChordGlyph extends ScoreNoteChordGlyphBase {
                         ? this.renderer.smuflMetrics.stemDown.get(n.symbol).topY
                         : -this.renderer.smuflMetrics.glyphHeights.get(n.symbol) / 2) * scale;
                 // stem size according to duration
-                pos += this.renderer.smuflMetrics.standardStemLength * scale;
-                const bottomCenterY = this.renderer.centerStaffStemY(this.direction);
+                pos += sr.smuflMetrics.getStemLength(this.beat.duration, sr.hasFlag(this.beat)) * scale;
+                pos += this._stemLengthExtension;
+                let bottomCenterY = sr.centerStaffStemY(this.direction);
+                bottomCenterY += this._stemLengthExtension;
                 return Math.max(bottomCenterY, pos);
             case NoteYPosition.StemUp:
                 pos -=
-                    (this.renderer.smuflMetrics.stemUp.has(n.symbol)
-                        ? this.renderer.smuflMetrics.stemUp.get(n.symbol).bottomY
-                        : 0) * scale;
+                    (sr.smuflMetrics.stemUp.has(n.symbol) ? sr.smuflMetrics.stemUp.get(n.symbol).bottomY : 0) * scale;
                 break;
             case NoteYPosition.StemDown:
                 pos -=
-                    (this.renderer.smuflMetrics.stemDown.has(n.symbol)
-                        ? this.renderer.smuflMetrics.stemDown.get(n.symbol).topY
-                        : -this.renderer.smuflMetrics.glyphHeights.get(n.symbol) / 2) * scale;
+                    (sr.smuflMetrics.stemDown.has(n.symbol)
+                        ? sr.smuflMetrics.stemDown.get(n.symbol).topY
+                        : -sr.smuflMetrics.glyphHeights.get(n.symbol) / 2) * scale;
                 break;
         }
         return pos;
@@ -70170,14 +70371,15 @@ class ScoreNoteChordGlyph extends ScoreNoteChordGlyphBase {
         }
         else {
             if (this.direction === BeamDirection.Up) {
-                belowBeatEffectsY = this._internalGetNoteY(this.maxNote.glyph, NoteYPosition.Bottom) + effectSpacing;
+                belowBeatEffectsY =
+                    this._internalGetNoteY(this.maxStepsNote.glyph, NoteYPosition.Bottom) + effectSpacing;
                 aboveBeatEffectsY =
-                    this._internalGetNoteY(this.minNote.glyph, NoteYPosition.TopWithStem) - effectSpacing;
+                    this._internalGetNoteY(this.minStepsNote.glyph, NoteYPosition.TopWithStem) - effectSpacing;
             }
             else {
                 belowBeatEffectsY =
-                    this._internalGetNoteY(this.maxNote.glyph, NoteYPosition.BottomWithStem) + effectSpacing;
-                aboveBeatEffectsY = this._internalGetNoteY(this.minNote.glyph, NoteYPosition.Top) - effectSpacing;
+                    this._internalGetNoteY(this.maxStepsNote.glyph, NoteYPosition.BottomWithStem) + effectSpacing;
+                aboveBeatEffectsY = this._internalGetNoteY(this.minStepsNote.glyph, NoteYPosition.Top) - effectSpacing;
             }
         }
         let minEffectY = null;
@@ -70211,27 +70413,27 @@ class ScoreNoteChordGlyph extends ScoreNoteChordGlyphBase {
             scoreRenderer.registerBeatEffectOverflows(minEffectY, maxEffectY ?? 0);
         }
         if (this.beat.isTremolo && !this.beat.deadSlapped) {
-            const direction = this.direction;
-            let tremoloY = 0;
-            if (direction === BeamDirection.Up) {
-                const topY = this._internalGetNoteY(this.minNote.glyph, NoteYPosition.TopWithStem);
-                const bottomY = this._internalGetNoteY(this.minNote.glyph, NoteYPosition.StemUp);
-                tremoloY = (topY + bottomY) / 2;
-            }
-            else {
-                const topY = this._internalGetNoteY(this.maxNote.glyph, NoteYPosition.StemDown);
-                const bottomY = this._internalGetNoteY(this.maxNote.glyph, NoteYPosition.BottomWithStem);
-                tremoloY = (topY + bottomY) / 2;
-            }
-            let tremoloX = this.stemX;
-            const speed = this.beat.tremoloSpeed;
-            if (this.beat.duration < Duration.Half) {
-                tremoloX = this.width / 2;
-            }
-            this._tremoloPicking = new TremoloPickingGlyph(tremoloX, tremoloY, speed);
+            this._tremoloPicking = new TremoloPickingGlyph(0, 0, this.beat.tremoloPicking);
             this._tremoloPicking.renderer = this.renderer;
             this._tremoloPicking.doLayout();
+            this._alignTremoloPickingGlyph();
+        }
+    }
+    _alignTremoloPickingGlyph() {
+        const g = this._tremoloPicking;
+        const direction = this.direction;
+        if (direction === BeamDirection.Up) {
+            g.alignTremoloPickingGlyph(direction, this.getHighestNoteY(NoteYPosition.TopWithStem), this.getHighestNoteY(NoteYPosition.Center), this.beat.duration);
+        }
+        else {
+            g.alignTremoloPickingGlyph(direction, this.getLowestNoteY(NoteYPosition.BottomWithStem), this.getLowestNoteY(NoteYPosition.Center), this.beat.duration);
+        }
+        this._stemLengthExtension = g.stemExtensionHeight;
+        let tremoloX = this.stemX;
+        if (this.beat.duration < Duration.Half) {
+            tremoloX = this.width / 2;
         }
+        g.x = tremoloX;
     }
     buildBoundingsLookup(beatBounds, cx, cy) {
         for (const note of this._notes) {
@@ -70480,17 +70682,17 @@ class ScoreWhammyBarGlyph extends ScoreHelperNotesBaseGlyph {
         if (!endGlyph) {
             return false;
         }
-        return !!endGlyph.minNote && !!endGlyph.maxNote;
+        return !!endGlyph.minStepsNote && !!endGlyph.maxStepsNote;
     }
     getBoundingBoxTop() {
-        if (this._endGlyph?.minNote) {
-            return this._endGlyph.minNote.glyph.getBoundingBoxTop();
+        if (this._endGlyph?.minStepsNote) {
+            return this._endGlyph.minStepsNote.glyph.getBoundingBoxTop();
         }
         return super.getBoundingBoxTop();
     }
     getBoundingBoxBottom() {
-        if (this._endGlyph?.maxNote) {
-            return this._endGlyph.maxNote.glyph.getBoundingBoxBottom();
+        if (this._endGlyph?.maxStepsNote) {
+            return this._endGlyph.maxStepsNote.glyph.getBoundingBoxBottom();
         }
         return super.getBoundingBoxBottom();
     }
@@ -70723,6 +70925,89 @@ class ScoreWhammyBarGlyph extends ScoreHelperNotesBaseGlyph {
     }
 }
 
+/**
+ * @internal
+ */
+class SlashNoteHeadGlyph extends NoteHeadGlyphBase {
+    beatEffects = new Map();
+    noteHeadElement = NoteSubElement.SlashNoteHead;
+    effectElement = BeatSubElement.SlashEffects;
+    stemX = 0;
+    constructor(x, y, beat) {
+        super(x, y, beat.graceType !== GraceType.None, SlashNoteHeadGlyph.getSymbol(beat.duration));
+        this.beat = beat;
+    }
+    paint(cx, cy, canvas) {
+        const _ = this.beat.notes.length === 0
+            ? undefined
+            : ElementStyleHelper.note(canvas, this.noteHeadElement, this.beat.notes[0]);
+        try {
+            super.paint(cx, cy, canvas);
+            this._paintEffects(cx, cy, canvas);
+        }
+        finally {
+            _?.[Symbol.dispose]?.();
+        }
+    }
+    _paintEffects(cx, cy, canvas) {
+        const _ = ElementStyleHelper.beat(canvas, this.effectElement, this.beat);
+        try {
+            for (const g of this.beatEffects.values()) {
+                g.paint(cx + this.x, cy + this.y, canvas);
+            }
+        }
+        finally {
+            _?.[Symbol.dispose]?.();
+        }
+    }
+    doLayout() {
+        super.doLayout();
+        const lr = this.renderer;
+        const effectSpacing = lr.smuflMetrics.onNoteEffectPadding;
+        let effectY = lr.smuflMetrics.glyphHeights.get(this.symbol);
+        let minEffectY = Number.NaN;
+        let maxEffectY = Number.NaN;
+        for (const g of this.beatEffects.values()) {
+            g.y += effectY;
+            g.x += this.width / 2;
+            g.renderer = lr;
+            effectY += g.height + effectSpacing;
+            g.doLayout();
+            if (Number.isNaN(minEffectY) || minEffectY > effectY) {
+                minEffectY = effectY;
+            }
+            if (Number.isNaN(maxEffectY) || maxEffectY < effectY) {
+                maxEffectY = effectY;
+            }
+        }
+        if (!Number.isNaN(minEffectY)) {
+            lr.registerBeatEffectOverflows(minEffectY, maxEffectY);
+        }
+        const direction = lr.getBeatDirection(this.beat);
+        const symbol = this.symbol;
+        if (direction === BeamDirection.Up) {
+            const stemInfoUp = lr.smuflMetrics.stemUp.has(symbol) ? lr.smuflMetrics.stemUp.get(symbol).x : 0;
+            this.stemX = stemInfoUp;
+        }
+        else {
+            const stemInfoDown = lr.smuflMetrics.stemDown.has(symbol) ? lr.smuflMetrics.stemDown.get(symbol).x : 0;
+            this.stemX = stemInfoDown;
+        }
+    }
+    static getSymbol(duration) {
+        switch (duration) {
+            case Duration.QuadrupleWhole:
+            case Duration.DoubleWhole:
+            case Duration.Whole:
+                return MusicFontSymbol.NoteheadSlashWhiteWhole;
+            case Duration.Half:
+                return MusicFontSymbol.NoteheadSlashWhiteHalf;
+            default:
+                return MusicFontSymbol.NoteheadSlashHorizontalEnds;
+        }
+    }
+}
+
 /**
  * @internal
  */
@@ -70761,9 +71046,6 @@ class ScoreBeatGlyph extends BeatOnNoteGlyphBase {
     get effectElement() {
         return BeatSubElement.StandardNotationEffects;
     }
-    getNoteX(note, requestedPosition) {
-        return this.noteHeads ? this.noteHeads.getNoteX(note, requestedPosition) : 0;
-    }
     buildBoundingsLookup(beatBounds, cx, cy) {
         if (this.noteHeads) {
             this.noteHeads.buildBoundingsLookup(beatBounds, cx + this.x, cy + this.y);
@@ -70795,20 +71077,34 @@ class ScoreBeatGlyph extends BeatOnNoteGlyphBase {
         }
         return y;
     }
-    getLowestNoteY() {
-        return this.noteHeads ? this.noteHeads.getLowestNoteY() : 0;
+    getLowestNoteY(requestedPosition) {
+        // NOTE: slash handled automatically
+        return this.noteHeads ? this.noteHeads.getLowestNoteY(requestedPosition) : 0;
     }
-    getHighestNoteY() {
-        return this.noteHeads ? this.noteHeads.getHighestNoteY() : 0;
+    getHighestNoteY(requestedPosition) {
+        // NOTE: slash handled automatically
+        return this.noteHeads ? this.noteHeads.getHighestNoteY(requestedPosition) : 0;
     }
     getNoteY(note, requestedPosition) {
+        // for slashed beats always lookup first note
+        if (note.beat.slashed) {
+            note = note.beat.notes[0];
+        }
         return this.noteHeads ? this.noteHeads.getNoteY(note, requestedPosition) : 0;
     }
+    getNoteX(note, requestedPosition) {
+        // for slashed beats always lookup first note
+        if (note.beat.slashed) {
+            note = note.beat.notes[0];
+        }
+        return this.noteHeads ? this.noteHeads.getNoteX(note, requestedPosition) : 0;
+    }
     getRestY(requestedPosition) {
         const g = this.restGlyph;
         if (g) {
             switch (requestedPosition) {
                 case NoteYPosition.TopWithStem:
+                    return g.getBoundingBoxTop() - this.renderer.smuflMetrics.getStemLength(Duration.Quarter, true);
                 case NoteYPosition.Top:
                     return g.getBoundingBoxTop();
                 case NoteYPosition.Center:
@@ -70816,8 +71112,9 @@ class ScoreBeatGlyph extends BeatOnNoteGlyphBase {
                 case NoteYPosition.StemDown:
                     return g.getBoundingBoxTop() + g.height / 2;
                 case NoteYPosition.Bottom:
-                case NoteYPosition.BottomWithStem:
                     return g.getBoundingBoxBottom();
+                case NoteYPosition.BottomWithStem:
+                    return g.getBoundingBoxBottom() + this.renderer.smuflMetrics.getStemLength(Duration.Quarter, true);
             }
         }
         return 0;
@@ -70900,10 +71197,18 @@ class ScoreBeatGlyph extends BeatOnNoteGlyphBase {
         noteHeads.beat = this.container.beat;
         const ghost = new GhostNoteContainerGlyph(false);
         ghost.renderer = this.renderer;
-        for (const note of this.container.beat.notes) {
-            if (note.isVisible && (!note.beat.slashed || note.index === 0)) {
-                this._createNoteGlyph(note);
-                ghost.addParenthesis(note);
+        if (this.container.beat.slashed) {
+            const steps = sr.heightLineCount - 1;
+            const slash = new SlashNoteHeadGlyph(0, sr.getScoreY(steps), this.container.beat);
+            slash.colorOverride = ElementStyleHelper.noteColor(sr.resources, NoteSubElement.StandardNotationNoteHead, this.container.beat.notes[0]);
+            this.noteHeads.addMainNoteGlyph(slash, this.container.beat.notes[0], steps);
+        }
+        else {
+            for (const note of this.container.beat.notes) {
+                if (note.isVisible) {
+                    this._createNoteGlyph(note);
+                    ghost.addParenthesis(note);
+                }
             }
         }
         this.addNormal(noteHeads);
@@ -70932,6 +71237,24 @@ class ScoreBeatGlyph extends BeatOnNoteGlyphBase {
                 this.addEffect(group);
             }
         }
+        if (this.renderer.bar.isMultiVoice) {
+            let highestNotePosition = 0;
+            let lowestNotePosition = 0;
+            const direction = sr.getBeatDirection(this.container.beat);
+            let offset = 0;
+            if (this.container.beat.hasTuplet) {
+                offset += sr.tupletOffset + sr.tupletSize;
+            }
+            if (direction === BeamDirection.Up) {
+                highestNotePosition = this.getHighestNoteY(NoteYPosition.TopWithStem) - offset;
+                lowestNotePosition = this.getLowestNoteY(NoteYPosition.Bottom);
+            }
+            else {
+                highestNotePosition = this.getHighestNoteY(NoteYPosition.Top);
+                lowestNotePosition = this.getLowestNoteY(NoteYPosition.BottomWithStem) + offset;
+            }
+            this.renderer.collisionHelper.reserveBeatSlot(this.container.beat, highestNotePosition, lowestNotePosition);
+        }
     }
     _createRestGlyphs() {
         const sr = this.renderer;
@@ -70998,9 +71321,6 @@ class ScoreBeatGlyph extends BeatOnNoteGlyphBase {
             }
             Logger.warning('Rendering', `No articulation found for percussion instrument ${n.percussionArticulation}`);
         }
-        if (n.beat.slashed) {
-            return new SlashNoteHeadGlyph(0, 0, n.beat.duration, isGrace, n.beat);
-        }
         if (n.isDead) {
             return new DeadNoteHeadGlyph(0, 0, isGrace);
         }
@@ -71020,13 +71340,7 @@ class ScoreBeatGlyph extends BeatOnNoteGlyphBase {
         const noteHeadGlyph = this._createNoteHeadGlyph(n);
         noteHeadGlyph.colorOverride = ElementStyleHelper.noteColor(sr.resources, NoteSubElement.StandardNotationNoteHead, n);
         // calculate y position
-        let steps;
-        if (n.beat.slashed) {
-            steps = sr.heightLineCount - 1;
-        }
-        else {
-            steps = sr.getNoteSteps(n);
-        }
+        let steps = sr.getNoteSteps(n);
         noteHeadGlyph.y = sr.getScoreY(steps);
         this.noteHeads.addMainNoteGlyph(noteHeadGlyph, n, steps);
         if (!n.beat.slashed && n.harmonicType !== HarmonicType.None && n.harmonicType !== HarmonicType.Natural) {
@@ -71040,7 +71354,7 @@ class ScoreBeatGlyph extends BeatOnNoteGlyphBase {
         }
         const belowBeatEffects = this.noteHeads.belowBeatEffects;
         const aboveBeatEffects = this.noteHeads.aboveBeatEffects;
-        const outsideBeatEffects = this.renderer.getBeatDirection(this.container.beat) === BeamDirection.Up
+        const outsideBeatEffects = sr.getBeatDirection(this.container.beat) === BeamDirection.Up
             ? this.noteHeads.belowBeatEffects
             : this.noteHeads.aboveBeatEffects;
         if (n.isStaccato && !belowBeatEffects.has('Staccato')) {
@@ -71357,16 +71671,16 @@ class ScoreBendGlyph extends ScoreHelperNotesBaseGlyph {
             switch (note.bendType) {
                 case BendType.Bend:
                 case BendType.PrebendBend:
-                    endY = this._endNoteGlyph.minNote.glyph.getBoundingBoxTop();
+                    endY = this._endNoteGlyph.minStepsNote.glyph.getBoundingBoxTop();
                     endX = width;
                     break;
                 case BendType.BendRelease:
-                    endY = this._middleNoteGlyph.minNote.glyph.getBoundingBoxTop();
+                    endY = this._middleNoteGlyph.minStepsNote.glyph.getBoundingBoxTop();
                     endX = width / 2;
                     break;
                 case BendType.Release:
                 case BendType.PrebendRelease:
-                    endY = this._endNoteGlyph.maxNote.glyph.getBoundingBoxTop();
+                    endY = this._endNoteGlyph.maxStepsNote.glyph.getBoundingBoxTop();
                     endX = width;
                     break;
             }
@@ -72056,15 +72370,15 @@ class ScoreBeatContainerGlyph extends BeatContainerGlyph {
         const beat = this.beat;
         const isGrace = beat.graceType !== GraceType.None;
         if (sr.hasFlag(beat)) {
-            const direction = this.renderer.getBeatDirection(beat);
+            const direction = sr.getBeatDirection(beat);
             const scale = isGrace ? EngravingSettings.GraceScale : 1;
             const symbol = FlagGlyph.getSymbol(beat.duration, direction, isGrace);
-            const flagWidth = this.renderer.smuflMetrics.glyphWidths.get(symbol) * scale;
+            const flagWidth = sr.smuflMetrics.glyphWidths.get(symbol) * scale;
             this._flagStretch = flagWidth;
         }
         else if (isGrace) {
             // always use flag size as spacing on grace notes
-            const graceSpacing = this.renderer.smuflMetrics.glyphWidths.get(MusicFontSymbol.Flag8thUp) * EngravingSettings.GraceScale;
+            const graceSpacing = sr.smuflMetrics.glyphWidths.get(MusicFontSymbol.Flag8thUp) * EngravingSettings.GraceScale;
             this._flagStretch = graceSpacing;
         }
         super.doLayout();
@@ -72246,73 +72560,26 @@ class ScoreBarRenderer extends LineBarRenderer {
     get tupletSubElement() {
         return BeatSubElement.StandardNotationTuplet;
     }
-    _getSlashFlagY() {
-        const line = (this.heightLineCount - 1) / 2;
-        const slashY = this.getLineY(line);
-        return slashY;
-    }
     getFlagTopY(beat, direction) {
-        if (beat.slashed) {
-            let slashY = this._getSlashFlagY();
-            const symbol = SlashNoteHeadGlyph.getSymbol(beat.duration);
-            const scale = beat.graceType !== GraceType.None ? EngravingSettings.GraceScale : 1;
-            if (direction === BeamDirection.Down) {
-                slashY -= this.smuflMetrics.stemDown.has(symbol)
-                    ? this.smuflMetrics.stemDown.get(symbol).topY * scale
-                    : 0;
-            }
-            else {
-                slashY -= this.smuflMetrics.stemUp.has(symbol)
-                    ? this.smuflMetrics.stemUp.get(symbol).bottomY * scale
-                    : 0;
-                if (!beat.isRest) {
-                    slashY -= this.smuflMetrics.standardStemLength + scale;
-                }
-            }
-            return slashY;
-        }
-        const minNote = this.accidentalHelper.getMinStepsNote(beat);
-        if (minNote) {
-            return this.getNoteY(minNote, direction === BeamDirection.Up ? NoteYPosition.TopWithStem : NoteYPosition.StemDown);
+        const position = direction === BeamDirection.Up ? NoteYPosition.TopWithStem : NoteYPosition.StemDown;
+        if (beat.isRest) {
+            return this.getRestY(beat, position);
         }
-        let y = this.getScoreY(this.accidentalHelper.getMinSteps(beat));
-        if (direction === BeamDirection.Up && !beat.isRest) {
-            const scale = beat.graceType !== GraceType.None ? EngravingSettings.GraceScale : 1;
-            y -= this.smuflMetrics.standardStemLength * scale;
+        else {
+            return this.voiceContainer.getHighestNoteY(beat, position);
         }
-        return y;
     }
     getFlagBottomY(beat, direction) {
-        if (beat.slashed) {
-            let slashY = this._getSlashFlagY();
-            const symbol = SlashNoteHeadGlyph.getSymbol(beat.duration);
-            const scale = beat.graceType !== GraceType.None ? EngravingSettings.GraceScale : 1;
-            if (direction === BeamDirection.Down) {
-                slashY -= this.smuflMetrics.stemDown.has(symbol)
-                    ? this.smuflMetrics.stemDown.get(symbol).topY * scale
-                    : 0;
-                slashY += this.smuflMetrics.standardStemLength + scale;
-            }
-            else {
-                slashY -= this.smuflMetrics.stemUp.has(symbol)
-                    ? this.smuflMetrics.stemUp.get(symbol).bottomY * scale
-                    : 0;
-            }
-            return slashY;
-        }
-        const maxNote = this.accidentalHelper.getMaxStepsNote(beat);
-        if (maxNote) {
-            return this.getNoteY(maxNote, direction === BeamDirection.Up ? NoteYPosition.StemUp : NoteYPosition.BottomWithStem);
+        const position = direction === BeamDirection.Up ? NoteYPosition.StemUp : NoteYPosition.BottomWithStem;
+        if (beat.isRest) {
+            return this.getRestY(beat, position);
         }
-        let y = this.getScoreY(this.accidentalHelper.getMaxSteps(beat));
-        if (direction === BeamDirection.Down) {
-            const scale = beat.graceType !== GraceType.None ? EngravingSettings.GraceScale : 1;
-            y += this.smuflMetrics.standardStemLength * scale;
+        else {
+            return this.voiceContainer.getLowestNoteY(beat, position);
         }
-        return y;
     }
     getBeamDirection(helper) {
-        return helper.direction;
+        return this._beamDirections.has(helper) ? this._beamDirections.get(helper) : BeamDirection.Up;
     }
     centerStaffStemY(direction) {
         const isStandardFive = this.bar.staff.standardNotationLineCount === Staff.DefaultStandardNotationLineCount;
@@ -72326,50 +72593,9 @@ class ScoreBarRenderer extends LineBarRenderer {
         }
         return this.getScoreY(0);
     }
-    getStemBottomY(_beamingHelper) {
-        throw new Error('Method not implemented.');
-    }
     get middleYPosition() {
         return this.getScoreY(this.bar.staff.standardNotationLineCount - 1);
     }
-    getNoteY(note, requestedPosition) {
-        if (note.beat.slashed) {
-            const line = (this.heightLineCount - 1) / 2;
-            return this.getLineY(line);
-        }
-        let y = super.getNoteY(note, requestedPosition);
-        if (Number.isNaN(y)) {
-            // NOTE: some might request the note position before the glyphs have been created
-            // e.g. the beaming helper, for these we just need a rough
-            // estimate on the position
-            const steps = AccidentalHelper.computeStepsWithoutAccidentals(this.bar, note);
-            y = this.getScoreY(steps);
-            const scale = note.beat.graceType === GraceType.None ? 1 : EngravingSettings.GraceScale;
-            const stemHeight = this.smuflMetrics.standardStemLength * scale;
-            const noteHeadHeight = this.smuflMetrics.glyphHeights.get(NoteHeadGlyph.getSymbol(note.beat.duration)) * scale;
-            switch (requestedPosition) {
-                case NoteYPosition.TopWithStem:
-                    y -= stemHeight;
-                    break;
-                case NoteYPosition.Top:
-                    y -= noteHeadHeight / 2;
-                    break;
-                case NoteYPosition.Center:
-                    break;
-                case NoteYPosition.Bottom:
-                    y += noteHeadHeight / 2;
-                    break;
-                case NoteYPosition.BottomWithStem:
-                    y += stemHeight;
-                    break;
-                case NoteYPosition.StemUp:
-                    break;
-                case NoteYPosition.StemDown:
-                    break;
-            }
-        }
-        return y;
-    }
     applyLayoutingInfo() {
         const result = super.applyLayoutingInfo();
         if (result && this.bar.isMultiVoice) {
@@ -72386,34 +72612,6 @@ class ScoreBarRenderer extends LineBarRenderer {
         }
         return result;
     }
-    calculateBeamYWithDirection(h, x, direction) {
-        if (h.beats.length === 0) {
-            return direction === BeamDirection.Up
-                ? this.getFlagTopY(h.beats[0], direction)
-                : this.getFlagBottomY(h.beats[0], direction);
-        }
-        this.ensureBeamDrawingInfo(h, direction);
-        return h.drawingInfos.get(direction).calcY(x);
-    }
-    getBarLineStart(beat, direction) {
-        if (beat.slashed) {
-            return direction === BeamDirection.Down
-                ? this.getFlagTopY(beat, direction)
-                : this.getFlagBottomY(beat, direction);
-        }
-        if (direction === BeamDirection.Up) {
-            const maxNote = this.accidentalHelper.getMaxStepsNote(beat);
-            if (maxNote) {
-                return this.getNoteY(maxNote, NoteYPosition.StemUp);
-            }
-            return this.getScoreY(this.accidentalHelper.getMaxSteps(beat));
-        }
-        const minNote = this.accidentalHelper.getMinStepsNote(beat);
-        if (minNote) {
-            return this.getNoteY(minNote, NoteYPosition.StemDown);
-        }
-        return this.getScoreY(this.accidentalHelper.getMinSteps(beat));
-    }
     getMinLineOfBeat(beat) {
         return this.accidentalHelper.getMinSteps(beat) / 2;
     }
@@ -72555,27 +72753,62 @@ class ScoreBarRenderer extends LineBarRenderer {
     getNoteSteps(n) {
         return this.accidentalHelper.getNoteSteps(n);
     }
+    _beamDirections = new Map();
     completeBeamingHelper(helper) {
-        // for multi-voice bars we need to register the positions
-        // for multi-voice rest displacement to avoid collisions
-        if (this.bar.isMultiVoice && helper.highestNoteInHelper && helper.lowestNoteInHelper) {
-            let highestNotePosition = 0;
-            let lowestNotePosition = 0;
-            let offset = 0;
-            if (helper.hasTuplet) {
-                offset += this.resources.effectFont.size * 2;
-            }
-            if (helper.direction === BeamDirection.Up) {
-                highestNotePosition = this.getNoteY(helper.highestNoteInHelper, NoteYPosition.TopWithStem) - offset;
-                lowestNotePosition = this.getNoteY(helper.lowestNoteInHelper, NoteYPosition.Bottom);
-            }
-            else {
-                highestNotePosition = this.getNoteY(helper.highestNoteInHelper, NoteYPosition.Top);
-                lowestNotePosition = this.getNoteY(helper.lowestNoteInHelper, NoteYPosition.BottomWithStem) + offset;
-            }
-            for (const beat of helper.beats) {
-                this.helpers.collisionHelper.reserveBeatSlot(beat, highestNotePosition, lowestNotePosition);
-            }
+        const direction = this._calculateBeamDirection(helper);
+        this._beamDirections.set(helper, direction);
+    }
+    _calculateBeamDirection(helper) {
+        // no proper voice (should not happen usually)
+        if (!helper.voice) {
+            return BeamDirection.Up;
+        }
+        // we have a preferred direction
+        if (helper.preferredBeamDirection !== null) {
+            return helper.preferredBeamDirection;
+        }
+        // on multi-voice setups secondary voices are always down
+        if (helper.voice.index > 0) {
+            return this._invertBeamDirection(helper, BeamDirection.Down);
+        }
+        // on multi-voice setups primary voices are always up
+        if (helper.voice.bar.isMultiVoice) {
+            return this._invertBeamDirection(helper, BeamDirection.Up);
+        }
+        // grace notes are always up
+        if (helper.beats[0].graceType !== GraceType.None) {
+            return this._invertBeamDirection(helper, BeamDirection.Up);
+        }
+        if (helper.beats.length === 1 && helper.beats[0].slashed) {
+            return this._invertBeamDirection(helper, BeamDirection.Down);
+        }
+        // the average line is used for determination
+        //      key lowerequal than middle line -> up
+        //      key higher than middle line -> down
+        if (helper.highestNoteInHelper && helper.lowestNoteInHelper) {
+            // NOTE: This is the only place where we need the locations before we have positioned the notes
+            // TODO: we should first register all note-heads and calculate the accidentals+steps
+            const highestNotePosition = this._getNoteCenterYBeforeLayouting(helper.highestNoteInHelper);
+            const lowestNotePosition = this._getNoteCenterYBeforeLayouting(helper.lowestNoteInHelper);
+            const avg = (highestNotePosition + lowestNotePosition) / 2;
+            return this._invertBeamDirection(helper, this.middleYPosition < avg ? BeamDirection.Up : BeamDirection.Down);
+        }
+        return this._invertBeamDirection(helper, BeamDirection.Up);
+    }
+    _getNoteCenterYBeforeLayouting(note) {
+        const steps = AccidentalHelper.computeStepsWithoutAccidentals(this.bar, note);
+        return this.getScoreY(steps);
+    }
+    _invertBeamDirection(helper, direction) {
+        if (!helper.invertBeamDirection) {
+            return direction;
+        }
+        switch (direction) {
+            case BeamDirection.Down:
+                return BeamDirection.Up;
+            // case BeamDirection.Up:
+            default:
+                return BeamDirection.Down;
         }
     }
     paintBeamingStem(beat, _cy, x, topY, bottomY, canvas) {
@@ -72618,6 +72851,8 @@ class SlashRestGlyph extends ScoreRestGlyph {
  * @internal
  */
 class SlashBeatGlyph extends BeatOnNoteGlyphBase {
+    _tremoloPicking;
+    _stemLengthExtension = 0;
     noteHeads = null;
     deadSlapped = null;
     restGlyph = null;
@@ -72660,17 +72895,18 @@ class SlashBeatGlyph extends BeatOnNoteGlyphBase {
             beatBounds.addNote(noteBounds);
         }
     }
-    getLowestNoteY() {
-        return this.noteHeads ? this.noteHeads.y : 0;
+    getLowestNoteY(requestedPosition) {
+        return this._internalGetNoteY(requestedPosition);
     }
-    getHighestNoteY() {
-        return this.noteHeads ? this.noteHeads.y : 0;
+    getHighestNoteY(requestedPosition) {
+        return this._internalGetNoteY(requestedPosition);
     }
     getRestY(requestedPosition) {
         const g = this.restGlyph;
         if (g) {
             switch (requestedPosition) {
                 case NoteYPosition.TopWithStem:
+                    return g.getBoundingBoxTop() - this.renderer.smuflMetrics.getStemLength(Duration.Quarter, true);
                 case NoteYPosition.Top:
                     return g.getBoundingBoxTop();
                 case NoteYPosition.Center:
@@ -72678,35 +72914,70 @@ class SlashBeatGlyph extends BeatOnNoteGlyphBase {
                 case NoteYPosition.StemDown:
                     return g.getBoundingBoxTop() + g.height / 2;
                 case NoteYPosition.Bottom:
-                case NoteYPosition.BottomWithStem:
                     return g.getBoundingBoxBottom();
+                case NoteYPosition.BottomWithStem:
+                    return g.getBoundingBoxBottom() + this.renderer.smuflMetrics.getStemLength(Duration.Quarter, true);
             }
         }
         return 0;
     }
-    getNoteY(note, requestedPosition) {
+    getNoteY(_note, requestedPosition) {
+        return this._internalGetNoteY(requestedPosition);
+    }
+    _internalGetNoteY(requestedPosition) {
         let g = null;
         let symbol = MusicFontSymbol.None;
+        let hasStem = false;
         if (this.noteHeads) {
             g = this.noteHeads;
-            symbol = SlashNoteHeadGlyph.getSymbol(note.beat.duration);
+            symbol = SlashNoteHeadGlyph.getSymbol(this.container.beat.duration);
+            hasStem = true;
         }
         else if (this.deadSlapped) {
             g = this.deadSlapped;
         }
         if (g) {
             let pos = this.y + g.y;
+            const sr = this.renderer;
+            const beat = this.container.beat;
+            const scale = beat.graceType !== GraceType.None ? EngravingSettings.GraceScale : 1;
             switch (requestedPosition) {
-                case NoteYPosition.Top:
                 case NoteYPosition.TopWithStem:
+                    if (hasStem) {
+                        // stem start
+                        pos -=
+                            (sr.smuflMetrics.stemUp.has(symbol) ? sr.smuflMetrics.stemUp.get(symbol).bottomY : 0) *
+                                scale;
+                        // stem size according to duration
+                        pos -= sr.smuflMetrics.getStemLength(beat.duration, sr.hasFlag(beat)) * scale;
+                        pos -= this._stemLengthExtension;
+                    }
+                    else {
+                        pos -= g.height / 2;
+                    }
+                    return pos;
+                case NoteYPosition.Top:
                     pos -= g.height / 2;
                     break;
                 case NoteYPosition.Center:
                     break;
                 case NoteYPosition.Bottom:
-                case NoteYPosition.BottomWithStem:
                     pos += g.height / 2;
                     break;
+                case NoteYPosition.BottomWithStem:
+                    if (hasStem) {
+                        pos -=
+                            (sr.smuflMetrics.stemDown.has(symbol)
+                                ? sr.smuflMetrics.stemDown.get(symbol).topY
+                                : -sr.smuflMetrics.glyphHeights.get(symbol) / 2) * scale;
+                        // stem size according to duration
+                        pos += sr.smuflMetrics.getStemLength(beat.duration, sr.hasFlag(beat)) * scale;
+                        pos += this._stemLengthExtension;
+                    }
+                    else {
+                        pos += g.height / 2;
+                    }
+                    return pos;
                 case NoteYPosition.StemUp:
                     pos -= this.renderer.smuflMetrics.stemUp.has(symbol)
                         ? this.renderer.smuflMetrics.stemUp.get(symbol).bottomY
@@ -72735,11 +73006,16 @@ class SlashBeatGlyph extends BeatOnNoteGlyphBase {
         }
         else if (!this.container.beat.isEmpty) {
             if (!this.container.beat.isRest) {
-                const isGrace = this.container.beat.graceType !== GraceType.None;
-                const noteHeadGlyph = new SlashNoteHeadGlyph(0, glyphY, this.container.beat.duration, isGrace, this.container.beat);
+                const noteHeadGlyph = new SlashNoteHeadGlyph(0, glyphY, this.container.beat);
                 this.noteHeads = noteHeadGlyph;
                 noteHeadGlyph.beat = this.container.beat;
                 this.addNormal(noteHeadGlyph);
+                if (this.container.beat.isTremolo) {
+                    this._tremoloPicking = new TremoloPickingGlyph(0, 0, this.container.beat.tremoloPicking);
+                    this._tremoloPicking.renderer = this.renderer;
+                    this._tremoloPicking.doLayout();
+                    this._alignTremoloPickingGlyph();
+                }
             }
             else {
                 const restGlyph = new SlashRestGlyph(0, glyphY, this.container.beat.duration);
@@ -72774,6 +73050,27 @@ class SlashBeatGlyph extends BeatOnNoteGlyphBase {
             this.stemX = this.onTimeX;
         }
         this.middleX = this.onTimeX;
+        const tremolo = this._tremoloPicking;
+        if (tremolo) {
+            tremolo.x = this.container.beat.duration < Duration.Half ? this.width / 2 : this.stemX;
+        }
+    }
+    _alignTremoloPickingGlyph() {
+        const g = this._tremoloPicking;
+        g.alignTremoloPickingGlyph(BeamDirection.Up, this._internalGetNoteY(NoteYPosition.TopWithStem), this._internalGetNoteY(NoteYPosition.Center), this.container.beat.duration);
+        this._stemLengthExtension = g.stemExtensionHeight;
+        let tremoloX = this.stemX;
+        if (this.container.beat.duration < Duration.Half) {
+            tremoloX = this.width / 2;
+        }
+        g.x = tremoloX;
+    }
+    paint(cx, cy, canvas) {
+        super.paint(cx, cy, canvas);
+        const tremolo = this._tremoloPicking;
+        if (tremolo) {
+            tremolo.paint(cx + this.x, cy + this.y, canvas);
+        }
     }
 }
 
@@ -72808,15 +73105,15 @@ class SlashBeatContainerGlyph extends BeatContainerGlyph {
         const beat = this.beat;
         const isGrace = beat.graceType !== GraceType.None;
         if (sr.hasFlag(beat)) {
-            const direction = this.renderer.getBeatDirection(beat);
+            const direction = sr.getBeatDirection(beat);
             const scale = isGrace ? EngravingSettings.GraceScale : 1;
             const symbol = FlagGlyph.getSymbol(beat.duration, direction, isGrace);
-            const flagWidth = this.renderer.smuflMetrics.glyphWidths.get(symbol) * scale;
+            const flagWidth = sr.smuflMetrics.glyphWidths.get(symbol) * scale;
             this._flagStretch = flagWidth;
         }
         else if (isGrace) {
             // always use flag size as spacing on grace notes
-            const graceSpacing = this.renderer.smuflMetrics.glyphWidths.get(MusicFontSymbol.Flag8thUp) * EngravingSettings.GraceScale;
+            const graceSpacing = sr.smuflMetrics.glyphWidths.get(MusicFontSymbol.Flag8thUp) * EngravingSettings.GraceScale;
             this._flagStretch = graceSpacing;
         }
         super.doLayout();
@@ -72903,45 +73200,26 @@ class SlashBarRenderer extends LineBarRenderer {
     getNoteLine(_note) {
         return 0;
     }
-    getFlagTopY(beat, _direction) {
-        let slashY = this.getLineY(0);
-        const symbol = SlashNoteHeadGlyph.getSymbol(beat.duration);
-        const scale = beat.graceType !== GraceType.None ? EngravingSettings.GraceScale : 1;
-        slashY -= this.smuflMetrics.stemUp.has(symbol) ? this.smuflMetrics.stemUp.get(symbol).bottomY * scale : 0;
-        if (!beat.isRest) {
-            slashY -= this.smuflMetrics.standardStemLength + scale;
+    getFlagTopY(beat, direction) {
+        const position = direction === BeamDirection.Up ? NoteYPosition.TopWithStem : NoteYPosition.StemDown;
+        if (beat.notes.length > 0) {
+            return this.getNoteY(beat.notes[0], position);
         }
-        return slashY;
-    }
-    getFlagBottomY(beat, _direction) {
-        let slashY = this.getLineY(0);
-        const symbol = SlashNoteHeadGlyph.getSymbol(beat.duration);
-        const scale = beat.graceType !== GraceType.None ? EngravingSettings.GraceScale : 1;
-        slashY -= this.smuflMetrics.stemUp.has(symbol) ? this.smuflMetrics.stemUp.get(symbol).bottomY * scale : 0;
-        return slashY;
-    }
-    getBeamDirection(_helper) {
-        return BeamDirection.Up;
-    }
-    getNoteY(note, requestedPosition) {
-        let y = super.getNoteY(note, requestedPosition);
-        if (Number.isNaN(y)) {
-            y = this.getLineY(0);
+        else {
+            return this.getRestY(beat, position);
         }
-        return y;
     }
-    calculateBeamYWithDirection(h, x, direction) {
-        if (h.beats.length === 0) {
-            return direction === BeamDirection.Up
-                ? this.getFlagTopY(h.beats[0], direction)
-                : this.getFlagBottomY(h.beats[0], direction);
+    getFlagBottomY(beat, direction) {
+        const position = direction === BeamDirection.Up ? NoteYPosition.StemUp : NoteYPosition.BottomWithStem;
+        if (beat.notes.length > 0) {
+            return this.getNoteY(beat.notes[0], position);
+        }
+        else {
+            return this.getRestY(beat, position);
         }
-        this.ensureBeamDrawingInfo(h, direction);
-        return h.drawingInfos.get(direction).calcY(x);
     }
-    getBarLineStart(_beat, _direction) {
-        const noteHeadHeight = this.smuflMetrics.glyphHeights.get(MusicFontSymbol.NoteheadSlashWhiteHalf);
-        return this.getLineY(0) - noteHeadHeight / 2;
+    getBeamDirection(_helper) {
+        return BeamDirection.Up;
     }
     createLinePreBeatGlyphs() {
         // Key signature
@@ -72985,6 +73263,9 @@ class SlashBarRenderer extends LineBarRenderer {
         }
         this.calculateBeamingOverflows(rendererTop, rendererBottom);
     }
+    shouldPaintBeamingHelper(h) {
+        return super.shouldPaintBeamingHelper(h) && h.voice.index === 0;
+    }
     paintBeamingStem(beat, _cy, x, topY, bottomY, canvas) {
         const _ = ElementStyleHelper.beat(canvas, BeatSubElement.SlashStem, beat);
         try {
@@ -73031,6 +73312,15 @@ class NoteNumberGlyph extends Glyph {
         super(x, y);
         this._note = note;
     }
+    get _padding() {
+        return this.renderer.lineSpacing * 0.25;
+    }
+    getBoundingBoxTop() {
+        return this.y - this.height / 2 - this._padding;
+    }
+    getBoundingBoxBottom() {
+        return this.y + this.height / 2;
+    }
     doLayout() {
         const n = this._note;
         let fret = n.fret - n.beat.voice.bar.staff.transpositionPitch;
@@ -73105,11 +73395,12 @@ class NoteNumberGlyph extends Glyph {
             return;
         }
         const textWidth = this.noteStringWidth + this._trillNoteStringWidth;
-        const x = (cx + this.x + (this.width - textWidth) / 2);
-        this.paintTrill(x, cy, canvas);
+        const x = cx + this.x + (this.width - textWidth) / 2;
+        const y = cy + this.y;
+        this.paintTrill(x, y, canvas);
         const _ = ElementStyleHelper.note(canvas, NoteSubElement.GuitarTabFretNumber, this._note);
         try {
-            canvas.fillText(this._noteString, x, cy + this.y);
+            canvas.fillText(this._noteString, x, y);
         }
         finally {
             _?.[Symbol.dispose]?.();
@@ -73120,7 +73411,7 @@ class NoteNumberGlyph extends Glyph {
         try {
             const prevFont = this.renderer.scoreRenderer.canvas.font;
             this.renderer.scoreRenderer.canvas.font = this.renderer.resources.graceFont;
-            canvas.fillText(this._trillNoteString, x + this.noteStringWidth, cy + this.y);
+            canvas.fillText(this._trillNoteString, x + this.noteStringWidth, cy);
             this.renderer.scoreRenderer.canvas.font = prevFont;
         }
         finally {
@@ -73179,11 +73470,11 @@ class TabNoteChordGlyph extends Glyph {
         }
         return 0;
     }
-    getLowestNoteY() {
-        return this.maxStringNote ? this.getNoteY(this.maxStringNote, NoteYPosition.Center) : 0;
+    getLowestNoteY(requestedPosition) {
+        return this.maxStringNote ? this.getNoteY(this.maxStringNote, requestedPosition) : 0;
     }
-    getHighestNoteY() {
-        return this.minStringNote ? this.getNoteY(this.minStringNote, NoteYPosition.Center) : 0;
+    getHighestNoteY(requestedPosition) {
+        return this.minStringNote ? this.getNoteY(this.minStringNote, requestedPosition) : 0;
     }
     getNoteY(note, requestedPosition) {
         if (this.notesPerString.has(note.string)) {
@@ -73191,23 +73482,44 @@ class TabNoteChordGlyph extends Glyph {
             let pos = this.y + n.y;
             switch (requestedPosition) {
                 case NoteYPosition.Top:
-                case NoteYPosition.TopWithStem:
                     pos -= n.height / 2;
                     break;
+                case NoteYPosition.StemUp:
+                    pos = this.y + n.getBoundingBoxTop();
+                    break;
                 case NoteYPosition.Center:
                     break;
                 case NoteYPosition.Bottom:
-                case NoteYPosition.BottomWithStem:
                     pos += n.height / 2;
                     break;
-                case NoteYPosition.StemUp:
                 case NoteYPosition.StemDown:
+                    pos = this.y + n.getBoundingBoxBottom();
+                    break;
+                case NoteYPosition.TopWithStem:
+                    pos = -this.renderer.settings.notation.rhythmHeight;
+                    pos -= this.calculateTremoloHeightForStem();
+                    break;
+                case NoteYPosition.BottomWithStem:
+                    pos = this.renderer.height + this.renderer.settings.notation.rhythmHeight;
+                    pos += this.calculateTremoloHeightForStem();
                     break;
             }
             return pos;
         }
         return 0;
     }
+    calculateTremoloHeightForStem() {
+        const beat = this.beat;
+        if (!beat.isTremolo) {
+            return 0;
+        }
+        if (beat.duration <= Duration.Quarter) {
+            return 0;
+        }
+        const symbol = TremoloPickingGlyph._getSymbol(beat.tremoloPicking);
+        const smufl = this.renderer.smuflMetrics;
+        return smufl.glyphHeights.has(symbol) ? smufl.glyphHeights.get(symbol) : 0;
+    }
     doLayout() {
         let w = 0;
         if (this.beat.deadSlapped) {
@@ -73333,6 +73645,20 @@ class TabBeatGlyph extends BeatOnNoteGlyphBase {
         return BeatSubElement.GuitarTabEffects;
     }
     getNoteX(note, requestedPosition) {
+        if (this.slash) {
+            let pos = this.slash.x;
+            switch (requestedPosition) {
+                case NoteXPosition.Left:
+                    break;
+                case NoteXPosition.Center:
+                    pos += this.slash.width / 2;
+                    break;
+                case NoteXPosition.Right:
+                    pos += this.slash.width;
+                    break;
+            }
+            return pos;
+        }
         return this.noteNumbers ? this.noteNumbers.getNoteX(note, requestedPosition) : 0;
     }
     getNoteY(note, requestedPosition) {
@@ -73343,6 +73669,7 @@ class TabBeatGlyph extends BeatOnNoteGlyphBase {
         if (g) {
             switch (requestedPosition) {
                 case NoteYPosition.TopWithStem:
+                    return g.getBoundingBoxTop() - this.renderer.smuflMetrics.getStemLength(Duration.Quarter, true);
                 case NoteYPosition.Top:
                     return g.getBoundingBoxTop();
                 case NoteYPosition.Center:
@@ -73350,17 +73677,18 @@ class TabBeatGlyph extends BeatOnNoteGlyphBase {
                 case NoteYPosition.StemDown:
                     return g.getBoundingBoxTop() + g.height / 2;
                 case NoteYPosition.Bottom:
+                    return g.getBoundingBoxTop();
                 case NoteYPosition.BottomWithStem:
-                    return g.getBoundingBoxBottom();
+                    return g.getBoundingBoxBottom() + this.renderer.smuflMetrics.getStemLength(Duration.Quarter, true);
             }
         }
         return 0;
     }
-    getLowestNoteY() {
-        return this.noteNumbers ? this.noteNumbers.getLowestNoteY() : 0;
+    getLowestNoteY(requestedPosition) {
+        return this.noteNumbers ? this.noteNumbers.getLowestNoteY(requestedPosition) : 0;
     }
-    getHighestNoteY() {
-        return this.noteNumbers ? this.noteNumbers.getHighestNoteY() : 0;
+    getHighestNoteY(requestedPosition) {
+        return this.noteNumbers ? this.noteNumbers.getHighestNoteY(requestedPosition) : 0;
     }
     buildBoundingsLookup(beatBounds, cx, cy) {
         if (this.noteNumbers) {
@@ -73378,7 +73706,7 @@ class TabBeatGlyph extends BeatOnNoteGlyphBase {
             if (this.container.beat.slashed && !this.container.beat.notes.some(x => x.isTieDestination)) {
                 const line = Math.floor((this.renderer.bar.staff.tuning.length - 1) / 2);
                 const slashY = tabRenderer.getLineY(line);
-                const slashNoteHead = new SlashNoteHeadGlyph(0, slashY, this.container.beat.duration, isGrace, this.container.beat);
+                const slashNoteHead = new SlashNoteHeadGlyph(0, slashY, this.container.beat);
                 slashNoteHead.noteHeadElement = NoteSubElement.GuitarTabFretNumber;
                 slashNoteHead.effectElement = BeatSubElement.GuitarTabEffects;
                 this.slash = slashNoteHead;
@@ -73401,8 +73729,7 @@ class TabBeatGlyph extends BeatOnNoteGlyphBase {
             //
             // Tremolo Picking
             if (this.container.beat.isTremolo && !beatEffects.has('tremolo')) {
-                const speed = this.container.beat.tremoloSpeed;
-                const glyph = new TremoloPickingGlyph(0, 0, speed);
+                const glyph = new TremoloPickingGlyph(0, 0, this.container.beat.tremoloPicking);
                 glyph.offsetY = this.renderer.smuflMetrics.glyphTop.get(glyph.symbol);
                 beatEffects.set('tremolo', glyph);
                 centeredEffectGlyphs.push(glyph);
@@ -73411,7 +73738,7 @@ class TabBeatGlyph extends BeatOnNoteGlyphBase {
             // Note dots
             //
             if (this.container.beat.dots > 0 && tabRenderer.rhythmMode !== TabRhythmMode.Hidden) {
-                const y = tabRenderer.getFlagAndBarPos();
+                const y = this.getNoteY(this.container.beat.maxNote, NoteYPosition.BottomWithStem);
                 for (let i = 0; i < this.container.beat.dots; i++) {
                     this.addEffect(new AugmentationDotGlyph(0, y));
                 }
@@ -73473,8 +73800,8 @@ class TabBeatGlyph extends BeatOnNoteGlyphBase {
         noteNumberGlyph.renderer = this.renderer;
         noteNumberGlyph.doLayout();
         this.noteNumbers.addNoteGlyph(noteNumberGlyph, n);
-        const topY = noteNumberGlyph.y - noteNumberGlyph.height / 2;
-        const bottomY = topY + noteNumberGlyph.height;
+        const topY = noteNumberGlyph.getBoundingBoxTop();
+        const bottomY = noteNumberGlyph.getBoundingBoxBottom();
         this.renderer.collisionHelper.reserveBeatSlot(this.container.beat, topY, bottomY);
         const minString = tr.minString;
         const maxString = tr.maxString;
@@ -74001,30 +74328,6 @@ class TabBarRenderer extends LineBarRenderer {
             }
         }
     }
-    adjustSizes() {
-        if (this.rhythmMode !== TabRhythmMode.Hidden) {
-            let shortestTremolo = Duration.Whole;
-            for (const b of this.helpers.beamHelpers) {
-                for (const h of b) {
-                    if (h.tremoloDuration && (!shortestTremolo || shortestTremolo < h.tremoloDuration)) {
-                        shortestTremolo = h.tremoloDuration;
-                    }
-                }
-            }
-            switch (shortestTremolo) {
-                case Duration.Eighth:
-                    this.height += this.smuflMetrics.glyphHeights.get(MusicFontSymbol.Tremolo1);
-                    break;
-                case Duration.Sixteenth:
-                    this.height += this.smuflMetrics.glyphHeights.get(MusicFontSymbol.Tremolo2);
-                    break;
-                case Duration.ThirtySecond:
-                    this.height += this.smuflMetrics.glyphHeights.get(MusicFontSymbol.Tremolo3);
-                    break;
-            }
-            this.registerOverflowBottom(this.settings.notation.rhythmHeight);
-        }
-    }
     doLayout() {
         const hasStandardNotation = this.bar.staff.showStandardNotation && this.scoreRenderer.layout.profile.has(ScoreBarRenderer.StaffId);
         if (!hasStandardNotation) {
@@ -74105,32 +74408,29 @@ class TabBarRenderer extends LineBarRenderer {
     drawBeamHelperAsFlags(h) {
         return super.drawBeamHelperAsFlags(h) || this.rhythmMode === TabRhythmMode.ShowWithBeams;
     }
-    getFlagTopY(beat, _direction) {
-        const container = this.getBeatContainer(beat);
-        if (!container || !beat.minStringNote || beat.duration === Duration.Half) {
-            return this.height - this.settings.notation.rhythmHeight - this.tupletSize;
+    getFlagTopY(beat, direction) {
+        const maxNote = beat.maxStringNote;
+        const position = direction === BeamDirection.Up ? NoteYPosition.TopWithStem : NoteYPosition.StemDown;
+        if (maxNote) {
+            return this.getNoteY(maxNote, position);
+        }
+        else {
+            return this.getRestY(beat, position);
         }
-        return container.getNoteY(beat.minStringNote, NoteYPosition.Bottom) + this.smuflMetrics.staffLineThickness;
-    }
-    getFlagBottomY(_beat, _direction) {
-        return this.getFlagAndBarPos();
-    }
-    getFlagStemSize(_duration, _forceMinStem = false) {
-        return 0; // fixed size via getFlagBottomY
     }
-    getBarLineStart(beat, direction) {
-        return this.getFlagTopY(beat, direction);
+    getFlagBottomY(beat, direction) {
+        const maxNote = beat.minStringNote;
+        const position = direction === BeamDirection.Up ? NoteYPosition.StemUp : NoteYPosition.BottomWithStem;
+        if (maxNote) {
+            return this.getNoteY(maxNote, position);
+        }
+        else {
+            return this.getRestY(beat, position);
+        }
     }
     getBeamDirection(_helper) {
         return BeamDirection.Down;
     }
-    getFlagAndBarPos() {
-        return this.height + this.settings.notation.rhythmHeight - (this._hasTuplets ? this.tupletSize / 2 : 0);
-    }
-    calculateBeamYWithDirection(_h, _x, _direction) {
-        // currently only used for duplets
-        return this.getFlagAndBarPos();
-    }
     shouldPaintFlag(beat) {
         if (!super.shouldPaintFlag(beat)) {
             return false;
@@ -74153,19 +74453,20 @@ class TabBarRenderer extends LineBarRenderer {
                 holes = this.helpers.collisionHelper.reservedLayoutAreasByDisplayTime.get(beat.displayStart).slots.slice();
                 holes.sort((a, b) => a.topY - b.topY);
             }
-            let y = bottomY;
-            while (y > topY) {
-                let lineY = topY;
-                // draw until next hole (if hole reaches into line)
-                if (holes.length > 0 && holes[holes.length - 1].bottomY > lineY) {
-                    const bottomHole = holes.pop();
-                    lineY = cy + bottomHole.bottomY;
-                    canvas.fillRect(x, lineY, this.smuflMetrics.stemThickness, y - lineY);
-                    y = cy + bottomHole.topY;
-                }
-                else {
-                    canvas.fillRect(x, lineY, this.smuflMetrics.stemThickness, y - lineY);
-                    break;
+            // fast path -> single note == full line
+            if (holes.length === 1) {
+                canvas.fillRect(x, topY, this.smuflMetrics.stemThickness, bottomY - topY);
+                return;
+            }
+            const bottomYRelative = bottomY - cy;
+            // slow path -> multiple notes == lines between notes
+            const bottomHole = holes[holes.length - 1];
+            canvas.fillRect(x, cy + bottomHole.bottomY, this.smuflMetrics.stemThickness, bottomYRelative - bottomHole.bottomY);
+            for (let i = holes.length - 1; i > 0; i--) {
+                const bottomHoleY = holes[i].topY;
+                const topHoleY = holes[i - 1].bottomY;
+                if (topHoleY < bottomHoleY) {
+                    canvas.fillRect(x, cy + topHoleY, this.smuflMetrics.stemThickness, bottomHoleY - topHoleY);
                 }
             }
         }
@@ -74173,6 +74474,15 @@ class TabBarRenderer extends LineBarRenderer {
             _?.[Symbol.dispose]?.();
         }
     }
+    calculateOverflows(rendererTop, rendererBottom) {
+        super.calculateOverflows(rendererTop, rendererBottom);
+        if (this.bar.isEmpty) {
+            return;
+        }
+        if (this.rhythmMode !== TabRhythmMode.Hidden) {
+            this.calculateBeamingOverflows(rendererTop, rendererBottom);
+        }
+    }
 }
 
 /**
@@ -76350,16 +76660,17 @@ class GpifWriter {
             beatNode.addElement('Fadding').innerText = FadeType[beat.fade];
         }
         if (beat.isTremolo) {
-            switch (beat.tremoloSpeed) {
-                case Duration.Eighth:
+            switch (beat.tremoloPicking.marks) {
+                case 1:
                     beatNode.addElement('Tremolo').innerText = '1/2';
                     break;
-                case Duration.Sixteenth:
+                case 2:
                     beatNode.addElement('Tremolo').innerText = '1/4';
                     break;
-                case Duration.ThirtySecond:
+                case 3:
                     beatNode.addElement('Tremolo').innerText = '1/8';
                     break;
+                // NOTE: guitar pro does not support other tremolos
             }
         }
         if (beat.hasChord) {
@@ -79356,6 +79667,8 @@ const _barrel$2 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty(
     get TrackNamePolicy () { return TrackNamePolicy; },
     TrackStyle,
     get TrackSubElement () { return TrackSubElement; },
+    TremoloPickingEffect,
+    get TremoloPickingStyle () { return TremoloPickingStyle; },
     get TripletFeel () { return TripletFeel; },
     Tuning,
     TupletGroup,