@mlightcad/cad-simple-viewer 1.7.3 → 1.7.5

package/lib/view/AcTrView2d.js

@@ -96,10 +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, acgiForegroundColorForBackground, log } from '@mlightcad/data-model';
+import { AcCmUiYieldGate, AcDbAttribute, AcDbBlockReference, acdbHostApplicationServices, AcDbMText, AcDbRasterImage, AcDbRay, AcDbRenderingCache, 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, AcTrMTextRenderer, AcTrRenderer, AcTrViewportView, hasPendingComplexLineTypeGlyphs } from '@mlightcad/three-renderer';
+import { AcTrEntity, AcTrGlyphEntity, AcTrGroup, AcTrMTextRenderer, AcTrRenderer, AcTrViewportView, hasPendingComplexLineTypeGlyphs, setAcTrDrawOrderZAllocator } from '@mlightcad/three-renderer';
 import { AcTrMatrixUtil } from '@mlightcad/three-renderer';
 import * as THREE from 'three';
 import Stats from 'three/examples/jsm/libs/stats.module';
@@ -115,6 +115,7 @@ import { acedEntityIntersectsSelectionBox, acedNeedsCrossingGeometryRefine } fro
 import { isEffectiveSpatialQueryHit } from '../editor/view/AcEdSpatialQueryResult';
 import { AcTrGeometryUtil } from '../util';
 import { acapRunDatabaseEdit } from '../util/AcApDatabaseEdit';
+import { collectTextStyleFontNames, planTextStyleFontPreload } from '../util/AcApTextStyleFontPreload';
 import { ACAP_READING_MODE_BACKGROUND, AcApReadingModeState } from './AcApReadingMode';
 import { trySelectReviewOverlay, trySelectReviewOverlaysByBox } from './AcEdReviewOverlayPick';
 import { AcEdViewKeyHandler } from './AcEdViewKeyHandler';
@@ -122,7 +123,7 @@ import { shouldExtendBboxForDirectEntity, tryBuildDirectEntityMeta } from './AcT
 import { AcTrEntityDisplayController } from './AcTrEntityDisplayController';
 import { assertAcTrGroupWcsBboxesConsistent, unionGroupWcsChildBoxes } from './AcTrGroupWcsBboxAssert';
 import { AcTrInheritedLayerMaterialMapper } from './AcTrInheritedLayerMaterialMapper';
-import { computeIntelligentExtents } from './AcTrIntelligentExtents';
+import { computeIntelligentExtentsAsync } from './AcTrIntelligentExtents';
 import { AcTrLayer } from './AcTrLayer';
 import { AcTrLayerAppearanceController } from './AcTrLayerAppearanceController';
 import { AcTrLayout } from './AcTrLayout';
@@ -131,6 +132,7 @@ import { AcTrLayoutViewManager } from './AcTrLayoutViewManager';
 import { sortPickResults } from './AcTrPickResultUtil';
 import { AcTrProgressiveOpenFitController } from './AcTrProgressiveOpenFitController';
 import { AcTrScene } from './AcTrScene';
