@mlightcad/cad-simple-viewer 1.6.3 → 1.7.1

package/lib/view/AcTrView2d.js

@@ -96,20 +96,26 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { AcCmUiYieldGate, AcDbAttribute, AcDbBlockReference, acdbHostApplicationServices, AcDbMText, AcDbRasterImage, AcDbRay, AcDbSysVarManager, AcDbViewport, AcDbXline, AcGeBox2d, AcGePoint2d, log } from '@mlightcad/data-model';
+import { AcCmUiYieldGate, AcDbAttribute, AcDbBlockReference, acdbHostApplicationServices, AcDbMText, AcDbRasterImage, AcDbRay, AcDbSysVarManager, AcDbViewport, AcDbXline, AcGeBox2d, AcGePoint2d, acgiForegroundColorForBackground, log } from '@mlightcad/data-model';
 import { AcDbSystemVariables } from '@mlightcad/data-model';
+import { FontManager } from '@mlightcad/mtext-renderer';
 import { AcTrEntity, AcTrGlyphEntity, AcTrGroup, AcTrRenderer, AcTrViewportView } from '@mlightcad/three-renderer';
 import { AcTrMatrixUtil } from '@mlightcad/three-renderer';
 import * as THREE from 'three';
 import Stats from 'three/examples/jsm/libs/stats.module';
 import { CSS2DRenderer } from 'three/examples/jsm/renderers/CSS2DRenderer.js';
 import { AcApDocManager, AcApSettingManager } from '../app';
+import { AcApZoomCmd } from '../command/AcApZoomCmd';
 import { isMarkupHtmlTextEditing } from '../command/markup/AcApMarkupTextEdit';
-import { AcEdBaseView, AcEdConditionWaiter, AcEdCorsorType, AcEdGripManager, AcEdMTextEditor, AcEdOpenMode, AcEdViewMode, eventBus, resolvePointerSelectionAction } from '../editor';
+import { notifyMeasurementLayoutChanged } from '../command/measure/AcApMeasurementStore';
+import { acedAttachMobileBoxGesture, AcEdBaseView, AcEdConditionWaiter, AcEdCorsorType, AcEdGripManager, acedGuardCanvasTouchCallout, acedInteractionStrategy, acedIsTouchDerivedMouseEvent, AcEdMTextEditor, AcEdOpenMode, acedShouldIgnoreCompatMouse, AcEdViewMode, eventBus, resolvePointerSelectionAction } from '../editor';
 import { ACGI_MODEL_SPACE_BACKGROUND, isModelSpaceDatabase, readLayoutBackgroundColor } from '../editor/global/AcEdUiColor';
+import { ML_UI_Z_CANVAS_HTML_OVERLAY } from '../editor/global/AcEdUiLayout';
+import { acedEntityIntersectsSelectionBox, acedNeedsCrossingGeometryRefine } from '../editor/view/AcEdSelectionBoxIntersect';
 import { isEffectiveSpatialQueryHit } from '../editor/view/AcEdSpatialQueryResult';
 import { AcTrGeometryUtil } from '../util';
 import { acapRunDatabaseEdit } from '../util/AcApDatabaseEdit';
+import { ACAP_READING_MODE_BACKGROUND, AcApReadingModeState } from './AcApReadingMode';
 import { trySelectReviewOverlay, trySelectReviewOverlaysByBox } from './AcEdReviewOverlayPick';
 import { AcEdViewKeyHandler } from './AcEdViewKeyHandler';
 import { shouldExtendBboxForDirectEntity, tryBuildDirectEntityMeta } from './AcTrDirectBatch';
