@mlightcad/cad-simple-viewer 1.5.9 → 1.5.11

package/lib/view/AcTrView2d.js

@@ -96,9 +96,9 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { AcDbAttribute, AcDbBlockReference, acdbHostApplicationServices, AcDbMText, AcDbRasterImage, AcDbRay, AcDbSysVarManager, AcDbViewport, AcDbXline, AcGeBox2d, AcGePoint2d, log } from '@mlightcad/data-model';
+import { AcCmUiYieldGate, AcDbAttribute, AcDbBlockReference, acdbHostApplicationServices, AcDbMText, AcDbRasterImage, AcDbRay, AcDbSysVarManager, AcDbViewport, AcDbXline, AcGeBox2d, AcGePoint2d, log } from '@mlightcad/data-model';
 import { AcDbSystemVariables } from '@mlightcad/data-model';
-import { AcTrEntity, AcTrGroup, AcTrRenderer, AcTrViewportView } from '@mlightcad/three-renderer';
+import { AcTrEntity, AcTrGlyphEntity, AcTrGroup, AcTrRenderer, AcTrViewportView } from '@mlightcad/three-renderer';
 import { AcTrMatrixUtil } from '@mlightcad/three-renderer';
 import * as THREE from 'three';
 import Stats from 'three/examples/jsm/libs/stats.module';
@@ -110,6 +110,7 @@ import { isEffectiveSpatialQueryHit } from '../editor/view/AcEdSpatialQueryResul
 import { AcTrGeometryUtil } from '../util';
 import { acapRunDatabaseEdit } from '../util/AcApDatabaseEdit';
 import { AcEdViewKeyHandler } from './AcEdViewKeyHandler';
+import { shouldExtendBboxForDirectEntity, tryBuildDirectEntityMeta } from './AcTrDirectBatch';
 import { AcTrEntityDisplayController } from './AcTrEntityDisplayController';
 import { assertAcTrGroupWcsBboxesConsistent, unionGroupWcsChildBoxes } from './AcTrGroupWcsBboxAssert';
 import { AcTrInheritedLayerMaterialMapper } from './AcTrInheritedLayerMaterialMapper';
