forgecad 0.10.2 → 0.10.4

package/dist/assets/{constructionHistoryWorker-CZ42Dksy.js → constructionHistoryWorker-cTHWRJEi.js}

@@ -722,12 +722,12 @@ class Vector2 {
    * @param {number} angle - The angle to rotate, in radians.
    * @return {Vector2} A reference to this vector.
    */
-  rotateAround(center, angle) {
+  rotateAround(center2, angle) {
     const c2 = Math.cos(angle), s = Math.sin(angle);
-    const x2 = this.x - center.x;
-    const y2 = this.y - center.y;
-    this.x = x2 * c2 - y2 * s + center.x;
-    this.y = x2 * s + y2 * c2 + center.y;
+    const x2 = this.x - center2.x;
+    const y2 = this.y - center2.y;
+    this.x = x2 * c2 - y2 * s + center2.x;
+    this.y = x2 * s + y2 * c2 + center2.y;
     return this;
   }
   /**
@@ -3256,10 +3256,10 @@ class Box3 {
    * @param {Vector3} size - The x, y and z dimensions of the box.
    * @return {Box3} A reference to this bounding box.
    */
-  setFromCenterAndSize(center, size) {
+  setFromCenterAndSize(center2, size) {
     const halfSize = _vector$b.copy(size).multiplyScalar(0.5);
-    this.min.copy(center).sub(halfSize);
-    this.max.copy(center).add(halfSize);
+    this.min.copy(center2).sub(halfSize);
+    this.max.copy(center2).add(halfSize);
     return this;
   }
   /**
@@ -3709,9 +3709,9 @@ class Sphere {
    * @param {Vector3} [center=(0,0,0)] - The center of the sphere
    * @param {number} [radius=-1] - The radius of the sphere.
    */
-  constructor(center = new Vector3(), radius = -1) {
+  constructor(center2 = new Vector3(), radius = -1) {
     this.isSphere = true;
-    this.center = center;
+    this.center = center2;
     this.radius = radius;
   }
   /**
@@ -3721,8 +3721,8 @@ class Sphere {
    * @param {number} radius - The radius.
    * @return {Sphere} A reference to this sphere.
    */
-  set(center, radius) {
-    this.center.copy(center);
+  set(center2, radius) {
+    this.center.copy(center2);
     this.radius = radius;
     return this;
   }
@@ -3737,15 +3737,15 @@ class Sphere {
    * @return {Sphere} A reference to this sphere.
    */
   setFromPoints(points, optionalCenter) {
-    const center = this.center;
+    const center2 = this.center;
     if (optionalCenter !== void 0) {
-      center.copy(optionalCenter);
+      center2.copy(optionalCenter);
     } else {
-      _box$3.setFromPoints(points).getCenter(center);
+      _box$3.setFromPoints(points).getCenter(center2);
     }
     let maxRadiusSq = 0;
     for (let i = 0, il = points.length; i < il; i++) {
-      maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(points[i]));
+      maxRadiusSq = Math.max(maxRadiusSq, center2.distanceToSquared(points[i]));
     }
     this.radius = Math.sqrt(maxRadiusSq);
     return this;
@@ -7133,7 +7133,7 @@ class BufferGeometry extends EventDispatcher {
       return;
     }
     if (position) {
-      const center = this.boundingSphere.center;
+      const center2 = this.boundingSphere.center;
       _box$2.setFromBufferAttribute(position);
       if (morphAttributesPosition) {
         for (let i = 0, il = morphAttributesPosition.length; i < il; i++) {
@@ -7150,11 +7150,11 @@ class BufferGeometry extends EventDispatcher {
           }
         }
       }
-      _box$2.getCenter(center);
+      _box$2.getCenter(center2);
       let maxRadiusSq = 0;
       for (let i = 0, il = position.count; i < il; i++) {
         _vector$8.fromBufferAttribute(position, i);
-        maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector$8));
+        maxRadiusSq = Math.max(maxRadiusSq, center2.distanceToSquared(_vector$8));
       }
       if (morphAttributesPosition) {
         for (let i = 0, il = morphAttributesPosition.length; i < il; i++) {
@@ -7166,7 +7166,7 @@ class BufferGeometry extends EventDispatcher {
               _offset.fromBufferAttribute(position, j);
               _vector$8.add(_offset);
             }
-            maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector$8));
+            maxRadiusSq = Math.max(maxRadiusSq, center2.distanceToSquared(_vector$8));
           }
         }
       }
@@ -8043,6 +8043,12 @@ if (typeof window !== "undefined") {
   }
 }
 const SHAPE_BACKEND_MARKER = Symbol.for("forgecad.shapeBackend");
+const POSITION_OFFSET = 0;
+const NORMAL_OFFSET = 3;
+const UV_OFFSET = 6;
+const NUM_PROP_POSITION_ONLY = 3;
+const NUM_PROP_WITH_NORMAL = 6;
+const NUM_PROP_WITH_UV = 8;
 function isShapeBackend(value) {
   return Boolean(value && typeof value === "object" && value[SHAPE_BACKEND_MARKER] === true);
 }
@@ -9187,11 +9193,11 @@ function applyFilletSelectionToManifold(base, selection, radius, segments, wasm)
   const height = edgeLength(selection);
   if (!(height > 1e-6)) return base;
   const pad = Math.max(MIN_EDGE_PAD, radius);
-  const span = height + pad * 2;
+  const span2 = height + pad * 2;
   const frame = edgeFrameMatrix(selection, -pad);
   const cs = buildFilletCrossSection(selection, radius, segments, wasm) ?? legacyFilletCrossSection(selection, radius, segments, wasm);
-  const corner = cs.wedge.extrude(span, 0, 0, void 0, false).transform(frame);
-  const cyl = cs.cylinder.extrude(span, 0, 0, void 0, false).transform(frame);
+  const corner = cs.wedge.extrude(span2, 0, 0, void 0, false).transform(frame);
+  const cyl = cs.cylinder.extrude(span2, 0, 0, void 0, false).transform(frame);
   const crescent = wasm.Manifold.difference([corner, cyl]);
   return wasm.Manifold.difference([base, crescent]);
 }
@@ -9199,11 +9205,11 @@ function applyConcaveFilletSelectionToManifold(base, selection, radius, segments
   const height = edgeLength(selection);
   if (!(height > 1e-6)) return base;
   const pad = Math.max(MIN_EDGE_PAD, radius);
-  const span = height + pad * 2;
+  const span2 = height + pad * 2;
   const frame = edgeFrameMatrix(selection, -pad);
   const cs = buildFilletCrossSection(selection, radius, segments, wasm) ?? legacyFilletCrossSection(selection, radius, segments, wasm);
-  const corner = cs.wedge.extrude(span, 0, 0, void 0, false).transform(frame);
-  const cyl = cs.cylinder.extrude(span, 0, 0, void 0, false).transform(frame);
+  const corner = cs.wedge.extrude(span2, 0, 0, void 0, false).transform(frame);
+  const cyl = cs.cylinder.extrude(span2, 0, 0, void 0, false).transform(frame);
   const crescent = wasm.Manifold.difference([corner, cyl]);
   return wasm.Manifold.union([base, crescent]);
 }
