@mlightcad/cad-simple-viewer 1.7.5 → 1.7.6-preview.0

package/lib/view/AcTrView2d.js

@@ -119,6 +119,7 @@ import { collectTextStyleFontNames, planTextStyleFontPreload } from '../util/AcA
 import { ACAP_READING_MODE_BACKGROUND, AcApReadingModeState } from './AcApReadingMode';
 import { trySelectReviewOverlay, trySelectReviewOverlaysByBox } from './AcEdReviewOverlayPick';
 import { AcEdViewKeyHandler } from './AcEdViewKeyHandler';
+import { absorbConvertQueue, adaptConvertSliceSize, createConvertPending, hasPendingActiveOwner } from './AcTrConvertQueue';
 import { shouldExtendBboxForDirectEntity, tryBuildDirectEntityMeta } from './AcTrDirectBatch';
 import { AcTrEntityDisplayController } from './AcTrEntityDisplayController';
 import { assertAcTrGroupWcsBboxesConsistent, unionGroupWcsChildBoxes } from './AcTrGroupWcsBboxAssert';
@@ -288,6 +289,13 @@ var AcTrView2d = /** @class */ (function (_super) {
          * `setTimeout` storm after the loading overlay hides.
          */
         _this._convertQueue = [];
+        /**
+         * Paper-space block table record ids whose viewport entities were converted
+         * before an {@link AcTrLayoutView} existed, so {@link batchConvert} could
+         * not create the {@link AcTrViewportView}. Repaired when that layout view
+         * is created.
+         */
+        _this._viewportRepairOwnerIds = new Set();
         /** In-flight progressive convert drain; shared so awaiters wait for the queue. */
         _this._convertDrainPromise = null;
         /**
@@ -296,8 +304,15 @@ var AcTrView2d = /** @class */ (function (_super) {
          * document open.
          */
         _this._convertEpoch = 0;
-        /** Last time progressive open marked the canvas dirty for paint. */
+        /** Last time progressive open actually painted mid-convert. */
         _this._lastProgressivePaintAt = 0;
+        /**
+         * When true, the next progressive mid-open paint must not be throttled
+         * (camera moved — user pan/zoom or incremental auto-fit).
+         */
+        _this._progressivePaintUrgent = false;
+        /** Pause convert until this `performance.now()` after user input. */
+        _this._progressiveInputPauseUntil = 0;
         /** Mid-open WebGL paints while progressive convert was still running. */
         _this._progressivePaintCount = 0;
         /** Cooperative yields taken inside progressive {@link batchConvert}. */
@@ -376,17 +391,39 @@ var AcTrView2d = /** @class */ (function (_super) {
                 camera: _this.internalCamera
             });
             var stillLoading = _this._numOfEntitiesToProcess > 0;
-            var deferRenderWhileLoading = stillLoading && !_this._progressiveRendering;
-            if (!_this._isDirty && !_this._htmlDirty && !stillLoading)
+            var sceneBusy = stillLoading || _this._pendingGeometryJobs > 0;
+            // Headless non-progressive (`cooperativeYield` false): skip WebGL until
+            // idle. Export reads scene batches, not the framebuffer, and software
+            // WebGL + uncapped rAF spent most of open time rasterizing. Interactive
+            // non-progressive still paints under "Rendering drawing ..." — throttled
+            // below so each glyph completion does not redraw the full scene.
+            var deferRenderWhileLoading = !_this._progressiveRendering && !_this._cooperativeYield && sceneBusy;
+            if (!_this._isDirty && !_this._htmlDirty && !sceneBusy) {
                 return;
+            }
             if (deferRenderWhileLoading)
                 return;
             if (!_this._isDirty && !_this._htmlDirty)
                 return;
+            // Mid-open throttle: progressive convert paints, and interactive
+            // non-progressive paints while the scene is still busy. Camera changes
+            // set `_progressivePaintUrgent` so pan/zoom still redraw now.
+            var countMidOpenPaint = _this.shouldCountMidOpenPaint(stillLoading, sceneBusy);
+            var throttleOpenPaint = _this._isDirty && !_this._progressivePaintUrgent && countMidOpenPaint;
+            if (throttleOpenPaint) {
+                var intervalMs = _this._progressiveRendering
+                    ? AcTrView2d.PROGRESSIVE_OPEN_PAINT_INTERVAL_MS
+                    : AcTrView2d.NON_PROGRESSIVE_OPEN_PAINT_INTERVAL_MS;
+                if (performance.now() - _this._lastProgressivePaintAt < intervalMs) {
+                    return;
+                }
+            }
             var needsRedraw = false;
             if (_this._isDirty) {
-                if (_this._progressiveRendering && stillLoading) {
+                if (countMidOpenPaint) {
                     _this._progressivePaintCount++;
+                    _this._lastProgressivePaintAt = performance.now();
+                    _this._progressivePaintUrgent = false;
                 }
                 needsRedraw = _this._layoutViewManager.render(_this._scene);
             }
@@ -404,6 +441,20 @@ var AcTrView2d = /** @class */ (function (_super) {
             _this._htmlDirty = false;
         };
         _this._disposeCanvasTouchCallout = disposeCanvasTouchCallout;
+        var onProgressiveInput = function () { return _this.noteProgressiveUserInput(); };
+        renderer.domElement.addEventListener('pointerdown', onProgressiveInput, {
+            capture: true
+        });
+        renderer.domElement.addEventListener('wheel', onProgressiveInput, {
+            capture: true,
+            passive: true
+        });
+        _this._disposeProgressiveInputWatch = function () {
+            renderer.domElement.removeEventListener('pointerdown', onProgressiveInput, { capture: true });
+            renderer.domElement.removeEventListener('wheel', onProgressiveInput, {
+                capture: true
+            });
+        };
         _this._gripManager = new AcEdGripManager(_this);
         _this._keyHandler = new AcEdViewKeyHandler(_this);
         if (options.calculateSizeCallback) {
@@ -910,10 +961,9 @@ var AcTrView2d = /** @class */ (function (_super) {
          * The open-file progress overlay uses this when
          * {@link AcApOpenDatabaseOptions.progressiveRendering} is off, so
          * "Rendering drawing ..." stays up until deferred glyph jobs finish.
-         * When progressive rendering is on, the overlay uses
-         * {@link isConvertingEntities} and may hide while text geometry continues
-         * in the deferred pool (pan/zoom enabled). Deprecated `waitForTextGeometry`
-         * no longer selects this gate.
+         * When progressive rendering is on, the overlay hides at CONVERSION `END`
+         * and does not wait on this flag (pan/zoom enabled while convert continues).
+         * Deprecated `waitForTextGeometry` no longer selects this gate.
          */
         get: function () {
             return this._numOfEntitiesToProcess > 0 || this._pendingGeometryJobs > 0;
@@ -1004,7 +1054,9 @@ var AcTrView2d = /** @class */ (function (_super) {
     });
     Object.defineProperty(AcTrView2d.prototype, "cooperativeYield", {
         /**
-         * When false, entity convert skips cooperative yields (headless export).
+         * When false, entity convert skips cooperative yields and non-progressive
+         * mid-open WebGL paints (headless export). Interactive viewers keep this
+         * `true` so "Rendering drawing ..." can still refresh the canvas.
          */
         get: function () {
             return this._cooperativeYield;
@@ -1018,8 +1070,8 @@ var AcTrView2d = /** @class */ (function (_super) {
     Object.defineProperty(AcTrView2d.prototype, "progressiveOpenStats", {
         /**
          * Open-convert counters for OPENPROF / palette (cooperative yields during
-         * convert, and mid-open paints when progressive rendering is enabled).
-         * Reset when progressive mode is enabled for an open.
+         * convert, and throttled mid-open paints). Reset when progressive mode is
+         * enabled for an open.
          */
         get: function () {
             return {
@@ -1034,6 +1086,85 @@ var AcTrView2d = /** @class */ (function (_super) {
         this._progressivePaintCount = 0;
         this._progressiveYieldCount = 0;
         this._lastProgressivePaintAt = 0;
+        this._progressivePaintUrgent = false;
+        this._progressiveInputPauseUntil = 0;
+    };
+    /**
+     * True while a recent canvas pointerdown/wheel asked convert to pause.
+     * Does not treat hover mousemove as a pause (that starved convert).
+     */
+    AcTrView2d.prototype.isProgressiveGesturePauseActive = function () {
+        return performance.now() < this._progressiveInputPauseUntil;
+    };
+    /**
+     * True when the browser reports pending discrete input (clicks, keys).
+     * Continuous events (mousemove) are excluded so hover does not throttle
+     * progressive convert.
+     */
+    AcTrView2d.prototype.isProgressiveDiscreteInputPending = function () {
+        var _a;
+        var scheduling = navigator.scheduling;
+        return ((_a = scheduling === null || scheduling === void 0 ? void 0 : scheduling.isInputPending) === null || _a === void 0 ? void 0 : _a.call(scheduling)) === true;
+    };
+    /**
+     * Notes user interaction during progressive convert so paints stay urgent
+     * and the drain loop pauses briefly for OrbitControls.
+     */
+    AcTrView2d.prototype.noteProgressiveUserInput = function () {
+        if (!this._progressiveRendering || this._numOfEntitiesToProcess <= 0) {
+            return;
+        }
+        this._progressivePaintUrgent = true;
+        this._isDirty = true;
+        this._progressiveInputPauseUntil =
+            performance.now() + AcTrView2d.PROGRESSIVE_INPUT_PAUSE_MS;
+    };
+    /**
+     * Yields during progressive convert: honor the time budget; after
+     * pointerdown/wheel pause briefly for OrbitControls; on discrete pending
+     * input yield once so handlers run without extending the pause window.
+     */
+    AcTrView2d.prototype.progressiveYieldForInput = function (yieldGate, yieldToEventLoop) {
+        return __awaiter(this, void 0, void 0, function () {
+            var didYield;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.isProgressiveGesturePauseActive()) return [3 /*break*/, 5];
+                        return [4 /*yield*/, yieldToEventLoop()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (!(performance.now() < this._progressiveInputPauseUntil)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 16); })];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 2];
+                    case 4:
+                        this._progressiveYieldCount++;
+                        return [2 /*return*/];
+                    case 5:
+                        if (!this.isProgressiveDiscreteInputPending()) return [3 /*break*/, 7];
+                        return [4 /*yield*/, yieldToEventLoop()];
+                    case 6:
+                        _a.sent();
+                        this._progressiveYieldCount++;
+                        return [2 /*return*/];
+                    case 7:
+                        if (!yieldGate) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, yieldGate.maybeYield(yieldToEventLoop)];
+                    case 8:
+                        didYield = _a.sent();
+                        if (didYield) {
+                            this._progressiveYieldCount++;
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
     };
     /**
      * Enables progressive camera framing while entities are batch-converted at
@@ -1480,6 +1611,31 @@ var AcTrView2d = /** @class */ (function (_super) {
                         includeLayouts = (options === null || options === void 0 ? void 0 : options.includeLayouts) !== false;
                         db = AcApDocManager.instance.curDocument.database;
                         pending = [];
+                        // Open streams entities through `drainConvertQueue` and claims each id
+                        // before the scene commit (deferred glyphs / INSERT text). Headless
+                        // export used to scan here as soon as parse returned, while that drain
+                        // was still running. Claimed ids are not in the scene yet, so they
+                        // looked missing and `batchConvert({ forExport: true })` expanded them
+                        // again — serially, because export convert does not defer glyph work.
+                        // On a text-heavy drawing that second pass dominates wall time and
+                        // leaves duplicate geometry in the snapshot. Wait until the open drain
+                        // has claimed or committed every streamed entity, then skip those ids.
+                        return [4 /*yield*/, this.drainConvertQueue()
+                            // Paper-space tabs the user never visited exist in the layout table but
+                            // may be missing from the scene until first switch. HTML export needs
+                            // every layout's geometry, so register those BTRs before collecting.
+                        ];
+                    case 1:
+                        // Open streams entities through `drainConvertQueue` and claims each id
+                        // before the scene commit (deferred glyphs / INSERT text). Headless
+                        // export used to scan here as soon as parse returned, while that drain
+                        // was still running. Claimed ids are not in the scene yet, so they
+                        // looked missing and `batchConvert({ forExport: true })` expanded them
+                        // again — serially, because export convert does not defer glyph work.
+                        // On a text-heavy drawing that second pass dominates wall time and
+                        // leaves duplicate geometry in the snapshot. Wait until the open drain
+                        // has claimed or committed every streamed entity, then skip those ids.
+                        _j.sent();
                         layoutTable = (_h = db.objects) === null || _h === void 0 ? void 0 : _h.layout;
                         if (includeLayouts && (layoutTable === null || layoutTable === void 0 ? void 0 : layoutTable.newIterator)) {
                             try {
@@ -1509,7 +1665,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                                 if (!blockTableRecord) {
                                     continue;
                                 }
-                                pending.push.apply(pending, __spreadArray([], __read(this._entityDisplay.collectMissingEntitiesForExport(blockTableRecord, function (objectId) { return _this.hasEntity(objectId); }, includeInvisibleLayers)), false));
+                                pending.push.apply(pending, __spreadArray([], __read(this._entityDisplay.collectMissingEntitiesForExport(blockTableRecord, function (objectId) { return _this.isEntityConvertScheduled(objectId); }, includeInvisibleLayers)), false));
                             }
                         }
                         catch (e_5_1) { e_5 = { error: e_5_1 }; }
@@ -1519,14 +1675,14 @@ var AcTrView2d = /** @class */ (function (_super) {
                             }
                             finally { if (e_5) throw e_5.error; }
                         }
-                        if (!(pending.length > 0)) return [3 /*break*/, 2];
+                        if (!(pending.length > 0)) return [3 /*break*/, 3];
                         this._numOfEntitiesToProcess += pending.length;
                         return [4 /*yield*/, this.batchConvert(pending, { forExport: true })];
-                    case 1:
+                    case 2:
                         _j.sent();
-                        _j.label = 2;
-                    case 2: return [4 /*yield*/, this.waitUntilIdle()];
-                    case 3:
+                        _j.label = 3;
+                    case 3: return [4 /*yield*/, this.waitUntilIdle(120000)];
+                    case 4:
                         idle = _j.sent();
                         if (!idle) {
                             log.warn('[AcTrView2d] Timed out waiting for deferred geometry before export');
@@ -2359,6 +2515,17 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.hasEntity = function (objectId) {
         return this._scene.hasEntity(objectId);
     };
+    /**
+     * True when an entity is already in the scene or claimed by an in-flight
+     * convert (including deferred glyph commits that have not called
+     * `addEntity` yet).
+     */
+    AcTrView2d.prototype.isEntityConvertScheduled = function (objectId) {
+        var id = String(objectId !== null && objectId !== void 0 ? objectId : '');
+        if (!id)
+            return false;
+        return this.hasEntity(objectId) || this._claimedConvertObjectIds.has(id);
+    };
     /**
      * @inheritdoc
      */
@@ -2517,6 +2684,17 @@ var AcTrView2d = /** @class */ (function (_super) {
         this._initializedLayouts.add(layoutBtrId);
         this._externallyFramedLayouts.add(layoutBtrId);
     };
+    /**
+     * Whether the layout has already been visited (or framed by the
+     * application layer), i.e. a switch to it will not run the first-visit
+     * auto zoom. Lets callers that frame a layout themselves (FIND) call
+     * {@link markLayoutAsInitialized} only when it is still needed.
+     *
+     * @param layoutBtrId Input the block table record id of the layout
+     */
+    AcTrView2d.prototype.isLayoutInitialized = function (layoutBtrId) {
+        return this._initializedLayouts.has(layoutBtrId);
+    };
     /**
      * Returns the 2D box of drawable geometry in the active layout.
      *
@@ -2618,6 +2796,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         this._convertEpoch++;
         this.clearFontLoadedRedrawTimer();
         this._convertQueue.length = 0;
+        this._viewportRepairOwnerIds.clear();
         this._numOfEntitiesToProcess = 0;
         this._claimedConvertObjectIds.clear();
         this._entityConvertGeneration.clear();
@@ -2664,6 +2843,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         this.clearFontLoadedRedrawTimer();
         this.cancelOpenLineworkFrame();
         this._convertQueue.length = 0;
+        this._viewportRepairOwnerIds.clear();
         this._numOfEntitiesToProcess = 0;
         this._claimedConvertObjectIds.clear();
         this._entityConvertGeneration.clear();
@@ -2696,6 +2876,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         this.clearFontLoadedRedrawTimer();
         this.cancelOpenLineworkFrame();
         this._convertQueue.length = 0;
+        this._viewportRepairOwnerIds.clear();
         this._numOfEntitiesToProcess = 0;
         this._claimedConvertObjectIds.clear();
         this._entityConvertGeneration.clear();
@@ -2770,21 +2951,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                         _a.label = 3;
                     case 3: return [2 /*return*/];
                     case 4:
-                        this._convertDrainPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
-                            var batch;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        if (!(this._convertQueue.length > 0)) return [3 /*break*/, 2];
-                                        batch = this._convertQueue.splice(0, this._convertQueue.length);
-                                        return [4 /*yield*/, this.batchConvert(batch)];
-                                    case 1:
-                                        _a.sent();
-                                        return [3 /*break*/, 0];
-                                    case 2: return [2 /*return*/];
-                                }
-                            });
-                        }); })().finally(function () {
+                        this._convertDrainPromise = this.runConvertDrain().finally(function () {
                             _this._convertDrainPromise = null;
                         });
                         return [4 /*yield*/, this._convertDrainPromise];
@@ -2795,9 +2962,188 @@ var AcTrView2d = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Converts the queued entities in slices, active layout first.
+     *
+     * `drainConvertQueue` used to hand the whole queue to one
+     * {@link batchConvert}. Model-space block references queued ahead of the
+     * sheet then blocked the sheet's frame and viewports for the entire batch,
+     * and a layout activated during that batch stayed starved until it
+     * finished. Slices return here so a newly active layout is ordered ahead
+     * of the remainder. Paper-active opens use a modest slice budget so the
+     * sheet can paint soon; model-active opens match the inner
+     * {@link batchConvert} yield cadence and grow slices for throughput so
+     * Model-first drawings are not slowed by fine outer slicing. Headless
+     * opens (`cooperativeYield === false`) still convert in one batch after
+     * that reorder.
+     */
+    AcTrView2d.prototype.runConvertDrain = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var epoch, interactive, slice, lastYieldAt, state, queued, activeNow, activeChanged, end, startedAt, took, modelActive, modelYieldBudget, budget;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        epoch = this._convertEpoch;
+                        interactive = this._cooperativeYield;
+                        slice = !interactive
+                            ? Number.POSITIVE_INFINITY
+                            : this.activeLayoutBtrId === this.modelSpaceBtrId
+                                ? AcTrView2d.CONVERT_SLICE_MAX
+                                : 1;
+                        lastYieldAt = performance.now();
+                        state = createConvertPending(this._convertQueue.splice(0, this._convertQueue.length), this.activeLayoutBtrId);
+                        this.repairViewportViewsFor(state.activeOwnerId);
+                        _a.label = 1;
+                    case 1:
+                        if (!(state.cursor < state.pending.length ||
+                            this._convertQueue.length > 0)) return [3 /*break*/, 12];
+                        if (this._convertEpoch !== epoch)
+                            return [2 /*return*/];
+                        queued = this._convertQueue.splice(0, this._convertQueue.length);
+                        activeNow = this.activeLayoutBtrId;
+                        activeChanged = activeNow !== state.activeOwnerId;
+                        state = absorbConvertQueue(state, queued, activeNow);
+                        if (activeChanged) {
+                            this.repairViewportViewsFor(activeNow);
+                            // Drop back to a small slice so the newly active layout's own
+                            // entities are not buried inside a leftover large model-space bite.
+                            if (interactive)
+                                slice = 1;
+                        }
+                        this.flushViewportViewRepairs();
+                        if (state.cursor >= state.pending.length)
+                            return [3 /*break*/, 12];
+                        end = Math.min(state.pending.length, state.cursor + slice);
+                        startedAt = performance.now();
+                        return [4 /*yield*/, this.batchConvert(state.pending.slice(state.cursor, end))];
+                    case 2:
+                        _a.sent();
+                        state.cursor = end;
+                        if (this._convertEpoch !== epoch)
+                            return [2 /*return*/];
+                        if (!interactive)
+                            return [3 /*break*/, 1];
+                        took = performance.now() - startedAt;
+                        modelActive = state.activeOwnerId === this.modelSpaceBtrId;
+                        modelYieldBudget = this._progressiveRendering
+                            ? AcTrView2d.PROGRESSIVE_OPEN_YIELD_BUDGET_MS
+                            : AcTrView2d.OPEN_CONVERT_YIELD_BUDGET_MS;
+                        budget = modelActive
+                            ? modelYieldBudget
+                            : AcTrView2d.CONVERT_SLICE_BUDGET_MS;
+                        slice = adaptConvertSliceSize({
+                            slice: slice,
+                            tookMs: took,
+                            budgetMs: budget,
+                            maxSlice: AcTrView2d.CONVERT_SLICE_MAX,
+                            // Fine 2× growth only while a paper sheet still needs converting.
+                            // Model-active (or paper already drained) prefers 4× throughput.
+                            activeLayoutPending: !modelActive && hasPendingActiveOwner(state)
+                        });
+                        if (!(this._progressiveRendering &&
+                            this.isProgressiveGesturePauseActive())) return [3 /*break*/, 7];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 0); })];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        if (!(performance.now() < this._progressiveInputPauseUntil)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 16); })];
+                    case 5:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 6:
+                        lastYieldAt = performance.now();
+                        if (this._convertEpoch !== epoch)
+                            return [2 /*return*/];
+                        return [3 /*break*/, 11];
+                    case 7:
+                        if (!(this._progressiveRendering &&
+                            this.isProgressiveDiscreteInputPending())) return [3 /*break*/, 9];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 0); })];
+                    case 8:
+                        _a.sent();
+                        lastYieldAt = performance.now();
+                        if (this._convertEpoch !== epoch)
+                            return [2 /*return*/];
+                        return [3 /*break*/, 11];
+                    case 9:
+                        if (!(performance.now() - lastYieldAt >= budget)) return [3 /*break*/, 11];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 0); })];
+                    case 10:
+                        _a.sent();
+                        lastYieldAt = performance.now();
+                        if (this._convertEpoch !== epoch)
+                            return [2 /*return*/];
+                        _a.label = 11;
+                    case 11: return [3 /*break*/, 1];
+                    case 12:
+                        this.repairViewportViewsFor(this.activeLayoutBtrId);
+                        this.flushViewportViewRepairs();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Creates missing {@link AcTrViewportView}s for one paper layout.
+     *
+     * Safe to call before the layout's entities have been committed to the
+     * scene: the database block table record already holds the viewports.
+     * Model space is skipped so a large model is not walked on every slice.
+     *
+     * @param layoutBtrId - Block table record id of the layout to repair.
+     */
+    AcTrView2d.prototype.repairViewportViewsFor = function (layoutBtrId) {
+        var _a;
+        if (!layoutBtrId || layoutBtrId === this.modelSpaceBtrId)
+            return;
+        var layoutView = this._layoutViewManager.getAt(layoutBtrId);
+        if (!layoutView || layoutView.viewportCount > 0) {
+            if (layoutView && layoutView.viewportCount > 0) {
+                this._viewportRepairOwnerIds.delete(layoutBtrId);
+            }
+            return;
+        }
+        try {
+            var db = (_a = AcApDocManager.instance.curDocument) === null || _a === void 0 ? void 0 : _a.database;
+            var blockTableRecord = db === null || db === void 0 ? void 0 : db.tables.blockTable.getIdAt(layoutBtrId);
+            if (!blockTableRecord)
+                return;
+            var before = layoutView.viewportCount;
+            this.ensureViewportViews(blockTableRecord, layoutView);
+            if (layoutView.viewportCount > before) {
+                this._isDirty = true;
+            }
+            // The block table record was readable. Drop the id even when every
+            // viewport was the default paper-space one, so a model-sized record
+            // is not walked again on the next slice.
+            this._viewportRepairOwnerIds.delete(layoutBtrId);
+        }
+        catch (error) {
+            log.error('[AcTrView2d] Error repairing viewport views:', error);
+        }
+    };
+    /**
+     * Retries viewport-view creation for owners recorded while their layout
+     * view did not exist yet.
+     */
+    AcTrView2d.prototype.flushViewportViewRepairs = function () {
+        if (this._viewportRepairOwnerIds.size === 0)
+            return;
+        var ownerIds = Array.from(this._viewportRepairOwnerIds);
+        for (var i = 0; i < ownerIds.length; i++) {
+            this.repairViewportViewsFor(ownerIds[i]);
+        }
+    };
     /**
      * Marks the canvas dirty for progressive open, throttled to avoid painting
      * on every entity (which dominated total open time).
+     *
+     * Does not stamp {@link _lastProgressivePaintAt} — that updates only when
+     * {@link animate} actually paints. Does not set
+     * {@link _progressivePaintUrgent}; camera moves do that so pan/zoom stay
+     * immediate while convert-driven paints remain rare.
      */
     AcTrView2d.prototype.markProgressiveDirty = function (force) {
         if (force === void 0) { force = false; }
@@ -2806,9 +3152,28 @@ var AcTrView2d = /** @class */ (function (_super) {
             now - this._lastProgressivePaintAt >=
                 AcTrView2d.PROGRESSIVE_OPEN_PAINT_INTERVAL_MS) {
             this._isDirty = true;
-            this._lastProgressivePaintAt = now;
         }
     };
+    /**
+     * Interactive non-progressive open: dirty the canvas so {@link animate} can
+     * refresh under "Rendering drawing ...". Headless (`cooperativeYield`
+     * false) leaves this unset; the pool-drain / convert-end dirty is enough.
+     * {@link animate} applies {@link NON_PROGRESSIVE_OPEN_PAINT_INTERVAL_MS}.
+     */
+    AcTrView2d.prototype.markInteractiveOpenDirty = function () {
+        if (this._progressiveRendering || !this._cooperativeYield) {
+            return;
+        }
+        this._isDirty = true;
+    };
+    /**
+     * True when this frame's WebGL paint should count toward OPENPROF mid-open
+     * paints and use the open-time throttle (unless the camera marked urgent).
+     */
+    AcTrView2d.prototype.shouldCountMidOpenPaint = function (stillLoading, sceneBusy) {
+        return ((this._progressiveRendering && stillLoading) ||
+            (!this._progressiveRendering && this._cooperativeYield && sceneBusy));
+    };
     /**
      * @inheritdoc
      */
@@ -2864,9 +3229,11 @@ var AcTrView2d = /** @class */ (function (_super) {
      * view teardown). Safe to call more than once.
      */
     AcTrView2d.prototype.dispose = function () {
-        var _a;
+        var _a, _b;
         (_a = this._disposeCanvasTouchCallout) === null || _a === void 0 ? void 0 : _a.call(this);
         this._disposeCanvasTouchCallout = undefined;
+        (_b = this._disposeProgressiveInputWatch) === null || _b === void 0 ? void 0 : _b.call(this);
+        this._disposeProgressiveInputWatch = undefined;
         this.clearFontLoadedRedrawTimer();
         this.cancelOpenLineworkFrame();
         this.stopAnimationLoop();
@@ -2934,11 +3301,19 @@ var AcTrView2d = /** @class */ (function (_super) {
             layoutView.events.viewChanged.addEventListener(function () {
                 _this._progressiveOpenFit.onLayoutViewChanged();
                 _this._isDirty = true;
+                // Bypass mid-open paint throttle so pan/zoom (and incremental fit)
+                // remain visible while convert continues.
+                if (_this._progressiveRendering && _this._numOfEntitiesToProcess > 0) {
+                    _this._progressivePaintUrgent = true;
+                }
                 _this.events.viewChanged.dispatch();
                 _this.clearHover();
             });
             this._layoutViewManager.add(layoutView);
         }
+        // Viewport entities may already have been converted while this view was
+        // missing. Creating it is the moment those AcTrViewportViews can exist.
+        this.flushViewportViewRepairs();
         return layoutView;
     };
     /**
@@ -2974,41 +3349,20 @@ var AcTrView2d = /** @class */ (function (_super) {
             var existingLayout = this._scene.layouts.get(layoutBtrId);
             if (existingLayout && existingLayout.isLoaded) {
                 // Streamed layouts flip `isLoaded` from `addEntity` before scene
-                // commits finish. Still repair the viewport-view race when entities
-                // are already in the scene but AcTrViewportView creation was skipped.
-                var layoutView_1 = this._layoutViewManager.getAt(layoutBtrId);
-                if (existingLayout.entityCount > 0 &&
-                    layoutView_1 &&
-                    layoutView_1.viewportCount === 0) {
-                    this.ensureViewportViews(blockTableRecord, layoutView_1);
-                }
+                // commits finish (`entityCount` still 0). Viewport views are read
+                // from the block table record, so repair them even while the sheet's
+                // own entities are still queued behind model space.
+                this.repairViewportViewsFor(layoutBtrId);
                 return;
             }
             if (this._loadingLayouts.has(layoutBtrId)) {
                 return;
             }
-            // Ensure `AcTrViewportView`s exist for every real `AcDbViewport`
-            // in this layout when the layout's entities were already streamed
-            // in by the document parser. There is a race in the parser-driven
-            // load path: `addLayout(layout)` creates the `AcTrLayoutView`,
-            // but the parser may dispatch the AcDbViewport entities before
-            // that happens. When that races, `batchConvert`'s viewport
-            // handler does `_layoutViewManager.getAt(entity.ownerId)`, gets
-            // `undefined`, and **silently skips creating the
-            // AcTrViewportView**. The reload path below used to mask this by
-            // re-running batchConvert after the layoutView existed, but the
-            // entityCount-skip optimization that follows removes that
-            // side-effect, so we do the viewport-view-only pass explicitly
-            // here. Skipped when the layout is empty — in that case the
-            // batchConvert path below will create the viewport views directly
-            // as it processes each entity.
-            var layoutView = this._layoutViewManager.getAt(layoutBtrId);
-            if (existingLayout &&
-                existingLayout.entityCount > 0 &&
-                layoutView &&
-                layoutView.viewportCount === 0) {
-                this.ensureViewportViews(blockTableRecord, layoutView);
-            }
+            // Same repair as the isLoaded path: the layout view can exist before
+            // any of its entities have been committed to the scene. Viewport
+            // entities converted before `addLayout` created that view are recorded
+            // in `_viewportRepairOwnerIds` and attached here.
+            this.repairViewportViewsFor(layoutBtrId);
             // Model space (and any other layout pre-populated by the document
             // parser at open time) lands here without `isLoaded` ever having
             // been flipped — the initial entity stream goes through
@@ -3586,9 +3940,13 @@ var AcTrView2d = /** @class */ (function (_super) {
             void job
                 .run()
                 .then(function () {
-                // Convert counter often hits 0 before fonts finish; without this,
-                // text added later never paints until the user pans/zooms.
-                if (job.epoch === _this._convertEpoch) {
+                // Progressive: dirty every glyph (animate throttles paints).
+                // Interactive non-progressive: same, under a longer open-paint
+                // interval so "Rendering drawing ..." still shows progress.
+                // Headless non-progressive: skip — the pool-drain dirty below
+                // queues the single frame export/scripts need.
+                if (job.epoch === _this._convertEpoch &&
+                    (_this._progressiveRendering || _this._cooperativeYield)) {
                     _this._isDirty = true;
                 }
             })
@@ -3648,6 +4006,31 @@ var AcTrView2d = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Adds an {@link AcTrViewportView} for a real paper-space viewport.
+     *
+     * When the layout view does not exist yet, the owner id is remembered and
+     * {@link flushViewportViewRepairs} creates the view once the layout view
+     * does. Adding twice for the same viewport id replaces the previous view.
+     *
+     * @param entity - Viewport entity, already past the default-viewport filter
+     *   at the caller's discretion. Checked again here.
+     */
+    AcTrView2d.prototype.attachViewportView = function (entity) {
+        if (AcTrViewportView.isDefaultPaperSpaceViewport(entity))
+            return;
+        var ownerId = entity.ownerId;
+        var layoutView = ownerId
+            ? this._layoutViewManager.getAt(ownerId)
+            : undefined;
+        if (!layoutView) {
+            if (ownerId)
+                this._viewportRepairOwnerIds.add(ownerId);
+            return;
+        }
+        layoutView.addViewport(new AcTrViewportView(layoutView, this.toGiViewportWithFrozenLayers(entity), this._renderer));
+        this._isDirty = true;
+    };
     /**
      * Walks the given block table record once and creates one
      * `AcTrViewportView` for every real `AcDbViewport` entity it finds
@@ -3676,7 +4059,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                     continue;
                 if (AcTrViewportView.isDefaultPaperSpaceViewport(entity))
                     continue;
-                var viewportView = new AcTrViewportView(layoutView, entity.toGiViewport(), this._renderer);
+                var viewportView = new AcTrViewportView(layoutView, this.toGiViewportWithFrozenLayers(entity), this._renderer);
                 layoutView.addViewport(viewportView);
             }
         }
@@ -3688,6 +4071,44 @@ var AcTrView2d = /** @class */ (function (_super) {
             finally { if (e_16) throw e_16.error; }
         }
     };
+    /**
+     * Builds an {@link AcGiViewport} and ensures VPLAYER frozen layers are
+     * present as resolved names. Older data-model builds read group 331 into
+     * {@link AcDbViewport.frozenLayerIds} but omit them from `toGiViewport()`.
+     */
+    AcTrView2d.prototype.toGiViewportWithFrozenLayers = function (entity) {
+        var e_17, _a;
+        var _b;
+        var gi = entity.toGiViewport();
+        if (gi.frozenLayers && gi.frozenLayers.length > 0) {
+            return gi;
+        }
+        var ids = entity.frozenLayerIds;
+        if (!(ids === null || ids === void 0 ? void 0 : ids.length))
+            return gi;
+        var names = [];
+        var layerTable = (_b = entity.database) === null || _b === void 0 ? void 0 : _b.tables.layerTable;
+        if (layerTable) {
+            try {
+                for (var ids_1 = __values(ids), ids_1_1 = ids_1.next(); !ids_1_1.done; ids_1_1 = ids_1.next()) {
+                    var id = ids_1_1.value;
+                    var layer = layerTable.getIdAt(id);
+                    if (layer)
+                        names.push(layer.name);
+                }
+            }
+            catch (e_17_1) { e_17 = { error: e_17_1 }; }
+            finally {
+                try {
+                    if (ids_1_1 && !ids_1_1.done && (_a = ids_1.return)) _a.call(ids_1);
+                }
+                finally { if (e_17) throw e_17.error; }
+            }
+        }
+        gi.frozenLayerIds = __spreadArray([], __read(ids), false);
+        gi.frozenLayers = names;
+        return gi;
+    };
     /**
      * Converts the specified database entities to three entities
      * @param entities - The database entities
@@ -3695,12 +4116,12 @@ var AcTrView2d = /** @class */ (function (_super) {
      */
     AcTrView2d.prototype.batchConvert = function (entities_3) {
         return __awaiter(this, arguments, void 0, function (entities, options) {
-            var epoch, db, progressive, yieldGate, yieldToEventLoop, _loop_4, this_3, i;
+            var epoch, db, progressive, yieldBudgetMs, yieldGate, yieldToEventLoop, _loop_4, this_3, i;
             var _this = this;
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             if (options === void 0) { options = {}; }
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         epoch = this._convertEpoch;
                         // Fallback: if STYLE-stage preload never started (e.g. non-conversion open
@@ -3713,21 +4134,24 @@ var AcTrView2d = /** @class */ (function (_super) {
                             }
                         }
                         progressive = this._progressiveRendering && !options.forExport;
+                        yieldBudgetMs = progressive
+                            ? AcTrView2d.PROGRESSIVE_OPEN_YIELD_BUDGET_MS
+                            : AcTrView2d.OPEN_CONVERT_YIELD_BUDGET_MS;
                         yieldGate = options.forExport || !this._cooperativeYield
                             ? undefined
-                            : new AcCmUiYieldGate(AcTrView2d.OPEN_CONVERT_YIELD_BUDGET_MS);
+                            : new AcCmUiYieldGate(yieldBudgetMs);
                         yieldToEventLoop = function () {
                             return new Promise(function (resolve) { return setTimeout(resolve, 0); });
                         };
                         _loop_4 = function (i) {
-                            var entity, shouldConvert, objectId_1, convertGen_1, directMeta, added, superseded, threeEntity_1, isMultiLayerGroup, deferGeometry, isExtendBbox_1, commitEntity, layoutView, viewportView, fileName, error_3, didYield;
-                            return __generator(this, function (_e) {
-                                switch (_e.label) {
+                            var entity, shouldConvert, objectId_1, convertGen_1, directMeta, added, superseded, threeEntity_1, isMultiLayerGroup, deferGeometry, isExtendBbox_1, commitEntity, fileName, error_3, failedId, didYield;
+                            return __generator(this, function (_f) {
+                                switch (_f.label) {
                                     case 0:
                                         entity = entities[i];
-                                        _e.label = 1;
+                                        _f.label = 1;
                                     case 1:
-                                        _e.trys.push([1, 9, 10, 11]);
+                                        _f.trys.push([1, 9, 10, 11]);
                                         // Document was cleared / replaced while this batch was draining.
                                         if (epoch !== this_3._convertEpoch) {
                                             return [2 /*return*/, "continue"];
@@ -3755,16 +4179,20 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         }
                                         objectId_1 = String((_a = entity.objectId) !== null && _a !== void 0 ? _a : '');
                                         convertGen_1 = 0;
-                                        if (!options.forExport) {
-                                            if (objectId_1 &&
-                                                (this_3.hasEntity(objectId_1) ||
-                                                    this_3._claimedConvertObjectIds.has(objectId_1))) {
-                                                return [2 /*return*/, "continue"];
-                                            }
-                                            if (objectId_1) {
-                                                this_3._claimedConvertObjectIds.add(objectId_1);
-                                                convertGen_1 = (_b = this_3._entityConvertGeneration.get(objectId_1)) !== null && _b !== void 0 ? _b : 0;
+                                        if (objectId_1 &&
+                                            (this_3.hasEntity(objectId_1) ||
+                                                this_3._claimedConvertObjectIds.has(objectId_1))) {
+                                            // The border may already be in the scene from a pass that ran
+                                            // before the layout view existed. Still attach the viewport
+                                            // view; a second border is not drawn because we continue below.
+                                            if (entity instanceof AcDbViewport) {
+                                                this_3.attachViewportView(entity);
                                             }
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        if (objectId_1) {
+                                            this_3._claimedConvertObjectIds.add(objectId_1);
+                                            convertGen_1 = (_b = this_3._entityConvertGeneration.get(objectId_1)) !== null && _b !== void 0 ? _b : 0;
                                         }
                                         directMeta = tryBuildDirectEntityMeta(entity, this_3._renderer);
                                         if (directMeta) {
@@ -3783,6 +4211,9 @@ var AcTrView2d = /** @class */ (function (_super) {
                                                             this_3.markProgressiveDirty();
                                                             this_3._progressiveOpenFit.afterGeometryBatch(function () { return _this.getDrawingExtents(); }, i);
                                                         }
+                                                        else {
+                                                            this_3.markInteractiveOpenDirty();
+                                                        }
                                                     }
                                                 }
                                             }
@@ -3797,8 +4228,14 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         threeEntity_1 = this_3.drawEntity(entity, false);
                                         // Viewports may produce no border geometry (e.g. on a no-plot layer) while
                                         // still needing an AcTrViewportView for model content below.
-                                        if (!threeEntity_1 && !(entity instanceof AcDbViewport))
+                                        if (!threeEntity_1 && !(entity instanceof AcDbViewport)) {
+                                            // Release the claim so a later export pass can retry; otherwise
+                                            // `forExport` claim checks would skip this id forever.
+                                            if (objectId_1) {
+                                                this_3._claimedConvertObjectIds.delete(objectId_1);
+                                            }
                                             return [2 /*return*/, "continue"];
+                                        }
                                         if (!threeEntity_1) return [3 /*break*/, 8];
                                         threeEntity_1.objectId = entity.objectId;
                                         threeEntity_1.ownerId = entity.ownerId;
@@ -3823,8 +4260,8 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         return [3 /*break*/, 4];
                                     case 2: return [4 /*yield*/, this_3.handleGroup(threeEntity_1, progressive, epoch, convertGen_1)];
                                     case 3:
-                                        _e.sent();
-                                        _e.label = 4;
+                                        _f.sent();
+                                        _f.label = 4;
                                     case 4: return [3 /*break*/, 8];
                                     case 5:
                                         isExtendBbox_1 = !(entity instanceof AcDbRay || entity instanceof AcDbXline);
@@ -3863,6 +4300,9 @@ var AcTrView2d = /** @class */ (function (_super) {
                                                             this.markProgressiveDirty();
                                                             this._progressiveOpenFit.afterGeometryBatch(function () { return _this.getDrawingExtents(); }, i);
                                                         }
+                                                        else {
+                                                            this.markInteractiveOpenDirty();
+                                                        }
                                                         return [2 /*return*/];
                                                 }
                                             });
@@ -3872,8 +4312,8 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         return [3 /*break*/, 8];
                                     case 6: return [4 /*yield*/, commitEntity()];
                                     case 7:
-                                        _e.sent();
-                                        _e.label = 8;
+                                        _f.sent();
+                                        _f.label = 8;
                                     case 8:
                                         if (epoch !== this_3._convertEpoch) {
                                             return [2 /*return*/, "continue"];
@@ -3884,13 +4324,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                                             // user-created viewport. The redundant check below is kept as
                                             // a defensive guard in case a future refactor reorders the
                                             // early-skip — it costs ~nothing and prevents a regression.
-                                            if (!AcTrViewportView.isDefaultPaperSpaceViewport(entity)) {
-                                                layoutView = this_3._layoutViewManager.getAt(entity.ownerId);
-                                                if (layoutView) {
-                                                    viewportView = new AcTrViewportView(layoutView, entity.toGiViewport(), this_3._renderer);
-                                                    layoutView.addViewport(viewportView);
-                                                }
-                                            }
+                                            this_3.attachViewportView(entity);
                                         }
                                         else if (entity instanceof AcDbRasterImage) {
                                             fileName = entity.imageFileName;
@@ -3903,7 +4337,11 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         }
                                         return [3 /*break*/, 11];
                                     case 9:
-                                        error_3 = _e.sent();
+                                        error_3 = _f.sent();
+                                        failedId = String((_d = entity.objectId) !== null && _d !== void 0 ? _d : '');
+                                        if (failedId) {
+                                            this_3._claimedConvertObjectIds.delete(failedId);
+                                        }
                                         log.error("[AcTrView2d] Failed to convert entity ".concat(entity.objectId, " (").concat(entity.type, "):"), error_3);
                                         return [3 /*break*/, 11];
                                     case 10:
@@ -3917,27 +4355,37 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         if (epoch !== this_3._convertEpoch) {
                                             return [2 /*return*/, "continue"];
                                         }
-                                        if (!yieldGate) return [3 /*break*/, 13];
-                                        return [4 /*yield*/, yieldGate.maybeYield(yieldToEventLoop)];
+                                        if (!progressive) return [3 /*break*/, 13];
+                                        // Prefer input-aware yields so pan/zoom are not starved after the
+                                        // overlay is gone; paint throttling stays in markProgressiveDirty.
+                                        return [4 /*yield*/, this_3.progressiveYieldForInput(yieldGate, yieldToEventLoop)];
                                     case 12:
-                                        didYield = _e.sent();
+                                        // Prefer input-aware yields so pan/zoom are not starved after the
+                                        // overlay is gone; paint throttling stays in markProgressiveDirty.
+                                        _f.sent();
+                                        return [3 /*break*/, 15];
+                                    case 13:
+                                        if (!yieldGate) return [3 /*break*/, 15];
+                                        return [4 /*yield*/, yieldGate.maybeYield(yieldToEventLoop)];
+                                    case 14:
+                                        didYield = _f.sent();
                                         if (didYield) {
                                             this_3._progressiveYieldCount++;
                                         }
-                                        _e.label = 13;
-                                    case 13: return [2 /*return*/];
+                                        _f.label = 15;
+                                    case 15: return [2 /*return*/];
                                 }
                             });
                         };
                         this_3 = this;
                         i = 0;
-                        _d.label = 1;
+                        _e.label = 1;
                     case 1:
                         if (!(i < entities.length)) return [3 /*break*/, 4];
                         return [5 /*yield**/, _loop_4(i)];
                     case 2:
-                        _d.sent();
-                        _d.label = 3;
+                        _e.sent();
+                        _e.label = 3;
                     case 3:
                         ++i;
                         return [3 /*break*/, 1];
@@ -3951,6 +4399,12 @@ var AcTrView2d = /** @class */ (function (_super) {
      * with their union before spatial-index registration.
      */
     AcTrView2d.prototype.syncGroupSpatialBoundsForIndexing = function (group) {
+        var lazy = group.peekLazyChildBoxes();
+        if (lazy && lazy.boxes.length > 0) {
+            var userData_1 = group.userData;
+            userData_1.lazySpatialChildren = lazy;
+            return;
+        }
         group.refreshWcsChildBoxesFromChildren();
         if (group.wcsChildBoxes.length === 0) {
             return;
@@ -3968,45 +4422,45 @@ var AcTrView2d = /** @class */ (function (_super) {
     };
     AcTrView2d.prototype.handleGroup = function (group_1, progressive_1) {
         return __awaiter(this, arguments, void 0, function (group, progressive, epoch, convertGen) {
-            var t0, objectId, children, objectsGroupByLayer_1, children_1, children_1_1, child, renderContext_1, groupObjectId_1, groupLayerName_1, groupChildBoxes_1, aggregateSpatialBbox_1, registeredChildIndex_1;
-            var e_17, _a;
+            var t0, objectId, children, objectsGroupByLayer_2, children_1, children_1_1, child, renderContext, groupObjectId, groupLayerName, lazyChildren, groupChildBoxes, aggregateSpatialBbox, registeredChildIndex, yieldToEventLoop, lastGroupYieldAt, _loop_5, this_4, objectsGroupByLayer_1, objectsGroupByLayer_1_1, _a, layerName, objects, e_18_1;
+            var e_19, _b, e_18, _c;
             var _this = this;
-            var _b, _c;
+            var _d, _e;
             if (epoch === void 0) { epoch = this._convertEpoch; }
             if (convertGen === void 0) { convertGen = 0; }
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            return __generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
                         t0 = performance.now();
-                        _d.label = 1;
+                        _f.label = 1;
                     case 1:
-                        _d.trys.push([1, , 3, 4]);
+                        _f.trys.push([1, , 11, 12]);
                         return [4 /*yield*/, this.finishEntityGeometry(group, progressive)];
                     case 2:
-                        _d.sent();
+                        _f.sent();
                         if (epoch !== this._convertEpoch) {
                             group.dispose();
                             return [2 /*return*/];
                         }
-                        objectId = String((_b = group.objectId) !== null && _b !== void 0 ? _b : '');
+                        objectId = String((_d = group.objectId) !== null && _d !== void 0 ? _d : '');
                         if (objectId &&
-                            ((_c = this._entityConvertGeneration.get(objectId)) !== null && _c !== void 0 ? _c : 0) !== convertGen) {
+                            ((_e = this._entityConvertGeneration.get(objectId)) !== null && _e !== void 0 ? _e : 0) !== convertGen) {
                             group.dispose();
                             return [2 /*return*/];
                         }
                         this.syncGroupSpatialBoundsForIndexing(group);
                         children = group.children;
-                        objectsGroupByLayer_1 = new Map();
+                        objectsGroupByLayer_2 = new Map();
                         children.forEach(function (child) {
                             var _a;
                             if (child.visible === false) {
                                 return;
                             }
                             var layerName = child.userData.layerName;
-                            if (!objectsGroupByLayer_1.has(layerName)) {
-                                objectsGroupByLayer_1.set(layerName, []);
+                            if (!objectsGroupByLayer_2.has(layerName)) {
+                                objectsGroupByLayer_2.set(layerName, []);
                             }
-                            (_a = objectsGroupByLayer_1.get(layerName)) === null || _a === void 0 ? void 0 : _a.push(child);
+                            (_a = objectsGroupByLayer_2.get(layerName)) === null || _a === void 0 ? void 0 : _a.push(child);
                         });
                         // Important:
                         // Sometimes one group may contain huge amount of objects (> 100,000). So it is important
@@ -4024,89 +4478,136 @@ var AcTrView2d = /** @class */ (function (_super) {
                                 child.parent = null;
                             }
                         }
-                        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+                        catch (e_19_1) { e_19 = { error: e_19_1 }; }
                         finally {
                             try {
-                                if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
+                                if (children_1_1 && !children_1_1.done && (_b = children_1.return)) _b.call(children_1);
                             }
-                            finally { if (e_17) throw e_17.error; }
+                            finally { if (e_19) throw e_19.error; }
                         }
-                        renderContext_1 = group.renderContext;
-                        groupObjectId_1 = group.objectId;
-                        groupLayerName_1 = group.layerName;
-                        // AcDbRenderingCache.draw (and similar paths such as AcDbTable) already call
-                        // applyMatrix on the group, which updates wcsBbbox and wcsChildBoxes to WCS.
-                        // Do not multiply group.matrix here — that would double-transform spatial bounds.
-                        if (process.env.NODE_ENV !== 'production') {
+                        renderContext = group.renderContext;
+                        groupObjectId = group.objectId;
+                        groupLayerName = group.layerName;
+                        lazyChildren = group.userData.lazySpatialChildren;
+                        if (process.env.NODE_ENV !== 'production' && !lazyChildren) {
                             assertAcTrGroupWcsBboxesConsistent(group);
                         }
-                        groupChildBoxes_1 = group.wcsChildBoxes.map(function (box) { return ({
-                            minX: box.minX,
-                            minY: box.minY,
-                            maxX: box.maxX,
-                            maxY: box.maxY,
-                            id: box.id
-                        }); });
-                        aggregateSpatialBbox_1 = groupChildBoxes_1.length > 0
-                            ? unionGroupWcsChildBoxes(group)
-                            : group.wcsBbox.clone();
-                        if (groupChildBoxes_1.length > 0) {
-                            group.wcsBbox = aggregateSpatialBbox_1.clone();
+                        groupChildBoxes = lazyChildren
+                            ? []
+                            : group.wcsChildBoxes.map(function (box) { return ({
+                                minX: box.minX,
+                                minY: box.minY,
+                                maxX: box.maxX,
+                                maxY: box.maxY,
+                                id: box.id
+                            }); });
+                        aggregateSpatialBbox = lazyChildren
+                            ? group.wcsBbox.clone()
+                            : groupChildBoxes.length > 0
+                                ? unionGroupWcsChildBoxes(group)
+                                : group.wcsBbox.clone();
+                        if (groupChildBoxes.length > 0) {
+                            group.wcsBbox = aggregateSpatialBbox.clone();
                         }
-                        registeredChildIndex_1 = false;
-                        objectsGroupByLayer_1.forEach(function (objects, layerName) {
-                            // Nested layer-0 may already be resolved to an inner INSERT layer during
-                            // flatten. Remaining "0" buckets inherit this (outermost) INSERT layer.
-                            var effectiveLayerName = layerName === '0' ? groupLayerName_1 : layerName;
-                            // Material remap must still treat authored layer-0 drawables as layer-0
-                            // ByLayer even when nest resolution already rewrote layerName.
-                            var sourceLayerForMaterials = objects.some(function (object) {
-                                var _a;
-                                var data = object.userData;
-                                return ((_a = data.authoredLayerName) !== null && _a !== void 0 ? _a : layerName) === '0';
-                            })
-                                ? '0'
-                                : layerName;
-                            // Keep runtime layer metadata/material cache aligned with the inherited layer so
-                            // later layer style edits (color, linetype, lineweight, transparency) target this
-                            // object set correctly.
-                            _this._inheritedLayerMaterialMapper.remap(objects, sourceLayerForMaterials, effectiveLayerName);
-                            // One INSERT can expand to children from multiple layers. Here we create one
-                            // render entity per layer bucket but preserve the INSERT object id for all
-                            // buckets, so selection/highlight still maps back to the same database object.
-                            // Within each layer bucket, the object id remains unique in scene indexing.
-                            var entity = new AcTrEntity(renderContext_1);
-                            // Copy the INSERT matrix exactly — applyMatrix4 decomposes and drops
-                            // reflections from mirrored block scales.
-                            entity.matrix.copy(group.matrix);
-                            entity.matrixAutoUpdate = false;
-                            entity.matrixWorldNeedsUpdate = true;
-                            entity.objectId = groupObjectId_1;
-                            entity.ownerId = group.ownerId;
-                            // If block-definition entities are on layer "0", this bucket now uses the layer
-                            // of the block reference itself (effectiveLayerName).
-                            entity.layerName = effectiveLayerName;
-                            entity.userData.insertLayerName = groupLayerName_1;
-                            entity.wcsBbox = aggregateSpatialBbox_1.clone();
-                            var entityUserData = entity.userData;
-                            if (!registeredChildIndex_1 && groupChildBoxes_1.length > 0) {
-                                entityUserData.spatialIndexChildBoxes = groupChildBoxes_1;
-                                registeredChildIndex_1 = true;
-                            }
-                            // Important:
-                            // DO NOT USE spread operator when adding objects because it may be one very large array
-                            // and can result in maximum call stack size exceeded
-                            for (var i = 0; i < objects.length; i++) {
-                                entity.add(objects[i]);
-                            }
-                            entity.updateMatrixWorld(true);
-                            _this._layerAppearance.refreshTextMaterialsInObjectTree(entity);
-                            var tAdd = performance.now();
-                            _this._scene.addEntity(entity, true);
-                            _this._convertPhaseMs.addEntity += performance.now() - tAdd;
-                            _this.applySessionHiddenObjectState(groupObjectId_1);
-                            entity.dispose();
-                        });
+                        registeredChildIndex = false;
+                        yieldToEventLoop = function () {
+                            return new Promise(function (resolve) { return setTimeout(resolve, 0); });
+                        };
+                        lastGroupYieldAt = progressive ? performance.now() : 0;
+                        _loop_5 = function (layerName, objects) {
+                            var effectiveLayerName, sourceLayerForMaterials, entity, entityUserData, i, tAdd;
+                            return __generator(this, function (_g) {
+                                switch (_g.label) {
+                                    case 0:
+                                        effectiveLayerName = layerName === '0' ? groupLayerName : layerName;
+                                        sourceLayerForMaterials = objects.some(function (object) {
+                                            var _a;
+                                            var data = object.userData;
+                                            return ((_a = data.authoredLayerName) !== null && _a !== void 0 ? _a : layerName) === '0';
+                                        })
+                                            ? '0'
+                                            : layerName;
+                                        // Keep runtime layer metadata/material cache aligned with the inherited layer so
+                                        // later layer style edits (color, linetype, lineweight, transparency) target this
+                                        // object set correctly.
+                                        this_4._inheritedLayerMaterialMapper.remap(objects, sourceLayerForMaterials, effectiveLayerName);
+                                        entity = new AcTrEntity(renderContext);
+                                        // Copy the INSERT matrix exactly — applyMatrix4 decomposes and drops
+                                        // reflections from mirrored block scales.
+                                        entity.matrix.copy(group.matrix);
+                                        entity.matrixAutoUpdate = false;
+                                        entity.matrixWorldNeedsUpdate = true;
+                                        entity.objectId = groupObjectId;
+                                        entity.ownerId = group.ownerId;
+                                        // If block-definition entities are on layer "0", this bucket now uses the layer
+                                        // of the block reference itself (effectiveLayerName).
+                                        entity.layerName = effectiveLayerName;
+                                        entity.userData.insertLayerName = groupLayerName;
+                                        entity.wcsBbox = aggregateSpatialBbox.clone();
+                                        entityUserData = entity.userData;
+                                        if (!registeredChildIndex && lazyChildren) {
+                                            ;
+                                            entity.userData.lazySpatialChildren = lazyChildren;
+                                            registeredChildIndex = true;
+                                        }
+                                        else if (!registeredChildIndex && groupChildBoxes.length > 0) {
+                                            entityUserData.spatialIndexChildBoxes = groupChildBoxes;
+                                            registeredChildIndex = true;
+                                        }
+                                        // Important:
+                                        // DO NOT USE spread operator when adding objects because it may be one very large array
+                                        // and can result in maximum call stack size exceeded
+                                        for (i = 0; i < objects.length; i++) {
+                                            entity.add(objects[i]);
+                                        }
+                                        entity.updateMatrixWorld(true);
+                                        this_4._layerAppearance.refreshTextMaterialsInObjectTree(entity);
+                                        tAdd = performance.now();
+                                        this_4._scene.addEntity(entity, true);
+                                        this_4._convertPhaseMs.addEntity += performance.now() - tAdd;
+                                        this_4.applySessionHiddenObjectState(groupObjectId);
+                                        entity.dispose();
+                                        if (!(progressive &&
+                                            epoch === this_4._convertEpoch &&
+                                            performance.now() - lastGroupYieldAt >=
+                                                AcTrView2d.PROGRESSIVE_OPEN_YIELD_BUDGET_MS)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, yieldToEventLoop()];
+                                    case 1:
+                                        _g.sent();
+                                        lastGroupYieldAt = performance.now();
+                                        _g.label = 2;
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_4 = this;
+                        _f.label = 3;
+                    case 3:
+                        _f.trys.push([3, 8, 9, 10]);
+                        objectsGroupByLayer_1 = __values(objectsGroupByLayer_2), objectsGroupByLayer_1_1 = objectsGroupByLayer_1.next();
+                        _f.label = 4;
+                    case 4:
+                        if (!!objectsGroupByLayer_1_1.done) return [3 /*break*/, 7];
+                        _a = __read(objectsGroupByLayer_1_1.value, 2), layerName = _a[0], objects = _a[1];
+                        return [5 /*yield**/, _loop_5(layerName, objects)];
+                    case 5:
+                        _f.sent();
+                        _f.label = 6;
+                    case 6:
+                        objectsGroupByLayer_1_1 = objectsGroupByLayer_1.next();
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_18_1 = _f.sent();
+                        e_18 = { error: e_18_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (objectsGroupByLayer_1_1 && !objectsGroupByLayer_1_1.done && (_c = objectsGroupByLayer_1.return)) _c.call(objectsGroupByLayer_1);
+                        }
+                        finally { if (e_18) throw e_18.error; }
+                        return [7 /*endfinally*/];
+                    case 10:
                         group.dispose();
                         if (progressive) {
                             this.markProgressiveDirty();
@@ -4114,11 +4615,14 @@ var AcTrView2d = /** @class */ (function (_super) {
                                 return _this.getDrawingExtents();
                             });
                         }
-                        return [3 /*break*/, 4];
-                    case 3:
+                        else {
+                            this.markInteractiveOpenDirty();
+                        }
+                        return [3 /*break*/, 12];
+                    case 11:
                         this._convertPhaseMs.handleGroup += performance.now() - t0;
                         return [7 /*endfinally*/];
-                    case 4: return [2 /*return*/];
+                    case 12: return [2 /*return*/];
                 }
             });
         });
@@ -4173,27 +4677,57 @@ var AcTrView2d = /** @class */ (function (_super) {
         }
     };
     /**
-     * Wall-time between cooperative yields during scene convert (ms).
-     * Used for both progressive and non-progressive opens so large drawings
-     * (e.g. multi-sheet architectural DWGs) cannot freeze the main thread long
-     * enough for Chromium to show "Page Unresponsive" while the overlay still
-     * reads "Rendering drawing ...". Kept relatively large so convert
-     * throughput stays high; smaller budgets made open 2–3× slower.
+     * Wall-time between cooperative yields during scene convert (ms) when
+     * progressive rendering is off. Overlay still blocks input, so a larger
+     * budget keeps throughput high while avoiding Chromium "Page Unresponsive".
      */
     AcTrView2d.OPEN_CONVERT_YIELD_BUDGET_MS = 300;
     /**
-     * Minimum interval between progressive mid-open paints (ms).
-     * Full-scene WebGL paints dominate open wall time on large drawings;
-     * paint much less often than we yield. Independent of convert yields —
-     * non-progressive opens still yield without mid-open WebGL paints.
+     * Yield cadence during progressive open (ms). Overlay stays hidden; keep
+     * slices near one frame so pan/zoom handlers can run. Discrete
+     * `navigator.scheduling.isInputPending` yields once so handlers run;
+     * pointerdown/wheel set a short pause so OrbitControls can catch up.
+     */
+    AcTrView2d.PROGRESSIVE_OPEN_YIELD_BUDGET_MS = 32;
+    /** Extra idle window after canvas pointerdown/wheel so gestures stay fluid. */
+    AcTrView2d.PROGRESSIVE_INPUT_PAUSE_MS = 120;
+    /**
+     * Minimum interval between progressive mid-open paints driven by convert
+     * (ms). Full-scene WebGL paints dominate open wall time; user camera
+     * changes bypass this throttle via {@link _progressivePaintUrgent}.
      */
-    AcTrView2d.PROGRESSIVE_OPEN_PAINT_INTERVAL_MS = 1000;
+    AcTrView2d.PROGRESSIVE_OPEN_PAINT_INTERVAL_MS = 2500;
+    /**
+     * Minimum interval between interactive non-progressive mid-open paints (ms)
+     * while convert / deferred glyphs run under "Rendering drawing ...".
+     * Longer than {@link PROGRESSIVE_OPEN_PAINT_INTERVAL_MS}: the overlay is
+     * semi-transparent (`rgba(0,0,0,0.45)`), but each paint still redraws the
+     * full scene and used to fire on every glyph completion. Headless
+     * (`cooperativeYield` false) skips these paints entirely.
+     */
+    AcTrView2d.NON_PROGRESSIVE_OPEN_PAINT_INTERVAL_MS = 4000;
     /**
      * Max concurrent deferred glyph/INSERT geometry finalizers. Large drawings
      * enqueue thousands of jobs; keep this modest to limit peak JS heap during
      * open while retaining reasonable text throughput after convert finishes.
      */
     AcTrView2d.DEFERRED_GEOMETRY_CONCURRENCY = 8;
+    /**
+     * Target wall time of one interactive convert slice (ms) while a paper
+     * layout is active.
+     *
+     * Slices return to the drain so a layout activated mid-open can jump ahead
+     * of a long model-space batch. Kept well above one frame (≈50–100 ms) so
+     * the fixed cost of each slice — yield, paint, queue absorb — does not
+     * dominate total load time. The 300ms yield inside {@link batchConvert}
+     * still applies within a slice.
+     */
+    AcTrView2d.CONVERT_SLICE_BUDGET_MS = 64;
+    /**
+     * Upper bound on entities per slice. Heavy block references stay at 1
+     * because a slice that overruns the time budget is halved.
+     */
+    AcTrView2d.CONVERT_SLICE_MAX = 512;
     return AcTrView2d;
 }(AcEdBaseView));
 export { AcTrView2d };