@mlightcad/cad-simple-viewer 1.7.5 → 1.7.6

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';
@@ -179,6 +180,11 @@ var AcTrView2d = /** @class */ (function (_super) {
         var container = (_a = mergedOptions.container) !== null && _a !== void 0 ? _a : document.createElement('div');
         mergedOptions.container = container;
         container.style.overflow = 'hidden';
+        // Allow focusing the container after canvas clicks so document-level
+        // shortcuts stay scoped to this viewer without stealing host-page focus.
+        if (!container.hasAttribute('tabindex')) {
+            container.tabIndex = -1;
+        }
         var renderer = new THREE.WebGLRenderer({
             antialias: true,
             alpha: true
@@ -288,6 +294,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 +309,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}. */
@@ -344,6 +364,12 @@ var AcTrView2d = /** @class */ (function (_super) {
          * ENTITY parse and linework convert; glyph jobs await this before draw.
          */
         _this._textStyleFontPreloadPromise = null;
+        /**
+         * Aborts canvas / document DOM listeners registered on this view.
+         * Custom singleton listeners are removed explicitly in {@link dispose}.
+         */
+        _this._viewDomAbort = new AbortController();
+        _this._viewDisposed = false;
         /** Transient reading mode forces black linework on a white canvas. */
         _this._readingMode = new AcApReadingModeState({
             getCurrentBackgroundColor: function () { return _this._renderer.currentBackgroundColor; },
@@ -376,17 +402,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 +452,31 @@ var AcTrView2d = /** @class */ (function (_super) {
             _this._htmlDirty = false;
         };
         _this._disposeCanvasTouchCallout = disposeCanvasTouchCallout;
+        var onProgressiveInput = function () { return _this.noteProgressiveUserInput(); };
+        // Pointer and wheel both claim shortcut focus so undo/erase still work
+        // after zooming without a prior click, without stealing focus from host
+        // inputs/textareas/contenteditable fields.
+        var onCanvasPointerDown = function () {
+            onProgressiveInput();
+            _this.focusViewerForShortcuts();
+        };
+        var onCanvasWheel = function () {
+            onProgressiveInput();
+            _this.focusViewerForShortcuts();
+        };
+        renderer.domElement.addEventListener('pointerdown', onCanvasPointerDown, {
+            capture: true
+        });
+        renderer.domElement.addEventListener('wheel', onCanvasWheel, {
+            capture: true,
+            passive: true
+        });
+        _this._disposeProgressiveInputWatch = function () {
+            renderer.domElement.removeEventListener('pointerdown', onCanvasPointerDown, { capture: true });
+            renderer.domElement.removeEventListener('wheel', onCanvasWheel, {
+                capture: true
+            });
+        };
         _this._gripManager = new AcEdGripManager(_this);
         _this._keyHandler = new AcEdViewKeyHandler(_this);
         if (options.calculateSizeCallback) {
@@ -417,27 +490,32 @@ var AcTrView2d = /** @class */ (function (_super) {
         setAcTrDrawOrderZAllocator(function () { return _this._renderer.allocateDrawOrderZ(); });
         var fontMapping = AcApSettingManager.instance.fontMapping;
         _this._renderer.setFontMapping(fontMapping);
-        _this._renderer.events.fontNotFound.addEventListener(function (args) {
+        _this._onFontNotFound = function (args) {
             var _a;
             eventBus.emit('font-not-found', {
                 fontName: args.fontName,
                 count: (_a = args.count) !== null && _a !== void 0 ? _a : 0
             });
-        });
-        _this._renderer.events.fontLoaded.addEventListener(function (args) {
+        };
+        _this._onFontLoaded = function (args) {
             // Lazy load success clears FontManager.missedFonts; refresh status-bar state.
             eventBus.emit('missed-data-changed', {});
             // On-demand faces (e.g. style `malgun`) may finish after the first glyph
             // bake. Rebuild text so Hangul is not left as permanent '?'.
             _this.scheduleGlyphRedrawAfterFontLoad(args === null || args === void 0 ? void 0 : args.fontName);
-        });
+        };
+        _this._renderer.events.fontNotFound.addEventListener(_this._onFontNotFound);
+        _this._renderer.events.fontLoaded.addEventListener(_this._onFontLoaded);
         _this._scene = _this.createScene();
         _this._layerAppearance = new AcTrLayerAppearanceController(_this._scene, _this._renderer);
         _this._inheritedLayerMaterialMapper = new AcTrInheritedLayerMaterialMapper(function (layerName) { return _this._layerAppearance.getEffectiveLayerTraits(layerName); }, _this._renderer);
         // Initialize background color through setter to keep renderer/cursor in sync.
         _this.backgroundColor =
             (_b = mergedOptions.background) !== null && _b !== void 0 ? _b : ACGI_MODEL_SPACE_BACKGROUND;
-        _this._stats = _this.createStats(AcApSettingManager.instance.isShowStats && _this.isActiveManagedView());
+        // During main-view construction the manager singleton is not published yet,
+        // so treat a missing manager as "this is the primary canvas".
+        _this._stats = _this.createStats(AcApSettingManager.instance.isShowStats &&
+            (AcApDocManager.tryGetInstance() == null || _this.isActiveManagedView()));
         // Layout background sysvars drive the canvas clear colour and ACI-7
         // inversion (`MODELBKCOLOR` for model space, `PAPERBKCOLOR` for the
         // active layout). `COLORTHEME` only affects UI chrome — see
@@ -445,23 +523,28 @@ var AcTrView2d = /** @class */ (function (_super) {
         var sysVarManager = AcDbSysVarManager.instance();
         var modelBkVar = AcDbSystemVariables.MODELBKCOLOR.toLowerCase();
         var paperBkVar = AcDbSystemVariables.PAPERBKCOLOR.toLowerCase();
-        sysVarManager.events.sysVarChanged.addEventListener(function (args) {
+        _this._onSysVarChanged = function (args) {
             var nameLower = args.name.toLowerCase();
             if (nameLower === modelBkVar || nameLower === paperBkVar) {
-                var isModelSpace = _this.isModelSpaceLayout(args.database);
+                var database = args.database;
+                if (!database)
+                    return;
+                var isModelSpace = _this.isModelSpaceLayout(database);
                 var applies = (nameLower === modelBkVar && isModelSpace) ||
                     (nameLower === paperBkVar && !isModelSpace);
                 if (!applies) {
                     return;
                 }
-                _this.applyCanvasBackground(readLayoutBackgroundColor(args.database, isModelSpace));
+                _this.applyCanvasBackground(readLayoutBackgroundColor(database, isModelSpace));
             }
-        });
-        AcApSettingManager.instance.events.modified.addEventListener(function (args) {
+        };
+        sysVarManager.events.sysVarChanged.addEventListener(_this._onSysVarChanged);
+        _this._onSettingsModified = function (args) {
             if (args.key == 'isShowStats') {
                 _this.toggleStatsVisibility(_this._stats, args.value);
             }
-        });
+        };
+        AcApSettingManager.instance.events.modified.addEventListener(_this._onSettingsModified);
         var selectionStartWcs = null;
         var selectionStartCanvas = null;
         var selectionPreviewEl = null;
@@ -567,6 +650,7 @@ var AcTrView2d = /** @class */ (function (_super) {
             selectionStartWcs = null;
             selectionStartCanvas = null;
         };
+        var viewDomSignal = _this._viewDomAbort.signal;
         _this.canvas.addEventListener('mousedown', function (e) {
             if (e.button !== 0)
                 return;
@@ -576,7 +660,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                 return;
             }
             beginSelectionPreview(e.clientX, e.clientY);
-        });
+        }, { signal: viewDomSignal });
         _this.canvas.addEventListener('mousemove', function (e) {
             if (!selectionStartWcs || !selectionPreviewEl || !selectionStartCanvas) {
                 return;
@@ -585,7 +669,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                 return;
             }
             updateSelectionPreview(e.clientX, e.clientY, _this.getPointerSelectionAction(e));
-        });
+        }, { signal: viewDomSignal });
         _this.canvas.addEventListener('mouseup', function (e) {
             if (_this._gripManager.isDragging) {
                 resetSelectionDrag();
@@ -602,8 +686,8 @@ var AcTrView2d = /** @class */ (function (_super) {
             });
             var action = _this.getPointerSelectionAction(e);
             finishSelection(e.clientX, e.clientY, action, _this.isSelectionClick(selectionStartCanvas, endCanvas));
-        });
-        acedAttachMobileBoxGesture({
+        }, { signal: viewDomSignal });
+        _this._disposeMobileBoxGesture = acedAttachMobileBoxGesture({
             element: _this.canvas,
             shouldStart: function () { return canHandleMobileBoxGesture(); },
             setNavigationEnabled: function (enabled) {
@@ -642,16 +726,19 @@ var AcTrView2d = /** @class */ (function (_super) {
                 return;
             }
             void _this.openPickedEntityEditor(e);
-        });
+        }, { signal: viewDomSignal });
         // When using OrbitControls in THREE.js, it attaches its own event listeners to the DOM elements,
         // such as the canvas or the entire document. This can interfere with other event listeners you
-        // add, including the keydown event.
+        // add, including the keydown event. Scope to this view's container so host-page shortcuts
+        // (and post-destroy key presses) are not captured.
         document.addEventListener('keydown', function (e) {
             if (!_this.isActiveManagedView())
                 return;
+            if (!_this.isShortcutEventInsideViewer(e))
+                return;
             _this._keyHandler.handleKeyDown(e);
-        });
-        acdbHostApplicationServices().layoutManager.events.layoutSwitched.addEventListener(function (args) {
+        }, { signal: viewDomSignal });
+        _this._onLayoutSwitched = function (args) {
             var _a, _b;
             if (!_this.isActiveManagedView())
                 return;
@@ -691,7 +778,8 @@ var AcTrView2d = /** @class */ (function (_super) {
             if (isFirstVisit) {
                 _this.applyInitialZoom(btrId, args.layout);
             }
-        });
+        };
+        acdbHostApplicationServices().layoutManager.events.layoutSwitched.addEventListener(_this._onLayoutSwitched);
         _this._css2dRenderer = new CSS2DRenderer();
         _this._css2dRenderer.setSize(_this.width, _this.height);
         _this._css2dRenderer.domElement.style.position = 'absolute';
@@ -790,12 +878,14 @@ var AcTrView2d = /** @class */ (function (_super) {
         // This method is called after camera and render are created.
         // Children class can override this method to add its own logic
         this.setCursor(AcEdCorsorType.Crosshair);
-        this.editor.events.commandWillStart.addEventListener(function () {
+        this._onCommandWillStartHitTest = function () {
             _this.htmlTransientManager.setHitTestEnabled(false);
-        });
-        this.editor.events.commandEnded.addEventListener(function () {
+        };
+        this._onCommandEndedHitTest = function () {
             _this.htmlTransientManager.setHitTestEnabled(true);
-        });
+        };
+        this.editor.events.commandWillStart.addEventListener(this._onCommandWillStartHitTest);
+        this.editor.events.commandEnded.addEventListener(this._onCommandEndedHitTest);
     };
     Object.defineProperty(AcTrView2d.prototype, "mode", {
         /**
@@ -910,10 +1000,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 +1093,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 +1109,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 +1125,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 +1650,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 +1704,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 +1714,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');
@@ -2035,6 +2230,37 @@ var AcTrView2d = /** @class */ (function (_super) {
         var sortedResults = sortPickResults(results, point);
         return pickOneOnly ? sortedResults.slice(0, 1) : sortedResults;
     };
+    /**
+     * @inheritdoc
+     */
+    AcTrView2d.prototype.getViewportCoordinateMapper = function (viewportId) {
+        var e_7, _a;
+        var _b, _c;
+        var vpView;
+        try {
+            for (var _d = __values((_c = (_b = this.activeLayoutView) === null || _b === void 0 ? void 0 : _b.viewportViews) !== null && _c !== void 0 ? _c : []), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var candidate = _e.value;
+                if (candidate.viewport.id === viewportId) {
+                    vpView = candidate;
+                    break;
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        if (!vpView)
+            return undefined;
+        return {
+            paperToModel: function (point) { return vpView.paperPointToModel(point); },
+            modelToPaper: function (point) { return vpView.modelPointToPaper(point); },
+            containsPaperPoint: function (point) { return vpView.containsPaperPoint(point); }
+        };
+    };
     /**
      * Resolves hits against the model-space layout for each viewport the
      * click drills through. Appends the matches into `results` (caller
@@ -2052,7 +2278,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * paper-space pick.
      */
     AcTrView2d.prototype.pickThroughViewports = function (paperPoint, paperBox, viewports, results) {
-        var e_7, _a;
+        var e_8, _a;
         var modelLayout = this._scene.modelSpaceLayout;
         if (!modelLayout)
             return;
@@ -2077,7 +2303,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                 if (!isEffectiveSpatialQueryHit(item))
                     return;
                 if (modelLayout.isIntersectWith(item.id, vpRaycaster)) {
-                    results.push(item);
+                    results.push(__assign(__assign({}, item), { viewportId: vpView.viewport.id }));
                 }
             });
         };
@@ -2087,12 +2313,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 _loop_1(vpView);
             }
         }
-        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
         finally {
             try {
                 if (viewports_1_1 && !viewports_1_1.done && (_a = viewports_1.return)) _a.call(viewports_1);
             }
-            finally { if (e_7) throw e_7.error; }
+            finally { if (e_8) throw e_8.error; }
         }
     };
     /**
@@ -2125,7 +2351,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * that interior also selects those polylines and can stall highlight work.
      */
     AcTrView2d.prototype.refineCrossingSelectionHits = function (box, results) {
-        var e_8, _a;
+        var e_9, _a;
         var _b;
         var database = (_b = AcApDocManager.instance.curDocument) === null || _b === void 0 ? void 0 : _b.database;
         if (!database) {
@@ -2150,12 +2376,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 }
             }
         }
-        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
         finally {
             try {
                 if (results_1_1 && !results_1_1.done && (_a = results_1.return)) _a.call(results_1);
             }
-            finally { if (e_8) throw e_8.error; }
+            finally { if (e_9) throw e_9.error; }
         }
         return ids;
     };
@@ -2171,7 +2397,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @inheritdoc
      */
     AcTrView2d.prototype.updateLayer = function (layer, changes) {
-        var e_9, _a;
+        var e_10, _a;
         var touchedObjectIds = this._scene.updateLayer(this.toLayerInfo(layer)).touchedObjectIds;
         if (this._layerAppearance.layerStyleMayHaveChanged(changes)) {
             this._layerAppearance.syncFromLiveRecord(layer);
@@ -2193,12 +2419,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 this.applySessionHiddenObjectState(objectId);
             }
         }
-        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
         finally {
             try {
                 if (touchedObjectIds_1_1 && !touchedObjectIds_1_1.done && (_a = touchedObjectIds_1.return)) _a.call(touchedObjectIds_1);
             }
-            finally { if (e_9) throw e_9.error; }
+            finally { if (e_10) throw e_10.error; }
         }
         this._isDirty = true;
     };
@@ -2359,6 +2585,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
      */
@@ -2461,7 +2698,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * drawable entity that must be rebuilt (for example ATTRIB → INSERT).
      */
     AcTrView2d.prototype.resolveSceneUpdateEntities = function (entities) {
-        var e_10, _a;
+        var e_11, _a;
         var _b;
         var db = (_b = AcApDocManager.instance.curDocument) === null || _b === void 0 ? void 0 : _b.database;
         var resolved = [];
@@ -2483,12 +2720,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 resolved.push(target);
             }
         }
-        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
         finally {
             try {
                 if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
             }
-            finally { if (e_10) throw e_10.error; }
+            finally { if (e_11) throw e_11.error; }
         }
         return resolved;
     };
@@ -2517,6 +2754,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.
      *
@@ -2610,20 +2858,31 @@ var AcTrView2d = /** @class */ (function (_super) {
         waiter.start();
     };
     /**
-     * @inheritdoc
+     * Invalidates in-flight progressive convert and empties convert / deferred
+     * queues without tearing down the renderer or DOM.
+     *
+     * Call before {@link AcApDocManager.destroy} tears down documents so
+     * in-flight commits do not keep reading the manager singleton.
      */
-    AcTrView2d.prototype.clear = function () {
+    AcTrView2d.prototype.abortConversion = function () {
         // Invalidate any in-flight progressive convert so it neither paints into
         // the cleared scene nor double-decrements the processing counter.
         this._convertEpoch++;
         this.clearFontLoadedRedrawTimer();
         this._convertQueue.length = 0;
+        this._viewportRepairOwnerIds.clear();
         this._numOfEntitiesToProcess = 0;
         this._claimedConvertObjectIds.clear();
         this._entityConvertGeneration.clear();
         this.cancelOpenLineworkFrame();
         this.resetDeferredGeometryQueue();
         this._entityProcessingIdleAt = 0;
+    };
+    /**
+     * @inheritdoc
+     */
+    AcTrView2d.prototype.clear = function () {
+        this.abortConversion();
         this._scene.clear();
         this._renderer.resetDrawOrderZ();
         this._isDirty = true;
@@ -2664,6 +2923,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 +2956,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();
@@ -2738,12 +2999,44 @@ var AcTrView2d = /** @class */ (function (_super) {
     /**
      * True when this view is the document manager's live canvas.
      * Satellite/preview views must ignore global shortcuts and layout switches.
+     * Returns false when no manager exists so post-destroy key handlers do not
+     * reach {@link AcApDocManager.instance}.
      */
     AcTrView2d.prototype.isActiveManagedView = function () {
         var _a;
         var singleton = AcApDocManager;
         var current = (_a = singleton._instance) === null || _a === void 0 ? void 0 : _a.curView;
-        return current == null || current === this;
+        return current != null && current === this;
+    };
+    /**
+     * Moves keyboard focus into the viewer container after canvas interaction so
+     * document-level shortcuts stay scoped to this view.
+     *
+     * Skips host editable fields so wheel-over-canvas does not interrupt typing.
+     */
+    AcTrView2d.prototype.focusViewerForShortcuts = function () {
+        var active = document.activeElement;
+        if (active instanceof Node && this.container.contains(active)) {
+            return;
+        }
+        if (active instanceof HTMLElement &&
+            (active.tagName === 'INPUT' ||
+                active.tagName === 'TEXTAREA' ||
+                active.isContentEditable)) {
+            return;
+        }
+        this.container.focus({ preventScroll: true });
+    };
+    /**
+     * True when the key event originated from (or is focused within) this view.
+     */
+    AcTrView2d.prototype.isShortcutEventInsideViewer = function (e) {
+        var target = e.target;
+        if (target instanceof Node && this.container.contains(target)) {
+            return true;
+        }
+        var active = document.activeElement;
+        return active instanceof Node && this.container.contains(active);
     };
     /**
      * Drains the convert queue on a single serial worker so ENTITY flush chunks
@@ -2770,21 +3063,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 +3074,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 +3264,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
      */
@@ -2858,18 +3335,63 @@ var AcTrView2d = /** @class */ (function (_super) {
         }
     };
     /**
-     * Releases canvas DOM listeners and stops the animation loop.
+     * Releases canvas DOM, WebGL context, convert work, and listeners.
      *
      * Call when this view will no longer be used (manager destroy / split
      * view teardown). Safe to call more than once.
      */
     AcTrView2d.prototype.dispose = function () {
-        var _a;
+        var _a, _b, _c;
+        if (this._viewDisposed)
+            return;
+        this._viewDisposed = true;
+        // Stop convert before tearing down documents/singletons that commit paths read.
+        this.abortConversion();
         (_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;
+        (_c = this._disposeMobileBoxGesture) === null || _c === void 0 ? void 0 : _c.call(this);
+        this._disposeMobileBoxGesture = undefined;
+        this._viewDomAbort.abort();
+        if (this._onFontNotFound) {
+            this._renderer.events.fontNotFound.removeEventListener(this._onFontNotFound);
+        }
+        if (this._onFontLoaded) {
+            this._renderer.events.fontLoaded.removeEventListener(this._onFontLoaded);
+        }
+        if (this._onSysVarChanged) {
+            AcDbSysVarManager.instance().events.sysVarChanged.removeEventListener(this._onSysVarChanged);
+        }
+        if (this._onSettingsModified) {
+            AcApSettingManager.instance.events.modified.removeEventListener(this._onSettingsModified);
+        }
+        if (this._onLayoutSwitched) {
+            acdbHostApplicationServices().layoutManager.events.layoutSwitched.removeEventListener(this._onLayoutSwitched);
+        }
+        if (this._onCommandWillStartHitTest) {
+            this.editor.events.commandWillStart.removeEventListener(this._onCommandWillStartHitTest);
+        }
+        if (this._onCommandEndedHitTest) {
+            this.editor.events.commandEnded.removeEventListener(this._onCommandEndedHitTest);
+        }
+        this._gripManager.dispose();
         this.clearFontLoadedRedrawTimer();
         this.cancelOpenLineworkFrame();
         this.stopAnimationLoop();
+        this.selectionSet.clear();
+        this.htmlTransientManager.dispose();
+        this._scene.clear();
+        this._renderer.dispose();
+        AcDbRenderingCache.instance.clear();
+        var webgl = this._renderer.internalRenderer;
+        webgl.dispose();
+        webgl.forceContextLoss();
+        this.canvas.remove();
+        this._css2dRenderer.domElement.remove();
+        this._stats.dom.remove();
+        // Editor / command line / ResizeObserver (after canvas/CSS2D removed).
+        _super.prototype.dispose.call(this);
     };
     /**
      * @inheritdoc
@@ -2934,11 +3456,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;
     };
     /**
@@ -2963,7 +3493,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @param layoutBtrId Input the block table record id of the layout
      */
     AcTrView2d.prototype.loadLayoutEntitiesIfNeeded = function (layoutBtrId) {
-        var e_11, _a;
+        var e_12, _a;
         var _this = this;
         try {
             var db = AcApDocManager.instance.curDocument.database;
@@ -2974,41 +3504,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
@@ -3048,12 +3557,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                     entities_2.push(entity);
                 }
             }
-            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+            catch (e_12_1) { e_12 = { error: e_12_1 }; }
             finally {
                 try {
                     if (iterator_1_1 && !iterator_1_1.done && (_a = iterator_1.return)) _a.call(iterator_1);
                 }
-                finally { if (e_11) throw e_11.error; }
+                finally { if (e_12) throw e_12.error; }
             }
             if (entities_2.length === 0) {
                 // Empty layout (e.g. a freshly-created paper space tab). Mark as
@@ -3377,8 +3886,8 @@ var AcTrView2d = /** @class */ (function (_super) {
      */
     AcTrView2d.prototype.redrawGlyphEntitiesAfterFontLoad = function (epoch, fontName) {
         return __awaiter(this, void 0, void 0, function () {
-            var redrawEpoch, glyphs, _a, _b, layout, glyphs_1, glyphs_1_1, glyph, e_12_1, defaults, normalized_1, msSinceIdle, db;
-            var e_13, _c, e_12, _d;
+            var redrawEpoch, glyphs, _a, _b, layout, glyphs_1, glyphs_1_1, glyph, e_13_1, defaults, normalized_1, msSinceIdle, db;
+            var e_14, _c, e_13, _d;
             var _e, _f;
             return __generator(this, function (_g) {
                 switch (_g.label) {
@@ -3400,12 +3909,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                                 });
                             }
                         }
-                        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                        catch (e_14_1) { e_14 = { error: e_14_1 }; }
                         finally {
                             try {
                                 if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                             }
-                            finally { if (e_13) throw e_13.error; }
+                            finally { if (e_14) throw e_14.error; }
                         }
                         _g.label = 1;
                     case 1:
@@ -3428,14 +3937,14 @@ var AcTrView2d = /** @class */ (function (_super) {
                         return [3 /*break*/, 2];
                     case 5: return [3 /*break*/, 8];
                     case 6:
-                        e_12_1 = _g.sent();
-                        e_12 = { error: e_12_1 };
+                        e_13_1 = _g.sent();
+                        e_13 = { error: e_13_1 };
                         return [3 /*break*/, 8];
                     case 7:
                         try {
                             if (glyphs_1_1 && !glyphs_1_1.done && (_d = glyphs_1.return)) _d.call(glyphs_1);
                         }
-                        finally { if (e_12) throw e_12.error; }
+                        finally { if (e_13) throw e_13.error; }
                         return [7 /*endfinally*/];
                     case 8:
                         if (glyphs.length > 0) {
@@ -3486,7 +3995,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         });
     };
     AcTrView2d.prototype.groupHasPendingGlyphGeometry = function (group) {
-        var e_14, _a;
+        var e_15, _a;
         try {
             // Prefer O(block-def shells). A full THREE.traverse over a mega-block
             // (100k+ flattened mesh leaves) was dominating scene-convert wall time.
@@ -3497,12 +4006,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 }
             }
         }
-        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_14) throw e_14.error; }
+            finally { if (e_15) throw e_15.error; }
         }
         return AcTrView2d.directChildrenHavePendingGlyphs(group);
     };
@@ -3513,7 +4022,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * a whole-floor INSERT is O(glyph shells), not O(all drawable leaves).
      */
     AcTrView2d.directChildrenHavePendingGlyphs = function (root) {
-        var e_15, _a;
+        var e_16, _a;
         var children = root.children;
         for (var i = 0; i < children.length; i++) {
             var child = children[i];
@@ -3525,7 +4034,7 @@ var AcTrView2d = /** @class */ (function (_super) {
             }
             if (child instanceof AcTrGroup) {
                 try {
-                    for (var _b = (e_15 = void 0, __values(child.getSourceEntities())), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    for (var _b = (e_16 = void 0, __values(child.getSourceEntities())), _c = _b.next(); !_c.done; _c = _b.next()) {
                         var entity = _c.value;
                         if (entity instanceof AcTrGlyphEntity &&
                             !entity.hasDrawableGeometry()) {
@@ -3533,12 +4042,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                         }
                     }
                 }
-                catch (e_15_1) { e_15 = { error: e_15_1 }; }
+                catch (e_16_1) { e_16 = { error: e_16_1 }; }
                 finally {
                     try {
                         if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                     }
-                    finally { if (e_15) throw e_15.error; }
+                    finally { if (e_16) throw e_16.error; }
                 }
                 if (AcTrView2d.directChildrenHavePendingGlyphs(child)) {
                     return true;
@@ -3586,9 +4095,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 +4161,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
@@ -3667,7 +4205,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * paper layouts.
      */
     AcTrView2d.prototype.ensureViewportViews = function (blockTableRecord, layoutView) {
-        var e_16, _a;
+        var e_17, _a;
         var iterator = blockTableRecord.newIterator();
         try {
             for (var iterator_2 = __values(iterator), iterator_2_1 = iterator_2.next(); !iterator_2_1.done; iterator_2_1 = iterator_2.next()) {
@@ -3676,17 +4214,55 @@ 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);
             }
         }
-        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
         finally {
             try {
                 if (iterator_2_1 && !iterator_2_1.done && (_a = iterator_2.return)) _a.call(iterator_2);
             }
-            finally { if (e_16) throw e_16.error; }
+            finally { if (e_17) throw e_17.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_18, _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_18_1) { e_18 = { error: e_18_1 }; }
+            finally {
+                try {
+                    if (ids_1_1 && !ids_1_1.done && (_a = ids_1.return)) _a.call(ids_1);
+                }
+                finally { if (e_18) throw e_18.error; }
+            }
         }
+        gi.frozenLayerIds = __spreadArray([], __read(ids), false);
+        gi.frozenLayers = names;
+        return gi;
     };
     /**
      * Converts the specified database entities to three entities
@@ -3695,12 +4271,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 +4289,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 +4334,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 +4366,9 @@ var AcTrView2d = /** @class */ (function (_super) {
                                                             this_3.markProgressiveDirty();
                                                             this_3._progressiveOpenFit.afterGeometryBatch(function () { return _this.getDrawingExtents(); }, i);
                                                         }
+                                                        else {
+                                                            this_3.markInteractiveOpenDirty();
+                                                        }
                                                     }
                                                 }
                                             }
@@ -3797,8 +4383,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 +4415,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 +4455,9 @@ var AcTrView2d = /** @class */ (function (_super) {
                                                             this.markProgressiveDirty();
                                                             this._progressiveOpenFit.afterGeometryBatch(function () { return _this.getDrawingExtents(); }, i);
                                                         }
+                                                        else {
+                                                            this.markInteractiveOpenDirty();
+                                                        }
                                                         return [2 /*return*/];
                                                 }
                                             });
@@ -3872,8 +4467,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 +4479,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 +4492,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 +4510,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 +4554,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 +4577,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_19_1;
+            var e_20, _b, e_19, _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 +4633,136 @@ var AcTrView2d = /** @class */ (function (_super) {
                                 child.parent = null;
                             }
                         }
-                        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+                        catch (e_20_1) { e_20 = { error: e_20_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_20) throw e_20.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_19_1 = _f.sent();
+                        e_19 = { error: e_19_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_19) throw e_19.error; }
+                        return [7 /*endfinally*/];
+                    case 10:
                         group.dispose();
                         if (progressive) {
                             this.markProgressiveDirty();
@@ -4114,11 +4770,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 +4832,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 = 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.PROGRESSIVE_OPEN_PAINT_INTERVAL_MS = 1000;
+    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 };