forgecad 0.10.5 → 0.11.0

package/dist/assets/{inspectWorker-UXMxlcR8.js → inspectWorker-Cuby2qfT.js}

@@ -4149,8 +4149,8 @@ class Vector3 {
    * @param {Vector3} normal - The (normalized) normal vector.
    * @return {Vector3} A reference to this vector.
    */
-  reflect(normal) {
-    return this.sub(_vector$c.copy(normal).multiplyScalar(2 * this.dot(normal)));
+  reflect(normal2) {
+    return this.sub(_vector$c.copy(normal2).multiplyScalar(2 * this.dot(normal2)));
   }
   /**
    * Returns the angle between the given vector and this instance in radians.
@@ -5492,29 +5492,29 @@ class Ray {
     _edge2.subVectors(c2, a2);
     _normal$1.crossVectors(_edge1, _edge2);
     let DdN = this.direction.dot(_normal$1);
-    let sign;
+    let sign2;
     if (DdN > 0) {
       if (backfaceCulling) return null;
-      sign = 1;
+      sign2 = 1;
     } else if (DdN < 0) {
-      sign = -1;
+      sign2 = -1;
       DdN = -DdN;
     } else {
       return null;
     }
     _diff.subVectors(this.origin, a2);
-    const DdQxE2 = sign * this.direction.dot(_edge2.crossVectors(_diff, _edge2));
+    const DdQxE2 = sign2 * this.direction.dot(_edge2.crossVectors(_diff, _edge2));
     if (DdQxE2 < 0) {
       return null;
     }
-    const DdE1xQ = sign * this.direction.dot(_edge1.cross(_diff));
+    const DdE1xQ = sign2 * this.direction.dot(_edge1.cross(_diff));
     if (DdE1xQ < 0) {
       return null;
     }
     if (DdQxE2 + DdE1xQ > DdN) {
       return null;
     }
-    const QdN = -sign * _diff.dot(_normal$1);
+    const QdN = -sign2 * _diff.dot(_normal$1);
     if (QdN < 0) {
       return null;
     }
@@ -10116,11 +10116,11 @@ class BufferGeometry extends EventDispatcher {
       position.applyMatrix4(matrix);
       position.needsUpdate = true;
     }
-    const normal = this.attributes.normal;
-    if (normal !== void 0) {
+    const normal2 = this.attributes.normal;
+    if (normal2 !== void 0) {
       const normalMatrix = new Matrix3().getNormalMatrix(matrix);
-      normal.applyNormalMatrix(normalMatrix);
-      normal.needsUpdate = true;
+      normal2.applyNormalMatrix(normalMatrix);
+      normal2.needsUpdate = true;
     }
     const tangent = this.attributes.tangent;
     if (tangent !== void 0) {
@@ -10833,7 +10833,7 @@ class Mesh extends Object3D {
    * @param {Raycaster} raycaster - The raycaster.
    * @param {Array<Object>} intersects - The target array that holds the intersection points.
    */
-  raycast(raycaster, intersects) {
+  raycast(raycaster, intersects2) {
     const geometry = this.geometry;
     const material = this.material;
     const matrixWorld = this.matrixWorld;
@@ -10851,9 +10851,9 @@ class Mesh extends Object3D {
     if (geometry.boundingBox !== null) {
       if (_ray$3.intersectsBox(geometry.boundingBox) === false) return;
     }
-    this._computeIntersections(raycaster, intersects, _ray$3);
+    this._computeIntersections(raycaster, intersects2, _ray$3);
   }
-  _computeIntersections(raycaster, intersects, rayLocalSpace) {
+  _computeIntersections(raycaster, intersects2, rayLocalSpace) {
     let intersection2;
     const geometry = this.geometry;
     const material = this.material;
@@ -10861,7 +10861,7 @@ class Mesh extends Object3D {
     const position = geometry.attributes.position;
     const uv = geometry.attributes.uv;
     const uv1 = geometry.attributes.uv1;
-    const normal = geometry.attributes.normal;
+    const normal2 = geometry.attributes.normal;
     const groups = geometry.groups;
     const drawRange = geometry.drawRange;
     if (index2 !== null) {
@@ -10875,11 +10875,11 @@ class Mesh extends Object3D {
             const a2 = index2.getX(j);
             const b = index2.getX(j + 1);
             const c2 = index2.getX(j + 2);
-            intersection2 = checkGeometryIntersection(this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal, a2, b, c2);
+            intersection2 = checkGeometryIntersection(this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal2, a2, b, c2);
             if (intersection2) {
               intersection2.faceIndex = Math.floor(j / 3);
               intersection2.face.materialIndex = group.materialIndex;
-              intersects.push(intersection2);
+              intersects2.push(intersection2);
             }
           }
         }
@@ -10890,10 +10890,10 @@ class Mesh extends Object3D {
           const a2 = index2.getX(i);
           const b = index2.getX(i + 1);
           const c2 = index2.getX(i + 2);
-          intersection2 = checkGeometryIntersection(this, material, raycaster, rayLocalSpace, uv, uv1, normal, a2, b, c2);
+          intersection2 = checkGeometryIntersection(this, material, raycaster, rayLocalSpace, uv, uv1, normal2, a2, b, c2);
           if (intersection2) {
             intersection2.faceIndex = Math.floor(i / 3);
-            intersects.push(intersection2);
+            intersects2.push(intersection2);
           }
         }
       }
@@ -10908,11 +10908,11 @@ class Mesh extends Object3D {
             const a2 = j;
             const b = j + 1;
             const c2 = j + 2;
-            intersection2 = checkGeometryIntersection(this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal, a2, b, c2);
+            intersection2 = checkGeometryIntersection(this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal2, a2, b, c2);
             if (intersection2) {
               intersection2.faceIndex = Math.floor(j / 3);
               intersection2.face.materialIndex = group.materialIndex;
-              intersects.push(intersection2);
+              intersects2.push(intersection2);
             }
           }
         }
@@ -10923,10 +10923,10 @@ class Mesh extends Object3D {
           const a2 = i;
           const b = i + 1;
           const c2 = i + 2;
-          intersection2 = checkGeometryIntersection(this, material, raycaster, rayLocalSpace, uv, uv1, normal, a2, b, c2);
+          intersection2 = checkGeometryIntersection(this, material, raycaster, rayLocalSpace, uv, uv1, normal2, a2, b, c2);
           if (intersection2) {
             intersection2.faceIndex = Math.floor(i / 3);
-            intersects.push(intersection2);
+            intersects2.push(intersection2);
           }
         }
       }
@@ -10951,7 +10951,7 @@ function checkIntersection$1(object, material, raycaster, ray2, pA, pB, pC, poin
     object
   };
 }
-function checkGeometryIntersection(object, material, raycaster, ray2, uv, uv1, normal, a2, b, c2) {
+function checkGeometryIntersection(object, material, raycaster, ray2, uv, uv1, normal2, a2, b, c2) {
   object.getVertexPosition(a2, _vA$1);
   object.getVertexPosition(b, _vB$1);
   object.getVertexPosition(c2, _vC$1);
@@ -10965,8 +10965,8 @@ function checkGeometryIntersection(object, material, raycaster, ray2, uv, uv1, n
     if (uv1) {
       intersection2.uv1 = Triangle.getInterpolatedAttribute(uv1, a2, b, c2, barycoord, new Vector2());
     }
-    if (normal) {
-      intersection2.normal = Triangle.getInterpolatedAttribute(normal, a2, b, c2, barycoord, new Vector3());
+    if (normal2) {
+      intersection2.normal = Triangle.getInterpolatedAttribute(normal2, a2, b, c2, barycoord, new Vector3());
       if (intersection2.normal.dot(ray2.direction) > 0) {
         intersection2.normal.multiplyScalar(-1);
       }
@@ -11020,9 +11020,9 @@ class Plane {
    * @param {Vector3} [normal=(1,0,0)] - A unit length vector defining the normal of the plane.
    * @param {number} [constant=0] - The signed distance from the origin to the plane.
    */
-  constructor(normal = new Vector3(1, 0, 0), constant = 0) {
+  constructor(normal2 = new Vector3(1, 0, 0), constant = 0) {
     this.isPlane = true;
-    this.normal = normal;
+    this.normal = normal2;
     this.constant = constant;
   }
   /**
@@ -11032,8 +11032,8 @@ class Plane {
    * @param {number} constant - The constant.
    * @return {Plane} A reference to this plane.
    */
-  set(normal, constant) {
-    this.normal.copy(normal);
+  set(normal2, constant) {
+    this.normal.copy(normal2);
     this.constant = constant;
     return this;
   }
@@ -11060,8 +11060,8 @@ class Plane {
    * @param {Vector3} point - A coplanar point.
    * @return {Plane} A reference to this plane.
    */
-  setFromNormalAndCoplanarPoint(normal, point2) {
-    this.normal.copy(normal);
+  setFromNormalAndCoplanarPoint(normal2, point2) {
+    this.normal.copy(normal2);
     this.constant = -point2.dot(this.normal);
     return this;
   }
@@ -11076,8 +11076,8 @@ class Plane {
    * @return {Plane} A reference to this plane.
    */
   setFromCoplanarPoints(a2, b, c2) {
-    const normal = _vector1.subVectors(c2, b).cross(_vector2.subVectors(a2, b)).normalize();
-    this.setFromNormalAndCoplanarPoint(normal, a2);
+    const normal2 = _vector1.subVectors(c2, b).cross(_vector2.subVectors(a2, b)).normalize();
+    this.setFromNormalAndCoplanarPoint(normal2, a2);
     return this;
   }
   /**
@@ -11218,8 +11218,8 @@ class Plane {
   applyMatrix4(matrix, optionalNormalMatrix) {
     const normalMatrix = optionalNormalMatrix || _normalMatrix.getNormalMatrix(matrix);
     const referencePoint = this.coplanarPoint(_vector1).applyMatrix4(matrix);
-    const normal = this.normal.applyMatrix3(normalMatrix).normalize();
-    this.constant = -referencePoint.dot(normal);
+    const normal2 = this.normal.applyMatrix3(normalMatrix).normalize();
+    this.constant = -referencePoint.dot(normal2);
     return this;
   }
   /**
@@ -12224,7 +12224,7 @@ class BatchedMesh extends Mesh {
       copyArrayContents(oldGeometry.attributes[key2].array, geometry.attributes[key2].array);
     }
   }
-  raycast(raycaster, intersects) {
+  raycast(raycaster, intersects2) {
     const instanceInfo = this._instanceInfo;
     const geometryInfoList = this._geometryInfo;
     const matrixWorld = this.matrixWorld;
@@ -12253,7 +12253,7 @@ class BatchedMesh extends Mesh {
         const intersect2 = _batchIntersects$1[j];
         intersect2.object = this;
         intersect2.batchId = i;
-        intersects.push(intersect2);
+        intersects2.push(intersect2);
       }
       _batchIntersects$1.length = 0;
     }
@@ -12389,6 +12389,502 @@ class BatchedMesh extends Mesh {
     this.onBeforeRender(renderer, null, shadowCamera, geometry, depthMaterial);
   }
 }
+function earcut(data, holeIndices, dim = 2) {
+  const hasHoles = holeIndices && holeIndices.length;
+  const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+  let outerNode = linkedList(data, 0, outerLen, dim, true);
+  const triangles = [];
+  if (!outerNode || outerNode.next === outerNode.prev) return triangles;
+  let minX, minY, invSize;
+  if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+  if (data.length > 80 * dim) {
+    minX = Infinity;
+    minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (let i = dim; i < outerLen; i += dim) {
+      const x2 = data[i];
+      const y2 = data[i + 1];
+      if (x2 < minX) minX = x2;
+      if (y2 < minY) minY = y2;
+      if (x2 > maxX) maxX = x2;
+      if (y2 > maxY) maxY = y2;
+    }
+    invSize = Math.max(maxX - minX, maxY - minY);
+    invSize = invSize !== 0 ? 32767 / invSize : 0;
+  }
+  earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+  return triangles;
+}
+function linkedList(data, start, end, dim, clockwise) {
+  let last;
+  if (clockwise === signedArea$4(data, start, end, dim) > 0) {
+    for (let i = start; i < end; i += dim) last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+  } else {
+    for (let i = end - dim; i >= start; i -= dim) last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+  }
+  if (last && equals(last, last.next)) {
+    removeNode(last);
+    last = last.next;
+  }
+  return last;
+}
+function filterPoints(start, end) {
+  if (!start) return start;
+  if (!end) end = start;
+  let p2 = start, again;
+  do {
+    again = false;
+    if (!p2.steiner && (equals(p2, p2.next) || area(p2.prev, p2, p2.next) === 0)) {
+      removeNode(p2);
+      p2 = end = p2.prev;
+      if (p2 === p2.next) break;
+      again = true;
+    } else {
+      p2 = p2.next;
+    }
+  } while (again || p2 !== end);
+  return end;
+}
+function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+  if (!ear) return;
+  if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
+  let stop = ear;
+  while (ear.prev !== ear.next) {
+    const prev = ear.prev;
+    const next = ear.next;
+    if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+      triangles.push(prev.i, ear.i, next.i);
+      removeNode(ear);
+      ear = next.next;
+      stop = next.next;
+      continue;
+    }
+    ear = next;
+    if (ear === stop) {
+      if (!pass) {
+        earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+      } else if (pass === 1) {
+        ear = cureLocalIntersections(filterPoints(ear), triangles);
+        earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+      } else if (pass === 2) {
+        splitEarcut(ear, triangles, dim, minX, minY, invSize);
+      }
+      break;
+    }
+  }
+}
+function isEar(ear) {
+  const a2 = ear.prev, b = ear, c2 = ear.next;
+  if (area(a2, b, c2) >= 0) return false;
+  const ax = a2.x, bx = b.x, cx = c2.x, ay = a2.y, by = b.y, cy = c2.y;
+  const x0 = Math.min(ax, bx, cx), y0 = Math.min(ay, by, cy), x1 = Math.max(ax, bx, cx), y1 = Math.max(ay, by, cy);
+  let p2 = c2.next;
+  while (p2 !== a2) {
+    if (p2.x >= x0 && p2.x <= x1 && p2.y >= y0 && p2.y <= y1 && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) return false;
+    p2 = p2.next;
+  }
+  return true;
+}
+function isEarHashed(ear, minX, minY, invSize) {
+  const a2 = ear.prev, b = ear, c2 = ear.next;
+  if (area(a2, b, c2) >= 0) return false;
+  const ax = a2.x, bx = b.x, cx = c2.x, ay = a2.y, by = b.y, cy = c2.y;
+  const x0 = Math.min(ax, bx, cx), y0 = Math.min(ay, by, cy), x1 = Math.max(ax, bx, cx), y1 = Math.max(ay, by, cy);
+  const minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize);
+  let p2 = ear.prevZ, n = ear.nextZ;
+  while (p2 && p2.z >= minZ && n && n.z <= maxZ) {
+    if (p2.x >= x0 && p2.x <= x1 && p2.y >= y0 && p2.y <= y1 && p2 !== a2 && p2 !== c2 && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) return false;
+    p2 = p2.prevZ;
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a2 && n !== c2 && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+    n = n.nextZ;
+  }
+  while (p2 && p2.z >= minZ) {
+    if (p2.x >= x0 && p2.x <= x1 && p2.y >= y0 && p2.y <= y1 && p2 !== a2 && p2 !== c2 && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) return false;
+    p2 = p2.prevZ;
+  }
+  while (n && n.z <= maxZ) {
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a2 && n !== c2 && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+    n = n.nextZ;
+  }
+  return true;
+}
+function cureLocalIntersections(start, triangles) {
+  let p2 = start;
+  do {
+    const a2 = p2.prev, b = p2.next.next;
+    if (!equals(a2, b) && intersects(a2, p2, p2.next, b) && locallyInside(a2, b) && locallyInside(b, a2)) {
+      triangles.push(a2.i, p2.i, b.i);
+      removeNode(p2);
+      removeNode(p2.next);
+      p2 = start = b;
+    }
+    p2 = p2.next;
+  } while (p2 !== start);
+  return filterPoints(p2);
+}
+function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+  let a2 = start;
+  do {
+    let b = a2.next.next;
+    while (b !== a2.prev) {
+      if (a2.i !== b.i && isValidDiagonal(a2, b)) {
+        let c2 = splitPolygon(a2, b);
+        a2 = filterPoints(a2, a2.next);
+        c2 = filterPoints(c2, c2.next);
+        earcutLinked(a2, triangles, dim, minX, minY, invSize, 0);
+        earcutLinked(c2, triangles, dim, minX, minY, invSize, 0);
+        return;
+      }
+      b = b.next;
+    }
+    a2 = a2.next;
+  } while (a2 !== start);
+}
+function eliminateHoles(data, holeIndices, outerNode, dim) {
+  const queue = [];
+  for (let i = 0, len2 = holeIndices.length; i < len2; i++) {
+    const start = holeIndices[i] * dim;
+    const end = i < len2 - 1 ? holeIndices[i + 1] * dim : data.length;
+    const list = linkedList(data, start, end, dim, false);
+    if (list === list.next) list.steiner = true;
+    queue.push(getLeftmost(list));
+  }
+  queue.sort(compareXYSlope);
+  for (let i = 0; i < queue.length; i++) {
+    outerNode = eliminateHole(queue[i], outerNode);
+  }
+  return outerNode;
+}
+function compareXYSlope(a2, b) {
+  let result = a2.x - b.x;
+  if (result === 0) {
+    result = a2.y - b.y;
+    if (result === 0) {
+      const aSlope = (a2.next.y - a2.y) / (a2.next.x - a2.x);
+      const bSlope = (b.next.y - b.y) / (b.next.x - b.x);
+      result = aSlope - bSlope;
+    }
+  }
+  return result;
+}
+function eliminateHole(hole, outerNode) {
+  const bridge = findHoleBridge(hole, outerNode);
+  if (!bridge) {
+    return outerNode;
+  }
+  const bridgeReverse = splitPolygon(bridge, hole);
+  filterPoints(bridgeReverse, bridgeReverse.next);
+  return filterPoints(bridge, bridge.next);
+}
+function findHoleBridge(hole, outerNode) {
+  let p2 = outerNode;
+  const hx = hole.x;
+  const hy = hole.y;
+  let qx = -Infinity;
+  let m2;
+  if (equals(hole, p2)) return p2;
+  do {
+    if (equals(hole, p2.next)) return p2.next;
+    else if (hy <= p2.y && hy >= p2.next.y && p2.next.y !== p2.y) {
+      const x2 = p2.x + (hy - p2.y) * (p2.next.x - p2.x) / (p2.next.y - p2.y);
+      if (x2 <= hx && x2 > qx) {
+        qx = x2;
+        m2 = p2.x < p2.next.x ? p2 : p2.next;
+        if (x2 === hx) return m2;
+      }
+    }
+    p2 = p2.next;
+  } while (p2 !== outerNode);
+  if (!m2) return null;
+  const stop = m2;
+  const mx = m2.x;
+  const my = m2.y;
+  let tanMin = Infinity;
+  p2 = m2;
+  do {
+    if (hx >= p2.x && p2.x >= mx && hx !== p2.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p2.x, p2.y)) {
+      const tan = Math.abs(hy - p2.y) / (hx - p2.x);
+      if (locallyInside(p2, hole) && (tan < tanMin || tan === tanMin && (p2.x > m2.x || p2.x === m2.x && sectorContainsSector(m2, p2)))) {
+        m2 = p2;
+        tanMin = tan;
+      }
+    }
+    p2 = p2.next;
+  } while (p2 !== stop);
+  return m2;
+}
+function sectorContainsSector(m2, p2) {
+  return area(m2.prev, m2, p2.prev) < 0 && area(p2.next, m2, m2.next) < 0;
+}
+function indexCurve(start, minX, minY, invSize) {
+  let p2 = start;
+  do {
+    if (p2.z === 0) p2.z = zOrder(p2.x, p2.y, minX, minY, invSize);
+    p2.prevZ = p2.prev;
+    p2.nextZ = p2.next;
+    p2 = p2.next;
+  } while (p2 !== start);
+  p2.prevZ.nextZ = null;
+  p2.prevZ = null;
+  sortLinked(p2);
+}
+function sortLinked(list) {
+  let numMerges;
+  let inSize = 1;
+  do {
+    let p2 = list;
+    let e;
+    list = null;
+    let tail = null;
+    numMerges = 0;
+    while (p2) {
+      numMerges++;
+      let q = p2;
+      let pSize = 0;
+      for (let i = 0; i < inSize; i++) {
+        pSize++;
+        q = q.nextZ;
+        if (!q) break;
+      }
+      let qSize = inSize;
+      while (pSize > 0 || qSize > 0 && q) {
+        if (pSize !== 0 && (qSize === 0 || !q || p2.z <= q.z)) {
+          e = p2;
+          p2 = p2.nextZ;
+          pSize--;
+        } else {
+          e = q;
+          q = q.nextZ;
+          qSize--;
+        }
+        if (tail) tail.nextZ = e;
+        else list = e;
+        e.prevZ = tail;
+        tail = e;
+      }
+      p2 = q;
+    }
+    tail.nextZ = null;
+    inSize *= 2;
+  } while (numMerges > 1);
+  return list;
+}
+function zOrder(x2, y2, minX, minY, invSize) {
+  x2 = (x2 - minX) * invSize | 0;
+  y2 = (y2 - minY) * invSize | 0;
+  x2 = (x2 | x2 << 8) & 16711935;
+  x2 = (x2 | x2 << 4) & 252645135;
+  x2 = (x2 | x2 << 2) & 858993459;
+  x2 = (x2 | x2 << 1) & 1431655765;
+  y2 = (y2 | y2 << 8) & 16711935;
+  y2 = (y2 | y2 << 4) & 252645135;
+  y2 = (y2 | y2 << 2) & 858993459;
+  y2 = (y2 | y2 << 1) & 1431655765;
+  return x2 | y2 << 1;
+}
+function getLeftmost(start) {
+  let p2 = start, leftmost = start;
+  do {
+    if (p2.x < leftmost.x || p2.x === leftmost.x && p2.y < leftmost.y) leftmost = p2;
+    p2 = p2.next;
+  } while (p2 !== start);
+  return leftmost;
+}
+function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+  return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+}
+function pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, px, py) {
+  return !(ax === px && ay === py) && pointInTriangle(ax, ay, bx, by, cx, cy, px, py);
+}
+function isValidDiagonal(a2, b) {
+  return a2.next.i !== b.i && a2.prev.i !== b.i && !intersectsPolygon(a2, b) && // dones't intersect other edges
+  (locallyInside(a2, b) && locallyInside(b, a2) && middleInside(a2, b) && // locally visible
+  (area(a2.prev, a2, b.prev) || area(a2, b.prev, b)) || // does not create opposite-facing sectors
+  equals(a2, b) && area(a2.prev, a2, a2.next) > 0 && area(b.prev, b, b.next) > 0);
+}
+function area(p2, q, r) {
+  return (q.y - p2.y) * (r.x - q.x) - (q.x - p2.x) * (r.y - q.y);
+}
+function equals(p1, p2) {
+  return p1.x === p2.x && p1.y === p2.y;
+}
+function intersects(p1, q1, p2, q2) {
+  const o1 = sign(area(p1, q1, p2));
+  const o2 = sign(area(p1, q1, q2));
+  const o3 = sign(area(p2, q2, p1));
+  const o4 = sign(area(p2, q2, q1));
+  if (o1 !== o2 && o3 !== o4) return true;
+  if (o1 === 0 && onSegment(p1, p2, q1)) return true;
+  if (o2 === 0 && onSegment(p1, q2, q1)) return true;
+  if (o3 === 0 && onSegment(p2, p1, q2)) return true;
+  if (o4 === 0 && onSegment(p2, q1, q2)) return true;
+  return false;
+}
+function onSegment(p2, q, r) {
+  return q.x <= Math.max(p2.x, r.x) && q.x >= Math.min(p2.x, r.x) && q.y <= Math.max(p2.y, r.y) && q.y >= Math.min(p2.y, r.y);
+}
+function sign(num) {
+  return num > 0 ? 1 : num < 0 ? -1 : 0;
+}
+function intersectsPolygon(a2, b) {
+  let p2 = a2;
+  do {
+    if (p2.i !== a2.i && p2.next.i !== a2.i && p2.i !== b.i && p2.next.i !== b.i && intersects(p2, p2.next, a2, b)) return true;
+    p2 = p2.next;
+  } while (p2 !== a2);
+  return false;
+}
+function locallyInside(a2, b) {
+  return area(a2.prev, a2, a2.next) < 0 ? area(a2, b, a2.next) >= 0 && area(a2, a2.prev, b) >= 0 : area(a2, b, a2.prev) < 0 || area(a2, a2.next, b) < 0;
+}
+function middleInside(a2, b) {
+  let p2 = a2;
+  let inside = false;
+  const px = (a2.x + b.x) / 2;
+  const py = (a2.y + b.y) / 2;
+  do {
+    if (p2.y > py !== p2.next.y > py && p2.next.y !== p2.y && px < (p2.next.x - p2.x) * (py - p2.y) / (p2.next.y - p2.y) + p2.x)
+      inside = !inside;
+    p2 = p2.next;
+  } while (p2 !== a2);
+  return inside;
+}
+function splitPolygon(a2, b) {
+  const a22 = createNode(a2.i, a2.x, a2.y), b22 = createNode(b.i, b.x, b.y), an = a2.next, bp = b.prev;
+  a2.next = b;
+  b.prev = a2;
+  a22.next = an;
+  an.prev = a22;
+  b22.next = a22;
+  a22.prev = b22;
+  bp.next = b22;
+  b22.prev = bp;
+  return b22;
+}
+function insertNode(i, x2, y2, last) {
+  const p2 = createNode(i, x2, y2);
+  if (!last) {
+    p2.prev = p2;
+    p2.next = p2;
+  } else {
+    p2.next = last.next;
+    p2.prev = last;
+    last.next.prev = p2;
+    last.next = p2;
+  }
+  return p2;
+}
+function removeNode(p2) {
+  p2.next.prev = p2.prev;
+  p2.prev.next = p2.next;
+  if (p2.prevZ) p2.prevZ.nextZ = p2.nextZ;
+  if (p2.nextZ) p2.nextZ.prevZ = p2.prevZ;
+}
+function createNode(i, x2, y2) {
+  return {
+    i,
+    // vertex index in coordinates array
+    x: x2,
+    y: y2,
+    // vertex coordinates
+    prev: null,
+    // previous and next vertex nodes in a polygon ring
+    next: null,
+    z: 0,
+    // z-order curve value
+    prevZ: null,
+    // previous and next nodes in z-order
+    nextZ: null,
+    steiner: false
+    // indicates whether this is a steiner point
+  };
+}
+function signedArea$4(data, start, end, dim) {
+  let sum2 = 0;
+  for (let i = start, j = end - dim; i < end; i += dim) {
+    sum2 += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+    j = i;
+  }
+  return sum2;
+}
+class Earcut {
+  /**
+   * Triangulates the given shape definition by returning an array of triangles.
+   *
+   * @param {Array<number>} data - An array with 2D points.
+   * @param {Array<number>} holeIndices - An array with indices defining holes.
+   * @param {number} [dim=2] - The number of coordinates per vertex in the input array.
+   * @return {Array<number>} An array representing the triangulated faces. Each face is defined by three consecutive numbers
+   * representing vertex indices.
+   */
+  static triangulate(data, holeIndices, dim = 2) {
+    return earcut(data, holeIndices, dim);
+  }
+}
+class ShapeUtils {
+  /**
+   * Calculate area of a ( 2D ) contour polygon.
+   *
+   * @param {Array<Vector2>} contour - An array of 2D points.
+   * @return {number} The area.
+   */
+  static area(contour) {
+    const n = contour.length;
+    let a2 = 0;
+    for (let p2 = n - 1, q = 0; q < n; p2 = q++) {
+      a2 += contour[p2].x * contour[q].y - contour[q].x * contour[p2].y;
+    }
+    return a2 * 0.5;
+  }
+  /**
+   * Returns `true` if the given contour uses a clockwise winding order.
+   *
+   * @param {Array<Vector2>} pts - An array of 2D points defining a polygon.
+   * @return {boolean} Whether the given contour uses a clockwise winding order or not.
+   */
+  static isClockWise(pts) {
+    return ShapeUtils.area(pts) < 0;
+  }
+  /**
+   * Triangulates the given shape definition.
+   *
+   * @param {Array<Vector2>} contour - An array of 2D points defining the contour.
+   * @param {Array<Array<Vector2>>} holes - An array that holds arrays of 2D points defining the holes.
+   * @return {Array<Array<number>>} An array that holds for each face definition an array with three indices.
+   */
+  static triangulateShape(contour, holes) {
+    const vertices = [];
+    const holeIndices = [];
+    const faces = [];
+    removeDupEndPts(contour);
+    addContour(vertices, contour);
+    let holeIndex = contour.length;
+    holes.forEach(removeDupEndPts);
+    for (let i = 0; i < holes.length; i++) {
+      holeIndices.push(holeIndex);
+      holeIndex += holes[i].length;
+      addContour(vertices, holes[i]);
+    }
+    const triangles = Earcut.triangulate(vertices, holeIndices);
+    for (let i = 0; i < triangles.length; i += 3) {
+      faces.push(triangles.slice(i, i + 3));
+    }
+    return faces;
+  }
+}
+function removeDupEndPts(points) {
+  const l = points.length;
+  if (l > 2 && points[l - 1].equals(points[0])) {
+    points.pop();
+  }
+}
+function addContour(vertices, contour) {
+  for (let i = 0; i < contour.length; i++) {
+    vertices.push(contour[i].x);
+    vertices.push(contour[i].y);
+  }
+}
 const _matrix = /* @__PURE__ */ new Matrix4();
 class Raycaster {
   /**
@@ -12489,10 +12985,10 @@ class Raycaster {
    * @param {Array<Raycaster~Intersection>} [intersects=[]] The target array that holds the result of the method.
    * @return {Array<Raycaster~Intersection>} An array holding the intersection points.
    */
-  intersectObject(object, recursive = true, intersects = []) {
-    intersect(object, this, intersects, recursive);
-    intersects.sort(ascSort);
-    return intersects;
+  intersectObject(object, recursive = true, intersects2 = []) {
+    intersect(object, this, intersects2, recursive);
+    intersects2.sort(ascSort);
+    return intersects2;
   }
   /**
    * Checks all intersection between the ray and the objects with or without
@@ -12504,27 +13000,27 @@ class Raycaster {
    * @param {Array<Raycaster~Intersection>} [intersects=[]] The target array that holds the result of the method.
    * @return {Array<Raycaster~Intersection>} An array holding the intersection points.
    */
-  intersectObjects(objects, recursive = true, intersects = []) {
+  intersectObjects(objects, recursive = true, intersects2 = []) {
     for (let i = 0, l = objects.length; i < l; i++) {
-      intersect(objects[i], this, intersects, recursive);
+      intersect(objects[i], this, intersects2, recursive);
     }
-    intersects.sort(ascSort);
-    return intersects;
+    intersects2.sort(ascSort);
+    return intersects2;
   }
 }
 function ascSort(a2, b) {
   return a2.distance - b.distance;
 }
-function intersect(object, raycaster, intersects, recursive) {
+function intersect(object, raycaster, intersects2, recursive) {
   let propagate = true;
   if (object.layers.test(raycaster.layers)) {
-    const result = object.raycast(raycaster, intersects);
+    const result = object.raycast(raycaster, intersects2);
     if (result === false) propagate = false;
   }
   if (propagate === true && recursive === true) {
     const children = object.children;
     for (let i = 0, l = children.length; i < l; i++) {
-      intersect(children[i], raycaster, intersects, true);
+      intersect(children[i], raycaster, intersects2, true);
     }
   }
 }
@@ -13100,7 +13596,7 @@ function cloneSdfNode(node) {
   }
 }
 const SHEET_METAL_EDGES = ["top", "right", "bottom", "left"];
-const EPS$3 = 1e-9;
+const EPS$4 = 1e-9;
 function isFinitePositive$1(value) {
   return Number.isFinite(value) && value > 0;
 }
@@ -13141,7 +13637,7 @@ function edgeDisplayName(edge) {
   return `sheetMetal().flange("${edge}", ...)`;
 }
 function normalizeAngle(angleDeg) {
-  return Math.abs(angleDeg) <= EPS$3 ? 0 : angleDeg;
+  return Math.abs(angleDeg) <= EPS$4 ? 0 : angleDeg;
 }
 function validateSheetMetalModel(model) {
   if (!isFinitePositive$1(model.panel.width) || !isFinitePositive$1(model.panel.height)) {
@@ -13153,7 +13649,7 @@ function validateSheetMetalModel(model) {
   if (!isFiniteNonNegative(model.bendRadius)) {
     return "sheetMetal() requires a finite non-negative bendRadius.";
   }
-  if (model.bendRadius <= EPS$3) {
+  if (model.bendRadius <= EPS$4) {
     return "sheetMetal() v1 requires a positive bendRadius so the bend region stays explicit instead of collapsing into a sharp fold.";
   }
   if (model.bendAllowance.kind !== "k-factor") {
@@ -13215,7 +13711,7 @@ function deriveSheetMetalModel(model) {
     const trimEnd = flanges.has(adjacent.end) ? model.cornerRelief.size : 0;
     const fullLength = edge === "top" || edge === "bottom" ? model.panel.width : model.panel.height;
     const span2 = fullLength - trimStart - trimEnd;
-    if (!(span2 > EPS$3)) {
+    if (!(span2 > EPS$4)) {
       throw new Error(
         `${edgeDisplayName(edge)} loses all usable span after applying the defended rectangular corner relief size ${model.cornerRelief.size}.`
       );
@@ -13245,13 +13741,13 @@ function deriveSheetMetalModel(model) {
 function isSheetMetalPlanarRegionName(name) {
   return name === "panel" || name === "flange-top" || name === "flange-right" || name === "flange-bottom" || name === "flange-left";
 }
-function transformPlacement(origin, u2, v, normal) {
+function transformPlacement(origin, u2, v, normal2) {
   return {
     workplane: {
       origin: [origin[0], origin[1], origin[2]],
       u: [u2[0], u2[1], u2[2]],
       v: [v[0], v[1], v[2]],
-      normal: [normal[0], normal[1], normal[2]],
+      normal: [normal2[0], normal2[1], normal2[2]],
       source: { kind: "face-ref", faceName: "sheet-metal-placement" }
     },
     u: 0,
@@ -13261,7 +13757,7 @@ function transformPlacement(origin, u2, v, normal) {
   };
 }
 function translatePlan(plan, x2, y2, z2) {
-  if (Math.abs(x2) <= EPS$3 && Math.abs(y2) <= EPS$3 && Math.abs(z2) <= EPS$3) return cloneShapeCompilePlan(plan);
+  if (Math.abs(x2) <= EPS$4 && Math.abs(y2) <= EPS$4 && Math.abs(z2) <= EPS$4) return cloneShapeCompilePlan(plan);
   return appendShapeCompileTransform(cloneShapeCompilePlan(plan), {
     kind: "translate",
     x: x2,
@@ -13269,9 +13765,9 @@ function translatePlan(plan, x2, y2, z2) {
     z: z2
   });
 }
-function workplanePlacedPlan(plan, origin, u2, v, normal) {
-  const placement = transformPlacement(origin, u2, v, normal);
-  const matrix = [u2[0], u2[1], u2[2], 0, v[0], v[1], v[2], 0, normal[0], normal[1], normal[2], 0, origin[0], origin[1], origin[2], 1];
+function workplanePlacedPlan(plan, origin, u2, v, normal2) {
+  const placement = transformPlacement(origin, u2, v, normal2);
+  const matrix = [u2[0], u2[1], u2[2], 0, v[0], v[1], v[2], 0, normal2[0], normal2[1], normal2[2], 0, origin[0], origin[1], origin[2], 1];
   return appendShapeCompileTransform(cloneShapeCompilePlan(plan), {
     kind: "workplanePlacement",
     matrix,
@@ -13406,11 +13902,11 @@ 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, center2, normal, 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$7(center2),
-    normal: cloneVec3$7(normal),
+    normal: cloneVec3$7(normal2),
     planar,
     uAxis: cloneFaceAxis(uAxis),
     vAxis: cloneFaceAxis(vAxis),
@@ -13761,7 +14257,7 @@ function requireNonZeroFiniteScale3(value, label) {
   }
   return scale2;
 }
-const EPS$2 = 1e-10;
+const EPS$3 = 1e-10;
 function subVec3(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
@@ -13787,7 +14283,7 @@ function projectRadial(v, axis) {
 function signedAngleAroundAxis(from, to, axis) {
   const fromLen = lengthVec3$1(from);
   const toLen = lengthVec3$1(to);
-  if (fromLen < EPS$2 || toLen < EPS$2) return 0;
+  if (fromLen < EPS$3 || toLen < EPS$3) return 0;
   const fn = scaleVec3(from, 1 / fromLen);
   const tn = scaleVec3(to, 1 / toLen);
   const sin2 = dotVec3$2(axis, crossVec3$1(fn, tn));
@@ -13808,19 +14304,19 @@ function solveRotateAroundAngle(axis, pivot, movingPoint, targetPoint, options =
   const targetDecomp = projectRadial(target, unitAxis);
   const movingRadialLen = lengthVec3$1(movingDecomp.radial);
   const targetRadialLen = lengthVec3$1(targetDecomp.radial);
-  if (movingRadialLen < EPS$2) {
-    if (mode === "line" && targetRadialLen >= EPS$2) {
+  if (movingRadialLen < EPS$3) {
+    if (mode === "line" && targetRadialLen >= EPS$3) {
       throw new Error("rotateAroundTo(...): moving point lies on the rotation axis, so line alignment is impossible");
     }
     return 0;
   }
   if (mode === "plane") {
-    if (targetRadialLen < EPS$2) {
+    if (targetRadialLen < EPS$3) {
       throw new Error("rotateAroundTo(...): target point lies on the rotation axis, so the target plane is undefined");
     }
     return signedAngleAroundAxis(movingDecomp.radial, targetDecomp.radial, unitAxis);
   }
-  if (targetRadialLen < EPS$2) {
+  if (targetRadialLen < EPS$3) {
     throw new Error("rotateAroundTo(...): target line lies on the rotation axis, but the moving point does not");
   }
   const axialTol = 1e-8 * Math.max(1, Math.abs(movingDecomp.axial), Math.abs(targetDecomp.axial));
@@ -13857,7 +14353,7 @@ function multiplyMat4(a2, b) {
 }
 function normalizeVec3$2(v) {
   const len2 = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-  if (len2 < EPS$2) throw new Error("Axis must be non-zero");
+  if (len2 < EPS$3) throw new Error("Axis must be non-zero");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function transformPoint$2(m2, p2, w2) {
@@ -13887,7 +14383,7 @@ function invertMat4(m2) {
   const b10 = a21 * a33 - a23 * a31;
   const b11 = a22 * a33 - a23 * a32;
   const det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-  if (Math.abs(det) < EPS$2) throw new Error("Transform matrix is not invertible");
+  if (Math.abs(det) < EPS$3) throw new Error("Transform matrix is not invertible");
   const invDet = 1 / det;
   out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet;
   out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * invDet;
@@ -14242,6 +14738,33 @@ function cloneSurfaceTrimLoopCompilePlan(loop) {
     samples: loop.samples
   };
 }
+function cloneThicknessFieldCompilePlan$1(plan) {
+  switch (plan.kind) {
+    case "constant":
+      return { kind: "constant", thickness: canonicalNumber(plan.thickness) };
+    case "alongU":
+    case "alongV":
+      return {
+        kind: plan.kind,
+        stations: plan.stations.map((station) => ({
+          t: canonicalNumber(station.t),
+          thickness: canonicalNumber(station.thickness)
+        })),
+        easing: plan.easing
+      };
+    case "grid":
+      return { kind: "grid", values: plan.values.map((row) => row.map(canonicalNumber)), easing: plan.easing };
+    case "nurbs":
+      return {
+        kind: "nurbs",
+        values: plan.values.map((row) => row.map(canonicalNumber)),
+        degreeU: plan.degreeU,
+        degreeV: plan.degreeV,
+        knotsU: plan.knotsU.map(canonicalNumber),
+        knotsV: plan.knotsV.map(canonicalNumber)
+      };
+  }
+}
 function cloneAnalyticSurfaceCompilePlan(surface) {
   switch (surface.kind) {
     case "plane":
@@ -15098,7 +15621,8 @@ function cloneShapeCompilePlan(plan) {
       result = {
         kind: "surfaceThicken",
         base: cloneShapeCompilePlan(plan.base),
-        thickness: canonicalNumber(plan.thickness)
+        thickness: canonicalNumber(plan.thickness),
+        thicknessField: plan.thicknessField ? cloneThicknessFieldCompilePlan$1(plan.thicknessField) : void 0
       };
       break;
     case "surfaceSolid":
@@ -15199,12 +15723,12 @@ function profilePlanFromCrossSection(cross2) {
   if (plans.length === 1) return plans[0];
   return { kind: "boolean", op: "union", profiles: plans, transforms: [] };
 }
-function buildTrimByPlaneShapeCompilePlan(base, normal, originOffset) {
-  const len2 = Math.sqrt(normal[0] * normal[0] + normal[1] * normal[1] + normal[2] * normal[2]);
+function buildTrimByPlaneShapeCompilePlan(base, normal2, originOffset) {
+  const len2 = Math.sqrt(normal2[0] * normal2[0] + normal2[1] * normal2[1] + normal2[2] * normal2[2]);
   if (len2 === 0) throw new Error("trimByPlane: normal vector must not be zero");
-  const nx = normal[0] / len2;
-  const ny = normal[1] / len2;
-  const nz = normal[2] / len2;
+  const nx = normal2[0] / len2;
+  const ny = normal2[1] / len2;
+  const nz = normal2[2] / len2;
   const adjustedOffset = originOffset / len2;
   return {
     kind: "trimByPlane",
@@ -15227,11 +15751,12 @@ function buildLoftShapeCompilePlan(profiles, heights, options) {
     edgeLabels: options.edgeLabels ? { ...options.edgeLabels } : void 0
   };
 }
-function buildSurfaceThickenShapeCompilePlan(base, thickness) {
+function buildSurfaceThickenShapeCompilePlan(base, thickness, thicknessField) {
   return {
     kind: "surfaceThicken",
     base: cloneShapeCompilePlan(base),
-    thickness: canonicalNumber(thickness)
+    thickness: canonicalNumber(thickness),
+    thicknessField: thicknessField ? cloneThicknessFieldCompilePlan$1(thicknessField) : void 0
   };
 }
 const DRAFT_TO_LOFT_EPSILON = 1e-9;
@@ -17599,13 +18124,13 @@ function sdPolylineSweep3(node, x2, y2, z2) {
   return d2;
 }
 function signedArea2D$2(loop) {
-  let area = 0;
+  let area2 = 0;
   for (let index2 = 0; index2 < loop.length; index2 += 1) {
     const [x1, y1] = loop[index2];
     const [x2, y2] = loop[(index2 + 1) % loop.length];
-    area += x1 * y2 - x2 * y1;
+    area2 += x1 * y2 - x2 * y1;
   }
-  return area * 0.5;
+  return area2 * 0.5;
 }
 function pointInLoop2D(point2, loop) {
   let inside = false;
@@ -17613,8 +18138,8 @@ function pointInLoop2D(point2, loop) {
   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 intersects = yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi + 1e-20) + xi;
-    if (intersects) inside = !inside;
+    const intersects2 = yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi + 1e-20) + xi;
+    if (intersects2) inside = !inside;
   }
   return inside;
 }
@@ -18586,13 +19111,13 @@ function sdTaperedSegment(b, x2, y2, z2, a2, end, ra, rb) {
   return b.sub(length3(b, sx, sy, sz), radius);
 }
 function signedArea2D$1(loop) {
-  let area = 0;
+  let area2 = 0;
   for (let index2 = 0; index2 < loop.length; index2 += 1) {
     const [x1, y1] = loop[index2];
     const [x2, y2] = loop[(index2 + 1) % loop.length];
-    area += x1 * y2 - x2 * y1;
+    area2 += x1 * y2 - x2 * y1;
   }
-  return area * 0.5;
+  return area2 * 0.5;
 }
 function sdProfileExtrude(b, node, x2, y2, z2) {
   const zMin = Math.min(0, node.height);
@@ -18962,6 +19487,7 @@ function deepFreezePlanData(value) {
   return value;
 }
 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;
@@ -19596,6 +20122,21 @@ function deBoor3D(controlPoints, weights, knots, degree, u2) {
   if (wSum === 0) return [0, 0, 0];
   return [wx / wSum, wy / wSum, wz / wSum];
 }
+function deBoor2D(controlPoints, weights, knots, degree, u2) {
+  const n = controlPoints.length;
+  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 = span2 - degree + j;
+    const w2 = weights[idx] * N[j];
+    wx += w2 * controlPoints[idx][0];
+    wy += w2 * controlPoints[idx][1];
+    wSum += w2;
+  }
+  if (wSum === 0) return [0, 0];
+  return [wx / wSum, wy / wSum];
+}
 function remapToKnotDomain(t, n, degree, knots) {
   const uMin = knots[degree];
   const uMax = knots[n];
@@ -19974,13 +20515,13 @@ function vec3Norm(v) {
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function signedArea2D(loop) {
-  let area = 0;
+  let area2 = 0;
   for (let index2 = 0; index2 < loop.length; index2 += 1) {
     const [x1, y1] = loop[index2];
     const [x2, y2] = loop[(index2 + 1) % loop.length];
-    area += x1 * y2 - x2 * y1;
+    area2 += x1 * y2 - x2 * y1;
   }
-  return area * 0.5;
+  return area2 * 0.5;
 }
 function buildSdfLoopEdges(pts) {
   const n = pts.length;
@@ -20606,6 +21147,9 @@ function clamp$1(value, min2, max2) {
 function dot3$4(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
+function cross3$6(a2, b) {
+  return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
+}
 function normalize3$2(v, context) {
   const length4 = Math.hypot(v[0], v[1], v[2]);
   if (length4 <= 1e-12) throw new Error(`${context} requires a non-zero vector`);
@@ -20659,24 +21203,59 @@ function inverseMat4(m2) {
   return out;
 }
 function signedArea2$1(loop) {
-  let area = 0;
+  let area2 = 0;
   for (let idx = 0; idx < loop.length; idx += 1) {
     const current = loop[idx];
     const next = loop[(idx + 1) % loop.length];
-    area += current[0] * next[1] - next[0] * current[1];
+    area2 += current[0] * next[1] - next[0] * current[1];
+  }
+  return area2 * 0.5;
+}
+function mirrorMatrixFromNormal(normal2) {
+  const n = normalize3$2(normal2, "SDF mirror transform");
+  return [
+    1 - 2 * n[0] * n[0],
+    -2 * n[1] * n[0],
+    -2 * n[2] * n[0],
+    0,
+    -2 * n[0] * n[1],
+    1 - 2 * n[1] * n[1],
+    -2 * n[2] * n[1],
+    0,
+    -2 * n[0] * n[2],
+    -2 * n[1] * n[2],
+    1 - 2 * n[2] * n[2],
+    0,
+    0,
+    0,
+    0,
+    1
+  ];
+}
+function matrixFromShapeCompileTransformStep(step) {
+  switch (step.kind) {
+    case "translate":
+      return Transform.translation(step.x, step.y, step.z).toArray();
+    case "scale":
+      return Transform.scale([step.x, step.y, step.z]).toArray();
+    case "rotateAround":
+      return Transform.rotationAxis([step.axisX, step.axisY, step.axisZ], step.degrees, [step.pivotX, step.pivotY, step.pivotZ]).toArray();
+    case "workplanePlacement":
+      return step.matrix;
+    case "mirror":
+      return mirrorMatrixFromNormal([step.normalX, step.normalY, step.normalZ]);
   }
-  return area * 0.5;
 }
 function linearDeterminant(matrix) {
   return matrix[0] * (matrix[5] * matrix[10] - matrix[9] * matrix[6]) - matrix[4] * (matrix[1] * matrix[10] - matrix[9] * matrix[2]) + matrix[8] * (matrix[1] * matrix[6] - matrix[5] * matrix[2]);
 }
-function transformNormal(matrix, normal) {
+function transformNormal(matrix, normal2) {
   const inverse = inverseMat4(matrix);
   return normalize3$2(
     [
-      inverse[0] * normal[0] + inverse[1] * normal[1] + inverse[2] * normal[2],
-      inverse[4] * normal[0] + inverse[5] * normal[1] + inverse[6] * normal[2],
-      inverse[8] * normal[0] + inverse[9] * normal[1] + inverse[10] * normal[2]
+      inverse[0] * normal2[0] + inverse[1] * normal2[1] + inverse[2] * normal2[2],
+      inverse[4] * normal2[0] + inverse[5] * normal2[1] + inverse[6] * normal2[2],
+      inverse[8] * normal2[0] + inverse[9] * normal2[1] + inverse[10] * normal2[2]
     ],
     "SDF mesh normal transform"
   );
@@ -20691,10 +21270,10 @@ function transformRuntimeMesh(mesh, matrix) {
     vertProperties[offset + 1] = point2[1];
     vertProperties[offset + 2] = point2[2];
     if (mesh.numProp >= 6) {
-      const normal = transformNormal(matrix, [vertProperties[offset + 3], vertProperties[offset + 4], vertProperties[offset + 5]]);
-      vertProperties[offset + 3] = normal[0];
-      vertProperties[offset + 4] = normal[1];
-      vertProperties[offset + 5] = normal[2];
+      const normal2 = transformNormal(matrix, [vertProperties[offset + 3], vertProperties[offset + 4], vertProperties[offset + 5]]);
+      vertProperties[offset + 3] = normal2[0];
+      vertProperties[offset + 4] = normal2[1];
+      vertProperties[offset + 5] = normal2[2];
     }
   }
   const triVerts = new Uint32Array(mesh.triVerts);
@@ -20707,6 +21286,9 @@ function transformRuntimeMesh(mesh, matrix) {
   }
   return { ...mesh, vertProperties, triVerts };
 }
+function transformRuntimeMeshSteps(mesh, steps) {
+  return steps.reduce((current, step) => transformRuntimeMesh(current, matrixFromShapeCompileTransformStep(step)), mesh);
+}
 function cloneBounds3(bounds) {
   return {
     min: [bounds.min[0], bounds.min[1], bounds.min[2]],
@@ -20809,9 +21391,9 @@ function distanceSqToTriangle(p2, tri) {
   if (vb <= 0 && d2 >= 0 && d6 <= 0) return distanceSqToSegment(p2, tri.a, tri.c);
   const va = d3 * d6 - d5 * d4;
   if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) return distanceSqToSegment(p2, tri.b, tri.c);
-  const normal = [ab[1] * ac[2] - ab[2] * ac[1], ab[2] * ac[0] - ab[0] * ac[2], ab[0] * ac[1] - ab[1] * ac[0]];
-  const normalLenSq = Math.max(dot3$4(normal, normal), 1e-20);
-  const signed = dot3$4(ap, normal);
+  const normal2 = [ab[1] * ac[2] - ab[2] * ac[1], ab[2] * ac[0] - ab[0] * ac[2], ab[0] * ac[1] - ab[1] * ac[0]];
+  const normalLenSq = Math.max(dot3$4(normal2, normal2), 1e-20);
+  const signed = dot3$4(ap, normal2);
   return signed * signed / normalLenSq;
 }
 function rayHitsTriangleX(p2, tri) {
@@ -21258,13 +21840,13 @@ function applyConcaveChamferSelectionToManifold(base, selection, size, wasm) {
   const chamfer = triangle3.extrude(span2, 0, 0, void 0, false).transform(frame);
   return wasm.Manifold.union([base, chamfer]);
 }
-const EPS$1 = 1e-8;
+const EPS$2 = 1e-8;
 function midpoint$1(start, end) {
   return [(start[0] + end[0]) * 0.5, (start[1] + end[1]) * 0.5, (start[2] + end[2]) * 0.5];
 }
 function normalize$4(v) {
   const len2 = Math.hypot(v[0], v[1], v[2]);
-  if (len2 <= EPS$1) throw new Error("Edge feature selection requires a non-zero direction vector");
+  if (len2 <= EPS$2) throw new Error("Edge feature selection requires a non-zero direction vector");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function subtract(a2, b) {
@@ -21343,7 +21925,7 @@ function rigidTransformForEdgeStep(step) {
     case "mirror": {
       const [nx0, ny0, nz0] = [step.normalX, step.normalY, step.normalZ];
       const len2 = Math.hypot(nx0, ny0, nz0);
-      if (len2 <= EPS$1) return Transform.identity();
+      if (len2 <= EPS$2) return Transform.identity();
       const nx = nx0 / len2;
       const ny = ny0 / len2;
       const nz = nz0 / len2;
@@ -21643,7 +22225,7 @@ function isRectangleProfile(points) {
     return [next[0] - point2[0], next[1] - point2[1]];
   });
   const lengths = vectors.map(([x2, y2]) => Math.hypot(x2, y2));
-  if (lengths.some((length4) => length4 <= EPS$1)) return false;
+  if (lengths.some((length4) => length4 <= EPS$2)) return false;
   const dot01 = vectors[0][0] * vectors[1][0] + vectors[0][1] * vectors[1][1];
   const dot12 = vectors[1][0] * vectors[2][0] + vectors[1][1] * vectors[2][1];
   const dot23 = vectors[2][0] * vectors[3][0] + vectors[2][1] * vectors[3][1];
@@ -22171,6 +22753,16 @@ function signedTriangleMeshVolume(triangles, vertexAt2) {
   }
   return volume6 / 6;
 }
+function trianglesToTriVerts(triangles) {
+  const triVerts = new Uint32Array(triangles.length * 3);
+  for (let triIndex = 0; triIndex < triangles.length; triIndex++) {
+    const triangle3 = triangles[triIndex];
+    triVerts[triIndex * 3] = triangle3[0];
+    triVerts[triIndex * 3 + 1] = triangle3[1];
+    triVerts[triIndex * 3 + 2] = triangle3[2];
+  }
+  return triVerts;
+}
 function triVertsToTriangles(triVerts) {
   const triangles = [];
   for (let idx = 0; idx < triVerts.length; idx += 3) {
@@ -22197,23 +22789,23 @@ function cleanZero(value) {
   return Object.is(value, -0) ? 0 : value;
 }
 function planeFrameToWorldToPlaneMatrix(frame) {
-  const { origin, u: u2, v, normal } = frame;
+  const { origin, u: u2, v, normal: normal2 } = frame;
   return [
     u2[0],
     v[0],
-    normal[0],
+    normal2[0],
     0,
     u2[1],
     v[1],
-    normal[1],
+    normal2[1],
     0,
     u2[2],
     v[2],
-    normal[2],
+    normal2[2],
     0,
     cleanZero(-(u2[0] * origin[0] + u2[1] * origin[1] + u2[2] * origin[2])),
     cleanZero(-(v[0] * origin[0] + v[1] * origin[1] + v[2] * origin[2])),
-    cleanZero(-(normal[0] * origin[0] + normal[1] * origin[1] + normal[2] * origin[2])),
+    cleanZero(-(normal2[0] * origin[0] + normal2[1] * origin[1] + normal2[2] * origin[2])),
     1
   ];
 }
@@ -22614,8 +23206,8 @@ function classifyLoops(loops) {
   const holes = [];
   for (const loop of loops) {
     if (loop.length < 3) continue;
-    const area = signedArea$3(loop);
-    if (area >= 0) {
+    const area2 = signedArea$3(loop);
+    if (area2 >= 0) {
       outers.push(loop);
     } else {
       holes.push(loop);
@@ -22665,13 +23257,13 @@ function matchLoopsAcrossProfiles(profileLoops) {
   return groups;
 }
 function signedArea$3(loop) {
-  let area = 0;
+  let area2 = 0;
   for (let i = 0; i < loop.length; i++) {
     const p1 = loop[i];
     const p2 = loop[(i + 1) % loop.length];
-    area += p1[0] * p2[1] - p2[0] * p1[1];
+    area2 += p1[0] * p2[1] - p2[0] * p1[1];
   }
-  return area * 0.5;
+  return area2 * 0.5;
 }
 function detectCorners(loop) {
   const corners = [];
@@ -22766,7 +23358,7 @@ function maxQuadDeviation(rings, heights, colA, colB) {
     const b = [rings[i][colB][0], rings[i][colB][1], heights[i]];
     const c2 = [rings[i + 1][colB][0], rings[i + 1][colB][1], heights[i + 1]];
     const d2 = [rings[i + 1][colA][0], rings[i + 1][colA][1], heights[i + 1]];
-    const n = cross3$5(sub3$1(b, a2), sub3$1(d2, a2));
+    const n = cross3$5(sub3$2(b, a2), sub3$2(d2, a2));
     const len2 = Math.hypot(n[0], n[1], n[2]);
     if (len2 < 1e-12) continue;
     const deviation = Math.abs((n[0] * (c2[0] - a2[0]) + n[1] * (c2[1] - a2[1]) + n[2] * (c2[2] - a2[2])) / len2);
@@ -23044,16 +23636,16 @@ function buildSpanRowsFromStations(stations) {
 function stationTangent(stations, t, i, j) {
   const R = stations.length;
   if (i === 0) {
-    return scale3$1(sub3$1(stations[1][j], stations[0][j]), 1 / (t[1] - t[0]));
+    return scale3$2(sub3$2(stations[1][j], stations[0][j]), 1 / (t[1] - t[0]));
   }
   if (i === R - 1) {
-    return scale3$1(sub3$1(stations[R - 1][j], stations[R - 2][j]), 1 / (t[R - 1] - t[R - 2]));
+    return scale3$2(sub3$2(stations[R - 1][j], stations[R - 2][j]), 1 / (t[R - 1] - t[R - 2]));
   }
   const hPrev = t[i] - t[i - 1];
   const hNext = t[i + 1] - t[i];
-  const dPrev = scale3$1(sub3$1(stations[i][j], stations[i - 1][j]), 1 / hPrev);
-  const dNext = scale3$1(sub3$1(stations[i + 1][j], stations[i][j]), 1 / hNext);
-  return scale3$1(add3$1(scale3$1(dPrev, hNext), scale3$1(dNext, hPrev)), 1 / (hPrev + hNext));
+  const dPrev = scale3$2(sub3$2(stations[i][j], stations[i - 1][j]), 1 / hPrev);
+  const dNext = scale3$2(sub3$2(stations[i + 1][j], stations[i][j]), 1 / hNext);
+  return scale3$2(add3$2(scale3$2(dPrev, hNext), scale3$2(dNext, hPrev)), 1 / (hPrev + hNext));
 }
 function hermite(p0, m0, p1, m1, h, u2) {
   const u22 = u2 * u2;
@@ -23080,8 +23672,8 @@ function hermite(p0, m0, p1, m1, h, u2) {
 }
 function stitchSingleLoopLoft(loops, heights, wasm, options) {
   const normalizedLoops = loops.map((loop) => {
-    const area = signedArea$3(loop);
-    return area < 0 ? [...loop].reverse() : loop;
+    const area2 = signedArea$3(loop);
+    return area2 < 0 ? [...loop].reverse() : loop;
   });
   const compatible = buildCompatibleRings(normalizedLoops, heights, options.edgeLength);
   if (!compatible) return null;
@@ -23108,12 +23700,12 @@ function stitchSingleLoopLoft(loops, heights, wasm, options) {
       const curr = points[j];
       const next = points[(j + 1) % N];
       if (cornerSet.has(j)) {
-        const nFwd = surfaceNormal(sub3$1(next, curr), tangents[j]);
-        const nBwd = surfaceNormal(sub3$1(curr, prev), tangents[j]);
+        const nFwd = surfaceNormal(sub3$2(next, curr), tangents[j]);
+        const nBwd = surfaceNormal(sub3$2(curr, prev), tangents[j]);
         fwd[j] = pushVert(curr, nFwd);
         bwd[j] = pushVert(curr, nBwd);
       } else {
-        const idx = pushVert(curr, surfaceNormal(sub3$1(next, prev), tangents[j]));
+        const idx = pushVert(curr, surfaceNormal(sub3$2(next, prev), tangents[j]));
         fwd[j] = idx;
         bwd[j] = idx;
       }
@@ -23166,8 +23758,8 @@ function stitchSingleLoopLoft(loops, heights, wasm, options) {
 }
 function stitchSingleLoopLoftOnFrames(loops, frames, wasm, options) {
   const normalizedLoops = loops.map((loop) => {
-    const area = signedArea$3(loop);
-    return area < 0 ? [...loop].reverse() : loop;
+    const area2 = signedArea$3(loop);
+    return area2 < 0 ? [...loop].reverse() : loop;
   });
   const stationDistances = cumulativeFrameDistances(frames);
   const compatible = buildCompatibleRings(normalizedLoops, stationDistances, options.edgeLength);
@@ -23196,12 +23788,12 @@ function stitchSingleLoopLoftOnFrames(loops, frames, wasm, options) {
       const curr = points[j];
       const next = points[(j + 1) % N];
       if (cornerSet.has(j)) {
-        const nFwd = surfaceNormal(sub3$1(next, curr), tangents[j]);
-        const nBwd = surfaceNormal(sub3$1(curr, prev), tangents[j]);
+        const nFwd = surfaceNormal(sub3$2(next, curr), tangents[j]);
+        const nBwd = surfaceNormal(sub3$2(curr, prev), tangents[j]);
         fwd[j] = pushVert(curr, nFwd);
         bwd[j] = pushVert(curr, nBwd);
       } else {
-        const idx = pushVert(curr, surfaceNormal(sub3$1(next, prev), tangents[j]));
+        const idx = pushVert(curr, surfaceNormal(sub3$2(next, prev), tangents[j]));
         fwd[j] = idx;
         bwd[j] = idx;
       }
@@ -23223,7 +23815,7 @@ function stitchSingleLoopLoftOnFrames(loops, frames, wasm, options) {
   }
   const bottomTris = wasm.triangulate([rings[0]]);
   const bottomBase = vertCount;
-  const bottomNormal = scale3$1(frames[0].normal, -1);
+  const bottomNormal = scale3$2(frames[0].normal, -1);
   for (const p2 of rows[0].points) pushVert(p2, bottomNormal);
   for (const tri of bottomTris) {
     const [v0, v1, v2] = Array.isArray(tri) ? tri : [tri[0], tri[1], tri[2]];
@@ -23276,13 +23868,13 @@ function surfaceNormal(chord, span2) {
   }
   return [n[0] / len2, n[1] / len2, n[2] / len2];
 }
-function sub3$1(a2, b) {
+function sub3$2(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
-function add3$1(a2, b) {
+function add3$2(a2, b) {
   return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
 }
-function scale3$1(a2, s) {
+function scale3$2(a2, s) {
   return [a2[0] * s, a2[1] * s, a2[2] * s];
 }
 function cross3$5(a2, b) {
@@ -23338,19 +23930,19 @@ const _ManifoldShapeBackend = class _ManifoldShapeBackend {
   scale(v) {
     return new _ManifoldShapeBackend(this.getLiveManifold("scale()").scale(v));
   }
-  mirror(normal) {
-    return new _ManifoldShapeBackend(this.getLiveManifold("mirror()").mirror(normal));
+  mirror(normal2) {
+    return new _ManifoldShapeBackend(this.getLiveManifold("mirror()").mirror(normal2));
   }
   split(other) {
     const [inside, outside] = this.getLiveManifold("split()").split(requireManifoldShapeBackend(other, "ShapeBackend.split()"));
     return [new _ManifoldShapeBackend(inside), new _ManifoldShapeBackend(outside)];
   }
-  splitByPlane(normal, originOffset) {
-    const [inside, outside] = this.getLiveManifold("splitByPlane()").splitByPlane(normal, originOffset);
+  splitByPlane(normal2, originOffset) {
+    const [inside, outside] = this.getLiveManifold("splitByPlane()").splitByPlane(normal2, originOffset);
     return [new _ManifoldShapeBackend(inside), new _ManifoldShapeBackend(outside)];
   }
-  trimByPlane(normal, originOffset) {
-    return new _ManifoldShapeBackend(this.getLiveManifold("trimByPlane()").trimByPlane(normal, originOffset));
+  trimByPlane(normal2, originOffset) {
+    return new _ManifoldShapeBackend(this.getLiveManifold("trimByPlane()").trimByPlane(normal2, originOffset));
   }
   simplify(tolerance) {
     return new _ManifoldShapeBackend(this.getLiveManifold("simplify()").simplify(tolerance));
@@ -23635,13 +24227,13 @@ function stitchLoopAlongPath(loop, _path, frames, wasm) {
   }
 }
 function signedArea$2(loop) {
-  let area = 0;
+  let area2 = 0;
   for (let i = 0; i < loop.length; i++) {
     const p1 = loop[i];
     const p2 = loop[(i + 1) % loop.length];
-    area += p1[0] * p2[1] - p2[0] * p1[1];
+    area2 += p1[0] * p2[1] - p2[0] * p1[1];
   }
-  return area * 0.5;
+  return area2 * 0.5;
 }
 function sub$2(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
@@ -23683,6 +24275,27 @@ function disposeWasmObject(value) {
 function disposeWasmObjects(values) {
   for (const value of values) disposeWasmObject(value);
 }
+function lowerRuntimeMeshToManifold(mesh, wasm, context) {
+  const vertexCount = mesh.numVert ?? mesh.vertProperties.length / mesh.numProp;
+  let triVerts = mesh.triVerts;
+  if (!isClosedConsistentlyWoundTriangleMesh(triVerts, vertexCount)) {
+    triVerts = trianglesToTriVerts(orientClosedTriangleMesh(triVertsToTriangles(triVerts), context));
+  }
+  if (!isClosedConsistentlyWoundTriangleMesh(triVerts, vertexCount)) {
+    throw new Error(`${context} produced an open, non-manifold, or inconsistently wound triangle mesh.`);
+  }
+  const wasmMesh = new wasm.Mesh({
+    numProp: mesh.numProp,
+    vertProperties: new Float32Array(mesh.vertProperties),
+    triVerts: new Uint32Array(triVerts)
+  });
+  try {
+    wasmMesh.merge();
+    return new wasm.Manifold(wasmMesh);
+  } finally {
+    disposeWasmObject(wasmMesh);
+  }
+}
 function nowMs$1() {
   return typeof performance !== "undefined" ? performance.now() : Date.now();
 }
@@ -23995,27 +24608,27 @@ function cross3$4(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
 function fromSlicesPlaneFrameForManifold(normalInput) {
-  const normal = normalizeVec3$1(normalInput, "Shape.fromSlices group normal");
-  const [nx, ny, nz] = normal;
+  const normal2 = normalizeVec3$1(normalInput, "Shape.fromSlices group normal");
+  const [nx, ny, nz] = normal2;
   if (Math.abs(nz) > 1 - 1e-8) {
-    return { u: [1, 0, 0], v: [0, nz > 0 ? 1 : -1, 0], normal };
+    return { u: [1, 0, 0], v: [0, nz > 0 ? 1 : -1, 0], normal: normal2 };
   }
   if (Math.abs(ny) > 1 - 1e-8) {
-    return { u: [1, 0, 0], v: [0, 0, ny > 0 ? 1 : -1], normal };
+    return { u: [1, 0, 0], v: [0, 0, ny > 0 ? 1 : -1], normal: normal2 };
   }
   if (Math.abs(nx) > 1 - 1e-8) {
-    return { u: [0, 1, 0], v: [0, 0, nx > 0 ? 1 : -1], normal };
+    return { u: [0, 1, 0], v: [0, 0, nx > 0 ? 1 : -1], normal: normal2 };
   }
   const reference = Math.abs(nx) < 0.9 ? [1, 0, 0] : [0, 1, 0];
-  const u2 = normalizeVec3$1(cross3$4(reference, normal), "Shape.fromSlices profile u axis");
-  return { u: u2, v: cross3$4(normal, u2), normal };
+  const u2 = normalizeVec3$1(cross3$4(reference, normal2), "Shape.fromSlices profile u axis");
+  return { u: u2, v: cross3$4(normal2, u2), normal: normal2 };
 }
-function fromSlicesLocalToWorldMatrixForManifold(normal) {
-  const frame = fromSlicesPlaneFrameForManifold(normal);
+function fromSlicesLocalToWorldMatrixForManifold(normal2) {
+  const frame = fromSlicesPlaneFrameForManifold(normal2);
   return Transform.from(planeFrameToWorldToPlaneMatrix({ origin: [0, 0, 0], u: frame.u, v: frame.v, normal: frame.normal })).inverse().toArray();
 }
-function transformZAlignedFromSlicesPlanForManifold(base, normal) {
-  const matrix = fromSlicesLocalToWorldMatrixForManifold(normal);
+function transformZAlignedFromSlicesPlanForManifold(base, normal2) {
+  const matrix = fromSlicesLocalToWorldMatrixForManifold(normal2);
   const isIdentity = Math.abs(matrix[0] - 1) <= OFFSET_SOLID_EPS && Math.abs(matrix[5] - 1) <= OFFSET_SOLID_EPS && Math.abs(matrix[10] - 1) <= OFFSET_SOLID_EPS && Math.abs(matrix[15] - 1) <= OFFSET_SOLID_EPS && matrix.every((value, idx) => idx === 0 || idx === 5 || idx === 10 || idx === 15 ? true : Math.abs(value) <= OFFSET_SOLID_EPS);
   if (isIdentity) return base;
   return {
@@ -24149,13 +24762,13 @@ function profilePolygonsForManifold(profile, wasm) {
   }
 }
 function signedArea2(loop) {
-  let area = 0;
+  let area2 = 0;
   for (let idx = 0; idx < loop.length; idx++) {
     const current = loop[idx];
     const next = loop[(idx + 1) % loop.length];
-    area += current[0] * next[1] - next[0] * current[1];
+    area2 += current[0] * next[1] - next[0] * current[1];
   }
-  return area * 0.5;
+  return area2 * 0.5;
 }
 function profilePolygonLoopTopologyMatches(left, right) {
   let leftOuterCount = 0;
@@ -24347,8 +24960,8 @@ function lowerShapeSweepCompilePlan(plan, wasm) {
   });
   return lowerSdfToManifold(levelSetFieldToStandardSdf3(input.sdf), input.bounds, input.edgeLength, wasm);
 }
-function buildPlaneFrame(normal) {
-  const [nx, ny, nz] = normal;
+function buildPlaneFrame(normal2) {
+  const [nx, ny, nz] = normal2;
   if (Math.abs(nz) > 1 - 1e-8) {
     const s = nz > 0 ? 1 : -1;
     return { u: [1, 0, 0], v: [0, s, 0] };
@@ -24784,8 +25397,8 @@ function edgeSegmentToSelection(segment) {
   const surfaceDirB = pickSurfaceDir(nBx, nBy);
   const projX = avgX;
   const projY = avgY;
-  const sign = convex ? -1 : 1;
-  const quadrant = [projX >= 0 ? sign : -sign, projY >= 0 ? sign : -sign];
+  const sign2 = convex ? -1 : 1;
+  const quadrant = [projX >= 0 ? sign2 : -sign2, projY >= 0 ? sign2 : -sign2];
   return {
     kind: "line-segment",
     edgeName: `mesh-edge-${segment.index}`,
@@ -25003,9 +25616,15 @@ function lowerShapeCompilePlanToManifold(plan, wasm) {
     case "surfaceFill":
     case "surfaceSew":
     case "surfaceExtend":
-    case "surfaceThicken":
     case "surfaceSolid":
       throw new Error(`Exact surfacing operations require the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
+    case "surfaceThicken":
+      if (!plan.thicknessField) throw new Error(`Exact surfacing operations require the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
+      return lowerRuntimeMeshToManifold(
+        meshFromThickenedSurfaceSheetPlan(plan.base, plan.thickness, plan.thicknessField),
+        wasm,
+        "Surface.thicken() variable thickness"
+      );
     case "importedStep":
       throw new Error(`importStep("${plan.filePath}") requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
     default:
@@ -25304,14 +25923,14 @@ function normalizeTrimPolygonForManifold(points, context) {
     }
   }
   if (deduped.length < 3) throw new Error(`${context}: trim loop requires at least 3 distinct points`);
-  let area = 0;
+  let area2 = 0;
   for (let i = 0; i < deduped.length; i++) {
     const a2 = deduped[i];
     const b = deduped[(i + 1) % deduped.length];
-    area += a2[0] * b[1] - b[0] * a2[1];
+    area2 += a2[0] * b[1] - b[0] * a2[1];
   }
-  if (Math.abs(area) <= 1e-12) throw new Error(`${context}: trim loop area is too small`);
-  if (area < 0) deduped.reverse();
+  if (Math.abs(area2) <= 1e-12) throw new Error(`${context}: trim loop area is too small`);
+  if (area2 < 0) deduped.reverse();
   return deduped;
 }
 function sampleNurbsUvTrimLoop(loop) {
@@ -25453,10 +26072,10 @@ function extractMeshFromShape(oc, shape, linearDeflection = DEFAULT_LINEAR_DEFLE
         const pt = tri.Node(i).Transformed(trsf);
         allPositions.push(pt.X(), pt.Y(), pt.Z());
         if (faceHasNormals) {
-          const normal = tri.Normal_1(i);
-          const transformedNormal = normal.Transformed(trsf);
-          const sign = reversed ? -1 : 1;
-          allNormals.push(transformedNormal.X() * sign, transformedNormal.Y() * sign, transformedNormal.Z() * sign);
+          const normal2 = tri.Normal_1(i);
+          const transformedNormal = normal2.Transformed(trsf);
+          const sign2 = reversed ? -1 : 1;
+          allNormals.push(transformedNormal.X() * sign2, transformedNormal.Y() * sign2, transformedNormal.Z() * sign2);
         } else {
           allNormals.push(0, 0, 0);
         }
@@ -25683,9 +26302,9 @@ const _OCCTShapeBackend = class _OCCTShapeBackend {
     const transformed = new oc.BRepBuilderAPI_GTransform_2(this.getLiveShape("scale()"), gtrsf, true);
     return new _OCCTShapeBackend(transformed.Shape());
   }
-  mirror(normal) {
+  mirror(normal2) {
     const oc = getOCCT();
-    const ax2 = new oc.gp_Ax2_3(new oc.gp_Pnt_3(0, 0, 0), new oc.gp_Dir_4(normal[0], normal[1], normal[2]));
+    const ax2 = new oc.gp_Ax2_3(new oc.gp_Pnt_3(0, 0, 0), new oc.gp_Dir_4(normal2[0], normal2[1], normal2[2]));
     const trsf = new oc.gp_Trsf_1();
     trsf.SetMirror_3(ax2);
     const transformed = new oc.BRepBuilderAPI_Transform_2(this.getLiveShape("mirror()"), trsf, true);
@@ -25700,13 +26319,13 @@ const _OCCTShapeBackend = class _OCCTShapeBackend {
     outside.Build(new oc.Message_ProgressRange_1());
     return [new _OCCTShapeBackend(inside.Shape()), new _OCCTShapeBackend(outside.Shape())];
   }
-  splitByPlane(normal, originOffset) {
+  splitByPlane(normal2, originOffset) {
     const oc = getOCCT();
-    const dir = new oc.gp_Dir_4(normal[0], normal[1], normal[2]);
-    const pln = new oc.gp_Pln_3(new oc.gp_Pnt_3(normal[0] * originOffset, normal[1] * originOffset, normal[2] * originOffset), dir);
+    const dir = new oc.gp_Dir_4(normal2[0], normal2[1], normal2[2]);
+    const pln = new oc.gp_Pln_3(new oc.gp_Pnt_3(normal2[0] * originOffset, normal2[1] * originOffset, normal2[2] * originOffset), dir);
     const halfSpace = new oc.BRepPrimAPI_MakeHalfSpace_1(
       new oc.BRepBuilderAPI_MakeFace_9(pln, -1e6, 1e6, -1e6, 1e6).Face(),
-      new oc.gp_Pnt_3(normal[0] * (originOffset + 1), normal[1] * (originOffset + 1), normal[2] * (originOffset + 1))
+      new oc.gp_Pnt_3(normal2[0] * (originOffset + 1), normal2[1] * (originOffset + 1), normal2[2] * (originOffset + 1))
     );
     const inside = new oc.BRepAlgoAPI_Common_3(this.getLiveShape("splitByPlane()"), halfSpace.Solid(), new oc.Message_ProgressRange_1());
     inside.Build(new oc.Message_ProgressRange_1());
@@ -25714,8 +26333,8 @@ const _OCCTShapeBackend = class _OCCTShapeBackend {
     outside.Build(new oc.Message_ProgressRange_1());
     return [new _OCCTShapeBackend(inside.Shape()), new _OCCTShapeBackend(outside.Shape())];
   }
-  trimByPlane(normal, originOffset) {
-    const [inside] = this.splitByPlane(normal, originOffset);
+  trimByPlane(normal2, originOffset) {
+    const [inside] = this.splitByPlane(normal2, originOffset);
     return inside;
   }
   boundingBox() {
@@ -25837,7 +26456,7 @@ function requireOCCTShape(backend, apiName = "requireOCCTShape()") {
   }
   throw new Error(`${apiName} requires an OCCT-backed shape.`);
 }
-function vertex(mesh, index2) {
+function vertex$2(mesh, index2) {
   const offset = index2 * mesh.numProp;
   return [mesh.vertProperties[offset], mesh.vertProperties[offset + 1], mesh.vertProperties[offset + 2]];
 }
@@ -25847,7 +26466,7 @@ function meshBounds(mesh) {
   const max2 = [-Infinity, -Infinity, -Infinity];
   const count = mesh.numVert ?? mesh.vertProperties.length / mesh.numProp;
   for (let idx = 0; idx < count; idx += 1) {
-    const point2 = vertex(mesh, idx);
+    const point2 = vertex$2(mesh, idx);
     for (let axis = 0; axis < 3; axis += 1) {
       min2[axis] = Math.min(min2[axis], point2[axis]);
       max2[axis] = Math.max(max2[axis], point2[axis]);
@@ -25858,24 +26477,24 @@ function meshBounds(mesh) {
 function meshVolume(mesh) {
   let volume = 0;
   for (let tri = 0; tri < mesh.numTri; tri += 1) {
-    const a2 = vertex(mesh, mesh.triVerts[tri * 3]);
-    const b = vertex(mesh, mesh.triVerts[tri * 3 + 1]);
-    const c2 = vertex(mesh, mesh.triVerts[tri * 3 + 2]);
+    const a2 = vertex$2(mesh, mesh.triVerts[tri * 3]);
+    const b = vertex$2(mesh, mesh.triVerts[tri * 3 + 1]);
+    const c2 = vertex$2(mesh, mesh.triVerts[tri * 3 + 2]);
     volume += (a2[0] * (b[1] * c2[2] - b[2] * c2[1]) + a2[1] * (b[2] * c2[0] - b[0] * c2[2]) + a2[2] * (b[0] * c2[1] - b[1] * c2[0])) / 6;
   }
   return Math.abs(volume);
 }
 function meshSurfaceArea(mesh) {
-  let area = 0;
+  let area2 = 0;
   for (let tri = 0; tri < mesh.numTri; tri += 1) {
-    const a2 = vertex(mesh, mesh.triVerts[tri * 3]);
-    const b = vertex(mesh, mesh.triVerts[tri * 3 + 1]);
-    const c2 = vertex(mesh, mesh.triVerts[tri * 3 + 2]);
+    const a2 = vertex$2(mesh, mesh.triVerts[tri * 3]);
+    const b = vertex$2(mesh, mesh.triVerts[tri * 3 + 1]);
+    const c2 = vertex$2(mesh, mesh.triVerts[tri * 3 + 2]);
     const ab = [b[0] - a2[0], b[1] - a2[1], b[2] - a2[2]];
     const ac = [c2[0] - a2[0], c2[1] - a2[1], c2[2] - a2[2]];
-    area += Math.hypot(ab[1] * ac[2] - ab[2] * ac[1], ab[2] * ac[0] - ab[0] * ac[2], ab[0] * ac[1] - ab[1] * ac[0]) * 0.5;
+    area2 += Math.hypot(ab[1] * ac[2] - ab[2] * ac[1], ab[2] * ac[0] - ab[0] * ac[2], ab[0] * ac[1] - ab[1] * ac[0]) * 0.5;
   }
-  return area;
+  return area2;
 }
 function meshBodyCount(mesh) {
   if (mesh.numTri === 0) return 0;
@@ -30990,11 +31609,11 @@ function requireClipper() {
       };
       ClipperLib2.JS.AreaOfPolygons = function(poly, scale2) {
         if (!scale2) scale2 = 1;
-        var area = 0;
+        var area2 = 0;
         for (var i = 0; i < poly.length; i++) {
-          area += ClipperLib2.Clipper.Area(poly[i]);
+          area2 += ClipperLib2.Clipper.Area(poly[i]);
         }
-        return area / (scale2 * scale2);
+        return area2 / (scale2 * scale2);
       };
       ClipperLib2.JS.BoundsOfPath = function(path, scale2) {
         return ClipperLib2.JS.BoundsOfPaths([path], scale2);
@@ -33082,8 +33701,8 @@ function cleanLoop$2(points) {
   return out.length >= 3 && Math.abs(signedArea2$1(out)) > 1e-12 ? out : [];
 }
 function orient(loop, ccw) {
-  const area = signedArea2$1(loop);
-  return ccw && area < 0 || !ccw && area > 0 ? [...loop].reverse() : loop.map(([x2, y2]) => [x2, y2]);
+  const area2 = signedArea2$1(loop);
+  return ccw && area2 < 0 || !ccw && area2 > 0 ? [...loop].reverse() : loop.map(([x2, y2]) => [x2, y2]);
 }
 function closeRing$2(points) {
   const ring = points.map(([x2, y2]) => [snap(x2), snap(y2)]);
@@ -33514,8 +34133,8 @@ function runtimeMeshFromReconstructionData(mesh) {
     mergeToVert: mesh.mergeToVert
   };
 }
-function mirrorMatrix$2(normal) {
-  const n = normalize3$2(normal, "SDF mirror() normal");
+function mirrorMatrix$2(normal2) {
+  const n = normalize3$2(normal2, "SDF mirror() normal");
   return [
     1 - 2 * n[0] * n[0],
     -2 * n[1] * n[0],
@@ -33623,8 +34242,8 @@ const _SdfShapeBackend = class _SdfShapeBackend {
       this.mesh ? transformRuntimeMesh(this.mesh, matrix) : null
     );
   }
-  mirror(normal) {
-    return this.transform(mirrorMatrix$2(normal));
+  mirror(normal2) {
+    return this.transform(mirrorMatrix$2(normal2));
   }
   split(other) {
     const cutter = otherAsSdf(other, this.field.edgeLength);
@@ -33646,12 +34265,12 @@ const _SdfShapeBackend = class _SdfShapeBackend {
     };
     return [new _SdfShapeBackend(inside), new _SdfShapeBackend(outside)];
   }
-  splitByPlane(normal, originOffset) {
-    return [this.trimByPlane(normal, originOffset), this.trimByPlane([-normal[0], -normal[1], -normal[2]], -originOffset)];
+  splitByPlane(normal2, originOffset) {
+    return [this.trimByPlane(normal2, originOffset), this.trimByPlane([-normal2[0], -normal2[1], -normal2[2]], -originOffset)];
   }
-  trimByPlane(normal, originOffset) {
-    const n = normalize3$2(normal, "SDF trimByPlane() normal");
-    const offset = originOffset / Math.hypot(normal[0], normal[1], normal[2]);
+  trimByPlane(normal2, originOffset) {
+    const n = normalize3$2(normal2, "SDF trimByPlane() normal");
+    const offset = originOffset / Math.hypot(normal2[0], normal2[1], normal2[2]);
     const field2 = {
       edgeLength: this.field.edgeLength,
       bounds: this.field.bounds,
@@ -33791,6 +34410,92 @@ let SdfPolygonProfileBackend = _SdfPolygonProfileBackend;
 function wrapSdfPolygonProfileBackend(polygons) {
   return new SdfPolygonProfileBackend(cloneLoops$1(polygons));
 }
+const EPS$1 = 1e-9;
+function vertex$1(mesh, index2, distance) {
+  const start = index2 * mesh.numProp;
+  const props = Array.from(mesh.vertProperties.slice(start, start + mesh.numProp));
+  return {
+    props,
+    distance: distance(props[0], props[1], props[2])
+  };
+}
+function interpolate(a2, b) {
+  const t = a2.distance / (a2.distance - b.distance);
+  const props = a2.props.map((value, index2) => value + (b.props[index2] - value) * t);
+  return { props, distance: 0 };
+}
+function clipPolygon(vertices) {
+  let output = vertices;
+  const input = output;
+  output = [];
+  for (let index2 = 0; index2 < input.length; index2 += 1) {
+    const current = input[index2];
+    const previous = input[(index2 + input.length - 1) % input.length];
+    const currentInside = current.distance >= -EPS$1;
+    const previousInside = previous.distance >= -EPS$1;
+    if (currentInside && previousInside) {
+      output.push(current);
+    } else if (currentInside && !previousInside) {
+      output.push(interpolate(previous, current), current);
+    } else if (!currentInside && previousInside) {
+      output.push(interpolate(previous, current));
+    }
+  }
+  return output;
+}
+function normalizeInterpolatedNormals(props, numProp) {
+  if (numProp < 6) return props;
+  const length4 = Math.hypot(props[3], props[4], props[5]);
+  if (length4 <= EPS$1) return props;
+  const next = [...props];
+  next[3] /= length4;
+  next[4] /= length4;
+  next[5] /= length4;
+  return next;
+}
+function keyFor(props) {
+  return props.slice(0, 3).map((value) => value.toFixed(8)).join(",");
+}
+function clipSurfaceMeshBySignedDistance(mesh, distance) {
+  const positions = [];
+  const indices = [];
+  const vertexByKey = /* @__PURE__ */ new Map();
+  const addVertex = (clipVertex) => {
+    const props = normalizeInterpolatedNormals(clipVertex.props, mesh.numProp);
+    const key2 = keyFor(props);
+    const existing = vertexByKey.get(key2);
+    if (existing !== void 0) return existing;
+    const index2 = positions.length / mesh.numProp;
+    vertexByKey.set(key2, index2);
+    positions.push(...props);
+    return index2;
+  };
+  for (let tri = 0; tri < mesh.numTri; tri += 1) {
+    const clipped = clipPolygon([
+      vertex$1(mesh, mesh.triVerts[tri * 3], distance),
+      vertex$1(mesh, mesh.triVerts[tri * 3 + 1], distance),
+      vertex$1(mesh, mesh.triVerts[tri * 3 + 2], distance)
+    ]);
+    if (clipped.length < 3) continue;
+    const first = addVertex(clipped[0]);
+    for (let index2 = 1; index2 < clipped.length - 1; index2 += 1) {
+      const b = addVertex(clipped[index2]);
+      const c2 = addVertex(clipped[index2 + 1]);
+      if (first !== b && b !== c2 && c2 !== first) indices.push(first, b, c2);
+    }
+  }
+  return {
+    numProp: mesh.numProp,
+    numVert: positions.length / mesh.numProp,
+    numTri: indices.length / 3,
+    vertProperties: new Float32Array(positions),
+    triVerts: new Uint32Array(indices)
+  };
+}
+function clipSurfaceMeshByPlane(mesh, normalInput, originOffset) {
+  const normal2 = normalize3$2(normalInput, "SDF surface mesh clip normal");
+  return clipSurfaceMeshBySignedDistance(mesh, (x2, y2, z2) => x2 * normal2[0] + y2 * normal2[1] + z2 * normal2[2] - originOffset);
+}
 const CUBE_CORNER_OFFSETS = [
   [0, 0, 0],
   [1, 0, 0],
@@ -34417,8 +35122,8 @@ function transformFaceSurface(surface, tx) {
   const scale2 = uniformDistanceScale(tx.toArray());
   switch (surface.kind) {
     case "plane": {
-      const normal = transformSurfaceAxis(tx, surface.normal);
-      return normal ? { kind: "plane", normal } : void 0;
+      const normal2 = transformSurfaceAxis(tx, surface.normal);
+      return normal2 ? { kind: "plane", normal: normal2 } : void 0;
     }
     case "cylinder": {
       if (scale2 === null) return void 0;
@@ -34548,13 +35253,13 @@ function cloneRegion$1(region) {
   };
 }
 function signedArea$1(points) {
-  let area = 0;
+  let area2 = 0;
   for (let i = 0; i < points.length; i++) {
     const [x0, y0] = points[i];
     const [x1, y1] = points[(i + 1) % points.length];
-    area += x0 * y1 - x1 * y0;
+    area2 += x0 * y1 - x1 * y0;
   }
-  return area / 2;
+  return area2 / 2;
 }
 function cleanLoop(points) {
   const cleaned = [];
@@ -34572,11 +35277,11 @@ function cleanLoop(points) {
   return cleaned.length >= 3 && Math.abs(signedArea$1(cleaned)) > 1e-10 ? cleaned : [];
 }
 function orientLoop(points, ccw) {
-  const area = signedArea$1(points);
-  if (ccw && area < 0 || !ccw && area > 0) return [...points].reverse();
+  const area2 = signedArea$1(points);
+  if (ccw && area2 < 0 || !ccw && area2 > 0) return [...points].reverse();
   return points.map(([x2, y2]) => [x2, y2]);
 }
-function pointInLoop(point2, loop) {
+function pointInLoop$1(point2, loop) {
   let inside = false;
   for (let i = 0, j = loop.length - 1; i < loop.length; j = i++) {
     const [xi, yi] = loop[i];
@@ -34602,7 +35307,7 @@ function loopsToRegions(polygons) {
   const loopRegion = /* @__PURE__ */ new Map();
   for (const loop of loops) {
     const containers = loops.filter(
-      (candidate) => candidate !== loop && Math.abs(signedArea$1(candidate)) > Math.abs(signedArea$1(loop)) && pointInLoop(loop[0], candidate)
+      (candidate) => candidate !== loop && Math.abs(signedArea$1(candidate)) > Math.abs(signedArea$1(loop)) && pointInLoop$1(loop[0], candidate)
     );
     if (containers.length % 2 === 0) {
       const region2 = { outer: orientLoop(loop, true), holes: [] };
@@ -34611,7 +35316,7 @@ function loopsToRegions(polygons) {
       continue;
     }
     const parent = containers.find(
-      (candidate) => containers.filter((other) => other !== candidate && pointInLoop(candidate[0], other)).length % 2 === 0
+      (candidate) => containers.filter((other) => other !== candidate && pointInLoop$1(candidate[0], other)).length % 2 === 0
     );
     const region = parent ? loopRegion.get(parent) : void 0;
     if (region) region.holes.push(orientLoop(loop, false));
@@ -35115,16 +35820,16 @@ function boundsCorners(bounds) {
     [maxX, maxY, maxZ]
   ];
 }
-function perpendicularAxes(normal) {
-  const seed = Math.abs(normal[2]) < 0.9 ? [0, 0, 1] : [0, 1, 0];
-  const uAxis = normalizeVec3(cross$2(seed, normal));
-  const vAxis = normalizeVec3(cross$2(normal, uAxis));
+function perpendicularAxes(normal2) {
+  const seed = Math.abs(normal2[2]) < 0.9 ? [0, 0, 1] : [0, 1, 0];
+  const uAxis = normalizeVec3(cross$2(seed, normal2));
+  const vAxis = normalizeVec3(cross$2(normal2, uAxis));
   return { uAxis, vAxis };
 }
-function createBoundedHalfSpace(bounds, normal, originOffset) {
-  const normalLength = Math.hypot(normal[0], normal[1], normal[2]);
+function createBoundedHalfSpace(bounds, normal2, originOffset) {
+  const normalLength = Math.hypot(normal2[0], normal2[1], normal2[2]);
   if (normalLength <= 1e-12) throw new Error("Truck trimByPlane() normal vector must not be zero.");
-  const n = [normal[0] / normalLength, normal[1] / normalLength, normal[2] / normalLength];
+  const n = [normal2[0] / normalLength, normal2[1] / normalLength, normal2[2] / normalLength];
   const signedOffset = originOffset / normalLength;
   const corners = boundsCorners(bounds);
   const planeOrigin = scale(n, signedOffset);
@@ -35227,13 +35932,13 @@ function explicitEdgeDisplayName(payload, explicitEdge, explicitEdgeIndex, start
   return { name: fallback, faceName: fallback };
 }
 function signedArea2d(points) {
-  let area = 0;
+  let area2 = 0;
   for (let i = 0; i < points.length; i++) {
     const [x0, y0] = points[i];
     const [x1, y1] = points[(i + 1) % points.length];
-    area += x0 * y1 - x1 * y0;
+    area2 += x0 * y1 - x1 * y0;
   }
-  return area / 2;
+  return area2 / 2;
 }
 function cleanLoop2d(points) {
   const cleaned = [];
@@ -35474,8 +36179,8 @@ const _TruckShapeBackend = class _TruckShapeBackend {
     const [sx, sy, sz] = typeof v === "number" ? [v, v, v] : v;
     return this.transform(Transform.scale([sx, sy, sz]).toArray());
   }
-  mirror(normal) {
-    const [nx0, ny0, nz0] = normal;
+  mirror(normal2) {
+    const [nx0, ny0, nz0] = normal2;
     const len2 = Math.hypot(nx0, ny0, nz0);
     if (len2 < 1e-12) return this.clone();
     const nx = nx0 / len2;
@@ -35512,20 +36217,20 @@ const _TruckShapeBackend = class _TruckShapeBackend {
       new _TruckShapeBackend(wasm.geometry_boolean(handles, "difference"))
     ];
   }
-  splitByPlane(normal, originOffset) {
-    return [this.trimByPlane(normal, originOffset), this.trimByPlane([-normal[0], -normal[1], -normal[2]], -originOffset)];
+  splitByPlane(normal2, originOffset) {
+    return [this.trimByPlane(normal2, originOffset), this.trimByPlane([-normal2[0], -normal2[1], -normal2[2]], -originOffset)];
   }
-  trimByPlane(normal, originOffset) {
+  trimByPlane(normal2, originOffset) {
     const wasm = getTruckGeometryWasm();
     const bounds = this.boundingBox();
-    const normalLength = Math.hypot(normal[0], normal[1], normal[2]);
+    const normalLength = Math.hypot(normal2[0], normal2[1], normal2[2]);
     if (normalLength <= 1e-12) throw new Error("Truck trimByPlane() normal vector must not be zero.");
-    const n = [normal[0] / normalLength, normal[1] / normalLength, normal[2] / normalLength];
+    const n = [normal2[0] / normalLength, normal2[1] / normalLength, normal2[2] / normalLength];
     const signedOffset = originOffset / normalLength;
     const distances = boundsCorners(bounds).map((corner) => dot$2(corner, n) - signedOffset);
     if (distances.every((distance) => distance >= -1e-8)) return this.clone();
     if (distances.every((distance) => distance <= 1e-8)) return new _TruckShapeBackend(wasm.geometry_create_empty());
-    const halfSpace = createBoundedHalfSpace(bounds, normal, originOffset);
+    const halfSpace = createBoundedHalfSpace(bounds, normal2, originOffset);
     try {
       return new _TruckShapeBackend(
         wasm.geometry_boolean(
@@ -35738,8 +36443,8 @@ function applyProfileTransformsToRegion(region, transforms) {
   };
 }
 function orientRingForClipper(points, ccw) {
-  const area = signedArea(points);
-  if (ccw && area < 0 || !ccw && area > 0) {
+  const area2 = signedArea(points);
+  if (ccw && area2 < 0 || !ccw && area2 > 0) {
     return [...points].reverse();
   }
   return points;
@@ -35881,12 +36586,12 @@ function openRing(ring) {
   return deduped;
 }
 function signedArea(points) {
-  let area = 0;
+  let area2 = 0;
   for (let i = 0; i < points.length; i++) {
     const next = (i + 1) % points.length;
-    area += points[i][0] * points[next][1] - points[next][0] * points[i][1];
+    area2 += points[i][0] * points[next][1] - points[next][0] * points[i][1];
   }
-  return area / 2;
+  return area2 / 2;
 }
 function regionBounds(region) {
   var _a3, _b3;
@@ -36086,7 +36791,7 @@ function dot3$2(a2, b) {
 function subtract3(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
-function localToWorldMatrix(origin, uAxis, vAxis, normal) {
+function localToWorldMatrix(origin, uAxis, vAxis, normal2) {
   return [
     uAxis[0],
     uAxis[1],
@@ -36096,9 +36801,9 @@ function localToWorldMatrix(origin, uAxis, vAxis, normal) {
     vAxis[1],
     vAxis[2],
     0,
-    normal[0],
-    normal[1],
-    normal[2],
+    normal2[0],
+    normal2[1],
+    normal2[2],
     0,
     origin[0],
     origin[1],
@@ -36227,15 +36932,15 @@ function rotateRegion(region, degrees, pivot) {
     holes: region.holes.map((hole) => hole.map((point2) => rotatePointAround(point2, degrees, pivot)))
   };
 }
-function mirrorPointAcrossLineNormal(point2, normal) {
-  const normalLengthSq = normal[0] * normal[0] + normal[1] * normal[1];
+function mirrorPointAcrossLineNormal(point2, normal2) {
+  const normalLengthSq = normal2[0] * normal2[0] + normal2[1] * normal2[1];
   if (normalLengthSq <= 1e-18) return null;
-  const signedDistanceScale = 2 * (point2[0] * normal[0] + point2[1] * normal[1]) / normalLengthSq;
-  return [point2[0] - signedDistanceScale * normal[0], point2[1] - signedDistanceScale * normal[1]];
+  const signedDistanceScale = 2 * (point2[0] * normal2[0] + point2[1] * normal2[1]) / normalLengthSq;
+  return [point2[0] - signedDistanceScale * normal2[0], point2[1] - signedDistanceScale * normal2[1]];
 }
-function mirrorRegionAcrossVerticalPlane(region, normal) {
+function mirrorRegionAcrossVerticalPlane(region, normal2) {
   const mirrorLoop = (loop) => {
-    const mirrored = loop.map((point2) => mirrorPointAcrossLineNormal(point2, normal));
+    const mirrored = loop.map((point2) => mirrorPointAcrossLineNormal(point2, normal2));
     if (mirrored.some((point2) => point2 == null)) return null;
     return mirrored.reverse();
   };
@@ -36309,9 +37014,9 @@ function applyShapeTransformToVerticalPrism(prism, step) {
     case "mirror": {
       const xyNormalLength = Math.hypot(step.normalX, step.normalY);
       if (xyNormalLength > 1e-9 && Math.abs(step.normalZ) <= 1e-9) {
-        const normal = [step.normalX, step.normalY];
-        const regions = prism.regions.map((region) => mirrorRegionAcrossVerticalPlane(region, normal));
-        const topRegions = (_d2 = prism.topRegions) == null ? void 0 : _d2.map((region) => mirrorRegionAcrossVerticalPlane(region, normal));
+        const normal2 = [step.normalX, step.normalY];
+        const regions = prism.regions.map((region) => mirrorRegionAcrossVerticalPlane(region, normal2));
+        const topRegions = (_d2 = prism.topRegions) == null ? void 0 : _d2.map((region) => mirrorRegionAcrossVerticalPlane(region, normal2));
         if (regions.some((region) => region == null) || (topRegions == null ? void 0 : topRegions.some((region) => region == null))) return null;
         return {
           regions,
@@ -37984,7 +38689,7 @@ function lowerVariableSweepPlan(plan) {
     )
   );
 }
-function resamplePolyline(points, count) {
+function resamplePolyline$1(points, count) {
   if (points.length === 0) return [];
   if (points.length === 1 || count <= 1) return [points[0]];
   const cumulative = [0];
@@ -38008,35 +38713,35 @@ function resamplePolyline(points, count) {
   }
   return out;
 }
-function sampleSurfaceCurve(path, resolution) {
+function sampleSurfaceCurve$1(path, resolution) {
   const count = Math.max(2, resolution + 1);
-  return resamplePolyline(sampleTruckSweepPath(path, count, false), count);
+  return resamplePolyline$1(sampleTruckSweepPath(path, count, false), count);
 }
-function reversePoints(points) {
+function reversePoints$1(points) {
   return [...points].reverse();
 }
-function surfaceGridForRuledPlan(plan) {
+function surfaceGridForRuledPlan$1(plan) {
   const count = Math.max(2, plan.resolution + 1);
   return [
-    resamplePolyline(sampleSurfaceCurve(plan.curveA, plan.resolution), count),
-    resamplePolyline(sampleSurfaceCurve(plan.curveB, plan.resolution), count)
+    resamplePolyline$1(sampleSurfaceCurve$1(plan.curveA, plan.resolution), count),
+    resamplePolyline$1(sampleSurfaceCurve$1(plan.curveB, plan.resolution), count)
   ];
 }
-function namedBoundaryCurve(plan, name) {
+function namedBoundaryCurve$1(plan, name) {
   var _a3;
   return ((_a3 = plan.boundaries.find((boundary) => boundary.name === name)) == null ? void 0 : _a3.curve) ?? null;
 }
-function surfaceGridForFillPlan(plan) {
-  const bottomCurve = namedBoundaryCurve(plan, "v0");
-  const rightCurve = namedBoundaryCurve(plan, "u1");
-  const topCurve = namedBoundaryCurve(plan, "v1");
-  const leftCurve = namedBoundaryCurve(plan, "u0");
+function surfaceGridForFillPlan$1(plan) {
+  const bottomCurve = namedBoundaryCurve$1(plan, "v0");
+  const rightCurve = namedBoundaryCurve$1(plan, "u1");
+  const topCurve = namedBoundaryCurve$1(plan, "v1");
+  const leftCurve = namedBoundaryCurve$1(plan, "u0");
   if (!bottomCurve || !rightCurve || !topCurve || !leftCurve || plan.boundaries.some((boundary) => boundary.support)) return null;
   const count = Math.max(2, plan.resolution + 1);
-  const bottom = sampleSurfaceCurve(bottomCurve, plan.resolution);
-  const right = sampleSurfaceCurve(rightCurve, plan.resolution);
-  const top = reversePoints(sampleSurfaceCurve(topCurve, plan.resolution));
-  const left = reversePoints(sampleSurfaceCurve(leftCurve, plan.resolution));
+  const bottom = sampleSurfaceCurve$1(bottomCurve, plan.resolution);
+  const right = sampleSurfaceCurve$1(rightCurve, plan.resolution);
+  const top = reversePoints$1(sampleSurfaceCurve$1(topCurve, plan.resolution));
+  const left = reversePoints$1(sampleSurfaceCurve$1(leftCurve, plan.resolution));
   const p00 = bottom[0];
   const p10 = bottom[bottom.length - 1];
   const p01 = top[0];
@@ -38051,62 +38756,62 @@ function surfaceGridForFillPlan(plan) {
       const topPoint = top[uIdx];
       const leftPoint = left[vIdx];
       const rightPoint = right[vIdx];
-      const bilinear = [
+      const bilinear2 = [
         (1 - u2) * (1 - v) * p00[0] + u2 * (1 - v) * p10[0] + (1 - u2) * v * p01[0] + u2 * v * p11[0],
         (1 - u2) * (1 - v) * p00[1] + u2 * (1 - v) * p10[1] + (1 - u2) * v * p01[1] + u2 * v * p11[1],
         (1 - u2) * (1 - v) * p00[2] + u2 * (1 - v) * p10[2] + (1 - u2) * v * p01[2] + u2 * v * p11[2]
       ];
       row.push([
-        (1 - v) * bottomPoint[0] + v * topPoint[0] + (1 - u2) * leftPoint[0] + u2 * rightPoint[0] - bilinear[0],
-        (1 - v) * bottomPoint[1] + v * topPoint[1] + (1 - u2) * leftPoint[1] + u2 * rightPoint[1] - bilinear[1],
-        (1 - v) * bottomPoint[2] + v * topPoint[2] + (1 - u2) * leftPoint[2] + u2 * rightPoint[2] - bilinear[2]
+        (1 - v) * bottomPoint[0] + v * topPoint[0] + (1 - u2) * leftPoint[0] + u2 * rightPoint[0] - bilinear2[0],
+        (1 - v) * bottomPoint[1] + v * topPoint[1] + (1 - u2) * leftPoint[1] + u2 * rightPoint[1] - bilinear2[1],
+        (1 - v) * bottomPoint[2] + v * topPoint[2] + (1 - u2) * leftPoint[2] + u2 * rightPoint[2] - bilinear2[2]
       ]);
     }
     grid.push(row);
   }
   return grid;
 }
-function add3(a2, b) {
+function add3$1(a2, b) {
   return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
 }
-function scale3(v, s) {
+function scale3$1(v, s) {
   return [v[0] * s, v[1] * s, v[2] * s];
 }
-function analyticYForFrame(axis, xAxis) {
+function analyticYForFrame$1(axis, xAxis) {
   return normalizedVector3(cross3$3(axis, xAxis), "analytic surface yAxis");
 }
-function radialPoint(xAxis, yAxis, u2, radius) {
-  return add3(scale3(xAxis, Math.cos(u2) * radius), scale3(yAxis, Math.sin(u2) * radius));
+function radialPoint$1(xAxis, yAxis, u2, radius) {
+  return add3$1(scale3$1(xAxis, Math.cos(u2) * radius), scale3$1(yAxis, Math.sin(u2) * radius));
 }
-function analyticSurfacePoint(plan, u2, v) {
+function analyticSurfacePoint$1(plan, u2, v) {
   switch (plan.kind) {
     case "plane":
-      return add3(add3(plan.origin, scale3(plan.uAxis, u2)), scale3(plan.vAxis, v));
+      return add3$1(add3$1(plan.origin, scale3$1(plan.uAxis, u2)), scale3$1(plan.vAxis, v));
     case "cylinder": {
-      const yAxis = analyticYForFrame(plan.axis, plan.xAxis);
-      return add3(add3(plan.origin, scale3(plan.axis, v)), radialPoint(plan.xAxis, yAxis, u2, plan.radius));
+      const yAxis = analyticYForFrame$1(plan.axis, plan.xAxis);
+      return add3$1(add3$1(plan.origin, scale3$1(plan.axis, v)), radialPoint$1(plan.xAxis, yAxis, u2, plan.radius));
     }
     case "cone": {
-      const yAxis = analyticYForFrame(plan.axis, plan.xAxis);
+      const yAxis = analyticYForFrame$1(plan.axis, plan.xAxis);
       const t = (v - plan.vMin) / (plan.vMax - plan.vMin);
       const radius = plan.radiusBottom + (plan.radiusTop - plan.radiusBottom) * t;
-      return add3(add3(plan.origin, scale3(plan.axis, v)), radialPoint(plan.xAxis, yAxis, u2, radius));
+      return add3$1(add3$1(plan.origin, scale3$1(plan.axis, v)), radialPoint$1(plan.xAxis, yAxis, u2, radius));
     }
     case "sphere": {
-      const yAxis = analyticYForFrame(plan.axis, plan.xAxis);
-      const radial = radialPoint(plan.xAxis, yAxis, u2, plan.radius * Math.cos(v));
-      return add3(add3(plan.center, radial), scale3(plan.axis, plan.radius * Math.sin(v)));
+      const yAxis = analyticYForFrame$1(plan.axis, plan.xAxis);
+      const radial = radialPoint$1(plan.xAxis, yAxis, u2, plan.radius * Math.cos(v));
+      return add3$1(add3$1(plan.center, radial), scale3$1(plan.axis, plan.radius * Math.sin(v)));
     }
     case "torus": {
-      const yAxis = analyticYForFrame(plan.axis, plan.xAxis);
-      const radial = radialPoint(plan.xAxis, yAxis, u2, plan.majorRadius + plan.minorRadius * Math.cos(v));
-      return add3(add3(plan.center, radial), scale3(plan.axis, plan.minorRadius * Math.sin(v)));
+      const yAxis = analyticYForFrame$1(plan.axis, plan.xAxis);
+      const radial = radialPoint$1(plan.xAxis, yAxis, u2, plan.majorRadius + plan.minorRadius * Math.cos(v));
+      return add3$1(add3$1(plan.center, radial), scale3$1(plan.axis, plan.minorRadius * Math.sin(v)));
     }
     default:
       return assertExhaustive(plan);
   }
 }
-function surfaceGridForAnalyticPlan(plan) {
+function surfaceGridForAnalyticPlan$1(plan) {
   if (plan.trim) return null;
   const rows = Math.max(2, plan.resolution + 1);
   const cols = Math.max(2, plan.resolution + 1);
@@ -38117,7 +38822,7 @@ function surfaceGridForAnalyticPlan(plan) {
     const row = [];
     for (let uIdx = 0; uIdx < cols; uIdx++) {
       const u2 = uMin + (uMax - uMin) * uIdx / (cols - 1);
-      row.push(analyticSurfacePoint(plan.surface, u2, v));
+      row.push(analyticSurfacePoint$1(plan.surface, u2, v));
     }
     grid.push(row);
   }
@@ -38162,11 +38867,11 @@ function surfaceGridForPlan(plan) {
       return grid;
     }
     case "analyticSurface":
-      return surfaceGridForAnalyticPlan(plan);
+      return surfaceGridForAnalyticPlan$1(plan);
     case "surfaceRuled":
-      return surfaceGridForRuledPlan(plan);
+      return surfaceGridForRuledPlan$1(plan);
     case "surfaceFill":
-      return surfaceGridForFillPlan(plan);
+      return surfaceGridForFillPlan$1(plan);
     default:
       return null;
   }
@@ -38218,10 +38923,10 @@ function triangleNormal(vertices, triangle3) {
   const c2 = vertices[triangle3[2]];
   const ab = [b[0] - a2[0], b[1] - a2[1], b[2] - a2[2]];
   const ac = [c2[0] - a2[0], c2[1] - a2[1], c2[2] - a2[2]];
-  const normal = cross3$3(ab, ac);
-  const len2 = Math.hypot(normal[0], normal[1], normal[2]);
+  const normal2 = cross3$3(ab, ac);
+  const len2 = Math.hypot(normal2[0], normal2[1], normal2[2]);
   if (len2 <= 1e-12) return null;
-  return [normal[0] / len2, normal[1] / len2, normal[2] / len2];
+  return [normal2[0] / len2, normal2[1] / len2, normal2[2] / len2];
 }
 function offsetClosedSurfaceMesh(mesh, thickness) {
   let triangles;
@@ -38235,22 +38940,22 @@ function offsetClosedSurfaceMesh(mesh, thickness) {
   }
   const normals = Array.from({ length: mesh.vertices.length }, () => [0, 0, 0]);
   for (const triangle3 of triangles) {
-    const normal = triangleNormal(mesh.vertices, triangle3);
-    if (!normal) return null;
+    const normal2 = triangleNormal(mesh.vertices, triangle3);
+    if (!normal2) return null;
     for (const vertexIndex of triangle3) {
-      normals[vertexIndex][0] += normal[0];
-      normals[vertexIndex][1] += normal[1];
-      normals[vertexIndex][2] += normal[2];
+      normals[vertexIndex][0] += normal2[0];
+      normals[vertexIndex][1] += normal2[1];
+      normals[vertexIndex][2] += normal2[2];
     }
   }
   const offsetVertices = mesh.vertices.map((vertex2, index2) => {
-    const normal = normals[index2];
-    const len2 = Math.hypot(normal[0], normal[1], normal[2]);
+    const normal2 = normals[index2];
+    const len2 = Math.hypot(normal2[0], normal2[1], normal2[2]);
     if (len2 <= 1e-12) return [vertex2[0], vertex2[1], vertex2[2]];
     return [
-      vertex2[0] - normal[0] / len2 * thickness,
-      vertex2[1] - normal[1] / len2 * thickness,
-      vertex2[2] - normal[2] / len2 * thickness
+      vertex2[0] - normal2[0] / len2 * thickness,
+      vertex2[1] - normal2[1] / len2 * thickness,
+      vertex2[2] - normal2[2] / len2 * thickness
     ];
   });
   const innerOffset = mesh.vertices.length;
@@ -38306,19 +39011,19 @@ function lowerThickenedSurfaceGrid(points, thickness) {
   return wrapTruckShapeBackend(getTruckGeometryWasm().geometry_create_thickened_surface_grid(JSON.stringify({ points }), thickness));
 }
 function lowerSurfaceRuledPlan(plan) {
-  return lowerSurfaceGrid(surfaceGridForRuledPlan(plan));
+  return lowerSurfaceGrid(surfaceGridForRuledPlan$1(plan));
 }
 function lowerSurfaceFillPlan(plan) {
   var _a3, _b3;
   if ((((_a3 = plan.interiorCurves) == null ? void 0 : _a3.length) ?? 0) > 0 || (((_b3 = plan.interiorPoints) == null ? void 0 : _b3.length) ?? 0) > 0) {
     truckUnsupported("surface fill with interior constraint curves/points");
   }
-  const grid = surfaceGridForFillPlan(plan);
+  const grid = surfaceGridForFillPlan$1(plan);
   if (!grid) truckUnsupported("surface fill constraints beyond four-boundary Coons patches");
   return lowerSurfaceGrid(grid);
 }
 function lowerAnalyticSurfacePlan(plan) {
-  const grid = surfaceGridForAnalyticPlan(plan);
+  const grid = surfaceGridForAnalyticPlan$1(plan);
   if (!grid) truckUnsupported("trimmed analytic surfaces in the Truck backend");
   return lowerSurfaceGrid(grid);
 }
@@ -38333,6 +39038,12 @@ function lowerSurfaceSewPlan(plan) {
   }
 }
 function lowerSurfaceThickenPlan(plan) {
+  if (plan.thicknessField) {
+    const mesh = meshFromThickenedSurfaceSheetPlan(plan.base, plan.thickness, plan.thicknessField);
+    return wrapTruckShapeBackend(
+      getTruckGeometryWasm().geometry_create_imported_triangle_mesh(JSON.stringify(triangleMeshSpecFromShapeMesh(mesh)))
+    );
+  }
   const sewShapes = surfaceSewShapesForPlan(plan.base);
   if (sewShapes) {
     const closedSew = lowerThickenedClosedSewMesh(sewShapes, plan.thickness);
@@ -38372,23 +39083,23 @@ function cross3$3(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
 function fromSlicesPlaneFrame(normalInput) {
-  const normal = normalizedVector3(normalInput, "Shape.fromSlices group normal");
-  const [nx, ny, nz] = normal;
+  const normal2 = normalizedVector3(normalInput, "Shape.fromSlices group normal");
+  const [nx, ny, nz] = normal2;
   if (Math.abs(nz) > 1 - 1e-8) {
-    return { u: [1, 0, 0], v: [0, nz > 0 ? 1 : -1, 0], normal };
+    return { u: [1, 0, 0], v: [0, nz > 0 ? 1 : -1, 0], normal: normal2 };
   }
   if (Math.abs(ny) > 1 - 1e-8) {
-    return { u: [1, 0, 0], v: [0, 0, ny > 0 ? 1 : -1], normal };
+    return { u: [1, 0, 0], v: [0, 0, ny > 0 ? 1 : -1], normal: normal2 };
   }
   if (Math.abs(nx) > 1 - 1e-8) {
-    return { u: [0, 1, 0], v: [0, 0, nx > 0 ? 1 : -1], normal };
+    return { u: [0, 1, 0], v: [0, 0, nx > 0 ? 1 : -1], normal: normal2 };
   }
   const reference = Math.abs(nx) < 0.9 ? [1, 0, 0] : [0, 1, 0];
-  const u2 = normalizedVector3(cross3$3(reference, normal), "Shape.fromSlices profile u axis");
-  return { u: u2, v: cross3$3(normal, u2), normal };
+  const u2 = normalizedVector3(cross3$3(reference, normal2), "Shape.fromSlices profile u axis");
+  return { u: u2, v: cross3$3(normal2, u2), normal: normal2 };
 }
-function fromSlicesLocalToWorldMatrix(normal) {
-  const frame = fromSlicesPlaneFrame(normal);
+function fromSlicesLocalToWorldMatrix(normal2) {
+  const frame = fromSlicesPlaneFrame(normal2);
   return [
     frame.u[0],
     frame.u[1],
@@ -38430,8 +39141,8 @@ function fromSlicesSingleSliceHalfExtent$1(plan) {
   }
   return Math.max(1, radius + maxOffsetMagnitude + plan.boundsPadding + plan.edgeLength * 3);
 }
-function transformZAlignedFromSlicesGroupPlan(base, normal) {
-  const matrix = fromSlicesLocalToWorldMatrix(normal);
+function transformZAlignedFromSlicesGroupPlan(base, normal2) {
+  const matrix = fromSlicesLocalToWorldMatrix(normal2);
   const isIdentity = Math.abs(matrix[0] - 1) <= 1e-12 && Math.abs(matrix[5] - 1) <= 1e-12 && Math.abs(matrix[10] - 1) <= 1e-12 && Math.abs(matrix[15] - 1) <= 1e-12 && matrix.every((value, idx) => idx === 0 || idx === 5 || idx === 10 || idx === 15 ? true : Math.abs(value) <= 1e-12);
   if (isIdentity) return base;
   return {
@@ -38622,8 +39333,8 @@ function lowerShapeCompilePlanToTruckBackend(plan) {
   return lowerShapeBackendWithCache("truck", plan, lowerShapeCompilePlanToTruckBackendUncached);
 }
 function orientProfileLoop(points, ccw) {
-  const area = signedArea(points);
-  if (ccw && area < 0 || !ccw && area > 0) return [...points].reverse();
+  const area2 = signedArea(points);
+  if (ccw && area2 < 0 || !ccw && area2 > 0) return [...points].reverse();
   return points.map(([x2, y2]) => [x2, y2]);
 }
 function lowerProfileCompilePlanToTruckProfileBackend(plan) {
@@ -38673,8 +39384,8 @@ function normalizeVec3OrNull(v) {
   const length4 = Math.hypot(v[0], v[1], v[2]);
   return length4 > EXACT_PROFILE_EPS ? [v[0] / length4, v[1] / length4, v[2] / length4] : null;
 }
-function mirrorTransformMatrix(normal) {
-  const unit = normalizeVec3OrNull(normal);
+function mirrorTransformMatrix(normal2) {
+  const unit = normalizeVec3OrNull(normal2);
   if (!unit) return Transform.identity().toArray();
   const [nx, ny, nz] = unit;
   return [
@@ -42182,10 +42893,10 @@ function normVec3(v) {
   if (len2 < 1e-10) return null;
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
-function tangentFrame(normal) {
-  const ref = Math.abs(normal[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
-  const v = normVec3(cross$1(normal, ref));
-  const u2 = normVec3(cross$1(v, normal));
+function tangentFrame(normal2) {
+  const ref = Math.abs(normal2[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+  const v = normVec3(cross$1(normal2, ref));
+  const u2 = normVec3(cross$1(v, normal2));
   return { u: u2, v };
 }
 const NORMAL_COS_EPS$1 = 0.9998;
@@ -42205,15 +42916,15 @@ function clusterMeshFaces(shape) {
     const e1 = [v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]];
     const e2 = [v2[0] - v0[0], v2[1] - v0[1], v2[2] - v0[2]];
     const rawCross = cross$1(e1, e2);
-    const normal = normVec3(rawCross);
-    if (!normal) continue;
+    const normal2 = normVec3(rawCross);
+    if (!normal2) continue;
     const crossLen = Math.sqrt(rawCross[0] * rawCross[0] + rawCross[1] * rawCross[1] + rawCross[2] * rawCross[2]);
     const triArea2 = crossLen / 2;
-    const planeOffset = dot$1(normal, v0);
+    const planeOffset = dot$1(normal2, v0);
     const triCentroid2 = [(v0[0] + v1[0] + v2[0]) / 3, (v0[1] + v1[1] + v2[1]) / 3, (v0[2] + v1[2] + v2[2]) / 3];
     let merged = false;
     for (const c2 of clusters) {
-      if (dot$1(c2.normal, normal) > NORMAL_COS_EPS$1 && Math.abs(c2.planeOffset - planeOffset) < PLANE_OFFSET_EPS$1) {
+      if (dot$1(c2.normal, normal2) > NORMAL_COS_EPS$1 && Math.abs(c2.planeOffset - planeOffset) < PLANE_OFFSET_EPS$1) {
         c2.centroidSum[0] += triCentroid2[0];
         c2.centroidSum[1] += triCentroid2[1];
         c2.centroidSum[2] += triCentroid2[2];
@@ -42225,7 +42936,7 @@ function clusterMeshFaces(shape) {
     }
     if (!merged) {
       clusters.push({
-        normal,
+        normal: normal2,
         planeOffset,
         centroidSum: [triCentroid2[0], triCentroid2[1], triCentroid2[2]],
         count: 1,
@@ -42399,8 +43110,8 @@ function facesAreCoplanar(faces) {
   const planeOffset = firstNormal[0] * first.center[0] + firstNormal[1] * first.center[1] + firstNormal[2] * first.center[2];
   for (const face of faces.slice(1)) {
     if (face.planar === false || !face.uAxis || !face.vAxis) return false;
-    const normal = normalizeAxis(face.normal);
-    const alignment = Math.abs(firstNormal[0] * normal[0] + firstNormal[1] * normal[1] + firstNormal[2] * normal[2]);
+    const normal2 = normalizeAxis(face.normal);
+    const alignment = Math.abs(firstNormal[0] * normal2[0] + firstNormal[1] * normal2[1] + firstNormal[2] * normal2[2]);
     if (Math.abs(alignment - 1) > 1e-6) return false;
     const offset = firstNormal[0] * face.center[0] + firstNormal[1] * face.center[1] + firstNormal[2] * face.center[2];
     if (Math.abs(offset - planeOffset) > 1e-6) return false;
@@ -42543,12 +43254,12 @@ function canonicalShapeStepMatrix(step) {
       return [...step.matrix];
   }
 }
-function mirrorMatrix$1(normal) {
-  const len2 = Math.hypot(normal[0], normal[1], normal[2]);
+function mirrorMatrix$1(normal2) {
+  const len2 = Math.hypot(normal2[0], normal2[1], normal2[2]);
   if (len2 < 1e-12) return Transform.identity().toArray();
-  const nx = normal[0] / len2;
-  const ny = normal[1] / len2;
-  const nz = normal[2] / len2;
+  const nx = normal2[0] / len2;
+  const ny = normal2[1] / len2;
+  const nz = normal2[2] / len2;
   return [
     1 - 2 * nx * nx,
     -2 * nx * ny,
@@ -42618,8 +43329,8 @@ function normalize2d(vec2) {
 function cross3$2(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
-function orthonormalBasisFromNormal(normal) {
-  const n = normalizeAxis(normal);
+function orthonormalBasisFromNormal(normal2) {
+  const n = normalizeAxis(normal2);
   const seed = Math.abs(n[2]) < 0.9 ? [0, 0, 1] : [0, 1, 0];
   const u2 = normalizeAxis(cross3$2(seed, n));
   const v = normalizeAxis(cross3$2(n, u2));
@@ -43556,10 +44267,10 @@ function resolveShapeFaceTableInternal(plan, owner) {
             forwardStart3[1] - reverseStart3[1],
             forwardStart3[2] - reverseStart3[2]
           ]);
-          const normal = normalizeAxis(cross3$2(edgeVec, depthVec));
+          const normal2 = normalizeAxis(cross3$2(edgeVec, depthVec));
           registerFace(table, {
             name: wall.name,
-            normal,
+            normal: normal2,
             center: averageVec3([reverseStart3, reverseEnd3, forwardStart3, forwardEnd3]),
             planar: true,
             uAxis: edgeVec,
@@ -43651,22 +44362,22 @@ function resolveShapeFaceTableInternal(plan, owner) {
       const baseTable = resolveShapeFaceTable(plan.base);
       const centers = Array.from(baseTable.faces.values()).map((face) => face.center);
       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 normal = normalizeAxis([plan.normalX, plan.normalY, plan.normalZ]);
-      const planeDistance = averageCenter[0] * normal[0] + averageCenter[1] * normal[1] + averageCenter[2] * normal[2] - 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 center2 = [
-        averageCenter[0] - normal[0] * planeDistance,
-        averageCenter[1] - normal[1] * planeDistance,
-        averageCenter[2] - normal[2] * planeDistance
+        averageCenter[0] - normal2[0] * planeDistance,
+        averageCenter[1] - normal2[1] * planeDistance,
+        averageCenter[2] - normal2[2] * planeDistance
       ];
-      const basis = orthonormalBasisFromNormal(normal);
+      const basis = orthonormalBasisFromNormal(normal2);
       registerFace(table, {
         name: "plane-cap",
-        normal,
+        normal: normal2,
         center: center2,
         planar: true,
         uAxis: basis.u,
         vAxis: basis.v,
-        surface: { kind: "plane", normal },
+        surface: { kind: "plane", normal: normal2 },
         query: planeCapQuery
       });
       return table;
@@ -44422,16 +45133,16 @@ function buildCarrierFaceRefs(mesh, carriers) {
     const ny = (bz - az) * (cx - ax) - (bx - ax) * (cz - az);
     const nz = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
     const twoArea = Math.hypot(nx, ny, nz);
-    const area = twoArea * 0.5;
+    const area2 = twoArea * 0.5;
     let a2 = acc.get(name);
     if (!a2) {
       a2 = { area: 0, cx: 0, cy: 0, cz: 0, nx: 0, ny: 0, nz: 0, facetNormal: null };
       acc.set(name, a2);
     }
-    a2.area += area;
-    a2.cx += (ax + bx + cx) / 3 * area;
-    a2.cy += (ay + by + cy) / 3 * area;
-    a2.cz += (az + bz + cz) / 3 * area;
+    a2.area += area2;
+    a2.cx += (ax + bx + cx) / 3 * area2;
+    a2.cy += (ay + by + cy) / 3 * area2;
+    a2.cz += (az + bz + cz) / 3 * area2;
     a2.nx += nx * 0.5;
     a2.ny += ny * 0.5;
     a2.nz += nz * 0.5;
@@ -44441,9 +45152,9 @@ function buildCarrierFaceRefs(mesh, carriers) {
     if (a2.area <= 0) continue;
     const center2 = [a2.cx / a2.area, a2.cy / a2.area, a2.cz / a2.area];
     const nlen = Math.hypot(a2.nx, a2.ny, a2.nz);
-    const normal = nlen > 1e-9 ? [a2.nx / nlen, a2.ny / nlen, a2.nz / nlen] : a2.facetNormal ?? [0, 0, 1];
+    const normal2 = nlen > 1e-9 ? [a2.nx / nlen, a2.ny / nlen, a2.nz / nlen] : a2.facetNormal ?? [0, 0, 1];
     const surface = surfaceByName.get(name);
-    out.set(name, { name, center: center2, normal, surface, planar: surface ? surface.kind === "plane" : void 0 });
+    out.set(name, { name, center: center2, normal: normal2, surface, planar: surface ? surface.kind === "plane" : void 0 });
   }
   return out;
 }
@@ -44915,7 +45626,7 @@ function normalize3(v) {
 function cross3(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
-function sub3(a2, b) {
+function sub3$1(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function negate3(v) {
@@ -44938,7 +45649,7 @@ function alignmentMatrix(childOrigin, childAxis, childUp, parentOrigin, parentAx
     r10 * childOrigin[0] + r11 * childOrigin[1] + r12 * childOrigin[2],
     r20 * childOrigin[0] + r21 * childOrigin[1] + r22 * childOrigin[2]
   ];
-  const t = sub3(parentOrigin, rc);
+  const t = sub3$1(parentOrigin, rc);
   return Transform.from([r00, r10, r20, 0, r01, r11, r21, 0, r02, r12, r22, 0, t[0], t[1], t[2], 1]);
 }
 function computeSinglePairAlignment(childPort, targetPort) {
@@ -44977,8 +45688,8 @@ function computeMultiPairAlignment(pairs, childPorts, targetPorts, tolerance = 0
     [0, 0, 0]
   ];
   for (const p2 of pairs) {
-    const s = sub3(p2.childOrigin, srcCentroid);
-    const t2 = sub3(p2.targetOrigin, tgtCentroid);
+    const s = sub3$1(p2.childOrigin, srcCentroid);
+    const t2 = sub3$1(p2.targetOrigin, tgtCentroid);
     for (let i = 0; i < 3; i++) {
       for (let j = 0; j < 3; j++) {
         h[i][j] += s[i] * t2[j];
@@ -44991,7 +45702,7 @@ function computeMultiPairAlignment(pairs, childPorts, targetPorts, tolerance = 0
     R[1][0] * srcCentroid[0] + R[1][1] * srcCentroid[1] + R[1][2] * srcCentroid[2],
     R[2][0] * srcCentroid[0] + R[2][1] * srcCentroid[1] + R[2][2] * srcCentroid[2]
   ];
-  const t = sub3(tgtCentroid, rSrc);
+  const t = sub3$1(tgtCentroid, rSrc);
   const transform = Transform.from([
     R[0][0],
     R[1][0],
@@ -45013,7 +45724,7 @@ function computeMultiPairAlignment(pairs, childPorts, targetPorts, tolerance = 0
   const residuals = [];
   for (const p2 of pairs) {
     const transformed = transform.point(p2.childOrigin);
-    const diff = sub3(transformed, p2.targetOrigin);
+    const diff = sub3$1(transformed, p2.targetOrigin);
     residuals.push(len3(diff));
   }
   const maxResidual = Math.max(...residuals);
@@ -45214,7 +45925,7 @@ function getConnectorDistance(ports, nameA, nameB) {
   const b = ports[nameB];
   if (!a2) throw new Error(`connectorDistance: unknown connector "${nameA}"`);
   if (!b) throw new Error(`connectorDistance: unknown connector "${nameB}"`);
-  const d2 = sub3(a2.origin, b.origin);
+  const d2 = sub3$1(a2.origin, b.origin);
   return len3(d2);
 }
 function getConnectorMeasurements(ports, name) {
@@ -45277,8 +45988,8 @@ function requireVec3Pivot(v, method) {
   if (!Array.isArray(v) || v.length !== 3 || !v.every((n) => typeof n === "number" && Number.isFinite(n)))
     throw new Error(`${method} pivot must be [x, y, z] with finite numbers, got ${JSON.stringify(v)}`);
 }
-function mirrorPlaneMatrix(normal) {
-  const [nx0, ny0, nz0] = normal;
+function mirrorPlaneMatrix(normal2) {
+  const [nx0, ny0, nz0] = normal2;
   const len2 = Math.hypot(nx0, ny0, nz0);
   if (len2 < 1e-12) return Transform.identity().toArray();
   const nx = nx0 / len2, ny = ny0 / len2, nz = nz0 / len2;
@@ -45581,13 +46292,13 @@ class ShapeGroup {
     return scaled.translate(scalePivot[0], scalePivot[1], scalePivot[2]);
   }
   /** Mirror across a plane through the group's bounding-box center. */
-  mirror(normal) {
-    return this.mirrorThrough(this._bboxCenter(), normal);
+  mirror(normal2) {
+    return this.mirrorThrough(this._bboxCenter(), normal2);
   }
   /** Mirror across a plane through an explicit point. */
-  mirrorThrough(point2, normal) {
+  mirrorThrough(point2, normal2) {
     const mirrorPoint = requireFiniteVec3$1(point2, "ShapeGroup.mirrorThrough() point");
-    const mirrorNormal = requireNonZeroFiniteVec3(normal, "ShapeGroup.mirrorThrough() normal");
+    const mirrorNormal = requireNonZeroFiniteVec3(normal2, "ShapeGroup.mirrorThrough() normal");
     const matrix = mirrorPlaneMatrix(mirrorNormal);
     if (mirrorPoint[0] === 0 && mirrorPoint[1] === 0 && mirrorPoint[2] === 0) {
       return this.mapChildrenTransform((c2) => {
@@ -46781,12 +47492,12 @@ function clusterTriangles(mesh) {
     nx /= len2;
     ny /= len2;
     nz /= len2;
-    const normal = [nx, ny, nz];
+    const normal2 = [nx, ny, nz];
     const planeOffset = nx * v0x + ny * v0y + nz * v0z;
     let matched = -1;
     for (let c2 = 0; c2 < clusters.length; c2++) {
       const cl = clusters[c2];
-      if (dot3(cl.normal, normal) > NORMAL_COS_EPS && Math.abs(cl.planeOffset - planeOffset) < PLANE_OFFSET_EPS) {
+      if (dot3(cl.normal, normal2) > NORMAL_COS_EPS && Math.abs(cl.planeOffset - planeOffset) < PLANE_OFFSET_EPS) {
         matched = c2;
         break;
       }
@@ -46796,7 +47507,7 @@ function clusterTriangles(mesh) {
       triCluster[t] = matched;
     } else {
       triCluster[t] = clusters.length;
-      clusters.push({ normal, planeOffset, triangleIndices: [t] });
+      clusters.push({ normal: normal2, planeOffset, triangleIndices: [t] });
     }
   }
   return { clusters, triCluster };
@@ -47336,6 +48047,112 @@ function autoFitProjection(spec, bbox) {
 function isImageHandle(value) {
   return typeof value === "object" && value !== null && value.__forgeImage === true;
 }
+function ease(t, easing) {
+  if (easing !== "easeInOut") return t;
+  return t * t * (3 - 2 * t);
+}
+function interpolateStations(profile, t) {
+  const stations = profile.stations;
+  if (t <= stations[0].t) return stations[0].thickness;
+  for (let index2 = 0; index2 < stations.length - 1; index2 += 1) {
+    const a2 = stations[index2];
+    const b = stations[index2 + 1];
+    if (t > b.t) continue;
+    const localT = ease((t - a2.t) / Math.max(1e-12, b.t - a2.t), profile.easing);
+    return a2.thickness + (b.thickness - a2.thickness) * localT;
+  }
+  return stations[stations.length - 1].thickness;
+}
+function bilinear(values, u2, v, easing) {
+  const uScaled = ease(Math.min(1, Math.max(0, u2)), easing) * (values.length - 1);
+  const vScaled = ease(Math.min(1, Math.max(0, v)), easing) * (values[0].length - 1);
+  const u0 = Math.min(values.length - 2, Math.floor(uScaled));
+  const v0 = Math.min(values[0].length - 2, Math.floor(vScaled));
+  const fu = uScaled - u0;
+  const fv = vScaled - v0;
+  const a2 = values[u0][v0] + (values[u0 + 1][v0] - values[u0][v0]) * fu;
+  const b = values[u0][v0 + 1] + (values[u0 + 1][v0 + 1] - values[u0][v0 + 1]) * fu;
+  return a2 + (b - a2) * fv;
+}
+function evaluateScalarNurbs(plan, u2, v) {
+  const degreeU = plan.degreeU;
+  const degreeV = plan.degreeV;
+  const values = plan.values;
+  const uMin = plan.knotsU[degreeU];
+  const uMax = plan.knotsU[values.length];
+  const vMin = plan.knotsV[degreeV];
+  const vMax = plan.knotsV[values[0].length];
+  const uu = uMin + Math.min(1, Math.max(0, u2)) * (uMax - uMin);
+  const vv = vMin + Math.min(1, Math.max(0, v)) * (vMax - vMin);
+  const spanU = findSpan(values.length - 1, degreeU, uu, plan.knotsU);
+  const spanV = findSpan(values[0].length - 1, degreeV, vv, plan.knotsV);
+  const basisU = basisFuns(spanU, uu, degreeU, plan.knotsU);
+  const basisV = basisFuns(spanV, vv, degreeV, plan.knotsV);
+  let out = 0;
+  for (let i = 0; i <= degreeU; i += 1) {
+    const row = spanU - degreeU + i;
+    for (let j = 0; j <= degreeV; j += 1) {
+      const col = spanV - degreeV + j;
+      out += basisU[i] * basisV[j] * values[row][col];
+    }
+  }
+  return out;
+}
+function cloneThicknessFieldCompilePlan(plan) {
+  switch (plan.kind) {
+    case "constant":
+      return { kind: "constant", thickness: plan.thickness };
+    case "alongU":
+    case "alongV":
+      return { kind: plan.kind, stations: plan.stations.map((station) => ({ ...station })), easing: plan.easing };
+    case "grid":
+      return { kind: "grid", values: plan.values.map((row) => [...row]), easing: plan.easing };
+    case "nurbs":
+      return {
+        kind: "nurbs",
+        values: plan.values.map((row) => [...row]),
+        degreeU: plan.degreeU,
+        degreeV: plan.degreeV,
+        knotsU: [...plan.knotsU],
+        knotsV: [...plan.knotsV]
+      };
+  }
+}
+function evaluateThicknessField(plan, u2, v) {
+  switch (plan.kind) {
+    case "constant":
+      return plan.thickness;
+    case "alongU":
+      return interpolateStations(plan, u2);
+    case "alongV":
+      return interpolateStations(plan, v);
+    case "grid":
+      return bilinear(plan.values, u2, v, plan.easing);
+    case "nurbs":
+      return evaluateScalarNurbs(plan, u2, v);
+  }
+}
+function maxThicknessFieldValue(plan, samples = 16) {
+  if (plan.kind === "constant") return plan.thickness;
+  if (plan.kind === "alongU" || plan.kind === "alongV") return Math.max(...plan.stations.map((station) => station.thickness));
+  if (plan.kind === "grid" || plan.kind === "nurbs") return Math.max(...plan.values.flat());
+  let max2 = 0;
+  for (let i = 0; i <= samples; i += 1) {
+    for (let j = 0; j <= samples; j += 1) max2 = Math.max(max2, evaluateThicknessField(plan, i / samples, j / samples));
+  }
+  return max2;
+}
+const FIELD_PLANS = /* @__PURE__ */ new WeakMap();
+function normalizeThicknessInput(input, label) {
+  if (typeof input === "number") return { thickness: input };
+  if (input && typeof input === "object") {
+    const stored = FIELD_PLANS.get(input);
+    if (!stored) throw new Error(`${label} must be created by Thickness.*.`);
+    const plan = cloneThicknessFieldCompilePlan(stored);
+    return plan.kind === "constant" ? { thickness: plan.thickness } : { thickness: maxThicknessFieldValue(plan), field: plan };
+  }
+  throw new Error(`${label} must be a number or Thickness.* field.`);
+}
 const _shapeDimensions = /* @__PURE__ */ new WeakMap();
 let _shapeDimensionCounter = 0;
 function nextShapeDimensionId() {
@@ -47438,8 +48255,8 @@ function rotationAroundAxisMatrix(axis, angleDeg, pivot) {
   const tz = pz - (m20 * px + m21 * py + m22 * pz);
   return [m00, m10, m20, 0, m01, m11, m21, 0, m02, m12, m22, 0, tx, ty, tz, 1];
 }
-function mirrorMatrix(normal) {
-  const [nx0, ny0, nz0] = normal;
+function mirrorMatrix(normal2) {
+  const [nx0, ny0, nz0] = normal2;
   const len2 = Math.hypot(nx0, ny0, nz0);
   if (len2 < 1e-12) return Transform.identity().toArray();
   const nx = nx0 / len2;
@@ -49052,19 +49869,19 @@ class Shape {
     return scaled.translate(scalePivot[0], scalePivot[1], scalePivot[2]);
   }
   /** Mirror across a plane through the shape's bounding box center, defined by its normal vector. */
-  mirror(normal) {
+  mirror(normal2) {
     const bb = this.boundingBox();
     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(center2, normal);
+    return this.mirrorThrough(center2, normal2);
   }
   /** Mirror across a plane through an explicit point, defined by its normal vector. */
-  mirrorThrough(point2, normal) {
+  mirrorThrough(point2, normal2) {
     const mirrorPoint = requireFiniteVec3$1(point2, "Shape.mirrorThrough() point");
-    const mirrorNormal = requireNonZeroFiniteVec3(normal, "Shape.mirrorThrough() normal");
+    const mirrorNormal = requireNonZeroFiniteVec3(normal2, "Shape.mirrorThrough() normal");
     if (mirrorPoint[0] === 0 && mirrorPoint[1] === 0 && mirrorPoint[2] === 0) {
       const transformedPlan2 = appendShapeCompileTransform(getShapeCompilePlanInternal(this), {
         kind: "mirror",
@@ -49320,8 +50137,8 @@ class Shape {
     ];
   }
   /** Split by infinite plane. Returns [positive-side, negative-side]. */
-  splitByPlane(normal, originOffset = 0) {
-    const planeNormal = requireNonZeroFiniteVec3(normal, "Shape.splitByPlane() normal");
+  splitByPlane(normal2, originOffset = 0) {
+    const planeNormal = requireNonZeroFiniteVec3(normal2, "Shape.splitByPlane() normal");
     const planeOffset = requireFiniteNumber(originOffset, "Shape.splitByPlane() originOffset");
     const info = deriveGeometryInfo(getShapeGeometryInfoInternal(this), "boolean", {
       topology: "none"
@@ -49350,8 +50167,8 @@ class Shape {
     ];
   }
   /** Keep the positive side of the plane and discard the opposite side. */
-  trimByPlane(normal, originOffset = 0) {
-    const planeNormal = requireNonZeroFiniteVec3(normal, "Shape.trimByPlane() normal");
+  trimByPlane(normal2, originOffset = 0) {
+    const planeNormal = requireNonZeroFiniteVec3(normal2, "Shape.trimByPlane() normal");
     const planeOffset = requireFiniteNumber(originOffset, "Shape.trimByPlane() originOffset");
     const basePlan = getShapeCompilePlanInternal(this);
     const nextPlan = createOwnedTopologyRewritePlan(
@@ -49398,7 +50215,8 @@ class Shape {
   }
   /** Offset-thicken an exact open surface or shell into a solid. */
   thicken(thickness) {
-    const wallThickness = requireFiniteNumber(thickness, "Shape.thicken() thickness");
+    const resolvedThickness = normalizeThicknessInput(thickness, "Shape.thicken() thickness");
+    const wallThickness = requireFiniteNumber(resolvedThickness.thickness, "Shape.thicken() thickness");
     if (wallThickness === 0) {
       throw new Error("Shape.thicken() requires a non-zero finite thickness.");
     }
@@ -49407,12 +50225,17 @@ class Shape {
       throw new Error("Shape.thicken() is only available on surface-representation shapes.");
     }
     const basePlan = getShapeCompilePlanInternal(this);
-    const nextPlan = buildSurfaceThickenShapeCompilePlan(basePlan, wallThickness);
-    const representation = info.backend === "occt" || info.backend === "truck" ? "brep-solid" : "mesh-solid";
+    const nextPlan = buildSurfaceThickenShapeCompilePlan(basePlan, wallThickness, resolvedThickness.field);
+    const variableThickness = resolvedThickness.field !== void 0;
+    const representation = variableThickness || info.backend !== "occt" && info.backend !== "truck" ? "mesh-solid" : "brep-solid";
     return setShapeCompilePlanInternal(
       setShapeGeometryInfoInternal(
         withBaseDimensionsPreservingOutputTopology(this, buildShapeFromCompilePlan(nextPlan, this.colorHex)),
-        deriveGeometryInfo(info, "shell", { representation, topology: info.backend === "truck" ? "kernel" : "none" })
+        deriveGeometryInfo(info, "shell", {
+          representation,
+          fidelity: variableThickness ? "sampled" : void 0,
+          topology: variableThickness ? "none" : info.backend === "truck" ? "kernel" : "none"
+        })
       ),
       nextPlan
     );
@@ -50004,6 +50827,783 @@ class NurbsSurface {
     return this.knotsV[this.degreeV] + domainT * (this.knotsV[this.nV] - this.knotsV[this.degreeV]);
   }
 }
+function cleanTrimLoop(points, context) {
+  const open = [...points];
+  if (open.length > 1) {
+    const first = open[0];
+    const last = open[open.length - 1];
+    if (Math.hypot(first[0] - last[0], first[1] - last[1]) <= 1e-12) open.pop();
+  }
+  const out = [];
+  for (const point2 of open) {
+    const previous = out[out.length - 1];
+    if (!previous || Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-12) out.push(point2);
+  }
+  if (out.length < 3) throw new Error(`${context}: trim loop requires at least 3 distinct points`);
+  if (Math.abs(signedArea2$1(out)) <= 1e-12) throw new Error(`${context}: trim loop area is too small`);
+  return out;
+}
+function sampleTrimLoop(loop, context) {
+  if (loop.kind === "polygon") return cleanTrimLoop(loop.points, context);
+  const uMin = loop.knots[loop.degree];
+  const uMax = loop.knots[loop.controlPoints.length];
+  const count = Math.max(3, loop.samples);
+  const samples = Array.from({ length: count }, (_unused, index2) => {
+    const t = count === 1 ? 0 : index2 / (count - 1);
+    return deBoor2D(loop.controlPoints, loop.weights, loop.knots, loop.degree, uMin + t * (uMax - uMin));
+  });
+  return cleanTrimLoop(samples, context);
+}
+function pointInLoop(point2, loop) {
+  let inside = false;
+  for (let i = 0, j = loop.length - 1; i < loop.length; j = i++) {
+    const a2 = loop[i];
+    const b = loop[j];
+    const intersects2 = a2[1] > point2[1] !== b[1] > point2[1] && point2[0] < (b[0] - a2[0]) * (point2[1] - a2[1]) / (b[1] - a2[1]) + a2[0];
+    if (intersects2) inside = !inside;
+  }
+  return inside;
+}
+function sampleTrim(trim) {
+  if (!trim) return null;
+  return {
+    outer: sampleTrimLoop(trim.outer, "nurbsSurface(trim.outer)"),
+    holes: trim.holes.map((hole, index2) => sampleTrimLoop(hole, `nurbsSurface(trim.holes[${index2}])`))
+  };
+}
+function uvInsideTrim(uv, trim) {
+  if (!trim) return true;
+  if (!pointInLoop(uv, trim.outer)) return false;
+  return !trim.holes.some((hole) => pointInLoop(uv, hole));
+}
+function add3(a2, b) {
+  return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
+}
+function sub3(a2, b) {
+  return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
+}
+function scale3(v, scale2) {
+  return [v[0] * scale2, v[1] * scale2, v[2] * scale2];
+}
+function distance3(a2, b) {
+  return Math.hypot(a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]);
+}
+function radialPoint(xAxis, yAxis, u2, radius) {
+  return add3(scale3(xAxis, Math.cos(u2) * radius), scale3(yAxis, Math.sin(u2) * radius));
+}
+function analyticYForFrame(axis, xAxis) {
+  return normalize3$2(cross3$6(axis, xAxis), "SDF analytic surface yAxis");
+}
+function analyticSurfacePoint(surface, u2, v) {
+  switch (surface.kind) {
+    case "plane":
+      return add3(add3(surface.origin, scale3(surface.uAxis, u2)), scale3(surface.vAxis, v));
+    case "cylinder": {
+      const yAxis = analyticYForFrame(surface.axis, surface.xAxis);
+      return add3(add3(surface.origin, scale3(surface.axis, v)), radialPoint(surface.xAxis, yAxis, u2, surface.radius));
+    }
+    case "cone": {
+      const yAxis = analyticYForFrame(surface.axis, surface.xAxis);
+      const t = (v - surface.vMin) / (surface.vMax - surface.vMin);
+      const radius = surface.radiusBottom + (surface.radiusTop - surface.radiusBottom) * t;
+      return add3(add3(surface.origin, scale3(surface.axis, v)), radialPoint(surface.xAxis, yAxis, u2, radius));
+    }
+    case "sphere": {
+      const yAxis = analyticYForFrame(surface.axis, surface.xAxis);
+      const radial = radialPoint(surface.xAxis, yAxis, u2, surface.radius * Math.cos(v));
+      return add3(add3(surface.center, radial), scale3(surface.axis, surface.radius * Math.sin(v)));
+    }
+    case "torus": {
+      const yAxis = analyticYForFrame(surface.axis, surface.xAxis);
+      const radial = radialPoint(surface.xAxis, yAxis, u2, surface.majorRadius + surface.minorRadius * Math.cos(v));
+      return add3(add3(surface.center, radial), scale3(surface.axis, surface.minorRadius * Math.sin(v)));
+    }
+  }
+}
+function resamplePolyline(points, count) {
+  if (points.length === 0) return [];
+  if (points.length === 1 || count <= 1) return [points[0]];
+  const cumulative = [0];
+  for (let index2 = 1; index2 < points.length; index2 += 1) {
+    cumulative.push(cumulative[index2 - 1] + Math.hypot(...sub3(points[index2], points[index2 - 1])));
+  }
+  const total = cumulative[cumulative.length - 1];
+  if (total <= 1e-12) return Array.from({ length: count }, () => points[0]);
+  const out = [];
+  let segment = 0;
+  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 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]);
+  }
+  return out;
+}
+function sampleSurfaceCurve(path, resolution) {
+  const count = Math.max(2, resolution + 1);
+  return resamplePolyline(sampleSweepPath(path), count);
+}
+function reversePoints(points) {
+  return [...points].reverse();
+}
+function pointTolerance(points) {
+  if (points.length === 0) return 1e-7;
+  const min2 = [...points[0]];
+  const max2 = [...points[0]];
+  for (const point2 of points) {
+    min2[0] = Math.min(min2[0], point2[0]);
+    min2[1] = Math.min(min2[1], point2[1]);
+    min2[2] = Math.min(min2[2], point2[2]);
+    max2[0] = Math.max(max2[0], point2[0]);
+    max2[1] = Math.max(max2[1], point2[1]);
+    max2[2] = Math.max(max2[2], point2[2]);
+  }
+  return Math.max(1e-7, distance3(min2, max2) * 1e-7);
+}
+function samePoint(a2, b, tolerance) {
+  return distance3(a2, b) <= tolerance;
+}
+function cleanSampledCurve(points, tolerance, context) {
+  const cleaned = [];
+  for (const point2 of points) {
+    const previous = cleaned[cleaned.length - 1];
+    if (!previous || !samePoint(point2, previous, tolerance)) cleaned.push(point2);
+  }
+  if (cleaned.length > 1 && samePoint(cleaned[0], cleaned[cleaned.length - 1], tolerance)) cleaned.pop();
+  if (cleaned.length < 2) throw new Error(`${context} boundary curve must have at least two distinct sample points.`);
+  return cleaned;
+}
+function stitchBoundaryLoop(boundaries, tolerance) {
+  const tryStitch = (seed, remaining) => {
+    const loop = [...seed];
+    const unused = [...remaining];
+    while (unused.length > 0) {
+      const end = loop[loop.length - 1];
+      const matchIndex = unused.findIndex(
+        (curve) => samePoint(curve[0], end, tolerance) || samePoint(curve[curve.length - 1], end, tolerance)
+      );
+      if (matchIndex < 0) return null;
+      const [match] = unused.splice(matchIndex, 1);
+      const oriented = samePoint(match[0], end, tolerance) ? match : reversePoints(match);
+      loop.push(...oriented.slice(1));
+    }
+    if (!samePoint(loop[0], loop[loop.length - 1], tolerance)) return null;
+    loop.pop();
+    return loop;
+  };
+  return tryStitch(boundaries[0], boundaries.slice(1)) ?? tryStitch(reversePoints(boundaries[0]), boundaries.slice(1));
+}
+function rejectSdfInteriorConstraints(plan) {
+  var _a3, _b3;
+  if ((((_a3 = plan.interiorCurves) == null ? void 0 : _a3.length) ?? 0) > 0 || (((_b3 = plan.interiorPoints) == null ? void 0 : _b3.length) ?? 0) > 0) {
+    throw new Error(
+      "SDF backend cannot build a Surface.Fill() with interior constraint curves/points. Use the OCCT backend for constrained fills."
+    );
+  }
+}
+function sampledFillBoundaryLoop(plan) {
+  rejectSdfInteriorConstraints(plan);
+  if (plan.boundaries.length < 3) throw new Error("SDF backend sampled Surface.Fill() requires at least three boundary curves.");
+  const rawBoundaries = plan.boundaries.map((boundary) => sampleSurfaceCurve(boundary.curve, plan.resolution));
+  const tolerance = pointTolerance(rawBoundaries.flat());
+  const boundaries = rawBoundaries.map(
+    (points, index2) => cleanSampledCurve(points, tolerance, `SDF sampled Surface.Fill() boundary '${plan.boundaries[index2].name}'`)
+  );
+  const loop = stitchBoundaryLoop(boundaries, tolerance);
+  if (!loop) throw new Error("SDF backend sampled Surface.Fill() requires boundary curves to form one closed loop.");
+  if (loop.length < 3) throw new Error("SDF backend sampled Surface.Fill() requires at least three distinct boundary points.");
+  return loop;
+}
+function surfaceGridForRuledPlan(plan) {
+  const count = Math.max(2, plan.resolution + 1);
+  return [
+    resamplePolyline(sampleSurfaceCurve(plan.curveA, plan.resolution), count),
+    resamplePolyline(sampleSurfaceCurve(plan.curveB, plan.resolution), count)
+  ];
+}
+function namedBoundaryCurve(plan, name) {
+  return plan.boundaries.find((boundary) => boundary.name === name) ?? null;
+}
+function hasUnconstrainedCoonsFillBoundaries(plan) {
+  return !!namedBoundaryCurve(plan, "v0") && !!namedBoundaryCurve(plan, "u1") && !!namedBoundaryCurve(plan, "v1") && !!namedBoundaryCurve(plan, "u0") && !plan.boundaries.some((boundary) => boundary.support);
+}
+function surfaceGridForFillPlan(plan) {
+  rejectSdfInteriorConstraints(plan);
+  const bottomCurve = namedBoundaryCurve(plan, "v0");
+  const rightCurve = namedBoundaryCurve(plan, "u1");
+  const topCurve = namedBoundaryCurve(plan, "v1");
+  const leftCurve = namedBoundaryCurve(plan, "u0");
+  if (!bottomCurve || !rightCurve || !topCurve || !leftCurve || plan.boundaries.some((boundary) => boundary.support)) {
+    throw new Error("SDF backend gridded Surface.Patch()/Surface.Fill() requires an unconstrained four-boundary Coons patch.");
+  }
+  const count = Math.max(2, plan.resolution + 1);
+  const bottom = sampleSurfaceCurve(bottomCurve.curve, plan.resolution);
+  const right = sampleSurfaceCurve(rightCurve.curve, plan.resolution);
+  const top = reversePoints(sampleSurfaceCurve(topCurve.curve, plan.resolution));
+  const left = reversePoints(sampleSurfaceCurve(leftCurve.curve, plan.resolution));
+  const p00 = bottom[0];
+  const p10 = bottom[bottom.length - 1];
+  const p01 = top[0];
+  const p11 = top[top.length - 1];
+  const grid = [];
+  for (let vIndex = 0; vIndex < count; vIndex += 1) {
+    const v = vIndex / (count - 1);
+    const row = [];
+    for (let uIndex = 0; uIndex < count; uIndex += 1) {
+      const u2 = uIndex / (count - 1);
+      const bottomPoint = bottom[uIndex];
+      const topPoint = top[uIndex];
+      const leftPoint = left[vIndex];
+      const rightPoint = right[vIndex];
+      const bilinear2 = [
+        (1 - u2) * (1 - v) * p00[0] + u2 * (1 - v) * p10[0] + (1 - u2) * v * p01[0] + u2 * v * p11[0],
+        (1 - u2) * (1 - v) * p00[1] + u2 * (1 - v) * p10[1] + (1 - u2) * v * p01[1] + u2 * v * p11[1],
+        (1 - u2) * (1 - v) * p00[2] + u2 * (1 - v) * p10[2] + (1 - u2) * v * p01[2] + u2 * v * p11[2]
+      ];
+      row.push([
+        (1 - v) * bottomPoint[0] + v * topPoint[0] + (1 - u2) * leftPoint[0] + u2 * rightPoint[0] - bilinear2[0],
+        (1 - v) * bottomPoint[1] + v * topPoint[1] + (1 - u2) * leftPoint[1] + u2 * rightPoint[1] - bilinear2[1],
+        (1 - v) * bottomPoint[2] + v * topPoint[2] + (1 - u2) * leftPoint[2] + u2 * rightPoint[2] - bilinear2[2]
+      ]);
+    }
+    grid.push(row);
+  }
+  return grid;
+}
+function surfaceGridForAnalyticPlan(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(plan.surface, u2, v));
+      uvRow.push([uNorm, vNorm]);
+    }
+    grid.push(row);
+    uvGrid.push(uvRow);
+  }
+  return { grid, trim: sampleTrim(plan.trim), uvGrid };
+}
+function computeGridNormals(positions, indices) {
+  const normals = Array.from({ length: positions.length }, () => [0, 0, 0]);
+  for (let index2 = 0; index2 < indices.length; index2 += 3) {
+    const a2 = positions[indices[index2]];
+    const b = positions[indices[index2 + 1]];
+    const c2 = positions[indices[index2 + 2]];
+    const normal2 = cross3$6(sub3(b, a2), sub3(c2, a2));
+    for (const vertexIndex of [indices[index2], indices[index2 + 1], indices[index2 + 2]]) {
+      normals[vertexIndex][0] += normal2[0];
+      normals[vertexIndex][1] += normal2[1];
+      normals[vertexIndex][2] += normal2[2];
+    }
+  }
+  return normals.map((normal2) => {
+    const length4 = Math.hypot(normal2[0], normal2[1], normal2[2]);
+    return length4 <= 1e-12 ? [0, 0, 1] : [normal2[0] / length4, normal2[1] / length4, normal2[2] / length4];
+  });
+}
+function meshFromSurfaceGrid(grid, trim = null, context = "SDF surface sheet", uvGrid) {
+  var _a3;
+  const rows = grid.length;
+  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)) {
+      throw new Error(`${context} UV grid must match the sampled surface grid.`);
+    }
+    for (const row of uvGrid) uvs.push(...row);
+  } else {
+    for (let row = 0; row < rows; row += 1) {
+      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 centroid = [(uvs[a2][0] + uvs[b][0] + uvs[c2][0]) / 3, (uvs[a2][1] + uvs[b][1] + uvs[c2][1]) / 3];
+    return uvInsideTrim(centroid, trim);
+  };
+  for (let row = 0; row < rows - 1; row += 1) {
+    for (let col = 0; col < cols - 1; col += 1) {
+      const a2 = row * cols + col;
+      const b = a2 + 1;
+      const c2 = (row + 1) * cols + col;
+      const d2 = c2 + 1;
+      if (includeTriangle(a2, c2, b)) sourceIndices.push(a2, c2, b);
+      if (includeTriangle(b, c2, d2)) sourceIndices.push(b, c2, d2);
+    }
+  }
+  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 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 * 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,
+    numVert: compactPositions.length,
+    numTri: compactIndices.length / 3,
+    vertProperties,
+    triVerts: new Uint32Array(compactIndices)
+  };
+}
+function polygonNormal3(points, context) {
+  const normal2 = [0, 0, 0];
+  for (let index2 = 0; index2 < points.length; index2 += 1) {
+    const a2 = points[index2];
+    const b = points[(index2 + 1) % points.length];
+    normal2[0] += (a2[1] - b[1]) * (a2[2] + b[2]);
+    normal2[1] += (a2[2] - b[2]) * (a2[0] + b[0]);
+    normal2[2] += (a2[0] - b[0]) * (a2[1] + b[1]);
+  }
+  return normalize3$2(normal2, `${context} boundary normal`);
+}
+function planarProjectionFrame(points, context) {
+  const origin = points[0];
+  const normal2 = polygonNormal3(points, context);
+  const tolerance = pointTolerance(points) * 100;
+  const uSource = points.find((point2) => distance3(point2, origin) > tolerance);
+  if (!uSource) throw new Error(`${context} boundary loop collapsed to one point.`);
+  const u2 = normalize3$2(sub3(uSource, origin), `${context} u axis`);
+  const v = cross3$6(normal2, u2);
+  const maxPlaneError = points.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$4(sub3(point2, origin), normal2))), 0);
+  if (maxPlaneError > tolerance) throw new Error(`${context} boundary loop must be planar for sampled SDF triangulation.`);
+  return { origin, u: u2, v, tolerance };
+}
+function meshFromPlanarBoundaryLoop(loop, context) {
+  const frame = planarProjectionFrame(loop, context);
+  const projected = loop.map((point2) => {
+    const relative = sub3(point2, frame.origin);
+    return new Vector2(dot3$4(relative, frame.u), dot3$4(relative, frame.v));
+  });
+  const triangles = ShapeUtils.triangulateShape(projected, []);
+  if (triangles.length === 0) throw new Error(`${context} boundary loop could not be triangulated.`);
+  const positions = loop;
+  const indices = [];
+  for (const triangle3 of triangles) {
+    const [a2, b, c2] = triangle3;
+    const areaNormal = cross3$6(sub3(positions[b], positions[a2]), sub3(positions[c2], positions[a2]));
+    if (Math.hypot(...areaNormal) > frame.tolerance * frame.tolerance) indices.push(a2, b, c2);
+  }
+  if (indices.length === 0) throw new Error(`${context} boundary loop collapsed to zero area.`);
+  const normals = computeGridNormals(positions, indices);
+  const vertProperties = new Float32Array(positions.length * 6);
+  for (let index2 = 0; index2 < positions.length; index2 += 1) {
+    const offset = index2 * 6;
+    vertProperties[offset] = positions[index2][0];
+    vertProperties[offset + 1] = positions[index2][1];
+    vertProperties[offset + 2] = positions[index2][2];
+    vertProperties[offset + 3] = normals[index2][0];
+    vertProperties[offset + 4] = normals[index2][1];
+    vertProperties[offset + 5] = normals[index2][2];
+  }
+  return {
+    numProp: 6,
+    numVert: positions.length,
+    numTri: indices.length / 3,
+    vertProperties,
+    triVerts: new Uint32Array(indices)
+  };
+}
+function meshFromSurfaceFillPlan(plan) {
+  if (!hasUnconstrainedCoonsFillBoundaries(plan))
+    return meshFromPlanarBoundaryLoop(sampledFillBoundaryLoop(plan), "SDF sampled Surface.Fill()");
+  return meshFromSurfaceGrid(surfaceGridForFillPlan(plan), null, "SDF filled surface");
+}
+function meshFromOpenNurbsSurface(plan) {
+  const sample = surfaceGridForNurbsPlan(plan);
+  return meshFromSurfaceGrid(sample.grid, sample.trim ?? null, "SDF NURBS surface", sample.uvGrid);
+}
+function surfaceGridForNurbsPlan(plan) {
+  const surface = new NurbsSurface(plan.controlGrid, {
+    degreeU: plan.degreeU,
+    degreeV: plan.degreeV,
+    weights: plan.weightsGrid,
+    knotsU: plan.knotsU,
+    knotsV: plan.knotsV,
+    domain: plan.domain
+  });
+  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], uvGrid };
+}
+function surfaceGridForSheetPlan(plan) {
+  if (plan.kind === "queryOwner") return surfaceGridForSheetPlan(plan.base);
+  if (plan.kind === "transform") {
+    const sample = surfaceGridForSheetPlan(plan.base);
+    let grid = sample.grid;
+    for (const step of plan.steps) {
+      const matrix = matrixFromShapeCompileTransformStep(step);
+      grid = grid.map((row) => row.map((point2) => transformPoint$1(matrix, point2)));
+    }
+    return { ...sample, grid };
+  }
+  if (plan.kind === "nurbsSurface") return surfaceGridForNurbsPlan(plan);
+  if (plan.kind === "analyticSurface") {
+    const { grid, trim, uvGrid } = surfaceGridForAnalyticPlan(plan);
+    return { grid, rowAxis: "u", trim, uDomain: [0, 1], vDomain: [0, 1], uvGrid };
+  }
+  if (plan.kind === "surfaceRuled") return { grid: surfaceGridForRuledPlan(plan), rowAxis: "v" };
+  if (plan.kind === "surfaceFill") return { grid: surfaceGridForFillPlan(plan), rowAxis: "v" };
+  if (plan.kind === "surfaceExtend") return surfaceGridForExtendedPlan(plan);
+  throw new Error("SDF backend can Surface.Extend() only sampled NURBS, analytic, ruled, fill, or already-extended sheets right now.");
+}
+function averageBoundaryStep(points, adjacent) {
+  let total = 0;
+  let count = 0;
+  for (let index2 = 0; index2 < points.length; index2 += 1) {
+    const distance = distance3(points[index2], adjacent[index2]);
+    if (distance > 1e-9) {
+      total += distance;
+      count += 1;
+    }
+  }
+  return count === 0 ? 1 : total / count;
+}
+function extendPoint(boundary, adjacent, scale2) {
+  return [
+    boundary[0] + (boundary[0] - adjacent[0]) * scale2,
+    boundary[1] + (boundary[1] - adjacent[1]) * scale2,
+    boundary[2] + (boundary[2] - adjacent[2]) * scale2
+  ];
+}
+function defaultUvGrid(rows, cols, uDomain, vDomain) {
+  const grid = [];
+  for (let row = 0; row < rows; row += 1) {
+    const u2 = rows === 1 ? uDomain[0] : uDomain[0] + (uDomain[1] - uDomain[0]) * row / (rows - 1);
+    const uvRow = [];
+    for (let col = 0; col < cols; col += 1) {
+      const v = cols === 1 ? vDomain[0] : vDomain[0] + (vDomain[1] - vDomain[0]) * col / (cols - 1);
+      uvRow.push([u2, v]);
+    }
+    grid.push(uvRow);
+  }
+  return grid;
+}
+function averageUvAxis(points, axis) {
+  return points.reduce((total, point2) => total + point2[axis], 0) / points.length;
+}
+function extendTrimLoop(loop, axis, from, to) {
+  const tolerance = Math.max(1e-6, Math.abs(to - from) * 1e-6);
+  let hits = 0;
+  const extended = loop.map((point2) => {
+    if (Math.abs(point2[axis] - from) > tolerance) return point2;
+    hits += 1;
+    const next = [...point2];
+    next[axis] = to;
+    return next;
+  });
+  return { loop: extended, hits };
+}
+function extendTrimForBoundary(trim, axis, from, to) {
+  if (!trim) return null;
+  const outer = extendTrimLoop(trim.outer, axis, from, to);
+  if (outer.hits < 2) {
+    const name = axis === 0 ? "u" : "v";
+    throw new Error(`SDF backend Surface.Extend() trimmed sheet has no visible ${name} boundary on the selected edge.`);
+  }
+  return {
+    outer: outer.loop,
+    holes: trim.holes.map((hole) => extendTrimLoop(hole, axis, from, to).loop)
+  };
+}
+function uvDomainFromGrid(uvGrid) {
+  let uMin = Number.POSITIVE_INFINITY;
+  let uMax = Number.NEGATIVE_INFINITY;
+  let vMin = Number.POSITIVE_INFINITY;
+  let vMax = Number.NEGATIVE_INFINITY;
+  for (const row of uvGrid) {
+    for (const [u2, v] of row) {
+      uMin = Math.min(uMin, u2);
+      uMax = Math.max(uMax, u2);
+      vMin = Math.min(vMin, v);
+      vMax = Math.max(vMax, v);
+    }
+  }
+  return { uDomain: [uMin, uMax], vDomain: [vMin, vMax] };
+}
+function surfaceGridForExtendedPlan(plan) {
+  var _a3;
+  const sample = surfaceGridForSheetPlan(plan.base);
+  const grid = sample.grid.map((row) => [...row]);
+  const rows = grid.length;
+  const cols = ((_a3 = grid[0]) == null ? void 0 : _a3.length) ?? 0;
+  if (rows < 2 || cols < 2) throw new Error("SDF backend Surface.Extend() requires at least a 2x2 sampled sheet.");
+  const uvGrid = sample.uvGrid ?? defaultUvGrid(rows, cols, sample.uDomain ?? [0, 1], sample.vDomain ?? [0, 1]);
+  const trimAxis = plan.inU ? 0 : 1;
+  const extendRows = plan.inU ? sample.rowAxis === "u" : sample.rowAxis === "v";
+  if (extendRows) {
+    const boundaryIndex = plan.after ? rows - 1 : 0;
+    const adjacentIndex = plan.after ? rows - 2 : 1;
+    const boundary2 = grid[boundaryIndex];
+    const adjacent2 = grid[adjacentIndex];
+    const boundaryUv2 = uvGrid[boundaryIndex];
+    const adjacentUv2 = uvGrid[adjacentIndex];
+    const scale22 = plan.length / averageBoundaryStep(boundary2, adjacent2);
+    const extension = boundary2.map((point2, index2) => extendPoint(point2, adjacent2[index2], scale22));
+    const extensionUv = boundaryUv2.map(
+      (uv, index2) => [uv[0] + (uv[0] - adjacentUv2[index2][0]) * scale22, uv[1] + (uv[1] - adjacentUv2[index2][1]) * scale22]
+    );
+    const nextGrid2 = plan.after ? [...grid, extension] : [extension, ...grid];
+    const nextUvGrid2 = plan.after ? [...uvGrid, extensionUv] : [extensionUv, ...uvGrid];
+    const domain2 = uvDomainFromGrid(nextUvGrid2);
+    return {
+      grid: nextGrid2,
+      rowAxis: sample.rowAxis,
+      trim: extendTrimForBoundary(sample.trim, trimAxis, averageUvAxis(boundaryUv2, trimAxis), averageUvAxis(extensionUv, trimAxis)),
+      uvGrid: nextUvGrid2,
+      ...domain2
+    };
+  }
+  const boundaryCol = plan.after ? cols - 1 : 0;
+  const adjacentCol = plan.after ? cols - 2 : 1;
+  const boundary = grid.map((row) => row[boundaryCol]);
+  const adjacent = grid.map((row) => row[adjacentCol]);
+  const boundaryUv = uvGrid.map((row) => row[boundaryCol]);
+  const adjacentUv = uvGrid.map((row) => row[adjacentCol]);
+  const scale2 = plan.length / averageBoundaryStep(boundary, adjacent);
+  const nextGrid = grid.map((row, rowIndex) => {
+    const extension = extendPoint(row[boundaryCol], adjacent[rowIndex], scale2);
+    return plan.after ? [...row, extension] : [extension, ...row];
+  });
+  const nextUvGrid = uvGrid.map((row, rowIndex) => {
+    const uv = boundaryUv[rowIndex];
+    const adjacent2 = adjacentUv[rowIndex];
+    const extensionUv = [uv[0] + (uv[0] - adjacent2[0]) * scale2, uv[1] + (uv[1] - adjacent2[1]) * scale2];
+    return plan.after ? [...row, extensionUv] : [extensionUv, ...row];
+  });
+  const domain = uvDomainFromGrid(nextUvGrid);
+  return {
+    grid: nextGrid,
+    rowAxis: sample.rowAxis,
+    trim: extendTrimForBoundary(
+      sample.trim,
+      trimAxis,
+      averageUvAxis(boundaryUv, trimAxis),
+      averageUvAxis(
+        nextUvGrid.map((row) => row[plan.after ? cols : 0]),
+        trimAxis
+      )
+    ),
+    uvGrid: nextUvGrid,
+    ...domain
+  };
+}
+function vertex(mesh, index2) {
+  const offset = index2 * mesh.numProp;
+  return [mesh.vertProperties[offset], mesh.vertProperties[offset + 1], mesh.vertProperties[offset + 2]];
+}
+function normal(mesh, index2) {
+  if (mesh.numProp < 6) throw new Error("SDF surface thickening requires mesh normals.");
+  const offset = index2 * mesh.numProp;
+  return [mesh.vertProperties[offset + 3], mesh.vertProperties[offset + 4], mesh.vertProperties[offset + 5]];
+}
+function boundaryEdges(mesh) {
+  const edges = /* @__PURE__ */ new Map();
+  const add2 = (a2, b) => {
+    const key2 = a2 < b ? `${a2}/${b}` : `${b}/${a2}`;
+    const existing = edges.get(key2);
+    if (existing) existing.count += 1;
+    else edges.set(key2, { a: a2, b, count: 1 });
+  };
+  for (let tri = 0; tri < mesh.numTri; tri += 1) {
+    const a2 = mesh.triVerts[tri * 3];
+    const b = mesh.triVerts[tri * 3 + 1];
+    const c2 = mesh.triVerts[tri * 3 + 2];
+    add2(a2, b);
+    add2(b, c2);
+    add2(c2, a2);
+  }
+  return [...edges.values()].filter((edge) => edge.count === 1).map((edge) => [edge.a, edge.b]);
+}
+function thicknessAtMeshVertex(openMesh, index2, thickness, field2) {
+  if (!field2) return thickness;
+  if (openMesh.numProp !== NUM_PROP_WITH_UV) {
+    throw new Error(
+      "Variable surface thickness requires a parametric UV sheet. Use Surface.Net, Surface.Nurbs, or an analytic Surface.* sheet."
+    );
+  }
+  const offset = index2 * openMesh.numProp;
+  const value = evaluateThicknessField(field2, openMesh.vertProperties[offset + UV_OFFSET], openMesh.vertProperties[offset + UV_OFFSET + 1]);
+  if (!Number.isFinite(value) || value <= 0) throw new Error(`Variable surface thickness evaluated to ${value} at vertex ${index2}.`);
+  return value;
+}
+function meshFromThickenedOpenSurface(openMesh, thickness, field2) {
+  const topCount = openMesh.numVert ?? openMesh.vertProperties.length / openMesh.numProp;
+  const allPositions = [];
+  for (let index2 = 0; index2 < topCount; index2 += 1) {
+    const [x2, y2, z2] = vertex(openMesh, index2);
+    allPositions.push(x2, y2, z2);
+  }
+  for (let index2 = 0; index2 < topCount; index2 += 1) {
+    const [x2, y2, z2] = vertex(openMesh, index2);
+    const [nx, ny, nz] = normal(openMesh, index2);
+    const localThickness = thicknessAtMeshVertex(openMesh, index2, thickness, field2);
+    allPositions.push(x2 - nx * localThickness, y2 - ny * localThickness, z2 - nz * localThickness);
+  }
+  const allIndices = [];
+  for (const index2 of openMesh.triVerts) allIndices.push(index2);
+  for (let index2 = 0; index2 < openMesh.triVerts.length; index2 += 3) {
+    allIndices.push(openMesh.triVerts[index2] + topCount, openMesh.triVerts[index2 + 2] + topCount, openMesh.triVerts[index2 + 1] + topCount);
+  }
+  for (const [a2, b] of boundaryEdges(openMesh)) {
+    allIndices.push(a2, a2 + topCount, b, b, a2 + topCount, b + topCount);
+  }
+  return {
+    numProp: 3,
+    numVert: allPositions.length / 3,
+    numTri: allIndices.length / 3,
+    vertProperties: new Float32Array(allPositions),
+    triVerts: new Uint32Array(allIndices)
+  };
+}
+function mergeSurfaceMeshes(meshes) {
+  const positions = [];
+  const normals = [];
+  const indices = [];
+  const vertexByKey = /* @__PURE__ */ new Map();
+  const keyFor2 = (point2) => point2.map((value) => value.toFixed(7)).join(",");
+  for (const mesh of meshes) {
+    const remap = /* @__PURE__ */ new Map();
+    const count = mesh.numVert ?? mesh.vertProperties.length / mesh.numProp;
+    for (let index2 = 0; index2 < count; index2 += 1) {
+      const offset = index2 * mesh.numProp;
+      const point2 = [mesh.vertProperties[offset], mesh.vertProperties[offset + 1], mesh.vertProperties[offset + 2]];
+      const key2 = keyFor2(point2);
+      let target = vertexByKey.get(key2);
+      if (target === void 0) {
+        target = positions.length;
+        vertexByKey.set(key2, target);
+        positions.push(point2);
+        normals.push([0, 0, 0]);
+      }
+      if (mesh.numProp >= 6) {
+        normals[target][0] += mesh.vertProperties[offset + 3];
+        normals[target][1] += mesh.vertProperties[offset + 4];
+        normals[target][2] += mesh.vertProperties[offset + 5];
+      }
+      remap.set(index2, target);
+    }
+    for (const sourceIndex of mesh.triVerts) {
+      const mapped = remap.get(sourceIndex);
+      if (mapped === void 0) throw new Error("SDF surface mesh merge encountered an invalid triangle index.");
+      indices.push(mapped);
+    }
+  }
+  const fallbackNormals = computeGridNormals(positions, indices);
+  const vertProperties = new Float32Array(positions.length * 6);
+  for (let index2 = 0; index2 < positions.length; index2 += 1) {
+    const normal2 = Math.hypot(...normals[index2]) <= 1e-12 ? fallbackNormals[index2] : normalize3$2(normals[index2], "SDF surface mesh normal");
+    const offset = index2 * 6;
+    vertProperties[offset] = positions[index2][0];
+    vertProperties[offset + 1] = positions[index2][1];
+    vertProperties[offset + 2] = positions[index2][2];
+    vertProperties[offset + 3] = normal2[0];
+    vertProperties[offset + 4] = normal2[1];
+    vertProperties[offset + 5] = normal2[2];
+  }
+  return {
+    numProp: 6,
+    numVert: positions.length,
+    numTri: indices.length / 3,
+    vertProperties,
+    triVerts: new Uint32Array(indices)
+  };
+}
+function isOpenSurfaceSheetMeshPlan(plan) {
+  if (plan.kind === "queryOwner") return isOpenSurfaceSheetMeshPlan(plan.base);
+  if (plan.kind === "transform") return isOpenSurfaceSheetMeshPlan(plan.base);
+  if (plan.kind === "trimByPlane") return isOpenSurfaceSheetMeshPlan(plan.base);
+  if (plan.kind === "boolean") return plan.op === "union" && plan.shapes.every(isOpenSurfaceSheetMeshPlan);
+  return plan.kind === "nurbsSurface" && plan.thickness === 0 || plan.kind === "analyticSurface" || plan.kind === "surfaceRuled" || plan.kind === "surfaceFill" || plan.kind === "surfaceExtend" || plan.kind === "surfaceSew";
+}
+function meshFromOpenSurfaceSheetPlan(plan) {
+  if (plan.kind === "queryOwner") return meshFromOpenSurfaceSheetPlan(plan.base);
+  if (plan.kind === "transform") return transformRuntimeMeshSteps(meshFromOpenSurfaceSheetPlan(plan.base), plan.steps);
+  if (plan.kind === "trimByPlane") {
+    return clipSurfaceMeshByPlane(meshFromOpenSurfaceSheetPlan(plan.base), [plan.normalX, plan.normalY, plan.normalZ], plan.originOffset);
+  }
+  if (plan.kind === "boolean" && plan.op === "union" && plan.shapes.every(isOpenSurfaceSheetMeshPlan)) {
+    return mergeSurfaceMeshes(plan.shapes.map(meshFromOpenSurfaceSheetPlan));
+  }
+  if (plan.kind === "nurbsSurface") return meshFromOpenNurbsSurface(plan);
+  if (plan.kind === "analyticSurface") {
+    const { grid, trim, uvGrid } = surfaceGridForAnalyticPlan(plan);
+    return meshFromSurfaceGrid(grid, trim, "SDF analytic surface", uvGrid);
+  }
+  if (plan.kind === "surfaceRuled") return meshFromSurfaceGrid(surfaceGridForRuledPlan(plan), null, "SDF ruled surface");
+  if (plan.kind === "surfaceFill") return meshFromSurfaceFillPlan(plan);
+  if (plan.kind === "surfaceExtend") {
+    const sample = surfaceGridForExtendedPlan(plan);
+    return meshFromSurfaceGrid(sample.grid, sample.trim ?? null, "SDF extended surface", sample.uvGrid);
+  }
+  if (plan.kind === "surfaceSew") return mergeSurfaceMeshes(plan.shapes.map(meshFromOpenSurfaceSheetPlan));
+  throw new Error("SDF backend can render open surface sheets only for NURBS, analytic, ruled, fill, sew, and union plans right now.");
+}
+function meshFromThickenedSurfaceSheetPlan(plan, thickness, field2) {
+  return meshFromThickenedOpenSurface(meshFromOpenSurfaceSheetPlan(plan), thickness, field2);
+}
 const DEFAULT_LEAF_SIZE = 8;
 function cloneVec3$3(value) {
   return [value[0], value[1], value[2]];
@@ -51306,9 +52906,9 @@ function summarizeRoughnessTriangles(triangles, edgeAngles, edgeCount, boundaryE
   };
   let totalArea = 0;
   for (const tri of triangles) {
-    const area = Number.isFinite(tri.area) ? tri.area : 0;
-    totalArea += area;
-    areaByClass[roughnessClassForAngle(tri.maxAngleDeg, options)] += area;
+    const area2 = Number.isFinite(tri.area) ? tri.area : 0;
+    totalArea += area2;
+    areaByClass[roughnessClassForAngle(tri.maxAngleDeg, options)] += area2;
   }
   const sortedAngles = [...edgeAngles].sort((lhs, rhs) => lhs - rhs);
   const meanAngleDeg = sortedAngles.length > 0 ? Number((sortedAngles.reduce((sum2, angle) => sum2 + angle, 0) / sortedAngles.length).toFixed(2)) : null;
@@ -51439,22 +53039,22 @@ function readSurfaceTriangles(position) {
   const b = new Vector3();
   const c2 = new Vector3();
   const ac = new Vector3();
-  const normal = new Vector3();
+  const normal2 = new Vector3();
   const triangleCount = Math.floor(position.count / 3);
   for (let tri = 0; tri < triangleCount; tri += 1) {
     const offset = tri * 3;
     a2.fromBufferAttribute(position, offset);
     b.fromBufferAttribute(position, offset + 1);
     c2.fromBufferAttribute(position, offset + 2);
-    normal.subVectors(b, a2).cross(ac.subVectors(c2, a2));
-    const areaTwice = normal.length();
+    normal2.subVectors(b, a2).cross(ac.subVectors(c2, a2));
+    const areaTwice = normal2.length();
     if (areaTwice <= MIN_TRIANGLE_AREA) continue;
     triangles.push({
       index: tri,
       a: a2.clone(),
       b: b.clone(),
       c: c2.clone(),
-      normal: normal.clone().multiplyScalar(1 / areaTwice),
+      normal: normal2.clone().multiplyScalar(1 / areaTwice),
       area: areaTwice * 0.5
     });
   }
@@ -51578,7 +53178,7 @@ function analyzeRoughnessGeometry(sourceGeometry, rawOptions = {}) {
   const b = new Vector3();
   const c2 = new Vector3();
   const ac = new Vector3();
-  const normal = new Vector3();
+  const normal2 = new Vector3();
   const bbox = new Box3().setFromBufferAttribute(position);
   const snap2 = Math.max(1e-6, bbox.getSize(new Vector3()).length() * 1e-8);
   for (let tri = 0; tri < triangleCount; tri += 1) {
@@ -51586,10 +53186,10 @@ function analyzeRoughnessGeometry(sourceGeometry, rawOptions = {}) {
     readVertex(position, offset, a2);
     readVertex(position, offset + 1, b);
     readVertex(position, offset + 2, c2);
-    normal.subVectors(b, a2).cross(ac.subVectors(c2, a2));
-    const areaTwice = normal.length();
+    normal2.subVectors(b, a2).cross(ac.subVectors(c2, a2));
+    const areaTwice = normal2.length();
     triangles[tri] = { area: areaTwice * 0.5, maxAngleDeg: 0 };
-    normals[tri] = areaTwice > 1e-12 ? normal.multiplyScalar(1 / areaTwice).clone() : new Vector3(0, 0, 1);
+    normals[tri] = areaTwice > 1e-12 ? normal2.multiplyScalar(1 / areaTwice).clone() : new Vector3(0, 0, 1);
     const keys = [vertexKey$1(a2, snap2), vertexKey$1(b, snap2), vertexKey$1(c2, snap2)];
     for (let edge = 0; edge < 3; edge += 1) {
       const key2 = edgeKey$2(keys[edge], keys[(edge + 1) % 3]);
@@ -53518,7 +55118,7 @@ function checkIntersection(ray2, pA, pB, pC, point2, side, near, far) {
     point: point2.clone()
   };
 }
-function checkBufferGeometryIntersection(ray2, position, normal, uv, uv1, a2, b, c2, side, near, far) {
+function checkBufferGeometryIntersection(ray2, position, normal2, uv, uv1, a2, b, c2, side, near, far) {
   _vA.fromBufferAttribute(position, a2);
   _vB.fromBufferAttribute(position, b);
   _vC.fromBufferAttribute(position, c2);
@@ -53538,10 +55138,10 @@ function checkBufferGeometryIntersection(ray2, position, normal, uv, uv1, a2, b,
       _uvC.fromBufferAttribute(uv1, c2);
       intersection2.uv1 = Triangle.getInterpolation(_intersectionPoint, _vA, _vB, _vC, _uvA, _uvB, _uvC, new Vector2());
     }
-    if (normal) {
-      _normalA.fromBufferAttribute(normal, a2);
-      _normalB.fromBufferAttribute(normal, b);
-      _normalC.fromBufferAttribute(normal, c2);
+    if (normal2) {
+      _normalA.fromBufferAttribute(normal2, a2);
+      _normalB.fromBufferAttribute(normal2, b);
+      _normalC.fromBufferAttribute(normal2, c2);
       intersection2.normal = Triangle.getInterpolation(_intersectionPoint, _vA, _vB, _vC, _normalA, _normalB, _normalC, new Vector3());
       if (intersection2.normal.dot(ray2.direction) > 0) {
         intersection2.normal.multiplyScalar(-1);
@@ -53574,8 +55174,8 @@ function intersectTri(geo, side, ray2, tri, intersections, near, far) {
     b = index2.getX(b);
     c2 = index2.getX(c2);
   }
-  const { position, normal, uv, uv1 } = geo.attributes;
-  const intersection2 = checkBufferGeometryIntersection(ray2, position, normal, uv, uv1, a2, b, c2, side, near, far);
+  const { position, normal: normal2, uv, uv1 } = geo.attributes;
+  const intersection2 = checkBufferGeometryIntersection(ray2, position, normal2, uv, uv1, a2, b, c2, side, near, far);
   if (intersection2) {
     intersection2.faceIndex = tri;
     if (intersections) intersections.push(intersection2);
@@ -53815,27 +55415,27 @@ function iterateOverTriangles_indirect(offset, count, bvh, intersectsTriangleFun
   }
   return false;
 }
-function raycast(bvh, root, side, ray2, intersects, near, far) {
+function raycast(bvh, root, side, ray2, intersects2, near, far) {
   BufferStack.setBuffer(bvh._roots[root]);
-  _raycast$1(0, bvh, side, ray2, intersects, near, far);
+  _raycast$1(0, bvh, side, ray2, intersects2, near, far);
   BufferStack.clearBuffer();
 }
-function _raycast$1(nodeIndex32, bvh, side, ray2, intersects, near, far) {
+function _raycast$1(nodeIndex32, bvh, side, ray2, intersects2, near, far) {
   const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
   const nodeIndex16 = nodeIndex32 * 2;
   const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
   if (isLeaf) {
     const offset = OFFSET(nodeIndex32, uint32Array2);
     const count = COUNT(nodeIndex16, uint16Array2);
-    intersectTris(bvh, side, ray2, offset, count, intersects, near, far);
+    intersectTris(bvh, side, ray2, offset, count, intersects2, near, far);
   } else {
     const leftIndex = LEFT_NODE(nodeIndex32);
     if (intersectRay(leftIndex, float32Array2, ray2, near, far)) {
-      _raycast$1(leftIndex, bvh, side, ray2, intersects, near, far);
+      _raycast$1(leftIndex, bvh, side, ray2, intersects2, near, far);
     }
     const rightIndex = RIGHT_NODE(nodeIndex32, uint32Array2);
     if (intersectRay(rightIndex, float32Array2, ray2, near, far)) {
-      _raycast$1(rightIndex, bvh, side, ray2, intersects, near, far);
+      _raycast$1(rightIndex, bvh, side, ray2, intersects2, near, far);
     }
   }
 }
@@ -54209,27 +55809,27 @@ function refit_indirect(bvh, nodeIndices = null) {
     }
   }
 }
-function raycast_indirect(bvh, root, side, ray2, intersects, near, far) {
+function raycast_indirect(bvh, root, side, ray2, intersects2, near, far) {
   BufferStack.setBuffer(bvh._roots[root]);
-  _raycast(0, bvh, side, ray2, intersects, near, far);
+  _raycast(0, bvh, side, ray2, intersects2, near, far);
   BufferStack.clearBuffer();
 }
-function _raycast(nodeIndex32, bvh, side, ray2, intersects, near, far) {
+function _raycast(nodeIndex32, bvh, side, ray2, intersects2, near, far) {
   const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
   const nodeIndex16 = nodeIndex32 * 2;
   const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
   if (isLeaf) {
     const offset = OFFSET(nodeIndex32, uint32Array2);
     const count = COUNT(nodeIndex16, uint16Array2);
-    intersectTris_indirect(bvh, side, ray2, offset, count, intersects, near, far);
+    intersectTris_indirect(bvh, side, ray2, offset, count, intersects2, near, far);
   } else {
     const leftIndex = LEFT_NODE(nodeIndex32);
     if (intersectRay(leftIndex, float32Array2, ray2, near, far)) {
-      _raycast(leftIndex, bvh, side, ray2, intersects, near, far);
+      _raycast(leftIndex, bvh, side, ray2, intersects2, near, far);
     }
     const rightIndex = RIGHT_NODE(nodeIndex32, uint32Array2);
     if (intersectRay(rightIndex, float32Array2, ray2, near, far)) {
-      _raycast(rightIndex, bvh, side, ray2, intersects, near, far);
+      _raycast(rightIndex, bvh, side, ray2, intersects2, near, far);
     }
   }
 }
@@ -54899,7 +56499,7 @@ class MeshBVH {
   raycast(ray2, materialOrSide = FrontSide, near = 0, far = Infinity) {
     const roots = this._roots;
     const geometry = this.geometry;
-    const intersects = [];
+    const intersects2 = [];
     const isMaterial = materialOrSide.isMaterial;
     const isArrayMaterial = Array.isArray(materialOrSide);
     const groups = geometry.groups;
@@ -54907,16 +56507,16 @@ class MeshBVH {
     const raycastFunc = this.indirect ? raycast_indirect : raycast;
     for (let i = 0, l = roots.length; i < l; i++) {
       const materialSide = isArrayMaterial ? materialOrSide[groups[i].materialIndex].side : side;
-      const startCount = intersects.length;
-      raycastFunc(this, i, materialSide, ray2, intersects, near, far);
+      const startCount = intersects2.length;
+      raycastFunc(this, i, materialSide, ray2, intersects2, near, far);
       if (isArrayMaterial) {
         const materialIndex = groups[i].materialIndex;
-        for (let j = startCount, jl = intersects.length; j < jl; j++) {
-          intersects[j].face.materialIndex = materialIndex;
+        for (let j = startCount, jl = intersects2.length; j < jl; j++) {
+          intersects2[j].face.materialIndex = materialIndex;
         }
       }
     }
-    return intersects;
+    return intersects2;
   }
   raycastFirst(ray2, materialOrSide = FrontSide, near = 0, far = Infinity) {
     const roots = this._roots;
@@ -55115,14 +56715,14 @@ const origBatchedRaycastFunc = BatchedMesh.prototype.raycast;
 const _worldScale = /* @__PURE__ */ new Vector3();
 const _mesh = /* @__PURE__ */ new Mesh();
 const _batchIntersects = [];
-function acceleratedRaycast(raycaster, intersects) {
+function acceleratedRaycast(raycaster, intersects2) {
   if (this.isBatchedMesh) {
-    acceleratedBatchedMeshRaycast.call(this, raycaster, intersects);
+    acceleratedBatchedMeshRaycast.call(this, raycaster, intersects2);
   } else {
-    acceleratedMeshRaycast.call(this, raycaster, intersects);
+    acceleratedMeshRaycast.call(this, raycaster, intersects2);
   }
 }
-function acceleratedBatchedMeshRaycast(raycaster, intersects) {
+function acceleratedBatchedMeshRaycast(raycaster, intersects2) {
   if (this.boundsTrees) {
     const boundsTrees = this.boundsTrees;
     const drawInfo = this._drawInfo || this._instanceInfo;
@@ -55153,7 +56753,7 @@ function acceleratedBatchedMeshRaycast(raycaster, intersects) {
         const intersect2 = _batchIntersects[j];
         intersect2.object = this;
         intersect2.batchId = i;
-        intersects.push(intersect2);
+        intersects2.push(intersect2);
       }
       _batchIntersects.length = 0;
     }
@@ -55162,10 +56762,10 @@ function acceleratedBatchedMeshRaycast(raycaster, intersects) {
     _mesh.material = null;
     _mesh.geometry = null;
   } else {
-    origBatchedRaycastFunc.call(this, raycaster, intersects);
+    origBatchedRaycastFunc.call(this, raycaster, intersects2);
   }
 }
-function acceleratedMeshRaycast(raycaster, intersects) {
+function acceleratedMeshRaycast(raycaster, intersects2) {
   if (this.geometry.boundsTree) {
     if (this.material === void 0) return;
     tmpInverseMatrix.copy(this.matrixWorld).invert();
@@ -55179,19 +56779,19 @@ function acceleratedMeshRaycast(raycaster, intersects) {
     if (raycaster.firstHitOnly === true) {
       const hit = convertRaycastIntersect(bvh.raycastFirst(ray, this.material, near, far), this, raycaster);
       if (hit) {
-        intersects.push(hit);
+        intersects2.push(hit);
       }
     } else {
       const hits = bvh.raycast(ray, this.material, near, far);
       for (let i = 0, l = hits.length; i < l; i++) {
         const hit = convertRaycastIntersect(hits[i], this, raycaster);
         if (hit) {
-          intersects.push(hit);
+          intersects2.push(hit);
         }
       }
     }
   } else {
-    origMeshRaycastFunc.call(this, raycaster, intersects);
+    origMeshRaycastFunc.call(this, raycaster, intersects2);
   }
 }
 function cloneGeometryForFaceColors$1(geometry) {
@@ -55248,13 +56848,13 @@ function firstOppositeSurfaceDistance(raycaster, rayTargetMeshes, point2, direct
   }
   return null;
 }
-function triangleThickness(raycaster, rayTargetMeshes, centroid, normal, epsilon2, far, contactTolerance) {
-  const forward = firstOppositeSurfaceDistance(raycaster, rayTargetMeshes, centroid, normal, epsilon2, far, contactTolerance);
+function triangleThickness(raycaster, rayTargetMeshes, centroid, normal2, epsilon2, far, contactTolerance) {
+  const forward = firstOppositeSurfaceDistance(raycaster, rayTargetMeshes, centroid, normal2, epsilon2, far, contactTolerance);
   const backward = firstOppositeSurfaceDistance(
     raycaster,
     rayTargetMeshes,
     centroid,
-    normal.clone().negate(),
+    normal2.clone().negate(),
     epsilon2,
     far,
     contactTolerance
@@ -55263,12 +56863,12 @@ function triangleThickness(raycaster, rayTargetMeshes, centroid, normal, epsilon
   if (backward == null) return forward;
   return Math.min(forward, backward);
 }
-function measureThicknessAtPoint(context, point2, normal) {
+function measureThicknessAtPoint(context, point2, normal2) {
   return triangleThickness(
     context.raycaster,
     context.rayTargetMeshes,
     point2,
-    normal,
+    normal2,
     context.epsilon,
     context.far,
     context.contactTolerance
@@ -55372,8 +56972,8 @@ function triangleMetrics(position, tri, a2, b, c2) {
   const ab = b.distanceTo(a2);
   const bc = c2.distanceTo(b);
   const ca = a2.distanceTo(c2);
-  const area = b.clone().sub(a2).cross(c2.clone().sub(a2)).length() * 0.5;
-  return { area, maxEdge: Math.max(ab, bc, ca) };
+  const area2 = b.clone().sub(a2).cross(c2.clone().sub(a2)).length() * 0.5;
+  return { area: area2, maxEdge: Math.max(ab, bc, ca) };
 }
 function buildTriangleInfos(position) {
   const triangleCount = Math.floor(position.count / 3);
@@ -55399,16 +56999,16 @@ function buildTriangleInfos(position) {
     const caLen = vc.distanceTo(va);
     ab.subVectors(vb, va);
     ac.subVectors(vc, va);
-    const normal = ab.clone().cross(ac);
-    const area = normal.length() * 0.5;
-    normal.normalize();
+    const normal2 = ab.clone().cross(ac);
+    const area2 = normal2.length() * 0.5;
+    normal2.normalize();
     infos.push({
       tri,
       a: va,
       b: vb,
       c: vc,
-      normal,
-      area,
+      normal: normal2,
+      area: area2,
       maxEdge: Math.max(abLen, bcLen, caLen)
     });
   }
@@ -55450,8 +57050,8 @@ function buildTriangleAdjacency(infos, tolerance) {
   }
   return adjacency.map((neighbors) => [...neighbors]);
 }
-function triangleOnPlane(info, origin, normal, tolerance) {
-  return Math.abs(info.a.clone().sub(origin).dot(normal)) <= tolerance && Math.abs(info.b.clone().sub(origin).dot(normal)) <= tolerance && Math.abs(info.c.clone().sub(origin).dot(normal)) <= tolerance;
+function triangleOnPlane(info, origin, normal2, tolerance) {
+  return Math.abs(info.a.clone().sub(origin).dot(normal2)) <= tolerance && Math.abs(info.b.clone().sub(origin).dot(normal2)) <= tolerance && Math.abs(info.c.clone().sub(origin).dot(normal2)) <= tolerance;
 }
 function detectPlanarComponents(infos, tolerance) {
   const adjacency = buildTriangleAdjacency(infos, tolerance);
@@ -55481,12 +57081,12 @@ function detectPlanarComponents(infos, tolerance) {
 }
 function planarBasis(component, infos) {
   const origin = infos[component[0]].a.clone();
-  const normal = new Vector3();
+  const normal2 = new Vector3();
   let bestEdge = new Vector3(1, 0, 0);
   let bestEdgeLength = 0;
   for (const tri of component) {
     const info = infos[tri];
-    normal.addScaledVector(info.normal, info.area);
+    normal2.addScaledVector(info.normal, info.area);
     for (const [left, right] of [
       [info.a, info.b],
       [info.b, info.c],
@@ -55500,15 +57100,15 @@ function planarBasis(component, infos) {
       }
     }
   }
-  normal.normalize();
-  const uAxis = bestEdge.sub(normal.clone().multiplyScalar(bestEdge.dot(normal)));
+  normal2.normalize();
+  const uAxis = bestEdge.sub(normal2.clone().multiplyScalar(bestEdge.dot(normal2)));
   if (uAxis.lengthSq() < 1e-12) {
-    uAxis.copy(Math.abs(normal.z) < 0.9 ? new Vector3(0, 0, 1) : new Vector3(1, 0, 0));
-    uAxis.sub(normal.clone().multiplyScalar(uAxis.dot(normal)));
+    uAxis.copy(Math.abs(normal2.z) < 0.9 ? new Vector3(0, 0, 1) : new Vector3(1, 0, 0));
+    uAxis.sub(normal2.clone().multiplyScalar(uAxis.dot(normal2)));
   }
   uAxis.normalize();
-  const vAxis = normal.clone().cross(uAxis).normalize();
-  return { origin, normal, uAxis, vAxis };
+  const vAxis = normal2.clone().cross(uAxis).normalize();
+  return { origin, normal: normal2, uAxis, vAxis };
 }
 function planarCoordinate(point2, patch) {
   const relative = point2.clone().sub(patch.origin);
@@ -55840,7 +57440,7 @@ function buildMeasuredSurfaceScalarField(sourceGeometry, rawOptions, fieldOption
     const aValue = new Float32Array(position.count);
     const measurementContext = measurement.createContext(fieldGeometry, rawOptions, context);
     const point2 = new Vector3();
-    const normal = new Vector3();
+    const normal2 = new Vector3();
     const ab = new Vector3();
     const ac = new Vector3();
     try {
@@ -55864,7 +57464,7 @@ function buildMeasuredSurfaceScalarField(sourceGeometry, rawOptions, fieldOption
         }
         ab.subVectors(b, a2);
         ac.subVectors(c2, a2);
-        normal.copy(ab).cross(ac).normalize();
+        normal2.copy(ab).cross(ac).normalize();
         uvs[tri * 6] = (patch.x + PATCH_GUTTER + 0.5) / width;
         uvs[tri * 6 + 1] = (patch.y + PATCH_GUTTER + 0.5) / height;
         uvs[tri * 6 + 2] = (patch.x + PATCH_GUTTER + patch.inner + 0.5) / width;
@@ -55875,7 +57475,7 @@ function buildMeasuredSurfaceScalarField(sourceGeometry, rawOptions, fieldOption
           for (let px = 0; px < patch.side; px += 1) {
             const [u2, v] = triangleParamForTexel(px, py, patch.inner);
             point2.copy(a2).addScaledVector(ab, u2).addScaledVector(ac, v);
-            const value = measurement.measureAtPoint(measurementContext, point2, normal);
+            const value = measurement.measureAtPoint(measurementContext, point2, normal2);
             const texel = (patch.y + py) * width + patch.x + px;
             if (value != null) values[texel] = value;
           }
@@ -55987,16 +57587,16 @@ function boxDistanceToPointSq(box, point2) {
   const z2 = point2.z < box.min.z ? box.min.z - point2.z : point2.z > box.max.z ? point2.z - box.max.z : 0;
   return x2 * x2 + y2 * y2 + z2 * z2;
 }
-function candidateTravelsThroughMaterial(context, point2, normal, candidate, candidateDistance) {
+function candidateTravelsThroughMaterial(context, point2, normal2, candidate, candidateDistance) {
   if (candidateDistance <= Math.max(context.epsilon, context.contactTolerance)) return false;
   const direction2 = candidate.clone().sub(point2).multiplyScalar(1 / candidateDistance);
-  if (direction2.dot(normal) >= -1e-5) return false;
+  if (direction2.dot(normal2) >= -1e-5) return false;
   const firstHit = firstRayHitDistance(context, point2, direction2);
   if (firstHit == null) return false;
   const tolerance = Math.max(context.contactTolerance, context.epsilon * 8);
   return Math.abs(firstHit - candidateDistance) <= tolerance;
 }
-function measureThroughThicknessAtPoint(context, point2, normal) {
+function measureThroughThicknessAtPoint(context, point2, normal2) {
   let bestDistanceSq = Infinity;
   const closest = new Vector3();
   const candidate = new Vector3();
@@ -56009,7 +57609,7 @@ function measureThroughThicknessAtPoint(context, point2, normal) {
         const distanceSq = candidate.distanceToSquared(point2);
         if (distanceSq >= bestDistanceSq) return;
         const distance = Math.sqrt(distanceSq);
-        if (!candidateTravelsThroughMaterial(context, point2, normal, candidate, distance)) return;
+        if (!candidateTravelsThroughMaterial(context, point2, normal2, candidate, distance)) return;
         bestDistanceSq = distanceSq;
         closest.copy(candidate);
       }
@@ -56272,10 +57872,10 @@ function vertexNormals(mesh) {
     const b = mesh.tris[t + 1];
     const c2 = mesh.tris[t + 2];
     const n = triNormal(mesh.positions, a2, b, c2);
-    const area = triArea(mesh.positions, a2, b, c2);
-    const nx = n[0] * area;
-    const ny = n[1] * area;
-    const nz = n[2] * area;
+    const area2 = triArea(mesh.positions, a2, b, c2);
+    const nx = n[0] * area2;
+    const ny = n[1] * area2;
+    const nz = n[2] * area2;
     for (const vi of [a2, b, c2]) {
       acc[vi * 3] += nx;
       acc[vi * 3 + 1] += ny;
@@ -56508,9 +58108,9 @@ function reconstructSurfaceScalarField(trianglePositions, samples, options = {})
     vertexCount
   };
 }
-const DEFAULT_COLORMAP = "viridis";
+const DEFAULT_COLORMAP = "inferno";
 const DEFAULT_THICKNESS_COLOR_SCALE = {
-  colormap: "viridis",
+  colormap: "inferno",
   domainMin: 0,
   domainMax: 6,
   reversed: true
@@ -56878,17 +58478,17 @@ class FrozenShapeBackend {
   scale(v) {
     return this.getReconstructedBackend().scale(v);
   }
-  mirror(normal) {
-    return this.getReconstructedBackend().mirror(normal);
+  mirror(normal2) {
+    return this.getReconstructedBackend().mirror(normal2);
   }
   split(other) {
     return this.getReconstructedBackend().split(other);
   }
-  splitByPlane(normal, originOffset) {
-    return this.getReconstructedBackend().splitByPlane(normal, originOffset);
+  splitByPlane(normal2, originOffset) {
+    return this.getReconstructedBackend().splitByPlane(normal2, originOffset);
   }
-  trimByPlane(normal, originOffset) {
-    return this.getReconstructedBackend().trimByPlane(normal, originOffset);
+  trimByPlane(normal2, originOffset) {
+    return this.getReconstructedBackend().trimByPlane(normal2, originOffset);
   }
   volume() {
     return this.getReconstructedBackend().volume();