@crystaldesign/real-time-viewer-next 26.11.0-beta.24 → 26.11.0-beta.26

package/build/esm/{DeckCutoutSubsystem-4369a7a2.js → DeckCutoutSubsystem-9560be24.js}

@@ -1,5 +1,5 @@
-import { p as parseElementKey, u as useRTVStore, b as bootPhase, D as DECK_COLLAR_LOAD_ID } from './index-fa3c5a24.js';
-import { useMemo, useRef, useEffect, useState, useCallback } from 'react';
+import { p as parseElementKey, u as useStableEnvSlice, a as useRTVStore, b as bootPhase, D as DECK_COLLAR_LOAD_ID } from './index-8a26c68f.js';
+import { useRef, useEffect, useMemo, useState, useCallback } from 'react';
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { useThree, useFrame } from '@react-three/fiber';
@@ -9,12 +9,12 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import '@babel/runtime/helpers/asyncToGenerator';
 import '@babel/runtime/regenerator';
-import 'three/examples/jsm/loaders/DRACOLoader.js';
-import 'three/examples/jsm/loaders/GLTFLoader.js';
 import 'zustand';
 import 'zustand/middleware';
 import '@babel/runtime/helpers/typeof';
 import 'postprocessing';
+import 'three/examples/jsm/loaders/DRACOLoader.js';
+import 'three/examples/jsm/loaders/GLTFLoader.js';
 import '@react-three/drei';
 import '@babel/runtime/helpers/classCallCheck';
 import '@babel/runtime/helpers/createClass';
@@ -23,6 +23,9 @@ import '@babel/runtime/helpers/getPrototypeOf';
 import '@babel/runtime/helpers/inherits';
 import 'classnames';
 import 'three-mesh-bvh';
+import 'three/examples/jsm/lines/LineSegments2.js';
+import 'three/examples/jsm/lines/LineSegmentsGeometry.js';
+import 'three/examples/jsm/lines/LineMaterial.js';
 import '@babel/runtime/helpers/objectWithoutProperties';
 import 'three/examples/jsm/environments/RoomEnvironment.js';
 import 'three/examples/jsm/loaders/RGBELoader.js';
@@ -133,9 +136,9 @@ function measureArticle(scene, patterns, elementsInfo) {
   };
 }
 
