forgecad 0.10.3 → 0.10.4

package/dist/assets/{inspectWorker-Y4cOzNyA.js → inspectWorker-ymhBV4Ll.js}

@@ -21,11 +21,14 @@ const UVMapping = 300;
 const RepeatWrapping = 1e3;
 const ClampToEdgeWrapping = 1001;
 const MirroredRepeatWrapping = 1002;
+const NearestFilter = 1003;
 const LinearFilter = 1006;
 const LinearMipmapLinearFilter = 1008;
 const UnsignedByteType = 1009;
+const UnsignedIntType = 1014;
 const FloatType = 1015;
 const RGBAFormat = 1023;
+const RedIntegerFormat = 1029;
 const NoColorSpace = "";
 const SRGBColorSpace = "srgb";
 const LinearSRGBColorSpace = "srgb-linear";
@@ -1083,12 +1086,12 @@ class Vector2 {
    * @param {number} angle - The angle to rotate, in radians.
    * @return {Vector2} A reference to this vector.
    */
-  rotateAround(center, angle) {
+  rotateAround(center2, angle) {
     const c2 = Math.cos(angle), s = Math.sin(angle);
-    const x2 = this.x - center.x;
-    const y2 = this.y - center.y;
-    this.x = x2 * c2 - y2 * s + center.x;
-    this.y = x2 * s + y2 * c2 + center.y;
+    const x2 = this.x - center2.x;
+    const y2 = this.y - center2.y;
+    this.x = x2 * c2 - y2 * s + center2.x;
+    this.y = x2 * s + y2 * c2 + center2.y;
     return this;
   }
   /**
@@ -4472,10 +4475,10 @@ class Box3 {
    * @param {Vector3} size - The x, y and z dimensions of the box.
    * @return {Box3} A reference to this bounding box.
    */
-  setFromCenterAndSize(center, size) {
+  setFromCenterAndSize(center2, size) {
     const halfSize = _vector$b.copy(size).multiplyScalar(0.5);
-    this.min.copy(center).sub(halfSize);
-    this.max.copy(center).add(halfSize);
+    this.min.copy(center2).sub(halfSize);
+    this.max.copy(center2).add(halfSize);
     return this;
   }
   /**
@@ -4925,9 +4928,9 @@ class Sphere {
    * @param {Vector3} [center=(0,0,0)] - The center of the sphere
    * @param {number} [radius=-1] - The radius of the sphere.
    */
-  constructor(center = new Vector3(), radius = -1) {
+  constructor(center2 = new Vector3(), radius = -1) {
     this.isSphere = true;
-    this.center = center;
+    this.center = center2;
     this.radius = radius;
   }
   /**
@@ -4937,8 +4940,8 @@ class Sphere {
    * @param {number} radius - The radius.
    * @return {Sphere} A reference to this sphere.
    */
-  set(center, radius) {
-    this.center.copy(center);
+  set(center2, radius) {
+    this.center.copy(center2);
     this.radius = radius;
     return this;
   }
@@ -4953,15 +4956,15 @@ class Sphere {
    * @return {Sphere} A reference to this sphere.
    */
   setFromPoints(points, optionalCenter) {
-    const center = this.center;
+    const center2 = this.center;
     if (optionalCenter !== void 0) {
-      center.copy(optionalCenter);
+      center2.copy(optionalCenter);
     } else {
-      _box$3.setFromPoints(points).getCenter(center);
+      _box$3.setFromPoints(points).getCenter(center2);
     }
     let maxRadiusSq = 0;
     for (let i = 0, il = points.length; i < il; i++) {
-      maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(points[i]));
+      maxRadiusSq = Math.max(maxRadiusSq, center2.distanceToSquared(points[i]));
     }
     this.radius = Math.sqrt(maxRadiusSq);
     return this;
@@ -5178,9 +5181,9 @@ class Ray {
    * @param {Vector3} [origin=(0,0,0)] - The origin of the ray.
    * @param {Vector3} [direction=(0,0,-1)] - The (normalized) direction of the ray.
    */
-  constructor(origin = new Vector3(), direction = new Vector3(0, 0, -1)) {
+  constructor(origin = new Vector3(), direction2 = new Vector3(0, 0, -1)) {
     this.origin = origin;
-    this.direction = direction;
+    this.direction = direction2;
   }
   /**
    * Sets the ray's components by copying the given values.
@@ -5189,9 +5192,9 @@ class Ray {
    * @param {Vector3} direction - The direction.
    * @return {Ray} A reference to this ray.
    */
-  set(origin, direction) {
+  set(origin, direction2) {
     this.origin.copy(origin);
-    this.direction.copy(direction);
+    this.direction.copy(direction2);
     return this;
   }
   /**
@@ -5200,9 +5203,9 @@ class Ray {
    * @param {Ray} ray - The ray to copy.
    * @return {Ray} A reference to this ray.
    */
-  copy(ray) {
-    this.origin.copy(ray.origin);
-    this.direction.copy(ray.direction);
+  copy(ray2) {
+    this.origin.copy(ray2.origin);
+    this.direction.copy(ray2.direction);
     return this;
   }
   /**
@@ -5534,8 +5537,8 @@ class Ray {
    * @param {Ray} ray - The ray to test for equality.
    * @return {boolean} Whether this ray is equal with the given one.
    */
-  equals(ray) {
-    return ray.origin.equals(this.origin) && ray.direction.equals(this.direction);
+  equals(ray2) {
+    return ray2.origin.equals(this.origin) && ray2.direction.equals(this.direction);
   }
   /**
    * Returns a new ray with copied values from this instance.
@@ -8069,10 +8072,10 @@ class Triangle {
    * @param {Vector3} direction - The (normalized) direction vector.
    * @return {boolean} Whether the triangle is oriented towards the given direction or not.
    */
-  static isFrontFacing(a2, b, c2, direction) {
+  static isFrontFacing(a2, b, c2, direction2) {
     _v0$1.subVectors(c2, b);
     _v1$3.subVectors(a2, b);
-    return _v0$1.cross(_v1$3).dot(direction) < 0 ? true : false;
+    return _v0$1.cross(_v1$3).dot(direction2) < 0 ? true : false;
   }
   /**
    * Sets the triangle's vertices by copying the given values.
@@ -8217,8 +8220,8 @@ class Triangle {
    * @param {Vector3} direction - The (normalized) direction vector.
    * @return {boolean} Whether the triangle is oriented towards the given direction or not.
    */
-  isFrontFacing(direction) {
-    return Triangle.isFrontFacing(this.a, this.b, this.c, direction);
+  isFrontFacing(direction2) {
+    return Triangle.isFrontFacing(this.a, this.b, this.c, direction2);
   }
   /**
    * Returns `true` if this triangle intersects with the given box.
@@ -10330,7 +10333,7 @@ class BufferGeometry extends EventDispatcher {
       return;
     }
     if (position) {
-      const center = this.boundingSphere.center;
+      const center2 = this.boundingSphere.center;
       _box$2.setFromBufferAttribute(position);
       if (morphAttributesPosition) {
         for (let i = 0, il = morphAttributesPosition.length; i < il; i++) {
@@ -10347,11 +10350,11 @@ class BufferGeometry extends EventDispatcher {
           }
         }
       }
-      _box$2.getCenter(center);
+      _box$2.getCenter(center2);
       let maxRadiusSq = 0;
       for (let i = 0, il = position.count; i < il; i++) {
         _vector$8.fromBufferAttribute(position, i);
-        maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector$8));
+        maxRadiusSq = Math.max(maxRadiusSq, center2.distanceToSquared(_vector$8));
       }
       if (morphAttributesPosition) {
         for (let i = 0, il = morphAttributesPosition.length; i < il; i++) {
@@ -10363,7 +10366,7 @@ class BufferGeometry extends EventDispatcher {
               _offset.fromBufferAttribute(position, j);
               _vector$8.add(_offset);
             }
-            maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector$8));
+            maxRadiusSq = Math.max(maxRadiusSq, center2.distanceToSquared(_vector$8));
           }
         }
       }
@@ -10930,12 +10933,12 @@ class Mesh extends Object3D {
     }
   }
 }
-function checkIntersection$1(object, material, raycaster, ray, pA, pB, pC, point2) {
+function checkIntersection$1(object, material, raycaster, ray2, pA, pB, pC, point2) {
   let intersect2;
   if (material.side === BackSide) {
-    intersect2 = ray.intersectTriangle(pC, pB, pA, true, point2);
+    intersect2 = ray2.intersectTriangle(pC, pB, pA, true, point2);
   } else {
-    intersect2 = ray.intersectTriangle(pA, pB, pC, material.side === FrontSide, point2);
+    intersect2 = ray2.intersectTriangle(pA, pB, pC, material.side === FrontSide, point2);
   }
   if (intersect2 === null) return null;
   _intersectionPointWorld.copy(point2);
@@ -10948,11 +10951,11 @@ function checkIntersection$1(object, material, raycaster, ray, pA, pB, pC, point
     object
   };
 }
-function checkGeometryIntersection(object, material, raycaster, ray, uv, uv1, normal, a2, b, c2) {
+function checkGeometryIntersection(object, material, raycaster, ray2, uv, uv1, normal, a2, b, c2) {
   object.getVertexPosition(a2, _vA$1);
   object.getVertexPosition(b, _vB$1);
   object.getVertexPosition(c2, _vC$1);
-  const intersection2 = checkIntersection$1(object, material, raycaster, ray, _vA$1, _vB$1, _vC$1, _intersectionPoint$1);
+  const intersection2 = checkIntersection$1(object, material, raycaster, ray2, _vA$1, _vB$1, _vC$1, _intersectionPoint$1);
   if (intersection2) {
     const barycoord = new Vector3();
     Triangle.getBarycoord(_intersectionPoint$1, _vA$1, _vB$1, _vC$1, barycoord);
@@ -10964,7 +10967,7 @@ function checkGeometryIntersection(object, material, raycaster, ray, uv, uv1, no
     }
     if (normal) {
       intersection2.normal = Triangle.getInterpolatedAttribute(normal, a2, b, c2, barycoord, new Vector3());
-      if (intersection2.normal.dot(ray.direction) > 0) {
+      if (intersection2.normal.dot(ray2.direction) > 0) {
         intersection2.normal.multiplyScalar(-1);
       }
     }
@@ -10981,6 +10984,32 @@ function checkGeometryIntersection(object, material, raycaster, ray, uv, uv1, no
   }
   return intersection2;
 }
+class DataTexture extends Texture {
+  /**
+   * Constructs a new data texture.
+   *
+   * @param {?TypedArray} [data=null] - The buffer data.
+   * @param {number} [width=1] - The width of the texture.
+   * @param {number} [height=1] - The height of the texture.
+   * @param {number} [format=RGBAFormat] - The texture format.
+   * @param {number} [type=UnsignedByteType] - The texture type.
+   * @param {number} [mapping=Texture.DEFAULT_MAPPING] - The texture mapping.
+   * @param {number} [wrapS=ClampToEdgeWrapping] - The wrapS value.
+   * @param {number} [wrapT=ClampToEdgeWrapping] - The wrapT value.
+   * @param {number} [magFilter=NearestFilter] - The mag filter value.
+   * @param {number} [minFilter=NearestFilter] - The min filter value.
+   * @param {number} [anisotropy=Texture.DEFAULT_ANISOTROPY] - The anisotropy value.
+   * @param {string} [colorSpace=NoColorSpace] - The color space.
+   */
+  constructor(data = null, width = 1, height = 1, format, type, mapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, colorSpace) {
+    super(null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace);
+    this.isDataTexture = true;
+    this.image = { data, width, height };
+    this.generateMipmaps = false;
+    this.flipY = false;
+    this.unpackAlignment = 1;
+  }
+}
 const _vector1 = /* @__PURE__ */ new Vector3();
 const _vector2 = /* @__PURE__ */ new Vector3();
 const _normalMatrix = /* @__PURE__ */ new Matrix3();
@@ -11121,8 +11150,8 @@ class Plane {
    * @return {?Vector3} The intersection point.
    */
   intersectLine(line, target) {
-    const direction = line.delta(_vector1);
-    const denominator = this.normal.dot(direction);
+    const direction2 = line.delta(_vector1);
+    const denominator = this.normal.dot(direction2);
     if (denominator === 0) {
       if (this.distanceToPoint(line.start) === 0) {
         return target.copy(line.start);
@@ -11133,7 +11162,7 @@ class Plane {
     if (t < 0 || t > 1) {
       return null;
     }
-    return target.copy(line.start).addScaledVector(direction, t);
+    return target.copy(line.start).addScaledVector(direction2, t);
   }
   /**
    * Returns `true` if the given line segment intersects with (passes through) the plane.
@@ -11222,6 +11251,1144 @@ class Plane {
     return new this.constructor().copy(this);
   }
 }
+const _sphere$3 = /* @__PURE__ */ new Sphere();
+const _vector$6 = /* @__PURE__ */ new Vector3();
+class Frustum {
+  /**
+   * Constructs a new frustum.
+   *
+   * @param {Plane} [p0] - The first plane that encloses the frustum.
+   * @param {Plane} [p1] - The second plane that encloses the frustum.
+   * @param {Plane} [p2] - The third plane that encloses the frustum.
+   * @param {Plane} [p3] - The fourth plane that encloses the frustum.
+   * @param {Plane} [p4] - The fifth plane that encloses the frustum.
+   * @param {Plane} [p5] - The sixth plane that encloses the frustum.
+   */
+  constructor(p0 = new Plane(), p1 = new Plane(), p2 = new Plane(), p3 = new Plane(), p4 = new Plane(), p5 = new Plane()) {
+    this.planes = [p0, p1, p2, p3, p4, p5];
+  }
+  /**
+   * Sets the frustum planes by copying the given planes.
+   *
+   * @param {Plane} [p0] - The first plane that encloses the frustum.
+   * @param {Plane} [p1] - The second plane that encloses the frustum.
+   * @param {Plane} [p2] - The third plane that encloses the frustum.
+   * @param {Plane} [p3] - The fourth plane that encloses the frustum.
+   * @param {Plane} [p4] - The fifth plane that encloses the frustum.
+   * @param {Plane} [p5] - The sixth plane that encloses the frustum.
+   * @return {Frustum} A reference to this frustum.
+   */
+  set(p0, p1, p2, p3, p4, p5) {
+    const planes = this.planes;
+    planes[0].copy(p0);
+    planes[1].copy(p1);
+    planes[2].copy(p2);
+    planes[3].copy(p3);
+    planes[4].copy(p4);
+    planes[5].copy(p5);
+    return this;
+  }
+  /**
+   * Copies the values of the given frustum to this instance.
+   *
+   * @param {Frustum} frustum - The frustum to copy.
+   * @return {Frustum} A reference to this frustum.
+   */
+  copy(frustum) {
+    const planes = this.planes;
+    for (let i = 0; i < 6; i++) {
+      planes[i].copy(frustum.planes[i]);
+    }
+    return this;
+  }
+  /**
+   * Sets the frustum planes from the given projection matrix.
+   *
+   * @param {Matrix4} m - The projection matrix.
+   * @param {(WebGLCoordinateSystem|WebGPUCoordinateSystem)} coordinateSystem - The coordinate system.
+   * @return {Frustum} A reference to this frustum.
+   */
+  setFromProjectionMatrix(m2, coordinateSystem = WebGLCoordinateSystem) {
+    const planes = this.planes;
+    const me = m2.elements;
+    const me0 = me[0], me1 = me[1], me2 = me[2], me3 = me[3];
+    const me4 = me[4], me5 = me[5], me6 = me[6], me7 = me[7];
+    const me8 = me[8], me9 = me[9], me10 = me[10], me11 = me[11];
+    const me12 = me[12], me13 = me[13], me14 = me[14], me15 = me[15];
+    planes[0].setComponents(me3 - me0, me7 - me4, me11 - me8, me15 - me12).normalize();
+    planes[1].setComponents(me3 + me0, me7 + me4, me11 + me8, me15 + me12).normalize();
+    planes[2].setComponents(me3 + me1, me7 + me5, me11 + me9, me15 + me13).normalize();
+    planes[3].setComponents(me3 - me1, me7 - me5, me11 - me9, me15 - me13).normalize();
+    planes[4].setComponents(me3 - me2, me7 - me6, me11 - me10, me15 - me14).normalize();
+    if (coordinateSystem === WebGLCoordinateSystem) {
+      planes[5].setComponents(me3 + me2, me7 + me6, me11 + me10, me15 + me14).normalize();
+    } else if (coordinateSystem === WebGPUCoordinateSystem) {
+      planes[5].setComponents(me2, me6, me10, me14).normalize();
+    } else {
+      throw new Error("THREE.Frustum.setFromProjectionMatrix(): Invalid coordinate system: " + coordinateSystem);
+    }
+    return this;
+  }
+  /**
+   * Returns `true` if the 3D object's bounding sphere is intersecting this frustum.
+   *
+   * Note that the 3D object must have a geometry so that the bounding sphere can be calculated.
+   *
+   * @param {Object3D} object - The 3D object to test.
+   * @return {boolean} Whether the 3D object's bounding sphere is intersecting this frustum or not.
+   */
+  intersectsObject(object) {
+    if (object.boundingSphere !== void 0) {
+      if (object.boundingSphere === null) object.computeBoundingSphere();
+      _sphere$3.copy(object.boundingSphere).applyMatrix4(object.matrixWorld);
+    } else {
+      const geometry = object.geometry;
+      if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
+      _sphere$3.copy(geometry.boundingSphere).applyMatrix4(object.matrixWorld);
+    }
+    return this.intersectsSphere(_sphere$3);
+  }
+  /**
+   * Returns `true` if the given sprite is intersecting this frustum.
+   *
+   * @param {Sprite} sprite - The sprite to test.
+   * @return {boolean} Whether the sprite is intersecting this frustum or not.
+   */
+  intersectsSprite(sprite) {
+    _sphere$3.center.set(0, 0, 0);
+    _sphere$3.radius = 0.7071067811865476;
+    _sphere$3.applyMatrix4(sprite.matrixWorld);
+    return this.intersectsSphere(_sphere$3);
+  }
+  /**
+   * Returns `true` if the given bounding sphere is intersecting this frustum.
+   *
+   * @param {Sphere} sphere - The bounding sphere to test.
+   * @return {boolean} Whether the bounding sphere is intersecting this frustum or not.
+   */
+  intersectsSphere(sphere) {
+    const planes = this.planes;
+    const center2 = sphere.center;
+    const negRadius = -sphere.radius;
+    for (let i = 0; i < 6; i++) {
+      const distance = planes[i].distanceToPoint(center2);
+      if (distance < negRadius) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Returns `true` if the given bounding box is intersecting this frustum.
+   *
+   * @param {Box3} box - The bounding box to test.
+   * @return {boolean} Whether the bounding box is intersecting this frustum or not.
+   */
+  intersectsBox(box) {
+    const planes = this.planes;
+    for (let i = 0; i < 6; i++) {
+      const plane = planes[i];
+      _vector$6.x = plane.normal.x > 0 ? box.max.x : box.min.x;
+      _vector$6.y = plane.normal.y > 0 ? box.max.y : box.min.y;
+      _vector$6.z = plane.normal.z > 0 ? box.max.z : box.min.z;
+      if (plane.distanceToPoint(_vector$6) < 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Returns `true` if the given point lies within the frustum.
+   *
+   * @param {Vector3} point - The point to test.
+   * @return {boolean} Whether the point lies within this frustum or not.
+   */
+  containsPoint(point2) {
+    const planes = this.planes;
+    for (let i = 0; i < 6; i++) {
+      if (planes[i].distanceToPoint(point2) < 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Returns a new frustum with copied values from this instance.
+   *
+   * @return {Frustum} A clone of this instance.
+   */
+  clone() {
+    return new this.constructor().copy(this);
+  }
+}
+function ascIdSort(a2, b) {
+  return a2 - b;
+}
+function sortOpaque(a2, b) {
+  return a2.z - b.z;
+}
+function sortTransparent(a2, b) {
+  return b.z - a2.z;
+}
+class MultiDrawRenderList {
+  constructor() {
+    this.index = 0;
+    this.pool = [];
+    this.list = [];
+  }
+  push(start, count, z2, index2) {
+    const pool = this.pool;
+    const list = this.list;
+    if (this.index >= pool.length) {
+      pool.push({
+        start: -1,
+        count: -1,
+        z: -1,
+        index: -1
+      });
+    }
+    const item = pool[this.index];
+    list.push(item);
+    this.index++;
+    item.start = start;
+    item.count = count;
+    item.z = z2;
+    item.index = index2;
+  }
+  reset() {
+    this.list.length = 0;
+    this.index = 0;
+  }
+}
+const _matrix$1 = /* @__PURE__ */ new Matrix4();
+const _whiteColor = /* @__PURE__ */ new Color(1, 1, 1);
+const _frustum = /* @__PURE__ */ new Frustum();
+const _box$1 = /* @__PURE__ */ new Box3();
+const _sphere$2 = /* @__PURE__ */ new Sphere();
+const _vector$5 = /* @__PURE__ */ new Vector3();
+const _forward = /* @__PURE__ */ new Vector3();
+const _temp = /* @__PURE__ */ new Vector3();
+const _renderList = /* @__PURE__ */ new MultiDrawRenderList();
+const _mesh$1 = /* @__PURE__ */ new Mesh();
+const _batchIntersects$1 = [];
+function copyAttributeData(src, target, targetOffset = 0) {
+  const itemSize = target.itemSize;
+  if (src.isInterleavedBufferAttribute || src.array.constructor !== target.array.constructor) {
+    const vertexCount = src.count;
+    for (let i = 0; i < vertexCount; i++) {
+      for (let c2 = 0; c2 < itemSize; c2++) {
+        target.setComponent(i + targetOffset, c2, src.getComponent(i, c2));
+      }
+    }
+  } else {
+    target.array.set(src.array, targetOffset * itemSize);
+  }
+  target.needsUpdate = true;
+}
+function copyArrayContents(src, target) {
+  if (src.constructor !== target.constructor) {
+    const len = Math.min(src.length, target.length);
+    for (let i = 0; i < len; i++) {
+      target[i] = src[i];
+    }
+  } else {
+    const len = Math.min(src.length, target.length);
+    target.set(new src.constructor(src.buffer, 0, len));
+  }
+}
+class BatchedMesh extends Mesh {
+  /**
+   * Constructs a new batched mesh.
+   *
+   * @param {number} maxInstanceCount - The maximum number of individual instances planned to be added and rendered.
+   * @param {number} maxVertexCount - The maximum number of vertices to be used by all unique geometries.
+   * @param {number} [maxIndexCount=maxVertexCount*2] - The maximum number of indices to be used by all unique geometries
+   * @param {Material|Array<Material>} [material] - The mesh material.
+   */
+  constructor(maxInstanceCount, maxVertexCount, maxIndexCount = maxVertexCount * 2, material) {
+    super(new BufferGeometry(), material);
+    this.isBatchedMesh = true;
+    this.perObjectFrustumCulled = true;
+    this.sortObjects = true;
+    this.boundingBox = null;
+    this.boundingSphere = null;
+    this.customSort = null;
+    this._instanceInfo = [];
+    this._geometryInfo = [];
+    this._availableInstanceIds = [];
+    this._availableGeometryIds = [];
+    this._nextIndexStart = 0;
+    this._nextVertexStart = 0;
+    this._geometryCount = 0;
+    this._visibilityChanged = true;
+    this._geometryInitialized = false;
+    this._maxInstanceCount = maxInstanceCount;
+    this._maxVertexCount = maxVertexCount;
+    this._maxIndexCount = maxIndexCount;
+    this._multiDrawCounts = new Int32Array(maxInstanceCount);
+    this._multiDrawStarts = new Int32Array(maxInstanceCount);
+    this._multiDrawCount = 0;
+    this._multiDrawInstances = null;
+    this._matricesTexture = null;
+    this._indirectTexture = null;
+    this._colorsTexture = null;
+    this._initMatricesTexture();
+    this._initIndirectTexture();
+  }
+  /**
+   * The maximum number of individual instances that can be stored in the batch.
+   *
+   * @type {number}
+   * @readonly
+   */
+  get maxInstanceCount() {
+    return this._maxInstanceCount;
+  }
+  /**
+   * The instance count.
+   *
+   * @type {number}
+   * @readonly
+   */
+  get instanceCount() {
+    return this._instanceInfo.length - this._availableInstanceIds.length;
+  }
+  /**
+   * The number of unused vertices.
+   *
+   * @type {number}
+   * @readonly
+   */
+  get unusedVertexCount() {
+    return this._maxVertexCount - this._nextVertexStart;
+  }
+  /**
+   * The number of unused indices.
+   *
+   * @type {number}
+   * @readonly
+   */
+  get unusedIndexCount() {
+    return this._maxIndexCount - this._nextIndexStart;
+  }
+  _initMatricesTexture() {
+    let size = Math.sqrt(this._maxInstanceCount * 4);
+    size = Math.ceil(size / 4) * 4;
+    size = Math.max(size, 4);
+    const matricesArray = new Float32Array(size * size * 4);
+    const matricesTexture = new DataTexture(matricesArray, size, size, RGBAFormat, FloatType);
+    this._matricesTexture = matricesTexture;
+  }
+  _initIndirectTexture() {
+    let size = Math.sqrt(this._maxInstanceCount);
+    size = Math.ceil(size);
+    const indirectArray = new Uint32Array(size * size);
+    const indirectTexture = new DataTexture(indirectArray, size, size, RedIntegerFormat, UnsignedIntType);
+    this._indirectTexture = indirectTexture;
+  }
+  _initColorsTexture() {
+    let size = Math.sqrt(this._maxInstanceCount);
+    size = Math.ceil(size);
+    const colorsArray = new Float32Array(size * size * 4).fill(1);
+    const colorsTexture = new DataTexture(colorsArray, size, size, RGBAFormat, FloatType);
+    colorsTexture.colorSpace = ColorManagement.workingColorSpace;
+    this._colorsTexture = colorsTexture;
+  }
+  _initializeGeometry(reference) {
+    const geometry = this.geometry;
+    const maxVertexCount = this._maxVertexCount;
+    const maxIndexCount = this._maxIndexCount;
+    if (this._geometryInitialized === false) {
+      for (const attributeName in reference.attributes) {
+        const srcAttribute = reference.getAttribute(attributeName);
+        const { array, itemSize, normalized } = srcAttribute;
+        const dstArray = new array.constructor(maxVertexCount * itemSize);
+        const dstAttribute = new BufferAttribute(dstArray, itemSize, normalized);
+        geometry.setAttribute(attributeName, dstAttribute);
+      }
+      if (reference.getIndex() !== null) {
+        const indexArray = maxVertexCount > 65535 ? new Uint32Array(maxIndexCount) : new Uint16Array(maxIndexCount);
+        geometry.setIndex(new BufferAttribute(indexArray, 1));
+      }
+      this._geometryInitialized = true;
+    }
+  }
+  // Make sure the geometry is compatible with the existing combined geometry attributes
+  _validateGeometry(geometry) {
+    const batchGeometry = this.geometry;
+    if (Boolean(geometry.getIndex()) !== Boolean(batchGeometry.getIndex())) {
+      throw new Error('THREE.BatchedMesh: All geometries must consistently have "index".');
+    }
+    for (const attributeName in batchGeometry.attributes) {
+      if (!geometry.hasAttribute(attributeName)) {
+        throw new Error(`THREE.BatchedMesh: Added geometry missing "${attributeName}". All geometries must have consistent attributes.`);
+      }
+      const srcAttribute = geometry.getAttribute(attributeName);
+      const dstAttribute = batchGeometry.getAttribute(attributeName);
+      if (srcAttribute.itemSize !== dstAttribute.itemSize || srcAttribute.normalized !== dstAttribute.normalized) {
+        throw new Error("THREE.BatchedMesh: All attributes must have a consistent itemSize and normalized value.");
+      }
+    }
+  }
+  /**
+   * Validates the instance defined by the given ID.
+   *
+   * @param {number} instanceId - The instance to validate.
+   */
+  validateInstanceId(instanceId) {
+    const instanceInfo = this._instanceInfo;
+    if (instanceId < 0 || instanceId >= instanceInfo.length || instanceInfo[instanceId].active === false) {
+      throw new Error(`THREE.BatchedMesh: Invalid instanceId ${instanceId}. Instance is either out of range or has been deleted.`);
+    }
+  }
+  /**
+   * Validates the geometry defined by the given ID.
+   *
+   * @param {number} geometryId - The geometry to validate.
+   */
+  validateGeometryId(geometryId) {
+    const geometryInfoList = this._geometryInfo;
+    if (geometryId < 0 || geometryId >= geometryInfoList.length || geometryInfoList[geometryId].active === false) {
+      throw new Error(`THREE.BatchedMesh: Invalid geometryId ${geometryId}. Geometry is either out of range or has been deleted.`);
+    }
+  }
+  /**
+   * Takes a sort a function that is run before render. The function takes a list of instances to
+   * sort and a camera. The objects in the list include a "z" field to perform a depth-ordered sort with.
+   *
+   * @param {Function} func - The custom sort function.
+   * @return {BatchedMesh} A reference to this batched mesh.
+   */
+  setCustomSort(func) {
+    this.customSort = func;
+    return this;
+  }
+  /**
+   * Computes the bounding box, updating {@link BatchedMesh#boundingBox}.
+   * Bounding boxes aren't computed by default. They need to be explicitly computed,
+   * otherwise they are `null`.
+   */
+  computeBoundingBox() {
+    if (this.boundingBox === null) {
+      this.boundingBox = new Box3();
+    }
+    const boundingBox2 = this.boundingBox;
+    const instanceInfo = this._instanceInfo;
+    boundingBox2.makeEmpty();
+    for (let i = 0, l = instanceInfo.length; i < l; i++) {
+      if (instanceInfo[i].active === false) continue;
+      const geometryId = instanceInfo[i].geometryIndex;
+      this.getMatrixAt(i, _matrix$1);
+      this.getBoundingBoxAt(geometryId, _box$1).applyMatrix4(_matrix$1);
+      boundingBox2.union(_box$1);
+    }
+  }
+  /**
+   * Computes the bounding sphere, updating {@link BatchedMesh#boundingSphere}.
+   * Bounding spheres aren't computed by default. They need to be explicitly computed,
+   * otherwise they are `null`.
+   */
+  computeBoundingSphere() {
+    if (this.boundingSphere === null) {
+      this.boundingSphere = new Sphere();
+    }
+    const boundingSphere = this.boundingSphere;
+    const instanceInfo = this._instanceInfo;
+    boundingSphere.makeEmpty();
+    for (let i = 0, l = instanceInfo.length; i < l; i++) {
+      if (instanceInfo[i].active === false) continue;
+      const geometryId = instanceInfo[i].geometryIndex;
+      this.getMatrixAt(i, _matrix$1);
+      this.getBoundingSphereAt(geometryId, _sphere$2).applyMatrix4(_matrix$1);
+      boundingSphere.union(_sphere$2);
+    }
+  }
+  /**
+   * Adds a new instance to the batch using the geometry of the given ID and returns
+   * a new id referring to the new instance to be used by other functions.
+   *
+   * @param {number} geometryId - The ID of a previously added geometry via {@link BatchedMesh#addGeometry}.
+   * @return {number} The instance ID.
+   */
+  addInstance(geometryId) {
+    const atCapacity = this._instanceInfo.length >= this.maxInstanceCount;
+    if (atCapacity && this._availableInstanceIds.length === 0) {
+      throw new Error("THREE.BatchedMesh: Maximum item count reached.");
+    }
+    const instanceInfo = {
+      visible: true,
+      active: true,
+      geometryIndex: geometryId
+    };
+    let drawId = null;
+    if (this._availableInstanceIds.length > 0) {
+      this._availableInstanceIds.sort(ascIdSort);
+      drawId = this._availableInstanceIds.shift();
+      this._instanceInfo[drawId] = instanceInfo;
+    } else {
+      drawId = this._instanceInfo.length;
+      this._instanceInfo.push(instanceInfo);
+    }
+    const matricesTexture = this._matricesTexture;
+    _matrix$1.identity().toArray(matricesTexture.image.data, drawId * 16);
+    matricesTexture.needsUpdate = true;
+    const colorsTexture = this._colorsTexture;
+    if (colorsTexture) {
+      _whiteColor.toArray(colorsTexture.image.data, drawId * 4);
+      colorsTexture.needsUpdate = true;
+    }
+    this._visibilityChanged = true;
+    return drawId;
+  }
+  /**
+   * Adds the given geometry to the batch and returns the associated
+   * geometry id referring to it to be used in other functions.
+   *
+   * @param {BufferGeometry} geometry - The geometry to add.
+   * @param {number} [reservedVertexCount=-1] - Optional parameter specifying the amount of
+   * vertex buffer space to reserve for the added geometry. This is necessary if it is planned
+   * to set a new geometry at this index at a later time that is larger than the original geometry.
+   * Defaults to the length of the given geometry vertex buffer.
+   * @param {number} [reservedIndexCount=-1] - Optional parameter specifying the amount of index
+   * buffer space to reserve for the added geometry. This is necessary if it is planned to set a
+   * new geometry at this index at a later time that is larger than the original geometry. Defaults to
+   * the length of the given geometry index buffer.
+   * @return {number} The geometry ID.
+   */
+  addGeometry(geometry, reservedVertexCount = -1, reservedIndexCount = -1) {
+    this._initializeGeometry(geometry);
+    this._validateGeometry(geometry);
+    const geometryInfo = {
+      // geometry information
+      vertexStart: -1,
+      vertexCount: -1,
+      reservedVertexCount: -1,
+      indexStart: -1,
+      indexCount: -1,
+      reservedIndexCount: -1,
+      // draw range information
+      start: -1,
+      count: -1,
+      // state
+      boundingBox: null,
+      boundingSphere: null,
+      active: true
+    };
+    const geometryInfoList = this._geometryInfo;
+    geometryInfo.vertexStart = this._nextVertexStart;
+    geometryInfo.reservedVertexCount = reservedVertexCount === -1 ? geometry.getAttribute("position").count : reservedVertexCount;
+    const index2 = geometry.getIndex();
+    const hasIndex = index2 !== null;
+    if (hasIndex) {
+      geometryInfo.indexStart = this._nextIndexStart;
+      geometryInfo.reservedIndexCount = reservedIndexCount === -1 ? index2.count : reservedIndexCount;
+    }
+    if (geometryInfo.indexStart !== -1 && geometryInfo.indexStart + geometryInfo.reservedIndexCount > this._maxIndexCount || geometryInfo.vertexStart + geometryInfo.reservedVertexCount > this._maxVertexCount) {
+      throw new Error("THREE.BatchedMesh: Reserved space request exceeds the maximum buffer size.");
+    }
+    let geometryId;
+    if (this._availableGeometryIds.length > 0) {
+      this._availableGeometryIds.sort(ascIdSort);
+      geometryId = this._availableGeometryIds.shift();
+      geometryInfoList[geometryId] = geometryInfo;
+    } else {
+      geometryId = this._geometryCount;
+      this._geometryCount++;
+      geometryInfoList.push(geometryInfo);
+    }
+    this.setGeometryAt(geometryId, geometry);
+    this._nextIndexStart = geometryInfo.indexStart + geometryInfo.reservedIndexCount;
+    this._nextVertexStart = geometryInfo.vertexStart + geometryInfo.reservedVertexCount;
+    return geometryId;
+  }
+  /**
+   * Replaces the geometry at the given ID with the provided geometry. Throws an error if there
+   * is not enough space reserved for geometry. Calling this will change all instances that are
+   * rendering that geometry.
+   *
+   * @param {number} geometryId - The ID of the geometry that should be replaced with the given geometry.
+   * @param {BufferGeometry} geometry - The new geometry.
+   * @return {number} The geometry ID.
+   */
+  setGeometryAt(geometryId, geometry) {
+    if (geometryId >= this._geometryCount) {
+      throw new Error("THREE.BatchedMesh: Maximum geometry count reached.");
+    }
+    this._validateGeometry(geometry);
+    const batchGeometry = this.geometry;
+    const hasIndex = batchGeometry.getIndex() !== null;
+    const dstIndex = batchGeometry.getIndex();
+    const srcIndex = geometry.getIndex();
+    const geometryInfo = this._geometryInfo[geometryId];
+    if (hasIndex && srcIndex.count > geometryInfo.reservedIndexCount || geometry.attributes.position.count > geometryInfo.reservedVertexCount) {
+      throw new Error("THREE.BatchedMesh: Reserved space not large enough for provided geometry.");
+    }
+    const vertexStart = geometryInfo.vertexStart;
+    const reservedVertexCount = geometryInfo.reservedVertexCount;
+    geometryInfo.vertexCount = geometry.getAttribute("position").count;
+    for (const attributeName in batchGeometry.attributes) {
+      const srcAttribute = geometry.getAttribute(attributeName);
+      const dstAttribute = batchGeometry.getAttribute(attributeName);
+      copyAttributeData(srcAttribute, dstAttribute, vertexStart);
+      const itemSize = srcAttribute.itemSize;
+      for (let i = srcAttribute.count, l = reservedVertexCount; i < l; i++) {
+        const index2 = vertexStart + i;
+        for (let c2 = 0; c2 < itemSize; c2++) {
+          dstAttribute.setComponent(index2, c2, 0);
+        }
+      }
+      dstAttribute.needsUpdate = true;
+      dstAttribute.addUpdateRange(vertexStart * itemSize, reservedVertexCount * itemSize);
+    }
+    if (hasIndex) {
+      const indexStart = geometryInfo.indexStart;
+      const reservedIndexCount = geometryInfo.reservedIndexCount;
+      geometryInfo.indexCount = geometry.getIndex().count;
+      for (let i = 0; i < srcIndex.count; i++) {
+        dstIndex.setX(indexStart + i, vertexStart + srcIndex.getX(i));
+      }
+      for (let i = srcIndex.count, l = reservedIndexCount; i < l; i++) {
+        dstIndex.setX(indexStart + i, vertexStart);
+      }
+      dstIndex.needsUpdate = true;
+      dstIndex.addUpdateRange(indexStart, geometryInfo.reservedIndexCount);
+    }
+    geometryInfo.start = hasIndex ? geometryInfo.indexStart : geometryInfo.vertexStart;
+    geometryInfo.count = hasIndex ? geometryInfo.indexCount : geometryInfo.vertexCount;
+    geometryInfo.boundingBox = null;
+    if (geometry.boundingBox !== null) {
+      geometryInfo.boundingBox = geometry.boundingBox.clone();
+    }
+    geometryInfo.boundingSphere = null;
+    if (geometry.boundingSphere !== null) {
+      geometryInfo.boundingSphere = geometry.boundingSphere.clone();
+    }
+    this._visibilityChanged = true;
+    return geometryId;
+  }
+  /**
+   * Deletes the geometry defined by the given ID from this batch. Any instances referencing
+   * this geometry will also be removed as a side effect.
+   *
+   * @param {number} geometryId - The ID of the geometry to remove from the batch.
+   * @return {BatchedMesh} A reference to this batched mesh.
+   */
+  deleteGeometry(geometryId) {
+    const geometryInfoList = this._geometryInfo;
+    if (geometryId >= geometryInfoList.length || geometryInfoList[geometryId].active === false) {
+      return this;
+    }
+    const instanceInfo = this._instanceInfo;
+    for (let i = 0, l = instanceInfo.length; i < l; i++) {
+      if (instanceInfo[i].active && instanceInfo[i].geometryIndex === geometryId) {
+        this.deleteInstance(i);
+      }
+    }
+    geometryInfoList[geometryId].active = false;
+    this._availableGeometryIds.push(geometryId);
+    this._visibilityChanged = true;
+    return this;
+  }
+  /**
+   * Deletes an existing instance from the batch using the given ID.
+   *
+   * @param {number} instanceId - The ID of the instance to remove from the batch.
+   * @return {BatchedMesh} A reference to this batched mesh.
+   */
+  deleteInstance(instanceId) {
+    this.validateInstanceId(instanceId);
+    this._instanceInfo[instanceId].active = false;
+    this._availableInstanceIds.push(instanceId);
+    this._visibilityChanged = true;
+    return this;
+  }
+  /**
+   * Repacks the sub geometries in [name] to remove any unused space remaining from
+   * previously deleted geometry, freeing up space to add new geometry.
+   *
+   * @param {number} instanceId - The ID of the instance to remove from the batch.
+   * @return {BatchedMesh} A reference to this batched mesh.
+   */
+  optimize() {
+    let nextVertexStart = 0;
+    let nextIndexStart = 0;
+    const geometryInfoList = this._geometryInfo;
+    const indices = geometryInfoList.map((e, i) => i).sort((a2, b) => {
+      return geometryInfoList[a2].vertexStart - geometryInfoList[b].vertexStart;
+    });
+    const geometry = this.geometry;
+    for (let i = 0, l = geometryInfoList.length; i < l; i++) {
+      const index2 = indices[i];
+      const geometryInfo = geometryInfoList[index2];
+      if (geometryInfo.active === false) {
+        continue;
+      }
+      if (geometry.index !== null) {
+        if (geometryInfo.indexStart !== nextIndexStart) {
+          const { indexStart, vertexStart, reservedIndexCount } = geometryInfo;
+          const index3 = geometry.index;
+          const array = index3.array;
+          const elementDelta = nextVertexStart - vertexStart;
+          for (let j = indexStart; j < indexStart + reservedIndexCount; j++) {
+            array[j] = array[j] + elementDelta;
+          }
+          index3.array.copyWithin(nextIndexStart, indexStart, indexStart + reservedIndexCount);
+          index3.addUpdateRange(nextIndexStart, reservedIndexCount);
+          geometryInfo.indexStart = nextIndexStart;
+        }
+        nextIndexStart += geometryInfo.reservedIndexCount;
+      }
+      if (geometryInfo.vertexStart !== nextVertexStart) {
+        const { vertexStart, reservedVertexCount } = geometryInfo;
+        const attributes = geometry.attributes;
+        for (const key2 in attributes) {
+          const attribute = attributes[key2];
+          const { array, itemSize } = attribute;
+          array.copyWithin(nextVertexStart * itemSize, vertexStart * itemSize, (vertexStart + reservedVertexCount) * itemSize);
+          attribute.addUpdateRange(nextVertexStart * itemSize, reservedVertexCount * itemSize);
+        }
+        geometryInfo.vertexStart = nextVertexStart;
+      }
+      nextVertexStart += geometryInfo.reservedVertexCount;
+      geometryInfo.start = geometry.index ? geometryInfo.indexStart : geometryInfo.vertexStart;
+      this._nextIndexStart = geometry.index ? geometryInfo.indexStart + geometryInfo.reservedIndexCount : 0;
+      this._nextVertexStart = geometryInfo.vertexStart + geometryInfo.reservedVertexCount;
+    }
+    return this;
+  }
+  /**
+   * Returns the bounding box for the given geometry.
+   *
+   * @param {number} geometryId - The ID of the geometry to return the bounding box for.
+   * @param {Box3} target - The target object that is used to store the method's result.
+   * @return {Box3|null} The geometry's bounding box. Returns `null` if no geometry has been found for the given ID.
+   */
+  getBoundingBoxAt(geometryId, target) {
+    if (geometryId >= this._geometryCount) {
+      return null;
+    }
+    const geometry = this.geometry;
+    const geometryInfo = this._geometryInfo[geometryId];
+    if (geometryInfo.boundingBox === null) {
+      const box = new Box3();
+      const index2 = geometry.index;
+      const position = geometry.attributes.position;
+      for (let i = geometryInfo.start, l = geometryInfo.start + geometryInfo.count; i < l; i++) {
+        let iv = i;
+        if (index2) {
+          iv = index2.getX(iv);
+        }
+        box.expandByPoint(_vector$5.fromBufferAttribute(position, iv));
+      }
+      geometryInfo.boundingBox = box;
+    }
+    target.copy(geometryInfo.boundingBox);
+    return target;
+  }
+  /**
+   * Returns the bounding sphere for the given geometry.
+   *
+   * @param {number} geometryId - The ID of the geometry to return the bounding sphere for.
+   * @param {Sphere} target - The target object that is used to store the method's result.
+   * @return {Sphere|null} The geometry's bounding sphere. Returns `null` if no geometry has been found for the given ID.
+   */
+  getBoundingSphereAt(geometryId, target) {
+    if (geometryId >= this._geometryCount) {
+      return null;
+    }
+    const geometry = this.geometry;
+    const geometryInfo = this._geometryInfo[geometryId];
+    if (geometryInfo.boundingSphere === null) {
+      const sphere = new Sphere();
+      this.getBoundingBoxAt(geometryId, _box$1);
+      _box$1.getCenter(sphere.center);
+      const index2 = geometry.index;
+      const position = geometry.attributes.position;
+      let maxRadiusSq = 0;
+      for (let i = geometryInfo.start, l = geometryInfo.start + geometryInfo.count; i < l; i++) {
+        let iv = i;
+        if (index2) {
+          iv = index2.getX(iv);
+        }
+        _vector$5.fromBufferAttribute(position, iv);
+        maxRadiusSq = Math.max(maxRadiusSq, sphere.center.distanceToSquared(_vector$5));
+      }
+      sphere.radius = Math.sqrt(maxRadiusSq);
+      geometryInfo.boundingSphere = sphere;
+    }
+    target.copy(geometryInfo.boundingSphere);
+    return target;
+  }
+  /**
+   * Sets the given local transformation matrix to the defined instance.
+   * Negatively scaled matrices are not supported.
+   *
+   * @param {number} instanceId - The ID of an instance to set the matrix of.
+   * @param {Matrix4} matrix - A 4x4 matrix representing the local transformation of a single instance.
+   * @return {BatchedMesh} A reference to this batched mesh.
+   */
+  setMatrixAt(instanceId, matrix) {
+    this.validateInstanceId(instanceId);
+    const matricesTexture = this._matricesTexture;
+    const matricesArray = this._matricesTexture.image.data;
+    matrix.toArray(matricesArray, instanceId * 16);
+    matricesTexture.needsUpdate = true;
+    return this;
+  }
+  /**
+   * Returns the local transformation matrix of the defined instance.
+   *
+   * @param {number} instanceId - The ID of an instance to get the matrix of.
+   * @param {Matrix4} matrix - The target object that is used to store the method's result.
+   * @return {Matrix4} The instance's local transformation matrix.
+   */
+  getMatrixAt(instanceId, matrix) {
+    this.validateInstanceId(instanceId);
+    return matrix.fromArray(this._matricesTexture.image.data, instanceId * 16);
+  }
+  /**
+   * Sets the given color to the defined instance.
+   *
+   * @param {number} instanceId - The ID of an instance to set the color of.
+   * @param {Color} color - The color to set the instance to.
+   * @return {BatchedMesh} A reference to this batched mesh.
+   */
+  setColorAt(instanceId, color) {
+    this.validateInstanceId(instanceId);
+    if (this._colorsTexture === null) {
+      this._initColorsTexture();
+    }
+    color.toArray(this._colorsTexture.image.data, instanceId * 4);
+    this._colorsTexture.needsUpdate = true;
+    return this;
+  }
+  /**
+   * Returns the color of the defined instance.
+   *
+   * @param {number} instanceId - The ID of an instance to get the color of.
+   * @param {Color} color - The target object that is used to store the method's result.
+   * @return {Color} The instance's color.
+   */
+  getColorAt(instanceId, color) {
+    this.validateInstanceId(instanceId);
+    return color.fromArray(this._colorsTexture.image.data, instanceId * 4);
+  }
+  /**
+   * Sets the visibility of the instance.
+   *
+   * @param {number} instanceId - The id of the instance to set the visibility of.
+   * @param {boolean} visible - Whether the instance is visible or not.
+   * @return {BatchedMesh} A reference to this batched mesh.
+   */
+  setVisibleAt(instanceId, visible) {
+    this.validateInstanceId(instanceId);
+    if (this._instanceInfo[instanceId].visible === visible) {
+      return this;
+    }
+    this._instanceInfo[instanceId].visible = visible;
+    this._visibilityChanged = true;
+    return this;
+  }
+  /**
+   * Returns the visibility state of the defined instance.
+   *
+   * @param {number} instanceId - The ID of an instance to get the visibility state of.
+   * @return {boolean} Whether the instance is visible or not.
+   */
+  getVisibleAt(instanceId) {
+    this.validateInstanceId(instanceId);
+    return this._instanceInfo[instanceId].visible;
+  }
+  /**
+   * Sets the geometry ID of the instance at the given index.
+   *
+   * @param {number} instanceId - The ID of the instance to set the geometry ID of.
+   * @param {number} geometryId - The geometry ID to be use by the instance.
+   * @return {BatchedMesh} A reference to this batched mesh.
+   */
+  setGeometryIdAt(instanceId, geometryId) {
+    this.validateInstanceId(instanceId);
+    this.validateGeometryId(geometryId);
+    this._instanceInfo[instanceId].geometryIndex = geometryId;
+    return this;
+  }
+  /**
+   * Returns the geometry ID of the defined instance.
+   *
+   * @param {number} instanceId - The ID of an instance to get the geometry ID of.
+   * @return {number} The instance's geometry ID.
+   */
+  getGeometryIdAt(instanceId) {
+    this.validateInstanceId(instanceId);
+    return this._instanceInfo[instanceId].geometryIndex;
+  }
+  /**
+   * Get the range representing the subset of triangles related to the attached geometry,
+   * indicating the starting offset and count, or `null` if invalid.
+   *
+   * @param {number} geometryId - The id of the geometry to get the range of.
+   * @param {Object} [target] - The target object that is used to store the method's result.
+   * @return {{
+   * 	vertexStart:number,vertexCount:number,reservedVertexCount:number,
+   * 	indexStart:number,indexCount:number,reservedIndexCount:number,
+   * 	start:number,count:number
+   * }} The result object with range data.
+   */
+  getGeometryRangeAt(geometryId, target = {}) {
+    this.validateGeometryId(geometryId);
+    const geometryInfo = this._geometryInfo[geometryId];
+    target.vertexStart = geometryInfo.vertexStart;
+    target.vertexCount = geometryInfo.vertexCount;
+    target.reservedVertexCount = geometryInfo.reservedVertexCount;
+    target.indexStart = geometryInfo.indexStart;
+    target.indexCount = geometryInfo.indexCount;
+    target.reservedIndexCount = geometryInfo.reservedIndexCount;
+    target.start = geometryInfo.start;
+    target.count = geometryInfo.count;
+    return target;
+  }
+  /**
+   * Resizes the necessary buffers to support the provided number of instances.
+   * If the provided arguments shrink the number of instances but there are not enough
+   * unused Ids at the end of the list then an error is thrown.
+   *
+   * @param {number} maxInstanceCount - The max number of individual instances that can be added and rendered by the batch.
+  */
+  setInstanceCount(maxInstanceCount) {
+    const availableInstanceIds = this._availableInstanceIds;
+    const instanceInfo = this._instanceInfo;
+    availableInstanceIds.sort(ascIdSort);
+    while (availableInstanceIds[availableInstanceIds.length - 1] === instanceInfo.length) {
+      instanceInfo.pop();
+      availableInstanceIds.pop();
+    }
+    if (maxInstanceCount < instanceInfo.length) {
+      throw new Error(`BatchedMesh: Instance ids outside the range ${maxInstanceCount} are being used. Cannot shrink instance count.`);
+    }
+    const multiDrawCounts = new Int32Array(maxInstanceCount);
+    const multiDrawStarts = new Int32Array(maxInstanceCount);
+    copyArrayContents(this._multiDrawCounts, multiDrawCounts);
+    copyArrayContents(this._multiDrawStarts, multiDrawStarts);
+    this._multiDrawCounts = multiDrawCounts;
+    this._multiDrawStarts = multiDrawStarts;
+    this._maxInstanceCount = maxInstanceCount;
+    const indirectTexture = this._indirectTexture;
+    const matricesTexture = this._matricesTexture;
+    const colorsTexture = this._colorsTexture;
+    indirectTexture.dispose();
+    this._initIndirectTexture();
+    copyArrayContents(indirectTexture.image.data, this._indirectTexture.image.data);
+    matricesTexture.dispose();
+    this._initMatricesTexture();
+    copyArrayContents(matricesTexture.image.data, this._matricesTexture.image.data);
+    if (colorsTexture) {
+      colorsTexture.dispose();
+      this._initColorsTexture();
+      copyArrayContents(colorsTexture.image.data, this._colorsTexture.image.data);
+    }
+  }
+  /**
+   * Resizes the available space in the batch's vertex and index buffer attributes to the provided sizes.
+   * If the provided arguments shrink the geometry buffers but there is not enough unused space at the
+   * end of the geometry attributes then an error is thrown.
+   *
+   * @param {number} maxVertexCount - The maximum number of vertices to be used by all unique geometries to resize to.
+   * @param {number} maxIndexCount - The maximum number of indices to be used by all unique geometries to resize to.
+  */
+  setGeometrySize(maxVertexCount, maxIndexCount) {
+    const validRanges = [...this._geometryInfo].filter((info) => info.active);
+    const requiredVertexLength = Math.max(...validRanges.map((range) => range.vertexStart + range.reservedVertexCount));
+    if (requiredVertexLength > maxVertexCount) {
+      throw new Error(`BatchedMesh: Geometry vertex values are being used outside the range ${maxIndexCount}. Cannot shrink further.`);
+    }
+    if (this.geometry.index) {
+      const requiredIndexLength = Math.max(...validRanges.map((range) => range.indexStart + range.reservedIndexCount));
+      if (requiredIndexLength > maxIndexCount) {
+        throw new Error(`BatchedMesh: Geometry index values are being used outside the range ${maxIndexCount}. Cannot shrink further.`);
+      }
+    }
+    const oldGeometry = this.geometry;
+    oldGeometry.dispose();
+    this._maxVertexCount = maxVertexCount;
+    this._maxIndexCount = maxIndexCount;
+    if (this._geometryInitialized) {
+      this._geometryInitialized = false;
+      this.geometry = new BufferGeometry();
+      this._initializeGeometry(oldGeometry);
+    }
+    const geometry = this.geometry;
+    if (oldGeometry.index) {
+      copyArrayContents(oldGeometry.index.array, geometry.index.array);
+    }
+    for (const key2 in oldGeometry.attributes) {
+      copyArrayContents(oldGeometry.attributes[key2].array, geometry.attributes[key2].array);
+    }
+  }
+  raycast(raycaster, intersects) {
+    const instanceInfo = this._instanceInfo;
+    const geometryInfoList = this._geometryInfo;
+    const matrixWorld = this.matrixWorld;
+    const batchGeometry = this.geometry;
+    _mesh$1.material = this.material;
+    _mesh$1.geometry.index = batchGeometry.index;
+    _mesh$1.geometry.attributes = batchGeometry.attributes;
+    if (_mesh$1.geometry.boundingBox === null) {
+      _mesh$1.geometry.boundingBox = new Box3();
+    }
+    if (_mesh$1.geometry.boundingSphere === null) {
+      _mesh$1.geometry.boundingSphere = new Sphere();
+    }
+    for (let i = 0, l = instanceInfo.length; i < l; i++) {
+      if (!instanceInfo[i].visible || !instanceInfo[i].active) {
+        continue;
+      }
+      const geometryId = instanceInfo[i].geometryIndex;
+      const geometryInfo = geometryInfoList[geometryId];
+      _mesh$1.geometry.setDrawRange(geometryInfo.start, geometryInfo.count);
+      this.getMatrixAt(i, _mesh$1.matrixWorld).premultiply(matrixWorld);
+      this.getBoundingBoxAt(geometryId, _mesh$1.geometry.boundingBox);
+      this.getBoundingSphereAt(geometryId, _mesh$1.geometry.boundingSphere);
+      _mesh$1.raycast(raycaster, _batchIntersects$1);
+      for (let j = 0, l2 = _batchIntersects$1.length; j < l2; j++) {
+        const intersect2 = _batchIntersects$1[j];
+        intersect2.object = this;
+        intersect2.batchId = i;
+        intersects.push(intersect2);
+      }
+      _batchIntersects$1.length = 0;
+    }
+    _mesh$1.material = null;
+    _mesh$1.geometry.index = null;
+    _mesh$1.geometry.attributes = {};
+    _mesh$1.geometry.setDrawRange(0, Infinity);
+  }
+  copy(source) {
+    super.copy(source);
+    this.geometry = source.geometry.clone();
+    this.perObjectFrustumCulled = source.perObjectFrustumCulled;
+    this.sortObjects = source.sortObjects;
+    this.boundingBox = source.boundingBox !== null ? source.boundingBox.clone() : null;
+    this.boundingSphere = source.boundingSphere !== null ? source.boundingSphere.clone() : null;
+    this._geometryInfo = source._geometryInfo.map((info) => ({
+      ...info,
+      boundingBox: info.boundingBox !== null ? info.boundingBox.clone() : null,
+      boundingSphere: info.boundingSphere !== null ? info.boundingSphere.clone() : null
+    }));
+    this._instanceInfo = source._instanceInfo.map((info) => ({ ...info }));
+    this._maxInstanceCount = source._maxInstanceCount;
+    this._maxVertexCount = source._maxVertexCount;
+    this._maxIndexCount = source._maxIndexCount;
+    this._geometryInitialized = source._geometryInitialized;
+    this._geometryCount = source._geometryCount;
+    this._multiDrawCounts = source._multiDrawCounts.slice();
+    this._multiDrawStarts = source._multiDrawStarts.slice();
+    this._matricesTexture = source._matricesTexture.clone();
+    this._matricesTexture.image.data = this._matricesTexture.image.data.slice();
+    if (this._colorsTexture !== null) {
+      this._colorsTexture = source._colorsTexture.clone();
+      this._colorsTexture.image.data = this._colorsTexture.image.data.slice();
+    }
+    return this;
+  }
+  /**
+   * Frees the GPU-related resources allocated by this instance. Call this
+   * method whenever this instance is no longer used in your app.
+   */
+  dispose() {
+    this.geometry.dispose();
+    this._matricesTexture.dispose();
+    this._matricesTexture = null;
+    this._indirectTexture.dispose();
+    this._indirectTexture = null;
+    if (this._colorsTexture !== null) {
+      this._colorsTexture.dispose();
+      this._colorsTexture = null;
+    }
+  }
+  onBeforeRender(renderer, scene, camera, geometry, material) {
+    if (!this._visibilityChanged && !this.perObjectFrustumCulled && !this.sortObjects) {
+      return;
+    }
+    const index2 = geometry.getIndex();
+    const bytesPerElement = index2 === null ? 1 : index2.array.BYTES_PER_ELEMENT;
+    const instanceInfo = this._instanceInfo;
+    const multiDrawStarts = this._multiDrawStarts;
+    const multiDrawCounts = this._multiDrawCounts;
+    const geometryInfoList = this._geometryInfo;
+    const perObjectFrustumCulled = this.perObjectFrustumCulled;
+    const indirectTexture = this._indirectTexture;
+    const indirectArray = indirectTexture.image.data;
+    if (perObjectFrustumCulled) {
+      _matrix$1.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse).multiply(this.matrixWorld);
+      _frustum.setFromProjectionMatrix(
+        _matrix$1,
+        renderer.coordinateSystem
+      );
+    }
+    let multiDrawCount = 0;
+    if (this.sortObjects) {
+      _matrix$1.copy(this.matrixWorld).invert();
+      _vector$5.setFromMatrixPosition(camera.matrixWorld).applyMatrix4(_matrix$1);
+      _forward.set(0, 0, -1).transformDirection(camera.matrixWorld).transformDirection(_matrix$1);
+      for (let i = 0, l = instanceInfo.length; i < l; i++) {
+        if (instanceInfo[i].visible && instanceInfo[i].active) {
+          const geometryId = instanceInfo[i].geometryIndex;
+          this.getMatrixAt(i, _matrix$1);
+          this.getBoundingSphereAt(geometryId, _sphere$2).applyMatrix4(_matrix$1);
+          let culled = false;
+          if (perObjectFrustumCulled) {
+            culled = !_frustum.intersectsSphere(_sphere$2);
+          }
+          if (!culled) {
+            const geometryInfo = geometryInfoList[geometryId];
+            const z2 = _temp.subVectors(_sphere$2.center, _vector$5).dot(_forward);
+            _renderList.push(geometryInfo.start, geometryInfo.count, z2, i);
+          }
+        }
+      }
+      const list = _renderList.list;
+      const customSort = this.customSort;
+      if (customSort === null) {
+        list.sort(material.transparent ? sortTransparent : sortOpaque);
+      } else {
+        customSort.call(this, list, camera);
+      }
+      for (let i = 0, l = list.length; i < l; i++) {
+        const item = list[i];
+        multiDrawStarts[multiDrawCount] = item.start * bytesPerElement;
+        multiDrawCounts[multiDrawCount] = item.count;
+        indirectArray[multiDrawCount] = item.index;
+        multiDrawCount++;
+      }
+      _renderList.reset();
+    } else {
+      for (let i = 0, l = instanceInfo.length; i < l; i++) {
+        if (instanceInfo[i].visible && instanceInfo[i].active) {
+          const geometryId = instanceInfo[i].geometryIndex;
+          let culled = false;
+          if (perObjectFrustumCulled) {
+            this.getMatrixAt(i, _matrix$1);
+            this.getBoundingSphereAt(geometryId, _sphere$2).applyMatrix4(_matrix$1);
+            culled = !_frustum.intersectsSphere(_sphere$2);
+          }
+          if (!culled) {
+            const geometryInfo = geometryInfoList[geometryId];
+            multiDrawStarts[multiDrawCount] = geometryInfo.start * bytesPerElement;
+            multiDrawCounts[multiDrawCount] = geometryInfo.count;
+            indirectArray[multiDrawCount] = i;
+            multiDrawCount++;
+          }
+        }
+      }
+    }
+    indirectTexture.needsUpdate = true;
+    this._multiDrawCount = multiDrawCount;
+    this._visibilityChanged = false;
+  }
+  onBeforeShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial) {
+    this.onBeforeRender(renderer, null, shadowCamera, geometry, depthMaterial);
+  }
+}
 const _matrix = /* @__PURE__ */ new Matrix4();
 class Raycaster {
   /**
@@ -11232,8 +12399,8 @@ class Raycaster {
    * @param {number} [near=0] - All results returned are further away than near. Near can't be negative.
    * @param {number} [far=Infinity] - All results returned are closer than far. Far can't be lower than near.
    */
-  constructor(origin, direction, near = 0, far = Infinity) {
-    this.ray = new Ray(origin, direction);
+  constructor(origin, direction2, near = 0, far = Infinity) {
+    this.ray = new Ray(origin, direction2);
     this.near = near;
     this.far = far;
     this.camera = null;
@@ -11252,8 +12419,8 @@ class Raycaster {
    * @param {Vector3} origin - The origin vector where the ray casts from.
    * @param {Vector3} direction - The (normalized) direction vector that gives direction to the ray.
    */
-  set(origin, direction) {
-    this.ray.set(origin, direction);
+  set(origin, direction2) {
+    this.ray.set(origin, direction2);
   }
   /**
    * Uses the given coordinates and camera to compute a new origin and direction for the internal ray.
@@ -11663,6 +12830,7 @@ function cloneTopologyRewritePropagation(propagation) {
 }
 function faceQueryRefsEqual(a2, b) {
   if (a2 == null || b == null) return a2 == null && b == null;
+  if (a2 === b) return true;
   if (a2.kind !== b.kind) return false;
   switch (a2.kind) {
     case "canonical-face":
@@ -11679,6 +12847,7 @@ function faceQueryRefsEqual(a2, b) {
 }
 function edgeQueryRefsEqual(a2, b) {
   if (a2 == null || b == null) return a2 == null && b == null;
+  if (a2 === b) return true;
   if (a2.kind !== b.kind) return false;
   switch (a2.kind) {
     case "tracked-edge":
@@ -12045,8 +13214,8 @@ function deriveSheetMetalModel(model) {
     const trimStart = flanges.has(adjacent.start) ? model.cornerRelief.size : 0;
     const trimEnd = flanges.has(adjacent.end) ? model.cornerRelief.size : 0;
     const fullLength = edge === "top" || edge === "bottom" ? model.panel.width : model.panel.height;
-    const span = fullLength - trimStart - trimEnd;
-    if (!(span > EPS$3)) {
+    const span2 = fullLength - trimStart - trimEnd;
+    if (!(span2 > EPS$3)) {
       throw new Error(
         `${edgeDisplayName(edge)} loses all usable span after applying the defended rectangular corner relief size ${model.cornerRelief.size}.`
       );
@@ -12058,7 +13227,7 @@ function deriveSheetMetalModel(model) {
       bendAllowance,
       trimStart,
       trimEnd,
-      span,
+      span: span2,
       centerAlongEdge: (trimStart - trimEnd) / 2
     });
   }
@@ -12237,10 +13406,10 @@ function lowerSheetMetalBasePlan(model, output) {
   const pieces = lowerSheetMetalBasePiecePlans(model, output).map((piece) => piece.plan);
   return pieces.length === 1 ? pieces[0] : buildBooleanShapeCompilePlan("union", pieces);
 }
-function descriptor(name, center, normal, planar, uAxis, vAxis, semantic = "face", memberNames = [name], coplanar = planar) {
+function descriptor(name, center2, normal, planar, uAxis, vAxis, semantic = "face", memberNames = [name], coplanar = planar) {
   return {
     name,
-    center: cloneVec3$7(center),
+    center: cloneVec3$7(center2),
     normal: cloneVec3$7(normal),
     planar,
     uAxis: cloneFaceAxis(uAxis),
@@ -16089,6 +17258,23 @@ function analyzeNodeUV(node, toLocal) {
 function clampUnit$1(v) {
   return v < -1 ? -1 : v > 1 ? 1 : v;
 }
+function sphereUVLocal(lx, ly, lz, radius) {
+  const u2 = atan2(ly, lx) * radius;
+  const len = sqrt$3(lx * lx + ly * ly + lz * lz);
+  const v = acos(clampUnit$1(lz / (len || 1))) * radius;
+  return [u2, v];
+}
+function cylinderUVLocal(lx, ly, lz, radius) {
+  const u2 = atan2(ly, lx) * radius;
+  const v = lz;
+  return [u2, v];
+}
+function torusUVLocal(lx, ly, lz, majorRadius, minorRadius) {
+  const u2 = atan2(ly, lx) * majorRadius;
+  const xyDist = sqrt$3(lx * lx + ly * ly) - majorRadius;
+  const v = atan2(lz, xyDist) * minorRadius;
+  return [u2, v];
+}
 function compileUVFunction(analysis) {
   if (analysis.mode === "triplanar") return null;
   const toLocal = analysis.toLocal;
@@ -16097,19 +17283,14 @@ function compileUVFunction(analysis) {
       const R = analysis.radius;
       return (p2) => {
         const lp = toLocal(p2);
-        const u2 = atan2(lp[1], lp[0]) * R;
-        const len = sqrt$3(lp[0] * lp[0] + lp[1] * lp[1] + lp[2] * lp[2]);
-        const v = acos(clampUnit$1(lp[2] / (len || 1))) * R;
-        return [u2, v];
+        return sphereUVLocal(lp[0], lp[1], lp[2], R);
       };
     }
     case "cylinder": {
       const r = analysis.radius;
       return (p2) => {
         const lp = toLocal(p2);
-        const u2 = atan2(lp[1], lp[0]) * r;
-        const v = lp[2];
-        return [u2, v];
+        return cylinderUVLocal(lp[0], lp[1], lp[2], r);
       };
     }
     case "torus": {
@@ -16117,10 +17298,7 @@ function compileUVFunction(analysis) {
       const r = analysis.radius;
       return (p2) => {
         const lp = toLocal(p2);
-        const u2 = atan2(lp[1], lp[0]) * R;
-        const xyDist = sqrt$3(lp[0] * lp[0] + lp[1] * lp[1]) - R;
-        const v = atan2(lp[2], xyDist) * r;
-        return [u2, v];
+        return torusUVLocal(lp[0], lp[1], lp[2], R, r);
       };
     }
   }
@@ -16431,8 +17609,8 @@ function sdProfileRevolve$1(profileFn, degrees, x2, y2, z2) {
   const profileDistance = profileFn(radial, z2);
   if (abs(degrees) >= 360) return profileDistance;
   const sweep = abs(degrees) * DEG$1;
-  const center = degrees * DEG$1 * 0.5;
-  let angle = Math.atan2(y2, x2) - center;
+  const center2 = degrees * DEG$1 * 0.5;
+  let angle = Math.atan2(y2, x2) - center2;
   while (angle <= -PI$1) angle += PI$1 * 2;
   while (angle > PI$1) angle -= PI$1 * 2;
   const half = sweep * 0.5;
@@ -16450,9 +17628,9 @@ function smax$1(a2, b, k2) {
 function repeatCoord$1(v, spacing, count) {
   if (spacing <= 0) return v;
   if (count > 0) {
-    const center = (count - 1) * 0.5;
-    const index2 = clamp$3(Math.round(v / spacing + center), 0, count - 1);
-    return v - (index2 - center) * spacing;
+    const center2 = (count - 1) * 0.5;
+    const index2 = clamp$3(Math.round(v / spacing + center2), 0, count - 1);
+    return v - (index2 - center2) * spacing;
   }
   return v - spacing * Math.round(v / spacing);
 }
@@ -16482,13 +17660,13 @@ function compileTypedSurfacePattern(pattern) {
     case "surfacePattern:constant":
       return () => pattern.value;
     case "surfacePattern:sineWave": {
-      const { direction, wavelength, amplitude, phase, bias } = pattern;
+      const { direction: direction2, wavelength, amplitude, phase, bias } = pattern;
       const frequency = 2 * PI$1 / wavelength;
-      return (u2, v) => bias + sin$1((u2 * direction[0] + v * direction[1]) * frequency + phase) * amplitude;
+      return (u2, v) => bias + sin$1((u2 * direction2[0] + v * direction2[1]) * frequency + phase) * amplitude;
     }
     case "surfacePattern:stripes": {
-      const { direction, spacing, width, depth } = pattern;
-      return (u2, v) => evalStripesPattern(u2, v, direction[0], direction[1], spacing, width, depth);
+      const { direction: direction2, spacing, width, depth } = pattern;
+      return (u2, v) => evalStripesPattern(u2, v, direction2[0], direction2[1], spacing, width, depth);
     }
     case "surfacePattern:overUnderWeave": {
       const { spacing, threadWidth, depth, underScale } = pattern;
@@ -17378,8 +18556,8 @@ function sdProfileRevolve(b, node, x2, y2, z2) {
   const profileDistance = profilePolygonsSdf(b, node.polygons, radial, z2);
   if (Math.abs(node.degrees) >= 360) return profileDistance;
   const sweep = Math.abs(node.degrees) * DEG;
-  const center = node.degrees * DEG * 0.5;
-  const angle = b.sub(b.atan2(y2, x2), b.constant(center));
+  const center2 = node.degrees * DEG * 0.5;
+  const angle = b.sub(b.atan2(y2, x2), b.constant(center2));
   const wrapped = b.sub(angle, b.mul(b.constant(TAU), b.round(b.div(angle, b.constant(TAU)))));
   const absAngle = b.abs(wrapped);
   const half = sweep * 0.5;
@@ -17446,9 +18624,9 @@ function select01(b, selector, ifOne, ifZero) {
 function repeatCoord(b, v, spacing, count) {
   if (spacing <= 0) return v;
   if (count > 0) {
-    const center = (count - 1) * 0.5;
-    const index2 = clampSlot(b, b.round(b.add(b.div(v, b.constant(spacing)), b.constant(center))), 0, count - 1);
-    return b.sub(v, b.mul(b.sub(index2, b.constant(center)), b.constant(spacing)));
+    const center2 = (count - 1) * 0.5;
+    const index2 = clampSlot(b, b.round(b.add(b.div(v, b.constant(spacing)), b.constant(center2))), 0, count - 1);
+    return b.sub(v, b.mul(b.sub(index2, b.constant(center2)), b.constant(spacing)));
   }
   return b.sub(v, b.mul(b.constant(spacing), b.round(b.div(v, b.constant(spacing)))));
 }
@@ -17719,6 +18897,11 @@ function deepFreezePlanData(value) {
   return value;
 }
 const SHAPE_BACKEND_MARKER = Symbol.for("forgecad.shapeBackend");
+const NORMAL_OFFSET = 3;
+const UV_OFFSET = 6;
+const NUM_PROP_POSITION_ONLY = 3;
+const NUM_PROP_WITH_NORMAL = 6;
+const NUM_PROP_WITH_UV = 8;
 function isShapeBackend(value) {
   return Boolean(value && typeof value === "object" && value[SHAPE_BACKEND_MARKER] === true);
 }
@@ -18252,14 +19435,14 @@ function findSpan(n, degree, u2, knots) {
   }
   return mid;
 }
-function basisFuns(span, u2, degree, knots) {
+function basisFuns(span2, u2, degree, knots) {
   const N = new Array(degree + 1);
   const left = new Array(degree + 1);
   const right = new Array(degree + 1);
   N[0] = 1;
   for (let j = 1; j <= degree; j++) {
-    left[j] = u2 - knots[span + 1 - j];
-    right[j] = knots[span + j] - u2;
+    left[j] = u2 - knots[span2 + 1 - j];
+    right[j] = knots[span2 + j] - u2;
     let saved = 0;
     for (let r = 0; r < j; r++) {
       const denom = right[r + 1] + left[j - r];
@@ -18271,15 +19454,15 @@ function basisFuns(span, u2, degree, knots) {
   }
   return N;
 }
-function basisFunsDeriv(span, u2, degree, knots, nDeriv) {
+function basisFunsDeriv(span2, u2, degree, knots, nDeriv) {
   const ndu = Array.from({ length: degree + 1 }, () => new Array(degree + 1).fill(0));
   const a2 = Array.from({ length: 2 }, () => new Array(degree + 1).fill(0));
   const left = new Array(degree + 1);
   const right = new Array(degree + 1);
   ndu[0][0] = 1;
   for (let j = 1; j <= degree; j++) {
-    left[j] = u2 - knots[span + 1 - j];
-    right[j] = knots[span + j] - u2;
+    left[j] = u2 - knots[span2 + 1 - j];
+    right[j] = knots[span2 + j] - u2;
     let saved = 0;
     for (let r2 = 0; r2 < j; r2++) {
       ndu[j][r2] = right[r2 + 1] + left[j - r2];
@@ -18332,11 +19515,11 @@ function basisFunsDeriv(span, u2, degree, knots, nDeriv) {
 }
 function deBoor3D(controlPoints, weights, knots, degree, u2) {
   const n = controlPoints.length;
-  const span = findSpan(n, degree, u2, knots);
-  const N = basisFuns(span, u2, degree, knots);
+  const span2 = findSpan(n, degree, u2, knots);
+  const N = basisFuns(span2, u2, degree, knots);
   let wx = 0, wy = 0, wz = 0, wSum = 0;
   for (let j = 0; j <= degree; j++) {
-    const idx = span - degree + j;
+    const idx = span2 - degree + j;
     const w2 = weights[idx] * N[j];
     wx += w2 * controlPoints[idx][0];
     wy += w2 * controlPoints[idx][1];
@@ -18732,49 +19915,55 @@ function signedArea2D(loop) {
   }
   return area * 0.5;
 }
-function pointInLoop$1(point2, loop) {
+function buildSdfLoopEdges(pts) {
+  const n = pts.length;
+  const ax = new Float64Array(n);
+  const ay = new Float64Array(n);
+  const ex = new Float64Array(n);
+  const ey = new Float64Array(n);
+  const invLen2 = new Float64Array(n);
+  for (let i = 0; i < n; i += 1) {
+    const a2 = pts[i];
+    const b = pts[(i + 1) % n];
+    const vx = b[0] - a2[0];
+    const vy = b[1] - a2[1];
+    ax[i] = a2[0];
+    ay[i] = a2[1];
+    ex[i] = vx;
+    ey[i] = vy;
+    const len2 = vx * vx + vy * vy;
+    invLen2[i] = len2 < 1e-12 ? 0 : 1 / len2;
+  }
+  return { n, area: signedArea2D(pts), ax, ay, ex, ey, invLen2 };
+}
+function loopSignedDistanceScalar(px, py, e) {
+  let minDist2 = Infinity;
   let inside = false;
-  const [px, py] = point2;
-  for (let index2 = 0, prev = loop.length - 1; index2 < loop.length; prev = index2, index2 += 1) {
-    const [xi, yi] = loop[index2];
-    const [xj, yj] = loop[prev];
-    const intersects = yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi + 1e-20) + xi;
-    if (intersects) inside = !inside;
-  }
-  return inside;
-}
-function pointSegDist2D(point2, a2, b) {
-  const abx = b[0] - a2[0];
-  const aby = b[1] - a2[1];
-  const apx = point2[0] - a2[0];
-  const apy = point2[1] - a2[1];
-  const den = abx * abx + aby * aby;
-  const t = den < 1e-12 ? 0 : clamp$1((apx * abx + apy * aby) / den, 0, 1);
-  const qx = a2[0] + abx * t;
-  const qy = a2[1] + aby * t;
-  const dx = point2[0] - qx;
-  const dy = point2[1] - qy;
-  return Math.sqrt(dx * dx + dy * dy);
-}
-function loopSignedDistance(point2, loop) {
-  let minDist = Infinity;
-  for (let index2 = 0; index2 < loop.length; index2 += 1) {
-    const a2 = loop[index2];
-    const b = loop[(index2 + 1) % loop.length];
-    minDist = Math.min(minDist, pointSegDist2D(point2, a2, b));
-  }
-  return pointInLoop$1(point2, loop) ? minDist : -minDist;
+  for (let i = 0; i < e.n; i += 1) {
+    const ax = e.ax[i];
+    const ay = e.ay[i];
+    const vx = e.ex[i];
+    const vy = e.ey[i];
+    const t = clamp$1(((px - ax) * vx + (py - ay) * vy) * e.invLen2[i], 0, 1);
+    const ddx = px - (ax + vx * t);
+    const ddy = py - (ay + vy * t);
+    const d22 = ddx * ddx + ddy * ddy;
+    if (d22 < minDist2) minDist2 = d22;
+    const by = ay + vy;
+    if (ay > py !== by > py && px < vx * (py - ay) / (vy + 1e-20) + ax) inside = !inside;
+  }
+  const d2 = Math.sqrt(minDist2);
+  return inside ? d2 : -d2;
 }
 function compilePolygonsSdf(polygons) {
-  const loops = polygons.filter((loop) => Array.isArray(loop) && loop.length >= 3).map((loop) => ({ pts: loop.map(([x2, y2]) => [x2, y2]), area: signedArea2D(loop) }));
+  const loops = polygons.filter((loop) => Array.isArray(loop) && loop.length >= 3).map((loop) => buildSdfLoopEdges(loop.map(([x2, y2]) => [x2, y2])));
   if (loops.length === 0) {
     return () => -1;
   }
   return (x2, y2) => {
-    const point2 = [x2, y2];
     let field2 = -Infinity;
     for (const loop of loops) {
-      const loopField = loopSignedDistance(point2, loop.pts);
+      const loopField = loopSignedDistanceScalar(x2, y2, loop);
       field2 = loop.area >= 0 ? Math.max(field2, loopField) : Math.min(field2, -loopField);
     }
     return field2;
@@ -18932,24 +20121,40 @@ function interpolateSweepFrame(segment, alpha, origin) {
 function findNearestSweepPoint(point2, segments) {
   let bestIndex = 0;
   let bestAlpha = 0;
-  let bestPoint = segments[0].a;
+  let bestAlong = 0;
   let bestDist2 = Infinity;
+  const px = point2[0];
+  const py = point2[1];
+  const pz = point2[2];
   for (let index2 = 0; index2 < segments.length; index2 += 1) {
     const segment = segments[index2];
-    const offset = vec3Sub(point2, segment.a);
-    const along = clamp$1(vec3Dot(offset, segment.t), 0, segment.len);
-    const alpha = segment.len > 1e-9 ? along / segment.len : 0;
-    const pointOnPath = vec3Add(segment.a, vec3Scale(segment.t, along));
-    const delta = vec3Sub(point2, pointOnPath);
-    const dist2 = vec3Dot(delta, delta);
+    const ax = segment.a[0];
+    const ay = segment.a[1];
+    const az = segment.a[2];
+    const tx = segment.t[0];
+    const ty = segment.t[1];
+    const tz = segment.t[2];
+    const along = clamp$1((px - ax) * tx + (py - ay) * ty + (pz - az) * tz, 0, segment.len);
+    const qx = ax + tx * along;
+    const qy = ay + ty * along;
+    const qz = az + tz * along;
+    const dx = px - qx;
+    const dy = py - qy;
+    const dz = pz - qz;
+    const dist2 = dx * dx + dy * dy + dz * dz;
     if (dist2 < bestDist2) {
       bestIndex = index2;
-      bestAlpha = alpha;
-      bestPoint = pointOnPath;
+      bestAlong = along;
+      bestAlpha = segment.len > 1e-9 ? along / segment.len : 0;
       bestDist2 = dist2;
     }
   }
   const bestSegment = segments[bestIndex];
+  const bestPoint = [
+    bestSegment.a[0] + bestSegment.t[0] * bestAlong,
+    bestSegment.a[1] + bestSegment.t[1] * bestAlong,
+    bestSegment.a[2] + bestSegment.t[2] * bestAlong
+  ];
   return {
     segmentIndex: bestIndex,
     segment: bestSegment,
@@ -19946,11 +21151,11 @@ function applyFilletSelectionToManifold(base, selection, radius, segments, wasm)
   const height = edgeLength(selection);
   if (!(height > 1e-6)) return base;
   const pad = Math.max(MIN_EDGE_PAD, radius);
-  const span = height + pad * 2;
+  const span2 = height + pad * 2;
   const frame = edgeFrameMatrix(selection, -pad);
   const cs = buildFilletCrossSection(selection, radius, segments, wasm) ?? legacyFilletCrossSection(selection, radius, segments, wasm);
-  const corner = cs.wedge.extrude(span, 0, 0, void 0, false).transform(frame);
-  const cyl = cs.cylinder.extrude(span, 0, 0, void 0, false).transform(frame);
+  const corner = cs.wedge.extrude(span2, 0, 0, void 0, false).transform(frame);
+  const cyl = cs.cylinder.extrude(span2, 0, 0, void 0, false).transform(frame);
   const crescent = wasm.Manifold.difference([corner, cyl]);
   return wasm.Manifold.difference([base, crescent]);
 }
@@ -19958,11 +21163,11 @@ function applyConcaveFilletSelectionToManifold(base, selection, radius, segments
   const height = edgeLength(selection);
   if (!(height > 1e-6)) return base;
   const pad = Math.max(MIN_EDGE_PAD, radius);
-  const span = height + pad * 2;
+  const span2 = height + pad * 2;
   const frame = edgeFrameMatrix(selection, -pad);
   const cs = buildFilletCrossSection(selection, radius, segments, wasm) ?? legacyFilletCrossSection(selection, radius, segments, wasm);
-  const corner = cs.wedge.extrude(span, 0, 0, void 0, false).transform(frame);
-  const cyl = cs.cylinder.extrude(span, 0, 0, void 0, false).transform(frame);
+  const corner = cs.wedge.extrude(span2, 0, 0, void 0, false).transform(frame);
+  const cyl = cs.cylinder.extrude(span2, 0, 0, void 0, false).transform(frame);
   const crescent = wasm.Manifold.difference([corner, cyl]);
   return wasm.Manifold.union([base, crescent]);
 }
@@ -19970,20 +21175,20 @@ function applyChamferSelectionToManifold(base, selection, size, wasm) {
   const height = edgeLength(selection);
   if (!(height > 1e-6)) return base;
   const pad = Math.max(MIN_EDGE_PAD, size);
-  const span = height + pad * 2;
+  const span2 = height + pad * 2;
   const frame = edgeFrameMatrix(selection, -pad);
   const triangle3 = buildChamferCrossSection(selection, size, wasm) ?? legacyChamferCrossSection(selection, size, wasm);
-  const chamfer = triangle3.extrude(span, 0, 0, void 0, false).transform(frame);
+  const chamfer = triangle3.extrude(span2, 0, 0, void 0, false).transform(frame);
   return wasm.Manifold.difference([base, chamfer]);
 }
 function applyConcaveChamferSelectionToManifold(base, selection, size, wasm) {
   const height = edgeLength(selection);
   if (!(height > 1e-6)) return base;
   const pad = Math.max(MIN_EDGE_PAD, size);
-  const span = height + pad * 2;
+  const span2 = height + pad * 2;
   const frame = edgeFrameMatrix(selection, -pad);
   const triangle3 = buildChamferCrossSection(selection, size, wasm) ?? legacyChamferCrossSection(selection, size, wasm);
-  const chamfer = triangle3.extrude(span, 0, 0, void 0, false).transform(frame);
+  const chamfer = triangle3.extrude(span2, 0, 0, void 0, false).transform(frame);
   return wasm.Manifold.union([base, chamfer]);
 }
 const EPS$1 = 1e-8;
@@ -21832,8 +23037,8 @@ function stitchSingleLoopLoft(loops, heights, wasm, options) {
     return null;
   }
 }
-function surfaceNormal(chord, span) {
-  const n = cross3$5(chord, span);
+function surfaceNormal(chord, span2) {
+  const n = cross3$5(chord, span2);
   const len = Math.hypot(n[0], n[1], n[2]);
   if (len < 1e-12) {
     const radial = Math.hypot(chord[0], chord[1]);
@@ -22476,6 +23681,16 @@ function fromSlicesSingleSliceHalfExtentForManifold(plan) {
   return Math.max(1, radius + maxOffsetMagnitude + plan.boundsPadding + plan.edgeLength * 3);
 }
 const BOOLEAN_OPERAND_NORMAL_SHARP_ANGLE_DEG = 60;
+const BOOLEAN_OPERAND_UV_EXTRA_PROP_MIN = 4;
+function rejectParametricUvBooleanOperands(shapes) {
+  for (const shape of shapes) {
+    if (shape.numProp() >= BOOLEAN_OPERAND_UV_EXTRA_PROP_MIN) {
+      throw new Error(
+        "Cannot boolean a shape that carries parametric UV (mesh numProp 8, vertProperties[6..7]). Parametric UV is baked into the mesh and is destroyed by cuts — Manifold interpolates the uv channels from the other operand onto every new cut/seam vertex. Apply booleans BEFORE texturing the result, or use a projected texture (Shape.wrapTexture with Wrap.*), which is computed from final position and survives booleans."
+      );
+    }
+  }
+}
 function promoteBooleanOperandNormals(shapes) {
   let maxExtra = 0;
   for (const shape of shapes) maxExtra = Math.max(maxExtra, shape.numProp());
@@ -22497,6 +23712,12 @@ function lowerShapeBooleanCompilePlan(plan, wasm) {
   if (shapes.length === 1) {
     return shapes[0];
   }
+  try {
+    rejectParametricUvBooleanOperands(shapes);
+  } catch (error) {
+    disposeWasmObjects(shapes);
+    throw error;
+  }
   const { operands, created } = promoteBooleanOperandNormals(shapes);
   try {
     switch (plan.op) {
@@ -22538,8 +23759,8 @@ function vectorLength3$1(v) {
 function subtract3$1(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
-function addScaled3$1(point2, direction, scale2) {
-  return [point2[0] + direction[0] * scale2, point2[1] + direction[1] * scale2, point2[2] + direction[2] * scale2];
+function addScaled3$1(point2, direction2, scale2) {
+  return [point2[0] + direction2[0] * scale2, point2[1] + direction2[1] * scale2, point2[2] + direction2[2] * scale2];
 }
 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]];
@@ -23254,9 +24475,9 @@ function lowerVerticalVariableSweepStitchedForManifold(plan, sectionPolygons, wa
     return null;
   }
   const frameY = cross3$4(tangent, frameX);
-  const span = end[2] - start[2];
+  const span2 = end[2] - start[2];
   const sections = sectionPolygons.map((section) => ({
-    height: start[2] + span * section.t,
+    height: start[2] + span2 * section.t,
     polygons: section.polygons.map(
       (loop) => loop.map(([u2, v]) => [start[0] + u2 * frameX[0] + v * frameY[0], start[1] + u2 * frameX[1] + v * frameY[1]])
     )
@@ -31765,8 +32986,8 @@ function revolveProfilePolygonsToSdfField(polygons, degrees = 360) {
       const profileDistance = profile.eval(radial, z2);
       if (Math.abs(degrees) >= 360) return profileDistance;
       const sweep = Math.abs(degrees) * (Math.PI / 180);
-      const center = degrees * Math.PI / 360;
-      let angle = Math.atan2(y2, x2) - center;
+      const center2 = degrees * Math.PI / 360;
+      let angle = Math.atan2(y2, x2) - center2;
       while (angle <= -Math.PI) angle += Math.PI * 2;
       while (angle > Math.PI) angle -= Math.PI * 2;
       const half = sweep / 2;
@@ -32683,18 +33904,18 @@ function circleFootprintFromProfile(plan) {
   if (plan.kind !== "circle") return null;
   const radius = Math.abs(plan.radius);
   if (!finitePositive$1(radius)) return null;
-  const center = transformProfilePointThrough([0, 0], plan.transforms);
+  const center2 = transformProfilePointThrough([0, 0], plan.transforms);
   const xPoint = transformProfilePointThrough([1, 0], plan.transforms);
   const yPoint = transformProfilePointThrough([0, 1], plan.transforms);
-  const xAxis = [xPoint[0] - center[0], xPoint[1] - center[1]];
-  const yAxis = [yPoint[0] - center[0], yPoint[1] - center[1]];
+  const xAxis = [xPoint[0] - center2[0], xPoint[1] - center2[1]];
+  const yAxis = [yPoint[0] - center2[0], yPoint[1] - center2[1]];
   const xScale = Math.hypot(xAxis[0], xAxis[1]);
   const yScale = Math.hypot(yAxis[0], yAxis[1]);
   const dot2 = xAxis[0] * yAxis[0] + xAxis[1] * yAxis[1];
   if (!finitePositive$1(xScale) || !finitePositive$1(yScale)) return null;
   if (Math.abs(xScale - yScale) > EPS || Math.abs(dot2) > EPS * xScale * yScale) return null;
   return {
-    center,
+    center: center2,
     radius: radius * xScale,
     segments: plan.segments
   };
@@ -33493,19 +34714,19 @@ function explicitGeometrySurface(geometry, face) {
     }
   }
   if ("AnalyticSphere" in geometry) {
-    const center = geometry.AnalyticSphere.center;
+    const center2 = geometry.AnalyticSphere.center;
     const radius = geometry.AnalyticSphere.radius;
-    if (isVec3(center) && isFiniteNumber(radius) && radius > 0) {
-      return { kind: "sphere", center, radius };
+    if (isVec3(center2) && isFiniteNumber(radius) && radius > 0) {
+      return { kind: "sphere", center: center2, radius };
     }
   }
   if ("AnalyticTorus" in geometry) {
-    const center = geometry.AnalyticTorus.center;
+    const center2 = geometry.AnalyticTorus.center;
     const axis = geometry.AnalyticTorus.axis;
     const majorRadius = geometry.AnalyticTorus.major_radius;
     const minorRadius = geometry.AnalyticTorus.minor_radius;
-    if (isVec3(center) && isVec3(axis) && isFiniteNumber(majorRadius) && isFiniteNumber(minorRadius) && majorRadius > 0 && minorRadius > 0) {
-      return { kind: "torus", center, axis: normalizeVec3(axis), majorRadius, minorRadius };
+    if (isVec3(center2) && isVec3(axis) && isFiniteNumber(majorRadius) && isFiniteNumber(minorRadius) && majorRadius > 0 && minorRadius > 0) {
+      return { kind: "torus", center: center2, axis: normalizeVec3(axis), majorRadius, minorRadius };
     }
   }
   if ("NurbsPatch" in geometry) {
@@ -33599,13 +34820,13 @@ function explicitGeometrySurface(geometry, face) {
 function explicitEdgeCurve(geometry, faceName) {
   var _a3, _b3, _c2, _d2, _e2;
   if (!geometry) return void 0;
-  const center = (_a3 = geometry.CircularArc) == null ? void 0 : _a3.center;
+  const center2 = (_a3 = geometry.CircularArc) == null ? void 0 : _a3.center;
   const axis = (_b3 = geometry.CircularArc) == null ? void 0 : _b3.axis;
   const radius = (_c2 = geometry.CircularArc) == null ? void 0 : _c2.radius;
-  if (center !== void 0 && axis !== void 0 && radius !== void 0 && isVec3(center) && isVec3(axis) && isFiniteNumber(radius) && radius > 0) {
+  if (center2 !== void 0 && axis !== void 0 && radius !== void 0 && isVec3(center2) && isVec3(axis) && isFiniteNumber(radius) && radius > 0) {
     return {
       kind: "circle",
-      center,
+      center: center2,
       axis: normalizeVec3(axis),
       radius,
       faceName
@@ -36221,15 +37442,15 @@ function regionsHaveMatchingTopology$1(stations) {
   );
 }
 function lowerDraftPlan(plan) {
-  const direction = normalizedVector3(plan.pullDirection, "draft() pull direction");
-  if (Math.abs(direction[0]) > 1e-9 || Math.abs(direction[1]) > 1e-9 || Math.abs(Math.abs(direction[2]) - 1) > 1e-9) {
+  const direction2 = normalizedVector3(plan.pullDirection, "draft() pull direction");
+  if (Math.abs(direction2[0]) > 1e-9 || Math.abs(direction2[1]) > 1e-9 || Math.abs(Math.abs(direction2[2]) - 1) > 1e-9) {
     return truckUnsupported("draft() for non-Z pull directions");
   }
   const prism = lowerPlanToVerticalPrism(plan.base, true);
   if (!prism) return truckUnsupported("draft() for non-vertical-prism solids");
   if (!(prism.zMax > prism.zMin + 1e-9)) return truckUnsupported("draft() with collapsed vertical span");
   const tanAngle = Math.tan(plan.angleDeg * Math.PI / 180);
-  const axialSign = direction[2] >= 0 ? 1 : -1;
+  const axialSign = direction2[2] >= 0 ? 1 : -1;
   const offsetAtZ = (z2) => (axialSign * z2 - plan.neutralPlaneOffset) * tanAngle;
   const bottomReferenceRegions = prism.regions.map(simplifyCollinearRegion);
   const sourceTopRegions = prism.topRegions ?? prism.regions;
@@ -36279,8 +37500,8 @@ function offsetLoftPlan(plan, thickness) {
     )
   );
 }
-function addScaled3(point2, direction, scale2) {
-  return [point2[0] + direction[0] * scale2, point2[1] + direction[1] * scale2, point2[2] + direction[2] * scale2];
+function addScaled3(point2, direction2, scale2) {
+  return [point2[0] + direction2[0] * scale2, point2[1] + direction2[1] * scale2, point2[2] + direction2[2] * scale2];
 }
 function isStraightMonotonePolyline(points) {
   if (points.length < 2) return false;
@@ -36549,8 +37770,8 @@ function resamplePolyline(points, count) {
   for (let idx = 0; idx < count; idx++) {
     const target = idx / (count - 1) * total;
     while (segment < cumulative.length - 2 && cumulative[segment + 1] < target) segment++;
-    const span = cumulative[segment + 1] - cumulative[segment];
-    const t = span > 1e-12 ? (target - cumulative[segment]) / span : 0;
+    const span2 = cumulative[segment + 1] - cumulative[segment];
+    const t = span2 > 1e-12 ? (target - cumulative[segment]) / span2 : 0;
     const a2 = points[segment];
     const b = points[segment + 1];
     out.push([a2[0] + (b[0] - a2[0]) * t, a2[1] + (b[1] - a2[1]) * t, a2[2] + (b[2] - a2[2]) * t]);
@@ -37308,12 +38529,12 @@ function transformedSphereProfile(basePlan, steps, sliceOffset) {
     transform = transform.mul(transformForShapeTransform(step));
     scale2 *= stepScale;
   }
-  const center = transform.point([0, 0, 0]);
+  const center2 = transform.point([0, 0, 0]);
   const radius = Math.abs(source.radius * scale2);
-  const sectionRadius = sliceOffset == null ? radius : Math.sqrt(Math.max(0, radius * radius - (sliceOffset - center[2]) * (sliceOffset - center[2])));
+  const sectionRadius = sliceOffset == null ? radius : Math.sqrt(Math.max(0, radius * radius - (sliceOffset - center2[2]) * (sliceOffset - center2[2])));
   if (sectionRadius <= EXACT_PROFILE_EPS) return emptyProfilePlan();
   const profile = circleProfilePlan(sectionRadius, source.segments);
-  if (!isNearlyZero(center[0]) || !isNearlyZero(center[1])) profile.transforms.push({ kind: "translate", x: center[0], y: center[1] });
+  if (!isNearlyZero(center2[0]) || !isNearlyZero(center2[1])) profile.transforms.push({ kind: "translate", x: center2[0], y: center2[1] });
   return profile;
 }
 function profileTransformsForShapeTransform(step) {
@@ -37416,20 +38637,20 @@ function sliceOffsetBeforeShapeTransforms(steps, offset) {
   }
   return sourceOffset;
 }
-function transformZSpan(span, step) {
+function transformZSpan(span2, step) {
   switch (step.kind) {
     case "translate":
-      return [span[0] + step.z, span[1] + step.z];
+      return [span2[0] + step.z, span2[1] + step.z];
     case "scale":
       if (!Number.isFinite(step.z) || isNearlyZero(step.z)) return null;
-      return [Math.min(span[0] * step.z, span[1] * step.z), Math.max(span[0] * step.z, span[1] * step.z)];
+      return [Math.min(span2[0] * step.z, span2[1] * step.z), Math.max(span2[0] * step.z, span2[1] * step.z)];
     case "rotateAround": {
       const axisLength = Math.hypot(step.axisX, step.axisY, step.axisZ);
       if (axisLength <= EXACT_PROFILE_EPS) return null;
       const axisX = step.axisX / axisLength;
       const axisY = step.axisY / axisLength;
       const axisZ = step.axisZ / axisLength;
-      return !isNearlyZero(axisX) || !isNearlyZero(axisY) || Math.abs(Math.abs(axisZ) - 1) > EXACT_PROFILE_EPS ? null : span;
+      return !isNearlyZero(axisX) || !isNearlyZero(axisY) || Math.abs(Math.abs(axisZ) - 1) > EXACT_PROFILE_EPS ? null : span2;
     }
     case "mirror": {
       const normalLength = Math.hypot(step.normalX, step.normalY, step.normalZ);
@@ -37437,14 +38658,14 @@ function transformZSpan(span, step) {
       const normalX = step.normalX / normalLength;
       const normalY = step.normalY / normalLength;
       const normalZ = step.normalZ / normalLength;
-      if (isNearlyZero(normalX) && isNearlyZero(normalY)) return [-span[1], -span[0]];
-      return isNearlyZero(normalZ) ? span : null;
+      if (isNearlyZero(normalX) && isNearlyZero(normalY)) return [-span2[1], -span2[0]];
+      return isNearlyZero(normalZ) ? span2 : null;
     }
     case "workplanePlacement": {
       const replay = workplanePlacementReplay(step.matrix);
       if (!replay) return null;
-      const z0 = replay.zScale * span[0] + replay.zTranslate;
-      const z1 = replay.zScale * span[1] + replay.zTranslate;
+      const z0 = replay.zScale * span2[0] + replay.zTranslate;
+      const z1 = replay.zScale * span2[1] + replay.zTranslate;
       return [Math.min(z0, z1), Math.max(z0, z1)];
     }
     default:
@@ -37498,14 +38719,14 @@ function transformProfilePointThroughRadial(point2, transforms) {
   return out;
 }
 function profileRadialTransformBasis(transforms) {
-  const center = transformProfilePointThroughRadial([0, 0], transforms);
+  const center2 = transformProfilePointThroughRadial([0, 0], transforms);
   const xBasis = transformProfilePointThroughRadial([1, 0], transforms);
   const yBasis = transformProfilePointThroughRadial([0, 1], transforms);
-  if (!center || !xBasis || !yBasis) return null;
+  if (!center2 || !xBasis || !yBasis) return null;
   return {
-    center,
-    xAxis: [xBasis[0] - center[0], xBasis[1] - center[1]],
-    yAxis: [yBasis[0] - center[0], yBasis[1] - center[1]]
+    center: center2,
+    xAxis: [xBasis[0] - center2[0], xBasis[1] - center2[1]],
+    yAxis: [yBasis[0] - center2[0], yBasis[1] - center2[1]]
   };
 }
 function circleRadialProjectionInterval(plan) {
@@ -37625,11 +38846,11 @@ function radialRoundedRectSignedDistance(footprint, point2) {
   const qy = Math.abs(localPoint[1]) - Math.max(0, footprint.halfHeight - footprint.radius);
   return Math.hypot(Math.max(qx, 0), Math.max(qy, 0)) + Math.min(Math.max(qx, qy), 0) - footprint.radius;
 }
-function radialRoundedRectHalfExtentAlong(footprint, direction) {
+function radialRoundedRectHalfExtentAlong(footprint, direction2) {
   const coreHalfWidth = Math.max(0, footprint.halfWidth - footprint.radius);
   const coreHalfHeight = Math.max(0, footprint.halfHeight - footprint.radius);
-  const directionLength = Math.hypot(direction[0], direction[1]);
-  return Math.abs(direction[0] * footprint.xAxis[0] + direction[1] * footprint.xAxis[1]) * coreHalfWidth + Math.abs(direction[0] * footprint.yAxis[0] + direction[1] * footprint.yAxis[1]) * coreHalfHeight + footprint.radius * directionLength;
+  const directionLength = Math.hypot(direction2[0], direction2[1]);
+  return Math.abs(direction2[0] * footprint.xAxis[0] + direction2[1] * footprint.xAxis[1]) * coreHalfWidth + Math.abs(direction2[0] * footprint.yAxis[0] + direction2[1] * footprint.yAxis[1]) * coreHalfHeight + footprint.radius * directionLength;
 }
 function radialRoundedRectBoundaryMaxDistanceFromPoint(footprint, point2) {
   const coreHalfWidth = Math.max(0, footprint.halfWidth - footprint.radius);
@@ -37653,13 +38874,13 @@ function radialRoundedRectBoundaryMaxDistanceFromPoint(footprint, point2) {
     [-1, -1]
   ];
   for (const [sx, sy] of cornerSigns) {
-    const center = [sx * coreHalfWidth, sy * coreHalfHeight];
-    includeLocal([center[0] + sx * footprint.radius, center[1]]);
-    includeLocal([center[0], center[1] + sy * footprint.radius]);
-    const away = [center[0] - localPoint[0], center[1] - localPoint[1]];
+    const center2 = [sx * coreHalfWidth, sy * coreHalfHeight];
+    includeLocal([center2[0] + sx * footprint.radius, center2[1]]);
+    includeLocal([center2[0], center2[1] + sy * footprint.radius]);
+    const away = [center2[0] - localPoint[0], center2[1] - localPoint[1]];
     const awayLength = Math.hypot(away[0], away[1]);
     if (awayLength > EXACT_PROFILE_EPS && away[0] * sx >= -EXACT_PROFILE_EPS && away[1] * sy >= -EXACT_PROFILE_EPS) {
-      includeLocal([center[0] + away[0] / awayLength * footprint.radius, center[1] + away[1] / awayLength * footprint.radius]);
+      includeLocal([center2[0] + away[0] / awayLength * footprint.radius, center2[1] + away[1] / awayLength * footprint.radius]);
     }
   }
   return maxDistance;
@@ -37746,10 +38967,10 @@ function lineIntervalsForRect(base, tangent, halfWidth, halfHeight) {
   if (halfWidth < -EXACT_PROFILE_EPS || halfHeight < -EXACT_PROFILE_EPS) return null;
   let min2 = -Infinity;
   let max2 = Infinity;
-  const applyAxis = (origin, direction, extent) => {
-    if (Math.abs(direction) <= EXACT_PROFILE_EPS) return Math.abs(origin) <= extent + EXACT_PROFILE_EPS;
-    const a2 = (-extent - origin) / direction;
-    const b = (extent - origin) / direction;
+  const applyAxis = (origin, direction2, extent) => {
+    if (Math.abs(direction2) <= EXACT_PROFILE_EPS) return Math.abs(origin) <= extent + EXACT_PROFILE_EPS;
+    const a2 = (-extent - origin) / direction2;
+    const b = (extent - origin) / direction2;
     min2 = Math.max(min2, Math.min(a2, b));
     max2 = Math.min(max2, Math.max(a2, b));
     return min2 <= max2 + EXACT_PROFILE_EPS;
@@ -37757,10 +38978,10 @@ function lineIntervalsForRect(base, tangent, halfWidth, halfHeight) {
   if (!applyAxis(base[0], tangent[0], halfWidth) || !applyAxis(base[1], tangent[1], halfHeight)) return [];
   return [[min2, max2]];
 }
-function lineIntervalsForCircle(base, tangent, center, radius) {
+function lineIntervalsForCircle(base, tangent, center2, radius) {
   if (radius < -EXACT_PROFILE_EPS) return null;
-  const dx = base[0] - center[0];
-  const dy = base[1] - center[1];
+  const dx = base[0] - center2[0];
+  const dy = base[1] - center2[1];
   const projection = dx * tangent[0] + dy * tangent[1];
   const distanceSq = dx * dx + dy * dy - projection * projection;
   const radiusSq = radius * radius;
@@ -37803,7 +39024,7 @@ function roundedRectRadialSliceIntervals(plan, y2) {
       [-coreHalfWidth, coreHalfHeight],
       [-coreHalfWidth, -coreHalfHeight]
     ];
-    for (const center of centers) include(lineIntervalsForCircle(base, tangent, center, radius));
+    for (const center2 of centers) include(lineIntervalsForCircle(base, tangent, center2, radius));
   }
   const xFunctional = [basis.xAxis[0], basis.yAxis[0]];
   const xAtBase = basis.center[0] + xFunctional[0] * base[0] + xFunctional[1] * base[1];
@@ -39111,9 +40332,9 @@ function expandSimpleFullRevolutionProfileFootprint(plan, distance) {
   }
 }
 function profilePlanForSimpleFullRevolutionFootprint(footprint, segments) {
-  const translate = (profile, center) => {
-    if (!isNearlyZero(center[0]) || !isNearlyZero(center[1])) {
-      profile.transforms.push({ kind: "translate", x: center[0], y: center[1] });
+  const translate = (profile, center2) => {
+    if (!isNearlyZero(center2[0]) || !isNearlyZero(center2[1])) {
+      profile.transforms.push({ kind: "translate", x: center2[0], y: center2[1] });
     }
     return profile;
   };
@@ -39131,7 +40352,7 @@ function profilePlanForSimpleFullRevolutionFootprint(footprint, segments) {
         footprint.footprint.center
       ) : null;
     case "roundedRect": {
-      const { halfWidth, halfHeight, radius, xAxis, yAxis, center } = footprint.footprint;
+      const { halfWidth, halfHeight, radius, xAxis, yAxis, center: center2 } = footprint.footprint;
       if (halfWidth <= EXACT_PROFILE_EPS || halfHeight <= EXACT_PROFILE_EPS || radius < -EXACT_PROFILE_EPS) return null;
       const profile = roundedRectProfilePlan({
         width: halfWidth * 2,
@@ -39146,7 +40367,7 @@ function profilePlanForSimpleFullRevolutionFootprint(footprint, segments) {
           m11: yAxis[1]
         })
       );
-      return translate(profile, center);
+      return translate(profile, center2);
     }
     default:
       return assertExhaustive(footprint);
@@ -39603,28 +40824,28 @@ function cleanSweepPolyline(points) {
 function verticalSweepFrameTransforms(path, up) {
   if (!up.every(Number.isFinite)) return null;
   const [originX, originY] = path[0];
-  let direction = 0;
+  let direction2 = 0;
   for (let idx = 1; idx < path.length; idx += 1) {
     const [x2, y2, z2] = path[idx];
     if (!isNearlyZero(x2 - originX) || !isNearlyZero(y2 - originY)) return null;
     const dz = z2 - path[idx - 1][2];
     if (isNearlyZero(dz)) return null;
     const segmentDirection = dz > 0 ? 1 : -1;
-    if (direction === 0) direction = segmentDirection;
-    if (direction !== segmentDirection) return null;
+    if (direction2 === 0) direction2 = segmentDirection;
+    if (direction2 !== segmentDirection) return null;
   }
-  let xAxisX = up[1] * direction;
-  let xAxisY = -up[0] * direction;
+  let xAxisX = up[1] * direction2;
+  let xAxisY = -up[0] * direction2;
   let xAxisLength = Math.hypot(xAxisX, xAxisY);
   if (xAxisLength <= 1e-8) {
     xAxisX = 0;
-    xAxisY = -direction;
+    xAxisY = -direction2;
     xAxisLength = 1;
   }
   xAxisX /= xAxisLength;
   xAxisY /= xAxisLength;
-  const yAxisX = -direction * xAxisY;
-  const yAxisY = direction * xAxisX;
+  const yAxisX = -direction2 * xAxisY;
+  const yAxisY = direction2 * xAxisX;
   const determinant = xAxisX * yAxisY - yAxisX * xAxisY;
   if (Math.abs(Math.abs(determinant) - 1) > 1e-7) return null;
   const expectedYAxisX = determinant > 0 ? -xAxisY : xAxisY;
@@ -39733,16 +40954,16 @@ function exactVerticalProjectionProfilePlan(plan) {
       const base = exactVerticalProjectionProfilePlan(plan.base);
       if (!base) return null;
       let profile = base.profile;
-      let span = [base.zMin, base.zMax];
+      let span2 = [base.zMin, base.zMax];
       for (const step of plan.steps) {
         const projectedTransforms = profileTransformsForShapeTransform(step);
         if (!projectedTransforms) return null;
-        const nextSpan = transformZSpan(span, step);
+        const nextSpan = transformZSpan(span2, step);
         if (!nextSpan) return null;
         profile = appendProfileTransforms(profile, projectedTransforms);
-        span = nextSpan;
+        span2 = nextSpan;
       }
-      return { profile, zMin: span[0], zMax: span[1] };
+      return { profile, zMin: span2[0], zMax: span2[1] };
     }
     default:
       return null;
@@ -39762,7 +40983,7 @@ function projectVerticalDifferenceProfilePlan(subject, clips) {
   const clipped = clips.map((clip) => ({ clip, span: clippedZSpan(subject, clip) })).filter((entry) => entry.span != null);
   if (clipped.length === 0) return cloneProfileCompilePlan(subject.profile);
   const zBreaks = [subject.zMin, subject.zMax];
-  for (const { span } of clipped) zBreaks.push(span[0], span[1]);
+  for (const { span: span2 } of clipped) zBreaks.push(span2[0], span2[1]);
   zBreaks.sort((a2, b) => a2 - b);
   const uniqueBreaks = [];
   for (const z2 of zBreaks) {
@@ -39775,7 +40996,7 @@ function projectVerticalDifferenceProfilePlan(subject, clips) {
     const zMax = uniqueBreaks[idx + 1];
     if (zMax - zMin <= EXACT_PROFILE_EPS) continue;
     const zMid = (zMin + zMax) / 2;
-    const activeClips = clipped.filter(({ span }) => offsetInRange(zMid, span[0], span[1]));
+    const activeClips = clipped.filter(({ span: span2 }) => offsetInRange(zMid, span2[0], span2[1]));
     if (activeClips.length === 0) return cloneProfileCompilePlan(subject.profile);
     slabProfiles.push({
       kind: "boolean",
@@ -39933,9 +41154,9 @@ function offsetSolidVerticalVariableSweepSlicedProfilePlan(plan, offset) {
   if (base.kind !== "variableSweep" || !Number.isFinite(plan.thickness) || isNearlyZero(plan.thickness)) return null;
   const pathInfo = verticalSweepPathInfo(base.path, base.up);
   if (!pathInfo || isNearlyZero(pathInfo.endZ - pathInfo.startZ)) return null;
-  const direction = pathInfo.endZ > pathInfo.startZ ? 1 : -1;
-  const startZ = pathInfo.startZ - direction * plan.thickness;
-  const endZ = pathInfo.endZ + direction * plan.thickness;
+  const direction2 = pathInfo.endZ > pathInfo.startZ ? 1 : -1;
+  const startZ = pathInfo.startZ - direction2 * plan.thickness;
+  const endZ = pathInfo.endZ + direction2 * plan.thickness;
   if (Math.abs(endZ - startZ) <= EXACT_PROFILE_EPS) return null;
   if (!offsetInRange(offset, startZ, endZ)) return emptyProfilePlan();
   const offsetProfileSections = base.sections.map(
@@ -40748,7 +41969,7 @@ function clusterMeshFaces(shape) {
   return clusters;
 }
 function clusterToFaceRef(cluster, name = "") {
-  const center = [
+  const center2 = [
     cluster.centroidSum[0] / cluster.count,
     cluster.centroidSum[1] / cluster.count,
     cluster.centroidSum[2] / cluster.count
@@ -40757,7 +41978,7 @@ function clusterToFaceRef(cluster, name = "") {
   return {
     name,
     normal: cluster.normal,
-    center,
+    center: center2,
     planar: true,
     uAxis: u2,
     vAxis: v
@@ -40929,7 +42150,7 @@ function representativeFaceForMembers(name, faces, query, semantic) {
   const cloned = faces.map((face) => cloneFaceRefValue(face));
   const first = cloned[0];
   const coplanar = facesAreCoplanar(cloned);
-  const center = cloned.reduce(
+  const center2 = cloned.reduce(
     (acc, face) => [acc[0] + face.center[0], acc[1] + face.center[1], acc[2] + face.center[2]],
     [0, 0, 0]
   );
@@ -40937,7 +42158,7 @@ function representativeFaceForMembers(name, faces, query, semantic) {
   const representative = {
     ...first,
     name,
-    center: [center[0] / count, center[1] / count, center[2] / count],
+    center: [center2[0] / count, center2[1] / count, center2[2] / count],
     query: cloneFaceQueryRef(query),
     planar: coplanar ? first.planar : false,
     uAxis: coplanar ? first.uAxis : void 0,
@@ -42057,10 +43278,10 @@ function resolveShapeFaceTableInternal(plan, owner) {
       if (!planeCapQuery) return table;
       const baseTable = resolveShapeFaceTable(plan.base);
       const centers = Array.from(baseTable.faces.values()).map((face) => face.center);
-      const averageCenter = centers.length > 0 ? centers.reduce((acc, center2) => [acc[0] + center2[0], acc[1] + center2[1], acc[2] + center2[2]], [0, 0, 0]).map((value) => value / centers.length) : [0, 0, plan.originOffset];
+      const averageCenter = centers.length > 0 ? centers.reduce((acc, center22) => [acc[0] + center22[0], acc[1] + center22[1], acc[2] + center22[2]], [0, 0, 0]).map((value) => value / centers.length) : [0, 0, plan.originOffset];
       const 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 center = [
+      const center2 = [
         averageCenter[0] - normal[0] * planeDistance,
         averageCenter[1] - normal[1] * planeDistance,
         averageCenter[2] - normal[2] * planeDistance
@@ -42069,7 +43290,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
       registerFace(table, {
         name: "plane-cap",
         normal,
-        center,
+        center: center2,
         planar: true,
         uAxis: basis.u,
         vAxis: basis.v,
@@ -43256,8 +44477,8 @@ class ShapeGroup {
     );
   }
   /** Reorient the group so its local Z axis points along `direction`. */
-  pointAlong(direction) {
-    const [dx, dy, dz] = requireNonZeroFiniteVec3(direction, "ShapeGroup.pointAlong() direction");
+  pointAlong(direction2) {
+    const [dx, dy, dz] = requireNonZeroFiniteVec3(direction2, "ShapeGroup.pointAlong() direction");
     const len = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
     const nx = dx / len, ny = dy / len, nz = dz / len;
     const cx = -ny, cy = nx, cz = 0;
@@ -44801,10 +46022,10 @@ function rayTriangle(ox, oy, oz, dx, dy, dz, ax, ay, az, bx, by, bz, cx, cy, cz)
   const t = (e2x * qx + e2y * qy + e2z * qz) * invDet;
   return t;
 }
-function rayMeshIntersect(mesh, origin, direction) {
+function rayMeshIntersect(mesh, origin, direction2) {
   const { numProp, numTri, triVerts, vertProperties } = mesh;
   const [ox, oy, oz] = origin;
-  const [dx, dy, dz] = direction;
+  const [dx, dy, dz] = direction2;
   const hits = [];
   for (let t = 0; t < numTri; t++) {
     const i0 = triVerts[t * 3];
@@ -44969,6 +46190,99 @@ function computeSeatOverTranslation(targetFaceVertices, targetFaceNormal, selfMe
     sampleCount: targetFaceVertices.length
   };
 }
+const UV_ANCHORS = ["top", "bottom", "front", "back", "left", "right"];
+new Set(UV_ANCHORS);
+const FACE_FRAME = {
+  front: { u: 0, v: 2 },
+  // -y face: u→x, v→z
+  back: { u: 0, v: 2 },
+  // +y face
+  left: { u: 1, v: 2 },
+  // -x face: u→y, v→z
+  right: { u: 1, v: 2 },
+  // +x face
+  top: { u: 0, v: 1 },
+  // +z face: u→x, v→y
+  bottom: { u: 0, v: 1 }
+  // -z face
+};
+const AXIS_INDEX = { x: 0, y: 1, z: 2 };
+function span(bbox, axis) {
+  return bbox.max[axis] - bbox.min[axis];
+}
+function center(bbox) {
+  return [
+    (bbox.min[0] + bbox.max[0]) / 2,
+    (bbox.min[1] + bbox.max[1]) / 2,
+    (bbox.min[2] + bbox.max[2]) / 2
+  ];
+}
+function autoFitProjection(spec, bbox) {
+  switch (spec.kind) {
+    case "flat": {
+      const frame = FACE_FRAME[spec.onto];
+      const out = { ...spec };
+      if (out.width === void 0) {
+        const w2 = span(bbox, frame.u);
+        if (w2 > 0) {
+          out.width = w2;
+          if (out.offsetU === void 0) out.offsetU = bbox.min[frame.u];
+        }
+      }
+      if (out.height === void 0) {
+        const h = span(bbox, frame.v);
+        if (h > 0) {
+          out.height = h;
+          if (out.offsetV === void 0) out.offsetV = bbox.min[frame.v];
+        }
+      }
+      return out;
+    }
+    case "box": {
+      const out = { ...spec };
+      if (out.size === void 0) {
+        const sx = span(bbox, 0);
+        const sy = span(bbox, 1);
+        const sz = span(bbox, 2);
+        if (sx > 0 && sy > 0 && sz > 0) out.size = [sx, sy, sz];
+      }
+      if (out.origin === void 0) out.origin = center(bbox);
+      return out;
+    }
+    case "cylinder": {
+      const axis = AXIS_INDEX[spec.axis];
+      const out = { ...spec };
+      if (out.height === void 0) {
+        const h = span(bbox, axis);
+        if (h > 0) {
+          out.height = h;
+          if (out.offsetV === void 0) out.offsetV = bbox.min[axis];
+        }
+      }
+      if (out.origin === void 0) out.origin = center(bbox);
+      return out;
+    }
+    case "sphere": {
+      const out = { ...spec };
+      if (out.origin === void 0) out.origin = center(bbox);
+      if (out.radius === void 0) {
+        const c2 = center(bbox);
+        const radius = Math.max(
+          bbox.max[0] - c2[0],
+          bbox.max[1] - c2[1],
+          bbox.max[2] - c2[2]
+        );
+        if (radius > 0) out.radius = radius;
+      }
+      return out;
+    }
+    default:
+      throw new Error(`autoFitProjection: unknown projection kind "${spec.kind}"`);
+  }
+}
+function isImageHandle(value) {
+  return typeof value === "object" && value !== null && value.__forgeImage === true;
+}
 const _shapeDimensions = /* @__PURE__ */ new WeakMap();
 let _shapeDimensionCounter = 0;
 function nextShapeDimensionId() {
@@ -45321,8 +46635,8 @@ function mergeShapeSourceSpans(sources, target) {
       records = /* @__PURE__ */ new Map();
       _shapeSourceSpans.set(target, records);
     }
-    for (const [key2, span] of sourceRecords) {
-      if (!records.has(key2)) records.set(key2, span);
+    for (const [key2, span2] of sourceRecords) {
+      if (!records.has(key2)) records.set(key2, span2);
     }
   }
 }
@@ -45559,6 +46873,7 @@ function withBaseDimensions(base, out) {
   if (baseTopo) _shapeTopology.set(out, cloneTopology(baseTopo));
   const baseLabels = cloneFaceLabelMap(_shapeFaceLabels.get(base));
   if (baseLabels) _shapeFaceLabels.set(out, baseLabels);
+  if (base.materialProps) out.materialProps = { ...base.materialProps };
   copyShapeReferenceMetadata(base, out);
   copyShapeSourceSpans(base, out);
   return setShapeCompilePlanInternal(out, getShapeCompilePlanInternal(base));
@@ -45623,6 +46938,30 @@ function createOwnedTopologyRewritePlan(plan, operation2, buildPropagation) {
   const owner = createShapeQueryOwner(operation2);
   return wrapShapeCompilePlanWithQueryOwner(attachTopologyRewritePropagation(plan, buildPropagation(owner)), owner);
 }
+const KNOWN_PROJECTION_KINDS = /* @__PURE__ */ new Set(["flat", "cylinder", "sphere", "box"]);
+function validateProjectionFinite(spec) {
+  switch (spec.kind) {
+    case "flat":
+      if (spec.width !== void 0) requireFiniteNumber(spec.width, "wrapTexture() flat width");
+      if (spec.height !== void 0) requireFiniteNumber(spec.height, "wrapTexture() flat height");
+      if (spec.offsetU !== void 0) requireFiniteNumber(spec.offsetU, "wrapTexture() flat offsetU");
+      if (spec.offsetV !== void 0) requireFiniteNumber(spec.offsetV, "wrapTexture() flat offsetV");
+      break;
+    case "box":
+      if (spec.size !== void 0) requireFiniteVec3$1(spec.size, "wrapTexture() box size");
+      if (spec.origin !== void 0) requireFiniteVec3$1(spec.origin, "wrapTexture() box origin");
+      break;
+    case "cylinder":
+      if (spec.height !== void 0) requireFiniteNumber(spec.height, "wrapTexture() cylinder height");
+      if (spec.offsetV !== void 0) requireFiniteNumber(spec.offsetV, "wrapTexture() cylinder offsetV");
+      if (spec.origin !== void 0) requireFiniteVec3$1(spec.origin, "wrapTexture() cylinder origin");
+      break;
+    case "sphere":
+      if (spec.origin !== void 0) requireFiniteVec3$1(spec.origin, "wrapTexture() sphere origin");
+      if (spec.radius !== void 0) requireFiniteNumber(spec.radius, "wrapTexture() sphere radius");
+      break;
+  }
+}
 function parseReferencePath(path) {
   const trimmed = path.trim();
   if (!trimmed) throw new Error("Shape.ref() requires a non-empty path.");
@@ -46000,6 +47339,61 @@ class Shape {
     out.materialProps = { ...this.materialProps ?? {}, ...props };
     return out;
   }
+  /**
+   * Wrap an imported bitmap image around this shape using a projection.
+   *
+   * **Details**
+   *
+   * The `image` comes from `Import.image('path.png')`; the `projection` is one of the `Wrap.*`
+   * helpers — `Wrap.flat({ onto: 'top' })` lays it flat on a face, `Wrap.aroundCylinder({ axis: 'z' })`
+   * wraps it like a can label, `Wrap.onSphere()` maps it like a globe, and `Wrap.box()` cube-maps
+   * it onto the six sides.
+   *
+   * By default the image **auto-fits** the shape — one copy across the relevant extent, so no
+   * `width`/`height`/`size` is needed (pass them only to override). The (u,v) is derived from each
+   * vertex's final world position, so the image stays glued to the surface through transforms and
+   * boolean cuts with no UV layout to maintain — apply `wrapTexture` *after* positioning the shape.
+   * Returns a new Shape; the original is unchanged.
+   *
+   * **Example**
+   *
+   * ```js
+   * const logo = Import.image('./logo.png');
+   * box(80, 80, 10).wrapTexture(logo, Wrap.flat({ onto: 'top' }));            // auto-fits the face
+   *
+   * const label = Import.image('./label.jpg');
+   * cylinder(60, 20).wrapTexture(label, Wrap.aroundCylinder({ axis: 'z' }));  // wraps the side
+   * ```
+   *
+   * @param image - An imported bitmap from `Import.image(...)`
+   * @param projection - A projection spec from `Wrap.flat` / `Wrap.aroundCylinder` / `Wrap.onSphere` / `Wrap.box`
+   * @returns A new Shape with the projected texture recorded in its material properties
+   * @category Materials
+   */
+  wrapTexture(image, projection) {
+    if (!isImageHandle(image)) {
+      throw new Error("wrapTexture() expects an image from Import.image(...) as its first argument");
+    }
+    if (!projection || typeof projection !== "object" || !KNOWN_PROJECTION_KINDS.has(projection.kind)) {
+      throw new Error(
+        `wrapTexture() expects a projection from Wrap.flat / Wrap.aroundCylinder / Wrap.onSphere / Wrap.box, got ${JSON.stringify(projection == null ? void 0 : projection.kind)}`
+      );
+    }
+    const bbox = this.boundingBox();
+    const filled = autoFitProjection(projection, bbox);
+    validateProjectionFinite(filled);
+    const out = this.clone();
+    out.materialProps = {
+      ...this.materialProps ?? {},
+      texture: {
+        image: image.dataUri,
+        projection: filled,
+        imageWidth: image.width,
+        imageHeight: image.height
+      }
+    };
+    return out;
+  }
   /** Return a new Shape wrapper for explicit duplication in scripts. */
   clone() {
     const out = withCopiedDimensions(this, new Shape(getShapeRuntimeBackendInternal(this).clone(), this.colorHex));
@@ -46527,12 +47921,12 @@ class Shape {
   scale(v) {
     const scale2 = requireNonZeroFiniteScale3(v, "Shape.scale() scale");
     const bb = this.boundingBox();
-    const center = [
+    const center2 = [
       (bb.min[0] + bb.max[0]) / 2,
       (bb.min[1] + bb.max[1]) / 2,
       (bb.min[2] + bb.max[2]) / 2
     ];
-    return this.scaleAround(center, scale2);
+    return this.scaleAround(center2, scale2);
   }
   /** Scale the shape uniformly or per-axis from an explicit pivot point. */
   scaleAround(pivot, v) {
@@ -46566,12 +47960,12 @@ class Shape {
   /** Mirror across a plane through the shape's bounding box center, defined by its normal vector. */
   mirror(normal) {
     const bb = this.boundingBox();
-    const center = [
+    const center2 = [
       (bb.min[0] + bb.max[0]) / 2,
       (bb.min[1] + bb.max[1]) / 2,
       (bb.min[2] + bb.max[2]) / 2
     ];
-    return this.mirrorThrough(center, normal);
+    return this.mirrorThrough(center2, normal);
   }
   /** Mirror across a plane through an explicit point, defined by its normal vector. */
   mirrorThrough(point2, normal) {
@@ -46611,8 +48005,8 @@ class Shape {
    *
    * Example: cylinder(40, 5).pointAlong([1, 0, 0]) — lays cylinder along X, starting at origin
    */
-  pointAlong(direction) {
-    const [dx, dy, dz] = requireNonZeroFiniteVec3(direction, "Shape.pointAlong() direction");
+  pointAlong(direction2) {
+    const [dx, dy, dz] = requireNonZeroFiniteVec3(direction2, "Shape.pointAlong() direction");
     const len = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
     const nx = dx / len, ny = dy / len, nz = dz / len;
     const cx = -ny, cy = nx, cz = 0;
@@ -49304,731 +50698,204 @@ function thicknessClass(thickness, options) {
 }
 function thicknessColor(thickness, options) {
   if (thickness == null || !Number.isFinite(thickness) || thickness <= 0) return THICKNESS_COLORS.unknown;
-  const span = Math.max(1e-9, options.colorMaxThickness - options.colorMinThickness);
-  return gradientColor(THICKNESS_GRADIENT_COLORS, (thickness - options.colorMinThickness) / span);
+  const span2 = Math.max(1e-9, options.colorMaxThickness - options.colorMinThickness);
+  return gradientColor(THICKNESS_GRADIENT_COLORS, (thickness - options.colorMinThickness) / span2);
 }
-function cloneGeometryForFaceColors(geometry) {
-  return geometry.index ? geometry.toNonIndexed() : geometry.clone();
+const CENTER = 0;
+const AVERAGE = 1;
+const SAH = 2;
+const CONTAINED = 2;
+const TRIANGLE_INTERSECT_COST = 1.25;
+const TRAVERSAL_COST = 1;
+const BYTES_PER_NODE = 6 * 4 + 4 + 4;
+const IS_LEAFNODE_FLAG = 65535;
+const FLOAT32_EPSILON = Math.pow(2, -24);
+const SKIP_GENERATION = Symbol("SKIP_GENERATION");
+function getVertexCount(geo) {
+  return geo.index ? geo.index.count : geo.attributes.position.count;
 }
-function geometryMaxDimension(geometry) {
-  geometry.computeBoundingBox();
-  const box = geometry.boundingBox;
-  if (!box) return 1;
-  const size = new Vector3();
-  box.getSize(size);
-  return Math.max(1, size.x, size.y, size.z);
+function getTriCount(geo) {
+  return getVertexCount(geo) / 3;
 }
-function firstOppositeSurfaceDistance(raycaster, rayTargetMeshes, jumpableMeshes, point2, direction, epsilon2, far, contactTolerance) {
-  const origin = point2.clone().addScaledVector(direction, epsilon2);
-  raycaster.set(origin, direction);
-  raycaster.near = epsilon2;
-  raycaster.far = far;
-  const hits = raycaster.intersectObjects(rayTargetMeshes, false);
-  for (const hit of hits) {
-    if (hit.distance <= epsilon2) continue;
-    if (hit.distance <= contactTolerance && jumpableMeshes.has(hit.object)) continue;
-    return hit.distance + epsilon2;
+function getIndexArray(vertexCount, BufferConstructor = ArrayBuffer) {
+  if (vertexCount > 65535) {
+    return new Uint32Array(new BufferConstructor(4 * vertexCount));
+  } else {
+    return new Uint16Array(new BufferConstructor(2 * vertexCount));
   }
-  return null;
 }
-function triangleThickness(raycaster, rayTargetMeshes, jumpableMeshes, centroid, normal, epsilon2, far, contactTolerance) {
-  const forward = firstOppositeSurfaceDistance(
-    raycaster,
-    rayTargetMeshes,
-    jumpableMeshes,
-    centroid,
-    normal,
-    epsilon2,
-    far,
-    contactTolerance
-  );
-  const backward = firstOppositeSurfaceDistance(
-    raycaster,
-    rayTargetMeshes,
-    jumpableMeshes,
-    centroid,
-    normal.clone().negate(),
-    epsilon2,
-    far,
-    contactTolerance
-  );
-  if (forward == null) return backward;
-  if (backward == null) return forward;
-  return Math.min(forward, backward);
+function ensureIndex(geo, options) {
+  if (!geo.index) {
+    const vertexCount = geo.attributes.position.count;
+    const BufferConstructor = options.useSharedArrayBuffer ? SharedArrayBuffer : ArrayBuffer;
+    const index2 = getIndexArray(vertexCount, BufferConstructor);
+    geo.setIndex(new BufferAttribute(index2, 1));
+    for (let i = 0; i < vertexCount; i++) {
+      index2[i] = i;
+    }
+  }
 }
-function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}, context = {}) {
-  const options = resolveThicknessInspectionOptions(rawOptions);
-  const geometry = cloneGeometryForFaceColors(sourceGeometry);
-  const position = geometry.getAttribute("position");
-  if (!position || position.count < 3) {
-    return {
-      geometry,
-      samples: [],
-      pointSamples: [],
-      triangleCount: 0,
-      sampledTriangleCount: 0,
-      sampleStride: 1,
-      warnings: ["No triangle geometry."]
-    };
+function getFullGeometryRange(geo, range) {
+  const triCount = getTriCount(geo);
+  const drawRange = range ? range : geo.drawRange;
+  const start = drawRange.start / 3;
+  const end = (drawRange.start + drawRange.count) / 3;
+  const offset = Math.max(0, start);
+  const count = Math.min(triCount, end) - offset;
+  return [{
+    offset: Math.floor(offset),
+    count: Math.floor(count)
+  }];
+}
+function getRootIndexRanges(geo, range) {
+  if (!geo.groups || !geo.groups.length) {
+    return getFullGeometryRange(geo, range);
   }
-  const triangleCount = Math.floor(position.count / 3);
-  const surfaceTriangles = readSurfaceTriangles(position);
-  const surfaceSamples = sampleSurfaceTriangles(surfaceTriangles, options.maxSamplesPerObject);
-  const connectedGeometries = context.connectedGeometries ?? [];
-  const maxDim2 = Math.max(geometryMaxDimension(geometry), ...connectedGeometries.map(geometryMaxDimension));
-  const epsilon2 = Math.max(1e-4, maxDim2 * 1e-6);
-  const far = Math.max(maxDim2 * 4, options.maxThickness * 4, 1);
-  const colors = new Float32Array(position.count * 3);
-  const triangleThicknessValues = new Array(triangleCount).fill(void 0);
-  const samples = [];
-  const pointSamples = [];
-  const warnings = [];
-  const rayMaterial = new MeshBasicMaterial({ side: DoubleSide });
-  const rayTargets = [
-    { mesh: new Mesh(geometry, rayMaterial), jumpable: false },
-    ...connectedGeometries.map((connectedGeometry) => ({
-      mesh: new Mesh(connectedGeometry, rayMaterial),
-      jumpable: true
-    }))
-  ];
-  const rayTargetMeshes = rayTargets.map((target) => target.mesh);
-  const jumpableMeshes = new Set(rayTargets.filter((target) => target.jumpable).map((target) => target.mesh));
-  const raycaster = new Raycaster();
-  if (surfaceTriangles.length === 0) {
-    warnings.push("No non-degenerate triangle surface was available for thickness sampling.");
-  } else if (surfaceSamples.length < surfaceTriangles.length) {
-    warnings.push(
-      `Area sampling budget ${surfaceSamples.length} covers ${surfaceTriangles.length} surface triangles; increase --thickness-samples for denser analysis.`
-    );
+  const ranges = [];
+  const rangeBoundaries = /* @__PURE__ */ new Set();
+  const drawRange = range ? range : geo.drawRange;
+  const drawRangeStart = drawRange.start / 3;
+  const drawRangeEnd = (drawRange.start + drawRange.count) / 3;
+  for (const group of geo.groups) {
+    const groupStart = group.start / 3;
+    const groupEnd = (group.start + group.count) / 3;
+    rangeBoundaries.add(Math.max(drawRangeStart, groupStart));
+    rangeBoundaries.add(Math.min(drawRangeEnd, groupEnd));
   }
-  const sampledTriangleIndexes = /* @__PURE__ */ new Set();
-  for (const sample of surfaceSamples) {
-    sampledTriangleIndexes.add(sample.triangle.index);
-    const thickness = triangleThickness(
-      raycaster,
-      rayTargetMeshes,
-      jumpableMeshes,
-      sample.position,
-      sample.normal,
-      epsilon2,
-      far,
-      options.contactTolerance
-    );
-    samples.push({ thickness, area: sample.area });
-    const previous = triangleThicknessValues[sample.triangle.index];
-    if (previous === void 0 || previous == null || thickness != null && thickness < previous) {
-      triangleThicknessValues[sample.triangle.index] = thickness;
-    }
-    pointSamples.push({
-      position: [sample.position.x, sample.position.y, sample.position.z],
-      normal: [sample.normal.x, sample.normal.y, sample.normal.z],
-      value: thickness,
-      className: thicknessClass(thickness, options),
-      color: thicknessColor(thickness, options),
-      area: sample.area
+  const sortedBoundaries = Array.from(rangeBoundaries.values()).sort((a2, b) => a2 - b);
+  for (let i = 0; i < sortedBoundaries.length - 1; i++) {
+    const start = sortedBoundaries[i];
+    const end = sortedBoundaries[i + 1];
+    ranges.push({
+      offset: Math.floor(start),
+      count: Math.floor(end - start)
     });
   }
-  for (let tri = 0; tri < triangleCount; tri += 1) {
-    const color = thicknessColor(triangleThicknessValues[tri], options);
-    const offset = tri * 3;
-    for (let vertex2 = 0; vertex2 < 3; vertex2 += 1) {
-      const colorOffset = (offset + vertex2) * 3;
-      colors[colorOffset] = color[0] / 255;
-      colors[colorOffset + 1] = color[1] / 255;
-      colors[colorOffset + 2] = color[2] / 255;
-    }
-  }
-  geometry.setAttribute("color", new BufferAttribute(colors, 3));
-  rayMaterial.dispose();
-  return {
-    geometry,
-    samples,
-    pointSamples,
-    triangleCount,
-    sampledTriangleCount: sampledTriangleIndexes.size,
-    sampleStride: Math.max(1, Math.ceil(Math.max(1, surfaceTriangles.length) / Math.max(1, sampledTriangleIndexes.size))),
-    warnings
-  };
-}
-const DEFAULT_VERTEX_CAP = 2e6;
-const DEFAULT_TARGET_EDGE_SPACING_FACTOR = 2;
-const DEFAULT_K = 8;
-const DEFAULT_GATE_DOT = 0.3;
-const SCATTER_CELL_SPACING_FACTOR = 1.5;
-const SCATTER_RADIUS_SPACING_FACTOR = 3;
-const IDW_DISTANCE_FLOOR = 1e-9;
-const MAX_SUBDIVISION_PASSES = 24;
-function subVec(a2, b) {
-  return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
-}
-function crossVec(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 lenVec(a2) {
-  return Math.hypot(a2[0], a2[1], a2[2]);
-}
-function getVert(positions, i) {
-  const o = i * 3;
-  return [positions[o], positions[o + 1], positions[o + 2]];
-}
-function triArea(positions, a2, b, c2) {
-  const va = getVert(positions, a2);
-  return 0.5 * lenVec(crossVec(subVec(getVert(positions, b), va), subVec(getVert(positions, c2), va)));
-}
-function triNormal(positions, a2, b, c2) {
-  const va = getVert(positions, a2);
-  const n = crossVec(subVec(getVert(positions, b), va), subVec(getVert(positions, c2), va));
-  const l = lenVec(n) || 1;
-  return [n[0] / l, n[1] / l, n[2] / l];
+  return ranges;
 }
-function edgeLen(positions, a2, b) {
-  return lenVec(subVec(getVert(positions, a2), getVert(positions, b)));
+function hasGroupGaps(geometry, range) {
+  const vertexCount = getTriCount(geometry);
+  const groups = getRootIndexRanges(geometry, range).sort((a2, b) => a2.offset - b.offset);
+  const finalGroup = groups[groups.length - 1];
+  finalGroup.count = Math.min(vertexCount - finalGroup.offset, finalGroup.count);
+  let total = 0;
+  groups.forEach(({ count }) => total += count);
+  return vertexCount !== total;
 }
-function maxEdge(positions, a2, b, c2) {
-  return Math.max(edgeLen(positions, a2, b), edgeLen(positions, b, c2), edgeLen(positions, c2, a2));
+function getBounds(triangleBounds2, offset, count, target, centroidTarget) {
+  let minx = Infinity;
+  let miny = Infinity;
+  let minz = Infinity;
+  let maxx = -Infinity;
+  let maxy = -Infinity;
+  let maxz = -Infinity;
+  let cminx = Infinity;
+  let cminy = Infinity;
+  let cminz = Infinity;
+  let cmaxx = -Infinity;
+  let cmaxy = -Infinity;
+  let cmaxz = -Infinity;
+  for (let i = offset * 6, end = (offset + count) * 6; i < end; i += 6) {
+    const cx = triangleBounds2[i + 0];
+    const hx = triangleBounds2[i + 1];
+    const lx = cx - hx;
+    const rx = cx + hx;
+    if (lx < minx) minx = lx;
+    if (rx > maxx) maxx = rx;
+    if (cx < cminx) cminx = cx;
+    if (cx > cmaxx) cmaxx = cx;
+    const cy = triangleBounds2[i + 2];
+    const hy = triangleBounds2[i + 3];
+    const ly = cy - hy;
+    const ry = cy + hy;
+    if (ly < miny) miny = ly;
+    if (ry > maxy) maxy = ry;
+    if (cy < cminy) cminy = cy;
+    if (cy > cmaxy) cmaxy = cy;
+    const cz = triangleBounds2[i + 4];
+    const hz = triangleBounds2[i + 5];
+    const lz = cz - hz;
+    const rz = cz + hz;
+    if (lz < minz) minz = lz;
+    if (rz > maxz) maxz = rz;
+    if (cz < cminz) cminz = cz;
+    if (cz > cmaxz) cmaxz = cz;
+  }
+  target[0] = minx;
+  target[1] = miny;
+  target[2] = minz;
+  target[3] = maxx;
+  target[4] = maxy;
+  target[5] = maxz;
+  centroidTarget[0] = cminx;
+  centroidTarget[1] = cminy;
+  centroidTarget[2] = cminz;
+  centroidTarget[3] = cmaxx;
+  centroidTarget[4] = cmaxy;
+  centroidTarget[5] = cmaxz;
 }
-function weld(positions) {
-  if (positions.length % 9 !== 0) {
-    throw new Error(
-      `weld: positions length must be a multiple of 9 (9 floats per triangle), got ${positions.length}`
-    );
+function computeTriangleBounds(geo, target = null, offset = null, count = null) {
+  const posAttr = geo.attributes.position;
+  const index2 = geo.index ? geo.index.array : null;
+  const triCount = getTriCount(geo);
+  const normalized = posAttr.normalized;
+  let triangleBounds2;
+  if (target === null) {
+    triangleBounds2 = new Float32Array(triCount * 6);
+    offset = 0;
+    count = triCount;
+  } else {
+    triangleBounds2 = target;
+    offset = offset || 0;
+    count = count || triCount;
   }
-  positions.length / 3;
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (let i = 0; i < positions.length; i += 3) {
-    const x2 = positions[i];
-    const y2 = positions[i + 1];
-    const z2 = positions[i + 2];
-    if (!Number.isFinite(x2) || !Number.isFinite(y2) || !Number.isFinite(z2)) {
-      throw new Error(`weld: non-finite vertex position at float index ${i}`);
-    }
-    if (x2 < minX) minX = x2;
-    if (y2 < minY) minY = y2;
-    if (z2 < minZ) minZ = z2;
-    if (x2 > maxX) maxX = x2;
-    if (y2 > maxY) maxY = y2;
-    if (z2 > maxZ) maxZ = z2;
+  const posArr = posAttr.array;
+  const bufferOffset = posAttr.offset || 0;
+  let stride = 3;
+  if (posAttr.isInterleavedBufferAttribute) {
+    stride = posAttr.data.stride;
   }
-  const diagonal = Math.hypot(maxX - minX, maxY - minY, maxZ - minZ);
-  const tolerance = Math.max(diagonal * 1e-5, Number.EPSILON);
-  const remap = /* @__PURE__ */ new Map();
-  const out = [];
-  const tris = [];
-  const inv = 1 / tolerance;
-  const quantKey = (i) => {
-    const qx = Math.round(positions[i] * inv);
-    const qy = Math.round(positions[i + 1] * inv);
-    const qz = Math.round(positions[i + 2] * inv);
-    return `${qx},${qy},${qz}`;
-  };
-  for (let tri = 0; tri < positions.length; tri += 9) {
-    const idx = [];
-    for (let corner = 0; corner < 3; corner += 1) {
-      const o = tri + corner * 3;
-      const key2 = quantKey(o);
-      let vi = remap.get(key2);
-      if (vi === void 0) {
-        vi = out.length / 3;
-        out.push(positions[o], positions[o + 1], positions[o + 2]);
-        remap.set(key2, vi);
-      }
-      idx.push(vi);
+  const getters = ["getX", "getY", "getZ"];
+  for (let tri = offset; tri < offset + count; tri++) {
+    const tri3 = tri * 3;
+    const tri6 = tri * 6;
+    let ai = tri3 + 0;
+    let bi = tri3 + 1;
+    let ci = tri3 + 2;
+    if (index2) {
+      ai = index2[ai];
+      bi = index2[bi];
+      ci = index2[ci];
     }
-    if (idx[0] !== idx[1] && idx[1] !== idx[2] && idx[2] !== idx[0]) {
-      tris.push(idx[0], idx[1], idx[2]);
+    if (!normalized) {
+      ai = ai * stride + bufferOffset;
+      bi = bi * stride + bufferOffset;
+      ci = ci * stride + bufferOffset;
     }
-  }
-  const distinctVertexCount = out.length / 3;
-  const degenerate = distinctVertexCount < 3 || tris.length === 0;
-  return { positions: out, tris, degenerate };
-}
-function adaptiveSubdivide(mesh, targetEdge, vertexCap) {
-  requirePositiveFiniteNumber(targetEdge, "adaptiveSubdivide targetEdge");
-  requireIntegerAtLeast(vertexCap, "adaptiveSubdivide vertexCap", 3);
-  const positions = mesh.positions.slice();
-  let tris = mesh.tris.slice();
-  let capped = false;
-  const keyOf = (a2, b) => a2 < b ? `${a2}_${b}` : `${b}_${a2}`;
-  for (let pass = 0; pass < MAX_SUBDIVISION_PASSES; pass += 1) {
-    const next = [];
-    const midCache = /* @__PURE__ */ new Map();
-    let changed = false;
-    const getMid = (a2, b) => {
-      const key2 = keyOf(a2, b);
-      let mi = midCache.get(key2);
-      if (mi === void 0) {
-        mi = positions.length / 3;
-        const ao = a2 * 3;
-        const bo = b * 3;
-        positions.push(
-          (positions[ao] + positions[bo]) / 2,
-          (positions[ao + 1] + positions[bo + 1]) / 2,
-          (positions[ao + 2] + positions[bo + 2]) / 2
-        );
-        midCache.set(key2, mi);
-      }
-      return mi;
-    };
-    for (let t = 0; t < tris.length; t += 3) {
-      const a2 = tris[t];
-      const b = tris[t + 1];
-      const c2 = tris[t + 2];
-      const vertexCount = positions.length / 3;
-      if (maxEdge(positions, a2, b, c2) > targetEdge && vertexCount < vertexCap) {
-        const ab = getMid(a2, b);
-        const bc = getMid(b, c2);
-        const ca = getMid(c2, a2);
-        next.push(a2, ab, ca, ab, b, bc, ca, bc, c2, ab, bc, ca);
-        changed = true;
+    for (let el = 0; el < 3; el++) {
+      let a2, b, c2;
+      if (normalized) {
+        a2 = posAttr[getters[el]](ai);
+        b = posAttr[getters[el]](bi);
+        c2 = posAttr[getters[el]](ci);
       } else {
-        if (positions.length / 3 >= vertexCap) capped = true;
-        next.push(a2, b, c2);
+        a2 = posArr[ai + el];
+        b = posArr[bi + el];
+        c2 = posArr[ci + el];
       }
+      let min2 = a2;
+      if (b < min2) min2 = b;
+      if (c2 < min2) min2 = c2;
+      let max2 = a2;
+      if (b > max2) max2 = b;
+      if (c2 > max2) max2 = c2;
+      const halfExtents = (max2 - min2) / 2;
+      const el2 = el * 2;
+      triangleBounds2[tri6 + el2 + 0] = min2 + halfExtents;
+      triangleBounds2[tri6 + el2 + 1] = halfExtents + (Math.abs(min2) + halfExtents) * FLOAT32_EPSILON;
     }
-    tris = next;
-    if (!changed) break;
   }
-  return { positions, tris, capped };
-}
-function vertexNormals(mesh) {
-  const vertexCount = mesh.positions.length / 3;
-  const acc = new Float32Array(vertexCount * 3);
-  for (let t = 0; t < mesh.tris.length; t += 3) {
-    const a2 = mesh.tris[t];
-    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;
-    for (const vi of [a2, b, c2]) {
-      acc[vi * 3] += nx;
-      acc[vi * 3 + 1] += ny;
-      acc[vi * 3 + 2] += nz;
-    }
-  }
-  for (let i = 0; i < vertexCount; i += 1) {
-    const o = i * 3;
-    const l = Math.hypot(acc[o], acc[o + 1], acc[o + 2]) || 1;
-    acc[o] /= l;
-    acc[o + 1] /= l;
-    acc[o + 2] /= l;
-  }
-  return acc;
-}
-function buildSampleGrid(positions, cell) {
-  const grid = /* @__PURE__ */ new Map();
-  const sampleCount = positions.length / 3;
-  for (let i = 0; i < sampleCount; i += 1) {
-    const o = i * 3;
-    const key2 = `${Math.floor(positions[o] / cell)},${Math.floor(positions[o + 1] / cell)},${Math.floor(positions[o + 2] / cell)}`;
-    let arr = grid.get(key2);
-    if (!arr) {
-      arr = [];
-      grid.set(key2, arr);
-    }
-    arr.push(i);
-  }
-  return { grid, cell };
-}
-function gatherSamples(sampleGrid, p2, rings, out) {
-  out.length = 0;
-  const { cell, grid } = sampleGrid;
-  const bx = Math.floor(p2[0] / cell);
-  const by = Math.floor(p2[1] / cell);
-  const bz = Math.floor(p2[2] / cell);
-  for (let dx = -rings; dx <= rings; dx += 1) {
-    for (let dy = -rings; dy <= rings; dy += 1) {
-      for (let dz = -rings; dz <= rings; dz += 1) {
-        const arr = grid.get(`${bx + dx},${by + dy},${bz + dz}`);
-        if (arr) for (const i of arr) out.push(i);
-      }
-    }
-  }
-}
-function scatterToVertices(positions, vnormals, samples, spacing, k2, gateDot) {
-  const cell = spacing * SCATTER_CELL_SPACING_FACTOR;
-  const sampleGrid = buildSampleGrid(samples.positions, cell);
-  const radius = spacing * SCATTER_RADIUS_SPACING_FACTOR;
-  const radius2 = radius * radius;
-  const vertexCount = positions.length / 3;
-  const values = new Float32Array(vertexCount);
-  let holeCount = 0;
-  const candidates = [];
-  const scratchP = [0, 0, 0];
-  const bestD2 = new Float64Array(k2);
-  const bestVal = new Float64Array(k2);
-  for (let vi = 0; vi < vertexCount; vi += 1) {
-    const pi = vi * 3;
-    const px = positions[pi];
-    const py = positions[pi + 1];
-    const pz = positions[pi + 2];
-    const nx = vnormals[pi];
-    const ny = vnormals[pi + 1];
-    const nz = vnormals[pi + 2];
-    scratchP[0] = px;
-    scratchP[1] = py;
-    scratchP[2] = pz;
-    gatherSamples(sampleGrid, scratchP, 3, candidates);
-    let count = 0;
-    let worst = 0;
-    let worstD2 = -Infinity;
-    for (let c2 = 0; c2 < candidates.length; c2 += 1) {
-      const si = candidates[c2];
-      const so = si * 3;
-      const dx = samples.positions[so] - px;
-      const dy = samples.positions[so + 1] - py;
-      const dz = samples.positions[so + 2] - pz;
-      const d2 = dx * dx + dy * dy + dz * dz;
-      if (d2 > radius2) continue;
-      if (samples.normals[so] * nx + samples.normals[so + 1] * ny + samples.normals[so + 2] * nz < gateDot) continue;
-      const val = samples.values[si];
-      if (count < k2) {
-        bestD2[count] = d2;
-        bestVal[count] = val;
-        if (d2 > worstD2) {
-          worstD2 = d2;
-          worst = count;
-        }
-        count += 1;
-      } else if (d2 < worstD2) {
-        bestD2[worst] = d2;
-        bestVal[worst] = val;
-        worstD2 = -Infinity;
-        for (let t = 0; t < k2; t += 1) {
-          if (bestD2[t] > worstD2) {
-            worstD2 = bestD2[t];
-            worst = t;
-          }
-        }
-      }
-    }
-    if (count === 0) {
-      holeCount += 1;
-      values[vi] = NaN;
-      continue;
-    }
-    let w2 = 0;
-    let acc = 0;
-    for (let t = 0; t < count; t += 1) {
-      const ww = 1 / Math.max(bestD2[t], IDW_DISTANCE_FLOOR);
-      w2 += ww;
-      acc += ww * bestVal[t];
-    }
-    values[vi] = acc / w2;
-  }
-  return { values, holeCount };
-}
-function backfillHoles(values, mesh) {
-  const vertexCount = values.length;
-  const adjacency = Array.from({ length: vertexCount }, () => []);
-  for (let t = 0; t < mesh.tris.length; t += 3) {
-    const a2 = mesh.tris[t];
-    const b = mesh.tris[t + 1];
-    const c2 = mesh.tris[t + 2];
-    adjacency[a2].push(b, c2);
-    adjacency[b].push(a2, c2);
-    adjacency[c2].push(a2, b);
-  }
-  let frontier = [];
-  for (let i = 0; i < vertexCount; i += 1) {
-    if (Number.isFinite(values[i])) frontier.push(i);
-  }
-  if (frontier.length === 0) {
-    values.fill(0);
-    return;
-  }
-  while (frontier.length > 0) {
-    const nextFrontier = [];
-    for (const v of frontier) {
-      const val = values[v];
-      for (const n of adjacency[v]) {
-        if (!Number.isFinite(values[n])) {
-          values[n] = val;
-          nextFrontier.push(n);
-        }
-      }
-    }
-    frontier = nextFrontier;
-  }
-}
-function reconstructSurfaceScalarField(trianglePositions, samples, options = {}) {
-  if (!(trianglePositions instanceof Float32Array)) {
-    throw new Error("reconstructSurfaceScalarField: trianglePositions must be a Float32Array");
-  }
-  if (trianglePositions.length === 0 || trianglePositions.length % 9 !== 0) {
-    throw new Error(
-      `reconstructSurfaceScalarField: trianglePositions length must be a positive multiple of 9, got ${trianglePositions.length}`
-    );
-  }
-  if (!(samples.positions instanceof Float32Array) || !(samples.values instanceof Float32Array) || !(samples.normals instanceof Float32Array)) {
-    throw new Error("reconstructSurfaceScalarField: samples positions/values/normals must be Float32Arrays");
-  }
-  const sampleCount = samples.values.length;
-  if (sampleCount === 0) {
-    throw new Error("reconstructSurfaceScalarField: samples must be non-empty");
-  }
-  if (samples.positions.length !== sampleCount * 3) {
-    throw new Error(
-      `reconstructSurfaceScalarField: samples.positions length ${samples.positions.length} must equal values*3 (${sampleCount * 3})`
-    );
-  }
-  if (samples.normals.length !== sampleCount * 3) {
-    throw new Error(
-      `reconstructSurfaceScalarField: samples.normals length ${samples.normals.length} must equal values*3 (${sampleCount * 3})`
-    );
-  }
-  for (let i = 0; i < sampleCount; i += 1) {
-    requireFiniteNumber(samples.values[i], `samples.values[${i}]`);
-  }
-  const vertexCap = options.vertexCap === void 0 ? DEFAULT_VERTEX_CAP : requireIntegerAtLeast(options.vertexCap, "vertexCap", 3);
-  const targetEdgeSpacingFactor = options.targetEdgeSpacingFactor === void 0 ? DEFAULT_TARGET_EDGE_SPACING_FACTOR : requirePositiveFiniteNumber(options.targetEdgeSpacingFactor, "targetEdgeSpacingFactor");
-  const k2 = options.k === void 0 ? DEFAULT_K : requireIntegerAtLeast(options.k, "k", 1);
-  const gateDot = options.gateDot === void 0 ? DEFAULT_GATE_DOT : requireFiniteNumber(options.gateDot, "gateDot");
-  const welded = weld(trianglePositions);
-  let surfaceArea = 0;
-  for (let t = 0; t < welded.tris.length; t += 3) {
-    surfaceArea += triArea(welded.positions, welded.tris[t], welded.tris[t + 1], welded.tris[t + 2]);
-  }
-  const sampleSpacing = surfaceArea > 0 ? Math.sqrt(surfaceArea / sampleCount) : 0;
-  let subdivided;
-  if (welded.degenerate || !(sampleSpacing > 0)) {
-    subdivided = { positions: welded.positions, tris: welded.tris, capped: false };
-  } else {
-    const targetEdge = targetEdgeSpacingFactor * sampleSpacing;
-    subdivided = adaptiveSubdivide(welded, targetEdge, vertexCap);
-  }
-  const normals = vertexNormals(subdivided);
-  const effectiveSpacing = sampleSpacing > 0 ? sampleSpacing : 1;
-  const scatter = scatterToVertices(subdivided.positions, normals, samples, effectiveSpacing, k2, gateDot);
-  let valueMin = Infinity;
-  let valueMax = -Infinity;
-  for (let i = 0; i < scatter.values.length; i += 1) {
-    const v = scatter.values[i];
-    if (!Number.isFinite(v)) continue;
-    if (v < valueMin) valueMin = v;
-    if (v > valueMax) valueMax = v;
-  }
-  if (!Number.isFinite(valueMin) || !Number.isFinite(valueMax)) {
-    valueMin = 0;
-    valueMax = 0;
-  }
-  backfillHoles(scatter.values, subdivided);
-  const vertexCount = subdivided.positions.length / 3;
-  return {
-    positions: Float32Array.from(subdivided.positions),
-    normals,
-    index: Uint32Array.from(subdivided.tris),
-    values: scatter.values,
-    valueMin,
-    valueMax,
-    capped: subdivided.capped,
-    degenerate: welded.degenerate,
-    holeCount: scatter.holeCount,
-    vertexCount
-  };
-}
-const CENTER = 0;
-const AVERAGE = 1;
-const SAH = 2;
-const CONTAINED = 2;
-const TRIANGLE_INTERSECT_COST = 1.25;
-const TRAVERSAL_COST = 1;
-const BYTES_PER_NODE = 6 * 4 + 4 + 4;
-const IS_LEAFNODE_FLAG = 65535;
-const FLOAT32_EPSILON = Math.pow(2, -24);
-const SKIP_GENERATION = Symbol("SKIP_GENERATION");
-function getVertexCount(geo) {
-  return geo.index ? geo.index.count : geo.attributes.position.count;
-}
-function getTriCount(geo) {
-  return getVertexCount(geo) / 3;
-}
-function getIndexArray(vertexCount, BufferConstructor = ArrayBuffer) {
-  if (vertexCount > 65535) {
-    return new Uint32Array(new BufferConstructor(4 * vertexCount));
-  } else {
-    return new Uint16Array(new BufferConstructor(2 * vertexCount));
-  }
-}
-function ensureIndex(geo, options) {
-  if (!geo.index) {
-    const vertexCount = geo.attributes.position.count;
-    const BufferConstructor = options.useSharedArrayBuffer ? SharedArrayBuffer : ArrayBuffer;
-    const index2 = getIndexArray(vertexCount, BufferConstructor);
-    geo.setIndex(new BufferAttribute(index2, 1));
-    for (let i = 0; i < vertexCount; i++) {
-      index2[i] = i;
-    }
-  }
-}
-function getFullGeometryRange(geo, range) {
-  const triCount = getTriCount(geo);
-  const drawRange = range ? range : geo.drawRange;
-  const start = drawRange.start / 3;
-  const end = (drawRange.start + drawRange.count) / 3;
-  const offset = Math.max(0, start);
-  const count = Math.min(triCount, end) - offset;
-  return [{
-    offset: Math.floor(offset),
-    count: Math.floor(count)
-  }];
-}
-function getRootIndexRanges(geo, range) {
-  if (!geo.groups || !geo.groups.length) {
-    return getFullGeometryRange(geo, range);
-  }
-  const ranges = [];
-  const rangeBoundaries = /* @__PURE__ */ new Set();
-  const drawRange = range ? range : geo.drawRange;
-  const drawRangeStart = drawRange.start / 3;
-  const drawRangeEnd = (drawRange.start + drawRange.count) / 3;
-  for (const group of geo.groups) {
-    const groupStart = group.start / 3;
-    const groupEnd = (group.start + group.count) / 3;
-    rangeBoundaries.add(Math.max(drawRangeStart, groupStart));
-    rangeBoundaries.add(Math.min(drawRangeEnd, groupEnd));
-  }
-  const sortedBoundaries = Array.from(rangeBoundaries.values()).sort((a2, b) => a2 - b);
-  for (let i = 0; i < sortedBoundaries.length - 1; i++) {
-    const start = sortedBoundaries[i];
-    const end = sortedBoundaries[i + 1];
-    ranges.push({
-      offset: Math.floor(start),
-      count: Math.floor(end - start)
-    });
-  }
-  return ranges;
-}
-function hasGroupGaps(geometry, range) {
-  const vertexCount = getTriCount(geometry);
-  const groups = getRootIndexRanges(geometry, range).sort((a2, b) => a2.offset - b.offset);
-  const finalGroup = groups[groups.length - 1];
-  finalGroup.count = Math.min(vertexCount - finalGroup.offset, finalGroup.count);
-  let total = 0;
-  groups.forEach(({ count }) => total += count);
-  return vertexCount !== total;
-}
-function getBounds(triangleBounds2, offset, count, target, centroidTarget) {
-  let minx = Infinity;
-  let miny = Infinity;
-  let minz = Infinity;
-  let maxx = -Infinity;
-  let maxy = -Infinity;
-  let maxz = -Infinity;
-  let cminx = Infinity;
-  let cminy = Infinity;
-  let cminz = Infinity;
-  let cmaxx = -Infinity;
-  let cmaxy = -Infinity;
-  let cmaxz = -Infinity;
-  for (let i = offset * 6, end = (offset + count) * 6; i < end; i += 6) {
-    const cx = triangleBounds2[i + 0];
-    const hx = triangleBounds2[i + 1];
-    const lx = cx - hx;
-    const rx = cx + hx;
-    if (lx < minx) minx = lx;
-    if (rx > maxx) maxx = rx;
-    if (cx < cminx) cminx = cx;
-    if (cx > cmaxx) cmaxx = cx;
-    const cy = triangleBounds2[i + 2];
-    const hy = triangleBounds2[i + 3];
-    const ly = cy - hy;
-    const ry = cy + hy;
-    if (ly < miny) miny = ly;
-    if (ry > maxy) maxy = ry;
-    if (cy < cminy) cminy = cy;
-    if (cy > cmaxy) cmaxy = cy;
-    const cz = triangleBounds2[i + 4];
-    const hz = triangleBounds2[i + 5];
-    const lz = cz - hz;
-    const rz = cz + hz;
-    if (lz < minz) minz = lz;
-    if (rz > maxz) maxz = rz;
-    if (cz < cminz) cminz = cz;
-    if (cz > cmaxz) cmaxz = cz;
-  }
-  target[0] = minx;
-  target[1] = miny;
-  target[2] = minz;
-  target[3] = maxx;
-  target[4] = maxy;
-  target[5] = maxz;
-  centroidTarget[0] = cminx;
-  centroidTarget[1] = cminy;
-  centroidTarget[2] = cminz;
-  centroidTarget[3] = cmaxx;
-  centroidTarget[4] = cmaxy;
-  centroidTarget[5] = cmaxz;
-}
-function computeTriangleBounds(geo, target = null, offset = null, count = null) {
-  const posAttr = geo.attributes.position;
-  const index2 = geo.index ? geo.index.array : null;
-  const triCount = getTriCount(geo);
-  const normalized = posAttr.normalized;
-  let triangleBounds2;
-  if (target === null) {
-    triangleBounds2 = new Float32Array(triCount * 6);
-    offset = 0;
-    count = triCount;
-  } else {
-    triangleBounds2 = target;
-    offset = offset || 0;
-    count = count || triCount;
-  }
-  const posArr = posAttr.array;
-  const bufferOffset = posAttr.offset || 0;
-  let stride = 3;
-  if (posAttr.isInterleavedBufferAttribute) {
-    stride = posAttr.data.stride;
-  }
-  const getters = ["getX", "getY", "getZ"];
-  for (let tri = offset; tri < offset + count; tri++) {
-    const tri3 = tri * 3;
-    const tri6 = tri * 6;
-    let ai = tri3 + 0;
-    let bi = tri3 + 1;
-    let ci = tri3 + 2;
-    if (index2) {
-      ai = index2[ai];
-      bi = index2[bi];
-      ci = index2[ci];
-    }
-    if (!normalized) {
-      ai = ai * stride + bufferOffset;
-      bi = bi * stride + bufferOffset;
-      ci = ci * stride + bufferOffset;
-    }
-    for (let el = 0; el < 3; el++) {
-      let a2, b, c2;
-      if (normalized) {
-        a2 = posAttr[getters[el]](ai);
-        b = posAttr[getters[el]](bi);
-        c2 = posAttr[getters[el]](ci);
-      } else {
-        a2 = posArr[ai + el];
-        b = posArr[bi + el];
-        c2 = posArr[ci + el];
-      }
-      let min2 = a2;
-      if (b < min2) min2 = b;
-      if (c2 < min2) min2 = c2;
-      let max2 = a2;
-      if (b > max2) max2 = b;
-      if (c2 > max2) max2 = c2;
-      const halfExtents = (max2 - min2) / 2;
-      const el2 = el * 2;
-      triangleBounds2[tri6 + el2 + 0] = min2 + halfExtents;
-      triangleBounds2[tri6 + el2 + 1] = halfExtents + (Math.abs(min2) + halfExtents) * FLOAT32_EPSILON;
-    }
-  }
-  return triangleBounds2;
+  return triangleBounds2;
 }
 function arrayToBox(nodeIndex32, array, target) {
   target.min.x = array[nodeIndex32];
@@ -50154,10 +51021,10 @@ function getOptimalSplit(nodeBoundingData, centroidBoundingData, triangleBounds2
           }
         }
         for (let c2 = cStart; c2 < cEnd; c2 += 6) {
-          const center = triangleBounds2[c2 + 2 * a2];
+          const center2 = triangleBounds2[c2 + 2 * a2];
           for (let bi = 0; bi < splitCount; bi++) {
             const bin = truncatedBins[bi];
-            if (center >= bin.candidate) {
+            if (center2 >= bin.candidate) {
               expandByTriangleBounds(c2, triangleBounds2, bin.rightCacheBounds);
             } else {
               expandByTriangleBounds(c2, triangleBounds2, bin.leftCacheBounds);
@@ -50652,24 +51519,24 @@ const sphereIntersectTriangle = (function() {
   const planeTemp = new Plane();
   const lineTemp = new Line3();
   return function sphereIntersectTriangle2(sphere, triangle3) {
-    const { radius, center } = sphere;
+    const { radius, center: center2 } = sphere;
     const { a: a2, b, c: c2 } = triangle3;
     lineTemp.start = a2;
     lineTemp.end = b;
-    const closestPoint1 = lineTemp.closestPointToPoint(center, true, closestPointTemp);
-    if (closestPoint1.distanceTo(center) <= radius) return true;
+    const closestPoint1 = lineTemp.closestPointToPoint(center2, true, closestPointTemp);
+    if (closestPoint1.distanceTo(center2) <= radius) return true;
     lineTemp.start = a2;
     lineTemp.end = c2;
-    const closestPoint2 = lineTemp.closestPointToPoint(center, true, closestPointTemp);
-    if (closestPoint2.distanceTo(center) <= radius) return true;
+    const closestPoint2 = lineTemp.closestPointToPoint(center2, true, closestPointTemp);
+    if (closestPoint2.distanceTo(center2) <= radius) return true;
     lineTemp.start = b;
     lineTemp.end = c2;
-    const closestPoint3 = lineTemp.closestPointToPoint(center, true, closestPointTemp);
-    if (closestPoint3.distanceTo(center) <= radius) return true;
+    const closestPoint3 = lineTemp.closestPointToPoint(center2, true, closestPointTemp);
+    if (closestPoint3.distanceTo(center2) <= radius) return true;
     const plane = triangle3.getPlane(planeTemp);
-    const dp = Math.abs(plane.distanceToPoint(center));
+    const dp = Math.abs(plane.distanceToPoint(center2));
     if (dp <= radius) {
-      const pp = plane.projectPoint(center, projectedPointTemp);
+      const pp = plane.projectPoint(center2, projectedPointTemp);
       const cp = triangle3.containsPoint(pp);
       if (cp) return true;
     }
@@ -51467,26 +52334,26 @@ const _normalA = /* @__PURE__ */ new Vector3();
 const _normalB = /* @__PURE__ */ new Vector3();
 const _normalC = /* @__PURE__ */ new Vector3();
 const _intersectionPoint = /* @__PURE__ */ new Vector3();
-function checkIntersection(ray, pA, pB, pC, point2, side, near, far) {
+function checkIntersection(ray2, pA, pB, pC, point2, side, near, far) {
   let intersect2;
   if (side === BackSide) {
-    intersect2 = ray.intersectTriangle(pC, pB, pA, true, point2);
+    intersect2 = ray2.intersectTriangle(pC, pB, pA, true, point2);
   } else {
-    intersect2 = ray.intersectTriangle(pA, pB, pC, side !== DoubleSide, point2);
+    intersect2 = ray2.intersectTriangle(pA, pB, pC, side !== DoubleSide, point2);
   }
   if (intersect2 === null) return null;
-  const distance = ray.origin.distanceTo(point2);
+  const distance = ray2.origin.distanceTo(point2);
   if (distance < near || distance > far) return null;
   return {
     distance,
     point: point2.clone()
   };
 }
-function checkBufferGeometryIntersection(ray, position, normal, uv, uv1, a2, b, c2, side, near, far) {
+function checkBufferGeometryIntersection(ray2, position, normal, uv, uv1, a2, b, c2, side, near, far) {
   _vA.fromBufferAttribute(position, a2);
   _vB.fromBufferAttribute(position, b);
   _vC.fromBufferAttribute(position, c2);
-  const intersection2 = checkIntersection(ray, _vA, _vB, _vC, _intersectionPoint, side, near, far);
+  const intersection2 = checkIntersection(ray2, _vA, _vB, _vC, _intersectionPoint, side, near, far);
   if (intersection2) {
     const barycoord = new Vector3();
     Triangle.getBarycoord(_intersectionPoint, _vA, _vB, _vC, barycoord);
@@ -51507,7 +52374,7 @@ function checkBufferGeometryIntersection(ray, position, normal, uv, uv1, a2, b,
       _normalB.fromBufferAttribute(normal, b);
       _normalC.fromBufferAttribute(normal, c2);
       intersection2.normal = Triangle.getInterpolation(_intersectionPoint, _vA, _vB, _vC, _normalA, _normalB, _normalC, new Vector3());
-      if (intersection2.normal.dot(ray.direction) > 0) {
+      if (intersection2.normal.dot(ray2.direction) > 0) {
         intersection2.normal.multiplyScalar(-1);
       }
     }
@@ -51527,7 +52394,7 @@ function checkBufferGeometryIntersection(ray, position, normal, uv, uv1, a2, b,
   }
   return intersection2;
 }
-function intersectTri(geo, side, ray, tri, intersections, near, far) {
+function intersectTri(geo, side, ray2, tri, intersections, near, far) {
   const triOffset = tri * 3;
   let a2 = triOffset + 0;
   let b = triOffset + 1;
@@ -51539,7 +52406,7 @@ function intersectTri(geo, side, ray, tri, intersections, near, far) {
     c2 = index2.getX(c2);
   }
   const { position, normal, uv, uv1 } = geo.attributes;
-  const intersection2 = checkBufferGeometryIntersection(ray, position, normal, uv, uv1, a2, b, c2, side, near, far);
+  const intersection2 = checkBufferGeometryIntersection(ray2, position, normal, uv, uv1, a2, b, c2, side, near, far);
   if (intersection2) {
     intersection2.faceIndex = tri;
     if (intersections) intersections.push(intersection2);
@@ -51569,19 +52436,19 @@ function setTriangle(tri, i, index2, pos) {
   tc.y = pos.getY(i2);
   tc.z = pos.getZ(i2);
 }
-function intersectTris(bvh, side, ray, offset, count, intersections, near, far) {
+function intersectTris(bvh, side, ray2, offset, count, intersections, near, far) {
   const { geometry, _indirectBuffer } = bvh;
   for (let i = offset, end = offset + count; i < end; i++) {
-    intersectTri(geometry, side, ray, i, intersections, near, far);
+    intersectTri(geometry, side, ray2, i, intersections, near, far);
   }
 }
-function intersectClosestTri(bvh, side, ray, offset, count, near, far) {
+function intersectClosestTri(bvh, side, ray2, offset, count, near, far) {
   const { geometry, _indirectBuffer } = bvh;
   let dist = Infinity;
   let res = null;
   for (let i = offset, end = offset + count; i < end; i++) {
     let intersection2;
-    intersection2 = intersectTri(geometry, side, ray, i, null, near, far);
+    intersection2 = intersectTri(geometry, side, ray2, i, null, near, far);
     if (intersection2 && intersection2.distance < dist) {
       res = intersection2;
       dist = intersection2.distance;
@@ -51702,12 +52569,12 @@ function refit(bvh, nodeIndices = null) {
     }
   }
 }
-function intersectRay(nodeIndex32, array, ray, near, far) {
+function intersectRay(nodeIndex32, array, ray2, near, far) {
   let tmin, tmax, tymin, tymax, tzmin, tzmax;
-  const invdirx = 1 / ray.direction.x, invdiry = 1 / ray.direction.y, invdirz = 1 / ray.direction.z;
-  const ox = ray.origin.x;
-  const oy = ray.origin.y;
-  const oz = ray.origin.z;
+  const invdirx = 1 / ray2.direction.x, invdiry = 1 / ray2.direction.y, invdirz = 1 / ray2.direction.z;
+  const ox = ray2.origin.x;
+  const oy = ray2.origin.y;
+  const oz = ray2.origin.z;
   let minx = array[nodeIndex32];
   let maxx = array[nodeIndex32 + 3];
   let miny = array[nodeIndex32 + 1];
@@ -51743,20 +52610,20 @@ function intersectRay(nodeIndex32, array, ray, near, far) {
   if (tzmax < tmax || tmax !== tmax) tmax = tzmax;
   return tmin <= far && tmax >= near;
 }
-function intersectTris_indirect(bvh, side, ray, offset, count, intersections, near, far) {
+function intersectTris_indirect(bvh, side, ray2, offset, count, intersections, near, far) {
   const { geometry, _indirectBuffer } = bvh;
   for (let i = offset, end = offset + count; i < end; i++) {
     let vi = _indirectBuffer ? _indirectBuffer[i] : i;
-    intersectTri(geometry, side, ray, vi, intersections, near, far);
+    intersectTri(geometry, side, ray2, vi, intersections, near, far);
   }
 }
-function intersectClosestTri_indirect(bvh, side, ray, offset, count, near, far) {
+function intersectClosestTri_indirect(bvh, side, ray2, offset, count, near, far) {
   const { geometry, _indirectBuffer } = bvh;
   let dist = Infinity;
   let res = null;
   for (let i = offset, end = offset + count; i < end; i++) {
     let intersection2;
-    intersection2 = intersectTri(geometry, side, ray, _indirectBuffer ? _indirectBuffer[i] : i, null, near, far);
+    intersection2 = intersectTri(geometry, side, ray2, _indirectBuffer ? _indirectBuffer[i] : i, null, near, far);
     if (intersection2 && intersection2.distance < dist) {
       res = intersection2;
       dist = intersection2.distance;
@@ -51779,49 +52646,49 @@ function iterateOverTriangles_indirect(offset, count, bvh, intersectsTriangleFun
   }
   return false;
 }
-function raycast(bvh, root, side, ray, intersects, near, far) {
+function raycast(bvh, root, side, ray2, intersects, near, far) {
   BufferStack.setBuffer(bvh._roots[root]);
-  _raycast$1(0, bvh, side, ray, intersects, near, far);
+  _raycast$1(0, bvh, side, ray2, intersects, near, far);
   BufferStack.clearBuffer();
 }
-function _raycast$1(nodeIndex32, bvh, side, ray, intersects, near, far) {
+function _raycast$1(nodeIndex32, bvh, side, ray2, intersects, 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, ray, offset, count, intersects, near, far);
+    intersectTris(bvh, side, ray2, offset, count, intersects, near, far);
   } else {
     const leftIndex = LEFT_NODE(nodeIndex32);
-    if (intersectRay(leftIndex, float32Array2, ray, near, far)) {
-      _raycast$1(leftIndex, bvh, side, ray, intersects, near, far);
+    if (intersectRay(leftIndex, float32Array2, ray2, near, far)) {
+      _raycast$1(leftIndex, bvh, side, ray2, intersects, near, far);
     }
     const rightIndex = RIGHT_NODE(nodeIndex32, uint32Array2);
-    if (intersectRay(rightIndex, float32Array2, ray, near, far)) {
-      _raycast$1(rightIndex, bvh, side, ray, intersects, near, far);
+    if (intersectRay(rightIndex, float32Array2, ray2, near, far)) {
+      _raycast$1(rightIndex, bvh, side, ray2, intersects, near, far);
     }
   }
 }
 const _xyzFields$1 = ["x", "y", "z"];
-function raycastFirst(bvh, root, side, ray, near, far) {
+function raycastFirst(bvh, root, side, ray2, near, far) {
   BufferStack.setBuffer(bvh._roots[root]);
-  const result = _raycastFirst$1(0, bvh, side, ray, near, far);
+  const result = _raycastFirst$1(0, bvh, side, ray2, near, far);
   BufferStack.clearBuffer();
   return result;
 }
-function _raycastFirst$1(nodeIndex32, bvh, side, ray, near, far) {
+function _raycastFirst$1(nodeIndex32, bvh, side, ray2, near, far) {
   const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
   let nodeIndex16 = nodeIndex32 * 2;
   const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
   if (isLeaf) {
     const offset = OFFSET(nodeIndex32, uint32Array2);
     const count = COUNT(nodeIndex16, uint16Array2);
-    return intersectClosestTri(bvh, side, ray, offset, count, near, far);
+    return intersectClosestTri(bvh, side, ray2, offset, count, near, far);
   } else {
     const splitAxis = SPLIT_AXIS(nodeIndex32, uint32Array2);
     const xyzAxis = _xyzFields$1[splitAxis];
-    const rayDir = ray.direction[xyzAxis];
+    const rayDir = ray2.direction[xyzAxis];
     const leftToRight = rayDir >= 0;
     let c1, c2;
     if (leftToRight) {
@@ -51831,8 +52698,8 @@ function _raycastFirst$1(nodeIndex32, bvh, side, ray, near, far) {
       c1 = RIGHT_NODE(nodeIndex32, uint32Array2);
       c2 = LEFT_NODE(nodeIndex32);
     }
-    const c1Intersection = intersectRay(c1, float32Array2, ray, near, far);
-    const c1Result = c1Intersection ? _raycastFirst$1(c1, bvh, side, ray, near, far) : null;
+    const c1Intersection = intersectRay(c1, float32Array2, ray2, near, far);
+    const c1Result = c1Intersection ? _raycastFirst$1(c1, bvh, side, ray2, near, far) : null;
     if (c1Result) {
       const point2 = c1Result.point[xyzAxis];
       const isOutside = leftToRight ? point2 <= float32Array2[c2 + splitAxis] : (
@@ -51843,8 +52710,8 @@ function _raycastFirst$1(nodeIndex32, bvh, side, ray, near, far) {
         return c1Result;
       }
     }
-    const c2Intersection = intersectRay(c2, float32Array2, ray, near, far);
-    const c2Result = c2Intersection ? _raycastFirst$1(c2, bvh, side, ray, near, far) : null;
+    const c2Intersection = intersectRay(c2, float32Array2, ray2, near, far);
+    const c2Result = c2Intersection ? _raycastFirst$1(c2, bvh, side, ray2, near, far) : null;
     if (c1Result && c2Result) {
       return c1Result.distance <= c2Result.distance ? c1Result : c2Result;
     } else {
@@ -52173,49 +53040,49 @@ function refit_indirect(bvh, nodeIndices = null) {
     }
   }
 }
-function raycast_indirect(bvh, root, side, ray, intersects, near, far) {
+function raycast_indirect(bvh, root, side, ray2, intersects, near, far) {
   BufferStack.setBuffer(bvh._roots[root]);
-  _raycast(0, bvh, side, ray, intersects, near, far);
+  _raycast(0, bvh, side, ray2, intersects, near, far);
   BufferStack.clearBuffer();
 }
-function _raycast(nodeIndex32, bvh, side, ray, intersects, near, far) {
+function _raycast(nodeIndex32, bvh, side, ray2, intersects, 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, ray, offset, count, intersects, near, far);
+    intersectTris_indirect(bvh, side, ray2, offset, count, intersects, near, far);
   } else {
     const leftIndex = LEFT_NODE(nodeIndex32);
-    if (intersectRay(leftIndex, float32Array2, ray, near, far)) {
-      _raycast(leftIndex, bvh, side, ray, intersects, near, far);
+    if (intersectRay(leftIndex, float32Array2, ray2, near, far)) {
+      _raycast(leftIndex, bvh, side, ray2, intersects, near, far);
     }
     const rightIndex = RIGHT_NODE(nodeIndex32, uint32Array2);
-    if (intersectRay(rightIndex, float32Array2, ray, near, far)) {
-      _raycast(rightIndex, bvh, side, ray, intersects, near, far);
+    if (intersectRay(rightIndex, float32Array2, ray2, near, far)) {
+      _raycast(rightIndex, bvh, side, ray2, intersects, near, far);
     }
   }
 }
 const _xyzFields = ["x", "y", "z"];
-function raycastFirst_indirect(bvh, root, side, ray, near, far) {
+function raycastFirst_indirect(bvh, root, side, ray2, near, far) {
   BufferStack.setBuffer(bvh._roots[root]);
-  const result = _raycastFirst(0, bvh, side, ray, near, far);
+  const result = _raycastFirst(0, bvh, side, ray2, near, far);
   BufferStack.clearBuffer();
   return result;
 }
-function _raycastFirst(nodeIndex32, bvh, side, ray, near, far) {
+function _raycastFirst(nodeIndex32, bvh, side, ray2, near, far) {
   const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
   let nodeIndex16 = nodeIndex32 * 2;
   const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
   if (isLeaf) {
     const offset = OFFSET(nodeIndex32, uint32Array2);
     const count = COUNT(nodeIndex16, uint16Array2);
-    return intersectClosestTri_indirect(bvh, side, ray, offset, count, near, far);
+    return intersectClosestTri_indirect(bvh, side, ray2, offset, count, near, far);
   } else {
     const splitAxis = SPLIT_AXIS(nodeIndex32, uint32Array2);
     const xyzAxis = _xyzFields[splitAxis];
-    const rayDir = ray.direction[xyzAxis];
+    const rayDir = ray2.direction[xyzAxis];
     const leftToRight = rayDir >= 0;
     let c1, c2;
     if (leftToRight) {
@@ -52225,8 +53092,8 @@ function _raycastFirst(nodeIndex32, bvh, side, ray, near, far) {
       c1 = RIGHT_NODE(nodeIndex32, uint32Array2);
       c2 = LEFT_NODE(nodeIndex32);
     }
-    const c1Intersection = intersectRay(c1, float32Array2, ray, near, far);
-    const c1Result = c1Intersection ? _raycastFirst(c1, bvh, side, ray, near, far) : null;
+    const c1Intersection = intersectRay(c1, float32Array2, ray2, near, far);
+    const c1Result = c1Intersection ? _raycastFirst(c1, bvh, side, ray2, near, far) : null;
     if (c1Result) {
       const point2 = c1Result.point[xyzAxis];
       const isOutside = leftToRight ? point2 <= float32Array2[c2 + splitAxis] : (
@@ -52237,8 +53104,8 @@ function _raycastFirst(nodeIndex32, bvh, side, ray, near, far) {
         return c1Result;
       }
     }
-    const c2Intersection = intersectRay(c2, float32Array2, ray, near, far);
-    const c2Result = c2Intersection ? _raycastFirst(c2, bvh, side, ray, near, far) : null;
+    const c2Intersection = intersectRay(c2, float32Array2, ray2, near, far);
+    const c2Result = c2Intersection ? _raycastFirst(c2, bvh, side, ray2, near, far) : null;
     if (c1Result && c2Result) {
       return c1Result.distance <= c2Result.distance ? c1Result : c2Result;
     } else {
@@ -52860,7 +53727,7 @@ class MeshBVH {
     }
   }
   /* Core Cast Functions */
-  raycast(ray, materialOrSide = FrontSide, near = 0, far = Infinity) {
+  raycast(ray2, materialOrSide = FrontSide, near = 0, far = Infinity) {
     const roots = this._roots;
     const geometry = this.geometry;
     const intersects = [];
@@ -52872,7 +53739,7 @@ class MeshBVH {
     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, ray, intersects, near, far);
+      raycastFunc(this, i, materialSide, ray2, intersects, near, far);
       if (isArrayMaterial) {
         const materialIndex = groups[i].materialIndex;
         for (let j = startCount, jl = intersects.length; j < jl; j++) {
@@ -52882,7 +53749,7 @@ class MeshBVH {
     }
     return intersects;
   }
-  raycastFirst(ray, materialOrSide = FrontSide, near = 0, far = Infinity) {
+  raycastFirst(ray2, materialOrSide = FrontSide, near = 0, far = Infinity) {
     const roots = this._roots;
     const geometry = this.geometry;
     const isMaterial = materialOrSide.isMaterial;
@@ -52893,7 +53760,7 @@ class MeshBVH {
     const raycastFirstFunc = this.indirect ? raycastFirst_indirect : raycastFirst;
     for (let i = 0, l = roots.length; i < l; i++) {
       const materialSide = isArrayMaterial ? materialOrSide[groups[i].materialIndex].side : side;
-      const result = raycastFirstFunc(this, i, materialSide, ray, near, far);
+      const result = raycastFirstFunc(this, i, materialSide, ray2, near, far);
       if (result != null && (closestResult == null || result.distance < closestResult.distance)) {
         closestResult = result;
         if (isArrayMaterial) {
@@ -53062,6 +53929,637 @@ class MeshBVH {
     return target;
   }
 }
+function convertRaycastIntersect(hit, object, raycaster) {
+  if (hit === null) {
+    return null;
+  }
+  hit.point.applyMatrix4(object.matrixWorld);
+  hit.distance = hit.point.distanceTo(raycaster.ray.origin);
+  hit.object = object;
+  return hit;
+}
+const ray = /* @__PURE__ */ new Ray();
+const direction = /* @__PURE__ */ new Vector3();
+const tmpInverseMatrix = /* @__PURE__ */ new Matrix4();
+const origMeshRaycastFunc = Mesh.prototype.raycast;
+const origBatchedRaycastFunc = BatchedMesh.prototype.raycast;
+const _worldScale = /* @__PURE__ */ new Vector3();
+const _mesh = /* @__PURE__ */ new Mesh();
+const _batchIntersects = [];
+function acceleratedRaycast(raycaster, intersects) {
+  if (this.isBatchedMesh) {
+    acceleratedBatchedMeshRaycast.call(this, raycaster, intersects);
+  } else {
+    acceleratedMeshRaycast.call(this, raycaster, intersects);
+  }
+}
+function acceleratedBatchedMeshRaycast(raycaster, intersects) {
+  if (this.boundsTrees) {
+    const boundsTrees = this.boundsTrees;
+    const drawInfo = this._drawInfo || this._instanceInfo;
+    const drawRanges = this._drawRanges || this._geometryInfo;
+    const matrixWorld = this.matrixWorld;
+    _mesh.material = this.material;
+    _mesh.geometry = this.geometry;
+    const oldBoundsTree = _mesh.geometry.boundsTree;
+    const oldDrawRange = _mesh.geometry.drawRange;
+    if (_mesh.geometry.boundingSphere === null) {
+      _mesh.geometry.boundingSphere = new Sphere();
+    }
+    for (let i = 0, l = drawInfo.length; i < l; i++) {
+      if (!this.getVisibleAt(i)) {
+        continue;
+      }
+      const geometryId = drawInfo[i].geometryIndex;
+      _mesh.geometry.boundsTree = boundsTrees[geometryId];
+      this.getMatrixAt(i, _mesh.matrixWorld).premultiply(matrixWorld);
+      if (!_mesh.geometry.boundsTree) {
+        this.getBoundingBoxAt(geometryId, _mesh.geometry.boundingBox);
+        this.getBoundingSphereAt(geometryId, _mesh.geometry.boundingSphere);
+        const drawRange = drawRanges[geometryId];
+        _mesh.geometry.setDrawRange(drawRange.start, drawRange.count);
+      }
+      _mesh.raycast(raycaster, _batchIntersects);
+      for (let j = 0, l2 = _batchIntersects.length; j < l2; j++) {
+        const intersect2 = _batchIntersects[j];
+        intersect2.object = this;
+        intersect2.batchId = i;
+        intersects.push(intersect2);
+      }
+      _batchIntersects.length = 0;
+    }
+    _mesh.geometry.boundsTree = oldBoundsTree;
+    _mesh.geometry.drawRange = oldDrawRange;
+    _mesh.material = null;
+    _mesh.geometry = null;
+  } else {
+    origBatchedRaycastFunc.call(this, raycaster, intersects);
+  }
+}
+function acceleratedMeshRaycast(raycaster, intersects) {
+  if (this.geometry.boundsTree) {
+    if (this.material === void 0) return;
+    tmpInverseMatrix.copy(this.matrixWorld).invert();
+    ray.copy(raycaster.ray).applyMatrix4(tmpInverseMatrix);
+    _worldScale.setFromMatrixScale(this.matrixWorld);
+    direction.copy(ray.direction).multiply(_worldScale);
+    const scaleFactor = direction.length();
+    const near = raycaster.near / scaleFactor;
+    const far = raycaster.far / scaleFactor;
+    const bvh = this.geometry.boundsTree;
+    if (raycaster.firstHitOnly === true) {
+      const hit = convertRaycastIntersect(bvh.raycastFirst(ray, this.material, near, far), this, raycaster);
+      if (hit) {
+        intersects.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);
+        }
+      }
+    }
+  } else {
+    origMeshRaycastFunc.call(this, raycaster, intersects);
+  }
+}
+function cloneGeometryForFaceColors(geometry) {
+  return geometry.index ? geometry.toNonIndexed() : geometry.clone();
+}
+function makeThicknessRaycastTarget(sourceGeometry, rayMaterial, jumpable) {
+  const geometry = sourceGeometry.clone();
+  geometry.boundsTree = new MeshBVH(geometry);
+  const mesh = new Mesh(geometry, rayMaterial);
+  mesh.raycast = acceleratedRaycast;
+  return { mesh, jumpable, geometry };
+}
+function geometryMaxDimension(geometry) {
+  geometry.computeBoundingBox();
+  const box = geometry.boundingBox;
+  if (!box) return 1;
+  const size = new Vector3();
+  box.getSize(size);
+  return Math.max(1, size.x, size.y, size.z);
+}
+function firstOppositeSurfaceDistance(raycaster, rayTargetMeshes, jumpableMeshes, point2, direction2, epsilon2, far, contactTolerance) {
+  const origin = point2.clone().addScaledVector(direction2, epsilon2);
+  raycaster.set(origin, direction2);
+  raycaster.near = epsilon2;
+  raycaster.far = far;
+  const hits = raycaster.intersectObjects(rayTargetMeshes, false);
+  for (const hit of hits) {
+    if (hit.distance <= epsilon2) continue;
+    if (hit.distance <= contactTolerance && jumpableMeshes.has(hit.object)) continue;
+    return hit.distance + epsilon2;
+  }
+  return null;
+}
+function triangleThickness(raycaster, rayTargetMeshes, jumpableMeshes, centroid, normal, epsilon2, far, contactTolerance) {
+  const forward = firstOppositeSurfaceDistance(
+    raycaster,
+    rayTargetMeshes,
+    jumpableMeshes,
+    centroid,
+    normal,
+    epsilon2,
+    far,
+    contactTolerance
+  );
+  const backward = firstOppositeSurfaceDistance(
+    raycaster,
+    rayTargetMeshes,
+    jumpableMeshes,
+    centroid,
+    normal.clone().negate(),
+    epsilon2,
+    far,
+    contactTolerance
+  );
+  if (forward == null) return backward;
+  if (backward == null) return forward;
+  return Math.min(forward, backward);
+}
+function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}, context = {}) {
+  const options = resolveThicknessInspectionOptions(rawOptions);
+  const geometry = cloneGeometryForFaceColors(sourceGeometry);
+  const position = geometry.getAttribute("position");
+  if (!position || position.count < 3) {
+    return {
+      geometry,
+      samples: [],
+      pointSamples: [],
+      triangleCount: 0,
+      sampledTriangleCount: 0,
+      sampleStride: 1,
+      warnings: ["No triangle geometry."]
+    };
+  }
+  const triangleCount = Math.floor(position.count / 3);
+  const surfaceTriangles = readSurfaceTriangles(position);
+  const surfaceSamples = sampleSurfaceTriangles(surfaceTriangles, options.maxSamplesPerObject);
+  const connectedGeometries = context.connectedGeometries ?? [];
+  const maxDim2 = Math.max(geometryMaxDimension(geometry), ...connectedGeometries.map(geometryMaxDimension));
+  const epsilon2 = Math.max(1e-4, maxDim2 * 1e-6);
+  const far = Math.max(maxDim2 * 4, options.maxThickness * 4, 1);
+  const colors = new Float32Array(position.count * 3);
+  const triangleThicknessValues = new Array(triangleCount).fill(void 0);
+  const samples = [];
+  const pointSamples = [];
+  const warnings = [];
+  const rayMaterial = new MeshBasicMaterial({ side: DoubleSide });
+  const rayTargets = [
+    makeThicknessRaycastTarget(geometry, rayMaterial, false),
+    ...connectedGeometries.map((connectedGeometry) => makeThicknessRaycastTarget(connectedGeometry, rayMaterial, true))
+  ];
+  try {
+    const rayTargetMeshes = rayTargets.map((target) => target.mesh);
+    const jumpableMeshes = new Set(rayTargets.filter((target) => target.jumpable).map((target) => target.mesh));
+    const raycaster = new Raycaster();
+    if (surfaceTriangles.length === 0) {
+      warnings.push("No non-degenerate triangle surface was available for thickness sampling.");
+    } else if (surfaceSamples.length < surfaceTriangles.length) {
+      warnings.push(
+        `Area sampling budget ${surfaceSamples.length} covers ${surfaceTriangles.length} surface triangles; increase --thickness-samples for denser analysis.`
+      );
+    }
+    const sampledTriangleIndexes = /* @__PURE__ */ new Set();
+    for (const sample of surfaceSamples) {
+      sampledTriangleIndexes.add(sample.triangle.index);
+      const thickness = triangleThickness(
+        raycaster,
+        rayTargetMeshes,
+        jumpableMeshes,
+        sample.position,
+        sample.normal,
+        epsilon2,
+        far,
+        options.contactTolerance
+      );
+      samples.push({ thickness, area: sample.area });
+      const previous = triangleThicknessValues[sample.triangle.index];
+      if (previous === void 0 || previous == null || thickness != null && thickness < previous) {
+        triangleThicknessValues[sample.triangle.index] = thickness;
+      }
+      pointSamples.push({
+        position: [sample.position.x, sample.position.y, sample.position.z],
+        normal: [sample.normal.x, sample.normal.y, sample.normal.z],
+        value: thickness,
+        className: thicknessClass(thickness, options),
+        color: thicknessColor(thickness, options),
+        area: sample.area
+      });
+    }
+    for (let tri = 0; tri < triangleCount; tri += 1) {
+      const color = thicknessColor(triangleThicknessValues[tri], options);
+      const offset = tri * 3;
+      for (let vertex2 = 0; vertex2 < 3; vertex2 += 1) {
+        const colorOffset = (offset + vertex2) * 3;
+        colors[colorOffset] = color[0] / 255;
+        colors[colorOffset + 1] = color[1] / 255;
+        colors[colorOffset + 2] = color[2] / 255;
+      }
+    }
+    geometry.setAttribute("color", new BufferAttribute(colors, 3));
+    return {
+      geometry,
+      samples,
+      pointSamples,
+      triangleCount,
+      sampledTriangleCount: sampledTriangleIndexes.size,
+      sampleStride: Math.max(1, Math.ceil(Math.max(1, surfaceTriangles.length) / Math.max(1, sampledTriangleIndexes.size))),
+      warnings
+    };
+  } finally {
+    rayTargets.forEach((target) => target.geometry.dispose());
+    rayMaterial.dispose();
+  }
+}
+const DEFAULT_VERTEX_CAP = 2e6;
+const DEFAULT_TARGET_EDGE_SPACING_FACTOR = 2;
+const DEFAULT_K = 8;
+const DEFAULT_GATE_DOT = 0.3;
+const SCATTER_CELL_SPACING_FACTOR = 1.5;
+const SCATTER_RADIUS_SPACING_FACTOR = 3;
+const IDW_DISTANCE_FLOOR = 1e-9;
+const MAX_SUBDIVISION_PASSES = 24;
+function subVec(a2, b) {
+  return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
+}
+function crossVec(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 lenVec(a2) {
+  return Math.hypot(a2[0], a2[1], a2[2]);
+}
+function getVert(positions, i) {
+  const o = i * 3;
+  return [positions[o], positions[o + 1], positions[o + 2]];
+}
+function triArea(positions, a2, b, c2) {
+  const va = getVert(positions, a2);
+  return 0.5 * lenVec(crossVec(subVec(getVert(positions, b), va), subVec(getVert(positions, c2), va)));
+}
+function triNormal(positions, a2, b, c2) {
+  const va = getVert(positions, a2);
+  const n = crossVec(subVec(getVert(positions, b), va), subVec(getVert(positions, c2), va));
+  const l = lenVec(n) || 1;
+  return [n[0] / l, n[1] / l, n[2] / l];
+}
+function edgeLen(positions, a2, b) {
+  return lenVec(subVec(getVert(positions, a2), getVert(positions, b)));
+}
+function maxEdge(positions, a2, b, c2) {
+  return Math.max(edgeLen(positions, a2, b), edgeLen(positions, b, c2), edgeLen(positions, c2, a2));
+}
+function weld(positions) {
+  if (positions.length % 9 !== 0) {
+    throw new Error(
+      `weld: positions length must be a multiple of 9 (9 floats per triangle), got ${positions.length}`
+    );
+  }
+  positions.length / 3;
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  for (let i = 0; i < positions.length; i += 3) {
+    const x2 = positions[i];
+    const y2 = positions[i + 1];
+    const z2 = positions[i + 2];
+    if (!Number.isFinite(x2) || !Number.isFinite(y2) || !Number.isFinite(z2)) {
+      throw new Error(`weld: non-finite vertex position at float index ${i}`);
+    }
+    if (x2 < minX) minX = x2;
+    if (y2 < minY) minY = y2;
+    if (z2 < minZ) minZ = z2;
+    if (x2 > maxX) maxX = x2;
+    if (y2 > maxY) maxY = y2;
+    if (z2 > maxZ) maxZ = z2;
+  }
+  const diagonal = Math.hypot(maxX - minX, maxY - minY, maxZ - minZ);
+  const tolerance = Math.max(diagonal * 1e-5, Number.EPSILON);
+  const remap = /* @__PURE__ */ new Map();
+  const out = [];
+  const tris = [];
+  const inv = 1 / tolerance;
+  const quantKey = (i) => {
+    const qx = Math.round(positions[i] * inv);
+    const qy = Math.round(positions[i + 1] * inv);
+    const qz = Math.round(positions[i + 2] * inv);
+    return `${qx},${qy},${qz}`;
+  };
+  for (let tri = 0; tri < positions.length; tri += 9) {
+    const idx = [];
+    for (let corner = 0; corner < 3; corner += 1) {
+      const o = tri + corner * 3;
+      const key2 = quantKey(o);
+      let vi = remap.get(key2);
+      if (vi === void 0) {
+        vi = out.length / 3;
+        out.push(positions[o], positions[o + 1], positions[o + 2]);
+        remap.set(key2, vi);
+      }
+      idx.push(vi);
+    }
+    if (idx[0] !== idx[1] && idx[1] !== idx[2] && idx[2] !== idx[0]) {
+      tris.push(idx[0], idx[1], idx[2]);
+    }
+  }
+  const distinctVertexCount = out.length / 3;
+  const degenerate = distinctVertexCount < 3 || tris.length === 0;
+  return { positions: out, tris, degenerate };
+}
+function adaptiveSubdivide(mesh, targetEdge, vertexCap) {
+  requirePositiveFiniteNumber(targetEdge, "adaptiveSubdivide targetEdge");
+  requireIntegerAtLeast(vertexCap, "adaptiveSubdivide vertexCap", 3);
+  const positions = mesh.positions.slice();
+  let tris = mesh.tris.slice();
+  let capped = false;
+  const keyOf = (a2, b) => a2 < b ? `${a2}_${b}` : `${b}_${a2}`;
+  for (let pass = 0; pass < MAX_SUBDIVISION_PASSES; pass += 1) {
+    const next = [];
+    const midCache = /* @__PURE__ */ new Map();
+    let changed = false;
+    const getMid = (a2, b) => {
+      const key2 = keyOf(a2, b);
+      let mi = midCache.get(key2);
+      if (mi === void 0) {
+        mi = positions.length / 3;
+        const ao = a2 * 3;
+        const bo = b * 3;
+        positions.push(
+          (positions[ao] + positions[bo]) / 2,
+          (positions[ao + 1] + positions[bo + 1]) / 2,
+          (positions[ao + 2] + positions[bo + 2]) / 2
+        );
+        midCache.set(key2, mi);
+      }
+      return mi;
+    };
+    for (let t = 0; t < tris.length; t += 3) {
+      const a2 = tris[t];
+      const b = tris[t + 1];
+      const c2 = tris[t + 2];
+      const vertexCount = positions.length / 3;
+      if (maxEdge(positions, a2, b, c2) > targetEdge && vertexCount < vertexCap) {
+        const ab = getMid(a2, b);
+        const bc = getMid(b, c2);
+        const ca = getMid(c2, a2);
+        next.push(a2, ab, ca, ab, b, bc, ca, bc, c2, ab, bc, ca);
+        changed = true;
+      } else {
+        if (positions.length / 3 >= vertexCap) capped = true;
+        next.push(a2, b, c2);
+      }
+    }
+    tris = next;
+    if (!changed) break;
+  }
+  return { positions, tris, capped };
+}
+function vertexNormals(mesh) {
+  const vertexCount = mesh.positions.length / 3;
+  const acc = new Float32Array(vertexCount * 3);
+  for (let t = 0; t < mesh.tris.length; t += 3) {
+    const a2 = mesh.tris[t];
+    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;
+    for (const vi of [a2, b, c2]) {
+      acc[vi * 3] += nx;
+      acc[vi * 3 + 1] += ny;
+      acc[vi * 3 + 2] += nz;
+    }
+  }
+  for (let i = 0; i < vertexCount; i += 1) {
+    const o = i * 3;
+    const l = Math.hypot(acc[o], acc[o + 1], acc[o + 2]) || 1;
+    acc[o] /= l;
+    acc[o + 1] /= l;
+    acc[o + 2] /= l;
+  }
+  return acc;
+}
+function buildSampleGrid(positions, cell) {
+  const grid = /* @__PURE__ */ new Map();
+  const sampleCount = positions.length / 3;
+  for (let i = 0; i < sampleCount; i += 1) {
+    const o = i * 3;
+    const key2 = `${Math.floor(positions[o] / cell)},${Math.floor(positions[o + 1] / cell)},${Math.floor(positions[o + 2] / cell)}`;
+    let arr = grid.get(key2);
+    if (!arr) {
+      arr = [];
+      grid.set(key2, arr);
+    }
+    arr.push(i);
+  }
+  return { grid, cell };
+}
+function gatherSamples(sampleGrid, p2, rings, out) {
+  out.length = 0;
+  const { cell, grid } = sampleGrid;
+  const bx = Math.floor(p2[0] / cell);
+  const by = Math.floor(p2[1] / cell);
+  const bz = Math.floor(p2[2] / cell);
+  for (let dx = -rings; dx <= rings; dx += 1) {
+    for (let dy = -rings; dy <= rings; dy += 1) {
+      for (let dz = -rings; dz <= rings; dz += 1) {
+        const arr = grid.get(`${bx + dx},${by + dy},${bz + dz}`);
+        if (arr) for (const i of arr) out.push(i);
+      }
+    }
+  }
+}
+function scatterToVertices(positions, vnormals, samples, spacing, k2, gateDot) {
+  const cell = spacing * SCATTER_CELL_SPACING_FACTOR;
+  const sampleGrid = buildSampleGrid(samples.positions, cell);
+  const radius = spacing * SCATTER_RADIUS_SPACING_FACTOR;
+  const radius2 = radius * radius;
+  const vertexCount = positions.length / 3;
+  const values = new Float32Array(vertexCount);
+  let holeCount = 0;
+  const candidates = [];
+  const scratchP = [0, 0, 0];
+  const bestD2 = new Float64Array(k2);
+  const bestVal = new Float64Array(k2);
+  for (let vi = 0; vi < vertexCount; vi += 1) {
+    const pi = vi * 3;
+    const px = positions[pi];
+    const py = positions[pi + 1];
+    const pz = positions[pi + 2];
+    const nx = vnormals[pi];
+    const ny = vnormals[pi + 1];
+    const nz = vnormals[pi + 2];
+    scratchP[0] = px;
+    scratchP[1] = py;
+    scratchP[2] = pz;
+    gatherSamples(sampleGrid, scratchP, 3, candidates);
+    let count = 0;
+    let worst = 0;
+    let worstD2 = -Infinity;
+    for (let c2 = 0; c2 < candidates.length; c2 += 1) {
+      const si = candidates[c2];
+      const so = si * 3;
+      const dx = samples.positions[so] - px;
+      const dy = samples.positions[so + 1] - py;
+      const dz = samples.positions[so + 2] - pz;
+      const d2 = dx * dx + dy * dy + dz * dz;
+      if (d2 > radius2) continue;
+      if (samples.normals[so] * nx + samples.normals[so + 1] * ny + samples.normals[so + 2] * nz < gateDot) continue;
+      const val = samples.values[si];
+      if (count < k2) {
+        bestD2[count] = d2;
+        bestVal[count] = val;
+        if (d2 > worstD2) {
+          worstD2 = d2;
+          worst = count;
+        }
+        count += 1;
+      } else if (d2 < worstD2) {
+        bestD2[worst] = d2;
+        bestVal[worst] = val;
+        worstD2 = -Infinity;
+        for (let t = 0; t < k2; t += 1) {
+          if (bestD2[t] > worstD2) {
+            worstD2 = bestD2[t];
+            worst = t;
+          }
+        }
+      }
+    }
+    if (count === 0) {
+      holeCount += 1;
+      values[vi] = NaN;
+      continue;
+    }
+    let w2 = 0;
+    let acc = 0;
+    for (let t = 0; t < count; t += 1) {
+      const ww = 1 / Math.max(bestD2[t], IDW_DISTANCE_FLOOR);
+      w2 += ww;
+      acc += ww * bestVal[t];
+    }
+    values[vi] = acc / w2;
+  }
+  return { values, holeCount };
+}
+function backfillHoles(values, mesh) {
+  const vertexCount = values.length;
+  const adjacency = Array.from({ length: vertexCount }, () => []);
+  for (let t = 0; t < mesh.tris.length; t += 3) {
+    const a2 = mesh.tris[t];
+    const b = mesh.tris[t + 1];
+    const c2 = mesh.tris[t + 2];
+    adjacency[a2].push(b, c2);
+    adjacency[b].push(a2, c2);
+    adjacency[c2].push(a2, b);
+  }
+  let frontier = [];
+  for (let i = 0; i < vertexCount; i += 1) {
+    if (Number.isFinite(values[i])) frontier.push(i);
+  }
+  if (frontier.length === 0) {
+    values.fill(0);
+    return;
+  }
+  while (frontier.length > 0) {
+    const nextFrontier = [];
+    for (const v of frontier) {
+      const val = values[v];
+      for (const n of adjacency[v]) {
+        if (!Number.isFinite(values[n])) {
+          values[n] = val;
+          nextFrontier.push(n);
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+}
+function reconstructSurfaceScalarField(trianglePositions, samples, options = {}) {
+  if (!(trianglePositions instanceof Float32Array)) {
+    throw new Error("reconstructSurfaceScalarField: trianglePositions must be a Float32Array");
+  }
+  if (trianglePositions.length === 0 || trianglePositions.length % 9 !== 0) {
+    throw new Error(
+      `reconstructSurfaceScalarField: trianglePositions length must be a positive multiple of 9, got ${trianglePositions.length}`
+    );
+  }
+  if (!(samples.positions instanceof Float32Array) || !(samples.values instanceof Float32Array) || !(samples.normals instanceof Float32Array)) {
+    throw new Error("reconstructSurfaceScalarField: samples positions/values/normals must be Float32Arrays");
+  }
+  const sampleCount = samples.values.length;
+  if (sampleCount === 0) {
+    throw new Error("reconstructSurfaceScalarField: samples must be non-empty");
+  }
+  if (samples.positions.length !== sampleCount * 3) {
+    throw new Error(
+      `reconstructSurfaceScalarField: samples.positions length ${samples.positions.length} must equal values*3 (${sampleCount * 3})`
+    );
+  }
+  if (samples.normals.length !== sampleCount * 3) {
+    throw new Error(
+      `reconstructSurfaceScalarField: samples.normals length ${samples.normals.length} must equal values*3 (${sampleCount * 3})`
+    );
+  }
+  for (let i = 0; i < sampleCount; i += 1) {
+    requireFiniteNumber(samples.values[i], `samples.values[${i}]`);
+  }
+  const vertexCap = options.vertexCap === void 0 ? DEFAULT_VERTEX_CAP : requireIntegerAtLeast(options.vertexCap, "vertexCap", 3);
+  const targetEdgeSpacingFactor = options.targetEdgeSpacingFactor === void 0 ? DEFAULT_TARGET_EDGE_SPACING_FACTOR : requirePositiveFiniteNumber(options.targetEdgeSpacingFactor, "targetEdgeSpacingFactor");
+  const k2 = options.k === void 0 ? DEFAULT_K : requireIntegerAtLeast(options.k, "k", 1);
+  const gateDot = options.gateDot === void 0 ? DEFAULT_GATE_DOT : requireFiniteNumber(options.gateDot, "gateDot");
+  const welded = weld(trianglePositions);
+  let surfaceArea = 0;
+  for (let t = 0; t < welded.tris.length; t += 3) {
+    surfaceArea += triArea(welded.positions, welded.tris[t], welded.tris[t + 1], welded.tris[t + 2]);
+  }
+  const sampleSpacing = surfaceArea > 0 ? Math.sqrt(surfaceArea / sampleCount) : 0;
+  let subdivided;
+  if (welded.degenerate || !(sampleSpacing > 0)) {
+    subdivided = { positions: welded.positions, tris: welded.tris, capped: false };
+  } else {
+    const targetEdge = targetEdgeSpacingFactor * sampleSpacing;
+    subdivided = adaptiveSubdivide(welded, targetEdge, vertexCap);
+  }
+  const normals = vertexNormals(subdivided);
+  const effectiveSpacing = sampleSpacing > 0 ? sampleSpacing : 1;
+  const scatter = scatterToVertices(subdivided.positions, normals, samples, effectiveSpacing, k2, gateDot);
+  let valueMin = Infinity;
+  let valueMax = -Infinity;
+  for (let i = 0; i < scatter.values.length; i += 1) {
+    const v = scatter.values[i];
+    if (!Number.isFinite(v)) continue;
+    if (v < valueMin) valueMin = v;
+    if (v > valueMax) valueMax = v;
+  }
+  if (!Number.isFinite(valueMin) || !Number.isFinite(valueMax)) {
+    valueMin = 0;
+    valueMax = 0;
+  }
+  backfillHoles(scatter.values, subdivided);
+  const vertexCount = subdivided.positions.length / 3;
+  return {
+    positions: Float32Array.from(subdivided.positions),
+    normals,
+    index: Uint32Array.from(subdivided.tris),
+    values: scatter.values,
+    valueMin,
+    valueMax,
+    capped: subdivided.capped,
+    degenerate: welded.degenerate,
+    holeCount: scatter.holeCount,
+    vertexCount
+  };
+}
 const DEFAULT_COLORMAP = "viridis";
 function cloneSerializedFaceRef(face) {
   return {
@@ -53096,7 +54594,8 @@ class FrozenShapeBackend {
       edgePositions: this._data.geometryEdgePositions,
       triangleFaceIds: this._data.geometryTriangleFaceIds,
       faceIdNames: this._data.geometryFaceIdNames,
-      hasSmoothNormals: this._data.hasSmoothNormals ?? false
+      hasSmoothNormals: this._data.hasSmoothNormals ?? false,
+      uvs: this._data.geometryUvs
     };
   }
   getMeshReconstructionData() {
@@ -53264,9 +54763,17 @@ const EDGE_THRESHOLD_DOT = Math.cos(Math.PI / 180);
 const SMOOTH_THRESHOLD_DOT = Math.cos(30 * Math.PI / 180);
 function computeGeometryArrays(mesh, options = {}) {
   const { numProp, numTri: triCount, triVerts, vertProperties, vertNormals, cornerNormals } = mesh;
+  if (numProp !== NUM_PROP_POSITION_ONLY && numProp !== NUM_PROP_WITH_NORMAL && numProp !== NUM_PROP_WITH_UV) {
+    throw new Error(
+      `computeGeometryArrays: illegal vertProperties numProp ${numProp}. Only ${NUM_PROP_POSITION_ONLY} (position), ${NUM_PROP_WITH_NORMAL} (position+normal), and ${NUM_PROP_WITH_UV} (position+normal+uv) are valid; ${numProp} (e.g. a truncated uv channel) is not.`
+    );
+  }
+  const hasStoredNormals = numProp === NUM_PROP_WITH_NORMAL || numProp === NUM_PROP_WITH_UV;
+  const hasStoredUvs = numProp === NUM_PROP_WITH_UV;
   const useCornerNormals = !!cornerNormals && cornerNormals.length === triCount * 9;
   const positions = new Float32Array(triCount * 9);
   const normals = new Float32Array(triCount * 9);
+  const uvs = hasStoredUvs ? new Float32Array(triCount * 6) : void 0;
   const faceNx = new Float32Array(triCount);
   const faceNy = new Float32Array(triCount);
   const faceNz = new Float32Array(triCount);
@@ -53296,6 +54803,15 @@ function computeGeometryArrays(mesh, options = {}) {
     positions[o + 6] = cx;
     positions[o + 7] = cy;
     positions[o + 8] = cz;
+    if (uvs) {
+      const u2 = t * 6;
+      uvs[u2] = vertProperties[i0 * numProp + UV_OFFSET];
+      uvs[u2 + 1] = vertProperties[i0 * numProp + UV_OFFSET + 1];
+      uvs[u2 + 2] = vertProperties[i1 * numProp + UV_OFFSET];
+      uvs[u2 + 3] = vertProperties[i1 * numProp + UV_OFFSET + 1];
+      uvs[u2 + 4] = vertProperties[i2 * numProp + UV_OFFSET];
+      uvs[u2 + 5] = vertProperties[i2 * numProp + UV_OFFSET + 1];
+    }
     if (useCornerNormals) {
       for (let k2 = 0; k2 < 9; k2++) normals[o + k2] = cornerNormals[o + k2];
     } else if (vertNormals) {
@@ -53308,13 +54824,13 @@ function computeGeometryArrays(mesh, options = {}) {
       normals[o + 6] = vertNormals[i2 * 3];
       normals[o + 7] = vertNormals[i2 * 3 + 1];
       normals[o + 8] = vertNormals[i2 * 3 + 2];
-    } else if (numProp >= 6) {
+    } else if (hasStoredNormals) {
       const corners = [i0, i1, i2];
       for (let v = 0; v < 3; v++) {
         const base = corners[v] * numProp;
-        const nx = vertProperties[base + 3];
-        const ny = vertProperties[base + 4];
-        const nz = vertProperties[base + 5];
+        const nx = vertProperties[base + NORMAL_OFFSET];
+        const ny = vertProperties[base + NORMAL_OFFSET + 1];
+        const nz = vertProperties[base + NORMAL_OFFSET + 2];
         const oc = o + v * 3;
         if (nx * nx + ny * ny + nz * nz > 1e-12) {
           normals[oc] = nx;
@@ -53341,7 +54857,7 @@ function computeGeometryArrays(mesh, options = {}) {
     faceNy[t] = fny;
     faceNz[t] = fnz;
   }
-  if (!useCornerNormals && !vertNormals && numProp < 6 && triCount > 0) {
+  if (!useCornerNormals && !vertNormals && !hasStoredNormals && triCount > 0) {
     computeAutoSmoothNormals(
       triVerts,
       vertProperties,
@@ -53360,7 +54876,8 @@ function computeGeometryArrays(mesh, options = {}) {
     positions,
     normals,
     edgePositions,
-    hasSmoothNormals: triCount > 0
+    hasSmoothNormals: triCount > 0,
+    uvs
   };
 }
 function computeAutoSmoothNormals(triVerts, vertProperties, numProp, triCount, faceNx, faceNy, faceNz, normals, mergeFromVert, mergeToVert) {
@@ -53495,10 +55012,11 @@ function attachKernelFaceMetadata(geometry, triangleFaceIds, faceIdNames) {
 }
 function shapeToGeometry(shape) {
   if (shape instanceof FrozenShape) {
-    const { positions, normals, edgePositions, triangleFaceIds, faceIdNames, hasSmoothNormals } = shape.getPrecomputedGeometry();
+    const { positions, normals, edgePositions, triangleFaceIds, faceIdNames, hasSmoothNormals, uvs } = shape.getPrecomputedGeometry();
     const solid = new BufferGeometry();
     solid.setAttribute("position", new BufferAttribute(positions, 3));
     solid.setAttribute("normal", new BufferAttribute(normals, 3));
+    if (uvs) solid.setAttribute("uv", new BufferAttribute(uvs, 2));
     attachKernelFaceMetadata(solid, triangleFaceIds, faceIdNames);
     const edges = new BufferGeometry();
     edges.setAttribute("position", new BufferAttribute(edgePositions, 3));
@@ -53521,7 +55039,7 @@ function shapeToGeometryFallback(shape) {
   } catch {
     mesh = shape.getMesh();
   }
-  const { positions, normals, edgePositions, hasSmoothNormals } = computeGeometryArrays({
+  const { positions, normals, edgePositions, hasSmoothNormals, uvs } = computeGeometryArrays({
     numProp: mesh.numProp,
     numTri: mesh.numTri,
     triVerts: mesh.triVerts,
@@ -53534,6 +55052,7 @@ function shapeToGeometryFallback(shape) {
   const solid = new BufferGeometry();
   solid.setAttribute("position", new BufferAttribute(positions, 3));
   solid.setAttribute("normal", new BufferAttribute(normals, 3));
+  if (uvs) solid.setAttribute("uv", new BufferAttribute(uvs, 2));
   attachKernelFaceMetadata(solid, mesh.faceID, mesh.faceIdNames);
   const edges = new BufferGeometry();
   edges.setAttribute("position", new BufferAttribute(edgePositions, 3));
@@ -53727,8 +55246,25 @@ function meshVertexColorBuffersFor(input, colorForEntryId) {
   }
   return out;
 }
+const COLLISION_SOURCE_COLOR = [180, 200, 220];
+const COLLISION_HIGHLIGHT_COLOR = [255, 68, 16];
 const FLOATING_HIGHLIGHT_COLOR = [255, 68, 16];
 const FLOATING_HIDDEN_COLOR = [0, 0, 0];
+const FLOATING_CONTEXT_COLOR = [38, 49, 58];
+const COLLISION_PALETTE = [
+  COLLISION_HIGHLIGHT_COLOR,
+  [0, 204, 255],
+  [255, 214, 0],
+  [66, 220, 120],
+  [255, 76, 196],
+  [142, 106, 255],
+  [255, 145, 48],
+  [86, 232, 202],
+  [210, 245, 60],
+  [255, 120, 120],
+  [80, 150, 255],
+  [190, 110, 60]
+];
 const MASK_PALETTE = [
   [230, 25, 75],
   [60, 180, 75],
@@ -53764,6 +55300,9 @@ function maskRgbForIndex(index2) {
 function maskColorForIndex(index2) {
   return rgbToHex(maskRgbForIndex(index2));
 }
+function collisionColorForIndex(index2) {
+  return rgbToHex(COLLISION_PALETTE[(index2 - 1) % COLLISION_PALETTE.length]);
+}
 function lerp(a2, b, t) {
   return a2 + (b - a2) * Math.max(0, Math.min(1, t));
 }
@@ -53779,6 +55318,7 @@ function distanceColorForRootDistance(distance, maxDistance) {
 }
 const workerScope = self;
 const SCALAR_SURFACE_VERTEX_CAP = 2e6;
+const SCALAR_SURFACE_TARGET_EDGE_SPACING_FACTOR = 8;
 class EmptyIntersectionShape {
   intersect() {
     return {
@@ -53852,6 +55392,69 @@ function objectColorsFor(objects, input, colorByEntryId) {
     })
   );
 }
+function countLabel(count, singular, plural) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+function componentBodyDetail(component) {
+  if (component.objectCount === component.bodyCount) return countLabel(component.bodyCount, "body", "bodies");
+  return `${countLabel(component.bodyCount, "body", "bodies")}, ${countLabel(component.objectCount, "object", "objects")}`;
+}
+function formatDistance(value) {
+  if (!Number.isFinite(value)) return "unreachable";
+  if (Math.abs(value) <= 1e-9) return "root";
+  const fixed = Math.abs(value) < 10 ? value.toFixed(2) : value.toFixed(1);
+  return `${fixed.replace(/\.?0+$/, "")} from root`;
+}
+function connectivityLegendSwatches(report) {
+  return report.components.map(
+    (component) => ({
+      label: `Component ${component.index}`,
+      detail: componentBodyDetail(component),
+      color: maskColorForIndex(component.index - 1)
+    })
+  );
+}
+function distanceLegendSwatches(report) {
+  return report.components.map(
+    (component) => ({
+      label: component.isRoot ? `Root ${component.index}` : `Component ${component.index}`,
+      detail: `${componentBodyDetail(component)}, ${formatDistance(component.rootDistance)}`,
+      color: distanceColorForRootDistance(component.rootDistance, report.maxRootDistance)
+    })
+  );
+}
+function floatingLegendSwatches(report) {
+  const bodyCount = report.components.reduce((total, component) => total + component.bodyCount, 0);
+  const groundedBodyCount = Math.max(0, bodyCount - report.floatingBodyCount);
+  return [
+    {
+      label: "Floating",
+      detail: countLabel(report.floatingBodyCount, "body", "bodies"),
+      color: rgbToHex(FLOATING_HIGHLIGHT_COLOR)
+    },
+    {
+      label: "Context",
+      detail: countLabel(groundedBodyCount, "grounded body", "grounded bodies"),
+      color: rgbToHex(FLOATING_CONTEXT_COLOR)
+    }
+  ];
+}
+function collisionLegendSwatches(collisions) {
+  return [
+    ...collisions.map(
+      (collision) => ({
+        label: `Overlap ${collision.index}`,
+        detail: `${collision.sourceName} vs ${collision.targetName}`,
+        color: collisionColorForIndex(collision.index)
+      })
+    ),
+    {
+      label: "Ghost body",
+      detail: "source geometry",
+      color: rgbToHex(COLLISION_SOURCE_COLOR)
+    }
+  ];
+}
 function scalarSamplesFromPointSamples(pointSamples) {
   const finite = pointSamples.filter((sample) => sample.value != null && Number.isFinite(sample.value));
   const positions = new Float32Array(finite.length * 3);
@@ -53887,7 +55490,10 @@ function analyzeScalarChannel(request) {
       });
       const samples = scalarSamplesFromPointSamples(analysis.pointSamples);
       if (samples.values.length > 0) {
-        const field2 = reconstructSurfaceScalarField(object.positions, samples, { vertexCap: SCALAR_SURFACE_VERTEX_CAP });
+        const field2 = reconstructSurfaceScalarField(object.positions, samples, {
+          vertexCap: SCALAR_SURFACE_VERTEX_CAP,
+          targetEdgeSpacingFactor: SCALAR_SURFACE_TARGET_EDGE_SPACING_FACTOR
+        });
         const bvhGeometry = new BufferGeometry();
         bvhGeometry.setAttribute("position", new BufferAttribute(field2.positions, 3));
         bvhGeometry.setIndex(new BufferAttribute(field2.index, 1));
@@ -53937,6 +55543,7 @@ function analyzeScalarChannel(request) {
     meshColorObjects: [],
     scalarSurfaceObjects,
     collisionGeometryObjects: [],
+    legendSwatches: [],
     warnings
   };
 }
@@ -53968,6 +55575,7 @@ function analyzeConnectivityChannel(request) {
       meshColorObjects: meshColorObjectsFor(bodyInput, colorByEntryId2),
       scalarSurfaceObjects: [],
       collisionGeometryObjects: [],
+      legendSwatches: distanceLegendSwatches(report2),
       warnings: report2.warnings
     };
   }
@@ -53983,6 +55591,7 @@ function analyzeConnectivityChannel(request) {
       meshColorObjects: meshColorObjectsFor(bodyInput, colorByEntryId2),
       scalarSurfaceObjects: [],
       collisionGeometryObjects: [],
+      legendSwatches: floatingLegendSwatches(report2),
       warnings: report2.warnings
     };
   }
@@ -53995,6 +55604,7 @@ function analyzeConnectivityChannel(request) {
     meshColorObjects: meshColorObjectsFor(bodyInput, colorByEntryId),
     scalarSurfaceObjects: [],
     collisionGeometryObjects: [],
+    legendSwatches: connectivityLegendSwatches(report),
     warnings: report.warnings
   };
 }
@@ -54101,6 +55711,7 @@ function analyzeCollisionChannel(request) {
     meshColorObjects: [],
     scalarSurfaceObjects: [],
     collisionGeometryObjects,
+    legendSwatches: collisionLegendSwatches(collisionGeometryObjects),
     warnings: [...request.warnings ?? [], ...report.warnings]
   };
 }