@cristiancosano/pallet-builder 0.1.0

package/dist/pallet-builder.js

@@ -0,0 +1,2611 @@
+import De, { createContext as Ge, useContext as Ve, useMemo as k, useCallback as H, memo as V, useRef as Ee, useEffect as fe, useState as ae } from "react";
+import { Html as ke, OrbitControls as Xe } from "@react-three/drei";
+import * as $ from "three";
+import { useThree as Ae, Canvas as pe } from "@react-three/fiber";
+const L = {
+  WOOD: "WOOD",
+  PLASTIC: "PLASTIC",
+  METAL: "METAL",
+  COMPOSITE: "COMPOSITE"
+}, me = {
+  CARDBOARD: "CARDBOARD",
+  WOOD: "WOOD",
+  PLASTIC: "PLASTIC"
+}, ie = {
+  BOX: "BOX",
+  REFRIGERATED: "REFRIGERATED",
+  FLATBED: "FLATBED",
+  TAUTLINER: "TAUTLINER",
+  CUSTOM: "CUSTOM"
+}, ue = {
+  /** Palet EUR/EPAL — Estándar europeo (1200×800×144mm, ISO 6780) */
+  EUR: {
+    dimensions: { width: 1200, height: 144, depth: 800 },
+    material: L.WOOD,
+    maxWeight: 1e3,
+    maxStackHeight: 2200,
+    weight: 25
+  },
+  /** Palet GMA/Americano — Estándar norteamericano (1219×1016×145mm, 48"×40") */
+  GMA: {
+    dimensions: { width: 1219, height: 145, depth: 1016 },
+    material: L.WOOD,
+    maxWeight: 1200,
+    maxStackHeight: 2200,
+    weight: 30
+  },
+  /** Palet UK Standard — Reino Unido (1200×1000×150mm) */
+  UK: {
+    dimensions: { width: 1200, height: 150, depth: 1e3 },
+    material: L.WOOD,
+    maxWeight: 1e3,
+    maxStackHeight: 2200,
+    weight: 28
+  },
+  /** Palet asiático estándar — Asia Pallet (1100×1100×150mm, ISO 6780) */
+  ASIA: {
+    dimensions: { width: 1100, height: 150, depth: 1100 },
+    material: L.WOOD,
+    maxWeight: 1e3,
+    maxStackHeight: 2200,
+    weight: 28
+  },
+  /** Palet australiano estándar — Australia (1165×1165×150mm) */
+  AUSTRALIAN: {
+    dimensions: { width: 1165, height: 150, depth: 1165 },
+    material: L.WOOD,
+    maxWeight: 1e3,
+    maxStackHeight: 2200,
+    weight: 29
+  },
+  /** Medio palet EUR — Half European Pallet (800×600×144mm) */
+  HALF_EUR: {
+    dimensions: { width: 800, height: 144, depth: 600 },
+    material: L.WOOD,
+    maxWeight: 500,
+    maxStackHeight: 2200,
+    weight: 12
+  },
+  /** Cuarto de palet EUR — Quarter European Pallet (600×400×144mm) */
+  QUARTER_EUR: {
+    dimensions: { width: 600, height: 144, depth: 400 },
+    material: L.WOOD,
+    maxWeight: 250,
+    maxStackHeight: 2200,
+    weight: 6
+  },
+  /** Palet ISO 1 — ISO 6780 (1200×1000×150mm) */
+  ISO_1: {
+    dimensions: { width: 1200, height: 150, depth: 1e3 },
+    material: L.WOOD,
+    maxWeight: 1e3,
+    maxStackHeight: 2200,
+    weight: 28
+  },
+  /** Palet ISO 2 — ISO 6780 (1200×800×144mm, equivalente a EUR) */
+  ISO_2: {
+    dimensions: { width: 1200, height: 144, depth: 800 },
+    material: L.WOOD,
+    maxWeight: 1e3,
+    maxStackHeight: 2200,
+    weight: 25
+  }
+};
+ue.GMA;
+const Ze = {
+  [ie.BOX]: {
+    dimensions: { width: 2480, height: 2700, depth: 13600 },
+    maxWeight: 24e3
+  },
+  [ie.REFRIGERATED]: {
+    dimensions: { width: 2440, height: 2590, depth: 13100 },
+    maxWeight: 22e3
+  },
+  [ie.FLATBED]: {
+    dimensions: { width: 2480, height: 2700, depth: 13600 },
+    maxWeight: 25e3
+  },
+  [ie.TAUTLINER]: {
+    dimensions: { width: 2480, height: 2700, depth: 13600 },
+    maxWeight: 24e3
+  }
+}, At = {
+  thickness: 10,
+  // mm
+  weight: 2
+  // kg
+}, Y = {
+  MM_TO_M: 1e-3,
+  M_TO_MM: 1e3
+}, Ne = 1, Me = 0.6, Oe = 0.9, Le = {
+  id: "unstyled",
+  name: "Sin estilo",
+  box: {
+    color: "#e07b39",
+    roughness: 0.6,
+    metalness: 0.1,
+    opacity: 1
+  },
+  pallet: {
+    color: "#c4a26e",
+    edgeColor: "#8b7355",
+    roughness: 0.85,
+    metalness: 0.05
+  },
+  separator: {
+    colorOverride: null,
+    roughness: 0.8
+  },
+  selection: {
+    selectedColor: "#ff0000",
+    highlightedColor: "#42a5f5"
+  },
+  warehouse: {
+    floorColor: "#8a8a8a",
+    floorRoughness: 0.8,
+    wallColor: "#d0d0d0",
+    wallOpacity: 0.4,
+    ambientIntensity: 0.4,
+    directionalIntensity: 0.8,
+    showGrid: !0,
+    gridColor: "#666666",
+    gridSecondaryColor: "#999999"
+  },
+  truck: {
+    floorColor: "#8a7e72",
+    wallColor: "#b0b0b0",
+    wallOpacity: 0.35,
+    showGrid: !0,
+    gridColor: "#666666",
+    gridSecondaryColor: "#999999",
+    cabColor: "#3a5f8a",
+    chassisColor: "#2a2a2a",
+    wheelColor: "#1a1a1a"
+  }
+}, Ie = {
+  id: "industrial",
+  name: "Industrial",
+  box: {
+    color: "#d4895a",
+    roughness: 0.7,
+    metalness: 0.05,
+    opacity: 1
+  },
+  pallet: {
+    color: "#a8854a",
+    edgeColor: "#6b5030",
+    roughness: 0.9,
+    metalness: 0.02
+  },
+  separator: {
+    colorOverride: null,
+    roughness: 0.85
+  },
+  selection: {
+    selectedColor: "#e53935",
+    highlightedColor: "#29b6f6"
+  },
+  warehouse: {
+    floorColor: "#5c5c5c",
+    floorRoughness: 0.92,
+    wallColor: "#b0b8be",
+    wallOpacity: 0.5,
+    ambientIntensity: 0.5,
+    directionalIntensity: 1,
+    showGrid: !0,
+    gridColor: "#4a4a4a",
+    gridSecondaryColor: "#6a6a6a"
+  },
+  truck: {
+    floorColor: "#6e6358",
+    wallColor: "#9eaab4",
+    wallOpacity: 0.4,
+    showGrid: !0,
+    gridColor: "#4a4a4a",
+    gridSecondaryColor: "#6a6a6a",
+    cabColor: "#2e4a6b",
+    chassisColor: "#1e1e1e",
+    wheelColor: "#111111"
+  }
+}, Ye = {
+  unstyled: Le,
+  industrial: Ie
+}, xe = Ie;
+var re = { exports: {} }, ee = {};
+var Pe;
+function Ue() {
+  if (Pe) return ee;
+  Pe = 1;
+  var o = /* @__PURE__ */ Symbol.for("react.transitional.element"), e = /* @__PURE__ */ Symbol.for("react.fragment");
+  function t(i, n, r) {
+    var a = null;
+    if (r !== void 0 && (a = "" + r), n.key !== void 0 && (a = "" + n.key), "key" in n) {
+      r = {};
+      for (var f in n)
+        f !== "key" && (r[f] = n[f]);
+    } else r = n;
+    return n = r.ref, {
+      $$typeof: o,
+      type: i,
+      key: a,
+      ref: n !== void 0 ? n : null,
+      props: r
+    };
+  }
+  return ee.Fragment = e, ee.jsx = t, ee.jsxs = t, ee;
+}
+var te = {};
+var Re;
+function Fe() {
+  return Re || (Re = 1, process.env.NODE_ENV !== "production" && (function() {
+    function o(m) {
+      if (m == null) return null;
+      if (typeof m == "function")
+        return m.$$typeof === R ? null : m.displayName || m.name || null;
+      if (typeof m == "string") return m;
+      switch (m) {
+        case h:
+          return "Fragment";
+        case T:
+          return "Profiler";
+        case j:
+          return "StrictMode";
+        case _:
+          return "Suspense";
+        case y:
+          return "SuspenseList";
+        case E:
+          return "Activity";
+      }
+      if (typeof m == "object")
+        switch (typeof m.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), m.$$typeof) {
+          case d:
+            return "Portal";
+          case b:
+            return m.displayName || "Context";
+          case z:
+            return (m._context.displayName || "Context") + ".Consumer";
+          case M:
+            var C = m.render;
+            return m = m.displayName, m || (m = C.displayName || C.name || "", m = m !== "" ? "ForwardRef(" + m + ")" : "ForwardRef"), m;
+          case w:
+            return C = m.displayName || null, C !== null ? C : o(m.type) || "Memo";
+          case S:
+            C = m._payload, m = m._init;
+            try {
+              return o(m(C));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function e(m) {
+      return "" + m;
+    }
+    function t(m) {
+      try {
+        e(m);
+        var C = !1;
+      } catch {
+        C = !0;
+      }
+      if (C) {
+        C = console;
+        var I = C.error, W = typeof Symbol == "function" && Symbol.toStringTag && m[Symbol.toStringTag] || m.constructor.name || "Object";
+        return I.call(
+          C,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          W
+        ), e(m);
+      }
+    }
+    function i(m) {
+      if (m === h) return "<>";
+      if (typeof m == "object" && m !== null && m.$$typeof === S)
+        return "<...>";
+      try {
+        var C = o(m);
+        return C ? "<" + C + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function n() {
+      var m = O.A;
+      return m === null ? null : m.getOwner();
+    }
+    function r() {
+      return Error("react-stack-top-frame");
+    }
+    function a(m) {
+      if (P.call(m, "key")) {
+        var C = Object.getOwnPropertyDescriptor(m, "key").get;
+        if (C && C.isReactWarning) return !1;
+      }
+      return m.key !== void 0;
+    }
+    function f(m, C) {
+      function I() {
+        N || (N = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          C
+        ));
+      }
+      I.isReactWarning = !0, Object.defineProperty(m, "key", {
+        get: I,
+        configurable: !0
+      });
+    }
+    function g() {
+      var m = o(this.type);
+      return U[m] || (U[m] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), m = this.props.ref, m !== void 0 ? m : null;
+    }
+    function v(m, C, I, W, ne, de) {
+      var B = I.ref;
+      return m = {
+        $$typeof: l,
+        type: m,
+        key: C,
+        props: I,
+        _owner: W
+      }, (B !== void 0 ? B : null) !== null ? Object.defineProperty(m, "ref", {
+        enumerable: !1,
+        get: g
+      }) : Object.defineProperty(m, "ref", { enumerable: !1, value: null }), m._store = {}, Object.defineProperty(m._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(m, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(m, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: ne
+      }), Object.defineProperty(m, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: de
+      }), Object.freeze && (Object.freeze(m.props), Object.freeze(m)), m;
+    }
+    function u(m, C, I, W, ne, de) {
+      var B = C.children;
+      if (B !== void 0)
+        if (W)
+          if (A(B)) {
+            for (W = 0; W < B.length; W++)
+              x(B[W]);
+            Object.freeze && Object.freeze(B);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else x(B);
+      if (P.call(C, "key")) {
+        B = o(m);
+        var Q = Object.keys(C).filter(function(Be) {
+          return Be !== "key";
+        });
+        W = 0 < Q.length ? "{key: someKey, " + Q.join(": ..., ") + ": ...}" : "{key: someKey}", J[B + W] || (Q = 0 < Q.length ? "{" + Q.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          W,
+          B,
+          Q,
+          B
+        ), J[B + W] = !0);
+      }
+      if (B = null, I !== void 0 && (t(I), B = "" + I), a(C) && (t(C.key), B = "" + C.key), "key" in C) {
+        I = {};
+        for (var he in C)
+          he !== "key" && (I[he] = C[he]);
+      } else I = C;
+      return B && f(
+        I,
+        typeof m == "function" ? m.displayName || m.name || "Unknown" : m
+      ), v(
+        m,
+        B,
+        I,
+        n(),
+        ne,
+        de
+      );
+    }
+    function x(m) {
+      p(m) ? m._store && (m._store.validated = 1) : typeof m == "object" && m !== null && m.$$typeof === S && (m._payload.status === "fulfilled" ? p(m._payload.value) && m._payload.value._store && (m._payload.value._store.validated = 1) : m._store && (m._store.validated = 1));
+    }
+    function p(m) {
+      return typeof m == "object" && m !== null && m.$$typeof === l;
+    }
+    var c = De, l = /* @__PURE__ */ Symbol.for("react.transitional.element"), d = /* @__PURE__ */ Symbol.for("react.portal"), h = /* @__PURE__ */ Symbol.for("react.fragment"), j = /* @__PURE__ */ Symbol.for("react.strict_mode"), T = /* @__PURE__ */ Symbol.for("react.profiler"), z = /* @__PURE__ */ Symbol.for("react.consumer"), b = /* @__PURE__ */ Symbol.for("react.context"), M = /* @__PURE__ */ Symbol.for("react.forward_ref"), _ = /* @__PURE__ */ Symbol.for("react.suspense"), y = /* @__PURE__ */ Symbol.for("react.suspense_list"), w = /* @__PURE__ */ Symbol.for("react.memo"), S = /* @__PURE__ */ Symbol.for("react.lazy"), E = /* @__PURE__ */ Symbol.for("react.activity"), R = /* @__PURE__ */ Symbol.for("react.client.reference"), O = c.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, P = Object.prototype.hasOwnProperty, A = Array.isArray, G = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    c = {
+      react_stack_bottom_frame: function(m) {
+        return m();
+      }
+    };
+    var N, U = {}, F = c.react_stack_bottom_frame.bind(
+      c,
+      r
+    )(), X = G(i(r)), J = {};
+    te.Fragment = h, te.jsx = function(m, C, I) {
+      var W = 1e4 > O.recentlyCreatedOwnerStacks++;
+      return u(
+        m,
+        C,
+        I,
+        !1,
+        W ? Error("react-stack-top-frame") : F,
+        W ? G(i(m)) : X
+      );
+    }, te.jsxs = function(m, C, I) {
+      var W = 1e4 > O.recentlyCreatedOwnerStacks++;
+      return u(
+        m,
+        C,
+        I,
+        !0,
+        W ? Error("react-stack-top-frame") : F,
+        W ? G(i(m)) : X
+      );
+    };
+  })()), te;
+}
+var _e;
+function He() {
+  return _e || (_e = 1, process.env.NODE_ENV === "production" ? re.exports = Ue() : re.exports = Fe()), re.exports;
+}
+var s = He();
+const $e = Ge(xe);
+function ve({ preset: o, children: e }) {
+  const t = k(() => o ? typeof o == "string" ? Ye[o] ?? xe : o : xe, [o]);
+  return /* @__PURE__ */ s.jsx($e.Provider, { value: t, children: e });
+}
+function ce() {
+  return Ve($e);
+}
+function le(o) {
+  let e = 0;
+  for (const t of o.floors) {
+    e += t.pallet.dimensions.height;
+    const i = t.boxes.reduce((n, r) => {
+      const a = r.position.y + r.box.dimensions.height;
+      return Math.max(n, a);
+    }, 0);
+    e += i, t.separatorAbove && (e += t.separatorAbove.dimensions.height);
+  }
+  return e;
+}
+function we(o) {
+  let e = 0;
+  for (const t of o.floors)
+    e += t.pallet.weight, e += t.boxes.reduce((i, n) => i + n.box.weight, 0), t.separatorAbove && (e += t.separatorAbove.weight);
+  return e;
+}
+function qe(o, e) {
+  const t = e || o.id, i = o.floors.map((n, r) => {
+    const a = n.boxes.map((f, g) => {
+      const v = `${t}:f${r}:b${g}`, u = (x) => x.map((p) => {
+        const c = n.boxes.findIndex((l) => l.id === p);
+        return c >= 0 ? `${t}:f${r}:b${c}` : p;
+      });
+      return {
+        ...f,
+        id: v,
+        supportedBy: u(f.supportedBy),
+        supporting: u(f.supporting)
+      };
+    });
+    return {
+      ...n,
+      boxes: a
+    };
+  });
+  return {
+    ...o,
+    floors: i
+  };
+}
+function D(o) {
+  let e = o.box.dimensions.width, t = o.box.dimensions.depth;
+  const i = o.box.dimensions.height;
+  return (o.rotation.y === 90 || o.rotation.y === 270) && ([e, t] = [t, e]), {
+    minX: o.position.x,
+    maxX: o.position.x + e,
+    minY: o.position.y,
+    maxY: o.position.y + i,
+    minZ: o.position.z,
+    maxZ: o.position.z + t
+  };
+}
+function oe(o) {
+  const e = o.stackedPallet, t = e.floors[0].pallet, i = t.dimensions.width, n = t.dimensions.depth, r = le(e), a = o.yRotation * Math.PI / 180, f = Math.cos(a), g = Math.sin(a), u = [
+    { x: 0, z: 0 },
+    { x: i, z: 0 },
+    { x: i, z: n },
+    { x: 0, z: n }
+  ].map((d) => ({
+    x: o.position.x + d.x * f + d.z * g,
+    z: o.position.z - d.x * g + d.z * f
+  })), x = Math.min(...u.map((d) => d.x)), p = Math.max(...u.map((d) => d.x)), c = Math.min(...u.map((d) => d.z)), l = Math.max(...u.map((d) => d.z));
+  return {
+    minX: x,
+    maxX: p,
+    minY: o.position.y,
+    maxY: o.position.y + r,
+    minZ: c,
+    maxZ: l
+  };
+}
+function ye(o, e, t = Ne) {
+  return o.minX < e.maxX - t && o.maxX > e.minX + t && o.minY < e.maxY - t && o.maxY > e.minY + t && o.minZ < e.maxZ - t && o.maxZ > e.minZ + t;
+}
+function Je(o) {
+  const e = [];
+  for (let t = 0; t < o.length; t++)
+    for (let i = t + 1; i < o.length; i++) {
+      const n = D(o[t]), r = D(o[i]);
+      ye(n, r) && e.push({
+        code: "BR-002",
+        severity: "error",
+        message: `Colisión entre cajas ${o[t].id} y ${o[i].id}`,
+        involvedIds: [o[t].id, o[i].id]
+      });
+    }
+  return { isValid: e.length === 0, violations: e };
+}
+function Qe(o) {
+  const e = [];
+  for (let t = 0; t < o.length; t++)
+    for (let i = t + 1; i < o.length; i++) {
+      const n = oe(o[t]), r = oe(o[i]);
+      ye(n, r) && e.push({
+        code: "BR-003",
+        severity: "error",
+        message: `Colisión entre palets ${o[t].id} y ${o[i].id}`,
+        involvedIds: [o[t].id, o[i].id]
+      });
+    }
+  return { isValid: e.length === 0, violations: e };
+}
+function Ke(o, e) {
+  const t = [], i = D(o);
+  return (i.minX < 0 || i.maxX > e.dimensions.width) && t.push({
+    code: "BR-001",
+    severity: "error",
+    message: `Caja ${o.id} sobresale por el eje X del palet`,
+    involvedIds: [o.id, e.id]
+  }), (i.minZ < 0 || i.maxZ > e.dimensions.depth) && t.push({
+    code: "BR-001",
+    severity: "error",
+    message: `Caja ${o.id} sobresale por el eje Z del palet`,
+    involvedIds: [o.id, e.id]
+  }), i.maxY > e.maxStackHeight && t.push({
+    code: "BR-001",
+    severity: "error",
+    message: `Caja ${o.id} excede la altura máxima de apilamiento del palet`,
+    involvedIds: [o.id, e.id]
+  }), { isValid: t.length === 0, violations: t };
+}
+function et(o, e) {
+  const t = [];
+  for (const i of o) {
+    const n = Ke(i, e);
+    t.push(...n.violations);
+  }
+  return { isValid: t.length === 0, violations: t };
+}
+function tt(o, e) {
+  const t = [], i = oe(o), n = e.dimensions;
+  return (i.minX < 0 || i.maxX > n.width) && t.push({
+    code: "BR-402",
+    severity: "error",
+    message: `Palet ${o.id} sobresale por el ancho del camión`,
+    involvedIds: [o.id, e.id]
+  }), (i.minZ < 0 || i.maxZ > n.depth) && t.push({
+    code: "BR-402",
+    severity: "error",
+    message: `Palet ${o.id} sobresale por la profundidad del camión`,
+    involvedIds: [o.id, e.id]
+  }), i.maxY > n.height && t.push({
+    code: "BR-404",
+    severity: "error",
+    message: `Palet ${o.id} excede la altura del camión`,
+    involvedIds: [o.id, e.id]
+  }), { isValid: t.length === 0, violations: t };
+}
+function Ot(o, e) {
+  const t = [], i = oe(o);
+  return i.maxY > e && t.push({
+    code: "BR-403",
+    severity: "error",
+    message: `Palet ${o.id} excede el techo de la estancia (${i.maxY}mm > ${e}mm)`,
+    involvedIds: [o.id]
+  }), { isValid: t.length === 0, violations: t };
+}
+function it(o) {
+  const e = [], t = o.boxes.reduce((n, r) => n + r.box.weight, 0), i = o.pallet.maxWeight;
+  return t > i ? e.push({
+    code: "BR-101",
+    severity: "error",
+    message: `Peso de cajas (${t.toFixed(1)}kg) excede el máximo del palet (${i}kg)`,
+    involvedIds: [o.pallet.id]
+  }) : t > i * Oe && e.push({
+    code: "BR-101",
+    severity: "warning",
+    message: `Peso de cajas (${t.toFixed(1)}kg) supera el 90% del máximo del palet (${i}kg)`,
+    involvedIds: [o.pallet.id]
+  }), { isValid: e.filter((n) => n.severity === "error").length === 0, violations: e };
+}
+function It(o) {
+  const e = [], t = o.pallets.reduce(
+    (i, n) => i + we(n.stackedPallet),
+    0
+  );
+  return t > o.maxWeight ? e.push({
+    code: "BR-102",
+    severity: "error",
+    message: `Peso total (${t.toFixed(1)}kg) excede el máximo del camión (${o.maxWeight}kg)`,
+    involvedIds: [o.id]
+  }) : t > o.maxWeight * Oe && e.push({
+    code: "BR-102",
+    severity: "warning",
+    message: `Peso total (${t.toFixed(1)}kg) supera el 90% del máximo del camión (${o.maxWeight}kg)`,
+    involvedIds: [o.id]
+  }), { isValid: e.filter((i) => i.severity === "error").length === 0, violations: e };
+}
+function ot(o) {
+  const e = [];
+  for (const t of o) {
+    if (!t.box.fragile) continue;
+    const i = t.box.fragilityMaxWeight ?? 0, n = st(t, o);
+    n > i && e.push({
+      code: "BR-103",
+      severity: "error",
+      message: `Caja frágil ${t.id} soporta ${n.toFixed(1)}kg (máx: ${i}kg)`,
+      involvedIds: [t.id]
+    });
+  }
+  return { isValid: e.length === 0, violations: e };
+}
+function st(o, e) {
+  const t = D(o);
+  let i = 0;
+  for (const n of e) {
+    if (n.id === o.id) continue;
+    const r = D(n);
+    r.minY >= t.maxY - 1 && r.minX < t.maxX && r.maxX > t.minX && r.minZ < t.maxZ && r.maxZ > t.minZ && (i += n.box.weight);
+  }
+  return i;
+}
+function nt(o, e) {
+  const t = [];
+  if (e.length === 0) return { isValid: !0, violations: t };
+  const i = e.reduce((g, v) => g + v.box.weight, 0);
+  if (i === 0) return { isValid: !0, violations: t };
+  let n = 0, r = 0;
+  for (const g of e) {
+    const v = D(g), u = (v.minX + v.maxX) / 2, x = (v.minZ + v.maxZ) / 2;
+    n += u * g.box.weight, r += x * g.box.weight;
+  }
+  n /= i, r /= i;
+  const a = o.dimensions.width / 2, f = o.dimensions.depth / 2;
+  return (Math.abs(n - a) > o.dimensions.width / 6 || Math.abs(r - f) > o.dimensions.depth / 6) && t.push({
+    code: "BR-104",
+    severity: "warning",
+    message: `Centro de gravedad descentrado (${n.toFixed(0)}, ${r.toFixed(0)}) respecto al centro del palet`,
+    involvedIds: [o.id]
+  }), { isValid: !0, violations: t };
+}
+function rt(o) {
+  const e = [];
+  for (const t of o) {
+    if (t.box.stackable) continue;
+    const i = D(t);
+    for (const n of o) {
+      if (n.id === t.id) continue;
+      const r = D(n);
+      r.minY >= i.maxY - 1 && r.minX < i.maxX && r.maxX > i.minX && r.minZ < i.maxZ && r.maxZ > i.minZ && e.push({
+        code: "BR-201",
+        severity: "error",
+        message: `Caja ${n.id} apilada sobre caja no apilable ${t.id}`,
+        involvedIds: [t.id, n.id]
+      });
+    }
+  }
+  return { isValid: e.length === 0, violations: e };
+}
+function at(o) {
+  const e = [];
+  for (const t of o) {
+    const i = D(t), n = (i.maxX - i.minX) * (i.maxZ - i.minZ);
+    for (const r of o) {
+      if (r.id === t.id) continue;
+      const a = D(r);
+      if (a.minY < i.maxY - 1 || a.minX >= i.maxX || a.maxX <= i.minX || a.minZ >= i.maxZ || a.maxZ <= i.minZ) continue;
+      const f = (a.maxX - a.minX) * (a.maxZ - a.minZ);
+      r.box.weight > t.box.weight * 1.5 && f > n * 1.2 && e.push({
+        code: "BR-203",
+        severity: "warning",
+        message: `Pirámide invertida: caja ${r.id} (${r.box.weight}kg) sobre caja ${t.id} (${t.box.weight}kg)`,
+        involvedIds: [t.id, r.id]
+      });
+    }
+  }
+  return { isValid: !0, violations: e };
+}
+function $t(o) {
+  const e = [];
+  if (o.floors.length <= 1) return { isValid: !0, violations: e };
+  const t = o.floors[0].pallet;
+  for (let i = 1; i < o.floors.length; i++) {
+    const n = o.floors[i].pallet;
+    (n.dimensions.width !== t.dimensions.width || n.dimensions.depth !== t.dimensions.depth) && e.push({
+      code: "BR-301",
+      severity: "error",
+      message: `Piso ${i}: dimensiones (${n.dimensions.width}×${n.dimensions.depth}) distintas a la base (${t.dimensions.width}×${t.dimensions.depth})`,
+      involvedIds: [t.id, n.id]
+    });
+  }
+  return { isValid: e.length === 0, violations: e };
+}
+function Wt(o) {
+  const e = [];
+  for (let t = 0; t < o.floors.length - 1; t++)
+    o.floors[t].separatorAbove || e.push({
+      code: "BR-302",
+      severity: "error",
+      message: `Falta separador entre piso ${t} y piso ${t + 1}`,
+      involvedIds: [o.id]
+    });
+  return { isValid: e.length === 0, violations: e };
+}
+function Bt(o, e) {
+  const t = [], i = le(o);
+  return i > e && t.push({
+    code: "BR-303",
+    severity: "error",
+    message: `Altura del stack (${i}mm) excede la del contenedor (${e}mm)`,
+    involvedIds: [o.id]
+  }), { isValid: t.length === 0, violations: t };
+}
+function Dt(o) {
+  const e = [], t = we(o), i = o.floors[0].pallet.maxWeight, n = t - o.floors[0].pallet.weight;
+  return n > i && e.push({
+    code: "BR-304",
+    severity: "error",
+    message: `Peso de carga del stack (${n.toFixed(1)}kg) excede la capacidad del palet base (${i}kg)`,
+    involvedIds: [o.id]
+  }), { isValid: e.length === 0, violations: e };
+}
+function ct(o) {
+  const e = [];
+  for (const t of o) {
+    const i = D(t);
+    if (i.minY <= 1) continue;
+    const n = (i.maxX - i.minX) * (i.maxZ - i.minZ);
+    let r = 0;
+    for (const a of o) {
+      if (a.id === t.id) continue;
+      const f = D(a);
+      if (Math.abs(f.maxY - i.minY) > 2) continue;
+      const g = Math.max(0, Math.min(i.maxX, f.maxX) - Math.max(i.minX, f.minX)), v = Math.max(0, Math.min(i.maxZ, f.maxZ) - Math.max(i.minZ, f.minZ));
+      r += g * v;
+    }
+    n > 0 && r / n < Me && e.push({
+      code: "BR-004",
+      severity: "error",
+      message: `Caja ${t.id} sin soporte suficiente (${(r / n * 100).toFixed(0)}% < ${Me * 100}%)`,
+      involvedIds: [t.id]
+    });
+  }
+  return { isValid: e.length === 0, violations: e };
+}
+function q(o) {
+  if (o.length === 0) return { x: 0, y: 0, z: 0 };
+  let e = 0, t = 0, i = 0, n = 0;
+  for (const r of o) {
+    const a = D(r), f = (a.minX + a.maxX) / 2, g = (a.minY + a.maxY) / 2, v = (a.minZ + a.maxZ) / 2, u = r.box.weight;
+    t += f * u, i += g * u, n += v * u, e += u;
+  }
+  return e === 0 ? { x: 0, y: 0, z: 0 } : {
+    x: t / e,
+    y: i / e,
+    z: n / e
+  };
+}
+function se(o, e) {
+  if (e.length === 0) return 100;
+  const t = q(e), i = o.dimensions.width / 2, n = o.dimensions.depth / 2, r = Math.abs(t.x - i) / (o.dimensions.width / 2), a = Math.abs(t.z - n) / (o.dimensions.depth / 2), f = Math.max(0, 100 - (r + a) * 50), g = e.reduce((x, p) => {
+    const c = D(p);
+    return Math.max(x, c.maxY);
+  }, 0), v = g > 0 ? t.y / g : 0, u = Math.max(0, 100 - Math.max(0, v - 0.5) * 100);
+  return Math.round(f * 0.7 + u * 0.3);
+}
+function lt(o, e) {
+  const t = [];
+  if (e.length === 0) return { isValid: !0, violations: t };
+  const i = q(e);
+  return (i.x < 0 || i.x > o.dimensions.width || i.z < 0 || i.z > o.dimensions.depth) && t.push({
+    code: "BR-502",
+    severity: "error",
+    message: `Centro de gravedad (${i.x.toFixed(0)}, ${i.z.toFixed(0)}) fuera del palet`,
+    involvedIds: [o.id]
+  }), { isValid: t.length === 0, violations: t };
+}
+function dt(o, e) {
+  const t = [];
+  if (e.length === 0) return { isValid: !0, violations: t };
+  const i = se(o, e);
+  i < 50 ? t.push({
+    code: "BR-501",
+    severity: "error",
+    message: `Score de estabilidad bajo (${i}/100, mínimo: 50)`,
+    involvedIds: [o.id]
+  }) : i < 70 && t.push({
+    code: "BR-501",
+    severity: "warning",
+    message: `Score de estabilidad mejorable (${i}/100, recomendado: ≥70)`,
+    involvedIds: [o.id]
+  });
+  const n = q(e), r = e.reduce((a, f) => Math.max(a, D(f).maxY), 0);
+  return r > 0 && n.y > r * 0.6 && t.push({
+    code: "BR-503",
+    severity: "warning",
+    message: `Centro de gravedad alto (${n.y.toFixed(0)}mm, ${(n.y / r * 100).toFixed(0)}% de la altura)`,
+    involvedIds: [o.id]
+  }), { isValid: t.filter((a) => a.severity === "error").length === 0, violations: t };
+}
+function ht(o, e) {
+  let t = !1;
+  const i = e.length;
+  for (let n = 0, r = i - 1; n < i; r = n++) {
+    const a = e[n].x, f = e[n].z, g = e[r].x, v = e[r].z;
+    f > o.z != v > o.z && o.x < (g - a) * (o.z - f) / (v - f) + a && (t = !t);
+  }
+  return t;
+}
+function We(o, e) {
+  const t = [], i = oe(o), n = [
+    { x: i.minX, z: i.minZ },
+    { x: i.maxX, z: i.minZ },
+    { x: i.maxX, z: i.maxZ },
+    { x: i.minX, z: i.maxZ }
+  ];
+  for (const r of n)
+    if (!ht(r, e.floorPolygon)) {
+      t.push({
+        code: "BR-401",
+        severity: "error",
+        message: `Palet ${o.id} fuera de la estancia ${e.name} en (${r.x}, ${r.z})`,
+        involvedIds: [o.id, e.id]
+      });
+      break;
+    }
+  return i.maxY > e.ceilingHeight && t.push({
+    code: "BR-403",
+    severity: "error",
+    message: `Palet ${o.id} excede el techo de la estancia ${e.name}`,
+    involvedIds: [o.id, e.id]
+  }), { isValid: t.length === 0, violations: t };
+}
+class mt {
+  id = "column";
+  name = "Columnas por tipo";
+  pack(e, t) {
+    const i = [], n = [], r = /* @__PURE__ */ new Map();
+    for (const c of e) {
+      const l = c.type ?? c.sku ?? "default";
+      r.has(l) || r.set(l, []), r.get(l).push(c);
+    }
+    let a = 0, f = 0;
+    for (const [, c] of r) {
+      if (c.length === 0) continue;
+      const l = c[0], d = l.dimensions.width, h = l.dimensions.depth, j = l.dimensions.height;
+      if (a + d > t.dimensions.width) {
+        n.push(...c);
+        continue;
+      }
+      let T = 0, z = 0, b = 0;
+      for (; b < c.length; ) {
+        const M = c[b];
+        if (T + h > t.dimensions.depth) {
+          if (T = 0, z += j, z + j > t.maxStackHeight) {
+            n.push(...c.slice(b));
+            break;
+          }
+          continue;
+        }
+        i.push({
+          id: `placed-${++f}`,
+          box: M,
+          position: { x: a, y: z, z: T },
+          rotation: { x: 0, y: 0, z: 0 },
+          supportedBy: [],
+          supporting: []
+        }), T += h, b++;
+      }
+      a += d;
+    }
+    const g = t.dimensions.width * t.maxStackHeight * t.dimensions.depth, v = i.reduce((c, l) => {
+      const d = l.box.dimensions;
+      return c + d.width * d.height * d.depth;
+    }, 0), u = i.reduce((c, l) => c + l.box.weight, 0), x = q(i), p = se(t, i);
+    return {
+      placements: i,
+      metrics: {
+        volumeUtilization: g > 0 ? v / g : 0,
+        weightUtilization: t.maxWeight > 0 ? u / t.maxWeight : 0,
+        centerOfGravity: x,
+        stabilityScore: p
+      },
+      unplacedBoxes: n
+    };
+  }
+}
+class ut {
+  id = "bin-packing-3d";
+  name = "Bin Packing 3D (FFD Height)";
+  pack(e, t) {
+    const i = [], n = [], r = [...e].sort((x, p) => {
+      const c = x.dimensions.width * x.dimensions.height * x.dimensions.depth;
+      return p.dimensions.width * p.dimensions.height * p.dimensions.depth - c;
+    }), a = [
+      {
+        x: 0,
+        y: 0,
+        z: 0,
+        width: t.dimensions.width,
+        height: t.maxStackHeight,
+        depth: t.dimensions.depth
+      }
+    ];
+    let f = 0;
+    for (const x of r) {
+      let p = !1;
+      const c = [
+        { w: x.dimensions.width, h: x.dimensions.height, d: x.dimensions.depth, rot: 0 },
+        { w: x.dimensions.depth, h: x.dimensions.height, d: x.dimensions.width, rot: 90 }
+      ];
+      for (let l = 0; l < a.length && !p; l++) {
+        const d = a[l];
+        for (const h of c)
+          if (h.w <= d.width && h.h <= d.height && h.d <= d.depth) {
+            const j = {
+              id: `placed-${++f}`,
+              box: x,
+              position: { x: d.x, y: d.y, z: d.z },
+              rotation: { x: 0, y: h.rot, z: 0 },
+              supportedBy: [],
+              supporting: []
+            }, T = D(j);
+            if (!i.some(
+              (b) => ye(D(b), T)
+            )) {
+              i.push(j), p = !0, a.splice(l, 1), d.width - h.w > 0 && a.push({
+                x: d.x + h.w,
+                y: d.y,
+                z: d.z,
+                width: d.width - h.w,
+                height: d.height,
+                depth: d.depth
+              }), d.height - h.h > 0 && a.push({
+                x: d.x,
+                y: d.y + h.h,
+                z: d.z,
+                width: h.w,
+                height: d.height - h.h,
+                depth: h.d
+              }), d.depth - h.d > 0 && a.push({
+                x: d.x,
+                y: d.y,
+                z: d.z + h.d,
+                width: h.w,
+                height: d.height,
+                depth: d.depth - h.d
+              }), a.sort((b, M) => b.y - M.y || b.x - M.x || b.z - M.z);
+              break;
+            }
+          }
+      }
+      p || n.push(x);
+    }
+    const g = t.dimensions.width * t.maxStackHeight * t.dimensions.depth, v = i.reduce((x, p) => {
+      const c = p.box.dimensions;
+      return x + c.width * c.height * c.depth;
+    }, 0), u = i.reduce((x, p) => x + p.box.weight, 0);
+    return {
+      placements: i,
+      metrics: {
+        volumeUtilization: g > 0 ? v / g : 0,
+        weightUtilization: t.maxWeight > 0 ? u / t.maxWeight : 0,
+        centerOfGravity: q(i),
+        stabilityScore: se(t, i)
+      },
+      unplacedBoxes: n
+    };
+  }
+}
+class xt {
+  id = "type-group";
+  name = "Agrupación por tipo";
+  pack(e, t) {
+    const i = [], n = [], r = [...e].sort((l, d) => {
+      const h = l.type ?? l.sku ?? "z", j = d.type ?? d.sku ?? "z";
+      return h !== j ? h.localeCompare(j) : l.fragile !== d.fragile ? l.fragile ? 1 : -1 : d.weight - l.weight;
+    });
+    let a = 0, f = 0, g = 0, v = 0, u = 0;
+    for (const l of r) {
+      const d = l.dimensions.width, h = l.dimensions.height, j = l.dimensions.depth;
+      if (a + d > t.dimensions.width && (a = 0, f += v > 0 ? j : 0), f + j > t.dimensions.depth && (a = 0, f = 0, g += v, v = 0), g + h > t.maxStackHeight) {
+        n.push(l);
+        continue;
+      }
+      if (a + d > t.dimensions.width) {
+        n.push(l);
+        continue;
+      }
+      if (f + j > t.dimensions.depth) {
+        n.push(l);
+        continue;
+      }
+      i.push({
+        id: `placed-${++u}`,
+        box: l,
+        position: { x: a, y: g, z: f },
+        rotation: { x: 0, y: 0, z: 0 },
+        supportedBy: [],
+        supporting: []
+      }), a += d, v = Math.max(v, h);
+    }
+    const x = t.dimensions.width * t.maxStackHeight * t.dimensions.depth, p = i.reduce((l, d) => {
+      const h = d.box.dimensions;
+      return l + h.width * h.height * h.depth;
+    }, 0), c = i.reduce((l, d) => l + d.box.weight, 0);
+    return {
+      placements: i,
+      metrics: {
+        volumeUtilization: x > 0 ? p / x : 0,
+        weightUtilization: t.maxWeight > 0 ? c / t.maxWeight : 0,
+        centerOfGravity: q(i),
+        stabilityScore: se(t, i)
+      },
+      unplacedBoxes: n
+    };
+  }
+}
+class gt {
+  strategies = /* @__PURE__ */ new Map();
+  constructor() {
+    this.register(new mt()), this.register(new ut()), this.register(new xt());
+  }
+  register(e) {
+    this.strategies.set(e.id, e);
+  }
+  get(e) {
+    const t = this.strategies.get(e);
+    if (!t)
+      throw new Error(`Packing strategy "${e}" not found. Available: ${this.listIds().join(", ")}`);
+    return t;
+  }
+  list() {
+    return Array.from(this.strategies.values());
+  }
+  listIds() {
+    return Array.from(this.strategies.keys());
+  }
+  has(e) {
+    return this.strategies.has(e);
+  }
+}
+const ft = new gt();
+let pt = 0;
+function Te() {
+  return `pallet-${++pt}`;
+}
+class Z {
+  // ═══ Palets estándar internacionales ═══════════════════════════
+  /** Palet EUR/EPAL — Estándar europeo (1200×800×144mm, ISO 6780, madera, 1000kg) */
+  static euro(e) {
+    return Z.fromPreset("EUR", e);
+  }
+  /** Palet GMA — Estándar norteamericano (1219×1016×145mm, 48"×40", madera, 1200kg) */
+  static gma(e) {
+    return Z.fromPreset("GMA", e);
+  }
+  /** @deprecated Use gma() instead. Alias para compatibilidad. */
+  static american(e) {
+    return Z.gma(e);
+  }
+  /** Palet UK Standard — Reino Unido (1200×1000×150mm, madera, 1000kg) */
+  static uk(e) {
+    return Z.fromPreset("UK", e);
+  }
+  /** Palet Asia — Estándar asiático (1100×1100×150mm, ISO 6780, madera, 1000kg) */
+  static asia(e) {
+    return Z.fromPreset("ASIA", e);
+  }
+  /** Palet australiano — Estándar de Australia (1165×1165×150mm, madera, 1000kg) */
+  static australian(e) {
+    return Z.fromPreset("AUSTRALIAN", e);
+  }
+  /** Medio palet EUR — Half European Pallet (800×600×144mm, madera, 500kg) */
+  static halfEuro(e) {
+    return Z.fromPreset("HALF_EUR", e);
+  }
+  /** Cuarto de palet EUR — Quarter European Pallet (600×400×144mm, madera, 250kg) */
+  static quarterEuro(e) {
+    return Z.fromPreset("QUARTER_EUR", e);
+  }
+  /** Palet ISO 1 — ISO 6780 (1200×1000×150mm, igual que UK) */
+  static iso1(e) {
+    return Z.fromPreset("ISO_1", e);
+  }
+  /** Palet ISO 2 — ISO 6780 (1200×800×144mm, equivalente a EUR) */
+  static iso2(e) {
+    return Z.fromPreset("ISO_2", e);
+  }
+  // ═══ Método genérico desde preset ═════════════════════════════
+  /**
+   * Crea un palet desde un preset por su clave
+   * @param presetKey - Clave del preset (EUR, GMA, UK, ASIA, etc.)
+   * @param overrides - Propiedades a sobrescribir
+   */
+  static fromPreset(e, t) {
+    const i = ue[e];
+    if (!i)
+      throw new Error(`Unknown pallet preset: ${e}`);
+    return {
+      id: Te(),
+      dimensions: { ...i.dimensions },
+      material: i.material,
+      maxWeight: i.maxWeight,
+      maxStackHeight: i.maxStackHeight,
+      weight: i.weight,
+      metadata: { preset: e },
+      ...t
+    };
+  }
+  // ═══ Palet custom ══════════════════════════════════════════════
+  /** Palet custom con dimensiones arbitrarias */
+  static custom(e, t) {
+    return {
+      id: Te(),
+      dimensions: { ...e },
+      material: L.WOOD,
+      maxWeight: 1e3,
+      maxStackHeight: 2200,
+      weight: 25,
+      metadata: {},
+      ...t
+    };
+  }
+  // ═══ Utilidades ════════════════════════════════════════════════
+  /**
+   * Lista todos los presets disponibles con sus características
+   */
+  static listPresets() {
+    return Object.entries(ue).map(([e, t]) => ({
+      key: e,
+      dimensions: t.dimensions,
+      maxWeight: t.maxWeight,
+      weight: t.weight
+    }));
+  }
+}
+let vt = 0;
+function ze() {
+  return `truck-${++vt}`;
+}
+class Gt {
+  /** Crea un camión a partir de un preset de tipo */
+  static fromPreset(e, t) {
+    const i = Ze[e];
+    return {
+      id: ze(),
+      name: `Camión ${e}`,
+      truckType: e,
+      dimensions: { ...i.dimensions },
+      maxWeight: i.maxWeight,
+      pallets: [],
+      metadata: {},
+      ...t
+    };
+  }
+  /** Crea un camión custom con dimensiones y peso arbitrarios */
+  static custom(e, t, i) {
+    return {
+      id: ze(),
+      name: "Camión Custom",
+      truckType: ie.CUSTOM,
+      dimensions: { ...e },
+      maxWeight: t,
+      pallets: [],
+      metadata: {},
+      ...i
+    };
+  }
+}
+let wt = 0;
+function yt() {
+  return `box-${++wt}`;
+}
+class ge {
+  /** Crea una caja con valores por defecto razonables */
+  static create(e, t) {
+    return {
+      id: yt(),
+      dimensions: { ...e },
+      weight: 5,
+      fragile: !1,
+      stackable: !0,
+      metadata: {},
+      ...t
+    };
+  }
+  /** Caja frágil con peso máximo encima */
+  static fragile(e, t, i) {
+    return ge.create(e, {
+      fragile: !0,
+      fragilityMaxWeight: t,
+      ...i
+    });
+  }
+  /** Caja pesada y no apilable */
+  static heavy(e, t, i) {
+    return ge.create(e, {
+      weight: t,
+      stackable: !1,
+      ...i
+    });
+  }
+}
+function Vt(o, e) {
+  return k(() => {
+    const t = Je(o), i = et(o, e), r = it({ pallet: e, boxes: o }), a = ct(o), f = rt(o), g = at(o), v = dt(e, o), u = lt(e, o), x = ot(o), p = nt(e, o), c = [...f.violations, ...g.violations], l = [...v.violations, ...u.violations], d = [
+      ...t.violations,
+      ...i.violations,
+      ...r.violations,
+      ...a.violations,
+      ...c,
+      ...l,
+      ...x.violations,
+      ...p.violations
+    ];
+    return {
+      isValid: d.filter((h) => h.severity === "error").length === 0,
+      violations: d,
+      collisions: t,
+      bounds: i,
+      weight: r,
+      gravity: a,
+      stacking: {
+        isValid: f.isValid,
+        violations: c
+      },
+      stability: {
+        isValid: v.isValid && u.isValid,
+        violations: l
+      },
+      fragile: x,
+      distribution: p
+    };
+  }, [o, e]);
+}
+function Xt(o) {
+  return k(() => {
+    if (!o || o.floors.length === 0)
+      return {
+        volumeUtilization: 0,
+        weightUtilization: 0,
+        centerOfGravity: { x: 0, y: 0, z: 0 },
+        stabilityScore: 100,
+        totalHeight: 0,
+        totalWeight: 0,
+        boxCount: 0,
+        floorCount: 0
+      };
+    const e = le(o), t = we(o), i = o.floors[0].pallet, n = o.floors.flatMap((x) => x.boxes), r = n.length, a = o.floors.length, f = i.dimensions.width * i.maxStackHeight * i.dimensions.depth, g = n.reduce((x, p) => {
+      const c = p.box.dimensions;
+      return x + c.width * c.height * c.depth;
+    }, 0), v = q(n), u = se(i, n);
+    return {
+      volumeUtilization: f > 0 ? g / f : 0,
+      weightUtilization: i.maxWeight > 0 ? t / i.maxWeight : 0,
+      centerOfGravity: v,
+      stabilityScore: u,
+      totalHeight: e,
+      totalWeight: t,
+      boxCount: r,
+      floorCount: a
+    };
+  }, [o]);
+}
+function Zt(o, e = ft) {
+  const t = k(
+    () => e.list().map((n) => ({ id: n.id, name: n.name })),
+    [e]
+  ), i = H(
+    (n, r) => e.get(o).pack(n, r),
+    [o, e]
+  );
+  return { availableStrategies: t, pack: i };
+}
+function Nt(o) {
+  return k(() => {
+    const e = [];
+    for (const n of o.pallets) {
+      const r = We(n, o);
+      e.push(...r.violations);
+    }
+    const t = Qe(o.pallets), i = [
+      ...e,
+      ...t.violations
+    ];
+    return {
+      isValid: i.filter((n) => n.severity === "error").length === 0,
+      violations: i,
+      palletInRoom: {
+        isValid: e.length === 0,
+        violations: e
+      },
+      palletCollisions: t
+    };
+  }, [o]);
+}
+const bt = V(function({
+  placedBox: e,
+  selected: t = !1,
+  highlighted: i = !1,
+  showLabel: n = !1,
+  color: r,
+  opacity: a,
+  selectedColor: f,
+  highlightedColor: g,
+  onClick: v,
+  onHover: u
+}) {
+  const x = Ee(null), p = ce(), { box: c, position: l, rotation: d } = e, h = Y.MM_TO_M, j = r ?? c.color ?? p.box.color, T = a ?? p.box.opacity, z = f ?? p.selection.selectedColor, b = g ?? p.selection.highlightedColor;
+  let M = c.dimensions.width, _ = c.dimensions.depth;
+  (d.y === 90 || d.y === 270) && ([M, _] = [_, M]);
+  const y = k(
+    () => [M * h, c.dimensions.height * h, _ * h],
+    [M, _, c.dimensions.height, h]
+  ), w = k(
+    () => new $.Vector3(
+      l.x * h + y[0] / 2,
+      l.y * h + y[1] / 2,
+      l.z * h + y[2] / 2
+    ),
+    [l, y, h]
+  ), S = t ? z : i ? b : null, E = H(
+    (P) => {
+      P.stopPropagation(), v?.(e.id);
+    },
+    [v, e.id]
+  ), R = H(
+    (P) => {
+      P.stopPropagation(), u?.(e.id);
+    },
+    [u, e.id]
+  ), O = H(() => {
+    u?.(null);
+  }, [u]);
+  return /* @__PURE__ */ s.jsxs("group", { children: [
+    /* @__PURE__ */ s.jsxs(
+      "mesh",
+      {
+        ref: x,
+        position: w,
+        onClick: E,
+        onPointerOver: R,
+        onPointerOut: O,
+        castShadow: !0,
+        receiveShadow: !0,
+        children: [
+          /* @__PURE__ */ s.jsx("boxGeometry", { args: y }),
+          /* @__PURE__ */ s.jsx(
+            "meshStandardMaterial",
+            {
+              color: j,
+              transparent: T < 1,
+              opacity: T,
+              roughness: p.box.roughness,
+              metalness: p.box.metalness
+            }
+          )
+        ]
+      }
+    ),
+    S && /* @__PURE__ */ s.jsxs("mesh", { position: w, children: [
+      /* @__PURE__ */ s.jsx("boxGeometry", { args: y }),
+      /* @__PURE__ */ s.jsx(
+        "meshBasicMaterial",
+        {
+          color: S,
+          wireframe: !0,
+          wireframeLinewidth: 1,
+          transparent: !0,
+          opacity: 0.9,
+          depthTest: !1
+        }
+      )
+    ] }),
+    S && /* @__PURE__ */ s.jsxs("lineSegments", { position: w, renderOrder: 999, children: [
+      /* @__PURE__ */ s.jsx("edgesGeometry", { args: [new $.BoxGeometry(...y)] }),
+      /* @__PURE__ */ s.jsx("lineBasicMaterial", { color: S })
+    ] }),
+    n && /* @__PURE__ */ s.jsx(
+      ke,
+      {
+        position: [w.x, w.y + y[1] / 2 + 0.05, w.z],
+        center: !0,
+        style: {
+          background: "rgba(0,0,0,0.75)",
+          color: "white",
+          padding: "2px 6px",
+          borderRadius: "3px",
+          fontSize: "11px",
+          whiteSpace: "nowrap",
+          pointerEvents: "none"
+        },
+        children: c.sku ?? c.type ?? c.id
+      }
+    )
+  ] });
+}), jt = V(function({
+  pallet: e,
+  position: t = { x: 0, y: 0, z: 0 },
+  color: i,
+  edgeColor: n
+}) {
+  const r = ce(), a = i ?? r.pallet.color, f = n ?? r.pallet.edgeColor, g = Y.MM_TO_M, v = e.dimensions, u = k(
+    () => [v.width * g, v.height * g, v.depth * g],
+    [v, g]
+  ), x = k(
+    () => new $.Vector3(
+      t.x * g + u[0] / 2,
+      t.y * g + u[1] / 2,
+      t.z * g + u[2] / 2
+    ),
+    [t, u, g]
+  );
+  return /* @__PURE__ */ s.jsxs("group", { children: [
+    /* @__PURE__ */ s.jsxs("mesh", { position: x, castShadow: !0, receiveShadow: !0, children: [
+      /* @__PURE__ */ s.jsx("boxGeometry", { args: u }),
+      /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: a, roughness: r.pallet.roughness, metalness: r.pallet.metalness })
+    ] }),
+    /* @__PURE__ */ s.jsxs("lineSegments", { position: x, children: [
+      /* @__PURE__ */ s.jsx("edgesGeometry", { args: [new $.BoxGeometry(...u)] }),
+      /* @__PURE__ */ s.jsx("lineBasicMaterial", { color: f })
+    ] })
+  ] });
+}), St = {
+  [me.CARDBOARD]: "#b5926b",
+  [me.WOOD]: "#c4a26e",
+  [me.PLASTIC]: "#90a4ae"
+}, Ct = V(function({
+  separator: e,
+  position: t = { x: 0, y: 0, z: 0 }
+}) {
+  const i = Y.MM_TO_M, n = e.dimensions, r = k(
+    () => [n.width * i, n.height * i, n.depth * i],
+    [n, i]
+  ), a = k(
+    () => new $.Vector3(
+      t.x * i + r[0] / 2,
+      t.y * i + r[1] / 2,
+      t.z * i + r[2] / 2
+    ),
+    [t, r, i]
+  ), f = St[e.material];
+  return /* @__PURE__ */ s.jsxs("mesh", { position: a, receiveShadow: !0, children: [
+    /* @__PURE__ */ s.jsx("boxGeometry", { args: r }),
+    /* @__PURE__ */ s.jsx(
+      "meshStandardMaterial",
+      {
+        color: f,
+        roughness: 0.9,
+        metalness: 0,
+        transparent: !0,
+        opacity: 0.85
+      }
+    )
+  ] });
+}), be = V(
+  function({
+    stackedPallet: e,
+    position: t = { x: 0, y: 0, z: 0 },
+    yRotation: i = 0,
+    palletId: n,
+    selectedBoxId: r,
+    highlightedBoxId: a,
+    selectedColor: f,
+    highlightedColor: g,
+    showLabels: v = !1,
+    onBoxClick: u,
+    onBoxHover: x
+  }) {
+    const p = k(
+      () => qe(e, n),
+      [e, n]
+    ), c = Y.MM_TO_M, l = k(() => i * Math.PI / 180, [i]), d = k(() => {
+      const h = [];
+      let j = 0;
+      for (const T of p.floors) {
+        h.push(j), j += T.pallet.dimensions.height;
+        const z = T.boxes.reduce(
+          (b, M) => Math.max(b, M.position.y + M.box.dimensions.height),
+          0
+        );
+        j += z, T.separatorAbove && (j += T.separatorAbove.dimensions.height);
+      }
+      return h;
+    }, [p]);
+    return /* @__PURE__ */ s.jsx(
+      "group",
+      {
+        position: [t.x * c, t.y * c, t.z * c],
+        rotation: [0, l, 0],
+        children: p.floors.map((h, j) => {
+          const T = d[j], z = T + h.pallet.dimensions.height;
+          return /* @__PURE__ */ s.jsxs("group", { children: [
+            /* @__PURE__ */ s.jsx(
+              jt,
+              {
+                pallet: h.pallet,
+                position: { x: 0, y: T, z: 0 }
+              }
+            ),
+            h.boxes.map((b) => /* @__PURE__ */ s.jsx(
+              bt,
+              {
+                placedBox: {
+                  ...b,
+                  position: {
+                    x: b.position.x,
+                    y: b.position.y + z,
+                    z: b.position.z
+                  }
+                },
+                selected: r === b.id,
+                highlighted: a === b.id,
+                selectedColor: f,
+                highlightedColor: g,
+                showLabel: v,
+                onClick: u,
+                onHover: x
+              },
+              b.id
+            )),
+            h.separatorAbove && /* @__PURE__ */ s.jsx(
+              Ct,
+              {
+                separator: h.separatorAbove,
+                position: {
+                  x: 0,
+                  y: z + h.boxes.reduce(
+                    (b, M) => Math.max(b, M.position.y + M.box.dimensions.height),
+                    0
+                  ),
+                  z: 0
+                }
+              }
+            )
+          ] }, `floor-${j}`);
+        })
+      }
+    );
+  }
+), Lt = V(function({
+  text: e,
+  position: t,
+  visible: i = !0,
+  fontSize: n = 12,
+  color: r = "white",
+  background: a = "rgba(0,0,0,0.75)"
+}) {
+  if (!i) return null;
+  const f = Y.MM_TO_M;
+  return /* @__PURE__ */ s.jsx(
+    ke,
+    {
+      position: [t.x * f, t.y * f, t.z * f],
+      center: !0,
+      style: {
+        background: a,
+        color: r,
+        padding: "2px 8px",
+        borderRadius: "4px",
+        fontSize: `${n}px`,
+        whiteSpace: "nowrap",
+        pointerEvents: "none",
+        userSelect: "none"
+      },
+      children: e
+    }
+  );
+}), Mt = V(
+  function({
+    room: e,
+    floorColor: t,
+    wallColor: i,
+    showGrid: n,
+    children: r
+  }) {
+    const a = ce(), f = t ?? a.warehouse.floorColor, g = i ?? a.warehouse.wallColor, v = n ?? a.warehouse.showGrid, u = Y.MM_TO_M, x = e.ceilingHeight * u, { shape: p, minX: c, maxX: l, minZ: d, maxZ: h } = k(() => {
+      const y = e.floorPolygon;
+      let w = 1 / 0, S = -1 / 0, E = 1 / 0, R = -1 / 0;
+      for (const P of y)
+        w = Math.min(w, P.x * u), S = Math.max(S, P.x * u), E = Math.min(E, P.z * u), R = Math.max(R, P.z * u);
+      const O = new $.Shape();
+      O.moveTo(y[0].x * u, -y[0].z * u);
+      for (let P = 1; P < y.length; P++)
+        O.lineTo(y[P].x * u, -y[P].z * u);
+      return O.closePath(), { shape: O, minX: w, maxX: S, minZ: E, maxZ: R };
+    }, [e.floorPolygon, u]), j = k(() => {
+      const y = e.floorPolygon, w = [], S = [];
+      for (let R = 0; R < y.length; R++) {
+        const O = y[R], P = y[(R + 1) % y.length], A = R * 4;
+        w.push(
+          O.x * u,
+          0,
+          O.z * u,
+          P.x * u,
+          0,
+          P.z * u,
+          P.x * u,
+          x,
+          P.z * u,
+          O.x * u,
+          x,
+          O.z * u
+        ), S.push(
+          A,
+          A + 1,
+          A + 2,
+          A,
+          A + 2,
+          A + 3
+        );
+      }
+      const E = new $.BufferGeometry();
+      return E.setAttribute("position", new $.Float32BufferAttribute(w, 3)), E.setIndex(S), E.computeVertexNormals(), E;
+    }, [e.floorPolygon, x, u]), T = l - c, z = h - d, b = (c + l) / 2, M = (d + h) / 2, _ = k(() => {
+      if (!v) return null;
+      const y = 0.5, w = 0.01, S = [];
+      for (let R = c; R <= l; R += y)
+        S.push(R, w, d, R, w, h);
+      for (let R = d; R <= h; R += y)
+        S.push(c, w, R, l, w, R);
+      const E = new $.BufferGeometry();
+      return E.setAttribute("position", new $.Float32BufferAttribute(S, 3)), E;
+    }, [v, c, l, d, h]);
+    return /* @__PURE__ */ s.jsxs("group", { children: [
+      /* @__PURE__ */ s.jsxs("mesh", { rotation: [-Math.PI / 2, 0, 0], position: [0, -5e-3, 0], receiveShadow: !0, children: [
+        /* @__PURE__ */ s.jsx("shapeGeometry", { args: [p] }),
+        /* @__PURE__ */ s.jsx(
+          "meshStandardMaterial",
+          {
+            color: f,
+            side: $.DoubleSide,
+            roughness: a.warehouse.floorRoughness
+          }
+        )
+      ] }),
+      /* @__PURE__ */ s.jsx("mesh", { geometry: j, position: [0, 0, 0], receiveShadow: !0, children: /* @__PURE__ */ s.jsx(
+        "meshStandardMaterial",
+        {
+          color: g,
+          side: $.DoubleSide,
+          roughness: 0.7,
+          transparent: !0,
+          opacity: a.warehouse.wallOpacity
+        }
+      ) }),
+      v && _ && /* @__PURE__ */ s.jsx("lineSegments", { geometry: _, children: /* @__PURE__ */ s.jsx(
+        "lineBasicMaterial",
+        {
+          color: a.warehouse.gridColor,
+          opacity: 0.5,
+          transparent: !0,
+          depthWrite: !1
+        }
+      ) }),
+      /* @__PURE__ */ s.jsx("ambientLight", { intensity: a.warehouse.ambientIntensity }),
+      /* @__PURE__ */ s.jsx(
+        "directionalLight",
+        {
+          position: [b + T, x * 0.8, M + z],
+          intensity: a.warehouse.directionalIntensity,
+          castShadow: !0,
+          "shadow-mapSize-width": 1024,
+          "shadow-mapSize-height": 1024
+        }
+      ),
+      /* @__PURE__ */ s.jsx(
+        "pointLight",
+        {
+          position: [b, x * 0.9, M],
+          intensity: 0.5,
+          distance: Math.max(T, z) * 2
+        }
+      ),
+      r
+    ] });
+  }
+), K = V(function({ position: e, radius: t, width: i, color: n }) {
+  return /* @__PURE__ */ s.jsxs("group", { position: e, children: [
+    /* @__PURE__ */ s.jsxs("mesh", { rotation: [0, 0, Math.PI / 2], castShadow: !0, children: [
+      /* @__PURE__ */ s.jsx("cylinderGeometry", { args: [t, t, i, 24] }),
+      /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: n, roughness: 0.9, metalness: 0.1 })
+    ] }),
+    /* @__PURE__ */ s.jsxs("mesh", { rotation: [0, 0, Math.PI / 2], children: [
+      /* @__PURE__ */ s.jsx("cylinderGeometry", { args: [t * 0.55, t * 0.55, i + 5e-3, 16] }),
+      /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: "#888888", roughness: 0.3, metalness: 0.7 })
+    ] })
+  ] });
+}), Pt = V(function({
+  truck: e,
+  showGrid: t,
+  wallOpacity: i = 0.3,
+  showRoof: n = !1,
+  showSideWalls: r = !0,
+  children: a
+}) {
+  const g = ce().truck, v = t ?? g.showGrid, u = Y.MM_TO_M, x = e.dimensions.width * u, p = e.dimensions.height * u, c = e.dimensions.depth * u, l = 0.05, d = 0.08, h = 0.28, j = 0.18, T = 0.15, z = 0.25, b = h + T, M = b + h + 0.1, _ = M + z / 2 + d / 2, y = x + l * 2, w = x * 0.65, S = p * 0.85, E = 0.15, R = c + l + E, O = _, P = k(() => {
+    if (!v) return null;
+    const G = 0.5, N = _ + 2e-3, U = [];
+    for (let X = 0; X <= x; X += G)
+      U.push(X, N, 0, X, N, c);
+    for (let X = 0; X <= c; X += G)
+      U.push(0, N, X, x, N, X);
+    const F = new $.BufferGeometry();
+    return F.setAttribute("position", new $.Float32BufferAttribute(U, 3)), F;
+  }, [v, x, c, _]), A = k(
+    () => /* @__PURE__ */ s.jsx(
+      "meshStandardMaterial",
+      {
+        color: g.wallColor,
+        roughness: 0.5,
+        metalness: 0.3,
+        transparent: i < 1,
+        opacity: i,
+        side: $.DoubleSide,
+        depthWrite: i >= 0.95
+      }
+    ),
+    [g.wallColor, i]
+  );
+  return /* @__PURE__ */ s.jsxs("group", { children: [
+    /* @__PURE__ */ s.jsxs(
+      "mesh",
+      {
+        position: [x / 2, _, c / 2],
+        rotation: [-Math.PI / 2, 0, 0],
+        receiveShadow: !0,
+        children: [
+          /* @__PURE__ */ s.jsx("planeGeometry", { args: [x, c] }),
+          /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: g.floorColor, roughness: 0.85 })
+        ]
+      }
+    ),
+    /* @__PURE__ */ s.jsxs("mesh", { position: [x / 2, _ - d / 2, c / 2], castShadow: !0, receiveShadow: !0, children: [
+      /* @__PURE__ */ s.jsx("boxGeometry", { args: [x + l * 2, d, c + l] }),
+      /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: g.floorColor, roughness: 0.85, metalness: 0.1 })
+    ] }),
+    r && /* @__PURE__ */ s.jsxs("mesh", { position: [-l / 2, _ + p / 2, c / 2], castShadow: !0, children: [
+      /* @__PURE__ */ s.jsx("boxGeometry", { args: [l, p, c + l] }),
+      A
+    ] }),
+    r && /* @__PURE__ */ s.jsxs("mesh", { position: [x + l / 2, _ + p / 2, c / 2], castShadow: !0, children: [
+      /* @__PURE__ */ s.jsx("boxGeometry", { args: [l, p, c + l] }),
+      A
+    ] }),
+    /* @__PURE__ */ s.jsxs("mesh", { position: [x / 2, _ + p / 2, c + l / 2], castShadow: !0, children: [
+      /* @__PURE__ */ s.jsx("boxGeometry", { args: [x + l * 2, p, l] }),
+      A
+    ] }),
+    n && /* @__PURE__ */ s.jsxs("mesh", { position: [x / 2, _ + p, c / 2], castShadow: !0, children: [
+      /* @__PURE__ */ s.jsx("boxGeometry", { args: [x + l * 2, l, c + l] }),
+      A
+    ] }),
+    v && P && /* @__PURE__ */ s.jsx("lineSegments", { geometry: P, children: /* @__PURE__ */ s.jsx(
+      "lineBasicMaterial",
+      {
+        color: g.gridColor,
+        opacity: 0.5,
+        transparent: !0,
+        depthWrite: !1
+      }
+    ) }),
+    /* @__PURE__ */ s.jsxs("mesh", { position: [x * 0.25, M, (c + w + E) / 2], castShadow: !0, children: [
+      /* @__PURE__ */ s.jsx("boxGeometry", { args: [0.12, z, c + w + E] }),
+      /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: g.chassisColor, roughness: 0.7, metalness: 0.5 })
+    ] }),
+    /* @__PURE__ */ s.jsxs("mesh", { position: [x * 0.75, M, (c + w + E) / 2], castShadow: !0, children: [
+      /* @__PURE__ */ s.jsx("boxGeometry", { args: [0.12, z, c + w + E] }),
+      /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: g.chassisColor, roughness: 0.7, metalness: 0.5 })
+    ] }),
+    [0.15, 0.35, 0.55, 0.75, 0.95].map((G) => /* @__PURE__ */ s.jsxs("mesh", { position: [x / 2, M, c * G], castShadow: !0, children: [
+      /* @__PURE__ */ s.jsx("boxGeometry", { args: [x * 0.6, 0.06, 0.06] }),
+      /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: g.chassisColor, roughness: 0.7, metalness: 0.5 })
+    ] }, G)),
+    /* @__PURE__ */ s.jsx(K, { position: [-j / 2 - l, b, c * 0.12], radius: h, width: j, color: g.wheelColor }),
+    /* @__PURE__ */ s.jsx(K, { position: [x + j / 2 + l, b, c * 0.12], radius: h, width: j, color: g.wheelColor }),
+    /* @__PURE__ */ s.jsx(K, { position: [-j / 2 - l, b, c * 0.22], radius: h, width: j, color: g.wheelColor }),
+    /* @__PURE__ */ s.jsx(K, { position: [x + j / 2 + l, b, c * 0.22], radius: h, width: j, color: g.wheelColor }),
+    /* @__PURE__ */ s.jsx(K, { position: [-j / 2 - l, b, R + w * 0.5], radius: h, width: j, color: g.wheelColor }),
+    /* @__PURE__ */ s.jsx(K, { position: [x + j / 2 + l, b, R + w * 0.5], radius: h, width: j, color: g.wheelColor }),
+    /* @__PURE__ */ s.jsxs("group", { position: [x / 2, O, R], children: [
+      /* @__PURE__ */ s.jsxs("mesh", { position: [0, S / 2, w / 2], castShadow: !0, receiveShadow: !0, children: [
+        /* @__PURE__ */ s.jsx("boxGeometry", { args: [y, S, w] }),
+        /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: g.cabColor, roughness: 0.4, metalness: 0.3 })
+      ] }),
+      /* @__PURE__ */ s.jsxs(
+        "mesh",
+        {
+          position: [0, S * 0.6, w + 0.01],
+          castShadow: !0,
+          children: [
+            /* @__PURE__ */ s.jsx("planeGeometry", { args: [y * 0.75, S * 0.4] }),
+            /* @__PURE__ */ s.jsx(
+              "meshStandardMaterial",
+              {
+                color: "#88bbdd",
+                transparent: !0,
+                opacity: 0.5,
+                roughness: 0.1,
+                metalness: 0.6,
+                side: $.DoubleSide
+              }
+            )
+          ]
+        }
+      ),
+      /* @__PURE__ */ s.jsxs("mesh", { position: [-y / 2 - 0.01, S * 0.6, w * 0.55], rotation: [0, Math.PI / 2, 0], children: [
+        /* @__PURE__ */ s.jsx("planeGeometry", { args: [w * 0.5, S * 0.3] }),
+        /* @__PURE__ */ s.jsx(
+          "meshStandardMaterial",
+          {
+            color: "#88bbdd",
+            transparent: !0,
+            opacity: 0.4,
+            roughness: 0.1,
+            metalness: 0.6,
+            side: $.DoubleSide
+          }
+        )
+      ] }),
+      /* @__PURE__ */ s.jsxs("mesh", { position: [y / 2 + 0.01, S * 0.6, w * 0.55], rotation: [0, -Math.PI / 2, 0], children: [
+        /* @__PURE__ */ s.jsx("planeGeometry", { args: [w * 0.5, S * 0.3] }),
+        /* @__PURE__ */ s.jsx(
+          "meshStandardMaterial",
+          {
+            color: "#88bbdd",
+            transparent: !0,
+            opacity: 0.4,
+            roughness: 0.1,
+            metalness: 0.6,
+            side: $.DoubleSide
+          }
+        )
+      ] }),
+      /* @__PURE__ */ s.jsxs("mesh", { position: [0, S + 0.04, w / 2], children: [
+        /* @__PURE__ */ s.jsx("boxGeometry", { args: [y * 0.95, 0.08, w * 0.9] }),
+        /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: g.cabColor, roughness: 0.4, metalness: 0.3 })
+      ] }),
+      /* @__PURE__ */ s.jsxs("mesh", { position: [0, S + 0.25, w * 0.1], rotation: [-0.3, 0, 0], children: [
+        /* @__PURE__ */ s.jsx("boxGeometry", { args: [y * 0.9, 0.04, w * 0.5] }),
+        /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: g.cabColor, roughness: 0.4, metalness: 0.3 })
+      ] }),
+      /* @__PURE__ */ s.jsxs("mesh", { position: [-y * 0.35, S * 0.2, w + 0.02], children: [
+        /* @__PURE__ */ s.jsx("boxGeometry", { args: [y * 0.15, 0.08, 0.02] }),
+        /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: "#ffffcc", emissive: "#ffffaa", emissiveIntensity: 0.3 })
+      ] }),
+      /* @__PURE__ */ s.jsxs("mesh", { position: [y * 0.35, S * 0.2, w + 0.02], children: [
+        /* @__PURE__ */ s.jsx("boxGeometry", { args: [y * 0.15, 0.08, 0.02] }),
+        /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: "#ffffcc", emissive: "#ffffaa", emissiveIntensity: 0.3 })
+      ] }),
+      /* @__PURE__ */ s.jsxs("mesh", { position: [0, 0.06, w + 0.04], castShadow: !0, children: [
+        /* @__PURE__ */ s.jsx("boxGeometry", { args: [y * 1.02, 0.12, 0.06] }),
+        /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: g.chassisColor, roughness: 0.5, metalness: 0.6 })
+      ] })
+    ] }),
+    [-1, 1].map((G) => /* @__PURE__ */ s.jsxs(
+      "mesh",
+      {
+        position: [
+          G === -1 ? -l - j * 0.5 : x + l + j * 0.5,
+          b + h * 0.6,
+          c * 0.17
+        ],
+        castShadow: !0,
+        children: [
+          /* @__PURE__ */ s.jsx("boxGeometry", { args: [j + 0.04, 0.04, h * 2.5] }),
+          /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: g.chassisColor, roughness: 0.6, metalness: 0.4 })
+        ]
+      },
+      `fender-rear-${G}`
+    )),
+    /* @__PURE__ */ s.jsxs("mesh", { position: [-l / 2 + 0.01, _ + p * 0.3, -0.01], children: [
+      /* @__PURE__ */ s.jsx("boxGeometry", { args: [0.08, 0.12, 0.02] }),
+      /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: "#ff3333", emissive: "#ff0000", emissiveIntensity: 0.3 })
+    ] }),
+    /* @__PURE__ */ s.jsxs("mesh", { position: [x + l / 2 - 0.01, _ + p * 0.3, -0.01], children: [
+      /* @__PURE__ */ s.jsx("boxGeometry", { args: [0.08, 0.12, 0.02] }),
+      /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: "#ff3333", emissive: "#ff0000", emissiveIntensity: 0.3 })
+    ] }),
+    /* @__PURE__ */ s.jsx("ambientLight", { intensity: 0.45 }),
+    /* @__PURE__ */ s.jsx(
+      "directionalLight",
+      {
+        position: [x / 2, _ + p * 1.5, c * 0.8],
+        intensity: 0.75,
+        castShadow: !0,
+        "shadow-mapSize-width": 1024,
+        "shadow-mapSize-height": 1024
+      }
+    ),
+    /* @__PURE__ */ s.jsx("pointLight", { position: [x / 2, _ + p * 0.7, c / 2], intensity: 0.35 }),
+    /* @__PURE__ */ s.jsx("pointLight", { position: [x / 2, _ + p * 0.9, c * 0.3], intensity: 0.25 }),
+    /* @__PURE__ */ s.jsx("group", { position: [0, _, 0], children: a })
+  ] });
+});
+function Rt(o, e, t) {
+  if (!t)
+    return {
+      perspective: [3, 3, 3],
+      isometric: [4, 4, 4],
+      top: [0, 5, 0],
+      front: [0, 1.5, 5],
+      side: [5, 1.5, 0]
+    }[o];
+  const { width: i, height: n, depth: r } = t, [a, f, g] = e, u = Math.sqrt(i ** 2 + n ** 2 + r ** 2) * 3;
+  switch (o) {
+    case "perspective":
+      return [
+        a + u * 0.6,
+        f + u * 0.5,
+        g + u * 0.6
+      ];
+    case "isometric":
+      return [
+        a + u * 0.577,
+        f + u * 0.577,
+        g + u * 0.577
+      ];
+    case "top":
+      return [a, f + Math.max(u, n * 2), g];
+    case "front":
+      return [a, f + n * 0.5, g + Math.max(u, r * 1.5)];
+    case "side":
+      return [a + Math.max(u, i * 1.5), f + n * 0.5, g];
+  }
+}
+const je = V(function({
+  preset: e = "perspective",
+  autoRotate: t = !1,
+  enablePan: i = !0,
+  enableZoom: n = !0,
+  target: r = [0, 0, 0],
+  minDistance: a = 0.5,
+  maxDistance: f = 50,
+  sceneSize: g
+}) {
+  const { camera: v } = Ae(), u = Ee(null);
+  return fe(() => {
+    const x = Rt(e, r, g), p = new $.Vector3(x[0], x[1], x[2]), c = new $.Vector3(...r), l = v.position.clone(), d = 1e3, h = Date.now(), j = () => {
+      const T = Date.now() - h, z = Math.min(T / d, 1), b = 1 - Math.pow(1 - z, 3);
+      v.position.lerpVectors(l, p, b), u.current && (u.current.target.lerp(c, b), u.current.update()), z < 1 && requestAnimationFrame(j);
+    };
+    j();
+  }, [e, g, v, r]), /* @__PURE__ */ s.jsx(
+    Xe,
+    {
+      ref: u,
+      target: r,
+      autoRotate: t,
+      autoRotateSpeed: 0.5,
+      enablePan: i,
+      enableZoom: n,
+      enableRotate: !0,
+      minDistance: a,
+      maxDistance: f,
+      enableDamping: !0,
+      dampingFactor: 0.05,
+      rotateSpeed: 0.5,
+      zoomSpeed: 0.8,
+      panSpeed: 0.5,
+      makeDefault: !0
+    }
+  );
+}), _t = {
+  perspective: { label: "Perspectiva", icon: "📐" },
+  isometric: { label: "Isométrica", icon: "🔲" },
+  top: { label: "Superior", icon: "⬇️" },
+  front: { label: "Frontal", icon: "➡️" },
+  side: { label: "Lateral", icon: "⬅️" }
+};
+V(function({
+  currentPreset: e,
+  onPresetChange: t,
+  position: i = "top-right"
+}) {
+  const n = ["perspective", "isometric", "top", "front", "side"];
+  return /* @__PURE__ */ s.jsxs("div", { className: `view-controls view-controls--${i}`, children: [
+    /* @__PURE__ */ s.jsx("div", { className: "view-controls__title", children: "Vista" }),
+    /* @__PURE__ */ s.jsx("div", { className: "view-controls__buttons", children: n.map((r) => {
+      const { label: a, icon: f } = _t[r], g = e === r;
+      return /* @__PURE__ */ s.jsxs(
+        "button",
+        {
+          className: `view-controls__button ${g ? "view-controls__button--active" : ""}`,
+          onClick: () => t(r),
+          title: a,
+          "aria-label": a,
+          children: [
+            /* @__PURE__ */ s.jsx("span", { className: "view-controls__icon", role: "img", "aria-hidden": "true", children: f }),
+            /* @__PURE__ */ s.jsx("span", { className: "view-controls__label", children: a })
+          ]
+        },
+        r
+      );
+    }) })
+  ] });
+});
+const Se = V(function({
+  sceneWidth: e,
+  sceneDepth: t,
+  sceneType: i,
+  floorPolygon: n,
+  cameraPosition: r,
+  targetPosition: a,
+  position: f = "bottom-left"
+}) {
+  const u = k(() => 130 / Math.max(e, t), [e, t]), x = (h, j) => ({
+    x: 10 + h * u,
+    y: 10 + j * u
+  }), p = k(() => i !== "warehouse" || !n || n.length === 0 ? "" : `M ${n.map((j) => {
+    const T = x(j.x, j.z);
+    return `${T.x},${T.y}`;
+  }).join(" L ")} Z`, [i, n, u]), c = k(() => {
+    if (i !== "truck") return null;
+    const h = x(0, 0);
+    return {
+      x: h.x,
+      y: h.y,
+      width: e * u,
+      height: t * u
+    };
+  }, [i, e, t, u]), l = r ? x(r.x, r.z) : null, d = a ? x(a.x, a.z) : null;
+  return /* @__PURE__ */ s.jsxs("div", { className: `minimap minimap--${f}`, children: [
+    /* @__PURE__ */ s.jsx("div", { className: "minimap__title", children: "Mapa" }),
+    /* @__PURE__ */ s.jsxs(
+      "svg",
+      {
+        className: "minimap__canvas",
+        width: 150,
+        height: 150,
+        viewBox: "0 0 150 150",
+        xmlns: "http://www.w3.org/2000/svg",
+        children: [
+          /* @__PURE__ */ s.jsx("rect", { width: 150, height: 150, fill: "#1a1a2e" }),
+          i === "warehouse" && p && /* @__PURE__ */ s.jsx("path", { d: p, fill: "rgba(96, 165, 250, 0.15)", stroke: "#60a5fa", strokeWidth: "2" }),
+          i === "truck" && c && /* @__PURE__ */ s.jsx(
+            "rect",
+            {
+              x: c.x,
+              y: c.y,
+              width: c.width,
+              height: c.height,
+              fill: "rgba(96, 165, 250, 0.15)",
+              stroke: "#60a5fa",
+              strokeWidth: "2"
+            }
+          ),
+          /* @__PURE__ */ s.jsx("defs", { children: /* @__PURE__ */ s.jsx(
+            "pattern",
+            {
+              id: "minimap-grid",
+              width: u,
+              height: u,
+              patternUnits: "userSpaceOnUse",
+              children: /* @__PURE__ */ s.jsx(
+                "path",
+                {
+                  d: `M ${u} 0 L 0 0 0 ${u}`,
+                  fill: "none",
+                  stroke: "rgba(255, 255, 255, 0.08)",
+                  strokeWidth: "0.5"
+                }
+              )
+            }
+          ) }),
+          i === "truck" && c && /* @__PURE__ */ s.jsx(
+            "rect",
+            {
+              x: c.x,
+              y: c.y,
+              width: c.width,
+              height: c.height,
+              fill: "url(#minimap-grid)"
+            }
+          ),
+          d && /* @__PURE__ */ s.jsxs("g", { children: [
+            /* @__PURE__ */ s.jsx("circle", { cx: d.x, cy: d.y, r: "3", fill: "#f87171", opacity: "0.6" }),
+            /* @__PURE__ */ s.jsx("circle", { cx: d.x, cy: d.y, r: "5", fill: "none", stroke: "#f87171", strokeWidth: "1.5" })
+          ] }),
+          l && /* @__PURE__ */ s.jsxs("g", { children: [
+            /* @__PURE__ */ s.jsx("circle", { cx: l.x, cy: l.y, r: "4", fill: "#60a5fa" }),
+            d && /* @__PURE__ */ s.jsx(
+              "line",
+              {
+                x1: l.x,
+                y1: l.y,
+                x2: d.x,
+                y2: d.y,
+                stroke: "#60a5fa",
+                strokeWidth: "1",
+                strokeDasharray: "2,2",
+                opacity: "0.6"
+              }
+            )
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ s.jsxs("div", { className: "minimap__legend", children: [
+      /* @__PURE__ */ s.jsxs("div", { className: "minimap__legend-item", children: [
+        /* @__PURE__ */ s.jsx("span", { className: "minimap__legend-dot minimap__legend-dot--camera" }),
+        /* @__PURE__ */ s.jsx("span", { className: "minimap__legend-text", children: "Cámara" })
+      ] }),
+      /* @__PURE__ */ s.jsxs("div", { className: "minimap__legend-item", children: [
+        /* @__PURE__ */ s.jsx("span", { className: "minimap__legend-dot minimap__legend-dot--target" }),
+        /* @__PURE__ */ s.jsx("span", { className: "minimap__legend-text", children: "Objetivo" })
+      ] })
+    ] })
+  ] });
+});
+function Tt() {
+  const { camera: o } = Ae(), [e, t] = ae({
+    x: o.position.x,
+    y: o.position.y,
+    z: o.position.z
+  });
+  return fe(() => {
+    let i;
+    const n = () => {
+      t({
+        x: o.position.x,
+        y: o.position.y,
+        z: o.position.z
+      }), i = requestAnimationFrame(n);
+    };
+    return i = requestAnimationFrame(n), () => {
+      i && cancelAnimationFrame(i);
+    };
+  }, [o]), e;
+}
+function Ce({ onPositionChange: o }) {
+  const e = Tt();
+  return fe(() => {
+    o(e);
+  }, [e, o]), null;
+}
+const Yt = V(function({
+  stackedPallet: e,
+  preset: t,
+  selectedBoxId: i,
+  highlightedBoxId: n,
+  selectedColor: r,
+  highlightedColor: a,
+  showLabels: f = !1,
+  cameraPreset: g = "perspective",
+  showGrid: v = !0,
+  showMiniMap: u = !1,
+  onBoxClick: x,
+  onBoxHover: p,
+  children: c,
+  style: l
+}) {
+  const d = Y.MM_TO_M, h = e.floors[0]?.pallet, [j, T] = ae({ x: 0, z: 0 }), z = H((w) => {
+    T({ x: w.x, z: w.z });
+  }, []), b = k(() => h ? {
+    width: h.dimensions.width * d,
+    height: le(e) * d,
+    depth: h.dimensions.depth * d
+  } : { width: 1.2, height: 1, depth: 0.8 }, [h, e, d]), M = k(() => {
+    const w = h ? h.dimensions.width * d / 2 : 0, S = h ? h.dimensions.depth * d / 2 : 0, E = b.height / 2;
+    return [w, E, S];
+  }, [h, d, b.height]), _ = k(() => {
+    const S = Math.sqrt(
+      b.width ** 2 + b.height ** 2 + b.depth ** 2
+    ) * 3.5;
+    return [
+      M[0] + S * 0.7,
+      M[1] + S * 0.6,
+      M[2] + S * 0.7
+    ];
+  }, [M, b]), y = k(() => {
+    if (!v || !h) return null;
+    const w = h.dimensions.width * d, S = h.dimensions.depth * d, E = 0.2, R = 1e-3, O = [];
+    for (let A = 0; A <= w; A += E)
+      O.push(A, R, 0, A, R, S);
+    for (let A = 0; A <= S; A += E)
+      O.push(0, R, A, w, R, A);
+    const P = new $.BufferGeometry();
+    return P.setAttribute("position", new $.Float32BufferAttribute(O, 3)), P;
+  }, [v, h, d]);
+  return /* @__PURE__ */ s.jsxs("div", { style: { position: "relative", width: "100%", height: "100%" }, children: [
+    /* @__PURE__ */ s.jsx(
+      pe,
+      {
+        shadows: !0,
+        camera: {
+          position: _,
+          fov: 45,
+          near: 0.01,
+          far: 100
+        },
+        style: { width: "100%", height: "100%", ...l },
+        children: /* @__PURE__ */ s.jsxs(ve, { preset: t, children: [
+          /* @__PURE__ */ s.jsx("ambientLight", { intensity: 0.4 }),
+          /* @__PURE__ */ s.jsx(
+            "directionalLight",
+            {
+              position: [5, 8, 5],
+              intensity: 0.8,
+              castShadow: !0,
+              "shadow-mapSize-width": 1024,
+              "shadow-mapSize-height": 1024
+            }
+          ),
+          /* @__PURE__ */ s.jsx("hemisphereLight", { intensity: 0.3, color: "#ffffff", groundColor: "#444444" }),
+          /* @__PURE__ */ s.jsx(
+            je,
+            {
+              preset: g,
+              target: M,
+              sceneSize: b,
+              minDistance: 0.3,
+              maxDistance: Math.max(b.width, b.height, b.depth) * 4
+            }
+          ),
+          /* @__PURE__ */ s.jsx(Ce, { onPositionChange: z }),
+          /* @__PURE__ */ s.jsxs("mesh", { rotation: [-Math.PI / 2, 0, 0], position: [M[0], -2e-3, M[2]], receiveShadow: !0, children: [
+            /* @__PURE__ */ s.jsx("planeGeometry", { args: [
+              h ? h.dimensions.width * d * 1.5 : 3,
+              h ? h.dimensions.depth * d * 1.5 : 3
+            ] }),
+            /* @__PURE__ */ s.jsx("meshStandardMaterial", { color: "#e0e0e0", roughness: 0.9 })
+          ] }),
+          v && y && /* @__PURE__ */ s.jsx("lineSegments", { geometry: y, children: /* @__PURE__ */ s.jsx(
+            "lineBasicMaterial",
+            {
+              color: "#aaaaaa",
+              opacity: 0.5,
+              transparent: !0,
+              depthWrite: !1
+            }
+          ) }),
+          /* @__PURE__ */ s.jsx(
+            be,
+            {
+              stackedPallet: e,
+              selectedBoxId: i,
+              highlightedBoxId: n,
+              selectedColor: r,
+              highlightedColor: a,
+              showLabels: f,
+              onBoxClick: x,
+              onBoxHover: p
+            }
+          ),
+          c
+        ] })
+      }
+    ),
+    u && h && /* @__PURE__ */ s.jsx(
+      Se,
+      {
+        sceneWidth: b.width,
+        sceneDepth: b.depth,
+        sceneType: "truck",
+        cameraPosition: j,
+        targetPosition: { x: M[0], z: M[2] },
+        position: "bottom-left"
+      }
+    )
+  ] });
+}), Ut = V(function({
+  truck: e,
+  preset: t,
+  selectedBoxId: i,
+  highlightedBoxId: n,
+  selectedColor: r,
+  highlightedColor: a,
+  showLabels: f = !1,
+  showGrid: g,
+  wallOpacity: v = 0.3,
+  showRoof: u = !1,
+  showSideWalls: x = !0,
+  cameraPreset: p = "perspective",
+  showMiniMap: c = !1,
+  onBoxClick: l,
+  onBoxHover: d,
+  children: h,
+  style: j
+}) {
+  const [T, z] = ae({ x: 0, z: 0 }), b = H((P) => {
+    z({ x: P.x, z: P.z });
+  }, []), M = Y.MM_TO_M, _ = e.dimensions.width * M, y = e.dimensions.height * M, w = e.dimensions.depth * M, S = k(
+    () => [_ / 2, y / 2, w / 2],
+    [_, y, w]
+  ), E = k(
+    () => ({ width: _, height: y, depth: w }),
+    [_, y, w]
+  ), R = k(() => [_ * 0.8, y * 1.2, w * 0.4], [_, y, w]), O = k(() => e.pallets.filter((P) => {
+    const A = tt(P, e);
+    return A.isValid ? !0 : (console.error(
+      `[TruckScene] Palet "${P.id}" fuera de los límites del camión.`,
+      "Violaciones:",
+      A.violations
+    ), !1);
+  }), [e]);
+  return /* @__PURE__ */ s.jsxs("div", { style: { position: "relative", width: "100%", height: "100%" }, children: [
+    /* @__PURE__ */ s.jsx(
+      pe,
+      {
+        shadows: !0,
+        camera: {
+          position: R,
+          fov: 45,
+          near: 0.01,
+          far: 200
+        },
+        style: { width: "100%", height: "100%", ...j },
+        children: /* @__PURE__ */ s.jsxs(ve, { preset: t, children: [
+          /* @__PURE__ */ s.jsx(
+            je,
+            {
+              preset: p,
+              target: S,
+              sceneSize: E,
+              maxDistance: Math.max(_, y, w) * 3,
+              minDistance: 0.5
+            }
+          ),
+          /* @__PURE__ */ s.jsx(Ce, { onPositionChange: b }),
+          /* @__PURE__ */ s.jsxs(
+            Pt,
+            {
+              truck: e,
+              showGrid: g,
+              wallOpacity: v,
+              showRoof: u,
+              showSideWalls: x,
+              children: [
+                O.map((P) => /* @__PURE__ */ s.jsx(
+                  be,
+                  {
+                    stackedPallet: P.stackedPallet,
+                    position: P.position,
+                    yRotation: P.yRotation,
+                    palletId: P.id,
+                    selectedBoxId: i,
+                    highlightedBoxId: n,
+                    selectedColor: r,
+                    highlightedColor: a,
+                    showLabels: f,
+                    onBoxClick: l,
+                    onBoxHover: d
+                  },
+                  P.id
+                )),
+                h
+              ]
+            }
+          )
+        ] })
+      }
+    ),
+    c && /* @__PURE__ */ s.jsx(
+      Se,
+      {
+        sceneWidth: _,
+        sceneDepth: w,
+        sceneType: "truck",
+        cameraPosition: T,
+        targetPosition: { x: S[0], z: S[2] },
+        position: "bottom-left"
+      }
+    )
+  ] });
+}), Ft = V(function({
+  room: e,
+  preset: t,
+  selectedBoxId: i,
+  highlightedBoxId: n,
+  selectedColor: r,
+  highlightedColor: a,
+  showLabels: f = !1,
+  cameraPreset: g = "perspective",
+  showMiniMap: v = !1,
+  onBoxClick: u,
+  onBoxHover: x,
+  children: p,
+  style: c
+}) {
+  const l = Y.MM_TO_M, [d, h] = ae({ x: 0, z: 0 }), j = H((y) => {
+    h({ x: y.x, z: y.z });
+  }, []), { target: T, sceneSize: z, initialCameraPosition: b } = k(() => {
+    const y = e.floorPolygon;
+    let w = 1 / 0, S = -1 / 0, E = 1 / 0, R = -1 / 0;
+    for (const C of y)
+      w = Math.min(w, C.x * l), S = Math.max(S, C.x * l), E = Math.min(E, C.z * l), R = Math.max(R, C.z * l);
+    const O = S - w, P = R - E, A = e.ceilingHeight * l, G = (w + S) / 2, N = (E + R) / 2, U = [G, A / 2, N], F = { width: O, height: A, depth: P }, J = Math.sqrt(O ** 2 + A ** 2 + P ** 2) * 0.8, m = [
+      G + J * 0.6,
+      A + J * 0.5,
+      N + J * 0.6
+    ];
+    return {
+      target: U,
+      sceneSize: F,
+      initialCameraPosition: m
+    };
+  }, [e.floorPolygon, e.ceilingHeight, l]), M = k(() => e.floorPolygon.map((y) => ({ x: y.x * l, z: y.z * l })), [e.floorPolygon, l]), _ = k(() => e.pallets.filter((y) => {
+    const w = We(y, e);
+    return w.isValid ? !0 : (console.error(
+      `[WarehouseScene] Palet "${y.id}" fuera de los límites de la estancia "${e.name}".`,
+      "Violaciones:",
+      w.violations
+    ), !1);
+  }), [e]);
+  return /* @__PURE__ */ s.jsxs("div", { style: { position: "relative", width: "100%", height: "100%" }, children: [
+    /* @__PURE__ */ s.jsx(
+      pe,
+      {
+        shadows: !0,
+        camera: {
+          position: b,
+          fov: 45,
+          near: 0.01,
+          far: 300
+        },
+        style: { width: "100%", height: "100%", ...c },
+        children: /* @__PURE__ */ s.jsxs(ve, { preset: t, children: [
+          /* @__PURE__ */ s.jsx(
+            je,
+            {
+              preset: g,
+              target: T,
+              sceneSize: z,
+              maxDistance: Math.max(z.width, z.height, z.depth) * 4,
+              minDistance: 0.5
+            }
+          ),
+          /* @__PURE__ */ s.jsx(Ce, { onPositionChange: j }),
+          /* @__PURE__ */ s.jsxs(Mt, { room: e, children: [
+            _.map((y) => /* @__PURE__ */ s.jsx(
+              be,
+              {
+                stackedPallet: y.stackedPallet,
+                position: y.position,
+                yRotation: y.yRotation,
+                palletId: y.id,
+                selectedBoxId: i,
+                highlightedBoxId: n,
+                selectedColor: r,
+                highlightedColor: a,
+                showLabels: f,
+                onBoxClick: u,
+                onBoxHover: x
+              },
+              y.id
+            )),
+            p
+          ] })
+        ] })
+      }
+    ),
+    v && /* @__PURE__ */ s.jsx(
+      Se,
+      {
+        sceneWidth: z.width,
+        sceneDepth: z.depth,
+        sceneType: "warehouse",
+        floorPolygon: M,
+        cameraPosition: d,
+        targetPosition: { x: T[0], z: T[2] },
+        position: "bottom-left"
+      }
+    )
+  ] });
+});
+export {
+  ut as BinPacking3DStrategy,
+  bt as BoxComponent,
+  ge as BoxFactory,
+  Ne as COLLISION_TOLERANCE,
+  je as CameraControlsComponent,
+  mt as ColumnStrategy,
+  xe as DEFAULT_PRESET,
+  Lt as Label,
+  Me as MIN_SUPPORT_PERCENTAGE,
+  Ie as PRESET_INDUSTRIAL,
+  Le as PRESET_UNSTYLED,
+  gt as PackingRegistry,
+  jt as PalletComponent,
+  Z as PalletFactory,
+  L as PalletMaterial,
+  Yt as PalletScene,
+  ve as PresetProvider,
+  Ye as SCENE_PRESETS,
+  At as SEPARATOR_DEFAULTS,
+  ue as STANDARD_PALLETS,
+  Ct as SeparatorComponent,
+  me as SeparatorMaterial,
+  be as StackedPalletComponent,
+  Ze as TRUCK_PRESETS,
+  Pt as TruckEnvironment,
+  Gt as TruckFactory,
+  Ut as TruckScene,
+  ie as TruckType,
+  xt as TypeGroupStrategy,
+  Y as UNITS,
+  Oe as WEIGHT_WARNING_THRESHOLD,
+  Mt as WarehouseEnvironment,
+  Ft as WarehouseScene,
+  ye as aabbIntersects,
+  q as calculateCenterOfGravity,
+  se as calculateStabilityScore,
+  ft as defaultRegistry,
+  qe as ensureUniqueBoxIds,
+  D as getBoxBoundingBox,
+  oe as getPalletBoundingBox,
+  le as getStackedPalletTotalHeight,
+  we as getStackedPalletTotalWeight,
+  ht as pointInPolygon,
+  Zt as usePackingStrategy,
+  Xt as usePalletMetrics,
+  Vt as usePhysicsValidation,
+  ce as usePreset,
+  Nt as useWarehouseValidation,
+  et as validateAllBoxesInPalletBounds,
+  Ke as validateBoxInPalletBounds,
+  rt as validateBoxStackability,
+  lt as validateCogInsideSupport,
+  ot as validateFragileLoad,
+  at as validateInvertedPyramid,
+  Je as validateNoBoxCollisions,
+  Qe as validateNoPalletCollisions,
+  Ot as validatePalletHeight,
+  We as validatePalletInRoom,
+  tt as validatePalletInTruck,
+  it as validatePalletWeight,
+  Wt as validateSeparators,
+  dt as validateStability,
+  $t as validateStackDimensions,
+  Bt as validateStackHeight,
+  Dt as validateStackWeight,
+  ct as validateSupport,
+  It as validateTruckWeight,
+  nt as validateWeightDistribution
+};
+//# sourceMappingURL=pallet-builder.js.map