door_models 5.4.8 → 5.5.0

package/dist/index.cjs.js

@@ -0,0 +1,2813 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var THREE = require('three');
+var drei = require('@react-three/drei');
+var csg = require('@react-three/csg');
+var three = require('@react-spring/three');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var THREE__namespace = /*#__PURE__*/_interopNamespace(THREE);
+
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+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 _objectSpread2(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 _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+const doorSettings = {
+  NOF: {
+    topThk: "0mm",
+    sidesThk: "0mm",
+    frameDepth: 0
+  },
+  AF20_40: {
+    frameDepth: 103,
+    topThk: "20mm",
+    sidesThk: "20mm",
+    doorStopOffset: "42mm",
+    doorStopWidth: 20,
+    doorStopDepth: 13,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5,
+    doorDepth: 40
+  },
+  AF20_50: {
+    doorDepth: 50,
+    frameDepth: 103,
+    topThk: "20mm",
+    sidesThk: "20mm",
+    doorStopOffset: "30mm",
+    doorStopWidth: 20,
+    doorStopDepth: 13,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5
+  },
+  AF40_40: {
+    frameDepth: 103,
+    topThk: "40mm",
+    sidesThk: "40mm",
+    doorStopOffset: "42mm",
+    doorStopWidth: 20,
+    doorStopDepth: 13,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5,
+    doorDepth: 40
+  },
+  AF40_50: {
+    doorDepth: 50,
+    frameDepth: 103,
+    topThk: "40mm",
+    sidesThk: "40mm",
+    doorStopOffset: "30mm",
+    doorStopWidth: 20,
+    doorStopDepth: 13,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5
+  },
+  WF_40: {
+    doorDepth: 39.6,
+    frameDepth: 103,
+    topThk: "31.6mm",
+    sidesThk: "31.6mm",
+    doorStopOffset: "0mm",
+    doorStopWidth: 16.4,
+    doorStopDepth: 58.4,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5
+  },
+  WF_50: {
+    doorDepth: 51.6,
+    frameDepth: 103,
+    topThk: "31.6mm",
+    sidesThk: "31.6mm",
+    doorStopOffset: "0mm",
+    doorStopWidth: 16,
+    doorStopDepth: 46.4,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5
+  },
+  WF_100: {
+    doorDepth: 102,
+    frameDepth: 102,
+    topThk: "52mm",
+    sidesThk: "52mm",
+    doorStopOffset: "17.6mm",
+    doorStopWidth: 16.4,
+    doorStopDepth: 44.8,
+    notchWidth: "16mm",
+    notchDepth: "66.5mm",
+    notchposition: 0.02,
+    gasketDepth: 5,
+    gasketWidth: 5,
+    secondDoorStopWidth: 29,
+    secondDoorStopDepth: 17.6,
+    secondDoorStopOffset: 0
+  },
+  WF_FLI: {
+    doorDepth: 51,
+    frameDepth: 102,
+    topThk: "52mm",
+    sidesThk: "52mm",
+    doorStopOffset: "17.4mm",
+    doorStopWidth: 16.4,
+    doorStopDepth: 34,
+    notchWidth: "14mm",
+    notchDepth: "66mm",
+    notchposition: 0.02,
+    gasketDepth: 5,
+    gasketWidth: 5,
+    secondDoorStopWidth: 29,
+    secondDoorStopDepth: 17.6,
+    secondDoorStopOffset: 0
+  },
+  WDGF_WDG100: {
+    doorDepth: 86,
+    frameDepth: 86,
+    topThk: "50mm",
+    sidesThk: "50mm",
+    doorStopOffset: "34mm",
+    doorStopWidth: 13,
+    doorStopDepth: 30,
+    notchWidth: "14mm",
+    notchDepth: "66mm",
+    notchposition: 0.02,
+    gasketDepth: 4.5,
+    gasketWidth: 5,
+    secondDoorStopWidth: 23,
+    secondDoorStopDepth: 30,
+    secondDoorStopOffset: 13
+  },
+  MXF_40: {
+    doorDepth: 38,
+    frameDepth: 103,
+    topThk: "18mm",
+    sidesThk: "18mm",
+    doorStopOffset: "45mm",
+    doorStopWidth: 15,
+    doorStopDepth: 15,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5
+  },
+  MXF_50: {
+    doorDepth: 50,
+    frameDepth: 103,
+    topThk: "18.2mm",
+    sidesThk: "18.2mm",
+    doorStopOffset: "33mm",
+    doorStopWidth: 15,
+    doorStopDepth: 15,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5
+  },
+  MXCAF_40: {
+    doorDepth: 38,
+    frameDepth: 103,
+    topThk: "18mm",
+    sidesThk: "18mm",
+    doorStopOffset: "45mm",
+    doorStopWidth: 15,
+    doorStopDepth: 15,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5
+  },
+  MXCAF_50: {
+    doorDepth: 50,
+    frameDepth: 103,
+    topThk: "18.2mm",
+    sidesThk: "18.2mm",
+    doorStopOffset: "33mm",
+    doorStopWidth: 15,
+    doorStopDepth: 15,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5
+  }
+};
+
+const _excluded = ["doorDepth"];
+const ConfiguratorContext = /*#__PURE__*/React.createContext(undefined);
+const ConfiguratorProvider = _ref => {
+  let {
+    children,
+    initialIs2D = false,
+    initialMaterials = {}
+  } = _ref;
+  const [materials, setMaterials] = React.useState(initialMaterials);
+  const [is2D, setIs2D] = React.useState(initialIs2D);
+  const [isPlaneVisible, setIsPlaneVisible] = React.useState(false);
+  const [isFrameVisible, setIsFrameVisible] = React.useState(true);
+  const [cpid, setCpid] = React.useState("");
+  const [totalHeight, setTotalHeight] = React.useState(2700);
+  const [totalWidth, setTotalWidth] = React.useState(974);
+  const [totalDepth, setTotalDepth] = React.useState(103);
+  const [glassVisible, setGlassVisible] = React.useState(false);
+  const [glassDepth, setGlassDepth] = React.useState(8);
+  const [isDoubleDoor, setIsDoubleDoor] = React.useState(false);
+  const [door, setDoor] = React.useState({
+    doorMaterial: "door_material",
+    doorWidth: 0,
+    doorHeight: 0,
+    theDoorDepth: 40,
+    doorPivot: "left",
+    doorOpening: "out"
+  });
+  const [doorFrame, setDoorFrame] = React.useState({
+    frameMaterial: "doorFrame_material",
+    doorStopMaterial: "doorStop_material",
+    gasketMaterial: "gasket_material",
+    hingeMaterial: "hinge_material",
+    glassMaterial: "glass_material",
+    frameDepth: 103,
+    topThk: "20mm",
+    sidesThk: "20mm",
+    doorStopOffset: "30mm",
+    doorStopWidth: 20,
+    doorStopDepth: 13,
+    notchWidth: "20mm",
+    notchDepth: "40mm",
+    notchposition: 0.01,
+    gasketDepth: 5,
+    gasketWidth: 5,
+    secondDoorStopWidth: 20,
+    secondDoorStopDepth: 30,
+    secondDoorStopOffset: 13
+  });
+  const [interiorFanlight, setInteriorFanlight] = React.useState({
+    visible: false,
+    height: 300,
+    material: "interiorFanlight_material"
+  });
+  const [exteriorFanlight, setExteriorFanlight] = React.useState({
+    visible: false,
+    height: 300,
+    depth: 60,
+    material: "exteriorFanlight_material"
+  });
+  const [occulus, setOcculus] = React.useState({
+    visible: false,
+    infillVisible: true,
+    x1: 150,
+    x2: 150,
+    y1: 150,
+    y2: 150,
+    material: "infill_material",
+    depth: 20
+  });
+  const [frontCoverPanel, setFrontCoverPanel] = React.useState({
+    visible: false,
+    width: 73,
+    height: 2200,
+    depth: 12,
+    material: "front_cover_material"
+  });
+  const [backCoverPanel, setBackCoverPanel] = React.useState({
+    visible: false,
+    width: 73,
+    height: 2200,
+    depth: 12,
+    material: "back_cover_material"
+  });
+  const [frontDoorPlane, setFrontDoorPlane] = React.useState({
+    visible: true,
+    material: "frontDoor_material"
+  });
+  const [backDoorPlane, setBackDoorPlane] = React.useState({
+    visible: true,
+    material: "frontDoor_material"
+  });
+  const [glass, setGlass] = React.useState({
+    visible: false,
+    material: "infill_material",
+    depth: 20
+  });
+  const [baseConfig, setBaseConfig] = React.useState(null);
+  const [frameType, setFrameType] = React.useState("AF20_40");
+  const [bodyType, setBodyType] = React.useState("40");
+  const [exteriorFanlightType, setExteriorFanlightType] = React.useState("WPFL");
+  const doorHeight = 0;
+  const [newPivotPosition, setNewPivotPosition] = React.useState(0);
+  const [, setParseMessage] = React.useState({
+    type: "",
+    text: ""
+  });
+
+  // DXF Export state
+  const [exportDXF, setExportDXF] = React.useState(null);
+  const [collectElementsFromGroup, setCollectElementsFromGroup] = React.useState(null);
+  React.useEffect(() => {
+    setIs2D(initialIs2D);
+  }, [initialIs2D]);
+  React.useEffect(() => {
+    if (initialMaterials) {
+      setMaterials(initialMaterials);
+    }
+  }, [initialMaterials]);
+  const handleParseCpid = React.useCallback(cpidToParse => {
+    const showMessage = function (text) {
+      let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "error";
+      setParseMessage({
+        text,
+        type
+      });
+      setTimeout(() => setParseMessage({
+        text: "",
+        type: ""
+      }), 4000);
+    };
+    if (!cpidToParse || !cpidToParse.trim().startsWith("P_")) {
+      showMessage("Invalid format: CPID must start with 'P_'.");
+      return;
+    }
+    const parts = cpidToParse.trim().split("_");
+    if (parts.length < 4) {
+      showMessage("Invalid format: Not enough parts in CPID.");
+      return;
+    }
+    const newConfig = {
+      fanlightVisible: false,
+      fanlightType: "WPFL",
+      interiorFanlightVisible: false,
+      occulusVisible: false,
+      frameType: "",
+      bodyType: ""
+    };
+    let currentIndex = 1;
+
+    //  Door Type
+    if (parts[currentIndex] === "SD") {
+      setIsDoubleDoor(false);
+      setTotalHeight(2700);
+      setTotalWidth(974);
+      currentIndex++;
+    } else if (parts[currentIndex] === "DD") {
+      setIsDoubleDoor(true);
+      setTotalWidth(1802);
+      currentIndex++;
+    } else {
+      showMessage("Unsupported Door Type: Only 'SD' or 'DD' is supported.");
+      return;
+    }
+
+    //Fanlight Type
+    const fanlightPart = parts[currentIndex];
+    const validFanlights = ["WPFL", "ALDGFL", "ALSGFL"];
+    if (fanlightPart === "FH") {
+      newConfig.fanlightVisible = false;
+      currentIndex++;
+    } else if (validFanlights.includes(fanlightPart)) {
+      setExteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+        height: 300
+      }));
+      newConfig.fanlightVisible = true;
+      newConfig.fanlightType = fanlightPart;
+      currentIndex++;
+    } else {
+      showMessage("Invalid Fanlight Type: '".concat(fanlightPart, "'."));
+      return;
+    }
+
+    //  Frame and Body Type
+    const validSimpleFrameTypes = ["AF20", "AF40", "WF", "MXF", "MXCAF", "NOF"];
+    const validBodyTypes = ["40", "50", "FLI", "100", "WDG100", "SG8", "SG10", "SG12"];
+    let framePart = parts[currentIndex];
+    let bodyPartRaw = parts[currentIndex + 1] || "";
+    let frameFound = false;
+    if ("".concat(framePart, "_").concat(bodyPartRaw) === "WDGF_WDG100") {
+      newConfig.frameType = "WDGF_WDG100";
+      newConfig.bodyType = "WDG100";
+      currentIndex += 2;
+      frameFound = true;
+    } else if (validSimpleFrameTypes.includes(framePart)) {
+      let tempBody = bodyPartRaw.replace("OCC", "");
+      if (validBodyTypes.includes(tempBody)) {
+        newConfig.frameType = framePart === "NOF" ? "NOF" : "".concat(framePart, "_").concat(tempBody);
+        newConfig.bodyType = tempBody;
+        if (bodyPartRaw.endsWith("OCC")) {
+          newConfig.occulusVisible = true;
+          setOcculus(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+            x1: 150,
+            x2: 150,
+            y1: 150,
+            y2: 150
+          }));
+        }
+        currentIndex += 2;
+        frameFound = true;
+      }
+    }
+    if (!frameFound) {
+      showMessage("Invalid Frame/Body combination starting with '".concat(framePart, "'."));
+      return;
+    }
+    for (let i = currentIndex; i < parts.length; i++) {
+      if (parts[i] === "IFL") {
+        setInteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+          height: 300
+        }));
+        newConfig.interiorFanlightVisible = true;
+      } else if (parts[i] === "OCC") {
+        newConfig.occulusVisible = true;
+      }
+    }
+
+    // Apply final configuration
+    setFrameType(newConfig.frameType);
+    setBodyType(newConfig.bodyType);
+    setExteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: newConfig.fanlightVisible
+    }));
+    if (newConfig.fanlightVisible) {
+      setExteriorFanlightType(newConfig.fanlightType);
+    }
+    setInteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: newConfig.interiorFanlightVisible
+    }));
+    setOcculus(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: newConfig.occulusVisible
+    }));
+    setCpid(cpidToParse);
+    showMessage("Configuration Applied!", "success");
+  }, [setCpid, setBodyType, setExteriorFanlight, setExteriorFanlightType, setFrameType, setInteriorFanlight, setOcculus, setIsDoubleDoor, setTotalWidth]);
+
+  // --- BodyType Effect ---
+  React.useEffect(() => {
+    let newDoorDepth = 40;
+    switch (bodyType) {
+      case "50":
+        newDoorDepth = 50;
+        break;
+      case "SG8":
+        newDoorDepth = 8;
+        break;
+      case "SG10":
+        newDoorDepth = 10;
+        break;
+      case "SG12":
+        newDoorDepth = 12;
+        break;
+    }
+    setDoor(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      theDoorDepth: newDoorDepth
+    }));
+  }, [bodyType]);
+
+  // --- FrameType Effect ---
+  React.useEffect(() => {
+    setIsFrameVisible(frameType !== "NOF");
+    setGlassVisible(false);
+    let newSettings = {};
+    let lookupKey = frameType;
+    if (frameType.startsWith("AF20_SG")) {
+      lookupKey = "AF20_40";
+    } else if (frameType.startsWith("AF40_SG")) {
+      lookupKey = "AF40_40";
+    }
+    if (doorSettings[lookupKey]) {
+      newSettings = _objectSpread2({}, doorSettings[lookupKey]);
+    }
+    if (lookupKey === "WDGF_WDG100") {
+      setGlassVisible(true);
+    }
+
+    // Store pristine settings for scaling
+    setBaseConfig(newSettings);
+    const isMxCaf = frameType.startsWith("MXCAF");
+    setFrontCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: isMxCaf
+    }));
+    setBackCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      visible: isMxCaf
+    }));
+    const {
+        doorDepth
+      } = newSettings,
+      newFrameSettings = _objectWithoutProperties(newSettings, _excluded);
+    setDoorFrame(prev => _objectSpread2(_objectSpread2({}, prev), newFrameSettings));
+    if (doorDepth !== undefined) {
+      setDoor(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+        theDoorDepth: doorDepth
+      }));
+    }
+
+    // Sync totalDepth with the frame's default depth when frame type changes.
+    if (newSettings.frameDepth) {
+      setTotalDepth(newSettings.frameDepth);
+    }
+  }, [frameType]);
+
+  // --- useEffect for scaling based on totalDepth ---
+  React.useEffect(() => {
+    if (!baseConfig || !baseConfig.frameDepth || baseConfig.frameDepth === 0) return;
+    const baseFrameDepth = baseConfig.frameDepth;
+    const ratio = totalDepth / baseFrameDepth;
+    const scaleProportionally = value => {
+      if (typeof value === "number") {
+        return value * ratio;
+      }
+      if (typeof value === "string" && value.endsWith("mm")) {
+        const num = parseFloat(value);
+        if (!isNaN(num)) {
+          return num * ratio + "mm";
+        }
+      }
+      return value; // Return original if not scalable
+    };
+    setDoorFrame(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      frameDepth: totalDepth,
+      doorStopDepth: scaleProportionally(baseConfig.doorStopDepth),
+      notchDepth: scaleProportionally(baseConfig.notchDepth),
+      gasketDepth: scaleProportionally(baseConfig.gasketDepth),
+      secondDoorStopDepth: scaleProportionally(baseConfig.secondDoorStopDepth)
+    }));
+    if (baseConfig.doorDepth !== undefined) {
+      const baseDoorDepth = baseConfig.doorDepth;
+      const frameDelta = totalDepth - baseFrameDepth;
+      let newDoorDepth;
+      if (frameDelta > 0) {
+        // --- THIS IS THE VALUE TO TWEAK ---
+        // Increase this multiplier to make the door body grow faster when totalDepth increases.
+        // A value of 1.0 means it grows at the same rate as the frame.
+        // A value of 2.0 means it grows twice as fast as the frame.
+        const increaseMultiplier = 0.8;
+        newDoorDepth = baseDoorDepth + frameDelta * increaseMultiplier;
+      } else {
+        // When decreasing totalDepth, the door body scales down proportionally.
+        newDoorDepth = baseDoorDepth * ratio;
+      }
+      setDoor(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+        theDoorDepth: newDoorDepth
+      }));
+    }
+    const baseCoverPanelDepth = 12;
+    setFrontCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      depth: baseCoverPanelDepth * ratio
+    }));
+    setBackCoverPanel(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+      depth: baseCoverPanelDepth * ratio
+    }));
+  }, [totalDepth, baseConfig]);
+
+  // ---  Exterior Fanlight Logic ---
+  React.useEffect(() => {
+    if (!exteriorFanlight.visible) return;
+    switch (exteriorFanlightType) {
+      case "WPFL":
+        setExteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+          depth: doorFrame.frameDepth
+        }));
+        break;
+      case "ALDGFL":
+        setExteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+          depth: doorFrame.frameDepth
+        }));
+        break;
+      case "ALSGFL":
+        setExteriorFanlight(prev => _objectSpread2(_objectSpread2({}, prev), {}, {
+          depth: 40
+        }));
+        break;
+    }
+  }, [exteriorFanlight.visible, exteriorFanlightType, doorFrame.frameDepth, setExteriorFanlight]);
+  React.useEffect(() => {
+    setOcculus(prevOcculus => _objectSpread2(_objectSpread2({}, prevOcculus), {}, {
+      depth: door.theDoorDepth
+    }));
+  }, [door.theDoorDepth]);
+  React.useEffect(() => {
+    const topThkValue = parseInt(doorFrame.topThk) || 0;
+    const exteriorFanlightHeight = exteriorFanlight.visible ? exteriorFanlight.height : 0;
+    const newDoorHeight = totalHeight - topThkValue - exteriorFanlightHeight;
+    setDoor(prevDoor => _objectSpread2(_objectSpread2({}, prevDoor), {}, {
+      doorHeight: newDoorHeight > 0 ? newDoorHeight : 0
+    }));
+  }, [totalHeight, doorFrame.topThk, exteriorFanlight.visible, exteriorFanlight.height]);
+  React.useEffect(() => {
+    const sidesThkValue = parseInt(doorFrame.sidesThk) || 0;
+    const numDoors = isDoubleDoor ? 2 : 1;
+    const newDoorWidth = (totalWidth - sidesThkValue * 2) / numDoors;
+    setDoor(prevDoor => _objectSpread2(_objectSpread2({}, prevDoor), {}, {
+      doorWidth: newDoorWidth > 0 ? newDoorWidth : 0
+    }));
+  }, [totalWidth, doorFrame.sidesThk, isDoubleDoor]);
+  return /*#__PURE__*/jsxRuntime.jsx(ConfiguratorContext.Provider, {
+    value: {
+      materials,
+      setMaterials,
+      is2D,
+      setIs2D,
+      isPlaneVisible,
+      setIsPlaneVisible,
+      isFrameVisible,
+      setIsFrameVisible,
+      cpid,
+      setCpid,
+      door,
+      setDoor,
+      doorFrame,
+      setDoorFrame,
+      interiorFanlight,
+      setInteriorFanlight,
+      exteriorFanlight,
+      setExteriorFanlight,
+      occulus,
+      setOcculus,
+      frontCoverPanel,
+      setFrontCoverPanel,
+      backCoverPanel,
+      setBackCoverPanel,
+      frontDoorPlane,
+      setFrontDoorPlane,
+      backDoorPlane,
+      setBackDoorPlane,
+      glass,
+      setGlass,
+      frameType,
+      setFrameType,
+      bodyType,
+      setBodyType,
+      totalHeight,
+      setTotalHeight,
+      totalDepth,
+      setTotalDepth,
+      totalWidth,
+      setTotalWidth,
+      exteriorFanlightType,
+      setExteriorFanlightType,
+      glassVisible,
+      setGlassVisible,
+      glassDepth,
+      setGlassDepth,
+      handleParseCpid,
+      newPivotPosition,
+      setNewPivotPosition,
+      doorHeight,
+      isDoubleDoor,
+      setIsDoubleDoor,
+      exportDXF,
+      setExportDXF,
+      collectElementsFromGroup,
+      setCollectElementsFromGroup
+    },
+    children: children
+  });
+};
+const useConfigurator = () => {
+  const context = React.useContext(ConfiguratorContext);
+  if (!context) {
+    throw new Error("useConfigurator must be used within a ConfiguratorProvider");
+  }
+  return context;
+};
+
+// Reasonable defaults to avoid heavy anisotropy and ensure mips are generated.
+const DEFAULT_ANISOTROPY = 8;
+const DEFAULT_MIN_FILTER = THREE__namespace.LinearMipmapLinearFilter;
+const DEFAULT_MAG_FILTER = THREE__namespace.LinearFilter;
+const DEFAULT_WRAP = THREE__namespace.ClampToEdgeWrapping;
+// Helper function to check for hex color codes
+const isHexColor = str => /^#([0-9A-F]{3}){1,2}$/i.test(str);
+
+/**
+ * A simple "builder" that creates a THREE.MeshStandardMaterial from a prop and an
+ * optional map of pre-loaded textures. It now loads textures if they are not pre-loaded.
+ * @param prop - The material definition (string or object).
+ * @param textures - A map of URL -> THREE.Texture, provided by useTexture.
+ * @returns A THREE.MeshStandardMaterial instance.
+ */
+const buildMaterial = (prop, textures) => {
+  if (!prop) {
+    return new THREE__namespace.MeshStandardMaterial({
+      color: "#cccccc",
+      roughness: 0.8
+    });
+  }
+  const sourceValue = typeof prop === "string" ? prop : prop.value;
+  const opacity = typeof prop === "object" ? prop.opacity : 1;
+
+  // Start with base parameters.
+  const params = {
+    roughness: 0.8,
+    side: THREE__namespace.DoubleSide
+  };
+  if (isHexColor(sourceValue)) {
+    // It's a color. Explicitly set the color and ensure no texture is applied.
+    params.color = sourceValue;
+    params.map = null;
+  } else {
+    // It's a texture. Explicitly set the color to white to avoid tinting the texture.
+    params.color = "#ffffff";
+    let texture = null;
+    if (textures && textures[sourceValue]) {
+      // Use the pre-loaded texture.
+      texture = textures[sourceValue];
+    } else if (sourceValue) {
+      // Not pre-loaded, so load it now.
+      // TextureLoader caches results internally, so this is efficient.
+      texture = new THREE__namespace.TextureLoader().load(sourceValue);
+    }
+    if (texture && !texture.__configuredForDoorMaterials) {
+      texture.anisotropy = Math.min(texture.anisotropy || DEFAULT_ANISOTROPY, DEFAULT_ANISOTROPY);
+      texture.minFilter = DEFAULT_MIN_FILTER;
+      texture.magFilter = DEFAULT_MAG_FILTER;
+      texture.wrapS = DEFAULT_WRAP;
+      texture.wrapT = DEFAULT_WRAP;
+      texture.needsUpdate = true;
+      texture.__configuredForDoorMaterials = true;
+    }
+    params.map = texture;
+  }
+
+  // Handle transparency explicitly to prevent lingering state.
+  if (opacity !== undefined && opacity < 1) {
+    params.transparent = true;
+    params.opacity = opacity;
+  } else {
+    // Explicitly turn transparency off if opacity is 1 or undefined.
+    params.transparent = false;
+    params.opacity = 1;
+  }
+  return new THREE__namespace.MeshStandardMaterial(params);
+};
+const getFirstValidValue = values => {
+  for (const val of values) {
+    if (val) {
+      return val;
+    }
+  }
+  return undefined;
+};
+
+const useDoorMaterials = function () {
+  let materialsProp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const preloadErrorNotified = React.useRef(false);
+
+  // Cache built materials per unique key to avoid reallocating MeshStandardMaterials
+  const materialCache = React.useRef(new Map());
+
+  // 1. Collect all unique texture URLs from the props.
+  const textureUrls = React.useMemo(() => {
+    const urls = new Set();
+    // Iterate over all passed material props
+    Object.values(materialsProp).forEach(prop => {
+      // Get the value, whether it's a string or inside an object
+      const value = typeof prop === "string" ? prop : prop === null || prop === void 0 ? void 0 : prop.value;
+      // If it's a valid URL, add it to our set to avoid duplicates
+      if (value && (value.startsWith("http") || value.startsWith("/"))) {
+        urls.add(value);
+      }
+    });
+    return Array.from(urls);
+  }, [materialsProp]);
+
+  // Preload textures up front so they are ready when the scene mounts.
+  React.useEffect(() => {
+    textureUrls.forEach(url => {
+      try {
+        drei.useTexture.preload(url);
+      } catch (err) {
+        if (!preloadErrorNotified.current) {
+          preloadErrorNotified.current = true;
+          console.error("[textures] preload failed for", url, err);
+          alert("Texture preload failed; check network or texture URLs. Rendering may be degraded.");
+        }
+      }
+    });
+  }, [textureUrls]);
+
+  // 2. Load all textures at once.
+  // !! THIS IS THE MAGIC !!
+  // `useTexture` will pause ("suspend") this component's rendering
+  // until all textures in the array are fully loaded.
+  const loadedTextures = drei.useTexture(textureUrls);
+
+  // 3. Create a map from URL back to the loaded THREE.Texture for easy lookup.
+  const textureMap = React.useMemo(() => {
+    const map = {};
+    textureUrls.forEach((url, index) => {
+      map[url] = loadedTextures[index];
+    });
+    return map;
+  }, [textureUrls, loadedTextures]);
+
+  // 4. Now that textures are guaranteed to be loaded, build all materials.
+  // This memo ensures the materials are only created when props or textures change.
+  return React.useMemo(() => {
+    const build = prop => {
+      var _prop$value, _prop$opacity;
+      const key = typeof prop === "string" ? "s:".concat(prop) : prop ? "o:".concat((_prop$value = prop.value) !== null && _prop$value !== void 0 ? _prop$value : "", ":").concat((_prop$opacity = prop.opacity) !== null && _prop$opacity !== void 0 ? _prop$opacity : "") : "__none__";
+      const textureKey = textureUrls.join("|");
+      const cacheKey = "".concat(key, "::").concat(textureKey);
+      const cached = materialCache.current.get(cacheKey);
+      if (cached) return cached;
+      const created = buildMaterial(prop, textureMap);
+      materialCache.current.set(cacheKey, created);
+      return created;
+    };
+    return {
+      doorMaterial: build(materialsProp.Body),
+      frameMaterial: build(getFirstValidValue([materialsProp.D_PRF_COLOR, materialsProp.D_FR_SRF_DECOR, materialsProp.D_FR_SRF_DECOR_S2])),
+      gasketMaterial: build(materialsProp.D_GASKET),
+      doorStopMaterial: build(getFirstValidValue([materialsProp.D_PRF_COLOR, materialsProp.D_FR_SRF_DECOR, materialsProp.D_FR_SRF_DECOR_S2])),
+      interiorFanlightMaterial: build(materialsProp.D_SRF_DECOR),
+      exteriorFanlightMaterial: build(materialsProp.D_SRF_DECOR),
+      occulusInfillMaterial: build(materialsProp.D_FR_COLOR),
+      glassInfillMaterial: build(materialsProp.D_FR_COLOR),
+      frontCoverPanelMaterial: build(getFirstValidValue([materialsProp.D_PRF_COLOR, materialsProp.D_FR_SRF_DECOR, materialsProp.D_FR_SRF_DECOR_S2])),
+      backCoverPanelMaterial: build(getFirstValidValue([materialsProp.D_PRF_COLOR, materialsProp.D_FR_SRF_DECOR, materialsProp.D_FR_SRF_DECOR_S2])),
+      frontDoorPlaneMaterial: build(materialsProp.D_SRF_DECOR_2),
+      backDoorPlaneMaterial: build(materialsProp.D_SRF_DECOR),
+      hingeBodyMaterial: build(materialsProp.Hinge),
+      hingeAccentMaterial: build(materialsProp.HingeCuts)
+    };
+  }, [materialsProp, textureMap, textureUrls]);
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+// Three.js Y-up -> IFC / CAD coords:
+//   IFC X = x
+//   IFC Y = z (depth)
+//   IFC Z = y (height)
+/**
+ * Convert a Three.js Vector3 (X, Y, Z) into IFC / CAD-style coordinates (X, Z, Y).
+ *
+ * In Three.js:
+ *   - X = horizontal
+ *   - Y = up
+ *   - Z = depth
+ *
+ * In IFC / CAD for this project:
+ *   - X = X
+ *   - Y = Z (depth)
+ *   - Z = Y (height)
+ *
+ * @param {THREE.Vector3} vec3 - Original Three.js vector.
+ * @returns {{ x: number, y: number, z: number }} - Re-mapped IFC-style coordinates.
+ */
+function threeToIfcCoords(vec3) {
+  return {
+    x: vec3.x,
+    y: vec3.z,
+    z: vec3.y
+  };
+}
+/**
+ * Trigger a file download in the browser from a Blob.
+ *
+ * @param {Blob} blob - File data as a Blob.
+ * @param {string} name - File name shown to the user (e.g. "project_123.dxf").
+ */
+function downloadBlob(blob, name) {
+  var a = document.createElement("a");
+  var url = URL.createObjectURL(blob);
+  a.href = url;
+  a.download = name;
+  a.click();
+  setTimeout(function () {
+    return URL.revokeObjectURL(url);
+  }, 100);
+}
+/**
+ * useDxfExportPayload
+ *
+ * High-level hook to:
+ *  - Walk a Three.js group (rootGroupRef) and extract all exportable meshes.
+ *  - Convert their geometry into IFC-style coordinates (X, Z, Y).
+ *  - Build a JSON payload of "elements" (positions + indices + IFC type).
+ *  - Optionally call the `/api/ifc-dxf` endpoint and download the resulting DXF.
+ *
+ * You typically:
+ *  1. Wrap all exportable meshes in a single `<group ref={exportGroupRef}>`.
+ *  2. Call `useDxfExportPayload({ rootGroupRef, getPropsForMesh })`.
+ *  3. Use:
+ *     - `collectElementsFromGroup()` if you just want the raw payload.
+ *     - `exportDxfFromServer()` if you want to call the API + download DXF.
+ *
+ * @param {Object} params
+ * @param {React.RefObject<THREE.Group>} params.rootGroupRef
+ *   Parent group containing all exportable meshes (walls, doors, etc.).
+ * @param {(mesh: THREE.Mesh) => { ifcType?: string, props?: any }} [params.getPropsForMesh]
+ *   Optional mapper to attach IFC metadata (ifcType + props) to each mesh.
+ *   If omitted, the hook falls back to `mesh.userData` heuristics.
+ * @param {string|number} [params.projectNumber='1987348']
+ *   Optional project identifier used only for naming in DXF export (e.g. "1987348").
+ * @param {string} [params.version='V0.1']
+ *   Optional version label used only for naming in DXF export (e.g. "V0.1").
+ *
+ * @returns {{
+ *   collectElementsFromGroup: () => {
+ *     elements: Array<{
+ *       uuid: string,
+ *       name: string,
+ *       ifcType: string,
+ *       props: any,
+ *       worldPositions: number[],
+ *       localPositions: number[],
+ *       matrixWorld: number[],
+ *       indices: number[]
+ *     }>,
+ *     stats: {
+ *       meshCount: number,
+ *       elementCount: number,
+ *       vertexCount: number,
+ *       triangleCount: number
+ *     },
+ *     countsByType: Record<string, number>
+ *   },
+ *   exportDxfFromServer: (options?: {
+ *     projectName?: string,
+ *     schema?: string,
+ *     format?: string,
+ *     bakeWorld?: boolean,
+ *     compat?: any,
+ *     fileName?: string
+ *   }) => Promise<void>
+ * }}
+ */
+function useDxfExportPayload(_a) {
+  var _this = this;
+  var _b = _a === void 0 ? {} : _a,
+    rootGroupRef = _b.rootGroupRef,
+    getPropsForMesh = _b.getPropsForMesh,
+    _c = _b.projectNumber,
+    projectNumber = _c === void 0 ? "1987348" : _c,
+    // used for naming (DXF file, project label)
+    _d = _b.version,
+    // used for naming (DXF file, project label)
+    version = _d === void 0 ? "V1.0" : _d;
+  var collectElementsFromGroup = React.useCallback(function () {
+    var root = rootGroupRef === null || rootGroupRef === void 0 ? void 0 : rootGroupRef.current;
+    if (!root) {
+      console.warn("[DXF-PAYLOAD] rootGroupRef.current is null, nothing to export");
+      alert("DXF export aborted: no export group found in the scene.");
+      return {
+        elements: [],
+        stats: {
+          meshCount: 0,
+          elementCount: 0,
+          vertexCount: 0,
+          triangleCount: 0
+        },
+        countsByType: {}
+      };
+    }
+    // Make sure transforms are up to date for the whole subtree
+    root.updateWorldMatrix(true, true);
+    var elements = [];
+    var meshCount = 0;
+    var vertexCount = 0;
+    var triangleCount = 0;
+    var tmpLocal = new THREE__namespace.Vector3();
+    var tmpWorld = new THREE__namespace.Vector3();
+    root.traverse(function (obj) {
+      var _a, _b, _c, _d, _e;
+      var mesh = obj;
+      if (!mesh.isMesh) return;
+      // Skip helper meshes (like invisible selection boxes)
+      var mat = mesh.material;
+      if (mat && mat.transparent && mat.opacity === 0) return;
+      var geometry = mesh.geometry;
+      if (!geometry || !geometry.attributes || !geometry.attributes.position) {
+        console.warn("[DXF-PAYLOAD] Mesh skipped: missing geometry or position attribute", mesh.name || mesh.uuid);
+        return;
+      }
+      var positionAttr = geometry.getAttribute("position");
+      var vCount = positionAttr.count;
+      if (vCount < 3) {
+        console.warn("[DXF-PAYLOAD] Mesh skipped: fewer than 3 vertices", {
+          name: mesh.name,
+          uuid: mesh.uuid
+        });
+        return;
+      }
+      meshCount += 1;
+      vertexCount += vCount;
+      var localPositions = new Array(vCount * 3);
+      var worldPositions = new Array(vCount * 3);
+      var worldMatrix = mesh.matrixWorld;
+      // Build local + world positions (already in IFC axes)
+      for (var i = 0; i < vCount; i++) {
+        tmpLocal.fromBufferAttribute(positionAttr, i);
+        // Local IFC coords (no world matrix): x, z, y
+        var li = threeToIfcCoords(tmpLocal);
+        localPositions[3 * i + 0] = li.x;
+        localPositions[3 * i + 1] = li.y;
+        localPositions[3 * i + 2] = li.z;
+        // World IFC coords
+        tmpWorld.copy(tmpLocal).applyMatrix4(worldMatrix);
+        var wi = threeToIfcCoords(tmpWorld);
+        worldPositions[3 * i + 0] = wi.x;
+        worldPositions[3 * i + 1] = wi.y;
+        worldPositions[3 * i + 2] = wi.z;
+      }
+      // Indices (triangles)
+      var indices;
+      if (geometry.index) {
+        indices = Array.from(geometry.index.array);
+      } else {
+        // Assume non-indexed geometry is already triangulated (3 verrtices pe tri)
+        var triCount = Math.floor(vCount / 3);
+        var indexCount = triCount * 3;
+        indices = new Array(indexCount);
+        for (var i = 0; i < indexCount; i++) {
+          indices[i] = i;
+        }
+      }
+      // Optional flip: mimic current buildElementsForIfcAndDxf behaviour
+      try {
+        if (worldMatrix.determinant() >= 0) {
+          for (var i = 0; i < indices.length; i += 3) {
+            var tmp = indices[i + 1];
+            indices[i + 1] = indices[i + 2];
+            indices[i + 2] = tmp;
+          }
+        }
+      } catch (_f) {
+        // ignore
+      }
+      triangleCount += indices.length / 3;
+      // IFC type + props
+      var ifcType = "IfcBuildingElementProxy";
+      var props = {};
+      if (typeof getPropsForMesh === "function") {
+        var extra = getPropsForMesh(mesh) || {};
+        ifcType = extra.ifcType || ifcType;
+        props = extra.props || props;
+      } else {
+        // Fallback: derive from userData / type (not used in your current setup)
+        ifcType = ((_a = mesh.userData) === null || _a === void 0 ? void 0 : _a.ifcType) || (((_b = mesh.userData) === null || _b === void 0 ? void 0 : _b.type) === "door" ? "IfcDoor" : ((_c = mesh.userData) === null || _c === void 0 ? void 0 : _c.type) === "wall" ? "IfcWall" : "IfcBuildingElementProxy");
+        var color = mesh.material && mesh.material.color && typeof mesh.material.color.getHexString === "function" ? "#".concat(mesh.material.color.getHexString()) : undefined;
+        props = __assign(__assign({}, mesh.userData), {
+          materialName: (_d = mesh.material) === null || _d === void 0 ? void 0 : _d.name,
+          colorHex: color
+        });
+      }
+      var element = {
+        uuid: mesh.uuid,
+        name: mesh.name || ((_e = mesh.userData) === null || _e === void 0 ? void 0 : _e.name) || "",
+        ifcType: ifcType,
+        props: props,
+        worldPositions: worldPositions,
+        localPositions: localPositions,
+        matrixWorld: Array.from(worldMatrix.elements),
+        indices: indices
+      };
+      elements.push(element);
+    });
+    var stats = {
+      meshCount: meshCount,
+      elementCount: elements.length,
+      vertexCount: vertexCount,
+      triangleCount: triangleCount
+    };
+    // Extra: count elements per IFC type (walls / doors / others)
+    var countsByType = elements.reduce(function (acc, el) {
+      var key = el.ifcType || "UNKNOWN";
+      acc[key] = (acc[key] || 0) + 1;
+      return acc;
+    }, {});
+    console.log("[DXF-PAYLOAD] collectElementsFromGroup() summary:", stats);
+    console.log("[DXF-PAYLOAD] countsByType:", countsByType);
+    if (elements[0]) {
+      var e0 = elements[0];
+      console.log("[DXF-PAYLOAD] First element preview:", {
+        uuid: e0.uuid,
+        name: e0.name,
+        ifcType: e0.ifcType,
+        worldPositionsLength: e0.worldPositions.length,
+        indicesLength: e0.indices.length
+      });
+    }
+    return {
+      elements: elements,
+      stats: stats,
+      countsByType: countsByType
+    };
+  }, [rootGroupRef, getPropsForMesh]);
+  /**
+   * Call the `/api/ifc-dxf` endpoint using the current scene geometry and
+   * immediately download the resulting DXF.
+   *
+   * The geometry is collected from `rootGroupRef` via `collectElementsFromGroup()`,
+   * then POSTed as `{ projectName, schema, format, bakeWorld, compat, elements }`.
+   *
+   * @async
+   * @function exportDxfFromServer
+   * @param {Object} [options]
+   * @param {string} [options.projectName=`Roometry Project ${projectNumber}`]
+   *   Project label forwarded to the backend. If omitted, a dynamic default is
+   *   used that includes the `projectNumber` (e.g. "Roometry Project 1987348").
+   * @param {string} [options.schema='IFC4']
+   *   IFC schema hint forwarded to the backend (currently "IFC4" or "IFC2X3").
+   * @param {string} [options.format='tfs']
+   *   Internal IFC body format flag forwarded to the backend.
+   * @param {boolean} [options.bakeWorld=false]
+   *   Whether the backend should bake world transforms into IFC geometry.
+   * @param {any} [options.compat={ useRootContextForBody: true }]
+   *   Extra compatibility flags passed through to the IFC builder.
+   * @param {string} [options.fileName=`${projectNumber}_v${version}_.dxf`]
+   *   Downloaded DXF file name. By default it includes `projectNumber` and `version`
+   *   so exports are easily traceable (e.g. "1987348_vV0.1_.dxf").
+   *
+   * @returns {Promise<void>}
+   */
+  var exportDxfFromServer = React.useCallback(function (_a) {
+    var _b = _a === void 0 ? {} : _a,
+      _c = _b.projectName,
+      projectName = _c === void 0 ? "Roometry Project ".concat(projectNumber) : _c,
+      // dynamic default using projectNumber
+      _d = _b.schema,
+      // dynamic default using projectNumber
+      schema = _d === void 0 ? "IFC4" : _d,
+      _e = _b.format,
+      format = _e === void 0 ? "tfs" : _e,
+      _f = _b.bakeWorld,
+      bakeWorld = _f === void 0 ? false : _f,
+      _g = _b.compat,
+      compat = _g === void 0 ? {
+        useRootContextForBody: true
+      } : _g,
+      _h = _b.fileName,
+      fileName = _h === void 0 ? "".concat(projectNumber, "_v").concat(version, "_.dxf") : _h;
+    return __awaiter(_this, void 0, void 0, function () {
+      var _j, elements, stats, countsByType, res, txt, payload, dxfText, dxfBlob, err_1, msg;
+      return __generator(this, function (_k) {
+        switch (_k.label) {
+          case 0:
+            _j = collectElementsFromGroup(), elements = _j.elements, stats = _j.stats, countsByType = _j.countsByType;
+            if (!elements.length) {
+              console.warn("[DXF] No elements to export");
+              alert("DXF export failed: no geometry to export");
+              return [2 /*return*/];
+            }
+            console.log("[DXF] Payload for /api/ifc-dxf:", __assign(__assign({}, stats), {
+              countsByType: countsByType,
+              firstElement: elements[0] && {
+                uuid: elements[0].uuid,
+                name: elements[0].name,
+                ifcType: elements[0].ifcType,
+                worldPositionsLength: elements[0].worldPositions.length,
+                indicesLength: elements[0].indices.length
+              }
+            }));
+            _k.label = 1;
+          case 1:
+            _k.trys.push([1, 6,, 7]);
+            return [4 /*yield*/, fetch("http://192.168.30.92:3009/api/ifc-dxf", {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify({
+                projectName: projectName,
+                schema: schema,
+                format: format,
+                bakeWorld: bakeWorld,
+                compat: compat,
+                elements: elements
+              })
+            })];
+          case 2:
+            res = _k.sent();
+            if (!!res.ok) return [3 /*break*/, 4];
+            return [4 /*yield*/, res.text()];
+          case 3:
+            txt = _k.sent();
+            console.error("[DXF] Server error:", txt);
+            alert("DXF export failed: " + txt);
+            return [2 /*return*/];
+          case 4:
+            return [4 /*yield*/, res.json()];
+          case 5:
+            payload = _k.sent();
+            console.log("[DXF] Server stats:", payload.stats);
+            dxfText = payload.dxf;
+            if (typeof dxfText !== "string") {
+              console.error("[DXF] Invalid DXF in response:", payload);
+              alert("DXF export failed: invalid DXF payload from server");
+              return [2 /*return*/];
+            }
+            dxfBlob = new Blob([dxfText], {
+              type: "image/vnd.dxf"
+            });
+            downloadBlob(dxfBlob, fileName);
+            return [3 /*break*/, 7];
+          case 6:
+            err_1 = _k.sent();
+            msg = err_1 instanceof Error ? err_1.message : String(err_1);
+            console.error("[DXF] Network error:", err_1);
+            alert("DXF export failed (network): " + msg);
+            return [3 /*break*/, 7];
+          case 7:
+            return [2 /*return*/];
+        }
+      });
+    });
+  }, [collectElementsFromGroup, projectNumber, version]);
+  return {
+    collectElementsFromGroup: collectElementsFromGroup,
+    exportDxfFromServer: exportDxfFromServer
+  };
+}
+
+const CAST_SHADOW_MESHES = false;
+const RECEIVE_SHADOW_MESHES = false;
+const ROSE_SEGMENTS = 20;
+const HANDLE_SEGMENTS = 20;
+const HANDLE_SPHERE_SEGMENTS = 16;
+const KEYHOLE_SEGMENTS = 12;
+const HINGE_SEGMENTS = 16;
+
+function DoorFrame(_ref) {
+  let {
+    materials,
+    doorModelsProps
+  } = _ref;
+  const {
+    doorOpening: doorOpeningProp
+  } = doorModelsProps;
+  const {
+    isFrameVisible,
+    door,
+    doorFrame,
+    interiorFanlight,
+    exteriorFanlight,
+    frontCoverPanel,
+    backCoverPanel,
+    frameType,
+    glassVisible,
+    glassDepth,
+    isDoubleDoor
+  } = useConfigurator();
+
+  // --- Dimension calculations ---
+  const {
+    doorWidth,
+    doorHeight,
+    theDoorDepth
+  } = door;
+  const doorOpening = doorOpeningProp || door.doorOpening;
+  const {
+    frameDepth,
+    topThk,
+    sidesThk,
+    doorStopWidth,
+    doorStopDepth,
+    doorStopOffset,
+    notchWidth,
+    notchDepth,
+    notchposition,
+    gasketWidth,
+    gasketDepth,
+    secondDoorStopWidth,
+    secondDoorStopDepth
+  } = doorFrame;
+  const {
+    height: interiorFanlightHeightValue
+  } = interiorFanlight;
+  const {
+    height: exteriorFanlightHeightValue,
+    depth: exteriorFanlightDepthValue
+  } = exteriorFanlight;
+  const {
+    width: architraveWidth,
+    depth: architraveDepth
+  } = frontCoverPanel;
+  const interiorFanlightHeight = interiorFanlight.visible ? interiorFanlightHeightValue : 0;
+  const topThkValue = parseInt(topThk) || 20;
+  const sidesThkValue = parseInt(sidesThk) || 20;
+
+  // Convert dimensions from mm to meters
+  const interiorFanlightHeightM = interiorFanlightHeight / 1000;
+  const doorWidthM = doorWidth / 1000;
+  const totalOpeningHeightM = doorHeight / 1000;
+  const doorDepthM = theDoorDepth / 1000;
+  const frameDepthM = frameDepth / 1000;
+  const topFrameWidthM = topThkValue / 1000;
+  const sidesFrameWidthM = sidesThkValue / 1000;
+  const totalOpeningWidthM = isDoubleDoor ? doorWidthM * 2 : doorWidthM;
+  const exteriorFanlightHeightM = exteriorFanlight.visible ? exteriorFanlightHeightValue / 1000 : 0;
+  const exteriorFanlightDepthM = exteriorFanlightDepthValue / 1000;
+  const doorStopWidthM = doorStopWidth / 1000;
+  const doorStopDepthM = doorStopDepth / 1000;
+  const architraveProfileM = architraveWidth / 1000;
+  const architraveDepthM = architraveDepth / 1000;
+  const gasketWidthM = gasketWidth / 1000;
+  const gasketDepthM = gasketDepth / 1000;
+  const doorStopOffsetFromEdgeM = parseInt(doorStopOffset) / 1000;
+  const notchWidthM = (parseInt(notchWidth) || 20) / 1000;
+  const notchDepthM = (parseInt(notchDepth) || 40) / 1000;
+  const isOpeningIn = doorOpening === "in";
+  const doorStopPositionZ = React.useMemo(() => isOpeningIn ? frameDepthM / 2 - doorStopOffsetFromEdgeM - doorStopDepthM / 2 : -frameDepthM / 2 + doorStopOffsetFromEdgeM + doorStopDepthM / 2, [isOpeningIn, frameDepthM, doorStopOffsetFromEdgeM, doorStopDepthM]);
+  const gasketZPosition = React.useMemo(() => isOpeningIn ? doorStopPositionZ - doorStopDepthM / 2 - gasketDepthM / 2 : doorStopPositionZ + doorStopDepthM / 2 + gasketDepthM / 2, [isOpeningIn, doorStopPositionZ, doorStopDepthM, gasketDepthM]);
+  const secondDoorStopWidthM = secondDoorStopWidth / 1000;
+  const secondDoorStopDepthM = secondDoorStopDepth / 1000;
+  const secondDoorStopPositionZ = isOpeningIn ? frameDepthM / 2 - secondDoorStopDepthM / 2 : -frameDepthM / 2 + secondDoorStopDepthM / 2;
+  const secondGasketZPosition = isOpeningIn ? secondDoorStopPositionZ - secondDoorStopDepthM / 2 - gasketDepthM / 2 : secondDoorStopPositionZ + secondDoorStopDepthM / 2 + gasketDepthM / 2;
+  const doorCenterZ = React.useMemo(() => {
+    if (frameType === "WF_FLI") {
+      return isOpeningIn ? frameDepthM / 2 - doorDepthM / 2 : -frameDepthM / 2 + doorDepthM / 2;
+    }
+    if (["WDGF_WDG100", "WF_100"].includes(frameType)) {
+      return 0;
+    }
+    const gasketFaceZ = isOpeningIn ? gasketZPosition - gasketDepthM / 2 : gasketZPosition + gasketDepthM / 2;
+    return isOpeningIn ? gasketFaceZ - doorDepthM / 2 : gasketFaceZ + doorDepthM / 2;
+  }, [isOpeningIn, gasketZPosition, gasketDepthM, doorDepthM, frameType, frameDepthM]);
+  const GlassPanelDepthM = glassDepth / 1000;
+
+  // --- Centering & Positioning ---
+  const sideFrameCenterY = topFrameWidthM / 2;
+  const interiorFanlightYPosition = totalOpeningHeightM / 2 - interiorFanlightHeightM / 2;
+  const topFrameCenterY = totalOpeningHeightM / 2 + topFrameWidthM / 2;
+  const exteriorFanlightYPosition = topFrameCenterY + topFrameWidthM / 2 + exteriorFanlightHeightM / 2;
+  const frontArchitraveZ = frameDepthM / 2 + architraveDepthM / 2;
+  const backArchitraveZ = -frameDepthM / 2 - architraveDepthM / 2;
+  const leftArchitraveX = -totalOpeningWidthM / 2 - architraveProfileM / 2;
+  const rightArchitraveX = totalOpeningWidthM / 2 + architraveProfileM / 2;
+  const topArchitraveY = totalOpeningHeightM / 2 + architraveProfileM / 2;
+  const topArchitraveWidth = totalOpeningWidthM + 2 * architraveProfileM;
+  const topGasketYPosition = totalOpeningHeightM / 2 - doorStopWidthM + gasketWidthM / 2;
+  const leftGasketXPosition = -totalOpeningWidthM / 2 + doorStopWidthM - gasketWidthM / 2;
+  const rightGasketXPosition = totalOpeningWidthM / 2 - doorStopWidthM + gasketWidthM / 2;
+  const secondTopGasketYPosition = totalOpeningHeightM / 2 - secondDoorStopWidthM + gasketWidthM / 2;
+  const secondLeftGasketXPosition = -totalOpeningWidthM / 2 + secondDoorStopWidthM - gasketWidthM / 2;
+  const secondRightGasketXPosition = totalOpeningWidthM / 2 - secondDoorStopWidthM + gasketWidthM / 2;
+  const leftGlass_Z = -frameDepthM / 2 + GlassPanelDepthM / 2 - GlassPanelDepthM;
+  const rightGlass_Z = frameDepthM / 2 - GlassPanelDepthM / 2 + GlassPanelDepthM;
+  return /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
+    children: [frontCoverPanel.visible && /*#__PURE__*/jsxRuntime.jsxs("group", {
+      "position-z": frontArchitraveZ,
+      children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+        position: [0, topArchitraveY, 0],
+        castShadow: CAST_SHADOW_MESHES,
+        material: materials.frontCoverPanelMaterial,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [topArchitraveWidth, architraveProfileM, architraveDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        position: [leftArchitraveX, 0, 0],
+        castShadow: CAST_SHADOW_MESHES,
+        material: materials.frontCoverPanelMaterial,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [architraveProfileM, totalOpeningHeightM, architraveDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        position: [rightArchitraveX, 0, 0],
+        castShadow: CAST_SHADOW_MESHES,
+        material: materials.frontCoverPanelMaterial,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [architraveProfileM, totalOpeningHeightM, architraveDepthM]
+        })
+      })]
+    }), backCoverPanel.visible && /*#__PURE__*/jsxRuntime.jsxs("group", {
+      "position-z": backArchitraveZ,
+      children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+        position: [0, topArchitraveY, 0],
+        castShadow: CAST_SHADOW_MESHES,
+        material: materials.backCoverPanelMaterial,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [topArchitraveWidth, architraveProfileM, architraveDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        position: [leftArchitraveX, 0, 0],
+        castShadow: CAST_SHADOW_MESHES,
+        material: materials.backCoverPanelMaterial,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [architraveProfileM, totalOpeningHeightM, architraveDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        position: [rightArchitraveX, 0, 0],
+        castShadow: CAST_SHADOW_MESHES,
+        material: materials.backCoverPanelMaterial,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [architraveProfileM, totalOpeningHeightM, architraveDepthM]
+        })
+      })]
+    }), exteriorFanlight.visible && /*#__PURE__*/jsxRuntime.jsx("mesh", {
+      position: [0, exteriorFanlightYPosition, 0],
+      castShadow: CAST_SHADOW_MESHES,
+      material: materials.exteriorFanlightMaterial,
+      children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+        args: [totalOpeningWidthM + sidesFrameWidthM * 2, exteriorFanlightHeightM, exteriorFanlightDepthM]
+      })
+    }), isFrameVisible && /*#__PURE__*/jsxRuntime.jsxs("group", {
+      children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+        castShadow: CAST_SHADOW_MESHES,
+        position: [0, topFrameCenterY, 0],
+        children: /*#__PURE__*/jsxRuntime.jsxs(csg.Geometry, {
+          useGroups: true,
+          children: [/*#__PURE__*/jsxRuntime.jsx(csg.Base, {
+            name: "frame-base",
+            material: materials.frameMaterial,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [totalOpeningWidthM, topFrameWidthM, frameDepthM]
+            })
+          }), !["MXF_40", "MXF_50", "MXCAF_40", "MXCAF_50"].includes(frameType) && /*#__PURE__*/jsxRuntime.jsx(csg.Subtraction, {
+            name: "cut-exterior",
+            material: materials.frameMaterial,
+            position: [0, notchposition, 0],
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [totalOpeningWidthM + 0.01, notchWidthM, notchDepthM]
+            })
+          })]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        castShadow: CAST_SHADOW_MESHES,
+        position: [-totalOpeningWidthM / 2 - sidesFrameWidthM / 2, sideFrameCenterY, 0],
+        children: /*#__PURE__*/jsxRuntime.jsxs(csg.Geometry, {
+          useGroups: true,
+          children: [/*#__PURE__*/jsxRuntime.jsx(csg.Base, {
+            name: "frame-base",
+            material: materials.frameMaterial,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [sidesFrameWidthM, totalOpeningHeightM + topFrameWidthM, frameDepthM]
+            })
+          }), !["MXF_40", "MXF_50", "MXCAF_40", "MXCAF_50"].includes(frameType) && /*#__PURE__*/jsxRuntime.jsx(csg.Subtraction, {
+            name: "cut-exterior",
+            material: materials.frameMaterial,
+            position: [-notchposition, 0, 0],
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [notchWidthM, totalOpeningHeightM + topFrameWidthM + 0.01, notchDepthM]
+            })
+          })]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        castShadow: CAST_SHADOW_MESHES,
+        position: [totalOpeningWidthM / 2 + sidesFrameWidthM / 2, sideFrameCenterY, 0],
+        children: /*#__PURE__*/jsxRuntime.jsxs(csg.Geometry, {
+          useGroups: true,
+          children: [/*#__PURE__*/jsxRuntime.jsx(csg.Base, {
+            name: "frame-base",
+            material: materials.frameMaterial,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [sidesFrameWidthM, totalOpeningHeightM + topFrameWidthM, frameDepthM]
+            })
+          }), !["MXF_40", "MXF_50", "MXCAF_40", "MXCAF_50"].includes(frameType) && /*#__PURE__*/jsxRuntime.jsx(csg.Subtraction, {
+            name: "cut-exterior",
+            material: materials.frameMaterial,
+            position: [notchposition, 0, 0],
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [notchWidthM, totalOpeningHeightM + topFrameWidthM + 0.01, notchDepthM]
+            })
+          })]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        castShadow: CAST_SHADOW_MESHES,
+        position: [0, totalOpeningHeightM / 2 - doorStopWidthM / 2, doorStopPositionZ],
+        material: materials.doorStopMaterial,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [totalOpeningWidthM, doorStopWidthM, doorStopDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        castShadow: CAST_SHADOW_MESHES,
+        position: [-totalOpeningWidthM / 2 + doorStopWidthM / 2, 0, doorStopPositionZ],
+        material: materials.doorStopMaterial,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [doorStopWidthM, totalOpeningHeightM, doorStopDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        castShadow: CAST_SHADOW_MESHES,
+        position: [totalOpeningWidthM / 2 - doorStopWidthM / 2, 0, doorStopPositionZ],
+        material: materials.doorStopMaterial,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [doorStopWidthM, totalOpeningHeightM, doorStopDepthM]
+        })
+      }), frameType !== "WF_FLI" && /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
+        children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+          castShadow: CAST_SHADOW_MESHES,
+          position: [0, topGasketYPosition, gasketZPosition],
+          material: materials.gasketMaterial,
+          children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+            args: [totalOpeningWidthM - 0.03, gasketWidthM + 0.005, gasketDepthM]
+          })
+        }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+          castShadow: CAST_SHADOW_MESHES,
+          position: [leftGasketXPosition - 0.005, -0.005, gasketZPosition],
+          material: materials.gasketMaterial,
+          children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+            args: [gasketWidthM + 0.005, totalOpeningHeightM - 0.02, gasketDepthM]
+          })
+        }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+          castShadow: CAST_SHADOW_MESHES,
+          position: [rightGasketXPosition + 0.005, -0.005, gasketZPosition],
+          material: materials.gasketMaterial,
+          children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+            args: [gasketWidthM + 0.005, totalOpeningHeightM - 0.02, gasketDepthM]
+          })
+        })]
+      }), ["WDGF_WDG100", "WF_100", "WF_FLI"].includes(frameType) && /*#__PURE__*/jsxRuntime.jsxs("group", {
+        children: [/*#__PURE__*/jsxRuntime.jsxs("group", {
+          children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+            castShadow: CAST_SHADOW_MESHES,
+            position: [0, totalOpeningHeightM / 2 - secondDoorStopWidthM / 2, secondDoorStopPositionZ],
+            material: materials.doorStopMaterial,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [totalOpeningWidthM, secondDoorStopWidthM, secondDoorStopDepthM]
+            })
+          }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+            castShadow: CAST_SHADOW_MESHES,
+            position: [-totalOpeningWidthM / 2 + secondDoorStopWidthM / 2, 0, secondDoorStopPositionZ],
+            material: materials.doorStopMaterial,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [secondDoorStopWidthM, totalOpeningHeightM, secondDoorStopDepthM]
+            })
+          }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+            castShadow: CAST_SHADOW_MESHES,
+            position: [totalOpeningWidthM / 2 - secondDoorStopWidthM / 2, 0, secondDoorStopPositionZ],
+            material: materials.doorStopMaterial,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [secondDoorStopWidthM, totalOpeningHeightM, secondDoorStopDepthM]
+            })
+          })]
+        }), /*#__PURE__*/jsxRuntime.jsxs("group", {
+          children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+            castShadow: CAST_SHADOW_MESHES,
+            position: [0, secondTopGasketYPosition - 0.005, secondGasketZPosition],
+            material: materials.gasketMaterial,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [totalOpeningWidthM - 0.03, gasketWidthM + 0.005, gasketDepthM]
+            })
+          }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+            castShadow: CAST_SHADOW_MESHES,
+            position: [secondLeftGasketXPosition - 0.005, -0.01, secondGasketZPosition],
+            material: materials.gasketMaterial,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [gasketWidthM + 0.005, totalOpeningHeightM - 0.04, gasketDepthM]
+            })
+          }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+            castShadow: CAST_SHADOW_MESHES,
+            position: [secondRightGasketXPosition + 0.005, -0.01, secondGasketZPosition],
+            material: materials.gasketMaterial,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [gasketWidthM + 0.004, totalOpeningHeightM - 0.04, gasketDepthM]
+            })
+          })]
+        }), glassVisible && /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
+          children: [/*#__PURE__*/jsxRuntime.jsxs("group", {
+            children: [["WDGF_WDG100", "WF_100"].includes(frameType) && /*#__PURE__*/jsxRuntime.jsx("mesh", {
+              castShadow: CAST_SHADOW_MESHES,
+              position: [0, topFrameCenterY - secondDoorStopWidthM / 2, leftGlass_Z],
+              material: materials.glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [totalOpeningWidthM - 2 * secondDoorStopWidthM, topFrameWidthM + secondDoorStopWidthM, GlassPanelDepthM]
+              })
+            }), !["WDGF_WDG100", "WF_100"].includes(frameType) && /*#__PURE__*/jsxRuntime.jsx("mesh", {
+              castShadow: CAST_SHADOW_MESHES,
+              position: [0, topFrameCenterY, leftGlass_Z],
+              material: materials.glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [totalOpeningWidthM - 2 * secondDoorStopWidthM, topFrameWidthM, GlassPanelDepthM]
+              })
+            }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+              castShadow: CAST_SHADOW_MESHES,
+              position: [-totalOpeningWidthM / 2 - sidesFrameWidthM / 2 + secondDoorStopWidthM / 2, sideFrameCenterY, leftGlass_Z],
+              material: materials.glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [sidesFrameWidthM + secondDoorStopWidthM, totalOpeningHeightM + topFrameWidthM, GlassPanelDepthM]
+              })
+            }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+              castShadow: CAST_SHADOW_MESHES,
+              position: [totalOpeningWidthM / 2 + sidesFrameWidthM / 2 - secondDoorStopWidthM / 2, sideFrameCenterY, leftGlass_Z],
+              material: materials.glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [sidesFrameWidthM + secondDoorStopWidthM, totalOpeningHeightM + topFrameWidthM, GlassPanelDepthM]
+              })
+            })]
+          }), /*#__PURE__*/jsxRuntime.jsxs("group", {
+            children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+              castShadow: CAST_SHADOW_MESHES,
+              position: [0, topFrameCenterY, rightGlass_Z],
+              material: materials.glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [totalOpeningWidthM, topFrameWidthM, GlassPanelDepthM]
+              })
+            }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+              castShadow: CAST_SHADOW_MESHES,
+              position: [-totalOpeningWidthM / 2 - sidesFrameWidthM / 2, sideFrameCenterY, rightGlass_Z],
+              material: materials.glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [sidesFrameWidthM, totalOpeningHeightM + topFrameWidthM, GlassPanelDepthM]
+              })
+            }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+              castShadow: CAST_SHADOW_MESHES,
+              position: [totalOpeningWidthM / 2 + sidesFrameWidthM / 2, sideFrameCenterY, rightGlass_Z],
+              material: materials.glassInfillMaterial,
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [sidesFrameWidthM, totalOpeningHeightM + topFrameWidthM, GlassPanelDepthM]
+              })
+            })]
+          })]
+        })]
+      })]
+    }), interiorFanlight.visible && /*#__PURE__*/jsxRuntime.jsx("mesh", {
+      position: [0, interiorFanlightYPosition, doorCenterZ],
+      castShadow: CAST_SHADOW_MESHES,
+      material: materials.interiorFanlightMaterial,
+      children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+        args: [totalOpeningWidthM, interiorFanlightHeightM, doorDepthM]
+      })
+    })]
+  });
+}
+
+const availableMaterials = {
+  black: new THREE__namespace.MeshStandardMaterial({
+    color: "#000000"
+  }),
+  metal: new THREE__namespace.MeshStandardMaterial({
+    color: "#aaaaaa",
+    metalness: 1.0,
+    roughness: 0.4
+  }),
+  darkgrey: new THREE__namespace.MeshStandardMaterial({
+    color: "#5e5e5e"
+  }),
+  grey: new THREE__namespace.MeshStandardMaterial({
+    color: "#cccccc"
+  }),
+  yellow: new THREE__namespace.MeshStandardMaterial({
+    color: "#ffff00"
+  }),
+  darkBrown: new THREE__namespace.MeshStandardMaterial({
+    color: "#a0522d"
+  }),
+  brown: new THREE__namespace.MeshStandardMaterial({
+    color: "#d2b48c"
+  }),
+  glass: new THREE__namespace.MeshStandardMaterial({
+    color: "#ffffff",
+    roughness: 0.1,
+    transparent: true,
+    opacity: 0.7
+  }),
+  aluminum: new THREE__namespace.MeshStandardMaterial({
+    color: "#abb0aa",
+    metalness: 0.8,
+    roughness: 0.5,
+    envMapIntensity: 1.2
+  }),
+  aluminumBrighter: new THREE__namespace.MeshStandardMaterial({
+    color: "#cdcdcd",
+    metalness: 0.8,
+    roughness: 0.5,
+    envMapIntensity: 1.2
+  }),
+  aluminumExtraBrighter: new THREE__namespace.MeshStandardMaterial({
+    color: "#ececec",
+    metalness: 0.8,
+    roughness: 0.5,
+    envMapIntensity: 1.2
+  }),
+  silver: new THREE__namespace.MeshStandardMaterial({
+    color: "#c0c0c0",
+    metalness: 1.0,
+    roughness: 0.2
+  }),
+  gold: new THREE__namespace.MeshStandardMaterial({
+    color: "#ffd700",
+    metalness: 1.0,
+    roughness: 0.3
+  }),
+  diamond: new THREE__namespace.MeshStandardMaterial({
+    color: "#e0f7fa",
+    metalness: 0.9,
+    roughness: 0.05,
+    transparent: true,
+    opacity: 0.9,
+    envMapIntensity: 1.5
+  }),
+  test_material: new THREE__namespace.MeshStandardMaterial({
+    color: "red",
+    roughness: 0.1
+  })
+};
+new THREE__namespace.MeshStandardMaterial({
+  color: "#cccccc",
+  roughness: 0.8
+});
+new THREE__namespace.MeshStandardMaterial({
+  color: "#000",
+  roughness: 0.8
+});
+
+const MergedPlate = _ref => {
+  let {
+    plateMaterial,
+    roseThickness,
+    faceZ
+  } = _ref;
+  const geometry = React.useMemo(() => {
+    const shape = new THREE__namespace.Shape();
+    const width = 0.1;
+    const height = 0.24;
+    const radius = 0.01;
+    shape.moveTo(-width / 2, -height / 2);
+    shape.lineTo(-width / 2, height / 2);
+    shape.lineTo(width / 2 - radius, height / 2);
+    shape.absarc(width / 2 - radius, height / 2 - radius, radius, Math.PI / 2, 0, true);
+    shape.lineTo(width / 2, -height / 2 + radius);
+    shape.absarc(width / 2 - radius, -height / 2 + radius, radius, 0, -Math.PI / 2, true);
+    shape.lineTo(-width / 2, -height / 2);
+    const extrudeSettings = {
+      steps: 2,
+      depth: roseThickness,
+      bevelEnabled: false
+    };
+    return new THREE__namespace.ExtrudeGeometry(shape, extrudeSettings);
+  }, [roseThickness]);
+  return /*#__PURE__*/jsxRuntime.jsx("group", {
+    "position-z": faceZ,
+    children: /*#__PURE__*/jsxRuntime.jsx("mesh", {
+      geometry: geometry,
+      material: plateMaterial,
+      castShadow: CAST_SHADOW_MESHES
+    })
+  });
+};
+
+function GlassHandle(_ref) {
+  let {
+    position,
+    doorDepthM,
+    doorPivot
+  } = _ref;
+  const roseRadius = 0.035;
+  const roseThickness = 0.005;
+  const handleRadius = 0.015;
+  const handleLength = 0.2;
+  const faceZ = doorDepthM / 2 + roseThickness / 2;
+  const connectorLength = handleLength / 3;
+  return /*#__PURE__*/jsxRuntime.jsxs("group", {
+    position: position,
+    children: [[faceZ, -faceZ].map((z, i) => /*#__PURE__*/jsxRuntime.jsxs(React__default["default"].Fragment, {
+      children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+        rotation: [Math.PI / 2, 0, 0],
+        "position-z": z + (z > 0 ? roseThickness : -roseThickness) + 0.002,
+        material: availableMaterials.aluminum,
+        castShadow: CAST_SHADOW_MESHES,
+        children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+          args: [roseRadius, roseRadius, roseThickness, ROSE_SEGMENTS]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsxs("mesh", {
+        position: [0, -0.08, z + (z > 0 ? roseThickness : -roseThickness)],
+        castShadow: CAST_SHADOW_MESHES,
+        children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+          rotation: [Math.PI / 2, 0, 0],
+          position: [0, 0.0075, 0],
+          material: availableMaterials.aluminum,
+          children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+            args: [0.01, 0.01, roseThickness, KEYHOLE_SEGMENTS]
+          })
+        }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+          position: [0, -0.0075, 0],
+          material: availableMaterials.aluminum,
+          children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+            args: [0.01, 0.015, roseThickness]
+          })
+        })]
+      })]
+    }, i)), /*#__PURE__*/jsxRuntime.jsxs("group", {
+      "scale-x": doorPivot === "left" ? -1 : 1,
+      children: [[faceZ, -faceZ].map((z, i) => /*#__PURE__*/jsxRuntime.jsx(MergedPlate, {
+        faceZ: z,
+        plateMaterial: availableMaterials.aluminumExtraBrighter,
+        roseThickness: roseThickness
+      }, "plate-".concat(i))), /*#__PURE__*/jsxRuntime.jsxs("group", {
+        children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+          position: [handleLength / 2, 0, faceZ + connectorLength],
+          rotation: [0, 0, Math.PI / 2],
+          material: availableMaterials.aluminum,
+          castShadow: CAST_SHADOW_MESHES,
+          children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+            args: [handleRadius, handleRadius, handleLength, HANDLE_SEGMENTS]
+          })
+        }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+          position: [0, 0, faceZ + connectorLength / 2],
+          rotation: [Math.PI / 2, 0, 0],
+          material: availableMaterials.aluminum,
+          castShadow: CAST_SHADOW_MESHES,
+          children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+            args: [handleRadius, handleRadius, connectorLength, HANDLE_SEGMENTS]
+          })
+        }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+          position: [0, 0, faceZ + connectorLength],
+          material: availableMaterials.aluminum,
+          castShadow: CAST_SHADOW_MESHES,
+          children: /*#__PURE__*/jsxRuntime.jsx("sphereGeometry", {
+            args: [handleRadius, HANDLE_SPHERE_SEGMENTS, HANDLE_SPHERE_SEGMENTS]
+          })
+        })]
+      }), /*#__PURE__*/jsxRuntime.jsxs("group", {
+        children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+          position: [handleLength / 2, 0, -(faceZ + connectorLength)],
+          rotation: [0, 0, Math.PI / 2],
+          material: availableMaterials.aluminum,
+          castShadow: CAST_SHADOW_MESHES,
+          children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+            args: [handleRadius, handleRadius, handleLength, HANDLE_SEGMENTS]
+          })
+        }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+          position: [0, 0, -(faceZ + connectorLength / 2)],
+          rotation: [Math.PI / 2, 0, 0],
+          material: availableMaterials.aluminum,
+          castShadow: CAST_SHADOW_MESHES,
+          children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+            args: [handleRadius, handleRadius, connectorLength, HANDLE_SEGMENTS]
+          })
+        }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+          position: [0, 0, -(faceZ + connectorLength)],
+          material: availableMaterials.aluminum,
+          castShadow: CAST_SHADOW_MESHES,
+          children: /*#__PURE__*/jsxRuntime.jsx("sphereGeometry", {
+            args: [handleRadius, HANDLE_SPHERE_SEGMENTS, HANDLE_SPHERE_SEGMENTS]
+          })
+        })]
+      })]
+    })]
+  });
+}
+
+function StandardHandle(_ref) {
+  let {
+    position,
+    doorDepthM,
+    doorPivot,
+    frameType,
+    handleColor
+  } = _ref;
+  const frontGLTF = drei.useGLTF("/glb/HandlerStandardFront.glb");
+  const backGLTF = drei.useGLTF("/glb/HandlerStandardBack.glb");
+
+  // Apply color to front handle materials
+  React__default["default"].useEffect(() => {
+    if (frontGLTF.materials) {
+      Object.values(frontGLTF.materials).forEach(material => {
+        if (material) {
+          material.color.set(handleColor);
+        }
+      });
+    }
+  }, [frontGLTF.materials, handleColor]);
+
+  // Apply color to back handle materials
+  React__default["default"].useEffect(() => {
+    if (backGLTF.materials) {
+      Object.values(backGLTF.materials).forEach(material => {
+        if (material) {
+          material.color.set(handleColor);
+        }
+      });
+    }
+  }, [backGLTF.materials, handleColor]);
+
+  // --- Thickness ---
+  // default 5mm, but 8mm + 1–2mm if WDG frame
+  const roseThickness = frameType === "WDGF_WDG100" ? 0.008 + 0.0015 : 0.005;
+
+  // face offset based on thickness
+  const faceZ = doorDepthM / 2 + roseThickness / 2;
+
+  // Clone scenes
+  const frontScene = React__default["default"].useMemo(() => frontGLTF.nodes.Scene.clone() || frontGLTF.nodes.root.clone(), [frontGLTF]);
+  const backScene = React__default["default"].useMemo(() => backGLTF.nodes.Scene.clone() || backGLTF.nodes.root.clone(), [backGLTF]);
+  return /*#__PURE__*/jsxRuntime.jsx("group", {
+    scale: 1.5,
+    position: position,
+    children: /*#__PURE__*/jsxRuntime.jsxs("group", {
+      scale: [doorPivot === "left" ? -1 : 1, 1, 1],
+      children: [/*#__PURE__*/jsxRuntime.jsx("group", {
+        position: [0, 0, faceZ],
+        children: /*#__PURE__*/jsxRuntime.jsx("primitive", {
+          object: frontScene,
+          castShadow: CAST_SHADOW_MESHES
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("group", {
+        position: [0, 0, -faceZ],
+        rotation: [0, Math.PI, 0],
+        children: /*#__PURE__*/jsxRuntime.jsx("primitive", {
+          object: backScene,
+          castShadow: CAST_SHADOW_MESHES
+        })
+      })]
+    })
+  });
+}
+
+function DoorHandle(_ref) {
+  let {
+    bodyType,
+    handleX,
+    handleHeightM,
+    doorDepthM,
+    doorPivot,
+    handleColor
+  } = _ref;
+  const isSingleGlass = ["SG8", "SG10", "SG12"].includes(bodyType);
+  const handlePos = [handleX, handleHeightM, 0];
+  const {
+    frameType
+  } = useConfigurator();
+  return isSingleGlass ? /*#__PURE__*/jsxRuntime.jsx(GlassHandle, {
+    position: [handleX, handleHeightM, -0.0024],
+    doorDepthM: doorDepthM,
+    doorPivot: doorPivot
+  }) : /*#__PURE__*/jsxRuntime.jsx(StandardHandle, {
+    position: handlePos,
+    doorDepthM: doorDepthM,
+    doorPivot: doorPivot,
+    frameType: frameType,
+    handleColor: handleColor
+  });
+}
+
+function GlassHinge(_ref) {
+  let {
+    position,
+    pivot,
+    frameSideWidth,
+    doorDepthM,
+    material,
+    gasketMaterial
+  } = _ref;
+  const plateWidth = 130 / 1000;
+  const plateHeight = 55 / 1000;
+  const plateThickness = 8 / 1000;
+  const gasketThickness = 1 / 1000;
+  const pivotRadius = 10 / 1000;
+  const pivotHeight = plateHeight;
+  const sideMultiplier = pivot === "left" ? 1 : -1;
+  const plateOffsetX = sideMultiplier * (plateWidth / 3 + frameSideWidth);
+  const holeRadius = 10 / 1000;
+  const holeSpacingX = 45 / 1000;
+  return /*#__PURE__*/jsxRuntime.jsxs("group", {
+    position: position,
+    children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+      material: material,
+      castShadow: CAST_SHADOW_MESHES,
+      receiveShadow: RECEIVE_SHADOW_MESHES,
+      "position-x": 0.01,
+      children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+        args: [pivotRadius, pivotRadius, pivotHeight, HINGE_SEGMENTS]
+      })
+    }), /*#__PURE__*/jsxRuntime.jsxs("group", {
+      "position-x": plateOffsetX,
+      children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+        "position-z": -(doorDepthM / 2) - plateThickness / 2 - gasketThickness,
+        material: material,
+        castShadow: CAST_SHADOW_MESHES,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [plateWidth, plateHeight, plateThickness]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        "position-z": -(doorDepthM / 2) - gasketThickness / 2,
+        material: gasketMaterial,
+        castShadow: CAST_SHADOW_MESHES,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [plateWidth, plateHeight, gasketThickness]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        "position-z": doorDepthM / 2 + plateThickness / 2 + gasketThickness,
+        castShadow: CAST_SHADOW_MESHES,
+        children: /*#__PURE__*/jsxRuntime.jsxs(csg.Geometry, {
+          useGroups: true,
+          children: [/*#__PURE__*/jsxRuntime.jsx(csg.Base, {
+            material: material,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [plateWidth, plateHeight, plateThickness]
+            })
+          }), /*#__PURE__*/jsxRuntime.jsx(csg.Subtraction, {
+            position: [-sideMultiplier * (holeSpacingX / 2), 0, 0],
+            rotation: [Math.PI / 2, 0, 0],
+            children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+              args: [holeRadius, holeRadius, plateThickness + 0.01, KEYHOLE_SEGMENTS]
+            })
+          }), /*#__PURE__*/jsxRuntime.jsx(csg.Subtraction, {
+            position: [sideMultiplier * (holeSpacingX / 2), 0, 0],
+            rotation: [Math.PI / 2, 0, 0],
+            children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+              args: [holeRadius, holeRadius, plateThickness + 0.01, KEYHOLE_SEGMENTS]
+            })
+          })]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        "position-z": doorDepthM / 2 + gasketThickness / 2,
+        material: gasketMaterial,
+        castShadow: CAST_SHADOW_MESHES,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [plateWidth, plateHeight, gasketThickness]
+        })
+      })]
+    })]
+  });
+}
+
+function DoorStopCuts(_ref) {
+  let {
+    visible,
+    width,
+    height,
+    stopWidth,
+    stopDepth,
+    stopPositionZ,
+    centerZ,
+    material,
+    setName
+  } = _ref;
+  if (!visible) return null;
+  return /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
+    children: [/*#__PURE__*/jsxRuntime.jsx(csg.Subtraction, {
+      name: "cut-top-".concat(setName),
+      material: material,
+      position: [0, height / 2 - stopWidth / 2 + 0.0001, stopPositionZ - centerZ],
+      children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+        args: [width + 0.01, stopWidth, stopDepth + 0.01]
+      })
+    }), /*#__PURE__*/jsxRuntime.jsx(csg.Subtraction, {
+      name: "cut-left-".concat(setName),
+      material: material,
+      position: [-width / 2 + stopWidth / 2 - 0.0001, 0, stopPositionZ - centerZ],
+      children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+        args: [stopWidth, height + 0.01, stopDepth + 0.01]
+      })
+    }), /*#__PURE__*/jsxRuntime.jsx(csg.Subtraction, {
+      name: "cut-right-".concat(setName),
+      material: material,
+      position: [width / 2 - stopWidth / 2 + 0.0001, 0, stopPositionZ - centerZ],
+      children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+        args: [stopWidth, height + 0.01, stopDepth + 0.01]
+      })
+    })]
+  });
+}
+
+function DoorLeaf(_ref) {
+  let {
+    pivot,
+    xOffset,
+    materials,
+    handleColor
+  } = _ref;
+  // Destructure materials from props.
+  const {
+    doorMaterial,
+    glassInfillMaterial,
+    hingeBodyMaterial,
+    gasketMaterial,
+    occulusInfillMaterial,
+    frontDoorPlaneMaterial,
+    backDoorPlaneMaterial,
+    hingeAccentMaterial
+  } = materials;
+
+  // Get NON-MATERIAL state from the context.
+  const {
+    isFrameVisible,
+    door,
+    doorFrame,
+    interiorFanlight,
+    occulus,
+    frontDoorPlane,
+    backDoorPlane,
+    frameType,
+    bodyType,
+    glassVisible,
+    glassDepth
+  } = useConfigurator();
+
+  // --- Dimension calculations ---
+  const {
+    doorWidth,
+    doorHeight,
+    theDoorDepth,
+    doorOpening
+  } = door;
+  const {
+    frameDepth,
+    sidesThk,
+    doorStopWidth,
+    doorStopDepth,
+    doorStopOffset,
+    gasketDepth,
+    secondDoorStopWidth,
+    secondDoorStopDepth
+  } = doorFrame;
+  const initialDoorHeight = React.useRef(null);
+  React.useEffect(() => {
+    if (doorHeight > 0 && initialDoorHeight.current === null) {
+      initialDoorHeight.current = doorHeight;
+    }
+  }, [doorHeight]);
+  const {
+    x1: occulusX1,
+    x2: occulusX2,
+    y1: occulusY1,
+    y2: occulusY2,
+    depth: occulusInfillDepth
+  } = occulus;
+  const interiorFanlightHeight = interiorFanlight.visible ? interiorFanlight.height : 0;
+  const mainDoorHeight = doorHeight - interiorFanlightHeight;
+  const sidesThkValue = parseInt(sidesThk) || 20;
+
+  // Convert dimensions from mm to meters
+  const doorWidthM = doorWidth / 1000;
+  const mainDoorHeightM = mainDoorHeight / 1000;
+  const totalOpeningHeightM = doorHeight / 1000;
+  const doorDepthM = theDoorDepth / 1000;
+  const frameDepthM = frameDepth / 1000;
+  const sidesFrameWidthM = sidesThkValue / 1000;
+  const occulusX1M = occulusX1 / 1000;
+  const occulusX2M = occulusX2 / 1000;
+  const occulusY1M = occulusY1 / 1000;
+  const occulusY2M = occulusY2 / 1000;
+  const occulusInfillDepthM = occulusInfillDepth / 1000;
+  const doorStopWidthM = doorStopWidth / 1000;
+  const doorStopDepthM = doorStopDepth / 1000;
+  const gasketDepthM = gasketDepth / 1000;
+  const doorStopOffsetFromEdgeM = parseInt(doorStopOffset) / 1000;
+  const isOpeningIn = doorOpening === "in";
+  const doorStopPositionZ = React.useMemo(() => isOpeningIn ? frameDepthM / 2 - doorStopOffsetFromEdgeM - doorStopDepthM / 2 : -frameDepthM / 2 + doorStopOffsetFromEdgeM + doorStopDepthM / 2, [isOpeningIn, frameDepthM, doorStopOffsetFromEdgeM, doorStopDepthM]);
+  const gasketZPosition = React.useMemo(() => isOpeningIn ? doorStopPositionZ - doorStopDepthM / 2 - gasketDepthM / 2 : doorStopPositionZ + doorStopDepthM / 2 + gasketDepthM / 2, [isOpeningIn, doorStopPositionZ, doorStopDepthM, gasketDepthM]);
+  const secondDoorStopWidthM = secondDoorStopWidth / 1000;
+  const secondDoorStopDepthM = secondDoorStopDepth / 1000;
+  const secondDoorStopPositionZ = isOpeningIn ? frameDepthM / 2 - secondDoorStopDepthM / 2 : -frameDepthM / 2 + secondDoorStopDepthM / 2;
+  const doorCenterZ = React.useMemo(() => {
+    if (frameType === "WF_FLI") {
+      return isOpeningIn ? frameDepthM / 2 - doorDepthM / 2 : -frameDepthM / 2 + doorDepthM / 2;
+    }
+    if (["WDGF_WDG100", "WF_100"].includes(frameType)) {
+      return 0;
+    }
+    const gasketFaceZ = isOpeningIn ? gasketZPosition - gasketDepthM / 2 : gasketZPosition + gasketDepthM / 2;
+    return isOpeningIn ? gasketFaceZ - doorDepthM / 2 : gasketFaceZ + doorDepthM / 2;
+  }, [isOpeningIn, gasketZPosition, gasketDepthM, doorDepthM, frameType, frameDepthM]);
+  const GlassPanelDepthM = glassDepth / 1000;
+  const frontGlassOffsetZ = doorDepthM / 2 + GlassPanelDepthM / 2;
+  const backGlassOffsetZ = -doorDepthM / 2 - GlassPanelDepthM / 2;
+  const occulusWidthM = doorWidthM - occulusX1M - occulusX2M;
+  const occulusHeightM = mainDoorHeightM - occulusY1M - occulusY2M;
+  const occulusPositionXM = (occulusX1M - occulusX2M) / 2;
+  const occulusPositionYM = (occulusY2M - occulusY1M) / 2;
+  React.useEffect(() => {
+    const materialsToUpdate = [frontDoorPlaneMaterial, backDoorPlaneMaterial];
+    materialsToUpdate.forEach(material => {
+      // Check if the material has a texture map
+      if (material.map) {
+        // Set the texture to repeat
+        material.map.wrapS = THREE__namespace.RepeatWrapping;
+        material.map.wrapT = THREE__namespace.RepeatWrapping;
+        material.map.repeat.set(doorWidthM, mainDoorHeightM);
+        material.map.needsUpdate = true;
+      }
+    });
+  }, [doorWidthM, mainDoorHeightM, frontDoorPlaneMaterial, backDoorPlaneMaterial]);
+  const [isOpen, setIsOpen] = React.useState(false);
+  const hingeSideX = pivot === "left" ? -doorWidthM / 2 : doorWidthM / 2;
+
+  // --- PIVOT ---
+  const hingeZ = React.useMemo(() => {
+    if (frameType === "WF_FLI") {
+      return isOpeningIn ? doorCenterZ - doorDepthM / 2 : doorCenterZ + doorDepthM / 2;
+    }
+    return isOpeningIn ? -frameDepthM / 2 : frameDepthM / 2;
+  }, [frameType, isOpeningIn, doorCenterZ, doorDepthM, frameDepthM]);
+  const doorOffsetZ = React.useMemo(() => doorCenterZ - hingeZ, [doorCenterZ, hingeZ]);
+  const directionMultiplier = doorOpening === "in" ? 1 : -1;
+  const {
+    rotation
+  } = three.useSpring({
+    rotation: isOpen ? [0, (pivot === "left" ? Math.PI / 2 : -Math.PI / 2) * directionMultiplier, 0] : [0, 0, 0],
+    config: {
+      mass: 1,
+      tension: 100,
+      friction: 20
+    }
+  });
+  const handleClick = () => setIsOpen(!isOpen);
+  const doorYPosition = -totalOpeningHeightM / 2 + mainDoorHeightM / 2;
+
+  // Handle positioning logic
+  const handleCenterYFromDoorBottom = 1.0;
+  const safeHandleY = Math.min(Math.max(handleCenterYFromDoorBottom, 0.25), mainDoorHeightM - 0.25);
+  const handleHeightM = -mainDoorHeightM / 2 + safeHandleY;
+  const isSingleGlass = ["SG8", "SG10", "SG12"].includes(bodyType);
+  const nonHingeSideX = pivot === "left" ? doorWidthM / 2 : -doorWidthM / 2;
+  let handleX;
+  if (isSingleGlass) {
+    const plateHalfWidth = 0.05;
+    handleX = nonHingeSideX + (pivot === "left" ? -plateHalfWidth : plateHalfWidth);
+  } else {
+    const latchMarginM = 0.08;
+    handleX = nonHingeSideX + (pivot === "left" ? -latchMarginM : latchMarginM);
+  }
+
+  // Hinge dimension calculations
+  const hingeTotalHeightM = 120 / 1000;
+  const hingeRadiusM = 8 / 1000;
+  const capHeightM = 4 / 1000;
+  const separatorHeightM = 4 / 1000;
+  const barrelPartHeight = (hingeTotalHeightM - capHeightM * 2 - separatorHeightM) / 2;
+  const isGlassDoor = React.useMemo(() => ["SG8", "SG10", "SG12"].includes(bodyType), [bodyType]);
+
+  // Hinge positioning logic
+  const standardHingeYPositions = React.useMemo(() => {
+    const numHinges = 4;
+    const topMargin = 180 / 1000;
+    const bottomMargin = 180 / 1000;
+    const availableHeight = mainDoorHeightM - topMargin - bottomMargin;
+    const spacing = availableHeight / (numHinges - 1);
+    return Array.from({
+      length: numHinges
+    }, (_, i) => mainDoorHeightM / 2 - topMargin - i * spacing);
+  }, [mainDoorHeightM]);
+  const glassHingeYPositions = React.useMemo(() => {
+    return [mainDoorHeightM / 2 - 250 / 1000, mainDoorHeightM / 2 - 450 / 1000, -mainDoorHeightM / 2 + 250 / 1000];
+  }, [mainDoorHeightM]);
+  const isStandardHingeVisible = React.useMemo(() => {
+    if (isGlassDoor || !isFrameVisible) return false;
+    return !["WDGF_WDG100", "WF_100", "WF_FLI"].includes(frameType);
+  }, [isFrameVisible, frameType, isGlassDoor]);
+  return /*#__PURE__*/jsxRuntime.jsxs("group", {
+    "position-x": xOffset,
+    children: [isStandardHingeVisible && standardHingeYPositions.map((y, index) => /*#__PURE__*/jsxRuntime.jsxs("group", {
+      position: [hingeSideX, doorYPosition + y, hingeZ],
+      children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+        material: hingeBodyMaterial,
+        position: [0, separatorHeightM / 2 + barrelPartHeight / 2, 0],
+        castShadow: CAST_SHADOW_MESHES,
+        children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+          args: [hingeRadiusM, hingeRadiusM, barrelPartHeight, HINGE_SEGMENTS]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+        material: hingeAccentMaterial,
+        position: [0, separatorHeightM / 2 + barrelPartHeight + capHeightM / 2, 0],
+        castShadow: CAST_SHADOW_MESHES,
+        children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+          args: [hingeRadiusM, hingeRadiusM, capHeightM, HINGE_SEGMENTS]
+        })
+      })]
+    }, "frame-hinge-".concat(index))), /*#__PURE__*/jsxRuntime.jsxs(three.a.group, {
+      position: [hingeSideX, doorYPosition, hingeZ],
+      rotation: rotation.to((x, y, z) => [x, y, z]),
+      onClick: handleClick,
+      onPointerOver: () => document.body.style.cursor = "pointer",
+      onPointerOut: () => document.body.style.cursor = "auto",
+      children: [isStandardHingeVisible && standardHingeYPositions.map((y, index) => /*#__PURE__*/jsxRuntime.jsxs("group", {
+        position: [0, y, 0],
+        children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+          material: hingeBodyMaterial,
+          position: [0, -separatorHeightM / 2 - barrelPartHeight / 2, 0],
+          castShadow: CAST_SHADOW_MESHES,
+          children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+            args: [hingeRadiusM, hingeRadiusM, barrelPartHeight, HINGE_SEGMENTS]
+          })
+        }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+          material: hingeAccentMaterial,
+          position: [0, -separatorHeightM / 2 - barrelPartHeight - capHeightM / 2, 0],
+          castShadow: CAST_SHADOW_MESHES,
+          children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+            args: [hingeRadiusM, hingeRadiusM, capHeightM, HINGE_SEGMENTS]
+          })
+        }), /*#__PURE__*/jsxRuntime.jsx("mesh", {
+          material: hingeAccentMaterial,
+          position: [0, 0, 0],
+          castShadow: CAST_SHADOW_MESHES,
+          children: /*#__PURE__*/jsxRuntime.jsx("cylinderGeometry", {
+            args: [hingeRadiusM, hingeRadiusM, separatorHeightM, HINGE_SEGMENTS]
+          })
+        })]
+      }, "door-hinge-".concat(index))), isGlassDoor && isFrameVisible && glassHingeYPositions.map((y, index) => /*#__PURE__*/jsxRuntime.jsx(GlassHinge, {
+        position: [0, y, doorOffsetZ + 0.0001],
+        pivot: pivot,
+        frameSideWidth: sidesFrameWidthM,
+        doorDepthM: doorDepthM,
+        material: hingeBodyMaterial,
+        gasketMaterial: gasketMaterial
+      }, "glass-hinge-".concat(index))), /*#__PURE__*/jsxRuntime.jsxs("group", {
+        position: [-hingeSideX, 0, doorOffsetZ],
+        children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+          castShadow: CAST_SHADOW_MESHES,
+          receiveShadow: RECEIVE_SHADOW_MESHES,
+          children: /*#__PURE__*/jsxRuntime.jsxs(csg.Geometry, {
+            useGroups: true,
+            children: [/*#__PURE__*/jsxRuntime.jsx(csg.Base, {
+              name: "door-base",
+              material: doorMaterial,
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [doorWidthM, mainDoorHeightM, doorDepthM]
+              })
+            }), /*#__PURE__*/jsxRuntime.jsx(DoorStopCuts, {
+              visible: ["WDGF_WDG100", "WF_100", "WF_FLI"].includes(frameType),
+              width: doorWidthM,
+              height: totalOpeningHeightM,
+              stopWidth: doorStopWidthM,
+              stopDepth: doorStopDepthM,
+              stopPositionZ: doorStopPositionZ,
+              centerZ: doorCenterZ,
+              material: doorMaterial,
+              setName: "1"
+            }), /*#__PURE__*/jsxRuntime.jsx(DoorStopCuts, {
+              visible: ["WDGF_WDG100", "WF_100", "WF_FLI"].includes(frameType),
+              width: doorWidthM,
+              height: totalOpeningHeightM,
+              stopWidth: secondDoorStopWidthM,
+              stopDepth: secondDoorStopDepthM,
+              stopPositionZ: secondDoorStopPositionZ,
+              centerZ: doorCenterZ,
+              material: doorMaterial,
+              setName: "2"
+            }), occulus.visible && occulusWidthM > 0 && occulusHeightM > 0 && /*#__PURE__*/jsxRuntime.jsx(csg.Subtraction, {
+              position: [occulusPositionXM, occulusPositionYM, 0],
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [occulusWidthM, occulusHeightM, doorDepthM + 0.01]
+              })
+            })]
+          })
+        }), glassVisible && /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
+          children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+            position: [0, 0, frontGlassOffsetZ],
+            castShadow: CAST_SHADOW_MESHES,
+            material: glassInfillMaterial,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [doorWidthM, mainDoorHeightM, GlassPanelDepthM]
+            })
+          }), !["WDGF_WDG100", "WF_100"].includes(frameType) && /*#__PURE__*/jsxRuntime.jsx("mesh", {
+            position: [0, 0, backGlassOffsetZ],
+            castShadow: CAST_SHADOW_MESHES,
+            material: glassInfillMaterial,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [doorWidthM, mainDoorHeightM, GlassPanelDepthM]
+            })
+          }), ["WDGF_WDG100", "WF_100"].includes(frameType) && /*#__PURE__*/jsxRuntime.jsx("mesh", {
+            position: [0, -secondDoorStopWidthM / 2, backGlassOffsetZ],
+            castShadow: CAST_SHADOW_MESHES,
+            material: glassInfillMaterial,
+            children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+              args: [doorWidthM - 2 * secondDoorStopWidthM, mainDoorHeightM - secondDoorStopWidthM, GlassPanelDepthM]
+            })
+          })]
+        }), frontDoorPlane.visible && /*#__PURE__*/jsxRuntime.jsx("mesh", {
+          position: [0, 0, doorDepthM / 2 + 0.0005],
+          castShadow: CAST_SHADOW_MESHES,
+          children: /*#__PURE__*/jsxRuntime.jsxs(csg.Geometry, {
+            useGroups: true,
+            children: [/*#__PURE__*/jsxRuntime.jsx(csg.Base, {
+              material: frontDoorPlaneMaterial,
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [doorWidthM, mainDoorHeightM, 0.001]
+              })
+            }), occulus.visible && occulusWidthM > 0 && occulusHeightM > 0 && /*#__PURE__*/jsxRuntime.jsx(csg.Subtraction, {
+              position: [occulusPositionXM, occulusPositionYM, 0],
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [occulusWidthM, occulusHeightM, 0.002]
+              })
+            })]
+          })
+        }), backDoorPlane.visible && /*#__PURE__*/jsxRuntime.jsx("mesh", {
+          position: [0, 0, -doorDepthM / 2 - 0.0005],
+          castShadow: CAST_SHADOW_MESHES,
+          children: /*#__PURE__*/jsxRuntime.jsxs(csg.Geometry, {
+            useGroups: true,
+            children: [/*#__PURE__*/jsxRuntime.jsx(csg.Base, {
+              material: backDoorPlaneMaterial,
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [doorWidthM, mainDoorHeightM, 0.0001]
+              })
+            }), occulus.visible && occulusWidthM > 0 && occulusHeightM > 0 && /*#__PURE__*/jsxRuntime.jsx(csg.Subtraction, {
+              position: [occulusPositionXM, occulusPositionYM, 0],
+              children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+                args: [occulusWidthM, occulusHeightM, 0.002]
+              })
+            })]
+          })
+        }), occulus.visible && occulus.infillVisible && occulusWidthM > 0 && occulusHeightM > 0 && /*#__PURE__*/jsxRuntime.jsx("mesh", {
+          position: [occulusPositionXM, occulusPositionYM, 0],
+          castShadow: CAST_SHADOW_MESHES,
+          material: occulusInfillMaterial,
+          children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+            args: [occulusWidthM, occulusHeightM, occulusInfillDepthM]
+          })
+        }), /*#__PURE__*/jsxRuntime.jsx(DoorHandle, {
+          bodyType: bodyType,
+          handleX: handleX,
+          handleHeightM: handleHeightM,
+          doorDepthM: doorDepthM,
+          doorPivot: pivot,
+          handleColor: handleColor
+        })]
+      })]
+    })]
+  });
+}
+
+function DoorModels(props) {
+  const {
+    doorName,
+    materials: materialsProp,
+    doorPivot: doorPivotProp,
+    doorOpening: doorOpeningProp,
+    totalWidth: totalWidthProp,
+    totalHeight: totalHeightProp,
+    totalDepth: totalDepthProp
+  } = props;
+  const {
+    is2D,
+    totalWidth,
+    door,
+    setDoor,
+    doorFrame,
+    handleParseCpid,
+    isDoubleDoor,
+    setMaterials,
+    setTotalWidth,
+    setTotalHeight,
+    setTotalDepth,
+    setExportDXF,
+    setCollectElementsFromGroup
+  } = useConfigurator();
+
+  /**
+   * Root Three.js group used for DXF export.
+   * Every Mesh under this group will be visited by `useDxfExportPayload`.
+   */
+  const exportGroupRef = React.useRef(null);
+
+  /**
+   * Optional mapper to attach IFC meta to each mesh.
+   * This will be called by the DXF export hook for every mesh it finds.
+   */
+  const getPropsForMesh = React.useCallback(mesh => {
+    const userData = mesh.userData || {};
+    return {
+      // You can adapt this logic to your own IFC type mapping
+      ifcType: userData.ifcType || (userData.type === "door" ? "IfcDoor" : userData.type === "window" ? "IfcWindow" : "IfcBuildingElementProxy"),
+      props: _objectSpread2({
+        name: mesh.name
+      }, userData)
+    };
+  }, []);
+  const {
+    collectElementsFromGroup,
+    exportDxfFromServer
+  } = useDxfExportPayload({
+    rootGroupRef: exportGroupRef,
+    getPropsForMesh,
+    projectNumber: "1987348",
+    version: "V1.0"
+  });
+
+  /**
+   * Convenience handler to trigger DXF export.
+   * This calls the backend and downloads the DXF returned.
+   */
+  const exportDXF = React.useCallback(() => {
+    exportDxfFromServer();
+  }, [exportDxfFromServer]);
+
+  // Register export functions in context
+  React.useEffect(() => {
+    setExportDXF(() => exportDXF);
+    setCollectElementsFromGroup(() => collectElementsFromGroup);
+
+    // Cleanup
+    return () => {
+      setExportDXF(null);
+      setCollectElementsFromGroup(null);
+    };
+  }, [exportDXF, collectElementsFromGroup, setExportDXF, setCollectElementsFromGroup]);
+  React.useEffect(() => {
+    if (doorName) {
+      handleParseCpid(doorName);
+    }
+  }, [doorName, handleParseCpid]);
+  React.useEffect(() => {
+    if (materialsProp) {
+      setMaterials(materialsProp);
+    }
+  }, [materialsProp, setMaterials]);
+  React.useEffect(() => {
+    if (doorPivotProp || doorOpeningProp) {
+      setDoor(prevDoor => _objectSpread2(_objectSpread2(_objectSpread2({}, prevDoor), doorPivotProp && {
+        doorPivot: doorPivotProp
+      }), doorOpeningProp && {
+        doorOpening: doorOpeningProp
+      }));
+    }
+  }, [doorPivotProp, doorOpeningProp, setDoor]);
+  React.useEffect(() => {
+    if (totalWidthProp !== undefined) {
+      setTotalWidth(totalWidthProp);
+    }
+  }, [totalWidthProp, setTotalWidth]);
+  React.useEffect(() => {
+    if (totalHeightProp !== undefined) {
+      setTotalHeight(totalHeightProp);
+    }
+  }, [totalHeightProp, setTotalHeight]);
+  React.useEffect(() => {
+    if (totalDepthProp !== undefined) {
+      setTotalDepth(totalDepthProp);
+    }
+  }, [totalDepthProp, setTotalDepth]);
+
+  // --- Material Logic (Centralized in parent component) ---
+  const allMaterials = useDoorMaterials(materialsProp);
+
+  // --- Dimension calculations ---
+  const {
+    doorWidth,
+    doorHeight
+  } = door;
+  const doorPivot = doorPivotProp || door.doorPivot;
+  const {
+    topThk,
+    frameDepth
+  } = doorFrame;
+  const initialDoorHeight = React.useRef(null);
+  React.useEffect(() => {
+    if (initialDoorHeight.current === null && doorHeight > 0) {
+      initialDoorHeight.current = doorHeight;
+    }
+  }, [doorHeight]);
+  const pivotNewPosition = React.useMemo(() => {
+    if (initialDoorHeight.current === null || initialDoorHeight.current === 0) return 0;
+    return (doorHeight - initialDoorHeight.current) / 2 / 1000;
+  }, [doorHeight]);
+  const topThkValue = parseInt(topThk) || 20;
+
+  // Convert dimensions from mm to meters
+  const totalWidthM = totalWidthProp !== undefined ? totalWidthProp / 1000 : totalWidth / 1000;
+  const totalHeightM = totalHeightProp !== undefined ? totalHeightProp / 1000 : doorHeight / 1000;
+  const doorWidthM = doorWidth / 1000;
+  const frameDepthM = frameDepth / 1000;
+  const topFrameWidthM = topThkValue / 1000;
+  const doorInstances = React.useMemo(() => {
+    if (isDoubleDoor) {
+      return [{
+        key: "left",
+        pivot: "left",
+        x: -doorWidthM / 2
+      }, {
+        key: "right",
+        pivot: "right",
+        x: doorWidthM / 2
+      }];
+    }
+    return [{
+      key: "single",
+      pivot: doorPivot,
+      x: 0
+    }];
+  }, [isDoubleDoor, doorWidthM, doorPivot]);
+
+  // --- Centering & Positioning ---
+  const yCenteringOffset = -topFrameWidthM / 2;
+  if (is2D) {
+    return /*#__PURE__*/jsxRuntime.jsx(jsxRuntime.Fragment, {
+      children: /*#__PURE__*/jsxRuntime.jsx("group", {
+        ref: exportGroupRef,
+        "position-y": yCenteringOffset + 0.1,
+        children: /*#__PURE__*/jsxRuntime.jsxs("mesh", {
+          children: [/*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+            args: [totalWidth / 1000, 0.1, frameDepth / 1000]
+          }), /*#__PURE__*/jsxRuntime.jsx("meshBasicMaterial", {
+            color: "white",
+            side: THREE__namespace.DoubleSide
+          })]
+        })
+      })
+    });
+  }
+
+  // Extract handleColor from materials prop
+  const handleColor = materialsProp === null || materialsProp === void 0 ? void 0 : materialsProp.handleColor;
+  return /*#__PURE__*/jsxRuntime.jsx(jsxRuntime.Fragment, {
+    children: /*#__PURE__*/jsxRuntime.jsxs("group", {
+      ref: exportGroupRef,
+      children: [/*#__PURE__*/jsxRuntime.jsx("mesh", {
+        visible: false,
+        children: /*#__PURE__*/jsxRuntime.jsx("boxGeometry", {
+          args: [totalWidthM, totalHeightM, frameDepthM]
+        })
+      }), /*#__PURE__*/jsxRuntime.jsxs("group", {
+        "position-y": yCenteringOffset + pivotNewPosition,
+        children: [/*#__PURE__*/jsxRuntime.jsx(DoorFrame, {
+          materials: allMaterials,
+          doorModelsProps: props
+        }), doorInstances.map(instance => /*#__PURE__*/jsxRuntime.jsx(DoorLeaf, {
+          pivot: instance.pivot,
+          xOffset: instance.x,
+          materials: allMaterials,
+          handleColor: handleColor
+        }, instance.key))]
+      })]
+    })
+  });
+}
+
+const DoorConfigurator = _ref => {
+  let {
+    doorName,
+    materials,
+    doorPivot,
+    doorOpening,
+    is2D = false,
+    totalWidth,
+    totalHeight,
+    totalDepth
+  } = _ref;
+  return /*#__PURE__*/jsxRuntime.jsx(ConfiguratorProvider, {
+    initialIs2D: is2D,
+    children: /*#__PURE__*/jsxRuntime.jsx(DoorModels, {
+      doorName: doorName,
+      materials: materials,
+      doorPivot: doorPivot,
+      doorOpening: doorOpening,
+      totalWidth: totalWidth,
+      totalHeight: totalHeight,
+      totalDepth: totalDepth
+    })
+  });
+};
+
+exports["default"] = DoorConfigurator;
+exports.useConfigurator = useConfigurator;
+//# sourceMappingURL=index.cjs.js.map