@coderline/alphatab 1.9.0-alpha.1768 → 1.9.0-alpha.1803

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.9.0-alpha.1768 (develop, build 1768)
+ * alphaTab v1.9.0-alpha.1803 (develop, build 1803)
  *
  * Copyright © 2026, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -209,9 +209,9 @@
      * @internal
      */
     class VersionInfo {
-        static version = '1.9.0-alpha.1768';
-        static date = '2026-04-10T03:35:57.433Z';
-        static commit = '759bd788fc094ab5cb4db380f6a7657e459c14bf';
+        static version = '1.9.0-alpha.1803';
+        static date = '2026-05-15T04:13:04.606Z';
+        static commit = 'a87a8635a0a0306cdab1c7fe2e9e72576ed6f795';
         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.
          */
@@ -31948,7 +32042,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 +32335,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);
         }
     }
 
@@ -32634,9 +32737,16 @@
          *
          * The page layout does not use `displayWidth`. The use of absolute widths would break the proper alignments needed for this kind of display.
          *
-         * Also note that the sizing is including any glyphs and notation elements within the bar. e.g. if there are clefs in the bar, they are still "squeezed" into the available size.
-         * It is not the case that the actual notes with their lengths are sized accordingly. This fits the sizing system of Guitar Pro and when files are customized there,
-         * alphaTab will match this layout quite close.
+         * In both modes, prefix and postfix glyphs (clef, key signature, time signature, barlines) are treated as fixed overhead: they keep their
+         * natural size and the remaining staff width is distributed across bars by a per-bar weight. This matches the convention used by
+         * Guitar Pro, Dorico, Finale, Sibelius and MuseScore. Bars that carry a system-start prefix or a mid-line clef/key/time-signature change
+         * are therefore visibly wider than plain bars with the same weight. The weight source depends on the mode:
+         *
+         * * `Automatic` (default for `page` layout): weights come from the built-in spacing engine (the natural content width of each bar).
+         *   `displayScale` on the model is ignored.
+         * * `UseModelLayout` (and the `parchment` layout): weights come from `bar.displayScale` / `masterBar.displayScale`. An unset
+         *   `displayScale` defaults to `1` and behaves identically to an explicit `1`, matching Guitar Pro (which omits the value when the
+         *   author hasn't customized it).
          *
          * ### Horizontal Layout
          *
@@ -38835,14 +38945,25 @@
          */
         boundsLookup;
         /**
-         * Finished the lookup for optimized access.
+         * Whether this system's bounds have already been scaled via `finish`. Prevents double-scaling
+         * when the parent `BoundsLookup` is preserved across partial renders and `finish` is invoked
+         * again on a mix of already-scaled (preserved) and newly-registered (natural-coordinate) systems.
+         */
+        isFinished = false;
+        /**
+         * Finished the lookup for optimized access. Idempotent: once finished, further calls are no-ops
+         * so preserved systems survive partial renders without being re-scaled.
          */
         finish(scale = 1) {
+            if (this.isFinished) {
+                return;
+            }
             this.realBounds.scaleWith(scale);
             this.visualBounds.scaleWith(scale);
             for (const t of this.bars) {
                 t.finish(scale);
             }
+            this.isFinished = true;
         }
         /**
          * Adds a new master bar to this lookup.
@@ -39015,6 +39136,58 @@
             }
             this.isFinished = true;
         }
+        /**
+         * Re-opens the lookup for registrations without discarding previously registered bounds.
+         * Used by the renderer when it preserves this lookup across a partial render so that new
+         * bounds for the re-layouted range can be added while preserved systems stay intact.
+         * @internal
+         */
+        resetForPartialUpdate() {
+            this.isFinished = false;
+        }
+        /**
+         * Removes all entries belonging to the given master bar index and any bars after it.
+         * Used before a partial render re-registers bounds for the re-layouted range, so the
+         * preserved lookup ends up with only the unchanged entries when registration begins.
+         *
+         * Assumes the layout aligns its re-layouted range to system boundaries - i.e. the first
+         * system to clear starts exactly at `masterBarIndex`. Caller is responsible for passing
+         * the first master-bar-index of the first re-layouted system.
+         * @internal
+         */
+        clearFromMasterBar(masterBarIndex) {
+            // drop staff systems whose bars start at or after the cleared range.
+            let firstRemovedSystem = -1;
+            for (let i = 0; i < this.staffSystems.length; i++) {
+                const systemBars = this.staffSystems[i].bars;
+                if (systemBars.length > 0 && systemBars[0].index >= masterBarIndex) {
+                    firstRemovedSystem = i;
+                    break;
+                }
+            }
+            if (firstRemovedSystem !== -1) {
+                this.staffSystems.splice(firstRemovedSystem, this.staffSystems.length - firstRemovedSystem);
+            }
+            // drop master bar entries at or beyond the cleared range.
+            for (const key of Array.from(this._masterBarLookup.keys())) {
+                if (key >= masterBarIndex) {
+                    this._masterBarLookup.delete(key);
+                }
+            }
+            // drop beat entries whose beats belong to cleared bars.
+            for (const key of Array.from(this._beatLookup.keys())) {
+                const list = this._beatLookup.get(key);
+                const filtered = list.filter(b => b.beat.voice.bar.index < masterBarIndex);
+                if (filtered.length === 0) {
+                    this._beatLookup.delete(key);
+                }
+                else if (filtered.length !== list.length) {
+                    this._beatLookup.set(key, filtered);
+                }
+            }
+            // drop the in-progress pointer - the next addStaffSystem call will replace it.
+            this._currentStaffSystem = null;
+        }
         /**
          * Adds a new staff sytem to the lookup.
          * @param bounds The staff system bounds to add.
@@ -46846,7 +47019,15 @@
                 Logger.warning('Rendering', 'AlphaTab skipped rendering because of width=0 (element invisible)', null);
                 return;
             }
-            this.boundsLookup = new BoundsLookup();
+            // For partial renders we preserve the existing lookup so bars outside the re-layouted
+            // range keep their already-scaled bounds - the layout will clear the changed range
+            // before the paint pass re-registers fresh entries for it.
+            if (renderHints?.firstChangedMasterBar !== undefined && this.boundsLookup) {
+                this.boundsLookup.resetForPartialUpdate();
+            }
+            else {
+                this.boundsLookup = new BoundsLookup();
+            }
             this._recreateCanvas();
             this.canvas.lineWidth = 1;
             this.canvas.settings = this.settings;
@@ -48720,9 +48901,6 @@
          * @param beat The beat to add.
          */
         highlightBeat(beat, playbackStart) {
-            if (beat.isEmpty && !beat.voice.isEmpty) {
-                return;
-            }
             if (!this._highlightedBeats.has(beat.id)) {
                 this._highlightedBeats.set(beat.id, true);
                 this.highlightedBeats.push(new BeatTickLookupItem(beat, playbackStart));
@@ -49092,6 +49270,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
@@ -49252,6 +49445,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.
          */
@@ -49618,10 +49818,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.
@@ -49639,6 +49851,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
@@ -50190,7 +50408,13 @@
             let beatStart = beat.playbackStart;
             let audioDuration = beat.playbackDuration;
             const masterBarDuration = beat.voice.bar.masterBar.calculateDuration();
-            if (beat.voice.bar.isEmpty) {
+            // For a bar whose voice contains a single empty beat (the typical "whole-bar rest"
+            // placeholder inserted during score.finish), extend the beat's audio duration to cover
+            // the full bar so cursor navigation has a beat to follow across the whole bar. Don't
+            // apply this when the voice has multiple beats: those represent explicit rhythmic
+            // subdivisions even when each beat is empty (e.g. a recording grid of placeholder
+            // slots), and overriding would make every beat overlap the whole bar.
+            if (beat.voice.bar.isEmpty && beat.voice.beats.length === 1) {
                 audioDuration = masterBarDuration;
             }
             else if (beat.voice.bar.masterBar.tripletFeel !== TripletFeel.NoTripletFeel &&
@@ -52216,21 +52440,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
@@ -54811,7 +55020,8 @@
                         this._isInitialBeatCursorUpdate ||
                         barBounds.y !== previousBeatBounds.barBounds.masterBarBounds.visualBounds.y ||
                         startBeatX < previousBeatBounds.onNotesX ||
-                        barBoundings.index > previousBeatBounds.barBounds.masterBarBounds.index + 1;
+                        barBoundings.index > previousBeatBounds.barBounds.masterBarBounds.index + 1 ||
+                        barBounds.h !== previousBeatBounds.barBounds.masterBarBounds.visualBounds.h;
                     if (jumpCursor) {
                         cursorHandler.placeBeatCursor(beatCursor, beatBoundings, startBeatX);
                     }
@@ -55430,23 +55640,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 {
@@ -58051,8 +58262,9 @@
                     break;
                 case 'alphaTab.renderScore':
                     this._updateFontSizes(data.fontSizes);
+                    const renderHints = data.renderHints;
                     const score = data.score == null ? null : JsonConverter.jsObjectToScore(data.score, this._renderer.settings);
-                    this._renderMultiple(score, data.trackIndexes);
+                    this._renderMultiple(score, data.trackIndexes, renderHints);
                     break;
                 case 'alphaTab.updateSettings':
                     this._updateSettings(data.settings);
@@ -61492,6 +61704,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;
         }
@@ -61561,16 +61779,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
@@ -61586,13 +61876,77 @@
             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, this.tieDirection === BeamDirection.Down, this._tieHeight, this.renderer.smuflMetrics.tieMidpointThickness);
+                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 {
+                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;
         }
@@ -61611,11 +61965,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];
@@ -61624,15 +61985,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;
             }
@@ -62925,6 +63283,15 @@
             }
             return false;
         }
