@crystaldesign/real-time-viewer-next 26.13.0-beta.2 → 26.13.0-beta.21

package/build/esm/{index-428fd8ca.js → index-6f58b1ed.js}

@@ -3486,7 +3486,14 @@ var DECK_CUTOUT_ARTICLE_RULE_CONFIG = field.group({
    * How far (m) below the deck top the geometry projection reaches — captures the rim, ignores the
    * sunk basin body.
    */
-  footprintSliceDepth: field.number(0.35)
+  footprintSliceDepth: field.number(0.35),
+  /**
+   * Shape the cutout from these geos only: comma-separated catalog geo-name prefixes (`GEO_Pool`
+   * matches `GEO_Pool`, `GEO_Pool_Rim`, …). The traced outline, the rim that places the article and
+   * sizes the water, and the fallback rect then describe the basin alone, not the stairs or cover the
+   * same article ships with. '' = the whole article; a prefix matching no geo falls back to it.
+   */
+  geoPrefix: field.value('')
 });
 
 /**
@@ -4434,7 +4441,7 @@ var chunk$2;
 /** Memoized so the preload and the lazy mount share ONE chunk request. */
 function loadChunk$2() {
   var _chunk;
-  return (_chunk = chunk$2) !== null && _chunk !== void 0 ? _chunk : chunk$2 = import('./WaterSurface-10a28566.js');
+  return (_chunk = chunk$2) !== null && _chunk !== void 0 ? _chunk : chunk$2 = import('./WaterSurface-f3e878b1.js');
 }
 
 /**
@@ -4469,7 +4476,7 @@ var chunk$1;
 /** Memoized so the preload and the lazy mount share ONE chunk request. */
 function loadChunk$1() {
   var _chunk;
-  return (_chunk = chunk$1) !== null && _chunk !== void 0 ? _chunk : chunk$1 = import('./DeckCutoutSubsystem-6453a4f4.js');
+  return (_chunk = chunk$1) !== null && _chunk !== void 0 ? _chunk : chunk$1 = import('./DeckCutoutSubsystem-8b702df0.js');
 }
 
 /**
@@ -4514,7 +4521,7 @@ var chunk;
 /** Memoized so the preload and the lazy mount share ONE chunk request. */
 function loadChunk() {
   var _chunk;
-  return (_chunk = chunk) !== null && _chunk !== void 0 ? _chunk : chunk = import('./SunLensflare-46fa6ee8.js');
+  return (_chunk = chunk) !== null && _chunk !== void 0 ? _chunk : chunk = import('./SunLensflare-0676ae6e.js');
 }
 
 /**
@@ -7537,7 +7544,7 @@ var createSelectionSlice = function createSelectionSlice(set, get) {
         frontOnElementName: frontOnElementName
       });
     },
-    refocusFocused: function refocusFocused() {
+    refocusFocused: function refocusFocused(follow) {
       var _get$cameraConfig$sel3;
       var elementName = get().focusedElementName;
       if (!elementName) return;
@@ -7551,7 +7558,8 @@ var createSelectionSlice = function createSelectionSlice(set, get) {
         type: type,
         elevation: elevation,
         frontOn: frontOn,
-        paddingScale: paddingScale
+        paddingScale: paddingScale,
+        follow: follow
       });
       if (!((_get$cameraConfig$sel3 = get().cameraConfig.selectionMovesCamera) !== null && _get$cameraConfig$sel3 !== void 0 ? _get$cameraConfig$sel3 : DEFAULT_CAMERA_CONFIG.selectionMovesCamera)) return;
       get().enqueueCameraAction({
@@ -7559,7 +7567,8 @@ var createSelectionSlice = function createSelectionSlice(set, get) {
         elementName: elementName,
         focusElevationDeg: elevation,
         frontOn: frontOn,
-        paddingScale: paddingScale
+        paddingScale: paddingScale,
+        follow: follow
       });
     },
     resolveElementName: function resolveElementName(elementId) {
@@ -7618,6 +7627,12 @@ var createVersionsSlice = function createVersionsSlice(set, get) {
         articleVersion: get().articleVersion + 1
       });
     },
+    articleSettledVersion: 0,
+    bumpArticleSettledVersion: function bumpArticleSettledVersion() {
+      return set({
+        articleSettledVersion: get().articleSettledVersion + 1
+      });
+    },
     decorVersion: 0,
     bumpDecorVersion: function bumpDecorVersion() {
       return set({
@@ -9309,16 +9324,20 @@ function useShadowDirty() {
     return s.markShadowsDirty;
   });
 
-  // Geometry landed or moved: article geos mounted / pose committed, environment GLB mounted.
+  // Geometry landed or moved: article geos mounted / pose committed, environment GLB mounted, and the
+  // article's placement settled (the deck anchor moves it after its geos mount).
   var articleVersion = useRTVStore$1(function (s) {
     return s.articleVersion;
   });
+  var articleSettledVersion = useRTVStore$1(function (s) {
+    return s.articleSettledVersion;
+  });
   var decorVersion = useRTVStore$1(function (s) {
     return s.decorVersion;
   });
   useEffect(function () {
     markShadowsDirty('scene geometry');
-  }, [articleVersion, decorVersion, markShadowsDirty]);
+  }, [articleVersion, articleSettledVersion, decorVersion, markShadowsDirty]);
   var sunDirection = useRTVStore$1(function (s) {
     var sun = s.resolvedEnvironment.lighting.sun;
     return sun === false ? null : sun.direction;
@@ -13887,6 +13906,27 @@ function frameScene(ctx, baseAngle) {
     padding: padding
   };
 }
+
+/**
+ * `reframeOnSceneChange: 'follow'`: the camera keeps its current view direction and its zoom
+ * relative to the recipe's fit, around the recipe's (re-derived) look-at point. `basisDistance` is the
+ * fit distance the recipe produced before the change — a camera at half of that stays at half of the
+ * new one.
+ */
+function followPose(recipe, current, basisDistance) {
+  var offset = current.position.clone().sub(current.target);
+  var currentDistance = offset.length();
+  // Negated `>` so a NaN basis (a fit stored while the canvas had no size) falls back instead of poisoning the pose.
+  if (!(currentDistance > 1e-6) || !(basisDistance > 1e-6)) return {
+    position: recipe.position.clone(),
+    target: recipe.target.clone()
+  };
+  var recipeDistance = recipe.position.distanceTo(recipe.target);
+  return {
+    position: recipe.target.clone().addScaledVector(offset.divideScalar(currentDistance), currentDistance * (recipeDistance / basisDistance)),
+    target: recipe.target.clone()
+  };
+}
 function frameToResult(frame, aspect, cfg) {
   var dist = frame.radius / fovHalfTan(cfg);
   // The portrait fudge only applies to the isotropic sphere radius; the box-projected
@@ -14754,7 +14794,8 @@ var TWO_D_UP_HINTS = {
 function useCameraActions(controlsRef, animate, opts) {
   var viewMode = opts.viewMode,
     frameCtx = opts.frameCtx,
-    poseBook = opts.poseBook;
+    poseBook = opts.poseBook,
+    animating = opts.animating;
   var cameraConfig = frameCtx.cameraConfig;
   var cameraActionQueue = useRTVStore$1(function (s) {
     return s.cameraActionQueue;
@@ -14767,11 +14808,18 @@ function useCameraActions(controlsRef, animate, opts) {
   // recomputes the live overview so it tracks a scene that may have grown while focused.
   var inFocusRef = useRef(false);
 
+  // Destination of the last fly — the pose a retarget mid-flight must read instead of the in-between camera.
+  var flightEndRef = useRef(null);
+
   // Shared fly: every action animates to a pose and, on arrival, commits the target. Re-enabling
   // OrbitControls is the animation's own business — it holds a controls lock for the whole flight
   // (see {@link controlsLock}). `up2D` selects the top-down up-hint pair; omit for a 3D orbit pose.
   var flyTo = useCallback(function (endPos, endTarget, flyOpts) {
     var _flyOpts$duration;
+    flightEndRef.current = {
+      position: endPos.clone(),
+      target: endTarget.clone()
+    };
     animate({
       endPos: endPos,
       endTarget: endTarget,
@@ -14786,6 +14834,21 @@ function useCameraActions(controlsRef, animate, opts) {
       }
     }, flyOpts !== null && flyOpts !== void 0 && flyOpts.up2D ? TWO_D_UP_HINTS : undefined);
   }, [animate, controlsRef]);
+
+  // Fit distance of the last focus recipe — what a `follow` refocus scales the user's current zoom against.
+  var focusFitDistanceRef = useRef(null);
+
+  /** The user's current view direction and relative zoom around `recipe`'s look-at point (see `followPose`). */
+  var followCurrent = useCallback(function (recipe, basisDistance) {
+    var c = controlsRef.current;
+    if (!c || basisDistance == null) return recipe;
+    // Mid-flight the camera sits between two fits; the zoom the basis belongs to is the flight's destination.
+    var current = animating.current && flightEndRef.current ? flightEndRef.current : {
+      position: c.object.position,
+      target: c.target
+    };
+    return followPose(recipe, current, basisDistance);
+  }, [controlsRef, animating]);
   var processAction = useCallback(function (action) {
     var is2D = viewMode === '2d';
     // In 2D the ONLY programmatic camera motion is the auto-fit (`reframe` / `reset`) — element
@@ -14807,9 +14870,12 @@ function useCameraActions(controlsRef, animate, opts) {
         {
           if (is2D) break;
           inFocusRef.current = true;
-          var _result = computeCamera3D(frameCtx, action.elementName, undefined, action.focusElevationDeg, action.frontOn, action.paddingScale);
+          var recipe = computeCamera3D(frameCtx, action.elementName, undefined, action.focusElevationDeg, action.frontOn, action.paddingScale);
+          var basis = focusFitDistanceRef.current;
+          focusFitDistanceRef.current = recipe.position.distanceTo(recipe.target);
+          var _result = action.follow ? followCurrent(recipe, basis) : recipe;
           flyTo(_result.position, _result.target);
-          LOG$b.debug('CameraController: focusElement', action.elementName, 'elev=', action.focusElevationDeg);
+          LOG$b.debug('CameraController: focusElement', action.elementName, 'elev=', action.focusElevationDeg, action.follow ? '— follow' : '');
           break;
         }
       case 'unfocus':
@@ -14875,16 +14941,19 @@ function useCameraActions(controlsRef, animate, opts) {
           // saved overview so subsequent `reset` calls honour the new framing too. We
           // deliberately ignore explicit initialPosition/Target — those are a host
           // hard-override, not a framing computation.
-          var _result6 = is2D ? computeCamera2D(frameCtx) : computeCamera3D(frameCtx);
-          if (viewMode === '3d') poseBook.setOverview3D(_result6.position, _result6.target);
+          var _recipe = is2D ? computeCamera2D(frameCtx) : computeCamera3D(frameCtx);
+          // The saved overview is the last overview fit, so its distance is what `follow` keeps the zoom relative to.
+          var overview3D = poseBook.overview3D;
+          var _result6 = !is2D && action.follow ? followCurrent(_recipe, overview3D.position.distanceTo(overview3D.target)) : _recipe;
+          if (viewMode === '3d') poseBook.setOverview3D(_recipe.position, _recipe.target);
           flyTo(_result6.position, _result6.target, {
             up2D: is2D
           });
-          LOG$b.debug('CameraController: reframe world', viewMode);
+          LOG$b.debug("CameraController: reframe world".concat(action.follow ? ' — follow' : ''), viewMode);
           break;
         }
     }
-  }, [viewMode, frameCtx, flyTo, poseBook]);
+  }, [viewMode, frameCtx, flyTo, followCurrent, poseBook]);
   useEffect(function () {
     if (cameraActionQueue.length === 0) return;
     var actions = drainCameraActions();
@@ -15176,6 +15245,7 @@ function useCameraConstraints(camera, controlsRef, opts) {
   var collisionTargets = useRef(null);
   var collisionTargetsFor = useRef({
     article: -1,
+    settled: -1,
     decor: -1
   });
   var collisionDir = useRef(new Vector3());
@@ -15209,16 +15279,19 @@ function useCameraConstraints(camera, controlsRef, opts) {
    *
    * Element poses moving between two bumps (mid-drag) are picked up regardless: the raycast reads
    * live world matrices. Only `bounds` goes stale, and only as a slightly-off early-out until the
-   * drag-end bump.
+   * next bump — `articleSettledVersion` included, which covers a placement pass (the deck anchor)
+   * moving the article after its geos mounted.
    */
   var ensureCollisionTargets = useCallback(function () {
     var _useRTVStore$getState = useRTVStore$1.getState(),
       articleVersion = _useRTVStore$getState.articleVersion,
+      articleSettledVersion = _useRTVStore$getState.articleSettledVersion,
       decorVersion = _useRTVStore$getState.decorVersion;
     var builtFor = collisionTargetsFor.current;
     var cached = collisionTargets.current;
-    if (cached && builtFor.article === articleVersion && builtFor.decor === decorVersion) return cached;
+    if (cached && builtFor.article === articleVersion && builtFor.settled === articleSettledVersion && builtFor.decor === decorVersion) return cached;
     builtFor.article = articleVersion;
+    builtFor.settled = articleSettledVersion;
     builtFor.decor = decorVersion;
     flushPendingBVH();
     var targets = collectCollisionTargets(threeScene);
@@ -15766,6 +15839,16 @@ function CameraController() {
     }
     return 2;
   }, [scene3d]);
+
+  // Placement-dependent camera work keys on the SETTLED article, not on geometry mounting: a
+  // placement pass (the deck-cutout anchor) moves the elements over the frames after the mount.
+  var articleSettledVersion = useRTVStore$1(function (s) {
+    return s.articleSettledVersion;
+  });
+
+  // Orbit-target bounds: the render script's ground-shadow box, widened by where the article actually
+  // settled — the deck anchor can push it well off that footprint, and a look-at point that follows it
+  // must not be clamped back towards the old spot.
   var sceneBBox = useMemo(function () {
     var _scene3d$groundShadow3;
     if (!(scene3d !== null && scene3d !== void 0 && (_scene3d$groundShadow3 = scene3d.groundShadow) !== null && _scene3d$groundShadow3 !== void 0 && _scene3d$groundShadow3.enabled)) return null;
@@ -15777,12 +15860,16 @@ function CameraController() {
       sx = _scene3d$groundShadow5[0],
       sy = _scene3d$groundShadow5[1],
       sz = _scene3d$groundShadow5[2];
-    var margin = limits.targetBoundsMargin;
+    var box = new Box3(new Vector3(cx - sx / 2, cy - sy / 2, cz - sz / 2), new Vector3(cx + sx / 2, cy + sy / 2, cz + sz / 2));
+    var content = sceneContentBox(threeScene);
+    if (content) box.union(content);
+    box.expandByScalar(limits.targetBoundsMargin);
     return {
-      min: new Vector3(cx - sx / 2 - margin, cy - sy / 2 - margin, cz - sz / 2 - margin),
-      max: new Vector3(cx + sx / 2 + margin, cy + sy / 2 + margin, cz + sz / 2 + margin)
+      min: box.min,
+      max: box.max
     };
-  }, [scene3d, limits.targetBoundsMargin]);
+    // `articleSettledVersion` is the trigger: the content box is read from the live scene.
+  }, [scene3d, limits.targetBoundsMargin, threeScene, articleSettledVersion]);
 
   // Frame context, shared by all camera hooks.
   var frameCtx = useMemo(function () {
@@ -15808,7 +15895,7 @@ function CameraController() {
   }, [elementCount, scene2dElementCount]);
 
   // Auto-refit the 2D view when the 2D planning changes — a freetext resize (bounds grow/shrink) or an
-  // element add/remove. The `articleVersion` content-box reframe below doesn't cover 2D (the 3D geos
+  // element add/remove. The settled-article content-box reframe below doesn't cover 2D (the 3D geos
   // unmount in 2D, so `sceneContentBox` is null), so key off the 2D bounding box directly. The 2D zoom
   // is system-owned (manual zoom is disabled via `limits2d`), so the refit is unconditional: the camera
   // always tracks the planning size. The first observation only baselines (entering 2D is already
@@ -15876,17 +15963,14 @@ function CameraController() {
   }, [isAccessoryMoving]);
 
   // Camera reaction to element add/delete (mains AND accessories — both are `Element#` nodes).
-  // Keyed on `articleVersion` (bumped after geometry mounts / a pose commits) so the scene is settled
-  // before we frame/measure, and diffs the element name SET.
+  // Keyed on `articleSettledVersion` — geometry mounted AND every placement pass done — so the camera
+  // measures the article where it finally rests, and diffs the element name SET.
   //   - FOCUSED  → stay focused; follow only when the focused element itself was re-keyed (a move).
   //                Following the selection to a newly placed element is driven by the host
   //                `selectedElementId` prop (setSelectedElementFromProp), not here.
   //   - OVERVIEW (not focused) → re-fit the view to the new element bounding box, but only when that
   //                box actually changed (`elementBoxChanged`).
   // Skips the first scene (initial framing already fit it).
-  var articleVersion = useRTVStore$1(function (s) {
-    return s.articleVersion;
-  });
   var prevElementNamesRef = useRef(null);
   var prevElementBoxRef = useRef(null);
   useEffect(function () {
@@ -15954,7 +16038,9 @@ function CameraController() {
     // keeping the camera where the user left it across scene size changes. Selection-driven focus
     // (follow-on-replace, host `selectedElementId`) still moves the camera.
     var reframeOnSceneChange = (_s$cameraConfig$refra = s.cameraConfig.reframeOnSceneChange) !== null && _s$cameraConfig$refra !== void 0 ? _s$cameraConfig$refra : DEFAULT_CAMERA_CONFIG.reframeOnSceneChange;
+    var follow = reframeOnSceneChange === 'follow';
     var selectionMovesCamera = (_s$cameraConfig$selec = s.cameraConfig.selectionMovesCamera) !== null && _s$cameraConfig$selec !== void 0 ? _s$cameraConfig$selec : DEFAULT_CAMERA_CONFIG.selectionMovesCamera;
+    var refitOnChange = boxChanged && settled && !!reframeOnSceneChange;
     if (s.focusedElementName != null) {
       var focusedSurvived = cur.has(s.focusedElementName);
 
@@ -15976,10 +16062,12 @@ function CameraController() {
         s.clearFocus();
         // `clearFocus` already no-ops its own fly when selection must not move the camera; this
         // reframe is a separate grab, so it needs the same gate.
-        if (selectionMovesCamera) s.enqueueCameraAction({
-          type: 'reframe'
-        });
-        return;
+        if (selectionMovesCamera) {
+          s.enqueueCameraAction({
+            type: 'reframe'
+          });
+          return;
+        }
       }
 
       // Focused element's own node vanished. Follow to a selectable main among the names added THIS
@@ -15996,12 +16084,19 @@ function CameraController() {
           return st === 'selectable' || st === 'selected';
         });
         if (followName) s.focusOnElement(followName);
-      } else if (setUnchanged && boxChanged && settled && reframeOnSceneChange) {
+      }
+      if (!selectionMovesCamera) {
+        // Focus is state only here — the camera never left the overview, so keep fitting that.
+        if (refitOnChange) s.enqueueCameraAction({
+          type: 'reframe',
+          follow: follow
+        });
+      } else if (focusedSurvived && setUnchanged && refitOnChange) {
         // Focused element survived and NOTHING was added/replaced/removed, but its geometry changed
         // (e.g. a size edit shipped as a fresh render script). Re-fit the focus so the camera re-orients
         // to the resized element. Mirrors the overview reframe below; `refocusFocused` recomputes the
         // 2D/3D focus framing for the current view mode.
-        s.refocusFocused();
+        s.refocusFocused(follow);
       }
       return;
     }
@@ -16027,13 +16122,14 @@ function CameraController() {
     // Re-fit the overview to the new element bounding box — only when it changed (covers a pure size
     // edit with no add/remove), and never while a drag/rotate is still in progress (the move settles
     // into a new assembly first).
-    if (boxChanged && settled && reframeOnSceneChange) {
+    if (refitOnChange) {
       LOG$a.debug('CameraController: element bbox changed in overview → reframe to fit');
       s.enqueueCameraAction({
-        type: 'reframe'
+        type: 'reframe',
+        follow: follow
       });
     }
-  }, [articleVersion]);
+  }, [articleSettledVersion]);
 
   // Camera creation: proxy + real split.
   //
@@ -16123,7 +16219,8 @@ function CameraController() {
   useCameraActions(controlsRef, animate, {
     viewMode: viewMode,
     frameCtx: frameCtx,
-    poseBook: poseBook
+    poseBook: poseBook,
+    animating: animating
   });
   var _useCameraConstraints = useCameraConstraints(proxyCamera, controlsRef, {
       controlsMode: controlsMode,
@@ -16209,6 +16306,74 @@ function CameraController() {
   });
 }
 
+/** Consecutive frames the article's bounds must hold still before its placement counts as settled. */
+var STABLE_FRAMES = 3;
+/** Bounds movement (m) below which two measures are the same placement — the deck anchor's own epsilon. */
+var EPSILON_SQ = 1e-3 * 1e-3;
+function sameBounds(a, b) {
+  if (a == null || b == null) return a === b;
+  return a.min.distanceToSquared(b.min) < EPSILON_SQ && a.max.distanceToSquared(b.max) < EPSILON_SQ;
+}
+
+/**
+ * Publishes `articleSettledVersion`: the article's world bounds stopped moving after a change.
+ *
+ * Armed by everything that can move the article — geometry mounting or a pose commit
+ * (`articleVersion`), a floor arriving (`decorVersion`, which re-runs the deck anchor) and a placement
+ * pass writing its result (`elementAnchorOffsets`). While armed it measures the content box once per
+ * frame and bumps once the box held still for {@link STABLE_FRAMES}, so a consumer sees the article
+ * where it finally rests, whichever pass put it there. Several changes inside one settle window
+ * collapse into one bump.
+ */
+function ArticleSettleTracker() {
+  var scene = useThree(function (s) {
+    return s.scene;
+  });
+  var invalidate = useThree(function (s) {
+    return s.invalidate;
+  });
+  var armedRef = useRef(false);
+  var stableRef = useRef(0);
+  var lastBoxRef = useRef(null);
+  useEffect(function () {
+    var arm = function arm() {
+      armedRef.current = true;
+      stableRef.current = 0;
+      invalidate();
+    };
+    var unsubscribers = [useRTVStore$1.subscribe(function (s) {
+      return s.articleVersion;
+    }, arm), useRTVStore$1.subscribe(function (s) {
+      return s.decorVersion;
+    }, arm), useRTVStore$1.subscribe(function (s) {
+      return s.elementAnchorOffsets;
+    }, arm)];
+    return function () {
+      return unsubscribers.forEach(function (unsubscribe) {
+        return unsubscribe();
+      });
+    };
+  }, [invalidate]);
+  useFrame(function () {
+    if (!armedRef.current) return;
+    var box = sceneContentBox(scene);
+    if (sameBounds(box, lastBoxRef.current)) {
+      stableRef.current += 1;
+    } else {
+      stableRef.current = 0;
+      lastBoxRef.current = box ? box.clone() : null;
+    }
+    // An on-demand frameloop would otherwise stop right here and never count the settle out.
+    if (stableRef.current < STABLE_FRAMES) {
+      invalidate();
+      return;
+    }
+    armedRef.current = false;
+    useRTVStore$1.getState().bumpArticleSettledVersion();
+  });
+  return null;
+}
+
 var wrap = "wrap-FtDo5";
 var dp = "dp-B372X";
 var dpAttach = "dp-attach-J1C1i";
@@ -18291,9 +18456,10 @@ function DimensionLines3D() {
   var hideUnit = useRTVStore$1(function (s) {
     return s.resolvedEnvironment.dimensionLineHideUnit;
   });
-  // Lines are measured from the mounted element meshes; re-measure when those land or move.
-  var articleVersion = useRTVStore$1(function (s) {
-    return s.articleVersion;
+  // Lines are measured from the element meshes' world bounds, so they wait for the SETTLED placement:
+  // the deck anchor moves an article onto its resting spot after its geometry mounts.
+  var articleSettledVersion = useRTVStore$1(function (s) {
+    return s.articleSettledVersion;
   });
   var scene = useThree(function (s) {
     return s.scene;
@@ -18384,7 +18550,7 @@ function DimensionLines3D() {
       }
     }
     return [].concat(_toConsumableArray(sizeLines), _toConsumableArray(gapLines));
-  }, [viewMode, selectedName, scopeNames, articleVersion, scene2d, articleNodeById, childrenOfName, parentOfName, isAccessoryMoving, accessoryGrids, scene, camera, sidesSig, getSelectionScopeNames]);
+  }, [viewMode, selectedName, scopeNames, articleSettledVersion, scene2d, articleNodeById, childrenOfName, parentOfName, isAccessoryMoving, accessoryGrids, scene, camera, sidesSig, getSelectionScopeNames]);
 
   // `lines` is the only thing that mounts/unmounts children of the group.
   useLayoutEffect(function () {
@@ -22863,7 +23029,7 @@ function SceneRenderer() {
             onCreated: handleCreated,
             shadows: true,
             children: /*#__PURE__*/jsxs(ViewModeRuntimeProvider, {
-              children: [/*#__PURE__*/jsx(FirstFrameMark, {}), /*#__PURE__*/jsx(FrameloopVisibilityController, {}), /*#__PURE__*/jsx(PerfLogController, {}), /*#__PURE__*/jsx(CameraController, {}), /*#__PURE__*/jsx(SceneContent, {
+              children: [/*#__PURE__*/jsx(FirstFrameMark, {}), /*#__PURE__*/jsx(FrameloopVisibilityController, {}), /*#__PURE__*/jsx(PerfLogController, {}), /*#__PURE__*/jsx(ArticleSettleTracker, {}), /*#__PURE__*/jsx(CameraController, {}), /*#__PURE__*/jsx(SceneContent, {
                 matConfig: matConfig
               })]
             })
@@ -25314,11 +25480,11 @@ var preset = {
             halfExtentX: 2.5705,
             halfExtentZ: 7.071
           },
-          // -6cm margin: the deck laps 6cm over the pool's rim, hiding the seam between the
+          // -13cm margin: the deck laps 13cm over the pool's rim, hiding the seam between the
           // collar edge and the moulded lip.
           articleSync: {
             enabled: true,
-            margin: -0.06
+            margin: -0.13
           },
           // The pool is centered in the authored hole (HQS grows articles from their center, so
           // every size needs re-placing). Offsets fine-tune its resting spot within the hole.
@@ -25353,9 +25519,12 @@ var preset = {
           // footprintSliceDepth below the deck top, projected onto the floor). The traced rim bbox
           // replaces the raw article bbox for placement and water, so no calibration is needed.
           // Without a matching rule there is no outline and no collar — the area stays open.
+          // Only the `GEO_Pool…` geos shape the cutout: the article ships more than the basin, and the
+          // hole, the resting spot and the water should follow the basin alone.
           articleRules: [{
             match: 'HUELSE_POOL',
-            footprintFromGeometry: true
+            footprintFromGeometry: true,
+            geoPrefix: 'GEO_Pool'
           }]
           // The collar continues FLOOR_Wood_1's wood by fitting its mapping. To make it a DIFFERENT
           // material instead (another wood, stone, tile), give it its own maps — the tiling is then
@@ -25427,9 +25596,10 @@ var preset = {
     // The pool is flat and sunk into the deck, so the bbox-fraction focus point lands at water
     // level; lift the orbit pivot a meter above it.
     focusTargetYOffset: 1,
-    // Pool resizes reshape the deck cutout every config edit — keep the camera where the user
-    // left it instead of re-fitting to the new bounds.
-    reframeOnSceneChange: false,
+    // Pool resizes reshape the deck cutout every config edit, and the anchor grows the pool away from
+    // one border — so the look-at point and fit distance follow the resized pool, but the user's (or
+    // the sweep's) view angle and zoom are kept instead of re-fitting to the initial angle.
+    reframeOnSceneChange: 'follow',
     // Selection never moves the camera in this scene. The framing here is authored (limits, sectors,
     // autoRotate), and the default behaviour — fly to the element on select, out to the overview on
     // deselect, recenter on a click into empty space — discards it on the first click. Elements still

package/build/esm/index.js

@@ -1,4 +1,4 @@
-export { E as ENVIRONMENT_CONFIG, W as WHITE_ROOM_PRESET, j as buildScene2D, R as default, m as emitConfig, k as getDimensionConfigs, i as internals, a as useRTVStore } from './index-428fd8ca.js';
+export { E as ENVIRONMENT_CONFIG, W as WHITE_ROOM_PRESET, j as buildScene2D, R as default, m as emitConfig, k as getDimensionConfigs, i as internals, a as useRTVStore } from './index-6f58b1ed.js';
 import 'react';
 import '@react-three/fiber';
 import 'three';

package/build/types/real-time-viewer-next/src/config/environment.config.d.ts

@@ -95,6 +95,7 @@ export declare const ENVIRONMENT_CONFIG: import("./descriptor").GroupDescriptor<
                 match: import("./descriptor").ValueField<string>;
                 footprintFromGeometry: import("./descriptor").BooleanField;
                 footprintSliceDepth: import("./descriptor").NumberField;
+                geoPrefix: import("./descriptor").ValueField<string>;
             }>>;
             collar: import("./descriptor").GroupDescriptor<{
                 recess: import("./descriptor").NumberField;

package/build/types/real-time-viewer-next/src/config/environment.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"environment.config.d.ts","sourceRoot":"","sources":["../../../../../src/config/environment.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAc5F;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;IAW7B;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACvE,MAAM,MAAM,yBAAyB,GAAG,cAAc,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAElF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,yBAA8D,CAAC"}
+{"version":3,"file":"environment.config.d.ts","sourceRoot":"","sources":["../../../../../src/config/environment.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAc5F;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;IAW7B;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACvE,MAAM,MAAM,yBAAyB,GAAG,cAAc,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAElF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,yBAA8D,CAAC"}

package/build/types/real-time-viewer-next/src/core/ArticleSettleTracker.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Publishes `articleSettledVersion`: the article's world bounds stopped moving after a change.
+ *
+ * Armed by everything that can move the article — geometry mounting or a pose commit
+ * (`articleVersion`), a floor arriving (`decorVersion`, which re-runs the deck anchor) and a placement
+ * pass writing its result (`elementAnchorOffsets`). While armed it measures the content box once per
+ * frame and bumps once the box held still for {@link STABLE_FRAMES}, so a consumer sees the article
+ * where it finally rests, whichever pass put it there. Several changes inside one settle window
+ * collapse into one bump.
+ */
+export declare function ArticleSettleTracker(): null;
+//# sourceMappingURL=ArticleSettleTracker.d.ts.map

package/build/types/real-time-viewer-next/src/core/ArticleSettleTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArticleSettleTracker.d.ts","sourceRoot":"","sources":["../../../../../src/core/ArticleSettleTracker.tsx"],"names":[],"mappings":"AAgBA;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,SAwCnC"}

package/build/types/real-time-viewer-next/src/core/SceneRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SceneRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/core/SceneRenderer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA6E,MAAM,OAAO,CAAC;AA4ClG,wBAAgB,aAAa,sBAmQ5B"}
+{"version":3,"file":"SceneRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/core/SceneRenderer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA6E,MAAM,OAAO,CAAC;AA6ClG,wBAAgB,aAAa,sBAoQ5B"}

package/build/types/real-time-viewer-next/src/core/camera/CameraController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CameraController.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/CameraController.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkD,MAAM,OAAO,CAAC;AAgDvE,wBAAgB,gBAAgB,sBA8a/B"}
+{"version":3,"file":"CameraController.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/CameraController.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkD,MAAM,OAAO,CAAC;AAgDvE,wBAAgB,gBAAgB,sBA8b/B"}

package/build/types/real-time-viewer-next/src/core/camera/useCameraActions.d.ts

@@ -1,4 +1,4 @@
-import type { RefObject } from 'react';
+import type { MutableRefObject, RefObject } from 'react';
 import type { OrbitControls as OrbitControlsImpl } from 'three-stdlib';
 import type { CameraFrameContext } from '../../utils/cameraFraming';
 import type { CameraPoseBook } from './cameraPoseBook';
@@ -7,6 +7,7 @@ interface UseCameraActionsOptions {
     viewMode: '3d' | '2d';
     frameCtx: CameraFrameContext;
     poseBook: CameraPoseBook;
+    animating: MutableRefObject<boolean>;
 }
 export declare function useCameraActions(controlsRef: RefObject<OrbitControlsImpl | null>, animate: AnimateFn, opts: UseCameraActionsOptions): void;
 export {};

package/build/types/real-time-viewer-next/src/core/camera/useCameraActions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCameraActions.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/useCameraActions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAUtD,UAAU,uBAAuB;IAC/B,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;IACtB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,uBAAuB,QA4InI"}
+{"version":3,"file":"useCameraActions.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/useCameraActions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEzD,OAAO,KAAK,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGvE,OAAO,KAAK,EAAE,kBAAkB,EAAe,MAAM,2BAA2B,CAAC;AAEjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAUtD,UAAU,uBAAuB;IAC/B,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;IACtB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,QAAQ,EAAE,cAAc,CAAC;IACzB,SAAS,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;CACtC;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,uBAAuB,QAqKnI"}

package/build/types/real-time-viewer-next/src/core/camera/useCameraConstraints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCameraConstraints.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/useCameraConstraints.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAmC,MAAM,OAAO,CAAC;AACpF,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACvE,OAAO,EAA2B,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAmDxF,UAAU,2BAA2B;IACnC,YAAY,EAAE,IAAI,GAAG,IAAI,CAAC;IAC1B,uFAAuF;IACvF,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,kGAAkG;IAClG,MAAM,EAAE,oBAAoB,CAAC;IAC7B,SAAS,EAAE;QAAE,GAAG,EAAE,OAAO,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACjD,SAAS,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;IAC9B,UAAU,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;CACvC;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAAE,IAAI,EAAE,2BAA2B;;EAySlJ"}
+{"version":3,"file":"useCameraConstraints.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/useCameraConstraints.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAmC,MAAM,OAAO,CAAC;AACpF,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACvE,OAAO,EAA2B,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAmDxF,UAAU,2BAA2B;IACnC,YAAY,EAAE,IAAI,GAAG,IAAI,CAAC;IAC1B,uFAAuF;IACvF,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,kGAAkG;IAClG,MAAM,EAAE,oBAAoB,CAAC;IAC7B,SAAS,EAAE;QAAE,GAAG,EAAE,OAAO,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACjD,SAAS,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;IAC9B,UAAU,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;CACvC;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAAE,IAAI,EAAE,2BAA2B;;EA2SlJ"}

package/build/types/real-time-viewer-next/src/core/dimension-lines/DimensionLines3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DimensionLines3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/DimensionLines3D.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqD,MAAM,OAAO,CAAC;AA8E1E,wBAAgB,gBAAgB,sBA2J/B"}
+{"version":3,"file":"DimensionLines3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/DimensionLines3D.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqD,MAAM,OAAO,CAAC;AA8E1E,wBAAgB,gBAAgB,sBA4J/B"}

package/build/types/real-time-viewer-next/src/core/environment/deckCutout/DeckCutoutArticleSync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DeckCutoutArticleSync.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/environment/deckCutout/DeckCutoutArticleSync.tsx"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,SA6KpC"}
+{"version":3,"file":"DeckCutoutArticleSync.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/environment/deckCutout/DeckCutoutArticleSync.tsx"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,SA2LpC"}

package/build/types/real-time-viewer-next/src/core/environment/deckCutout/articleFootprint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"articleFootprint.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/environment/deckCutout/articleFootprint.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACpB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,EAAoB,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAsBtH,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,mGAAmG;IACnG,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,8CAA8C;AAC9C,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,yHAAyH;IACzH,MAAM,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC;IAChC;;;;OAIG;IACH,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,MAAM,EAAE,MAAM,CAAC;IACf,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAWD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc,EAAE,GAAG,IAAI,CAYhG;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,6BAA6B,EAAE,EAC/C,aAAa,EAAE,SAAS,gBAAgB,EAAE,GACzC;IAAE,IAAI,EAAE,6BAA6B,GAAG,IAAI,CAAC;IAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAYlF;AAkHD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,kBAAkB,EAC/B,IAAI,EAAE,6BAA6B,GAAG,IAAI,EAC1C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE;IAAE,OAAO,EAAE,sBAAsB,GAAG,IAAI,CAAA;CAAE;AACjD,oGAAoG;AACpG,YAAY,SAAI,GACf,gBAAgB,CA8ElB"}
+{"version":3,"file":"articleFootprint.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/environment/deckCutout/articleFootprint.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACpB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,EAAoB,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAsBtH,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,mGAAmG;IACnG,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,8CAA8C;AAC9C,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,yHAAyH;IACzH,MAAM,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC;IAChC;;;;OAIG;IACH,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,MAAM,EAAE,MAAM,CAAC;IACf,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAWD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc,EAAE,GAAG,IAAI,CAYhG;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,6BAA6B,EAAE,EAC/C,aAAa,EAAE,SAAS,gBAAgB,EAAE,GACzC;IAAE,IAAI,EAAE,6BAA6B,GAAG,IAAI,CAAC;IAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAYlF;AAmHD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,kBAAkB,EAC/B,IAAI,EAAE,6BAA6B,GAAG,IAAI,EAC1C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE;IAAE,OAAO,EAAE,sBAAsB,GAAG,IAAI,CAAA;CAAE;AACjD,oGAAoG;AACpG,YAAY,SAAI,GACf,gBAAgB,CA8ElB"}