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

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.9.0-alpha.1768 (develop, build 1768)
+ * alphaTab v1.9.0-alpha.1785 (develop, build 1785)
  *
  * 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.1785';
+        static date = '2026-04-27T03:55:02.662Z';
+        static commit = '760ed909a3d8dc36b159d23b4ff6780e95a3daf1';
         static print(print) {
             print(`alphaTab ${VersionInfo.version}`);
             print(`commit: ${VersionInfo.commit}`);
@@ -32634,9 +32634,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 +38842,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 +39033,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 +46916,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 +48798,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));
@@ -50190,7 +50265,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 &&
@@ -54811,7 +54892,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);
                     }
@@ -58051,8 +58133,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);
@@ -62925,6 +63008,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 +65575,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 +65760,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 +65797,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 +65857,7 @@
         //         springX += this.calculateWidth(force, spring.springConstant);
         //     }
         // }
-        _calculateSpringConstant(spring, duration) {
+        _calculateSpringConstant(spring, duration, minDuration) {
             if (duration <= 0) {
                 duration = MidiUtils.toTicks(Duration.TwoHundredFiftySixth);
             }
@@ -65741,7 +65865,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 +65927,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 +66120,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 +66220,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 +66278,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 +66399,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 +66417,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 +66929,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 +66959,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 +66988,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 +67009,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 +67308,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 +67372,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 +67391,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 +67457,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 +67524,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 +67545,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 +67572,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 +67631,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 +67655,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 +67679,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 +67722,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 +67792,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 +67829,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 +67837,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 +67852,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;
                 }
@@ -69351,12 +69704,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 +70091,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);