-function _createForOfIteratorHelper$6(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$6(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray$6(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$6(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$6(r, a) : void 0; } }
-function _arrayLikeToArray$6(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _createForOfIteratorHelper$7(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$7(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$7(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$7(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$7(r, a) : void 0; } }
+function _arrayLikeToArray$7(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 /*
  * 2D polygon primitives — area, simplification, self-intersection guard, hull.
  */
@@ -159,45 +162,54 @@ function polygonSignedArea(points) {
   return area / 2;
 }
 
-/** Douglas–Peucker on an open chain (endpoints kept). */
-function simplifyChain(points, tolerance, out) {
-  if (points.length < 3) {
-    for (var i = 0; i < points.length - 1; i++) out.push(points[i]);
-    return;
-  }
-  var _points$ = _slicedToArray(points[0], 2),
-    ax = _points$[0],
-    az = _points$[1];
-  var _points2 = _slicedToArray(points[points.length - 1], 2),
-    bx = _points2[0],
-    bz = _points2[1];
-  var len = Math.hypot(bx - ax, bz - az) || EPS$2;
-  var maxDist = -1;
-  var maxIdx = -1;
-  for (var _i = 1; _i < points.length - 1; _i++) {
-    var _points$_i = _slicedToArray(points[_i], 2),
-      px = _points$_i[0],
-      pz = _points$_i[1];
-    var dist = Math.abs((bx - ax) * (az - pz) - (ax - px) * (bz - az)) / len;
-    if (dist > maxDist) {
-      maxDist = dist;
-      maxIdx = _i;
+/**
+ * Douglas–Peucker on an open chain (endpoints kept), iterating over [lo, hi] index ranges with an
+ * explicit stack. The recursive form sliced a fresh sub-array per level — O(n log n) copied points
+ * and matching GC churn on the multi-thousand-point contours a fine raster produces.
+ */
+function simplifyChain(points, lo, hi, tolerance, out) {
+  // Flat [lo, hi] pairs; the right half is pushed first so the left half pops (and emits) first.
+  var ranges = [lo, hi];
+  while (ranges.length > 0) {
+    var rangeHi = ranges.pop();
+    var rangeLo = ranges.pop();
+    if (rangeHi - rangeLo < 2) {
+      for (var i = rangeLo; i < rangeHi; i++) out.push(points[i]);
+      continue;
     }
+    var _points$rangeLo = _slicedToArray(points[rangeLo], 2),
+      ax = _points$rangeLo[0],
+      az = _points$rangeLo[1];
+    var _points$rangeHi = _slicedToArray(points[rangeHi], 2),
+      bx = _points$rangeHi[0],
+      bz = _points$rangeHi[1];
+    var len = Math.hypot(bx - ax, bz - az) || EPS$2;
+    var maxDist = -1;
+    var maxIdx = -1;
+    for (var _i = rangeLo + 1; _i < rangeHi; _i++) {
+      var _points$_i = _slicedToArray(points[_i], 2),
+        px = _points$_i[0],
+        pz = _points$_i[1];
+      var dist = Math.abs((bx - ax) * (az - pz) - (ax - px) * (bz - az)) / len;
+      if (dist > maxDist) {
+        maxDist = dist;
+        maxIdx = _i;
+      }
+    }
+    if (maxDist <= tolerance) {
+      out.push(points[rangeLo]);
+      continue;
+    }
+    ranges.push(maxIdx, rangeHi, rangeLo, maxIdx);
   }
-  if (maxDist <= tolerance) {
-    out.push(points[0]);
-    return;
-  }
-  simplifyChain(points.slice(0, maxIdx + 1), tolerance, out);
-  simplifyChain(points.slice(maxIdx), tolerance, out);
 }
 
 /** Douglas–Peucker for a closed polygon: split at the point farthest from the start, simplify both halves. */
 function simplifyClosedPolygon(points, tolerance) {
   if (points.length < 4 || tolerance <= 0) return _toConsumableArray(points);
-  var _points$2 = _slicedToArray(points[0], 2),
-    sx = _points$2[0],
-    sz = _points$2[1];
+  var _points$ = _slicedToArray(points[0], 2),
+    sx = _points$[0],
+    sz = _points$[1];
   var farIdx = 1;
   var farDist = -1;
   for (var i = 1; i < points.length; i++) {
@@ -208,8 +220,10 @@ function simplifyClosedPolygon(points, tolerance) {
     }
   }
   var out = [];
-  simplifyChain(points.slice(0, farIdx + 1), tolerance, out);
-  simplifyChain([].concat(_toConsumableArray(points.slice(farIdx)), [points[0]]), tolerance, out);
+  simplifyChain(points, 0, farIdx, tolerance, out);
+  // One wrap-around copy for the second half — the per-recursion slices are gone.
+  var wrapped = [].concat(_toConsumableArray(points.slice(farIdx)), [points[0]]);
+  simplifyChain(wrapped, 0, wrapped.length - 1, tolerance, out);
   return out;
 }
 
@@ -236,18 +250,18 @@ function isSimplePolygon(points) {
     var _points$i2 = _slicedToArray(points[i], 2),
       ax = _points$i2[0],
       az = _points$i2[1];
-    var _points3 = _slicedToArray(points[(i + 1) % n], 2),
-      bx = _points3[0],
-      bz = _points3[1];
+    var _points2 = _slicedToArray(points[(i + 1) % n], 2),
+      bx = _points2[0],
+      bz = _points2[1];
     for (var j = i + 1; j < n; j++) {
       // Skip the shared-endpoint neighbours (j === i+1, and the wrap pair).
       if (j === i + 1 || i === 0 && j === n - 1) continue;
       var _points$j = _slicedToArray(points[j], 2),
         cx = _points$j[0],
         cz = _points$j[1];
-      var _points4 = _slicedToArray(points[(j + 1) % n], 2),
-        dx = _points4[0],
-        dz = _points4[1];
+      var _points3 = _slicedToArray(points[(j + 1) % n], 2),
+        dx = _points3[0],
+        dz = _points3[1];
       if (segmentsCross(ax, az, bx, bz, cx, cz, dx, dz)) return false;
     }
   }
@@ -265,7 +279,7 @@ function convexHull(points) {
   };
   var build = function build(input) {
     var chain = [];
-    var _iterator = _createForOfIteratorHelper$6(input),
+    var _iterator = _createForOfIteratorHelper$7(input),
       _step;
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
@@ -316,9 +330,9 @@ function ensureSimplePolygon(points) {
   };
 }
 
-function _createForOfIteratorHelper$5(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$5(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray$5(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$5(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$5(r, a) : void 0; } }
-function _arrayLikeToArray$5(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _createForOfIteratorHelper$6(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$6(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$6(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$6(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$6(r, a) : void 0; } }
+function _arrayLikeToArray$6(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 /*
  * Binary raster mask operations — morphology (closing, offsetting, enclosed
  * fill) and marching-squares contouring.
@@ -327,6 +341,21 @@ function _arrayLikeToArray$5(r, a) { (null == a || a > r.length) && (a = r.lengt
  * centre; `originX/originZ` and `cell` map cell indices back to world units.
  */
 
+/**
+ * Grow-only pooled trace buffers. Every operation here (and the trace's own mask) used to allocate
+ * a fresh multi-MB buffer per article change — churn a tablet pays for in GC pauses. The trace is
+ * synchronous and single-threaded, so two slots cover it: slot 0 the mask itself, slot 1 the one
+ * morphology/flood scratch alive at any time. Buffers are zeroed on acquire and retained at their
+ * high-water mark (bounded by the trace's cell budget).
+ */
+var pooledBuffers = [new Uint8Array(0), new Uint8Array(0)];
+function pooledMaskBuffer(slot, size) {
+  if (pooledBuffers[slot].length < size) pooledBuffers[slot] = new Uint8Array(size);
+  var buffer = pooledBuffers[slot].subarray(0, size);
+  buffer.fill(0);
+  return buffer;
+}
+
 /**
  * Morphological closing (dilate then erode) with a square kernel of the given
  * radius — bridges seams between separately modelled parts without moving the
@@ -340,7 +369,7 @@ function _arrayLikeToArray$5(r, a) { (null == a || a > r.length) && (a = r.lengt
  */
 function closeMask(mask, nx, nz, radius) {
   if (radius < 1) return;
-  var scratch = new Uint8Array(mask.length);
+  var scratch = pooledMaskBuffer(1, mask.length);
   boxPassX(mask, scratch, nx, nz, radius, true);
   boxPassZ(scratch, mask, nx, nz, radius, true);
   boxPassX(mask, scratch, nx, nz, radius, false);
@@ -353,12 +382,15 @@ function closeMask(mask, nx, nz, radius) {
  * flood could not reach. Returns how many cells were added.
  */
 function fillEnclosed(mask, nx, nz) {
-  var reached = new Uint8Array(mask.length);
-  var stack = [];
+  var reached = pooledMaskBuffer(1, mask.length);
+  // A typed stack sized for the worst case: one flat allocation the GC frees without scanning,
+  // instead of a `number[]` regrowing through millions of pushes on a large background.
+  var stack = new Int32Array(mask.length);
+  var stackSize = 0;
   var visit = function visit(i) {
     if (mask[i] !== 0 || reached[i] !== 0) return;
     reached[i] = 1;
-    stack.push(i);
+    stack[stackSize++] = i;
   };
   for (var ix = 0; ix < nx; ix++) {
     visit(ix);
@@ -368,8 +400,8 @@ function fillEnclosed(mask, nx, nz) {
     visit(iz * nx);
     visit(iz * nx + nx - 1);
   }
-  while (stack.length > 0) {
-    var i = stack.pop();
+  while (stackSize > 0) {
+    var i = stack[--stackSize];
     var _ix = i % nx;
     var _iz = (i - _ix) / nx;
     if (_ix > 0) visit(i - 1);
@@ -396,7 +428,7 @@ function fillEnclosed(mask, nx, nz) {
  * 45° ones.
  */
 function offsetMask(mask, nx, nz, radius, dilate) {
-  var scratch = new Uint8Array(mask.length);
+  var scratch = pooledMaskBuffer(1, mask.length);
   boxPassX(mask, scratch, nx, nz, radius, dilate);
   boxPassZ(scratch, mask, nx, nz, radius, dilate);
 }
@@ -485,7 +517,7 @@ function marchingSquaresLoops(mask, nx, nz, originX, originZ, cell) {
       // Fully inside / fully outside is the overwhelming majority of cells —
       // returning before the segment lookup keeps the sweep near memory speed.
       if (c === 0 || c === 15) continue;
-      var _iterator = _createForOfIteratorHelper$5(MS_SEGMENTS[c]),
+      var _iterator = _createForOfIteratorHelper$6(MS_SEGMENTS[c]),
         _step;
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
@@ -503,7 +535,7 @@ function marchingSquaresLoops(mask, nx, nz, originX, originZ, cell) {
   }
   var visited = new Set();
   var loops = [];
-  var _iterator2 = _createForOfIteratorHelper$5(adjacency.keys()),
+  var _iterator2 = _createForOfIteratorHelper$6(adjacency.keys()),
     _step2;
   try {
     var _loop = function _loop() {
@@ -540,13 +572,20 @@ var EPS$1 = 1e-9;
 
 /**
  * Ceiling on the raster's cell count. The extent comes from article geometry, so a mis-scaled
- * model (metres authored as millimetres) can ask for a mask no browser can hold — and
- * `closeMask` / `fillEnclosed` / `offsetMask` each allocate another buffer this size. 16M cells
- * is a 20 m x 20 m article at the default 5 mm cell, far beyond anything real, and refusing is
+ * model (metres authored as millimetres) can ask for a mask no browser can hold. 16M cells is a
+ * 20 m x 20 m article at the default 5 mm cell, far beyond anything real, and refusing is
  * graceful: the caller falls back to the measured rect.
  */
 var MAX_MASK_CELLS = 16000000;
 
+/**
+ * Cell budget the raster COARSENS toward instead of refusing: above it, the cell size grows just
+ * enough to fit (a villa-cliff-sized authored pool at 5 mm is ~2.9M cells and stays untouched).
+ * Bounds the pooled mask buffers and the sweep time to what a tablet survives, at the price of a
+ * coarser outline for outsized articles — still their shape, not the rectangular fallback.
+ */
+var TARGET_MASK_CELLS = 4000000;
+
 /** What a trace did internally — see {@link TraceFootprintOptions.diagnostics}. */
 
 /**
@@ -560,16 +599,9 @@ var MAX_MASK_CELLS = 16000000;
 function traceFootprintFromTriangles(triangleXZ) {
   var _options$cellSize, _options$simplifyTole, _options$closeGap, _options$offset;
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var cell = (_options$cellSize = options.cellSize) !== null && _options$cellSize !== void 0 ? _options$cellSize : 0.005;
-  var tolerance = (_options$simplifyTole = options.simplifyTolerance) !== null && _options$simplifyTole !== void 0 ? _options$simplifyTole : cell;
-  // Closing radius in cells, so the sealed gap stays ~`closeGap` at any resolution.
-  var closeGap = (_options$closeGap = options.closeGap) !== null && _options$closeGap !== void 0 ? _options$closeGap : 0.02;
-  var closeRadius = closeGap <= 0 ? 0 : Math.max(1, Math.round(closeGap / (cell * 2)));
-  var offset = (_options$offset = options.offset) !== null && _options$offset !== void 0 ? _options$offset : 0;
-  var offsetRadius = Math.round(Math.abs(offset) / cell);
-  var grow = offset > 0;
+  var requestedCell = (_options$cellSize = options.cellSize) !== null && _options$cellSize !== void 0 ? _options$cellSize : 0.005;
   var triCount = Math.floor(triangleXZ.length / 6);
-  if (triCount < 1 || cell <= 0) return [];
+  if (triCount < 1 || requestedCell <= 0) return [];
   var minX = Infinity;
   var maxX = -Infinity;
   var minZ = Infinity;
@@ -582,7 +614,19 @@ function traceFootprintFromTriangles(triangleXZ) {
     if (z < minZ) minZ = z;
     if (z > maxZ) maxZ = z;
   }
-  if (!Number.isFinite(minX) || maxX - minX < cell || maxZ - minZ < cell) return [];
+  if (!Number.isFinite(minX) || maxX - minX < requestedCell || maxZ - minZ < requestedCell) return [];
+
+  // Coarsen toward the cell budget: everything below derives from the FINAL cell (radii,
+  // tolerance, edge-sampling threshold), so the budget check runs before any of them.
+  var rawCells = (Math.ceil((maxX - minX) / requestedCell) + 1) * (Math.ceil((maxZ - minZ) / requestedCell) + 1);
+  var cell = rawCells > TARGET_MASK_CELLS ? requestedCell * Math.sqrt(rawCells / TARGET_MASK_CELLS) : requestedCell;
+  var tolerance = (_options$simplifyTole = options.simplifyTolerance) !== null && _options$simplifyTole !== void 0 ? _options$simplifyTole : cell;
+  // Closing radius in cells, so the sealed gap stays ~`closeGap` at any resolution.
+  var closeGap = (_options$closeGap = options.closeGap) !== null && _options$closeGap !== void 0 ? _options$closeGap : 0.02;
+  var closeRadius = closeGap <= 0 ? 0 : Math.max(1, Math.round(closeGap / (cell * 2)));
+  var offset = (_options$offset = options.offset) !== null && _options$offset !== void 0 ? _options$offset : 0;
+  var offsetRadius = Math.round(Math.abs(offset) / cell);
+  var grow = offset > 0;
 
   // Empty border of `closeRadius + 1` cells per side: the closing's dilation
   // must have room to spread without the erosion then eating the shape's
@@ -593,7 +637,7 @@ function traceFootprintFromTriangles(triangleXZ) {
   var nx = Math.ceil((maxX - minX) / cell) + 2 * border + 1;
   var nz = Math.ceil((maxZ - minZ) / cell) + 2 * border + 1;
   if (nx * nz > MAX_MASK_CELLS) return [];
-  var mask = new Uint8Array(nx * nz);
+  var mask = pooledMaskBuffer(0, nx * nz);
   var cellOf = function cellOf(v, origin, n) {
     return Math.min(n - border - 1, Math.max(border, Math.floor((v - origin) / cell)));
   };
@@ -707,9 +751,9 @@ function traceFootprintFromTriangles(triangleXZ) {
   return simplified.length >= 3 ? simplified : [];
 }
 
-function _createForOfIteratorHelper$4(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$4(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray$4(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$4(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$4(r, a) : void 0; } }
-function _arrayLikeToArray$4(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _createForOfIteratorHelper$5(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$5(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$5(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$5(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$5(r, a) : void 0; } }
+function _arrayLikeToArray$5(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 
 /** The subset of a deckCutout article rule the matcher needs. */
 
@@ -720,7 +764,7 @@ function _arrayLikeToArray$4(r, a) { (null == a || a > r.length) && (a = r.lengt
  * per-element codexes.
  */
 function matchArticleRule(rules, articleCodex) {
-  var _iterator = _createForOfIteratorHelper$4(rules),
+  var _iterator = _createForOfIteratorHelper$5(rules),
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
@@ -745,9 +789,9 @@ function matchArticleRule(rules, articleCodex) {
   return null;
 }
 
-function _createForOfIteratorHelper$3(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$3(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray$3(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$3(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$3(r, a) : void 0; } }
-function _arrayLikeToArray$3(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _createForOfIteratorHelper$4(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$4(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$4(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$4(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$4(r, a) : void 0; } }
+function _arrayLikeToArray$4(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 
 /**
  * Raster cell (m) for the geometry-derived footprint. 5 mm follows cast-in
@@ -806,7 +850,7 @@ function pickArticleRule(rules, codexesByArea) {
   var _codexesByArea$;
   var primaryCodex = (_codexesByArea$ = codexesByArea[0]) === null || _codexesByArea$ === void 0 ? void 0 : _codexesByArea$.codex;
   var rule = matchArticleRule(rules, undefined);
-  var _iterator = _createForOfIteratorHelper$3(codexesByArea),
+  var _iterator = _createForOfIteratorHelper$4(codexesByArea),
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
@@ -837,10 +881,10 @@ function pickArticleRule(rules, codexesByArea) {
  * meshes change; anchor moves are pure translations and reuse the cache.
  * Returns the outline in CURRENT floor-local coordinates.
  */
-function traceArticleFootprint(elements, floorLocal, rect, minLocalY, offset, diagnostics, cache) {
+function traceArticleFootprint(elements, floorLocal, rect, minLocalY, offset, diagnostics, cache, pendingLiftY) {
   var meshes = [];
   var sigParts = [];
-  var _iterator2 = _createForOfIteratorHelper$3(elements),
+  var _iterator2 = _createForOfIteratorHelper$4(elements),
     _step2;
   try {
     for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
@@ -863,52 +907,63 @@ function traceArticleFootprint(elements, floorLocal, rect, minLocalY, offset, di
   var sizeX = rect.maxX - rect.minX;
   var sizeY = rect.maxY - rect.minY;
   var sizeZ = rect.maxZ - rect.minZ;
-  // The article's top belongs in the signature even though the outline is stored
-  // relative to the bbox: the slice plane is fixed, so moving the article
-  // VERTICALLY changes which triangles clear it, i.e. the traced shape itself.
-  // Without it the anchor's lift would keep returning the pre-lift outline.
-  var signature = "".concat(minLocalY.toFixed(3), "|").concat(rect.maxY.toFixed(3), "|").concat(offset.toFixed(3), "|").concat(sizeX.toFixed(3), "x").concat(sizeY.toFixed(3), "x").concat(sizeZ.toFixed(3), "|").concat(sigParts.join(','));
+  // Vertical position decides which triangles clear the fixed slice plane, so the top belongs in
+  // the signature. Signed with the POST-lift top: the pre-lift measure then produces the same
+  // signature as the post-lift one and the second measure hits the cache instead of re-tracing.
+  var signature = "".concat(minLocalY.toFixed(3), "|").concat((rect.maxY + pendingLiftY).toFixed(3), "|").concat(offset.toFixed(3), "|").concat(sizeX.toFixed(3), "x").concat(sizeY.toFixed(3), "x").concat(sizeZ.toFixed(3), "|").concat(sigParts.join(','));
   if (!cache.current || cache.current.signature !== signature) {
     var started = performance.now();
-    var xz = [];
-    var _triCount = 0;
     var _vertexCount = 0;
-    var _iterator3 = _createForOfIteratorHelper$3(meshes),
-      _step3;
-    try {
-      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-        var mesh = _step3.value;
-        var geometry = mesh.geometry;
+    // Transform every vertex once per mesh; triangles then index into the flat array. Kept per
+    // mesh so the count pass below can re-scan triangles without re-transforming.
+    var locals = meshes.map(function (mesh) {
+      var pos = mesh.geometry.getAttribute('position');
+      _vertexCount += pos.count;
+      _meshToFloor.multiplyMatrices(floorLocal, mesh.matrixWorld);
+      var local = new Float32Array(pos.count * 3);
+      for (var i = 0; i < pos.count; i++) {
+        _vertex$1.set(pos.getX(i), pos.getY(i), pos.getZ(i)).applyMatrix4(_meshToFloor);
+        local[i * 3] = _vertex$1.x;
+        // Slice at the post-lift height (see signature); a Y shift cannot change the XZ outline.
+        local[i * 3 + 1] = _vertex$1.y + pendingLiftY;
+        local[i * 3 + 2] = _vertex$1.z;
+      }
+      return local;
+    });
+    // Two passes over cheap index reads: count the slice triangles, then fill ONE exactly-sized
+    // typed array — a `number[]` grown by pushes held hundreds of thousands of boxed slots on a
+    // dense article and was re-copied on every capacity step.
+    var forEachSliceTriangle = function forEachSliceTriangle(emit) {
+      var count = 0;
+      for (var m = 0; m < meshes.length; m++) {
+        var geometry = meshes[m].geometry;
         var pos = geometry.getAttribute('position');
-        _vertexCount += pos.count;
-        _meshToFloor.multiplyMatrices(floorLocal, mesh.matrixWorld);
-        // Transform every vertex once; triangles then index into the flat array.
-        var local = new Float32Array(pos.count * 3);
-        for (var i = 0; i < pos.count; i++) {
-          _vertex$1.set(pos.getX(i), pos.getY(i), pos.getZ(i)).applyMatrix4(_meshToFloor);
-          local[i * 3] = _vertex$1.x;
-          local[i * 3 + 1] = _vertex$1.y;
-          local[i * 3 + 2] = _vertex$1.z;
-        }
+        var local = locals[m];
         var index = geometry.index;
         var triTotal = index ? Math.floor(index.count / 3) : Math.floor(pos.count / 3);
         for (var t = 0; t < triTotal; t++) {
           var a = index ? index.getX(t * 3) : t * 3;
           var b = index ? index.getX(t * 3 + 1) : t * 3 + 1;
           var c = index ? index.getX(t * 3 + 2) : t * 3 + 2;
-          var ya = local[a * 3 + 1];
-          var yb = local[b * 3 + 1];
-          var yc = local[c * 3 + 1];
-          if (ya < minLocalY && yb < minLocalY && yc < minLocalY) continue;
-          xz.push(local[a * 3], local[a * 3 + 2], local[b * 3], local[b * 3 + 2], local[c * 3], local[c * 3 + 2]);
-          _triCount += 1;
+          if (local[a * 3 + 1] < minLocalY && local[b * 3 + 1] < minLocalY && local[c * 3 + 1] < minLocalY) continue;
+          count += 1;
+          if (emit) emit(local[a * 3], local[a * 3 + 2], local[b * 3], local[b * 3 + 2], local[c * 3], local[c * 3 + 2]);
         }
       }
-    } catch (err) {
-      _iterator3.e(err);
-    } finally {
-      _iterator3.f();
-    }
+      return count;
+    };
+    var _triCount = forEachSliceTriangle(null);
+    var xz = new Float32Array(_triCount * 6);
+    var write = 0;
+    forEachSliceTriangle(function (ax, az, bx, bz, cx, cz) {
+      xz[write] = ax;
+      xz[write + 1] = az;
+      xz[write + 2] = bx;
+      xz[write + 3] = bz;
+      xz[write + 4] = cx;
+      xz[write + 5] = cz;
+      write += 6;
+    });
     var traced = traceFootprintFromTriangles(xz, {
       cellSize: GEOMETRY_FOOTPRINT_CELL,
       offset: offset,
@@ -959,6 +1014,7 @@ function traceArticleFootprint(elements, floorLocal, rect, minLocalY, offset, di
  */
 function deriveArticleFootprint(measurement, rule, margin, cache) {
   var _result$points$length, _result$points;
+  var pendingLiftY = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
   var result = {
     points: null,
     rim: null,
@@ -975,19 +1031,19 @@ function deriveArticleFootprint(measurement, rule, margin, cache) {
     elementObjects = measurement.elementObjects;
   var rawSizeX = rect.maxX - rect.minX;
   var rawSizeZ = rect.maxZ - rect.minZ;
-  var traced = traceArticleFootprint(topLevelElements(elementObjects), floorLocal, rect, floorTopY - rule.footprintSliceDepth, margin, result.trace, cache);
+  var traced = traceArticleFootprint(topLevelElements(elementObjects), floorLocal, rect, floorTopY - rule.footprintSliceDepth, margin, result.trace, cache, pendingLiftY);
   var minX = Infinity;
   var maxX = -Infinity;
   var minZ = Infinity;
   var maxZ = -Infinity;
   if (traced && traced.points.length >= 3) {
-    var _iterator4 = _createForOfIteratorHelper$3(traced.points),
-      _step4;
+    var _iterator3 = _createForOfIteratorHelper$4(traced.points),
+      _step3;
     try {
-      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-        var _step4$value = _slicedToArray(_step4.value, 2),
-          x = _step4$value[0],
-          z = _step4$value[1];
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var _step3$value = _slicedToArray(_step3.value, 2),
+          x = _step3$value[0],
+          z = _step3$value[1];
         if (x < minX) minX = x;
         if (x > maxX) maxX = x;
         if (z < minZ) minZ = z;
@@ -997,9 +1053,9 @@ function deriveArticleFootprint(measurement, rule, margin, cache) {
       // what the steps below need is the article's RIM extent (it sizes the
       // water volume), not the collar's inner boundary.
     } catch (err) {
-      _iterator4.e(err);
+      _iterator3.e(err);
     } finally {
-      _iterator4.f();
+      _iterator3.f();
     }
     minX += margin;
     maxX -= margin;
@@ -1042,9 +1098,9 @@ function deriveArticleFootprint(measurement, rule, margin, cache) {
   return result;
 }
 
-function _createForOfIteratorHelper$2(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$2(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray$2(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$2(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$2(r, a) : void 0; } }
-function _arrayLikeToArray$2(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _createForOfIteratorHelper$3(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$3(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$3(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$3(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$3(r, a) : void 0; } }
+function _arrayLikeToArray$3(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 
 /** Below this world delta (m) the element anchor correction is considered settled. */
 var ANCHOR_EPSILON = 1e-3;
@@ -1098,7 +1154,7 @@ function deriveElementAnchor(_ref) {
   var topLevel = topLevelElements(elementObjects);
   if (topLevel.length === 0) return null;
   var offsets = {};
-  var _iterator = _createForOfIteratorHelper$2(topLevel),
+  var _iterator = _createForOfIteratorHelper$3(topLevel),
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
@@ -1167,10 +1223,14 @@ function deriveWaterVolume(_ref) {
   };
 }
 
+function _createForOfIteratorHelper$2(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$2(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$2(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$2(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$2(r, a) : void 0; } }
+function _arrayLikeToArray$2(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 /**
  * One line describing the whole cutout pipeline, plus the `key` it changes with:
  * the caller logs only when the key moves, so the line appears once per codex /
  * rule / outline state (bounds coarse-rounded to cm) rather than every measure.
+ * `message` is lazy — composed only when the key moved.
  */
 function measureLog(_ref) {
   var _rule$match, _points$length, _fpBounds$map$join;
@@ -1182,38 +1242,59 @@ function measureLog(_ref) {
   var rect = measurement.rect,
     floorTopY = measurement.floorTopY;
   var points = footprint.points;
-  var fpBounds = points ? points.reduce(function (acc, _ref2) {
-    var _ref3 = _slicedToArray(_ref2, 2),
-      x = _ref3[0],
-      z = _ref3[1];
-    return [Math.min(acc[0], x), Math.max(acc[1], x), Math.min(acc[2], z), Math.max(acc[3], z)];
-  }, [Infinity, -Infinity, Infinity, -Infinity]) : null;
+  var fpMinX = Infinity;
+  var fpMaxX = -Infinity;
+  var fpMinZ = Infinity;
+  var fpMaxZ = -Infinity;
+  if (points) {
+    var _iterator = _createForOfIteratorHelper$2(points),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _slicedToArray(_step.value, 2),
+          x = _step$value[0],
+          z = _step$value[1];
+        if (x < fpMinX) fpMinX = x;
+        if (x > fpMaxX) fpMaxX = x;
+        if (z < fpMinZ) fpMinZ = z;
+        if (z > fpMaxZ) fpMaxZ = z;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  var fpBounds = points ? [fpMinX, fpMaxX, fpMinZ, fpMaxZ] : null;
   var key = "".concat(primaryCodex !== null && primaryCodex !== void 0 ? primaryCodex : '', "|").concat((_rule$match = rule === null || rule === void 0 ? void 0 : rule.match) !== null && _rule$match !== void 0 ? _rule$match : '', "|").concat(footprint.sampledCount, "|").concat((_points$length = points === null || points === void 0 ? void 0 : points.length) !== null && _points$length !== void 0 ? _points$length : 0, "|").concat((_fpBounds$map$join = fpBounds === null || fpBounds === void 0 ? void 0 : fpBounds.map(function (v) {
     return v.toFixed(2);
   }).join(',')) !== null && _fpBounds$map$join !== void 0 ? _fpBounds$map$join : '');
-  var rawSizeX = rect.maxX - rect.minX;
-  var rawSizeZ = rect.maxZ - rect.minZ;
-  // Where the slice plane sits relative to the article. The plane is anchored to
-  // the DECK top, so an article whose rim doesn't reach that high contributes
-  // nothing but its topmost stray detail.
-  var sliceInfo = rule && rule.footprintFromGeometry ? " | Y: deck top ".concat(floorTopY.toFixed(2), ", article [").concat(rect.minY.toFixed(2), ", ").concat(rect.maxY.toFixed(2), "], slice keeps \u2265 ").concat((floorTopY - rule.footprintSliceDepth).toFixed(2)) : '';
-  var fpInfo;
-  if (footprint.source === '') {
-    fpInfo = ' | NO outline rule matched this codex → NO COLLAR, the authored hole stays fully open';
-  } else if (fpBounds && points) {
-    // Room left between the outline and each authored hole edge. Negative on any
-    // side = the article is bigger than the hole it sits in; the collar clamps
-    // the outline to the hole and degrades toward a solid slab.
-    var slack = [fpBounds[0] - (hole.centerX - hole.halfExtentX), hole.centerX + hole.halfExtentX - fpBounds[1], fpBounds[2] - (hole.centerZ - hole.halfExtentZ), hole.centerZ + hole.halfExtentZ - fpBounds[3]].map(function (v) {
-      return v.toFixed(2);
-    });
-    fpInfo = " | measured ".concat(rawSizeX.toFixed(2), "\xD7").concat(rawSizeZ.toFixed(2)) + (footprint.tracedBounds === '' ? '' : " | traced ".concat(footprint.sampledCount, " pts ").concat(footprint.tracedBounds)) + " | outline ".concat(points.length, " pts X [").concat(fpBounds[0].toFixed(2), ", ").concat(fpBounds[1].toFixed(2), "] Z [").concat(fpBounds[2].toFixed(2), ", ").concat(fpBounds[3].toFixed(2), "]") + " | hole X [".concat((hole.centerX - hole.halfExtentX).toFixed(2), ", ").concat((hole.centerX + hole.halfExtentX).toFixed(2), "] Z [").concat((hole.centerZ - hole.halfExtentZ).toFixed(2), ", ").concat((hole.centerZ + hole.halfExtentZ).toFixed(2), "]") + " | slack X ".concat(slack[0], "/").concat(slack[1], " Z ").concat(slack[2], "/").concat(slack[3]) + " | ".concat(footprint.source).concat(footprint.repairNote) + (footprint.trace.loops > 0 ? " | trace: ".concat(footprint.trace.filledCells, " cells (").concat(footprint.trace.enclosedFilled, " filled in), ").concat(footprint.trace.loops, " loop(s), kept ").concat((footprint.trace.chosenAreaShare * 100).toFixed(0), "% of contour area, ").concat(footprint.trace.pointsBeforeSimplify, " \u2192 ").concat(footprint.trace.pointsAfterSimplify, " pts") : '');
-  } else {
-    fpInfo = " | ".concat(footprint.source, " produced NO usable outline (").concat(footprint.sampledCount, " pts)").concat(footprint.repairNote, " \u2192 NO COLLAR, the authored hole stays fully open");
-  }
+  var message = function message() {
+    var rawSizeX = rect.maxX - rect.minX;
+    var rawSizeZ = rect.maxZ - rect.minZ;
+    // Where the slice plane sits relative to the article. The plane is anchored to
+    // the DECK top, so an article whose rim doesn't reach that high contributes
+    // nothing but its topmost stray detail.
+    var sliceInfo = rule && rule.footprintFromGeometry ? " | Y: deck top ".concat(floorTopY.toFixed(2), ", article [").concat(rect.minY.toFixed(2), ", ").concat(rect.maxY.toFixed(2), "], slice keeps \u2265 ").concat((floorTopY - rule.footprintSliceDepth).toFixed(2)) : '';
+    var fpInfo;
+    if (footprint.source === '') {
+      fpInfo = ' | NO outline rule matched this codex → NO COLLAR, the authored hole stays fully open';
+    } else if (fpBounds && points) {
+      // Room left between the outline and each authored hole edge. Negative on any
+      // side = the article is bigger than the hole it sits in; the collar clamps
+      // the outline to the hole and degrades toward a solid slab.
+      var slack = [fpBounds[0] - (hole.centerX - hole.halfExtentX), hole.centerX + hole.halfExtentX - fpBounds[1], fpBounds[2] - (hole.centerZ - hole.halfExtentZ), hole.centerZ + hole.halfExtentZ - fpBounds[3]].map(function (v) {
+        return v.toFixed(2);
+      });
+      fpInfo = " | measured ".concat(rawSizeX.toFixed(2), "\xD7").concat(rawSizeZ.toFixed(2)) + (footprint.tracedBounds === '' ? '' : " | traced ".concat(footprint.sampledCount, " pts ").concat(footprint.tracedBounds)) + " | outline ".concat(points.length, " pts X [").concat(fpBounds[0].toFixed(2), ", ").concat(fpBounds[1].toFixed(2), "] Z [").concat(fpBounds[2].toFixed(2), ", ").concat(fpBounds[3].toFixed(2), "]") + " | hole X [".concat((hole.centerX - hole.halfExtentX).toFixed(2), ", ").concat((hole.centerX + hole.halfExtentX).toFixed(2), "] Z [").concat((hole.centerZ - hole.halfExtentZ).toFixed(2), ", ").concat((hole.centerZ + hole.halfExtentZ).toFixed(2), "]") + " | slack X ".concat(slack[0], "/").concat(slack[1], " Z ").concat(slack[2], "/").concat(slack[3]) + " | ".concat(footprint.source).concat(footprint.repairNote) + (footprint.trace.loops > 0 ? " | trace: ".concat(footprint.trace.filledCells, " cells (").concat(footprint.trace.enclosedFilled, " filled in), ").concat(footprint.trace.loops, " loop(s), kept ").concat((footprint.trace.chosenAreaShare * 100).toFixed(0), "% of contour area, ").concat(footprint.trace.pointsBeforeSimplify, " \u2192 ").concat(footprint.trace.pointsAfterSimplify, " pts") : '');
+    } else {
+      fpInfo = " | ".concat(footprint.source, " produced NO usable outline (").concat(footprint.sampledCount, " pts)").concat(footprint.repairNote, " \u2192 NO COLLAR, the authored hole stays fully open");
+    }
+    return "[DeckCutout] article codex: ".concat(primaryCodex !== null && primaryCodex !== void 0 ? primaryCodex : '(unknown)', " \u2192 rule: ").concat(rule ? "'".concat(rule.match, "'") : '(none — articleSync globals)').concat(sliceInfo).concat(fpInfo);
+  };
   return {
     key: key,
-    message: "[DeckCutout] article codex: ".concat(primaryCodex !== null && primaryCodex !== void 0 ? primaryCodex : '(unknown)', " \u2192 rule: ").concat(rule ? "'".concat(rule.match, "'") : '(none — articleSync globals)').concat(sliceInfo).concat(fpInfo)
+    message: message
   };
 }
 
@@ -1259,12 +1340,9 @@ function DeckCutoutArticleSync() {
   var scene = useThree(function (s) {
     return s.scene;
   });
-  var deckCutoutJson = useRTVStore(function (s) {
-    return JSON.stringify(s.resolvedEnvironment.scene.deckCutout);
+  var deform = useStableEnvSlice(function (env) {
+    return env.scene.deckCutout;
   });
-  var deform = useMemo(function () {
-    return JSON.parse(deckCutoutJson);
-  }, [deckCutoutJson]);
   var setWaterOverride = useRTVStore(function (s) {
     return s.setWaterVolumeOverride;
   });
@@ -1383,7 +1461,12 @@ function DeckCutoutArticleSync() {
     var _pickArticleRule = pickArticleRule(deform.articleRules, measured.codexesByArea),
       rule = _pickArticleRule.rule,
       primaryCodex = _pickArticleRule.primaryCodex;
-    var traced = deriveArticleFootprint(measured, rule, deform.articleSync.margin, geometryCacheRef);
+    // The anchor's lift changes what clears the slice plane and used to force a second full trace
+    // per article load. It is fully determined here (same formula as `deriveElementAnchor`), so
+    // the first trace evaluates the article at its post-lift height directly.
+    var anchorCfg = deform.elementAnchor;
+    var pendingLiftY = anchorActive ? (anchorCfg.alignTopToDeck ? measured.floorTopY - measured.rect.maxY : 0) + anchorCfg.offsetY : 0;
+    var traced = deriveArticleFootprint(measured, rule, deform.articleSync.margin, geometryCacheRef, pendingLiftY);
     var rect = traced.rim ? _objectSpread(_objectSpread({}, measured.rect), traced.rim) : measured.rect;
     var log = measureLog({
       measurement: measured,
@@ -1394,7 +1477,7 @@ function DeckCutoutArticleSync() {
     });
     if (matchLogRef.current !== log.key) {
       matchLogRef.current = log.key;
-      LOG$2.debug(log.message);
+      LOG$2.debug(log.message());
     }
 
     // The deck is never reshaped: the collar fills everything between its
@@ -2167,8 +2250,10 @@ function buildCollarGeometry(_ref) {
       uvs[_i * 2] = (_x * cos - _z * sin) / scale;
       uvs[_i * 2 + 1] = (_x * sin + _z * cos) / scale;
     }
-    geo.setAttribute('uv', new BufferAttribute(uvs, 2));
-    geo.setAttribute('uv1', new BufferAttribute(uvs, 2));
+    // ONE attribute on both slots: two attribute objects over the same array upload two GL buffers.
+    var uvAttribute = new BufferAttribute(uvs, 2);
+    geo.setAttribute('uv', uvAttribute);
+    geo.setAttribute('uv1', uvAttribute);
   } else if (deck.triangles) {
     // Continue the deck's own mapping. One fitted mapping when the deck's
     // unwrap is a single plane — it cannot shear, whereas deciding per vertex
@@ -2196,8 +2281,10 @@ function buildCollarGeometry(_ref) {
       _uvs[_i2 * 2] = sampled[0];
       _uvs[_i2 * 2 + 1] = sampled[1];
     }
-    geo.setAttribute('uv', new BufferAttribute(_uvs, 2));
-    geo.setAttribute('uv1', new BufferAttribute(_uvs, 2));
+    // See above — one attribute, one GL buffer, both slots.
+    var _uvAttribute = new BufferAttribute(_uvs, 2);
+    geo.setAttribute('uv', _uvAttribute);
+    geo.setAttribute('uv1', _uvAttribute);
   }
   return {
     geometry: geo,
@@ -2319,12 +2406,9 @@ function DeckCutoutCollar() {
   var scene = useThree(function (s) {
     return s.scene;
   });
-  var deckCutoutJson = useRTVStore(function (s) {
-    return JSON.stringify(s.resolvedEnvironment.scene.deckCutout);
+  var deform = useStableEnvSlice(function (env) {
+    return env.scene.deckCutout;
   });
-  var deform = useMemo(function () {
-    return JSON.parse(deckCutoutJson);
-  }, [deckCutoutJson]);
   var footprint = useRTVStore(function (s) {
     return s.deckCutoutFootprintOverride;
   });