+        /**
+         * The fixed-overhead width of this renderer: glyphs that do not stretch when
+         * the bar is scaled (clef, key signature, time signature, barlines, courtesy
+         * accidentals, etc). Treated as a fixed allocation by the system-level layout
+         * before distributing remaining width across bars by {@link Bar.displayScale}.
+         */
+        get fixedOverhead() {
+            return this._preBeatGlyphs.width + this._postBeatGlyphs.width;
+        }
         scaleToWidth(width) {
             // preBeat and postBeat glyphs do not get resized
             const containerWidth = width - this._preBeatGlyphs.width - this._postBeatGlyphs.width;
@@ -65483,6 +65850,22 @@
         postBeatSize = 0;
         minStretchForce = 0;
         totalSpringConstant = 0;
+        /**
+         * The smallest note duration encountered within this bar's springs, used as the reference in
+         * the Gourlay stretch formula. Read by the owning {@link StaffSystem} so that the system can
+         * aggregate a shared minimum across all bars and trigger a reconcile if an added bar introduces
+         * a shorter duration than previously seen.
+         */
+        get localMinDuration() {
+            return this._minDuration;
+        }
+        /**
+         * The minimum-duration reference against which the spring constants currently held by this info
+         * were computed. Set by {@link finish} and {@link recomputeSpringConstants}. The owning
+         * StaffSystem compares this against its system-wide minimum to decide whether spring constants
+         * need re-derivation.
+         */
+        computedWithMinDuration = 0;
         _updateMinStretchForce(force) {
             if (this.minStretchForce < force) {
                 this.minStretchForce = force;
@@ -65652,10 +66035,26 @@
                     this._incompleteGraceRodsWidth += sp.preBeatWidth + sp.postSpringWidth;
                 }
             }
-            this._calculateSpringConstants();
+            this._calculateSpringConstants(this._minDuration);
+            this.computedWithMinDuration = this._minDuration;
             this.version++;
         }