@@ -177,6 +183,9 @@ var AcTrView2d = /** @class */ (function (_super) {
         renderer.domElement.style.display = 'block';
         renderer.domElement.style.maxWidth = '100%';
         renderer.domElement.style.maxHeight = '100%';
+        // Keep one-finger picks (measure snap loupe) from being stolen by the
+        // browser scroll / long-press copy-selection callout (especially iOS).
+        var disposeCanvasTouchCallout = acedGuardCanvasTouchCallout(renderer.domElement, container);
         _this = _super.call(this, renderer.domElement, container) || this;
         /**
          * ID of the currently scheduled requestAnimationFrame callback.
@@ -265,10 +274,33 @@ var AcTrView2d = /** @class */ (function (_super) {
         /** Cooperative yields taken inside progressive {@link batchConvert}. */
         _this._progressiveYieldCount = 0;
         /**
-         * In-flight glyph/group geometry jobs that await fonts via asyncDraw.
+         * In-flight + queued glyph/group geometry jobs that await fonts via asyncDraw.
          * Counted separately so linework convert can continue while text waits.
          */
         _this._pendingGeometryJobs = 0;
+        /**
+         * Waiting deferred geometry runners. Capped concurrency avoids scheduling
+         * thousands of INSERT/text `asyncDraw` jobs at once (large multi-sheet DWGs
+         * otherwise flood the main thread and freeze on "Rendering drawing ...").
+         */
+        _this._deferredGeometryQueue = [];
+        /** Currently executing deferred geometry runners. */
+        _this._deferredGeometryActive = 0;
+        /**
+         * Debounced glyph rebuild after {@link FontManager.events.fontLoaded} so a
+         * burst of lazy face loads (simsun + malgun, etc.) triggers one redraw pass.
+         */
+        _this._fontLoadedRedrawTimer = null;
+        _this._fontLoadedRedrawEpoch = 0;
+        /** Transient reading mode forces black linework on a white canvas. */
+        _this._readingMode = new AcApReadingModeState({
+            getCurrentBackgroundColor: function () { return _this._renderer.currentBackgroundColor; },
+            applyViewClearColor: function (value) { return _this.applyViewClearColor(value); },
+            setCompareDisplay: function (options) { return _this.setCompareDisplay(options); },
+            markDirty: function () {
+                _this._isDirty = true;
+            }
+        });
         _this.animate = function () {
             var _a;
             _this._rafId = requestAnimationFrame(_this.animate);
@@ -304,6 +336,7 @@ var AcTrView2d = /** @class */ (function (_super) {
             _this._isDirty = needsRedraw;
             _this._htmlDirty = false;
         };
+        _this._disposeCanvasTouchCallout = disposeCanvasTouchCallout;
         _this._gripManager = new AcEdGripManager(_this);
         _this._keyHandler = new AcEdViewKeyHandler(_this);
         if (options.calculateSizeCallback) {
@@ -321,6 +354,13 @@ var AcTrView2d = /** @class */ (function (_super) {
                 count: (_a = args.count) !== null && _a !== void 0 ? _a : 0
             });
         });
+        _this._renderer.events.fontLoaded.addEventListener(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._scene = _this.createScene();
         _this._layerAppearance = new AcTrLayerAppearanceController(_this._scene, _this._renderer);
         _this._inheritedLayerMaterialMapper = new AcTrInheritedLayerMaterialMapper(function (layerName) { return _this._layerAppearance.getEffectiveLayerTraits(layerName); }, _this._renderer);
@@ -355,36 +395,45 @@ var AcTrView2d = /** @class */ (function (_super) {
         var selectionStartWcs = null;
         var selectionStartCanvas = null;
         var selectionPreviewEl = null;
-        var canHandleSelectionGesture = function () {
-            return (_this.mode === AcEdViewMode.SELECTION &&
-                !_this.editor.isActive &&
+        var canHandleIdlePointer = function () {
+            return (!_this.editor.isActive &&
                 !AcEdMTextEditor.getActiveInputBox() &&
                 !isMarkupHtmlTextEditing() &&
                 !_this._gripManager.isDragging);
         };
+        var canHandleSelectionGesture = function () {
+            return _this.mode === AcEdViewMode.SELECTION && canHandleIdlePointer();
+        };
+        var canHandleMobileBoxGesture = function () {
+            return (canHandleIdlePointer() &&
+                acedInteractionStrategy().canIdleTouchBox(_this.mode));
+        };
         var clearSelectionPreview = function () {
             selectionPreviewEl === null || selectionPreviewEl === void 0 ? void 0 : selectionPreviewEl.remove();
             selectionPreviewEl = null;
         };
-        _this.canvas.addEventListener('mousedown', function (e) {
-            if (e.button !== 0)
-                return;
-            if (!canHandleSelectionGesture())
-                return;
+        var resetSelectionDrag = function () {
+            selectionStartWcs = null;
+            selectionStartCanvas = null;
+            clearSelectionPreview();
+        };
+        var beginSelectionPreview = function (clientX, clientY) {
             selectionStartCanvas = _this.viewportToCanvas({
-                x: e.clientX,
-                y: e.clientY
+                x: clientX,
+                y: clientY
             });
             selectionStartWcs = _this.screenToWorld(selectionStartCanvas);
+            clearSelectionPreview();
             selectionPreviewEl = document.createElement('div');
             selectionPreviewEl.className = 'ml-jig-preview-rect';
             _this.container.appendChild(selectionPreviewEl);
-        });
-        _this.canvas.addEventListener('mousemove', function (e) {
+        };
+        var updateSelectionPreview = function (clientX, clientY, action) {
+            if (action === void 0) { action = 'replace'; }
             if (!selectionStartWcs || !selectionPreviewEl || !selectionStartCanvas) {
                 return;
             }
-            var curCanvas = _this.viewportToCanvas({ x: e.clientX, y: e.clientY });
+            var curCanvas = _this.viewportToCanvas({ x: clientX, y: clientY });
             var curWcs = _this.screenToWorld(curCanvas);
             var p1 = _this.worldToScreen(selectionStartWcs);
             var p2 = _this.worldToScreen(curWcs);
@@ -393,7 +442,6 @@ var AcTrView2d = /** @class */ (function (_super) {
             var width = Math.abs(p1.x - p2.x);
             var height = Math.abs(p1.y - p2.y);
             var mode = _this.getSelectionMode(selectionStartCanvas, curCanvas);
-            var action = _this.getPointerSelectionAction(e);
             var style = _this.getSelectionPreviewStyle(mode, action);
             Object.assign(selectionPreviewEl.style, {
                 left: "".concat(left, "px"),
@@ -404,24 +452,17 @@ var AcTrView2d = /** @class */ (function (_super) {
                 background: style.background
             });
             selectionPreviewEl.style.setProperty('--line-color', style.lineColor);
-        });
-        _this.canvas.addEventListener('mouseup', function (e) {
-            if (_this._gripManager.isDragging) {
-                selectionStartWcs = null;
-                selectionStartCanvas = null;
-                clearSelectionPreview();
-                return;
-            }
+        };
+        var finishSelection = function (clientX, clientY, action, isClick) {
             if (!selectionStartWcs || !selectionStartCanvas)
                 return;
             var endCanvas = _this.viewportToCanvas({
-                x: e.clientX,
-                y: e.clientY
+                x: clientX,
+                y: clientY
             });
             var endWcs = _this.screenToWorld(endCanvas);
             clearSelectionPreview();
-            var action = _this.getPointerSelectionAction(e);
-            if (_this.isSelectionClick(selectionStartCanvas, endCanvas)) {
+            if (isClick) {
                 if (trySelectReviewOverlay(_this, endCanvas.x, endCanvas.y, action)) {
                     if (action === 'replace') {
                         _this.selectionSet.clear();
@@ -455,6 +496,70 @@ var AcTrView2d = /** @class */ (function (_super) {
             }
             selectionStartWcs = null;
             selectionStartCanvas = null;
+        };
+        _this.canvas.addEventListener('mousedown', function (e) {
+            if (e.button !== 0)
+                return;
+            if (!canHandleSelectionGesture())
+                return;
+            if (acedIsTouchDerivedMouseEvent(e) || acedShouldIgnoreCompatMouse()) {
+                return;
+            }
+            beginSelectionPreview(e.clientX, e.clientY);
+        });
+        _this.canvas.addEventListener('mousemove', function (e) {
+            if (!selectionStartWcs || !selectionPreviewEl || !selectionStartCanvas) {
+                return;
+            }
+            if (acedIsTouchDerivedMouseEvent(e) || acedShouldIgnoreCompatMouse()) {
+                return;
+            }
+            updateSelectionPreview(e.clientX, e.clientY, _this.getPointerSelectionAction(e));
+        });
+        _this.canvas.addEventListener('mouseup', function (e) {
+            if (_this._gripManager.isDragging) {
+                resetSelectionDrag();
+                return;
+            }
+            if (!selectionStartWcs || !selectionStartCanvas)
+                return;
+            if (acedIsTouchDerivedMouseEvent(e) || acedShouldIgnoreCompatMouse()) {
+                return;
+            }
+            var endCanvas = _this.viewportToCanvas({
+                x: e.clientX,
+                y: e.clientY
+            });
+            var action = _this.getPointerSelectionAction(e);
+            finishSelection(e.clientX, e.clientY, action, _this.isSelectionClick(selectionStartCanvas, endCanvas));
+        });
+        acedAttachMobileBoxGesture({
+            element: _this.canvas,
+            shouldStart: function () { return canHandleMobileBoxGesture(); },
+            setNavigationEnabled: function (enabled) {
+                _this.setNavigationEnabled(enabled);
+            },
+            onActivate: function (clientX, clientY) {
+                beginSelectionPreview(clientX, clientY);
+                updateSelectionPreview(clientX, clientY);
+            },
+            onMove: function (clientX, clientY) {
+                updateSelectionPreview(clientX, clientY);
+            },
+            onBoxEnd: function (clientX, clientY, moved) {
+                finishSelection(clientX, clientY, 'replace', !moved);
+            },
+            onTap: function (clientX, clientY) {
+                selectionStartCanvas = _this.viewportToCanvas({
+                    x: clientX,
+                    y: clientY
+                });
+                selectionStartWcs = _this.screenToWorld(selectionStartCanvas);
+                finishSelection(clientX, clientY, 'replace', true);
+            },
+            onAbort: function () {
+                resetSelectionDrag();
+            }
         });
         _this.canvas.addEventListener('dblclick', function (e) {
             if (e.button !== 0)
@@ -523,7 +628,8 @@ var AcTrView2d = /** @class */ (function (_super) {
         _this._css2dRenderer.domElement.style.top = '0px';
         _this._css2dRenderer.domElement.style.left = '0px';
         _this._css2dRenderer.domElement.style.pointerEvents = 'none';
-        _this._css2dRenderer.domElement.style.zIndex = '99998';
+        // Below command line / mobile chrome / dialogs; above the WebGL canvas.
+        _this._css2dRenderer.domElement.style.zIndex = String(ML_UI_Z_CANVAS_HTML_OVERLAY);
         _this._css2dRenderer.domElement.style.maxWidth = '100%';
         _this._css2dRenderer.domElement.style.maxHeight = '100%';
         container.appendChild(_this._css2dRenderer.domElement);
@@ -542,7 +648,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         _this._htmlDirty = false;
         _this.startAnimationLoop();
         _this._numOfEntitiesToProcess = 0;
-        _this._pendingGeometryJobs = 0;
+        _this.resetDeferredGeometryQueue();
         return _this;
     }
     AcTrView2d.prototype.getPointerSelectionAction = function (e) {
@@ -557,9 +663,16 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @protected
      */
     AcTrView2d.prototype.initialize = function () {
+        var _this = this;
         // 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.htmlTransientManager.setHitTestEnabled(false);
+        });
+        this.editor.events.commandEnded.addEventListener(function () {
+            _this.htmlTransientManager.setHitTestEnabled(true);
+        });
     };
     Object.defineProperty(AcTrView2d.prototype, "mode", {
         /**
@@ -583,6 +696,37 @@ var AcTrView2d = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Enables or disables OrbitControls on the active layout view.
+     *
+     * @param enabled - When false, pan and zoom are disabled (e.g. while the
+     *   snap loupe is tracking a long-press).
+     */
+    AcTrView2d.prototype.setNavigationEnabled = function (enabled) {
+        var layoutView = this.activeLayoutView;
+        if (layoutView)
+            layoutView.enabled = enabled;
+    };
+    /**
+     * Shows or hides the screen-fixed snap loupe overlay viewport.
+     *
+     * @param state - Loupe screen rectangle and world box, or `null` to hide.
+     */
+    AcTrView2d.prototype.setSnapLoupe = function (state) {
+        var _a;
+        var overlay = (_a = this.activeLayoutView) === null || _a === void 0 ? void 0 : _a.overlayViewport;
+        if (!overlay)
+            return;
+        if (!state) {
+            overlay.visible = false;
+            this._isDirty = true;
+            return;
+        }
+        overlay.setScreenRect(state.x, state.y, state.size, state.size);
+        overlay.setViewBox(state.viewBox);
+        overlay.visible = true;
+        this._isDirty = true;
+    };
     Object.defineProperty(AcTrView2d.prototype, "renderer", {
         /**
          * Gets the Three.js renderer wrapper used for CAD rendering.
@@ -636,9 +780,14 @@ var AcTrView2d = /** @class */ (function (_super) {
          * True while batch conversion or deferred glyph/group geometry is still
          * running.
          *
-         * Parsing can report 100% before this reaches zero; callers opening files
-         * should wait on this (as {@link zoomToFitDrawing} does) before hiding
-         * progress UI or assuming the canvas is ready.
+         * Parsing can report 100% before this reaches zero; callers that need a
+         * fully drawable scene (export, scripted zoom) should wait on this (as
+         * {@link waitUntilIdle} / {@link zoomToFitDrawing} do).
+         *
+         * The open-file progress overlay intentionally uses
+         * {@link isConvertingEntities} instead so "Rendering drawing ..." can hide
+         * once linework convert finishes while text geometry continues in the
+         * deferred pool.
          */
         get: function () {
             return this._numOfEntitiesToProcess > 0 || this._pendingGeometryJobs > 0;
@@ -646,6 +795,17 @@ var AcTrView2d = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcTrView2d.prototype, "isConvertingEntities", {
+        /**
+         * True while the entity convert queue / {@link batchConvert} is still
+         * draining. Does **not** include deferred glyph/INSERT geometry jobs.
+         */
+        get: function () {
+            return this._numOfEntitiesToProcess > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Waits until batch conversion and deferred glyph/font geometry finish.
      *
@@ -705,8 +865,9 @@ var AcTrView2d = /** @class */ (function (_super) {
     });
     Object.defineProperty(AcTrView2d.prototype, "progressiveOpenStats", {
         /**
-         * Progressive-open counters for OPENPROF / palette (paints while converting,
-         * cooperative yields). Reset when progressive mode is enabled for an open.
+         * 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.
          */
         get: function () {
             return {
@@ -833,11 +994,27 @@ var AcTrView2d = /** @class */ (function (_super) {
      * manager. Does not touch `COLORTHEME` / UI chrome.
      */
     AcTrView2d.prototype.applyCanvasBackground = function (value) {
-        this._renderer.setClearColor(value);
-        // Updates style-manager background, repaints ACI-7 / bg-follow materials.
         this._renderer.currentBackgroundColor = value;
         this._layerAppearance.refreshTextMaterialsInObjectTree(this._scene.internalScene);
+        // Style-manager changeForeground only updates cache entries; batch
+        // containers own private material clones and must be repainted too.
+        this._scene.repaintForegroundMaterials(acgiForegroundColorForBackground(value));
         this.resyncForegroundLayersForBackground();
+        if (this._readingMode.isEnabled) {
+            this._readingMode.noteLayoutBackground(value);
+            this.applyViewClearColor(ACAP_READING_MODE_BACKGROUND);
+            return;
+        }
+        this.applyViewClearColor(value);
+    };
+    /**
+     * Updates only the WebGL clear colour and cursor chrome.
+     *
+     * Reading mode uses this so the white canvas is visual-only and does not
+     * repaint cached entity materials via the style manager.
+     */
+    AcTrView2d.prototype.applyViewClearColor = function (value) {
+        this._renderer.setClearColor(value);
         this.editor.syncCursorBackground(value);
         this._isDirty = true;
     };
@@ -901,6 +1078,29 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.syncDisplaySysVars = function (database) {
         this.bindDrawDatabase(database);
         this.applyCanvasBackground(readLayoutBackgroundColor(database, this.isModelSpaceLayout(database)));
+        this._readingMode.reapplyIfEnabled();
+    };
+    Object.defineProperty(AcTrView2d.prototype, "readingModeEnabled", {
+        /** Whether transient reading mode is active on this view. */
+        get: function () {
+            return this._readingMode.isEnabled;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** Toggles transient reading mode on or off. */
+    AcTrView2d.prototype.toggleReadingMode = function () {
+        this._readingMode.toggle();
+    };
+    /**
+     * Enables or disables transient reading mode (black linework, white canvas).
+     *
+     * @param enabled - When true, snapshots the current canvas background and
+     *   forces monochrome display; when false, restores the snapshot and
+     *   original entity colors.
+     */
+    AcTrView2d.prototype.setReadingMode = function (enabled) {
+        this._readingMode.setEnabled(enabled);
     };
     /**
      * Converts and renders model-space entities from a standalone, independently
@@ -1054,10 +1254,14 @@ var AcTrView2d = /** @class */ (function (_super) {
             return this._scene.activeLayoutBtrId;
         },
         set: function (value) {
+            var previous = this._scene.activeLayoutBtrId;
             this._layoutViewManager.activeLayoutBtrId = value;
             this._scene.activeLayoutBtrId = value;
             this.htmlTransientManager.setActiveLayoutId(value);
             this._isDirty = true;
+            if (previous !== value) {
+                notifyMeasurementLayoutChanged();
+            }
         },
         enumerable: false,
         configurable: true
@@ -1254,11 +1458,13 @@ var AcTrView2d = /** @class */ (function (_super) {
     /**
      * Re-render points with latest point style settings
      * @param displayMode Input display mode of points
+     * @param displaySize Input display size of points (`PDSIZE`)
      */
-    AcTrView2d.prototype.rerenderPoints = function (displayMode) {
+    AcTrView2d.prototype.rerenderPoints = function (displayMode, displaySize) {
+        if (displaySize === void 0) { displaySize = 0; }
         var activeLayout = this._scene.activeLayout;
         if (activeLayout) {
-            activeLayout.rerenderPoints(displayMode);
+            activeLayout.rerenderPoints(displayMode, displaySize);
             this._isDirty = true;
         }
     };
@@ -1277,6 +1483,10 @@ var AcTrView2d = /** @class */ (function (_super) {
             }
             _this._progressiveOpenFit.applyFinalFit(function () { return _this.resolveLayoutFitBox(); });
             _this.endProgressiveOpenFit();
+            var originalBtrId = layoutBtrId !== null && layoutBtrId !== void 0 ? layoutBtrId : _this.activeLayoutBtrId;
+            if (originalBtrId) {
+                AcApZoomCmd.rememberOriginalView(_this, originalBtrId);
+            }
         }, 300, // check every 300 ms
         timeout);
         waiter.start();
@@ -1360,9 +1570,10 @@ var AcTrView2d = /** @class */ (function (_super) {
     };
     AcTrView2d.prototype.editMTextEntity = function (mtext) {
         return __awaiter(this, void 0, void 0, function () {
-            var db, editor, applied, result_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var db, editor, applied, result_1, _a, _b;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         db = mtext.database;
                         if (mtext.lineSpacingFactor !== AcEdMTextEditor.defaultLineSpacingFactor) {
@@ -1379,20 +1590,23 @@ var AcTrView2d = /** @class */ (function (_super) {
                         this._isDirty = true;
                         editor = new AcEdMTextEditor();
                         applied = false;
-                        _a.label = 1;
+                        _d.label = 1;
                     case 1:
-                        _a.trys.push([1, , 3, 4]);
-                        return [4 /*yield*/, editor.open({
-                                view: this,
-                                location: mtext.location,
-                                width: this.resolveMTextEditorWidth(mtext),
-                                textHeight: this.resolveMTextEditorTextHeight(mtext),
-                                initialText: mtext.contents,
-                                initialAttachmentPoint: mtext.attachmentPoint,
-                                toolbarFontFamilies: this.getMTextToolbarFontFamilies()
-                            })];
-                    case 2:
-                        result_1 = _a.sent();
+                        _d.trys.push([1, , 4, 5]);
+                        _b = (_a = editor).open;
+                        _c = {
+                            view: this,
+                            location: mtext.location,
+                            width: this.resolveMTextEditorWidth(mtext),
+                            textHeight: this.resolveMTextEditorTextHeight(mtext),
+                            initialText: mtext.contents,
+                            initialAttachmentPoint: mtext.attachmentPoint
+                        };
+                        return [4 /*yield*/, this.getMTextToolbarFontFamilies()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, [(_c.toolbarFontFamilies = _d.sent(),
+                                _c)])];
+                    case 3:
+                        result_1 = _d.sent();
                         if (!result_1)
                             return [2 /*return*/];
                         acapRunDatabaseEdit(db, 'Edit MText', function () {
@@ -1407,14 +1621,14 @@ var AcTrView2d = /** @class */ (function (_super) {
                             opened.attachmentPoint = result_1.attachmentPoint;
                         });
                         applied = true;
-                        return [3 /*break*/, 4];
-                    case 3:
+                        return [3 /*break*/, 5];
+                    case 4:
                         if (!applied) {
                             this.updateEntity(mtext);
                             this._isDirty = true;
                         }
                         return [7 /*endfinally*/];
-                    case 4: return [2 /*return*/];
+                    case 5: return [2 /*return*/];
                 }
             });
         });
@@ -1437,10 +1651,21 @@ var AcTrView2d = /** @class */ (function (_super) {
         return Math.max(Math.abs(p1.y - p0.y), 1e-4);
     };
     AcTrView2d.prototype.getMTextToolbarFontFamilies = function () {
-        return Array.from(new Set(AcApDocManager.instance.avaiableFonts
-            .flatMap(function (fontInfo) { return fontInfo.name; })
-            .map(function (fontName) { return fontName.trim(); })
-            .filter(function (fontName) { return fontName.length > 0; })));
+        return __awaiter(this, void 0, void 0, function () {
+            var availableFonts;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, AcApDocManager.instance.getAvaiableFonts()];
+                    case 1:
+                        availableFonts = (_a = (_b.sent())) !== null && _a !== void 0 ? _a : [];
+                        return [2 /*return*/, Array.from(new Set(availableFonts
+                                .flatMap(function (fontInfo) { return fontInfo.name; })
+                                .map(function (fontName) { return fontName.trim(); })
+                                .filter(function (fontName) { return fontName.length > 0; })))];
+                }
+            });
+        });
     };
     /**
      * @inheritdoc
@@ -1610,6 +1835,48 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.selectByBox = function (box) {
         this.selectByBoxWithMode(box, 'crossing', 'add');
     };
+    /**
+     * Drops crossing spatial hits whose curve geometry misses the pick box.
+     *
+     * Large closed polylines (site boundaries, frames) have AABBs that cover
+     * huge empty interiors. Without this refine, crossing a small INSERT inside
+     * that interior also selects those polylines and can stall highlight work.
+     */
+    AcTrView2d.prototype.refineCrossingSelectionHits = function (box, results) {
+        var e_8, _a;
+        var _b;
+        var database = (_b = AcApDocManager.instance.curDocument) === null || _b === void 0 ? void 0 : _b.database;
+        if (!database) {
+            return results.map(function (item) { return item.id; });
+        }
+        var ids = [];
+        try {
+            for (var results_1 = __values(results), results_1_1 = results_1.next(); !results_1_1.done; results_1_1 = results_1.next()) {
+                var item = results_1_1.value;
+                if (!acedNeedsCrossingGeometryRefine(item)) {
+                    ids.push(item.id);
+                    continue;
+                }
+                var entityBox = new AcGeBox2d({ x: item.minX, y: item.minY }, { x: item.maxX, y: item.maxY });
+                if (box.containsBox(entityBox)) {
+                    ids.push(item.id);
+                    continue;
+                }
+                var entity = database.tables.blockTable.getEntityById(item.id);
+                if (!entity || acedEntityIntersectsSelectionBox(entity, box)) {
+                    ids.push(item.id);
+                }
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_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; }
+        }
+        return ids;
+    };
     /**
      * @inheritdoc
      */
@@ -1622,7 +1889,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @inheritdoc
      */
     AcTrView2d.prototype.updateLayer = function (layer, changes) {
-        var e_8, _a;
+        var e_9, _a;
         var touchedObjectIds = this._scene.updateLayer(this.toLayerInfo(layer)).touchedObjectIds;
         if (this._layerAppearance.layerStyleMayHaveChanged(changes)) {
             this._layerAppearance.syncFromLiveRecord(layer);
@@ -1644,12 +1911,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 this.applySessionHiddenObjectState(objectId);
             }
         }
-        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
         finally {
             try {
                 if (touchedObjectIds_1_1 && !touchedObjectIds_1_1.done && (_a = touchedObjectIds_1.return)) _a.call(touchedObjectIds_1);
             }
-            finally { if (e_8) throw e_8.error; }
+            finally { if (e_9) throw e_9.error; }
         }
         this._isDirty = true;
     };
@@ -1766,13 +2033,13 @@ var AcTrView2d = /** @class */ (function (_super) {
         var _a;
         var entities = Array.isArray(entity) ? entity : [entity];
         this._numOfEntitiesToProcess += entities.length;
-        if (this._progressiveRendering) {
-            (_a = this._convertQueue).push.apply(_a, __spreadArray([], __read(entities), false));
-            void this.drainConvertQueue();
-        }
-        else {
-            void this.batchConvert(entities);
-        }
+        // Always serialize convert through one drain loop. Non-progressive opens
+        // used to `void batchConvert(chunk)` per ENTITY flush chunk, which ran
+        // many converts in parallel and OOM'd dense drawings (e.g. cathedral.dwg)
+        // during "Rendering drawing ...". Progressive mid-open paints stay gated
+        // by `_progressiveRendering` inside batchConvert / markProgressiveDirty.
+        (_a = this._convertQueue).push.apply(_a, __spreadArray([], __read(entities), false));
+        void this.drainConvertQueue();
     };
     /**
      * @inheritdoc
@@ -1878,7 +2145,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * drawable entity that must be rebuilt (for example ATTRIB → INSERT).
      */
     AcTrView2d.prototype.resolveSceneUpdateEntities = function (entities) {
-        var e_9, _a;
+        var e_10, _a;
         var _b;
         var db = (_b = AcApDocManager.instance.curDocument) === null || _b === void 0 ? void 0 : _b.database;
         var resolved = [];
@@ -1900,12 +2167,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 resolved.push(target);
             }
         }
-        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
         finally {
             try {
                 if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
             }
-            finally { if (e_9) throw e_9.error; }
+            finally { if (e_10) throw e_10.error; }
         }
         return resolved;
     };
@@ -2018,6 +2285,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                 }
             }
             _this._isDirty = true;
+            AcApZoomCmd.rememberOriginalView(_this, btrId);
         }, 300, 0);
         waiter.start();
     };
@@ -2028,9 +2296,10 @@ var AcTrView2d = /** @class */ (function (_super) {
         // 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._numOfEntitiesToProcess = 0;
-        this._pendingGeometryJobs = 0;
+        this.resetDeferredGeometryQueue();
         this._scene.clear();
         this._isDirty = true;
         this._missedImages.clear();
@@ -2038,6 +2307,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         this._externallyFramedLayouts.clear();
         this._loadingLayouts.clear();
         this._renderer.dispose();
+        eventBus.emit('missed-data-changed', {});
     };
     /**
      * Captures GPU/camera/selection state so another document can occupy this view.
@@ -2052,6 +2322,7 @@ var AcTrView2d = /** @class */ (function (_super) {
             externallyFramedLayouts: this._externallyFramedLayouts,
             loadingLayouts: this._loadingLayouts,
             missedImages: this._missedImages,
+            missedFonts: this._renderer.snapshotMissedFonts(),
             selectionIds: this.selectionSet.ids
         };
     };
@@ -2061,16 +2332,19 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @param state - Snapshot previously returned by {@link captureSessionState} or {@link beginNewSession}.
      */
     AcTrView2d.prototype.restoreSessionState = function (state) {
+        var _a;
         this._convertEpoch++;
+        this.clearFontLoadedRedrawTimer();
         this._convertQueue.length = 0;
         this._numOfEntitiesToProcess = 0;
-        this._pendingGeometryJobs = 0;
+        this.resetDeferredGeometryQueue();
         this._scene = state.scene;
         this._layoutViewManager = state.layoutViewManager;
         this._initializedLayouts = state.initializedLayouts;
         this._externallyFramedLayouts = state.externallyFramedLayouts;
         this._loadingLayouts = state.loadingLayouts;
         this._missedImages = state.missedImages;
+        this._renderer.replaceMissedFonts((_a = state.missedFonts) !== null && _a !== void 0 ? _a : {});
         this.rebindLayerAppearance();
         this._layoutViewManager.resize(this.width, this.height);
         this.selectionSet.clear();
@@ -2078,6 +2352,7 @@ var AcTrView2d = /** @class */ (function (_super) {
             this.selectionSet.add(state.selectionIds);
         }
         this._isDirty = true;
+        eventBus.emit('missed-data-changed', {});
     };
     /**
      * Detaches the current scene and installs an empty one for a newly opened document.
@@ -2087,18 +2362,21 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.beginNewSession = function () {
         var parked = this.captureSessionState();
         this._convertEpoch++;
+        this.clearFontLoadedRedrawTimer();
         this._convertQueue.length = 0;
         this._numOfEntitiesToProcess = 0;
-        this._pendingGeometryJobs = 0;
+        this.resetDeferredGeometryQueue();
         this._scene = this.createScene();
         this._layoutViewManager = new AcTrLayoutViewManager();
         this._initializedLayouts = new Set();
         this._externallyFramedLayouts = new Set();
         this._loadingLayouts = new Set();
         this._missedImages = new Map();
+        this._renderer.clearMissedFonts();
         this.rebindLayerAppearance();
         this.selectionSet.clear();
         this._isDirty = true;
+        eventBus.emit('missed-data-changed', {});
         return parked;
     };
     /**
@@ -2113,6 +2391,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         state.externallyFramedLayouts.clear();
         state.loadingLayouts.clear();
         state.missedImages.clear();
+        state.missedFonts = {};
         state.selectionIds = [];
     };
     /**
@@ -2132,8 +2411,9 @@ var AcTrView2d = /** @class */ (function (_super) {
         return current == null || current === this;
     };
     /**
-     * Drains the progressive convert queue on a single serial worker so ENTITY
-     * flush chunks can enqueue while conversion overlaps the loading overlay.
+     * Drains the convert queue on a single serial worker so ENTITY flush chunks
+     * can enqueue without overlapping multiple {@link batchConvert} runs (which
+     * spikes heap on large drawings).
      *
      * Concurrent callers share the same promise; if more entities are queued
      * after a drain finishes, a follow-up drain is started.
@@ -2242,6 +2522,19 @@ var AcTrView2d = /** @class */ (function (_super) {
             this._rafId = null;
         }
     };
+    /**
+     * Releases canvas DOM listeners and stops the animation loop.
+     *
+     * 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;
+        (_a = this._disposeCanvasTouchCallout) === null || _a === void 0 ? void 0 : _a.call(this);
+        this._disposeCanvasTouchCallout = undefined;
+        this.clearFontLoadedRedrawTimer();
+        this.stopAnimationLoop();
+    };
     /**
      * @inheritdoc
      */
@@ -2272,11 +2565,21 @@ var AcTrView2d = /** @class */ (function (_super) {
         return stats;
     };
     AcTrView2d.prototype.onWindowResize = function () {
-        _super.prototype.onWindowResize.call(this);
+        // Refresh size first, then sync WebGL / CSS2D / frustum before notifying
+        // listeners so `worldToScreen` consumers see the new projection.
+        this.refreshViewSize();
         this._renderer.setSize(this.width, this.height);
         this._css2dRenderer.setSize(this.width, this.height);
         this._layoutViewManager.resize(this.width, this.height);
         this._isDirty = true;
+        this.events.viewResize.dispatch({
+            width: this.width,
+            height: this.height
+        });
+        // CSS2D badges reproject via `_isDirty`. Canvas overlays (measure /
+        // markup strokes, live preview) paint with `worldToScreen` and listen to
+        // `viewChanged` only — resize must notify them too.
+        this.events.viewChanged.dispatch();
     };
     AcTrView2d.prototype.startAnimationLoop = function () {
         if (this._rafId == null) {
@@ -2324,7 +2627,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @param layoutBtrId Input the block table record id of the layout
      */
     AcTrView2d.prototype.loadLayoutEntitiesIfNeeded = function (layoutBtrId) {
-        var e_10, _a;
+        var e_11, _a;
         var _this = this;
         try {
             var db = AcApDocManager.instance.curDocument.database;
@@ -2395,12 +2698,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                     entities_2.push(entity);
                 }
             }
-            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
             finally {
                 try {
                     if (iterator_1_1 && !iterator_1_1.done && (_a = iterator_1.return)) _a.call(iterator_1);
                 }
-                finally { if (e_10) throw e_10.error; }
+                finally { if (e_11) throw e_11.error; }
             }
             if (entities_2.length === 0) {
                 // Empty layout (e.g. a freshly-created paper space tab). Mark as
@@ -2531,11 +2834,9 @@ var AcTrView2d = /** @class */ (function (_super) {
                 switch (_a.label) {
                     case 0:
                         if (!(threeEntity instanceof AcTrGroup)) return [3 /*break*/, 2];
-                        // Compacted INSERT templates may skip syncDraw when fonts are awaited
-                        // later; still walk for empty glyph shells. Skip only when there is
-                        // nothing left to finalize (incl. post-cache ATTRIBs).
-                        if (threeEntity.getSourceEntities().length === 0 &&
-                            !this.groupHasPendingGlyphGeometry(threeEntity)) {
+                        // Linework-only INSERTs (no empty glyph shells) skip asyncDraw; spatial
+                        // boxes are refreshed by syncGroupSpatialBoundsForIndexing after commit.
+                        if (!this.groupHasPendingGlyphGeometry(threeEntity)) {
                             return [2 /*return*/];
                         }
                         return [4 /*yield*/, threeEntity.asyncDraw()];
@@ -2555,7 +2856,139 @@ var AcTrView2d = /** @class */ (function (_super) {
         });
     };
     AcTrView2d.prototype.needsDeferredFontGeometry = function (threeEntity) {
-        return (threeEntity instanceof AcTrGlyphEntity || threeEntity instanceof AcTrGroup);
+        if (threeEntity instanceof AcTrGlyphEntity) {
+            return !threeEntity.hasDrawableGeometry();
+        }
+        // Only defer INSERTs that still have empty glyph shells. Linework-only
+        // blocks should commit on the convert path and not occupy the geometry pool.
+        if (threeEntity instanceof AcTrGroup) {
+            return this.groupHasPendingGlyphGeometry(threeEntity);
+        }
+        return false;
+    };
+    AcTrView2d.prototype.clearFontLoadedRedrawTimer = function () {
+        if (this._fontLoadedRedrawTimer != null) {
+            clearTimeout(this._fontLoadedRedrawTimer);
+            this._fontLoadedRedrawTimer = null;
+        }
+    };
+    /**
+     * Coalesces late font-load notifications into one glyph rebuild pass.
+     */
+    AcTrView2d.prototype.scheduleGlyphRedrawAfterFontLoad = function (fontName) {
+        var _this = this;
+        this.clearFontLoadedRedrawTimer();
+        var epoch = this._convertEpoch;
+        this._fontLoadedRedrawTimer = setTimeout(function () {
+            _this._fontLoadedRedrawTimer = null;
+            if (epoch !== _this._convertEpoch) {
+                return;
+            }
+            void _this.redrawGlyphEntitiesAfterFontLoad(epoch, fontName);
+        }, 50);
+    };
+    /**
+     * Rebuilds text after a late {@link FontManager.events.fontLoaded}.
+     *
+     * Live {@link AcTrGlyphEntity} shells (rare: mid-convert / not yet batched)
+     * are re-drawn in place. Committed text is already flattened into batches and
+     * disposed, so on-demand faces (style `malgun` → Noto Sans KR) need a database
+     * regen once conversion is idle — otherwise Hangul stays baked as '?'.
+     */
+    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, db;
+            var e_13, _c, e_12, _d;
+            var _e, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        if (epoch !== this._convertEpoch) {
+                            return [2 /*return*/];
+                        }
+                        redrawEpoch = ++this._fontLoadedRedrawEpoch;
+                        glyphs = [];
+                        try {
+                            for (_a = __values(this._scene.layouts.values()), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                layout = _b.value;
+                                layout.layers.forEach(function (layer) {
+                                    layer.internalObject.traverse(function (obj) {
+                                        if (obj instanceof AcTrGlyphEntity) {
+                                            glyphs.push(obj);
+                                        }
+                                    });
+                                });
+                            }
+                        }
+                        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_13) throw e_13.error; }
+                        }
+                        _g.label = 1;
+                    case 1:
+                        _g.trys.push([1, 6, 7, 8]);
+                        glyphs_1 = __values(glyphs), glyphs_1_1 = glyphs_1.next();
+                        _g.label = 2;
+                    case 2:
+                        if (!!glyphs_1_1.done) return [3 /*break*/, 5];
+                        glyph = glyphs_1_1.value;
+                        if (epoch !== this._convertEpoch ||
+                            redrawEpoch !== this._fontLoadedRedrawEpoch) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, glyph.asyncDraw()];
+                    case 3:
+                        _g.sent();
+                        _g.label = 4;
+                    case 4:
+                        glyphs_1_1 = glyphs_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_12_1 = _g.sent();
+                        e_12 = { error: e_12_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; }
+                        return [7 /*endfinally*/];
+                    case 8:
+                        if (glyphs.length > 0) {
+                            if (epoch === this._convertEpoch) {
+                                this._isDirty = true;
+                            }
+                            return [2 /*return*/];
+                        }
+                        // Default preset loads during open are covered by awaitFontsBeforeDraw;
+                        // regenerating for those would thrash after every open.
+                        if (fontName) {
+                            defaults = FontManager.instance.defaultFonts;
+                            normalized_1 = fontName.toLowerCase();
+                            if (defaults.has(fontName) ||
+                                defaults.has(normalized_1) ||
+                                __spreadArray([], __read(defaults), false).some(function (name) { return name.toLowerCase() === normalized_1; })) {
+                                return [2 /*return*/];
+                            }
+                        }
+                        if (epoch !== this._convertEpoch ||
+                            redrawEpoch !== this._fontLoadedRedrawEpoch ||
+                            this.isProcessingEntities) {
+                            return [2 /*return*/];
+                        }
+                        db = (_f = (_e = AcApDocManager.instance) === null || _e === void 0 ? void 0 : _e.curDocument) === null || _f === void 0 ? void 0 : _f.database;
+                        if (!db) {
+                            return [2 /*return*/];
+                        }
+                        db.regen();
+                        return [2 /*return*/];
+                }
+            });
+        });
     };
     AcTrView2d.prototype.groupHasPendingGlyphGeometry = function (group) {
         var pending = false;
@@ -2569,32 +3002,69 @@ var AcTrView2d = /** @class */ (function (_super) {
     /**
      * Runs glyph/group geometry finalize off the main convert loop so other
      * entities keep converting while fonts download.
+     *
+     * Jobs are queued with bounded concurrency — unbounded parallel
+     * `asyncDraw` on large INSERT/text drawings can freeze the main thread
+     * during the "Rendering drawing ..." stage.
      */
     AcTrView2d.prototype.enqueueDeferredGeometry = function (run, epoch) {
-        var _this = this;
         if (epoch !== this._convertEpoch) {
             return;
         }
         this._pendingGeometryJobs++;
-        void run()
-            .then(function () {
-            // Convert counter often hits 0 before fonts finish; without this,
-            // text added later never paints until the user pans/zooms.
-            if (epoch === _this._convertEpoch) {
-                _this._isDirty = true;
+        this._deferredGeometryQueue.push({ run: run, epoch: epoch });
+        this.pumpDeferredGeometryQueue();
+    };
+    /**
+     * Starts queued deferred geometry jobs up to
+     * {@link DEFERRED_GEOMETRY_CONCURRENCY}.
+     */
+    AcTrView2d.prototype.pumpDeferredGeometryQueue = function () {
+        var _this = this;
+        var _loop_3 = function () {
+            var job = this_2._deferredGeometryQueue.shift();
+            if (job.epoch !== this_2._convertEpoch) {
+                this_2._pendingGeometryJobs = Math.max(0, this_2._pendingGeometryJobs - 1);
+                return "continue";
             }
-        })
-            .catch(function (error) {
-            log.error('[AcTrView2d] Deferred entity geometry failed:', error);
-        })
-            .finally(function () {
-            if (epoch === _this._convertEpoch) {
-                _this._pendingGeometryJobs = Math.max(0, _this._pendingGeometryJobs - 1);
-                if (_this._pendingGeometryJobs === 0) {
+            this_2._deferredGeometryActive++;
+            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) {
                     _this._isDirty = true;
                 }
-            }
-        });
+            })
+                .catch(function (error) {
+                log.error('[AcTrView2d] Deferred entity geometry failed:', error);
+            })
+                .finally(function () {
+                _this._deferredGeometryActive = Math.max(0, _this._deferredGeometryActive - 1);
+                if (job.epoch === _this._convertEpoch) {
+                    _this._pendingGeometryJobs = Math.max(0, _this._pendingGeometryJobs - 1);
+                    if (_this._pendingGeometryJobs === 0) {
+                        _this._isDirty = true;
+                    }
+                }
+                _this.pumpDeferredGeometryQueue();
+            });
+        };
+        var this_2 = this;
+        while (this._deferredGeometryActive <
+            AcTrView2d.DEFERRED_GEOMETRY_CONCURRENCY &&
+            this._deferredGeometryQueue.length > 0) {
+            _loop_3();
+        }
+    };
+    /** Drops queued deferred geometry and resets counters for a new epoch. */
+    AcTrView2d.prototype.resetDeferredGeometryQueue = function () {
+        this._deferredGeometryQueue.length = 0;
+        // Keep `_deferredGeometryActive`: in-flight runners still own concurrency
+        // slots until their `finally` runs. Zeroing here lets pump over-schedule
+        // when those completions decrement the counter afterward.
+        this._pendingGeometryJobs = 0;
     };
     /**
      * Waits until side-pool glyph/group jobs for the current convert epoch finish.
@@ -2638,7 +3108,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * paper layouts.
      */
     AcTrView2d.prototype.ensureViewportViews = function (blockTableRecord, layoutView) {
-        var e_11, _a;
+        var e_14, _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()) {
@@ -2651,12 +3121,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 layoutView.addViewport(viewportView);
             }
         }
-        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
         finally {
             try {
                 if (iterator_2_1 && !iterator_2_1.done && (_a = iterator_2.return)) _a.call(iterator_2);
             }
-            finally { if (e_11) throw e_11.error; }
+            finally { if (e_14) throw e_14.error; }
         }
     };
     /**
@@ -2666,7 +3136,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      */
     AcTrView2d.prototype.batchConvert = function (entities_3) {
         return __awaiter(this, arguments, void 0, function (entities, options) {
-            var epoch, progressive, yieldGate, yieldToEventLoop, _loop_3, this_2, i;
+            var epoch, progressive, yieldGate, yieldToEventLoop, _loop_4, this_3, i;
             var _this = this;
             if (options === void 0) { options = {}; }
             return __generator(this, function (_a) {
@@ -2674,13 +3144,13 @@ var AcTrView2d = /** @class */ (function (_super) {
                     case 0:
                         epoch = this._convertEpoch;
                         progressive = this._progressiveRendering && !options.forExport;
-                        yieldGate = progressive
-                            ? new AcCmUiYieldGate(AcTrView2d.PROGRESSIVE_OPEN_YIELD_BUDGET_MS)
-                            : undefined;
+                        yieldGate = options.forExport
+                            ? undefined
+                            : new AcCmUiYieldGate(AcTrView2d.OPEN_CONVERT_YIELD_BUDGET_MS);
                         yieldToEventLoop = function () {
                             return new Promise(function (resolve) { return setTimeout(resolve, 0); });
                         };
-                        _loop_3 = function (i) {
+                        _loop_4 = function (i) {
                             var entity, shouldConvert, directMeta, added, threeEntity_1, isMultiLayerGroup, deferGeometry, isExtendBbox_1, commitEntity, layoutView, viewportView, fileName, error_2, didYield;
                             return __generator(this, function (_b) {
                                 switch (_b.label) {
@@ -2690,7 +3160,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                                     case 1:
                                         _b.trys.push([1, 9, 10, 11]);
                                         // Document was cleared / replaced while this batch was draining.
-                                        if (epoch !== this_2._convertEpoch) {
+                                        if (epoch !== this_3._convertEpoch) {
                                             return [2 /*return*/, "continue"];
                                         }
                                         // Skip the default paper-space viewport (`*Paper_Space`) entirely:
@@ -2709,21 +3179,21 @@ var AcTrView2d = /** @class */ (function (_super) {
                                             return [2 /*return*/, "continue"];
                                         }
                                         shouldConvert = options.forExport
-                                            ? this_2._entityDisplay.shouldConvertForExport(entity)
-                                            : this_2._entityDisplay.shouldConvert(entity);
+                                            ? this_3._entityDisplay.shouldConvertForExport(entity)
+                                            : this_3._entityDisplay.shouldConvert(entity);
                                         if (!shouldConvert) {
                                             return [2 /*return*/, "continue"];
                                         }
-                                        directMeta = tryBuildDirectEntityMeta(entity, this_2._renderer);
+                                        directMeta = tryBuildDirectEntityMeta(entity, this_3._renderer);
                                         if (directMeta) {
                                             added = false;
                                             try {
-                                                added = this_2._scene.addDirectEntity(directMeta, shouldExtendBboxForDirectEntity(entity));
+                                                added = this_3._scene.addDirectEntity(directMeta, shouldExtendBboxForDirectEntity(entity));
                                                 if (added) {
-                                                    this_2.applySessionHiddenObjectState(entity.objectId);
+                                                    this_3.applySessionHiddenObjectState(entity.objectId);
                                                     if (progressive) {
-                                                        this_2.markProgressiveDirty();
-                                                        this_2._progressiveOpenFit.afterGeometryBatch(function () { return _this.resolveLayoutFitBox(); }, i);
+                                                        this_3.markProgressiveDirty();
+                                                        this_3._progressiveOpenFit.afterGeometryBatch(function () { return _this.resolveLayoutFitBox(); }, i);
                                                     }
                                                 }
                                             }
@@ -2735,7 +3205,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                                             }
                                             // Append refused (e.g. invisible) — fall through to the legacy path.
                                         }
-                                        threeEntity_1 = this_2.drawEntity(entity, false);
+                                        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))
@@ -2749,19 +3219,19 @@ var AcTrView2d = /** @class */ (function (_super) {
                                             threeEntity_1.isOnTheSameLayer) {
                                             // Even when a block expands to a single layer bucket, children authored on
                                             // layer "0" still inherit the INSERT layer for ByLayer traits (color, etc.).
-                                            this_2._inheritedLayerMaterialMapper.remap(threeEntity_1.children, '0', threeEntity_1.layerName);
+                                            this_3._inheritedLayerMaterialMapper.remap(threeEntity_1.children, '0', threeEntity_1.layerName);
                                             threeEntity_1.userData.insertLayerName = threeEntity_1.layerName;
                                         }
                                         isMultiLayerGroup = threeEntity_1 instanceof AcTrGroup &&
                                             !threeEntity_1.isOnTheSameLayer;
-                                        deferGeometry = !options.forExport && this_2.needsDeferredFontGeometry(threeEntity_1);
+                                        deferGeometry = !options.forExport && this_3.needsDeferredFontGeometry(threeEntity_1);
                                         if (!isMultiLayerGroup) return [3 /*break*/, 5];
                                         if (!deferGeometry) return [3 /*break*/, 2];
-                                        this_2.enqueueDeferredGeometry(function () {
+                                        this_3.enqueueDeferredGeometry(function () {
                                             return _this.handleGroup(threeEntity_1, progressive, epoch);
                                         }, epoch);
                                         return [3 /*break*/, 4];
-                                    case 2: return [4 /*yield*/, this_2.handleGroup(threeEntity_1, progressive, epoch)];
+                                    case 2: return [4 /*yield*/, this_3.handleGroup(threeEntity_1, progressive, epoch)];
                                     case 3:
                                         _b.sent();
                                         _b.label = 4;
@@ -2795,14 +3265,14 @@ var AcTrView2d = /** @class */ (function (_super) {
                                             });
                                         }); };
                                         if (!deferGeometry) return [3 /*break*/, 6];
-                                        this_2.enqueueDeferredGeometry(commitEntity, epoch);
+                                        this_3.enqueueDeferredGeometry(commitEntity, epoch);
                                         return [3 /*break*/, 8];
                                     case 6: return [4 /*yield*/, commitEntity()];
                                     case 7:
                                         _b.sent();
                                         _b.label = 8;
                                     case 8:
-                                        if (epoch !== this_2._convertEpoch) {
+                                        if (epoch !== this_3._convertEpoch) {
                                             return [2 /*return*/, "continue"];
                                         }
                                         if (entity instanceof AcDbViewport) {
@@ -2812,9 +3282,9 @@ var AcTrView2d = /** @class */ (function (_super) {
                                             // 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_2._layoutViewManager.getAt(entity.ownerId);
+                                                layoutView = this_3._layoutViewManager.getAt(entity.ownerId);
                                                 if (layoutView) {
-                                                    viewportView = new AcTrViewportView(layoutView, entity.toGiViewport(), this_2._renderer);
+                                                    viewportView = new AcTrViewportView(layoutView, entity.toGiViewport(), this_3._renderer);
                                                     layoutView.addViewport(viewportView);
                                                 }
                                             }
@@ -2822,7 +3292,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         else if (entity instanceof AcDbRasterImage) {
                                             fileName = entity.imageFileName;
                                             if (fileName && !entity.image) {
-                                                this_2._missedImages.set(entity.objectId, fileName);
+                                                this_3._missedImages.set(entity.objectId, fileName);
                                             }
                                         }
                                         return [3 /*break*/, 11];
@@ -2833,12 +3303,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                                     case 10:
                                         // Counter was reset in clear() when the epoch advanced; do not
                                         // decrease again or isProcessingEntities can go negative/warn.
-                                        if (epoch === this_2._convertEpoch) {
-                                            this_2.decreaseNumOfEntitiesToProcess();
+                                        if (epoch === this_3._convertEpoch) {
+                                            this_3.decreaseNumOfEntitiesToProcess();
                                         }
                                         return [7 /*endfinally*/];
                                     case 11:
-                                        if (epoch !== this_2._convertEpoch) {
+                                        if (epoch !== this_3._convertEpoch) {
                                             return [2 /*return*/, "continue"];
                                         }
                                         if (!yieldGate) return [3 /*break*/, 13];
@@ -2846,19 +3316,19 @@ var AcTrView2d = /** @class */ (function (_super) {
                                     case 12:
                                         didYield = _b.sent();
                                         if (didYield) {
-                                            this_2._progressiveYieldCount++;
+                                            this_3._progressiveYieldCount++;
                                         }
                                         _b.label = 13;
                                     case 13: return [2 /*return*/];
                                 }
                             });
                         };
-                        this_2 = this;
+                        this_3 = this;
                         i = 0;
                         _a.label = 1;
                     case 1:
                         if (!(i < entities.length)) return [3 /*break*/, 4];
-                        return [5 /*yield**/, _loop_3(i)];
+                        return [5 /*yield**/, _loop_4(i)];
                     case 2:
                         _a.sent();
                         _a.label = 3;
@@ -2893,7 +3363,7 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.handleGroup = function (group_1, progressive_1) {
         return __awaiter(this, arguments, void 0, function (group, progressive, epoch) {
             var children, objectsGroupByLayer, children_1, children_1_1, child, renderContext, groupObjectId, groupLayerName, groupChildBoxes, aggregateSpatialBbox;
-            var e_12, _a;
+            var e_15, _a;
             var _this = this;
             if (epoch === void 0) { epoch = this._convertEpoch; }
             return __generator(this, function (_b) {
@@ -2935,12 +3405,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                                 child.parent = null;
                             }
                         }
-                        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                        catch (e_15_1) { e_15 = { error: e_15_1 }; }
                         finally {
                             try {
                                 if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
                             }
-                            finally { if (e_12) throw e_12.error; }
+                            finally { if (e_15) throw e_15.error; }
                         }
                         renderContext = group.renderContext;
                         groupObjectId = group.objectId;
@@ -2986,7 +3456,11 @@ var AcTrView2d = /** @class */ (function (_super) {
                             // 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);
-                            entity.applyMatrix4(group.matrix);
+                            // 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
@@ -3002,6 +3476,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                             for (var i = 0; i < objects.length; i++) {
                                 entity.add(objects[i]);
                             }
+                            entity.updateMatrixWorld(true);
                             _this._layerAppearance.refreshTextMaterialsInObjectTree(entity);
                             _this._scene.addEntity(entity, true);
                             _this.applySessionHiddenObjectState(groupObjectId);
@@ -3034,17 +3509,27 @@ var AcTrView2d = /** @class */ (function (_super) {
         }
     };
     /**
-     * Wall-time between cooperative yields during progressive open (ms).
-     * Kept relatively large so convert throughput stays close to the
-     * non-progressive path; smaller budgets made open 2–3× slower.
+     * 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.
      */
-    AcTrView2d.PROGRESSIVE_OPEN_YIELD_BUDGET_MS = 300;
+    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.
+     * paint much less often than we yield. Independent of convert yields —
+     * non-progressive opens still yield without mid-open WebGL paints.
      */
     AcTrView2d.PROGRESSIVE_OPEN_PAINT_INTERVAL_MS = 1000;
+    /**
+     * 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;
     return AcTrView2d;
 }(AcEdBaseView));
 export { AcTrView2d };