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

package/dist/alphaTab.js

@@ -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.
  *
@@ -209,9 +209,9 @@
      * @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}`);
@@ -998,6 +998,38 @@
         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
@@ -1338,6 +1370,14 @@
          * 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";
     })(exports.NotationElement || (exports.NotationElement = {}));
     /**
      * The notation settings control how various music notation elements are shown and behaving
@@ -6134,6 +6174,16 @@
          * @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.
          */
@@ -6418,23 +6468,50 @@
                     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
@@ -7684,6 +7761,23 @@
          * @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.
          */
@@ -10227,7 +10321,7 @@
                 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) {
@@ -19657,7 +19751,7 @@
         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
@@ -21048,12 +21142,13 @@
          * @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);
         }
     }
     /**
@@ -24273,6 +24368,10 @@
             }
             // 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];
@@ -31948,7 +32047,9 @@
             [exports.NotationElement.RepeatCount, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
             [exports.NotationElement.BarNumber, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
             [exports.NotationElement.ScoreBendSlur, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
-            [exports.NotationElement.EffectAlternateEndings, new Font(RenderingResources._serifFont, 15, FontStyle.Plain)]
+            [exports.NotationElement.EffectAlternateEndings, new Font(RenderingResources._serifFont, 15, FontStyle.Plain)],
+            [exports.NotationElement.EffectHammerOnPullOffText, RenderingResources._effectFont],
+            [exports.NotationElement.EffectSlideText, RenderingResources._effectFont]
         ]);
         /**
          * The name of the SMuFL Font to use for rendering music symbols.
@@ -32239,9 +32340,16 @@
                     notationElement = exports.NotationElement.ScoreWords;
                     break;
             }
+            return this.getFontForNotationElement(notationElement);
+        }
+        /**
+         * @internal
+         * @param element
+         */
+        getFontForNotationElement(notationElement) {
             return this.elementFonts.has(notationElement)
                 ? this.elementFonts.get(notationElement)
-                : RenderingResources.defaultFonts.get(exports.NotationElement.ScoreWords);
+                : RenderingResources.defaultFonts.get(notationElement);
         }
     }
 
@@ -49167,6 +49275,21 @@
         }
     }
 
+    /**
+     * 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
@@ -49327,6 +49450,13 @@
          * @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.
          */
@@ -49693,10 +49823,22 @@
          * @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.
@@ -49714,6 +49856,12 @@
             }
         }
         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
@@ -52297,21 +52445,6 @@
         }
     }
 
-    /**
-     * 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
@@ -55512,23 +55645,24 @@
             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 {
@@ -61575,6 +61709,12 @@
         _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;
         }
@@ -61644,16 +61784,88 @@
             }
             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
@@ -61669,12 +61881,76 @@
             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;
@@ -61694,11 +61970,18 @@
         }
         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];
@@ -61707,15 +61990,12 @@
             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;
             }
@@ -68904,11 +69184,43 @@
         }
     }
 
+    /**
+     * 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: exports.NotationElement.EffectSlideText
+                };
+            }
+            // HammerPull
+            return {
+                fromNote: s.fromNote,
+                toNote: s.toNote,
+                text: s.text !== null ? s.text : isAscending ? 'H' : 'P',
+                element: exports.NotationElement.EffectHammerOnPullOffText
+            };
+        }
+    }
+
     /**
      * @internal
      */
     class TabSlurGlyph extends TabTieGlyph {
         _forSlide;
+        _labels = null;
         constructor(slurEffectId, startNote, endNote, forSlide, forEnd) {
             super(slurEffectId, startNote, endNote, forEnd);
             this._forSlide = forSlide;
@@ -68916,6 +69228,22 @@
         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) {
@@ -68941,6 +69269,7 @@
                 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;
@@ -68949,6 +69278,7 @@
                 case BeamDirection.Down:
                     if (startNote.realValue < this.startNote.realValue) {
                         this.startNote = startNote;
+                        this._labels = null;
                     }
                     if (endNote.realValue < this.endNote.realValue) {
                         this.endNote = endNote;
@@ -73686,9 +74016,26 @@
      * @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()