@mlightcad/cad-simple-viewer 1.7.1 → 1.7.3

package/lib/view/AcTrView2d.js

@@ -99,7 +99,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 import { AcCmUiYieldGate, AcDbAttribute, AcDbBlockReference, acdbHostApplicationServices, AcDbMText, AcDbRasterImage, AcDbRay, AcDbSysVarManager, AcDbViewport, AcDbXline, AcGeBox2d, AcGePoint2d, acgiForegroundColorForBackground, log } from '@mlightcad/data-model';
 import { AcDbSystemVariables } from '@mlightcad/data-model';
 import { FontManager } from '@mlightcad/mtext-renderer';
-import { AcTrEntity, AcTrGlyphEntity, AcTrGroup, AcTrRenderer, AcTrViewportView } from '@mlightcad/three-renderer';
+import { AcTrEntity, AcTrGlyphEntity, AcTrGroup, AcTrMTextRenderer, 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';
@@ -122,6 +122,7 @@ import { shouldExtendBboxForDirectEntity, tryBuildDirectEntityMeta } from './AcT
 import { AcTrEntityDisplayController } from './AcTrEntityDisplayController';
 import { assertAcTrGroupWcsBboxesConsistent, unionGroupWcsChildBoxes } from './AcTrGroupWcsBboxAssert';
 import { AcTrInheritedLayerMaterialMapper } from './AcTrInheritedLayerMaterialMapper';
+import { computeIntelligentExtents } from './AcTrIntelligentExtents';
 import { AcTrLayer } from './AcTrLayer';
 import { AcTrLayerAppearanceController } from './AcTrLayerAppearanceController';
 import { AcTrLayout } from './AcTrLayout';
@@ -130,6 +131,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
  */
@@ -247,6 +249,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.
@@ -273,6 +290,13 @@ var AcTrView2d = /** @class */ (function (_super) {
         _this._progressivePaintCount = 0;
         /** Cooperative yields taken inside progressive {@link batchConvert}. */
         _this._progressiveYieldCount = 0;
+        /**
+         * 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.
@@ -292,6 +316,22 @@ var AcTrView2d = /** @class */ (function (_super) {
          */
         _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; },
@@ -784,10 +824,13 @@ var AcTrView2d = /** @class */ (function (_super) {
          * fully drawable scene (export, scripted zoom) should wait on this (as
          * {@link waitUntilIdle} / {@link zoomToFitDrawing} do).
          *
-         * The open-file progress overlay intentionally uses
-         * {@link isConvertingEntities} instead so "Rendering drawing ..." can hide
-         * once linework convert finishes while text geometry continues in the
-         * deferred pool.
+         * 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;
@@ -1182,13 +1225,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];
@@ -1468,6 +1514,40 @@ var AcTrView2d = /** @class */ (function (_super) {
             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
      */
@@ -1507,6 +1587,34 @@ var AcTrView2d = /** @class */ (function (_super) {
         }
         return false;
     };
+    /**
+     * @inheritdoc
+     */
+    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();
+    };
+    /**
+     * Resolves intelligent zoom extents from spatial-index entity boxes.
+     */
+    AcTrView2d.prototype.resolveSmartFitBox = function () {
+        var activeLayout = this._scene.activeLayout;
+        if (!activeLayout)
+            return undefined;
+        return computeIntelligentExtents(activeLayout.collectSpatialExtentBoxes());
+    };
     /**
      * @inheritdoc
      */
@@ -2031,7 +2139,28 @@ var AcTrView2d = /** @class */ (function (_super) {
      */
     AcTrView2d.prototype.addEntity = function (entity) {
         var _a;
+        var _b;
         var entities = Array.isArray(entity) ? entity : [entity];
+        // 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
@@ -2102,6 +2231,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;
@@ -2110,6 +2240,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);
             }
@@ -2129,6 +2270,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                             this.highlight(selectedIds);
                         }
                         this._gripManager.refresh();
+                        this._isDirty = true;
                         return [2 /*return*/];
                 }
             });
@@ -2299,7 +2441,11 @@ var AcTrView2d = /** @class */ (function (_super) {
         this.clearFontLoadedRedrawTimer();
         this._convertQueue.length = 0;
         this._numOfEntitiesToProcess = 0;
+        this._claimedConvertObjectIds.clear();
+        this._entityConvertGeneration.clear();
+        this.cancelOpenLineworkFrame();
         this.resetDeferredGeometryQueue();
+        this._entityProcessingIdleAt = 0;
         this._scene.clear();
         this._isDirty = true;
         this._missedImages.clear();
@@ -2335,9 +2481,13 @@ var AcTrView2d = /** @class */ (function (_super) {
         var _a;
         this._convertEpoch++;
         this.clearFontLoadedRedrawTimer();
+        this.cancelOpenLineworkFrame();
         this._convertQueue.length = 0;
         this._numOfEntitiesToProcess = 0;
+        this._claimedConvertObjectIds.clear();
+        this._entityConvertGeneration.clear();
         this.resetDeferredGeometryQueue();
+        this._entityProcessingIdleAt = 0;
         this._scene = state.scene;
         this._layoutViewManager = state.layoutViewManager;
         this._initializedLayouts = state.initializedLayouts;
@@ -2363,9 +2513,13 @@ var AcTrView2d = /** @class */ (function (_super) {
         var parked = this.captureSessionState();
         this._convertEpoch++;
         this.clearFontLoadedRedrawTimer();
+        this.cancelOpenLineworkFrame();
         this._convertQueue.length = 0;
         this._numOfEntitiesToProcess = 0;
+        this._claimedConvertObjectIds.clear();
+        this._entityConvertGeneration.clear();
         this.resetDeferredGeometryQueue();
+        this._entityProcessingIdleAt = 0;
         this._scene = this.createScene();
         this._layoutViewManager = new AcTrLayoutViewManager();
         this._initializedLayouts = new Set();
@@ -2533,6 +2687,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         (_a = this._disposeCanvasTouchCallout) === null || _a === void 0 ? void 0 : _a.call(this);
         this._disposeCanvasTouchCallout = undefined;
         this.clearFontLoadedRedrawTimer();
+        this.cancelOpenLineworkFrame();
         this.stopAnimationLoop();
     };
     /**
@@ -2637,6 +2792,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)) {
@@ -2680,6 +2844,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;
@@ -2821,34 +2990,125 @@ 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) {
+            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 '?'.
+        var fallbackFonts = FontManager.instance.getFontsToLoad();
+        var preloadNames = __spreadArray([], __read(new Set(__spreadArray(__spreadArray([], __read(names), false), __read(fallbackFonts), false))), false);
+        if (preloadNames.length === 0) {
+            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 / '?'.
+        });
+    };
+    /**
+     * 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];
+                        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*/];
                 }
@@ -2864,7 +3124,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         if (threeEntity instanceof AcTrGroup) {
             return this.groupHasPendingGlyphGeometry(threeEntity);
         }
-        return false;
+        return hasPendingComplexLineTypeGlyphs(threeEntity);
     };
     AcTrView2d.prototype.clearFontLoadedRedrawTimer = function () {
         if (this._fontLoadedRedrawTimer != null) {
@@ -2892,12 +3152,15 @@ var AcTrView2d = /** @class */ (function (_super) {
      *
      * Live {@link AcTrGlyphEntity} shells (rare: mid-convert / not yet batched)
      * are re-drawn in place. Committed text is already flattened into batches and
-     * disposed, so on-demand faces (style `malgun` → Noto Sans KR) need a database
-     * regen once conversion is idle — otherwise Hangul stays baked as '?'.
+     * 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, db;
+            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) {
@@ -2964,8 +3227,10 @@ var AcTrView2d = /** @class */ (function (_super) {
                             }
                             return [2 /*return*/];
                         }
-                        // Default preset loads during open are covered by awaitFontsBeforeDraw;
-                        // regenerating for those would thrash after every open.
+                        // 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();
@@ -2976,8 +3241,21 @@ var AcTrView2d = /** @class */ (function (_super) {
                             }
                         }
                         if (epoch !== this._convertEpoch ||
-                            redrawEpoch !== this._fontLoadedRedrawEpoch ||
-                            this.isProcessingEntities) {
+                            redrawEpoch !== this._fontLoadedRedrawEpoch) {
+                            return [2 /*return*/];
+                        }
+                        // Font load before the first convert idle (empty scene, ENTITY stream not
+                        // started yet). Glyph jobs await that font. regen() here replays the
+                        // in-flight database: measured as thousands of duplicate convert claims
+                        // and a ~1GB heap spike at the start of open.
+                        if (this._entityProcessingIdleAt <= 0) {
+                            return [2 /*return*/];
+                        }
+                        msSinceIdle = performance.now() - this._entityProcessingIdleAt;
+                        // 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;
@@ -3047,13 +3325,13 @@ var AcTrView2d = /** @class */ (function (_super) {
                     if (_this._pendingGeometryJobs === 0) {
                         _this._isDirty = true;
                     }
+                    _this.stampEntityProcessingIdle();
                 }
                 _this.pumpDeferredGeometryQueue();
             });
         };
         var this_2 = this;
-        while (this._deferredGeometryActive <
-            AcTrView2d.DEFERRED_GEOMETRY_CONCURRENCY &&
+        while (this._deferredGeometryActive < AcTrView2d.DEFERRED_GEOMETRY_CONCURRENCY &&
             this._deferredGeometryQueue.length > 0) {
             _loop_3();
         }
@@ -3065,6 +3343,8 @@ var AcTrView2d = /** @class */ (function (_super) {
         // 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.
@@ -3136,13 +3416,23 @@ 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_4, this_3, 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 = options.forExport
                             ? undefined
@@ -3151,14 +3441,14 @@ var AcTrView2d = /** @class */ (function (_super) {
                             return new Promise(function (resolve) { return setTimeout(resolve, 0); });
                         };
                         _loop_4 = function (i) {
-                            var entity, shouldConvert, directMeta, added, threeEntity_1, isMultiLayerGroup, deferGeometry, isExtendBbox_1, commitEntity, layoutView, viewportView, fileName, error_2, didYield;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
+                            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_3._convertEpoch) {
                                             return [2 /*return*/, "continue"];
@@ -3184,23 +3474,43 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         if (!shouldConvert) {
                                             return [2 /*return*/, "continue"];
                                         }
+                                        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_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);
+                                                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.
@@ -3217,9 +3527,10 @@ 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_3._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 &&
@@ -3228,29 +3539,39 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         if (!isMultiLayerGroup) return [3 /*break*/, 5];
                                         if (!deferGeometry) return [3 /*break*/, 2];
                                         this_3.enqueueDeferredGeometry(function () {
-                                            return _this.handleGroup(threeEntity_1, progressive, epoch);
+                                            return _this.handleGroup(threeEntity_1, progressive, epoch, convertGen_1);
                                         }, epoch);
                                         return [3 /*break*/, 4];
-                                    case 2: return [4 /*yield*/, this_3.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);
@@ -3269,8 +3590,8 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         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_3._convertEpoch) {
                                             return [2 /*return*/, "continue"];
@@ -3294,10 +3615,13 @@ var AcTrView2d = /** @class */ (function (_super) {
                                             if (fileName && !entity.image) {
                                                 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:
@@ -3314,24 +3638,24 @@ var AcTrView2d = /** @class */ (function (_super) {
                                         if (!yieldGate) return [3 /*break*/, 13];
                                         return [4 /*yield*/, yieldGate.maybeYield(yieldToEventLoop)];
                                     case 12:
-                                        didYield = _b.sent();
+                                        didYield = _e.sent();
                                         if (didYield) {
                                             this_3._progressiveYieldCount++;
                                         }
-                                        _b.label = 13;
+                                        _e.label = 13;
                                     case 13: return [2 /*return*/];
                                 }
                             });
                         };
                         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_4(i)];
                     case 2:
-                        _a.sent();
-                        _a.label = 3;
+                        _d.sent();
+                        _d.label = 3;
                     case 3:
                         ++i;
                         return [3 /*break*/, 1];
@@ -3361,20 +3685,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;
+        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 _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();
@@ -3434,6 +3766,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                         if (groupChildBoxes.length > 0) {
                             group.wcsBbox = aggregateSpatialBbox.clone();
                         }
+                        registeredChildIndex = false;
                         objectsGroupByLayer.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.
@@ -3469,7 +3802,10 @@ var AcTrView2d = /** @class */ (function (_super) {
                             entity.userData.insertLayerName = groupLayerName;
                             entity.wcsBbox = aggregateSpatialBbox.clone();
                             var entityUserData = entity.userData;
-                            entityUserData.spatialIndexChildBoxes = groupChildBoxes;
+                            if (!registeredChildIndex && groupChildBoxes.length > 0) {
+                                entityUserData.spatialIndexChildBoxes = groupChildBoxes;
+                                registeredChildIndex = true;
+                            }
                             // Important:
                             // DO NOT USE spread operator when adding objects because it may be one very large array
                             // and can result in maximum call stack size exceeded
@@ -3506,6 +3842,36 @@ 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();
         }
     };
     /**