@mlightcad/cad-simple-viewer 1.4.13 → 1.5.1

package/lib/view/AcTrView2d.js

@@ -71,17 +71,18 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
-import { acdbHostApplicationServices, AcDbRasterImage, AcDbRay, AcDbSysVarManager, AcDbViewport, AcDbXline, AcGeBox2d, AcGePoint2d, log } from '@mlightcad/data-model';
+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 } from '@mlightcad/three-renderer';
+import { AcTrEntity, AcTrGroup, AcTrRenderer, AcTrViewportView, getMaterialMetadata, hasByLayerBinding, setMaterialMetadata } 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, AcEdViewMode, applyUiThemeFromBackground, eventBus } from '../editor';
+import { AcEdBaseView, AcEdConditionWaiter, AcEdCorsorType, AcEdMTextEditor, AcEdOpenMode, AcEdViewMode, applyUiThemeFromBackground, eventBus, resolvePointerSelectionAction } from '../editor';
 import { AcTrGeometryUtil } from '../util';
 import { AcTrLayoutView } from './AcTrLayoutView';
 import { AcTrLayoutViewManager } from './AcTrLayoutViewManager';
+import { sortPickResults } from './AcTrPickResultUtil';
 import { AcTrScene } from './AcTrScene';
 /**
  * Default view option values
@@ -144,6 +145,37 @@ var AcTrView2d = /** @class */ (function (_super) {
          * A value of `null` indicates that no animation frame is currently scheduled.
          */
         _this._rafId = null;
+        /**
+         * 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
+         * `AcTrLayout.isLoaded` to `true`, which would otherwise duplicate
+         * entities when the same layout tab is clicked twice in quick succession.
+         */
+        _this._loadingLayouts = new Set();
+        /**
+         * Block table record ids of layouts that have already received an
+         * initial zoom-to-fit. Used by the `layoutSwitched` handler to apply
+         * the auto-zoom **only on the first user visit** to each layout, and
+         * to preserve the camera state on subsequent visits (matches AutoCAD's
+         * per-tab view persistence).
+         *
+         * Cannot be inferred from `_layoutViewManager.has(btrId)` because
+         * `addLayout` pre-creates an `AcTrLayoutView` for every layout in the
+         * DWG at document load time — by the time the user clicks a layout
+         * tab the view already exists, so "first existence of view" is
+         * always false. This set tracks the orthogonal question "has the user
+         * actually focused on this layout before?".
+         *
+         * Marked from two entry points:
+         *  - `onAfterOpenDocument` (via `markLayoutAsInitialized`): the
+         *    document's startup layout is initialized externally, so we don't
+         *    auto-zoom again when the user clicks back to it.
+         *  - `layoutSwitched` handler: after the first user-driven switch
+         *    completes its initial zoom-to-fit.
+         */
+        _this._initializedLayouts = new Set();
         _this.animate = function () {
             var _a;
             _this._rafId = requestAnimationFrame(_this.animate);
@@ -179,11 +211,44 @@ var AcTrView2d = /** @class */ (function (_super) {
         // Initialize background color through setter to keep renderer/cursor/foreground in sync.
         _this.backgroundColor = mergedOptions.background || 0x000000;
         _this._stats = _this.createStats(AcApSettingManager.instance.isShowStats);
+        // Two sysvars can drive the canvas background:
+        //
+        // - WHITEBKCOLOR (boolean): the low-level "is the paper white?" flag
+        //   that the View has always honoured.
+        // - COLORTHEME (number): the AutoCAD-standard theme selector where
+        //   0 = dark theme (black bg) and 1 = light theme (white bg).
+        //
+        // The Vue composable `useDark` (cad-viewer) toggles only COLORTHEME
+        // when the user flips the theme.  Without this bridge, toggling the
+        // UI theme left WHITEBKCOLOR stale and the canvas kept its previous
+        // background even though `changeForeground` had been fired through
+        // MTEXT/line inversion — producing e.g. a black canvas in light mode
+        // or a white canvas in dark mode.
+        //
+        // Listening to both sysvars keeps either entry point working.  The
+        // two remain independent (settable in isolation) because setting
+        // `this.backgroundColor` is idempotent and the handler for each
+        // sysvar only fires when that specific variable changes.
         AcDbSysVarManager.instance().events.sysVarChanged.addEventListener(function (args) {
-            if (args.name === AcDbSystemVariables.WHITEBKCOLOR.toLowerCase()) {
+            var nameLower = args.name.toLowerCase();
+            if (nameLower === AcDbSystemVariables.WHITEBKCOLOR.toLowerCase()) {
                 var useWhiteBackgroundColor = args.newVal;
                 _this.backgroundColor = useWhiteBackgroundColor ? 0xffffff : 0;
             }
+            else if (nameLower === AcDbSystemVariables.COLORTHEME.toLowerCase()) {
+                // COLORTHEME is registered with type 'number' in the data-model
+                // (0 = dark, 1 = light), but the sysvar bus does not strictly
+                // coerce values.  Normalise defensively so plugins setting the
+                // value as a string or boolean still behave correctly.
+                var newVal = args.newVal;
+                var isLight = typeof newVal === 'number'
+                    ? newVal === 1
+                    : typeof newVal === 'boolean'
+                        ? newVal
+                        : String(newVal).toLowerCase() === 'light' ||
+                            String(newVal) === '1';
+                _this.backgroundColor = isLight ? 0xffffff : 0;
+            }
         });
         AcApSettingManager.instance.events.modified.addEventListener(function (args) {
             if (args.key == 'isShowStats') {
@@ -194,7 +259,9 @@ var AcTrView2d = /** @class */ (function (_super) {
         var selectionStartCanvas = null;
         var selectionPreviewEl = null;
         var canHandleSelectionGesture = function () {
-            return _this.mode === AcEdViewMode.SELECTION && !_this.editor.isActive;
+            return (_this.mode === AcEdViewMode.SELECTION &&
+                !_this.editor.isActive &&
+                !AcEdMTextEditor.getActiveInputBox());
         };
         var clearSelectionPreview = function () {
             selectionPreviewEl === null || selectionPreviewEl === void 0 ? void 0 : selectionPreviewEl.remove();
@@ -227,7 +294,7 @@ var AcTrView2d = /** @class */ (function (_super) {
             var width = Math.abs(p1.x - p2.x);
             var height = Math.abs(p1.y - p2.y);
             var mode = _this.getSelectionMode(selectionStartCanvas, curCanvas);
-            var action = _this.getSelectionActionFromEvent(e);
+            var action = _this.getPointerSelectionAction(e);
             var style = _this.getSelectionPreviewStyle(mode, action);
             Object.assign(selectionPreviewEl.style, {
                 left: "".concat(left, "px"),
@@ -248,7 +315,7 @@ var AcTrView2d = /** @class */ (function (_super) {
             });
             var endWcs = _this.screenToWorld(endCanvas);
             clearSelectionPreview();
-            var action = _this.getSelectionActionFromEvent(e);
+            var action = _this.getPointerSelectionAction(e);
             if (_this.isSelectionClick(selectionStartCanvas, endCanvas)) {
                 var picked = _this.pick(endWcs);
                 if (picked.length > 0) {
@@ -268,6 +335,16 @@ var AcTrView2d = /** @class */ (function (_super) {
             selectionStartWcs = null;
             selectionStartCanvas = null;
         });
+        _this.canvas.addEventListener('dblclick', function (e) {
+            if (e.button !== 0)
+                return;
+            if (!canHandleSelectionGesture())
+                return;
+            if (AcApDocManager.instance.curDocument.openMode !== AcEdOpenMode.Write) {
+                return;
+            }
+            void _this.openPickedMTextEditor(e);
+        });
         // When using OrbitControls in THREE.js, it attaches its own event listeners to the DOM elements,
         // such as the canvas or the entire document. This can interfere with other event listeners you
         // add, including the keydown event.
@@ -299,10 +376,50 @@ var AcTrView2d = /** @class */ (function (_super) {
             }
         });
         acdbHostApplicationServices().layoutManager.events.layoutSwitched.addEventListener(function (args) {
-            _this.activeLayoutBtrId = args.layout.blockTableRecordId;
-            _this.createLayoutViewIfNeeded(args.layout.blockTableRecordId);
-            _this.loadLayoutEntitiesIfNeeded(args.layout.blockTableRecordId);
+            var btrId = args.layout.blockTableRecordId;
+            // "First visit" is tracked separately from view existence because
+            // `addLayout` pre-creates an `AcTrLayoutView` for every layout in
+            // the DWG at load time — `_layoutViewManager.has(btrId)` is
+            // therefore `true` even for layouts the user has never focused
+            // on, and "first visit" computed from it would always be false.
+            // We use a dedicated set instead, marked here on first switch and
+            // also from `markLayoutAsInitialized` when the document opens
+            // straight into a layout (AcApDocManager has already framed it).
+            // Each AcTrLayoutView owns its own camera, so on subsequent
+            // visits the previous camera state is naturally restored and we
+            // must NOT zoom-to-fit again — that would be jarring and
+            // diverges from how AutoCAD preserves per-tab view state.
+            var isFirstVisit = !_this._initializedLayouts.has(btrId);
+            _this._initializedLayouts.add(btrId);
+            // Clear measurement overlays before swapping layouts.
+            // Measurements are screen/coordinate-anchored — their dimension
+            // text, hatch indicators, and HTML overlays were laid out in
+            // the previous layout's WCS (paper coords, ~unit scale) and
+            // would render at nonsense positions in a different layout
+            // (model WCS is typically O(10^5) larger, paper layouts use
+            // their own sheet coords). Selection state is intentionally
+            // **not** cleared here: it is entity-id-based and the same
+            // entity stays selected wherever it is rendered (the model
+            // entity drilled through a paper viewport remains visually
+            // selected when the user returns to model space, matching
+            // AutoCAD desktop's behaviour).
+            //
+            // Dynamic import avoids a circular dependency: the cleanup
+            // module already imports `AcTrView2d` for its
+            // `htmlTransientManager` cast, so a static import here would
+            // create a cycle. The cost (one extra microtask) is
+            // negligible for a layout switch.
+            void import('../command/measure/AcApClearMeasurementsCmd').then(function (_a) {
+                var clearAllMeasurements = _a.clearAllMeasurements;
+                return clearAllMeasurements(_this);
+            });
+            _this.activeLayoutBtrId = btrId;
+            _this.createLayoutViewIfNeeded(btrId);
+            _this.loadLayoutEntitiesIfNeeded(btrId);
             _this._isDirty = true;
+            if (isFirstVisit) {
+                _this.applyInitialZoom(btrId, args.layout);
+            }
         });
         _this._css2dRenderer = new CSS2DRenderer();
         _this._css2dRenderer.setSize(_this.width, _this.height);
@@ -321,6 +438,9 @@ var AcTrView2d = /** @class */ (function (_super) {
         _this._numOfEntitiesToProcess = 0;
         return _this;
     }
+    AcTrView2d.prototype.getPointerSelectionAction = function (e) {
+        return resolvePointerSelectionAction(e);
+    };
     /**
      * Initializes the viewer after renderer and camera are created.
      *
@@ -431,6 +551,9 @@ var AcTrView2d = /** @class */ (function (_super) {
         set: function (value) {
             this._renderer.setClearColor(value);
             this._renderer.changeForeground(value == 0 ? 0xffffff : 0);
+            // Store the canvas colour for theme-sensitive materials created after this
+            // point. `changeForeground` above keeps ACI 7 linework and hatches visible.
+            this._renderer.currentBackgroundColor = value;
             this.editor.setCursorColor(value == 0 ? 'white' : 'black');
             applyUiThemeFromBackground(value);
             this._isDirty = true;
@@ -486,6 +609,16 @@ var AcTrView2d = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcTrView2d.prototype, "cadScene", {
+        /**
+         * CAD scene graph used for rendering and HTML export.
+         */
+        get: function () {
+            return this._scene;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(AcTrView2d.prototype, "internalScene", {
         /**
          * The internal THREE scene used by this view.
@@ -613,40 +746,248 @@ var AcTrView2d = /** @class */ (function (_super) {
         this.activeLayoutView.flyTo(point, scale);
         this._isDirty = true;
     };
+    AcTrView2d.prototype.openPickedMTextEditor = function (e) {
+        return __awaiter(this, void 0, void 0, function () {
+            var point, worldPoint, picked, entity;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        point = this.viewportToCanvas({
+                            x: e.clientX,
+                            y: e.clientY
+                        });
+                        worldPoint = this.screenToWorld(point);
+                        picked = this.pick(worldPoint, undefined, true);
+                        if (!picked.length)
+                            return [2 /*return*/];
+                        entity = AcApDocManager.instance.curDocument.database.tables.blockTable.getEntityById(picked[0].id);
+                        if (!(entity instanceof AcDbMText))
+                            return [2 /*return*/];
+                        e.preventDefault();
+                        return [4 /*yield*/, this.editMTextEntity(entity)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AcTrView2d.prototype.editMTextEntity = function (mtext) {
+        return __awaiter(this, void 0, void 0, function () {
+            var editor, applied, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (mtext.lineSpacingFactor !== AcEdMTextEditor.defaultLineSpacingFactor) {
+                            mtext.lineSpacingFactor = AcEdMTextEditor.defaultLineSpacingFactor;
+                            mtext.triggerModifiedEvent();
+                        }
+                        // 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.
+                        // this.removeEntity(mtext)
+                        this._isDirty = true;
+                        editor = new AcEdMTextEditor();
+                        applied = false;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, editor.open({
+                                view: this,
+                                location: mtext.location,
+                                width: this.resolveMTextEditorWidth(mtext),
+                                textHeight: this.resolveMTextEditorTextHeight(mtext),
+                                initialText: mtext.contents,
+                                initialAttachmentPoint: mtext.attachmentPoint,
+                                toolbarFontFamilies: this.getMTextToolbarFontFamilies()
+                            })];
+                    case 2:
+                        result = _a.sent();
+                        if (!result)
+                            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();
+                        applied = true;
+                        return [3 /*break*/, 4];
+                    case 3:
+                        if (!applied) {
+                            this.updateEntity(mtext);
+                            this._isDirty = true;
+                        }
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AcTrView2d.prototype.resolveMTextEditorWidth = function (mtext) {
+        var width = Number(mtext.width);
+        if (Number.isFinite(width) && width > 0)
+            return width;
+        return 1e-4;
+    };
+    AcTrView2d.prototype.resolveMTextEditorTextHeight = function (mtext) {
+        var textHeight = Number(mtext.height);
+        if (Number.isFinite(textHeight) && textHeight > 0)
+            return textHeight;
+        return this.pixelsToWorldY(24);
+    };
+    AcTrView2d.prototype.pixelsToWorldY = function (pixels) {
+        var p0 = this.screenToWorld({ x: 0, y: 0 });
+        var p1 = this.screenToWorld({ x: 0, y: pixels });
+        return Math.max(Math.abs(p1.y - p0.y), 1e-4);
+    };
+    AcTrView2d.prototype.getMTextToolbarFontFamilies = function () {
+        return Array.from(new Set(AcApDocManager.instance.avaiableFonts
+            .flatMap(function (fontInfo) { return fontInfo.name; })
+            .map(function (fontName) { return fontName.trim(); })
+            .filter(function (fontName) { return fontName.length > 0; })));
+    };
     /**
      * @inheritdoc
+     *
+     * In **paper space** layouts the selection pipeline supports
+     * "drill-through": clicks inside a viewport rectangle resolve against
+     * the model-space entities that are visually rendered through that
+     * viewport, rather than picking the viewport's border. Clicks **near**
+     * the border still pick the `AcDbViewport` entity itself so the user
+     * can grip, move, lock or delete the viewport.
+     *
+     * This mirrors AutoCAD **web** behaviour (single-click selection of
+     * model content through the viewport). The desktop ARX behaviour
+     * (explicit MSPACE/PSPACE modes, CVPORT system variable, double-click
+     * to enter mspace) is a separate, larger feature — tracked in
+     * `.claude/plans/next_14_viewports_full.md` PR-γ Option A. We
+     * intentionally do **not** implement it here.
+     *
+     * The border vs interior decision uses a tolerance derived from
+     * `selectionBoxSize` (the same pixel-sized hit radius used elsewhere
+     * in pick) converted to paper-space WCS via `pointToBox`. This keeps
+     * the gesture consistent with how other entity edges behave — you
+     * 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;
         if (point == null)
             point = this.curPos;
         var results = [];
         var activeLayout = this._scene.activeLayout;
-        if (activeLayout) {
-            var activeLayoutView = this.activeLayoutView;
-            var box = activeLayoutView.pointToBox(point, hitRadius !== null && hitRadius !== void 0 ? hitRadius : this.selectionBoxSize);
-            var firstQueryResults = this._scene.search(box);
-            var threshold = Math.max(box.size.width / 2, box.size.height / 2);
-            var raycaster_1 = activeLayoutView.resetRaycaster(point, threshold);
-            if (pickOneOnly) {
-                firstQueryResults.some(function (item) {
-                    var objectId = item.id;
-                    if (activeLayout.isIntersectWith(objectId, raycaster_1)) {
-                        results.push(item);
-                        return true;
+        if (!activeLayout)
+            return results;
+        var activeLayoutView = this.activeLayoutView;
+        var effectiveHitRadius = hitRadius !== null && hitRadius !== void 0 ? hitRadius : this.selectionBoxSize;
+        var paperBox = activeLayoutView.pointToBox(point, effectiveHitRadius);
+        var threshold = Math.max(paperBox.size.width / 2, paperBox.size.height / 2);
+        // Identify drill-through viewports (paper space only): viewports whose
+        // paper rectangle contains the click AND whose border is NOT within
+        // tolerance of the click. The border tolerance is the average of the
+        // hit-box width/height — a robust, scale-aware proxy for "user is
+        // trying to grab the frame, not click inside".
+        var isPaperSpace = activeLayoutView.layoutBtrId !== this._scene.modelSpaceBtrId;
+        var borderTolerance = (paperBox.size.width + paperBox.size.height) / 2;
+        var drillThroughViewports = [];
+        var drillThroughViewportIds = new Set();
+        if (isPaperSpace) {
+            try {
+                for (var _b = __values(activeLayoutView.viewportViews), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var vpView = _c.value;
+                    if (vpView.containsPaperPoint(point) &&
+                        !vpView.isNearPaperBorder(point, borderTolerance)) {
+                        drillThroughViewports.push(vpView);
+                        drillThroughViewportIds.add(vpView.viewport.id);
                     }
-                    return false;
-                });
+                }
             }
-            else {
-                firstQueryResults.forEach(function (item) {
-                    var objectId = item.id;
-                    if (activeLayout.isIntersectWith(objectId, raycaster_1)) {
-                        results.push(item);
-                    }
-                });
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        // 1) Resolve hits in the active layout. Skip the `AcDbViewport`
+        //    entity for any viewport we're drilling through — otherwise the
+        //    rectangle's bounding box always wins (it covers the whole click
+        //    region) and selection feels "stuck on the frame".
+        var firstQueryResults = this._scene.search(paperBox);
+        var raycaster = activeLayoutView.resetRaycaster(point, threshold);
+        firstQueryResults.forEach(function (item) {
+            if (drillThroughViewportIds.has(item.id))
+                return;
+            if (activeLayout.isIntersectWith(item.id, raycaster)) {
+                results.push(item);
+            }
+        });
+        // 2) For each drill-through viewport, resolve hits against the
+        //    model-space layout using the viewport's own camera/raycaster.
+        if (drillThroughViewports.length > 0) {
+            this.pickThroughViewports(point, paperBox, drillThroughViewports, results);
+        }
+        var sortedResults = sortPickResults(results, point);
+        return pickOneOnly ? sortedResults.slice(0, 1) : sortedResults;
+    };
+    /**
+     * Resolves hits against the model-space layout for each viewport the
+     * click drills through. Appends the matches into `results` (caller
+     * sorts/dedups). Kept private and separate from `pick` so the main
+     * pick path stays a single straight read.
+     *
+     * Each viewport gets its own raycaster shot (using the viewport view's
+     * own camera, which is zoomed to `viewport.viewBox` in model WCS), so
+     * a click that lands in overlapping viewports correctly resolves
+     * against each viewport's particular model framing.
+     *
+     * `pickThroughViewports` does NOT consult the active (paper) layout's
+     * spatial index — that work is already done by the caller. It only
+     * adds model-space results that would otherwise be invisible to the
+     * paper-space pick.
+     */
+    AcTrView2d.prototype.pickThroughViewports = function (paperPoint, paperBox, viewports, results) {
+        var e_2, _a;
+        var modelLayout = this._scene.modelSpaceLayout;
+        if (!modelLayout)
+            return;
+        // Half-extent of the paper-space hit box (== "radius" in paper WCS).
+        // Multiplied per viewport by its paper→model scale, this becomes a
+        // model-WCS radius that the per-viewport raycaster threshold and the
+        // spatial-index probe both use. This keeps the hit area visually
+        // consistent across viewports at different zoom levels.
+        var paperHalfRadius = (paperBox.size.width + paperBox.size.height) / 4;
+        var _loop_1 = function (vpView) {
+            var modelPt = vpView.paperPointToModel(paperPoint);
+            var modelRadius = paperHalfRadius * vpView.paperToModelScale;
+            if (modelRadius <= 0)
+                return "continue";
+            var modelBox = new AcGeBox2d().setFromPoints([
+                new AcGePoint2d(modelPt.x - modelRadius, modelPt.y - modelRadius),
+                new AcGePoint2d(modelPt.x + modelRadius, modelPt.y + modelRadius)
+            ]);
+            var vpRaycaster = vpView.resetRaycaster(modelPt, modelRadius);
+            var modelHits = modelLayout.search(modelBox);
+            modelHits.forEach(function (item) {
+                if (modelLayout.isIntersectWith(item.id, vpRaycaster)) {
+                    results.push(item);
+                }
+            });
+        };
+        try {
+            for (var viewports_1 = __values(viewports), viewports_1_1 = viewports_1.next(); !viewports_1_1.done; viewports_1_1 = viewports_1.next()) {
+                var vpView = viewports_1_1.value;
+                _loop_1(vpView);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_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; }
         }
-        return results;
     };
     /**
      * @inheritdoc
@@ -674,12 +1015,27 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @inheritdoc
      */
     AcTrView2d.prototype.addLayer = function (layer) {
-        this._scene.addLayer({
+        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._isDirty = true;
     };
     /**
@@ -806,6 +1162,91 @@ var AcTrView2d = /** @class */ (function (_super) {
         this.createLayoutViewIfNeeded(layout.blockTableRecordId);
         this._isDirty = true;
     };
+    /**
+     * Marks a layout as already framed by an external caller (typically
+     * `AcApDocManager.onAfterOpenDocument`, which zooms the startup
+     * layout right after parsing). Subsequent `layoutSwitched` events
+     * for this btrId will skip their initial zoom-to-fit so the user's
+     * camera state on the startup layout is preserved when they click
+     * back to that tab.
+     *
+     * This is the public counterpart of the `_initializedLayouts` set —
+     * exposed so the application layer can stay in sync with the view's
+     * notion of "which layouts have been framed already" without
+     * needing access to private state.
+     */
+    AcTrView2d.prototype.markLayoutAsInitialized = function (layoutBtrId) {
+        this._initializedLayouts.add(layoutBtrId);
+    };
+    /**
+     * Applies the initial zoom-to-fit for a layout the user just switched
+     * into for the first time. Picks the best available "what should the
+     * camera frame?" signal in this order:
+     *
+     * 1. **`AcDbLayout.limits`** (LIMMIN/LIMMAX) — only when it actually
+     *    contains the layout's viewports. Many real DWGs ship with garbage
+     *    limits (e.g. `(0,0)-(12,9)` from a legacy template setup) that
+     *    don't reflect the actual paper sheet. We reject those by
+     *    checking containment against `viewportsBoundingBox`.
+     *
+     * 2. **`AcTrLayoutView.viewportsBoundingBox`** — bounding box of all
+     *    real user viewports in the layout. In production sheets viewports
+     *    typically span 70-90% of the paper, so this is a great proxy for
+     *    the printable area and (crucially) ignores outliers like title
+     *    blocks authored in a different unit/scale.
+     *
+     * 3. **`AcDbLayout.extents`** — the layout's own EXTMIN/EXTMAX, if
+     *    populated. Many parsers leave this empty (we've seen `(0,0)-(0,0)`),
+     *    so it sits below the viewport-based heuristic.
+     *
+     * 4. **`zoomToFitDrawing`** (entity extents from spatial index) —
+     *    last-resort fallback for layouts with no viewports and no
+     *    sensible limits/extents (e.g. a freshly created empty paper).
+     *    Vulnerable to scale-mismatch outliers, but better than no zoom.
+     *
+     * **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`.
+     * 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.
+     */
+    AcTrView2d.prototype.applyInitialZoom = function (btrId, layout) {
+        var _this = this;
+        var waiter = new AcEdConditionWaiter(function () { return _this._numOfEntitiesToProcess <= 0; }, function () {
+            var limits = layout.limits;
+            var layoutView = _this._layoutViewManager.getAt(btrId);
+            var vpsBox = layoutView === null || layoutView === void 0 ? void 0 : layoutView.viewportsBoundingBox;
+            var limitsContainsViewports = (function () {
+                if (!limits || limits.isEmpty())
+                    return false;
+                if (!vpsBox)
+                    return true;
+                return (limits.min.x <= vpsBox.min.x &&
+                    limits.min.y <= vpsBox.min.y &&
+                    limits.max.x >= vpsBox.max.x &&
+                    limits.max.y >= vpsBox.max.y);
+            })();
+            if (limits && !limits.isEmpty() && limitsContainsViewports) {
+                _this.zoomTo(limits);
+            }
+            else if (vpsBox) {
+                _this.zoomTo(vpsBox);
+            }
+            else if (layout.extents && !layout.extents.isEmpty()) {
+                var extents = layout.extents;
+                _this.zoomTo(new AcGeBox2d({ x: extents.min.x, y: extents.min.y }, { x: extents.max.x, y: extents.max.y }));
+            }
+            else if (_this._scene.box) {
+                _this.zoomTo(AcTrGeometryUtil.threeBox3dToGeBox2d(_this._scene.box));
+            }
+            _this._isDirty = true;
+        }, 300, 0);
+        waiter.start();
+    };
     /**
      * @inheritdoc
      */
@@ -893,10 +1334,26 @@ var AcTrView2d = /** @class */ (function (_super) {
     /**
      * Load entities from the specified layout if they haven't been loaded yet.
      * This ensures that when switching to a layout, all its entities are available for rendering.
+     *
+     * Two non-obvious invariants are enforced here:
+     *
+     * 1. The layout is looked up by `layoutBtrId` (the argument), not by
+     *    `this._scene.activeLayout`. The active layout reference happens to
+     *    match in the current `layoutSwitched` handler call site, but relying
+     *    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,
+     *    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
+     *    layout — visible as ghosted overdraw and double the spatial-index
+     *    weight.
+     *
      * @param layoutBtrId Input the block table record id of the layout
      */
     AcTrView2d.prototype.loadLayoutEntitiesIfNeeded = function (layoutBtrId) {
-        var e_1, _a;
+        var e_3, _a;
         var _this = this;
         try {
             var db = AcApDocManager.instance.curDocument.database;
@@ -904,10 +1361,60 @@ var AcTrView2d = /** @class */ (function (_super) {
             if (!blockTableRecord) {
                 return;
             }
-            var layout = this._scene.activeLayout;
-            if (layout && layout.isLoaded) {
+            var existingLayout = this._scene.layouts.get(layoutBtrId);
+            if (existingLayout && existingLayout.isLoaded) {
+                return;
+            }
+            if (this._loadingLayouts.has(layoutBtrId)) {
                 return;
             }
+            // Ensure `AcTrViewportView`s exist for every real `AcDbViewport`
+            // in this layout when the layout's entities were already streamed
+            // in by the document parser. There is a race in the parser-driven
+            // load path: `addLayout(layout)` creates the `AcTrLayoutView`,
+            // but the parser may dispatch the AcDbViewport entities before
+            // that happens. When that races, `batchConvert`'s viewport
+            // handler does `_layoutViewManager.getAt(entity.ownerId)`, gets
+            // `undefined`, and **silently skips creating the
+            // AcTrViewportView**. The reload path below used to mask this by
+            // re-running batchConvert after the layoutView existed, but the
+            // entityCount-skip optimization that follows removes that
+            // side-effect, so we do the viewport-view-only pass explicitly
+            // here. Skipped when the layout is empty — in that case the
+            // batchConvert path below will create the viewport views directly
+            // as it processes each entity.
+            var layoutView = this._layoutViewManager.getAt(layoutBtrId);
+            if (existingLayout &&
+                existingLayout.entityCount > 0 &&
+                layoutView &&
+                layoutView.viewportCount === 0) {
+                this.ensureViewportViews(blockTableRecord, layoutView);
+            }
+            // Model space (and any other layout pre-populated by the document
+            // parser at open time) lands here without `isLoaded` ever having
+            // been flipped — the initial entity stream goes through
+            // `addEntity()` directly, bypassing this method. Without this
+            // guard, switching back to model space from a paper layout would
+            // re-iterate the full block table record and re-batch-convert
+            // every entity (5759+ on real DWGs), freezing the UI for several
+            // seconds AND duplicating entities (every entity ends up in the
+            // layout twice, doubling the spatial-index weight and render
+            // cost).
+            //
+            // If the layout already has entities, the parser has finished
+            // loading them — flip the flag and bail. The reload path below
+            // is only for layouts whose entities were never streamed in
+            // (typically non-active paper-space layouts loaded on first user
+            // visit).
+            if (existingLayout && existingLayout.entityCount > 0) {
+                existingLayout.isLoaded = true;
+                return;
+            }
+            // Ensure layout exists in scene. `addEmptyLayout` is idempotent, but
+            // guarding the call avoids an unnecessary Map probe + log noise.
+            if (!existingLayout) {
+                this._scene.addEmptyLayout(layoutBtrId);
+            }
             // Collect all entities from this layout
             var entities_1 = [];
             var iterator = blockTableRecord.newIterator();
@@ -917,34 +1424,46 @@ var AcTrView2d = /** @class */ (function (_super) {
                     entities_1.push(entity);
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
             finally {
                 try {
                     if (iterator_1_1 && !iterator_1_1.done && (_a = iterator_1.return)) _a.call(iterator_1);
                 }
-                finally { if (e_1) throw e_1.error; }
+                finally { if (e_3) throw e_3.error; }
             }
-            // Ensure layout exists in scene
-            this._scene.addEmptyLayout(layoutBtrId);
-            if (entities_1.length > 0) {
-                // Load entities asynchronously
-                this._numOfEntitiesToProcess += entities_1.length;
-                setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
-                    var layout;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0: return [4 /*yield*/, this.batchConvert(entities_1)];
-                            case 1:
-                                _a.sent();
-                                layout = this._scene.layouts.get(layoutBtrId);
-                                if (layout) {
-                                    layout.isLoaded = true;
-                                }
-                                return [2 /*return*/];
-                        }
-                    });
-                }); });
+            if (entities_1.length === 0) {
+                // Empty layout (e.g. a freshly-created paper space tab). Mark as
+                // loaded immediately so subsequent visits short-circuit.
+                var layout = this._scene.layouts.get(layoutBtrId);
+                if (layout) {
+                    layout.isLoaded = true;
+                }
+                return;
             }
+            // Load entities asynchronously
+            this._loadingLayouts.add(layoutBtrId);
+            this._numOfEntitiesToProcess += entities_1.length;
+            setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                var layout;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, , 2, 3]);
+                            return [4 /*yield*/, this.batchConvert(entities_1)];
+                        case 1:
+                            _a.sent();
+                            layout = this._scene.layouts.get(layoutBtrId);
+                            if (layout) {
+                                layout.isLoaded = true;
+                            }
+                            return [3 /*break*/, 3];
+                        case 2:
+                            this._loadingLayouts.delete(layoutBtrId);
+                            return [7 /*endfinally*/];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            }); });
         }
         catch (error) {
             log.error('[AcTrView2d] Error loading layout entities:', error);
@@ -966,6 +1485,48 @@ var AcTrView2d = /** @class */ (function (_super) {
     AcTrView2d.prototype.drawEntity = function (entity, delay) {
         return entity.worldDraw(this._renderer, delay);
     };
+    /**
+     * Walks the given block table record once and creates one
+     * `AcTrViewportView` for every real `AcDbViewport` entity it finds
+     * (skipping the default paper-space viewport that is filtered
+     * everywhere else by `AcTrViewportView.isDefaultPaperSpaceViewport`).
+     *
+     * This is the recovery pass for paper-space layouts whose viewport
+     * entities reached `batchConvert` before the `AcTrLayoutView` was
+     * created — those entities were drawn and added to the scene, but
+     * the viewport-view creation step silently no-oped (lookup returned
+     * undefined). Without this recovery, `viewportsBoundingBox` stays
+     * `undefined` on first user visit, the initial-zoom strategy
+     * degrades to the bogus `limits` branch, and the layout renders as
+     * a "grain in the corner" with empty viewport scissors. See the
+     * call site in `loadLayoutEntitiesIfNeeded` for the full context.
+     *
+     * Cheap operation: only AcDbViewport entities are inspected; for a
+     * typical sheet that's a handful of entities even on 5000-entity
+     * paper layouts.
+     */
+    AcTrView2d.prototype.ensureViewportViews = function (blockTableRecord, layoutView) {
+        var e_4, _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()) {
+                var entity = iterator_2_1.value;
+                if (!(entity instanceof AcDbViewport))
+                    continue;
+                if (AcTrViewportView.isDefaultPaperSpaceViewport(entity))
+                    continue;
+                var viewportView = new AcTrViewportView(layoutView, entity.toGiViewport(), this._renderer);
+                layoutView.addViewport(viewportView);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_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; }
+        }
+    };
     /**
      * Converts the specified database entities to three entities
      * @param entities - The database entities
@@ -973,89 +1534,98 @@ var AcTrView2d = /** @class */ (function (_super) {
      */
     AcTrView2d.prototype.batchConvert = function (entities) {
         return __awaiter(this, void 0, void 0, function () {
-            var _loop_1, this_1, i;
-            var _this = this;
+            var i, entity, threeEntity, isExtendBbox, layoutView, viewportView, fileName, error_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _loop_1 = function (i) {
-                            var entity, threeEntity, isExtendBbox_1, layoutView, viewportView, fileName;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        entity = entities[i];
-                                        threeEntity = this_1.drawEntity(entity, true);
-                                        if (!threeEntity) return [3 /*break*/, 4];
-                                        threeEntity.objectId = entity.objectId;
-                                        threeEntity.ownerId = entity.ownerId;
-                                        threeEntity.layerName = entity.layer;
-                                        threeEntity.visible = entity.visibility;
-                                        if (!(threeEntity instanceof AcTrGroup &&
-                                            !threeEntity.isOnTheSameLayer)) return [3 /*break*/, 1];
-                                        this_1.handleGroup(threeEntity);
-                                        this_1.decreaseNumOfEntitiesToProcess();
-                                        return [3 /*break*/, 3];
-                                    case 1:
-                                        isExtendBbox_1 = !(entity instanceof AcDbRay || entity instanceof AcDbXline);
-                                        return [4 /*yield*/, threeEntity
-                                                .draw()
-                                                .then(function () {
-                                                _this._scene.addEntity(threeEntity, isExtendBbox_1);
-                                                // Release memory occupied by this entity
-                                                threeEntity.dispose();
-                                                _this._isDirty = true;
-                                            })
-                                                .finally(function () {
-                                                _this.decreaseNumOfEntitiesToProcess();
-                                            })];
-                                    case 2:
-                                        _b.sent();
-                                        _b.label = 3;
-                                    case 3:
-                                        if (entity instanceof AcDbViewport) {
-                                            // In paper space layouts, there is always a system-defined "default" viewport that exists as
-                                            // the bottom-most item. This viewport doesn't show any entities and is mainly for internal
-                                            // AutoCAD purposes. The viewport id number of this system-defined "default" viewport is 1.
-                                            if (entity.number !== 1) {
-                                                layoutView = this_1._layoutViewManager.getAt(entity.ownerId);
-                                                if (layoutView) {
-                                                    viewportView = new AcTrViewportView(layoutView, entity.toGiViewport(), this_1._renderer);
-                                                    layoutView.addViewport(viewportView);
-                                                }
-                                            }
-                                        }
-                                        else if (entity instanceof AcDbRasterImage) {
-                                            fileName = entity.imageFileName;
-                                            if (fileName)
-                                                this_1._missedImages.set(entity.objectId, fileName);
-                                        }
-                                        return [3 /*break*/, 5];
-                                    case 4:
-                                        this_1.decreaseNumOfEntitiesToProcess();
-                                        _b.label = 5;
-                                    case 5: return [2 /*return*/];
-                                }
-                            });
-                        };
-                        this_1 = this;
                         i = 0;
                         _a.label = 1;
                     case 1:
-                        if (!(i < entities.length)) return [3 /*break*/, 4];
-                        return [5 /*yield**/, _loop_1(i)];
+                        if (!(i < entities.length)) return [3 /*break*/, 9];
+                        entity = entities[i];
+                        _a.label = 2;
                     case 2:
-                        _a.sent();
-                        _a.label = 3;
+                        _a.trys.push([2, 6, 7, 8]);
+                        // 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*/, 8];
+                        }
+                        threeEntity = this.drawEntity(entity, true);
+                        if (!threeEntity)
+                            return [3 /*break*/, 8];
+                        threeEntity.objectId = entity.objectId;
+                        threeEntity.ownerId = entity.ownerId;
+                        threeEntity.layerName = entity.layer;
+                        threeEntity.visible = entity.visibility;
+                        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);
+                        }
+                        if (!(threeEntity instanceof AcTrGroup &&
+                            !threeEntity.isOnTheSameLayer)) return [3 /*break*/, 3];
+                        this.handleGroup(threeEntity);
+                        return [3 /*break*/, 5];
                     case 3:
+                        isExtendBbox = !(entity instanceof AcDbRay || entity instanceof AcDbXline);
+                        return [4 /*yield*/, threeEntity.draw()];
+                    case 4:
+                        _a.sent();
+                        this._scene.addEntity(threeEntity, isExtendBbox);
+                        // Release memory occupied by this entity
+                        threeEntity.dispose();
+                        this._isDirty = true;
+                        _a.label = 5;
+                    case 5:
+                        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)
+                                this._missedImages.set(entity.objectId, fileName);
+                        }
+                        return [3 /*break*/, 8];
+                    case 6:
+                        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:
+                        this.decreaseNumOfEntitiesToProcess();
+                        return [7 /*endfinally*/];
+                    case 8:
                         ++i;
                         return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/];
+                    case 9: return [2 /*return*/];
                 }
             });
         });
     };
     AcTrView2d.prototype.handleGroup = function (group) {
-        var e_2, _a;
+        var e_5, _a;
         var _this = this;
         var children = group.children;
         var objectsGroupByLayer = new Map();
@@ -1083,32 +1653,40 @@ var AcTrView2d = /** @class */ (function (_super) {
                 child.parent = null;
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        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_2) throw e_2.error; }
+            finally { if (e_5) throw e_5.error; }
         }
         var styleManager = group.styleManager;
         var groupObjectId = group.objectId;
         var groupLayerName = group.layerName;
         var groupBox = group.box;
+        var groupChildBoxes = group.boxes.map(function (box) { return (__assign({}, box)); });
         objectsGroupByLayer.forEach(function (objects, layerName) {
-            // In AutoCAD, an INSERT entity may reference multiple child entities that
-            // reside on different layers. During rendering, this engine groups entities
-            // by layer and assigns each group the INSERT entity's object ID.
-            // As a result, a single object ID (typically from an INSERT entity) may
-            // correspond to multiple layers. However, in this layer its object id is still
-            // uniqiue.
+            // 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;
-            // Here one group represents one block reference. If the layer name of entities in block
-            // definition is '0', it should be put on layer where the group exist.
-            entity.layerName = layerName === '0' ? groupLayerName : layerName;
+            // 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 = groupBox;
+            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
@@ -1121,6 +1699,86 @@ var AcTrView2d = /** @class */ (function (_super) {
         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.
+     */
+    AcTrView2d.prototype.remapInheritedLayerObjects = function (objects, sourceLayerName, effectiveLayerName) {
+        var e_6, _a;
+        var _this = this;
+        if (sourceLayerName === effectiveLayerName)
+            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_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (objects_1_1 && !objects_1_1.done && (_a = objects_1.return)) _a.call(objects_1);
+            }
+            finally { if (e_6) throw e_6.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;
+    };
+    /**
+     * 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.decreaseNumOfEntitiesToProcess = function () {
         this._numOfEntitiesToProcess--;
         if (this._numOfEntitiesToProcess < 0) {