@mlightcad/cad-simple-viewer 1.7.0 → 1.7.1

package/lib/view/AcTrView2d.js

@@ -96,8 +96,9 @@ 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';
@@ -107,9 +108,10 @@ import { AcApDocManager, AcApSettingManager } from '../app';
 import { AcApZoomCmd } from '../command/AcApZoomCmd';
 import { isMarkupHtmlTextEditing } from '../command/markup/AcApMarkupTextEdit';
 import { notifyMeasurementLayoutChanged } from '../command/measure/AcApMeasurementStore';
-import { acedAttachMobileBoxGesture, AcEdBaseView, AcEdConditionWaiter, AcEdCorsorType, AcEdGripManager, acedInteractionStrategy, acedIsTouchDerivedMouseEvent, AcEdMTextEditor, AcEdOpenMode, acedShouldIgnoreCompatMouse, AcEdViewMode, eventBus, resolvePointerSelectionAction } from '../editor';
+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';
@@ -182,11 +184,8 @@ var AcTrView2d = /** @class */ (function (_super) {
         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 context-menu gesture.
-        renderer.domElement.style.touchAction = 'none';
-        renderer.domElement.style.userSelect = 'none';
-        renderer.domElement.style.setProperty('-webkit-user-select', 'none');
-        renderer.domElement.style.setProperty('-webkit-touch-callout', 'none');
+        // 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.
@@ -275,10 +274,24 @@ 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; },
@@ -323,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) {
@@ -340,9 +354,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 count: (_a = args.count) !== null && _a !== void 0 ? _a : 0
             });
         });
-        _this._renderer.events.fontLoaded.addEventListener(function () {
+        _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);
@@ -631,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) {
@@ -763,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;
@@ -773,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.
      *
@@ -832,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 {
@@ -962,6 +996,9 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.applyCanvasBackground = function (value) {
         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);
@@ -1421,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;
         }
     };
@@ -1796,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
      */
@@ -1808,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);
@@ -1830,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;
     };
@@ -1952,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
@@ -2064,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 = [];
@@ -2086,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;
     };
@@ -2215,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();
@@ -2252,9 +2334,10 @@ var AcTrView2d = /** @class */ (function (_super) {
     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;
@@ -2279,9 +2362,10 @@ 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();
@@ -2327,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.
@@ -2437,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
      */
@@ -2529,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;
@@ -2600,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
@@ -2736,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()];
@@ -2760,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;
@@ -2774,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.
@@ -2843,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()) {
@@ -2856,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; }
         }
     };
     /**
@@ -2871,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) {
@@ -2879,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) {
@@ -2895,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:
@@ -2914,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);
                                                     }
                                                 }
                                             }
@@ -2940,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))
@@ -2954,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;
@@ -3000,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) {
@@ -3017,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);
                                                 }
                                             }
@@ -3027,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];
@@ -3038,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];
@@ -3051,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;
@@ -3098,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) {
@@ -3140,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;
@@ -3191,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
@@ -3207,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);
@@ -3239,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 };