-        _calculateSpringConstants() {
+        /**
+         * Re-derives the spring constants (and {@link minStretchForce} / {@link totalSpringConstant})
+         * using a caller-supplied minimum-duration reference rather than this bar's local minimum.
+         *
+         * Called by {@link StaffSystem.reconcileMinDurationIfDirty} when a bar added later to the
+         * system introduced a shorter note than previously seen, invalidating this bar's spring
+         * constants. Grace-rod data is not recomputed — it is independent of the minimum-duration
+         * reference. The internal {@link version} is bumped so downstream consumers (e.g.
+         * {@link BarRendererBase.applyLayoutingInfo}) pick up the refreshed positions.
+         */
+        recomputeSpringConstants(minDuration) {
+            this._calculateSpringConstants(minDuration);
+            this.computedWithMinDuration = minDuration;
+            this.version++;
+        }
+        _calculateSpringConstants(minDuration) {
             let totalSpringConstant = 0;
             const sortedSprings = this._timeSortedSprings;
             if (sortedSprings.length === 0) {
@@ -65673,7 +66072,7 @@
                     const nextSpring = sortedSprings[i + 1];
                     duration = Math.abs(nextSpring.timePosition - currentSpring.timePosition);
                 }
-                currentSpring.springConstant = this._calculateSpringConstant(currentSpring, duration);
+                currentSpring.springConstant = this._calculateSpringConstant(currentSpring, duration, minDuration);
                 totalSpringConstant += 1 / currentSpring.springConstant;
             }
             this.totalSpringConstant = 1 / totalSpringConstant;
@@ -65733,7 +66132,7 @@
         //         springX += this.calculateWidth(force, spring.springConstant);
         //     }
         // }
-        _calculateSpringConstant(spring, duration) {
+        _calculateSpringConstant(spring, duration, minDuration) {
             if (duration <= 0) {
                 duration = MidiUtils.toTicks(Duration.TwoHundredFiftySixth);
             }
@@ -65741,7 +66140,6 @@
                 spring.smallestDuration = duration;
             }
             const smallestDuration = spring.smallestDuration;
-            const minDuration = this._minDuration;
             const minDurationWidth = BarLayoutingInfo._defaultMinDurationWidth;
             const phi = 1 + 0.85 * Math.log2(duration / minDuration);
             return (smallestDuration / duration) * (1 / (phi * minDurationWidth));
@@ -65804,6 +66202,18 @@
         canWrap = true;
         masterBar;
         additionalMultiBarRestIndexes = null;
+        /**
+         * Max fixed overhead (prefix + postfix glyph width) across all staves of this bar.
+         * Used by the layout-mode horizontal scaling pass to carve out the fixed-overhead bucket
+         * before distributing staff width across bars.
+         */
+        maxFixedOverhead = 0;
+        /**
+         * Max natural content width (computedWidth - fixedOverhead) across all staves of this bar.
+         * Used as the bar weight when the layout ignores {@link MasterBar.displayScale} (e.g.
+         * Page layout with `SystemsLayoutMode.Automatic`).
+         */
+        maxContentWidth = 0;
         get lastMasterBarIndex() {
             if (this.additionalMultiBarRestIndexes) {
                 return this.additionalMultiBarRestIndexes[this.additionalMultiBarRestIndexes.length - 1];
@@ -65985,6 +66395,45 @@
          * This value is mainly used in the parchment style layout for correct scaling of the bars.
          */
         totalBarDisplayScale = 0;
+        /**
+         * Sum of per-bar {@link MasterBarsRenderers.maxFixedOverhead} across the system. The layout-mode
+         * horizontal scaling pass subtracts this from the available staff width before distributing the
+         * remainder across bars.
+         */
+        totalFixedOverhead = 0;
+        /**
+         * Sum of per-bar {@link MasterBarsRenderers.maxContentWidth} across the system. Used as the
+         * denominator when distributing staff width in modes that weight bars by natural content width
+         * (Page layout with `SystemsLayoutMode.Automatic`).
+         */
+        totalContentWidth = 0;
+        /**
+         * Shortest note duration (in ticks) across every bar that has been added to this system, used
+         * as the common reference in the Gourlay stretch formula so that rhythmically-equivalent beats
+         * in different bars of the same system align column-wise.
+         *
+         * `-1` means "no bar added yet". The value only moves downward during system assembly; when a
+         * new bar introduces a shorter minimum, {@link isMinDurationDirty} is set so that
+         * {@link reconcileMinDurationIfDirty} can re-derive spring constants on the previously-added
+         * bars before layout distribution runs.
+         */
+        minDuration = -1;
+        /**
+         * Set when a bar added to this system introduced a shorter {@link minDuration} than previously
+         * seen, leaving earlier bars' spring constants stale. Consumed by
+         * {@link reconcileMinDurationIfDirty} which is called from `VerticalLayoutBase._fitSystem`
+         * once the system is fully assembled.
+         */
+        isMinDurationDirty = false;
+        /**
+         * Whether this system coordinates a shared minimum-duration reference across its bars for the
+         * Gourlay stretch formula. Defaults to `true` for page-style and parchment layouts where bars
+         * of a system fight for a common staff width. Set to `false` for horizontal layouts where each
+         * bar is sized independently (by `bar.displayWidth` or its intrinsic width) and there is no
+         * column-alignment concern - each bar keeps its local minimum so pre-existing rendering is
+         * preserved.
+         */
+        shareMinDurationAcrossBars = true;
         isLast = false;
         masterBarsRenderers = [];
         staves = [];
@@ -66046,6 +66495,9 @@
             }
             this.firstVisibleStaff = firstVisibleStaff;
             this._calculateAccoladeSpacing(tracks);
+            // On the resize path the layoutingInfo was finalized in a previous layout pass, so we
+            // only need to check whether its min-duration reference still matches the new system's.
+            this._trackSystemMinDuration(renderers.layoutingInfo);
             this._applyLayoutAndUpdateWidth();
             return renderers;
         }
@@ -66101,10 +66553,89 @@
             this.firstVisibleStaff = firstVisibleStaff;
             this._calculateAccoladeSpacing(tracks);
             barLayoutingInfo.finish();
+            // Reconcile against the system-wide minimum-duration reference now that springs are
+            // finalized. If this bar introduced a shorter note, earlier bars become stale (flagged
+            // for bulk reconcile at fit time). If the system already had a shorter min than this
+            // bar's local one, this bar's spring constants are recomputed immediately so the width
+            // we return below reflects the shared reference.
+            this._trackSystemMinDuration(barLayoutingInfo);
             // ensure same widths of new renderer
             result.width = this._applyLayoutAndUpdateWidth();
             return result;
         }
+        /**
+         * Updates {@link minDuration} and {@link isMinDurationDirty} when a bar is added, and brings
+         * the just-added bar's {@link BarLayoutingInfo} in line with the current system minimum if the
+         * system already saw a shorter reference. The bulk reconcile over previously-added bars is
+         * deferred to {@link reconcileMinDurationIfDirty} (called from `_fitSystem`) to avoid
+         * re-iterating the system every time a bar is appended.
+         */
+        _trackSystemMinDuration(info) {
+            if (!this.shareMinDurationAcrossBars) {
+                return;
+            }
+            const localMin = info.localMinDuration;
+            if (this.minDuration === -1 || localMin < this.minDuration) {
+                // this bar shortens the system minimum; earlier bars (if any) are now stale
+                if (this.masterBarsRenderers.length > 1 && localMin !== this.minDuration) {
+                    this.isMinDurationDirty = true;
+                }
+                this.minDuration = localMin;
+            }
+            if (info.computedWithMinDuration > this.minDuration) {
+                // this bar was initialized against a larger (local) min than the system carries; pull
+                // it down to the system reference so its computedWidth reflects the shared spacing.
+                info.recomputeSpringConstants(this.minDuration);
+            }
+        }
+        /**
+         * Re-derives spring constants on bars whose {@link BarLayoutingInfo.computedWithMinDuration}
+         * is out of sync with the current {@link minDuration}, and rebuilds the cached system totals
+         * (widths, {@link totalFixedOverhead}, {@link totalContentWidth}) from the refreshed bar
+         * widths. Called from `VerticalLayoutBase._fitSystem` after the system is fully assembled and
+         * before distribution runs. No-op when {@link isMinDurationDirty} is false.
+         */
+        reconcileMinDurationIfDirty() {
+            if (!this.isMinDurationDirty) {
+                return;
+            }
+            let systemWidth = this.accoladeWidth;
+            let totalFixedOverhead = 0;
+            let totalContentWidth = 0;
+            for (const mb of this.masterBarsRenderers) {
+                if (mb.layoutingInfo.computedWithMinDuration > this.minDuration) {
+                    mb.layoutingInfo.recomputeSpringConstants(this.minDuration);
+                }
+                let maxPrefix = 0;
+                let maxContent = 0;
+                let realWidth = 0;
+                for (const r of mb.renderers) {
+                    r.applyLayoutingInfo();
+                    if (r.computedWidth > realWidth) {
+                        realWidth = r.computedWidth;
+                    }
+                    const overhead = r.fixedOverhead;
+                    if (overhead > maxPrefix) {
+                        maxPrefix = overhead;
+                    }
+                    const content = Math.max(0, r.computedWidth - overhead);
+                    if (content > maxContent) {
+                        maxContent = content;
+                    }
+                }
+                mb.maxFixedOverhead = maxPrefix;
+                mb.maxContentWidth = maxContent;
+                mb.width = realWidth;
+                systemWidth += realWidth;
+                totalFixedOverhead += maxPrefix;
+                totalContentWidth += maxContent;
+            }
+            this.width = systemWidth;
+            this.computedWidth = systemWidth;
+            this.totalFixedOverhead = totalFixedOverhead;
+            this.totalContentWidth = totalContentWidth;
+            this.isMinDurationDirty = false;
+        }
         getBarDisplayScale(renderer) {
             return this.staves.length > 1 ? renderer.bar.masterBar.displayScale : renderer.bar.displayScale;
         }
@@ -66143,12 +66674,16 @@
                 this.width -= width;
                 this.computedWidth -= width;
                 this.totalBarDisplayScale -= barDisplayScale;
+                this.totalFixedOverhead -= toRemove.maxFixedOverhead;
+                this.totalContentWidth -= toRemove.maxContentWidth;
                 return toRemove;
             }
             return null;
         }
         _applyLayoutAndUpdateWidth() {
             let realWidth = 0;
+            let maxFixedOverhead = 0;
+            let maxContentWidth = 0;
             let barDisplayScale = 0;
             for (const s of this.allStaves) {
                 const last = s.barRenderers[s.barRenderers.length - 1];
@@ -66157,8 +66692,21 @@
                 if (last.computedWidth > realWidth) {
                     realWidth = last.computedWidth;
                 }
+                const overhead = last.fixedOverhead;
+                if (overhead > maxFixedOverhead) {
+                    maxFixedOverhead = overhead;
+                }
+                const content = Math.max(0, last.computedWidth - overhead);
+                if (content > maxContentWidth) {
+                    maxContentWidth = content;
+                }
             }
+            const renderers = this.masterBarsRenderers[this.masterBarsRenderers.length - 1];
+            renderers.maxFixedOverhead = maxFixedOverhead;
+            renderers.maxContentWidth = maxContentWidth;
             this.totalBarDisplayScale += barDisplayScale;
+            this.totalFixedOverhead += maxFixedOverhead;
+            this.totalContentWidth += maxContentWidth;
             this.width += realWidth;
             this.computedWidth += realWidth;
             return realWidth;
@@ -66656,17 +67204,6 @@
         }
     }
 
