@crystaldesign/diva-web-planner-react 26.11.0-beta.3 → 26.11.0-beta.31

package/build/esm/index-0db38456.js

@@ -0,0 +1,965 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { u as useViewHandler, g as useRTVAnalyzerComponentsFromPlanner, h as registerRtvNextViewer } from './index-cb3f6a27.js';
+import { useRef, useEffect, useMemo } from 'react';
+import { observer } from 'mobx-react-lite';
+import { getLogger, useDivaCore } from '@crystaldesign/diva-core';
+import RealTimeRendererNext, { emitConfig, ENVIRONMENT_CONFIG, useRTVStore, WHITE_ROOM_PRESET } from '@crystaldesign/real-time-viewer-next';
+import { bootMark } from '@crystaldesign/web-planner-logic';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import { jsx } from 'react/jsx-runtime';
+import 'react-dynamic-multi-render';
+import '@babel/runtime/helpers/objectWithoutProperties';
+import '@babel/runtime/helpers/classCallCheck';
+import '@babel/runtime/helpers/createClass';
+import '@crystaldesign/diva-utils';
+import 'mobx';
+import 'classnames';
+import 'qrcode.react';
+import '@babel/runtime/helpers/typeof';
+import 'flat';
+import 'react-switch';
+import 'react-countup';
+
+/**
+ * Host-side accessory placement mode for the rtv-next planner. Single source of truth shared by the
+ * viewer host (passed into `uiConfig.accessoryPlacement`) and the accessory palette (which collapses
+ * variant families to one entry only in `autoPlaceDrag`). Flip to `'cellBoxes'` for the legacy
+ * click-to-place behavior.
+ */
+var ACCESSORY_PLACEMENT_MODE = 'autoPlaceDrag';
+
+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; }
+function ownKeys$1(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$1(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$1(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var LOG = getLogger('Planner', 'CreateImageShot');
+
+/**
+ * Fallback defaults for {@link CreateImageConfig} — overridden field-wise by the active RTV
+ * preset's `createImage` section, which in turn is overridden by the host's `createImageConfig`
+ * component parameter.
+ */
+var DEFAULTS = {
+  /** 4K at the 16:9 proportions of the host's capture stage — supersampled output. */
+  width: 3840,
+  height: 2160,
+  formats: ['png'],
+  jpegQuality: 0.92,
+  /** Extra render frames before the shutter, covering async label-font and SVG-texture loads. */
+  settleFrames: 60,
+  /**
+   * How long the 2D scene must stay unchanged before it counts as settled — an init with
+   * custom measures re-sizes/re-docks elements shortly after the first elements appear.
+   */
+  stableMs: 800,
+  /** Tight plan framing; the margin leaves room for dimension labels outside the element bounds. */
+  cameraPadding: 1.25
+};
+/**
+ * `initMode: 'CREATE_IMAGE'` — once the 2D plan has settled after planner init, captures it
+ * via the rtv-next capture engine and emits a `planImageCreated` event to the host
+ * (data: `{ images: PlanImage[] }`, one image per requested format). Fires once per mount.
+ */
+function useCreateImageShot(viewHandler, scene2d, preset) {
+  var enabled = viewHandler.configState.initMode === 'CREATE_IMAGE';
+  var firedRef = useRef(false);
+
+  // scene2d is rebuilt every render, so its identity is useless as a settle signal — track content.
+  var signature = enabled && scene2d ? scene2d.elements.map(function (e) {
+    return "".concat(e.elementId, ":").concat(e.width, "x").concat(e.depth, "@").concat(e.position[0], ",").concat(e.position[1]);
+  }).join('|') : '';
+  useEffect(function () {
+    if (!enabled || !signature || firedRef.current) return;
+    var cfg = _objectSpread$1(_objectSpread$1(_objectSpread$1({}, DEFAULTS), preset.createImage), viewHandler.configState.createImageConfig);
+    var timer = window.setTimeout(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var _viewHandler$actions, shot, _yield$useRTVStore$ge, _yield$useRTVStore$ge2, result, images, _iterator, _step, format, dataUrl, _viewHandler$actions2;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!firedRef.current) {
+              _context.next = 2;
+              break;
+            }
+            return _context.abrupt("return");
+          case 2:
+            firedRef.current = true;
+            _context.prev = 3;
+            shot = {
+              id: 'plan-2d',
+              viewMode: '2d',
+              showGrid: false,
+              showDimensionLines: true,
+              showPosNr: false,
+              environment: _objectSpread$1(_objectSpread$1(_objectSpread$1(_objectSpread$1({}, emitConfig(ENVIRONMENT_CONFIG, useRTVStore.getState().resolvedEnvironment)), cfg.dimensionLineUnit ? {
+                dimensionLineUnit: cfg.dimensionLineUnit
+              } : {}), cfg.dimensionLineHideUnit !== undefined ? {
+                dimensionLineHideUnit: cfg.dimensionLineHideUnit
+              } : {}), cfg.dimensionLineColor ? {
+                dimensionLineColor: cfg.dimensionLineColor
+              } : {}),
+              resolution: {
+                width: cfg.width,
+                height: cfg.height
+              },
+              camera: {
+                padding: cfg.cameraPadding
+              },
+              // Always capture a lossless PNG master; JPEG variants are re-encoded from it below.
+              format: 'png',
+              settleFrames: cfg.settleFrames
+            };
+            _context.next = 7;
+            return useRTVStore.getState().captureShots({
+              shots: [shot]
+            });
+          case 7:
+            _yield$useRTVStore$ge = _context.sent;
+            _yield$useRTVStore$ge2 = _slicedToArray(_yield$useRTVStore$ge, 1);
+            result = _yield$useRTVStore$ge2[0];
+            if (result) {
+              _context.next = 12;
+              break;
+            }
+            throw new Error('captureShots returned no result');
+          case 12:
+            images = [];
+            _iterator = _createForOfIteratorHelper$1(cfg.formats);
+            _context.prev = 14;
+            _iterator.s();
+          case 16:
+            if ((_step = _iterator.n()).done) {
+              _context.next = 31;
+              break;
+            }
+            format = _step.value;
+            if (!(format === 'jpeg')) {
+              _context.next = 24;
+              break;
+            }
+            _context.next = 21;
+            return reencodeJpeg(result.blob, cfg.jpegQuality);
+          case 21:
+            _context.t0 = _context.sent;
+            _context.next = 27;
+            break;
+          case 24:
+            _context.next = 26;
+            return blobToDataUrl(result.blob);
+          case 26:
+            _context.t0 = _context.sent;
+          case 27:
+            dataUrl = _context.t0;
+            images.push({
+              format: format,
+              dataUrl: dataUrl,
+              width: result.width,
+              height: result.height
+            });
+          case 29:
+            _context.next = 16;
+            break;
+          case 31:
+            _context.next = 36;
+            break;
+          case 33:
+            _context.prev = 33;
+            _context.t1 = _context["catch"](14);
+            _iterator.e(_context.t1);
+          case 36:
+            _context.prev = 36;
+            _iterator.f();
+            return _context.finish(36);
+          case 39:
+            (_viewHandler$actions = viewHandler.actions) === null || _viewHandler$actions === void 0 || _viewHandler$actions.onEvent({
+              type: 'planImageCreated',
+              data: {
+                images: images
+              }
+            });
+            _context.next = 47;
+            break;
+          case 42:
+            _context.prev = 42;
+            _context.t2 = _context["catch"](3);
+            LOG.warn('CREATE_IMAGE capture failed', _context.t2);
+            // Never leave the host waiting for a `planImageCreated` that can no longer come: report the
+            // failure and re-arm, so a later scene change gets another attempt.
+            firedRef.current = false;
+            (_viewHandler$actions2 = viewHandler.actions) === null || _viewHandler$actions2 === void 0 || _viewHandler$actions2.onEvent({
+              type: 'planImageFailed',
+              data: {
+                message: _context.t2 instanceof Error ? _context.t2.message : String(_context.t2)
+              }
+            });
+          case 47:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[3, 42], [14, 33, 36, 39]]);
+    })), cfg.stableMs);
+    return function () {
+      return window.clearTimeout(timer);
+    };
+  }, [enabled, signature, viewHandler, preset]);
+}
+function blobToDataUrl(blob) {
+  return new Promise(function (resolve, reject) {
+    var reader = new FileReader();
+    reader.onload = function () {
+      return resolve(reader.result);
+    };
+    reader.onerror = function () {
+      var _reader$error;
+      return reject((_reader$error = reader.error) !== null && _reader$error !== void 0 ? _reader$error : new Error('Failed to read image blob'));
+    };
+    reader.readAsDataURL(blob);
+  });
+}
+
+/**
+ * JPEG has no alpha channel and a direct JPEG read of the (transparent) WebGL canvas would
+ * composite onto black — re-encode the PNG master onto a white background instead.
+ */
+function reencodeJpeg(_x, _x2) {
+  return _reencodeJpeg.apply(this, arguments);
+}
+function _reencodeJpeg() {
+  _reencodeJpeg = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(pngBlob, quality) {
+    var bitmap, canvas, ctx;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return createImageBitmap(pngBlob);
+        case 2:
+          bitmap = _context2.sent;
+          canvas = document.createElement('canvas');
+          canvas.width = bitmap.width;
+          canvas.height = bitmap.height;
+          ctx = canvas.getContext('2d');
+          if (ctx) {
+            _context2.next = 9;
+            break;
+          }
+          throw new Error('2D canvas context unavailable for JPEG encoding');
+        case 9:
+          ctx.fillStyle = '#ffffff';
+          ctx.fillRect(0, 0, canvas.width, canvas.height);
+          ctx.drawImage(bitmap, 0, 0);
+          bitmap.close();
+          return _context2.abrupt("return", canvas.toDataURL('image/jpeg', quality));
+        case 14:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _reencodeJpeg.apply(this, arguments);
+}
+
+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; }
+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 PLANNER_TAB_GROUP_TYPES = new Set(['PLANNER', 'ACC_PLANNER', 'PLANNER_2.0']);
+
+// Accessory docking-point types rendered as attach/remove buttons in the 2D viewer (old planner's
+// `addDPUI` ACC branch — AVL/AVR are the side-copy buttons, handled separately).
+var ACC_DP_TYPES = new Set(['AVO', 'AVU', 'AVC', 'AVN', 'AVS']);
+
+// Environment config (lighting / HDRI / dome / post-processing / selection look) comes from ONE
+// channel: the preset — catalog RTV_PRESET meta tag when present, else WHITE_ROOM_PRESET — passed
+// via `config.profiles` below. With ?rtv-debug mounted, the analyzer preset channel overrides it.
+
+// Shelf-accessory placement UX. `cellBoxes` = current click-a-box-to-place. `autoPlaceDrag` =
+/** No catalog config → the viewer draws its default dimensions, no annotations. */
+var EMPTY_DIMENSION_CONFIGS = {};
+
+/**
+ * Per-article 2D dimension/annotation config: the catalog-level DIMENSION_CONFIG meta tag
+ * (ONE dictionary keyed by articleCodex, JSON). Absent → no per-article overrides. Entries are consumed structurally — the tag's JSON mirrors
+ * {@link ArticleDimensionMeta}.
+ */
+function getDimensionConfigs(viewHandler) {
+  var _viewHandler$divaWebP, _ref;
+  var fromCatalog = (_viewHandler$divaWebP = viewHandler.divaWebPlanner.getCatalogData()) === null || _viewHandler$divaWebP === void 0 ? void 0 : _viewHandler$divaWebP.dimensionConfig2D;
+  return (_ref = fromCatalog) !== null && _ref !== void 0 ? _ref : EMPTY_DIMENSION_CONFIGS;
+}
+
+/**
+ * Resolves `{...}` placeholders in a dimension-config label via the article template engine
+ * (`convertTemplateToCodex`, same syntax as supplierOrderCodex templates) — e.g.
+ * `widthPrefix: '{2300.vCodex}x'` → "6x".
+ */
+function resolveOptionPlaceholders(viewHandler, basketId, text) {
+  var _viewHandler$divaWebP2;
+  if (!text || !text.includes('{')) return text;
+  return (_viewHandler$divaWebP2 = viewHandler.divaWebPlanner.convertTemplateToCodex(basketId, text)) !== null && _viewHandler$divaWebP2 !== void 0 ? _viewHandler$divaWebP2 : text;
+}
+
+/**
+ * Translates the planner's `plannedElementsDict` into the viewer's 2D scene. `isPoolPlanning` is
+ * reported alongside it because it falls out of the same per-element dimension-config lookup: a
+ * planning whose articles carry a dimension config is a static drawing (pool plan).
+ */
+function buildScene2D(viewHandler) {
+  var _viewHandler$divaWebP3;
+  var fontUrl = (_viewHandler$divaWebP3 = viewHandler.divaWebPlanner.getCatalogData()) === null || _viewHandler$divaWebP3 === void 0 ? void 0 : _viewHandler$divaWebP3.plan2DFontUrl;
+  var dict = viewHandler.viewPlannerHandler.plannedElementsDict;
+  if (!dict || dict.size === 0) return {
+    isPoolPlanning: false
+  };
+  var dimConfigs = getDimensionConfigs(viewHandler);
+  var isPoolPlanning = false;
+  var elements = [];
+  var minX = Infinity,
+    minZ = Infinity,
+    maxX = -Infinity,
+    maxZ = -Infinity;
+  dict.forEach(function (plannerElements, setId) {
+    var _iterator = _createForOfIteratorHelper(plannerElements),
+      _step;
+    try {
+      var _loop = function _loop() {
+        var _pe$getGlobalWidth, _pe$getGlobalDepth, _dimMeta$annotations, _dimMeta$zLayer;
+        var pe = _step.value;
+        var center = pe.getWorldPosCenter();
+        // getSVGData() is the full OLF SVG and getGlobalWidth()/Depth() (ignoreOLF=false) are the OLF
+        // footprint size, so the plane is OLF-sized. getWorldPosCenter() is the OLF centre (see
+        // PlannerElementData.getWorldPosCornerOLF), so the plane sits on `position` directly — no pivot
+        // offset. Using the OLT size here (oltW/2 - w/2) mis-placed elements whose OLF differs from their
+        // OLT (e.g. a sofa's leg extension). The old real-time-viewer likewise centred the OLF shape on
+        // worldPosCenter with no OLT offset (Planner2DGrid.updatePlannerView).
+        var w = (_pe$getGlobalWidth = pe.getGlobalWidth()) !== null && _pe$getGlobalWidth !== void 0 ? _pe$getGlobalWidth : 0;
+        var d = (_pe$getGlobalDepth = pe.getGlobalDepth()) !== null && _pe$getGlobalDepth !== void 0 ? _pe$getGlobalDepth : 0;
+        var svgRaw = pe.getSVGData();
+        var h = pe.getHeightOLT();
+
+        // Accessory docking-point buttons. `LocalWorldPos` is OLF-corner-relative (cm) and the corner
+        // sits at the element centre + (-w/2, -d/2) in the unrotated frame, so the offset from the centre
+        // is `LocalWorldPos - (w/2, d/2)`. The viewer rotates it with the element. Skip a docked point on
+        // an element that is itself a docked accessory (mirrors Planner2DGrid.addDPUI).
+        var isDockedAcc = pe.getIsDockedAccessoire();
+        var dockingButtons = [];
+        var dockingPointsDebug = [];
+        var _iterator2 = _createForOfIteratorHelper(pe.getAllDockingPoints()),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var dp = _step2.value;
+            dockingPointsDebug.push({
+              dpId: dp.DpId,
+              type: dp.Type,
+              localOffset: [dp.LocalWorldPos.x - w / 2, dp.LocalWorldPos.z - d / 2],
+              rotDeg: dp.RotDeg,
+              isDocking: dp.IsDocking,
+              onElementId: dp.OnElementId,
+              number: dp.HasNumber ? dp.Number : undefined
+            });
+            if (!ACC_DP_TYPES.has(dp.Type)) continue;
+            if (dp.IsDocking && isDockedAcc) continue;
+            dockingButtons.push({
+              dpId: dp.DpId,
+              localOffset: [dp.LocalWorldPos.x - w / 2, dp.LocalWorldPos.z - d / 2],
+              iconRotDeg: dp.RotDeg,
+              isDocking: dp.IsDocking,
+              onElementId: dp.OnElementId
+            });
+          }
+
+          // OLT/OLF outlines for the analyzer's "Analyze OLT/OLF" overlay: the planner's world-space
+          // polygons (the exact geometry collision/placement uses) mapped back into the element-local
+          // unrotated frame around `center` — the inverse of Vector2.rotateOrigin(+RotDeg) + corner offset.
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        var rotRad = pe.getRotDeg() * Math.PI / 180;
+        var rotCos = Math.cos(rotRad);
+        var rotSin = Math.sin(rotRad);
+        var toLocalOutline = function toLocalOutline(poly) {
+          return poly.map(function (p) {
+            var dx = p.x - center.x;
+            var dz = p.y - center.z;
+            return [dx * rotCos + dz * rotSin, -dx * rotSin + dz * rotCos];
+          });
+        };
+        var oltWorld = pe.getOLTPolygonWorldPos();
+        var olfWorld = pe.getOLFPolygonWorldPos();
+        var outlinesDebug = oltWorld.length > 0 || olfWorld.length > 0 ? _objectSpread(_objectSpread({}, oltWorld.length > 0 ? {
+          olt: toLocalOutline(oltWorld)
+        } : {}), olfWorld.length > 0 ? {
+          olf: toLocalOutline(olfWorld)
+        } : {}) : undefined;
+        var dimMeta = dimConfigs[pe.ArticleCodex];
+        if (dimMeta != null) isPoolPlanning = true;
+
+        // Option-driven label texts: `{optionCodex}` placeholders in prefixes/postfixes and
+        // annotation texts resolve against the element's article options.
+        var resolveText = function resolveText(t) {
+          return resolveOptionPlaceholders(viewHandler, pe.getBasketId(), t);
+        };
+        var rawCfg = dimMeta === null || dimMeta === void 0 ? void 0 : dimMeta.dimensionConfig;
+        var dimensionConfig = rawCfg && [rawCfg.widthPrefix, rawCfg.widthPostfix, rawCfg.depthPrefix, rawCfg.depthPostfix].some(function (t) {
+          return t === null || t === void 0 ? void 0 : t.includes('{');
+        }) ? _objectSpread(_objectSpread({}, rawCfg), {}, {
+          widthPrefix: resolveText(rawCfg.widthPrefix),
+          widthPostfix: resolveText(rawCfg.widthPostfix),
+          depthPrefix: resolveText(rawCfg.depthPrefix),
+          depthPostfix: resolveText(rawCfg.depthPostfix)
+        }) : rawCfg;
+        var annotations = dimMeta !== null && dimMeta !== void 0 && (_dimMeta$annotations = dimMeta.annotations) !== null && _dimMeta$annotations !== void 0 && _dimMeta$annotations.some(function (a) {
+          return a.text.includes('{');
+        }) ? dimMeta.annotations.map(function (a) {
+          var _resolveText;
+          return _objectSpread(_objectSpread({}, a), {}, {
+            text: (_resolveText = resolveText(a.text)) !== null && _resolveText !== void 0 ? _resolveText : a.text
+          });
+        }) : dimMeta === null || dimMeta === void 0 ? void 0 : dimMeta.annotations;
+        elements.push({
+          name: "Element".concat(pe.getElementId()),
+          setId: setId,
+          elementId: pe.getElementId(),
+          position: [center.x, center.z],
+          pivotOffset: [0, 0],
+          rotation: pe.getRotDeg(),
+          width: w,
+          depth: d,
+          svgDataUrl: svgRaw ? "data:image/svg+xml;base64,".concat(btoa(unescape(encodeURIComponent(svgRaw)))) : undefined,
+          height: h > 0 ? h : undefined,
+          dockingButtons: dockingButtons.length > 0 ? dockingButtons : undefined,
+          dockingPointsDebug: dockingPointsDebug.length > 0 ? dockingPointsDebug : undefined,
+          outlinesDebug: outlinesDebug,
+          zLayer: (_dimMeta$zLayer = dimMeta === null || dimMeta === void 0 ? void 0 : dimMeta.zLayer) !== null && _dimMeta$zLayer !== void 0 ? _dimMeta$zLayer : pe.getLayer(),
+          opacity: dimMeta === null || dimMeta === void 0 ? void 0 : dimMeta.opacity,
+          dimensionConfig: dimensionConfig,
+          annotations: annotations
+        });
+        var halfW = w / 2;
+        var halfD = d / 2;
+        minX = Math.min(minX, center.x - halfW);
+        maxX = Math.max(maxX, center.x + halfW);
+        minZ = Math.min(minZ, center.z - halfD);
+        maxZ = Math.max(maxZ, center.z + halfD);
+      };
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        _loop();
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  });
+  if (elements.length === 0) return {
+    isPoolPlanning: isPoolPlanning
+  };
+  var dockingGroups = buildDockingGroups(dict);
+  return {
+    scene2d: _objectSpread(_objectSpread({
+      elements: elements,
+      boundingBox: {
+        x: (minX + maxX) / 2,
+        z: (minZ + maxZ) / 2,
+        width: maxX - minX,
+        depth: maxZ - minZ
+      }
+    }, fontUrl ? {
+      fontUrl: fontUrl
+    } : {}), dockingGroups.length > 0 ? {
+      dockingGroups: dockingGroups
+    } : {}),
+    isPoolPlanning: isPoolPlanning
+  };
+}
+
+/** Union-find on docking points to discover connected element groups. */
+function buildDockingGroups(dict) {
+  var parent = new Map();
+  function find(x) {
+    var root = x;
+    while (parent.get(root) !== root) root = parent.get(root);
+    var cur = x;
+    while (cur !== root) {
+      var next = parent.get(cur);
+      parent.set(cur, root);
+      cur = next;
+    }
+    return root;
+  }
+  function union(a, b) {
+    var ra = find(a);
+    var rb = find(b);
+    if (ra !== rb) parent.set(ra, rb);
+  }
+  dict.forEach(function (plannerElements) {
+    var _iterator3 = _createForOfIteratorHelper(plannerElements),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var pe = _step3.value;
+        var elId = pe.getElementId();
+        if (!parent.has(elId)) parent.set(elId, elId);
+        var _iterator4 = _createForOfIteratorHelper(pe.getDockingPoints()),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var dp = _step4.value;
+            if (dp.IsDocking && dp.OnElementId != null) {
+              var targetId = dp.OnElementId;
+              if (!parent.has(targetId)) parent.set(targetId, targetId);
+              union(elId, targetId);
+            }
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+  });
+  var groups = new Map();
+  var _iterator5 = _createForOfIteratorHelper(parent.keys()),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var id = _step5.value;
+      var root = find(id);
+      var group = groups.get(root);
+      if (!group) {
+        group = [];
+        groups.set(root, group);
+      }
+      group.push(id);
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  return _toConsumableArray(groups.values()).filter(function (g) {
+    return g.length > 1;
+  });
+}
+
+/**
+ * Phase 6 plumbing: build per-element overlay info from `plannedElementsDict`
+ * + `articleInfos`. The "selected" overlay state is sourced from
+ * `productState.rtvSelectedElementId` (planner truth) — `articleInfos.isActive`
+ * is only consulted for `posNr` / `canDelete` metadata so that a configurator
+ * lag after canvas deselect does not paint a deselected element as selected.
+ */
+function buildElementsInfoFromArticles(viewHandler) {
+  var _viewHandler$tabGroup, _viewHandler$divaWebP4, _viewHandler$tabGroup3;
+  // Keyed by the composite element key (`shelfElementId`): `"2"` for mains, `"2.0.6"` for
+  // accessories — matches what rtv-next parses from the 3D node name.
+  var map = new Map();
+  var articleInfos = viewHandler.settingsState.articleInfos;
+  var dict = viewHandler.viewPlannerHandler.plannedElementsDict;
+  var selectedElementId = viewHandler.productState.rtvSelectedElementId;
+  // In the shelf-planner step planning targets ALL corpora, so no main article is pickable (the
+  // corpus is navigated context → `active`: no hover, click is a no-op) and the shelf accessories
+  // are the only selectable things. Outside the step a shelf accessory is only pickable when the
+  // current configStep makes it configurable (`article.isActive`); otherwise it's inert and clicks/
+  // hover fall through to the parent corpus (`unselectable` → walk-to-ancestor in rtv-next).
+  var isShelfStep = ((_viewHandler$tabGroup = viewHandler.tabGroupState.curTabGroup) === null || _viewHandler$tabGroup === void 0 ? void 0 : _viewHandler$tabGroup.type) === 'SHELFPLANNER';
+
+  // AVL/AVR element copy (catalog property ELEMENT_COPY_AVLR): copy buttons on the selected
+  // standard-planner element that plan a copy docked at its free AVL/AVR docking point. `true`
+  // enables them in planner steps; a list of option codexes additionally enables them while one
+  // of those option steps is visited (the configurator-selected element is the copy source).
+  var inPlannerStep = function (_viewHandler$tabGroup2) {
+    var t = (_viewHandler$tabGroup2 = viewHandler.tabGroupState.curTabGroup) === null || _viewHandler$tabGroup2 === void 0 ? void 0 : _viewHandler$tabGroup2.type;
+    return t != null && PLANNER_TAB_GROUP_TYPES.has(t);
+  }();
+  var copyAVLRCfg = (_viewHandler$divaWebP4 = viewHandler.divaWebPlanner.getCatalogData()) === null || _viewHandler$divaWebP4 === void 0 ? void 0 : _viewHandler$divaWebP4.elementCopyAVLR;
+  var curOptionCodex = (_viewHandler$tabGroup3 = viewHandler.tabGroupState.curOption) === null || _viewHandler$tabGroup3 === void 0 ? void 0 : _viewHandler$tabGroup3.codex;
+  var avlrCopyEnabled = copyAVLRCfg != null && (inPlannerStep || Array.isArray(copyAVLRCfg) && curOptionCodex != null && copyAVLRCfg.includes(curOptionCodex));
+
+  // State for a single article entry, applying the step-aware accessory/corpus gating above.
+  // Accessory selection is NOT tracked by the numeric `selectedElementId` (rtv-next drives the
+  // accessory outline locally + via `selectedAccessoryKey`), so only mains resolve to `selected`.
+  var resolveState = function resolveState(elementId, isActive, isShelfAccessoire) {
+    if (isShelfAccessoire) {
+      if (isShelfStep) return 'selectable';
+      return isActive ? 'selectable' : 'unselectable';
+    }
+    // Main / corpus: never hover- or select-able while planning all corpora in the shelf step.
+    if (isShelfStep) return 'active';
+    if (elementId !== undefined && selectedElementId === elementId) return 'selected';
+    return isActive ? 'active' : 'selectable';
+  };
+  var articleByElementId = new Map();
+  for (var _i = 0, _Object$keys = Object.keys(articleInfos); _i < _Object$keys.length; _i++) {
+    var key = _Object$keys[_i];
+    var a = articleInfos[key];
+    if (a.elementId !== undefined) {
+      articleByElementId.set(a.elementId, {
+        setId: a.setId,
+        posNr: String(a.posNr),
+        isActive: a.isActive,
+        canDelete: a.isActive,
+        isShelfAccessoire: !!a.isShelfAccessoire,
+        shelfElementId: a.shelfElementId
+      });
+    }
+  }
+  if (dict) {
+    dict.forEach(function (plannerElements, setId) {
+      var _iterator6 = _createForOfIteratorHelper(plannerElements),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var _article$shelfElement, _article$setId, _article$canDelete;
+          var pe = _step6.value;
+          var elementId = pe.getElementId();
+          var parentElementId = pe.getParentElementId();
+          var article = articleByElementId.get(elementId);
+          var isBox = pe.getPlannerType() === 'BOX';
+          var canCopyLeft = void 0;
+          var canCopyRight = void 0;
+          var canCopyTop = void 0;
+          var copyAlwaysVisible = void 0;
+          if (isBox) {
+            // Not step-gated: box catalogs hide the planner step entirely, so box planning happens via
+            // these buttons during option steps. The viewer shows them on the selected element only.
+            canCopyLeft = true;
+            canCopyRight = true;
+            var avoDP = pe.getFreeDockingPointByTypeAndNumber('AVO', 1);
+            canCopyTop = avoDP != null && !avoDP.IsDisabled;
+          } else if (avlrCopyEnabled && parentElementId == null && !(article !== null && article !== void 0 && article.isShelfAccessoire)) {
+            canCopyLeft = pe.getFreeDockingPointsByType('AVL').some(function (dp) {
+              return !dp.IsDisabled;
+            });
+            canCopyRight = pe.getFreeDockingPointsByType('AVR').some(function (dp) {
+              return !dp.IsDisabled;
+            });
+            copyAlwaysVisible = true;
+          }
+
+          // `isActive` is computed per-context by the logic layer (loadPaletteInfos) and is exactly
+          // what drives the planner header's active badges: planner mode → none active (all selectable);
+          // shelf mode → the navigated main group is active; configStep → the current choice is active,
+          // alternatives are selectable. `resolveState` layers the step-aware accessory/corpus gating
+          // on top (see its definition above).
+          var state = !article ? 'unselectable' : resolveState(elementId, article.isActive, !!article.isShelfAccessoire);
+
+          // Element-type taxonomy. `isShelfAccessoire` comes from articleInfos (logic layer); box/
+          // accessoire are detectable from the planner element.
+          var type = article !== null && article !== void 0 && article.isShelfAccessoire ? 'shelfAccessoire' : isBox ? 'boxElement' : parentElementId != null ? 'accessoire' : 'planned';
+          map.set((_article$shelfElement = article === null || article === void 0 ? void 0 : article.shelfElementId) !== null && _article$shelfElement !== void 0 ? _article$shelfElement : String(elementId), {
+            setId: (_article$setId = article === null || article === void 0 ? void 0 : article.setId) !== null && _article$setId !== void 0 ? _article$setId : setId,
+            posNr: article === null || article === void 0 ? void 0 : article.posNr,
+            state: state,
+            type: type,
+            articleCodex: pe.ArticleCodex,
+            // Shelf accessories are deletable; an AVL/AVR-copy element (ELEMENT_COPY_AVLR) is a planned
+            // main you can copy right there, so it's deletable too. All other mains keep the
+            // active/selectable canDelete signal.
+            canDelete: article !== null && article !== void 0 && article.isShelfAccessoire || copyAlwaysVisible ? true : (_article$canDelete = article === null || article === void 0 ? void 0 : article.canDelete) !== null && _article$canDelete !== void 0 ? _article$canDelete : false,
+            parentElementId: parentElementId,
+            canCopyLeft: canCopyLeft,
+            canCopyRight: canCopyRight,
+            canCopyTop: canCopyTop,
+            copyAlwaysVisible: copyAlwaysVisible
+          });
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+    });
+  }
+
+  // Shelf accessories that aren't planner elements (absent from plannedElementsDict) still need an
+  // overlay entry — add them straight from articleInfos, keyed by their composite `shelfElementId`
+  // (e.g. "2.0.6"), which is what rtv-next parses from the accessory's node name. Their selectability
+  // is step-gated identically to the dict path (`resolveState`).
+  for (var _i2 = 0, _Object$keys2 = Object.keys(articleInfos); _i2 < _Object$keys2.length; _i2++) {
+    var _key = _Object$keys2[_i2];
+    var _a = articleInfos[_key];
+    if (!_a.isShelfAccessoire || !_a.shelfElementId || map.has(_a.shelfElementId)) continue;
+    map.set(_a.shelfElementId, {
+      setId: _a.setId,
+      posNr: String(_a.posNr),
+      state: resolveState(_a.elementId, _a.isActive, true),
+      type: 'shelfAccessoire',
+      canDelete: true
+    });
+  }
+  return map;
+}
+
+/**
+ * Resolve an accessory's composite ref (parent/grid/cell, recursion-safe) to the basket ids the
+ * paletteViewHandler needs: the parent shelf basket (for delete) and the accessory's own basket +
+ * codex (for select). Looks up `plannedPlacesOnGrids` by the parent element key + grid idx + cell.
+ */
+function resolveAccessoryTargets(viewHandler, ref) {
+  var _viewHandler$settings;
+  // `plannedPlacesOnGrids[].elementId` is the `E`-prefixed form ("E1"); the composite key from
+  // `shelfElementId`/`parseElementKey` is the bare form ("1"). Strip the leading `E` to match.
+  var parent = (_viewHandler$settings = viewHandler.settingsState.plannedPlacesOnGrids) === null || _viewHandler$settings === void 0 ? void 0 : _viewHandler$settings.find(function (p) {
+    var _p$elementId;
+    return ((_p$elementId = p.elementId) !== null && _p$elementId !== void 0 ? _p$elementId : '').replace(/^E/, '') === ref.parentElementKey;
+  });
+  if (!parent) return null;
+  var accBasketId;
+  var accCodex;
+  var gridName;
+  for (var _i3 = 0, _Object$keys3 = Object.keys(parent.grids); _i3 < _Object$keys3.length; _i3++) {
+    var name = _Object$keys3[_i3];
+    var g = parent.grids[name];
+    if (g.idx !== ref.gridId) continue;
+    gridName = name;
+    var acc = g.accessories.find(function (a) {
+      return a.index === ref.cellIdx;
+    });
+    if (acc) {
+      accBasketId = acc.basketId;
+      accCodex = acc.articleCodex;
+      break;
+    }
+  }
+  return {
+    parentBasketId: parent.basketId,
+    accBasketId: accBasketId,
+    accCodex: accCodex,
+    gridName: gridName
+  };
+}
+var PlannerRTVNext = function PlannerRTVNext() {
+  var _scene$isPoolPlanning, _ref2, _viewHandler$divaWebP5, _viewHandler$tabGroup4, _Object$values$find$s, _Object$values$find, _elementsInfo$get;
+  var viewHandler = useViewHandler();
+  var rtvAnalyzerComponents = useRTVAnalyzerComponentsFromPlanner();
+  var _useDivaCore = useDivaCore(),
+    _useDivaCore$state = _useDivaCore.state,
+    apiConfig = _useDivaCore$state.apiConfig,
+    jwt = _useDivaCore$state.jwt,
+    actions = _useDivaCore.actions;
+
+  // Mount effect, not the render body: this is the first moment the viewer component exists in the
+  // tree, which is what the boot report needs — the props it reads are re-derived on every render.
+  useEffect(function () {
+    bootMark('rtv: PlannerRTVNext mounted');
+  }, []);
+
+  // A new render script means the viewer is about to rebuild its scene — show the loading state
+  // until `onSceneReady` reports the rebuilt scene as live.
+  var prevHQRenderScript = useRef(viewHandler.hqRenderScript);
+  useEffect(function () {
+    if (viewHandler.hqRenderScript !== prevHQRenderScript.current) {
+      prevHQRenderScript.current = viewHandler.hqRenderScript;
+      if (viewHandler.hqRenderScript) {
+        actions.toggleLoading('RTV_Assembling', false, true);
+      }
+    }
+  }, [viewHandler.hqRenderScript, actions]);
+  var callbacks = useMemo(function () {
+    return {
+      onElementSelected: function onElementSelected(setId, elementId) {
+        viewHandler.viewPlannerHandler.onElementSelected(setId, elementId);
+      },
+      onElementDeselected: function onElementDeselected() {
+        viewHandler.viewPlannerHandler.onClearElementSelection();
+      },
+      updatePlannerTrans: function updatePlannerTrans(setId, plannerElementID, deltaMove, deltaAngleDeg, rotCorrection, transState, autoDockingDistance, turningPoint) {
+        viewHandler.divaWebPlanner.updatePlannerTrans(setId, plannerElementID, {
+          x: deltaMove.x,
+          y: deltaMove.y,
+          z: deltaMove.z
+        }, deltaAngleDeg, rotCorrection, transState, autoDockingDistance, turningPoint);
+      },
+      getDockSnapPreview: function getDockSnapPreview(setId, plannerElementID, autoDockingDistance, excludeElementIds) {
+        return viewHandler.divaWebPlanner.getDockSnapPreview(plannerElementID, autoDockingDistance, excludeElementIds);
+      },
+      onElementDeleted: function onElementDeleted(setId, elementId) {
+        viewHandler.viewPlannerHandler.onElementDeleted(setId, elementId);
+      },
+      onElementCopy: function onElementCopy(setId, elementId, copyIndex) {
+        return viewHandler.viewPlannerHandler.onElementCopy(setId, elementId, copyIndex);
+      },
+      onDockingPointInteraction: function onDockingPointInteraction(setId, elementId, dpId, isSelected, onElementId) {
+        return viewHandler.viewPlannerHandler.onDockingPointInteraction(setId, elementId, dpId, isSelected, onElementId);
+      },
+      onAccessoryPlace: function onAccessoryPlace(gridIdx, cellIdx, parentBasketId, articleCodex) {
+        viewHandler.paletteViewHandler.addAccessorieOnShelfPlannerView(gridIdx, cellIdx, parentBasketId, articleCodex);
+      },
+      onAccessoryDragOver: function onAccessoryDragOver(hasTarget) {
+        viewHandler.settingsState.setDraggedAccessoryHasTarget(hasTarget);
+      },
+      onAccessorySelect: function onAccessorySelect(ref) {
+        var t = resolveAccessoryTargets(viewHandler, ref);
+        if (!t) return;
+        viewHandler.paletteViewHandler.selectShelfAccessorie(t.accCodex, t.accBasketId);
+      },
+      onAccessoryDeselect: function onAccessoryDeselect() {
+        viewHandler.paletteViewHandler.selectShelfAccessorie(undefined);
+      },
+      onAccessoryDelete: function onAccessoryDelete(ref) {
+        var t = resolveAccessoryTargets(viewHandler, ref);
+        if (!t) return;
+        viewHandler.paletteViewHandler.deleteAccessorieOnShelfPlannerView(ref.gridId, ref.cellIdx, t.parentBasketId);
+      },
+      onAccessoryMoveStart: function onAccessoryMoveStart(ref) {
+        // The accessory's free-to-move target cells (old RTV's getMoveGrids) — own cells PLUS its
+        // variant-family siblings' cells (`includeFamily`), so the viewer can offer differently-sized
+        // drop targets and switch the article on release. Async (family variants are instantiated).
+        var t = resolveAccessoryTargets(viewHandler, ref);
+        if (!t || !t.accBasketId || !t.gridName) return undefined;
+        return viewHandler.divaWebPlanner.getFreeToMovePlacesOnGrids(t.gridName, t.accBasketId, true);
+      },
+      onAccessoryMove: function onAccessoryMove(ref, target) {
+        // `target` carries the DESTINATION element's basket + grid + cell (may differ from the source
+        // element — cross-element move), so we only need the accessory's own basket from the ref.
+        var t = resolveAccessoryTargets(viewHandler, ref);
+        if (!t || !t.accBasketId) return;
+        // If the target cell expects a different variant-family member, switch the article on move.
+        var switchTo = target.articleCodex && target.articleCodex !== t.accCodex ? target.articleCodex : undefined;
+        viewHandler.divaWebPlanner.moveShelfItemToGrid(t.accBasketId, target.parentBasketId, target.gridName, target.cellIdx, switchTo);
+      },
+      onSceneReady: function onSceneReady() {
+        bootMark('rtv: onSceneReady');
+        actions.toggleLoading('RTV_Assembling', false, false);
+      }
+    };
+  }, [viewHandler.viewPlannerHandler, viewHandler.divaWebPlanner, viewHandler, actions]);
+
+  // Planner-side single source of truth for canvas selection. Tracks
+  // `selectedElementsDict` in ViewPlannerHandler — kept in sync at all 3
+  // selection entry points (canvas-side `onElementSelected` /
+  // `onClearElementSelection`, and configurator-driven
+  // `updateElementSelectionConfig` / `updateElementSelectionPlanner`).
+  // Previously derived from `articleInfos.isActive`, which lagged after a
+  // canvas deselect and caused `setSelectedElementFromProp` to re-select
+  // the just-deselected element on the next render.
+  var selectedElementId = viewHandler.productState.rtvSelectedElementId;
+  var isVisible = viewHandler.isParentViewVisible;
+  // Announce the live rtv-next viewer page-wide: hidden sibling planner instances defer their
+  // whole boot while one is registered (see `ViewHandlerProvider`).
+  useEffect(function () {
+    if (!isVisible) return;
+    return registerRtvNextViewer();
+  }, [isVisible]);
+  var showRTV = viewHandler.productState.doShowRTV;
+  var show3DComb = viewHandler.productState.doShow3DComb;
+  var showGrid = viewHandler.productState.doShowGrid;
+  // Nothing is rendered in either case, so the planner→viewer translation is skipped: a hidden
+  // planner still re-renders on every MobX planner change and would otherwise walk the whole
+  // planned-elements dict and re-encode every element SVG for a viewer that is not mounted.
+  // CREATE_IMAGE never goes through the footer, so none of the view flags is ever set for it — the
+  // viewer must still mount, it *is* the capture source (see useCreateImageShot below).
+  var isCreateImage = viewHandler.configState.initMode === 'CREATE_IMAGE';
+  var isHidden = !isVisible || !showRTV && !show3DComb && !showGrid && !isCreateImage;
+
+  // `isPoolPlanning`: a planning whose articles carry a dimension config is a static drawing (pool
+  // plan) — hide all on-canvas buttons (posNr/move/rotate/trash chrome and docking-point buttons,
+  // both gated on `hideUiIcons` inside rtv-next) and force the dimension lines on.
+  var scene = isHidden ? undefined : buildScene2D(viewHandler);
+  var scene2d = scene === null || scene === void 0 ? void 0 : scene.scene2d;
+  var isPoolPlanning = (_scene$isPoolPlanning = scene === null || scene === void 0 ? void 0 : scene.isPoolPlanning) !== null && _scene$isPoolPlanning !== void 0 ? _scene$isPoolPlanning : false;
+
+  // Environment preset: the catalog-level RTV_PRESET meta tag when present (a DB source
+  // later), else the white-room default. Both are parse-once/module objects, so the
+  // identity is stable across renders. NOTE: with ?rtv-debug the analyzer preset channel
+  // applies AFTER this on mount and wins (use ?preset=<id> there to pick explicitly).
+  var rtvPreset = (_ref2 = (_viewHandler$divaWebP5 = viewHandler.divaWebPlanner.getCatalogData()) === null || _viewHandler$divaWebP5 === void 0 ? void 0 : _viewHandler$divaWebP5.rtvPreset) !== null && _ref2 !== void 0 ? _ref2 : WHITE_ROOM_PRESET;
+
+  // initMode CREATE_IMAGE: auto-capture the settled 2D plan and emit it to the host. A hook, so it
+  // has to stay above the guard below — it is inert without a scene, and while the planner renders
+  // nothing there is no mounted viewer to capture from anyway.
+  useCreateImageShot(viewHandler, scene2d, rtvPreset);
+  if (isHidden) return null;
+  var viewMode = showGrid || isCreateImage ? '2d' : '3d';
+  var curTabGroupType = (_viewHandler$tabGroup4 = viewHandler.tabGroupState.curTabGroup) === null || _viewHandler$tabGroup4 === void 0 ? void 0 : _viewHandler$tabGroup4.type;
+  var plannerMode = curTabGroupType != null && PLANNER_TAB_GROUP_TYPES.has(curTabGroupType);
+  var focusElementId = viewHandler.productState.rtvFocusElementId;
+  // Pool plannings are static drawings: dimension lines are always on (the UI toggle that
+  // would enable them is hidden along with the other buttons — see isPoolPlanning above).
+  var showDimensionLines = isPoolPlanning || viewHandler.productState.doShow3DDimensionLines;
+  var elementsInfo = buildElementsInfoFromArticles(viewHandler);
+
+  // Controlled accessory selection: map the host's selected shelf accessory (a basketId) to its
+  // composite 3D key ("2.0.6") so the canvas re-selects it after a place/move. `null` clears it.
+  var selectedAccessoryBasketId = viewHandler.settingsState.selectedShelfAccessoire;
+  var resolvedAccessoryKey = selectedAccessoryBasketId ? (_Object$values$find$s = (_Object$values$find = Object.values(viewHandler.settingsState.articleInfos).find(function (a) {
+    return a.basketId === selectedAccessoryBasketId;
+  })) === null || _Object$values$find === void 0 ? void 0 : _Object$values$find.shelfElementId) !== null && _Object$values$find$s !== void 0 ? _Object$values$find$s : null : null;
+  // `selectedShelfAccessoire` survives step navigation and config changes (it's only cleared by an
+  // explicit deselect), and rtv-next re-applies `selectedAccessoryKey` after every re-assembly — so
+  // a config change in a step where the accessory is not selectable would re-select it in the
+  // canvas. Gate the prop on the same step-aware overlay state that already gates clicks/hover.
+  var accessoryState = resolvedAccessoryKey ? (_elementsInfo$get = elementsInfo.get(resolvedAccessoryKey)) === null || _elementsInfo$get === void 0 ? void 0 : _elementsInfo$get.state : undefined;
+  var selectedAccessoryKey = resolvedAccessoryKey != null && accessoryState != null && accessoryState !== 'unselectable' ? resolvedAccessoryKey : null;
+
+  // In pure 2D / grid mode the viewer only needs scene2d — skip the 3D inputs so it never tries
+  // to fetch GLBs or accessory grid geometry for a view that shows neither.
+  var needs3D = viewMode !== '2d';
+  // The shelf-accessory grid geometry is fetched per catalog; the viewer falls back to this
+  // identity while nothing is placed yet to read it off (`plannedPlacesOnGrids` empty).
+  var catalogData = viewHandler.divaWebPlanner.getCatalogData();
+  var catalogInfo = catalogData !== null && catalogData !== void 0 && catalogData.catalogCodex ? {
+    catalogCodex: catalogData.catalogCodex,
+    iln: catalogData.supplierILN
+  } : undefined;
+  return /*#__PURE__*/jsx(RealTimeRendererNext, {
+    catalogInfo: needs3D ? catalogInfo : undefined,
+    hqRenderScript: needs3D ? viewHandler.hqRenderScript : undefined,
+    scene2d: scene2d,
+    viewMode: viewMode,
+    stopRender: !isVisible,
+    config: {
+      // Strip a trailing slash so downstream URL building (material blob paths, geo/texture URLs)
+      // doesn't emit `…/diva3darchiv//…` double slashes that the archive host may mis-route.
+      archiveBaseUrl: apiConfig.diva3darchive.endsWith('/') ? apiConfig.diva3darchive.slice(0, -1) : apiConfig.diva3darchive,
+      constructorServiceUrl: apiConfig.constructorService,
+      jwt: jwt,
+      // COBI-class planner: 3D is always available. The store default is
+      // already `{ supports3d: true }` but we pass it explicitly to make
+      // the contract obvious — flip to `false` to skip the geo preload and
+      // (once the lazy capsule lands) the entire 3D code chunk for a
+      // pure-2D catalog.
+      capabilities: {
+        supports3d: true
+      },
+      // Environment preset: catalog RTV_PRESET meta tag » white-room default (see
+      // `rtvPreset` above). With ?rtv-debug the analyzer preset channel overrides this.
+      profiles: rtvPreset.profiles,
+      profileMode: rtvPreset.profileMode,
+      camera: rtvPreset.camera,
+      uiConfig: _objectSpread({
+        plannerMode: viewHandler.productState.isBoxPlanner ? 'BoxPlanner' : '3DCOMB',
+        accessoryPlacement: ACCESSORY_PLACEMENT_MODE
+      }, isPoolPlanning ? {
+        hideUiIcons: true
+      } : {})
+    },
+    plannerMode: plannerMode,
+    freePlacesOnGrids: viewHandler.settingsState.freePlacesOnGrids,
+    plannedPlacesOnGrids: viewHandler.settingsState.plannedPlacesOnGrids,
+    armedAccessoryCodex: viewHandler.settingsState.armedAccessoryToken,
+    draggedAccessoryCodex: viewHandler.settingsState.draggedAccessoryCodex,
+    callbacks: callbacks,
+    analyzerComponents: rtvAnalyzerComponents,
+    focusElementId: focusElementId,
+    elementsInfo: elementsInfo,
+    selectedElementId: selectedElementId,
+    selectedAccessoryKey: selectedAccessoryKey,
+    showDimensionLines: showDimensionLines
+  });
+};
+var index = observer(PlannerRTVNext);
+
+export { index as default };