@crystaldesign/real-time-viewer-next 26.11.0-beta.18

package/build/esm/DeckCutoutSubsystem-76dfe828.js

@@ -0,0 +1,2536 @@
+import { p as parseElementKey, u as useRTVStore, b as bootPhase, D as DECK_COLLAR_LOAD_ID } from './index-920dd901.js';
+import { useMemo, useRef, useEffect, 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';
+import { getLogger } from '@crystaldesign/diva-core';
+import { Box3, Matrix4, Vector3, Matrix3, MeshStandardMaterial, Shape, Path, ExtrudeGeometry, BufferAttribute, TextureLoader, SRGBColorSpace, RepeatWrapping } from 'three';
+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 '@react-three/drei';
+import '@babel/runtime/helpers/classCallCheck';
+import '@babel/runtime/helpers/createClass';
+import '@babel/runtime/helpers/possibleConstructorReturn';
+import '@babel/runtime/helpers/getPrototypeOf';
+import '@babel/runtime/helpers/inherits';
+import 'classnames';
+import 'three-mesh-bvh';
+import '@babel/runtime/helpers/objectWithoutProperties';
+import 'three/examples/jsm/environments/RoomEnvironment.js';
+import 'three/examples/jsm/loaders/RGBELoader.js';
+import 'three/examples/jsm/loaders/EXRLoader.js';
+import '@react-three/postprocessing';
+import '@babel/runtime/helpers/construct';
+import 'detect-gpu';
+
+var ELEMENT_PREFIX = 'Element#';
+var _elementBox = new Box3();
+var _unionBox = new Box3();
+
+/** Article bounds in the deck mesh's local frame. */
+
+/** One planner element's article codex and its plan area, for the rule lookup. */
+
+/** Top-level planner element groups (no `Element#` ancestor) — the ones the anchor moves and the projection walks. */
+function topLevelElements(elementObjects) {
+  return elementObjects.filter(function (obj) {
+    for (var p = obj.parent; p; p = p.parent) {
+      if (p.name.startsWith(ELEMENT_PREFIX)) return false;
+    }
+    return true;
+  });
+}
+
+/** Same rect moved by a floor-local delta. */
+function shiftRect(rect, delta) {
+  return {
+    minX: rect.minX + delta.dx,
+    maxX: rect.maxX + delta.dx,
+    minY: rect.minY + delta.dy,
+    maxY: rect.maxY + delta.dy,
+    minZ: rect.minZ + delta.dz,
+    maxZ: rect.maxZ + delta.dz
+  };
+}
+
+/**
+ * Union bounds of every planner `Element#` group, expressed in the floor meshes'
+ * shared local space via the first name-matched deck mesh's inverse world
+ * matrix. That mesh is the one `meshesMatching` also hands the collar as its
+ * reference, so both work in identical coordinates.
+ *
+ * Returns null while the article or the deck isn't in the scene yet.
+ */
+function measureArticle(scene, patterns, elementsInfo) {
+  var _floorGeometry$boundi, _floorGeometry$boundi2;
+  var elementObjects = [];
+  var codexesByArea = [];
+  // Single-element holder rather than a `let`: the reference is assigned inside
+  // the traversal callback, which TypeScript's flow analysis does not follow.
+  var floorMatch = [];
+  _unionBox.makeEmpty();
+  scene.traverse(function (obj) {
+    var _elementsInfo$get;
+    // Same pre-order and same first-match rule as `meshesMatching`, folded into
+    // this traversal: a measure runs every frame while the pipeline converges,
+    // and walking the whole scene twice for it is the avoidable half.
+    if (floorMatch.length === 0) {
+      var mesh = obj;
+      if (mesh.isMesh && patterns.some(function (p) {
+        return mesh.name.includes(p);
+      })) floorMatch.push(mesh);
+    }
+    if (!obj.name.startsWith(ELEMENT_PREFIX)) return;
+    elementObjects.push(obj);
+    _elementBox.setFromObject(obj);
+    if (_elementBox.isEmpty()) return;
+    _unionBox.union(_elementBox);
+    var codex = (_elementsInfo$get = elementsInfo.get(parseElementKey(obj.name))) === null || _elementsInfo$get === void 0 ? void 0 : _elementsInfo$get.articleCodex;
+    if (codex !== undefined) {
+      codexesByArea.push({
+        codex: codex,
+        area: (_elementBox.max.x - _elementBox.min.x) * (_elementBox.max.z - _elementBox.min.z)
+      });
+    }
+  });
+  codexesByArea.sort(function (a, b) {
+    return b.area - a.area;
+  });
+  if (_unionBox.isEmpty()) return null;
+  var floorMesh = floorMatch[0];
+  if (!floorMesh) return null;
+  var floorLocal = new Matrix4().copy(floorMesh.matrixWorld).invert();
+  var floorGeometry = floorMesh.geometry;
+  if (!floorGeometry.boundingBox) floorGeometry.computeBoundingBox();
+  var floorTopY = (_floorGeometry$boundi = (_floorGeometry$boundi2 = floorGeometry.boundingBox) === null || _floorGeometry$boundi2 === void 0 ? void 0 : _floorGeometry$boundi2.max.y) !== null && _floorGeometry$boundi !== void 0 ? _floorGeometry$boundi : 0;
+  var worldBottomY = _unionBox.min.y;
+  // applyMatrix4 transforms all 8 corners and re-wraps them axis-aligned —
+  // exactly the article's footprint in floor-local space.
+  _unionBox.applyMatrix4(floorLocal);
+  return {
+    rect: {
+      minX: _unionBox.min.x,
+      maxX: _unionBox.max.x,
+      minY: _unionBox.min.y,
+      maxY: _unionBox.max.y,
+      minZ: _unionBox.min.z,
+      maxZ: _unionBox.max.z
+    },
+    worldBottomY: worldBottomY,
+    elementObjects: elementObjects,
+    codexesByArea: codexesByArea,
+    floorWorld: floorMesh.matrixWorld,
+    floorLocal: floorLocal,
+    floorTopY: floorTopY
+  };
+}
+
+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; }
+/*
+ * 2D polygon primitives — area, simplification, self-intersection guard, hull.
+ */
+
+/** 2D point; axis meaning depends on context (path space: x/y, floor space: x/z). */
+
+var EPS$2 = 1e-9;
+
+/** Shoelace signed area — positive for counter-clockwise winding (y-up convention). */
+function polygonSignedArea(points) {
+  var area = 0;
+  for (var i = 0; i < points.length; i++) {
+    var _points$i = _slicedToArray(points[i], 2),
+      x1 = _points$i[0],
+      y1 = _points$i[1];
+    var _points = _slicedToArray(points[(i + 1) % points.length], 2),
+      x2 = _points[0],
+      y2 = _points[1];
+    area += x1 * y2 - x2 * y1;
+  }
+  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;
+    }
+  }
+  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 farIdx = 1;
+  var farDist = -1;
+  for (var i = 1; i < points.length; i++) {
+    var d = Math.hypot(points[i][0] - sx, points[i][1] - sz);
+    if (d > farDist) {
+      farDist = d;
+      farIdx = i;
+    }
+  }
+  var out = [];
+  simplifyChain(points.slice(0, farIdx + 1), tolerance, out);
+  simplifyChain([].concat(_toConsumableArray(points.slice(farIdx)), [points[0]]), tolerance, out);
+  return out;
+}
+
+/** Do the closed segments a→b and c→d properly cross? Shared endpoints don't count. */
+function segmentsCross(ax, az, bx, bz, cx, cz, dx, dz) {
+  var cross = function cross(px, pz, qx, qz, rx, rz) {
+    return (qx - px) * (rz - pz) - (qz - pz) * (rx - px);
+  };
+  var d1 = cross(ax, az, bx, bz, cx, cz);
+  var d2 = cross(ax, az, bx, bz, dx, dz);
+  var d3 = cross(cx, cz, dx, dz, ax, az);
+  var d4 = cross(cx, cz, dx, dz, bx, bz);
+  // Strict sign change on both segments = a proper crossing. Collinear/touching
+  // cases are deliberately NOT flagged: traced outlines touch constantly and a
+  // triangulator handles that fine.
+  return (d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0);
+}
+
+/** True when no two non-adjacent edges of the closed polygon cross. O(n²) — fine for outline-sized input. */
+function isSimplePolygon(points) {
+  var n = points.length;
+  if (n < 4) return true;
+  for (var i = 0; i < n; i++) {
+    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];
+    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];
+      if (segmentsCross(ax, az, bx, bz, cx, cz, dx, dz)) return false;
+    }
+  }
+  return true;
+}
+
+/** Convex hull (Andrew's monotone chain), counter-clockwise. */
+function convexHull(points) {
+  if (points.length < 3) return _toConsumableArray(points);
+  var sorted = _toConsumableArray(points).sort(function (a, b) {
+    return a[0] - b[0] || a[1] - b[1];
+  });
+  var cross = function cross(o, a, b) {
+    return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+  };
+  var build = function build(input) {
+    var chain = [];
+    var _iterator = _createForOfIteratorHelper$6(input),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var p = _step.value;
+        while (chain.length >= 2 && cross(chain[chain.length - 2], chain[chain.length - 1], p) <= 0) chain.pop();
+        chain.push(p);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return chain;
+  };
+  var lower = build(sorted);
+  var upper = build(_toConsumableArray(sorted).reverse());
+  return [].concat(_toConsumableArray(lower.slice(0, -1)), _toConsumableArray(upper.slice(0, -1)));
+}
+
+/**
+ * Guarantee a polygon a triangulator can use. A self-intersecting outline is
+ * NOT rejected by earcut — it silently produces garbage (a stray wedge across
+ * the shape), so anything feeding generated geometry has to be checked first.
+ *
+ * The repair is the convex hull: a pool/article silhouette is convex or nearly
+ * so, which makes the hull a close and always-simple stand-in — visibly a
+ * little too generous rather than visibly broken. Returns null when even that
+ * degenerates.
+ */
+function ensureSimplePolygon(points) {
+  if (points.length < 3) return null;
+  if (isSimplePolygon(points)) {
+    // Collinear points pass the crossing test but enclose nothing, and a polygon the triangulator
+    // turns into zero triangles is not one this may hand back as clean.
+    if (Math.abs(polygonSignedArea(points)) <= EPS$2) return null;
+    return {
+      points: _toConsumableArray(points),
+      repaired: false
+    };
+  }
+  var hull = convexHull(points);
+  // The area check must stay inside the branches: a symmetric bowtie has signed area exactly 0,
+  // and it is the hull repair - not a rejection - that such an outline needs.
+  if (hull.length < 3 || Math.abs(polygonSignedArea(hull)) <= EPS$2) return null;
+  return {
+    points: hull,
+    repaired: true
+  };
+}
+
+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; }
+/*
+ * Binary raster mask operations — morphology (closing, offsetting, enclosed
+ * fill) and marching-squares contouring.
+ *
+ * A mask is an `nx * nz` Uint8Array of 0/1, row-major, one value per cell
+ * centre; `originX/originZ` and `cell` map cell indices back to world units.
+ */
+
+/**
+ * Morphological closing (dilate then erode) with a square kernel of the given
+ * radius — bridges seams between separately modelled parts without moving the
+ * silhouette.
+ *
+ * Each of the four passes is a SLIDING-WINDOW box count: the window is updated
+ * by one entering and one leaving row/column instead of being re-summed, so
+ * the cost is O(cells) independent of radius and every access is sequential.
+ * The naive per-cell kernel form (especially its column-strided half) costs an
+ * order of magnitude more at a fine raster.
+ */
+function closeMask(mask, nx, nz, radius) {
+  if (radius < 1) return;
+  var scratch = new Uint8Array(mask.length);
+  boxPassX(mask, scratch, nx, nz, radius, true);
+  boxPassZ(scratch, mask, nx, nz, radius, true);
+  boxPassX(mask, scratch, nx, nz, radius, false);
+  boxPassZ(scratch, mask, nx, nz, radius, false);
+}
+
+/**
+ * Turn the mask into the SOLID region its outer contour encloses: flood the
+ * background inward from the (always empty) border and set everything the
+ * flood could not reach. Returns how many cells were added.
+ */
+function fillEnclosed(mask, nx, nz) {
+  var reached = new Uint8Array(mask.length);
+  var stack = [];
+  var visit = function visit(i) {
+    if (mask[i] !== 0 || reached[i] !== 0) return;
+    reached[i] = 1;
+    stack.push(i);
+  };
+  for (var ix = 0; ix < nx; ix++) {
+    visit(ix);
+    visit((nz - 1) * nx + ix);
+  }
+  for (var iz = 0; iz < nz; iz++) {
+    visit(iz * nx);
+    visit(iz * nx + nx - 1);
+  }
+  while (stack.length > 0) {
+    var i = stack.pop();
+    var _ix = i % nx;
+    var _iz = (i - _ix) / nx;
+    if (_ix > 0) visit(i - 1);
+    if (_ix < nx - 1) visit(i + 1);
+    if (_iz > 0) visit(i - nx);
+    if (_iz < nz - 1) visit(i + nx);
+  }
+  var added = 0;
+  for (var _i = 0; _i < mask.length; _i++) {
+    if (mask[_i] === 0 && reached[_i] === 0) {
+      mask[_i] = 1;
+      added += 1;
+    }
+  }
+  return added;
+}
+
+/**
+ * Single morphological pass — dilate (grow) or erode (shrink) by a square
+ * kernel of the given radius. The raster form of a polygon offset: the same
+ * operation applied uniformly to every boundary cell, so it can neither miter
+ * a corner off nor cross itself across a concavity. The kernel is a square, so
+ * the offset is Chebyshev — exact on axis-aligned edges, up to √2 larger on
+ * 45° ones.
+ */
+function offsetMask(mask, nx, nz, radius, dilate) {
+  var scratch = new Uint8Array(mask.length);
+  boxPassX(mask, scratch, nx, nz, radius, dilate);
+  boxPassZ(scratch, mask, nx, nz, radius, dilate);
+}
+
+/** Per-index window sizes along an axis of length `n`, clipped at both ends (erode compares against these). */
+function windowSizes(radius, n) {
+  var sizes = new Int32Array(n);
+  for (var i = 0; i < n; i++) sizes[i] = Math.min(n - 1, i + radius) - Math.max(0, i - radius) + 1;
+  return sizes;
+}
+
+/** Horizontal box pass: `dilate` = any cell set in the window, else = all cells set. */
+function boxPassX(src, dst, nx, nz, radius, dilate) {
+  var sizes = windowSizes(radius, nx);
+  for (var iz = 0; iz < nz; iz++) {
+    var row = iz * nx;
+    var count = 0;
+    for (var k = 0; k <= radius && k < nx; k++) count += src[row + k];
+    for (var ix = 0; ix < nx; ix++) {
+      dst[row + ix] = (dilate ? count > 0 : count === sizes[ix]) ? 1 : 0;
+      var leaving = ix - radius;
+      var entering = ix + radius + 1;
+      if (leaving >= 0) count -= src[row + leaving];
+      if (entering < nx) count += src[row + entering];
+    }
+  }
+}
+
+/** Vertical box pass, carrying one count per column so rows are read in order. */
+function boxPassZ(src, dst, nx, nz, radius, dilate) {
+  var counts = new Int32Array(nx);
+  var sizes = windowSizes(radius, nz);
+  for (var k = 0; k <= radius && k < nz; k++) {
+    var row = k * nx;
+    for (var ix = 0; ix < nx; ix++) counts[ix] += src[row + ix];
+  }
+  for (var iz = 0; iz < nz; iz++) {
+    var _row = iz * nx;
+    var size = sizes[iz];
+    for (var _ix2 = 0; _ix2 < nx; _ix2++) dst[_row + _ix2] = (dilate ? counts[_ix2] > 0 : counts[_ix2] === size) ? 1 : 0;
+    var leaving = iz - radius;
+    var entering = iz + radius + 1;
+    if (leaving >= 0) {
+      var o = leaving * nx;
+      for (var _ix3 = 0; _ix3 < nx; _ix3++) counts[_ix3] -= src[o + _ix3];
+    }
+    if (entering < nz) {
+      var _o = entering * nx;
+      for (var _ix4 = 0; _ix4 < nx; _ix4++) counts[_ix4] += src[_o + _ix4];
+    }
+  }
+}
+
+/**
+ * Segment table per marching-squares case. Corners c0=(ix,iz) c1=(ix+1,iz)
+ * c2=(ix+1,iz+1) c3=(ix,iz+1); edges e0=c0c1 e1=c1c2 e2=c2c3 e3=c3c0. The
+ * saddle cases (5, 10) are split into two separate blobs.
+ */
+var MS_SEGMENTS = [[], [[3, 0]], [[0, 1]], [[3, 1]], [[1, 2]], [[3, 0], [1, 2]], [[0, 2]], [[3, 2]], [[2, 3]], [[0, 2]], [[0, 1], [2, 3]], [[1, 2]], [[1, 3]], [[0, 1]], [[3, 0]], []];
+
+/** Contour a binary node grid (values at cell centers) into closed loops of edge-midpoint coordinates. */
+function marchingSquaresLoops(mask, nx, nz, originX, originZ, cell) {
+  // Edge keys: horizontal edge between nodes (ix,iz)-(ix+1,iz) → 2*(iz*nx+ix); vertical (ix,iz)-(ix,iz+1) → 2*(iz*nx+ix)+1.
+  var edgeKey = function edgeKey(edge, ix, iz) {
+    if (edge === 0) return 2 * (iz * nx + ix);
+    if (edge === 2) return 2 * ((iz + 1) * nx + ix);
+    if (edge === 3) return 2 * (iz * nx + ix) + 1;
+    return 2 * (iz * nx + ix + 1) + 1;
+  };
+  var edgePoint = function edgePoint(key) {
+    var idx = Math.floor(key / 2);
+    var ix = idx % nx;
+    var iz = Math.floor(idx / nx);
+    return key % 2 === 0 ? [originX + (ix + 1) * cell, originZ + (iz + 0.5) * cell] : [originX + (ix + 0.5) * cell, originZ + (iz + 1) * cell];
+  };
+  var adjacency = new Map();
+  var link = function link(a, b) {
+    var la = adjacency.get(a);
+    if (la) la.push(b);else adjacency.set(a, [b]);
+    var lb = adjacency.get(b);
+    if (lb) lb.push(a);else adjacency.set(b, [a]);
+  };
+  for (var iz = 0; iz < nz - 1; iz++) {
+    for (var ix = 0; ix < nx - 1; ix++) {
+      var c = mask[iz * nx + ix] | mask[iz * nx + ix + 1] << 1 | mask[(iz + 1) * nx + ix + 1] << 2 | mask[(iz + 1) * nx + ix] << 3;
+      // 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]),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _slicedToArray(_step.value, 2),
+            ea = _step$value[0],
+            eb = _step$value[1];
+          link(edgeKey(ea, ix, iz), edgeKey(eb, ix, iz));
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }
+  var visited = new Set();
+  var loops = [];
+  var _iterator2 = _createForOfIteratorHelper$5(adjacency.keys()),
+    _step2;
+  try {
+    var _loop = function _loop() {
+      var start = _step2.value;
+      if (visited.has(start)) return 1; // continue
+      var loop = [];
+      var cur = start;
+      var prev = -1;
+      while (!visited.has(cur)) {
+        var _adjacency$get;
+        visited.add(cur);
+        loop.push(edgePoint(cur));
+        var next = ((_adjacency$get = adjacency.get(cur)) !== null && _adjacency$get !== void 0 ? _adjacency$get : []).find(function (k) {
+          return k !== prev && !visited.has(k);
+        });
+        if (next === undefined) break;
+        prev = cur;
+        cur = next;
+      }
+      if (loop.length >= 3) loops.push(loop);
+    };
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      if (_loop()) continue;
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return loops;
+}
+
+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
+ * graceful: the caller falls back to the measured rect.
+ */
+var MAX_MASK_CELLS = 16000000;
+
+/** What a trace did internally — see {@link TraceFootprintOptions.diagnostics}. */
+
+/**
+ * Trace the outer silhouette of a triangle soup already projected onto the
+ * plane: `triangleXZ` holds 6 numbers per triangle (x0 z0 x1 z1 x2 z2). The
+ * triangles are rasterized into a binary mask (cell centers + vertices + edge
+ * samples, then a 3×3 closing to seal sliver gaps), the mask is contoured with
+ * marching squares, and the largest closed loop is simplified. Returns [] when
+ * nothing usable comes out (fewer than 3 triangles, degenerate extent).
+ */
+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 triCount = Math.floor(triangleXZ.length / 6);
+  if (triCount < 1 || cell <= 0) return [];
+  var minX = Infinity;
+  var maxX = -Infinity;
+  var minZ = Infinity;
+  var maxZ = -Infinity;
+  for (var i = 0; i < triCount * 6; i += 2) {
+    var x = triangleXZ[i];
+    var z = triangleXZ[i + 1];
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (z < minZ) minZ = z;
+    if (z > maxZ) maxZ = z;
+  }
+  if (!Number.isFinite(minX) || maxX - minX < cell || maxZ - minZ < cell) return [];
+
+  // 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
+  // outermost cells, and the last ring keeps the contour closed.
+  var border = closeRadius + (grow ? offsetRadius : 0) + 1;
+  var originX = minX - border * cell;
+  var originZ = minZ - border * cell;
+  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 cellOf = function cellOf(v, origin, n) {
+    return Math.min(n - border - 1, Math.max(border, Math.floor((v - origin) / cell)));
+  };
+  var mark = function mark(x, z) {
+    mask[cellOf(z, originZ, nz) * nx + cellOf(x, originX, nx)] = 1;
+  };
+  for (var t = 0; t < triCount; t++) {
+    var o = t * 6;
+    var x0 = triangleXZ[o];
+    var z0 = triangleXZ[o + 1];
+    var x1 = triangleXZ[o + 2];
+    var z1 = triangleXZ[o + 3];
+    var x2 = triangleXZ[o + 4];
+    var z2 = triangleXZ[o + 5];
+    mark(x0, z0);
+    mark(x1, z1);
+    mark(x2, z2);
+
+    // Edge sampling is only needed for SLIVERS — a triangle thinner than a
+    // raster row can fall between row centers and be missed by the scanline
+    // fill below. Fat triangles (the vast majority in a real mesh) are fully
+    // covered by the fill, and skipping their edges is the difference between
+    // a fine raster being affordable and not.
+    var twiceArea = Math.abs((x1 - x0) * (z2 - z0) - (x2 - x0) * (z1 - z0));
+    var longestEdge = Math.max(Math.hypot(x1 - x0, z1 - z0), Math.hypot(x2 - x1, z2 - z1), Math.hypot(x0 - x2, z0 - z2));
+    var thickness = longestEdge > EPS$1 ? twiceArea / longestEdge : 0;
+    if (thickness < cell * 1.5) {
+      var edges = [[x0, z0, x1, z1], [x1, z1, x2, z2], [x2, z2, x0, z0]];
+      for (var _i = 0, _edges = edges; _i < _edges.length; _i++) {
+        var _edges$_i = _slicedToArray(_edges[_i], 4),
+          ax = _edges$_i[0],
+          az = _edges$_i[1],
+          bx = _edges$_i[2],
+          bz = _edges$_i[3];
+        var steps = Math.ceil(Math.hypot(bx - ax, bz - az) / (cell * 0.7));
+        for (var st = 1; st < steps; st++) {
+          var f = st / steps;
+          mark(ax + (bx - ax) * f, az + (bz - az) * f);
+        }
+      }
+    }
+    // Interior: scanline spans. Each raster row crosses a triangle in exactly
+    // one x interval, so the row is filled with a single `fill()` — no
+    // per-cell inside test, which is what makes a fine raster affordable.
+    var cz0 = cellOf(Math.min(z0, z1, z2), originZ, nz);
+    var cz1 = cellOf(Math.max(z0, z1, z2), originZ, nz);
+    for (var iz = cz0; iz <= cz1; iz++) {
+      var pz = originZ + (iz + 0.5) * cell;
+      var xa = Infinity;
+      var xb = -Infinity;
+      // Half-open [lo, hi) span test per edge ⇒ exactly two crossings, no
+      // double-count at shared vertices. Horizontal edges never cross.
+      for (var e = 0; e < 3; e++) {
+        var _ax = e === 0 ? x0 : e === 1 ? x1 : x2;
+        var _az = e === 0 ? z0 : e === 1 ? z1 : z2;
+        var _bx = e === 0 ? x1 : e === 1 ? x2 : x0;
+        var _bz = e === 0 ? z1 : e === 1 ? z2 : z0;
+        if (_az === _bz) continue;
+        if (pz < Math.min(_az, _bz) || pz >= Math.max(_az, _bz)) continue;
+        var _x = _ax + (pz - _az) / (_bz - _az) * (_bx - _ax);
+        if (_x < xa) xa = _x;
+        if (_x > xb) xb = _x;
+      }
+      if (xa > xb) continue;
+      // Fill the cells whose CENTER lies inside the span.
+      var from = Math.max(border, Math.ceil((xa - originX) / cell - 0.5));
+      var to = Math.min(nx - border - 1, Math.floor((xb - originX) / cell - 0.5));
+      if (from <= to) mask.fill(1, iz * nx + from, iz * nx + to + 1);
+    }
+  }
+  closeMask(mask, nx, nz, closeRadius);
+  // Offset AFTER the closing: seams have to be sealed before the boundary is
+  // moved, or the erosion widens them instead. An erosion strong enough to
+  // consume a thin shape empties the mask and the trace reports no contour,
+  // which the caller handles as a failed trace.
+  // Solidify BEFORE offsetting. The caller's slice keeps only geometry near the
+  // article's top, so a basin projects as a ring — its rim band with an empty
+  // middle. Eroding that ring thins it from both sides and destroys it once it
+  // is narrower than the offset, instead of moving the silhouette's outer
+  // boundary inward. Filling the enclosed middle first makes the erosion mean
+  // what it should. After the closing, so a sealed seam can't leak the fill out.
+  var enclosedFilled = fillEnclosed(mask, nx, nz);
+  if (offsetRadius >= 1) offsetMask(mask, nx, nz, offsetRadius, grow);
+  var diag = options.diagnostics;
+  if (diag) {
+    diag.enclosedFilled = enclosedFilled;
+    var filled = 0;
+    for (var _i2 = 0; _i2 < mask.length; _i2++) filled += mask[_i2];
+    diag.filledCells = filled;
+  }
+  var loops = marchingSquaresLoops(mask, nx, nz, originX, originZ, cell);
+  if (diag) diag.loops = loops.length;
+  if (loops.length === 0) return [];
+  var best = loops[0];
+  var bestArea = Math.abs(polygonSignedArea(best));
+  var totalArea = bestArea;
+  for (var _i3 = 1; _i3 < loops.length; _i3++) {
+    var a = Math.abs(polygonSignedArea(loops[_i3]));
+    totalArea += a;
+    if (a > bestArea) {
+      bestArea = a;
+      best = loops[_i3];
+    }
+  }
+  var simplified = simplifyClosedPolygon(best, tolerance);
+  if (diag) {
+    diag.chosenAreaShare = totalArea > 0 ? bestArea / totalArea : 0;
+    diag.pointsBeforeSimplify = best.length;
+    diag.pointsAfterSimplify = simplified.length;
+  }
+  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; }
+
+/** The subset of a deckCutout article rule the matcher needs. */
+
+/**
+ * First-match-wins lookup of an article rule by codex. Wildcard rules
+ * (`match: '*'` or empty) match even when no codex is known — they double as
+ * the fallback entry and keep footprints testable before the host ships
+ * per-element codexes.
+ */
+function matchArticleRule(rules, articleCodex) {
+  var _iterator = _createForOfIteratorHelper$4(rules),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var rule = _step.value;
+      var m = rule.match.trim();
+      if (m === '' || m === '*') return rule;
+      if (articleCodex === undefined) continue;
+      var hit = m.split(',').map(function (p) {
+        return p.trim();
+      }).filter(function (p) {
+        return p.length > 0;
+      }).some(function (p) {
+        return articleCodex.includes(p);
+      });
+      if (hit) return rule;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  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; }
+
+/**
+ * Raster cell (m) for the geometry-derived footprint. 5 mm follows cast-in
+ * steps and tight rim radii; the trace runs once per geometry change (cached),
+ * so the finer grid costs a one-off, not per-frame work.
+ */
+var GEOMETRY_FOOTPRINT_CELL = 0.005;
+
+/**
+ * Minimum share of the measured article extent a traced outline has to cover on
+ * BOTH axes to be believed. Below that it is a detail that happened to reach
+ * above the slice plane (a nozzle, a fitting) rather than the article's rim —
+ * and its bbox would otherwise drive the article's resting position too.
+ */
+var MIN_TRACE_COVERAGE = 0.6;
+/** Smallest usable rect extent (m) — guards the fallback against a margin that would invert it. */
+var MIN_RECT_EXTENT = 0.1;
+var _meshToFloor = new Matrix4();
+var _vertex$1 = new Vector3();
+
+/** XZ extents of the article's traced rim. */
+
+var EMPTY_TRACE_DIAGNOSTICS = function EMPTY_TRACE_DIAGNOSTICS() {
+  return {
+    filledCells: 0,
+    enclosedFilled: 0,
+    loops: 0,
+    chosenAreaShare: 0,
+    pointsBeforeSimplify: 0,
+    pointsAfterSimplify: 0
+  };
+};
+
+/**
+ * Rectangular fallback outline in floor-local XZ: the measured article rect
+ * grown by `margin` per side (negative laps the deck over the article). Null
+ * when the margin would collapse the rect.
+ */
+function measuredRectFootprint(rect, margin) {
+  var minX = rect.minX - margin;
+  var maxX = rect.maxX + margin;
+  var minZ = rect.minZ - margin;
+  var maxZ = rect.maxZ + margin;
+  if (maxX - minX < MIN_RECT_EXTENT || maxZ - minZ < MIN_RECT_EXTENT) return null;
+  return [[minX, minZ], [maxX, minZ], [maxX, maxZ], [minX, maxZ]];
+}
+
+/**
+ * First rule matching any element's codex, largest element first — but every
+ * element gets a look: an accessory bigger in plan than the article it belongs
+ * to (a roof, a surround) would otherwise name the scene, match nothing, and
+ * leave the deck area with no collar at all. `primaryCodex` reports whichever
+ * codex found the rule.
+ */
+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),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var candidate = _step.value;
+      var hit = matchArticleRule(rules, candidate.codex);
+      if (hit) {
+        rule = hit;
+        primaryCodex = candidate.codex;
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    rule: rule,
+    primaryCodex: primaryCodex
+  };
+}
+
+/**
+ * Silhouette of the article meshes projected onto the floor plane: every
+ * triangle with a vertex above `minLocalY` (floor-local) is rasterized and the
+ * outer contour traced. Expensive (walks all vertices), so the result is
+ * cached by a geometry signature and only re-traced when the article's
+ * 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) {
+  var meshes = [];
+  var sigParts = [];
+  var _iterator2 = _createForOfIteratorHelper$3(elements),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var el = _step2.value;
+      el.traverse(function (obj) {
+        var mesh = obj;
+        if (!mesh.isMesh || !mesh.visible) return;
+        var pos = mesh.geometry.getAttribute('position');
+        if (!pos) return;
+        meshes.push(mesh);
+        sigParts.push("".concat(mesh.name, ":").concat(pos.count));
+      });
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  if (meshes.length === 0) return null;
+  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(','));
+  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;
+        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 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;
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+    var traced = traceFootprintFromTriangles(xz, {
+      cellSize: GEOMETRY_FOOTPRINT_CELL,
+      offset: offset,
+      diagnostics: diagnostics
+    });
+    cache.current = {
+      signature: signature,
+      relPoints: traced.map(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+          x = _ref2[0],
+          z = _ref2[1];
+        return [x - rect.minX, z - rect.minZ];
+      }),
+      triCount: _triCount,
+      vertexCount: _vertexCount
+    };
+    return {
+      points: traced,
+      triCount: _triCount,
+      vertexCount: _vertexCount,
+      retraced: true,
+      traceMs: performance.now() - started
+    };
+  }
+  var _cache$current = cache.current,
+    relPoints = _cache$current.relPoints,
+    triCount = _cache$current.triCount,
+    vertexCount = _cache$current.vertexCount;
+  return {
+    points: relPoints.map(function (_ref3) {
+      var _ref4 = _slicedToArray(_ref3, 2),
+        x = _ref4[0],
+        z = _ref4[1];
+      return [x + rect.minX, z + rect.minZ];
+    }),
+    triCount: triCount,
+    vertexCount: vertexCount,
+    retraced: false,
+    traceMs: 0
+  };
+}
+
+/**
+ * The cutout outline for a measured article — offset by the deck margin, so it
+ * comes back as the collar's inner boundary. Needs no calibration: the trace
+ * follows the visible rim. Only `footprintFromGeometry` rules produce one;
+ * without such a rule the deck's authored hole stays fully open.
+ */
+function deriveArticleFootprint(measurement, rule, margin, cache) {
+  var _result$points$length, _result$points;
+  var result = {
+    points: null,
+    rim: null,
+    sampledCount: 0,
+    source: '',
+    repairNote: '',
+    tracedBounds: '',
+    trace: EMPTY_TRACE_DIAGNOSTICS()
+  };
+  if (!rule || !rule.footprintFromGeometry) return result;
+  var rect = measurement.rect,
+    floorLocal = measurement.floorLocal,
+    floorTopY = measurement.floorTopY,
+    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 minX = Infinity;
+  var maxX = -Infinity;
+  var minZ = Infinity;
+  var maxZ = -Infinity;
+  if (traced && traced.points.length >= 3) {
+    var _iterator4 = _createForOfIteratorHelper$3(traced.points),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var _step4$value = _slicedToArray(_step4.value, 2),
+          x = _step4$value[0],
+          z = _step4$value[1];
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (z < minZ) minZ = z;
+        if (z > maxZ) maxZ = z;
+      }
+      // The contour comes back with `margin` already applied, so undo it here:
+      // 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);
+    } finally {
+      _iterator4.f();
+    }
+    minX += margin;
+    maxX -= margin;
+    minZ += margin;
+    maxZ -= margin;
+    result.tracedBounds = "X [".concat(minX.toFixed(2), ", ").concat(maxX.toFixed(2), "] Z [").concat(minZ.toFixed(2), ", ").concat(maxZ.toFixed(2), "]");
+  }
+  // A trace covering only a fraction of the measured article is not the rim
+  // (see MIN_TRACE_COVERAGE). Believing it is worse than not tracing at all:
+  // its bbox replaces the measured one, so it would also decide where the
+  // article comes to rest.
+  var believable = maxX > minX && maxX - minX >= rawSizeX * MIN_TRACE_COVERAGE && maxZ - minZ >= rawSizeZ * MIN_TRACE_COVERAGE;
+  if (traced && believable) {
+    var _guarded$points;
+    result.rim = {
+      minX: minX,
+      maxX: maxX,
+      minZ: minZ,
+      maxZ: maxZ
+    };
+    // The margin was applied to the raster, so the contour is already the
+    // collar's inner boundary. It still passes the simple-polygon guard:
+    // marching squares can loop around a thin feature in a way earcut turns
+    // into a stray wedge instead of rejecting.
+    var guarded = ensureSimplePolygon(traced.points);
+    if (guarded !== null && guarded !== void 0 && guarded.repaired) result.repairNote = ' | HULL-REPAIRED, traced outline self-intersects (concavities lost)';
+    if (guarded === null) result.repairNote = ' | outline UNUSABLE even as a hull';
+    result.points = (_guarded$points = guarded === null || guarded === void 0 ? void 0 : guarded.points) !== null && _guarded$points !== void 0 ? _guarded$points : null;
+    result.sampledCount = traced.points.length;
+    result.source = traced.retraced ? "geometry traced in ".concat(traced.traceMs.toFixed(1), " ms (").concat(traced.vertexCount, " verts, ").concat(traced.triCount, " tris in slice)") : "geometry cached (".concat(traced.triCount, " tris in slice)");
+    return result;
+  }
+
+  // Rectangular cutout from the measured rect instead. Correctly sized and
+  // placed, just not shaped — which beats both a hole shaped by a stray detail
+  // and no cutout at all in a deck-sized authored hole.
+  result.points = measuredRectFootprint(rect, margin);
+  result.sampledCount = (_result$points$length = (_result$points = result.points) === null || _result$points === void 0 ? void 0 : _result$points.length) !== null && _result$points$length !== void 0 ? _result$points$length : 0;
+  result.source = maxX > minX ? "geometry: TRACE COVERS ONLY ".concat(((maxX - minX) / rawSizeX * 100).toFixed(0), "%\xD7").concat(((maxZ - minZ) / rawSizeZ * 100).toFixed(0), "% of the article \u2014 fell back to the measured rect") : 'geometry: NO TRIANGLES ABOVE THE SLICE PLANE — fell back to the measured rect';
+  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; }
+
+/** Below this world delta (m) the element anchor correction is considered settled. */
+var ANCHOR_EPSILON = 1e-3;
+var _desired = new Vector3();
+var _measured = new Vector3();
+
+/**
+ * Distance to move one axis so the anchored part of the measured article lands
+ * on the anchored part of the region. `'min'`/`'max'` pin that edge (the offset
+ * reads as an inset from it) so the article grows away from it; `'center'`
+ * centres, so it grows both ways.
+ */
+function anchorDelta1D(mode, center, halfExtent, measuredMin, measuredMax, offset) {
+  if (mode === 'min') return center - halfExtent + offset - measuredMin;
+  if (mode === 'max') return center + halfExtent - offset - measuredMax;
+  return center + offset - (measuredMin + measuredMax) / 2;
+}
+/**
+ * Nudge the top-level element groups so the measured article rect settles at
+ * the hole center (+ configured fine-tune offsets), optionally lifting it so
+ * its top meets the deck. The measured rect already includes the currently
+ * applied offsets, so the correction is incremental and converges in one
+ * measurement. Null once it is within {@link ANCHOR_EPSILON} — or when there is
+ * no top-level element to move.
+ */
+function deriveElementAnchor(_ref) {
+  var rect = _ref.rect,
+    hole = _ref.hole,
+    anchor = _ref.anchor,
+    floorWorld = _ref.floorWorld,
+    elementObjects = _ref.elementObjects,
+    deckTopLocalY = _ref.deckTopLocalY,
+    currentOffsets = _ref.currentOffsets;
+  var localDx = anchorDelta1D(anchor.anchorX, hole.centerX, hole.halfExtentX, rect.minX, rect.maxX, anchor.offsetX);
+  var localDz = anchorDelta1D(anchor.anchorZ, hole.centerZ, hole.halfExtentZ, rect.minZ, rect.maxZ, anchor.offsetZ);
+  var centerX = (rect.minX + rect.maxX) / 2;
+  var centerZ = (rect.minZ + rect.maxZ) / 2;
+  // Vertical: HQS places every element on the ground, so a shallower basin
+  // would sit with its rim below the deck — out of the footprint slice, and
+  // visibly sunk. Aligning the TOP instead makes the basin's depth irrelevant.
+  var measuredTopY = rect.maxY;
+  var localDy = (anchor.alignTopToDeck ? deckTopLocalY - measuredTopY : 0) + anchor.offsetY;
+
+  // Convert the local-space correction to world space via two mapped points.
+  _desired.set(centerX + localDx, measuredTopY + localDy, centerZ + localDz).applyMatrix4(floorWorld);
+  _measured.set(centerX, measuredTopY, centerZ).applyMatrix4(floorWorld);
+  var dx = _desired.x - _measured.x;
+  var dy = _desired.y - _measured.y;
+  var dz = _desired.z - _measured.z;
+  if (Math.abs(dx) < ANCHOR_EPSILON && Math.abs(dy) < ANCHOR_EPSILON && Math.abs(dz) < ANCHOR_EPSILON) return null;
+  var topLevel = topLevelElements(elementObjects);
+  if (topLevel.length === 0) return null;
+  var offsets = {};
+  var _iterator = _createForOfIteratorHelper$2(topLevel),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _currentOffsets$key;
+      var obj = _step.value;
+      // MUST be the same key `ElementGroup` subscribes with — the composite
+      // element key ("2", "2.0.6"), NOT the raw `Element#` name suffix (which
+      // still carries the setId, e.g. "PLANNING_xE2").
+      var key = parseElementKey(obj.name);
+      var prev = (_currentOffsets$key = currentOffsets[key]) !== null && _currentOffsets$key !== void 0 ? _currentOffsets$key : [0, 0, 0];
+      offsets[key] = [prev[0] + dx, prev[1] + dy, prev[2] + dz];
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    delta: {
+      dx: localDx,
+      dy: localDy,
+      dz: localDz
+    },
+    offsets: offsets
+  };
+}
+
+/** Floor for the derived water-volume depth (m) — guards degenerate measurements while geo streams in. */
+var MIN_WATER_DEPTH = 0.5;
+var _basis = new Matrix3();
+var _center = new Vector3();
+var _extentX = new Vector3();
+var _extentZ = new Vector3();
+/**
+ * Water volume following the MEASURED article rect — the water surface is a
+ * property of the pool, not of the cutout, so it tracks the pool wherever the
+ * element anchor settles it. No feedback: water never influences the measurement.
+ *
+ * The DEPTH is derived too: waterline down to the measured article bottom. The
+ * volume only needs to BOUND the pool interior; the PoolHeightMap finds the real
+ * floor within it.
+ */
+function deriveWaterVolume(_ref) {
+  var rect = _ref.rect,
+    waterSync = _ref.waterSync,
+    floorWorld = _ref.floorWorld,
+    articleWorldBottomY = _ref.articleWorldBottomY,
+    waterlineY = _ref.waterlineY;
+  var inset = waterSync.inset;
+  var sizeX = Math.max(rect.maxX - rect.minX - 2 * inset, 0.1);
+  var sizeZ = Math.max(rect.maxZ - rect.minZ - 2 * inset, 0.1);
+  _center.set((rect.minX + rect.maxX) / 2 + waterSync.offsetX, 0, (rect.minZ + rect.maxZ) / 2 + waterSync.offsetZ);
+  _center.applyMatrix4(floorWorld);
+
+  // World-axis extents of the rotated local rect (scenes rotate in 90° steps,
+  // so this stays exact; diagonal rotations would conservatively grow it).
+  _basis.setFromMatrix4(floorWorld);
+  _extentX.set(sizeX, 0, 0).applyMatrix3(_basis);
+  _extentZ.set(0, 0, sizeZ).applyMatrix3(_basis);
+  var worldSizeX = Math.abs(_extentX.x) + Math.abs(_extentZ.x);
+  var worldSizeZ = Math.abs(_extentX.z) + Math.abs(_extentZ.z);
+  var depth = Math.max(waterlineY - articleWorldBottomY, MIN_WATER_DEPTH);
+  return {
+    center: [_center.x, waterlineY, _center.z],
+    size: [worldSizeX, depth, worldSizeZ]
+  };
+}
+
+/**
+ * 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.
+ */
+function measureLog(_ref) {
+  var _rule$match, _points$length, _fpBounds$map$join;
+  var measurement = _ref.measurement,
+    rule = _ref.rule,
+    primaryCodex = _ref.primaryCodex,
+    footprint = _ref.footprint,
+    hole = _ref.hole;
+  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 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");
+  }
+  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)
+  };
+}
+
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var LOG$2 = getLogger('RealTimeViewer', 'DeckCutoutArticleSync');
+
+/** Re-measure cadence in frames — article geo loads/changes are not frame-critical. */
+var MEASURE_INTERVAL_FRAMES = 30;
+/**
+ * Consecutive no-change measures after which the pipeline is considered settled
+ * and the cheap idle cadence resumes.
+ *
+ * Deliberately NOT paired with hiding the scene: a scene-load gate registered
+ * from here cannot hide the one frame that matters (the new article paints with
+ * the previous outline before `articleVersion` — a passive effect — can react),
+ * so it would only hide the frames that the folded-in anchor delta already
+ * eliminates, at the price of a blank/overlay flash on every change.
+ */
+var SETTLE_STABLE_MEASURES = 3;
+
+/**
+ * Drives the cutout outline, element placement and water volume from the live
+ * article geometry (`deckCutout.articleSync` and friends):
+ *
+ * 1. {@link measureArticle} takes the union AABB of all planner `Element#`
+ *    groups in the floor meshes' shared local space.
+ * 2. {@link deriveArticleFootprint} shapes the cutout outline →
+ *    `deckCutoutFootprintOverride`, which `DeckCutoutCollar` fills against the
+ *    deck's authored hole. Its traced rim replaces the measured extents for the
+ *    steps below, so parts under the deck don't inflate placement/water.
+ * 3. {@link deriveElementAnchor} repositions the elements so their bbox rests
+ *    inside the authored hole (HQS `PosPivot === 'CENTER'` grows articles from
+ *    center, so the resting spot has to be re-derived) → `elementAnchorOffsets`.
+ * 4. {@link deriveWaterVolume} follows the anchored rect → `waterVolumeOverride`.
+ *
+ * Re-converges (per-frame measuring) when article or decor geometry lands, and
+ * otherwise re-measures on a slow idle cadence for the inputs that have no
+ * event (imperative scene-transform edits). All writers are epsilon-compared,
+ * so unchanged measurements are no-ops.
+ */
+function DeckCutoutArticleSync() {
+  var scene = useThree(function (s) {
+    return s.scene;
+  });
+  var deckCutoutJson = useRTVStore(function (s) {
+    return JSON.stringify(s.resolvedEnvironment.scene.deckCutout);
+  });
+  var deform = useMemo(function () {
+    return JSON.parse(deckCutoutJson);
+  }, [deckCutoutJson]);
+  var setWaterOverride = useRTVStore(function (s) {
+    return s.setWaterVolumeOverride;
+  });
+  var setFootprintOverride = useRTVStore(function (s) {
+    return s.setDeckCutoutFootprintOverride;
+  });
+  var frameRef = useRef(0);
+  // Boot diagnostics: how many measure passes the pipeline needed before it produced an outline.
+  var measureCountRef = useRef(0);
+  var footprintMarkedRef = useRef(false);
+  // One-shot codex/rule log: fires only when the measured codex or matched rule changes.
+  var matchLogRef = useRef(null);
+  var geometryCacheRef = useRef(null);
+  // Settle tracking: measure every frame while the pipeline is still changing.
+  var settlingRef = useRef(false);
+  var stableMeasuresRef = useRef(0);
+  var active = deform.enabled && deform.articleSync.enabled;
+  var anchorActive = active && deform.elementAnchor.enabled;
+  var waterActive = active && deform.waterSync.enabled;
+
+  // Clear derived state when a driver is turned off (and on unmount) so the
+  // manual config values take effect again.
+  // The cleanup is registered even while the driver is ACTIVE: an unmount that leaves
+  // `deckCutout.enabled` on — the host dropping the 3D scene takes `mountScene3D` down while the
+  // water stays on `mountWater` — would otherwise strand the last article's derived geometry, and
+  // the pool would keep that article's centre and size.
+  useEffect(function () {
+    if (!active) setFootprintOverride(null);
+    return function () {
+      return setFootprintOverride(null);
+    };
+  }, [active, setFootprintOverride]);
+  useEffect(function () {
+    var clear = function clear() {
+      if (Object.keys(useRTVStore.getState().elementAnchorOffsets).length > 0) {
+        useRTVStore.getState().setElementAnchorOffsets({});
+      }
+    };
+    if (!anchorActive) clear();
+    return clear;
+  }, [anchorActive]);
+  useEffect(function () {
+    if (!waterActive) setWaterOverride(null);
+    return function () {
+      return setWaterOverride(null);
+    };
+  }, [waterActive, setWaterOverride]);
+  var patterns = useMemo(function () {
+    return deform.nodeMatch.split(',').map(function (p) {
+      return p.trim();
+    }).filter(function (p) {
+      return p.length > 0;
+    });
+  }, [deform.nodeMatch]);
+
+  // `articleVersion` fires from inside the article's Suspense boundary — when a
+  // new article's geometry is fully loaded and live; `decorVersion` when a deck
+  // GLB (the floor frame) has mounted. Those are exactly the moments the
+  // pipeline has to re-converge, and the moments before which nothing should be
+  // shown.
+  var articleVersion = useRTVStore(function (s) {
+    return s.articleVersion;
+  });
+  var decorVersion = useRTVStore(function (s) {
+    return s.decorVersion;
+  });
+  useEffect(function () {
+    if (!active) return;
+    settlingRef.current = true;
+    stableMeasuresRef.current = 0;
+  }, [articleVersion, decorVersion, active]);
+  useFrame(function () {
+    if (!active || patterns.length === 0) return;
+    frameRef.current += 1;
+    // While unsettled, measure EVERY frame: the pipeline converges by
+    // re-measuring (the element anchor corrects against its own last move), so
+    // on the idle cadence each step of that convergence is a visible ~0.5 s
+    // state. Per-frame measuring collapses them into consecutive frames.
+    if (!settlingRef.current && frameRef.current % MEASURE_INTERVAL_FRAMES !== 1) return;
+
+    // A measure that changes nothing marks progress toward "settled". State is
+    // epsilon-compared in the store, so an unchanged write keeps the SAME
+    // object reference — comparing references detects real change exactly.
+    var before = useRTVStore.getState();
+    var beforeWater = before.waterVolumeOverride;
+    var beforeFootprint = before.deckCutoutFootprintOverride;
+    var anchorMoved = false;
+    // `waiting` = the article or floor isn't there yet. Nothing to converge on,
+    // so drop to the idle cadence; their arrival re-arms per-frame measuring
+    // through the version effect above.
+    var finishMeasure = function finishMeasure() {
+      var waiting = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      if (waiting) {
+        stableMeasuresRef.current = 0;
+        settlingRef.current = false;
+        return;
+      }
+      var after = useRTVStore.getState();
+      var changed = anchorMoved || after.waterVolumeOverride !== beforeWater || after.deckCutoutFootprintOverride !== beforeFootprint;
+      if (changed) {
+        stableMeasuresRef.current = 0;
+        settlingRef.current = true;
+        return;
+      }
+      stableMeasuresRef.current += 1;
+      if (stableMeasuresRef.current >= SETTLE_STABLE_MEASURES) settlingRef.current = false;
+    };
+    measureCountRef.current += 1;
+    var measured = measureArticle(scene, patterns, useRTVStore.getState().elementsInfo);
+    if (!measured) {
+      setWaterOverride(null);
+      setFootprintOverride(null);
+      finishMeasure(true);
+      return;
+    }
+    var _pickArticleRule = pickArticleRule(deform.articleRules, measured.codexesByArea),
+      rule = _pickArticleRule.rule,
+      primaryCodex = _pickArticleRule.primaryCodex;
+    var traced = deriveArticleFootprint(measured, rule, deform.articleSync.margin, geometryCacheRef);
+    var rect = traced.rim ? _objectSpread(_objectSpread({}, measured.rect), traced.rim) : measured.rect;
+    var log = measureLog({
+      measurement: measured,
+      rule: rule,
+      primaryCodex: primaryCodex,
+      footprint: traced,
+      hole: deform.authoredHole
+    });
+    if (matchLogRef.current !== log.key) {
+      matchLogRef.current = log.key;
+      LOG$2.debug(log.message);
+    }
+
+    // The deck is never reshaped: the collar fills everything between its
+    // authored hole and the article outline, so the hole the article rests in is
+    // a constant of the asset. The anchor MUST use that same `authoredHole` —
+    // anchoring to a different rect strands the article against one edge of the
+    // region and leaves the far side unused (it shows up as clamped outline points).
+    var anchor = anchorActive ? deriveElementAnchor({
+      rect: rect,
+      hole: deform.authoredHole,
+      anchor: deform.elementAnchor,
+      floorWorld: measured.floorWorld,
+      elementObjects: measured.elementObjects,
+      deckTopLocalY: measured.floorTopY,
+      currentOffsets: useRTVStore.getState().elementAnchorOffsets
+    }) : null;
+    anchorMoved = anchor !== null;
+    if (anchor) useRTVStore.getState().setElementAnchorOffsets(anchor.offsets);
+    // The anchor's move only shows from the NEXT frame, so everything derived
+    // from the article's position — the water surface, the shaped outline —
+    // would otherwise describe the old spot and visibly catch up one measure
+    // later. Folding the delta in here makes a single measure produce the final
+    // state: one visible update instead of a chain of them.
+    var anchored = anchor ? shiftRect(rect, anchor.delta) : rect;
+    setFootprintOverride(traced.points && anchor ? traced.points.map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        x = _ref2[0],
+        z = _ref2[1];
+      return [x + anchor.delta.dx, z + anchor.delta.dz];
+    }) : traced.points);
+    if (!footprintMarkedRef.current && useRTVStore.getState().deckCutoutFootprintOverride !== null) {
+      footprintMarkedRef.current = true;
+      bootPhase('deck: first footprint published', {
+        measures: measureCountRef.current
+      });
+    }
+    if (waterActive) {
+      setWaterOverride(deriveWaterVolume({
+        rect: anchored,
+        waterSync: deform.waterSync,
+        floorWorld: measured.floorWorld,
+        articleWorldBottomY: measured.worldBottomY,
+        waterlineY: useRTVStore.getState().resolvedEnvironment.water.volume.center[1]
+      }));
+    }
+    finishMeasure();
+  });
+  return null;
+}
+
+/*
+ * Local UV sampling — continues a mesh's texture mapping onto generated
+ * geometry that sits BESIDE it (e.g. a collar filling a floor's cutout).
+ *
+ * A single global affine mapping fitted over the whole surface only matches
+ * where the surface's unwrap really is one plane at one density. It fails for
+ * per-board UV islands, for surfaces whose density varies (a warped slab whose
+ * pattern anchoring is imperfect), and for neighbours whose unwraps differ.
+ * Sampling the NEAREST triangle's own mapping and extrapolating it sidesteps
+ * all of that: the generated surface continues exactly what its neighbour
+ * shows, locally.
+ *
+ * Deliberately three.js-free: a flat triangle soup in, UV out.
+ */
+
+/** Floats per triangle in the soup: (x, z, u, v) per vertex. */
+var UV_TRIANGLE_STRIDE = 12;
+var EPS = 1e-12;
+
+/** One affine UV mapping over XZ: `u = ux·x + uz·z + u0`, likewise for v. */
+
+/** Solve a 3x3 system by Cramer's rule; null when singular. */
+function solve3(m, b) {
+  var det = m[0] * (m[4] * m[8] - m[5] * m[7]) - m[1] * (m[3] * m[8] - m[5] * m[6]) + m[2] * (m[3] * m[7] - m[4] * m[6]);
+  if (Math.abs(det) < EPS) return null;
+  var d = function d(c0, c1, c2) {
+    return c0 * (m[4] * m[8] - m[5] * m[7]) - m[1] * (c1 * m[8] - m[5] * c2) + m[2] * (c1 * m[7] - m[4] * c2);
+  };
+  var x = d(b[0], b[1], b[2]) / det;
+  var y = (m[0] * (b[1] * m[8] - m[5] * b[2]) - b[0] * (m[3] * m[8] - m[5] * m[6]) + m[2] * (m[3] * b[2] - b[1] * m[6])) / det;
+  var z = (m[0] * (m[4] * b[2] - b[1] * m[7]) - m[1] * (m[3] * b[2] - b[1] * m[6]) + b[0] * (m[3] * m[7] - m[4] * m[6])) / det;
+  return [x, y, z];
+}
+
+/**
+ * Least-squares fit of ONE affine mapping over every vertex in the soup.
+ *
+ * Where it fits (a planar unwrap at uniform density), it beats
+ * {@link sampleNearestTriangleUV} on generated geometry: the local sampler
+ * decides per vertex, so two ends of a generated triangle can land on different
+ * source triangles and the interpolation between them blends two mappings —
+ * a visible shear, worst on long thin triangles like those a curved outline
+ * produces. One mapping for every vertex cannot shear. Check
+ * {@link AffineUV.residualMetres} before trusting it.
+ */
+function fitAffineUV(triangles, triangleCount) {
+  var samples = triangleCount * 3;
+  if (samples < 3) return null;
+  // Normal equations for the design matrix [x, z, 1], shared by u and v.
+  var sxx = 0;
+  var sxz = 0;
+  var sx = 0;
+  var szz = 0;
+  var sz = 0;
+  var sxu = 0;
+  var szu = 0;
+  var su = 0;
+  var sxv = 0;
+  var szv = 0;
+  var sv = 0;
+  for (var i = 0; i < samples; i++) {
+    var o = i * 4;
+    var x = triangles[o];
+    var z = triangles[o + 1];
+    var u = triangles[o + 2];
+    var v = triangles[o + 3];
+    sxx += x * x;
+    sxz += x * z;
+    sx += x;
+    szz += z * z;
+    sz += z;
+    sxu += x * u;
+    szu += z * u;
+    su += u;
+    sxv += x * v;
+    szv += z * v;
+    sv += v;
+  }
+  var m = [sxx, sxz, sx, sxz, szz, sz, sx, sz, samples];
+  var uSol = solve3(m, [sxu, szu, su]);
+  var vSol = solve3(m, [sxv, szv, sv]);
+  if (!uSol || !vSol) return null;
+  var errSq = 0;
+  for (var _i = 0; _i < samples; _i++) {
+    var _o = _i * 4;
+    var _x = triangles[_o];
+    var _z = triangles[_o + 1];
+    var du = uSol[0] * _x + uSol[1] * _z + uSol[2] - triangles[_o + 2];
+    var dv = vSol[0] * _x + vSol[1] * _z + vSol[2] - triangles[_o + 3];
+    errSq += du * du + dv * dv;
+  }
+  // UV error → metres, via the mapping's own uv-per-metre.
+  var perMetre = (Math.hypot(uSol[0], uSol[1]) + Math.hypot(vSol[0], vSol[1])) / 2;
+  var rms = Math.sqrt(errSq / samples);
+  return {
+    ux: uSol[0],
+    uz: uSol[1],
+    u0: uSol[2],
+    vx: vSol[0],
+    vz: vSol[1],
+    v0: vSol[2],
+    residualMetres: perMetre > EPS ? rms / perMetre : Infinity
+  };
+}
+
+/** Squared distance from (px, pz) to the segment (ax, az)–(bx, bz). */
+function segmentDistanceSq(px, pz, ax, az, bx, bz) {
+  var dx = bx - ax;
+  var dz = bz - az;
+  var lengthSq = dx * dx + dz * dz;
+  var t = lengthSq < EPS ? 0 : Math.max(0, Math.min(1, ((px - ax) * dx + (pz - az) * dz) / lengthSq));
+  var cx = ax + t * dx - px;
+  var cz = az + t * dz - pz;
+  return cx * cx + cz * cz;
+}
+
+/**
+ * Squared distance from a point to a triangle in the XZ plane — 0 inside it,
+ * else the nearest edge distance.
+ */
+function triangleDistanceSq(px, pz, x0, z0, x1, z1, x2, z2) {
+  // Zero area makes all three edge signs zero, so the inside test below would answer "contains"
+  // for every point on the plane and this triangle would win every query. It can stand in for
+  // nothing — keep it out of the running.
+  if ((x1 - x0) * (z2 - z0) - (x2 - x0) * (z1 - z0) === 0) return Infinity;
+  // Inside test via consistent edge signs (winding-agnostic).
+  var d0 = (x1 - x0) * (pz - z0) - (z1 - z0) * (px - x0);
+  var d1 = (x2 - x1) * (pz - z1) - (z2 - z1) * (px - x1);
+  var d2 = (x0 - x2) * (pz - z2) - (z0 - z2) * (px - x2);
+  var allNonNeg = d0 >= 0 && d1 >= 0 && d2 >= 0;
+  var allNonPos = d0 <= 0 && d1 <= 0 && d2 <= 0;
+  if (allNonNeg || allNonPos) return 0;
+  return Math.min(segmentDistanceSq(px, pz, x0, z0, x1, z1), segmentDistanceSq(px, pz, x1, z1, x2, z2), segmentDistanceSq(px, pz, x2, z2, x0, z0));
+}
+
+/** Nearest triangle by linear scan: minimum distance, ties to the lowest index. */
+function nearestTriangleLinear(triangles, triangleCount, x, z) {
+  var bestDistance = Infinity;
+  var best = -1;
+  for (var t = 0; t < triangleCount; t++) {
+    var o = t * UV_TRIANGLE_STRIDE;
+    var distance = triangleDistanceSq(x, z, triangles[o], triangles[o + 1], triangles[o + 4], triangles[o + 5], triangles[o + 8], triangles[o + 9]);
+    if (distance < bestDistance) {
+      // A containing triangle (distance 0) is as good as it gets.
+      bestDistance = distance;
+      best = t;
+      if (distance === 0) break;
+    }
+  }
+  return best;
+}
+
+/** Below this the scan is already shorter than the ring walk that would replace it. */
+var MIN_INDEXED_TRIANGLES = 64;
+/** Cap on the grid's columns and rows — bounds memory when the deck is a long thin strip. */
+var MAX_GRID_DIM = 256;
+/** A triangle covering more cells than this is scanned on every query instead of registered in all of them. */
+var MAX_TRIANGLE_CELLS = 64;
+/** Give up on the index once this share of the soup would be scanned on every query anyway. */
+var MAX_EXTRA_SHARE = 0.25;
+/**
+ * Relative slack on the ring-termination bound. The bound — nothing unvisited is
+ * nearer than the gap to the visited block — holds exactly in real arithmetic;
+ * the slack keeps it true in floating point, so the walk can never stop one
+ * rounding error before the triangle a linear scan would have found.
+ */
+var RING_SLACK = 1e-9;
+/** A query this many cells outside the grid is scanned linearly rather than walked to. */
+var MAX_QUERY_CELL_OFFSET = 1e7;
+
+/**
+ * Uniform XZ grid over a triangle soup, so a nearest-triangle query touches a
+ * handful of cells instead of every triangle. Build it once per surface with
+ * {@link buildTriangleGridIndex} and pass it to {@link sampleNearestTriangleUV},
+ * which then returns exactly what the linear scan returns — same triangle, same
+ * tie-break, same UV.
+ */
+
+function isFiniteXZ(x0, z0, x1, z1, x2, z2) {
+  return Number.isFinite(x0) && Number.isFinite(z0) && Number.isFinite(x1) && Number.isFinite(z1) && Number.isFinite(x2) && Number.isFinite(z2);
+}
+
+/** Column/row count for one axis, clamped to at least one cell and at most {@link MAX_GRID_DIM}. */
+function gridDim(extent, cellSize) {
+  return Math.min(MAX_GRID_DIM, Math.max(1, Math.ceil(extent / cellSize)));
+}
+
+/** Cell containing `value` on one axis, clamped into the grid (only the far edge needs the clamp). */
+function cellOf(value, min, cellSize, count) {
+  var i = Math.floor((value - min) / cellSize);
+  if (i < 0) return 0;
+  return i >= count ? count - 1 : i;
+}
+
+/**
+ * Uniform grid over the soup's XZ bounds, each triangle registered in every cell
+ * its bounding box overlaps. Build it once per surface — it depends on the soup
+ * alone — and reuse it for every query against that soup.
+ *
+ * Cell size is the larger of the mean triangle extent and the size that puts
+ * about one triangle in a cell: smaller than the triangles themselves only
+ * multiplies registrations without narrowing a query, larger leaves too many
+ * triangles per cell to skip.
+ *
+ * Returns null when an index would not pay for itself or could not be trusted —
+ * too few triangles, a soup that is one point, or too much of it non-finite. The
+ * caller then scans linearly, which is what the index reproduces anyway.
+ */
+function buildTriangleGridIndex(triangles, triangleCount) {
+  if (triangleCount < MIN_INDEXED_TRIANGLES) return null;
+  var minX = Infinity;
+  var maxX = -Infinity;
+  var minZ = Infinity;
+  var maxZ = -Infinity;
+  var extentSum = 0;
+  var finite = 0;
+  for (var t = 0; t < triangleCount; t++) {
+    var o = t * UV_TRIANGLE_STRIDE;
+    var x0 = triangles[o];
+    var z0 = triangles[o + 1];
+    var x1 = triangles[o + 4];
+    var z1 = triangles[o + 5];
+    var x2 = triangles[o + 8];
+    var z2 = triangles[o + 9];
+    if (!isFiniteXZ(x0, z0, x1, z1, x2, z2)) continue;
+    var tMinX = Math.min(x0, x1, x2);
+    var tMaxX = Math.max(x0, x1, x2);
+    var tMinZ = Math.min(z0, z1, z2);
+    var tMaxZ = Math.max(z0, z1, z2);
+    if (tMinX < minX) minX = tMinX;
+    if (tMaxX > maxX) maxX = tMaxX;
+    if (tMinZ < minZ) minZ = tMinZ;
+    if (tMaxZ > maxZ) maxZ = tMaxZ;
+    extentSum += Math.max(tMaxX - tMinX, tMaxZ - tMinZ);
+    finite += 1;
+  }
+  if (finite < MIN_INDEXED_TRIANGLES || triangleCount - finite > triangleCount * MAX_EXTRA_SHARE) return null;
+  var width = maxX - minX;
+  var depth = maxZ - minZ;
+  var span = Math.max(width, depth);
+  // Every triangle on one spot — no partition can separate them.
+  if (!(span > 0)) return null;
+  var perCell = width * depth / finite;
+  var cellSize = Math.max(extentSum / finite, perCell > 0 ? Math.sqrt(perCell) : 0, span / MAX_GRID_DIM);
+  var cols = gridDim(width, cellSize);
+  var rows = gridDim(depth, cellSize);
+  // An extreme aspect ratio can still ask for far more cells than triangles.
+  var maxCells = Math.max(1024, finite * 4);
+  if (cols * rows > maxCells) {
+    cellSize *= Math.sqrt(cols * rows / maxCells);
+    cols = gridDim(width, cellSize);
+    rows = gridDim(depth, cellSize);
+  }
+  var cellCount = cols * rows;
+  var spans = new Int32Array(triangleCount * 4);
+  // One slot ahead, so the prefix sum below turns counts into CSR offsets in place.
+  var cellStart = new Int32Array(cellCount + 1);
+  var extras = [];
+  for (var _t = 0; _t < triangleCount; _t++) {
+    var _o2 = _t * UV_TRIANGLE_STRIDE;
+    var _x2 = triangles[_o2];
+    var _z2 = triangles[_o2 + 1];
+    var _x3 = triangles[_o2 + 4];
+    var _z3 = triangles[_o2 + 5];
+    var _x4 = triangles[_o2 + 8];
+    var _z4 = triangles[_o2 + 9];
+    // Zero area makes every edge sign zero, so the inside test answers "distance
+    // 0" for any point whatsoever — position tells nothing about such a triangle.
+    if (!isFiniteXZ(_x2, _z2, _x3, _z3, _x4, _z4) || (_x3 - _x2) * (_z4 - _z2) - (_x4 - _x2) * (_z3 - _z2) === 0) {
+      spans[_t * 4] = -1;
+      extras.push(_t);
+      continue;
+    }
+    var i0 = cellOf(Math.min(_x2, _x3, _x4), minX, cellSize, cols);
+    var i1 = cellOf(Math.max(_x2, _x3, _x4), minX, cellSize, cols);
+    var j0 = cellOf(Math.min(_z2, _z3, _z4), minZ, cellSize, rows);
+    var j1 = cellOf(Math.max(_z2, _z3, _z4), minZ, cellSize, rows);
+    if ((i1 - i0 + 1) * (j1 - j0 + 1) > MAX_TRIANGLE_CELLS) {
+      spans[_t * 4] = -1;
+      extras.push(_t);
+      continue;
+    }
+    spans[_t * 4] = i0;
+    spans[_t * 4 + 1] = i1;
+    spans[_t * 4 + 2] = j0;
+    spans[_t * 4 + 3] = j1;
+    for (var j = j0; j <= j1; j++) {
+      for (var i = i0; i <= i1; i++) cellStart[j * cols + i + 1] += 1;
+    }
+  }
+  if (extras.length > triangleCount * MAX_EXTRA_SHARE) return null;
+  for (var c = 0; c < cellCount; c++) cellStart[c + 1] += cellStart[c];
+  var cellItems = new Int32Array(cellStart[cellCount]);
+  var cursor = cellStart.slice(0, cellCount);
+  for (var _t2 = 0; _t2 < triangleCount; _t2++) {
+    var _i2 = spans[_t2 * 4];
+    if (_i2 < 0) continue;
+    var _i3 = spans[_t2 * 4 + 1];
+    var _j = spans[_t2 * 4 + 2];
+    var _j2 = spans[_t2 * 4 + 3];
+    for (var _j3 = _j; _j3 <= _j2; _j3++) {
+      for (var _i4 = _i2; _i4 <= _i3; _i4++) {
+        var _c = _j3 * cols + _i4;
+        cellItems[cursor[_c]] = _t2;
+        cursor[_c] += 1;
+      }
+    }
+  }
+  return {
+    triangleCount: triangleCount,
+    minX: minX,
+    minZ: minZ,
+    cellSize: cellSize,
+    cols: cols,
+    rows: rows,
+    cellStart: cellStart,
+    cellItems: cellItems,
+    extras: Int32Array.from(extras)
+  };
+}
+
+/**
+ * Nearest triangle via {@link TriangleGridIndex}: the point's own cell first,
+ * then ring by ring outward.
+ *
+ * A ring may only end the walk once the best distance found is provably below
+ * the gap between the point and the block of cells already visited — every
+ * unvisited triangle lies outside that block, so nothing out there can be
+ * nearer. Ties go to the lowest triangle index whatever order the cells are
+ * walked in, which is what a linear scan's `distance < bestDistance` produces.
+ */
+function nearestTriangleIndexed(triangles, x, z, index) {
+  var minX = index.minX,
+    minZ = index.minZ,
+    cellSize = index.cellSize,
+    cols = index.cols,
+    rows = index.rows,
+    cellStart = index.cellStart,
+    cellItems = index.cellItems,
+    extras = index.extras;
+  var cx = Math.floor((x - minX) / cellSize);
+  var cz = Math.floor((z - minZ) / cellSize);
+  // A non-finite or absurdly distant query has no cell to start from.
+  if (!Number.isFinite(cx) || !Number.isFinite(cz) || Math.abs(cx) > MAX_QUERY_CELL_OFFSET || Math.abs(cz) > MAX_QUERY_CELL_OFFSET) {
+    return nearestTriangleLinear(triangles, index.triangleCount, x, z);
+  }
+  var bestDistance = Infinity;
+  var best = -1;
+  var consider = function consider(t) {
+    var o = t * UV_TRIANGLE_STRIDE;
+    var distance = triangleDistanceSq(x, z, triangles[o], triangles[o + 1], triangles[o + 4], triangles[o + 5], triangles[o + 8], triangles[o + 9]);
+    // Lowest index wins a tie, so cell order cannot change the answer. NaN and
+    // Infinity fail both tests, exactly as `distance < bestDistance` alone does.
+    if (distance < bestDistance || distance === bestDistance && t < best) {
+      bestDistance = distance;
+      best = t;
+    }
+  };
+  var scanCell = function scanCell(cell) {
+    var end = cellStart[cell + 1];
+    for (var k = cellStart[cell]; k < end; k++) consider(cellItems[k]);
+  };
+  for (var k = 0; k < extras.length; k++) consider(extras[k]);
+
+  // Rings are centred on the point's cell even when that sits outside the grid,
+  // so the gap below grows with distance instead of stalling at a clamped edge.
+  var first = Math.max(0, -cx, cx - cols + 1, -cz, cz - rows + 1);
+  var last = Math.max(cx, cols - 1 - cx, cz, rows - 1 - cz);
+  for (var r = first; r <= last; r++) {
+    var i0 = cx - r;
+    var i1 = cx + r;
+    var j0 = cz - r;
+    var j1 = cz + r;
+    var ia = Math.max(0, i0);
+    var ib = Math.min(cols - 1, i1);
+    if (j0 >= 0 && j0 < rows) {
+      for (var i = ia; i <= ib; i++) scanCell(j0 * cols + i);
+    }
+    if (r > 0) {
+      if (j1 >= 0 && j1 < rows) {
+        for (var _i5 = ia; _i5 <= ib; _i5++) scanCell(j1 * cols + _i5);
+      }
+      var ja = Math.max(0, j0 + 1);
+      var jb = Math.min(rows - 1, j1 - 1);
+      if (i0 >= 0 && i0 < cols) {
+        for (var j = ja; j <= jb; j++) scanCell(j * cols + i0);
+      }
+      if (i1 >= 0 && i1 < cols) {
+        for (var _j4 = ja; _j4 <= jb; _j4++) scanCell(_j4 * cols + i1);
+      }
+    }
+    // Distance from the point to the edge of everything visited so far. Strictly
+    // below it, no unvisited triangle can beat OR tie the best found.
+    var gap = Math.min(x - (minX + i0 * cellSize), minX + (i1 + 1) * cellSize - x, z - (minZ + j0 * cellSize), minZ + (j1 + 1) * cellSize - z);
+    if (gap > 0 && bestDistance < gap * gap * (1 - RING_SLACK)) return best;
+  }
+  return best;
+}
+
+/**
+ * UV at (x, z) taken from the triangle nearest to it, evaluated through that
+ * triangle's own affine mapping. Points outside the triangle EXTRAPOLATE it,
+ * which is the point: the sampled position generally lies in the hole beside
+ * the surface, and extrapolating its neighbour's plank mapping continues the
+ * pattern across the seam.
+ *
+ * `triangles` holds {@link UV_TRIANGLE_STRIDE} floats per triangle:
+ * `x0, z0, u0, v0, x1, z1, u1, v1, x2, z2, u2, v2`. Returns null for an empty
+ * soup or when every triangle is degenerate in XZ.
+ *
+ * Pass the soup's {@link TriangleGridIndex} to skip the linear scan over every
+ * triangle; the result is identical either way.
+ */
+function sampleNearestTriangleUV(triangles, triangleCount, x, z, index) {
+  var best = index && index.triangleCount === triangleCount ? nearestTriangleIndexed(triangles, x, z, index) : nearestTriangleLinear(triangles, triangleCount, x, z);
+  if (best < 0) return null;
+  var o = best * UV_TRIANGLE_STRIDE;
+  var x0 = triangles[o];
+  var z0 = triangles[o + 1];
+  var x1 = triangles[o + 4];
+  var z1 = triangles[o + 5];
+  var x2 = triangles[o + 8];
+  var z2 = triangles[o + 9];
+  var det = (z1 - z2) * (x0 - x2) + (x2 - x1) * (z0 - z2);
+  if (Math.abs(det) < EPS) return null;
+  // Barycentric weights, deliberately unclamped so the mapping extrapolates.
+  var w0 = ((z1 - z2) * (x - x2) + (x2 - x1) * (z - z2)) / det;
+  var w1 = ((z2 - z0) * (x - x2) + (x0 - x2) * (z - z2)) / det;
+  var w2 = 1 - w0 - w1;
+  return [w0 * triangles[o + 2] + w1 * triangles[o + 6] + w2 * triangles[o + 10], w0 * triangles[o + 3] + w1 * triangles[o + 7] + w2 * triangles[o + 11]];
+}
+
+function _createForOfIteratorHelper$1(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$1(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$1(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$1(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$1(r, a) : void 0; } }
+function _arrayLikeToArray$1(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; }
+
+/** Minimum +Y normal for a deck triangle to count as top surface (excludes side faces). */
+var UP_NORMAL_MIN = 0.9;
+/**
+ * How far (m) a single fitted mapping may miss the deck's own triangles before
+ * it is rejected in favour of per-vertex sampling. Below this the deck's unwrap
+ * is one plane, and one mapping reproduces it without the shear per-vertex
+ * sampling introduces between neighbouring generated triangles.
+ */
+var UV_FIT_MAX_RESIDUAL = 0.005;
+var _toReference = new Matrix4();
+var _normalMatrix = new Matrix3();
+var _vertex = new Vector3();
+var _normal = new Vector3();
+
+/** What the collar needs to look like a continuation of the deck it fills. */
+
+/** Every mesh under `root` whose name contains one of `patterns`, in traversal order. */
+function meshesMatching(root, patterns) {
+  var found = [];
+  root.traverse(function (obj) {
+    var mesh = obj;
+    if (mesh.isMesh && patterns.some(function (p) {
+      return mesh.name.includes(p);
+    })) found.push(mesh);
+  });
+  return found;
+}
+
+/**
+ * Deck material for generated geometry. The unique bakes (AO / light map) are
+ * authored in the deck's own 0–1 UV space and would smear arbitrarily across a
+ * mesh that isn't part of that unwrap, so they are dropped; the repeating
+ * pattern maps are kept as they are.
+ */
+function cloneDeckMaterial(source) {
+  var clone = source.clone();
+  if (clone instanceof MeshStandardMaterial) {
+    clone.aoMap = null;
+    clone.lightMap = null;
+  }
+  clone.needsUpdate = true;
+  return clone;
+}
+
+/**
+ * The UV attribute the deck's VISIBLE pattern reads. Read from the material
+ * rather than assumed, because copying the wrong channel of a multi-unwrap
+ * asset yields a pattern that is subtly the wrong size.
+ */
+function patternAttributeName(material) {
+  var single = Array.isArray(material) ? material[0] : material;
+  if (single instanceof MeshStandardMaterial && single.map) return single.map.channel === 0 ? 'uv' : "uv".concat(single.map.channel);
+  return 'uv';
+}
+
+/**
+ * Collect the top-surface triangles of every matched deck mesh as a flat
+ * (x, z, u, v)-per-vertex soup in `reference`'s local space, reading the UV
+ * attribute the deck's pattern actually samples.
+ *
+ * No proximity filter: `nodeMatch` names the deck to continue, so everything it
+ * names is the sample set. Filtering by distance to the cutout drops slabs whose
+ * TRIANGLE CENTROIDS fall outside the radius — which silently discards a deck
+ * modelled as a few large quads and leaves the collar with no material at all.
+ */
+function collectDeckTriangles(meshes, reference, attributeName) {
+  var referenceInverse = _toReference.copy(reference.matrixWorld).invert().clone();
+  var out = [];
+  var extent = {
+    minX: Infinity,
+    maxX: -Infinity,
+    minZ: Infinity,
+    maxZ: -Infinity
+  };
+  var _iterator = _createForOfIteratorHelper$1(meshes),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _geometry$getAttribut;
+      var mesh = _step.value;
+      var geometry = mesh.geometry;
+      var position = geometry.getAttribute('position');
+      var uv = (_geometry$getAttribut = geometry.getAttribute(attributeName)) !== null && _geometry$getAttribut !== void 0 ? _geometry$getAttribut : geometry.getAttribute('uv');
+      if (!position || !uv) continue;
+      var normal = geometry.getAttribute('normal');
+
+      // Mesh-local → reference-local (identity for parts sharing the frame, correct otherwise).
+      _toReference.multiplyMatrices(referenceInverse, mesh.matrixWorld);
+      var local = new Float32Array(position.count * 3);
+      for (var i = 0; i < position.count; i++) {
+        _vertex.set(position.getX(i), position.getY(i), position.getZ(i)).applyMatrix4(_toReference);
+        local[i * 3] = _vertex.x;
+        local[i * 3 + 1] = _vertex.y;
+        local[i * 3 + 2] = _vertex.z;
+        if (_vertex.x < extent.minX) extent.minX = _vertex.x;
+        if (_vertex.x > extent.maxX) extent.maxX = _vertex.x;
+        if (_vertex.z < extent.minZ) extent.minZ = _vertex.z;
+        if (_vertex.z > extent.maxZ) extent.maxZ = _vertex.z;
+      }
+      // Normals need the rotation part of the SAME transform the positions took, or a deck part
+      // rotated relative to `reference` is classified against its own axes and its top faces drop out.
+      var localNormalY = new Float32Array(normal ? normal.count : 0);
+      if (normal) {
+        _normalMatrix.getNormalMatrix(_toReference);
+        for (var _i = 0; _i < normal.count; _i++) {
+          _normal.set(normal.getX(_i), normal.getY(_i), normal.getZ(_i)).applyMatrix3(_normalMatrix).normalize();
+          localNormalY[_i] = _normal.y;
+        }
+      }
+
+      // Height fallback when the mesh ships no normals: the top face is the upper half.
+      var yMid = -Infinity;
+      if (!normal) {
+        var yMin = Infinity;
+        var yMax = -Infinity;
+        for (var _i2 = 0; _i2 < position.count; _i2++) {
+          var y = local[_i2 * 3 + 1];
+          if (y < yMin) yMin = y;
+          if (y > yMax) yMax = y;
+        }
+        yMid = (yMin + yMax) / 2;
+      }
+      var index = geometry.index;
+      var triCount = index ? Math.floor(index.count / 3) : Math.floor(position.count / 3);
+      for (var t = 0; t < triCount; 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 isTop = normal ? localNormalY[a] >= UP_NORMAL_MIN && localNormalY[b] >= UP_NORMAL_MIN && localNormalY[c] >= UP_NORMAL_MIN : local[a * 3 + 1] > yMid && local[b * 3 + 1] > yMid && local[c * 3 + 1] > yMid;
+        if (!isTop) continue;
+        for (var _i3 = 0, _arr = [a, b, c]; _i3 < _arr.length; _i3++) {
+          var vi = _arr[_i3];
+          out.push(local[vi * 3], local[vi * 3 + 2], uv.getX(vi), uv.getY(vi));
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var triangleCount = out.length / UV_TRIANGLE_STRIDE;
+  if (triangleCount < 1) return null;
+  return {
+    triangles: new Float32Array(out),
+    triangleCount: triangleCount,
+    extent: extent
+  };
+}
+
+/**
+ * Sample the deck the collar has to continue: the first name-matched mesh is the
+ * reference frame, all matched meshes feed the UV sample.
+ */
+function sampleDeckSurface(scene, patterns) {
+  var _meshes$, _bounds$max$y, _collected$triangles, _collected$triangleCo, _collected$extent;
+  var meshes = meshesMatching(scene, patterns);
+  var reference = (_meshes$ = meshes[0]) !== null && _meshes$ !== void 0 ? _meshes$ : null;
+  if (!reference) return {
+    reference: null,
+    surface: null
+  };
+  var geometry = reference.geometry;
+  if (!geometry.boundingBox) geometry.computeBoundingBox();
+  var attributeName = patternAttributeName(reference.material);
+  var collected = collectDeckTriangles(meshes, reference, attributeName);
+  var bounds = geometry.boundingBox;
+  return {
+    reference: reference,
+    surface: {
+      meshName: reference.name,
+      topY: (_bounds$max$y = bounds === null || bounds === void 0 ? void 0 : bounds.max.y) !== null && _bounds$max$y !== void 0 ? _bounds$max$y : 0,
+      slabThickness: bounds ? bounds.max.y - bounds.min.y : 0,
+      material: collected ? cloneDeckMaterial(Array.isArray(reference.material) ? reference.material[0] : reference.material) : null,
+      triangles: (_collected$triangles = collected === null || collected === void 0 ? void 0 : collected.triangles) !== null && _collected$triangles !== void 0 ? _collected$triangles : null,
+      triangleCount: (_collected$triangleCo = collected === null || collected === void 0 ? void 0 : collected.triangleCount) !== null && _collected$triangleCo !== void 0 ? _collected$triangleCo : 0,
+      triangleIndex: collected ? buildTriangleGridIndex(collected.triangles, collected.triangleCount) : null,
+      attributeName: attributeName,
+      uvFit: collected ? fitAffineUV(collected.triangles, collected.triangleCount) : null,
+      extent: (_collected$extent = collected === null || collected === void 0 ? void 0 : collected.extent) !== null && _collected$extent !== void 0 ? _collected$extent : null
+    }
+  };
+}
+
+/** Identity of a sampled surface — a fresh surface object rebuilds the collar geometry, so only an actual change may be applied. */
+function deckSurfaceKey(surface) {
+  return surface ? "".concat(surface.meshName, "|").concat(surface.topY.toFixed(4), "|").concat(surface.attributeName, "|").concat(surface.triangleCount) : 'none';
+}
+
+/** One-shot diagnostic lines for a newly acquired deck surface. */
+function describeDeckSurface(surface, hasOwnMaterial) {
+  var lines = [];
+  var e = surface.extent;
+  if (e) {
+    lines.push("[DeckCutoutCollar] matched deck meshes span X [".concat(e.minX.toFixed(3), ", ").concat(e.maxX.toFixed(3), "] Z [").concat(e.minZ.toFixed(3), ", ").concat(e.maxZ.toFixed(3), "]"));
+  }
+  lines.push("[DeckCutoutCollar] UV source: ".concat(hasOwnMaterial ? 'own material (declared world-planar tiling)' : surface.uvFit === null ? 'no fit possible (per-vertex sampling)' : surface.uvFit.residualMetres <= UV_FIT_MAX_RESIDUAL ? "one fitted mapping, residual ".concat((surface.uvFit.residualMetres * 1000).toFixed(2), " mm") : "per-vertex sampling \u2014 fit residual ".concat((surface.uvFit.residualMetres * 1000).toFixed(1), " mm exceeds ").concat(UV_FIT_MAX_RESIDUAL * 1000, " mm, deck unwrap is not one plane")));
+  return lines;
+}
+
+/** How far (m) the outline is held inside the ring's outer boundary. */
+var CLAMP_INSET = 1e-3;
+/**
+ * The collar ring, built in the floor meshes' shared local space (outline and
+ * hole rect are floor-local): a skirt is extruded downward along the inner edge
+ * so nothing shows through under the deck, the top sits `collar.recess` below
+ * the deck surface and the outer edge tucks `collar.overlap` under the deck —
+ * the last two kill z-fighting with the slab.
+ */
+function buildCollarGeometry(_ref) {
+  var footprint = _ref.footprint,
+    hole = _ref.hole,
+    collar = _ref.collar,
+    deck = _ref.deck,
+    ownMaterial = _ref.ownMaterial;
+  // Shape plane (x, y) becomes floor-local (x, z) after rotateX(π/2); the
+  // extrusion depth runs toward -Y (downward skirt). Winding of outer ring
+  // and hole is normalized by ExtrudeGeometry itself.
+  var shape = new Shape();
+  var minX = hole.centerX - hole.halfExtentX - collar.overlap;
+  var maxX = hole.centerX + hole.halfExtentX + collar.overlap;
+  var minZ = hole.centerZ - hole.halfExtentZ - collar.overlap;
+  var maxZ = hole.centerZ + hole.halfExtentZ + collar.overlap;
+  shape.moveTo(minX, minZ);
+  shape.lineTo(maxX, minZ);
+  shape.lineTo(maxX, maxZ);
+  shape.lineTo(minX, maxZ);
+  shape.closePath();
+
+  // The hole path MUST stay strictly inside the ring's outer boundary: a
+  // crossing path makes the triangulator emit garbage (a wedge of floor over
+  // the pool) rather than fail. Clamping degrades to a collar pinched flat
+  // against its outer edge, which is recoverable and obvious.
+  var clamped = 0;
+  var innerMinX = Infinity;
+  var innerMaxX = -Infinity;
+  var innerMinZ = Infinity;
+  var innerMaxZ = -Infinity;
+  var inner = new Path();
+  for (var i = 0; i < footprint.length; i++) {
+    var x = Math.min(maxX - CLAMP_INSET, Math.max(minX + CLAMP_INSET, footprint[i][0]));
+    var z = Math.min(maxZ - CLAMP_INSET, Math.max(minZ + CLAMP_INSET, footprint[i][1]));
+    if (x !== footprint[i][0] || z !== footprint[i][1]) clamped += 1;
+    if (x < innerMinX) innerMinX = x;
+    if (x > innerMaxX) innerMaxX = x;
+    if (z < innerMinZ) innerMinZ = z;
+    if (z > innerMaxZ) innerMaxZ = z;
+    if (i === 0) inner.moveTo(x, z);else inner.lineTo(x, z);
+  }
+  inner.closePath();
+  shape.holes.push(inner);
+  // What the ring actually came out as. `coverage` is the share of the hole
+  // the OPENING keeps: near 1 the collar is a hairline, near 0 it is a solid
+  // slab over the article (no visible cutout at all).
+  var coverage = (innerMaxX - innerMinX) * (innerMaxZ - innerMinZ) / ((maxX - minX) * (maxZ - minZ));
+  var diagnostic = "[DeckCutoutCollar] ring built: hole X [".concat(minX.toFixed(2), ", ").concat(maxX.toFixed(2), "] Z [").concat(minZ.toFixed(2), ", ").concat(maxZ.toFixed(2), "] | opening X [").concat(innerMinX.toFixed(2), ", ").concat(innerMaxX.toFixed(2), "] Z [").concat(innerMinZ.toFixed(2), ", ").concat(innerMaxZ.toFixed(2), "] = ").concat((coverage * 100).toFixed(0), "% of it | ").concat(clamped, "/").concat(footprint.length, " outline pts clamped").concat(clamped > 0 ? ' — THE ARTICLE IS LARGER THAN ITS HOLE' : '');
+
+  // Skirt as thin as the deck itself unless configured otherwise; a floor
+  // with no measurable thickness still needs a non-degenerate extrusion.
+  var skirtDepth = collar.skirtDepth > 0 ? collar.skirtDepth : Math.max(deck.slabThickness, 0.01);
+  var geo = new ExtrudeGeometry(shape, {
+    depth: skirtDepth,
+    bevelEnabled: false
+  });
+  geo.rotateX(Math.PI / 2);
+  geo.translate(0, deck.topY - collar.recess, 0);
+  if (ownMaterial) {
+    // Own material ⇒ the tiling is DECLARED, not inherited: a world-planar
+    // projection at `textureScale` metres per tile. Nothing to fit or sample,
+    // and swapping the maps for a different wood or stone needs no other change.
+    var textureScale = ownMaterial.textureScale,
+      rotationDeg = ownMaterial.rotationDeg,
+      offsetX = ownMaterial.offsetX,
+      offsetZ = ownMaterial.offsetZ;
+    var scale = textureScale > 0 ? textureScale : 1;
+    var angle = rotationDeg * Math.PI / 180;
+    var cos = Math.cos(angle);
+    var sin = Math.sin(angle);
+    var position = geo.getAttribute('position');
+    var uvs = new Float32Array(position.count * 2);
+    for (var _i = 0; _i < position.count; _i++) {
+      var _x = position.getX(_i) + offsetX;
+      var _z = position.getZ(_i) + offsetZ;
+      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));
+  } 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
+    // lets the two ends of a generated triangle land on different deck
+    // triangles and blend their mappings across it. Per-vertex sampling stays
+    // for the unwraps a single mapping cannot describe (per-board islands,
+    // varying density), where matching locally is the only faithful option.
+    //
+    // Written to BOTH channels so it lands wherever the material's maps look;
+    // the skirt's vertical faces inherit the same planar projection, which
+    // reads as shadow in a recessed band.
+    var fit = deck.uvFit && deck.uvFit.residualMetres <= UV_FIT_MAX_RESIDUAL ? deck.uvFit : null;
+    var _position = geo.getAttribute('position');
+    var _uvs = new Float32Array(_position.count * 2);
+    for (var _i2 = 0; _i2 < _position.count; _i2++) {
+      var _x2 = _position.getX(_i2);
+      var _z2 = _position.getZ(_i2);
+      if (fit) {
+        _uvs[_i2 * 2] = fit.ux * _x2 + fit.uz * _z2 + fit.u0;
+        _uvs[_i2 * 2 + 1] = fit.vx * _x2 + fit.vz * _z2 + fit.v0;
+        continue;
+      }
+      var sampled = sampleNearestTriangleUV(deck.triangles, deck.triangleCount, _x2, _z2, deck.triangleIndex);
+      if (!sampled) continue;
+      _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));
+  }
+  return {
+    geometry: geo,
+    diagnostic: diagnostic
+  };
+}
+
+var LOG$1 = getLogger('RealTimeViewer', 'DeckCutoutCollar');
+
+/** Shared loader — the collar's own maps are plain URLs, like `MaterialManager`'s. */
+var textureLoader = new TextureLoader();
+/**
+ * Load the collar's declared maps imperatively rather than through
+ * `useTexture`/`useLoader`: those suspend, and the collar mounts outside a
+ * Suspense boundary, so a slow texture would blank the whole scene group.
+ * Returns null until `mapUrl` resolves; the other maps are optional and simply
+ * aren't applied if they fail.
+ */
+function useCollarTextures(material) {
+  var mapUrl = material.mapUrl,
+    normalMapUrl = material.normalMapUrl,
+    roughnessMapUrl = material.roughnessMapUrl;
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    loaded = _useState2[0],
+    setLoaded = _useState2[1];
+  useEffect(function () {
+    if (mapUrl === '') {
+      setLoaded(null);
+      return;
+    }
+    var live = true;
+    var opened = [];
+    var load = function load(url) {
+      return url === '' ? Promise.resolve(null) : textureLoader.loadAsync(url).then(function (t) {
+        // A texture resolving after cleanup would never be reached by the
+        // cleanup's dispose loop — dispose it here instead of leaking it.
+        if (!live) {
+          t.dispose();
+          return null;
+        }
+        opened.push(t);
+        return t;
+      }, function () {
+        LOG$1.debug("[DeckCutoutCollar] collar texture failed to load: ".concat(url));
+        return null;
+      });
+    };
+    Promise.all([load(mapUrl), load(normalMapUrl), load(roughnessMapUrl)]).then(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 3),
+        map = _ref2[0],
+        normalMap = _ref2[1],
+        roughnessMap = _ref2[2];
+      if (!live || !map) return;
+      // Repeat wrapping is what makes the world-planar UVs tile at all; the
+      // colour map is the only one that carries colour (the others are data).
+      map.colorSpace = SRGBColorSpace;
+      for (var _i = 0, _arr = [map, normalMap, roughnessMap]; _i < _arr.length; _i++) {
+        var t = _arr[_i];
+        if (!t) continue;
+        t.wrapS = RepeatWrapping;
+        t.wrapT = RepeatWrapping;
+        t.needsUpdate = true;
+      }
+      setLoaded({
+        map: map,
+        normalMap: normalMap,
+        roughnessMap: roughnessMap
+      });
+    });
+    return function () {
+      live = false;
+      for (var _i2 = 0, _opened = opened; _i2 < _opened.length; _i2++) {
+        var t = _opened[_i2];
+        t.dispose();
+      }
+      setLoaded(null);
+    };
+  }, [mapUrl, normalMapUrl, roughnessMapUrl]);
+  return loaded;
+}
+
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(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(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(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(r, a) : void 0; } }
+function _arrayLikeToArray(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; }
+var LOG = getLogger('RealTimeViewer', 'DeckCutoutCollar');
+
+/**
+ * Page-lifetime latch for the collar hold — not the registry's `once`: StrictMode's simulated
+ * unmount runs the cleanup `end`, which would latch a once-id and kill the gate before the real
+ * boot. Flips only on a real completion (first collar geometry applied, or timeout).
+ */
+var collarGateSettled = false;
+
+/**
+ * Frames to wait after a decor bump before sampling. Every deck GLB writes its
+ * scene transform from its OWN `useFrame`, and this component's frame callback
+ * can run before theirs — sampling in the same frame would fold a just-mounted,
+ * still-untransformed part and the already-placed ones into one reference frame.
+ * One frame of slack means every mounted deck GLB has written its transform at
+ * least once before the sample reads their world matrices.
+ */
+var ACQUIRE_DELAY_FRAMES = 1;
+
+/**
+ * Generated coping collar for footprint-rule cutouts (`deckCutout.articleRules`):
+ * a flat ring filling the space between the deck's authored rectangular hole and
+ * the article's shaped outline. This is what makes the cutout follow the article
+ * — the deck GLB itself is never touched. Rendered only while
+ * `DeckCutoutArticleSync` publishes a footprint outline.
+ *
+ * It wears the DECK's material and continues the deck's own UV mapping (see
+ * {@link buildCollarGeometry}), unless the config declares own maps. The ring
+ * follows a name-matched floor mesh's world matrix every frame, so
+ * scene-transform edits need no rebuild.
+ */
+function DeckCutoutCollar() {
+  var _deck$material;
+  var scene = useThree(function (s) {
+    return s.scene;
+  });
+  var deckCutoutJson = useRTVStore(function (s) {
+    return JSON.stringify(s.resolvedEnvironment.scene.deckCutout);
+  });
+  var deform = useMemo(function () {
+    return JSON.parse(deckCutoutJson);
+  }, [deckCutoutJson]);
+  var footprint = useRTVStore(function (s) {
+    return s.deckCutoutFootprintOverride;
+  });
+  // Bumps once per mounted GLB — the deck arrives as several part GLBs, so this
+  // is the signal that there may be more meshes to sample than last time.
+  var decorVersion = useRTVStore(function (s) {
+    return s.decorVersion;
+  });
+  var ownTextures = useCollarTextures(deform.collar.material);
+  var meshRef = useRef(null);
+  var floorRef = useRef(null);
+  var surfaceKeyRef = useRef(null);
+  /** Frames left before the armed sample runs; negative means nothing is armed. */
+  var acquireDelayRef = useRef(-1);
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    deck = _useState2[0],
+    setDeck = _useState2[1];
+  var patterns = useMemo(function () {
+    return deform.nodeMatch.split(',').map(function (p) {
+      return p.trim();
+    }).filter(function (p) {
+      return p.length > 0;
+    });
+  }, [deform.nodeMatch]);
+
+  // Re-acquire the deck when the match config changes or the scene swaps.
+  useEffect(function () {
+    floorRef.current = null;
+    surfaceKeyRef.current = null;
+    setDeck(null);
+  }, [patterns]);
+  var collar = deform.collar;
+  // The area the collar owns, straight from the config. `nodeMatch` names the
+  // deck to CONTINUE, which is a different thing and may sit entirely outside
+  // this rect (see the preset).
+  var holeRect = deform.authoredHole;
+  var enabled = deform.enabled;
+  var active = enabled && footprint !== null && footprint.length >= 3;
+
+  // A configured cutout means a collar WILL appear — hold the reveal until its first GEOMETRY
+  // lands, otherwise it pops in about a second after the scene shows. The footprint needs the
+  // mounted article, so the initial window is generous and tightens once the footprint is in.
+  // Once-latched: later scene swaps rebuild behind the visible scene.
+  useEffect(function () {
+    if (!enabled || collarGateSettled) return;
+    useRTVStore.getState().beginSceneLoad(DECK_COLLAR_LOAD_ID, {
+      timeoutMs: 25000,
+      onTimeout: function onTimeout() {
+        return collarGateSettled = true;
+      }
+    });
+    return function () {
+      return useRTVStore.getState().endSceneLoad(DECK_COLLAR_LOAD_ID);
+    };
+  }, [enabled]);
+  useEffect(function () {
+    if (active && !collarGateSettled) {
+      useRTVStore.getState().beginSceneLoad(DECK_COLLAR_LOAD_ID, {
+        timeoutMs: 8000,
+        onTimeout: function onTimeout() {
+          return collarGateSettled = true;
+        }
+      });
+    }
+  }, [active]);
+  var acquireDeck = useCallback(function () {
+    var _sampleDeckSurface = sampleDeckSurface(scene, patterns),
+      reference = _sampleDeckSurface.reference,
+      surface = _sampleDeckSurface.surface;
+    floorRef.current = reference;
+
+    // A fresh surface object rebuilds the collar geometry, so only apply on an actual change.
+    var key = deckSurfaceKey(surface);
+    if (surfaceKeyRef.current === key) return;
+    surfaceKeyRef.current = key;
+    setDeck(surface);
+    if (!surface) return;
+    bootPhase('deck: surface sampled');
+    var _iterator = _createForOfIteratorHelper(describeDeckSurface(surface, ownTextures !== null)),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var line = _step.value;
+        LOG.debug(line);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }, [scene, patterns, ownTextures]);
+
+  // Arm the sample on every event that can change what is there to sample: the match config and
+  // every mounted deck GLB (the part GLBs land on different frames, and a sample taken from only
+  // the parts present so far would mis-map the rest of the ring). NOT the article: the sample
+  // reads the name-matched deck meshes only, so waiting for the footprint would serialize it
+  // behind the whole article load for nothing.
+  useEffect(function () {
+    if (!enabled) return;
+    acquireDelayRef.current = ACQUIRE_DELAY_FRAMES;
+  }, [enabled, decorVersion, acquireDeck]);
+
+  // Nothing named by `nodeMatch` is in the scene, so no collar can be built for the outline the
+  // article just published — the case where the hold above runs out instead of settling.
+  useEffect(function () {
+    if (!active || deck !== null) return;
+    LOG.debug("[DeckCutoutCollar] footprint active but NO floor mesh matches '".concat(deform.nodeMatch, "'"));
+  }, [active, deck, deform.nodeMatch]);
+  useFrame(function () {
+    if (!enabled) return;
+    if (acquireDelayRef.current >= 0) {
+      if (acquireDelayRef.current === 0) acquireDeck();
+      acquireDelayRef.current -= 1;
+    }
+    var floor = floorRef.current;
+    // The deck GLB was unmounted (URL cleared / swapped) — look again once; the replacement, if
+    // any, re-arms the effect above when it mounts.
+    if (floor && !floor.parent) acquireDeck();
+    var collarMesh = meshRef.current;
+    if (!floor || !collarMesh) return;
+    collarMesh.matrix.copy(floor.matrixWorld);
+    collarMesh.matrixWorldNeedsUpdate = true;
+  });
+  var geometry = useMemo(function () {
+    if (!enabled || deck === null || footprint === null || footprint.length < 3) return null;
+    var built = buildCollarGeometry({
+      footprint: footprint,
+      hole: holeRect,
+      collar: collar,
+      deck: deck,
+      ownMaterial: ownTextures ? collar.material : null
+    });
+    LOG.debug(built.diagnostic);
+    return built.geometry;
+  }, [enabled, footprint, holeRect.centerX, holeRect.centerZ, holeRect.halfExtentX, holeRect.halfExtentZ, collar, deck, ownTextures]);
+
+  // Settle the hold on the first BUILT collar, not on the deck sample: the sample lands as soon as
+  // the deck GLBs mount, long before the article publishes the outline the geometry needs. Ending
+  // the hold there would reveal the scene and let the collar appear afterwards — the exact pop the
+  // hold exists to prevent. This effect runs after the commit that put the collar mesh in the
+  // scene, so the reveal can only follow it.
+  useEffect(function () {
+    if (!geometry || collarGateSettled) return;
+    collarGateSettled = true;
+    bootPhase('deck: first collar geometry');
+    useRTVStore.getState().endSceneLoad(DECK_COLLAR_LOAD_ID);
+  }, [geometry]);
+  useEffect(function () {
+    return function () {
+      return geometry === null || geometry === void 0 ? void 0 : geometry.dispose();
+    };
+  }, [geometry]);
+
+  // The clone is ours to dispose; its textures are shared with the deck
+  // material and must survive (`Material.dispose` leaves them alone).
+  var deckMaterial = (_deck$material = deck === null || deck === void 0 ? void 0 : deck.material) !== null && _deck$material !== void 0 ? _deck$material : null;
+  useEffect(function () {
+    return function () {
+      return deckMaterial === null || deckMaterial === void 0 ? void 0 : deckMaterial.dispose();
+    };
+  }, [deckMaterial]);
+  if (!geometry) return null;
+  // The collar stands in for deck, so it casts like deck does (the deck edge
+  // over the cliff), whether it fills a hole or spans a whole area.
+  if (ownTextures) return /*#__PURE__*/jsx("mesh", {
+    ref: meshRef,
+    geometry: geometry,
+    matrixAutoUpdate: false,
+    receiveShadow: true,
+    castShadow: true,
+    children: /*#__PURE__*/jsx("meshStandardMaterial", {
+      map: ownTextures.map,
+      normalMap: ownTextures.normalMap,
+      roughnessMap: ownTextures.roughnessMap,
+      color: collar.color,
+      roughness: collar.roughness,
+      metalness: 0
+    })
+  });
+  if (deckMaterial) return /*#__PURE__*/jsx("mesh", {
+    ref: meshRef,
+    geometry: geometry,
+    material: deckMaterial,
+    matrixAutoUpdate: false,
+    receiveShadow: true,
+    castShadow: true
+  });
+  return /*#__PURE__*/jsx("mesh", {
+    ref: meshRef,
+    geometry: geometry,
+    matrixAutoUpdate: false,
+    receiveShadow: true,
+    castShadow: true,
+    children: /*#__PURE__*/jsx("meshStandardMaterial", {
+      color: collar.color,
+      roughness: collar.roughness,
+      metalness: 0
+    })
+  });
+}
+
+function DeckCutoutSubsystem() {
+  return /*#__PURE__*/jsxs(Fragment, {
+    children: [/*#__PURE__*/jsx(DeckCutoutArticleSync, {}), /*#__PURE__*/jsx(DeckCutoutCollar, {})]
+  });
+}
+
+export { DeckCutoutSubsystem };