@coderline/alphatab 1.9.0-alpha.1785 → 1.9.0-alpha.1804

package/dist/alphaTab.core.mjs

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.9.0-alpha.1785 (develop, build 1785)
+ * alphaTab v1.9.0-alpha.1804 (develop, build 1804)
  *
  * Copyright © 2026, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -203,9 +203,9 @@ class AlphaTabError extends Error {
  * @internal
  */
 class VersionInfo {
-    static version = '1.9.0-alpha.1785';
-    static date = '2026-04-27T03:55:02.662Z';
-    static commit = '760ed909a3d8dc36b159d23b4ff6780e95a3daf1';
+    static version = '1.9.0-alpha.1804';
+    static date = '2026-05-16T03:54:50.685Z';
+    static commit = '6e757c0cbec66598a7fa5327abc9d05616984486';
     static print(print) {
         print(`alphaTab ${VersionInfo.version}`);
         print(`commit: ${VersionInfo.commit}`);
@@ -992,6 +992,38 @@ var SlideOutType;
     SlideOutType[SlideOutType["PickSlideUp"] = 6] = "PickSlideUp";
 })(SlideOutType || (SlideOutType = {}));
 
+/**
+ * A slur arc spanning two notes, optionally with inner articulation
+ * segments. Corresponds conceptually to a MusicXML `<slur>` element
+ * plus the technique spans inside it.
+ *
+ * For this PR only effect slurs (hammer-pull + legato-slide chains)
+ * are derived in `Note.finish()`. Phrase and legato slurs may join
+ * this type in a future PR; a discriminator will be added at that
+ * point.
+ * @internal
+ */
+class Slur {
+    originNote;
+    destinationNote;
+    segments = [];
+}
+
+/**
+ * Articulation kind for an inner span of a {@link Slur}.
+ *
+ * Drives the renderer's font selection (which {@link NotationElement} to
+ * use) and the default label text when {@link SlurSegment.text} is null.
+ * `Note.finish()` classifies the kind once when building the slur; the
+ * renderer never re-derives it.
+ * @internal
+ */
+var SlurSegmentKind;
+(function (SlurSegmentKind) {
+    SlurSegmentKind[SlurSegmentKind["HammerPull"] = 0] = "HammerPull";
+    SlurSegmentKind[SlurSegmentKind["LegatoSlide"] = 1] = "LegatoSlide";
+})(SlurSegmentKind || (SlurSegmentKind = {}));
+
 /**
  * This public enum lists all vibrato types that can be performed.
  * @public
@@ -1332,6 +1364,14 @@ var NotationElement;
      * The slurs shown on bend effects within the score staff.
      */
     NotationElement[NotationElement["ScoreBendSlur"] = 55] = "ScoreBendSlur";
+    /**
+     * The hammer-on pull-off text shown on slurs.
+     */
+    NotationElement[NotationElement["EffectHammerOnPullOffText"] = 56] = "EffectHammerOnPullOffText";
+    /**
+     * The slide text shown on slurs.
+     */
+    NotationElement[NotationElement["EffectSlideText"] = 57] = "EffectSlideText";
 })(NotationElement || (NotationElement = {}));
 /**
  * The notation settings control how various music notation elements are shown and behaving
@@ -6128,6 +6168,16 @@ class Note {
      * @json_ignore
      */
     effectSlurDestination = null;
+    /**
+     * The {@link Slur} object whose origin is this note. Populated by
+     * `finish()`; non-null only on the chain-origin note of an effect
+     * slur. Carries the inner articulation segments used by the
+     * renderer to paint H/P/sl. labels along the arc.
+     * @clone_ignore
+     * @json_ignore
+     * @internal
+     */
+    effectSlur = null;
     /**
      * The ornament applied on the note.
      */
@@ -6412,23 +6462,50 @@ class Note {
                 break;
         }
         let effectSlurDestination = null;
