@mlightcad/cad-simple-viewer 1.7.0 → 1.7.2

package/lib/view/AcTrView2d.js

@@ -96,9 +96,10 @@ 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 { AcTrEntity, AcTrGlyphEntity, AcTrGroup, AcTrRenderer, AcTrViewportView } from '@mlightcad/three-renderer';
+import { FontManager } from '@mlightcad/mtext-renderer';
+import { AcTrEntity, AcTrGlyphEntity, AcTrGroup, AcTrRenderer, AcTrViewportView, hasPendingComplexLineTypeGlyphs } from '@mlightcad/three-renderer';
 import { AcTrMatrixUtil } from '@mlightcad/three-renderer';
 import * as THREE from 'three';
 import Stats from 'three/examples/jsm/libs/stats.module';
@@ -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';
@@ -128,6 +130,7 @@ import { AcTrLayoutViewManager } from './AcTrLayoutViewManager';
 import { sortPickResults } from './AcTrPickResultUtil';
 import { AcTrProgressiveOpenFitController } from './AcTrProgressiveOpenFitController';
 import { AcTrScene } from './AcTrScene';
+import { shouldRegenDatabaseAfterFontLoad } from './fontLoadRegen';
 /**
  * Default view option values
  */
@@ -182,11 +185,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.
@@ -248,6 +248,21 @@ var AcTrView2d = /** @class */ (function (_super) {
          * wasted conversion work — this set skips re-entry until the current pass ends.
          */
         _this._convertingLayers = new Set();
+        /**
+         * Object ids claimed by an in-flight interactive {@link batchConvert},
+         * including deferred glyph commits that have not yet called
+         * {@link AcTrScene.addEntity}. Without this, a second convert pass can
+         * append another batched slot for the same id (visible as doubled TEXT
+         * linetype labels) because {@link hasEntity} is still false.
+         */
+        _this._claimedConvertObjectIds = new Set();
+        /**
+         * Per-objectId convert generation. Bumped by {@link updateEntity} so an
+         * in-flight progressive {@link batchConvert} / deferred commit for the same
+         * id cannot `addEntity` after the scene was cleared for reconversion
+         * (ghost RasterImage / pre-replacement pixels).
+         */
+        _this._entityConvertGeneration = new Map();
         /**
          * When true, entity conversion during document open yields cooperatively so
          * geometry paints incrementally while the open overlay is still visible.
@@ -275,10 +290,47 @@ 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.
+         * Saved view was not applied at open. Frame batch bounds once linework
+         * convert drains, so the canvas is not blank until deferred glyphs finish.
+         * Applied on a timer so it does not run on the entity-parse stack.
+         */
+        _this._openLineworkFramePending = false;
+        _this._openLineworkFrameTimer = null;
+        /**
+         * 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;
+        /**
+         * `performance.now()` when convert and deferred glyph jobs last reached
+         * idle together. Zero until that first transition. Used to ignore the
+         * open-time `fontLoaded` regen that replays the loading spinner.
+         */
+        _this._entityProcessingIdleAt = 0;
+        /**
+         * Convert epoch for which text-style font preload was started.
+         */
+        _this._textStyleFontPreloadEpoch = -1;
+        /**
+         * In-flight (or resolved) preload of {@link AcDbTextStyleTable.fonts}.
+         * Started at conversion stage `STYLE` END so download overlaps LAYER/BLOCK/
+         * ENTITY parse and linework convert; glyph jobs await this before draw.
+         */
+        _this._textStyleFontPreloadPromise = null;
         /** Transient reading mode forces black linework on a white canvas. */
         _this._readingMode = new AcApReadingModeState({
             getCurrentBackgroundColor: function () { return _this._renderer.currentBackgroundColor; },
@@ -323,6 +375,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 +393,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 +687,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 +819,17 @@ 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 uses this when
+         * {@link AcApOpenDatabaseOptions.progressiveRendering} is off, so
+         * "Rendering drawing ..." stays up until deferred glyph jobs finish.
+         * When progressive rendering is on, the overlay uses
+         * {@link isConvertingEntities} and may hide while text geometry continues
+         * in the deferred pool (pan/zoom enabled). Deprecated `waitForTextGeometry`
+         * no longer selects this gate.
          */
         get: function () {
             return this._numOfEntitiesToProcess > 0 || this._pendingGeometryJobs > 0;
@@ -773,6 +837,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 +907,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 +1038,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);
@@ -1145,13 +1224,16 @@ var AcTrView2d = /** @class */ (function (_super) {
                         threeEntity.visible = entity.visibility !== false;
                         if (threeEntity instanceof AcTrGroup &&
                             threeEntity.isOnTheSameLayer) {
-                            // Children authored on layer "0" inherit the INSERT layer for
-                            // ByLayer traits (color, etc.), same as the primary-document path.
-                            this._inheritedLayerMaterialMapper.remap(threeEntity.children, '0', threeEntity.layerName);
+                            threeEntity.userData.insertLayerName = threeEntity.layerName;
                         }
                         return [4 /*yield*/, this.finishEntityGeometry(threeEntity, false)];
                     case 5:
                         _g.sent();
+                        if (threeEntity instanceof AcTrGroup &&
+                            threeEntity.isOnTheSameLayer) {
+                            // Remap after glyph geometry exists — see same-layer commit path.
+                            this._inheritedLayerMaterialMapper.remap(threeEntity.children, '0', threeEntity.layerName);
+                        }
                         layout.addEntity(threeEntity);
                         threeEntity.dispose();
                         return [3 /*break*/, 7];
@@ -1421,14 +1503,50 @@ 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;
         }
     };
+    /**
+     * When open framing waits on {@link zoomToFitDrawing}, show the linework
+     * bounds as soon as entity convert drains. The final fit still runs after
+     * deferred glyphs so text extents can refine the camera.
+     */
+    AcTrView2d.prototype.requestOpenLineworkFrame = function () {
+        this._openLineworkFramePending = true;
+        this.scheduleOpenLineworkFrame();
+    };
+    AcTrView2d.prototype.cancelOpenLineworkFrame = function () {
+        this._openLineworkFramePending = false;
+        if (this._openLineworkFrameTimer != null) {
+            clearTimeout(this._openLineworkFrameTimer);
+            this._openLineworkFrameTimer = null;
+        }
+    };
+    AcTrView2d.prototype.scheduleOpenLineworkFrame = function () {
+        var _this = this;
+        if (this._openLineworkFrameTimer != null ||
+            !this._openLineworkFramePending) {
+            return;
+        }
+        var delay = this.isConvertingEntities ? 50 : 0;
+        this._openLineworkFrameTimer = setTimeout(function () {
+            _this._openLineworkFrameTimer = null;
+            if (!_this._openLineworkFramePending)
+                return;
+            if (_this.isConvertingEntities) {
+                _this.scheduleOpenLineworkFrame();
+                return;
+            }
+            _this.frameOpenLineworkIfReady();
+        }, delay);
+    };
     /**
      * @inheritdoc
      */
@@ -1796,6 +1914,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 +1968,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 +1990,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;
     };
@@ -1950,15 +2110,36 @@ var AcTrView2d = /** @class */ (function (_super) {
      */
     AcTrView2d.prototype.addEntity = function (entity) {
         var _a;
+        var _b;
         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);
+        // Mark each owner layout as loaded as soon as the open-time ENTITY stream
+        // enqueues work. Progressive convert may not have committed scene entities
+        // yet (`entityCount` still 0); without this, `loadLayoutEntitiesIfNeeded`
+        // (from `onAfterOpenDocument` → `setActiveLayout`) re-iterates the BTR,
+        // double-increments `_numOfEntitiesToProcess`, and keeps
+        // "Rendering drawing ..." up long after linework should have finished —
+        // so progressive rendering cannot release pan/zoom on time.
+        for (var i = 0; i < entities.length; i++) {
+            var ownerId = (_b = entities[i]) === null || _b === void 0 ? void 0 : _b.ownerId;
+            if (!ownerId)
+                continue;
+            var layout = this._scene.layouts.get(ownerId);
+            if (!layout) {
+                this._scene.addEmptyLayout(ownerId);
+                layout = this._scene.layouts.get(ownerId);
+            }
+            if (layout && !layout.isLoaded) {
+                layout.isLoaded = true;
+            }
         }
+        this._numOfEntitiesToProcess += entities.length;
+        // 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
@@ -2021,6 +2202,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      */
     AcTrView2d.prototype.updateEntity = function (entity) {
         var _this = this;
+        var _a, _b;
         var entities = this.resolveSceneUpdateEntities(Array.isArray(entity) ? entity : [entity]);
         if (entities.length === 0)
             return;
@@ -2029,6 +2211,17 @@ var AcTrView2d = /** @class */ (function (_super) {
             .filter(function (objectId) { return _this.selectionSet.has(objectId); });
         for (var i = 0; i < entities.length; ++i) {
             var item = entities[i];
+            var objectId = String((_a = item.objectId) !== null && _a !== void 0 ? _a : '');
+            if (objectId) {
+                // Invalidate in-flight commits for this id before releasing the claim /
+                // clearing the scene, so a stale progressive convert cannot re-add the
+                // pre-update drawable after (or instead of) the reconversion pass.
+                this._entityConvertGeneration.set(objectId, ((_b = this._entityConvertGeneration.get(objectId)) !== null && _b !== void 0 ? _b : 0) + 1);
+                // Allow reconversion: open-time batchConvert claims objectIds to prevent
+                // duplicate progressive slots. updateEntity must release that claim or
+                // batchConvert skips the entity (scene already cleared → blank RasterImage).
+                this._claimedConvertObjectIds.delete(objectId);
+            }
             if (this._scene.hasEntity(item.objectId)) {
                 this._scene.removeEntity(item.objectId);
             }
@@ -2048,6 +2241,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                             this.highlight(selectedIds);
                         }
                         this._gripManager.refresh();
+                        this._isDirty = true;
                         return [2 /*return*/];
                 }
             });
@@ -2064,7 +2258,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 +2280,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 +2409,14 @@ 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._claimedConvertObjectIds.clear();
+        this._entityConvertGeneration.clear();
+        this.cancelOpenLineworkFrame();
+        this.resetDeferredGeometryQueue();
+        this._entityProcessingIdleAt = 0;
         this._scene.clear();
         this._isDirty = true;
         this._missedImages.clear();
@@ -2252,9 +2451,14 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.restoreSessionState = function (state) {
         var _a;
         this._convertEpoch++;
+        this.clearFontLoadedRedrawTimer();
+        this.cancelOpenLineworkFrame();
         this._convertQueue.length = 0;
         this._numOfEntitiesToProcess = 0;
-        this._pendingGeometryJobs = 0;
+        this._claimedConvertObjectIds.clear();
+        this._entityConvertGeneration.clear();
+        this.resetDeferredGeometryQueue();
+        this._entityProcessingIdleAt = 0;
         this._scene = state.scene;
         this._layoutViewManager = state.layoutViewManager;
         this._initializedLayouts = state.initializedLayouts;
@@ -2279,9 +2483,14 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.beginNewSession = function () {
         var parked = this.captureSessionState();
         this._convertEpoch++;
+        this.clearFontLoadedRedrawTimer();
+        this.cancelOpenLineworkFrame();
         this._convertQueue.length = 0;
         this._numOfEntitiesToProcess = 0;
-        this._pendingGeometryJobs = 0;
+        this._claimedConvertObjectIds.clear();
+        this._entityConvertGeneration.clear();
+        this.resetDeferredGeometryQueue();
+        this._entityProcessingIdleAt = 0;
         this._scene = this.createScene();
         this._layoutViewManager = new AcTrLayoutViewManager();
         this._initializedLayouts = new Set();
@@ -2327,8 +2536,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 +2647,20 @@ 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.cancelOpenLineworkFrame();
+        this.stopAnimationLoop();
+    };
     /**
      * @inheritdoc
      */
@@ -2529,7 +2753,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;
@@ -2539,6 +2763,15 @@ var AcTrView2d = /** @class */ (function (_super) {
             }
             var existingLayout = this._scene.layouts.get(layoutBtrId);
             if (existingLayout && existingLayout.isLoaded) {
+                // Streamed layouts flip `isLoaded` from `addEntity` before scene
+                // commits finish. Still repair the viewport-view race when entities
+                // are already in the scene but AcTrViewportView creation was skipped.
+                var layoutView_1 = this._layoutViewManager.getAt(layoutBtrId);
+                if (existingLayout.entityCount > 0 &&
+                    layoutView_1 &&
+                    layoutView_1.viewportCount === 0) {
+                    this.ensureViewportViews(blockTableRecord, layoutView_1);
+                }
                 return;
             }
             if (this._loadingLayouts.has(layoutBtrId)) {
@@ -2582,6 +2815,11 @@ var AcTrView2d = /** @class */ (function (_super) {
             // is only for layouts whose entities were never streamed in
             // (typically non-active paper-space layouts loaded on first user
             // visit).
+            //
+            // Note: `addEntity` now sets `isLoaded` when the open stream
+            // enqueues work, so the common progressive-open race (entityCount
+            // still 0 at `onAfterOpenDocument` while the convert queue is full)
+            // is handled by the `isLoaded` early return above.
             if (existingLayout && existingLayout.entityCount > 0) {
                 existingLayout.isLoaded = true;
                 return;
@@ -2600,12 +2838,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
@@ -2723,36 +2961,115 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.drawEntity = function (entity, delay) {
         return entity.worldDraw(this._renderer, delay);
     };
+    /**
+     * Starts loading fonts referenced by the drawing text style table.
+     *
+     * Call when conversion stage `STYLE` ends so the download overlaps later
+     * parse stages and linework convert. Does not block the caller — glyph
+     * finalize awaits {@link awaitTextStyleFontsReady} instead.
+     *
+     * @param database - Database whose text style table has just been filled.
+     */
+    AcTrView2d.prototype.startTextStyleFontPreload = function (database) {
+        var _a;
+        var epoch = this._convertEpoch;
+        if (this._textStyleFontPreloadEpoch === epoch &&
+            this._textStyleFontPreloadPromise) {
+            return;
+        }
+        this._textStyleFontPreloadEpoch = epoch;
+        var names = [];
+        try {
+            names = (_a = database.tables.textStyleTable.fonts) !== null && _a !== void 0 ? _a : [];
+        }
+        catch (_b) {
+            this._textStyleFontPreloadPromise = Promise.resolve();
+            return;
+        }
+        if (names.length === 0) {
+            this._textStyleFontPreloadPromise = Promise.resolve();
+            return;
+        }
+        this._textStyleFontPreloadPromise = FontManager.instance
+            .requestFonts(names)
+            .then(function () { }, function () {
+            // Glyph draw still falls back via FontManager defaults / '?'.
+        });
+    };
+    /**
+     * Waits until {@link startTextStyleFontPreload} has finished (or starts a
+     * fallback preload from this view's bound draw database if STYLE was missed).
+     */
+    AcTrView2d.prototype.awaitTextStyleFontsReady = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var db;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._textStyleFontPreloadPromise) {
+                            db = this._renderer.context.database;
+                            if (db) {
+                                this.startTextStyleFontPreload(db);
+                            }
+                            else {
+                                return [2 /*return*/];
+                            }
+                        }
+                        return [4 /*yield*/, this._textStyleFontPreloadPromise];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Finishes geometry for a converted entity.
      *
-     * Glyph entities and block groups use {@link AcTrEntity.asyncDraw} so
-     * {@link FontManager.awaitFontsBeforeDraw} can wait for fonts without
-     * relying on a full-scene regen. Other entities keep the sync finalize path.
+     * Glyph entities, complex-linetype lines, and block groups use
+     * {@link AcTrEntity.asyncDraw} so {@link FontManager.awaitFontsBeforeDraw}
+     * can wait for fonts without relying on a full-scene regen. Other entities
+     * keep the sync finalize path.
      */
     AcTrView2d.prototype.finishEntityGeometry = function (threeEntity, _progressive) {
         return __awaiter(this, void 0, void 0, function () {
+            var needsGlyphDraw;
             return __generator(this, function (_a) {
                 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)) {
+                        needsGlyphDraw = (threeEntity instanceof AcTrGroup &&
+                            this.groupHasPendingGlyphGeometry(threeEntity)) ||
+                            hasPendingComplexLineTypeGlyphs(threeEntity) ||
+                            (threeEntity instanceof AcTrGlyphEntity &&
+                                !threeEntity.hasDrawableGeometry());
+                        if (!needsGlyphDraw) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.awaitTextStyleFontsReady()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (!(threeEntity instanceof AcTrGroup)) return [3 /*break*/, 4];
+                        // 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()];
-                    case 1:
+                    case 3:
                         _a.sent();
                         return [2 /*return*/];
-                    case 2:
+                    case 4:
+                        if (!hasPendingComplexLineTypeGlyphs(threeEntity)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, threeEntity.asyncDraw()];
+                    case 5:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 6:
                         if (threeEntity.hasDrawableGeometry()) {
                             return [2 /*return*/];
                         }
                         return [4 /*yield*/, threeEntity.asyncDraw()];
-                    case 3:
+                    case 7:
                         _a.sent();
                         return [2 /*return*/];
                 }
@@ -2760,7 +3077,152 @@ 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 hasPendingComplexLineTypeGlyphs(threeEntity);
+    };
+    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. A database regen does not rebuild those batches — `entityAppended`
+     * skips ids the view already has — but it does replay open-file CONVERSION
+     * progress. That replay is skipped while the open has just gone idle
+     * ({@link shouldRegenDatabaseAfterFontLoad}); a face that arrives later can
+     * still regen.
+     */
+    AcTrView2d.prototype.redrawGlyphEntitiesAfterFontLoad = function (epoch, fontName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var redrawEpoch, glyphs, _a, _b, layout, glyphs_1, glyphs_1_1, glyph, e_12_1, defaults, normalized_1, msSinceIdle, db;
+            var e_13, _c, e_12, _d;
+            var _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/symbol preset faces are requested in the background under lazy
+                        // loading (mtext-renderer awaitFontsBeforeDraw only waits on content/style
+                        // fonts). Regenerating for every default face load would thrash after open;
+                        // style fonts that finish late still take the regen path below.
+                        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) {
+                            return [2 /*return*/];
+                        }
+                        msSinceIdle = this._entityProcessingIdleAt > 0
+                            ? performance.now() - this._entityProcessingIdleAt
+                            : null;
+                        // Open-time text awaits its fonts, then this debounced callback runs.
+                        // Regen here only flashes the loading spinner again after
+                        // "Rendering drawing ..." has already hidden (progressive rendering on).
+                        if (!shouldRegenDatabaseAfterFontLoad(this.isProcessingEntities, 0, msSinceIdle)) {
+                            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 +3236,71 @@ 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.stampEntityProcessingIdle();
+                }
+                _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;
+        this._textStyleFontPreloadPromise = null;
+        this._textStyleFontPreloadEpoch = -1;
     };
     /**
      * Waits until side-pool glyph/group jobs for the current convert epoch finish.
@@ -2843,7 +3344,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 +3357,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,31 +3372,41 @@ 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, db, progressive, yieldGate, yieldToEventLoop, _loop_4, this_3, i;
             var _this = this;
+            var _a, _b, _c;
             if (options === void 0) { options = {}; }
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         epoch = this._convertEpoch;
+                        // Fallback: if STYLE-stage preload never started (e.g. non-conversion open
+                        // paths), kick it off without blocking linework convert. Glyph finalize
+                        // awaits the promise via {@link awaitTextStyleFontsReady}.
+                        if (!options.forExport && !this._textStyleFontPreloadPromise) {
+                            db = this._renderer.context.database;
+                            if (db) {
+                                this.startTextStyleFontPreload(db);
+                            }
+                        }
                         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) {
-                            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) {
+                        _loop_4 = function (i) {
+                            var entity, shouldConvert, objectId_1, convertGen_1, directMeta, added, superseded, threeEntity_1, isMultiLayerGroup, deferGeometry, isExtendBbox_1, commitEntity, layoutView, viewportView, fileName, error_2, didYield;
+                            return __generator(this, function (_e) {
+                                switch (_e.label) {
                                     case 0:
                                         entity = entities[i];
-                                        _b.label = 1;
+                                        _e.label = 1;
                                     case 1:
-                                        _b.trys.push([1, 9, 10, 11]);
+                                        _e.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,33 +3425,53 @@ 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);
+                                        objectId_1 = String((_a = entity.objectId) !== null && _a !== void 0 ? _a : '');
+                                        convertGen_1 = 0;
+                                        if (!options.forExport) {
+                                            if (objectId_1 &&
+                                                (this_3.hasEntity(objectId_1) ||
+                                                    this_3._claimedConvertObjectIds.has(objectId_1))) {
+                                                return [2 /*return*/, "continue"];
+                                            }
+                                            if (objectId_1) {
+                                                this_3._claimedConvertObjectIds.add(objectId_1);
+                                                convertGen_1 = (_b = this_3._entityConvertGeneration.get(objectId_1)) !== null && _b !== void 0 ? _b : 0;
+                                            }
+                                        }
+                                        directMeta = tryBuildDirectEntityMeta(entity, this_3._renderer);
                                         if (directMeta) {
                                             added = false;
+                                            superseded = false;
                                             try {
-                                                added = this_2._scene.addDirectEntity(directMeta, shouldExtendBboxForDirectEntity(entity));
-                                                if (added) {
-                                                    this_2.applySessionHiddenObjectState(entity.objectId);
-                                                    if (progressive) {
-                                                        this_2.markProgressiveDirty();
-                                                        this_2._progressiveOpenFit.afterGeometryBatch(function () { return _this.resolveLayoutFitBox(); }, i);
+                                                if (objectId_1 &&
+                                                    ((_c = this_3._entityConvertGeneration.get(objectId_1)) !== null && _c !== void 0 ? _c : 0) !== convertGen_1) {
+                                                    superseded = true;
+                                                }
+                                                else {
+                                                    added = this_3._scene.addDirectEntity(directMeta, shouldExtendBboxForDirectEntity(entity));
+                                                    if (added) {
+                                                        this_3.applySessionHiddenObjectState(entity.objectId);
+                                                        if (progressive) {
+                                                            this_3.markProgressiveDirty();
+                                                            this_3._progressiveOpenFit.afterGeometryBatch(function () { return _this.resolveLayoutFitBox(); }, i);
+                                                        }
                                                     }
                                                 }
                                             }
                                             finally {
                                                 directMeta.geometry.dispose();
                                             }
-                                            if (added) {
+                                            if (superseded || added) {
                                                 return [2 /*return*/, "continue"];
                                             }
                                             // 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))
@@ -2952,40 +3483,51 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         threeEntity_1.visible = entity.visibility !== false;
                                         if (threeEntity_1 instanceof AcTrGroup &&
                                             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);
+                                            // Layer-0 inheritance must run AFTER finishEntityGeometry so TEXT/
+                                            // MTEXT glyph materials exist. Remapping earlier (before asyncDraw)
+                                            // leaves GM/GB-style labels as ACI-7 white while the block frame
+                                            // remaps correctly (GAS-Meter / GAS-Box, A517B / A517E).
                                             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 () {
-                                            return _this.handleGroup(threeEntity_1, progressive, epoch);
+                                        this_3.enqueueDeferredGeometry(function () {
+                                            return _this.handleGroup(threeEntity_1, progressive, epoch, convertGen_1);
                                         }, 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, convertGen_1)];
                                     case 3:
-                                        _b.sent();
-                                        _b.label = 4;
+                                        _e.sent();
+                                        _e.label = 4;
                                     case 4: return [3 /*break*/, 8];
                                     case 5:
                                         isExtendBbox_1 = !(entity instanceof AcDbRay || entity instanceof AcDbXline);
                                         commitEntity = function () { return __awaiter(_this, void 0, void 0, function () {
                                             var _this = this;
-                                            return __generator(this, function (_a) {
-                                                switch (_a.label) {
+                                            var _a;
+                                            return __generator(this, function (_b) {
+                                                switch (_b.label) {
                                                     case 0: return [4 /*yield*/, this.finishEntityGeometry(threeEntity_1, progressive)];
                                                     case 1:
-                                                        _a.sent();
+                                                        _b.sent();
                                                         if (epoch !== this._convertEpoch) {
                                                             threeEntity_1.dispose();
                                                             return [2 /*return*/];
                                                         }
+                                                        if (objectId_1 &&
+                                                            ((_a = this._entityConvertGeneration.get(objectId_1)) !== null && _a !== void 0 ? _a : 0) !==
+                                                                convertGen_1) {
+                                                            threeEntity_1.dispose();
+                                                            return [2 /*return*/];
+                                                        }
                                                         if (threeEntity_1 instanceof AcTrGroup) {
                                                             this.syncGroupSpatialBoundsForIndexing(threeEntity_1);
+                                                            if (threeEntity_1.isOnTheSameLayer) {
+                                                                this._inheritedLayerMaterialMapper.remap(threeEntity_1.children, '0', threeEntity_1.layerName);
+                                                            }
                                                         }
                                                         this._scene.addEntity(threeEntity_1, isExtendBbox_1);
                                                         this.applySessionHiddenObjectState(entity.objectId);
@@ -3000,14 +3542,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;
+                                        _e.sent();
+                                        _e.label = 8;
                                     case 8:
-                                        if (epoch !== this_2._convertEpoch) {
+                                        if (epoch !== this_3._convertEpoch) {
                                             return [2 /*return*/, "continue"];
                                         }
                                         if (entity instanceof AcDbViewport) {
@@ -3017,9 +3559,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,46 +3569,49 @@ 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);
+                                            }
+                                            else if (entity.image) {
+                                                this_3._missedImages.delete(entity.objectId);
                                             }
                                         }
                                         return [3 /*break*/, 11];
                                     case 9:
-                                        error_2 = _b.sent();
+                                        error_2 = _e.sent();
                                         log.error("[AcTrView2d] Failed to convert entity ".concat(entity.objectId, " (").concat(entity.type, "):"), error_2);
                                         return [3 /*break*/, 11];
                                     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];
                                         return [4 /*yield*/, yieldGate.maybeYield(yieldToEventLoop)];
                                     case 12:
-                                        didYield = _b.sent();
+                                        didYield = _e.sent();
                                         if (didYield) {
-                                            this_2._progressiveYieldCount++;
+                                            this_3._progressiveYieldCount++;
                                         }
-                                        _b.label = 13;
+                                        _e.label = 13;
                                     case 13: return [2 /*return*/];
                                 }
                             });
                         };
-                        this_2 = this;
+                        this_3 = this;
                         i = 0;
-                        _a.label = 1;
+                        _d.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;
+                        _d.sent();
+                        _d.label = 3;
                     case 3:
                         ++i;
                         return [3 /*break*/, 1];
@@ -3096,20 +3641,28 @@ var AcTrView2d = /** @class */ (function (_super) {
         userData.spatialIndexChildBoxes = childBoxes;
     };
     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;
+        return __awaiter(this, arguments, void 0, function (group, progressive, epoch, convertGen) {
+            var objectId, children, objectsGroupByLayer, children_1, children_1_1, child, renderContext, groupObjectId, groupLayerName, groupChildBoxes, aggregateSpatialBbox;
+            var e_15, _a;
             var _this = this;
+            var _b, _c;
             if (epoch === void 0) { epoch = this._convertEpoch; }
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            if (convertGen === void 0) { convertGen = 0; }
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0: return [4 /*yield*/, this.finishEntityGeometry(group, progressive)];
                     case 1:
-                        _b.sent();
+                        _d.sent();
                         if (epoch !== this._convertEpoch) {
                             group.dispose();
                             return [2 /*return*/];
                         }
+                        objectId = String((_b = group.objectId) !== null && _b !== void 0 ? _b : '');
+                        if (objectId &&
+                            ((_c = this._entityConvertGeneration.get(objectId)) !== null && _c !== void 0 ? _c : 0) !== convertGen) {
+                            group.dispose();
+                            return [2 /*return*/];
+                        }
                         this.syncGroupSpatialBoundsForIndexing(group);
                         children = group.children;
                         objectsGroupByLayer = new Map();
@@ -3140,12 +3693,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 +3744,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 +3764,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);
@@ -3236,20 +3794,60 @@ var AcTrView2d = /** @class */ (function (_super) {
             // the user pans/zooms (animate bails when !_isDirty && !_htmlDirty &&
             // !stillLoading).
             this._isDirty = true;
+            // Missed images (and fonts already tracked) are collected during convert;
+            // notify the Resources / External References palette once the queue is idle.
+            eventBus.emit('missed-data-changed', {});
+        }
+        this.stampEntityProcessingIdle();
+    };
+    /**
+     * Zooms to batch geometry once, after entity convert has drained.
+     */
+    AcTrView2d.prototype.frameOpenLineworkIfReady = function () {
+        if (!this._openLineworkFramePending || this.isConvertingEntities) {
+            return;
+        }
+        var box = this.resolveLayoutFitBox();
+        if (!box || box.isEmpty()) {
+            this._openLineworkFramePending = false;
+            return;
+        }
+        this._openLineworkFramePending = false;
+        // Programmatic so a progressive open does not treat this as a user zoom
+        // and skip the glyph-aware final fit.
+        this._progressiveOpenFit.frameProgrammatically(box);
+    };
+    /**
+     * Records the moment convert and deferred glyph jobs are both idle.
+     * Intermediate completions (linework done, text still queued) do not stamp.
+     */
+    AcTrView2d.prototype.stampEntityProcessingIdle = function () {
+        if (this._numOfEntitiesToProcess === 0 && this._pendingGeometryJobs === 0) {
+            this._entityProcessingIdleAt = performance.now();
         }
     };
     /**
-     * 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 };