+import { AcTrWorkSlice } from './AcTrWorkSlice';
 import { shouldRegenDatabaseAfterFontLoad } from './fontLoadRegen';
 /**
  * Default view option values
@@ -269,6 +271,16 @@ var AcTrView2d = /** @class */ (function (_super) {
          * geometry paints incrementally while the open overlay is still visible.
          */
         _this._progressiveRendering = false;
+        /**
+         * When true, open-time convert includes off/frozen-layer entities so HTML
+         * export does not need a second convert pass for those entities.
+         */
+        _this._convertInvisibleLayers = false;
+        /**
+         * When false, {@link batchConvert} skips cooperative setTimeout yields.
+         * Headless CLI sets this false; interactive viewers leave it true.
+         */
+        _this._cooperativeYield = true;
         /**
          * Serial convert queue for progressive opens. Chunks from `entityAppended`
          * enqueue here and a single drain loop runs {@link batchConvert}, so scene
@@ -341,6 +353,21 @@ var AcTrView2d = /** @class */ (function (_super) {
                 _this._isDirty = true;
             }
         });
+        /**
+         * Promise that resolves when text-style fonts needed by deferred glyph jobs
+         * are ready. Shared so concurrent deferred jobs do not each await a long
+         * font preload.
+         */
+        _this._deferredFontsReady = null;
+        /** Convert-phase wall timers (ms) for OPENPERF diagnostics. */
+        _this._convertPhaseMs = {
+            finishGeometry: 0,
+            handleGroup: 0,
+            addEntity: 0,
+            awaitFonts: 0
+        };
+        /** Last text-style font preload plan (for OPENPERF). */
+        _this._fontPreloadDiag = null;
         _this.animate = function () {
             var _a;
             _this._rafId = requestAnimationFrame(_this.animate);
@@ -385,6 +412,9 @@ var AcTrView2d = /** @class */ (function (_super) {
         renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
         renderer.setSize(_this.width, _this.height);
         _this._renderer = new AcTrRenderer(renderer);
+        // Shared across all layer batched groups so later entities (e.g. wipeouts)
+        // occlude earlier linework via depth, matching AutoCAD draw order.
+        setAcTrDrawOrderZAllocator(function () { return _this._renderer.allocateDrawOrderZ(); });
         var fontMapping = AcApSettingManager.instance.fontMapping;
         _this._renderer.setFontMapping(fontMapping);
         _this._renderer.events.fontNotFound.addEventListener(function (args) {
@@ -691,6 +721,59 @@ var AcTrView2d = /** @class */ (function (_super) {
         _this.resetDeferredGeometryQueue();
         return _this;
     }
+    AcTrView2d.prototype.ensureDeferredFontsReady = function () {
+        var _this = this;
+        if (!this._deferredFontsReady) {
+            var t0_1 = performance.now();
+            // Preset (fallback) + STYLE-table faces must both be ready before glyph
+            // bake. Linework convert does not await this promise.
+            var ready = Promise.all([
+                this.awaitPresetFontsReadySafe(),
+                this.awaitTextStyleFontsReady()
+            ]).then(function () { return undefined; }, function () { return undefined; });
+            this._deferredFontsReady = ready.then(function () {
+                _this._convertPhaseMs.awaitFonts += performance.now() - t0_1;
+            });
+        }
+        return this._deferredFontsReady;
+    };
+    /**
+     * Awaits DocManager preset preload when the singleton exists.
+     * No-op in unit tests that construct a view without a manager.
+     */
+    AcTrView2d.prototype.awaitPresetFontsReadySafe = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var singleton;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        singleton = AcApDocManager;
+                        if (!singleton._instance) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, singleton._instance.awaitPresetFontsReady()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Returns and resets convert-phase wall timers collected during the last open.
+     */
+    AcTrView2d.prototype.takeConvertPhaseTimings = function () {
+        var snapshot = __assign(__assign({}, this._convertPhaseMs), { fontPreload: this._fontPreloadDiag
+                ? __assign({}, this._fontPreloadDiag) : undefined });
+        this._convertPhaseMs = {
+            finishGeometry: 0,
+            handleGroup: 0,
+            addEntity: 0,
+            awaitFonts: 0
+        };
+        this._fontPreloadDiag = null;
+        return snapshot;
+    };
     AcTrView2d.prototype.getPointerSelectionAction = function (e) {
         return resolvePointerSelectionAction(e);
     };
@@ -906,6 +989,32 @@ var AcTrView2d = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcTrView2d.prototype, "convertInvisibleLayers", {
+        /**
+         * When true, open-time convert includes off/frozen-layer entities.
+         */
+        get: function () {
+            return this._convertInvisibleLayers;
+        },
+        set: function (value) {
+            this._convertInvisibleLayers = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcTrView2d.prototype, "cooperativeYield", {
+        /**
+         * When false, entity convert skips cooperative yields (headless export).
+         */
+        get: function () {
+            return this._cooperativeYield;
+        },
+        set: function (value) {
+            this._cooperativeYield = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(AcTrView2d.prototype, "progressiveOpenStats", {
         /**
          * Open-convert counters for OPENPROF / palette (cooperative yields during
@@ -1042,6 +1151,9 @@ var AcTrView2d = /** @class */ (function (_super) {
         // Style-manager changeForeground only updates cache entries; batch
         // containers own private material clones and must be repainted too.
         this._scene.repaintForegroundMaterials(acgiForegroundColorForBackground(value));
+        // Wipeouts track the canvas background (isBackgroundFill); repaint their
+        // batch-owned clones the same way as ACI-7 foreground materials.
+        this._scene.repaintBackgroundMaterials(value);
         this.resyncForegroundLayersForBackground();
         if (this._readingMode.isEnabled) {
             this._readingMode.noteLayoutBackground(value);
@@ -1561,7 +1673,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                 _this.endProgressiveOpenFit();
                 return;
             }
-            _this._progressiveOpenFit.applyFinalFit(function () { return _this.resolveLayoutFitBox(); });
+            _this._progressiveOpenFit.applyFinalFit(function () { return _this.getDrawingExtents(); });
             _this.endProgressiveOpenFit();
             var originalBtrId = layoutBtrId !== null && layoutBtrId !== void 0 ? layoutBtrId : _this.activeLayoutBtrId;
             if (originalBtrId) {
@@ -1593,27 +1705,87 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.zoomToSmartExtents = function (timeout) {
         var _this = this;
         if (timeout === void 0) { timeout = 0; }
-        var waiter = new AcEdConditionWaiter(function () { return !_this.isProcessingEntities; }, function () {
-            var smart = _this.resolveSmartFitBox();
-            if (smart) {
-                _this.zoomTo(smart);
-                _this._isDirty = true;
-                _this.endProgressiveOpenFit();
-                return;
-            }
-            _this._progressiveOpenFit.applyFinalFit(function () { return _this.resolveLayoutFitBox(); });
-            _this.endProgressiveOpenFit();
-        }, 300, timeout);
-        waiter.start();
+        return new Promise(function (resolve, reject) {
+            var waiter = new AcEdConditionWaiter(function () { return !_this.isProcessingEntities; }, function () {
+                void (function () { return __awaiter(_this, void 0, void 0, function () {
+                    var smart, error_2;
+                    var _this = this;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, this.resolveSmartFitBox()];
+                            case 1:
+                                smart = _a.sent();
+                                if (smart) {
+                                    this.zoomTo(smart);
+                                    this._isDirty = true;
+                                    this.endProgressiveOpenFit();
+                                    resolve();
+                                    return [2 /*return*/];
+                                }
+                                this._progressiveOpenFit.applyFinalFit(function () {
+                                    return _this.getDrawingExtents();
+                                });
+                                this.endProgressiveOpenFit();
+                                resolve();
+                                return [3 /*break*/, 3];
+                            case 2:
+                                error_2 = _a.sent();
+                                // Always clear progressive-open framing so a failed smart fit
+                                // cannot leave the open-fit overlay/state stuck indefinitely.
+                                this.endProgressiveOpenFit();
+                                reject(error_2);
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); })();
+            }, 300, timeout);
+            waiter.start();
+        });
     };
     /**
      * Resolves intelligent zoom extents from spatial-index entity boxes.
+     * Reuses the layout cache until entity geometry extents are invalidated.
+     * Collects and clusters cooperatively so the UI thread stays responsive.
      */
     AcTrView2d.prototype.resolveSmartFitBox = function () {
-        var activeLayout = this._scene.activeLayout;
-        if (!activeLayout)
-            return undefined;
-        return computeIntelligentExtents(activeLayout.collectSpatialExtentBoxes());
+        return __awaiter(this, void 0, void 0, function () {
+            var activeLayout, cached, generation, work, entries, smart;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        activeLayout = this._scene.activeLayout;
+                        if (!activeLayout)
+                            return [2 /*return*/, undefined];
+                        cached = activeLayout.cachedSmartExtents;
+                        if (cached) {
+                            return [2 /*return*/, cached];
+                        }
+                        generation = activeLayout.smartExtentsGeneration;
+                        work = new AcTrWorkSlice();
+                        return [4 /*yield*/, activeLayout.collectSpatialExtentBoxesAsync(work)];
+                    case 1:
+                        entries = _a.sent();
+                        return [4 /*yield*/, computeIntelligentExtentsAsync(entries, work)
+                            // Geometry changed while we yielded: discard this result (a newer cache
+                            // may already exist; otherwise the caller falls back to drawing extents).
+                        ];
+                    case 2:
+                        smart = _a.sent();
+                        // Geometry changed while we yielded: discard this result (a newer cache
+                        // may already exist; otherwise the caller falls back to drawing extents).
+                        if (activeLayout.smartExtentsGeneration !== generation) {
+                            return [2 /*return*/, activeLayout.cachedSmartExtents];
+                        }
+                        if (smart) {
+                            activeLayout.cachedSmartExtents = smart;
+                        }
+                        return [2 /*return*/, smart];
+                }
+            });
+        });
     };
     /**
      * @inheritdoc
@@ -1667,7 +1839,9 @@ var AcTrView2d = /** @class */ (function (_super) {
                 return entity;
             return undefined;
         }
-        if (entity instanceof AcDbAttribute) {
+        if (entity instanceof AcDbAttribute ||
+            entity.type === 'Attrib' ||
+            entity.type === 'Attribute') {
             var owner = AcApDocManager.instance.curDocument.database.tables.blockTable.getEntityById(entity.ownerId);
             if (owner instanceof AcDbBlockReference &&
                 owner.attributeIterator().count > 0) {
@@ -2344,10 +2518,14 @@ var AcTrView2d = /** @class */ (function (_super) {
         this._externallyFramedLayouts.add(layoutBtrId);
     };
     /**
-     * Resolves the 2D box to frame for the active layout once entities are
-     * converted. Uses {@link AcTrScene.box}, which is derived from batch geometry.
+     * Returns the 2D box of drawable geometry in the active layout.
+     *
+     * Uses {@link AcTrScene.box}, which is derived from batch geometry — not
+     * database header `EXTMIN`/`EXTMAX`, which are often stale on real DWGs.
+     *
+     * @inheritdoc
      */
-    AcTrView2d.prototype.resolveLayoutFitBox = function () {
+    AcTrView2d.prototype.getDrawingExtents = function () {
         var sceneBox = this._scene.box;
         if (sceneBox && !sceneBox.isEmpty()) {
             return AcTrGeometryUtil.threeBox3dToGeBox2d(sceneBox);
@@ -2375,7 +2553,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      *    populated. Many parsers leave this empty (we've seen `(0,0)-(0,0)`),
      *    so it sits below the viewport-based heuristic.
      *
-     * 4. **`resolveLayoutFitBox`** (entity extents from batch geometry) —
+     * 4. **`getDrawingExtents`** (entity extents from batch geometry) —
      *    last-resort fallback for layouts with no viewports and no
      *    sensible limits/extents (e.g. a freshly created empty paper).
      *    Vulnerable to scale-mismatch outliers, but better than no zoom.
@@ -2421,7 +2599,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                 _this.zoomTo(new AcGeBox2d({ x: extents.min.x, y: extents.min.y }, { x: extents.max.x, y: extents.max.y }));
             }
             else {
-                var box = _this.resolveLayoutFitBox();
+                var box = _this.getDrawingExtents();
                 if (box) {
                     _this.zoomTo(box);
                 }
@@ -2447,12 +2625,15 @@ var AcTrView2d = /** @class */ (function (_super) {
         this.resetDeferredGeometryQueue();
         this._entityProcessingIdleAt = 0;
         this._scene.clear();
+        this._renderer.resetDrawOrderZ();
         this._isDirty = true;
         this._missedImages.clear();
         this._initializedLayouts.clear();
         this._externallyFramedLayouts.clear();
         this._loadingLayouts.clear();
         this._renderer.dispose();
+        // Drop block templates when the scene is torn down (next open / close).
+        AcDbRenderingCache.instance.clear();
         eventBus.emit('missed-data-changed', {});
     };
     /**
@@ -2995,44 +3176,71 @@ var AcTrView2d = /** @class */ (function (_super) {
      *
      * 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.
+     * finalize awaits {@link awaitTextStyleFontsReady} (and the open-start
+     * preset gate) instead.
+     *
+     * Drawing-independent preset faces are loaded separately via
+     * {@link AcApDocManager.ensurePresetFontsForOpen} at open start.
      *
      * @param database - Database whose text style table has just been filled.
      */
     AcTrView2d.prototype.startTextStyleFontPreload = function (database) {
-        var _a;
+        var _a, _b;
         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) {
-            names = [];
-        }
-        // Style fonts alone are not enough: awaitFontsBeforeDraw only *awaits*
-        // content/style faces and kicks default/symbol fallbacks in the background.
-        // Drawings with empty primary font files (font falls back to the STYLE name)
-        // need those fallbacks loaded before the first glyph bake, otherwise Latin
-        // (and often all) text is permanently baked as '?'.
+        // Worker mode: do not parse STYLE faces on the main thread (would dual-
+        // parse mesh with workers). Each worker draw awaits its own content/style
+        // faces via awaitFontsBeforeDraw. Preset fallbacks are gated separately
+        // by ensurePresetFontsForOpen (scope: all).
+        //
+        // Main mode: gate deferred glyph jobs on style-table faces only. Unused
+        // preset faces were already started at open — do not re-request here.
+        var styleFonts = collectTextStyleFontNames(database);
         var fallbackFonts = FontManager.instance.getFontsToLoad();
-        var preloadNames = __spreadArray([], __read(new Set(__spreadArray(__spreadArray([], __read(names), false), __read(fallbackFonts), false))), false);
-        if (preloadNames.length === 0) {
+        var firstDefault = __spreadArray([], __read(FontManager.instance.defaultFonts), false)[0];
+        var plan = planTextStyleFontPreload(styleFonts, fallbackFonts, {
+            firstDefaultFont: firstDefault
+        });
+        var mtextRenderer = AcTrMTextRenderer.getInstance();
+        var parseSite = mtextRenderer.getRenderMode() === 'worker' ? 'worker' : 'main';
+        var singleton = AcApDocManager;
+        var preset = ((_b = (_a = singleton._instance) === null || _a === void 0 ? void 0 : _a.lastPresetFontsForOpen) === null || _b === void 0 ? void 0 : _b.length)
+            ? __spreadArray([], __read(singleton._instance.lastPresetFontsForOpen), false) : __spreadArray([], __read(fallbackFonts), false);
+        this._fontPreloadDiag = {
+            critical: __spreadArray([], __read(plan.critical), false),
+            workerWarm: [],
+            background: [],
+            preset: preset,
+            workerSkipped: 0,
+            parseSite: parseSite
+        };
+        if (parseSite === 'worker') {
             this._textStyleFontPreloadPromise = Promise.resolve();
             return;
         }
-        var mtextRenderer = AcTrMTextRenderer.getInstance();
-        this._textStyleFontPreloadPromise = Promise.all([
-            FontManager.instance.requestFonts(preloadNames),
-            // Worker isolates have their own FontManager; main-thread requestFonts
-            // alone does not populate them before asyncRenderMText.
-            mtextRenderer.loadFonts(fallbackFonts)
-        ]).then(function () { }, function () {
-            // Glyph draw still falls back via FontManager defaults / '?'.
+        // Same deadline as AcApDocManager.installFontFileLoadTimeout.
+        var preloadTimeoutMs = 30000;
+        if (plan.critical.length === 0) {
+            this._textStyleFontPreloadPromise = Promise.resolve();
+            return;
+        }
+        var preload = FontManager.instance.requestFonts(plan.critical);
+        this._textStyleFontPreloadPromise = new Promise(function (resolve) {
+            var timer = setTimeout(function () {
+                // Glyph draw still falls back via FontManager defaults / '?'.
+                resolve();
+            }, preloadTimeoutMs);
+            preload.then(function () {
+                clearTimeout(timer);
+                resolve();
+            }, function () {
+                clearTimeout(timer);
+                resolve();
+            });
         });
     };
     /**
@@ -3072,45 +3280,54 @@ var AcTrView2d = /** @class */ (function (_super) {
      */
     AcTrView2d.prototype.finishEntityGeometry = function (threeEntity, _progressive) {
         return __awaiter(this, void 0, void 0, function () {
-            var needsGlyphDraw;
+            var t0, isGroup, groupPending, needsGlyphDraw;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        needsGlyphDraw = (threeEntity instanceof AcTrGroup &&
-                            this.groupHasPendingGlyphGeometry(threeEntity)) ||
+                        t0 = performance.now();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 9, 10]);
+                        isGroup = threeEntity instanceof AcTrGroup;
+                        groupPending = isGroup && this.groupHasPendingGlyphGeometry(threeEntity);
+                        needsGlyphDraw = groupPending ||
                             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;
+                        if (!needsGlyphDraw) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.ensureDeferredFontsReady()];
                     case 2:
-                        if (!(threeEntity instanceof AcTrGroup)) return [3 /*break*/, 4];
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        if (!isGroup) return [3 /*break*/, 5];
                         // Linework-only INSERTs (no empty glyph shells) skip asyncDraw; spatial
                         // boxes are refreshed by syncGroupSpatialBoundsForIndexing after commit.
-                        if (!this.groupHasPendingGlyphGeometry(threeEntity)) {
+                        if (!groupPending) {
                             return [2 /*return*/];
                         }
                         return [4 /*yield*/, threeEntity.asyncDraw()];
-                    case 3:
+                    case 4:
                         _a.sent();
                         return [2 /*return*/];
-                    case 4:
-                        if (!hasPendingComplexLineTypeGlyphs(threeEntity)) return [3 /*break*/, 6];
-                        return [4 /*yield*/, threeEntity.asyncDraw()];
                     case 5:
+                        if (!hasPendingComplexLineTypeGlyphs(threeEntity)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, threeEntity.asyncDraw()];
+                    case 6:
                         _a.sent();
                         return [2 /*return*/];
-                    case 6:
+                    case 7:
                         if (threeEntity.hasDrawableGeometry()) {
                             return [2 /*return*/];
                         }
                         return [4 /*yield*/, threeEntity.asyncDraw()];
-                    case 7:
+                    case 8:
                         _a.sent();
-                        return [2 /*return*/];
+                        return [3 /*break*/, 10];
+                    case 9:
+                        this._convertPhaseMs.finishGeometry += performance.now() - t0;
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/];
                 }
             });
         });
@@ -3269,13 +3486,73 @@ var AcTrView2d = /** @class */ (function (_super) {
         });
     };
     AcTrView2d.prototype.groupHasPendingGlyphGeometry = function (group) {
-        var pending = false;
-        group.traverse(function (child) {
-            if (child instanceof AcTrGlyphEntity && !child.hasDrawableGeometry()) {
-                pending = true;
+        var e_14, _a;
+        try {
+            // Prefer O(block-def shells). A full THREE.traverse over a mega-block
+            // (100k+ flattened mesh leaves) was dominating scene-convert wall time.
+            for (var _b = __values(group.getSourceEntities()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entity = _c.value;
+                if (entity instanceof AcTrGlyphEntity && !entity.hasDrawableGeometry()) {
+                    return true;
+                }
             }
-        });
-        return pending;
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+        return AcTrView2d.directChildrenHavePendingGlyphs(group);
+    };
+    /**
+     * Walks only {@link AcTrEntity} containers for empty glyph shells.
+     *
+     * Skips raw mesh/line leaves under a flattened {@link AcTrGroup} so checking
+     * a whole-floor INSERT is O(glyph shells), not O(all drawable leaves).
+     */
+    AcTrView2d.directChildrenHavePendingGlyphs = function (root) {
+        var e_15, _a;
+        var children = root.children;
+        for (var i = 0; i < children.length; i++) {
+            var child = children[i];
+            if (child instanceof AcTrGlyphEntity) {
+                if (!child.hasDrawableGeometry()) {
+                    return true;
+                }
+                continue;
+            }
+            if (child instanceof AcTrGroup) {
+                try {
+                    for (var _b = (e_15 = void 0, __values(child.getSourceEntities())), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var entity = _c.value;
+                        if (entity instanceof AcTrGlyphEntity &&
+                            !entity.hasDrawableGeometry()) {
+                            return true;
+                        }
+                    }
+                }
+                catch (e_15_1) { e_15 = { error: e_15_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_15) throw e_15.error; }
+                }
+                if (AcTrView2d.directChildrenHavePendingGlyphs(child)) {
+                    return true;
+                }
+                continue;
+            }
+            if (child instanceof AcTrEntity) {
+                // Nested non-group entity that may still host deferred glyph children.
+                if (AcTrView2d.directChildrenHavePendingGlyphs(child)) {
+                    return true;
+                }
+            }
+        }
+        return false;
     };
     /**
      * Runs glyph/group geometry finalize off the main convert loop so other
@@ -3345,6 +3622,8 @@ var AcTrView2d = /** @class */ (function (_super) {
         this._pendingGeometryJobs = 0;
         this._textStyleFontPreloadPromise = null;
         this._textStyleFontPreloadEpoch = -1;
+        this._deferredFontsReady = null;
+        this._fontPreloadDiag = null;
     };
     /**
      * Waits until side-pool glyph/group jobs for the current convert epoch finish.
@@ -3388,7 +3667,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * paper layouts.
      */
     AcTrView2d.prototype.ensureViewportViews = function (blockTableRecord, layoutView) {
-        var e_14, _a;
+        var e_16, _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()) {
@@ -3401,12 +3680,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 layoutView.addViewport(viewportView);
             }
         }
-        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
         finally {
             try {
                 if (iterator_2_1 && !iterator_2_1.done && (_a = iterator_2.return)) _a.call(iterator_2);
             }
-            finally { if (e_14) throw e_14.error; }
+            finally { if (e_16) throw e_16.error; }
         }
     };
     /**
@@ -3434,14 +3713,14 @@ var AcTrView2d = /** @class */ (function (_super) {
                             }
                         }
                         progressive = this._progressiveRendering && !options.forExport;
-                        yieldGate = options.forExport
+                        yieldGate = options.forExport || !this._cooperativeYield
                             ? undefined
                             : new AcCmUiYieldGate(AcTrView2d.OPEN_CONVERT_YIELD_BUDGET_MS);
                         yieldToEventLoop = function () {
                             return new Promise(function (resolve) { return setTimeout(resolve, 0); });
                         };
                         _loop_4 = function (i) {
-                            var entity, shouldConvert, objectId_1, convertGen_1, directMeta, added, superseded, threeEntity_1, isMultiLayerGroup, deferGeometry, isExtendBbox_1, commitEntity, layoutView, viewportView, fileName, error_2, didYield;
+                            var entity, shouldConvert, objectId_1, convertGen_1, directMeta, added, superseded, threeEntity_1, isMultiLayerGroup, deferGeometry, isExtendBbox_1, commitEntity, layoutView, viewportView, fileName, error_3, didYield;
                             return __generator(this, function (_e) {
                                 switch (_e.label) {
                                     case 0:
@@ -3468,7 +3747,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                                             AcTrViewportView.isDefaultPaperSpaceViewport(entity)) {
                                             return [2 /*return*/, "continue"];
                                         }
-                                        shouldConvert = options.forExport
+                                        shouldConvert = options.forExport || this_3._convertInvisibleLayers
                                             ? this_3._entityDisplay.shouldConvertForExport(entity)
                                             : this_3._entityDisplay.shouldConvert(entity);
                                         if (!shouldConvert) {
@@ -3502,7 +3781,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                                                         this_3.applySessionHiddenObjectState(entity.objectId);
                                                         if (progressive) {
                                                             this_3.markProgressiveDirty();
-                                                            this_3._progressiveOpenFit.afterGeometryBatch(function () { return _this.resolveLayoutFitBox(); }, i);
+                                                            this_3._progressiveOpenFit.afterGeometryBatch(function () { return _this.getDrawingExtents(); }, i);
                                                         }
                                                     }
                                                 }
@@ -3550,6 +3829,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                                     case 5:
                                         isExtendBbox_1 = !(entity instanceof AcDbRay || entity instanceof AcDbXline);
                                         commitEntity = function () { return __awaiter(_this, void 0, void 0, function () {
+                                            var tAdd;
                                             var _this = this;
                                             var _a;
                                             return __generator(this, function (_b) {
@@ -3573,13 +3853,15 @@ var AcTrView2d = /** @class */ (function (_super) {
                                                                 this._inheritedLayerMaterialMapper.remap(threeEntity_1.children, '0', threeEntity_1.layerName);
                                                             }
                                                         }
+                                                        tAdd = performance.now();
                                                         this._scene.addEntity(threeEntity_1, isExtendBbox_1);
+                                                        this._convertPhaseMs.addEntity += performance.now() - tAdd;
                                                         this.applySessionHiddenObjectState(entity.objectId);
                                                         // Release memory occupied by this entity
                                                         threeEntity_1.dispose();
                                                         if (progressive) {
                                                             this.markProgressiveDirty();
-                                                            this._progressiveOpenFit.afterGeometryBatch(function () { return _this.resolveLayoutFitBox(); }, i);
+                                                            this._progressiveOpenFit.afterGeometryBatch(function () { return _this.getDrawingExtents(); }, i);
                                                         }
                                                         return [2 /*return*/];
                                                 }
@@ -3621,8 +3903,8 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         }
                                         return [3 /*break*/, 11];
                                     case 9:
-                                        error_2 = _e.sent();
-                                        log.error("[AcTrView2d] Failed to convert entity ".concat(entity.objectId, " (").concat(entity.type, "):"), error_2);
+                                        error_3 = _e.sent();
+                                        log.error("[AcTrView2d] Failed to convert entity ".concat(entity.objectId, " (").concat(entity.type, "):"), error_3);
                                         return [3 /*break*/, 11];
                                     case 10:
                                         // Counter was reset in clear() when the epoch advanced; do not
@@ -3686,16 +3968,21 @@ var AcTrView2d = /** @class */ (function (_super) {
     };
     AcTrView2d.prototype.handleGroup = function (group_1, progressive_1) {
         return __awaiter(this, arguments, void 0, function (group, progressive, epoch, convertGen) {
-            var objectId, children, objectsGroupByLayer, children_1, children_1_1, child, renderContext, groupObjectId, groupLayerName, groupChildBoxes, aggregateSpatialBbox, registeredChildIndex;
-            var e_15, _a;
+            var t0, objectId, children, objectsGroupByLayer_1, children_1, children_1_1, child, renderContext_1, groupObjectId_1, groupLayerName_1, groupChildBoxes_1, aggregateSpatialBbox_1, registeredChildIndex_1;
+            var e_17, _a;
             var _this = this;
             var _b, _c;
             if (epoch === void 0) { epoch = this._convertEpoch; }
             if (convertGen === void 0) { convertGen = 0; }
             return __generator(this, function (_d) {
                 switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.finishEntityGeometry(group, progressive)];
+                    case 0:
+                        t0 = performance.now();
+                        _d.label = 1;
                     case 1:
+                        _d.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, this.finishEntityGeometry(group, progressive)];
+                    case 2:
                         _d.sent();
                         if (epoch !== this._convertEpoch) {
                             group.dispose();
@@ -3709,17 +3996,17 @@ var AcTrView2d = /** @class */ (function (_super) {
                         }
                         this.syncGroupSpatialBoundsForIndexing(group);
                         children = group.children;
-                        objectsGroupByLayer = new Map();
+                        objectsGroupByLayer_1 = new Map();
                         children.forEach(function (child) {
                             var _a;
                             if (child.visible === false) {
                                 return;
                             }
                             var layerName = child.userData.layerName;
-                            if (!objectsGroupByLayer.has(layerName)) {
-                                objectsGroupByLayer.set(layerName, []);
+                            if (!objectsGroupByLayer_1.has(layerName)) {
+                                objectsGroupByLayer_1.set(layerName, []);
                             }
-                            (_a = objectsGroupByLayer.get(layerName)) === null || _a === void 0 ? void 0 : _a.push(child);
+                            (_a = objectsGroupByLayer_1.get(layerName)) === null || _a === void 0 ? void 0 : _a.push(child);
                         });
                         // Important:
                         // Sometimes one group may contain huge amount of objects (> 100,000). So it is important
@@ -3737,40 +4024,40 @@ var AcTrView2d = /** @class */ (function (_super) {
                                 child.parent = null;
                             }
                         }
-                        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+                        catch (e_17_1) { e_17 = { error: e_17_1 }; }
                         finally {
                             try {
                                 if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
                             }
-                            finally { if (e_15) throw e_15.error; }
+                            finally { if (e_17) throw e_17.error; }
                         }
-                        renderContext = group.renderContext;
-                        groupObjectId = group.objectId;
-                        groupLayerName = group.layerName;
+                        renderContext_1 = group.renderContext;
+                        groupObjectId_1 = group.objectId;
+                        groupLayerName_1 = group.layerName;
                         // AcDbRenderingCache.draw (and similar paths such as AcDbTable) already call
                         // applyMatrix on the group, which updates wcsBbbox and wcsChildBoxes to WCS.
                         // Do not multiply group.matrix here — that would double-transform spatial bounds.
                         if (process.env.NODE_ENV !== 'production') {
                             assertAcTrGroupWcsBboxesConsistent(group);
                         }
-                        groupChildBoxes = group.wcsChildBoxes.map(function (box) { return ({
+                        groupChildBoxes_1 = group.wcsChildBoxes.map(function (box) { return ({
                             minX: box.minX,
                             minY: box.minY,
                             maxX: box.maxX,
                             maxY: box.maxY,
                             id: box.id
                         }); });
-                        aggregateSpatialBbox = groupChildBoxes.length > 0
+                        aggregateSpatialBbox_1 = groupChildBoxes_1.length > 0
                             ? unionGroupWcsChildBoxes(group)
                             : group.wcsBbox.clone();
-                        if (groupChildBoxes.length > 0) {
-                            group.wcsBbox = aggregateSpatialBbox.clone();
+                        if (groupChildBoxes_1.length > 0) {
+                            group.wcsBbox = aggregateSpatialBbox_1.clone();
                         }
-                        registeredChildIndex = false;
-                        objectsGroupByLayer.forEach(function (objects, layerName) {
+                        registeredChildIndex_1 = false;
+                        objectsGroupByLayer_1.forEach(function (objects, layerName) {
                             // Nested layer-0 may already be resolved to an inner INSERT layer during
                             // flatten. Remaining "0" buckets inherit this (outermost) INSERT layer.
-                            var effectiveLayerName = layerName === '0' ? groupLayerName : layerName;
+                            var effectiveLayerName = layerName === '0' ? groupLayerName_1 : layerName;
                             // Material remap must still treat authored layer-0 drawables as layer-0
                             // ByLayer even when nest resolution already rewrote layerName.
                             var sourceLayerForMaterials = objects.some(function (object) {
@@ -3788,23 +4075,23 @@ var AcTrView2d = /** @class */ (function (_super) {
                             // render entity per layer bucket but preserve the INSERT object id for all
                             // buckets, so selection/highlight still maps back to the same database object.
                             // Within each layer bucket, the object id remains unique in scene indexing.
-                            var entity = new AcTrEntity(renderContext);
+                            var entity = new AcTrEntity(renderContext_1);
                             // Copy the INSERT matrix exactly — applyMatrix4 decomposes and drops
                             // reflections from mirrored block scales.
                             entity.matrix.copy(group.matrix);
                             entity.matrixAutoUpdate = false;
                             entity.matrixWorldNeedsUpdate = true;
-                            entity.objectId = groupObjectId;
+                            entity.objectId = groupObjectId_1;
                             entity.ownerId = group.ownerId;
                             // If block-definition entities are on layer "0", this bucket now uses the layer
                             // of the block reference itself (effectiveLayerName).
                             entity.layerName = effectiveLayerName;
-                            entity.userData.insertLayerName = groupLayerName;
-                            entity.wcsBbox = aggregateSpatialBbox.clone();
+                            entity.userData.insertLayerName = groupLayerName_1;
+                            entity.wcsBbox = aggregateSpatialBbox_1.clone();
                             var entityUserData = entity.userData;
-                            if (!registeredChildIndex && groupChildBoxes.length > 0) {
-                                entityUserData.spatialIndexChildBoxes = groupChildBoxes;
-                                registeredChildIndex = true;
+                            if (!registeredChildIndex_1 && groupChildBoxes_1.length > 0) {
+                                entityUserData.spatialIndexChildBoxes = groupChildBoxes_1;
+                                registeredChildIndex_1 = true;
                             }
                             // Important:
                             // DO NOT USE spread operator when adding objects because it may be one very large array
@@ -3814,18 +4101,24 @@ var AcTrView2d = /** @class */ (function (_super) {
                             }
                             entity.updateMatrixWorld(true);
                             _this._layerAppearance.refreshTextMaterialsInObjectTree(entity);
+                            var tAdd = performance.now();
                             _this._scene.addEntity(entity, true);
-                            _this.applySessionHiddenObjectState(groupObjectId);
+                            _this._convertPhaseMs.addEntity += performance.now() - tAdd;
+                            _this.applySessionHiddenObjectState(groupObjectId_1);
                             entity.dispose();
                         });
                         group.dispose();
                         if (progressive) {
                             this.markProgressiveDirty();
                             this._progressiveOpenFit.afterGeometryBatch(function () {
-                                return _this.resolveLayoutFitBox();
+                                return _this.getDrawingExtents();
                             });
                         }
-                        return [2 /*return*/];
+                        return [3 /*break*/, 4];
+                    case 3:
+                        this._convertPhaseMs.handleGroup += performance.now() - t0;
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
                 }
             });
         });
@@ -3855,7 +4148,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         if (!this._openLineworkFramePending || this.isConvertingEntities) {
             return;
         }
-        var box = this.resolveLayoutFitBox();
+        var box = this.getDrawingExtents();
         if (!box || box.isEmpty()) {
             this._openLineworkFramePending = false;
             return;
@@ -3872,6 +4165,11 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.stampEntityProcessingIdle = function () {
         if (this._numOfEntitiesToProcess === 0 && this._pendingGeometryJobs === 0) {
             this._entityProcessingIdleAt = performance.now();
+            // Release block templates after INSERT convert/glyph work finishes.
+            // Clearing at converter END was too early (convert still draining);
+            // keeping templates until the next open kept baked shells in memory and
+            // OOMed large drawings.
+            AcDbRenderingCache.instance.clear();
         }
     };
     /**