+        let effectSlurSegmentKind = null;
         if (this.isHammerPullOrigin && this.hammerPullDestination) {
             effectSlurDestination = this.hammerPullDestination;
+            effectSlurSegmentKind = SlurSegmentKind.HammerPull;
         }
         else if (this.slideOutType === SlideOutType.Legato && this.slideTarget) {
             effectSlurDestination = this.slideTarget;
+            effectSlurSegmentKind = SlurSegmentKind.LegatoSlide;
         }
         if (effectSlurDestination) {
             this.hasEffectSlur = true;
             if (this.effectSlurOrigin && this.beat.pickStroke === PickStroke.None) {
-                this.effectSlurOrigin.effectSlurDestination = effectSlurDestination;
-                this.effectSlurOrigin.effectSlurDestination.effectSlurOrigin = this.effectSlurOrigin;
+                const chainOrigin = this.effectSlurOrigin;
+                chainOrigin.effectSlurDestination = effectSlurDestination;
+                effectSlurDestination.effectSlurOrigin = chainOrigin;
                 this.effectSlurOrigin = null;
+                if (effectSlurSegmentKind !== null && chainOrigin.effectSlur !== null) {
+                    chainOrigin.effectSlur.destinationNote = effectSlurDestination;
+                    chainOrigin.effectSlur.segments.push({
+                        fromNote: this,
+                        toNote: effectSlurDestination,
+                        kind: effectSlurSegmentKind,
+                        text: null
+                    });
+                }
             }
             else {
                 this.isEffectSlurOrigin = true;
                 this.effectSlurDestination = effectSlurDestination;
-                this.effectSlurDestination.effectSlurOrigin = this;
+                effectSlurDestination.effectSlurOrigin = this;
+                // Always allocate a fresh Slur — finish() may run twice (worker re-finish);
+                // overwriting unconditionally keeps the derivation idempotent.
+                const slur = new Slur();
+                slur.originNote = this;
+                slur.destinationNote = effectSlurDestination;
+                if (effectSlurSegmentKind !== null) {
+                    slur.segments.push({
+                        fromNote: this,
+                        toNote: effectSlurDestination,
+                        kind: effectSlurSegmentKind,
+                        text: null
+                    });
+                }
+                this.effectSlur = slur;
             }
         }
         // try to detect what kind of bend was used and cleans unneeded points if required