@@ -190,7 +191,7 @@ var AcTrView2d = /** @class */ (function (_super) {
          * Block table record ids of layouts whose entities are currently being
          * batch-converted into the scene. Used by
          * {@link AcTrView2d.loadLayoutEntitiesIfNeeded} to guard against
-         * re-entrant calls before the `setTimeout` callback flips
+         * re-entrant calls before the convert drain flips
          * `AcTrLayout.isLoaded` to `true`, which would otherwise duplicate
          * entities when the same layout tab is clicked twice in quick succession.
          */
@@ -236,10 +237,36 @@ var AcTrView2d = /** @class */ (function (_super) {
          */
         _this._convertingLayers = new Set();
         /**
-         * When true, entity conversion during document open is deferred across
-         * event-loop turns so geometry appears incrementally.
+         * When true, entity conversion during document open yields cooperatively so
+         * geometry paints incrementally while the open overlay is still visible.
          */
         _this._progressiveRendering = false;
+        /**
+         * Serial convert queue for progressive opens. Chunks from `entityAppended`
+         * enqueue here and a single drain loop runs {@link batchConvert}, so scene
+         * convert overlaps ENTITY flush instead of waiting for a post-open
+         * `setTimeout` storm after the loading overlay hides.
+         */
+        _this._convertQueue = [];
+        /** In-flight progressive convert drain; shared so awaiters wait for the queue. */
+        _this._convertDrainPromise = null;
+        /**
+         * Bumped by {@link clear} so an in-flight {@link batchConvert} abandons
+         * scene writes and counter updates after the view has been reset for a new
+         * document open.
+         */
+        _this._convertEpoch = 0;
+        /** Last time progressive open marked the canvas dirty for paint. */
+        _this._lastProgressivePaintAt = 0;
+        /** Mid-open WebGL paints while progressive convert was still running. */
+        _this._progressivePaintCount = 0;
+        /** Cooperative yields taken inside progressive {@link batchConvert}. */
+        _this._progressiveYieldCount = 0;
+        /**
+         * In-flight glyph/group geometry jobs that await fonts via asyncDraw.
+         * Counted separately so linework convert can continue while text waits.
+         */
+        _this._pendingGeometryJobs = 0;
         _this.animate = function () {
             var _a;
             _this._rafId = requestAnimationFrame(_this.animate);
@@ -253,12 +280,20 @@ var AcTrView2d = /** @class */ (function (_super) {
                 return;
             if (deferRenderWhileLoading)
                 return;
+            if (!_this._isDirty)
+                return;
+            if (_this._progressiveRendering && stillLoading) {
+                _this._progressivePaintCount++;
+            }
             var needsRedraw = _this._layoutViewManager.render(_this._scene);
             if (_this.internalCamera) {
                 _this._css2dRenderer.render(_this._scene.internalScene, _this.internalCamera);
             }
             (_a = _this._stats) === null || _a === void 0 ? void 0 : _a.update();
-            _this._isDirty = (_this._progressiveRendering && stillLoading) || needsRedraw;
+            // Do not re-dirty every frame during progressive open — paint is throttled
+            // from geometry batches to keep total open time down. Counter hitting 0
+            // still forces a final dirty in decreaseNumOfEntitiesToProcess().
+            _this._isDirty = needsRedraw;
         };
         _this._gripManager = new AcEdGripManager(_this);
         _this._keyHandler = new AcEdViewKeyHandler(_this);
@@ -482,6 +517,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         _this._isDirty = true;
         _this.startAnimationLoop();
         _this._numOfEntitiesToProcess = 0;
+        _this._pendingGeometryJobs = 0;
         return _this;
     }
     AcTrView2d.prototype.getPointerSelectionAction = function (e) {
@@ -564,18 +600,62 @@ var AcTrView2d = /** @class */ (function (_super) {
     });
     Object.defineProperty(AcTrView2d.prototype, "isProcessingEntities", {
         /**
-         * True while {@link addEntity} batch-conversion callbacks are still running.
+         * True while batch conversion or deferred glyph/group geometry is still
+         * running.
          *
          * Parsing can report 100% before this reaches zero; callers opening files
          * should wait on this (as {@link zoomToFitDrawing} does) before hiding
          * progress UI or assuming the canvas is ready.
          */
         get: function () {
-            return this._numOfEntitiesToProcess > 0;
+            return this._numOfEntitiesToProcess > 0 || this._pendingGeometryJobs > 0;
         },
         enumerable: false,
         configurable: true
     });
+    /**
+     * Waits until batch conversion and deferred glyph/font geometry finish.
+     *
+     * Document open can resolve before text is drawable (`FontManager.lazyFontLoading`
+     * + deferred geometry jobs). Call this before raster/HTML export or scripted
+     * commands that assume a complete scene.
+     *
+     * @param timeoutMs - Maximum wait; returns `false` on timeout (default 60s).
+     * @returns `true` when idle, `false` if still busy after the timeout.
+     */
+    AcTrView2d.prototype.waitUntilIdle = function () {
+        return __awaiter(this, arguments, void 0, function (timeoutMs) {
+            var deadline, idleStreak;
+            if (timeoutMs === void 0) { timeoutMs = 60000; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        deadline = Date.now() + Math.max(0, timeoutMs);
+                        idleStreak = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!this.isProcessingEntities) {
+                            idleStreak++;
+                            if (idleStreak >= 2) {
+                                return [2 /*return*/, true];
+                            }
+                        }
+                        else {
+                            idleStreak = 0;
+                        }
+                        if (Date.now() > deadline) {
+                            return [2 /*return*/, !this.isProcessingEntities];
+                        }
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 16); })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
     Object.defineProperty(AcTrView2d.prototype, "progressiveRendering", {
         /**
          * Whether entity conversion during document open is deferred for progressive display.
@@ -585,10 +665,30 @@ var AcTrView2d = /** @class */ (function (_super) {
         },
         set: function (value) {
             this._progressiveRendering = value;
+            this.resetProgressiveOpenStats();
         },
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcTrView2d.prototype, "progressiveOpenStats", {
+        /**
+         * Progressive-open counters for OPENPROF / palette (paints while converting,
+         * cooperative yields). Reset when progressive mode is enabled for an open.
+         */
+        get: function () {
+            return {
+                paintCount: this._progressivePaintCount,
+                yieldCount: this._progressiveYieldCount
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcTrView2d.prototype.resetProgressiveOpenStats = function () {
+        this._progressivePaintCount = 0;
+        this._progressiveYieldCount = 0;
+        this._lastProgressivePaintAt = 0;
+    };
     /**
      * Enables progressive camera framing while entities are batch-converted at
      * document open. Pair with {@link zoomToFitDrawing} for the final accurate fit.
@@ -946,7 +1046,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      */
     AcTrView2d.prototype.ensureEntitiesConvertedForExport = function (options) {
         return __awaiter(this, void 0, void 0, function () {
-            var includeInvisibleLayers, db, pending, _a, _b, _c, layoutBtrId, blockTableRecord;
+            var includeInvisibleLayers, db, pending, _a, _b, _c, layoutBtrId, blockTableRecord, idle;
             var e_4, _d;
             var _this = this;
             return __generator(this, function (_e) {
@@ -972,13 +1072,18 @@ var AcTrView2d = /** @class */ (function (_super) {
                             }
                             finally { if (e_4) throw e_4.error; }
                         }
-                        if (pending.length === 0) {
-                            return [2 /*return*/];
-                        }
+                        if (!(pending.length > 0)) return [3 /*break*/, 2];
                         this._numOfEntitiesToProcess += pending.length;
                         return [4 /*yield*/, this.batchConvert(pending, { forExport: true })];
                     case 1:
                         _e.sent();
+                        _e.label = 2;
+                    case 2: return [4 /*yield*/, this.waitUntilIdle()];
+                    case 3:
+                        idle = _e.sent();
+                        if (!idle) {
+                            log.warn('[AcTrView2d] Timed out waiting for deferred geometry before export');
+                        }
                         return [2 /*return*/];
                 }
             });
@@ -1078,7 +1183,9 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.zoomToFitDrawing = function (timeout, layoutBtrId) {
         var _this = this;
         if (timeout === void 0) { timeout = 0; }
-        var waiter = new AcEdConditionWaiter(function () { return _this._numOfEntitiesToProcess <= 0; }, function () {
+        var waiter = new AcEdConditionWaiter(
+        // Include deferred glyph/group jobs so text extents land before final fit.
+        function () { return !_this.isProcessingEntities; }, function () {
             if (layoutBtrId && _this._externallyFramedLayouts.delete(layoutBtrId)) {
                 _this.endProgressiveOpenFit();
                 return;
@@ -1466,16 +1573,34 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @param entity Input one or multiple transient entities
      */
     AcTrView2d.prototype.addTransientEntity = function (entity) {
+        var _this = this;
         var entities = Array.isArray(entity) ? entity : [entity];
-        for (var i = 0; i < entities.length; ++i) {
+        var epoch = this._convertEpoch;
+        var _loop_2 = function (i) {
             var entity_1 = entities[i];
-            var threeEntity = this.drawEntity(entity_1, true);
+            var threeEntity = this_1.drawEntity(entity_1, true);
             if (threeEntity) {
                 threeEntity.objectId = entity_1.objectId;
-                threeEntity.syncDraw();
-                this._scene.addTransientEntity(threeEntity);
-                this._isDirty = true;
+                void threeEntity
+                    .asyncDraw()
+                    .then(function () {
+                    // Drop stale transients started before clear()/regen invalidated the view.
+                    if (epoch !== _this._convertEpoch) {
+                        threeEntity.dispose();
+                        return;
+                    }
+                    _this._scene.addTransientEntity(threeEntity);
+                    _this._isDirty = true;
+                })
+                    .catch(function (error) {
+                    log.error('[AcTrView2d] Transient entity geometry failed:', error);
+                    threeEntity.dispose();
+                });
             }
+        };
+        var this_1 = this;
+        for (var i = 0; i < entities.length; ++i) {
+            _loop_2(i);
         }
     };
     /**
@@ -1533,25 +1658,15 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @inheritdoc
      */
     AcTrView2d.prototype.addEntity = function (entity) {
-        var _this = this;
+        var _a;
         var entities = Array.isArray(entity) ? entity : [entity];
         this._numOfEntitiesToProcess += entities.length;
-        var convert = function () { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.batchConvert(entities)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); };
         if (this._progressiveRendering) {
-            setTimeout(convert);
-            this._isDirty = true;
+            (_a = this._convertQueue).push.apply(_a, __spreadArray([], __read(entities), false));
+            void this.drainConvertQueue();
         }
         else {
-            void convert();
+            void this.batchConvert(entities);
         }
     };
     /**
@@ -1629,12 +1744,23 @@ var AcTrView2d = /** @class */ (function (_super) {
         }
         // Reconvert through the same path as initial load so block references are
         // split by layer correctly and deferred MTEXT/SHAPE geometry is drawn.
-        void this.batchConvert(entities).then(function () {
-            if (selectedIds.length > 0) {
-                _this.highlight(selectedIds);
-            }
-            _this._gripManager.refresh();
-        });
+        void (function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.batchConvert(entities)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitUntilDeferredGeometryIdle()];
+                    case 2:
+                        _a.sent();
+                        if (selectedIds.length > 0) {
+                            this.highlight(selectedIds);
+                        }
+                        this._gripManager.refresh();
+                        return [2 /*return*/];
+                }
+            });
+        }); })();
         this._isDirty = true;
         // Not sure why texture for image entity isn't updated even if 'isDirty' flag is already set to true.
         // So add one timeout event to set 'isDirty' flag to true again to make it work
@@ -1743,16 +1869,17 @@ var AcTrView2d = /** @class */ (function (_super) {
      * **Critically, this runs through `AcEdConditionWaiter`**: at the
      * moment `layoutSwitched` fires, the layout's entities (including its
      * `AcDbViewport`s) have not yet been batch-converted into the scene
-     * — `loadLayoutEntitiesIfNeeded` chunked-converts via `setTimeout`.
+     * — `loadLayoutEntitiesIfNeeded` chunked-converts via the progressive
+     * convert queue (or direct `batchConvert`).
      * Without the waiter, `viewportsBoundingBox` returns undefined and
      * the strategy degrades into (1) zooming to garbage `limits`, or
      * (4) zooming to an empty scene box. The waiter polls
-     * `_numOfEntitiesToProcess` and only fires the heuristic once the
-     * conversion is done.
+     * {@link isProcessingEntities} (convert queue + deferred glyph jobs)
+     * and only fires the heuristic once conversion and text geometry finish.
      */
     AcTrView2d.prototype.applyInitialZoom = function (btrId, layout) {
         var _this = this;
-        var waiter = new AcEdConditionWaiter(function () { return _this._numOfEntitiesToProcess <= 0; }, function () {
+        var waiter = new AcEdConditionWaiter(function () { return !_this.isProcessingEntities; }, function () {
             if (_this._externallyFramedLayouts.delete(btrId)) {
                 return;
             }
@@ -1793,11 +1920,80 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @inheritdoc
      */
     AcTrView2d.prototype.clear = function () {
+        // Invalidate any in-flight progressive convert so it neither paints into
+        // the cleared scene nor double-decrements the processing counter.
+        this._convertEpoch++;
+        this._convertQueue.length = 0;
+        this._numOfEntitiesToProcess = 0;
+        this._pendingGeometryJobs = 0;
         this._scene.clear();
         this._isDirty = true;
         this._missedImages.clear();
         this._renderer.dispose();
     };
+    /**
+     * Drains the progressive convert queue on a single serial worker so ENTITY
+     * flush chunks can enqueue while conversion overlaps the loading overlay.
+     *
+     * Concurrent callers share the same promise; if more entities are queued
+     * after a drain finishes, a follow-up drain is started.
+     */
+    AcTrView2d.prototype.drainConvertQueue = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._convertDrainPromise) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this._convertDrainPromise];
+                    case 1:
+                        _a.sent();
+                        if (!(this._convertQueue.length > 0)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.drainConvertQueue()];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                    case 4:
+                        this._convertDrainPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var batch;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!(this._convertQueue.length > 0)) return [3 /*break*/, 2];
+                                        batch = this._convertQueue.splice(0, this._convertQueue.length);
+                                        return [4 /*yield*/, this.batchConvert(batch)];
+                                    case 1:
+                                        _a.sent();
+                                        return [3 /*break*/, 0];
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        }); })().finally(function () {
+                            _this._convertDrainPromise = null;
+                        });
+                        return [4 /*yield*/, this._convertDrainPromise];
+                    case 5:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Marks the canvas dirty for progressive open, throttled to avoid painting
+     * on every entity (which dominated total open time).
+     */
+    AcTrView2d.prototype.markProgressiveDirty = function (force) {
+        if (force === void 0) { force = false; }
+        var now = performance.now();
+        if (force ||
+            now - this._lastProgressivePaintAt >=
+                AcTrView2d.PROGRESSIVE_OPEN_PAINT_INTERVAL_MS) {
+            this._isDirty = true;
+            this._lastProgressivePaintAt = now;
+        }
+    };
     /**
      * @inheritdoc
      */
@@ -1886,7 +2082,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      *    on it would silently miss layouts that are pre-loaded ahead of
      *    becoming active (e.g. background prefetch).
      * 2. The `_loadingLayouts` guard prevents re-entrance while the
-     *    `setTimeout` chunked-convert callback is still in flight. Without it,
+     *    convert drain is still in flight. Without it,
      *    clicking the same layout tab twice in quick succession (or
      *    `layoutSwitched` firing twice during the async window) would iterate
      *    the block table record again and duplicate every entity in the
@@ -1988,31 +2184,35 @@ var AcTrView2d = /** @class */ (function (_super) {
             this._numOfEntitiesToProcess += entities_2.length;
             var convert = function () { return __awaiter(_this, void 0, void 0, function () {
                 var layout;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
                         case 0:
-                            _a.trys.push([0, , 2, 3]);
-                            return [4 /*yield*/, this.batchConvert(entities_2)];
+                            _b.trys.push([0, , 5, 6]);
+                            if (!this._progressiveRendering) return [3 /*break*/, 2];
+                            (_a = this._convertQueue).push.apply(_a, __spreadArray([], __read(entities_2), false));
+                            return [4 /*yield*/, this.drainConvertQueue()];
                         case 1:
-                            _a.sent();
+                            _b.sent();
+                            return [3 /*break*/, 4];
+                        case 2: return [4 /*yield*/, this.batchConvert(entities_2)];
+                        case 3:
+                            _b.sent();
+                            _b.label = 4;
+                        case 4:
                             layout = this._scene.layouts.get(layoutBtrId);
                             if (layout) {
                                 layout.isLoaded = true;
                             }
-                            return [3 /*break*/, 3];
-                        case 2:
+                            return [3 /*break*/, 6];
+                        case 5:
                             this._loadingLayouts.delete(layoutBtrId);
                             return [7 /*endfinally*/];
-                        case 3: return [2 /*return*/];
+                        case 6: return [2 /*return*/];
                     }
                 });
             }); };
-            if (this._progressiveRendering) {
-                setTimeout(convert);
-            }
-            else {
-                void convert();
-            }
+            void convert();
         }
         catch (error) {
             log.error('[AcTrView2d] Error loading layout entities:', error);
@@ -2087,21 +2287,25 @@ var AcTrView2d = /** @class */ (function (_super) {
         return entity.worldDraw(this._renderer, delay);
     };
     /**
-     * Finishes geometry for a converted entity. Block groups always use
-     * {@link AcTrGroup.syncDraw} to finalize deferred children. Progressive mode
-     * defers MTEXT/SHAPE to async workers; non-progressive mode uses
-     * {@link AcTrEntity.syncDraw}.
+     * 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.
      */
-    AcTrView2d.prototype.finishEntityGeometry = function (threeEntity, progressive) {
+    AcTrView2d.prototype.finishEntityGeometry = function (threeEntity, _progressive) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (threeEntity instanceof AcTrGroup) {
-                            threeEntity.syncDraw();
+                        if (!(threeEntity instanceof AcTrGroup)) return [3 /*break*/, 2];
+                        // Compacted INSERT templates may skip syncDraw when fonts are awaited
+                        // later; still walk for empty glyph shells. Skip only when there is
+                        // nothing left to finalize (incl. post-cache ATTRIBs).
+                        if (threeEntity.getSourceEntities().length === 0 &&
+                            !this.groupHasPendingGlyphGeometry(threeEntity)) {
                             return [2 /*return*/];
                         }
-                        if (!progressive) return [3 /*break*/, 2];
                         return [4 /*yield*/, threeEntity.asyncDraw()];
                     case 1:
                         _a.sent();
@@ -2110,12 +2314,82 @@ var AcTrView2d = /** @class */ (function (_super) {
                         if (threeEntity.hasDrawableGeometry()) {
                             return [2 /*return*/];
                         }
-                        threeEntity.syncDraw();
+                        return [4 /*yield*/, threeEntity.asyncDraw()];
+                    case 3:
+                        _a.sent();
                         return [2 /*return*/];
                 }
             });
         });
     };
+    AcTrView2d.prototype.needsDeferredFontGeometry = function (threeEntity) {
+        return (threeEntity instanceof AcTrGlyphEntity ||
+            threeEntity instanceof AcTrGroup);
+    };
+    AcTrView2d.prototype.groupHasPendingGlyphGeometry = function (group) {
+        var pending = false;
+        group.traverse(function (child) {
+            if (child instanceof AcTrGlyphEntity &&
+                !child.hasDrawableGeometry()) {
+                pending = true;
+            }
+        });
+        return pending;
+    };
+    /**
+     * Runs glyph/group geometry finalize off the main convert loop so other
+     * entities keep converting while fonts download.
+     */
+    AcTrView2d.prototype.enqueueDeferredGeometry = function (run, epoch) {
+        var _this = this;
+        if (epoch !== this._convertEpoch) {
+            return;
+        }
+        this._pendingGeometryJobs++;
+        void run()
+            .then(function () {
+            // Convert counter often hits 0 before fonts finish; without this,
+            // text added later never paints until the user pans/zooms.
+            if (epoch === _this._convertEpoch) {
+                _this._isDirty = true;
+            }
+        })
+            .catch(function (error) {
+            log.error('[AcTrView2d] Deferred entity geometry failed:', error);
+        })
+            .finally(function () {
+            if (epoch === _this._convertEpoch) {
+                _this._pendingGeometryJobs = Math.max(0, _this._pendingGeometryJobs - 1);
+                if (_this._pendingGeometryJobs === 0) {
+                    _this._isDirty = true;
+                }
+            }
+        });
+    };
+    /**
+     * Waits until side-pool glyph/group jobs for the current convert epoch finish.
+     * Used by entity updates that must highlight after text is in the scene.
+     */
+    AcTrView2d.prototype.waitUntilDeferredGeometryIdle = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var epoch;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        epoch = this._convertEpoch;
+                        _a.label = 1;
+                    case 1:
+                        if (!(epoch === this._convertEpoch &&
+                            this._pendingGeometryJobs > 0)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 0); })];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Walks the given block table record once and creates one
      * `AcTrViewportView` for every real `AcDbViewport` entity it finds
@@ -2163,116 +2437,206 @@ var AcTrView2d = /** @class */ (function (_super) {
      */
     AcTrView2d.prototype.batchConvert = function (entities_3) {
         return __awaiter(this, arguments, void 0, function (entities, options) {
-            var progressive, i, entity, shouldConvert, threeEntity, isExtendBbox, layoutView, viewportView, fileName, error_2;
+            var epoch, progressive, yieldGate, yieldToEventLoop, _loop_3, this_2, i;
             var _this = this;
             if (options === void 0) { options = {}; }
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        epoch = this._convertEpoch;
                         progressive = this._progressiveRendering && !options.forExport;
+                        yieldGate = progressive
+                            ? new AcCmUiYieldGate(AcTrView2d.PROGRESSIVE_OPEN_YIELD_BUDGET_MS)
+                            : undefined;
+                        yieldToEventLoop = function () {
+                            return new Promise(function (resolve) { return setTimeout(resolve, 0); });
+                        };
+                        _loop_3 = function (i) {
+                            var entity, shouldConvert, directMeta, added, threeEntity_1, isMultiLayerGroup, deferGeometry, isExtendBbox_1, commitEntity, layoutView, viewportView, fileName, error_2, didYield;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        entity = entities[i];
+                                        _b.label = 1;
+                                    case 1:
+                                        _b.trys.push([1, 9, 10, 11]);
+                                        // Document was cleared / replaced while this batch was draining.
+                                        if (epoch !== this_2._convertEpoch) {
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        // Skip the default paper-space viewport (`*Paper_Space`) entirely:
+                                        // it is an AutoCAD-internal viewport that exists in every paper
+                                        // layout and must not be drawn (would render a giant rectangle in
+                                        // the paper coordinate system), nor added to the spatial index
+                                        // (would stretch the layout's bounding box and break
+                                        // zoomToFitDrawing), nor turned into an AcTrViewportView (would
+                                        // setScissor over most of the canvas and squeeze the real user
+                                        // viewports into a corner). See
+                                        // `AcTrViewportView.isDefaultPaperSpaceViewport` for the criterion
+                                        // and the rationale (legacy `number === 1` is unreliable across
+                                        // parsers).
+                                        if (entity instanceof AcDbViewport &&
+                                            AcTrViewportView.isDefaultPaperSpaceViewport(entity)) {
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        shouldConvert = options.forExport
+                                            ? this_2._entityDisplay.shouldConvertForExport(entity)
+                                            : this_2._entityDisplay.shouldConvert(entity);
+                                        if (!shouldConvert) {
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        directMeta = tryBuildDirectEntityMeta(entity, this_2._renderer);
+                                        if (directMeta) {
+                                            added = false;
+                                            try {
+                                                added = this_2._scene.addDirectEntity(directMeta, shouldExtendBboxForDirectEntity(entity));
+                                                if (added) {
+                                                    this_2.applySessionHiddenObjectState(entity.objectId);
+                                                    if (progressive) {
+                                                        this_2.markProgressiveDirty();
+                                                        this_2._progressiveOpenFit.afterGeometryBatch(function () { return _this.resolveLayoutFitBox(); }, i);
+                                                    }
+                                                }
+                                            }
+                                            finally {
+                                                directMeta.geometry.dispose();
+                                            }
+                                            if (added) {
+                                                return [2 /*return*/, "continue"];
+                                            }
+                                            // Append refused (e.g. invisible) — fall through to the legacy path.
+                                        }
+                                        threeEntity_1 = this_2.drawEntity(entity, false);
+                                        // Viewports may produce no border geometry (e.g. on a no-plot layer) while
+                                        // still needing an AcTrViewportView for model content below.
+                                        if (!threeEntity_1 && !(entity instanceof AcDbViewport))
+                                            return [2 /*return*/, "continue"];
+                                        if (!threeEntity_1) return [3 /*break*/, 8];
+                                        threeEntity_1.objectId = entity.objectId;
+                                        threeEntity_1.ownerId = entity.ownerId;
+                                        threeEntity_1.layerName = entity.layer;
+                                        threeEntity_1.visible = entity.visibility !== false;
+                                        if (threeEntity_1 instanceof AcTrGroup &&
+                                            threeEntity_1.isOnTheSameLayer) {
+                                            // Even when a block expands to a single layer bucket, children authored on
+                                            // layer "0" still inherit the INSERT layer for ByLayer traits (color, etc.).
+                                            this_2._inheritedLayerMaterialMapper.remap(threeEntity_1.children, '0', threeEntity_1.layerName);
+                                            threeEntity_1.userData.insertLayerName = threeEntity_1.layerName;
+                                        }
+                                        isMultiLayerGroup = threeEntity_1 instanceof AcTrGroup &&
+                                            !threeEntity_1.isOnTheSameLayer;
+                                        deferGeometry = !options.forExport && this_2.needsDeferredFontGeometry(threeEntity_1);
+                                        if (!isMultiLayerGroup) return [3 /*break*/, 5];
+                                        if (!deferGeometry) return [3 /*break*/, 2];
+                                        this_2.enqueueDeferredGeometry(function () {
+                                            return _this.handleGroup(threeEntity_1, progressive, epoch);
+                                        }, epoch);
+                                        return [3 /*break*/, 4];
+                                    case 2: return [4 /*yield*/, this_2.handleGroup(threeEntity_1, progressive, epoch)];
+                                    case 3:
+                                        _b.sent();
+                                        _b.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) {
+                                                    case 0: return [4 /*yield*/, this.finishEntityGeometry(threeEntity_1, progressive)];
+                                                    case 1:
+                                                        _a.sent();
+                                                        if (epoch !== this._convertEpoch) {
+                                                            threeEntity_1.dispose();
+                                                            return [2 /*return*/];
+                                                        }
+                                                        if (threeEntity_1 instanceof AcTrGroup) {
+                                                            this.syncGroupSpatialBoundsForIndexing(threeEntity_1);
+                                                        }
+                                                        this._scene.addEntity(threeEntity_1, isExtendBbox_1);
+                                                        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);
+                                                        }
+                                                        return [2 /*return*/];
+                                                }
+                                            });
+                                        }); };
+                                        if (!deferGeometry) return [3 /*break*/, 6];
+                                        this_2.enqueueDeferredGeometry(commitEntity, epoch);
+                                        return [3 /*break*/, 8];
+                                    case 6: return [4 /*yield*/, commitEntity()];
+                                    case 7:
+                                        _b.sent();
+                                        _b.label = 8;
+                                    case 8:
+                                        if (epoch !== this_2._convertEpoch) {
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        if (entity instanceof AcDbViewport) {
+                                            // Default paper-space viewport was already filtered out at the
+                                            // top of the loop, so anything that reaches here is a real
+                                            // user-created viewport. The redundant check below is kept as
+                                            // a defensive guard in case a future refactor reorders the
+                                            // early-skip — it costs ~nothing and prevents a regression.
+                                            if (!AcTrViewportView.isDefaultPaperSpaceViewport(entity)) {
+                                                layoutView = this_2._layoutViewManager.getAt(entity.ownerId);
+                                                if (layoutView) {
+                                                    viewportView = new AcTrViewportView(layoutView, entity.toGiViewport(), this_2._renderer);
+                                                    layoutView.addViewport(viewportView);
+                                                }
+                                            }
+                                        }
+                                        else if (entity instanceof AcDbRasterImage) {
+                                            fileName = entity.imageFileName;
+                                            if (fileName && !entity.image) {
+                                                this_2._missedImages.set(entity.objectId, fileName);
+                                            }
+                                        }
+                                        return [3 /*break*/, 11];
+                                    case 9:
+                                        error_2 = _b.sent();
+                                        log.error("[AcTrView2d] Failed to convert entity ".concat(entity.objectId, " (").concat(entity.type, "):"), error_2);
+                                        return [3 /*break*/, 11];
+                                    case 10:
+                                        // Counter was reset in clear() when the epoch advanced; do not
+                                        // decrease again or isProcessingEntities can go negative/warn.
+                                        if (epoch === this_2._convertEpoch) {
+                                            this_2.decreaseNumOfEntitiesToProcess();
+                                        }
+                                        return [7 /*endfinally*/];
+                                    case 11:
+                                        if (epoch !== this_2._convertEpoch) {
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        if (!yieldGate) return [3 /*break*/, 13];
+                                        return [4 /*yield*/, yieldGate.maybeYield(yieldToEventLoop)];
+                                    case 12:
+                                        didYield = _b.sent();
+                                        if (didYield) {
+                                            this_2._progressiveYieldCount++;
+                                        }
+                                        _b.label = 13;
+                                    case 13: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_2 = this;
                         i = 0;
                         _a.label = 1;
                     case 1:
-                        if (!(i < entities.length)) return [3 /*break*/, 11];
-                        entity = entities[i];
-                        _a.label = 2;
+                        if (!(i < entities.length)) return [3 /*break*/, 4];
+                        return [5 /*yield**/, _loop_3(i)];
                     case 2:
-                        _a.trys.push([2, 8, 9, 10]);
-                        // Skip the default paper-space viewport (`*Paper_Space`) entirely:
-                        // it is an AutoCAD-internal viewport that exists in every paper
-                        // layout and must not be drawn (would render a giant rectangle in
-                        // the paper coordinate system), nor added to the spatial index
-                        // (would stretch the layout's bounding box and break
-                        // zoomToFitDrawing), nor turned into an AcTrViewportView (would
-                        // setScissor over most of the canvas and squeeze the real user
-                        // viewports into a corner). See
-                        // `AcTrViewportView.isDefaultPaperSpaceViewport` for the criterion
-                        // and the rationale (legacy `number === 1` is unreliable across
-                        // parsers).
-                        if (entity instanceof AcDbViewport &&
-                            AcTrViewportView.isDefaultPaperSpaceViewport(entity)) {
-                            return [3 /*break*/, 10];
-                        }
-                        shouldConvert = options.forExport
-                            ? this._entityDisplay.shouldConvertForExport(entity)
-                            : this._entityDisplay.shouldConvert(entity);
-                        if (!shouldConvert) {
-                            return [3 /*break*/, 10];
-                        }
-                        threeEntity = this.drawEntity(entity, progressive);
-                        // Viewports may produce no border geometry (e.g. on a no-plot layer) while
-                        // still needing an AcTrViewportView for model content below.
-                        if (!threeEntity && !(entity instanceof AcDbViewport))
-                            return [3 /*break*/, 10];
-                        if (!threeEntity) return [3 /*break*/, 7];
-                        threeEntity.objectId = entity.objectId;
-                        threeEntity.ownerId = entity.ownerId;
-                        threeEntity.layerName = entity.layer;
-                        threeEntity.visible = entity.visibility !== false;
-                        if (threeEntity instanceof AcTrGroup &&
-                            threeEntity.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._inheritedLayerMaterialMapper.remap(threeEntity.children, '0', threeEntity.layerName);
-                            threeEntity.userData.insertLayerName = threeEntity.layerName;
-                        }
-                        if (!(threeEntity instanceof AcTrGroup &&
-                            !threeEntity.isOnTheSameLayer)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.handleGroup(threeEntity, progressive)];
-                    case 3:
                         _a.sent();
-                        return [3 /*break*/, 7];
-                    case 4:
-                        isExtendBbox = !(entity instanceof AcDbRay || entity instanceof AcDbXline);
-                        return [4 /*yield*/, this.finishEntityGeometry(threeEntity, progressive)];
-                    case 5:
-                        _a.sent();
-                        if (threeEntity instanceof AcTrGroup) {
-                            this.syncGroupSpatialBoundsForIndexing(threeEntity);
-                        }
-                        this._scene.addEntity(threeEntity, isExtendBbox);
-                        this.applySessionHiddenObjectState(entity.objectId);
-                        // Release memory occupied by this entity
-                        threeEntity.dispose();
-                        if (!progressive) return [3 /*break*/, 7];
-                        this._isDirty = true;
-                        return [4 /*yield*/, this._progressiveOpenFit.afterGeometryBatch(function () { return _this.resolveLayoutFitBox(); }, i)];
-                    case 6:
-                        _a.sent();
-                        _a.label = 7;
-                    case 7:
-                        if (entity instanceof AcDbViewport) {
-                            // Default paper-space viewport was already filtered out at the
-                            // top of the loop, so anything that reaches here is a real
-                            // user-created viewport. The redundant check below is kept as
-                            // a defensive guard in case a future refactor reorders the
-                            // early-skip — it costs ~nothing and prevents a regression.
-                            if (!AcTrViewportView.isDefaultPaperSpaceViewport(entity)) {
-                                layoutView = this._layoutViewManager.getAt(entity.ownerId);
-                                if (layoutView) {
-                                    viewportView = new AcTrViewportView(layoutView, entity.toGiViewport(), this._renderer);
-                                    layoutView.addViewport(viewportView);
-                                }
-                            }
-                        }
-                        else if (entity instanceof AcDbRasterImage) {
-                            fileName = entity.imageFileName;
-                            if (fileName && !entity.image) {
-                                this._missedImages.set(entity.objectId, fileName);
-                            }
-                        }
-                        return [3 /*break*/, 10];
-                    case 8:
-                        error_2 = _a.sent();
-                        log.error("[AcTrView2d] Failed to convert entity ".concat(entity.objectId, " (").concat(entity.type, "):"), error_2);
-                        return [3 /*break*/, 10];
-                    case 9:
-                        this.decreaseNumOfEntitiesToProcess();
-                        return [7 /*endfinally*/];
-                    case 10:
+                        _a.label = 3;
+                    case 3:
                         ++i;
                         return [3 /*break*/, 1];
-                    case 11: return [2 /*return*/];
+                    case 4: return [2 /*return*/];
                 }
             });
         });
@@ -2297,16 +2661,21 @@ var AcTrView2d = /** @class */ (function (_super) {
         var userData = group.userData;
         userData.spatialIndexChildBoxes = childBoxes;
     };
-    AcTrView2d.prototype.handleGroup = function (group, progressive) {
-        return __awaiter(this, void 0, void 0, function () {
+    AcTrView2d.prototype.handleGroup = function (group_1, progressive_1) {
+        return __awaiter(this, arguments, void 0, function (group, progressive, epoch) {
             var children, objectsGroupByLayer, children_1, children_1_1, child, renderContext, groupObjectId, groupLayerName, groupChildBoxes, aggregateSpatialBbox;
             var e_11, _a;
             var _this = this;
+            if (epoch === void 0) { epoch = this._convertEpoch; }
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0: return [4 /*yield*/, this.finishEntityGeometry(group, progressive)];
                     case 1:
                         _b.sent();
+                        if (epoch !== this._convertEpoch) {
+                            group.dispose();
+                            return [2 /*return*/];
+                        }
                         this.syncGroupSpatialBoundsForIndexing(group);
                         children = group.children;
                         objectsGroupByLayer = new Map();
@@ -2410,9 +2779,9 @@ var AcTrView2d = /** @class */ (function (_super) {
                             entity.dispose();
                         });
                         group.dispose();
-                        if (this._progressiveRendering) {
-                            this._isDirty = true;
-                            void this._progressiveOpenFit.afterGeometryBatch(function () {
+                        if (progressive) {
+                            this.markProgressiveDirty();
+                            this._progressiveOpenFit.afterGeometryBatch(function () {
                                 return _this.resolveLayoutFitBox();
                             });
                         }
@@ -2427,11 +2796,25 @@ var AcTrView2d = /** @class */ (function (_super) {
             this._numOfEntitiesToProcess = 0;
             log.warn('Something wrong! The number of entities to process should not be less than 0.');
         }
-        else if (this._numOfEntitiesToProcess === 0 &&
-            !this._progressiveRendering) {
+        else if (this._numOfEntitiesToProcess === 0) {
+            // Always mark dirty when the queue drains. Progressive open throttles
+            // mid-open paints, so the last batch would otherwise never redraw until
+            // the user pans/zooms (animate bails when !_isDirty && !stillLoading).
             this._isDirty = true;
         }
     };
+    /**
+     * Wall-time between cooperative yields during progressive open (ms).
+     * Kept relatively large so convert throughput stays close to the
+     * non-progressive path; smaller budgets made open 2–3× slower.
+     */
+    AcTrView2d.PROGRESSIVE_OPEN_YIELD_BUDGET_MS = 300;
+    /**
+     * Minimum interval between progressive mid-open paints (ms).
+     * Full-scene WebGL paints dominate open wall time on large drawings;
+     * paint much less often than we yield.
+     */
+    AcTrView2d.PROGRESSIVE_OPEN_PAINT_INTERVAL_MS = 1000;
     return AcTrView2d;
 }(AcEdBaseView));
 export { AcTrView2d };