@solid-labs/fab-one-widget 0.1.4 → 0.1.6

package/dist/GirthManagerWidget-Ci-QU3Wh.js

@@ -0,0 +1,4137 @@
+import { jsxs as W, jsx as d, Fragment as He } from "react/jsx-runtime";
+import { createContext as tn, useCallback as Fe, useMemo as de, useState as Q, memo as nn, useEffect as Se, useRef as Ie } from "react";
+import { useFrame as Pt, useThree as on, Canvas as sn } from "@react-three/fiber";
+import { Html as Ke, Line as ge, OrbitControls as Dt } from "@react-three/drei";
+import * as J from "three";
+import { Plane as it, Vector3 as h, Box3 as Tt, Line3 as ht, Quaternion as Oe, Matrix4 as kt } from "three";
+import { create as rn } from "zustand";
+import { OBJLoader as ln } from "three/examples/jsm/loaders/OBJLoader.js";
+import { STLLoader as an } from "three/examples/jsm/loaders/STLLoader.js";
+import { MeshBVH as $e } from "three-mesh-bvh";
+let bo, dt, ao, jt;
+let __tla = (async () => {
+  const cn = {
+    showDragDrop: true,
+    showStartOver: true,
+    showInsertMeasurement: true,
+    showDebug: true,
+    showSpacingToggle: true,
+    showAmputationModal: true,
+    showNavigation: true,
+    showToolbar: true
+  }, fn = {
+    showDragDrop: false,
+    showStartOver: false,
+    showInsertMeasurement: false,
+    showDebug: false,
+    showSpacingToggle: false,
+    showAmputationModal: false,
+    showNavigation: false,
+    showToolbar: false
+  }, dn = tn(cn), gt = rn((e, r) => ({
+    landmarkPoints: [],
+    isAligned: false,
+    isCut: false,
+    addLandmarkPoint: (n) => e((t) => t.landmarkPoints.length >= 3 ? t : {
+      landmarkPoints: [
+        ...t.landmarkPoints,
+        n
+      ]
+    }),
+    removeLandmarkPoint: (n) => e((t) => ({
+      landmarkPoints: t.landmarkPoints.filter((i, a) => a !== n)
+    })),
+    clearLandmarkPoints: () => e({
+      landmarkPoints: [],
+      isAligned: false,
+      isCut: false
+    }),
+    updateLandmarkPositions: (n) => e((t) => ({
+      landmarkPoints: t.landmarkPoints.map((i, a) => ({
+        ...i,
+        position: n[a] ?? i.position
+      }))
+    })),
+    setAligned: (n) => e({
+      isAligned: n
+    }),
+    setCut: (n) => e({
+      isCut: n
+    }),
+    isSelectionComplete: () => r().landmarkPoints.length === 3
+  })), un = 0.45, Ye = 3, ut = 1e-3, We = 25.4, pn = 5, hn = [
+    0.25,
+    -0.25,
+    0.5,
+    -0.5
+  ];
+  function gn(e) {
+    const r = e.split(`
+`), n = [], t = [];
+    let i = false;
+    for (const a of r) if (a.startsWith("v ")) {
+      const c = a.trim().split(/\s+/);
+      if (c.length >= 7) {
+        n.push(parseFloat(c[1]), parseFloat(c[2]), parseFloat(c[3]));
+        let u = parseFloat(c[4]), s = parseFloat(c[5]), l = parseFloat(c[6]);
+        (u > 1 || s > 1 || l > 1) && (u /= 255, s /= 255, l /= 255), t.push(u, s, l), i = true;
+      } else c.length >= 4 && (n.push(parseFloat(c[1]), parseFloat(c[2]), parseFloat(c[3])), t.push(0, 0, 0));
+    }
+    return i ? {
+      positions: new Float32Array(n),
+      colors: new Float32Array(t)
+    } : null;
+  }
+  function mn(e, r, n, t) {
+    const i = e.getAttribute("position"), a = i.count, c = new Float32Array(a * 3), u = r.length / 3;
+    let s = 1 / 0, l = 1 / 0, o = 1 / 0, f = -1 / 0, y = -1 / 0, p = -1 / 0;
+    for (let b = 0; b < u; b++) {
+      const S = r[b * 3] * t, C = r[b * 3 + 1] * t, M = r[b * 3 + 2] * t;
+      S < s && (s = S), S > f && (f = S), C < l && (l = C), C > y && (y = C), M < o && (o = M), M > p && (p = M);
+    }
+    const x = Math.min(128, Math.max(16, Math.round(Math.cbrt(u)))), g = (f - s + 1e-6) / x, w = (y - l + 1e-6) / x, v = (p - o + 1e-6) / x, m = /* @__PURE__ */ new Map();
+    for (let b = 0; b < u; b++) {
+      const S = Math.min(x - 1, Math.floor((r[b * 3] * t - s) / g)), C = Math.min(x - 1, Math.floor((r[b * 3 + 1] * t - l) / w)), M = Math.min(x - 1, Math.floor((r[b * 3 + 2] * t - o) / v)), P = S * x * x + C * x + M;
+      let L = m.get(P);
+      L || (L = [], m.set(P, L)), L.push(b);
+    }
+    for (let b = 0; b < a; b++) {
+      const S = i.getX(b), C = i.getY(b), M = i.getZ(b), P = Math.min(x - 1, Math.max(0, Math.floor((S - s) / g))), L = Math.min(x - 1, Math.max(0, Math.floor((C - l) / w))), H = Math.min(x - 1, Math.max(0, Math.floor((M - o) / v)));
+      let O = 1 / 0, $ = 0;
+      for (let R = 0; R <= x && O > 0; R++) {
+        for (let Y = -R; Y <= R; Y++) for (let j = -R; j <= R; j++) for (let ne = -R; ne <= R; ne++) {
+          if (R > 0 && Math.abs(Y) < R && Math.abs(j) < R && Math.abs(ne) < R) continue;
+          const oe = P + Y, le = L + j, ee = H + ne;
+          if (oe < 0 || oe >= x || le < 0 || le >= x || ee < 0 || ee >= x) continue;
+          const D = m.get(oe * x * x + le * x + ee);
+          if (D) for (const z of D) {
+            const F = r[z * 3] * t, V = r[z * 3 + 1] * t, B = r[z * 3 + 2] * t, T = (S - F) ** 2 + (C - V) ** 2 + (M - B) ** 2;
+            T < O && (O = T, $ = z);
+          }
+        }
+        if (O < 1 / 0) break;
+      }
+      c[b * 3] = n[$ * 3], c[b * 3 + 1] = n[$ * 3 + 1], c[b * 3 + 2] = n[$ * 3 + 2];
+    }
+    e.setAttribute("color", new J.Float32BufferAttribute(c, 3));
+  }
+  const xn = 30, zt = [
+    "#4488ff",
+    "#ff4444",
+    "#44cc44",
+    "#ffaa00",
+    "#cc44ff",
+    "#44ffcc"
+  ];
+  function yn(e, r) {
+    const n = e.getVertices(), t = e.getFaces(), i = e.getComponentLabels(), a = /* @__PURE__ */ new Map();
+    for (let o = 0; o < i.length; o++) {
+      const f = i[o];
+      a.has(f) || a.set(f, []), a.get(f).push(o);
+    }
+    const c = [
+      ...a.keys()
+    ].sort((o, f) => o - f), u = [], s = [], l = [];
+    for (const o of c) {
+      const f = a.get(o), y = /* @__PURE__ */ new Map(), p = [], x = [];
+      for (const m of f) for (let b = 0; b < 3; b++) {
+        const S = t[m * 3 + b];
+        if (!y.has(S)) {
+          const C = p.length / 3;
+          p.push(n[S * 3], n[S * 3 + 1], n[S * 3 + 2]), y.set(S, C);
+        }
+        x.push(y.get(S));
+      }
+      const g = new J.BufferGeometry();
+      g.setAttribute("position", new J.Float32BufferAttribute(p, 3)), g.setIndex(x), g.computeVertexNormals(), u.push(g);
+      const v = o === r ? `#${o} inner` : o === 0 ? `#${o} outer` : `#${o} (${f.length} faces)`;
+      s.push(v), l.push(zt[o % zt.length]);
+    }
+    return {
+      geometries: u,
+      labels: s,
+      colors: l,
+      innerIdx: r
+    };
+  }
+  async function bn(e, r, n) {
+    let t = null;
+    try {
+      const i = gn(e);
+      n == null ? void 0 : n("Loading mesh..."), t = new r.WasmMeshSet(), t.loadObjString(e), n == null ? void 0 : n("Detecting units...");
+      const a = t.autoScaleToMm(pn);
+      n == null ? void 0 : n("Merging close vertices..."), t.applyMergeCloseVertices(1e-4), n == null ? void 0 : n("Analyzing mesh components...");
+      let c = false, u = null;
+      if (t.getComponentCount() >= 2) {
+        n == null ? void 0 : n("Building component debug info...");
+        const y = yn(t, null);
+        n == null ? void 0 : n("Extracting inner shell..."), c = t.extractInnerShell(xn), c ? (console.log("Inner shell extracted from double-shell mesh"), y.innerIdx = 1, y.labels[1] = "#1 inner (extracted)", y.labels[0] && (y.labels[0] = "#0 outer (discarded)"), u = y) : (n == null ? void 0 : n("Removing floating artifacts..."), t.splitAndKeepLargest(), u = y);
+      } else n == null ? void 0 : n("Removing floating artifacts..."), t.splitAndKeepLargest();
+      n == null ? void 0 : n("Closing holes..."), t.applyCloseHoles(30), t.applyMergeCloseVertices(1e-4), n == null ? void 0 : n("Extracting geometry...");
+      const l = t.getVertices(), o = t.getFaces();
+      if (l.length === 0) return null;
+      const f = new J.BufferGeometry();
+      if (f.setAttribute("position", new J.Float32BufferAttribute(l, 3)), f.setIndex(Array.from(o)), f.computeVertexNormals(), i) {
+        const y = a ? 1e3 : 1;
+        mn(f, i.positions, i.colors, y);
+      }
+      return {
+        geometry: f,
+        wasScaled: a,
+        innerShellExtracted: c,
+        componentDebug: u
+      };
+    } catch (i) {
+      return console.error("WASM processing failed:", i), null;
+    } finally {
+      if (t) try {
+        t.free();
+      } catch {
+      }
+    }
+  }
+  function wn(e) {
+    const n = new ln().parse(e);
+    let t = null;
+    return n.traverse((i) => {
+      i.isMesh && !t && (t = i.geometry);
+    }), t;
+  }
+  async function ft(e) {
+    const r = await e.arrayBuffer(), i = new an().parse(r).getAttribute("position");
+    if (!i || i.count === 0) throw new Error("Empty STL geometry");
+    const a = [];
+    for (let c = 0; c < i.count; c++) a.push(`v ${i.getX(c)} ${i.getY(c)} ${i.getZ(c)}`);
+    for (let c = 0; c < i.count; c += 3) a.push(`f ${c + 1} ${c + 2} ${c + 3}`);
+    return a.join(`
+`);
+  }
+  function Bt(e, r) {
+    const n = 1 / r;
+    return `${Math.round(e.x * n)}_${Math.round(e.y * n)}_${Math.round(e.z * n)}`;
+  }
+  function Rt(e, r) {
+    if (!e.length) return [];
+    const n = [];
+    for (const t of e) (n.length === 0 || n[n.length - 1].distanceTo(t) > r) && n.push(t.clone());
+    return n.length > 2 && n[0].distanceTo(n[n.length - 1]) > r && n.push(n[0].clone()), n;
+  }
+  function Ne(e) {
+    let r = 0;
+    for (let n = 0; n < e.length - 1; n++) r += e[n].distanceTo(e[n + 1]);
+    return r;
+  }
+  function Et(e, r = 1e-3, n = false) {
+    if (!e.length) return [];
+    const t = /* @__PURE__ */ new Map(), i = (l) => {
+      const o = Bt(l, r);
+      let f = t.get(o);
+      return f || (f = l.clone(), t.set(o, f)), f;
+    }, a = e.map((l) => ({
+      a: i(l.a),
+      b: i(l.b)
+    })), c = [];
+    for (; a.length; ) {
+      const l = a.pop(), o = [
+        l.a,
+        l.b
+      ];
+      let f = true;
+      for (; f; ) {
+        f = false;
+        for (let p = a.length - 1; p >= 0; p--) {
+          const { a: x, b: g } = a[p];
+          if (x.equals(o[o.length - 1])) o.push(g);
+          else if (g.equals(o[o.length - 1])) o.push(x);
+          else if (x.equals(o[0])) o.unshift(g);
+          else if (g.equals(o[0])) o.unshift(x);
+          else continue;
+          a.splice(p, 1), f = true;
+        }
+      }
+      const y = Rt(o, r);
+      y.length > 1 && c.push(y);
+    }
+    if (!c.length) return [];
+    if (c.sort((l, o) => Ne(o) - Ne(l)), !n) return c[0] ?? [];
+    const u = Ne(c[0]), s = c.filter((l) => Ne(l) >= u * 0.3);
+    return s[s.length - 1] ?? c[0];
+  }
+  function Ct(e, r, n, t = false) {
+    const i = new it(new h(0, 1, 0), -n), a = [], c = new Tt();
+    c.setFromBufferAttribute(r.getAttribute("position"));
+    const u = {
+      linePoints: [],
+      lineLength: 0,
+      rightmostPoint: new h(0, n, 0)
+    };
+    if (!i.intersectsBox(c)) return u;
+    const s = new ht(), l = new h();
+    e.shapecast({
+      intersectsBounds: (g) => i.intersectsBox(g),
+      intersectsTriangle: (g) => {
+        const w = [];
+        s.set(g.a, g.b), i.intersectLine(s, l) && w.push(l.clone()), s.set(g.b, g.c), i.intersectLine(s, l) && w.push(l.clone()), s.set(g.c, g.a), i.intersectLine(s, l) && w.push(l.clone()), w.length === 2 && a.push({
+          a: w[0],
+          b: w[1]
+        });
+      }
+    });
+    const o = Et(a, ut, t), f = Ne(o);
+    if (o.length < 2) return u;
+    let y = -1 / 0, p = new h(0, n, 0);
+    for (const g of o) g.x > y && (y = g.x, p = g.clone());
+    const x = o.length > 2 && o[0].distanceTo(o[o.length - 1]) < ut * 10;
+    return {
+      linePoints: o,
+      lineLength: f,
+      rightmostPoint: p,
+      isClosed: x
+    };
+  }
+  function Ze(e, r, n, t = false) {
+    const i = Ct(e, r, n, t);
+    if (i.isClosed && i.linePoints.length >= 3) return i;
+    console.warn(`[slice] y=${n.toFixed(2)} failed (pts=${i.linePoints.length}, closed=${i.isClosed}), retrying...`);
+    let a = i;
+    for (const c of hn) {
+      const u = Ct(e, r, n + c, t);
+      if (u.isClosed && u.linePoints.length >= 3) return console.log(`[slice] y=${n.toFixed(2)} recovered with offset ${c > 0 ? "+" : ""}${c}mm (pts=${u.linePoints.length}, len=${u.lineLength.toFixed(1)}mm)`), u;
+      u.linePoints.length > a.linePoints.length && (a = u);
+    }
+    return console.warn(`[slice] y=${n.toFixed(2)} all retries exhausted (pts=${a.linePoints.length}, closed=${a.isClosed})`), a;
+  }
+  function pt(e, r, n, t) {
+    const i = new it().setFromNormalAndCoplanarPoint(t.clone().normalize(), n), a = new Tt();
+    if (a.setFromBufferAttribute(r.getAttribute("position")), !i.intersectsBox(a)) return 0;
+    const c = [], u = new ht(), s = new h();
+    e.shapecast({
+      intersectsBounds: (o) => i.intersectsBox(o),
+      intersectsTriangle: (o) => {
+        const f = [];
+        u.set(o.a, o.b), i.intersectLine(u, s) && f.push(s.clone()), u.set(o.b, o.c), i.intersectLine(u, s) && f.push(s.clone()), u.set(o.c, o.a), i.intersectLine(u, s) && f.push(s.clone()), f.length === 2 && c.push({
+          a: f[0],
+          b: f[1]
+        });
+      }
+    });
+    const l = Et(c, ut);
+    return Ne(l);
+  }
+  function ot(e) {
+    return new $e(e, {
+      maxLeafTris: Ye
+    });
+  }
+  function vt(e, r, n) {
+    const t = e instanceof $e ? e : new $e(e, {
+      maxLeafTris: Ye
+    }), i = new it().setFromNormalAndCoplanarPoint(n.clone().normalize(), r), a = [], c = new ht(), u = new h();
+    return t.shapecast({
+      intersectsBounds: (s) => i.intersectsBox(s),
+      intersectsTriangle: (s) => {
+        const l = [];
+        c.set(s.a, s.b), i.intersectLine(c, u) && l.push(u.clone()), c.set(s.b, s.c), i.intersectLine(c, u) && l.push(u.clone()), c.set(s.c, s.a), i.intersectLine(c, u) && l.push(u.clone()), l.length === 2 && a.push({
+          a: l[0],
+          b: l[1]
+        });
+      }
+    }), a;
+  }
+  function Mt(e, r, n = 1e-3) {
+    if (!e.length) return [];
+    const t = /* @__PURE__ */ new Map(), i = (l) => {
+      const o = Bt(l, n);
+      let f = t.get(o);
+      return f || (f = l.clone(), t.set(o, f)), f;
+    }, a = e.map((l) => ({
+      a: i(l.a),
+      b: i(l.b)
+    })), c = [];
+    for (; a.length; ) {
+      const l = a.pop(), o = [
+        l.a,
+        l.b
+      ];
+      let f = true;
+      for (; f; ) {
+        f = false;
+        for (let p = a.length - 1; p >= 0; p--) {
+          const { a: x, b: g } = a[p];
+          if (x.equals(o[o.length - 1])) o.push(g);
+          else if (g.equals(o[o.length - 1])) o.push(x);
+          else if (x.equals(o[0])) o.unshift(g);
+          else if (g.equals(o[0])) o.unshift(x);
+          else continue;
+          a.splice(p, 1), f = true;
+        }
+      }
+      const y = Rt(o, n);
+      y.length > 1 && c.push(y);
+    }
+    if (!c.length) return [];
+    let u = [], s = 1 / 0;
+    for (const l of c) {
+      if (l.length < 3 || !(l[0].distanceTo(l[l.length - 1]) < 2)) continue;
+      const f = new h();
+      for (const p of l) f.add(p);
+      f.divideScalar(l.length);
+      const y = f.distanceTo(r);
+      y < s && (s = y, u = l);
+    }
+    if (u.length === 0) for (const l of c) {
+      if (l.length < 3) continue;
+      const o = new h();
+      for (const y of l) o.add(y);
+      o.divideScalar(l.length);
+      const f = o.distanceTo(r);
+      f < s && (s = f, u = l);
+    }
+    return u;
+  }
+  function Sn(e) {
+    const r = new h();
+    for (const n of e) r.add(n);
+    return r.divideScalar(e.length);
+  }
+  function zn(e, r, n) {
+    const t = new $e(e, {
+      maxLeafTris: Ye
+    }), i = new h().subVectors(r, n).normalize(), c = r.distanceTo(n) * 0.05;
+    let u = i.clone();
+    const s = (v) => {
+      const m = [];
+      for (let $ = -10; $ <= 0; $++) {
+        const R = r.clone().addScaledVector(v, $ * c), Y = vt(t, R, v), j = Mt(Y, R, 1);
+        j.length >= 3 && j[0].distanceTo(j[j.length - 1]) < 1 && m.push(Sn(j));
+      }
+      if (m.length < 3) return null;
+      const b = new h();
+      for (const $ of m) b.add($);
+      b.divideScalar(m.length);
+      let S = 0, C = 0, M = 0, P = 0, L = 0, H = 0;
+      for (const $ of m) {
+        const R = $.x - b.x, Y = $.y - b.y, j = $.z - b.z;
+        S += R * R, C += R * Y, M += R * j, P += Y * Y, L += Y * j, H += j * j;
+      }
+      let O = v.clone();
+      for (let $ = 0; $ < 30; $++) {
+        const R = S * O.x + C * O.y + M * O.z, Y = C * O.x + P * O.y + L * O.z, j = M * O.x + L * O.y + H * O.z, ne = new h(R, Y, j), oe = ne.length();
+        if (oe < 1e-10 || (ne.divideScalar(oe), O.distanceTo(ne) < 1e-8)) break;
+        O = ne;
+      }
+      return O.dot(i) < 0 && O.negate(), O;
+    };
+    for (let v = 0; v < 3; v++) {
+      const m = s(u);
+      if (!m) break;
+      const b = u.angleTo(m);
+      if (u = m, b < 1e-3) break;
+    }
+    const l = new h();
+    Math.abs(u.x) < 0.9 ? l.set(1, 0, 0) : l.set(0, 1, 0), l.crossVectors(u, l).normalize();
+    const o = new h().crossVectors(u, l).normalize(), f = (v) => {
+      const m = vt(t, r, v), b = Mt(m, r, 1);
+      if (b.length < 3) return {
+        circumference: 1 / 0,
+        closed: false
+      };
+      const S = b[0].distanceTo(b[b.length - 1]) < 1;
+      return {
+        circumference: Ne(b),
+        closed: S
+      };
+    };
+    let y = u.clone(), p = 1 / 0;
+    for (let v = -3; v <= 3; v += 1) for (let m = -3; m <= 3; m += 1) {
+      const b = v * Math.PI / 180, S = m * Math.PI / 180, C = u.clone().applyQuaternion(new Oe().setFromAxisAngle(l, b)).applyQuaternion(new Oe().setFromAxisAngle(o, S)).normalize(), M = f(C);
+      M.closed && M.circumference < p && (p = M.circumference, y = C);
+    }
+    const x = y.clone(), g = new h();
+    Math.abs(x.x) < 0.9 ? g.set(1, 0, 0) : g.set(0, 1, 0), g.crossVectors(x, g).normalize();
+    const w = new h().crossVectors(x, g).normalize();
+    for (let v = -5; v <= 5; v += 1) for (let m = -5; m <= 5; m += 1) {
+      const b = v * 0.1 * Math.PI / 180, S = m * 0.1 * Math.PI / 180, C = x.clone().applyQuaternion(new Oe().setFromAxisAngle(g, b)).applyQuaternion(new Oe().setFromAxisAngle(w, S)).normalize(), M = f(C);
+      M.closed && M.circumference < p && (p = M.circumference, y = C);
+    }
+    return p === 1 / 0 && (p = f(u).circumference, y = u), {
+      normal: y,
+      circumference: p
+    };
+  }
+  function Cn(e, r, n) {
+    const t = e.getAttribute("position"), i = e.getIndex();
+    if (!i) return {
+      isDoubleShell: false,
+      sampledFaces: 0,
+      opposingPairs: 0,
+      confidence: 0
+    };
+    const a = i.array, c = t.array, u = new h().subVectors(n, r).normalize(), s = n.distanceTo(r), l = Math.min(s * 0.06, 15), o = new $e(e, {
+      maxLeafTris: Ye
+    });
+    let f = new h(1, 0, 0);
+    Math.abs(u.dot(f)) > 0.9 && (f = new h(0, 1, 0)), f.sub(u.clone().multiplyScalar(u.dot(f))).normalize();
+    const y = new h().crossVectors(u, f).normalize(), p = 12, x = new h();
+    let g = 0, w = 0, v = 0;
+    for (const S of [
+      0.65,
+      0.78,
+      0.9
+    ]) {
+      const C = new h().lerpVectors(r, n, S);
+      let M = 0, P = 0, L = 0, H = 0;
+      for (let Y = 0; Y < a.length; Y += 3) {
+        const j = a[Y], ne = a[Y + 1], oe = a[Y + 2], le = (c[j * 3] + c[ne * 3] + c[oe * 3]) / 3, ee = (c[j * 3 + 1] + c[ne * 3 + 1] + c[oe * 3 + 1]) / 3, D = (c[j * 3 + 2] + c[ne * 3 + 2] + c[oe * 3 + 2]) / 3, z = le - C.x, F = ee - C.y, V = D - C.z;
+        Math.abs(z * u.x + F * u.y + V * u.z) > l || (M += le, P += ee, L += D, H++);
+      }
+      if (H < 8) continue;
+      const O = new h(M / H, P / H, L / H);
+      let $ = 0;
+      for (let Y = 0; Y < p; Y++) {
+        const j = Y / p * Math.PI * 2, ne = new h().addScaledVector(f, Math.cos(j)).addScaledVector(y, Math.sin(j)), oe = new J.Ray(O, ne);
+        let le = 0;
+        o.shapecast({
+          intersectsBounds: (ee) => oe.intersectsBox(ee),
+          intersectsTriangle: (ee) => (oe.intersectTriangle(ee.a, ee.b, ee.c, false, x) && le++, false)
+        }), $ += le, w++;
+      }
+      g += $, $ / p > 1.5 && v++;
+    }
+    if (w === 0) return {
+      isDoubleShell: false,
+      sampledFaces: 0,
+      opposingPairs: 0,
+      confidence: 0
+    };
+    const m = g / w;
+    return {
+      isDoubleShell: v >= 2,
+      sampledFaces: w,
+      opposingPairs: g,
+      confidence: m
+    };
+  }
+  function vn(e, r, n, t) {
+    const i = new h().subVectors(n, r), a = new h().subVectors(t, r), c = new h().subVectors(e, r), u = i.dot(i), s = i.dot(a), l = i.dot(c), o = a.dot(a), f = a.dot(c), y = 1 / (u * o - s * s), p = (o * l - s * f) * y, x = (u * f - s * l) * y;
+    return {
+      u: 1 - p - x,
+      v: p,
+      w: x
+    };
+  }
+  function st(e, r, n, t, i = false) {
+    const a = n.clone().normalize(), c = e.getAttribute("position"), u = e.getIndex();
+    if (!u) throw new Error("No index buffer");
+    const s = new h().subVectors(t, r).dot(a), l = Math.abs(s) < 1e-6 ? 1 : Math.sign(s), o = c.array, f = u.array, y = e.getAttribute("color"), p = y ? y.array : null, x = [], g = [], w = [], v = (D, z, F) => {
+      const V = x.length / 3;
+      return x.push(D, z, F), V;
+    }, m = (D) => new h(o[D * 3], o[D * 3 + 1], o[D * 3 + 2]), b = (D, z) => {
+      const F = new h().subVectors(D, r).dot(a), V = new h().subVectors(z, r).dot(a), B = F / (F - V);
+      return new h().lerpVectors(D, z, B);
+    }, S = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map(), P = (D) => {
+      let z = M.get(D);
+      return z === void 0 && (z = new h().subVectors(m(D), r).dot(a), M.set(D, z)), z;
+    }, L = (D) => {
+      if (S.has(D)) return S.get(D);
+      const z = m(D), F = v(z.x, z.y, z.z);
+      return p && g.push(p[D * 3], p[D * 3 + 1], p[D * 3 + 2]), S.set(D, F), F;
+    }, H = (D, z) => {
+      const F = D < z ? `${D}_${z}` : `${z}_${D}`;
+      if (C.has(F)) return C.get(F);
+      const V = b(m(D), m(z)), B = v(V.x, V.y, V.z);
+      if (p) {
+        const T = P(D), E = P(z), N = T / (T - E);
+        g.push(p[D * 3] + N * (p[z * 3] - p[D * 3]), p[D * 3 + 1] + N * (p[z * 3 + 1] - p[D * 3 + 1]), p[D * 3 + 2] + N * (p[z * 3 + 2] - p[D * 3 + 2]));
+      }
+      return C.set(F, B), B;
+    }, O = (D) => {
+      const z = P(D);
+      return Math.sign(z) === l || Math.abs(z) < 1e-6;
+    };
+    for (let D = 0; D < f.length; D += 3) {
+      const z = f[D], F = f[D + 1], V = f[D + 2], B = O(z), T = O(F), E = O(V), N = (B ? 1 : 0) + (T ? 1 : 0) + (E ? 1 : 0);
+      if (N !== 0) if (N === 3) w.push(L(z), L(F), L(V));
+      else if (N === 1) {
+        let X, q, ie;
+        B ? (X = z, q = F, ie = V) : T ? (X = F, q = V, ie = z) : (X = V, q = z, ie = F), w.push(L(X), H(X, q), H(X, ie));
+      } else {
+        let X, q, ie;
+        B ? T ? (X = V, q = z, ie = F) : (X = F, q = V, ie = z) : (X = z, q = F, ie = V);
+        const se = L(q), A = L(ie), I = H(q, X), k = H(ie, X);
+        w.push(se, I, A), w.push(A, I, k);
+      }
+    }
+    const $ = w.length / 3;
+    let R;
+    if (i) R = Array.from({
+      length: $
+    }, (D, z) => z);
+    else {
+      const D = /* @__PURE__ */ new Map();
+      for (let T = 0; T < $; T++) for (let E = 0; E < 3; E++) {
+        const N = w[T * 3 + E];
+        D.has(N) || D.set(N, []), D.get(N).push(T);
+      }
+      const z = /* @__PURE__ */ new Set(), F = [];
+      for (let T = 0; T < $; T++) {
+        if (z.has(T)) continue;
+        const E = [], N = [
+          T
+        ];
+        for (z.add(T); N.length > 0; ) {
+          const X = N.shift();
+          E.push(X);
+          for (let q = 0; q < 3; q++) {
+            const ie = w[X * 3 + q];
+            for (const se of D.get(ie)) z.has(se) || (z.add(se), N.push(se));
+          }
+        }
+        F.push(E);
+      }
+      let V = F[0] || [], B = 1 / 0;
+      for (const T of F) {
+        let E = 1 / 0;
+        for (const N of T) {
+          for (let X = 0; X < 3; X++) {
+            const q = w[N * 3 + X], ie = x[q * 3] - t.x, se = x[q * 3 + 1] - t.y, A = x[q * 3 + 2] - t.z, I = ie * ie + se * se + A * A;
+            I < E && (E = I);
+          }
+          if (E < B) break;
+        }
+        E < B && (B = E, V = T);
+      }
+      R = V;
+    }
+    const Y = /* @__PURE__ */ new Map(), j = [], ne = [], oe = [];
+    let le = 0;
+    for (const D of R) for (let z = 0; z < 3; z++) {
+      const F = w[D * 3 + z];
+      Y.has(F) || (j.push(x[F * 3], x[F * 3 + 1], x[F * 3 + 2]), p && ne.push(g[F * 3], g[F * 3 + 1], g[F * 3 + 2]), Y.set(F, le++)), oe.push(Y.get(F));
+    }
+    const ee = new J.BufferGeometry();
+    return ee.setAttribute("position", new J.Float32BufferAttribute(j, 3)), p && ne.length > 0 && ee.setAttribute("color", new J.Float32BufferAttribute(ne, 3)), ee.setIndex(oe), ee.computeVertexNormals(), ee.computeBoundingBox(), ee;
+  }
+  function rt(e, r, n) {
+    const t = e.getAttribute("position"), i = n - r;
+    if (i < 1) return null;
+    const a = 30, c = i / a, u = [];
+    for (let w = 0; w < a; w++) {
+      const v = r + w * c, m = r + (w + 1) * c;
+      let b = 0, S = 0, C = 0, M = 0;
+      for (let P = 0; P < t.count; P++) {
+        const L = t.getY(P);
+        L >= v && L < m && (b += t.getX(P), S += L, C += t.getZ(P), M++);
+      }
+      M > 20 && u.push(new h(b / M, S / M, C / M));
+    }
+    if (u.length < 5) return null;
+    const s = new h();
+    for (const w of u) s.add(w);
+    s.divideScalar(u.length);
+    let l = 0, o = 0, f = 0, y = 0, p = 0, x = 0;
+    for (const w of u) {
+      const v = w.x - s.x, m = w.y - s.y, b = w.z - s.z;
+      l += v * v, o += v * m, f += v * b, y += m * m, p += m * b, x += b * b;
+    }
+    let g = new h(0.01, 1, 0.01).normalize();
+    for (let w = 0; w < 30; w++) {
+      const v = l * g.x + o * g.y + f * g.z, m = o * g.x + y * g.y + p * g.z, b = f * g.x + p * g.y + x * g.z, S = new h(v, m, b), C = S.length();
+      if (C < 1e-10 || (S.divideScalar(C), g.distanceTo(S) < 1e-8)) break;
+      g = S;
+    }
+    return g.y < 0 && g.negate(), g;
+  }
+  function Wt(e, r, n, t) {
+    const i = e.getIndex(), a = i ? i.count / 3 : 0;
+    if (a < 10) return {
+      valid: false,
+      reason: `Geometry is empty or degenerate (${a} faces)`
+    };
+    const c = r - n;
+    if (c < 4) return {
+      valid: false,
+      reason: `Height too small (${c.toFixed(1)}mm < 4mm)`
+    };
+    if (c > 1e3) return {
+      valid: false,
+      reason: `Height too large (${c.toFixed(1)}mm > 1000mm)`
+    };
+    const u = new $e(e, {
+      maxLeafTris: Ye
+    }), s = Ze(u, e, r);
+    if (s.lineLength === 0) return {
+      valid: false,
+      reason: "No circumference at green point \u2014 mesh may be empty at that height"
+    };
+    const l = r - t;
+    if (l <= n) return {
+      valid: true,
+      reason: ""
+    };
+    const o = Ze(u, e, l);
+    if (s.lineLength > 0 && o.lineLength > 0) {
+      const y = s.lineLength / o.lineLength;
+      if (y < 0.5) return {
+        valid: false,
+        reason: `First circumference is too small relative to second (ratio ${y.toFixed(2)} < 0.5) \u2014 possible trimmed angle`
+      };
+    }
+    const f = r - t * 2;
+    if (f > n) {
+      const y = Ze(u, e, f);
+      if (o.lineLength > 0 && y.lineLength > 0) {
+        const p = o.lineLength / y.lineLength;
+        if (p < 0.5) return {
+          valid: false,
+          reason: `Second circumference is too small relative to third (ratio ${p.toFixed(2)} < 0.5) \u2014 possible trimmed angle`
+        };
+      }
+    }
+    return {
+      valid: true,
+      reason: ""
+    };
+  }
+  const Mn = [
+    {
+      nudge: 3,
+      angle: 0,
+      cutOffset: 5
+    },
+    {
+      nudge: 5,
+      angle: Math.PI * 2 / 3,
+      cutOffset: 3
+    },
+    {
+      nudge: 8,
+      angle: Math.PI * 4 / 3,
+      cutOffset: 4
+    },
+    {
+      nudge: -5,
+      angle: 0,
+      cutOffset: 6
+    }
+  ], nt = 5;
+  function Vt(e, r, n, t) {
+    const i = new Oe().setFromAxisAngle(n, t);
+    return e.applyMatrix4(new kt().makeRotationFromQuaternion(i)), r.map((a) => a.clone().applyQuaternion(i));
+  }
+  function _t(e, r, n) {
+    const t = new Oe().setFromAxisAngle(r, n);
+    e.applyMatrix4(new kt().makeRotationFromQuaternion(t));
+  }
+  function An(e, r, n, t, i, a) {
+    const c = n.getAttribute("position"), u = n.getIndex();
+    if (!u) return r;
+    const l = r[1].y + t * We, o = c.array, f = u.array, y = n.getAttribute("color"), p = y ? y.array : null, x = [], g = [], w = [], v = (A, I, k) => {
+      const G = x.length / 3;
+      return x.push(A, I, k), G;
+    }, m = (A) => [
+      o[A * 3],
+      o[A * 3 + 1],
+      o[A * 3 + 2]
+    ], b = (A, I) => {
+      const k = (l - A[1]) / (I[1] - A[1]);
+      return [
+        A[0] + k * (I[0] - A[0]),
+        l,
+        A[2] + k * (I[2] - A[2])
+      ];
+    }, S = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Map(), M = (A) => {
+      if (S.has(A)) return S.get(A);
+      const [I, k, G] = m(A), U = v(I, k, G);
+      return p && g.push(p[A * 3], p[A * 3 + 1], p[A * 3 + 2]), S.set(A, U), U;
+    }, P = (A, I) => {
+      const k = A < I ? `${A}_${I}` : `${I}_${A}`;
+      if (C.has(k)) return C.get(k);
+      const G = m(A), U = m(I), [re, Le, me] = b(G, U), ae = v(re, Le, me);
+      if (p) {
+        const xe = (l - G[1]) / (U[1] - G[1]);
+        g.push(p[A * 3] + xe * (p[I * 3] - p[A * 3]), p[A * 3 + 1] + xe * (p[I * 3 + 1] - p[A * 3 + 1]), p[A * 3 + 2] + xe * (p[I * 3 + 2] - p[A * 3 + 2]));
+      }
+      return C.set(k, ae), ae;
+    };
+    for (let A = 0; A < f.length; A += 3) {
+      const I = f[A], k = f[A + 1], G = f[A + 2], U = m(I), re = m(k), Le = m(G), me = U[1] < l, ae = re[1] < l, xe = Le[1] < l, Re = (me ? 1 : 0) + (ae ? 1 : 0) + (xe ? 1 : 0);
+      if (Re !== 0) if (Re === 3) w.push(M(I), M(k), M(G));
+      else if (Re === 1) {
+        let pe, we, he;
+        me ? (pe = I, we = k, he = G) : ae ? (pe = k, we = G, he = I) : (pe = G, we = I, he = k), w.push(M(pe), P(pe, we), P(pe, he));
+      } else {
+        let pe, we, he;
+        me ? ae ? (pe = G, we = I, he = k) : (pe = k, we = G, he = I) : (pe = I, we = k, he = G);
+        const Ge = M(we), fe = M(he), je = P(we, pe), Pe = P(he, pe);
+        w.push(Ge, je, fe), w.push(fe, je, Pe);
+      }
+    }
+    const L = w.length / 3, H = /* @__PURE__ */ new Map();
+    for (let A = 0; A < L; A++) for (let I = 0; I < 3; I++) {
+      const k = w[A * 3 + I];
+      H.has(k) || H.set(k, []), H.get(k).push(A);
+    }
+    const O = /* @__PURE__ */ new Map();
+    for (let A = 0; A < L; A++) O.set(A, /* @__PURE__ */ new Set());
+    for (const [, A] of H) for (const I of A) for (const k of A) I !== k && O.get(I).add(k);
+    const $ = /* @__PURE__ */ new Set(), R = [];
+    for (let A = 0; A < L; A++) {
+      if ($.has(A)) continue;
+      const I = [], k = [
+        A
+      ];
+      for ($.add(A); k.length > 0; ) {
+        const G = k.shift();
+        I.push(G);
+        for (const U of O.get(G)) $.has(U) || ($.add(U), k.push(U));
+      }
+      R.push(I);
+    }
+    const Y = r[0];
+    let j = R[0] || [], ne = 1 / 0;
+    for (const A of R) {
+      let I = 1 / 0;
+      for (const k of A) {
+        for (let G = 0; G < 3; G++) {
+          const U = w[k * 3 + G], re = x[U * 3] - Y.x, Le = x[U * 3 + 1] - Y.y, me = x[U * 3 + 2] - Y.z, ae = re * re + Le * Le + me * me;
+          ae < I && (I = ae);
+        }
+        if (I < ne) break;
+      }
+      I < ne && (ne = I, j = A);
+    }
+    const oe = /* @__PURE__ */ new Map(), le = [], ee = [], D = [];
+    let z = 0;
+    for (const A of j) for (let I = 0; I < 3; I++) {
+      const k = w[A * 3 + I];
+      oe.has(k) || (le.push(x[k * 3], x[k * 3 + 1], x[k * 3 + 2]), p && ee.push(g[k * 3], g[k * 3 + 1], g[k * 3 + 2]), oe.set(k, z++)), D.push(oe.get(k));
+    }
+    const F = new J.BufferGeometry();
+    F.setAttribute("position", new J.Float32BufferAttribute(le, 3)), p && ee.length > 0 && F.setAttribute("color", new J.Float32BufferAttribute(ee, 3)), F.setIndex(D), F.computeVertexNormals(), F.computeBoundingBox(), e.geometry.dispose(), e.geometry = F, i.onStatus("Refining alignment...");
+    const V = new h(0, 1, 0);
+    let B = [
+      ...r
+    ];
+    const T = (A, I) => {
+      B = Vt(F, B, A, I), a && _t(a, A, I);
+    };
+    for (let A = 0; A < 5; A++) {
+      const I = F.getAttribute("position"), k = Math.min(B[0].y, B[1].y), U = Math.max(B[0].y, B[1].y) - k;
+      if (U < 1) break;
+      const re = 30, Le = U / re, me = [];
+      for (let ye = 0; ye < re; ye++) {
+        const Te = k + ye * Le, Me = k + (ye + 1) * Le;
+        let Ae = 0, De = 0, ze = 0, Ee = 0;
+        for (let ke = 0; ke < I.count; ke++) {
+          const Ue = I.getY(ke);
+          Ue >= Te && Ue < Me && (Ae += I.getX(ke), De += Ue, ze += I.getZ(ke), Ee++);
+        }
+        Ee > 20 && me.push(new h(Ae / Ee, De / Ee, ze / Ee));
+      }
+      if (me.length < 5) break;
+      const ae = new h();
+      for (const ye of me) ae.add(ye);
+      ae.divideScalar(me.length);
+      let xe = 0, Re = 0, pe = 0, we = 0, he = 0, Ge = 0;
+      for (const ye of me) {
+        const Te = ye.x - ae.x, Me = ye.y - ae.y, Ae = ye.z - ae.z;
+        xe += Te * Te, Re += Te * Me, pe += Te * Ae, we += Me * Me, he += Me * Ae, Ge += Ae * Ae;
+      }
+      let fe = new h(0.01, 1, 0.01).normalize();
+      for (let ye = 0; ye < 30; ye++) {
+        const Te = xe * fe.x + Re * fe.y + pe * fe.z, Me = Re * fe.x + we * fe.y + he * fe.z, Ae = pe * fe.x + he * fe.y + Ge * fe.z, De = new h(Te, Me, Ae), ze = De.length();
+        if (ze < 1e-10 || (De.divideScalar(ze), fe.distanceTo(De) < 1e-8)) break;
+        fe = De;
+      }
+      fe.y < 0 && fe.negate();
+      const je = fe.dot(V);
+      if (Math.acos(Math.min(1, Math.abs(je))) * 180 / Math.PI < 0.1) break;
+      const Pe = new h().crossVectors(fe, V);
+      Pe.length() > 1e-4 && (Pe.normalize(), T(Pe, Math.acos(Math.min(1, Math.max(-1, je)))));
+    }
+    B[0].y > B[1].y && T(new h(1, 0, 0), Math.PI);
+    const E = B[0];
+    F.translate(-E.x, -E.y, -E.z), a && a.translate(-E.x, -E.y, -E.z), B = B.map((A) => new h(A.x - E.x, A.y - E.y, A.z - E.z));
+    const X = B[1].y + 5 * We, q = st(F, new h(0, X, 0), new h(0, 1, 0), B[0]);
+    e.geometry.dispose(), e.geometry = q, q.computeVertexNormals(), q.computeBoundingBox(), i.updateLandmarkPositions(B.map((A) => ({
+      x: A.x,
+      y: A.y,
+      z: A.z
+    })));
+    const ie = q.boundingBox, se = new h();
+    return ie.getSize(se), i.setModelSize(Math.max(se.x, se.y, se.z)), i.setCut(true), i.setAdjustedStartY(null), i.setAdjustedEndY(null), i.setOriginalEndY(B[1].y + 2 * We), B;
+  }
+  function Fn(e, r, n, t) {
+    const i = r.map((x) => new h(x.position.x, x.position.y, x.position.z)), a = i[0], c = i[1];
+    t.onStatus("Cutting double shell above green point...");
+    const u = c.y + 2 * We, s = new h(c.x, u, c.z), l = e.geometry, o = st(l, s, new h(0, 1, 0), a, true);
+    l.dispose(), e.geometry = o, o.computeVertexNormals(), o.computeBoundingBox(), t.onStatus("Setting blue point..."), t.addLandmarkPoint({
+      faceIndex: -1,
+      vertexIndices: [
+        0,
+        1,
+        2
+      ],
+      position: {
+        x: a.x,
+        y: a.y,
+        z: a.z
+      },
+      barycentricCoords: {
+        u: 0.33,
+        v: 0.33,
+        w: 0.34
+      }
+    }), i.push(a.clone()), t.updateLandmarkPositions(i.map((x) => ({
+      x: x.x,
+      y: x.y,
+      z: x.z
+    }))), t.setAligned(true), t.setCut(true), t.setAdjustedStartY(null), t.setAdjustedEndY(null), t.setOriginalEndY(c.y);
+    const f = o.boundingBox, y = new h();
+    f.getSize(y), t.setModelSize(Math.max(y.x, y.y, y.z)), t.onStatus("Validating results...");
+    const p = Wt(o, c.y, a.y, n);
+    p.valid || console.warn(`Double shell validation warning: ${p.reason}`);
+  }
+  function In(e, r, n, t) {
+    var _a, _b;
+    const i = e.geometry.clone(), a = r.map((s) => ({
+      ...s
+    })), c = new h(0, 1, 0);
+    if (t.skipDoubleShellDetection) console.log("Skipping double-shell detection: inner shell already extracted");
+    else {
+      const s = new h(r[0].position.x, r[0].position.y, r[0].position.z), l = new h(r[1].position.x, r[1].position.y, r[1].position.z);
+      t.onStatus("Detecting shell type...");
+      const o = Cn(e.geometry, s, l);
+      if (console.log(`Shell detection: ${o.isDoubleShell ? "DOUBLE" : "SINGLE"} shell (${o.opposingPairs} inward/${o.sampledFaces} total faces, confidence ${(o.confidence * 100).toFixed(0)}%)`), o.isDoubleShell) {
+        (_a = t.setDoubleShell) == null ? void 0 : _a.call(t, true), Fn(e, a, n, t), t.setClippedReferenceGeometry ? (i.computeVertexNormals(), t.setClippedReferenceGeometry(i)) : i.dispose();
+        return;
+      }
+      (_b = t.setDoubleShell) == null ? void 0 : _b.call(t, false);
+    }
+    let u = "";
+    for (let s = 0; s < nt; s++) try {
+      s > 0 && (t.onStatus(`Retry ${s}/${nt - 1} \u2014 ${u}`), e.geometry.dispose(), e.geometry = i.clone(), t.removeLandmarkPoint(2), t.setAligned(false), t.setCut(false));
+      let l = e.geometry, o = a.map((z) => new h(z.position.x, z.position.y, z.position.z));
+      const f = t.setClippedReferenceGeometry ? i.clone() : null;
+      let y = 5;
+      if (s > 0) {
+        const z = Mn[s - 1];
+        y = z.cutOffset;
+        const F = new h().subVectors(o[1], o[0]).normalize();
+        if (z.nudge < 0) o[1].addScaledVector(F, z.nudge);
+        else {
+          const E = new h();
+          Math.abs(F.x) < 0.9 ? E.crossVectors(F, new h(1, 0, 0)).normalize() : E.crossVectors(F, new h(0, 0, 1)).normalize(), E.applyAxisAngle(F, z.angle), o[1].addScaledVector(E, z.nudge);
+        }
+        const V = l.getAttribute("position");
+        let B = 1 / 0, T = 0;
+        for (let E = 0; E < V.count; E++) {
+          const N = V.getX(E) - o[1].x, X = V.getY(E) - o[1].y, q = V.getZ(E) - o[1].z, ie = N * N + X * X + q * q;
+          ie < B && (B = ie, T = E);
+        }
+        o[1].set(V.getX(T), V.getY(T), V.getZ(T)), console.log(`Retry ${s}: nudge=${z.nudge}mm angle=${(z.angle * 180 / Math.PI).toFixed(0)}\xB0 cutOffset=${z.cutOffset}" \u2192 green=(${o[1].x.toFixed(1)}, ${o[1].y.toFixed(1)}, ${o[1].z.toFixed(1)})`);
+      }
+      const p = (z, F) => {
+        o = Vt(l, o, z, F), f && _t(f, z, F);
+      }, x = o[0], g = o[1], { normal: w } = zn(l, g, x);
+      t.onStatus(s > 0 ? `Retry ${s}: Slicing mesh...` : "Slicing mesh at cut plane...");
+      const v = new h().subVectors(g, x).normalize(), m = Math.sign(v.dot(w)), b = g.clone().addScaledVector(w, m * y * We), S = st(l, b, w, x);
+      l.dispose(), l = S, e.geometry = l, t.onStatus(s > 0 ? `Retry ${s}: Rough alignment...` : "Rough alignment...");
+      const C = new h().subVectors(o[1], o[0]).normalize();
+      let M = C.dot(c), P = new h().crossVectors(C, c);
+      P.length() > 1e-4 && (P.normalize(), p(P, Math.acos(Math.min(1, Math.max(-1, M))))), o[0].y > o[1].y && p(new h(1, 0, 0), Math.PI), l.computeVertexNormals(), t.onStatus(s > 0 ? `Retry ${s}: Translating...` : "Translating to origin...");
+      const L = o[0].clone();
+      l.translate(-L.x, -L.y, -L.z), f && f.translate(-L.x, -L.y, -L.z), o = o.map((z) => new h(z.x - L.x, z.y - L.y, z.z - L.z)), t.onStatus(s > 0 ? `Retry ${s}: Isolating limb...` : "Isolating limb region...");
+      {
+        const z = ot(l), F = o[0].y, V = o[1].y, B = new h(0, 1, 0), T = 5;
+        l.computeBoundingBox();
+        const E = l.boundingBox.max.y, N = [];
+        for (let X = F + T; X < E; X += T) {
+          const q = pt(z, l, new h(0, X, 0), B);
+          q > 0 && N.push({
+            y: X,
+            circ: q
+          });
+        }
+        if (N.length > 5) {
+          const X = V - F, q = F + X * 0.3, ie = F + X * 0.7, se = N.filter((A) => A.y >= q && A.y <= ie);
+          if (se.length >= 3) {
+            const A = se.map((U) => U.circ).sort((U, re) => U - re), I = A[Math.floor(A.length / 2)], k = 1.6;
+            let G = null;
+            for (const U of N) if (!(U.y < V - T * 2) && U.circ > I * k) {
+              G = U.y - T;
+              break;
+            }
+            if (G === null) {
+              const U = N.find((re) => Math.abs(re.y - V) < T);
+              if (U && U.circ > I * k) {
+                for (let re = N.length - 1; re >= 0; re--) if (!(N[re].y > V + T) && N[re].circ <= I * k) {
+                  G = N[re].y + T;
+                  break;
+                }
+              }
+            }
+            if (G !== null && G > F + X * 0.5) {
+              console.log(`Limb isolation: cutting at Y=${G.toFixed(1)}mm (baseline circ=${I.toFixed(1)}mm, threshold=${(I * k).toFixed(1)}mm)`);
+              const U = st(l, new h(0, G, 0), B, o[0]);
+              l.dispose(), l = U, e.geometry = l, l.computeVertexNormals(), l.computeBoundingBox();
+            } else console.log(`Limb isolation: no anomaly detected (baseline=${I.toFixed(1)}mm)`);
+          }
+        }
+      }
+      t.onStatus(s > 0 ? `Retry ${s}: PCA alignment...` : "Iterative PCA alignment...");
+      const H = 10, O = 80, $ = o[0].y, R = o[1].y;
+      let Y = R - H;
+      for (let z = 0; z < O; z++) {
+        const F = Math.min(Y, R), V = Math.max(Y, R), B = rt(l, F, V);
+        if (B && (M = B.dot(c), Math.acos(Math.min(1, Math.abs(M))) * 180 / Math.PI > 0.1 && (P = new h().crossVectors(B, c), P.length() > 1e-4))) {
+          P.normalize(), p(P, Math.acos(Math.min(1, Math.max(-1, M))));
+          const E = o[0].clone();
+          l.translate(-E.x, -E.y, -E.z), f && f.translate(-E.x, -E.y, -E.z), o = o.map((N) => new h(N.x - E.x, N.y - E.y, N.z - E.z));
+        }
+        if (Y -= H, Y <= $) break;
+      }
+      l.computeVertexNormals(), t.onStatus(s > 0 ? `Retry ${s}: Setting blue point...` : "Setting blue point...");
+      const j = new h(o[0].x, o[0].y, o[0].z);
+      o.push(j), t.addLandmarkPoint({
+        faceIndex: -1,
+        vertexIndices: [
+          0,
+          1,
+          2
+        ],
+        position: {
+          x: j.x,
+          y: j.y,
+          z: j.z
+        },
+        barycentricCoords: {
+          u: 0.33,
+          v: 0.33,
+          w: 0.34
+        }
+      }), t.onStatus(s > 0 ? `Retry ${s}: Final PCA...` : "Final PCA refinement...");
+      for (let z = 0; z < 3; z++) {
+        const F = rt(l, 0, o[1].y);
+        if (F) {
+          if (M = F.dot(c), Math.acos(Math.min(1, Math.abs(M))) * 180 / Math.PI < 0.1) break;
+          if (P = new h().crossVectors(F, c), P.length() > 1e-4) {
+            P.normalize(), p(P, Math.acos(Math.min(1, Math.max(-1, M))));
+            const B = o[0].clone();
+            l.translate(-B.x, -B.y, -B.z), f && f.translate(-B.x, -B.y, -B.z), o = o.map((T) => new h(T.x - B.x, T.y - B.y, T.z - B.z));
+          }
+        }
+      }
+      if (o[1].y < o[0].y) {
+        p(new h(1, 0, 0), Math.PI);
+        const z = o[0].clone();
+        l.translate(-z.x, -z.y, -z.z), f && f.translate(-z.x, -z.y, -z.z), o = o.map((F) => new h(F.x - z.x, F.y - z.y, F.z - z.z));
+      }
+      l.computeVertexNormals(), l.computeBoundingBox(), t.onStatus(s > 0 ? `Retry ${s}: Circumference refinement...` : "Circumference refinement...");
+      {
+        const z = ot(l), F = o[1].y, V = o[0].y, B = [
+          F - We,
+          F - 2 * We,
+          F - 3 * We
+        ].filter((T) => T > V + 5);
+        if (B.length >= 2) {
+          const T = Math.PI / 180, E = (I, k) => {
+            const G = new h(0, 1, 0);
+            Math.abs(I) > 1e-10 && G.applyQuaternion(new Oe().setFromAxisAngle(new h(1, 0, 0), I)), Math.abs(k) > 1e-10 && G.applyQuaternion(new Oe().setFromAxisAngle(new h(0, 0, 1), k));
+            let U = 0;
+            for (const re of B) U += pt(z, l, new h(0, re, 0), G);
+            return U;
+          };
+          let N = 0, X = 0, q = E(0, 0);
+          for (let I = -3; I <= 3; I += 0.5) for (let k = -3; k <= 3; k += 0.5) {
+            const G = E(I * T, k * T);
+            G > 0 && G < q && (q = G, N = I * T, X = k * T);
+          }
+          const ie = N, se = X;
+          for (let I = -5; I <= 5; I++) for (let k = -5; k <= 5; k++) {
+            const G = ie + I * 0.1 * T, U = se + k * 0.1 * T, re = E(G, U);
+            re > 0 && re < q && (q = re, N = G, X = U);
+          }
+          const A = Math.sqrt(N * N + X * X);
+          if (A > 0.05 * T) {
+            console.log(`Circumference refinement: rotating ${(-N / T).toFixed(2)}\xB0X ${(-X / T).toFixed(2)}\xB0Z`), Math.abs(N) > 0.01 * T && p(new h(1, 0, 0), -N), Math.abs(X) > 0.01 * T && p(new h(0, 0, 1), -X);
+            const I = o[0].clone();
+            l.translate(-I.x, -I.y, -I.z), f && f.translate(-I.x, -I.y, -I.z), o = o.map((k) => new h(k.x - I.x, k.y - I.y, k.z - I.z)), l.computeVertexNormals();
+          } else console.log(`Circumference refinement: already optimal (${(A / T).toFixed(3)}\xB0)`);
+        }
+      }
+      const ne = o.map((z) => ({
+        x: z.x,
+        y: z.y,
+        z: z.z
+      }));
+      t.updateLandmarkPositions(ne), t.setAligned(true), t.onStatus(s > 0 ? `Retry ${s}: Cutting mesh...` : 'Cutting mesh 2" above green...'), o = An(e, o, l, 5, t, f), t.onStatus("Validating results...");
+      const oe = e.geometry, le = o[1].y, ee = o[0].y, D = Wt(oe, le, ee, n);
+      if (D.valid) {
+        console.log(`Processing succeeded on attempt ${s + 1}`), f && t.setClippedReferenceGeometry && (f.computeVertexNormals(), t.setClippedReferenceGeometry(f));
+        break;
+      }
+      console.warn(`Attempt ${s + 1} failed validation: ${D.reason}`), u = D.reason, f && f.dispose(), s === nt - 1 && (t.setError(`Processing produced unusual results after ${nt} attempts: ${D.reason}`), e.geometry.dispose(), e.geometry = i.clone(), t.removeLandmarkPoint(2), t.setAligned(false), t.setCut(false));
+    } catch (l) {
+      console.error("Processing failed:", l), t.setError(l instanceof Error ? l.message : "Failed to process mesh.");
+      break;
+    }
+    i.dispose();
+  }
+  const Ln = ({ message: e, onDismiss: r }) => W("div", {
+    style: {
+      position: "absolute",
+      top: 16,
+      right: 16,
+      padding: "12px 16px",
+      backgroundColor: "rgba(220, 53, 69, 0.95)",
+      borderRadius: 8,
+      color: "#fff",
+      fontSize: 14,
+      maxWidth: 300,
+      zIndex: 100,
+      display: "flex",
+      alignItems: "flex-start",
+      gap: 12
+    },
+    children: [
+      W("div", {
+        style: {
+          flex: 1
+        },
+        children: [
+          d("div", {
+            style: {
+              fontWeight: "bold",
+              marginBottom: 4
+            },
+            children: "Error"
+          }),
+          d("div", {
+            style: {
+              fontSize: 12,
+              opacity: 0.9
+            },
+            children: e
+          })
+        ]
+      }),
+      d("button", {
+        onClick: r,
+        style: {
+          background: "none",
+          border: "none",
+          color: "#fff",
+          cursor: "pointer",
+          fontSize: 18,
+          padding: 0,
+          lineHeight: 1,
+          opacity: 0.7
+        },
+        children: "x"
+      })
+    ]
+  }), At = ({ message: e }) => W("div", {
+    style: {
+      position: "absolute",
+      top: 0,
+      left: 0,
+      right: 0,
+      bottom: 0,
+      backgroundColor: "rgba(0, 0, 0, 0.7)",
+      display: "flex",
+      flexDirection: "column",
+      alignItems: "center",
+      justifyContent: "center",
+      zIndex: 100
+    },
+    children: [
+      d("div", {
+        style: {
+          width: 48,
+          height: 48,
+          border: "4px solid rgba(255, 255, 255, 0.2)",
+          borderTopColor: "#4a90d9",
+          borderRadius: "50%",
+          animation: "spin 1s linear infinite"
+        }
+      }),
+      e && d("div", {
+        style: {
+          marginTop: 16,
+          color: "#fff",
+          fontSize: 14
+        },
+        children: e
+      }),
+      d("style", {
+        children: "@keyframes spin { to { transform: rotate(360deg); } }"
+      })
+    ]
+  }), Pn = ({ mesh: e, maxPoints: r = 2, meshColor: n = "#c8c8c8", meshOpacity: t = 1 }) => {
+    const { addLandmarkPoint: i, landmarkPoints: a } = gt(), c = Fe((l) => {
+      if (a.length >= r) return;
+      l.stopPropagation();
+      const o = l.intersections[0], f = o == null ? void 0 : o.faceIndex;
+      if (!o || f == null) return;
+      const y = e.geometry, p = y.index;
+      let x;
+      p ? x = [
+        p.getX(f * 3),
+        p.getX(f * 3 + 1),
+        p.getX(f * 3 + 2)
+      ] : x = [
+        f * 3,
+        f * 3 + 1,
+        f * 3 + 2
+      ];
+      const g = y.getAttribute("position"), w = new h().fromBufferAttribute(g, x[0]), v = new h().fromBufferAttribute(g, x[1]), m = new h().fromBufferAttribute(g, x[2]);
+      w.applyMatrix4(e.matrixWorld), v.applyMatrix4(e.matrixWorld), m.applyMatrix4(e.matrixWorld);
+      const b = o.point, S = vn(b, w, v, m), C = {
+        faceIndex: f,
+        vertexIndices: x,
+        position: {
+          x: b.x,
+          y: b.y,
+          z: b.z
+        },
+        barycentricCoords: S
+      };
+      i(C);
+    }, [
+      e,
+      i,
+      a.length,
+      r
+    ]), u = de(() => !!e.geometry.getAttribute("color"), [
+      e
+    ]), s = de(() => new J.MeshStandardMaterial({
+      color: u ? "#ffffff" : n,
+      side: J.DoubleSide,
+      roughness: 0.6,
+      metalness: 0.1,
+      transparent: t < 1,
+      opacity: t,
+      vertexColors: u
+    }), [
+      n,
+      t,
+      u
+    ]);
+    return d("primitive", {
+      object: e,
+      onClick: c,
+      material: s
+    });
+  }, Dn = ({ point: e, index: r, markerSize: n, color: t, label: i }) => {
+    const [a, c] = Q(false);
+    return W("mesh", {
+      position: [
+        e.position.x,
+        e.position.y,
+        e.position.z
+      ],
+      onPointerOver: () => c(true),
+      onPointerOut: () => c(false),
+      children: [
+        d("sphereGeometry", {
+          args: [
+            n,
+            16,
+            16
+          ]
+        }),
+        d("meshBasicMaterial", {
+          color: t
+        }),
+        a && d(Ke, {
+          center: true,
+          style: {
+            pointerEvents: "none"
+          },
+          children: d("div", {
+            style: {
+              padding: "3px 8px",
+              backgroundColor: "rgba(0, 0, 0, 0.75)",
+              borderRadius: 4,
+              color: "#fff",
+              fontSize: 12,
+              fontFamily: "system-ui, sans-serif",
+              whiteSpace: "nowrap",
+              transform: "translateY(-24px)"
+            },
+            children: i
+          })
+        })
+      ]
+    }, r);
+  }, Tn = ({ modelSize: e, labels: r }) => {
+    const { landmarkPoints: n } = gt(), t = e * 0.02, i = [
+      "#ff4444",
+      "#44ff44",
+      "#4444ff"
+    ], c = r ?? [
+      "Origin",
+      "MPT",
+      "Cut Plane"
+    ];
+    return d(He, {
+      children: n.map((u, s) => d(Dn, {
+        point: u,
+        index: s,
+        markerSize: t,
+        color: i[s],
+        label: c[s]
+      }, s))
+    });
+  };
+  function kn(e) {
+    return de(() => e ? new $e(e, {
+      maxLeafTris: Ye
+    }) : null, [
+      e
+    ]);
+  }
+  const Ft = (e, r) => {
+    const n = Math.abs(e - r);
+    return n < 1 ? "#8BC34A" : n < 5 ? "#FFC107" : "#FF5722";
+  }, It = new J.Color("#8BC34A"), Lt = new J.Color("#FFC107"), Bn = new J.Color("#FF5722"), Rn = (e) => {
+    if (e < 1) return It.clone();
+    if (e < 5) {
+      const n = (e - 1) / 4;
+      return It.clone().lerp(Lt, n);
+    }
+    const r = Math.min((e - 5) / 5, 1);
+    return Lt.clone().lerp(Bn, r);
+  }, En = (e, r) => {
+    const n = e.length, t = new Float32Array(n * 2 * 3), i = new Float32Array(n * 2 * 3), a = [];
+    for (let s = 0; s < n; s++) {
+      const l = e[s], o = r[s], f = l.distanceTo(o), y = Rn(f);
+      if (t[s * 6] = l.x, t[s * 6 + 1] = l.y, t[s * 6 + 2] = l.z, i[s * 6] = y.r, i[s * 6 + 1] = y.g, i[s * 6 + 2] = y.b, t[s * 6 + 3] = o.x, t[s * 6 + 4] = o.y, t[s * 6 + 5] = o.z, i[s * 6 + 3] = y.r, i[s * 6 + 4] = y.g, i[s * 6 + 5] = y.b, s < n - 1) {
+        const p = s * 2, x = p + 1, g = (s + 1) * 2, w = g + 1;
+        a.push(p, x, g, x, w, g);
+      }
+    }
+    const c = new J.BufferGeometry();
+    c.setAttribute("position", new J.Float32BufferAttribute(t, 3)), c.setAttribute("color", new J.Float32BufferAttribute(i, 3)), c.setIndex(a);
+    const u = new J.MeshBasicMaterial({
+      vertexColors: true,
+      transparent: true,
+      opacity: 0.25,
+      side: J.DoubleSide,
+      depthTest: false,
+      depthWrite: false
+    });
+    return new J.Mesh(c, u);
+  }, Wn = ({ bvh: e, geometry: r, yPosition: n, color: t = "#00ff00", labelX: i, onDataChange: a, displayUnit: c = "mm", useInnerSurface: u = false, formValue: s, lineWidth: l = 1.5 }) => {
+    const o = de(() => Ze(e, r, n, u), [
+      e,
+      r,
+      n,
+      u
+    ]), { linePoints: f, lineLength: y } = o, p = de(() => {
+      if (s == null || y <= 0 || f.length < 2) return null;
+      const v = s / y, m = f.reduce((S, C) => S + C.x, 0) / f.length, b = f.reduce((S, C) => S + C.z, 0) / f.length;
+      return f.map((S) => new h(m + (S.x - m) * v, S.y, b + (S.z - b) * v));
+    }, [
+      f,
+      y,
+      s
+    ]), x = de(() => !p || f.length < 2 ? null : En(f, p), [
+      f,
+      p
+    ]);
+    Se(() => () => {
+      x && (x.geometry.dispose(), x.material.dispose());
+    }, [
+      x
+    ]);
+    const g = Ie(null), w = de(() => {
+      const v = new J.BufferGeometry();
+      v.setAttribute("position", new J.Float32BufferAttribute(new Float32Array(6), 3));
+      const m = new J.LineBasicMaterial({
+        color: 6710886,
+        depthTest: false,
+        depthWrite: false,
+        transparent: true
+      });
+      return new J.Line(v, m);
+    }, []);
+    return Se(() => () => {
+      w.geometry.dispose(), w.material.dispose();
+    }, [
+      w
+    ]), Se(() => {
+      y > 0 && (a == null ? void 0 : a({
+        yPosition: n,
+        originalValue: y,
+        modifiedValue: null
+      }));
+    }, [
+      y,
+      n,
+      a
+    ]), Pt(({ camera: v }) => {
+      if (!g.current || f.length < 2) return;
+      const m = new h();
+      v.getWorldDirection(m);
+      const b = new h(m.x, 0, m.z);
+      if (b.lengthSq() < 1e-8) return;
+      b.normalize();
+      const S = new h().crossVectors(b, new h(0, 1, 0)).normalize();
+      let C = -1 / 0, M = f[0];
+      for (const O of f) {
+        const $ = S.x * O.x + S.z * O.z;
+        $ > C && (C = $, M = O);
+      }
+      const P = i * 0.35, L = new h(M.x + S.x * P, n, M.z + S.z * P);
+      g.current.position.copy(L);
+      const H = w.geometry.getAttribute("position");
+      H.setXYZ(0, M.x, M.y, M.z), H.setXYZ(1, L.x, L.y, L.z), H.needsUpdate = true;
+    }), f.length < 2 ? null : W("group", {
+      children: [
+        d(ge, {
+          points: f,
+          color: t,
+          lineWidth: l,
+          depthTest: false,
+          depthWrite: false,
+          transparent: true
+        }),
+        x && d("primitive", {
+          object: x
+        }),
+        p && s != null && d(ge, {
+          points: p,
+          color: Ft(y, s),
+          lineWidth: 2.5,
+          dashed: true,
+          dashSize: 2,
+          gapSize: 1.5,
+          depthTest: false,
+          depthWrite: false,
+          transparent: true,
+          opacity: 0.8
+        }),
+        d("primitive", {
+          object: w
+        }),
+        d("group", {
+          ref: g,
+          children: d(Ke, {
+            zIndexRange: [
+              100,
+              0
+            ],
+            style: {
+              pointerEvents: "none",
+              transform: "translateY(-50%)"
+            },
+            children: W("div", {
+              style: {
+                display: "flex",
+                alignItems: "stretch",
+                gap: 0,
+                marginLeft: 10,
+                pointerEvents: "none",
+                whiteSpace: "nowrap"
+              },
+              children: [
+                W("div", {
+                  style: {
+                    display: "flex",
+                    alignItems: "center",
+                    gap: 4,
+                    padding: "5px 10px",
+                    backgroundColor: "rgba(0, 0, 0, 0.75)",
+                    borderRadius: s != null ? "4px 0 0 4px" : 4
+                  },
+                  children: [
+                    d("span", {
+                      style: {
+                        fontSize: 14,
+                        color: "#fff",
+                        fontFamily: "monospace",
+                        minWidth: 52,
+                        textAlign: "right"
+                      },
+                      children: c === "inch" ? (y / 25.4).toFixed(2) : y.toFixed(1)
+                    }),
+                    d("span", {
+                      style: {
+                        fontSize: 11,
+                        color: "rgba(255,255,255,0.6)",
+                        fontFamily: "monospace"
+                      },
+                      children: c === "inch" ? "in" : "mm"
+                    })
+                  ]
+                }),
+                s != null && y > 0 && (() => {
+                  const v = y - s, m = v > 0.5 ? "\u25B2" : v < -0.5 ? "\u25BC" : "", b = Ft(y, s);
+                  return W("div", {
+                    style: {
+                      display: "flex",
+                      alignItems: "center",
+                      gap: 5,
+                      padding: "5px 10px",
+                      backgroundColor: "rgba(0, 0, 0, 0.55)",
+                      borderRadius: "0 4px 4px 0",
+                      borderLeft: "1px solid rgba(255,255,255,0.12)"
+                    },
+                    children: [
+                      m && d("span", {
+                        style: {
+                          fontSize: 10,
+                          color: b,
+                          lineHeight: 1
+                        },
+                        children: m
+                      }),
+                      W("span", {
+                        style: {
+                          fontSize: 13,
+                          color: b,
+                          fontFamily: "monospace",
+                          fontWeight: 600
+                        },
+                        children: [
+                          v > 0 ? "+" : "",
+                          c === "inch" ? (v / 25.4).toFixed(2) : v.toFixed(1)
+                        ]
+                      }),
+                      W("span", {
+                        style: {
+                          fontSize: 11,
+                          color: "rgba(255,255,255,0.4)",
+                          fontFamily: "monospace"
+                        },
+                        children: [
+                          "form ",
+                          c === "inch" ? (s / 25.4).toFixed(2) : s.toFixed(0)
+                        ]
+                      })
+                    ]
+                  });
+                })()
+              ]
+            })
+          })
+        })
+      ]
+    });
+  }, Vn = nn(Wn), _n = ({ mesh: e, startY: r, endY: n, spacing: t, modelSize: i, onMeasurementsChange: a, reverseOrder: c = false, displayUnit: u = "mm", useInnerSurface: s = false, formMeasurements: l, originY: o }) => {
+    const f = Ie(/* @__PURE__ */ new Map()), y = e.geometry, p = kn(y), x = de(() => {
+      const m = [];
+      if (c) for (let b = n; b >= r; b -= t) m.push(b);
+      else for (let b = r; b <= n; b += t) m.push(b);
+      return m;
+    }, [
+      r,
+      n,
+      t,
+      c
+    ]);
+    Se(() => {
+      f.current.clear();
+    }, [
+      x
+    ]);
+    const g = [
+      "#5B9BD5"
+    ], w = i * un, v = Fe((m) => {
+      f.current.set(m.yPosition, m);
+      const b = Array.from(f.current.values()).sort((S, C) => c ? C.yPosition - S.yPosition : S.yPosition - C.yPosition);
+      a == null ? void 0 : a(b);
+    }, [
+      a,
+      c
+    ]);
+    return p ? d(He, {
+      children: x.map((m, b) => d(Vn, {
+        bvh: p,
+        geometry: y,
+        yPosition: m,
+        color: o != null && Math.abs(m - o) < t * 0.5 ? "#44ff44" : g[b % g.length],
+        labelX: w,
+        onDataChange: v,
+        displayUnit: u,
+        useInnerSurface: s,
+        formValue: l == null ? void 0 : l[b],
+        lineWidth: o != null && Math.abs(m - o) < t * 0.5 ? 4 : 1.5
+      }, m))
+    }) : null;
+  }, On = ({ mesh: e, greenY: r, modelSize: n, displayUnit: t = "mm" }) => {
+    var _a;
+    const i = e.geometry;
+    i.computeBoundingBox();
+    const a = ((_a = i.boundingBox) == null ? void 0 : _a.min.y) ?? 0, c = r - a, u = n * 0.4, s = n * 0.03, l = Ie(null);
+    Pt(({ camera: v }) => {
+      if (!l.current) return;
+      const m = new h();
+      v.getWorldDirection(m);
+      const b = new h(m.x, 0, m.z);
+      if (b.lengthSq() < 1e-8) return;
+      b.normalize();
+      const S = new h().crossVectors(new h(0, 1, 0), b).normalize();
+      l.current.position.set(S.x * u, 0, S.z * u);
+      const C = v.position.x - l.current.position.x, M = v.position.z - l.current.position.z;
+      l.current.rotation.y = Math.atan2(C, M);
+    });
+    const o = new h(0, r, 0), f = new h(0, a, 0), y = new h(0, (r + a) / 2, 0), p = new h(-s, r, 0), x = new h(s, r, 0), g = new h(-s, a, 0), w = new h(s, a, 0);
+    return W("group", {
+      ref: l,
+      children: [
+        d(ge, {
+          points: [
+            o,
+            f
+          ],
+          color: "#888888",
+          lineWidth: 1.5,
+          depthTest: false
+        }),
+        d(ge, {
+          points: [
+            p,
+            x
+          ],
+          color: "#888888",
+          lineWidth: 1.5,
+          depthTest: false
+        }),
+        d(ge, {
+          points: [
+            g,
+            w
+          ],
+          color: "#888888",
+          lineWidth: 1.5,
+          depthTest: false
+        }),
+        d("mesh", {
+          position: y,
+          children: d(Ke, {
+            center: true,
+            style: {
+              pointerEvents: "none"
+            },
+            children: W("div", {
+              style: {
+                padding: "4px 8px",
+                backgroundColor: "rgba(0, 0, 0, 0.7)",
+                borderRadius: 4,
+                color: "#fff",
+                fontSize: 16,
+                fontFamily: "monospace",
+                whiteSpace: "nowrap",
+                transform: "rotate(-90deg)",
+                transformOrigin: "center center",
+                pointerEvents: "none"
+              },
+              children: [
+                t === "inch" ? (c / 25.4).toFixed(2) : c.toFixed(1),
+                " ",
+                t === "inch" ? "in" : "mm"
+              ]
+            })
+          })
+        })
+      ]
+    });
+  }, $n = ({ modelSize: e, isAligned: r, isCut: n, mesh: t, viewMode: i, sliceY: a, landmarkCount: c = 0 }) => {
+    const { set: u, size: s, camera: l, invalidate: o } = on(), f = Ie(false), y = Ie(r), p = Ie(n), x = Ie(i), g = Ie(new h()), w = Ie(null), v = Ie(c), m = Fe(() => {
+      if (!t || e <= 0) return;
+      const S = t.geometry;
+      S.computeBoundingBox();
+      const C = S.boundingBox, M = new h();
+      C.getCenter(M);
+      const P = new h();
+      C.getSize(P), g.current.copy(P);
+      const L = s.width / s.height, H = Math.max(P.y, P.x / L) * 1.2, O = H * L, $ = new J.OrthographicCamera(-O / 2, O / 2, H / 2, -H / 2, 0.1, e * 10);
+      $.position.set(0, M.y, e * 2), $.lookAt(0, M.y, 0), u({
+        camera: $
+      });
+    }, [
+      t,
+      e,
+      s,
+      u
+    ]), b = Fe((S) => {
+      const C = S.position.clone(), M = C.length(), P = Math.atan2(C.x, C.z), L = Math.acos(C.y / M), O = P + 0.02;
+      S.position.set(M * Math.sin(L) * Math.sin(O), M * Math.cos(L), M * Math.sin(L) * Math.cos(O)), S.lookAt(0, 0, 0), S.updateMatrixWorld(true), o();
+    }, [
+      o
+    ]);
+    return Se(() => {
+      if (e > 0 && !f.current && !r) {
+        f.current = true;
+        const S = new J.PerspectiveCamera(50, s.width / s.height, 0.1, e * 10);
+        S.position.set(e * 0.3, e * 0.2, e * 1.5), S.lookAt(0, 0, 0), u({
+          camera: S
+        }), requestAnimationFrame(() => b(S));
+      }
+    }, [
+      e,
+      s,
+      u,
+      r,
+      b
+    ]), Se(() => {
+      const S = v.current;
+      v.current = c, S === 0 && c === 1 && !r && requestAnimationFrame(() => b(l));
+    }, [
+      c,
+      r,
+      l,
+      b
+    ]), Se(() => {
+      y.current === r && p.current === n || (y.current = r, p.current = n, r && i === "3D" && m());
+    }, [
+      r,
+      n,
+      i,
+      m
+    ]), Se(() => {
+      if (x.current === i) return;
+      const S = x.current;
+      if (x.current = i, !(!r || !t || e <= 0)) if (i === "2D" && a != null) {
+        w.current = l;
+        const C = t.geometry, M = C.getAttribute("position"), P = M.array, L = e * 0.15;
+        let H = 1 / 0, O = -1 / 0, $ = 1 / 0, R = -1 / 0, Y = false;
+        for (let B = 0; B < M.count; B++) if (Math.abs(P[B * 3 + 1] - a) < L) {
+          const T = P[B * 3], E = P[B * 3 + 2];
+          T < H && (H = T), T > O && (O = T), E < $ && ($ = E), E > R && (R = E), Y = true;
+        }
+        if (!Y) {
+          C.computeBoundingBox();
+          const B = C.boundingBox;
+          H = B.min.x, O = B.max.x, $ = B.min.z, R = B.max.z;
+        }
+        const j = (H + O) / 2, ne = ($ + R) / 2, oe = s.width / s.height, le = 1.4, ee = (O - H) * le, D = (R - $) * le;
+        let z, F;
+        ee / D > oe ? (z = ee, F = ee / oe) : (F = D, z = D * oe);
+        const V = new J.OrthographicCamera(-z / 2, z / 2, F / 2, -F / 2, 0.1, e * 10);
+        V.position.set(j, a + e * 2, ne), V.up.set(0, 0, -1), V.lookAt(j, a, ne), u({
+          camera: V
+        });
+      } else S === "2D" && (w.current ? (u({
+        camera: w.current
+      }), w.current = null) : m());
+    }, [
+      i,
+      a,
+      r,
+      t,
+      e,
+      s,
+      u,
+      l,
+      m
+    ]), Se(() => {
+      if (!r || !l || !l.isOrthographicCamera) return;
+      const S = l;
+      if (i === "2D") {
+        if (!t || a == null) return;
+        const C = t.geometry, M = C.getAttribute("position"), P = M.array, L = e * 0.15;
+        let H = 1 / 0, O = -1 / 0, $ = 1 / 0, R = -1 / 0, Y = false;
+        for (let z = 0; z < M.count; z++) if (Math.abs(P[z * 3 + 1] - a) < L) {
+          const F = P[z * 3], V = P[z * 3 + 2];
+          F < H && (H = F), F > O && (O = F), V < $ && ($ = V), V > R && (R = V), Y = true;
+        }
+        if (!Y) {
+          C.computeBoundingBox();
+          const z = C.boundingBox;
+          H = z.min.x, O = z.max.x, $ = z.min.z, R = z.max.z;
+        }
+        const j = s.width / s.height, ne = 1.4, oe = (O - H) * ne, le = (R - $) * ne;
+        let ee, D;
+        oe / le > j ? (ee = oe, D = oe / j) : (D = le, ee = le * j), S.left = -ee / 2, S.right = ee / 2, S.top = D / 2, S.bottom = -D / 2;
+      } else {
+        const C = g.current, M = s.width / s.height, P = Math.max(C.y, C.x / M) * 1.2, L = P * M;
+        S.left = -L / 2, S.right = L / 2, S.top = P / 2, S.bottom = -P / 2;
+      }
+      S.updateProjectionMatrix();
+    }, [
+      s.width,
+      s.height,
+      r,
+      l,
+      i,
+      t
+    ]), null;
+  }, jn = ({ mesh: e, isDragging: r }) => {
+    var _a;
+    const n = e.geometry;
+    n.computeBoundingBox();
+    const t = new h();
+    return (_a = n.boundingBox) == null ? void 0 : _a.getCenter(t), d(Dt, {
+      enableDamping: false,
+      enablePan: false,
+      minPolarAngle: Math.PI * 0.15,
+      maxPolarAngle: Math.PI * 0.85,
+      minZoom: 0.5,
+      maxZoom: 3,
+      enabled: !r,
+      target: [
+        t.x,
+        t.y,
+        t.z
+      ]
+    });
+  }, Nn = ({ wasAutoScaled: e, onDismiss: r }) => W("div", {
+    style: {
+      position: "absolute",
+      bottom: 16,
+      left: 16,
+      zIndex: 10,
+      display: "flex",
+      alignItems: "flex-start",
+      gap: 10,
+      padding: "10px 14px",
+      maxWidth: 320,
+      backgroundColor: e ? "rgba(30, 70, 160, 0.92)" : "rgba(40, 40, 40, 0.88)",
+      borderRadius: 8,
+      boxShadow: "0 2px 12px rgba(0,0,0,0.15)",
+      fontFamily: "system-ui, sans-serif"
+    },
+    children: [
+      d("span", {
+        style: {
+          fontSize: 13,
+          color: "#fff",
+          lineHeight: "20px"
+        },
+        children: e ? "Units detected as meters - converted to mm" : "Units detected as mm"
+      }),
+      d("button", {
+        onClick: r,
+        style: {
+          background: "none",
+          border: "none",
+          color: "rgba(255,255,255,0.7)",
+          cursor: "pointer",
+          fontSize: 16,
+          lineHeight: "20px",
+          padding: 0,
+          marginLeft: "auto",
+          flexShrink: 0
+        },
+        children: "X"
+      })
+    ]
+  }), Hn = ({ isDoubleShell: e, onDismiss: r }) => W("div", {
+    style: {
+      position: "absolute",
+      bottom: 68,
+      left: 16,
+      zIndex: 10,
+      display: "flex",
+      alignItems: "flex-start",
+      gap: 10,
+      padding: "10px 14px",
+      maxWidth: 320,
+      backgroundColor: e ? "rgba(130, 80, 20, 0.92)" : "rgba(40, 40, 40, 0.88)",
+      borderRadius: 8,
+      boxShadow: "0 2px 12px rgba(0,0,0,0.15)",
+      fontFamily: "system-ui, sans-serif"
+    },
+    children: [
+      d("span", {
+        style: {
+          fontSize: 13,
+          color: "#fff",
+          lineHeight: "20px"
+        },
+        children: e ? "Double shell scan detected" : "Single shell scan detected"
+      }),
+      d("button", {
+        onClick: r,
+        style: {
+          background: "none",
+          border: "none",
+          color: "rgba(255,255,255,0.7)",
+          cursor: "pointer",
+          fontSize: 16,
+          lineHeight: "20px",
+          padding: 0,
+          marginLeft: "auto",
+          flexShrink: 0
+        },
+        children: "X"
+      })
+    ]
+  }), Yn = ({ steps: e, currentStep: r, accentColor: n = "rgb(12, 67, 173)" }) => d("div", {
+    style: {
+      backgroundColor: "#fff",
+      borderBottom: "1px solid #e0e0e0",
+      display: "flex",
+      alignItems: "center",
+      padding: "24px 24px",
+      flexShrink: 0
+    },
+    children: e.map((t, i) => {
+      const a = t.number < r, c = t.number === r;
+      return W("div", {
+        style: {
+          display: "contents"
+        },
+        children: [
+          W("div", {
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: 8,
+              padding: "0 8px",
+              flexShrink: 0,
+              cursor: "default"
+            },
+            children: [
+              d("div", {
+                style: {
+                  width: 24,
+                  height: 24,
+                  borderRadius: "50%",
+                  backgroundColor: a || c ? n : "rgba(0, 0, 0, 0.38)",
+                  color: "#fff",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  fontSize: 12,
+                  fontFamily: "system-ui, sans-serif",
+                  flexShrink: 0
+                },
+                children: a ? "\u2713" : t.number
+              }),
+              d("div", {
+                style: {
+                  fontSize: 14,
+                  fontWeight: c ? 600 : 400,
+                  color: c ? "rgba(0, 0, 0, 0.87)" : "rgba(0, 0, 0, 0.54)",
+                  fontFamily: "system-ui, sans-serif",
+                  whiteSpace: "nowrap"
+                },
+                children: t.label
+              })
+            ]
+          }),
+          i < e.length - 1 && d("div", {
+            style: {
+              flex: "auto",
+              borderTop: "1px solid #bdbdbd",
+              margin: "0 8px"
+            }
+          })
+        ]
+      }, t.number);
+    })
+  }), Gn = ({ mesh: e, upperY: r, originY: n, modelSize: t, meshColor: i = "#c8c8c8", displayUnit: a = "mm" }) => {
+    const c = e.geometry, u = de(() => new $e(c, {
+      maxLeafTris: Ye
+    }), [
+      c
+    ]), s = de(() => Ze(u, c, n), [
+      u,
+      c,
+      n
+    ]), l = de(() => new it(new h(0, -1, 0), r), [
+      r
+    ]), { mlLine: o, apLine: f, mlWidth: y, apWidth: p } = de(() => {
+      let w = null, v = null, m = 0, b = 0;
+      if (s.linePoints.length >= 2) {
+        let S = s.linePoints[0], C = s.linePoints[0], M = s.linePoints[0], P = s.linePoints[0];
+        for (const L of s.linePoints) L.x < S.x && (S = L), L.x > C.x && (C = L), L.z < M.z && (M = L), L.z > P.z && (P = L);
+        w = [
+          new h(S.x, n, S.z),
+          new h(C.x, n, C.z)
+        ], v = [
+          new h(M.x, n, M.z),
+          new h(P.x, n, P.z)
+        ], m = w[0].distanceTo(w[1]), b = v[0].distanceTo(v[1]);
+      }
+      return {
+        mlLine: w,
+        apLine: v,
+        mlWidth: m,
+        apWidth: b
+      };
+    }, [
+      s,
+      n
+    ]), x = (w) => a === "inch" ? (w / 25.4).toFixed(2) : w.toFixed(1), g = a === "inch" ? "in" : "mm";
+    return W(He, {
+      children: [
+        d("mesh", {
+          geometry: e.geometry,
+          children: d("meshStandardMaterial", {
+            color: i,
+            side: J.DoubleSide,
+            transparent: true,
+            opacity: 0.15,
+            depthWrite: false,
+            clippingPlanes: [
+              l
+            ]
+          })
+        }),
+        s.linePoints.length >= 2 && d(ge, {
+          points: s.linePoints,
+          color: "#00ff00",
+          lineWidth: 3,
+          depthTest: false,
+          depthWrite: false,
+          transparent: true
+        }),
+        o && W(He, {
+          children: [
+            d(ge, {
+              points: o,
+              color: "#ff8800",
+              lineWidth: 2,
+              depthTest: false,
+              depthWrite: false,
+              transparent: true
+            }),
+            d(Ke, {
+              position: [
+                o[0].x,
+                n,
+                o[0].z - t * 0.02
+              ],
+              center: true,
+              style: {
+                pointerEvents: "none"
+              },
+              children: d("div", {
+                style: {
+                  whiteSpace: "nowrap",
+                  padding: "2px 6px",
+                  backgroundColor: "rgba(0,0,0,0.75)",
+                  borderRadius: 3
+                },
+                children: W("span", {
+                  style: {
+                    fontSize: 12,
+                    color: "#ff8800",
+                    fontFamily: "monospace"
+                  },
+                  children: [
+                    "ML ",
+                    x(y),
+                    " ",
+                    g
+                  ]
+                })
+              })
+            })
+          ]
+        }),
+        f && W(He, {
+          children: [
+            d(ge, {
+              points: f,
+              color: "#ff00ff",
+              lineWidth: 2,
+              depthTest: false,
+              depthWrite: false,
+              transparent: true
+            }),
+            d(Ke, {
+              position: [
+                Math.max(f[0].x, f[1].x) + t * 0.02,
+                n,
+                f[0].z > f[1].z ? f[0].z : f[1].z
+              ],
+              center: true,
+              style: {
+                pointerEvents: "none"
+              },
+              children: d("div", {
+                style: {
+                  whiteSpace: "nowrap",
+                  padding: "2px 6px",
+                  backgroundColor: "rgba(0,0,0,0.75)",
+                  borderRadius: 3
+                },
+                children: W("span", {
+                  style: {
+                    fontSize: 12,
+                    color: "#ff00ff",
+                    fontFamily: "monospace"
+                  },
+                  children: [
+                    "AP ",
+                    x(p),
+                    " ",
+                    g
+                  ]
+                })
+              })
+            })
+          ]
+        })
+      ]
+    });
+  }, Xn = {
+    pcaAxes: true,
+    obb: true,
+    obbAxis: true,
+    shellComponents: true,
+    circumferenceScan: false,
+    landmarkAxis: true,
+    iterativePCA: false,
+    fullRegionPCA: true
+  }, Zn = [
+    "#ff4444",
+    "#44cc44",
+    "#4488ff"
+  ];
+  function Ot(e) {
+    const r = e.getAttribute("position"), n = r.count, t = new h();
+    for (let g = 0; g < n; g++) t.x += r.getX(g), t.y += r.getY(g), t.z += r.getZ(g);
+    t.divideScalar(n);
+    let i = 0, a = 0, c = 0, u = 0, s = 0, l = 0;
+    for (let g = 0; g < n; g++) {
+      const w = r.getX(g) - t.x, v = r.getY(g) - t.y, m = r.getZ(g) - t.z;
+      i += w * w, a += w * v, c += w * m, u += v * v, s += v * m, l += m * m;
+    }
+    i /= n, a /= n, c /= n, u /= n, s /= n, l /= n;
+    const o = [], f = [], y = [
+      [
+        i,
+        a,
+        c
+      ],
+      [
+        a,
+        u,
+        s
+      ],
+      [
+        c,
+        s,
+        l
+      ]
+    ];
+    for (let g = 0; g < 3; g++) {
+      let w = new h(1 + g * 0.1, 1 - g * 0.1, 0.5 + g * 0.3).normalize(), v = 0;
+      for (let m = 0; m < 100; m++) {
+        const b = y[0][0] * w.x + y[0][1] * w.y + y[0][2] * w.z, S = y[1][0] * w.x + y[1][1] * w.y + y[1][2] * w.z, C = y[2][0] * w.x + y[2][1] * w.y + y[2][2] * w.z, M = new h(b, S, C);
+        if (v = M.length(), v < 1e-12) break;
+        if (M.divideScalar(v), w.distanceTo(M) < 1e-10) {
+          w = M;
+          break;
+        }
+        w = M;
+      }
+      o.push(w.clone()), f.push(v);
+      for (let m = 0; m < 3; m++) for (let b = 0; b < 3; b++) {
+        const S = [
+          w.x,
+          w.y,
+          w.z
+        ][m], C = [
+          w.x,
+          w.y,
+          w.z
+        ][b];
+        y[m][b] -= v * S * C;
+      }
+    }
+    const p = new h();
+    for (let g = 0; g < n; g++) p.x += r.getX(g), p.y += r.getY(g), p.z += r.getZ(g);
+    p.divideScalar(n);
+    const x = [
+      0,
+      0,
+      0
+    ];
+    for (let g = 0; g < 3; g++) {
+      let w = 1 / 0, v = -1 / 0;
+      const m = o[g];
+      for (let b = 0; b < n; b++) {
+        const S = r.getX(b) - p.x, C = r.getY(b) - p.y, M = r.getZ(b) - p.z, P = S * m.x + C * m.y + M * m.z;
+        P < w && (w = P), P > v && (v = P);
+      }
+      x[g] = (v - w) / 2;
+    }
+    return {
+      axes: o,
+      eigenvalues: f,
+      center: p,
+      halfExtents: x
+    };
+  }
+  function Kn({ pca: e }) {
+    return d("group", {
+      children: e.axes.map((r, n) => {
+        const t = e.center.clone().addScaledVector(r, e.halfExtents[n]), i = e.center.clone().addScaledVector(r, -e.halfExtents[n]);
+        return d(ge, {
+          points: [
+            i,
+            t
+          ],
+          color: Zn[n],
+          lineWidth: 2
+        }, n);
+      })
+    });
+  }
+  function Un({ pca: e }) {
+    const r = de(() => {
+      const { center: n, axes: t, halfExtents: i } = e, a = [];
+      for (let u = -1; u <= 1; u += 2) for (let s = -1; s <= 1; s += 2) for (let l = -1; l <= 1; l += 2) a.push(n.clone().addScaledVector(t[0], u * i[0]).addScaledVector(t[1], s * i[1]).addScaledVector(t[2], l * i[2]));
+      return [
+        [
+          0,
+          1
+        ],
+        [
+          2,
+          3
+        ],
+        [
+          4,
+          5
+        ],
+        [
+          6,
+          7
+        ],
+        [
+          0,
+          2
+        ],
+        [
+          1,
+          3
+        ],
+        [
+          4,
+          6
+        ],
+        [
+          5,
+          7
+        ],
+        [
+          0,
+          4
+        ],
+        [
+          1,
+          5
+        ],
+        [
+          2,
+          6
+        ],
+        [
+          3,
+          7
+        ]
+      ].map(([u, s]) => [
+        a[u],
+        a[s]
+      ]);
+    }, [
+      e
+    ]);
+    return d("group", {
+      children: r.map((n, t) => d(ge, {
+        points: n,
+        color: "#ffaa00",
+        lineWidth: 1,
+        transparent: true,
+        opacity: 0.5
+      }, t))
+    });
+  }
+  function Qn({ redPoint: e, greenPoint: r }) {
+    const n = de(() => new h().subVectors(r, e).normalize(), [
+      e,
+      r
+    ]), t = de(() => {
+      const a = n.dot(new h(0, 1, 0));
+      return Math.acos(Math.min(1, Math.abs(a))) * 180 / Math.PI;
+    }, [
+      n
+    ]), i = t < 1 ? "#44ff44" : t < 5 ? "#ffcc00" : "#ff4444";
+    return W("group", {
+      children: [
+        d(ge, {
+          points: [
+            e,
+            r
+          ],
+          color: i,
+          lineWidth: 3
+        }),
+        W("mesh", {
+          position: e,
+          children: [
+            d("sphereGeometry", {
+              args: [
+                1.5,
+                8,
+                8
+              ]
+            }),
+            d("meshBasicMaterial", {
+              color: "#ff4444"
+            })
+          ]
+        }),
+        W("mesh", {
+          position: r,
+          children: [
+            d("sphereGeometry", {
+              args: [
+                1.5,
+                8,
+                8
+              ]
+            }),
+            d("meshBasicMaterial", {
+              color: "#44ff44"
+            })
+          ]
+        })
+      ]
+    });
+  }
+  function qn({ geometry: e, redY: r, greenY: n, modelSize: t }) {
+    const a = t * 0.15, c = de(() => {
+      const u = [];
+      let s = n - 10;
+      const l = new h(0, 1, 0);
+      for (; s > r; ) {
+        const o = Math.min(s, n), f = Math.max(s, n), y = rt(e, o, f);
+        if (y) {
+          const p = y.dot(l), x = Math.acos(Math.min(1, Math.abs(p))) * 180 / Math.PI;
+          u.push({
+            axis: y,
+            regionMin: o,
+            regionMax: f,
+            angleDeg: x
+          });
+        }
+        s -= 10;
+      }
+      return u;
+    }, [
+      e,
+      r,
+      n
+    ]);
+    return d("group", {
+      children: c.map((u, s) => {
+        const l = (u.regionMin + u.regionMax) / 2, o = new h(0, l, 0), f = o.clone().addScaledVector(u.axis, a), y = o.clone().addScaledVector(u.axis, -a), p = s / Math.max(1, c.length - 1), x = u.angleDeg < 0.5 ? `hsl(${120 - p * 120}, 80%, 60%)` : `hsl(${40 - u.angleDeg * 2}, 90%, 55%)`;
+        return W("group", {
+          children: [
+            d(ge, {
+              points: [
+                y,
+                f
+              ],
+              color: x,
+              lineWidth: 1.5,
+              transparent: true,
+              opacity: 0.7
+            }),
+            d(ge, {
+              points: [
+                new h(-a * 0.3, u.regionMin, 0),
+                new h(a * 0.3, u.regionMin, 0)
+              ],
+              color: x,
+              lineWidth: 0.5,
+              transparent: true,
+              opacity: 0.3
+            })
+          ]
+        }, s);
+      })
+    });
+  }
+  function Jn({ geometry: e, redY: r, greenY: n, modelSize: t }) {
+    const i = de(() => {
+      const f = rt(e, r, n);
+      if (!f) return null;
+      const y = f.dot(new h(0, 1, 0)), p = Math.acos(Math.min(1, Math.abs(y))) * 180 / Math.PI;
+      return {
+        axis: f,
+        angleDeg: p
+      };
+    }, [
+      e,
+      r,
+      n
+    ]);
+    if (!i) return null;
+    const a = (r + n) / 2, c = new h(0, a, 0), u = t * 0.4, s = c.clone().addScaledVector(i.axis, u), l = c.clone().addScaledVector(i.axis, -u), o = i.angleDeg < 0.5 ? "#00ffff" : i.angleDeg < 2 ? "#ffcc00" : "#ff6600";
+    return d("group", {
+      children: d(ge, {
+        points: [
+          l,
+          s
+        ],
+        color: o,
+        lineWidth: 3,
+        dashed: true,
+        dashSize: 3,
+        gapSize: 2
+      })
+    });
+  }
+  function eo({ pca: e, modelSize: r }) {
+    const n = e.axes[0], t = r * 0.6, i = e.center.clone().addScaledVector(n, t), a = e.center.clone().addScaledVector(n, -t);
+    return d(ge, {
+      points: [
+        a,
+        i
+      ],
+      color: "#ff8800",
+      lineWidth: 2,
+      dashed: true,
+      dashSize: 3,
+      gapSize: 2
+    });
+  }
+  function to({ geometry: e, redY: r, greenY: n, modelSize: t }) {
+    const i = de(() => {
+      const l = ot(e), o = new h(0, 1, 0), f = 5;
+      e.computeBoundingBox();
+      const y = e.boundingBox.max.y, p = [];
+      for (let C = r + f; C < y; C += f) {
+        const M = pt(l, e, new h(0, C, 0), o);
+        M > 0 && p.push({
+          y: C,
+          circ: M
+        });
+      }
+      if (p.length < 5) return null;
+      const x = n - r, g = r + x * 0.3, w = r + x * 0.7, v = p.filter((C) => C.y >= g && C.y <= w);
+      if (v.length < 3) return null;
+      const m = v.map((C) => C.circ).sort((C, M) => C - M), b = m[Math.floor(m.length / 2)], S = Math.max(...p.map((C) => C.circ));
+      return {
+        circumferences: p,
+        baseline: b,
+        maxCirc: S
+      };
+    }, [
+      e,
+      r,
+      n
+    ]);
+    if (!i) return null;
+    const { circumferences: a, baseline: c, maxCirc: u } = i, s = t * 0.3 / u;
+    return W("group", {
+      children: [
+        a.map(({ y: l, circ: o }, f) => {
+          const y = o / c, p = y > 1.6 ? "#ff4444" : y > 1.3 ? "#ffcc00" : "#22cc66", x = o * s;
+          return d(ge, {
+            points: [
+              new h(-x, l, 0),
+              new h(x, l, 0)
+            ],
+            color: p,
+            lineWidth: 1.5,
+            transparent: true,
+            opacity: 0.6
+          }, f);
+        }),
+        (() => {
+          const l = c * 1.6 * s, o = a[0].y, f = a[a.length - 1].y;
+          return W(He, {
+            children: [
+              d(ge, {
+                points: [
+                  new h(-l, o, 0),
+                  new h(-l, f, 0)
+                ],
+                color: "#ff4444",
+                lineWidth: 1,
+                dashed: true,
+                dashSize: 3,
+                gapSize: 2,
+                transparent: true,
+                opacity: 0.4
+              }),
+              d(ge, {
+                points: [
+                  new h(l, o, 0),
+                  new h(l, f, 0)
+                ],
+                color: "#ff4444",
+                lineWidth: 1,
+                dashed: true,
+                dashSize: 3,
+                gapSize: 2,
+                transparent: true,
+                opacity: 0.4
+              })
+            ]
+          });
+        })()
+      ]
+    });
+  }
+  function no({ componentDebug: e }) {
+    return d("group", {
+      children: e.geometries.map((r, n) => {
+        const t = e.colors[n] ?? "#888888", i = n === e.innerIdx;
+        r.computeBoundingBox();
+        const a = new h();
+        return r.boundingBox.getCenter(a), W("group", {
+          children: [
+            d("mesh", {
+              geometry: r,
+              renderOrder: i ? 2 : 1,
+              children: d("meshStandardMaterial", {
+                color: t,
+                transparent: true,
+                opacity: i ? 0.5 : 0.2,
+                side: J.DoubleSide,
+                depthWrite: false,
+                polygonOffset: true,
+                polygonOffsetFactor: 1,
+                polygonOffsetUnits: 1
+              })
+            }),
+            d("mesh", {
+              geometry: r,
+              renderOrder: i ? 2 : 1,
+              children: d("meshBasicMaterial", {
+                color: t,
+                wireframe: true,
+                transparent: true,
+                opacity: i ? 0.4 : 0.15
+              })
+            }),
+            d("group", {
+              position: a,
+              children: d(Ke, {
+                center: true,
+                style: {
+                  pointerEvents: "none"
+                },
+                children: d("div", {
+                  style: {
+                    padding: "2px 8px",
+                    backgroundColor: "rgba(0,0,0,0.8)",
+                    borderRadius: 4,
+                    border: `1px solid ${t}`,
+                    whiteSpace: "nowrap"
+                  },
+                  children: d("span", {
+                    style: {
+                      fontSize: 11,
+                      color: t,
+                      fontFamily: "monospace",
+                      fontWeight: i ? 700 : 400
+                    },
+                    children: e.labels[n]
+                  })
+                })
+              })
+            })
+          ]
+        }, n);
+      })
+    });
+  }
+  function oo({ mesh: e, layers: r, landmarkPoints: n, componentDebug: t }) {
+    const i = e.geometry, a = de(() => i.getAttribute("position") ? Ot(i) : null, [
+      i
+    ]), c = de(() => !n || n.length < 2 ? null : {
+      red: new h(n[0].position.x, n[0].position.y, n[0].position.z),
+      green: new h(n[1].position.x, n[1].position.y, n[1].position.z)
+    }, [
+      n
+    ]);
+    return W("group", {
+      children: [
+        r.pcaAxes && a && d(Kn, {
+          pca: a
+        }),
+        r.obb && a && d(Un, {
+          pca: a
+        }),
+        r.obbAxis && a && d(eo, {
+          pca: a,
+          modelSize: a.halfExtents[0] ? Math.max(...a.halfExtents) * 2 : 100
+        }),
+        r.shellComponents && t && d(no, {
+          componentDebug: t
+        }),
+        r.circumferenceScan && c && d(to, {
+          geometry: i,
+          redY: c.red.y,
+          greenY: c.green.y,
+          modelSize: (a == null ? void 0 : a.halfExtents[0]) ? Math.max(...a.halfExtents) * 2 : 100
+        }),
+        r.landmarkAxis && c && d(Qn, {
+          redPoint: c.red,
+          greenPoint: c.green
+        }),
+        r.iterativePCA && c && d(qn, {
+          geometry: i,
+          redY: c.red.y,
+          greenY: c.green.y,
+          modelSize: (a == null ? void 0 : a.halfExtents[0]) ? Math.max(...a.halfExtents) * 2 : 100
+        }),
+        r.fullRegionPCA && c && d(Jn, {
+          geometry: i,
+          redY: c.red.y,
+          greenY: c.green.y,
+          modelSize: (a == null ? void 0 : a.halfExtents[0]) ? Math.max(...a.halfExtents) * 2 : 100
+        })
+      ]
+    });
+  }
+  function so({ mesh: e }) {
+    const r = e.geometry, n = de(() => {
+      if (!r.getAttribute("position")) return null;
+      const a = Ot(r), c = a.axes[0], u = a.halfExtents[0] * 1.3;
+      return {
+        axis: c,
+        center: a.center,
+        halfLen: u
+      };
+    }, [
+      r
+    ]);
+    if (!n) return null;
+    const t = n.center.clone().addScaledVector(n.axis, n.halfLen), i = n.center.clone().addScaledVector(n.axis, -n.halfLen);
+    return d(ge, {
+      points: [
+        i,
+        t
+      ],
+      color: "#666",
+      lineWidth: 1,
+      dashed: true,
+      dashSize: 4,
+      gapSize: 3,
+      transparent: true,
+      opacity: 0.4,
+      depthTest: false,
+      renderOrder: 999
+    });
+  }
+  const $t = [
+    {
+      key: "pcaAxes",
+      label: "PCA Axes (full mesh)",
+      color: "#ff4444",
+      group: "Geometry"
+    },
+    {
+      key: "obb",
+      label: "OBB Wireframe",
+      color: "#ffaa00",
+      group: "Geometry"
+    },
+    {
+      key: "obbAxis",
+      label: "OBB Primary Axis",
+      color: "#ff8800",
+      group: "Geometry"
+    },
+    {
+      key: "shellComponents",
+      label: "Shell Components",
+      color: "#4488ff",
+      group: "Shell Detection"
+    },
+    {
+      key: "circumferenceScan",
+      label: "Circumference Scan (step 4.5)",
+      color: "#22cc66",
+      group: "Isolation"
+    },
+    {
+      key: "landmarkAxis",
+      label: "Landmark Axis (rough align)",
+      color: "#44ff44",
+      group: "Alignment"
+    },
+    {
+      key: "iterativePCA",
+      label: "Iterative PCA (step 5)",
+      color: "#cc66ff",
+      group: "Alignment"
+    },
+    {
+      key: "fullRegionPCA",
+      label: "Full Region PCA (step 7)",
+      color: "#00ffff",
+      group: "Alignment"
+    }
+  ], ro = [
+    ...new Set($t.map((e) => e.group))
+  ];
+  function io({ layers: e, onToggleLayer: r }) {
+    return W("div", {
+      style: {
+        position: "absolute",
+        top: 16,
+        left: 16,
+        zIndex: 20,
+        backgroundColor: "rgba(7, 6, 17, 0.9)",
+        border: "1px solid rgba(255,255,255,0.1)",
+        borderRadius: 6,
+        padding: "10px 12px",
+        fontFamily: "system-ui, sans-serif",
+        fontSize: 12,
+        color: "#ccc",
+        minWidth: 180,
+        backdropFilter: "blur(8px)"
+      },
+      children: [
+        d("div", {
+          style: {
+            fontSize: 10,
+            fontWeight: 600,
+            textTransform: "uppercase",
+            letterSpacing: "0.5px",
+            color: "#888",
+            marginBottom: 8
+          },
+          children: "Debug Layers"
+        }),
+        ro.map((n) => W("div", {
+          children: [
+            d("div", {
+              style: {
+                fontSize: 9,
+                fontWeight: 600,
+                textTransform: "uppercase",
+                letterSpacing: "0.5px",
+                color: "#555",
+                marginTop: 6,
+                marginBottom: 4
+              },
+              children: n
+            }),
+            $t.filter((t) => t.group === n).map(({ key: t, label: i, color: a }) => W("label", {
+              style: {
+                display: "flex",
+                alignItems: "center",
+                gap: 8,
+                padding: "3px 0",
+                cursor: "pointer",
+                userSelect: "none"
+              },
+              children: [
+                d("input", {
+                  type: "checkbox",
+                  checked: e[t],
+                  onChange: () => r(t),
+                  style: {
+                    accentColor: a,
+                    width: 14,
+                    height: 14,
+                    cursor: "pointer"
+                  }
+                }),
+                d("span", {
+                  style: {
+                    width: 8,
+                    height: 8,
+                    borderRadius: "50%",
+                    backgroundColor: a,
+                    opacity: e[t] ? 1 : 0.3,
+                    flexShrink: 0
+                  }
+                }),
+                d("span", {
+                  style: {
+                    opacity: e[t] ? 1 : 0.5
+                  },
+                  children: i
+                })
+              ]
+            }, t))
+          ]
+        }, n))
+      ]
+    });
+  }
+  const lo = ({ config: e, spacingType: r, scanUrl: n, formMeasurements: t, onComplete: i, isDebugUser: a = false, onAnalyticsEvent: c, wasmModule: u }) => {
+    const [s, l] = Q(null), [o, f] = Q(0), [y, p] = Q(false), [x, g] = Q(false), [w, v] = Q(""), [m, b] = Q("3D"), [S, C] = Q(r === "AK" ? 2 : 1), [M, P] = Q(false), [L, H] = Q(null), [O, $] = Q(null), [R, Y] = Q(r ?? null), [j, ne] = Q("mm"), [oe, le] = Q(false), [ee, D] = Q(""), [z, F] = Q(false), [V, B] = Q(false), [T, E] = Q(false), [N, X] = Q(false), [q, ie] = Q(false), [se, A] = Q([]), [I, k] = Q(null), [G, U] = Q(null), [re, Le] = Q(null), [me, ae] = Q(null), [xe, Re] = Q(false), [pe, we] = Q(Xn), [he, Ge] = Q(false), [fe, je] = Q(null), [Pe, ye] = Q("obj"), [Te, Me] = Q(false), [Ae, De] = Q({}), [ze, Ee] = Q(t), [ke, Ue] = Q(true), [mt] = Q("#c8c8c8"), [Nt] = Q(1), [Xe, Ht] = Q(false), lt = Ie(null), { landmarkPoints: ce, clearLandmarkPoints: Yt, addLandmarkPoint: xt, removeLandmarkPoint: yt, updateLandmarkPositions: bt, setAligned: wt, isAligned: be, setCut: St, isCut: Gt } = gt(), at = S * We;
+    Se(() => {
+      t && Ee(t);
+    }, [
+      t
+    ]), Se(() => {
+      t || (Ee(void 0), De({}));
+    }, [
+      S
+    ]);
+    const ct = Ie(false);
+    Se(() => {
+      if (!be || se.length === 0 || ct.current || !c) return;
+      ct.current = true;
+      const _ = ce.length >= 3 ? Math.abs(ce[2].position.y - ce[1].position.y) : null;
+      c("dimensions_calculated", {
+        spacing_type: R,
+        source_unit: "mm",
+        file_format: Pe,
+        measurement_source: "scan_derived",
+        is_double_wall: T,
+        is_unit_converted: false,
+        form_measurements: (ze == null ? void 0 : ze.filter((K) => K != null)) ?? null,
+        scan_measurements: se.map((K) => +(K.modifiedValue ?? K.originalValue).toFixed(1)),
+        measurement_variance: ze ? se.map((K, ue) => {
+          const Z = ze[ue];
+          return Z == null ? null : +((K.modifiedValue ?? K.originalValue) - Z).toFixed(1);
+        }) : null,
+        frontal_height: _ !== null ? +_.toFixed(1) : null
+      });
+    }, [
+      be,
+      se
+    ]), Se(() => {
+      u !== void 0 && (lt.current = u), Ht(true);
+    }, [
+      u
+    ]);
+    const Qe = Fe((_, K) => {
+      _.computeBoundingBox();
+      const ue = _.boundingBox, Z = new h();
+      ue.getCenter(Z), _.translate(-Z.x, -Z.y, -Z.z), _.computeBoundingBox();
+      const Be = _.boundingBox, te = new h();
+      Be.getSize(te), f(Math.max(te.x, te.y, te.z));
+      const ve = new J.Mesh(_, new J.MeshStandardMaterial({
+        color: 8947848,
+        side: J.DoubleSide
+      }));
+      l(ve), F(K), B(true);
+    }, []), qe = Fe(async (_, K) => {
+      ae(null);
+      const ue = K.toLowerCase(), Z = ue.endsWith(".stl");
+      if (!ue.endsWith(".obj") && !Z) {
+        ae("Unsupported file format. Please use OBJ or STL.");
+        return;
+      }
+      ye(Z ? "stl" : "obj"), g(true), v("Processing file...");
+      try {
+        let te;
+        if (Z) if (v("Converting STL..."), _ instanceof ArrayBuffer) {
+          const Ce = new Blob([
+            _
+          ]), Ve = new File([
+            Ce
+          ], K);
+          te = await ft(Ve);
+        } else {
+          const Ce = new Blob([
+            _
+          ]), Ve = new File([
+            Ce
+          ], K);
+          te = await ft(Ve);
+        }
+        else te = typeof _ == "string" ? _ : new TextDecoder().decode(_);
+        const ve = lt.current ? await bn(te, lt.current, v) : null;
+        if (ve) e.showAmputationModal && !r ? (H(ve), P(true)) : (Qe(ve.geometry, ve.wasScaled), ve.innerShellExtracted && (X(true), E(true)), ve.componentDebug && $(ve.componentDebug));
+        else {
+          v("Using fallback loader...");
+          const Ce = wn(te);
+          Ce ? e.showAmputationModal && !r ? (H({
+            geometry: Ce,
+            wasScaled: false,
+            innerShellExtracted: false
+          }), P(true)) : Qe(Ce, false) : ae("Failed to parse the mesh.");
+        }
+      } catch (te) {
+        ae(te instanceof Error ? te.message : "Failed to process the mesh file.");
+      } finally {
+        g(false), v("");
+      }
+    }, [
+      Xe,
+      e.showAmputationModal,
+      r,
+      Qe
+    ]);
+    Se(() => {
+      if (!n || !Xe) return;
+      (async () => {
+        g(true), v("Downloading scan...");
+        try {
+          const K = await fetch(n);
+          if (!K.ok) throw new Error(`Failed to download scan: ${K.status}`);
+          const Z = new URL(n).pathname.split("/").pop() || "scan.obj";
+          if (Z.toLowerCase().endsWith(".stl")) {
+            const te = await K.arrayBuffer();
+            await qe(te, Z);
+          } else {
+            const te = await K.text();
+            await qe(te, Z);
+          }
+        } catch (K) {
+          ae(K instanceof Error ? K.message : "Failed to load scan from URL."), g(false), v("");
+        }
+      })();
+    }, [
+      n,
+      Xe
+    ]);
+    const Xt = Fe((_) => {
+      _.preventDefault(), p(true);
+    }, []), Zt = Fe((_) => {
+      _.preventDefault(), p(false);
+    }, []), Kt = Fe(async (_) => {
+      if (_.preventDefault(), p(false), !Xe) {
+        ae("WASM module is still loading. Please wait.");
+        return;
+      }
+      const K = _.dataTransfer.files[0];
+      if (!K) return;
+      const ue = K.name.toLowerCase();
+      if (!ue.endsWith(".obj") && !ue.endsWith(".stl")) {
+        ae("Please drop an OBJ or STL file.");
+        return;
+      }
+      if (ue.endsWith(".stl")) {
+        ye("stl"), g(true), v("Converting STL...");
+        try {
+          const Z = await ft(K);
+          await qe(Z, K.name);
+        } catch (Z) {
+          ae(Z instanceof Error ? Z.message : "Failed to process STL file."), g(false), v("");
+        }
+      } else {
+        const Z = await K.text();
+        await qe(Z, K.name);
+      }
+    }, [
+      Xe,
+      qe
+    ]), Ut = Fe((_) => {
+      Y(_), C(_ === "AK" ? 2 : 1), P(false), L && (Qe(L.geometry, L.wasScaled), L.innerShellExtracted && (X(true), E(true)), L.componentDebug && $(L.componentDebug), H(null)), c == null ? void 0 : c("file_loaded", {
+        spacing_type: _,
+        file_format: Pe,
+        is_double_wall: (L == null ? void 0 : L.innerShellExtracted) ?? false
+      });
+    }, [
+      L,
+      Qe,
+      c,
+      Pe
+    ]), Qt = Fe(() => {
+      !s || ce.length < 2 || (le(true), D("Please wait..."), setTimeout(() => {
+        In(s, ce, at, {
+          onStatus: D,
+          addLandmarkPoint: xt,
+          removeLandmarkPoint: yt,
+          updateLandmarkPositions: bt,
+          setAligned: wt,
+          setCut: St,
+          setModelSize: f,
+          setOriginalEndY: Le,
+          setAdjustedStartY: k,
+          setAdjustedEndY: U,
+          setError: ae,
+          setDoubleShell: (_) => {
+            E(_), ie(true);
+          },
+          setClippedReferenceGeometry: je,
+          skipDoubleShellDetection: N
+        }), ct.current = false, le(false);
+      }, 50));
+    }, [
+      s,
+      ce,
+      bt,
+      wt,
+      xt,
+      yt,
+      St,
+      at,
+      N
+    ]), qt = Fe(() => {
+      if (!i || !s || se.length === 0 || !R) return;
+      let _ = 0, K = 0;
+      const ue = ce.length >= 3 ? Math.abs(ce[2].position.y - ce[1].position.y) : 0;
+      if (ce.length >= 2) {
+        const Z = s.geometry, te = ce[1].position.y;
+        try {
+          const ve = ot(Z), Ce = Ze(ve, Z, te);
+          if (Ce.linePoints.length >= 2) {
+            let Ve = Ce.linePoints[0], Je = Ce.linePoints[0], et = Ce.linePoints[0], tt = Ce.linePoints[0];
+            for (const _e of Ce.linePoints) _e.x < Ve.x && (Ve = _e), _e.x > Je.x && (Je = _e), _e.z < et.z && (et = _e), _e.z > tt.z && (tt = _e);
+            _ = new h(Ve.x, te, Ve.z).distanceTo(new h(Je.x, te, Je.z)), K = new h(et.x, te, et.z).distanceTo(new h(tt.x, te, tt.z));
+          }
+        } catch {
+        }
+      }
+      i({
+        spacingType: R,
+        sourceUnit: "mm",
+        fileFormat: Pe,
+        measurementSource: ze ? "form_provided" : "scan_derived",
+        isDoubleWall: T,
+        isUnitConverted: false,
+        formMeasurements: ze,
+        scanMeasurements: se,
+        frontalHeight: ue,
+        transverseML: _,
+        transverseAP: K,
+        scanUrl: n
+      });
+    }, [
+      i,
+      s,
+      se,
+      R,
+      ce,
+      Pe,
+      T,
+      ze,
+      n
+    ]), Jt = be ? 4 : s ? ce.length === 0 ? 2 : 3 : 1, en = [
+      {
+        label: "Load File",
+        number: 1
+      },
+      {
+        label: "Set Origin",
+        number: 2
+      },
+      {
+        label: R === "AK" ? "Set IT/Perineum" : "Set MPT",
+        number: 3
+      },
+      {
+        label: "Results",
+        number: 4
+      }
+    ];
+    return W(dn.Provider, {
+      value: e,
+      children: [
+        W("div", {
+          style: {
+            flex: 1,
+            display: "flex",
+            flexDirection: "column",
+            backgroundColor: "#F9F9FA",
+            minWidth: 0,
+            position: "relative",
+            height: "100%"
+          },
+          children: [
+            e.showToolbar && d("div", {
+              style: {
+                height: 83,
+                backgroundColor: "#9e9e9e",
+                flexShrink: 0,
+                position: "relative",
+                overflow: "hidden"
+              },
+              children: d("div", {
+                style: {
+                  position: "absolute",
+                  inset: 0,
+                  opacity: 0.1,
+                  backgroundImage: "repeating-linear-gradient(45deg, transparent, transparent 10px, #fff 10px, #fff 12px)",
+                  pointerEvents: "none"
+                }
+              })
+            }),
+            d(Yn, {
+              steps: en,
+              currentStep: Jt
+            }),
+            W("div", {
+              style: {
+                flex: 1,
+                display: "flex",
+                flexDirection: "column",
+                minHeight: 0
+              },
+              children: [
+                W("div", {
+                  style: {
+                    flex: 1,
+                    position: "relative",
+                    minHeight: 0,
+                    overflow: "hidden"
+                  },
+                  onDragOver: e.showDragDrop ? Xt : void 0,
+                  onDragLeave: e.showDragDrop ? Zt : void 0,
+                  onDrop: e.showDragDrop ? Kt : void 0,
+                  children: [
+                    e.showDragDrop && !s && !x && d("div", {
+                      style: {
+                        position: "absolute",
+                        inset: 16,
+                        border: "3px dashed #ccc",
+                        borderRadius: 4,
+                        display: "flex",
+                        alignItems: "center",
+                        justifyContent: "center",
+                        pointerEvents: "none"
+                      },
+                      children: Xe ? d("div", {
+                        style: {
+                          fontSize: 18,
+                          color: "#aaa",
+                          fontWeight: 400,
+                          fontFamily: "system-ui, sans-serif"
+                        },
+                        children: "Drag & Drop Files Here"
+                      }) : W("div", {
+                        style: {
+                          textAlign: "center"
+                        },
+                        children: [
+                          d("div", {
+                            style: {
+                              width: 32,
+                              height: 32,
+                              border: "3px solid rgba(0,0,0,0.1)",
+                              borderTopColor: "#4a90d9",
+                              borderRadius: "50%",
+                              animation: "spin 1s linear infinite",
+                              margin: "0 auto 12px"
+                            }
+                          }),
+                          d("div", {
+                            style: {
+                              fontSize: 16,
+                              color: "#999",
+                              fontFamily: "system-ui, sans-serif"
+                            },
+                            children: "Loading WASM module..."
+                          }),
+                          d("style", {
+                            children: "@keyframes spin { to { transform: rotate(360deg); } }"
+                          })
+                        ]
+                      })
+                    }),
+                    !e.showDragDrop && !s && !x && !me && d("div", {
+                      style: {
+                        position: "absolute",
+                        inset: 0,
+                        display: "flex",
+                        alignItems: "center",
+                        justifyContent: "center"
+                      },
+                      children: W("div", {
+                        style: {
+                          textAlign: "center"
+                        },
+                        children: [
+                          d("div", {
+                            style: {
+                              width: 32,
+                              height: 32,
+                              border: "3px solid rgba(0,0,0,0.1)",
+                              borderTopColor: "#4a90d9",
+                              borderRadius: "50%",
+                              animation: "spin 1s linear infinite",
+                              margin: "0 auto 12px"
+                            }
+                          }),
+                          d("div", {
+                            style: {
+                              fontSize: 16,
+                              color: "#999",
+                              fontFamily: "system-ui, sans-serif"
+                            },
+                            children: "Loading scan..."
+                          }),
+                          d("style", {
+                            children: "@keyframes spin { to { transform: rotate(360deg); } }"
+                          })
+                        ]
+                      })
+                    }),
+                    s && !be && ce.length === 0 && W("div", {
+                      style: {
+                        position: "absolute",
+                        top: 16,
+                        left: "50%",
+                        transform: "translateX(-50%)",
+                        display: "flex",
+                        alignItems: "center",
+                        gap: 8,
+                        padding: "8px 16px",
+                        backgroundColor: "rgba(0, 0, 0, 0.6)",
+                        borderRadius: 8,
+                        color: "#fff",
+                        fontSize: 13,
+                        pointerEvents: "none",
+                        zIndex: 5,
+                        fontFamily: "system-ui, sans-serif"
+                      },
+                      children: [
+                        d("div", {
+                          style: {
+                            width: 10,
+                            height: 10,
+                            borderRadius: "50%",
+                            backgroundColor: "#ff4444",
+                            flexShrink: 0
+                          }
+                        }),
+                        "Click mesh to set Origin"
+                      ]
+                    }),
+                    s && !be && ce.length === 1 && W("div", {
+                      style: {
+                        position: "absolute",
+                        top: 16,
+                        left: "50%",
+                        transform: "translateX(-50%)",
+                        display: "flex",
+                        alignItems: "center",
+                        gap: 8,
+                        padding: "8px 16px",
+                        backgroundColor: "rgba(0, 0, 0, 0.6)",
+                        borderRadius: 8,
+                        color: "#fff",
+                        fontSize: 13,
+                        pointerEvents: "none",
+                        zIndex: 5,
+                        fontFamily: "system-ui, sans-serif"
+                      },
+                      children: [
+                        d("div", {
+                          style: {
+                            width: 10,
+                            height: 10,
+                            borderRadius: "50%",
+                            backgroundColor: "#44ff44",
+                            flexShrink: 0
+                          }
+                        }),
+                        "Click mesh to set ",
+                        R === "AK" ? "IT/Perineum" : "MPT"
+                      ]
+                    }),
+                    x && d(At, {
+                      message: w || "Processing mesh..."
+                    }),
+                    oe && d(At, {
+                      message: ee
+                    }),
+                    me && d(Ln, {
+                      message: me,
+                      onDismiss: () => ae(null)
+                    }),
+                    e.showAmputationModal && M && d("div", {
+                      style: {
+                        position: "absolute",
+                        inset: 0,
+                        backgroundColor: "rgba(0,0,0,0.32)",
+                        display: "flex",
+                        alignItems: "center",
+                        justifyContent: "center",
+                        zIndex: 20
+                      },
+                      children: W("div", {
+                        style: {
+                          backgroundColor: "#fff",
+                          borderRadius: 4,
+                          width: 560,
+                          boxShadow: "0 11px 15px -7px rgba(0,0,0,0.2), 0 24px 38px 3px rgba(0,0,0,0.14), 0 9px 46px 8px rgba(0,0,0,0.12)",
+                          fontFamily: "system-ui, sans-serif"
+                        },
+                        children: [
+                          W("div", {
+                            style: {
+                              padding: "24px 24px 20px"
+                            },
+                            children: [
+                              d("div", {
+                                style: {
+                                  fontSize: 20,
+                                  fontWeight: 500,
+                                  color: "rgba(0,0,0,0.87)",
+                                  marginBottom: 8
+                                },
+                                children: "Select Spacing Type"
+                              }),
+                              d("div", {
+                                style: {
+                                  fontSize: 14,
+                                  color: "rgba(0,0,0,0.54)",
+                                  marginBottom: 24
+                                },
+                                children: "Choose the measurement spacing for this scan"
+                              }),
+                              d("div", {
+                                style: {
+                                  display: "flex",
+                                  gap: 16
+                                },
+                                children: [
+                                  "AK",
+                                  "BK"
+                                ].map((_) => W("label", {
+                                  onClick: () => Y(_),
+                                  style: {
+                                    flex: 1,
+                                    display: "flex",
+                                    flexDirection: "column",
+                                    padding: "20px 24px",
+                                    border: "2px solid",
+                                    borderRadius: 4,
+                                    cursor: "pointer",
+                                    borderColor: R === _ ? "rgb(12, 67, 173)" : "#e0e0e0",
+                                    backgroundColor: R === _ ? "rgba(12, 67, 173, 0.04)" : "#fff",
+                                    transition: "border-color 0.15s, background-color 0.15s"
+                                  },
+                                  children: [
+                                    d("input", {
+                                      type: "radio",
+                                      name: "ampType",
+                                      checked: R === _,
+                                      onChange: () => Y(_),
+                                      style: {
+                                        accentColor: "rgb(12, 67, 173)",
+                                        marginBottom: 12,
+                                        width: 18,
+                                        height: 18
+                                      }
+                                    }),
+                                    d("span", {
+                                      style: {
+                                        fontSize: 18,
+                                        fontWeight: 600,
+                                        color: "rgba(0,0,0,0.87)",
+                                        marginBottom: 4
+                                      },
+                                      children: _
+                                    }),
+                                    W("span", {
+                                      style: {
+                                        fontSize: 13,
+                                        color: "rgba(0,0,0,0.54)"
+                                      },
+                                      children: [
+                                        _ === "AK" ? "2" : "1",
+                                        "-inch measurement spacing"
+                                      ]
+                                    })
+                                  ]
+                                }, _))
+                              })
+                            ]
+                          }),
+                          W("div", {
+                            style: {
+                              display: "flex",
+                              justifyContent: "flex-end",
+                              gap: 8,
+                              padding: "12px 24px 20px",
+                              borderTop: "1px solid #e0e0e0"
+                            },
+                            children: [
+                              d("button", {
+                                onClick: () => {
+                                  P(false), H(null);
+                                },
+                                style: {
+                                  padding: "6px 16px",
+                                  borderRadius: 4,
+                                  fontSize: 14,
+                                  fontWeight: 500,
+                                  backgroundColor: "#fff",
+                                  border: "1px solid #bdbdbd",
+                                  color: "rgba(0,0,0,0.87)",
+                                  cursor: "pointer",
+                                  fontFamily: "system-ui, sans-serif",
+                                  lineHeight: "36px",
+                                  letterSpacing: "0.4px"
+                                },
+                                children: "Cancel"
+                              }),
+                              d("button", {
+                                onClick: () => R && Ut(R),
+                                disabled: !R,
+                                style: {
+                                  padding: "6px 16px",
+                                  borderRadius: 4,
+                                  fontSize: 14,
+                                  fontWeight: 500,
+                                  backgroundColor: R ? "rgb(12, 67, 173)" : "#e0e0e0",
+                                  border: "none",
+                                  color: R ? "#fff" : "#9e9e9e",
+                                  cursor: R ? "pointer" : "not-allowed",
+                                  fontFamily: "system-ui, sans-serif",
+                                  lineHeight: "36px",
+                                  letterSpacing: "0.4px"
+                                },
+                                children: "Next \xBB"
+                              })
+                            ]
+                          })
+                        ]
+                      })
+                    }),
+                    e.showDragDrop && y && d("div", {
+                      style: {
+                        position: "absolute",
+                        inset: 0,
+                        backgroundColor: "rgba(12, 67, 173, 0.1)",
+                        border: "2px dashed rgb(12, 67, 173)",
+                        pointerEvents: "none",
+                        zIndex: 10
+                      }
+                    }),
+                    W(sn, {
+                      camera: {
+                        position: [
+                          0,
+                          0,
+                          5
+                        ]
+                      },
+                      style: {
+                        display: s ? "block" : "none",
+                        backgroundColor: xe ? "#070611" : void 0
+                      },
+                      gl: {
+                        localClippingEnabled: true
+                      },
+                      scene: {
+                        background: xe ? new J.Color("#070611") : null
+                      },
+                      children: [
+                        d("ambientLight", {
+                          intensity: 0.4
+                        }),
+                        d("directionalLight", {
+                          position: [
+                            10,
+                            10,
+                            5
+                          ],
+                          intensity: 1.2
+                        }),
+                        d("directionalLight", {
+                          position: [
+                            -5,
+                            5,
+                            -5
+                          ],
+                          intensity: 0.4
+                        }),
+                        d("directionalLight", {
+                          position: [
+                            0,
+                            -10,
+                            0
+                          ],
+                          intensity: 0.2
+                        }),
+                        s && m === "3D" && d(Pn, {
+                          mesh: s,
+                          maxPoints: 2,
+                          meshColor: mt,
+                          meshOpacity: xe ? 0.3 : Nt
+                        }),
+                        he && fe && m === "3D" && d("mesh", {
+                          geometry: fe,
+                          renderOrder: 1,
+                          children: d("meshStandardMaterial", {
+                            color: "#c8c8c8",
+                            transparent: true,
+                            opacity: 0.35,
+                            side: J.DoubleSide,
+                            depthWrite: false,
+                            polygonOffset: true,
+                            polygonOffsetFactor: 1,
+                            polygonOffsetUnits: 1
+                          })
+                        }),
+                        s && m === "3D" && d(Tn, {
+                          modelSize: o,
+                          labels: [
+                            "Origin",
+                            R === "AK" ? "IT/Perineum" : "MPT",
+                            "Cut Plane"
+                          ]
+                        }),
+                        d($n, {
+                          modelSize: o,
+                          isAligned: be,
+                          isCut: Gt,
+                          mesh: s,
+                          viewMode: m,
+                          sliceY: be && ce.length >= 2 ? G ?? re ?? ce[1].position.y : void 0,
+                          landmarkCount: ce.length
+                        }),
+                        !be && d(Dt, {
+                          enableDamping: false
+                        }),
+                        be && se.length > 0 && s && m === "3D" && d(jn, {
+                          mesh: s,
+                          isDragging: false
+                        }),
+                        s && be && ce.length >= 3 && (() => {
+                          const K = s.geometry.getIndex();
+                          if (!K || K.count < 30) return null;
+                          const ue = ce[2], Z = ce[1], Be = I ?? ue.position.y, te = G ?? re ?? Z.position.y;
+                          return m === "2D" ? d(Gn, {
+                            mesh: s,
+                            upperY: te,
+                            originY: Z.position.y,
+                            modelSize: o,
+                            meshColor: mt,
+                            displayUnit: j
+                          }) : W(He, {
+                            children: [
+                              d(_n, {
+                                mesh: s,
+                                startY: Be,
+                                endY: te,
+                                spacing: at,
+                                modelSize: o,
+                                onMeasurementsChange: A,
+                                reverseOrder: true,
+                                displayUnit: j,
+                                useInnerSurface: T && !N,
+                                formMeasurements: ke ? ze : void 0,
+                                originY: Z.position.y
+                              }),
+                              (!T || N) && d(On, {
+                                mesh: s,
+                                greenY: Z.position.y,
+                                modelSize: o,
+                                displayUnit: j
+                              })
+                            ]
+                          });
+                        })(),
+                        s && be && m === "3D" && d(so, {
+                          mesh: s
+                        }),
+                        s && e.showDebug && xe && m === "3D" && d(oo, {
+                          mesh: s,
+                          modelSize: o,
+                          layers: pe,
+                          landmarkPoints: ce,
+                          componentDebug: O
+                        })
+                      ]
+                    }),
+                    s && (e.showStartOver || e.showInsertMeasurement) && W("div", {
+                      style: {
+                        position: "absolute",
+                        top: 16,
+                        left: 16,
+                        zIndex: 10,
+                        display: "flex",
+                        gap: 8
+                      },
+                      children: [
+                        e.showStartOver && d("button", {
+                          onClick: () => window.location.reload(),
+                          style: {
+                            padding: "6px 16px",
+                            borderRadius: 4,
+                            fontSize: 13,
+                            fontWeight: 500,
+                            backgroundColor: "#fff",
+                            border: "1px solid #bdbdbd",
+                            color: "#333",
+                            cursor: "pointer",
+                            fontFamily: "system-ui, sans-serif",
+                            letterSpacing: "0.4px",
+                            boxShadow: "0 2px 8px rgba(0,0,0,0.1)"
+                          },
+                          children: "Start Over"
+                        }),
+                        e.showInsertMeasurement && d("button", {
+                          onClick: () => Me(true),
+                          style: {
+                            padding: "6px 16px",
+                            borderRadius: 4,
+                            fontSize: 13,
+                            fontWeight: 500,
+                            backgroundColor: "rgb(12, 67, 173)",
+                            border: "none",
+                            color: "#fff",
+                            cursor: "pointer",
+                            fontFamily: "system-ui, sans-serif",
+                            letterSpacing: "0.4px",
+                            boxShadow: "0 2px 8px rgba(0,0,0,0.1)"
+                          },
+                          children: "Insert Measurement"
+                        })
+                      ]
+                    }),
+                    e.showDebug && xe && s && m === "3D" && d(io, {
+                      layers: pe,
+                      onToggleLayer: (_) => we((K) => ({
+                        ...K,
+                        [_]: !K[_]
+                      }))
+                    }),
+                    be && se.length > 0 && W("div", {
+                      style: {
+                        position: "absolute",
+                        top: 16,
+                        right: 16,
+                        display: "flex",
+                        gap: 8,
+                        zIndex: 10
+                      },
+                      children: [
+                        W("div", {
+                          style: {
+                            display: "flex",
+                            borderRadius: 6,
+                            overflow: "hidden",
+                            border: "1px solid #ccc",
+                            boxShadow: "0 2px 8px rgba(0,0,0,0.1)"
+                          },
+                          children: [
+                            d("button", {
+                              onClick: () => b("3D"),
+                              style: {
+                                padding: "6px 14px",
+                                fontSize: 13,
+                                fontWeight: m === "3D" ? 600 : 400,
+                                backgroundColor: m === "3D" ? "rgb(12, 67, 173)" : "#fff",
+                                color: m === "3D" ? "#fff" : "#666",
+                                border: "none",
+                                cursor: "pointer",
+                                fontFamily: "system-ui, sans-serif"
+                              },
+                              children: "Frontal"
+                            }),
+                            d("button", {
+                              onClick: () => b("2D"),
+                              style: {
+                                padding: "6px 14px",
+                                fontSize: 13,
+                                fontWeight: m === "2D" ? 600 : 400,
+                                backgroundColor: m === "2D" ? "rgb(12, 67, 173)" : "#fff",
+                                color: m === "2D" ? "#fff" : "#666",
+                                border: "none",
+                                borderLeft: "1px solid #ccc",
+                                cursor: "pointer",
+                                fontFamily: "system-ui, sans-serif"
+                              },
+                              children: "Transverse"
+                            })
+                          ]
+                        }),
+                        W("div", {
+                          style: {
+                            display: "flex",
+                            borderRadius: 6,
+                            overflow: "hidden",
+                            border: "1px solid #ccc",
+                            boxShadow: "0 2px 8px rgba(0,0,0,0.1)"
+                          },
+                          children: [
+                            d("button", {
+                              onClick: () => ne("mm"),
+                              style: {
+                                padding: "6px 14px",
+                                fontSize: 13,
+                                fontWeight: j === "mm" ? 600 : 400,
+                                backgroundColor: j === "mm" ? "rgb(12, 67, 173)" : "#fff",
+                                color: j === "mm" ? "#fff" : "#666",
+                                border: "none",
+                                cursor: "pointer",
+                                fontFamily: "system-ui, sans-serif"
+                              },
+                              children: "mm"
+                            }),
+                            d("button", {
+                              onClick: () => ne("inch"),
+                              style: {
+                                padding: "6px 14px",
+                                fontSize: 13,
+                                fontWeight: j === "inch" ? 600 : 400,
+                                backgroundColor: j === "inch" ? "rgb(12, 67, 173)" : "#fff",
+                                color: j === "inch" ? "#fff" : "#666",
+                                border: "none",
+                                borderLeft: "1px solid #ccc",
+                                cursor: "pointer",
+                                fontFamily: "system-ui, sans-serif"
+                              },
+                              children: "in"
+                            })
+                          ]
+                        }),
+                        e.showSpacingToggle && m === "3D" && W("div", {
+                          style: {
+                            display: "flex",
+                            borderRadius: 6,
+                            overflow: "hidden",
+                            border: "1px solid #ccc",
+                            boxShadow: "0 2px 8px rgba(0,0,0,0.1)"
+                          },
+                          children: [
+                            d("button", {
+                              onClick: () => C(1),
+                              style: {
+                                padding: "6px 14px",
+                                fontSize: 13,
+                                fontWeight: S === 1 ? 600 : 400,
+                                backgroundColor: S === 1 ? "rgb(12, 67, 173)" : "#fff",
+                                color: S === 1 ? "#fff" : "#666",
+                                border: "none",
+                                cursor: "pointer",
+                                fontFamily: "system-ui, sans-serif"
+                              },
+                              children: '1"'
+                            }),
+                            d("button", {
+                              onClick: () => C(2),
+                              style: {
+                                padding: "6px 14px",
+                                fontSize: 13,
+                                fontWeight: S === 2 ? 600 : 400,
+                                backgroundColor: S === 2 ? "rgb(12, 67, 173)" : "#fff",
+                                color: S === 2 ? "#fff" : "#666",
+                                border: "none",
+                                borderLeft: "1px solid #ccc",
+                                cursor: "pointer",
+                                fontFamily: "system-ui, sans-serif"
+                              },
+                              children: '2"'
+                            })
+                          ]
+                        }),
+                        m === "3D" && fe && d("div", {
+                          style: {
+                            display: "flex",
+                            borderRadius: 6,
+                            overflow: "hidden",
+                            border: "1px solid #ccc",
+                            boxShadow: "0 2px 8px rgba(0,0,0,0.1)"
+                          },
+                          children: d("button", {
+                            onClick: () => Ge((_) => !_),
+                            style: {
+                              padding: "6px 14px",
+                              fontSize: 13,
+                              fontWeight: he ? 600 : 400,
+                              backgroundColor: he ? "rgb(12, 67, 173)" : "#fff",
+                              color: he ? "#fff" : "#666",
+                              border: "none",
+                              cursor: "pointer",
+                              fontFamily: "system-ui, sans-serif"
+                            },
+                            children: "Show Full Scan"
+                          })
+                        }),
+                        m === "3D" && ze && d("div", {
+                          style: {
+                            display: "flex",
+                            borderRadius: 6,
+                            overflow: "hidden",
+                            border: "1px solid #ccc",
+                            boxShadow: "0 2px 8px rgba(0,0,0,0.1)"
+                          },
+                          children: d("button", {
+                            onClick: () => Ue((_) => !_),
+                            style: {
+                              padding: "6px 14px",
+                              fontSize: 13,
+                              fontWeight: ke ? 600 : 400,
+                              backgroundColor: ke ? "rgb(12, 67, 173)" : "#fff",
+                              color: ke ? "#fff" : "#666",
+                              border: "none",
+                              cursor: "pointer",
+                              fontFamily: "system-ui, sans-serif"
+                            },
+                            children: "Form Overlay"
+                          })
+                        }),
+                        e.showDebug && a && d("div", {
+                          style: {
+                            display: "flex",
+                            borderRadius: 6,
+                            overflow: "hidden",
+                            border: "1px solid #ccc",
+                            boxShadow: "0 2px 8px rgba(0,0,0,0.1)"
+                          },
+                          children: d("button", {
+                            onClick: () => Re((_) => !_),
+                            style: {
+                              padding: "6px 14px",
+                              fontSize: 13,
+                              fontWeight: xe ? 600 : 400,
+                              backgroundColor: xe ? "#e65100" : "#fff",
+                              color: xe ? "#fff" : "#666",
+                              border: "none",
+                              cursor: "pointer",
+                              fontFamily: "system-ui, sans-serif"
+                            },
+                            children: "Debug"
+                          })
+                        })
+                      ]
+                    }),
+                    s && V && d(Nn, {
+                      wasAutoScaled: z,
+                      onDismiss: () => B(false)
+                    }),
+                    s && q && be && d(Hn, {
+                      isDoubleShell: T,
+                      onDismiss: () => ie(false)
+                    })
+                  ]
+                }),
+                W("div", {
+                  style: {
+                    padding: "12px 24px",
+                    backgroundColor: "#fff",
+                    borderTop: "1px solid #e0e0e0",
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "flex-end",
+                    gap: 8,
+                    flexShrink: 0
+                  },
+                  children: [
+                    s && !be && ce.length >= 2 && d("button", {
+                      onClick: Qt,
+                      style: {
+                        padding: "6px 16px",
+                        borderRadius: 4,
+                        fontSize: 14,
+                        fontWeight: 500,
+                        backgroundColor: "rgb(12, 67, 173)",
+                        border: "none",
+                        color: "#fff",
+                        cursor: "pointer",
+                        fontFamily: "system-ui, sans-serif",
+                        letterSpacing: "0.4px",
+                        lineHeight: "36px"
+                      },
+                      children: "Next \xBB"
+                    }),
+                    s && !be && ce.length >= 1 && d("button", {
+                      onClick: Yt,
+                      style: {
+                        padding: "6px 16px",
+                        borderRadius: 4,
+                        fontSize: 14,
+                        fontWeight: 500,
+                        backgroundColor: "#fff",
+                        border: "1px solid #bdbdbd",
+                        color: "#333",
+                        cursor: "pointer",
+                        fontFamily: "system-ui, sans-serif",
+                        letterSpacing: "0.4px",
+                        lineHeight: "36px"
+                      },
+                      children: "Reset Points"
+                    }),
+                    be && d("button", {
+                      onClick: qt,
+                      disabled: se.length === 0,
+                      style: {
+                        padding: "6px 16px",
+                        borderRadius: 4,
+                        fontSize: 14,
+                        fontWeight: 500,
+                        backgroundColor: se.length > 0 ? "rgb(12, 67, 173)" : "#e0e0e0",
+                        border: "none",
+                        color: se.length > 0 ? "#fff" : "#9e9e9e",
+                        cursor: se.length > 0 ? "pointer" : "not-allowed",
+                        fontFamily: "system-ui, sans-serif",
+                        letterSpacing: "0.4px",
+                        lineHeight: "36px"
+                      },
+                      children: "Continue to Next Step"
+                    })
+                  ]
+                })
+              ]
+            })
+          ]
+        }),
+        e.showInsertMeasurement && Te && (() => {
+          const _ = R === "AK" ? "IT/Perineum" : "MPT", K = S, ue = [];
+          for (let Z = 2; Z >= 1; Z -= K) ue.push(`${Z}\u2033 above ${_}`);
+          ue.push(`At ${_}`);
+          for (let Z = K; Z <= 9; Z += K) ue.push(`${Z}\u2033 below ${_}`);
+          return d("div", {
+            style: {
+              position: "fixed",
+              inset: 0,
+              backgroundColor: "rgba(0,0,0,0.32)",
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "flex-start",
+              paddingLeft: 40,
+              zIndex: 9999
+            },
+            children: W("div", {
+              style: {
+                backgroundColor: "#fff",
+                borderRadius: 4,
+                width: 620,
+                maxHeight: "80vh",
+                display: "flex",
+                flexDirection: "column",
+                boxShadow: "0 11px 15px -7px rgba(0,0,0,0.2), 0 24px 38px 3px rgba(0,0,0,0.14), 0 9px 46px 8px rgba(0,0,0,0.12)",
+                fontFamily: "system-ui, sans-serif"
+              },
+              children: [
+                W("div", {
+                  style: {
+                    padding: "24px 24px 0"
+                  },
+                  children: [
+                    W("div", {
+                      style: {
+                        fontSize: 20,
+                        fontWeight: 500,
+                        color: "rgba(0,0,0,0.87)",
+                        marginBottom: 4
+                      },
+                      children: [
+                        R,
+                        " Circumferences"
+                      ]
+                    }),
+                    W("div", {
+                      style: {
+                        fontSize: 13,
+                        color: "rgba(0,0,0,0.54)",
+                        marginBottom: 20
+                      },
+                      children: [
+                        "Enter form measurements (mm). ",
+                        K,
+                        "\u2033",
+                        " spacing."
+                      ]
+                    })
+                  ]
+                }),
+                d("div", {
+                  style: {
+                    padding: "0 24px",
+                    overflowY: "auto",
+                    flex: 1
+                  },
+                  children: d("div", {
+                    style: {
+                      display: "grid",
+                      gridTemplateColumns: "1fr 1fr",
+                      gap: "16px 24px"
+                    },
+                    children: ue.map((Z, Be) => W("div", {
+                      children: [
+                        W("label", {
+                          style: {
+                            display: "block",
+                            fontSize: 13,
+                            fontWeight: 500,
+                            color: "rgb(12, 67, 173)",
+                            marginBottom: 6
+                          },
+                          children: [
+                            Z,
+                            " (mm):"
+                          ]
+                        }),
+                        d("input", {
+                          type: "number",
+                          step: "0.1",
+                          value: Ae[Z] ?? "",
+                          onChange: (te) => De((ve) => ({
+                            ...ve,
+                            [Z]: te.target.value
+                          })),
+                          style: {
+                            width: "100%",
+                            padding: "10px 12px",
+                            fontSize: 15,
+                            border: "2px solid rgb(12, 67, 173)",
+                            borderRadius: 4,
+                            outline: "none",
+                            boxSizing: "border-box",
+                            fontFamily: "system-ui, sans-serif"
+                          }
+                        })
+                      ]
+                    }, Be))
+                  })
+                }),
+                W("div", {
+                  style: {
+                    display: "flex",
+                    justifyContent: "flex-end",
+                    gap: 8,
+                    padding: "16px 24px",
+                    borderTop: "1px solid #e0e0e0",
+                    marginTop: 16
+                  },
+                  children: [
+                    d("button", {
+                      onClick: () => {
+                        Me(false), De({});
+                      },
+                      style: {
+                        padding: "6px 16px",
+                        borderRadius: 4,
+                        fontSize: 14,
+                        fontWeight: 500,
+                        backgroundColor: "#fff",
+                        border: "1px solid #bdbdbd",
+                        color: "rgba(0,0,0,0.87)",
+                        cursor: "pointer",
+                        fontFamily: "system-ui, sans-serif",
+                        lineHeight: "36px",
+                        letterSpacing: "0.4px"
+                      },
+                      children: "Cancel"
+                    }),
+                    d("button", {
+                      onClick: () => {
+                        const Z = ue.map((te) => parseFloat(Ae[te] || "")), Be = Z.filter((te) => !isNaN(te));
+                        Ee(Be.length > 0 ? Z.map((te) => isNaN(te) ? void 0 : te) : void 0), Me(false);
+                      },
+                      style: {
+                        padding: "6px 16px",
+                        borderRadius: 4,
+                        fontSize: 14,
+                        fontWeight: 500,
+                        backgroundColor: "rgb(12, 67, 173)",
+                        border: "none",
+                        color: "#fff",
+                        cursor: "pointer",
+                        fontFamily: "system-ui, sans-serif",
+                        lineHeight: "36px",
+                        letterSpacing: "0.4px"
+                      },
+                      children: "Save"
+                    })
+                  ]
+                })
+              ]
+            })
+          });
+        })()
+      ]
+    });
+  };
+  jt = function(e) {
+    const r = e === "AK" ? 2 : 1, n = [];
+    for (let t = 2; t >= 1; t -= r) n.push(`${t}_above`);
+    n.push("at_ref");
+    for (let t = r; t <= 9; t += r) n.push(`${t}_below`);
+    return n;
+  };
+  dt = function(e, r) {
+    const n = jt(r), t = {};
+    for (let i = 0; i < Math.min(e.length, n.length); i++) {
+      const a = e[i];
+      a != null && !isNaN(a) && (t[n[i]] = a);
+    }
+    return t;
+  };
+  ao = function(e, r) {
+    if (!e) return;
+    const t = jt(r).map((i) => {
+      const a = e[i];
+      return a ?? void 0;
+    });
+    if (!t.every((i) => i == null)) return t;
+  };
+  bo = ({ request: e, onComplete: r, wasmModule: n }) => {
+    const [t, i] = Q(null), [a, c] = Q(n !== void 0);
+    Se(() => {
+      if (n !== void 0) {
+        c(true);
+        return;
+      }
+      let o = false;
+      return import("./galileo_core_geo-DFVJmkI7.js").then(async (f) => {
+        await f.default(), o || (i(f), c(true));
+      }).catch(() => {
+        o || c(true);
+      }), () => {
+        o = true;
+      };
+    }, [
+      n
+    ]);
+    const u = n !== void 0 ? n : t, s = de(() => ao(e.form_measurements, e.spacing_type), [
+      e.form_measurements,
+      e.spacing_type
+    ]), l = (o) => {
+      const f = o.scanMeasurements.map((w) => +(w.modifiedValue ?? w.originalValue).toFixed(1)), y = dt(f, e.spacing_type);
+      let p, x;
+      if (o.formMeasurements) {
+        p = dt(o.formMeasurements, e.spacing_type);
+        const w = o.scanMeasurements.map((v, m) => {
+          var _a;
+          const b = (_a = o.formMeasurements) == null ? void 0 : _a[m];
+          return b == null || isNaN(b) ? null : +((v.modifiedValue ?? v.originalValue) - b).toFixed(1);
+        });
+        x = dt(w, e.spacing_type);
+      }
+      const g = {
+        spacing_type: e.spacing_type,
+        source_unit: "mm",
+        file_format: o.fileFormat,
+        measurement_source: o.formMeasurements ? "form_provided" : "scan_derived",
+        is_double_wall: o.isDoubleWall,
+        is_unit_converted: false,
+        form_measurements: p,
+        scan_measurements: y,
+        measurement_variance: x,
+        scan_url: e.scan_url,
+        frontal_height: +o.frontalHeight.toFixed(1),
+        transverse_ml: +o.transverseML.toFixed(1),
+        transverse_ap: +o.transverseAP.toFixed(1)
+      };
+      console.log("[GirthManagerWidget] WidgetResponse:", JSON.stringify(g, null, 2)), r == null ? void 0 : r(g);
+    };
+    return a ? d("div", {
+      style: {
+        width: "100%",
+        height: "100%",
+        display: "flex"
+      },
+      children: d(lo, {
+        config: fn,
+        spacingType: e.spacing_type,
+        scanUrl: e.scan_url,
+        formMeasurements: s,
+        onComplete: l,
+        wasmModule: u
+      })
+    }) : d("div", {
+      style: {
+        width: "100%",
+        height: "100%",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center"
+      },
+      children: d("span", {
+        children: "Initializing..."
+      })
+    });
+  };
+})();
+export {
+  bo as G,
+  __tla,
+  dt as a,
+  ao as c,
+  jt as g
+};