-    /**
-     * @internal
-     */
-    class LazyPartial {
-        args;
-        renderCallback;
-        constructor(args, renderCallback) {
-            this.args = args;
-            this.renderCallback = renderCallback;
-        }
-    }
     /**
      * This is the base class for creating new layouting engines for the score renderer.
      * @internal
@@ -66697,15 +67234,21 @@
             this.doResize();
         }
         layoutAndRender(renderHints) {
-            this._lazyPartials.clear();
             this.slurRegistry.clear();
-            this.beamingRuleLookups.clear();
-            this._barRendererLookup.clear();
-            this.profile = Environment.staveProfiles.get(this.renderer.settings.display.staveProfile);
             const score = this.renderer.score;
             this.firstBarIndex = ModelUtils.computeFirstDisplayedBarIndex(score, this.renderer.settings);
             this.lastBarIndex = ModelUtils.computeLastDisplayedBarIndex(score, this.renderer.settings, this.firstBarIndex);
             this.multiBarRestInfo = ModelUtils.buildMultiBarRestInfo(this.renderer.tracks, this.firstBarIndex, this.lastBarIndex);
+            const firstChangedMasterBar = renderHints?.firstChangedMasterBar;
+            if (firstChangedMasterBar !== undefined) {
+                if (this.doUpdateForBars(renderHints)) {
+                    return;
+                }
+            }
+            this._lazyPartials.clear();
+            this.beamingRuleLookups.clear();
+            this._barRendererLookup.clear();
+            this.profile = Environment.staveProfiles.get(this.renderer.settings.display.staveProfile);
             this.pagePadding = this.renderer.settings.display.padding.map(p => p / this.renderer.settings.display.scale);
             if (!this.pagePadding) {
                 this.pagePadding = [0, 0, 0, 0];
@@ -66720,6 +67263,9 @@
             this.doLayoutAndRender(renderHints);
         }
         _lazyPartials = new Map();
+        getExistingPartialArgs(id) {
+            return this._lazyPartials.has(id) ? this._lazyPartials.get(id).args : undefined;
+        }
         registerPartial(args, callback) {
             if (args.height === 0) {
                 return;
@@ -66738,7 +67284,11 @@
             }
             else {
                 // in case of lazy loading -> first register lazy, then notify
-                this._lazyPartials.set(args.id, new LazyPartial(args, callback));
+                const partial = {
+                    args,
+                    renderCallback: callback
+                };
+                this._lazyPartials.set(args.id, partial);
                 this.renderer.partialLayoutFinished.trigger(args);
             }
         }
@@ -67033,7 +67583,7 @@
                 glyph.textAlign = TextAlign.Left;
             }
         }
-        layoutAndRenderAnnotation(y) {
+        _layoutAndRenderAnnotation(y) {
             // attention, you are not allowed to remove change this notice within any version of this library without permission!
             const msg = 'rendered by alphaTab';
             const resources = this.renderer.settings.display.resources;
@@ -67097,6 +67647,12 @@
         }
         doResize() {
         }
+        doUpdateForBars(_renderHints) {
+            // not supported yet, modifications likely cause anyhow full updates
+            // as we do not optimize effect bands yet. with effect bands being more 
+            // isolated in bars we could try updating dynamically
+            return false;
+        }
         doLayoutAndRender(renderHints) {
             const score = this.renderer.score;
             let startIndex = this.renderer.settings.display.startBar;
@@ -67110,6 +67666,11 @@
             endBarIndex = startIndex + endBarIndex - 1; // map count to array index
             endBarIndex = Math.min(score.masterBars.length - 1, Math.max(0, endBarIndex));
             this._system = this.createEmptyStaffSystem(0);
+            // Each bar in horizontal layout is sized independently (by bar.displayWidth or the bar's
+            // intrinsic width), so there is no shared staff width to distribute across bars. Keep each
+            // bar's spring constants referenced against its own local minimum-duration so rendering
+            // matches the historical per-bar behaviour.
+            this._system.shareMinDurationAcrossBars = false;
             this._system.isLast = true;
             this._system.x = this.pagePadding[0];
             this._system.y = this.pagePadding[1];
@@ -67171,7 +67732,7 @@
                 currentBarIndex += partial.masterBars.length;
             }
             this.height = this.layoutAndRenderBottomScoreInfo(this.height);
-            this.height = this.layoutAndRenderAnnotation(this.height);
+            this.height = this._layoutAndRenderAnnotation(this.height);
             this.height += this.pagePadding[3];
             this.height *= this.renderer.settings.display.scale;
         }
@@ -67238,11 +67799,16 @@
         _allMasterBarRenderers = [];
         _barsFromPreviousSystem = [];
         _reuseViewPort = false;
+        _preSystemPartialIds = [];
+        _systemPartialIds = [];
         doLayoutAndRender(renderHints) {
             let y = this.pagePadding[1];
             this.width = this.renderer.width;
             this._allMasterBarRenderers = [];
+            this._preSystemPartialIds = [];
+            this._systemPartialIds = [];
             this._reuseViewPort = renderHints?.reuseViewport ?? false;
+            this._systems = [];
             //
             // 1. Score Info
             y = this._layoutAndRenderScoreInfo(y, -1);
@@ -67254,15 +67820,23 @@
             y = this._layoutAndRenderChordDiagrams(y, -1);
             //
             // 4. One result per StaffSystem
-            y = this._layoutAndRenderScore(y);
+            y = this._layoutAndRenderScore(y, this.firstBarIndex);
             y = this.layoutAndRenderBottomScoreInfo(y);
-            y = this.layoutAndRenderAnnotation(y);
+            y = this._layoutAndRenderAnnotation(y);
             this.height = (y + this.pagePadding[3]) * this.renderer.settings.display.scale;
         }
         registerPartial(args, callback) {
             args.reuseViewport = this._reuseViewPort;
             super.registerPartial(args, callback);
         }
+        reregisterPartial(id) {
+            const args = this.getExistingPartialArgs(id);
+            if (!args) {
+                return;
+            }
+            args.reuseViewport = this._reuseViewPort;
+            this.renderer.partialLayoutFinished.trigger(args);
+        }
         get supportsResize() {
             return true;
         }
@@ -67273,6 +67847,47 @@
             }
             return x;
         }
+        doUpdateForBars(renderHints) {
+            this._reuseViewPort = renderHints.reuseViewport ?? false;
+            const firstModifiedMasterBar = renderHints.firstChangedMasterBar;
+            // first update existing systems as needed
+            const systemIndex = this._systems.findIndex(s => {
+                const first = s.masterBarsRenderers[0].masterBar.index;
+                const last = s.masterBarsRenderers[s.masterBarsRenderers.length - 1].masterBar.index;
+                return first <= firstModifiedMasterBar && firstModifiedMasterBar <= last;
+            });
+            if (systemIndex === -1 || !this.renderer.settings.core.enableLazyLoading) {
+                return false;
+            }
+            // Bars from the start of the re-layouted system onward will be re-registered during the
+            // paint pass. Clear their old entries from the preserved BoundsLookup so registration
+            // produces a clean, complete lookup after this render finishes.
+            const firstRebuiltBarIndex = this._systems[systemIndex].masterBarsRenderers[0].masterBar.index;
+            this.renderer.boundsLookup.clearFromMasterBar(firstRebuiltBarIndex);
+            // for now we do a full relayout from the first modified masterbar
+            // there is a lot of room for even more performant updates, but they come
+            // at a risk that features break.
+            // e.g. we could only shift systems where the content didn't change,
+            // but we might still have ties/slurs which have to be updated.
+            const removeSystems = this._systems.splice(systemIndex, this._systems.length - systemIndex);
+            this._systemPartialIds.splice(systemIndex, this._systemPartialIds.length - systemIndex);
+            const system = removeSystems[0];
+            let y = system.y;
+            const firstBarIndex = system.masterBarsRenderers[0].masterBar.index;
+            // signal all partials which didn't change
+            for (const preSystemPartial of this._preSystemPartialIds) {
+                this.reregisterPartial(preSystemPartial);
+            }
+            for (let i = 0; i < systemIndex; i++) {
+                this.reregisterPartial(this._systemPartialIds[i]);
+            }
+            // new partials for all other prats
+            y = this._layoutAndRenderScore(y, firstBarIndex);
+            y = this.layoutAndRenderBottomScoreInfo(y);
+            y = this._layoutAndRenderAnnotation(y);
+            this.height = (y + this.pagePadding[3]) * this.renderer.settings.display.scale;
+            return true;
+        }
         doResize() {
             let y = this.pagePadding[1];
             this.width = this.renderer.width;
@@ -67291,7 +67906,7 @@
             // 4. One result per StaffSystem
             y = this._resizeAndRenderScore(y, oldHeight);
             y = this.layoutAndRenderBottomScoreInfo(y);
-            y = this.layoutAndRenderAnnotation(y);
+            y = this._layoutAndRenderAnnotation(y);
             this.height = (y + this.pagePadding[3]) * this.renderer.settings.display.scale;
         }
         _layoutAndRenderTunings(y, totalHeight = -1) {
@@ -67315,6 +67930,7 @@
                 canvas.textAlign = TextAlign.Center;
                 this.tuningGlyph.paint(0, 0, canvas);
             });
+            this._preSystemPartialIds.push(e.id);
             return y + tuningHeight;
         }
         _layoutAndRenderChordDiagrams(y, totalHeight = -1) {
@@ -67338,6 +67954,7 @@
                 canvas.textAlign = TextAlign.Center;
                 this.chordDiagrams.paint(0, 0, canvas);
             });
+            this._preSystemPartialIds.push(e.id);
             return y + diagramHeight;
         }
         _layoutAndRenderScoreInfo(y, totalHeight = -1) {
@@ -67380,12 +67997,14 @@
                         g.paint(0, 0, canvas);
                     }
                 });
+                this._preSystemPartialIds.push(e.id);
             }
             return y + infoHeight;
         }
         _resizeAndRenderScore(y, oldHeight) {
             // if we have a fixed number of bars per row, we only need to refit them.
             const barsPerRowActive = this.getBarsPerSystem(0) > 0;
+            this._systemPartialIds = [];
             if (barsPerRowActive) {
                 for (let i = 0; i < this._systems.length; i++) {
                     const system = this._systems[i];
@@ -67448,11 +68067,9 @@
             }
             return y;
         }
-        _layoutAndRenderScore(y) {
-            const startIndex = this.firstBarIndex;
+        _layoutAndRenderScore(y, startIndex) {
             let currentBarIndex = startIndex;
             const endBarIndex = this.lastBarIndex;
-            this._systems = [];
             while (currentBarIndex <= endBarIndex) {
                 // create system and align set proper coordinates
                 const system = this._createStaffSystem(currentBarIndex, endBarIndex);
@@ -67487,6 +68104,7 @@
                 // since we use partial drawing
                 system.paint(0, -(args.y / this.renderer.settings.display.scale), canvas);
             });
+            this._systemPartialIds.push(args.id);
             // calculate coordinates for next system
             return height;
         }
@@ -67494,6 +68112,10 @@
          * Realignes the bars in this line according to the available space
          */
         _fitSystem(system) {
+            // If a bar added late in the assembly introduced a shorter note than earlier bars, the
+            // earlier bars' spring constants (and the cached system widths / totals) are stale.
+            // Reconcile now - it's a no-op when nothing changed.
+            system.reconcileMinDurationIfDirty();
             if (system.isFull || system.width > this._maxWidth || this.renderer.settings.display.justifyLastSystem) {
                 this._scaleToWidth(system, this._maxWidth);
             }
@@ -67505,29 +68127,35 @@
         _scaleToWidth(system, width) {
             const staffWidth = width - system.accoladeWidth;
             const shouldApplyBarScale = this.shouldApplyBarScale;
-            const totalScale = system.totalBarDisplayScale;
-            // NOTE: it currently delivers best results if we evenly distribute the available space across bars
-            // scaling bars relatively to their computed width, rather causes distortions whenever bars have
-            // pre-beat glyphs.
-            // most precise scaling would come if we use the contents (voiceContainerGlyph) width as a calculation
-            // factor. but this would make the calculation additionally complex with not much gain.
-            const difference = width - system.computedWidth;
-            const spacePerBar = difference / system.masterBarsRenderers.length;
+            // Industry fixed-overhead model (Behind Bars, Dorico, Finale, Sibelius, MuseScore, Guitar Pro):
+            // prefix/postfix glyphs (clef, key sig, time sig, barlines) are treated as fixed overhead and the
+            // remaining staff width is distributed across bars by a per-bar weight.
+            //
+            //   distributable = staffWidth - totalFixedOverhead
+            //   contentShare  = distributable / sum(weight)
+            //   bar.width     = bar.maxFixedOverhead + weight * contentShare
+            //
+            // The weight depends on the layout mode:
+            //   - shouldApplyBarScale=true  -> weight = bar.displayScale (model-driven, matches Guitar Pro)
+            //                                  displayScale defaults to 1, so an unset value behaves identically
+            //                                  to an explicit 1 (GP omits the property when not customized).
+            //   - shouldApplyBarScale=false -> weight = natural content width (automatic, ignores displayScale)
+            //
+            // Per-bar maxFixedOverhead / maxContentWidth and the system-wide totals are maintained incrementally
+            // in StaffSystem._applyLayoutAndUpdateWidth / revertLastBar so this pass can apply directly.
+            const weightTotal = shouldApplyBarScale ? system.totalBarDisplayScale : system.totalContentWidth;
+            const distributable = Math.max(0, staffWidth - system.totalFixedOverhead);
+            const contentShare = weightTotal > 0 ? distributable / weightTotal : 0;
             for (const s of system.allStaves) {
                 s.resetSharedLayoutData();
-                // scale the bars by keeping their respective ratio size
                 let w = 0;
-                for (const renderer of s.barRenderers) {
+                for (let i = 0; i < s.barRenderers.length; i++) {
+                    const renderer = s.barRenderers[i];
+                    const mb = system.masterBarsRenderers[i];
                     renderer.x = w;
                     renderer.y = s.topPadding + s.topOverflow;
-                    let actualBarWidth;
-                    if (shouldApplyBarScale) {
-                        const barDisplayScale = system.getBarDisplayScale(renderer);
-                        actualBarWidth = (barDisplayScale * staffWidth) / totalScale;
-                    }
-                    else {
-                        actualBarWidth = renderer.computedWidth + spacePerBar;
-                    }
+                    const weight = shouldApplyBarScale ? system.getBarDisplayScale(renderer) : mb.maxContentWidth;
+                    const actualBarWidth = mb.maxFixedOverhead + weight * contentShare;
                     renderer.scaleToWidth(actualBarWidth);
                     w += renderer.width;
                 }
@@ -68551,11 +69179,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;
@@ -68563,6 +69223,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) {
@@ -68588,6 +69264,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;
@@ -68596,6 +69273,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;
@@ -69351,12 +70029,24 @@
                     const firstNonRestBeamingHelper = this.helpers.getBeamingHelperForBeat(firstNonRestBeat);
                     const lastNonRestBeamingHelper = this.helpers.getBeamingHelperForBeat(lastNonRestBeat);
                     const direction = this.getTupletBeamDirection(firstNonRestBeamingHelper);
-                    let startY = this.calculateBeamYWithDirection(firstNonRestBeamingHelper, startX, direction);
-                    let endY = this.calculateBeamYWithDirection(lastNonRestBeamingHelper, endX, direction);
+                    let startY;
+                    let endY;
                     if (isRestOnly) {
-                        startY = Math.max(startY, endY);
+                        // rests have no stems, so anchor to the actual rest glyph bounds
+                        // instead of a stem-adjusted flag position (which would place the bracket
+                        // a full quarter-stem length away from the rests).
+                        if (direction === BeamDirection.Up) {
+                            startY = Math.min(this.getRestY(firstNonRestBeat, NoteYPosition.Top), this.getRestY(lastNonRestBeat, NoteYPosition.Top));
+                        }
+                        else {
+                            startY = Math.max(this.getRestY(firstNonRestBeat, NoteYPosition.Bottom), this.getRestY(lastNonRestBeat, NoteYPosition.Bottom));
+                        }
                         endY = startY;
                     }
+                    else {
+                        startY = this.calculateBeamYWithDirection(firstNonRestBeamingHelper, startX, direction);
+                        endY = this.calculateBeamYWithDirection(lastNonRestBeamingHelper, endX, direction);
+                    }
                     // align line centered in available space
                     if (direction === BeamDirection.Down) {
                         startY += shift;
@@ -69726,7 +70416,30 @@
             let minNoteY = 0;
             for (const v of this.helpers.beamHelpers) {
                 for (const h of v) {
-                    if (!this.shouldPaintBeamingHelper(h)) ;
+                    if (!this.shouldPaintBeamingHelper(h)) {
+                        // beam is not drawn, but a rest-only tuplet still draws a bracket
+                        // anchored to the rest glyph bounds and needs overflow reserved.
+                        if (h.hasTuplet && h.isRestBeamHelper) {
+                            const tupletGroup = h.beats[0].tupletGroup;
+                            const tupletFirst = tupletGroup.beats[0];
+                            const tupletLast = tupletGroup.beats[tupletGroup.beats.length - 1];
+                            const tupletDirection = this.getTupletBeamDirection(h);
+                            if (tupletDirection === BeamDirection.Up) {
+                                const restTop = Math.min(this.getRestY(tupletFirst, NoteYPosition.Top), this.getRestY(tupletLast, NoteYPosition.Top));
+                                const topY = restTop - this.tupletSize - this.tupletOffset;
+                                if (topY < maxNoteY) {
+                                    maxNoteY = topY;
+                                }
+                            }
+                            else {
+                                const restBottom = Math.max(this.getRestY(tupletFirst, NoteYPosition.Bottom), this.getRestY(tupletLast, NoteYPosition.Bottom));
+                                const bottomY = restBottom + this.tupletSize + this.tupletOffset;
+                                if (bottomY > minNoteY) {
+                                    minNoteY = bottomY;
+                                }
+                            }
+                        }
+                    }
                     else if (h.beats.length === 1 && h.beats[0].duration >= Duration.Half) {
                         const tupletDirection = this.getTupletBeamDirection(h);
                         const direction = this.getBeamDirection(h);
@@ -73298,9 +74011,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()