@@ -9211,20 +9217,20 @@ function applyChamferSelectionToManifold(base, selection, size, wasm) {
   const height = edgeLength(selection);
   if (!(height > 1e-6)) return base;
   const pad = Math.max(MIN_EDGE_PAD, size);
-  const span = height + pad * 2;
+  const span2 = height + pad * 2;
   const frame = edgeFrameMatrix(selection, -pad);
   const triangle = buildChamferCrossSection(selection, size, wasm) ?? legacyChamferCrossSection(selection, size, wasm);
-  const chamfer = triangle.extrude(span, 0, 0, void 0, false).transform(frame);
+  const chamfer = triangle.extrude(span2, 0, 0, void 0, false).transform(frame);
   return wasm.Manifold.difference([base, chamfer]);
 }
 function applyConcaveChamferSelectionToManifold(base, selection, size, wasm) {
   const height = edgeLength(selection);
   if (!(height > 1e-6)) return base;
   const pad = Math.max(MIN_EDGE_PAD, size);
-  const span = height + pad * 2;
+  const span2 = height + pad * 2;
   const frame = edgeFrameMatrix(selection, -pad);
   const triangle = buildChamferCrossSection(selection, size, wasm) ?? legacyChamferCrossSection(selection, size, wasm);
-  const chamfer = triangle.extrude(span, 0, 0, void 0, false).transform(frame);
+  const chamfer = triangle.extrude(span2, 0, 0, void 0, false).transform(frame);
   return wasm.Manifold.union([base, chamfer]);
 }
 function cloneEdgeFinishQuadrant(quadrant) {
@@ -9378,6 +9384,7 @@ function cloneTopologyRewritePropagation(propagation) {
 }
 function faceQueryRefsEqual(a2, b) {
   if (a2 == null || b == null) return a2 == null && b == null;
+  if (a2 === b) return true;
   if (a2.kind !== b.kind) return false;
   switch (a2.kind) {
     case "canonical-face":
@@ -9394,6 +9401,7 @@ function faceQueryRefsEqual(a2, b) {
 }
 function edgeQueryRefsEqual(a2, b) {
   if (a2 == null || b == null) return a2 == null && b == null;
+  if (a2 === b) return true;
   if (a2.kind !== b.kind) return false;
   switch (a2.kind) {
     case "tracked-edge":
@@ -9760,8 +9768,8 @@ function deriveSheetMetalModel(model) {
     const trimStart = flanges.has(adjacent.start) ? model.cornerRelief.size : 0;
     const trimEnd = flanges.has(adjacent.end) ? model.cornerRelief.size : 0;
     const fullLength = edge === "top" || edge === "bottom" ? model.panel.width : model.panel.height;
-    const span = fullLength - trimStart - trimEnd;
-    if (!(span > EPS$5)) {
+    const span2 = fullLength - trimStart - trimEnd;
+    if (!(span2 > EPS$5)) {
       throw new Error(
         `${edgeDisplayName(edge)} loses all usable span after applying the defended rectangular corner relief size ${model.cornerRelief.size}.`
       );
@@ -9773,7 +9781,7 @@ function deriveSheetMetalModel(model) {
       bendAllowance,
       trimStart,
       trimEnd,
-      span,
+      span: span2,
       centerAlongEdge: (trimStart - trimEnd) / 2
     });
   }
@@ -9952,10 +9960,10 @@ function lowerSheetMetalBasePlan(model, output) {
   const pieces = lowerSheetMetalBasePiecePlans(model, output).map((piece) => piece.plan);
   return pieces.length === 1 ? pieces[0] : buildBooleanShapeCompilePlan("union", pieces);
 }
-function descriptor(name, center, normal2, planar, uAxis, vAxis, semantic = "face", memberNames = [name], coplanar = planar) {
+function descriptor(name, center2, normal2, planar, uAxis, vAxis, semantic = "face", memberNames = [name], coplanar = planar) {
   return {
     name,
-    center: cloneVec3$3(center),
+    center: cloneVec3$3(center2),
     normal: cloneVec3$3(normal2),
     planar,
     uAxis: cloneFaceAxis(uAxis),
@@ -11408,14 +11416,14 @@ function findSpan(n, degree, u2, knots) {
   }
   return mid;
 }
-function basisFuns(span, u2, degree, knots) {
+function basisFuns(span2, u2, degree, knots) {
   const N = new Array(degree + 1);
   const left = new Array(degree + 1);
   const right = new Array(degree + 1);
   N[0] = 1;
   for (let j = 1; j <= degree; j++) {
-    left[j] = u2 - knots[span + 1 - j];
-    right[j] = knots[span + j] - u2;
+    left[j] = u2 - knots[span2 + 1 - j];
+    right[j] = knots[span2 + j] - u2;
     let saved = 0;
     for (let r = 0; r < j; r++) {
       const denom = right[r + 1] + left[j - r];
@@ -11427,13 +11435,72 @@ function basisFuns(span, u2, degree, knots) {
   }
   return N;
 }
+function basisFunsDeriv(span2, u2, degree, knots, nDeriv) {
+  const ndu = Array.from({ length: degree + 1 }, () => new Array(degree + 1).fill(0));
+  const a2 = Array.from({ length: 2 }, () => new Array(degree + 1).fill(0));
+  const left = new Array(degree + 1);
+  const right = new Array(degree + 1);
+  ndu[0][0] = 1;
+  for (let j = 1; j <= degree; j++) {
+    left[j] = u2 - knots[span2 + 1 - j];
+    right[j] = knots[span2 + j] - u2;
+    let saved = 0;
+    for (let r2 = 0; r2 < j; r2++) {
+      ndu[j][r2] = right[r2 + 1] + left[j - r2];
+      const temp = ndu[j][r2] === 0 ? 0 : ndu[r2][j - 1] / ndu[j][r2];
+      ndu[r2][j] = saved + right[r2 + 1] * temp;
+      saved = left[j - r2] * temp;
+    }
+    ndu[j][j] = saved;
+  }
+  const ders = Array.from({ length: nDeriv + 1 }, () => new Array(degree + 1).fill(0));
+  for (let j = 0; j <= degree; j++) {
+    ders[0][j] = ndu[j][degree];
+  }
+  for (let r2 = 0; r2 <= degree; r2++) {
+    let s1 = 0;
+    let s2 = 1;
+    a2[0][0] = 1;
+    for (let k2 = 1; k2 <= nDeriv; k2++) {
+      let d2 = 0;
+      const rk = r2 - k2;
+      const pk = degree - k2;
+      if (r2 >= k2) {
+        a2[s2][0] = ndu[pk + 1][rk] === 0 ? 0 : a2[s1][0] / ndu[pk + 1][rk];
+        d2 = a2[s2][0] * ndu[rk][pk];
+      }
+      const j1 = rk >= -1 ? 1 : -rk;
+      const j2 = r2 - 1 <= pk ? k2 - 1 : degree - r2;
+      for (let j = j1; j <= j2; j++) {
+        a2[s2][j] = ndu[pk + 1][rk + j] === 0 ? 0 : (a2[s1][j] - a2[s1][j - 1]) / ndu[pk + 1][rk + j];
+        d2 += a2[s2][j] * ndu[rk + j][pk];
+      }
+      if (r2 <= pk) {
+        a2[s2][k2] = ndu[pk + 1][r2] === 0 ? 0 : -a2[s1][k2 - 1] / ndu[pk + 1][r2];
+        d2 += a2[s2][k2] * ndu[r2][pk];
+      }
+      ders[k2][r2] = d2;
+      const tmp = s1;
+      s1 = s2;
+      s2 = tmp;
+    }
+  }
+  let r = degree;
+  for (let k2 = 1; k2 <= nDeriv; k2++) {
+    for (let j = 0; j <= degree; j++) {
+      ders[k2][j] *= r;
+    }
+    r *= degree - k2;
+  }
+  return ders;
+}
 function deBoor3D(controlPoints, weights, knots, degree, u2) {
   const n = controlPoints.length;
-  const span = findSpan(n, degree, u2, knots);
-  const N = basisFuns(span, u2, degree, knots);
+  const span2 = findSpan(n, degree, u2, knots);
+  const N = basisFuns(span2, u2, degree, knots);
   let wx = 0, wy = 0, wz = 0, wSum = 0;
   for (let j = 0; j <= degree; j++) {
-    const idx = span - degree + j;
+    const idx = span2 - degree + j;
     const w2 = weights[idx] * N[j];
     wx += w2 * controlPoints[idx][0];
     wy += w2 * controlPoints[idx][1];
@@ -11445,11 +11512,11 @@ function deBoor3D(controlPoints, weights, knots, degree, u2) {
 }
 function deBoor2D(controlPoints, weights, knots, degree, u2) {
   const n = controlPoints.length;
-  const span = findSpan(n, degree, u2, knots);
-  const N = basisFuns(span, u2, degree, knots);
+  const span2 = findSpan(n, degree, u2, knots);
+  const N = basisFuns(span2, u2, degree, knots);
   let wx = 0, wy = 0, wSum = 0;
   for (let j = 0; j <= degree; j++) {
-    const idx = span - degree + j;
+    const idx = span2 - degree + j;
     const w2 = weights[idx] * N[j];
     wx += w2 * controlPoints[idx][0];
     wy += w2 * controlPoints[idx][1];
@@ -15413,6 +15480,23 @@ function analyzeNodeUV(node, toLocal) {
 function clampUnit(v) {
   return v < -1 ? -1 : v > 1 ? 1 : v;
 }
+function sphereUVLocal(lx, ly, lz, radius) {
+  const u2 = atan2(ly, lx) * radius;
+  const len = sqrt$3(lx * lx + ly * ly + lz * lz);
+  const v = acos(clampUnit(lz / (len || 1))) * radius;
+  return [u2, v];
+}
+function cylinderUVLocal(lx, ly, lz, radius) {
+  const u2 = atan2(ly, lx) * radius;
+  const v = lz;
+  return [u2, v];
+}
+function torusUVLocal(lx, ly, lz, majorRadius, minorRadius) {
+  const u2 = atan2(ly, lx) * majorRadius;
+  const xyDist = sqrt$3(lx * lx + ly * ly) - majorRadius;
+  const v = atan2(lz, xyDist) * minorRadius;
+  return [u2, v];
+}
 function compileUVFunction(analysis) {
   if (analysis.mode === "triplanar") return null;
   const toLocal = analysis.toLocal;
@@ -15421,19 +15505,14 @@ function compileUVFunction(analysis) {
       const R = analysis.radius;
       return (p2) => {
         const lp = toLocal(p2);
-        const u2 = atan2(lp[1], lp[0]) * R;
-        const len = sqrt$3(lp[0] * lp[0] + lp[1] * lp[1] + lp[2] * lp[2]);
-        const v = acos(clampUnit(lp[2] / (len || 1))) * R;
-        return [u2, v];
+        return sphereUVLocal(lp[0], lp[1], lp[2], R);
       };
     }
     case "cylinder": {
       const r = analysis.radius;
       return (p2) => {
         const lp = toLocal(p2);
-        const u2 = atan2(lp[1], lp[0]) * r;
-        const v = lp[2];
-        return [u2, v];
+        return cylinderUVLocal(lp[0], lp[1], lp[2], r);
       };
     }
     case "torus": {
@@ -15441,10 +15520,7 @@ function compileUVFunction(analysis) {
       const r = analysis.radius;
       return (p2) => {
         const lp = toLocal(p2);
-        const u2 = atan2(lp[1], lp[0]) * R;
-        const xyDist = sqrt$3(lp[0] * lp[0] + lp[1] * lp[1]) - R;
-        const v = atan2(lp[2], xyDist) * r;
-        return [u2, v];
+        return torusUVLocal(lp[0], lp[1], lp[2], R, r);
       };
     }
   }
@@ -15755,8 +15831,8 @@ function sdProfileRevolve$1(profileFn, degrees, x2, y2, z2) {
   const profileDistance = profileFn(radial, z2);
   if (abs(degrees) >= 360) return profileDistance;
   const sweep = abs(degrees) * DEG$1;
-  const center = degrees * DEG$1 * 0.5;
-  let angle = Math.atan2(y2, x2) - center;
+  const center2 = degrees * DEG$1 * 0.5;
+  let angle = Math.atan2(y2, x2) - center2;
   while (angle <= -PI$1) angle += PI$1 * 2;
   while (angle > PI$1) angle -= PI$1 * 2;
   const half = sweep * 0.5;
@@ -15774,9 +15850,9 @@ function smax$1(a2, b, k2) {
 function repeatCoord$1(v, spacing, count) {
   if (spacing <= 0) return v;
   if (count > 0) {
-    const center = (count - 1) * 0.5;
-    const index2 = clamp$3(Math.round(v / spacing + center), 0, count - 1);
-    return v - (index2 - center) * spacing;
+    const center2 = (count - 1) * 0.5;
+    const index2 = clamp$3(Math.round(v / spacing + center2), 0, count - 1);
+    return v - (index2 - center2) * spacing;
   }
   return v - spacing * Math.round(v / spacing);
 }
@@ -16702,8 +16778,8 @@ function sdProfileRevolve(b, node, x2, y2, z2) {
   const profileDistance = profilePolygonsSdf(b, node.polygons, radial, z2);
   if (Math.abs(node.degrees) >= 360) return profileDistance;
   const sweep = Math.abs(node.degrees) * DEG;
-  const center = node.degrees * DEG * 0.5;
-  const angle = b.sub(b.atan2(y2, x2), b.constant(center));
+  const center2 = node.degrees * DEG * 0.5;
+  const angle = b.sub(b.atan2(y2, x2), b.constant(center2));
   const wrapped = b.sub(angle, b.mul(b.constant(TAU), b.round(b.div(angle, b.constant(TAU)))));
   const absAngle = b.abs(wrapped);
   const half = sweep * 0.5;
@@ -16770,9 +16846,9 @@ function select01(b, selector, ifOne, ifZero) {
 function repeatCoord(b, v, spacing, count) {
   if (spacing <= 0) return v;
   if (count > 0) {
-    const center = (count - 1) * 0.5;
-    const index2 = clampSlot(b, b.round(b.add(b.div(v, b.constant(spacing)), b.constant(center))), 0, count - 1);
-    return b.sub(v, b.mul(b.sub(index2, b.constant(center)), b.constant(spacing)));
+    const center2 = (count - 1) * 0.5;
+    const index2 = clampSlot(b, b.round(b.add(b.div(v, b.constant(spacing)), b.constant(center2))), 0, count - 1);
+    return b.sub(v, b.mul(b.sub(index2, b.constant(center2)), b.constant(spacing)));
   }
   return b.sub(v, b.mul(b.constant(spacing), b.round(b.div(v, b.constant(spacing)))));
 }
@@ -16863,7 +16939,7 @@ async function initTruckGeometryWasm() {
   if (_initPromise$1) return _initPromise$1;
   _initPromise$1 = (async () => {
     try {
-      const geometryModule = await import("./forgecad_geometry-BlMtqluF.js");
+      const geometryModule = await import("./forgecad_geometry-CZ_IfuvA.js");
       const isNode = isNodeRuntime();
       if (isNode) {
         const { readFileSync, existsSync } = await import("./__vite-browser-external-Dhvy_jtL.js");
@@ -17328,23 +17404,62 @@ class NurbsSurface {
     return [wx / wSum, wy / wSum, wz / wSum];
   }
   /**
-   * Evaluate the surface normal at (u, v) via cross product of partial derivatives.
+   * Evaluate the surface unit normal at (u, v) from analytic first derivatives.
+   *
+   * Uses Algorithm A2.3 basis-function derivatives with the rational quotient
+   * rule, so the normal is exact (no finite-difference epsilon, no error near
+   * the boundary). Constant chain-rule factors from the parameter remap scale Su
+   * and Sv positively and cancel under normalization, so they are omitted.
    */
   normalAt(u2, v) {
-    const eps = 1e-5;
-    const u0 = Math.max(0, u2 - eps), u1 = Math.min(1, u2 + eps);
-    const v0 = Math.max(0, v - eps), v1 = Math.min(1, v + eps);
-    const pu = this.pointAt(u1, v), pmu = this.pointAt(u0, v);
-    const pv = this.pointAt(u2, v1), pmv = this.pointAt(u2, v0);
-    const du = [pu[0] - pmu[0], pu[1] - pmu[1], pu[2] - pmu[2]];
-    const dv = [pv[0] - pmv[0], pv[1] - pmv[1], pv[2] - pmv[2]];
-    const nx = du[1] * dv[2] - du[2] * dv[1];
-    const ny = du[2] * dv[0] - du[0] * dv[2];
-    const nz = du[0] * dv[1] - du[1] * dv[0];
+    const { Su, Sv } = this.derivativesAt(u2, v);
+    const nx = Su[1] * Sv[2] - Su[2] * Sv[1];
+    const ny = Su[2] * Sv[0] - Su[0] * Sv[2];
+    const nz = Su[0] * Sv[1] - Su[1] * Sv[0];
     const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
     if (len < 1e-12) return [0, 0, 1];
     return [nx / len, ny / len, nz / len];
   }
+  /** Analytic first partial derivatives S_u, S_v (rational quotient rule). */
+  derivativesAt(u2, v) {
+    const uu = this.remapU(Math.max(0, Math.min(1, u2)));
+    const vv = this.remapV(Math.max(0, Math.min(1, v)));
+    const spanU = findSpan(this.nU, this.degreeU, uu, this.knotsU);
+    const spanV = findSpan(this.nV, this.degreeV, vv, this.knotsV);
+    const dU = basisFunsDeriv(spanU, uu, this.degreeU, this.knotsU, 1);
+    const dV = basisFunsDeriv(spanV, vv, this.degreeV, this.knotsV, 1);
+    const A = [0, 0, 0];
+    const Au = [0, 0, 0];
+    const Av = [0, 0, 0];
+    let w2 = 0;
+    let wu = 0;
+    let wv = 0;
+    for (let i = 0; i <= this.degreeU; i++) {
+      const rowIdx = spanU - this.degreeU + i;
+      for (let j = 0; j <= this.degreeV; j++) {
+        const colIdx = spanV - this.degreeV + j;
+        const weight = this.weightsGrid[rowIdx][colIdx];
+        const pt = this.controlGrid[rowIdx][colIdx];
+        const n00 = dU[0][i] * dV[0][j] * weight;
+        const n10 = dU[1][i] * dV[0][j] * weight;
+        const n01 = dU[0][i] * dV[1][j] * weight;
+        w2 += n00;
+        wu += n10;
+        wv += n01;
+        for (let c2 = 0; c2 < 3; c2++) {
+          A[c2] += n00 * pt[c2];
+          Au[c2] += n10 * pt[c2];
+          Av[c2] += n01 * pt[c2];
+        }
+      }
+    }
+    if (w2 === 0) return { S: [0, 0, 0], Su: [0, 0, 0], Sv: [0, 0, 0] };
+    const invW = 1 / w2;
+    const S = [A[0] * invW, A[1] * invW, A[2] * invW];
+    const Su = [(Au[0] - wu * S[0]) * invW, (Au[1] - wu * S[1]) * invW, (Au[2] - wu * S[2]) * invW];
+    const Sv = [(Av[0] - wv * S[0]) * invW, (Av[1] - wv * S[1]) * invW, (Av[2] - wv * S[2]) * invW];
+    return { S, Su, Sv };
+  }
   /**
    * Tessellate the surface into a triangle mesh.
    * Returns positions, normals, and triangle indices.
@@ -17789,49 +17904,55 @@ function signedArea2D(loop) {
   }
   return area2 * 0.5;
 }
-function pointInLoop$2(point2, loop) {
+function buildSdfLoopEdges(pts) {
+  const n = pts.length;
+  const ax = new Float64Array(n);
+  const ay = new Float64Array(n);
+  const ex = new Float64Array(n);
+  const ey = new Float64Array(n);
+  const invLen2 = new Float64Array(n);
+  for (let i = 0; i < n; i += 1) {
+    const a2 = pts[i];
+    const b = pts[(i + 1) % n];
+    const vx = b[0] - a2[0];
+    const vy = b[1] - a2[1];
+    ax[i] = a2[0];
+    ay[i] = a2[1];
+    ex[i] = vx;
+    ey[i] = vy;
+    const len2 = vx * vx + vy * vy;
+    invLen2[i] = len2 < 1e-12 ? 0 : 1 / len2;
+  }
+  return { n, area: signedArea2D(pts), ax, ay, ex, ey, invLen2 };
+}
+function loopSignedDistanceScalar(px, py, e) {
+  let minDist2 = Infinity;
   let inside = false;
-  const [px, py] = point2;
-  for (let index2 = 0, prev = loop.length - 1; index2 < loop.length; prev = index2, index2 += 1) {
-    const [xi, yi] = loop[index2];
-    const [xj, yj] = loop[prev];
-    const intersects2 = yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi + 1e-20) + xi;
-    if (intersects2) inside = !inside;
-  }
-  return inside;
-}
-function pointSegDist2D(point2, a2, b) {
-  const abx = b[0] - a2[0];
-  const aby = b[1] - a2[1];
-  const apx = point2[0] - a2[0];
-  const apy = point2[1] - a2[1];
-  const den = abx * abx + aby * aby;
-  const t = den < 1e-12 ? 0 : clamp$1((apx * abx + apy * aby) / den, 0, 1);
-  const qx = a2[0] + abx * t;
-  const qy = a2[1] + aby * t;
-  const dx = point2[0] - qx;
-  const dy = point2[1] - qy;
-  return Math.sqrt(dx * dx + dy * dy);
-}
-function loopSignedDistance(point2, loop) {
-  let minDist = Infinity;
-  for (let index2 = 0; index2 < loop.length; index2 += 1) {
-    const a2 = loop[index2];
-    const b = loop[(index2 + 1) % loop.length];
-    minDist = Math.min(minDist, pointSegDist2D(point2, a2, b));
-  }
-  return pointInLoop$2(point2, loop) ? minDist : -minDist;
+  for (let i = 0; i < e.n; i += 1) {
+    const ax = e.ax[i];
+    const ay = e.ay[i];
+    const vx = e.ex[i];
+    const vy = e.ey[i];
+    const t = clamp$1(((px - ax) * vx + (py - ay) * vy) * e.invLen2[i], 0, 1);
+    const ddx = px - (ax + vx * t);
+    const ddy = py - (ay + vy * t);
+    const d22 = ddx * ddx + ddy * ddy;
+    if (d22 < minDist2) minDist2 = d22;
+    const by = ay + vy;
+    if (ay > py !== by > py && px < vx * (py - ay) / (vy + 1e-20) + ax) inside = !inside;
+  }
+  const d2 = Math.sqrt(minDist2);
+  return inside ? d2 : -d2;
 }
 function compilePolygonsSdf(polygons) {
-  const loops = polygons.filter((loop) => Array.isArray(loop) && loop.length >= 3).map((loop) => ({ pts: loop.map(([x2, y2]) => [x2, y2]), area: signedArea2D(loop) }));
+  const loops = polygons.filter((loop) => Array.isArray(loop) && loop.length >= 3).map((loop) => buildSdfLoopEdges(loop.map(([x2, y2]) => [x2, y2])));
   if (loops.length === 0) {
     return () => -1;
   }
   return (x2, y2) => {
-    const point2 = [x2, y2];
     let field2 = -Infinity;
     for (const loop of loops) {
-      const loopField = loopSignedDistance(point2, loop.pts);
+      const loopField = loopSignedDistanceScalar(x2, y2, loop);
       field2 = loop.area >= 0 ? Math.max(field2, loopField) : Math.min(field2, -loopField);
     }
     return field2;
@@ -17989,24 +18110,40 @@ function interpolateSweepFrame(segment, alpha, origin) {
 function findNearestSweepPoint(point2, segments) {
   let bestIndex = 0;
   let bestAlpha = 0;
-  let bestPoint = segments[0].a;
+  let bestAlong = 0;
   let bestDist2 = Infinity;
+  const px = point2[0];
+  const py = point2[1];
+  const pz = point2[2];
   for (let index2 = 0; index2 < segments.length; index2 += 1) {
     const segment = segments[index2];
-    const offset = vec3Sub(point2, segment.a);
-    const along = clamp$1(vec3Dot(offset, segment.t), 0, segment.len);
-    const alpha = segment.len > 1e-9 ? along / segment.len : 0;
-    const pointOnPath = vec3Add(segment.a, vec3Scale(segment.t, along));
-    const delta = vec3Sub(point2, pointOnPath);
-    const dist2 = vec3Dot(delta, delta);
+    const ax = segment.a[0];
+    const ay = segment.a[1];
+    const az = segment.a[2];
+    const tx = segment.t[0];
+    const ty = segment.t[1];
+    const tz = segment.t[2];
+    const along = clamp$1((px - ax) * tx + (py - ay) * ty + (pz - az) * tz, 0, segment.len);
+    const qx = ax + tx * along;
+    const qy = ay + ty * along;
+    const qz = az + tz * along;
+    const dx = px - qx;
+    const dy = py - qy;
+    const dz = pz - qz;
+    const dist2 = dx * dx + dy * dy + dz * dz;
     if (dist2 < bestDist2) {
       bestIndex = index2;
-      bestAlpha = alpha;
-      bestPoint = pointOnPath;
+      bestAlong = along;
+      bestAlpha = segment.len > 1e-9 ? along / segment.len : 0;
       bestDist2 = dist2;
     }
   }
   const bestSegment = segments[bestIndex];
+  const bestPoint = [
+    bestSegment.a[0] + bestSegment.t[0] * bestAlong,
+    bestSegment.a[1] + bestSegment.t[1] * bestAlong,
+    bestSegment.a[2] + bestSegment.t[2] * bestAlong
+  ];
   return {
     segmentIndex: bestIndex,
     segment: bestSegment,
@@ -18995,8 +19132,8 @@ function stitchSingleLoopLoft(loops, heights, wasm, options) {
     return null;
   }
 }
-function surfaceNormal(chord, span) {
-  const n = cross3$6(chord, span);
+function surfaceNormal(chord, span2) {
+  const n = cross3$6(chord, span2);
   const len = Math.hypot(n[0], n[1], n[2]);
   if (len < 1e-12) {
     const radial = Math.hypot(chord[0], chord[1]);
@@ -19656,6 +19793,30 @@ function fromSlicesSingleSliceHalfExtentForManifold(plan) {
   }
   return Math.max(1, radius + maxOffsetMagnitude + plan.boundsPadding + plan.edgeLength * 3);
 }
+const BOOLEAN_OPERAND_NORMAL_SHARP_ANGLE_DEG = 60;
+const BOOLEAN_OPERAND_UV_EXTRA_PROP_MIN = 4;
+function rejectParametricUvBooleanOperands(shapes) {
+  for (const shape of shapes) {
+    if (shape.numProp() >= BOOLEAN_OPERAND_UV_EXTRA_PROP_MIN) {
+      throw new Error(
+        "Cannot boolean a shape that carries parametric UV (mesh numProp 8, vertProperties[6..7]). Parametric UV is baked into the mesh and is destroyed by cuts — Manifold interpolates the uv channels from the other operand onto every new cut/seam vertex. Apply booleans BEFORE texturing the result, or use a projected texture (Shape.wrapTexture with Wrap.*), which is computed from final position and survives booleans."
+      );
+    }
+  }
+}
+function promoteBooleanOperandNormals(shapes) {
+  let maxExtra = 0;
+  for (const shape of shapes) maxExtra = Math.max(maxExtra, shape.numProp());
+  if (maxExtra < 3) return { operands: shapes, created: [] };
+  const created = [];
+  const operands = shapes.map((shape) => {
+    if (shape.numProp() >= 3) return shape;
+    const promoted = shape.calculateNormals(0, BOOLEAN_OPERAND_NORMAL_SHARP_ANGLE_DEG);
+    created.push(promoted);
+    return promoted;
+  });
+  return { operands, created };
+}
 function lowerShapeBooleanCompilePlan(plan, wasm) {
   const shapes = plan.shapes.map((shape) => lowerShapeCompilePlanToManifold(shape, wasm));
   if (shapes.length === 0) {
@@ -19664,16 +19825,24 @@ function lowerShapeBooleanCompilePlan(plan, wasm) {
   if (shapes.length === 1) {
     return shapes[0];
   }
+  try {
+    rejectParametricUvBooleanOperands(shapes);
+  } catch (error) {
+    disposeWasmObjects(shapes);
+    throw error;
+  }
+  const { operands, created } = promoteBooleanOperandNormals(shapes);
   try {
     switch (plan.op) {
       case "union":
-        return wasm.Manifold.union(shapes);
+        return wasm.Manifold.union(operands);
       case "difference":
-        return wasm.Manifold.difference(shapes);
+        return wasm.Manifold.difference(operands);
       case "intersection":
-        return wasm.Manifold.intersection(shapes);
+        return wasm.Manifold.intersection(operands);
     }
   } finally {
+    disposeWasmObjects(created);
     disposeWasmObjects(shapes);
   }
 }
@@ -20419,9 +20588,9 @@ function lowerVerticalVariableSweepStitchedForManifold(plan, sectionPolygons, wa
     return null;
   }
   const frameY = cross3$5(tangent, frameX);
-  const span = end[2] - start[2];
+  const span2 = end[2] - start[2];
   const sections = sectionPolygons.map((section) => ({
-    height: start[2] + span * section.t,
+    height: start[2] + span2 * section.t,
     polygons: section.polygons.map(
       (loop) => loop.map(([u2, v]) => [start[0] + u2 * frameX[0] + v * frameY[0], start[1] + u2 * frameX[1] + v * frameY[1]])
     )
@@ -21023,12 +21192,16 @@ function lowerNurbsSurfaceToManifold(plan, wasm) {
   const { positions, normals, indices } = surface.tessellate(res, res);
   const thickness = plan.thickness;
   const numVerts = positions.length;
-  const allPositions = [];
-  for (const [x2, y2, z2] of positions) allPositions.push(x2, y2, z2);
+  const vertProps = [];
   for (let i = 0; i < numVerts; i++) {
     const [x2, y2, z2] = positions[i];
     const [nx, ny, nz] = normals[i];
-    allPositions.push(x2 - nx * thickness, y2 - ny * thickness, z2 - nz * thickness);
+    vertProps.push(x2, y2, z2, nx, ny, nz);
+  }
+  for (let i = 0; i < numVerts; i++) {
+    const [x2, y2, z2] = positions[i];
+    const [nx, ny, nz] = normals[i];
+    vertProps.push(x2 - nx * thickness, y2 - ny * thickness, z2 - nz * thickness, -nx, -ny, -nz);
   }
   const allIndices = [];
   for (const idx of indices) allIndices.push(idx);
@@ -21053,11 +21226,12 @@ function lowerNurbsSurfaceToManifold(plan, wasm) {
     allIndices.push(c2, c2 + numVerts, d2, d2, c2 + numVerts, d2 + numVerts);
   }
   const mesh = new wasm.Mesh({
-    numProp: 3,
-    vertProperties: new Float32Array(allPositions),
+    numProp: 6,
+    vertProperties: new Float32Array(vertProps),
     triVerts: new Uint32Array(allIndices)
   });
   try {
+    mesh.merge();
     return new wasm.Manifold(mesh);
   } finally {
     disposeWasmObject(mesh);
@@ -22963,7 +23137,7 @@ function lowerAxisymmetricEllipsoidForOCCT(oc, radius, heightRadius) {
 }
 function lowerOrthogonalEllipseFromSlicesPlan(oc, plan) {
   if (plan.groups.length !== 2) return null;
-  const center = [0, 0, 0];
+  const center2 = [0, 0, 0];
   const radii = [null, null, null];
   for (const group of plan.groups) {
     if (group.slices.length !== 1) return null;
@@ -22975,7 +23149,7 @@ function lowerOrthogonalEllipseFromSlicesPlan(oc, plan) {
     const uAxis = axisAlignedDirectionForOCCT(frame.u);
     const vAxis = axisAlignedDirectionForOCCT(frame.v);
     if (!normalAxis || !uAxis || !vAxis) return null;
-    center[normalAxis.axis] = normalAxis.sign * slice.offset;
+    center2[normalAxis.axis] = normalAxis.sign * slice.offset;
     if (!setEllipsoidRadiusForOCCT(radii, uAxis.axis, profileRadii[0])) return null;
     if (!setEllipsoidRadiusForOCCT(radii, vAxis.axis, profileRadii[1])) return null;
   }
@@ -22986,9 +23160,9 @@ function lowerOrthogonalEllipseFromSlicesPlan(oc, plan) {
   const axisymmetricTolerance = Math.max(1e-7, Math.max(Math.abs(rx), Math.abs(ry)) * 1e-7);
   if (Math.abs(rx - ry) > axisymmetricTolerance) return null;
   let shape = lowerAxisymmetricEllipsoidForOCCT(oc, (rx + ry) / 2, rz);
-  if (Math.hypot(center[0], center[1], center[2]) > 1e-10) {
+  if (Math.hypot(center2[0], center2[1], center2[2]) > 1e-10) {
     const trsf = new oc.gp_Trsf_1();
-    trsf.SetTranslation_1(new oc.gp_Vec_4(center[0], center[1], center[2]));
+    trsf.SetTranslation_1(new oc.gp_Vec_4(center2[0], center2[1], center2[2]));
     const moved = new oc.BRepBuilderAPI_Transform_2(shape, trsf, true);
     shape = moved.Shape();
   }
@@ -23910,8 +24084,8 @@ function resamplePolyline$1(points, count) {
   for (let index2 = 0; index2 < count; index2 += 1) {
     const target = index2 / (count - 1) * total;
     while (segment < cumulative.length - 2 && cumulative[segment + 1] < target) segment += 1;
-    const span = cumulative[segment + 1] - cumulative[segment];
-    const t = span > 1e-12 ? (target - cumulative[segment]) / span : 0;
+    const span2 = cumulative[segment + 1] - cumulative[segment];
+    const t = span2 > 1e-12 ? (target - cumulative[segment]) / span2 : 0;
     const a2 = points[segment];
     const b = points[segment + 1];
     out.push([a2[0] + (b[0] - a2[0]) * t, a2[1] + (b[1] - a2[1]) * t, a2[2] + (b[2] - a2[2]) * t]);
@@ -24042,19 +24216,23 @@ function surfaceGridForFillPlan$1(plan) {
 function surfaceGridForAnalyticPlan$1(plan) {
   const count = Math.max(2, plan.resolution + 1);
   const grid = [];
+  const uvGrid = [];
   const { uMin, uMax, vMin, vMax } = plan.surface;
   for (let uIndex = 0; uIndex < count; uIndex += 1) {
     const uNorm = uIndex / (count - 1);
     const u2 = uMin + (uMax - uMin) * uNorm;
     const row = [];
+    const uvRow = [];
     for (let vIndex = 0; vIndex < count; vIndex += 1) {
       const vNorm = vIndex / (count - 1);
       const v = vMin + (vMax - vMin) * vNorm;
       row.push(analyticSurfacePoint$1(plan.surface, u2, v));
+      uvRow.push([uNorm, vNorm]);
     }
     grid.push(row);
+    uvGrid.push(uvRow);
   }
-  return { grid, trim: sampleTrim(plan.trim) };
+  return { grid, trim: sampleTrim(plan.trim), uvGrid };
 }
 function computeGridNormals(positions, indices) {
   const normals = Array.from({ length: positions.length }, () => [0, 0, 0]);
@@ -24080,6 +24258,7 @@ function meshFromSurfaceGrid(grid, trim = null, context = "SDF surface sheet", u
   const cols = ((_a3 = grid[0]) == null ? void 0 : _a3.length) ?? 0;
   if (rows < 2 || cols < 2) throw new Error(`${context} requires at least a 2x2 sampled grid.`);
   const positions = grid.flat();
+  const hasParametricUv = uvGrid !== void 0;
   const uvs = [];
   if (uvGrid) {
     if (uvGrid.length !== rows || uvGrid.some((row) => row.length !== cols)) {
@@ -24091,6 +24270,16 @@ function meshFromSurfaceGrid(grid, trim = null, context = "SDF surface sheet", u
       for (let col = 0; col < cols; col += 1) uvs.push([row / (rows - 1), col / (cols - 1)]);
     }
   }
+  const normalizeUv = (() => {
+    if (!uvGrid) return (uv) => uv;
+    const { uDomain, vDomain } = uvDomainFromGrid(uvGrid);
+    const uSpan = uDomain[1] - uDomain[0];
+    const vSpan = vDomain[1] - vDomain[0];
+    return (uv) => [
+      uSpan > 0 ? (uv[0] - uDomain[0]) / uSpan : 0,
+      vSpan > 0 ? (uv[1] - vDomain[0]) / vSpan : 0
+    ];
+  })();
   const sourceIndices = [];
   const includeTriangle = (a2, b, c2) => {
     const centroid2 = [(uvs[a2][0] + uvs[b][0] + uvs[c2][0]) / 3, (uvs[a2][1] + uvs[b][1] + uvs[c2][1]) / 3];
@@ -24109,29 +24298,37 @@ function meshFromSurfaceGrid(grid, trim = null, context = "SDF surface sheet", u
   if (sourceIndices.length === 0) throw new Error(`${context} trim loops removed the whole sampled surface.`);
   const used = /* @__PURE__ */ new Map();
   const compactPositions = [];
+  const compactUvs = [];
   const compactIndices = sourceIndices.map((sourceIndex) => {
     const existing = used.get(sourceIndex);
     if (existing !== void 0) return existing;
     const next = compactPositions.length;
     used.set(sourceIndex, next);
     compactPositions.push(positions[sourceIndex]);
+    if (hasParametricUv) compactUvs.push(normalizeUv(uvs[sourceIndex]));
     return next;
   });
   const compactNormals = computeGridNormals(compactPositions, compactIndices);
-  const vertProperties = new Float32Array(compactPositions.length * 6);
+  const numProp = hasParametricUv ? NUM_PROP_WITH_UV : NUM_PROP_WITH_NORMAL;
+  const vertProperties = new Float32Array(compactPositions.length * numProp);
   for (let index2 = 0; index2 < compactPositions.length; index2 += 1) {
     const [x2, y2, z2] = compactPositions[index2];
     const [nx, ny, nz] = compactNormals[index2];
-    const offset = index2 * 6;
-    vertProperties[offset] = x2;
-    vertProperties[offset + 1] = y2;
-    vertProperties[offset + 2] = z2;
-    vertProperties[offset + 3] = nx;
-    vertProperties[offset + 4] = ny;
-    vertProperties[offset + 5] = nz;
+    const offset = index2 * numProp;
+    vertProperties[offset + POSITION_OFFSET] = x2;
+    vertProperties[offset + POSITION_OFFSET + 1] = y2;
+    vertProperties[offset + POSITION_OFFSET + 2] = z2;
+    vertProperties[offset + NORMAL_OFFSET] = nx;
+    vertProperties[offset + NORMAL_OFFSET + 1] = ny;
+    vertProperties[offset + NORMAL_OFFSET + 2] = nz;
+    if (hasParametricUv) {
+      const [u2, v] = compactUvs[index2];
+      vertProperties[offset + UV_OFFSET] = u2;
+      vertProperties[offset + UV_OFFSET + 1] = v;
+    }
   }
   return {
-    numProp: 6,
+    numProp,
     numVert: compactPositions.length,
     numTri: compactIndices.length / 3,
     vertProperties,
@@ -24216,16 +24413,20 @@ function surfaceGridForNurbsPlan(plan) {
   });
   const resolution = Math.max(2, Math.round(plan.resolution));
   const grid = [];
+  const uvGrid = [];
   for (let i = 0; i <= resolution; i += 1) {
     const u2 = i / resolution;
     const row = [];
+    const uvRow = [];
     for (let j = 0; j <= resolution; j += 1) {
       const v = j / resolution;
       row.push(surface.pointAt(u2, v));
+      uvRow.push([u2, v]);
     }
     grid.push(row);
+    uvGrid.push(uvRow);
   }
-  return { grid, rowAxis: "u", trim: sampleTrim(plan.trim), uDomain: [0, 1], vDomain: [0, 1] };
+  return { grid, rowAxis: "u", trim: sampleTrim(plan.trim), uDomain: [0, 1], vDomain: [0, 1], uvGrid };
 }
 function surfaceGridForSheetPlan(plan) {
   if (plan.kind === "queryOwner") return surfaceGridForSheetPlan(plan.base);
@@ -24240,8 +24441,8 @@ function surfaceGridForSheetPlan(plan) {
   }
   if (plan.kind === "nurbsSurface") return surfaceGridForNurbsPlan(plan);
   if (plan.kind === "analyticSurface") {
-    const { grid, trim } = surfaceGridForAnalyticPlan$1(plan);
-    return { grid, rowAxis: "u", trim, uDomain: [0, 1], vDomain: [0, 1] };
+    const { grid, trim, uvGrid } = surfaceGridForAnalyticPlan$1(plan);
+    return { grid, rowAxis: "u", trim, uDomain: [0, 1], vDomain: [0, 1], uvGrid };
   }
   if (plan.kind === "surfaceRuled") return { grid: surfaceGridForRuledPlan$1(plan), rowAxis: "v" };
   if (plan.kind === "surfaceFill") return { grid: surfaceGridForFillPlan$1(plan), rowAxis: "v" };
@@ -24515,8 +24716,8 @@ function meshFromOpenSurfaceSheetPlan(plan) {
   }
   if (plan.kind === "nurbsSurface") return meshFromOpenNurbsSurface(plan);
   if (plan.kind === "analyticSurface") {
-    const { grid, trim } = surfaceGridForAnalyticPlan$1(plan);
-    return meshFromSurfaceGrid(grid, trim, "SDF analytic surface");
+    const { grid, trim, uvGrid } = surfaceGridForAnalyticPlan$1(plan);
+    return meshFromSurfaceGrid(grid, trim, "SDF analytic surface", uvGrid);
   }
   if (plan.kind === "surfaceRuled") return meshFromSurfaceGrid(surfaceGridForRuledPlan$1(plan), null, "SDF ruled surface");
   if (plan.kind === "surfaceFill") return meshFromSurfaceFillPlan(plan);
@@ -31998,8 +32199,8 @@ function revolveProfilePolygonsToSdfField(polygons, degrees = 360) {
       const profileDistance = profile.eval(radial, z2);
       if (Math.abs(degrees) >= 360) return profileDistance;
       const sweep = Math.abs(degrees) * (Math.PI / 180);
-      const center = degrees * Math.PI / 360;
-      let angle = Math.atan2(y2, x2) - center;
+      const center2 = degrees * Math.PI / 360;
+      let angle = Math.atan2(y2, x2) - center2;
       while (angle <= -Math.PI) angle += Math.PI * 2;
       while (angle > Math.PI) angle -= Math.PI * 2;
       const half = sweep / 2;
@@ -33305,15 +33506,15 @@ function deBoorPoint(degree, knots, controlPoints, parameter) {
   const domainEnd = knots[controlPoints.length];
   const t = Math.max(domainStart, Math.min(domainEnd, parameter));
   if (t >= domainEnd - 1e-12) return controlPoints[controlPoints.length - 1];
-  let span = degree;
+  let span2 = degree;
   const lastSpan = controlPoints.length - 1;
-  while (span < lastSpan && t >= knots[span + 1]) span += 1;
+  while (span2 < lastSpan && t >= knots[span2 + 1]) span2 += 1;
   const points = [];
-  for (let index2 = 0; index2 <= degree; index2 += 1) points.push([...controlPoints[span - degree + index2]]);
+  for (let index2 = 0; index2 <= degree; index2 += 1) points.push([...controlPoints[span2 - degree + index2]]);
   for (let order = 1; order <= degree; order += 1) {
     for (let index2 = degree; index2 >= order; index2 -= 1) {
-      const knotLeft = knots[span - degree + index2];
-      const knotRight = knots[span + index2 + 1 - order];
+      const knotLeft = knots[span2 - degree + index2];
+      const knotRight = knots[span2 + index2 + 1 - order];
       const alpha = Math.abs(knotRight - knotLeft) <= 1e-12 ? 0 : (t - knotLeft) / (knotRight - knotLeft);
       points[index2] = [
         points[index2 - 1][0] * (1 - alpha) + points[index2][0] * alpha,
@@ -33329,16 +33530,16 @@ function deBoorHomogeneousPoint(degree, knots, controlPoints, parameter) {
   const domainEnd = knots[controlPoints.length];
   const t = Math.max(domainStart, Math.min(domainEnd, parameter));
   if (t >= domainEnd - 1e-12) return controlPoints[controlPoints.length - 1];
-  let span = degree;
+  let span2 = degree;
   const lastSpan = controlPoints.length - 1;
-  while (span < lastSpan && t >= knots[span + 1]) span += 1;
+  while (span2 < lastSpan && t >= knots[span2 + 1]) span2 += 1;
   const points = [];
   for (let index2 = 0; index2 <= degree; index2 += 1)
-    points.push([...controlPoints[span - degree + index2]]);
+    points.push([...controlPoints[span2 - degree + index2]]);
   for (let order = 1; order <= degree; order += 1) {
     for (let index2 = degree; index2 >= order; index2 -= 1) {
-      const knotLeft = knots[span - degree + index2];
-      const knotRight = knots[span + index2 + 1 - order];
+      const knotLeft = knots[span2 - degree + index2];
+      const knotRight = knots[span2 + index2 + 1 - order];
       const alpha = Math.abs(knotRight - knotLeft) <= 1e-12 ? 0 : (t - knotLeft) / (knotRight - knotLeft);
       points[index2] = [
         points[index2 - 1][0] * (1 - alpha) + points[index2][0] * alpha,
@@ -33400,9 +33601,9 @@ function closestBSplineParameter(curve, point2) {
 function wrappedBSplinePoint(curve, parameter) {
   const [domainStart, domainEnd] = bsplineDomain(curve);
   if (!curve.closed) return bsplinePoint(curve, parameter);
-  const span = domainEnd - domainStart;
-  let wrapped = (parameter - domainStart) % span + domainStart;
-  if (wrapped < domainStart) wrapped += span;
+  const span2 = domainEnd - domainStart;
+  let wrapped = (parameter - domainStart) % span2 + domainStart;
+  if (wrapped < domainStart) wrapped += span2;
   return bsplinePoint(curve, wrapped);
 }
 function bsplineSurfacePoint(surface, u2, v) {
@@ -33718,8 +33919,8 @@ function resampleClosedLoop(loop, count) {
   for (let index2 = 0; index2 < count; index2 += 1) {
     const target = index2 / count * total;
     while (segment < points.length - 1 && cumulative[segment + 1] < target) segment += 1;
-    const span = cumulative[segment + 1] - cumulative[segment];
-    const t = span <= 1e-12 ? 0 : (target - cumulative[segment]) / span;
+    const span2 = cumulative[segment + 1] - cumulative[segment];
+    const t = span2 <= 1e-12 ? 0 : (target - cumulative[segment]) / span2;
     const a2 = points[segment];
     const b = points[(segment + 1) % points.length];
     out.push([a2[0] + (b[0] - a2[0]) * t, a2[1] + (b[1] - a2[1]) * t, a2[2] + (b[2] - a2[2]) * t]);
@@ -33747,14 +33948,14 @@ function orientRadialTriangles(triangles, frame, sameSense) {
   const flip = sameSense ? !radialOutward : radialOutward;
   return flip ? triangles.map(reverseTriangle) : triangles;
 }
-function orientCenteredTriangles(triangles, center, sameSense) {
+function orientCenteredTriangles(triangles, center2, sameSense) {
   return triangles.map((triangle) => {
     const sample = [
       (triangle[0][0] + triangle[1][0] + triangle[2][0]) / 3,
       (triangle[0][1] + triangle[1][1] + triangle[2][1]) / 3,
       (triangle[0][2] + triangle[1][2] + triangle[2][2]) / 3
     ];
-    const outward = [sample[0] - center[0], sample[1] - center[1], sample[2] - center[2]];
+    const outward = [sample[0] - center2[0], sample[1] - center2[1], sample[2] - center2[2]];
     const normal2 = cross3$4(
       [triangle[1][0] - triangle[0][0], triangle[1][1] - triangle[0][1], triangle[1][2] - triangle[0][2]],
       [triangle[2][0] - triangle[0][0], triangle[2][1] - triangle[0][1], triangle[2][2] - triangle[0][2]]
@@ -33993,8 +34194,8 @@ function orientRevolvedProfileTriangles(triangles, frame, axis, profileCenter, p
       (triangle[0][2] + triangle[1][2] + triangle[2][2]) / 3
     ];
     const angle = revolutionAngle(frame, sample, filePath, "SURFACE_OF_REVOLUTION");
-    const center = rotateAroundAxis(profileCenter, axis, normalizeAngleDelta(angle - profileAngle));
-    const outward = sub3$1(sample, center);
+    const center2 = rotateAroundAxis(profileCenter, axis, normalizeAngleDelta(angle - profileAngle));
+    const outward = sub3$1(sample, center2);
     if (Math.hypot(outward[0], outward[1], outward[2]) <= 1e-12)
       failStepImport(filePath, "SURFACE_OF_REVOLUTION sample hit degenerate profile centerline.");
     const normal2 = cross3$4(sub3$1(triangle[1], triangle[0]), sub3$1(triangle[2], triangle[0]));
@@ -34399,18 +34600,18 @@ function triangulateTrimmedBSplineSurface(surface, loops, sameSense, filePath, c
   const { outer: uvLoop, holes } = trimmedBSplineSurfaceUvLoops(surface, loops, filePath, context);
   if (holes.length > 0 || !isConvexUvLoop(uvLoop))
     return triangulateBSplineSurfaceUvPolygon(surface, uvLoop, holes, sameSense, filePath, context);
-  const center = uvCentroid(uvLoop);
+  const center2 = uvCentroid(uvLoop);
   const ringCount = Math.max(3, Math.ceil(Math.max(surface.controlPoints.length, surface.controlPoints[0].length) * 1.5));
   const rings = [];
   for (let ringIndex = 1; ringIndex <= ringCount; ringIndex += 1) {
     const t = ringIndex / ringCount;
-    rings.push(uvLoop.map((point2) => [center[0] + (point2[0] - center[0]) * t, center[1] + (point2[1] - center[1]) * t]));
+    rings.push(uvLoop.map((point2) => [center2[0] + (point2[0] - center2[0]) * t, center2[1] + (point2[1] - center2[1]) * t]));
   }
   const mapPoint = (point2) => bsplineSurfacePoint(surface, point2[0], point2[1]);
   const triangles = [];
   const firstRing = rings[0];
   for (let index2 = 0; index2 < firstRing.length; index2 += 1) {
-    triangles.push([mapPoint(center), mapPoint(firstRing[index2]), mapPoint(firstRing[(index2 + 1) % firstRing.length])]);
+    triangles.push([mapPoint(center2), mapPoint(firstRing[index2]), mapPoint(firstRing[(index2 + 1) % firstRing.length])]);
   }
   for (let ringIndex = 1; ringIndex < rings.length; ringIndex += 1) {
     const inner = rings[ringIndex - 1];
@@ -34427,9 +34628,9 @@ function rotateArray(items, start) {
   return [...items.slice(start), ...items.slice(0, start)];
 }
 function periodicParameterDistance(a2, b, start, end) {
-  const span = end - start;
+  const span2 = end - start;
   const raw = Math.abs(a2 - b);
-  return Math.min(raw, Math.max(0, span - raw));
+  return Math.min(raw, Math.max(0, span2 - raw));
 }
 function closedUBSplineBoundaryRing(surface, loop, count, filePath, context) {
   const points = resampleClosedLoop(loop, count);
@@ -34694,11 +34895,11 @@ function sphericalLoopInfo(frame, radius, loop, filePath, context) {
     if (Math.abs(distance - radius) > tolerance)
       failStepImport(filePath, `${context} bounded SPHERICAL_SURFACE boundary point is not on the sphere.`);
   }
-  const center = centroid(points);
+  const center2 = centroid(points);
   const normal2 = normalize3$2(newellNormal(points), `${context} bounded SPHERICAL_SURFACE boundary normal`);
-  const maxPlaneError = points.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$3(sub3$1(point2, center), normal2))), 0);
+  const maxPlaneError = points.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$3(sub3$1(point2, center2), normal2))), 0);
   if (maxPlaneError > tolerance) failStepImport(filePath, `${context} bounded SPHERICAL_SURFACE boundary loop is not planar.`);
-  return { points, center, normal: normal2 };
+  return { points, center: center2, normal: normal2 };
 }
 function triangulateBoundedSphericalBand(frame, radius, loops, sameSense, filePath, context) {
   if (loops.length !== 2) failStepImport(filePath, `${context} bounded SPHERICAL_SURFACE band supports exactly two loops right now.`);
@@ -34719,15 +34920,15 @@ function triangulateBoundedSphericalBand(frame, radius, loops, sameSense, filePa
   const xProjection = dot3$3(rawX, axis);
   const xAxis = normalize3$2([rawX[0] - axis[0] * xProjection, rawX[1] - axis[1] * xProjection, rawX[2] - axis[2] * xProjection], context);
   const yAxis = cross3$4(axis, xAxis);
-  const loopAngle = (point2, center) => {
-    const local = sub3$1(point2, center);
+  const loopAngle = (point2, center2) => {
+    const local = sub3$1(point2, center2);
     return Math.atan2(dot3$3(local, yAxis), dot3$3(local, xAxis));
   };
-  const rotateLoop = (loop, center, targetAngle) => {
+  const rotateLoop = (loop, center2, targetAngle) => {
     let bestIndex = 0;
     let bestDistance = Number.POSITIVE_INFINITY;
     for (let index2 = 0; index2 < loop.length; index2 += 1) {
-      const distance = angleDistance(loopAngle(loop[index2], center), targetAngle);
+      const distance = angleDistance(loopAngle(loop[index2], center2), targetAngle);
       if (distance < bestDistance) {
         bestDistance = distance;
         bestIndex = index2;
@@ -34771,14 +34972,14 @@ function triangulateBoundedSphericalBand(frame, radius, loops, sameSense, filePa
   return orientCenteredTriangles(triangles, frame.origin, sameSense);
 }
 function orientBridgeTriangles(triangles, aCenter, bCenter, sameSense) {
-  const center = [(aCenter[0] + bCenter[0]) / 2, (aCenter[1] + bCenter[1]) / 2, (aCenter[2] + bCenter[2]) / 2];
+  const center2 = [(aCenter[0] + bCenter[0]) / 2, (aCenter[1] + bCenter[1]) / 2, (aCenter[2] + bCenter[2]) / 2];
   const sample = triangles[0];
   const mid = [
     (sample[0][0] + sample[1][0] + sample[2][0]) / 3,
     (sample[0][1] + sample[1][1] + sample[2][1]) / 3,
     (sample[0][2] + sample[1][2] + sample[2][2]) / 3
   ];
-  const outward = [mid[0] - center[0], mid[1] - center[1], mid[2] - center[2]];
+  const outward = [mid[0] - center2[0], mid[1] - center2[1], mid[2] - center2[2]];
   const normal2 = cross3$4(
     [sample[1][0] - sample[0][0], sample[1][1] - sample[0][1], sample[1][2] - sample[0][2]],
     [sample[2][0] - sample[0][0], sample[2][1] - sample[0][1], sample[2][2] - sample[0][2]]
@@ -36286,18 +36487,18 @@ function circleFootprintFromProfile(plan) {
   if (plan.kind !== "circle") return null;
   const radius = Math.abs(plan.radius);
   if (!finitePositive(radius)) return null;
-  const center = transformProfilePointThrough([0, 0], plan.transforms);
+  const center2 = transformProfilePointThrough([0, 0], plan.transforms);
   const xPoint = transformProfilePointThrough([1, 0], plan.transforms);
   const yPoint = transformProfilePointThrough([0, 1], plan.transforms);
-  const xAxis = [xPoint[0] - center[0], xPoint[1] - center[1]];
-  const yAxis = [yPoint[0] - center[0], yPoint[1] - center[1]];
+  const xAxis = [xPoint[0] - center2[0], xPoint[1] - center2[1]];
+  const yAxis = [yPoint[0] - center2[0], yPoint[1] - center2[1]];
   const xScale = Math.hypot(xAxis[0], xAxis[1]);
   const yScale = Math.hypot(yAxis[0], yAxis[1]);
   const dot2 = xAxis[0] * yAxis[0] + xAxis[1] * yAxis[1];
   if (!finitePositive(xScale) || !finitePositive(yScale)) return null;
   if (Math.abs(xScale - yScale) > EPS || Math.abs(dot2) > EPS * xScale * yScale) return null;
   return {
-    center,
+    center: center2,
     radius: radius * xScale,
     segments: plan.segments
   };
@@ -36856,19 +37057,19 @@ function explicitGeometrySurface(geometry, face) {
     }
   }
   if ("AnalyticSphere" in geometry) {
-    const center = geometry.AnalyticSphere.center;
+    const center2 = geometry.AnalyticSphere.center;
     const radius = geometry.AnalyticSphere.radius;
-    if (isVec3(center) && isFiniteNumber(radius) && radius > 0) {
-      return { kind: "sphere", center, radius };
+    if (isVec3(center2) && isFiniteNumber(radius) && radius > 0) {
+      return { kind: "sphere", center: center2, radius };
     }
   }
   if ("AnalyticTorus" in geometry) {
-    const center = geometry.AnalyticTorus.center;
+    const center2 = geometry.AnalyticTorus.center;
     const axis = geometry.AnalyticTorus.axis;
     const majorRadius = geometry.AnalyticTorus.major_radius;
     const minorRadius = geometry.AnalyticTorus.minor_radius;
-    if (isVec3(center) && isVec3(axis) && isFiniteNumber(majorRadius) && isFiniteNumber(minorRadius) && majorRadius > 0 && minorRadius > 0) {
-      return { kind: "torus", center, axis: normalizeVec3(axis), majorRadius, minorRadius };
+    if (isVec3(center2) && isVec3(axis) && isFiniteNumber(majorRadius) && isFiniteNumber(minorRadius) && majorRadius > 0 && minorRadius > 0) {
+      return { kind: "torus", center: center2, axis: normalizeVec3(axis), majorRadius, minorRadius };
     }
   }
   if ("NurbsPatch" in geometry) {
@@ -36962,13 +37163,13 @@ function explicitGeometrySurface(geometry, face) {
 function explicitEdgeCurve(geometry, faceName) {
   var _a3, _b3, _c2, _d2, _e2;
   if (!geometry) return void 0;
-  const center = (_a3 = geometry.CircularArc) == null ? void 0 : _a3.center;
+  const center2 = (_a3 = geometry.CircularArc) == null ? void 0 : _a3.center;
   const axis = (_b3 = geometry.CircularArc) == null ? void 0 : _b3.axis;
   const radius = (_c2 = geometry.CircularArc) == null ? void 0 : _c2.radius;
-  if (center !== void 0 && axis !== void 0 && radius !== void 0 && isVec3(center) && isVec3(axis) && isFiniteNumber(radius) && radius > 0) {
+  if (center2 !== void 0 && axis !== void 0 && radius !== void 0 && isVec3(center2) && isVec3(axis) && isFiniteNumber(radius) && radius > 0) {
     return {
       kind: "circle",
-      center,
+      center: center2,
       axis: normalizeVec3(axis),
       radius,
       faceName
@@ -37485,6 +37686,7 @@ const _TruckShapeBackend = class _TruckShapeBackend {
     const payload = JSON.parse(getTruckGeometryWasm().geometry_mesh(this.getLiveHandle("getMesh()")));
     const numTri = payload.triangles.length / 3;
     const numVert = payload.positions.length / 3;
+    const cornerNormals = payload.normals && payload.normals.length === numTri * 9 ? new Float32Array(payload.normals) : void 0;
     this.resource.mesh = {
       numProp: 3,
       numTri,
@@ -37498,7 +37700,8 @@ const _TruckShapeBackend = class _TruckShapeBackend {
       runTransform: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0]),
       faceID: new Int32Array(payload.face_ids),
       faceIdNames: payload.face_id_names ?? [],
-      halfedgeTangent: new Float32Array(0)
+      halfedgeTangent: new Float32Array(0),
+      cornerNormals
     };
     return this.resource.mesh;
   }
@@ -38719,6 +38922,16 @@ function boundsInteriorOverlap(a2, b) {
   const tolerance = 1e-8;
   return Math.min(a2.max[0], b.max[0]) - Math.max(a2.min[0], b.min[0]) > tolerance && Math.min(a2.max[1], b.max[1]) - Math.max(a2.min[1], b.min[1]) > tolerance && Math.min(a2.max[2], b.max[2]) - Math.max(a2.min[2], b.min[2]) > tolerance;
 }
+function boundsFaceOrInteriorOverlap(a2, b) {
+  const tolerance = 1e-8;
+  const overlaps = [
+    Math.min(a2.max[0], b.max[0]) - Math.max(a2.min[0], b.min[0]),
+    Math.min(a2.max[1], b.max[1]) - Math.max(a2.min[1], b.min[1]),
+    Math.min(a2.max[2], b.max[2]) - Math.max(a2.min[2], b.min[2])
+  ];
+  if (overlaps.some((overlap) => overlap < -tolerance)) return false;
+  return overlaps.filter((overlap) => overlap <= tolerance).length <= 1;
+}
 function boundsFromPoints(points) {
   const first = points[0];
   if (!first) return null;
@@ -38801,16 +39014,16 @@ function shapePlanBounds(plan) {
       return null;
   }
 }
-function hasPairwiseInteriorBoundsOverlap(shapes) {
+function hasPairwiseFaceOrInteriorBoundsOverlap(shapes) {
   const bounds = shapes.map((shape) => shape.boundingBox());
   for (let i = 0; i < bounds.length; i++) {
     for (let j = i + 1; j < bounds.length; j++) {
-      if (boundsInteriorOverlap(bounds[i], bounds[j])) return true;
+      if (boundsFaceOrInteriorOverlap(bounds[i], bounds[j])) return true;
     }
   }
   return false;
 }
-function interiorOverlapComponents(shapes) {
+function faceOrInteriorOverlapComponents(shapes) {
   const bounds = shapes.map((shape) => shape.boundingBox());
   const visited = /* @__PURE__ */ new Set();
   const components = [];
@@ -38824,7 +39037,7 @@ function interiorOverlapComponents(shapes) {
       component.push(current);
       for (let next = 0; next < shapes.length; next++) {
         if (visited.has(next)) continue;
-        if (boundsInteriorOverlap(bounds[current], bounds[next])) {
+        if (boundsFaceOrInteriorOverlap(bounds[current], bounds[next])) {
           visited.add(next);
           queue.push(next);
         }
@@ -38869,10 +39082,10 @@ function lowerGenericBooleanPlan(plan) {
   let returned = null;
   try {
     if (plan.op === "union") {
-      if (!hasPairwiseInteriorBoundsOverlap(shapes)) {
+      if (!hasPairwiseFaceOrInteriorBoundsOverlap(shapes)) {
         return null;
       }
-      const components = interiorOverlapComponents(shapes);
+      const components = faceOrInteriorOverlapComponents(shapes);
       if (components.length > 1) {
         returned = lowerClusteredUnion(shapes, components);
         return returned;
@@ -39402,9 +39615,13 @@ function shapeHasClosedNativeTopology(shape) {
 function normalizeTruckShapeForBooleanInput(shape) {
   if (shapeHasClosedNativeTopology(shape)) return shape;
   if (!meshHasRawBoundaryEdges(shape.getMesh())) return shape;
-  const normalized = normalizeFacetedTruckShape(shape);
-  disposeShapeBackend(shape);
-  return normalized;
+  try {
+    const normalized = normalizeFacetedTruckShape(shape);
+    disposeShapeBackend(shape);
+    return normalized;
+  } catch {
+    return shape;
+  }
 }
 function lowerSdfPlan(plan) {
   if (getUnsupportedSdfProgramReason(plan.tree) === void 0) {
@@ -39899,8 +40116,8 @@ function resamplePolyline(points, count) {
   for (let idx = 0; idx < count; idx++) {
     const target = idx / (count - 1) * total;
     while (segment < cumulative.length - 2 && cumulative[segment + 1] < target) segment++;
-    const span = cumulative[segment + 1] - cumulative[segment];
-    const t = span > 1e-12 ? (target - cumulative[segment]) / span : 0;
+    const span2 = cumulative[segment + 1] - cumulative[segment];
+    const t = span2 > 1e-12 ? (target - cumulative[segment]) / span2 : 0;
     const a2 = points[segment];
     const b = points[segment + 1];
     out.push([a2[0] + (b[0] - a2[0]) * t, a2[1] + (b[1] - a2[1]) * t, a2[2] + (b[2] - a2[2]) * t]);
@@ -40658,12 +40875,12 @@ function transformedSphereProfile(basePlan, steps, sliceOffset) {
     transform = transform.mul(transformForShapeTransform(step));
     scale2 *= stepScale;
   }
-  const center = transform.point([0, 0, 0]);
+  const center2 = transform.point([0, 0, 0]);
   const radius = Math.abs(source.radius * scale2);
-  const sectionRadius = sliceOffset == null ? radius : Math.sqrt(Math.max(0, radius * radius - (sliceOffset - center[2]) * (sliceOffset - center[2])));
+  const sectionRadius = sliceOffset == null ? radius : Math.sqrt(Math.max(0, radius * radius - (sliceOffset - center2[2]) * (sliceOffset - center2[2])));
   if (sectionRadius <= EXACT_PROFILE_EPS) return emptyProfilePlan();
   const profile = circleProfilePlan(sectionRadius, source.segments);
-  if (!isNearlyZero(center[0]) || !isNearlyZero(center[1])) profile.transforms.push({ kind: "translate", x: center[0], y: center[1] });
+  if (!isNearlyZero(center2[0]) || !isNearlyZero(center2[1])) profile.transforms.push({ kind: "translate", x: center2[0], y: center2[1] });
   return profile;
 }
 function profileTransformsForShapeTransform(step) {
@@ -40766,20 +40983,20 @@ function sliceOffsetBeforeShapeTransforms(steps, offset) {
   }
   return sourceOffset;
 }
-function transformZSpan(span, step) {
+function transformZSpan(span2, step) {
   switch (step.kind) {
     case "translate":
-      return [span[0] + step.z, span[1] + step.z];
+      return [span2[0] + step.z, span2[1] + step.z];
     case "scale":
       if (!Number.isFinite(step.z) || isNearlyZero(step.z)) return null;
-      return [Math.min(span[0] * step.z, span[1] * step.z), Math.max(span[0] * step.z, span[1] * step.z)];
+      return [Math.min(span2[0] * step.z, span2[1] * step.z), Math.max(span2[0] * step.z, span2[1] * step.z)];
     case "rotateAround": {
       const axisLength = Math.hypot(step.axisX, step.axisY, step.axisZ);
       if (axisLength <= EXACT_PROFILE_EPS) return null;
       const axisX = step.axisX / axisLength;
       const axisY = step.axisY / axisLength;
       const axisZ = step.axisZ / axisLength;
-      return !isNearlyZero(axisX) || !isNearlyZero(axisY) || Math.abs(Math.abs(axisZ) - 1) > EXACT_PROFILE_EPS ? null : span;
+      return !isNearlyZero(axisX) || !isNearlyZero(axisY) || Math.abs(Math.abs(axisZ) - 1) > EXACT_PROFILE_EPS ? null : span2;
     }
     case "mirror": {
       const normalLength = Math.hypot(step.normalX, step.normalY, step.normalZ);
@@ -40787,14 +41004,14 @@ function transformZSpan(span, step) {
       const normalX = step.normalX / normalLength;
       const normalY = step.normalY / normalLength;
       const normalZ = step.normalZ / normalLength;
-      if (isNearlyZero(normalX) && isNearlyZero(normalY)) return [-span[1], -span[0]];
-      return isNearlyZero(normalZ) ? span : null;
+      if (isNearlyZero(normalX) && isNearlyZero(normalY)) return [-span2[1], -span2[0]];
+      return isNearlyZero(normalZ) ? span2 : null;
     }
     case "workplanePlacement": {
       const replay = workplanePlacementReplay(step.matrix);
       if (!replay) return null;
-      const z0 = replay.zScale * span[0] + replay.zTranslate;
-      const z1 = replay.zScale * span[1] + replay.zTranslate;
+      const z0 = replay.zScale * span2[0] + replay.zTranslate;
+      const z1 = replay.zScale * span2[1] + replay.zTranslate;
       return [Math.min(z0, z1), Math.max(z0, z1)];
     }
     default:
@@ -40848,14 +41065,14 @@ function transformProfilePointThroughRadial(point2, transforms) {
   return out;
 }
 function profileRadialTransformBasis(transforms) {
-  const center = transformProfilePointThroughRadial([0, 0], transforms);
+  const center2 = transformProfilePointThroughRadial([0, 0], transforms);
   const xBasis = transformProfilePointThroughRadial([1, 0], transforms);
   const yBasis = transformProfilePointThroughRadial([0, 1], transforms);
-  if (!center || !xBasis || !yBasis) return null;
+  if (!center2 || !xBasis || !yBasis) return null;
   return {
-    center,
-    xAxis: [xBasis[0] - center[0], xBasis[1] - center[1]],
-    yAxis: [yBasis[0] - center[0], yBasis[1] - center[1]]
+    center: center2,
+    xAxis: [xBasis[0] - center2[0], xBasis[1] - center2[1]],
+    yAxis: [yBasis[0] - center2[0], yBasis[1] - center2[1]]
   };
 }
 function circleRadialProjectionInterval(plan) {
@@ -41003,13 +41220,13 @@ function radialRoundedRectBoundaryMaxDistanceFromPoint(footprint, point2) {
     [-1, -1]
   ];
   for (const [sx, sy] of cornerSigns) {
-    const center = [sx * coreHalfWidth, sy * coreHalfHeight];
-    includeLocal([center[0] + sx * footprint.radius, center[1]]);
-    includeLocal([center[0], center[1] + sy * footprint.radius]);
-    const away = [center[0] - localPoint[0], center[1] - localPoint[1]];
+    const center2 = [sx * coreHalfWidth, sy * coreHalfHeight];
+    includeLocal([center2[0] + sx * footprint.radius, center2[1]]);
+    includeLocal([center2[0], center2[1] + sy * footprint.radius]);
+    const away = [center2[0] - localPoint[0], center2[1] - localPoint[1]];
     const awayLength = Math.hypot(away[0], away[1]);
     if (awayLength > EXACT_PROFILE_EPS && away[0] * sx >= -EXACT_PROFILE_EPS && away[1] * sy >= -EXACT_PROFILE_EPS) {
-      includeLocal([center[0] + away[0] / awayLength * footprint.radius, center[1] + away[1] / awayLength * footprint.radius]);
+      includeLocal([center2[0] + away[0] / awayLength * footprint.radius, center2[1] + away[1] / awayLength * footprint.radius]);
     }
   }
   return maxDistance;
@@ -41107,10 +41324,10 @@ function lineIntervalsForRect(base, tangent, halfWidth, halfHeight) {
   if (!applyAxis(base[0], tangent[0], halfWidth) || !applyAxis(base[1], tangent[1], halfHeight)) return [];
   return [[min2, max2]];
 }
-function lineIntervalsForCircle(base, tangent, center, radius) {
+function lineIntervalsForCircle(base, tangent, center2, radius) {
   if (radius < -EXACT_PROFILE_EPS) return null;
-  const dx = base[0] - center[0];
-  const dy = base[1] - center[1];
+  const dx = base[0] - center2[0];
+  const dy = base[1] - center2[1];
   const projection = dx * tangent[0] + dy * tangent[1];
   const distanceSq = dx * dx + dy * dy - projection * projection;
   const radiusSq = radius * radius;
@@ -41153,7 +41370,7 @@ function roundedRectRadialSliceIntervals(plan, y2) {
       [-coreHalfWidth, coreHalfHeight],
       [-coreHalfWidth, -coreHalfHeight]
     ];
-    for (const center of centers) include(lineIntervalsForCircle(base, tangent, center, radius));
+    for (const center2 of centers) include(lineIntervalsForCircle(base, tangent, center2, radius));
   }
   const xFunctional = [basis.xAxis[0], basis.yAxis[0]];
   const xAtBase = basis.center[0] + xFunctional[0] * base[0] + xFunctional[1] * base[1];
@@ -41288,7 +41505,7 @@ function circleProfilePlan(radius, segments) {
 }
 function annulusProfilePlan(outerRadius, innerRadius, segments) {
   const outer = Math.abs(outerRadius);
-  const inner = Math.abs(innerRadius);
+  const inner = Math.max(0, innerRadius);
   if (outer <= EXACT_PROFILE_EPS) return emptyProfilePlan();
   if (inner <= EXACT_PROFILE_EPS) return circleProfilePlan(outer, segments);
   return {
@@ -42461,9 +42678,9 @@ function expandSimpleFullRevolutionProfileFootprint(plan, distance) {
   }
 }
 function profilePlanForSimpleFullRevolutionFootprint(footprint, segments) {
-  const translate = (profile, center) => {
-    if (!isNearlyZero(center[0]) || !isNearlyZero(center[1])) {
-      profile.transforms.push({ kind: "translate", x: center[0], y: center[1] });
+  const translate = (profile, center2) => {
+    if (!isNearlyZero(center2[0]) || !isNearlyZero(center2[1])) {
+      profile.transforms.push({ kind: "translate", x: center2[0], y: center2[1] });
     }
     return profile;
   };
@@ -42481,7 +42698,7 @@ function profilePlanForSimpleFullRevolutionFootprint(footprint, segments) {
         footprint.footprint.center
       ) : null;
     case "roundedRect": {
-      const { halfWidth, halfHeight, radius, xAxis, yAxis, center } = footprint.footprint;
+      const { halfWidth, halfHeight, radius, xAxis, yAxis, center: center2 } = footprint.footprint;
       if (halfWidth <= EXACT_PROFILE_EPS || halfHeight <= EXACT_PROFILE_EPS || radius < -EXACT_PROFILE_EPS) return null;
       const profile = roundedRectProfilePlan({
         width: halfWidth * 2,
@@ -42496,7 +42713,7 @@ function profilePlanForSimpleFullRevolutionFootprint(footprint, segments) {
           m11: yAxis[1]
         })
       );
-      return translate(profile, center);
+      return translate(profile, center2);
     }
     default:
       return assertExhaustive(footprint);
@@ -43083,16 +43300,16 @@ function exactVerticalProjectionProfilePlan(plan) {
       const base = exactVerticalProjectionProfilePlan(plan.base);
       if (!base) return null;
       let profile = base.profile;
-      let span = [base.zMin, base.zMax];
+      let span2 = [base.zMin, base.zMax];
       for (const step of plan.steps) {
         const projectedTransforms = profileTransformsForShapeTransform(step);
         if (!projectedTransforms) return null;
-        const nextSpan = transformZSpan(span, step);
+        const nextSpan = transformZSpan(span2, step);
         if (!nextSpan) return null;
         profile = appendProfileTransforms(profile, projectedTransforms);
-        span = nextSpan;
+        span2 = nextSpan;
       }
-      return { profile, zMin: span[0], zMax: span[1] };
+      return { profile, zMin: span2[0], zMax: span2[1] };
     }
     default:
       return null;
@@ -43112,7 +43329,7 @@ function projectVerticalDifferenceProfilePlan(subject, clips) {
   const clipped = clips.map((clip) => ({ clip, span: clippedZSpan(subject, clip) })).filter((entry) => entry.span != null);
   if (clipped.length === 0) return cloneProfileCompilePlan(subject.profile);
   const zBreaks = [subject.zMin, subject.zMax];
-  for (const { span } of clipped) zBreaks.push(span[0], span[1]);
+  for (const { span: span2 } of clipped) zBreaks.push(span2[0], span2[1]);
   zBreaks.sort((a2, b) => a2 - b);
   const uniqueBreaks = [];
   for (const z2 of zBreaks) {
@@ -43125,7 +43342,7 @@ function projectVerticalDifferenceProfilePlan(subject, clips) {
     const zMax = uniqueBreaks[idx + 1];
     if (zMax - zMin <= EXACT_PROFILE_EPS) continue;
     const zMid = (zMin + zMax) / 2;
-    const activeClips = clipped.filter(({ span }) => offsetInRange(zMid, span[0], span[1]));
+    const activeClips = clipped.filter(({ span: span2 }) => offsetInRange(zMid, span2[0], span2[1]));
     if (activeClips.length === 0) return cloneProfileCompilePlan(subject.profile);
     slabProfiles.push({
       kind: "boolean",
@@ -44098,7 +44315,7 @@ function clusterMeshFaces(shape) {
   return clusters;
 }
 function clusterToFaceRef(cluster, name = "") {
-  const center = [
+  const center2 = [
     cluster.centroidSum[0] / cluster.count,
     cluster.centroidSum[1] / cluster.count,
     cluster.centroidSum[2] / cluster.count
@@ -44107,7 +44324,7 @@ function clusterToFaceRef(cluster, name = "") {
   return {
     name,
     normal: cluster.normal,
-    center,
+    center: center2,
     planar: true,
     uAxis: u2,
     vAxis: v
@@ -44279,7 +44496,7 @@ function representativeFaceForMembers(name, faces, query, semantic) {
   const cloned = faces.map((face) => cloneFaceRefValue(face));
   const first = cloned[0];
   const coplanar = facesAreCoplanar(cloned);
-  const center = cloned.reduce(
+  const center2 = cloned.reduce(
     (acc, face) => [acc[0] + face.center[0], acc[1] + face.center[1], acc[2] + face.center[2]],
     [0, 0, 0]
   );
@@ -44287,7 +44504,7 @@ function representativeFaceForMembers(name, faces, query, semantic) {
   const representative = {
     ...first,
     name,
-    center: [center[0] / count, center[1] / count, center[2] / count],
+    center: [center2[0] / count, center2[1] / count, center2[2] / count],
     query: cloneFaceQueryRef(query),
     planar: coplanar ? first.planar : false,
     uAxis: coplanar ? first.uAxis : void 0,
@@ -45407,10 +45624,10 @@ function resolveShapeFaceTableInternal(plan, owner) {
       if (!planeCapQuery) return table;
       const baseTable = resolveShapeFaceTable(plan.base);
       const centers = Array.from(baseTable.faces.values()).map((face) => face.center);
-      const averageCenter = centers.length > 0 ? centers.reduce((acc, center2) => [acc[0] + center2[0], acc[1] + center2[1], acc[2] + center2[2]], [0, 0, 0]).map((value) => value / centers.length) : [0, 0, plan.originOffset];
+      const averageCenter = centers.length > 0 ? centers.reduce((acc, center22) => [acc[0] + center22[0], acc[1] + center22[1], acc[2] + center22[2]], [0, 0, 0]).map((value) => value / centers.length) : [0, 0, plan.originOffset];
       const normal2 = normalizeAxis([plan.normalX, plan.normalY, plan.normalZ]);
       const planeDistance = averageCenter[0] * normal2[0] + averageCenter[1] * normal2[1] + averageCenter[2] * normal2[2] - plan.originOffset;
-      const center = [
+      const center2 = [
         averageCenter[0] - normal2[0] * planeDistance,
         averageCenter[1] - normal2[1] * planeDistance,
         averageCenter[2] - normal2[2] * planeDistance
@@ -45419,7 +45636,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
       registerFace(table, {
         name: "plane-cap",
         normal: normal2,
-        center,
+        center: center2,
         planar: true,
         uAxis: basis.u,
         vAxis: basis.v,
@@ -48319,6 +48536,99 @@ function computeSeatOverTranslation(targetFaceVertices, targetFaceNormal, selfMe
     sampleCount: targetFaceVertices.length
   };
 }
+const UV_ANCHORS = ["top", "bottom", "front", "back", "left", "right"];
+new Set(UV_ANCHORS);
+const FACE_FRAME = {
+  front: { u: 0, v: 2 },
+  // -y face: u→x, v→z
+  back: { u: 0, v: 2 },
+  // +y face
+  left: { u: 1, v: 2 },
+  // -x face: u→y, v→z
+  right: { u: 1, v: 2 },
+  // +x face
+  top: { u: 0, v: 1 },
+  // +z face: u→x, v→y
+  bottom: { u: 0, v: 1 }
+  // -z face
+};
+const AXIS_INDEX = { x: 0, y: 1, z: 2 };
+function span(bbox, axis) {
+  return bbox.max[axis] - bbox.min[axis];
+}
+function center(bbox) {
+  return [
+    (bbox.min[0] + bbox.max[0]) / 2,
+    (bbox.min[1] + bbox.max[1]) / 2,
+    (bbox.min[2] + bbox.max[2]) / 2
+  ];
+}
+function autoFitProjection(spec, bbox) {
+  switch (spec.kind) {
+    case "flat": {
+      const frame = FACE_FRAME[spec.onto];
+      const out = { ...spec };
+      if (out.width === void 0) {
+        const w2 = span(bbox, frame.u);
+        if (w2 > 0) {
+          out.width = w2;
+          if (out.offsetU === void 0) out.offsetU = bbox.min[frame.u];
+        }
+      }
+      if (out.height === void 0) {
+        const h = span(bbox, frame.v);
+        if (h > 0) {
+          out.height = h;
+          if (out.offsetV === void 0) out.offsetV = bbox.min[frame.v];
+        }
+      }
+      return out;
+    }
+    case "box": {
+      const out = { ...spec };
+      if (out.size === void 0) {
+        const sx = span(bbox, 0);
+        const sy = span(bbox, 1);
+        const sz = span(bbox, 2);
+        if (sx > 0 && sy > 0 && sz > 0) out.size = [sx, sy, sz];
+      }
+      if (out.origin === void 0) out.origin = center(bbox);
+      return out;
+    }
+    case "cylinder": {
+      const axis = AXIS_INDEX[spec.axis];
+      const out = { ...spec };
+      if (out.height === void 0) {
+        const h = span(bbox, axis);
+        if (h > 0) {
+          out.height = h;
+          if (out.offsetV === void 0) out.offsetV = bbox.min[axis];
+        }
+      }
+      if (out.origin === void 0) out.origin = center(bbox);
+      return out;
+    }
+    case "sphere": {
+      const out = { ...spec };
+      if (out.origin === void 0) out.origin = center(bbox);
+      if (out.radius === void 0) {
+        const c2 = center(bbox);
+        const radius = Math.max(
+          bbox.max[0] - c2[0],
+          bbox.max[1] - c2[1],
+          bbox.max[2] - c2[2]
+        );
+        if (radius > 0) out.radius = radius;
+      }
+      return out;
+    }
+    default:
+      throw new Error(`autoFitProjection: unknown projection kind "${spec.kind}"`);
+  }
+}
+function isImageHandle(value) {
+  return typeof value === "object" && value !== null && value.__forgeImage === true;
+}
 const _shapeDimensions = /* @__PURE__ */ new WeakMap();
 let _shapeDimensionCounter = 0;
 function nextShapeDimensionId() {
@@ -48691,8 +49001,8 @@ function mergeShapeSourceSpans(sources, target) {
       records = /* @__PURE__ */ new Map();
       _shapeSourceSpans.set(target, records);
     }
-    for (const [key2, span] of sourceRecords) {
-      if (!records.has(key2)) records.set(key2, span);
+    for (const [key2, span2] of sourceRecords) {
+      if (!records.has(key2)) records.set(key2, span2);
     }
   }
 }
@@ -49098,7 +49408,7 @@ function annotateTruckPrimitiveAnalyticFaces(plan, topology) {
       const radiusTop = (source.radiusTop ?? source.radius) * distanceScale;
       const origin = transform.point(signedHeight >= 0 ? [0, 0, 0] : [0, 0, signedHeight]);
       const sidePointRadius = (Math.abs(radiusBottom) + Math.abs(radiusTop)) / 2;
-      const center = transform.point([sidePointRadius / distanceScale, 0, signedHeight / 2]);
+      const center2 = transform.point([sidePointRadius / distanceScale, 0, signedHeight / 2]);
       const normal2 = transformedUnitAxis(transform, [1, 0, 0]) ?? [1, 0, 0];
       const surface = sameScalar(radiusBottom, radiusTop) ? { kind: "cylinder", origin, axis, radius: radiusBottom, height } : { kind: "cone", origin, axis, radiusBottom, radiusTop, height };
       for (const [name, face] of faces) {
@@ -49109,7 +49419,7 @@ function annotateTruckPrimitiveAnalyticFaces(plan, topology) {
       upsertAnalyticFace(faces, {
         name: "side",
         normal: normal2,
-        center,
+        center: center2,
         planar: false,
         surface
       });
@@ -49119,8 +49429,8 @@ function annotateTruckPrimitiveAnalyticFaces(plan, topology) {
       if (distanceScale === null) return;
       const normal2 = transformedUnitAxis(transform, [1, 0, 0]) ?? [1, 0, 0];
       const radius = source.radius * distanceScale;
-      const center = transform.point([0, 0, 0]);
-      const surface = { kind: "sphere", center, radius };
+      const center2 = transform.point([0, 0, 0]);
+      const surface = { kind: "sphere", center: center2, radius };
       for (const [name, face] of faces) {
         if (name === "surface" || /^north-\d+$/.test(name) || /^band-\d+-\d+$/.test(name) || /^south-\d+$/.test(name)) {
           faces.set(name, { ...face, surface: cloneFaceSurface(surface) ?? surface });
@@ -49140,10 +49450,10 @@ function annotateTruckPrimitiveAnalyticFaces(plan, topology) {
       const axis = transformedUnitAxis(transform, [0, 0, 1]);
       const normal2 = transformedUnitAxis(transform, [1, 0, 0]) ?? [1, 0, 0];
       if (!axis) return;
-      const center = transform.point([0, 0, 0]);
+      const center2 = transform.point([0, 0, 0]);
       const surface = {
         kind: "torus",
-        center,
+        center: center2,
         axis,
         majorRadius: source.majorRadius * distanceScale,
         minorRadius: source.minorRadius * distanceScale
@@ -49318,7 +49628,7 @@ function addCompileAliasesToTopology(plan, topology) {
       ["top-rim", [radiusTop, 0, source.height], [0, radiusTop, source.height], [0, 0, source.height], radiusTop, [0, 0, 1]],
       ["bottom-rim", [source.radius, 0, 0], [0, source.radius, 0], [0, 0, 0], source.radius, [0, 0, -1]]
     ];
-    for (const [name, start, end, center, radius, axis] of semanticEdges2) {
+    for (const [name, start, end, center2, radius, axis] of semanticEdges2) {
       if (topology.edges.has(name)) continue;
       const faceName = name === "top-rim" ? "top" : "bottom";
       topology.edges.set(name, {
@@ -49333,7 +49643,7 @@ function addCompileAliasesToTopology(plan, topology) {
         },
         curve: {
           kind: "circle",
-          center,
+          center: center2,
           axis,
           radius,
           faceName
@@ -49527,6 +49837,7 @@ function withBaseDimensions(base, out) {
   if (baseTopo) _shapeTopology.set(out, cloneTopology(baseTopo));
   const baseLabels = cloneFaceLabelMap(_shapeFaceLabels.get(base));
   if (baseLabels) _shapeFaceLabels.set(out, baseLabels);
+  if (base.materialProps) out.materialProps = { ...base.materialProps };
   copyShapeReferenceMetadata(base, out);
   copyShapeSourceSpans(base, out);
   return setShapeCompilePlanInternal(out, getShapeCompilePlanInternal(base));
@@ -49615,6 +49926,30 @@ function createOwnedTopologyRewritePlan(plan, operation2, buildPropagation) {
   const owner = createShapeQueryOwner(operation2);
   return wrapShapeCompilePlanWithQueryOwner(attachTopologyRewritePropagation(plan, buildPropagation(owner)), owner);
 }
+const KNOWN_PROJECTION_KINDS = /* @__PURE__ */ new Set(["flat", "cylinder", "sphere", "box"]);
+function validateProjectionFinite(spec) {
+  switch (spec.kind) {
+    case "flat":
+      if (spec.width !== void 0) requireFiniteNumber(spec.width, "wrapTexture() flat width");
+      if (spec.height !== void 0) requireFiniteNumber(spec.height, "wrapTexture() flat height");
+      if (spec.offsetU !== void 0) requireFiniteNumber(spec.offsetU, "wrapTexture() flat offsetU");
+      if (spec.offsetV !== void 0) requireFiniteNumber(spec.offsetV, "wrapTexture() flat offsetV");
+      break;
+    case "box":
+      if (spec.size !== void 0) requireFiniteVec3$1(spec.size, "wrapTexture() box size");
+      if (spec.origin !== void 0) requireFiniteVec3$1(spec.origin, "wrapTexture() box origin");
+      break;
+    case "cylinder":
+      if (spec.height !== void 0) requireFiniteNumber(spec.height, "wrapTexture() cylinder height");
+      if (spec.offsetV !== void 0) requireFiniteNumber(spec.offsetV, "wrapTexture() cylinder offsetV");
+      if (spec.origin !== void 0) requireFiniteVec3$1(spec.origin, "wrapTexture() cylinder origin");
+      break;
+    case "sphere":
+      if (spec.origin !== void 0) requireFiniteVec3$1(spec.origin, "wrapTexture() sphere origin");
+      if (spec.radius !== void 0) requireFiniteNumber(spec.radius, "wrapTexture() sphere radius");
+      break;
+  }
+}
 function parseReferencePath(path) {
   const trimmed = path.trim();
   if (!trimmed) throw new Error("Shape.ref() requires a non-empty path.");
@@ -49960,7 +50295,7 @@ class Shape {
    *
    * Use `.color()` to set the base diffuse color; `.material()` controls how that color behaves
    * under light (metalness, roughness, clearcoat) and can add emissive glow independent of
-   * lighting. Emissive glow pairs naturally with the `postProcessing.bloom` effect in `scene()`.
+   * lighting.
    *
    * **Example**
    *
@@ -49992,6 +50327,61 @@ class Shape {
     out.materialProps = { ...this.materialProps ?? {}, ...props };
     return out;
   }
+  /**
+   * Wrap an imported bitmap image around this shape using a projection.
+   *
+   * **Details**
+   *
+   * The `image` comes from `Import.image('path.png')`; the `projection` is one of the `Wrap.*`
+   * helpers — `Wrap.flat({ onto: 'top' })` lays it flat on a face, `Wrap.aroundCylinder({ axis: 'z' })`
+   * wraps it like a can label, `Wrap.onSphere()` maps it like a globe, and `Wrap.box()` cube-maps
+   * it onto the six sides.
+   *
+   * By default the image **auto-fits** the shape — one copy across the relevant extent, so no
+   * `width`/`height`/`size` is needed (pass them only to override). The (u,v) is derived from each
+   * vertex's final world position, so the image stays glued to the surface through transforms and
+   * boolean cuts with no UV layout to maintain — apply `wrapTexture` *after* positioning the shape.
+   * Returns a new Shape; the original is unchanged.
+   *
+   * **Example**
+   *
+   * ```js
+   * const logo = Import.image('./logo.png');
+   * box(80, 80, 10).wrapTexture(logo, Wrap.flat({ onto: 'top' }));            // auto-fits the face
+   *
+   * const label = Import.image('./label.jpg');
+   * cylinder(60, 20).wrapTexture(label, Wrap.aroundCylinder({ axis: 'z' }));  // wraps the side
+   * ```
+   *
+   * @param image - An imported bitmap from `Import.image(...)`
+   * @param projection - A projection spec from `Wrap.flat` / `Wrap.aroundCylinder` / `Wrap.onSphere` / `Wrap.box`
+   * @returns A new Shape with the projected texture recorded in its material properties
+   * @category Materials
+   */
+  wrapTexture(image, projection) {
+    if (!isImageHandle(image)) {
+      throw new Error("wrapTexture() expects an image from Import.image(...) as its first argument");
+    }
+    if (!projection || typeof projection !== "object" || !KNOWN_PROJECTION_KINDS.has(projection.kind)) {
+      throw new Error(
+        `wrapTexture() expects a projection from Wrap.flat / Wrap.aroundCylinder / Wrap.onSphere / Wrap.box, got ${JSON.stringify(projection == null ? void 0 : projection.kind)}`
+      );
+    }
+    const bbox = this.boundingBox();
+    const filled = autoFitProjection(projection, bbox);
+    validateProjectionFinite(filled);
+    const out = this.clone();
+    out.materialProps = {
+      ...this.materialProps ?? {},
+      texture: {
+        image: image.dataUri,
+        projection: filled,
+        imageWidth: image.width,
+        imageHeight: image.height
+      }
+    };
+    return out;
+  }
   /** Return a new Shape wrapper for explicit duplication in scripts. */
   clone() {
     const out = withCopiedDimensions(this, new Shape(getShapeRuntimeBackendInternal(this).clone(), this.colorHex));
@@ -50519,12 +50909,12 @@ class Shape {
   scale(v) {
     const scale2 = requireNonZeroFiniteScale3(v, "Shape.scale() scale");
     const bb = this.boundingBox();
-    const center = [
+    const center2 = [
       (bb.min[0] + bb.max[0]) / 2,
       (bb.min[1] + bb.max[1]) / 2,
       (bb.min[2] + bb.max[2]) / 2
     ];
-    return this.scaleAround(center, scale2);
+    return this.scaleAround(center2, scale2);
   }
   /** Scale the shape uniformly or per-axis from an explicit pivot point. */
   scaleAround(pivot, v) {
@@ -50558,12 +50948,12 @@ class Shape {
   /** Mirror across a plane through the shape's bounding box center, defined by its normal vector. */
   mirror(normal2) {
     const bb = this.boundingBox();
-    const center = [
+    const center2 = [
       (bb.min[0] + bb.max[0]) / 2,
       (bb.min[1] + bb.max[1]) / 2,
       (bb.min[2] + bb.max[2]) / 2
     ];
-    return this.mirrorThrough(center, normal2);
+    return this.mirrorThrough(center2, normal2);
   }
   /** Mirror across a plane through an explicit point, defined by its normal vector. */
   mirrorThrough(point2, normal2) {
@@ -51323,7 +51713,8 @@ class FrozenShapeBackend {
       edgePositions: this._data.geometryEdgePositions,
       triangleFaceIds: this._data.geometryTriangleFaceIds,
       faceIdNames: this._data.geometryFaceIdNames,
-      hasSmoothNormals: this._data.hasSmoothNormals ?? false
+      hasSmoothNormals: this._data.hasSmoothNormals ?? false,
+      uvs: this._data.geometryUvs
     };
   }
   getMeshReconstructionData() {
@@ -51493,9 +51884,18 @@ class FrozenShape extends Shape {
 const EDGE_THRESHOLD_DOT = Math.cos(Math.PI / 180);
 const SMOOTH_THRESHOLD_DOT = Math.cos(30 * Math.PI / 180);
 function computeGeometryArrays(mesh, options = {}) {
-  const { numProp, numTri: triCount, triVerts, vertProperties, vertNormals } = mesh;
+  const { numProp, numTri: triCount, triVerts, vertProperties, vertNormals, cornerNormals } = mesh;
+  if (numProp !== NUM_PROP_POSITION_ONLY && numProp !== NUM_PROP_WITH_NORMAL && numProp !== NUM_PROP_WITH_UV) {
+    throw new Error(
+      `computeGeometryArrays: illegal vertProperties numProp ${numProp}. Only ${NUM_PROP_POSITION_ONLY} (position), ${NUM_PROP_WITH_NORMAL} (position+normal), and ${NUM_PROP_WITH_UV} (position+normal+uv) are valid; ${numProp} (e.g. a truncated uv channel) is not.`
+    );
+  }
+  const hasStoredNormals = numProp === NUM_PROP_WITH_NORMAL || numProp === NUM_PROP_WITH_UV;
+  const hasStoredUvs = numProp === NUM_PROP_WITH_UV;
+  const useCornerNormals = !!cornerNormals && cornerNormals.length === triCount * 9;
   const positions = new Float32Array(triCount * 9);
   const normals = new Float32Array(triCount * 9);
+  const uvs = hasStoredUvs ? new Float32Array(triCount * 6) : void 0;
   const faceNx = new Float32Array(triCount);
   const faceNy = new Float32Array(triCount);
   const faceNz = new Float32Array(triCount);
@@ -51525,7 +51925,18 @@ function computeGeometryArrays(mesh, options = {}) {
     positions[o + 6] = cx;
     positions[o + 7] = cy;
     positions[o + 8] = cz;
-    if (vertNormals) {
+    if (uvs) {
+      const u2 = t * 6;
+      uvs[u2] = vertProperties[i0 * numProp + UV_OFFSET];
+      uvs[u2 + 1] = vertProperties[i0 * numProp + UV_OFFSET + 1];
+      uvs[u2 + 2] = vertProperties[i1 * numProp + UV_OFFSET];
+      uvs[u2 + 3] = vertProperties[i1 * numProp + UV_OFFSET + 1];
+      uvs[u2 + 4] = vertProperties[i2 * numProp + UV_OFFSET];
+      uvs[u2 + 5] = vertProperties[i2 * numProp + UV_OFFSET + 1];
+    }
+    if (useCornerNormals) {
+      for (let k2 = 0; k2 < 9; k2++) normals[o + k2] = cornerNormals[o + k2];
+    } else if (vertNormals) {
       normals[o] = vertNormals[i0 * 3];
       normals[o + 1] = vertNormals[i0 * 3 + 1];
       normals[o + 2] = vertNormals[i0 * 3 + 2];
@@ -51535,13 +51946,13 @@ function computeGeometryArrays(mesh, options = {}) {
       normals[o + 6] = vertNormals[i2 * 3];
       normals[o + 7] = vertNormals[i2 * 3 + 1];
       normals[o + 8] = vertNormals[i2 * 3 + 2];
-    } else if (numProp >= 6) {
+    } else if (hasStoredNormals) {
       const corners = [i0, i1, i2];
       for (let v = 0; v < 3; v++) {
         const base = corners[v] * numProp;
-        const nx = vertProperties[base + 3];
-        const ny = vertProperties[base + 4];
-        const nz = vertProperties[base + 5];
+        const nx = vertProperties[base + NORMAL_OFFSET];
+        const ny = vertProperties[base + NORMAL_OFFSET + 1];
+        const nz = vertProperties[base + NORMAL_OFFSET + 2];
         const oc = o + v * 3;
         if (nx * nx + ny * ny + nz * nz > 1e-12) {
           normals[oc] = nx;
@@ -51568,7 +51979,7 @@ function computeGeometryArrays(mesh, options = {}) {
     faceNy[t] = fny;
     faceNz[t] = fnz;
   }
-  if (!vertNormals && numProp < 6 && triCount > 0) {
+  if (!useCornerNormals && !vertNormals && !hasStoredNormals && triCount > 0) {
     computeAutoSmoothNormals(
       triVerts,
       vertProperties,
@@ -51587,7 +51998,8 @@ function computeGeometryArrays(mesh, options = {}) {
     positions,
     normals,
     edgePositions,
-    hasSmoothNormals: triCount > 0
+    hasSmoothNormals: triCount > 0,
+    uvs
   };
 }
 function computeAutoSmoothNormals(triVerts, vertProperties, numProp, triCount, faceNx, faceNy, faceNz, normals, mergeFromVert, mergeToVert) {
@@ -51722,10 +52134,11 @@ function attachKernelFaceMetadata(geometry, triangleFaceIds, faceIdNames) {
 }
 function shapeToGeometry(shape) {
   if (shape instanceof FrozenShape) {
-    const { positions, normals, edgePositions, triangleFaceIds, faceIdNames, hasSmoothNormals } = shape.getPrecomputedGeometry();
+    const { positions, normals, edgePositions, triangleFaceIds, faceIdNames, hasSmoothNormals, uvs } = shape.getPrecomputedGeometry();
     const solid = new BufferGeometry();
     solid.setAttribute("position", new BufferAttribute(positions, 3));
     solid.setAttribute("normal", new BufferAttribute(normals, 3));
+    if (uvs) solid.setAttribute("uv", new BufferAttribute(uvs, 2));
     attachKernelFaceMetadata(solid, triangleFaceIds, faceIdNames);
     const edges = new BufferGeometry();
     edges.setAttribute("position", new BufferAttribute(edgePositions, 3));
@@ -51748,18 +52161,20 @@ function shapeToGeometryFallback(shape) {
   } catch {
     mesh = shape.getMesh();
   }
-  const { positions, normals, edgePositions, hasSmoothNormals } = computeGeometryArrays({
+  const { positions, normals, edgePositions, hasSmoothNormals, uvs } = computeGeometryArrays({
     numProp: mesh.numProp,
     numTri: mesh.numTri,
     triVerts: mesh.triVerts,
     vertProperties: mesh.vertProperties,
     mergeFromVert: mesh.mergeFromVert,
     mergeToVert: mesh.mergeToVert,
-    vertNormals
+    vertNormals,
+    cornerNormals: mesh.cornerNormals && mesh.cornerNormals.length === mesh.numTri * 9 ? mesh.cornerNormals : void 0
   });
   const solid = new BufferGeometry();
   solid.setAttribute("position", new BufferAttribute(positions, 3));
   solid.setAttribute("normal", new BufferAttribute(normals, 3));
+  if (uvs) solid.setAttribute("uv", new BufferAttribute(uvs, 2));
   attachKernelFaceMetadata(solid, mesh.faceID, mesh.faceIdNames);
   const edges = new BufferGeometry();
   edges.setAttribute("position", new BufferAttribute(edgePositions, 3));