@mlightcad/cad-simple-viewer 1.5.5 → 1.5.7

package/lib/view/AcTrView2d.js

@@ -71,25 +71,60 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { 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, getMaterialMetadata, hasByLayerBinding, setMaterialMetadata } from '@mlightcad/three-renderer';
+import { AcTrEntity, 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';
 import { CSS2DRenderer } from 'three/examples/jsm/renderers/CSS2DRenderer.js';
 import { AcApDocManager, AcApSettingManager } from '../app';
-import { AcEdBaseView, AcEdConditionWaiter, AcEdCorsorType, AcEdMTextEditor, AcEdOpenMode, AcEdViewMode, eventBus, resolvePointerSelectionAction } from '../editor';
-import { isModelSpaceDatabase, MODEL_SPACE_BACKGROUND, readLayoutBackgroundColor } from '../editor/global/AcEdUiColor';
+import { AcEdBaseView, AcEdConditionWaiter, AcEdCorsorType, AcEdGripManager, AcEdMTextEditor, AcEdOpenMode, AcEdViewMode, eventBus, resolvePointerSelectionAction } from '../editor';
+import { ACGI_MODEL_SPACE_BACKGROUND, isModelSpaceDatabase, readLayoutBackgroundColor } from '../editor/global/AcEdUiColor';
+import { isEffectiveSpatialQueryHit } from '../editor/view/AcEdSpatialQueryResult';
 import { AcTrGeometryUtil } from '../util';
+import { acapRunDatabaseEdit } from '../util/AcApDatabaseEdit';
+import { AcEdViewKeyHandler } from './AcEdViewKeyHandler';
+import { AcTrEntityDisplayController } from './AcTrEntityDisplayController';
+import { assertAcTrGroupWcsBboxesConsistent, unionGroupWcsChildBoxes } from './AcTrGroupWcsBboxAssert';
+import { AcTrInheritedLayerMaterialMapper } from './AcTrInheritedLayerMaterialMapper';
+import { AcTrLayer } from './AcTrLayer';
+import { AcTrLayerAppearanceController } from './AcTrLayerAppearanceController';
 import { AcTrLayoutView } from './AcTrLayoutView';
 import { AcTrLayoutViewManager } from './AcTrLayoutViewManager';
 import { sortPickResults } from './AcTrPickResultUtil';
+import { AcTrProgressiveOpenFitController } from './AcTrProgressiveOpenFitController';
 import { AcTrScene } from './AcTrScene';
 /**
  * Default view option values
  */
 export var DEFAULT_VIEW_2D_OPTIONS = {
-    background: MODEL_SPACE_BACKGROUND
+    background: ACGI_MODEL_SPACE_BACKGROUND
 };
 /**
  * A 2D CAD viewer component that renders CAD drawings using Three.js.
@@ -129,11 +164,15 @@ var AcTrView2d = /** @class */ (function (_super) {
         var mergedOptions = __assign(__assign({}, DEFAULT_VIEW_2D_OPTIONS), options);
         var container = (_a = mergedOptions.container) !== null && _a !== void 0 ? _a : document.createElement('div');
         mergedOptions.container = container;
+        container.style.overflow = 'hidden';
         var renderer = new THREE.WebGLRenderer({
             antialias: true,
             alpha: true
         });
         container.appendChild(renderer.domElement);
+        renderer.domElement.style.display = 'block';
+        renderer.domElement.style.maxWidth = '100%';
+        renderer.domElement.style.maxHeight = '100%';
         _this = _super.call(this, renderer.domElement, container) || this;
         /**
          * ID of the currently scheduled requestAnimationFrame callback.
@@ -185,6 +224,21 @@ var AcTrView2d = /** @class */ (function (_super) {
          * race during document open.
          */
         _this._externallyFramedLayouts = new Set();
+        /**
+         * Layer names with an in-flight {@link convertMissingEntitiesOnLayer} pass.
+         *
+         * {@link updateLayer} triggers that conversion fire-and-forget when a layer
+         * becomes visible again. Rapid or repeated layer-on events for the same name
+         * would otherwise start parallel {@link batchConvert} runs over the same
+         * pending entities. `hasEntity` prevents duplicate scene entries, but not the
+         * wasted conversion work — this set skips re-entry until the current pass ends.
+         */
+        _this._convertingLayers = new Set();
+        /**
+         * When true, entity conversion during document open is deferred across
+         * event-loop turns so geometry appears incrementally.
+         */
+        _this._progressiveRendering = false;
         _this.animate = function () {
             var _a;
             _this._rafId = requestAnimationFrame(_this.animate);
@@ -193,15 +247,20 @@ var AcTrView2d = /** @class */ (function (_super) {
                 camera: _this.internalCamera
             });
             var stillLoading = _this._numOfEntitiesToProcess > 0;
+            var deferRenderWhileLoading = stillLoading && !_this._progressiveRendering;
             if (!_this._isDirty && !stillLoading)
                 return;
+            if (deferRenderWhileLoading)
+                return;
             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 = stillLoading || needsRedraw;
+            _this._isDirty = (_this._progressiveRendering && stillLoading) || needsRedraw;
         };
+        _this._gripManager = new AcEdGripManager(_this);
+        _this._keyHandler = new AcEdViewKeyHandler(_this);
         if (options.calculateSizeCallback) {
             _this.setCalculateSizeCallback(options.calculateSizeCallback);
         }
@@ -218,8 +277,11 @@ var AcTrView2d = /** @class */ (function (_super) {
             });
         });
         _this._scene = _this.createScene();
+        _this._layerAppearance = new AcTrLayerAppearanceController(_this._scene, _this._renderer);
+        _this._inheritedLayerMaterialMapper = new AcTrInheritedLayerMaterialMapper(function (layerName) { return _this._layerAppearance.getEffectiveLayerTraits(layerName); }, _this._renderer);
         // Initialize background color through setter to keep renderer/cursor in sync.
-        _this.backgroundColor = (_b = mergedOptions.background) !== null && _b !== void 0 ? _b : MODEL_SPACE_BACKGROUND;
+        _this.backgroundColor =
+            (_b = mergedOptions.background) !== null && _b !== void 0 ? _b : ACGI_MODEL_SPACE_BACKGROUND;
         _this._stats = _this.createStats(AcApSettingManager.instance.isShowStats);
         // Layout background sysvars drive the canvas clear colour and ACI-7
         // inversion (`MODELBKCOLOR` for model space, `PAPERBKCOLOR` for the
@@ -251,7 +313,8 @@ var AcTrView2d = /** @class */ (function (_super) {
         var canHandleSelectionGesture = function () {
             return (_this.mode === AcEdViewMode.SELECTION &&
                 !_this.editor.isActive &&
-                !AcEdMTextEditor.getActiveInputBox());
+                !AcEdMTextEditor.getActiveInputBox() &&
+                !_this._gripManager.isDragging);
         };
         var clearSelectionPreview = function () {
             selectionPreviewEl === null || selectionPreviewEl === void 0 ? void 0 : selectionPreviewEl.remove();
@@ -297,6 +360,12 @@ var AcTrView2d = /** @class */ (function (_super) {
             selectionPreviewEl.style.setProperty('--line-color', style.lineColor);
         });
         _this.canvas.addEventListener('mouseup', function (e) {
+            if (_this._gripManager.isDragging) {
+                selectionStartWcs = null;
+                selectionStartCanvas = null;
+                clearSelectionPreview();
+                return;
+            }
             if (!selectionStartWcs || !selectionStartCanvas)
                 return;
             var endCanvas = _this.viewportToCanvas({
@@ -339,31 +408,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         // such as the canvas or the entire document. This can interfere with other event listeners you
         // add, including the keydown event.
         document.addEventListener('keydown', function (e) {
-            // Ignore global shortcuts while typing or during IME composition.
-            var target = e.target;
-            var isEditableTarget = target instanceof HTMLInputElement ||
-                target instanceof HTMLTextAreaElement ||
-                (target === null || target === void 0 ? void 0 : target.isContentEditable) === true;
-            // keyCode 229 is commonly reported by IME composing key events.
-            var isImeComposing = e.isComposing || e.keyCode === 229;
-            if (isEditableTarget || isImeComposing) {
-                return;
-            }
-            switch (e.code) {
-                case 'Escape':
-                    _this.selectionSet.clear();
-                    break;
-                case 'Delete':
-                case 'Backspace':
-                    // Only dispatch erase when no command is currently active.
-                    // Dispatching erase mid-command (e.g. while LINE awaits the next
-                    // point) corrupts the active command's input pipeline because
-                    // sendStringToExecute clears scripted inputs unconditionally.
-                    if (!_this.editor.isActive) {
-                        AcApDocManager.instance.sendStringToExecute('erase');
-                    }
-                    break;
-            }
+            _this._keyHandler.handleKeyDown(e);
         });
         acdbHostApplicationServices().layoutManager.events.layoutSwitched.addEventListener(function (args) {
             var btrId = args.layout.blockTableRecordId;
@@ -419,9 +464,18 @@ var AcTrView2d = /** @class */ (function (_super) {
         _this._css2dRenderer.domElement.style.left = '0px';
         _this._css2dRenderer.domElement.style.pointerEvents = 'none';
         _this._css2dRenderer.domElement.style.zIndex = '99998';
+        _this._css2dRenderer.domElement.style.maxWidth = '100%';
+        _this._css2dRenderer.domElement.style.maxHeight = '100%';
         container.appendChild(_this._css2dRenderer.domElement);
         _this._missedImages = new Map();
         _this._layoutViewManager = new AcTrLayoutViewManager();
+        _this._progressiveOpenFit = new AcTrProgressiveOpenFitController(function (box, margin) {
+            _this.activeLayoutView.zoomTo(box, margin !== null && margin !== void 0 ? margin : 1.1);
+            _this._isDirty = true;
+        });
+        _this._entityDisplay = new AcTrEntityDisplayController(function (layerName) {
+            return _this.resolveLayerInfo(layerName);
+        });
         _this.initialize();
         _this.onWindowResize();
         _this._isDirty = true;
@@ -479,6 +533,14 @@ var AcTrView2d = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcTrView2d.prototype, "gripManager", {
+        /** Grip point manager for the view (Write mode only). */
+        get: function () {
+            return this._gripManager;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(AcTrView2d.prototype, "isDirty", {
         /**
          * Gets whether the view needs to be re-rendered.
@@ -499,6 +561,46 @@ var AcTrView2d = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcTrView2d.prototype, "isProcessingEntities", {
+        /**
+         * True while {@link addEntity} batch-conversion callbacks are 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;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcTrView2d.prototype, "progressiveRendering", {
+        /**
+         * Whether entity conversion during document open is deferred for progressive display.
+         */
+        get: function () {
+            return this._progressiveRendering;
+        },
+        set: function (value) {
+            this._progressiveRendering = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Enables progressive camera framing while entities are batch-converted at
+     * document open. Pair with {@link zoomToFitDrawing} for the final accurate fit.
+     */
+    AcTrView2d.prototype.beginProgressiveOpenFit = function () {
+        this._progressiveOpenFit.begin(this._numOfEntitiesToProcess);
+    };
+    /**
+     * Disables progressive open framing after the final zoom-to-fit runs.
+     */
+    AcTrView2d.prototype.endProgressiveOpenFit = function () {
+        this._progressiveOpenFit.end();
+    };
     Object.defineProperty(AcTrView2d.prototype, "missedData", {
         /**
          * Gets information about missing data during rendering (fonts and images).
@@ -552,8 +654,9 @@ var AcTrView2d = /** @class */ (function (_super) {
      */
     AcTrView2d.prototype.applyCanvasBackground = function (value) {
         this._renderer.setClearColor(value);
+        // Updates style-manager background, repaints ACI-7 / bg-follow materials.
         this._renderer.currentBackgroundColor = value;
-        this._renderer.changeBackground(value);
+        this._layerAppearance.refreshTextMaterialsInObjectTree(this._scene.internalScene);
         this.editor.syncCursorBackground(value);
         this._isDirty = true;
     };
@@ -563,11 +666,21 @@ var AcTrView2d = /** @class */ (function (_super) {
         }
         return isModelSpaceDatabase(database);
     };
+    /**
+     * Binds the active drawing database on the renderer draw context.
+     *
+     * Called before document read so layer-table traits are available while layers
+     * are appended during open, and again after open to refresh display sysvars.
+     */
+    AcTrView2d.prototype.bindDrawDatabase = function (database) {
+        this._renderer.context.database = database;
+    };
     /**
      * Re-reads layout background sysvars from the active database. Called after
      * a document is opened so DWG-stored values take effect.
      */
     AcTrView2d.prototype.syncDisplaySysVars = function (database) {
+        this.bindDrawDatabase(database);
         this.applyCanvasBackground(readLayoutBackgroundColor(database, this.isModelSpaceLayout(database)));
     };
     /**
@@ -641,6 +754,55 @@ var AcTrView2d = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Converts every drawable entity into the scene before offline export.
+     *
+     * Interactive viewing skips off/frozen layers for performance; HTML snapshots
+     * store layer visibility separately and need full geometry so the exported
+     * layer panel can toggle layers on later.
+     *
+     * Converted geometry remains in the live scene after this call completes.
+     */
+    AcTrView2d.prototype.ensureEntitiesConvertedForExport = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var includeInvisibleLayers, db, pending, _a, _b, _c, layoutBtrId, blockTableRecord;
+            var e_1, _d;
+            var _this = this;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        includeInvisibleLayers = (options === null || options === void 0 ? void 0 : options.includeInvisibleLayers) !== false;
+                        db = AcApDocManager.instance.curDocument.database;
+                        pending = [];
+                        try {
+                            for (_a = __values(this._scene.layouts), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                _c = __read(_b.value, 1), layoutBtrId = _c[0];
+                                blockTableRecord = db.tables.blockTable.getIdAt(layoutBtrId);
+                                if (!blockTableRecord) {
+                                    continue;
+                                }
+                                pending.push.apply(pending, __spreadArray([], __read(this._entityDisplay.collectMissingEntitiesForExport(blockTableRecord, function (objectId) { return _this.hasEntity(objectId); }, includeInvisibleLayers)), false));
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        if (pending.length === 0) {
+                            return [2 /*return*/];
+                        }
+                        this._numOfEntitiesToProcess += pending.length;
+                        return [4 /*yield*/, this.batchConvert(pending, { forExport: true })];
+                    case 1:
+                        _e.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     Object.defineProperty(AcTrView2d.prototype, "internalScene", {
         /**
          * The internal THREE scene used by this view.
@@ -736,15 +898,12 @@ var AcTrView2d = /** @class */ (function (_super) {
         var _this = this;
         if (timeout === void 0) { timeout = 0; }
         var waiter = new AcEdConditionWaiter(function () { return _this._numOfEntitiesToProcess <= 0; }, function () {
-            if (layoutBtrId &&
-                _this._externallyFramedLayouts.delete(layoutBtrId)) {
+            if (layoutBtrId && _this._externallyFramedLayouts.delete(layoutBtrId)) {
+                _this.endProgressiveOpenFit();
                 return;
             }
-            var box = _this.resolveLayoutFitBox();
-            if (box) {
-                _this.zoomTo(box);
-                _this._isDirty = true;
-            }
+            _this._progressiveOpenFit.applyFinalFit(function () { return _this.resolveLayoutFitBox(); });
+            _this.endProgressiveOpenFit();
         }, 300, // check every 300 ms
         timeout);
         waiter.start();
@@ -800,13 +959,18 @@ var AcTrView2d = /** @class */ (function (_super) {
     };
     AcTrView2d.prototype.editMTextEntity = function (mtext) {
         return __awaiter(this, void 0, void 0, function () {
-            var editor, applied, result;
+            var db, editor, applied, result_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        db = mtext.database;
                         if (mtext.lineSpacingFactor !== AcEdMTextEditor.defaultLineSpacingFactor) {
-                            mtext.lineSpacingFactor = AcEdMTextEditor.defaultLineSpacingFactor;
-                            mtext.triggerModifiedEvent();
+                            acapRunDatabaseEdit(db, 'Edit MText', function () {
+                                var opened = db.openEntityForWrite(mtext);
+                                if (!(opened instanceof AcDbMText))
+                                    return;
+                                opened.lineSpacingFactor = AcEdMTextEditor.defaultLineSpacingFactor;
+                            });
                         }
                         // Hide the in-scene MTEXT while the inline editor renders its own copy; otherwise
                         // both draw at once (double text) when the user double-clicks to edit.
@@ -827,16 +991,20 @@ var AcTrView2d = /** @class */ (function (_super) {
                                 toolbarFontFamilies: this.getMTextToolbarFontFamilies()
                             })];
                     case 2:
-                        result = _a.sent();
-                        if (!result)
+                        result_1 = _a.sent();
+                        if (!result_1)
                             return [2 /*return*/];
-                        mtext.location = result.location;
-                        mtext.contents = result.contents;
-                        mtext.width = result.width;
-                        mtext.height = result.height;
-                        mtext.lineSpacingFactor = result.lineSpacingFactor;
-                        mtext.attachmentPoint = result.attachmentPoint;
-                        mtext.triggerModifiedEvent();
+                        acapRunDatabaseEdit(db, 'Edit MText', function () {
+                            var opened = db.openEntityForWrite(mtext);
+                            if (!(opened instanceof AcDbMText))
+                                return;
+                            opened.location = result_1.location;
+                            opened.contents = result_1.contents;
+                            opened.width = result_1.width;
+                            opened.height = result_1.height;
+                            opened.lineSpacingFactor = result_1.lineSpacingFactor;
+                            opened.attachmentPoint = result_1.attachmentPoint;
+                        });
                         applied = true;
                         return [3 /*break*/, 4];
                     case 3:
@@ -897,7 +1065,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * don't have to land pixel-perfect on the viewport line to grab it.
      */
     AcTrView2d.prototype.pick = function (point, hitRadius, pickOneOnly) {
-        var e_1, _a;
+        var e_2, _a;
         if (point == null)
             point = this.curPos;
         var results = [];
@@ -928,12 +1096,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                     }
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_1) throw e_1.error; }
+                finally { if (e_2) throw e_2.error; }
             }
         }
         // 1) Resolve hits in the active layout. Skip the `AcDbViewport`
@@ -945,6 +1113,8 @@ var AcTrView2d = /** @class */ (function (_super) {
         firstQueryResults.forEach(function (item) {
             if (drillThroughViewportIds.has(item.id))
                 return;
+            if (!isEffectiveSpatialQueryHit(item))
+                return;
             if (activeLayout.isIntersectWith(item.id, raycaster)) {
                 results.push(item);
             }
@@ -974,7 +1144,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * paper-space pick.
      */
     AcTrView2d.prototype.pickThroughViewports = function (paperPoint, paperBox, viewports, results) {
-        var e_2, _a;
+        var e_3, _a;
         var modelLayout = this._scene.modelSpaceLayout;
         if (!modelLayout)
             return;
@@ -996,6 +1166,8 @@ var AcTrView2d = /** @class */ (function (_super) {
             var vpRaycaster = vpView.resetRaycaster(modelPt, modelRadius);
             var modelHits = modelLayout.search(modelBox);
             modelHits.forEach(function (item) {
+                if (!isEffectiveSpatialQueryHit(item))
+                    return;
                 if (modelLayout.isIntersectWith(item.id, vpRaycaster)) {
                     results.push(item);
                 }
@@ -1007,19 +1179,19 @@ var AcTrView2d = /** @class */ (function (_super) {
                 _loop_1(vpView);
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
         finally {
             try {
                 if (viewports_1_1 && !viewports_1_1.done && (_a = viewports_1.return)) _a.call(viewports_1);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_3) throw e_3.error; }
         }
     };
     /**
      * @inheritdoc
      */
-    AcTrView2d.prototype.search = function (box) {
-        return this._scene.search(box);
+    AcTrView2d.prototype.search = function (box, options) {
+        return this._scene.search(box, options);
     };
     /**
      * @inheritdoc
@@ -1041,61 +1213,22 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @inheritdoc
      */
     AcTrView2d.prototype.addLayer = function (layer) {
-        var updatedLayers = this._scene.addLayer({
-            name: layer.name,
-            isFrozen: layer.isFrozen,
-            isOff: layer.isOff,
-            color: layer.color
-        });
-        var traits = {
-            layer: layer.name,
-            color: layer.color.clone(),
-            rgbColor: layer.color.RGB,
-            lineType: layer.lineStyle,
-            lineWeight: layer.lineWeight,
-            transparency: layer.transparency
-        };
-        var materials = this._renderer.updateLayerMaterial(layer.name, traits);
-        updatedLayers.forEach(function (updatedLayer) {
-            for (var id in materials) {
-                var material = materials[id];
-                updatedLayer.updateMaterial(Number(id), material);
-            }
-        });
+        this._scene.addLayer(this.toLayerInfo(layer));
+        this._layerAppearance.syncFromLiveRecord(layer);
         this._isDirty = true;
     };
     /**
      * @inheritdoc
      */
     AcTrView2d.prototype.updateLayer = function (layer, changes) {
-        var updatedLayers = this._scene.updateLayer({
-            name: layer.name,
-            isFrozen: layer.isFrozen,
-            isOff: layer.isOff,
-            color: layer.color
-        });
-        var traits = {};
-        if (changes.color) {
-            traits.color = changes.color.clone();
-            traits.rgbColor = changes.color.RGB;
-        }
-        if (changes.lineStyle) {
-            traits.lineType = layer.lineStyle;
+        this._scene.updateLayer(this.toLayerInfo(layer));
+        if (this._layerAppearance.layerStyleMayHaveChanged(changes)) {
+            this._layerAppearance.syncFromLiveRecord(layer);
         }
-        if (changes.lineWeight !== undefined) {
-            traits.lineWeight = changes.lineWeight;
+        if (this._entityDisplay.layerVisibilityMayHaveChanged(changes) &&
+            AcTrLayer.isLayerVisible(this.toLayerInfo(layer))) {
+            void this.convertMissingEntitiesOnLayer(layer.name);
         }
-        if (changes.transparency !== undefined) {
-            traits.transparency = changes.transparency;
-        }
-        traits.layer = layer.name; // always present
-        var materials = this._renderer.updateLayerMaterial(layer.name, traits);
-        updatedLayers.forEach(function (layer) {
-            for (var id in materials) {
-                var material = materials[id];
-                layer.updateMaterial(Number(id), material);
-            }
-        });
         this._isDirty = true;
     };
     /**
@@ -1109,6 +1242,7 @@ var AcTrView2d = /** @class */ (function (_super) {
             var threeEntity = this.drawEntity(entity_1, true);
             if (threeEntity) {
                 threeEntity.objectId = entity_1.objectId;
+                threeEntity.syncDraw();
                 this._scene.addTransientEntity(threeEntity);
                 this._isDirty = true;
             }
@@ -1122,6 +1256,49 @@ var AcTrView2d = /** @class */ (function (_super) {
         this._scene.removeTransientEntity(objectId);
         this._isDirty = true;
     };
+    /**
+     * @inheritdoc
+     */
+    AcTrView2d.prototype.canCreateEntityPreview = function (entityIds) {
+        return this._scene.canCreatePreview(entityIds);
+    };
+    /**
+     * @inheritdoc
+     */
+    AcTrView2d.prototype.createEntityPreview = function (entityIds) {
+        var handleId = this._scene.createPreview(entityIds);
+        if (handleId) {
+            this._isDirty = true;
+        }
+        return handleId;
+    };
+    /**
+     * @inheritdoc
+     */
+    AcTrView2d.prototype.updateEntityPreview = function (handleId, matrix) {
+        if (this._scene.updatePreview(handleId, AcTrMatrixUtil.createMatrix4(matrix))) {
+            this._isDirty = true;
+        }
+    };
+    /**
+     * @inheritdoc
+     */
+    AcTrView2d.prototype.removeEntityPreview = function (handleId) {
+        if (this._scene.removePreview(handleId)) {
+            this._isDirty = true;
+        }
+    };
+    /**
+     * @inheritdoc
+     */
+    AcTrView2d.prototype.updateTransientPreviewTransforms = function (transforms) {
+        if (this._scene.updateTransientPreviewTransforms(transforms.map(function (entry) { return ({
+            objectId: entry.objectId,
+            matrix: AcTrMatrixUtil.createMatrix4(entry.matrix)
+        }); }))) {
+            this._isDirty = true;
+        }
+    };
     /**
      * @inheritdoc
      */
@@ -1129,7 +1306,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         var _this = this;
         var entities = Array.isArray(entity) ? entity : [entity];
         this._numOfEntitiesToProcess += entities.length;
-        setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+        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)];
@@ -1138,8 +1315,14 @@ var AcTrView2d = /** @class */ (function (_super) {
                         return [2 /*return*/];
                 }
             });
-        }); });
-        this._isDirty = true;
+        }); };
+        if (this._progressiveRendering) {
+            setTimeout(convert);
+            this._isDirty = true;
+        }
+        else {
+            void convert();
+        }
     };
     /**
      * @inheritdoc
@@ -1192,28 +1375,30 @@ var AcTrView2d = /** @class */ (function (_super) {
         this._scene.setEntityVisible(objectId, false);
     };
     /**
-     * @inheritdoc
+     * Rebuilds scene geometry for entities whose shape or styling changed.
+     *
+     * Pure translations should use {@link translateEntity} instead.
      */
     AcTrView2d.prototype.updateEntity = function (entity) {
         var _this = this;
-        var entities = [];
-        if (Array.isArray(entity)) {
-            entities = entity;
-        }
-        else {
-            entities.push(entity);
-        }
+        var entities = Array.isArray(entity) ? entity : [entity];
+        var selectedIds = entities
+            .map(function (item) { return item.objectId; })
+            .filter(function (objectId) { return _this.selectionSet.has(objectId); });
         for (var i = 0; i < entities.length; ++i) {
             var entity_2 = entities[i];
-            var threeEntity = entity_2.worldDraw(this._renderer);
-            if (threeEntity) {
-                threeEntity.objectId = entity_2.objectId;
-                threeEntity.ownerId = entity_2.ownerId;
-                threeEntity.layerName = entity_2.layer;
-                threeEntity.visible = entity_2.visibility;
-                this._scene.updateEntity(threeEntity);
+            if (this._scene.hasEntity(entity_2.objectId)) {
+                this._scene.removeEntity(entity_2.objectId);
             }
         }
+        // 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();
+        });
         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
@@ -1408,6 +1593,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         if (layoutView == null) {
             layoutView = new AcTrLayoutView(this._renderer, layoutBtrId, this.width, this.height);
             layoutView.events.viewChanged.addEventListener(function () {
+                _this._progressiveOpenFit.onLayoutViewChanged();
                 _this._isDirty = true;
                 _this.events.viewChanged.dispatch();
                 _this.clearHover();
@@ -1438,7 +1624,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @param layoutBtrId Input the block table record id of the layout
      */
     AcTrView2d.prototype.loadLayoutEntitiesIfNeeded = function (layoutBtrId) {
-        var e_3, _a;
+        var e_4, _a;
         var _this = this;
         try {
             var db = AcApDocManager.instance.curDocument.database;
@@ -1509,12 +1695,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                     entities_1.push(entity);
                 }
             }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
             finally {
                 try {
                     if (iterator_1_1 && !iterator_1_1.done && (_a = iterator_1.return)) _a.call(iterator_1);
                 }
-                finally { if (e_3) throw e_3.error; }
+                finally { if (e_4) throw e_4.error; }
             }
             if (entities_1.length === 0) {
                 // Empty layout (e.g. a freshly-created paper space tab). Mark as
@@ -1525,10 +1711,10 @@ var AcTrView2d = /** @class */ (function (_super) {
                 }
                 return;
             }
-            // Load entities asynchronously
+            // Load entities asynchronously when progressive rendering is enabled.
             this._loadingLayouts.add(layoutBtrId);
             this._numOfEntitiesToProcess += entities_1.length;
-            setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+            var convert = function () { return __awaiter(_this, void 0, void 0, function () {
                 var layout;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
@@ -1548,7 +1734,13 @@ var AcTrView2d = /** @class */ (function (_super) {
                         case 3: return [2 /*return*/];
                     }
                 });
-            }); });
+            }); };
+            if (this._progressiveRendering) {
+                setTimeout(convert);
+            }
+            else {
+                void convert();
+            }
         }
         catch (error) {
             log.error('[AcTrView2d] Error loading layout entities:', error);
@@ -1567,9 +1759,91 @@ var AcTrView2d = /** @class */ (function (_super) {
             stats.dom.style.display = 'none'; // Hide the stats
         }
     };
+    AcTrView2d.prototype.toLayerInfo = function (layer) {
+        return {
+            name: layer.name,
+            isFrozen: layer.isFrozen,
+            isOff: layer.isOff,
+            color: layer.color
+        };
+    };
+    AcTrView2d.prototype.resolveLayerInfo = function (layerName) {
+        var layer = AcApDocManager.instance.curDocument.database.tables.layerTable.getAt(layerName);
+        return layer ? this.toLayerInfo(layer) : undefined;
+    };
+    /**
+     * Converts entities on the given layer that were skipped while the layer was
+     * off/frozen and therefore are not yet present in the scene.
+     */
+    AcTrView2d.prototype.convertMissingEntitiesOnLayer = function (layerName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var db, blockTableRecord, pending_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this._convertingLayers.has(layerName)) {
+                            return [2 /*return*/];
+                        }
+                        this._convertingLayers.add(layerName);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 3, 4]);
+                        db = AcApDocManager.instance.curDocument.database;
+                        blockTableRecord = db.tables.blockTable.getIdAt(this.activeLayoutBtrId);
+                        if (!blockTableRecord) {
+                            return [2 /*return*/];
+                        }
+                        pending_1 = this._entityDisplay.collectMissingEntitiesOnLayer(layerName, blockTableRecord, function (objectId) { return _this.hasEntity(objectId); });
+                        if (pending_1.length === 0) {
+                            return [2 /*return*/];
+                        }
+                        this._numOfEntitiesToProcess += pending_1.length;
+                        return [4 /*yield*/, this.batchConvert(pending_1)];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        this._convertingLayers.delete(layerName);
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
     AcTrView2d.prototype.drawEntity = function (entity, delay) {
         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}.
+     */
+    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();
+                            return [2 /*return*/];
+                        }
+                        if (!progressive) return [3 /*break*/, 2];
+                        return [4 /*yield*/, threeEntity.asyncDraw()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 2:
+                        if (threeEntity.hasDrawableGeometry()) {
+                            return [2 /*return*/];
+                        }
+                        threeEntity.syncDraw();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Walks the given block table record once and creates one
      * `AcTrViewportView` for every real `AcDbViewport` entity it finds
@@ -1589,7 +1863,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * paper layouts.
      */
     AcTrView2d.prototype.ensureViewportViews = function (blockTableRecord, layoutView) {
-        var e_4, _a;
+        var e_5, _a;
         var iterator = blockTableRecord.newIterator();
         try {
             for (var iterator_2 = __values(iterator), iterator_2_1 = iterator_2.next(); !iterator_2_1.done; iterator_2_1 = iterator_2.next()) {
@@ -1602,12 +1876,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 layoutView.addViewport(viewportView);
             }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
         finally {
             try {
                 if (iterator_2_1 && !iterator_2_1.done && (_a = iterator_2.return)) _a.call(iterator_2);
             }
-            finally { if (e_4) throw e_4.error; }
+            finally { if (e_5) throw e_5.error; }
         }
     };
     /**
@@ -1615,20 +1889,23 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @param entities - The database entities
      * @returns The converted three entities
      */
-    AcTrView2d.prototype.batchConvert = function (entities) {
-        return __awaiter(this, void 0, void 0, function () {
-            var i, entity, threeEntity, isExtendBbox, layoutView, viewportView, fileName, error_1;
+    AcTrView2d.prototype.batchConvert = function (entities_2) {
+        return __awaiter(this, arguments, void 0, function (entities, options) {
+            var progressive, i, entity, shouldConvert, threeEntity, isExtendBbox, layoutView, viewportView, fileName, error_1;
+            var _this = this;
+            if (options === void 0) { options = {}; }
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        progressive = this._progressiveRendering && !options.forExport;
                         i = 0;
                         _a.label = 1;
                     case 1:
-                        if (!(i < entities.length)) return [3 /*break*/, 9];
+                        if (!(i < entities.length)) return [3 /*break*/, 11];
                         entity = entities[i];
                         _a.label = 2;
                     case 2:
-                        _a.trys.push([2, 6, 7, 8]);
+                        _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
@@ -1642,40 +1919,55 @@ var AcTrView2d = /** @class */ (function (_super) {
                         // parsers).
                         if (entity instanceof AcDbViewport &&
                             AcTrViewportView.isDefaultPaperSpaceViewport(entity)) {
-                            return [3 /*break*/, 8];
+                            return [3 /*break*/, 10];
                         }
-                        if (!entity.visibility) {
-                            return [3 /*break*/, 8];
+                        shouldConvert = options.forExport
+                            ? this._entityDisplay.shouldConvertForExport(entity)
+                            : this._entityDisplay.shouldConvert(entity);
+                        if (!shouldConvert) {
+                            return [3 /*break*/, 10];
                         }
-                        threeEntity = this.drawEntity(entity, true);
-                        if (!threeEntity)
-                            return [3 /*break*/, 8];
+                        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;
+                        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.remapInheritedLayerObjects(threeEntity.children, '0', threeEntity.layerName);
+                            this._inheritedLayerMaterialMapper.remap(threeEntity.children, '0', threeEntity.layerName);
                         }
                         if (!(threeEntity instanceof AcTrGroup &&
-                            !threeEntity.isOnTheSameLayer)) return [3 /*break*/, 3];
-                        this.handleGroup(threeEntity);
-                        return [3 /*break*/, 5];
+                            !threeEntity.isOnTheSameLayer)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.handleGroup(threeEntity, progressive)];
                     case 3:
-                        isExtendBbox = !(entity instanceof AcDbRay || entity instanceof AcDbXline);
-                        return [4 /*yield*/, threeEntity.draw()];
+                        _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;
-                        _a.label = 5;
-                    case 5:
+                        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
@@ -1695,229 +1987,155 @@ var AcTrView2d = /** @class */ (function (_super) {
                             if (fileName)
                                 this._missedImages.set(entity.objectId, fileName);
                         }
-                        return [3 /*break*/, 8];
-                    case 6:
+                        return [3 /*break*/, 10];
+                    case 8:
                         error_1 = _a.sent();
                         log.error("[AcTrView2d] Failed to convert entity ".concat(entity.objectId, " (").concat(entity.type, "):"), error_1);
-                        return [3 /*break*/, 8];
-                    case 7:
+                        return [3 /*break*/, 10];
+                    case 9:
                         this.decreaseNumOfEntitiesToProcess();
                         return [7 /*endfinally*/];
-                    case 8:
+                    case 10:
                         ++i;
                         return [3 /*break*/, 1];
-                    case 9: return [2 /*return*/];
+                    case 11: return [2 /*return*/];
                 }
             });
         });
     };
-    AcTrView2d.prototype.handleGroup = function (group) {
-        var e_5, _a;
-        var _this = this;
-        var children = group.children;
-        var objectsGroupByLayer = new Map();
-        children.forEach(function (child) {
-            var _a;
-            if (!child.visible) {
-                return;
-            }
-            var layerName = child.userData.layerName;
-            if (!objectsGroupByLayer.has(layerName)) {
-                objectsGroupByLayer.set(layerName, []);
-            }
-            (_a = objectsGroupByLayer.get(layerName)) === null || _a === void 0 ? void 0 : _a.push(child);
-        });
-        // Important:
-        // Sometimes one group may contain huge amount of objects (> 100,000). So it is important
-        // to re-parent object with the fast approach. Calling add/remove method in THREE.Object3D
-        // is very slow because it do lots of things
-        // - Remove children from old group
-        // - Insert them into new group
-        // - Reset parent pointer
-        // - Do one updateMatrixWorld() at the end (optional)
-        // So we operate its children directly.
-        group.children = [];
-        try {
-            for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
-                var child = children_1_1.value;
-                child.parent = null;
-            }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
-            }
-            finally { if (e_5) throw e_5.error; }
-        }
-        var styleManager = group.styleManager;
-        var groupObjectId = group.objectId;
-        var groupLayerName = group.layerName;
-        var worldGroupBox = group.box.clone();
-        worldGroupBox.applyMatrix4(group.matrix);
-        var groupChildBoxes = group.boxes.map(function (box) {
-            var e_6, _a, e_7, _b;
-            var points = [
-                new THREE.Vector3(box.minX, box.minY, 0),
-                new THREE.Vector3(box.maxX, box.minY, 0),
-                new THREE.Vector3(box.maxX, box.maxY, 0),
-                new THREE.Vector3(box.minX, box.maxY, 0)
-            ];
-            try {
-                for (var points_1 = __values(points), points_1_1 = points_1.next(); !points_1_1.done; points_1_1 = points_1.next()) {
-                    var point = points_1_1.value;
-                    point.applyMatrix4(group.matrix);
-                }
-            }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (points_1_1 && !points_1_1.done && (_a = points_1.return)) _a.call(points_1);
-                }
-                finally { if (e_6) throw e_6.error; }
-            }
-            var minX = Infinity;
-            var minY = Infinity;
-            var maxX = -Infinity;
-            var maxY = -Infinity;
-            try {
-                for (var points_2 = __values(points), points_2_1 = points_2.next(); !points_2_1.done; points_2_1 = points_2.next()) {
-                    var point = points_2_1.value;
-                    minX = Math.min(minX, point.x);
-                    minY = Math.min(minY, point.y);
-                    maxX = Math.max(maxX, point.x);
-                    maxY = Math.max(maxY, point.y);
-                }
-            }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
-            finally {
-                try {
-                    if (points_2_1 && !points_2_1.done && (_b = points_2.return)) _b.call(points_2);
-                }
-                finally { if (e_7) throw e_7.error; }
-            }
-            return {
-                minX: minX,
-                minY: minY,
-                maxX: maxX,
-                maxY: maxY,
-                id: box.id
-            };
-        });
-        objectsGroupByLayer.forEach(function (objects, layerName) {
-            // AutoCAD block rule: entities authored on layer "0" inherit the INSERT's layer.
-            // Non-zero layers keep their original layer name.
-            var effectiveLayerName = layerName === '0' ? groupLayerName : layerName;
-            // Keep runtime layer metadata/material cache aligned with the inherited layer so
-            // later layer style edits (color, linetype, lineweight, transparency) target this
-            // object set correctly.
-            _this.remapInheritedLayerObjects(objects, layerName, effectiveLayerName);
-            // One INSERT can expand to children from multiple layers. Here we create one
-            // render entity per layer bucket but preserve the INSERT object id for all
-            // buckets, so selection/highlight still maps back to the same database object.
-            // Within each layer bucket, the object id remains unique in scene indexing.
-            var entity = new AcTrEntity(styleManager);
-            entity.applyMatrix4(group.matrix);
-            entity.objectId = groupObjectId;
-            entity.ownerId = group.ownerId;
-            // If block-definition entities are on layer "0", this bucket now uses the layer
-            // of the block reference itself (effectiveLayerName).
-            entity.layerName = effectiveLayerName;
-            entity.box = worldGroupBox;
-            var entityUserData = entity.userData;
-            entityUserData.spatialIndexChildBoxes = groupChildBoxes;
-            // 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
-            for (var i = 0; i < objects.length; i++) {
-                entity.add(objects[i]);
-            }
-            _this._scene.addEntity(entity, true);
-            _this.applySessionHiddenObjectState(groupObjectId);
-            entity.dispose();
-        });
-        group.dispose();
-        this._isDirty = true;
-    };
     /**
-     * Remaps layer metadata/material bindings from a source layer to the effective render layer.
-     *
-     * During block decomposition, one INSERT may be split into multiple layer buckets. For
-     * children authored on layer "0", AutoCAD requires inheriting the INSERT's own layer.
-     * This method applies that inheritance by mutating each child's `userData.layerName` and
-     * re-binding materials via renderer cache, so subsequent layer-level style changes still
-     * hit the correct material instances.
-     *
-     * @param objects - Root objects in the current layer bucket to traverse and remap.
-     * @param sourceLayerName - Layer name found in block definition before inheritance.
-     * @param effectiveLayerName - Final layer name used by rendering and style updates.
+     * Rebuilds block-reference child boxes and aligns aggregate {@link AcTrGroup.wcsBbox}
+     * with their union before spatial-index registration.
      */
-    AcTrView2d.prototype.remapInheritedLayerObjects = function (objects, sourceLayerName, effectiveLayerName) {
-        var e_8, _a;
-        var _this = this;
-        if (sourceLayerName === effectiveLayerName)
+    AcTrView2d.prototype.syncGroupSpatialBoundsForIndexing = function (group) {
+        group.refreshWcsChildBoxesFromChildren();
+        if (group.wcsChildBoxes.length === 0) {
             return;
-        var renderer = this._renderer;
-        var layerTraits = this.getEffectiveLayerTraits(effectiveLayerName);
-        try {
-            for (var objects_1 = __values(objects), objects_1_1 = objects_1.next(); !objects_1_1.done; objects_1_1 = objects_1.next()) {
-                var object = objects_1_1.value;
-                object.traverse(function (child) {
-                    if (child.userData.layerName === sourceLayerName) {
-                        child.userData.layerName = effectiveLayerName;
-                    }
-                    if (!('material' in child))
-                        return;
-                    var material = child.material;
-                    if (Array.isArray(material)) {
-                        var materials = material;
-                        child.material = materials.map(function (entry) {
-                            return renderer.getLayerBoundMaterial(_this.promoteLayerZeroByLayerColor(entry, sourceLayerName), effectiveLayerName, layerTraits);
-                        });
-                        return;
-                    }
-                    var remappedMaterial = renderer.getLayerBoundMaterial(_this.promoteLayerZeroByLayerColor(material, sourceLayerName), effectiveLayerName, layerTraits);
-                    child.material = remappedMaterial;
-                    child.userData.styleMaterialId = remappedMaterial.id;
-                });
-            }
-        }
-        catch (e_8_1) { e_8 = { error: e_8_1 }; }
-        finally {
-            try {
-                if (objects_1_1 && !objects_1_1.done && (_a = objects_1.return)) _a.call(objects_1);
-            }
-            finally { if (e_8) throw e_8.error; }
-        }
-    };
-    /**
-     * Some DXF conversion paths lose `isByLayerColor` on layer-0 block contents while still
-     * retaining other ByLayer markers (lineType/lineWeight/transparency). For AutoCAD-compatible
-     * INSERT inheritance, treat such colors as inheritable when remapping from layer "0".
-     */
-    AcTrView2d.prototype.promoteLayerZeroByLayerColor = function (material, sourceLayerName) {
-        var metadata = getMaterialMetadata(material);
-        var hasAnyOtherByLayerBinding = hasByLayerBinding(metadata) && metadata.isByLayerColor !== true;
-        if (sourceLayerName === '0' && hasAnyOtherByLayerBinding) {
-            setMaterialMetadata(material, { isByLayerColor: true });
         }
-        return material;
+        var childBoxes = group.wcsChildBoxes.map(function (box) { return ({
+            minX: box.minX,
+            minY: box.minY,
+            maxX: box.maxX,
+            maxY: box.maxY,
+            id: box.id
+        }); });
+        group.wcsBbox = unionGroupWcsChildBoxes(group);
+        var userData = group.userData;
+        userData.spatialIndexChildBoxes = childBoxes;
     };
-    /**
-     * Builds the resolved layer traits used when layer-0 block content inherits an INSERT layer.
-     */
-    AcTrView2d.prototype.getEffectiveLayerTraits = function (layerName) {
-        var layer = AcApDocManager.instance.curDocument.database.tables.layerTable.getAt(layerName);
-        if (!layer)
-            return undefined;
-        return {
-            layer: layer.name,
-            color: layer.color.clone(),
-            rgbColor: layer.color.RGB,
-            lineType: layer.lineStyle,
-            lineWeight: layer.lineWeight,
-            transparency: layer.transparency
-        };
+    AcTrView2d.prototype.handleGroup = function (group, progressive) {
+        return __awaiter(this, void 0, void 0, function () {
+            var children, objectsGroupByLayer, children_1, children_1_1, child, renderContext, groupObjectId, groupLayerName, groupChildBoxes, aggregateSpatialBbox;
+            var e_6, _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.finishEntityGeometry(group, progressive)];
+                    case 1:
+                        _b.sent();
+                        this.syncGroupSpatialBoundsForIndexing(group);
+                        children = group.children;
+                        objectsGroupByLayer = new Map();
+                        children.forEach(function (child) {
+                            var _a;
+                            if (child.visible === false) {
+                                return;
+                            }
+                            var layerName = child.userData.layerName;
+                            if (!objectsGroupByLayer.has(layerName)) {
+                                objectsGroupByLayer.set(layerName, []);
+                            }
+                            (_a = objectsGroupByLayer.get(layerName)) === null || _a === void 0 ? void 0 : _a.push(child);
+                        });
+                        // Important:
+                        // Sometimes one group may contain huge amount of objects (> 100,000). So it is important
+                        // to re-parent object with the fast approach. Calling add/remove method in THREE.Object3D
+                        // is very slow because it do lots of things
+                        // - Remove children from old group
+                        // - Insert them into new group
+                        // - Reset parent pointer
+                        // - Do one updateMatrixWorld() at the end (optional)
+                        // So we operate its children directly.
+                        group.children = [];
+                        try {
+                            for (children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
+                                child = children_1_1.value;
+                                child.parent = null;
+                            }
+                        }
+                        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                        finally {
+                            try {
+                                if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
+                            }
+                            finally { if (e_6) throw e_6.error; }
+                        }
+                        renderContext = group.renderContext;
+                        groupObjectId = group.objectId;
+                        groupLayerName = group.layerName;
+                        // AcDbRenderingCache.draw (and similar paths such as AcDbTable) already call
+                        // applyMatrix on the group, which updates wcsBbbox and wcsChildBoxes to WCS.
+                        // Do not multiply group.matrix here — that would double-transform spatial bounds.
+                        if (process.env.NODE_ENV !== 'production') {
+                            assertAcTrGroupWcsBboxesConsistent(group);
+                        }
+                        groupChildBoxes = group.wcsChildBoxes.map(function (box) { return ({
+                            minX: box.minX,
+                            minY: box.minY,
+                            maxX: box.maxX,
+                            maxY: box.maxY,
+                            id: box.id
+                        }); });
+                        aggregateSpatialBbox = groupChildBoxes.length > 0
+                            ? unionGroupWcsChildBoxes(group)
+                            : group.wcsBbox.clone();
+                        if (groupChildBoxes.length > 0) {
+                            group.wcsBbox = aggregateSpatialBbox.clone();
+                        }
+                        objectsGroupByLayer.forEach(function (objects, layerName) {
+                            // AutoCAD block rule: entities authored on layer "0" inherit the INSERT's layer.
+                            // Non-zero layers keep their original layer name.
+                            var effectiveLayerName = layerName === '0' ? groupLayerName : layerName;
+                            // Keep runtime layer metadata/material cache aligned with the inherited layer so
+                            // later layer style edits (color, linetype, lineweight, transparency) target this
+                            // object set correctly.
+                            _this._inheritedLayerMaterialMapper.remap(objects, layerName, effectiveLayerName);
+                            // One INSERT can expand to children from multiple layers. Here we create one
+                            // render entity per layer bucket but preserve the INSERT object id for all
+                            // buckets, so selection/highlight still maps back to the same database object.
+                            // Within each layer bucket, the object id remains unique in scene indexing.
+                            var entity = new AcTrEntity(renderContext);
+                            entity.applyMatrix4(group.matrix);
+                            entity.objectId = groupObjectId;
+                            entity.ownerId = group.ownerId;
+                            // If block-definition entities are on layer "0", this bucket now uses the layer
+                            // of the block reference itself (effectiveLayerName).
+                            entity.layerName = effectiveLayerName;
+                            entity.wcsBbox = aggregateSpatialBbox.clone();
+                            var entityUserData = entity.userData;
+                            entityUserData.spatialIndexChildBoxes = groupChildBoxes;
+                            // 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
+                            for (var i = 0; i < objects.length; i++) {
+                                entity.add(objects[i]);
+                            }
+                            _this._layerAppearance.refreshTextMaterialsInObjectTree(entity);
+                            _this._scene.addEntity(entity, true);
+                            _this.applySessionHiddenObjectState(groupObjectId);
+                            entity.dispose();
+                        });
+                        group.dispose();
+                        if (this._progressiveRendering) {
+                            this._isDirty = true;
+                            void this._progressiveOpenFit.afterGeometryBatch(function () {
+                                return _this.resolveLayoutFitBox();
+                            });
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
     };
     AcTrView2d.prototype.decreaseNumOfEntitiesToProcess = function () {
         this._numOfEntitiesToProcess--;
@@ -1925,6 +2143,10 @@ 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) {
+            this._isDirty = true;
+        }
     };
     return AcTrView2d;
 }(AcEdBaseView));