@@ -7678,6 +7755,23 @@ class Beat {
      * @json_ignore
      */
     effectSlurDestination = null;
+    /**
+     * Convenience accessor for the {@link Slur} of this beat. Returns
+     * the effect slur of whichever note in this beat owns it (the
+     * chain-origin note populated during `Note.finish()`), or `null`
+     * when no note in the beat is an effect-slur origin.
+     * @clone_ignore
+     * @json_ignore
+     * @internal
+     */
+    get effectSlur() {
+        for (const n of this.notes) {
+            if (n.effectSlur !== null) {
+                return n.effectSlur;
+            }
+        }
+        return null;
+    }
     /**
      * Gets or sets how the beaming should be done for this beat.
      */
@@ -10221,7 +10315,7 @@ class IOHelper {
             encoding = 'utf-8';
         }
         const decoder = new TextDecoder(encoding);
-        return decoder.decode(data.buffer);
+        return decoder.decode(data);
     }
     static _detectEncoding(data) {
         if (data.length > 2 && data[0] === 0xfe && data[1] === 0xff) {
@@ -19651,7 +19745,7 @@ class Gp3To5Importer extends ScoreImporter {
     static _versionString = 'FICHIER GUITAR PRO ';
     // NOTE: General Midi only defines percussion instruments from 35-81
     // Guitar Pro 5 allowed GS extensions (27-34 and 82-87)
-    // GP7-8 do not have all these definitions anymore, this lookup ensures some fallback 
+    // GP7-8 do not have all these definitions anymore, this lookup ensures some fallback
     // (even if they are not correct)
     // we can support this properly in future when we allow custom alphaTex articulation definitions
     // then we don't need to rely on GP specifics anymore but handle things on export/import
@@ -21042,12 +21136,13 @@ class GpBinaryHelpers {
      * @returns
      */
     static gpReadStringByteLength(data, length, encoding) {
+        // Fixed-width string field: 1 length byte + `length` data bytes, decoded
+        // up to min(stringLength, length). Always consumes 1 + length bytes.
         const stringLength = data.readByte();
-        const s = GpBinaryHelpers.gpReadString(data, stringLength, encoding);
-        if (stringLength < length) {
-            data.skip(length - stringLength);
-        }
-        return s;
+        const fieldBytes = new Uint8Array(length);
+        data.read(fieldBytes, 0, length);
+        const effectiveLength = Math.min(stringLength, length);
+        return IOHelper.toString(fieldBytes.subarray(0, effectiveLength), encoding);
     }
 }
 /**
@@ -24267,6 +24362,10 @@ class GpifParser {
         }
         // build masterbar automations
         for (const [barNumber, automations] of this._masterTrackAutomations) {
+            if (barNumber < 0 || barNumber >= this.score.masterBars.length) {
+                // automation references a bar that is not in the score's masterBars list
+                continue;
+            }
             const masterBar = this.score.masterBars[barNumber];
             for (let i = 0, j = automations.length; i < j; i++) {
                 const automation = automations[i];
@@ -31942,7 +32041,9 @@ class RenderingResources {
         [NotationElement.RepeatCount, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
         [NotationElement.BarNumber, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
         [NotationElement.ScoreBendSlur, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
-        [NotationElement.EffectAlternateEndings, new Font(RenderingResources._serifFont, 15, FontStyle.Plain)]
+        [NotationElement.EffectAlternateEndings, new Font(RenderingResources._serifFont, 15, FontStyle.Plain)],
+        [NotationElement.EffectHammerOnPullOffText, RenderingResources._effectFont],
+        [NotationElement.EffectSlideText, RenderingResources._effectFont]
     ]);
     /**
      * The name of the SMuFL Font to use for rendering music symbols.
@@ -32233,9 +32334,16 @@ class RenderingResources {
                 notationElement = NotationElement.ScoreWords;
                 break;
         }
+        return this.getFontForNotationElement(notationElement);
+    }
+    /**
+     * @internal
+     * @param element
+     */
+    getFontForNotationElement(notationElement) {
         return this.elementFonts.has(notationElement)
             ? this.elementFonts.get(notationElement)
-            : RenderingResources.defaultFonts.get(NotationElement.ScoreWords);
+            : RenderingResources.defaultFonts.get(notationElement);
     }
 }
 
@@ -49161,6 +49269,21 @@ class MasterBarTickLookup {
     }
 }
 
+/**
+ * Represents a range of the song that should be played.
+ * @public
+ */
+class PlaybackRange {
+    /**
+     * The position in midi ticks from where the song should start.
+     */
+    startTick = 0;
+    /**
+     * The position in midi ticks to where the song should be played.
+     */
+    endTick = 0;
+}
+
 /**
  * Describes how a cursor should be moving.
  * @public
@@ -49321,6 +49444,13 @@ class MidiTickLookup {
      * @internal
      */
     masterBarLookup = new Map();
+    /**
+     * A dictionary of all beat played. The index is the id to {@link Beat.id}.
+     * The value is the bar relative tick time at which the beat was registered during midi generation.
+     * This lookup only contains the first time a Beat is played.
+     * @internal
+     */
+    beatLookup = new Map();
     /**
      * A list of all {@link MasterBarTickLookup} sorted by time.
      */
@@ -49687,10 +49817,22 @@ class MidiTickLookup {
      * @returns The time in midi ticks at which the beat is played the first time or 0 if the beat is not contained
      */
     getBeatStart(beat) {
-        if (!this.masterBarLookup.has(beat.voice.bar.index)) {
+        if (!this.masterBarLookup.has(beat.voice.bar.index) || !this.beatLookup.has(beat.id)) {
             return 0;
         }
-        return this.masterBarLookup.get(beat.voice.bar.index).start + beat.playbackStart;
+        const mb = this.masterBarLookup.get(beat.voice.bar.index);
+        return mb.start + this.beatLookup.get(beat.id).startTick;
+    }
+    /**
+     * Gets the playback range in midi ticks for a given beat.
+     * @param beat The beat to find the time period for.
+     * @returns The relative playback range within the parent masterbar at which the beat start and ends playing
+     */
+    getRelativeBeatPlaybackRange(beat) {
+        if (!this.beatLookup.has(beat.id)) {
+            return undefined;
+        }
+        return this.beatLookup.get(beat.id);
     }
     /**
      * Adds a new {@link MasterBarTickLookup} to the lookup table.
@@ -49708,6 +49850,12 @@ class MidiTickLookup {
         }
     }
     addBeat(beat, start, duration) {
+        if (!this.beatLookup.has(beat.id)) {
+            const playbackRange = new PlaybackRange();
+            playbackRange.startTick = start;
+            playbackRange.endTick = start + duration;
+            this.beatLookup.set(beat.id, playbackRange);
+        }
         const currentMasterBar = this._currentMasterBar;
         if (currentMasterBar) {
             // pre-beat grace notes at the start of the bar we also add the beat to the previous bar
@@ -52291,21 +52439,6 @@ class ActiveBeatsChangedEventArgs {
     }
 }
 
-/**
- * Represents a range of the song that should be played.
- * @public
- */
-class PlaybackRange {
-    /**
-     * The position in midi ticks from where the song should start.
-     */
-    startTick = 0;
-    /**
-     * The position in midi ticks to where the song should be played.
-     */
-    endTick = 0;
-}
-
 /**
  * A {@link IAlphaSynth} implementation wrapping and underling other {@link IAlphaSynth}
  * allowing dynamic changing of the underlying instance without loosing aspects like the
@@ -55506,23 +55639,24 @@ class AlphaTabApiBase {
         if (this._selectionStart && this._tickCache) {
             // get the start and stop ticks (which consider properly repeats)
             const tickCache = this._tickCache;
-            const realMasterBarStart = tickCache.getMasterBarStart(this._selectionStart.beat.voice.bar.masterBar);
+            const realStartMasterBarStart = tickCache.getMasterBarStart(this._selectionStart.beat.voice.bar.masterBar);
+            const startBeatPlaybackRange = tickCache.getRelativeBeatPlaybackRange(this._selectionStart.beat);
+            const startBeatPlaybackStart = startBeatPlaybackRange?.startTick ?? this._selectionStart.beat.playbackStart;
             // move to selection start
             this._currentBeat = null; // reset current beat so it is updating the cursor
             if (this._player.state === PlayerState.Paused) {
-                this._cursorUpdateTick(this._tickCache.getBeatStart(this._selectionStart.beat), false, 1);
+                this._cursorUpdateTick(realStartMasterBarStart + startBeatPlaybackStart, false, 1);
             }
-            this.tickPosition = realMasterBarStart + this._selectionStart.beat.playbackStart;
+            this.tickPosition = realStartMasterBarStart + startBeatPlaybackStart;
             // set playback range
             if (this._selectionEnd && this._selectionStart.beat !== this._selectionEnd.beat) {
-                const realMasterBarEnd = tickCache.getMasterBarStart(this._selectionEnd.beat.voice.bar.masterBar);
+                const realEndMasterBarStart = tickCache.getMasterBarStart(this._selectionEnd.beat.voice.bar.masterBar);
+                const endBeatPlaybackRange = tickCache.getRelativeBeatPlaybackRange(this._selectionEnd.beat);
+                const endBeatPlaybackEnd = endBeatPlaybackRange?.endTick ??
+                    this._selectionEnd.beat.playbackStart + this._selectionEnd.beat.playbackDuration;
                 const range = new PlaybackRange();
-                range.startTick = realMasterBarStart + this._selectionStart.beat.playbackStart;
-                range.endTick =
-                    realMasterBarEnd +
-                        this._selectionEnd.beat.playbackStart +
-                        this._selectionEnd.beat.playbackDuration -
-                        50;
+                range.startTick = realStartMasterBarStart + startBeatPlaybackStart;
+                range.endTick = realEndMasterBarStart + endBeatPlaybackEnd - 50;
                 this.playbackRange = range;
             }
             else {
@@ -61569,6 +61703,12 @@ class TieGlyph extends Glyph {
     _tieHeight = 0;
     _boundingBox;
     _shouldPaint = false;
+    // Resolved per-label paint state. Lazily grown; re-layouts mutate
+    // existing entries in place and update `_resolvedLabelCount` to
+    // signal how many of them are valid this pass.
+    _resolvedLabels = [];
+    _resolvedLabelCount = 0;
+    _labelBaselineOffset = 0;
     get checkForOverflow() {
         return this._shouldPaint && this._boundingBox !== undefined;
     }
@@ -61638,16 +61778,88 @@ class TieGlyph extends Glyph {
         }
         this._boundingBox = undefined;
         this.y = Math.min(this._startY, this._endY);
+        const down = this.tieDirection === BeamDirection.Down;
         let tieBoundingBox;
+        // Bezier control points for the tie. Computed once and reused
+        // for both the bounding box (via _calculateActualTieHeightFromCps)
+        // and label-apex sampling further below — avoids a redundant
+        // call to _computeBezierControlPoints (and its 14-element array
+        // allocation) per labeled slur per layout.
+        let cps = [];
         if (this.shouldDrawBendSlur()) {
             this._tieHeight = 0;
-            tieBoundingBox = TieGlyph.calculateBendSlurHeight(this._startX, this._startY, this._endX, this._endY, this.tieDirection === BeamDirection.Down, this.renderer.smuflMetrics.tieHeight);
+            tieBoundingBox = TieGlyph.calculateBendSlurHeight(this._startX, this._startY, this._endX, this._endY, down, this.renderer.smuflMetrics.tieHeight);
         }
         else {
             this._tieHeight = this.getTieHeight(this._startX, this._startY, this._endX, this._endY);
-            tieBoundingBox = TieGlyph.calculateActualTieHeight(1, this._startX, this._startY, this._endX, this._endY, this.tieDirection === BeamDirection.Down, this._tieHeight, this.renderer.smuflMetrics.tieMidpointThickness);
+            const tieThickness = this.renderer.smuflMetrics.tieMidpointThickness;
+            cps = TieGlyph._computeBezierControlPoints(1, this._startX, this._startY, this._endX, this._endY, down, this._tieHeight, tieThickness);
+            tieBoundingBox = TieGlyph._calculateActualTieHeightFromCps(cps, this._startX, this._startY, this._endX, this._endY, down, tieThickness);
         }
         this._boundingBox = tieBoundingBox;
+        this._resolvedLabelCount = 0;
+        const labels = this.getSlurLabels();
+        if (labels !== null && labels.length > 0 && this.shouldPaintLabels()) {
+            const res = this.renderer.settings.display.resources;
+            const padding = this.renderer.smuflMetrics.oneStaffSpace * 0.25;
+            let maxTextHeight = 0;
+            // Single Y line for all labels — the outer arc apex.
+            // Painted offset adds `padding` on the outward side, so
+            // every label sits the same fixed distance from its arc.
+            const labelLineY = cps.length > 0
+                ? 0.125 * cps[7] + 0.375 * cps[9] + 0.375 * cps[11] + 0.125 * cps[13]
+                : (this._startY + this._endY) / 2;
+            for (const label of labels) {
+                const fromX = this.resolveLabelAnchorX(label.fromNote);
+                const toX = this.resolveLabelAnchorX(label.toNote);
+                if (fromX === null || toX === null) {
+                    continue;
+                }
+                const midX = (fromX + toX) / 2;
+                if (midX < this._startX || midX > this._endX) {
+                    continue;
+                }
+                // Per-element font.size as an upper bound on glyph
+                // height — avoids per-label measureText calls. All H/P
+                // and sl. labels use the same _effectFont, so this is
+                // typically computed once.
+                const font = res.getFontForNotationElement(label.element);
+                if (font.size > maxTextHeight) {
+                    maxTextHeight = font.size;
+                }
+                // grow cache lazily; mutate existing slot in place otherwise
+                let slot;
+                if (this._resolvedLabelCount < this._resolvedLabels.length) {
+                    slot = this._resolvedLabels[this._resolvedLabelCount];
+                    slot.x = midX;
+                    slot.y = labelLineY;
+                    slot.text = label.text;
+                    slot.element = label.element;
+                }
+                else {
+                    slot = {
+                        x: midX,
+                        y: labelLineY,
+                        text: label.text,
+                        element: label.element
+                    };
+                    this._resolvedLabels.push(slot);
+                }
+                this._resolvedLabelCount++;
+            }
+            if (this._resolvedLabelCount > 0) {
+                // canvas.textBaseline is 'hanging' (TextBaseline.Top), so
+                // fillText positions `y` at the glyph's top edge.
+                if (this.tieDirection === BeamDirection.Up) {
+                    tieBoundingBox.y -= maxTextHeight + padding;
+                    this._labelBaselineOffset = -(maxTextHeight + padding);
+                }
+                else {
+                    this._labelBaselineOffset = padding;
+                }
+                tieBoundingBox.h += maxTextHeight + padding;
+            }
+        }
         this.height = tieBoundingBox.h;
         if (this.tieDirection === BeamDirection.Up) {
             // the tie might go above `this.y` due to its shape
@@ -61663,12 +61875,76 @@ class TieGlyph extends Glyph {
         if (!this._shouldPaint) {
             return;
         }
+        const isDown = this.tieDirection === BeamDirection.Down;
         if (this.shouldDrawBendSlur()) {
-            TieGlyph.drawBendSlur(canvas, cx + this._startX, cy + this._startY, cx + this._endX, cy + this._endY, this.tieDirection === BeamDirection.Down, this.renderer.smuflMetrics.tieHeight);
+            TieGlyph.drawBendSlur(canvas, cx + this._startX, cy + this._startY, cx + this._endX, cy + this._endY, isDown, this.renderer.smuflMetrics.tieHeight);
+        }
+        else {
+            TieGlyph.paintTie(canvas, 1, cx + this._startX, cy + this._startY, cx + this._endX, cy + this._endY, isDown, this._tieHeight, this.renderer.smuflMetrics.tieMidpointThickness);
+        }
+        if (this._resolvedLabelCount > 0) {
+            const ta = canvas.textAlign;
+            const tb = canvas.textBaseline;
+            canvas.textAlign = TextAlign.Center;
+            canvas.textBaseline = TextBaseline.Top;
+            const res = this.renderer.resources;
+            let lastElement = -1;
+            for (let i = 0; i < this._resolvedLabelCount; i++) {
+                const label = this._resolvedLabels[i];
+                if (label.element !== lastElement) {
+                    canvas.font = res.getFontForNotationElement(label.element);
+                    lastElement = label.element;
+                }
+                canvas.fillText(label.text, cx + label.x, cy + label.y + this._labelBaselineOffset);
+            }
+            canvas.textAlign = ta;
+            canvas.textBaseline = tb;
+        }
+    }
+    /**
+     * Returns the labels to paint along this slur, or `null` when there
+     * are none. Override in subclasses.
+     */
+    getSlurLabels() {
+        return null;
+    }
+    /**
+     * Whether label painting is enabled. Defaults to `true`. Subclasses
+     * may override to disable labels on the bend-slur path or other
+     * special cases.
+     */
+    shouldPaintLabels() {
+        return !this.shouldDrawBendSlur();
+    }
+    /**
+     * Looks up the absolute X coordinate of an anchor note. Reuses
+     * the start/end bar renderers already resolved by the subclass
+     * (NoteTieGlyph) when the note's bar matches — most labels live
+     * in the slur's start or end bar, so this avoids the double Map
+     * lookup in `getRendererForBar` per label per layout. Returns
+     * `null` when the note's bar is not rendered on this glyph's
+     * staff (cross-system case).
+     */
+    resolveLabelAnchorX(note) {
+        const bar = note.beat.voice.bar;
+        let renderer = null;
+        const start = this.lookupStartBeatRenderer();
+        if (start !== null && start.bar === bar) {
+            renderer = start;
         }
         else {
-            TieGlyph.paintTie(canvas, 1, cx + this._startX, cy + this._startY, cx + this._endX, cy + this._endY, this.tieDirection === BeamDirection.Down, this._tieHeight, this.renderer.smuflMetrics.tieMidpointThickness);
+            const end = this.lookupEndBeatRenderer();
+            if (end !== null && end.bar === bar) {
+                renderer = end;
+            }
+            else {
+                renderer = this.renderer.scoreRenderer.layout.getRendererForBar(this.renderer.staff.staffId, bar);
+            }
         }
+        if (renderer === null) {
+            return null;
+        }
+        return renderer.x + renderer.getNoteX(note, NoteXPosition.Center);
     }
     getTieHeight(_startX, _startY, _endX, _endY) {
         return this.renderer.smuflMetrics.tieHeight;
@@ -61688,11 +61964,18 @@ class TieGlyph extends Glyph {
     }
     static calculateActualTieHeight(scale, x1, y1, x2, y2, down, offset, size) {
         const cp = TieGlyph._computeBezierControlPoints(scale, x1, y1, x2, y2, down, offset, size);
+        return TieGlyph._calculateActualTieHeightFromCps(cp, x1, y1, x2, y2, down, size);
+    }
+    /**
+     * Derives the bounding box for a tie from already-computed control
+     * points. Splits the bbox math from cps generation so callers that
+     * need BOTH cps and bbox (e.g. multi-label slur layout) avoid a
+     * second call to `_computeBezierControlPoints`.
+     */
+    static _calculateActualTieHeightFromCps(cp, x1, y1, x2, y2, down, size) {
         if (cp.length === 0) {
             return new Bounds(x1, y1, x2 - x1, y2 - y1);
         }
-        // For a musical tie/slur, the extrema occur predictably near the midpoint
-        // Evaluate at midpoint (t=0.5) and check endpoints
         const p0x = cp[0];
         const p0y = cp[1];
         const c1x = cp[2];
@@ -61701,15 +61984,12 @@ class TieGlyph extends Glyph {
         const c2y = cp[5];
         const p1x = cp[6];
         const p1y = cp[7];
-        // Evaluate at t=0.5 for midpoint
         const midX = 0.125 * p0x + 0.375 * c1x + 0.375 * c2x + 0.125 * p1x;
         const midY = 0.125 * p0y + 0.375 * c1y + 0.375 * c2y + 0.125 * p1y;
-        // Bounds are simply min/max of start, end, and midpoint
         const xMin = Math.min(p0x, p1x, midX);
         const xMax = Math.max(p0x, p1x, midX);
         let yMin = Math.min(p0y, p1y, midY);
         let yMax = Math.max(p0y, p1y, midY);
-        // Account for thickness of the tie/slur
         if (down) {
             yMax += size;
         }
@@ -68898,11 +69178,43 @@ class TabTieGlyph extends NoteTieGlyph {
     }
 }
 
+/**
+ * Helpers for building `TieGlyphLabel` instances from model-side
+ * {@link SlurSegment}s.
+ * @internal
+ */
+class TieGlyphLabels {
+    /**
+     * Builds a `TieGlyphLabel` for one segment of a slur. The
+     * `isAscending` flag selects between the H/P glyph for hammer-on
+     * vs. pull-off — score side passes a comparison on `realValue`,
+     * tab side passes a comparison on `fret`.
+     */
+    static build(s, isAscending) {
+        if (s.kind === SlurSegmentKind.LegatoSlide) {
+            return {
+                fromNote: s.fromNote,
+                toNote: s.toNote,
+                text: s.text !== null ? s.text : 'sl.',
+                element: NotationElement.EffectSlideText
+            };
+        }
+        // HammerPull
+        return {
+            fromNote: s.fromNote,
+            toNote: s.toNote,
+            text: s.text !== null ? s.text : isAscending ? 'H' : 'P',
+            element: NotationElement.EffectHammerOnPullOffText
+        };
+    }
+}
+
 /**
  * @internal
  */
 class TabSlurGlyph extends TabTieGlyph {
     _forSlide;
+    _labels = null;
     constructor(slurEffectId, startNote, endNote, forSlide, forEnd) {
         super(slurEffectId, startNote, endNote, forEnd);
         this._forSlide = forSlide;
@@ -68910,6 +69222,22 @@ class TabSlurGlyph extends TabTieGlyph {
     getTieHeight(startX, _startY, endX, _endY) {
         return (Math.log(endX - startX + 1) * this.renderer.settings.notation.slurHeight) / 2;
     }
+    getSlurLabels() {
+        if (this._labels === null) {
+            this._labels = [];
+            const slur = this.startNote.effectSlur;
+            if (slur !== null) {
+                const notationSettings = this.renderer.settings.notation;
+                for (const s of slur.segments) {
+                    const label = TieGlyphLabels.build(s, s.toNote.fret >= s.fromNote.fret);
+                    if (notationSettings.isNotationElementVisible(label.element)) {
+                        this._labels.push(label);
+                    }
+                }
+            }
+        }
+        return this._labels.length > 0 ? this._labels : null;
+    }
     tryExpand(startNote, endNote, forSlide, forEnd) {
         // same type required
         if (this._forSlide !== forSlide) {
@@ -68935,6 +69263,7 @@ class TabSlurGlyph extends TabTieGlyph {
             case BeamDirection.Up:
                 if (startNote.realValue > this.startNote.realValue) {
                     this.startNote = startNote;
+                    this._labels = null; // invalidate cache — labels live on startNote
                 }
                 if (endNote.realValue > this.endNote.realValue) {
                     this.endNote = endNote;
@@ -68943,6 +69272,7 @@ class TabSlurGlyph extends TabTieGlyph {
             case BeamDirection.Down:
                 if (startNote.realValue < this.startNote.realValue) {
                     this.startNote = startNote;
+                    this._labels = null;
                 }
                 if (endNote.realValue < this.endNote.realValue) {
                     this.endNote = endNote;
@@ -73680,9 +74010,26 @@ class ScoreTieGlyph extends NoteTieGlyph {
  * @internal
  */
 class ScoreSlurGlyph extends ScoreTieGlyph {
+    _labels = null;
     getTieHeight(startX, _startY, endX, _endY) {
         return (Math.log2(endX - startX + 1) * this.renderer.settings.notation.slurHeight) / 2;
     }
+    getSlurLabels() {
+        if (this._labels === null) {
+            this._labels = [];
+            const slur = this.startNote.beat.effectSlur;
+            if (slur !== null) {
+                const notationSettings = this.renderer.settings.notation;
+                for (const s of slur.segments) {
+                    const label = TieGlyphLabels.build(s, s.toNote.realValue >= s.fromNote.realValue);
+                    if (notationSettings.isNotationElementVisible(label.element)) {
+                        this._labels.push(label);
+                    }
+                }
+            }
+        }
+        return this._labels.length > 0 ? this._labels : null;
+    }
     calculateStartX() {
         return (this.renderer.x +
             (this._isStartCentered()