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

package/dist/alphaTab.js

@@ -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
@@ -209,9 +209,9 @@
      * @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}`);
@@ -4646,9 +4646,12 @@
         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";
@@ -6955,6 +6958,61 @@
         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
@@ -7377,13 +7435,59 @@
          * 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.
          */
@@ -7678,6 +7782,12 @@
             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 ? exports.NotationMode.GuitarPro : settings.notation.notationMode;
             let isGradual = this.text === 'grad' || this.text === 'grad.';
             if (isGradual && displayMode === exports.NotationMode.SongBook) {
@@ -8086,6 +8196,23 @@
         }
     }
 
+    // <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
@@ -8138,7 +8265,7 @@
             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;
@@ -8521,6 +8648,11 @@
             ['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'],
@@ -9281,7 +9413,15 @@
             ],
             ['volume', [[[[16], 0]]]],
             ['balance', [[[[16], 0]]]],
-            ['tp', [[[[16], 0, ['8', '16', '32']]]]],
+            [
+                'tp',
+                [
+                    [
+                        [[16], 0],
+                        [[10, 17], 1, ['default', 'buzzroll']]
+                    ]
+                ]
+            ],
             [
                 'barre',
                 [
@@ -15199,28 +15339,45 @@
                     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;
@@ -16427,7 +16584,11 @@
                     : 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:
@@ -16828,9 +16989,6 @@
             // 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) {
@@ -21451,18 +21609,9 @@
             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) {
@@ -23709,15 +23858,17 @@
                         }
                         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;
@@ -28785,16 +28936,12 @@
                         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
@@ -37905,6 +38052,38 @@
         }
     }
 
+    /**
+     * @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
      */
@@ -37987,7 +38166,9 @@
             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);
@@ -38113,8 +38294,14 @@
                 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);
@@ -39428,6 +39615,7 @@
             clone.tuningGlyphStringRowPadding = original.tuningGlyphStringRowPadding;
             clone.directionsScale = original.directionsScale;
             clone.multiVoiceDisplacedNoteHeadSpacing = original.multiVoiceDisplacedNoteHeadSpacing;
+            clone.stemFlagHeight = new Map(original.stemFlagHeight);
             return clone;
         }
     }
@@ -39739,6 +39927,20 @@
             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) {
@@ -40085,6 +40287,19 @@
          * 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 = 
@@ -40217,6 +40432,10 @@
                     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]
@@ -41173,6 +41392,14 @@
                     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]
@@ -41820,6 +42047,13 @@
             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) {
@@ -42101,6 +42335,12 @@
                 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;
         }
@@ -48322,7 +48562,12 @@
         }
         _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) {
@@ -48748,6 +48993,12 @@
         beat;
         preNotes;
         onNotes;
+        getLowestNoteY(requestedPosition) {
+            return this.onNotes.getLowestNoteY(requestedPosition);
+        }
+        getHighestNoteY(requestedPosition) {
+            return this.onNotes.getHighestNoteY(requestedPosition);
+        }
         get beatId() {
             return this.beat.id;
         }
@@ -48811,7 +49062,7 @@
             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;
@@ -60021,16 +60272,22 @@
                 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) {
@@ -60260,6 +60517,20 @@
             }
             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) {
@@ -60272,14 +60543,14 @@
             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)) {
@@ -60949,16 +61220,18 @@
             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;
@@ -60966,6 +61239,12 @@
         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) {
@@ -61060,7 +61339,6 @@
         voice = null;
         beats = [];
         shortestDuration = Duration.QuadrupleWhole;
-        tremoloDuration;
         /**
          * an indicator whether any beat has a tuplet on it.
          */
@@ -61103,43 +61381,9 @@
                 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:
@@ -61167,18 +61411,6 @@
             }
             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;
@@ -61212,11 +61444,6 @@
                 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;
                 }
@@ -62115,9 +62342,6 @@
         }
         completeBeamingHelper(_helper) {
         }
-        getBeatDirection(beat) {
-            return this.helpers.getBeamingHelperForBeat(beat)?.direction ?? BeamDirection.Up;
-        }
     }
 
     /**
@@ -67200,11 +67424,11 @@
                 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);
@@ -67653,6 +67877,12 @@
         get isLastOfVoice() {
             return false;
         }
+        getLowestNoteY(_requestedPosition) {
+            return 0;
+        }
+        getHighestNoteY(_requestedPosition) {
+            return 0;
+        }
         getNoteY(_note, _requestedPosition) {
             return 0;
         }
@@ -67804,6 +68034,11 @@
         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;
@@ -68008,9 +68243,17 @@
                 }
             }
         }
+        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;
@@ -68319,26 +68562,6 @@
                 }
             }
         }
-        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();
@@ -68350,6 +68573,9 @@
             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() {
@@ -68376,7 +68602,13 @@
                     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;
@@ -68482,21 +68714,22 @@
         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) {
@@ -68505,14 +68738,14 @@
                             }
                         }
                         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) {
@@ -68522,19 +68755,20 @@
                         }
                     }
                     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) {
@@ -68543,14 +68777,14 @@
                         }
                         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) {
@@ -68627,38 +68861,11 @@
             // 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
@@ -68714,9 +68921,9 @@
                 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;
@@ -68726,6 +68933,37 @@
                 }
             }
         }
+        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;
         }
@@ -68829,7 +69067,9 @@
                         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 +
@@ -68894,44 +69134,12 @@
             }
             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)) {
@@ -69014,6 +69222,19 @@
                 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);
+            }
+        }
     }
 
     /**
@@ -69182,132 +69403,6 @@
         }
     }
 
-    /**
-     * @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
      */
@@ -69357,6 +69452,44 @@
         }
     }
 
+    /**
+     * @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
      */
@@ -69720,8 +69853,8 @@
         _infos = [];
         _noteHeadInfo;
         noteGroup;
-        minNote = null;
-        maxNote = null;
+        minStepsNote = null;
+        maxStepsNote = null;
         get stemX() {
             if (!this.noteGroup) {
                 return 0;
@@ -69734,25 +69867,19 @@
             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) {
@@ -69988,7 +70115,7 @@
             }
         }
         _paintLedgerLines(cx, cy, canvas) {
-            if (!this.minNote) {
+            if (!this.minStepsNote) {
                 return;
             }
             const scoreRenderer = this.renderer;
@@ -70000,8 +70127,8 @@
                 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) {
@@ -70024,21 +70151,87 @@
      * @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;
+        }
     }
 
     /**
@@ -70049,6 +70242,7 @@
         _notes = [];
         _deadSlapped = null;
         _tremoloPicking = null;
+        _stemLengthExtension = 0;
         aboveBeatEffects = new Map();
         belowBeatEffects = new Map();
         beat;
@@ -70070,7 +70264,7 @@
                 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);
@@ -70103,19 +70297,26 @@
             }
             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;
@@ -70131,20 +70332,20 @@
                             ? 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;
@@ -70176,14 +70377,15 @@
             }
             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;
@@ -70217,27 +70419,27 @@
                 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) {
@@ -70486,17 +70688,17 @@
             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();
         }
@@ -70729,6 +70931,89 @@
         }
     }
 
+    /**
+     * @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
      */
@@ -70767,9 +71052,6 @@
         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);
@@ -70801,20 +71083,34 @@
             }
             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:
@@ -70822,8 +71118,9 @@
                     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;
@@ -70906,10 +71203,18 @@
             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);
@@ -70938,6 +71243,24 @@
                     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;
@@ -71004,9 +71327,6 @@
                 }
                 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);
             }
@@ -71026,13 +71346,7 @@
             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) {
@@ -71046,7 +71360,7 @@
             }
             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')) {
@@ -71363,16 +71677,16 @@
                 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;
                 }
@@ -72062,15 +72376,15 @@
             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();
@@ -72252,73 +72566,26 @@
         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;
@@ -72332,50 +72599,9 @@
             }
             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) {
@@ -72392,34 +72618,6 @@
             }
             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;
         }
@@ -72561,27 +72759,62 @@
         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) {
@@ -72624,6 +72857,8 @@
      * @internal
      */
     class SlashBeatGlyph extends BeatOnNoteGlyphBase {
+        _tremoloPicking;
+        _stemLengthExtension = 0;
         noteHeads = null;
         deadSlapped = null;
         restGlyph = null;
@@ -72666,17 +72901,18 @@
                 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:
@@ -72684,35 +72920,70 @@
                     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
@@ -72741,11 +73012,16 @@
             }
             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);
@@ -72780,6 +73056,27 @@
                 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);
+            }
         }
     }
 
@@ -72814,15 +73111,15 @@
             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();
@@ -72909,45 +73206,26 @@
         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
@@ -72991,6 +73269,9 @@
             }
             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 {
@@ -73037,6 +73318,15 @@
             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;
@@ -73111,11 +73401,12 @@
                 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]?.();
@@ -73126,7 +73417,7 @@
             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 {
@@ -73185,11 +73476,11 @@
             }
             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)) {
@@ -73197,23 +73488,44 @@
                 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) {
@@ -73339,6 +73651,20 @@
             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) {
@@ -73349,6 +73675,7 @@
             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:
@@ -73356,17 +73683,18 @@
                     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) {
@@ -73384,7 +73712,7 @@
                 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;
@@ -73407,8 +73735,7 @@
                 //
                 // 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);
@@ -73417,7 +73744,7 @@
                 // Note dots
                 //
                 if (this.container.beat.dots > 0 && tabRenderer.rhythmMode !== exports.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));
                     }
@@ -73479,8 +73806,8 @@
             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;
@@ -74007,30 +74334,6 @@
                 }
             }
         }
-        adjustSizes() {
-            if (this.rhythmMode !== exports.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) {
@@ -74111,32 +74414,29 @@
         drawBeamHelperAsFlags(h) {
             return super.drawBeamHelperAsFlags(h) || this.rhythmMode === exports.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;
@@ -74159,19 +74459,20 @@
                     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);
                     }
                 }
             }
@@ -74179,6 +74480,15 @@
                 _?.[Symbol.dispose]?.();
             }
         }
+        calculateOverflows(rendererTop, rendererBottom) {
+            super.calculateOverflows(rendererTop, rendererBottom);
+            if (this.bar.isEmpty) {
+                return;
+            }
+            if (this.rhythmMode !== exports.TabRhythmMode.Hidden) {
+                this.calculateBeamingOverflows(rendererTop, rendererBottom);
+            }
+        }
     }
 
     /**
@@ -76356,16 +76666,17 @@
                 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) {
@@ -79362,6 +79673,8 @@
         get TrackNamePolicy () { return TrackNamePolicy; },
         TrackStyle,
         get TrackSubElement () { return TrackSubElement; },
+        TremoloPickingEffect,
+        get TremoloPickingStyle () { return TremoloPickingStyle; },
         get TripletFeel () { return TripletFeel; },
         Tuning,
         TupletGroup,