forgecad 0.9.14 → 0.9.16

package/dist/assets/{inspectWorker-DeRnMVv1.js → inspectWorker-BuTJDVX6.js}

@@ -235,7 +235,7 @@ function denormalize(value, array) {
       throw new Error("Invalid component type.");
   }
 }
-function normalize$3(value, array) {
+function normalize$4(value, array) {
   switch (array.constructor) {
     case Float32Array:
       return value;
@@ -487,7 +487,7 @@ const MathUtils = {
    * @param {TypedArray} array - The typed array that defines the data type of the value.
    * @return {number} The normalize value.
    */
-  normalize: normalize$3,
+  normalize: normalize$4,
   /**
    * Denormalizes the given value according to the given typed array.
    *
@@ -9728,7 +9728,7 @@ class BufferAttribute {
    * @return {BufferAttribute} A reference to this instance.
    */
   setComponent(index2, component, value) {
-    if (this.normalized) value = normalize$3(value, this.array);
+    if (this.normalized) value = normalize$4(value, this.array);
     this.array[index2 * this.itemSize + component] = value;
     return this;
   }
@@ -9751,7 +9751,7 @@ class BufferAttribute {
    * @return {BufferAttribute} A reference to this instance.
    */
   setX(index2, x2) {
-    if (this.normalized) x2 = normalize$3(x2, this.array);
+    if (this.normalized) x2 = normalize$4(x2, this.array);
     this.array[index2 * this.itemSize] = x2;
     return this;
   }
@@ -9774,7 +9774,7 @@ class BufferAttribute {
    * @return {BufferAttribute} A reference to this instance.
    */
   setY(index2, y2) {
-    if (this.normalized) y2 = normalize$3(y2, this.array);
+    if (this.normalized) y2 = normalize$4(y2, this.array);
     this.array[index2 * this.itemSize + 1] = y2;
     return this;
   }
@@ -9797,7 +9797,7 @@ class BufferAttribute {
    * @return {BufferAttribute} A reference to this instance.
    */
   setZ(index2, z2) {
-    if (this.normalized) z2 = normalize$3(z2, this.array);
+    if (this.normalized) z2 = normalize$4(z2, this.array);
     this.array[index2 * this.itemSize + 2] = z2;
     return this;
   }
@@ -9820,7 +9820,7 @@ class BufferAttribute {
    * @return {BufferAttribute} A reference to this instance.
    */
   setW(index2, w2) {
-    if (this.normalized) w2 = normalize$3(w2, this.array);
+    if (this.normalized) w2 = normalize$4(w2, this.array);
     this.array[index2 * this.itemSize + 3] = w2;
     return this;
   }
@@ -9835,8 +9835,8 @@ class BufferAttribute {
   setXY(index2, x2, y2) {
     index2 *= this.itemSize;
     if (this.normalized) {
-      x2 = normalize$3(x2, this.array);
-      y2 = normalize$3(y2, this.array);
+      x2 = normalize$4(x2, this.array);
+      y2 = normalize$4(y2, this.array);
     }
     this.array[index2 + 0] = x2;
     this.array[index2 + 1] = y2;
@@ -9854,9 +9854,9 @@ class BufferAttribute {
   setXYZ(index2, x2, y2, z2) {
     index2 *= this.itemSize;
     if (this.normalized) {
-      x2 = normalize$3(x2, this.array);
-      y2 = normalize$3(y2, this.array);
-      z2 = normalize$3(z2, this.array);
+      x2 = normalize$4(x2, this.array);
+      y2 = normalize$4(y2, this.array);
+      z2 = normalize$4(z2, this.array);
     }
     this.array[index2 + 0] = x2;
     this.array[index2 + 1] = y2;
@@ -9876,10 +9876,10 @@ class BufferAttribute {
   setXYZW(index2, x2, y2, z2, w2) {
     index2 *= this.itemSize;
     if (this.normalized) {
-      x2 = normalize$3(x2, this.array);
-      y2 = normalize$3(y2, this.array);
-      z2 = normalize$3(z2, this.array);
-      w2 = normalize$3(w2, this.array);
+      x2 = normalize$4(x2, this.array);
+      y2 = normalize$4(y2, this.array);
+      z2 = normalize$4(z2, this.array);
+      w2 = normalize$4(w2, this.array);
     }
     this.array[index2 + 0] = x2;
     this.array[index2 + 1] = y2;
@@ -12298,6 +12298,55 @@ function cloneShapeWorkplanePlacement(placement) {
     placement: cloneSketchPlacementModel(placement.placement)
   };
 }
+function formatValidationValue(value) {
+  if (typeof value === "number") return Number.isNaN(value) ? "NaN" : String(value);
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return JSON.stringify(value);
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function requireFiniteNumber(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${label} must be a finite number, got ${formatValidationValue(value)}`);
+  }
+  return value;
+}
+function requirePositiveFiniteNumber(value, label) {
+  const n = requireFiniteNumber(value, label);
+  if (n <= 0) throw new Error(`${label} must be a positive finite number, got ${formatValidationValue(value)}`);
+  return n;
+}
+function requireFiniteVec3$1(value, label) {
+  if (!Array.isArray(value) || value.length !== 3) {
+    throw new Error(`${label} must be [x, y, z] with finite numbers, got ${formatValidationValue(value)}`);
+  }
+  return [
+    requireFiniteNumber(value[0], `${label}[0]`),
+    requireFiniteNumber(value[1], `${label}[1]`),
+    requireFiniteNumber(value[2], `${label}[2]`)
+  ];
+}
+function requireNonZeroFiniteVec3(value, label) {
+  const v = requireFiniteVec3$1(value, label);
+  if (v[0] === 0 && v[1] === 0 && v[2] === 0) throw new Error(`${label} must not be [0, 0, 0]`);
+  return v;
+}
+function requireFiniteMat4(value, label) {
+  if (!Array.isArray(value) || value.length !== 16) {
+    throw new Error(`${label} must be a 4x4 matrix array with 16 finite numbers, got ${formatValidationValue(value)}`);
+  }
+  return value.map((entry, index2) => requireFiniteNumber(entry, `${label}[${index2}]`));
+}
+function requireNonZeroFiniteScale3(value, label) {
+  const scale2 = typeof value === "number" ? [requireFiniteNumber(value, label), requireFiniteNumber(value, label), requireFiniteNumber(value, label)] : requireFiniteVec3$1(value, label);
+  if (Math.abs(scale2[0]) < 1e-12 || Math.abs(scale2[1]) < 1e-12 || Math.abs(scale2[2]) < 1e-12) {
+    throw new Error(`${label} must have finite non-zero components, got ${formatValidationValue(value)}`);
+  }
+  return scale2;
+}
 const EPS$3 = 1e-10;
 function subVec3(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
@@ -12379,9 +12428,6 @@ function solveRotateAroundAngle(axis, pivot, movingPoint, targetPoint, options =
 function identityMatrix() {
   return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 }
-function toMat4(input) {
-  return input instanceof Transform ? input.toArray() : input;
-}
 function multiplyMat4(a2, b) {
   const out = new Array(16).fill(0);
   for (let col = 0; col < 4; col++) {
@@ -12458,23 +12504,40 @@ class Transform {
   }
   /** Wrap an existing `Transform` or raw 4x4 matrix as a `Transform`. */
   static from(input) {
-    return input instanceof Transform ? input : new Transform(input);
+    return input instanceof Transform ? input : new Transform(requireFiniteMat4(input, "Transform.from() matrix"));
   }
   /** Create a translation transform. */
   static translation(x2, y2, z2) {
-    return new Transform([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x2, y2, z2, 1]);
+    return new Transform([
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      requireFiniteNumber(x2, "Transform.translation() x"),
+      requireFiniteNumber(y2, "Transform.translation() y"),
+      requireFiniteNumber(z2, "Transform.translation() z"),
+      1
+    ]);
   }
   /** Create a uniform or per-axis scale transform. */
   static scale(v) {
-    const sx = typeof v === "number" ? v : v[0];
-    const sy = typeof v === "number" ? v : v[1];
-    const sz = typeof v === "number" ? v : v[2];
+    const [sx, sy, sz] = requireNonZeroFiniteScale3(v, "Transform.scale() scale");
     return new Transform([sx, 0, 0, 0, 0, sy, 0, 0, 0, 0, sz, 0, 0, 0, 0, 1]);
   }
   /** Create a rotation around an arbitrary axis, optionally about a pivot. */
   static rotationAxis(axis, angleDeg, pivot = [0, 0, 0]) {
-    const [ux, uy, uz] = normalizeVec3$3(axis);
-    const rad = angleDeg * Math.PI / 180;
+    const [ux, uy, uz] = normalizeVec3$3(requireNonZeroFiniteVec3(axis, "Transform.rotationAxis() axis"));
+    const degrees = requireFiniteNumber(angleDeg, "Transform.rotationAxis() angleDeg");
+    const [px, py, pz] = requireFiniteVec3$1(pivot, "Transform.rotationAxis() pivot");
+    const rad = degrees * Math.PI / 180;
     const cos2 = Math.cos(rad);
     const sin2 = Math.sin(rad);
     const m00 = cos2 + ux * ux * (1 - cos2);
@@ -12486,7 +12549,6 @@ class Transform {
     const m20 = uz * ux * (1 - cos2) - uy * sin2;
     const m21 = uz * uy * (1 - cos2) + ux * sin2;
     const m22 = cos2 + uz * uz * (1 - cos2);
-    const [px, py, pz] = pivot;
     const tx = px - (m00 * px + m01 * py + m02 * pz);
     const ty = py - (m10 * px + m11 * py + m12 * pz);
     const tz = pz - (m20 * px + m21 * py + m22 * pz);
@@ -12494,12 +12556,16 @@ class Transform {
   }
   /** Solve the rotation needed to move one point onto a target line or plane. */
   static rotateAroundTo(axis, pivot, movingPoint, targetPoint, options = {}) {
-    const angleDeg = solveRotateAroundAngle(axis, pivot, movingPoint, targetPoint, options);
-    return Transform.rotationAxis(axis, angleDeg, pivot);
+    const rotateAxis = requireNonZeroFiniteVec3(axis, "Transform.rotateAroundTo() axis");
+    const rotatePivot = requireFiniteVec3$1(pivot, "Transform.rotateAroundTo() pivot");
+    const moving = requireFiniteVec3$1(movingPoint, "Transform.rotateAroundTo() movingPoint");
+    const target = requireFiniteVec3$1(targetPoint, "Transform.rotateAroundTo() targetPoint");
+    const angleDeg = solveRotateAroundAngle(rotateAxis, rotatePivot, moving, target, options);
+    return Transform.rotationAxis(rotateAxis, angleDeg, rotatePivot);
   }
   /** Compose transforms in chain order: `a.mul(b)` applies `a`, then `b`. */
   mul(other) {
-    const rhs = toMat4(other);
+    const rhs = other instanceof Transform ? other.toArray() : requireFiniteMat4(other, "Transform.mul() matrix");
     return new Transform(multiplyMat4(rhs, this.m));
   }
   /** Translate after the current transform. */
@@ -12510,7 +12576,20 @@ class Transform {
   rotateAxis(axis, angleDeg, pivot = [0, 0, 0]) {
     return this.mul(Transform.rotationAxis(axis, angleDeg, pivot));
   }
+  /** Rotate about the X axis after the current transform (parity with `Shape.rotateX`). */
+  rotateX(angleDeg, pivot = [0, 0, 0]) {
+    return this.rotateAxis([1, 0, 0], angleDeg, pivot);
+  }
+  /** Rotate about the Y axis after the current transform (parity with `Shape.rotateY`). */
+  rotateY(angleDeg, pivot = [0, 0, 0]) {
+    return this.rotateAxis([0, 1, 0], angleDeg, pivot);
+  }
+  /** Rotate about the Z axis after the current transform (parity with `Shape.rotateZ`). */
+  rotateZ(angleDeg, pivot = [0, 0, 0]) {
+    return this.rotateAxis([0, 0, 1], angleDeg, pivot);
+  }
   /** Scale after the current transform. */
+  // biome-ignore lint/suspicious/useAdjacentOverloadSignatures: Static Transform.scale() and chainable instance scale() intentionally share the CAD API name.
   scale(v) {
     return this.mul(Transform.scale(v));
   }
@@ -12520,11 +12599,11 @@ class Transform {
   }
   /** Transform a point using homogeneous coordinates. */
   point(p2) {
-    return transformPoint$1(this.m, p2, 1);
+    return transformPoint$1(this.m, requireFiniteVec3$1(p2, "Transform.point() point"), 1);
   }
   /** Transform a direction vector without translation. */
   vector(v) {
-    return transformPoint$1(this.m, v, 0);
+    return transformPoint$1(this.m, requireFiniteVec3$1(v, "Transform.vector() vector"), 0);
   }
   /** Return the transform as a raw 4x4 matrix array. */
   toArray() {
@@ -12913,6 +12992,42 @@ function cloneCutTaperCompilePlan(plan) {
     scale: [canonicalNumber(plan.scale[0]), canonicalNumber(plan.scale[1])]
   };
 }
+function cloneEdgeFeatureTarget(target) {
+  return {
+    midpoint: [target.midpoint[0], target.midpoint[1], target.midpoint[2]],
+    start: [target.start[0], target.start[1], target.start[2]],
+    end: [target.end[0], target.end[1], target.end[2]],
+    convex: target.convex,
+    ...target.nativeTopology ? { nativeTopology: { backend: target.nativeTopology.backend, edge: target.nativeTopology.edge } } : {}
+  };
+}
+function cloneEdgeFeatureQuery(query) {
+  if (!query) return void 0;
+  return {
+    ...query.near ? { near: [query.near[0], query.near[1], query.near[2]] } : {},
+    ...query.parallel ? { parallel: [query.parallel[0], query.parallel[1], query.parallel[2]] } : {},
+    ...query.perpendicular ? { perpendicular: [query.perpendicular[0], query.perpendicular[1], query.perpendicular[2]] } : {},
+    ...query.convex !== void 0 ? { convex: query.convex } : {},
+    ...query.concave !== void 0 ? { concave: query.concave } : {},
+    ...query.minAngle !== void 0 ? { minAngle: canonicalNumber(query.minAngle) } : {},
+    ...query.maxAngle !== void 0 ? { maxAngle: canonicalNumber(query.maxAngle) } : {},
+    ...query.minLength !== void 0 ? { minLength: canonicalNumber(query.minLength) } : {},
+    ...query.maxLength !== void 0 ? { maxLength: canonicalNumber(query.maxLength) } : {},
+    ...query.within ? {
+      within: {
+        ...query.within.xMin !== void 0 ? { xMin: canonicalNumber(query.within.xMin) } : {},
+        ...query.within.xMax !== void 0 ? { xMax: canonicalNumber(query.within.xMax) } : {},
+        ...query.within.yMin !== void 0 ? { yMin: canonicalNumber(query.within.yMin) } : {},
+        ...query.within.yMax !== void 0 ? { yMax: canonicalNumber(query.within.yMax) } : {},
+        ...query.within.zMin !== void 0 ? { zMin: canonicalNumber(query.within.zMin) } : {},
+        ...query.within.zMax !== void 0 ? { zMax: canonicalNumber(query.within.zMax) } : {}
+      }
+    } : {},
+    ...query.atZ !== void 0 ? { atZ: canonicalNumber(query.atZ) } : {},
+    ...query.tolerance !== void 0 ? { tolerance: canonicalNumber(query.tolerance) } : {},
+    ...query.angleTolerance !== void 0 ? { angleTolerance: canonicalNumber(query.angleTolerance) } : {}
+  };
+}
 function featureCutExtentForwardSide(extent) {
   return extent.kind === "two-sided" ? extent.forward : extent;
 }
@@ -13009,6 +13124,41 @@ function cloneSweepPathCompilePlan(path) {
         degree: path.degree,
         closed: path.closed
       };
+    case "route3d":
+      return {
+        kind: "route3d",
+        segments: path.segments.map(
+          (segment) => segment.kind === "line" ? {
+            kind: "line",
+            from: canonicalVec3(segment.from),
+            to: canonicalVec3(segment.to),
+            length: canonicalNumber(segment.length)
+          } : {
+            kind: "arc",
+            center: canonicalVec3(segment.center),
+            radius: canonicalNumber(segment.radius),
+            axis: canonicalVec3(segment.axis),
+            start: canonicalVec3(segment.start),
+            end: canonicalVec3(segment.end),
+            sweepDeg: canonicalNumber(segment.sweepDeg),
+            length: canonicalNumber(segment.length)
+          }
+        ),
+        ports: Object.fromEntries(
+          Object.entries(path.ports).map(([name, port]) => [
+            name,
+            {
+              name: port.name,
+              origin: canonicalVec3(port.origin),
+              axis: canonicalVec3(port.axis),
+              xAxis: canonicalVec3(port.xAxis),
+              yAxis: canonicalVec3(port.yAxis),
+              station: canonicalNumber(port.station)
+            }
+          ])
+        ),
+        length: canonicalNumber(path.length)
+      };
     default:
       assertExhaustive(path);
   }
@@ -13103,6 +13253,7 @@ function cloneProfileEdge(edge) {
   }
 }
 function cloneShapeCompilePlan(plan) {
+  var _a3, _b3, _c2;
   if (!plan) return null;
   let result;
   switch (plan.kind) {
@@ -13281,13 +13432,9 @@ function cloneShapeCompilePlan(plan) {
         radius: plan.radius,
         segments: plan.segments,
         continuity: plan.continuity,
-        edgeTargets: plan.edgeTargets.map((t) => ({
-          midpoint: [t.midpoint[0], t.midpoint[1], t.midpoint[2]],
-          start: [t.start[0], t.start[1], t.start[2]],
-          end: [t.end[0], t.end[1], t.end[2]],
-          convex: t.convex,
-          ...t.nativeTopology ? { nativeTopology: { backend: t.nativeTopology.backend, edge: t.nativeTopology.edge } } : {}
-        }))
+        edgeTargets: (_a3 = plan.edgeTargets) == null ? void 0 : _a3.map(cloneEdgeFeatureTarget),
+        edgeQuery: cloneEdgeFeatureQuery(plan.edgeQuery),
+        edgeSelection: plan.edgeSelection
       };
       break;
     case "cornerYBlend":
@@ -13297,13 +13444,7 @@ function cloneShapeCompilePlan(plan) {
         radius: plan.radius,
         segments: plan.segments,
         continuity: plan.continuity,
-        edgeTargets: plan.edgeTargets.map((t) => ({
-          midpoint: [t.midpoint[0], t.midpoint[1], t.midpoint[2]],
-          start: [t.start[0], t.start[1], t.start[2]],
-          end: [t.end[0], t.end[1], t.end[2]],
-          convex: t.convex,
-          ...t.nativeTopology ? { nativeTopology: { backend: t.nativeTopology.backend, edge: t.nativeTopology.edge } } : {}
-        })),
+        edgeTargets: ((_b3 = plan.edgeTargets) == null ? void 0 : _b3.map(cloneEdgeFeatureTarget)) ?? [],
         cornerPoint: [plan.cornerPoint[0], plan.cornerPoint[1], plan.cornerPoint[2]],
         cornerTolerance: canonicalNumber(plan.cornerTolerance),
         minBranchAngleDeg: canonicalNumber(plan.minBranchAngleDeg)
@@ -13314,13 +13455,9 @@ function cloneShapeCompilePlan(plan) {
         kind: "chamferEdges",
         base: cloneShapeCompilePlan(plan.base),
         size: plan.size,
-        edgeTargets: plan.edgeTargets.map((t) => ({
-          midpoint: [t.midpoint[0], t.midpoint[1], t.midpoint[2]],
-          start: [t.start[0], t.start[1], t.start[2]],
-          end: [t.end[0], t.end[1], t.end[2]],
-          convex: t.convex,
-          ...t.nativeTopology ? { nativeTopology: { backend: t.nativeTopology.backend, edge: t.nativeTopology.edge } } : {}
-        }))
+        edgeTargets: (_c2 = plan.edgeTargets) == null ? void 0 : _c2.map(cloneEdgeFeatureTarget),
+        edgeQuery: cloneEdgeFeatureQuery(plan.edgeQuery),
+        edgeSelection: plan.edgeSelection
       };
       break;
     case "draft":
@@ -13340,7 +13477,13 @@ function cloneShapeCompilePlan(plan) {
       };
       break;
     case "importedMesh":
-      result = { kind: "importedMesh", filePath: plan.filePath, format: plan.format, fileData: plan.fileData };
+      result = {
+        kind: "importedMesh",
+        filePath: plan.filePath,
+        format: plan.format,
+        ...plan.object ? { object: plan.object } : {},
+        fileData: plan.fileData
+      };
       break;
     case "sdf":
       result = {
@@ -13655,6 +13798,83 @@ function remapToKnotDomain(t, n, degree, knots) {
   const uMax = knots[n];
   return uMin + Math.max(0, Math.min(1, t)) * (uMax - uMin);
 }
+const EPSILON$2 = 1e-9;
+function add$2(a2, b) {
+  return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
+}
+function scale$2(v, factor) {
+  return [v[0] * factor, v[1] * factor, v[2] * factor];
+}
+function sub$2(a2, b) {
+  return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
+}
+function dot$3(a2, b) {
+  return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
+}
+function cross$4(a2, b) {
+  return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
+}
+function rotateAroundAxis(v, axis, angleRad) {
+  const c2 = Math.cos(angleRad);
+  const s = Math.sin(angleRad);
+  const term1 = scale$2(v, c2);
+  const term2 = scale$2(cross$4(axis, v), s);
+  const term3 = scale$2(axis, dot$3(axis, v) * (1 - c2));
+  return add$2(add$2(term1, term2), term3);
+}
+function arcPointAt(segment, t) {
+  const sweepRad = segment.sweepDeg * Math.PI / 180 * t;
+  return add$2(segment.center, rotateAroundAxis(sub$2(segment.start, segment.center), segment.axis, sweepRad));
+}
+function pushUnique(points, point) {
+  const prev = points[points.length - 1];
+  if (!prev || Math.hypot(prev[0] - point[0], prev[1] - point[1], prev[2] - point[2]) > EPSILON$2) {
+    points.push([point[0], point[1], point[2]]);
+  }
+}
+function resolveOptions(options) {
+  if (typeof options === "number") return { samples: Math.max(2, Math.floor(options)), maxAngleDeg: 6 };
+  return {
+    samples: Math.max(2, Math.floor((options == null ? void 0 : options.samples) ?? 48)),
+    maxAngleDeg: Math.max(0.25, (options == null ? void 0 : options.maxAngleDeg) ?? 6)
+  };
+}
+function routePointAt(plan, t) {
+  if (plan.segments.length === 0) return [0, 0, 0];
+  const target = Math.max(0, Math.min(1, t)) * plan.length;
+  let station = 0;
+  for (const segment of plan.segments) {
+    const next = station + segment.length;
+    if (target <= next || segment === plan.segments[plan.segments.length - 1]) {
+      const localT = segment.length <= EPSILON$2 ? 1 : Math.max(0, Math.min(1, (target - station) / segment.length));
+      if (segment.kind === "line") return add$2(segment.from, scale$2(sub$2(segment.to, segment.from), localT));
+      return arcPointAt(segment, localT);
+    }
+    station = next;
+  }
+  const last = plan.segments[plan.segments.length - 1];
+  return last.kind === "line" ? last.to : last.end;
+}
+function sampleRoute3DCompilePlan(plan, options) {
+  const resolved = resolveOptions(options);
+  const points = [];
+  const totalIntervals = Math.max(1, resolved.samples - 1);
+  for (const segment of plan.segments) {
+    const proportional = plan.length > EPSILON$2 ? Math.ceil(segment.length / plan.length * totalIntervals) : 1;
+    const arcIntervals = segment.kind === "arc" ? Math.ceil(Math.abs(segment.sweepDeg) / resolved.maxAngleDeg) : 1;
+    const intervals = Math.max(1, proportional, arcIntervals);
+    const start = segment.kind === "line" ? segment.from : segment.start;
+    pushUnique(points, start);
+    for (let i = 1; i <= intervals; i += 1) {
+      if (segment.kind === "line") {
+        pushUnique(points, add$2(segment.from, scale$2(sub$2(segment.to, segment.from), i / intervals)));
+      } else {
+        pushUnique(points, arcPointAt(segment, i / intervals));
+      }
+    }
+  }
+  return points;
+}
 function catmullRom3D$1(p0, p1, p2, p3, t, tension) {
   const tt = t * t;
   const ttt = tt * t;
@@ -13793,6 +14013,8 @@ function evalPathAt(path, t) {
       const u2 = remapToKnotDomain(Math.max(0, Math.min(1, t)), path.controlPoints.length, path.degree, path.knots);
       return deBoor3D(path.controlPoints, path.weights, path.knots, path.degree, u2);
     }
+    case "route3d":
+      return routePointAt(path, t);
   }
 }
 function estimateCurvatureAt(path, t) {
@@ -13839,10 +14061,13 @@ function sweepPathToPolyline(path, samples = 48) {
       }
       return result;
     }
+    case "route3d":
+      return sampleRoute3DCompilePlan(path, samples);
   }
 }
 function sweepPathToPolylineAdaptive(path, baseSamples = 48) {
   if (path.kind === "polyline") return path.points;
+  if (path.kind === "route3d") return sampleRoute3DCompilePlan(path, baseSamples);
   const probeCount = 64;
   const curvatures = [];
   for (let i = 0; i <= probeCount; i++) {
@@ -13873,7 +14098,7 @@ const EPS$2 = 1e-8;
 function midpoint$1(start, end) {
   return [(start[0] + end[0]) * 0.5, (start[1] + end[1]) * 0.5, (start[2] + end[2]) * 0.5];
 }
-function normalize$2(v) {
+function normalize$3(v) {
   const len = Math.hypot(v[0], v[1], v[2]);
   if (len <= EPS$2) throw new Error("Edge feature selection requires a non-zero direction vector");
   return [v[0] / len, v[1] / len, v[2] / len];
@@ -14292,8 +14517,8 @@ function extrudeEdgeSelection(plan, edgeName) {
   }
   const points = plan.profile.points;
   const [bl, br, _tr, tl] = points;
-  const u2 = normalize$2([br[0] - bl[0], br[1] - bl[1], 0]);
-  const v = normalize$2([tl[0] - bl[0], tl[1] - bl[1], 0]);
+  const u2 = normalize$3([br[0] - bl[0], br[1] - bl[1], 0]);
+  const v = normalize$3([tl[0] - bl[0], tl[1] - bl[1], 0]);
   const vertex = points[index2];
   const quadrant = index2 === 0 ? [1, -1] : index2 === 1 ? [-1, -1] : index2 === 2 ? [-1, 1] : [1, 1];
   return {
@@ -14314,9 +14539,9 @@ function extrudeEdgeSelection(plan, edgeName) {
 function applySelectionTransform(selection, transform) {
   const start = transform.point(selection.start);
   const end = transform.point(selection.end);
-  const basisX = normalize$2(transform.vector(selection.basisX));
-  const basisY = normalize$2(transform.vector(selection.basisY));
-  const axis = normalize$2(subtract(end, start));
+  const basisX = normalize$3(transform.vector(selection.basisX));
+  const basisY = normalize$3(transform.vector(selection.basisY));
+  const axis = normalize$3(subtract(end, start));
   return {
     kind: "line-segment",
     edgeName: selection.edgeName,
@@ -15591,6 +15816,20 @@ function cleanName(value) {
   const trimmed = value == null ? void 0 : value.replace(/\s+/g, " ").trim();
   return trimmed && trimmed.length > 0 ? trimmed : null;
 }
+function uniqueNames(baseNames) {
+  const totals = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Map();
+  for (const baseName of baseNames) totals.set(baseName, (totals.get(baseName) ?? 0) + 1);
+  return baseNames.map((baseName) => {
+    if ((totals.get(baseName) ?? 0) <= 1) return baseName;
+    const ordinal = (seen.get(baseName) ?? 0) + 1;
+    seen.set(baseName, ordinal);
+    return `${baseName} #${String(ordinal).padStart(3, "0")}`;
+  });
+}
+function normalizeSelector(value) {
+  return value.trim().replace(/\s+/g, " ").toLowerCase();
+}
 function extractModelXml(data) {
   const zip = unzipSync(new Uint8Array(data));
   const path = Object.keys(zip).find((entry) => entry.toLowerCase() === "3d/3dmodel.model");
@@ -15662,14 +15901,105 @@ function collectObjectGeometry(model, objectId, transforms = [], visiting = /* @
   }
   return { vertices, triangles, bbox };
 }
+function buildBuildEntries(model) {
+  const buildBaseNames = model.buildItems.map(
+    (item) => {
+      var _a3;
+      return cleanName((_a3 = model.objectsById.get(item.objectId)) == null ? void 0 : _a3.sourceName) ?? `object-${item.objectId}`;
+    }
+  );
+  const buildNames = uniqueNames(buildBaseNames);
+  return model.buildItems.map((item, index2) => {
+    const object = model.objectsById.get(item.objectId);
+    return {
+      stableRef: `3mf:build:${String(index2 + 1).padStart(3, "0")}:object:${item.objectId}`,
+      objectId: item.objectId,
+      autoName: buildNames[index2],
+      sourceName: object == null ? void 0 : object.sourceName,
+      type: object == null ? void 0 : object.type,
+      transform: item.transform
+    };
+  });
+}
+function buildObjectEntries(model) {
+  const objectNames = uniqueNames(model.objects.map((object) => cleanName(object.sourceName) ?? `object-${object.id}`));
+  return model.objects.map(
+    (object, index2) => ({
+      stableRef: `3mf:object:${object.id}`,
+      objectId: object.id,
+      autoName: objectNames[index2],
+      sourceName: object.sourceName,
+      type: object.type
+    })
+  );
+}
+function buildDefaultSourceEntries(model) {
+  return model.buildItems.length > 0 ? buildBuildEntries(model) : buildObjectEntries(model);
+}
+function buildSelectableEntries(model) {
+  return model.buildItems.length > 0 ? [...buildBuildEntries(model), ...buildObjectEntries(model)] : buildObjectEntries(model);
+}
+function entryMatchesSelector(entry, selector) {
+  const needle = normalizeSelector(selector);
+  return [
+    entry.stableRef,
+    entry.autoName,
+    entry.sourceName ?? "",
+    entry.objectId,
+    `object-${entry.objectId}`,
+    `3mf:object:${entry.objectId}`
+  ].some((candidate) => normalizeSelector(candidate) === needle);
+}
+function availableEntryList(entries) {
+  return entries.map((entry) => `${entry.autoName} [${entry.stableRef}]`).join(", ") || "none";
+}
+function selectSourceEntry(entries, selector) {
+  const matches = entries.filter((entry) => entryMatchesSelector(entry, selector));
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    throw new Error(
+      `3MF object selector "${selector}" is ambiguous. Use a stable ref: ${matches.map((entry) => entry.stableRef).join(", ")}`
+    );
+  }
+  throw new Error(`3MF object selector "${selector}" matched no build item or resource object. Available: ${availableEntryList(entries)}`);
+}
+function selectorLooksLikeStableRef(selector) {
+  return /^3mf:(build|object):/i.test(selector.trim());
+}
+function meshFromGeometry(geometry) {
+  const vertices = [];
+  const triangles = [];
+  for (const vertex of geometry.vertices) vertices.push(vertex[0], vertex[1], vertex[2]);
+  for (const triangle of geometry.triangles) triangles.push(triangle[0], triangle[1], triangle[2]);
+  return {
+    vertProperties: new Float32Array(vertices),
+    triVerts: new Uint32Array(triangles),
+    numProp: 3,
+    mergeFromVert: new Uint32Array(0),
+    mergeToVert: new Uint32Array(0)
+  };
+}
+function partFromEntry(model, entry) {
+  const geometry = collectObjectGeometry(model, entry.objectId, [entry.transform]);
+  return {
+    stableRef: entry.stableRef,
+    objectId: entry.objectId,
+    autoName: entry.autoName,
+    sourceName: entry.sourceName,
+    type: entry.type,
+    mesh: meshFromGeometry(geometry),
+    bbox: geometry.bbox,
+    vertexCount: geometry.vertices.length,
+    triangleCount: geometry.triangles.length
+  };
+}
 function parse3mfMesh(data) {
   const model = parseModel(data);
-  const sourceIds = model.buildItems.length > 0 ? model.buildItems.map((item) => item.objectId) : model.objects.map((object) => object.id);
-  const transforms = model.buildItems.length > 0 ? model.buildItems.map((item) => item.transform) : sourceIds.map(() => void 0);
+  const entries = buildDefaultSourceEntries(model);
   const vertices = [];
   const triangles = [];
-  sourceIds.forEach((objectId, index2) => {
-    const geometry = collectObjectGeometry(model, objectId, [transforms[index2]]);
+  entries.forEach((entry) => {
+    const geometry = collectObjectGeometry(model, entry.objectId, [entry.transform]);
     const offset = vertices.length / 3;
     for (const vertex of geometry.vertices) vertices.push(vertex[0], vertex[1], vertex[2]);
     for (const triangle of geometry.triangles) triangles.push(triangle[0] + offset, triangle[1] + offset, triangle[2] + offset);
@@ -15682,6 +16012,11 @@ function parse3mfMesh(data) {
     mergeToVert: new Uint32Array(0)
   };
 }
+function parse3mfMeshPart(data, selector) {
+  const model = parseModel(data);
+  const entries = selectorLooksLikeStableRef(selector) ? buildSelectableEntries(model) : buildDefaultSourceEntries(model);
+  return partFromEntry(model, selectSourceEntry(entries, selector));
+}
 function isStlBinary(data) {
   if (data.byteLength < 84) return false;
   const view = new DataView(data);
@@ -15826,17 +16161,17 @@ function parseObj(data) {
     mergeToVert: new Uint32Array(0)
   };
 }
-function parse3mf(data) {
-  return parse3mfMesh(data);
+function parse3mf(data, options = {}) {
+  return options.object ? parse3mfMeshPart(data, options.object).mesh : parse3mfMesh(data);
 }
-function parseMeshFile(data, format) {
+function parseMeshFile(data, format, options = {}) {
   switch (format) {
     case "stl":
       return parseStl(data);
     case "obj":
       return parseObj(data);
     case "3mf":
-      return parse3mf(data);
+      return parse3mf(data, options);
   }
 }
 function cleanZero(value) {
@@ -15863,6 +16198,84 @@ function planeFrameToWorldToPlaneMatrix(frame) {
     1
   ];
 }
+const DEFAULT_TOLERANCE = 1;
+const DEFAULT_ANGLE_TOLERANCE = 10;
+function distSq$2(a2, b) {
+  const dx = a2[0] - b[0];
+  const dy = a2[1] - b[1];
+  const dz = a2[2] - b[2];
+  return dx * dx + dy * dy + dz * dz;
+}
+function vecLength$2(v) {
+  return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+}
+function normalize$2(v) {
+  const len = vecLength$2(v);
+  if (len < 1e-12) return [0, 0, 0];
+  return [v[0] / len, v[1] / len, v[2] / len];
+}
+function absDot$1(a2, b) {
+  return Math.abs(a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2]);
+}
+function applyEdgeQueryFilters(edges, query) {
+  const tol = query.tolerance ?? DEFAULT_TOLERANCE;
+  const angleTol = query.angleTolerance ?? DEFAULT_ANGLE_TOLERANCE;
+  const cosAngleTol = Math.cos(angleTol * Math.PI / 180);
+  let result = edges;
+  if (query.convex === true) {
+    result = result.filter((e) => e.convex);
+  }
+  if (query.concave === true) {
+    result = result.filter((e) => !e.convex);
+  }
+  if (query.minAngle != null) {
+    const min2 = query.minAngle;
+    result = result.filter((e) => e.dihedralAngle >= min2);
+  }
+  if (query.maxAngle != null) {
+    const max2 = query.maxAngle;
+    result = result.filter((e) => e.dihedralAngle <= max2);
+  }
+  if (query.minLength != null) {
+    const min2 = query.minLength;
+    result = result.filter((e) => e.length >= min2);
+  }
+  if (query.maxLength != null) {
+    const max2 = query.maxLength;
+    result = result.filter((e) => e.length <= max2);
+  }
+  if (query.parallel) {
+    const dir = normalize$2(query.parallel);
+    result = result.filter((e) => absDot$1(e.direction, dir) >= cosAngleTol);
+  }
+  if (query.perpendicular) {
+    const dir = normalize$2(query.perpendicular);
+    const sinAngleTol = Math.sin(angleTol * Math.PI / 180);
+    result = result.filter((e) => absDot$1(e.direction, dir) <= sinAngleTol);
+  }
+  if (query.atZ != null) {
+    const z2 = query.atZ;
+    result = result.filter((e) => Math.abs(e.midpoint[2] - z2) <= tol);
+  }
+  if (query.within) {
+    const b = query.within;
+    result = result.filter((e) => {
+      const [mx, my, mz] = e.midpoint;
+      if (b.xMin != null && mx < b.xMin) return false;
+      if (b.xMax != null && mx > b.xMax) return false;
+      if (b.yMin != null && my < b.yMin) return false;
+      if (b.yMax != null && my > b.yMax) return false;
+      if (b.zMin != null && mz < b.zMin) return false;
+      if (b.zMax != null && mz > b.zMax) return false;
+      return true;
+    });
+  }
+  if (query.near) {
+    const pt = query.near;
+    result = result.slice().sort((a2, b) => distSq$2(a2.midpoint, pt) - distSq$2(b.midpoint, pt));
+  }
+  return result;
+}
 const SHELL_OPEN_FACE_CANONICAL = {
   front: "side-bottom",
   back: "side-top",
@@ -18170,6 +18583,8 @@ function getUnsupportedSdfProgramReason(node) {
       return "noise depends on table-based simplex evaluation";
     case "sdf:voronoi":
       return "voronoi depends on table-based Worley evaluation";
+    case "sdf:circularArray":
+      return "circularArray folds polar coordinates and is not implemented in SdfProgram yet";
     case "sdf:custom":
       return "custom uses a dynamic JavaScript function body";
     case "sdf:polylineSweep":
@@ -18850,6 +19265,7 @@ function requireOCCTShape(backend, apiName = "requireOCCTShape()") {
 }
 const BSPLINE_WIRE_THRESHOLD = 20;
 const OFFSET_SOLID_EPS$1 = 1e-8;
+const MANIFOLD_BACKEND_REQUIRED_HINT = "Select the Manifold backend in the editor or run the CLI with --backend manifold.";
 function transformProfileRadiusPoint$1(point, step) {
   switch (step.kind) {
     case "translate":
@@ -19555,6 +19971,31 @@ function findOCCTEdgeByMidpoint(oc, shape, midpoint2) {
   }
   return bestEdge;
 }
+function edgeSegmentToTarget(segment) {
+  return {
+    midpoint: [segment.midpoint[0], segment.midpoint[1], segment.midpoint[2]],
+    start: [segment.start[0], segment.start[1], segment.start[2]],
+    end: [segment.end[0], segment.end[1], segment.end[2]],
+    convex: segment.convex,
+    ...segment.nativeTopology ? { nativeTopology: segment.nativeTopology } : {}
+  };
+}
+function selectOCCTEdgeFeatureTargets(base, plan) {
+  if (!plan.edgeQuery) return plan.edgeTargets ?? [];
+  const mesh = wrapOCCTShapeBackend(base).getMesh();
+  const selected = applyEdgeQueryFilters(
+    extractEdgeSegments({
+      numProp: mesh.numProp,
+      numTri: mesh.numTri,
+      triVerts: mesh.triVerts,
+      vertProperties: mesh.vertProperties,
+      mergeFromVert: mesh.mergeFromVert,
+      mergeToVert: mesh.mergeToVert
+    }),
+    plan.edgeQuery
+  );
+  return (plan.edgeSelection === "first" ? selected.slice(0, 1) : selected).map(edgeSegmentToTarget);
+}
 function occtPointDistance(point, target) {
   return Math.hypot(point.X() - target[0], point.Y() - target[1], point.Z() - target[2]);
 }
@@ -19574,7 +20015,7 @@ function lowerFilletEdgesPlan$1(oc, plan) {
     mkFillet.SetContinuity(mapSurfaceContinuityToOcct(oc, plan.continuity), 2 * Math.PI / 180);
   }
   let addedCount = 0;
-  for (const target of plan.edgeTargets) {
+  for (const target of selectOCCTEdgeFeatureTargets(base, plan)) {
     const matchedEdge = findOCCTEdgeByMidpoint(oc, base, target.midpoint);
     if (matchedEdge) {
       mkFillet.Add_2(plan.radius, matchedEdge);
@@ -19621,7 +20062,7 @@ function lowerChamferEdgesPlan$1(oc, plan) {
   const base = lowerShapeCompilePlanToOCCT(plan.base, oc);
   const mkChamfer = new oc.BRepFilletAPI_MakeChamfer(base);
   let addedCount = 0;
-  for (const target of plan.edgeTargets) {
+  for (const target of selectOCCTEdgeFeatureTargets(base, plan)) {
     const matchedEdge = findOCCTEdgeByMidpoint(oc, base, target.midpoint);
     if (matchedEdge) {
       mkChamfer.Add_2(plan.size, matchedEdge);
@@ -19908,7 +20349,7 @@ function _lowerShapeCompilePlanToOCCTInner(plan, oc) {
         `importMesh("${plan.filePath}") is not supported with the OCCT backend. Switch to the Manifold backend or use the default backend.`
       );
     case "sdf":
-      throw new Error("SDF shapes require the Manifold backend. Add setActiveBackend('manifold') at the top of your script.");
+      throw new Error(`SDF shapes require the Manifold backend. ${MANIFOLD_BACKEND_REQUIRED_HINT}`);
     case "fromSlices":
       return lowerFromSlicesPlan$1(oc, plan);
     case "nurbsSurface":
@@ -20080,6 +20521,7 @@ function buildBSplineCurveHandleFromSweepPathPlan(oc, path, context, allowApprox
     case "catmull-rom":
     case "hermite":
     case "quintic-hermite":
+    case "route3d":
       if (allowApproximation) {
         return buildApproximateBSplineCurveHandle(oc, sweepPathToPolyline(path, 96), context);
       }
@@ -20460,27 +20902,166 @@ function lowerLoftPlan$1(oc, plan) {
   }
   return ts.Shape();
 }
-function buildZToNormalTransform(oc, normal) {
+function fromSlicesPlaneFrameForOCCT(normalInput) {
+  const normal = normalizeVec3$2(normalInput);
+  if (!normal) throw new Error("Shape.fromSlices group normal must be non-zero");
   const [nx, ny, nz] = normal;
+  if (Math.abs(nz) > 1 - 1e-8) {
+    return { u: [1, 0, 0], v: [0, nz > 0 ? 1 : -1, 0], normal };
+  }
+  if (Math.abs(ny) > 1 - 1e-8) {
+    return { u: [1, 0, 0], v: [0, 0, ny > 0 ? 1 : -1], normal };
+  }
+  if (Math.abs(nx) > 1 - 1e-8) {
+    return { u: [0, 1, 0], v: [0, 0, nx > 0 ? 1 : -1], normal };
+  }
+  const reference = Math.abs(nx) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+  const u2 = normalizeVec3$2(crossVec3$1(reference, normal));
+  if (!u2) throw new Error("Shape.fromSlices profile u axis is invalid");
+  return { u: u2, v: crossVec3$1(normal, u2), normal };
+}
+function buildFromSlicesLocalToWorldTransform(oc, normal) {
+  const frame = fromSlicesPlaneFrameForOCCT(normal);
   const trsf = new oc.gp_Trsf_1();
-  if (Math.abs(nx) < 1e-10 && Math.abs(ny) < 1e-10) {
-    if (nz < 0) {
-      trsf.SetRotation_1(new oc.gp_Ax1_2(new oc.gp_Pnt_3(0, 0, 0), new oc.gp_Dir_4(1, 0, 0)), Math.PI);
-    }
-    return trsf;
-  }
-  const ax = -ny;
-  const ay = nx;
-  const az = 0;
-  const len = Math.sqrt(ax * ax + ay * ay + az * az);
-  const angle = Math.acos(Math.max(-1, Math.min(1, nz)));
-  trsf.SetRotation_1(new oc.gp_Ax1_2(new oc.gp_Pnt_3(0, 0, 0), new oc.gp_Dir_4(ax / len, ay / len, az / len)), angle);
+  trsf.SetValues(
+    frame.u[0],
+    frame.v[0],
+    frame.normal[0],
+    0,
+    frame.u[1],
+    frame.v[1],
+    frame.normal[1],
+    0,
+    frame.u[2],
+    frame.v[2],
+    frame.normal[2],
+    0
+  );
   return trsf;
 }
+function axisAlignedDirectionForOCCT(vector) {
+  let bestAxis = 0;
+  let best = Math.abs(vector[0]);
+  for (const axis of [1, 2]) {
+    const value = Math.abs(vector[axis]);
+    if (value > best) {
+      best = value;
+      bestAxis = axis;
+    }
+  }
+  if (best < 1 - 1e-8) return null;
+  return { axis: bestAxis, sign: vector[bestAxis] < 0 ? -1 : 1 };
+}
+function centeredEllipseProfileRadiiForOCCT(plan) {
+  if (plan.kind !== "circle") return null;
+  let rx = Math.abs(plan.radius);
+  let ry = Math.abs(plan.radius);
+  for (const transform of plan.transforms) {
+    if (transform.kind !== "scale") return null;
+    rx *= Math.abs(transform.x);
+    ry *= Math.abs(transform.y);
+  }
+  return rx > 1e-10 && ry > 1e-10 ? [rx, ry] : null;
+}
+function setEllipsoidRadiusForOCCT(radii, axis, radius) {
+  const existing = radii[axis];
+  if (existing == null) {
+    radii[axis] = radius;
+    return true;
+  }
+  const tolerance = Math.max(1e-7, Math.max(Math.abs(existing), Math.abs(radius)) * 1e-7);
+  return Math.abs(existing - radius) <= tolerance;
+}
+function buildRationalQuadraticEdgeForOCCT(oc, points, weights) {
+  const poles = new oc.TColgp_Array1OfPnt_2(1, 3);
+  const weightArr = new oc.TColStd_Array1OfReal_2(1, 3);
+  for (let i = 0; i < 3; i++) {
+    const [x2, y2, z2] = points[i];
+    poles.SetValue(i + 1, new oc.gp_Pnt_3(x2, y2, z2));
+    weightArr.SetValue(i + 1, weights[i]);
+  }
+  const knots = new oc.TColStd_Array1OfReal_2(1, 2);
+  knots.SetValue(1, 0);
+  knots.SetValue(2, 1);
+  const mults = new oc.TColStd_Array1OfInteger_2(1, 2);
+  mults.SetValue(1, 3);
+  mults.SetValue(2, 3);
+  const curve = new oc.Geom_BSplineCurve_2(poles, weightArr, knots, mults, 2, false, true);
+  const handle = new oc.Handle_Geom_BSplineCurve_2(curve);
+  return new oc.BRepBuilderAPI_MakeEdge_24(new oc.Handle_Geom_Curve_2(handle.get())).Edge();
+}
+function lowerAxisymmetricEllipsoidForOCCT(oc, radius, heightRadius) {
+  const w2 = Math.SQRT1_2;
+  const mkWire = new oc.BRepBuilderAPI_MakeWire_1();
+  mkWire.Add_1(
+    buildRationalQuadraticEdgeForOCCT(
+      oc,
+      [
+        [0, 0, heightRadius],
+        [radius, 0, heightRadius],
+        [radius, 0, 0]
+      ],
+      [1, w2, 1]
+    )
+  );
+  mkWire.Add_1(
+    buildRationalQuadraticEdgeForOCCT(
+      oc,
+      [
+        [radius, 0, 0],
+        [radius, 0, -heightRadius],
+        [0, 0, -heightRadius]
+      ],
+      [1, w2, 1]
+    )
+  );
+  mkWire.Add_1(new oc.BRepBuilderAPI_MakeEdge_3(new oc.gp_Pnt_3(0, 0, -heightRadius), new oc.gp_Pnt_3(0, 0, heightRadius)).Edge());
+  const face = buildFaceFromWire(oc, mkWire.Wire());
+  const axis = new oc.gp_Ax1_2(new oc.gp_Pnt_3(0, 0, 0), new oc.gp_Dir_4(0, 0, 1));
+  const revol = new oc.BRepPrimAPI_MakeRevol_1(face, axis, Math.PI * 2, true);
+  revol.Build(new oc.Message_ProgressRange_1());
+  if (!revol.IsDone()) {
+    throw new Error("Shape.fromSlices exact ellipsoid revolve failed");
+  }
+  return revol.Shape();
+}
+function lowerOrthogonalEllipseFromSlicesPlan(oc, plan) {
+  if (plan.groups.length !== 2) return null;
+  const center = [0, 0, 0];
+  const radii = [null, null, null];
+  for (const group of plan.groups) {
+    if (group.slices.length !== 1) return null;
+    const slice = group.slices[0];
+    const profileRadii = centeredEllipseProfileRadiiForOCCT(slice.profile);
+    if (!profileRadii) return null;
+    const frame = fromSlicesPlaneFrameForOCCT(group.normal);
+    const normalAxis = axisAlignedDirectionForOCCT(frame.normal);
+    const uAxis = axisAlignedDirectionForOCCT(frame.u);
+    const vAxis = axisAlignedDirectionForOCCT(frame.v);
+    if (!normalAxis || !uAxis || !vAxis) return null;
+    center[normalAxis.axis] = normalAxis.sign * slice.offset;
+    if (!setEllipsoidRadiusForOCCT(radii, uAxis.axis, profileRadii[0])) return null;
+    if (!setEllipsoidRadiusForOCCT(radii, vAxis.axis, profileRadii[1])) return null;
+  }
+  if (radii.some((radius) => radius == null)) return null;
+  const rx = radii[0];
+  const ry = radii[1];
+  const rz = radii[2];
+  const axisymmetricTolerance = Math.max(1e-7, Math.max(Math.abs(rx), Math.abs(ry)) * 1e-7);
+  if (Math.abs(rx - ry) > axisymmetricTolerance) return null;
+  let shape = lowerAxisymmetricEllipsoidForOCCT(oc, (rx + ry) / 2, rz);
+  if (Math.hypot(center[0], center[1], center[2]) > 1e-10) {
+    const trsf = new oc.gp_Trsf_1();
+    trsf.SetTranslation_1(new oc.gp_Vec_4(center[0], center[1], center[2]));
+    const moved = new oc.BRepBuilderAPI_Transform_2(shape, trsf, true);
+    shape = moved.Shape();
+  }
+  return shape;
+}
 function lowerFromSlicesGroup(oc, group, singleSliceHalfExtent) {
   const { normal, slices } = group;
   const sorted = [...slices].sort((a2, b) => a2.offset - b.offset);
-  const rotTrsf = buildZToNormalTransform(oc, normal);
+  const localToWorldTrsf = buildFromSlicesLocalToWorldTransform(oc, normal);
   if (sorted.length === 1) {
     const s = sorted[0];
     const rawFace = lowerProfileToFace(oc, s.profile);
@@ -20494,7 +21075,7 @@ function lowerFromSlicesGroup(oc, group, singleSliceHalfExtent) {
     centerTrsf.SetTranslation_1(new oc.gp_Vec_4(0, 0, s.offset - extrudeHalf));
     const centered = new oc.BRepBuilderAPI_Transform_2(shape, centerTrsf, true);
     shape = centered.Shape();
-    const rotated = new oc.BRepBuilderAPI_Transform_2(shape, rotTrsf, true);
+    const rotated = new oc.BRepBuilderAPI_Transform_2(shape, localToWorldTrsf, true);
     return rotated.Shape();
   }
   const ts = new oc.BRepOffsetAPI_ThruSections(true, false, 1e-6);
@@ -20505,10 +21086,8 @@ function lowerFromSlicesGroup(oc, group, singleSliceHalfExtent) {
     wire = toBSplineWireIfNeeded(oc, wire);
     const placeTrsf = new oc.gp_Trsf_1();
     placeTrsf.SetTranslation_1(new oc.gp_Vec_4(0, 0, s.offset));
-    const compound = new oc.gp_Trsf_1();
-    compound.Multiply(rotTrsf);
-    compound.Multiply(placeTrsf);
-    const transformed = new oc.BRepBuilderAPI_Transform_2(wire, compound, true);
+    const placed = new oc.BRepBuilderAPI_Transform_2(wire, placeTrsf, true);
+    const transformed = new oc.BRepBuilderAPI_Transform_2(placed.Shape(), localToWorldTrsf, true);
     ts.AddWire(oc.TopoDS.Wire_1(transformed.Shape()));
   }
   ts.CheckCompatibility(true);
@@ -20520,6 +21099,8 @@ function lowerFromSlicesGroup(oc, group, singleSliceHalfExtent) {
 }
 function lowerFromSlicesPlan$1(oc, plan) {
   if (plan.groups.length === 0) throw new Error("Shape.fromSlices requires at least one slice");
+  const exactEllipsoid = lowerOrthogonalEllipseFromSlicesPlan(oc, plan);
+  if (exactEllipsoid) return exactEllipsoid;
   const singleSliceHalfExtent = fromSlicesSingleSliceHalfExtentForOCCT(plan);
   const groupSolids = plan.groups.map((g2) => lowerFromSlicesGroup(oc, g2, singleSliceHalfExtent));
   if (groupSolids.length === 1) return groupSolids[0];
@@ -20546,14 +21127,40 @@ function buildPolylineSpineWire(oc, points) {
   }
   return mkWire.Wire();
 }
+function buildRoute3DSpineWire(oc, path) {
+  if (path.segments.length === 0) throw new Error("Route3D sweep path needs at least one segment");
+  const mkWire = new oc.BRepBuilderAPI_MakeWire_1();
+  for (const segment of path.segments) {
+    if (segment.kind === "line") {
+      const [x1, y1, z1] = segment.from;
+      const [x2, y2, z2] = segment.to;
+      if (x1 === x2 && y1 === y2 && z1 === z2) continue;
+      mkWire.Add_1(new oc.BRepBuilderAPI_MakeEdge_3(new oc.gp_Pnt_3(x1, y1, z1), new oc.gp_Pnt_3(x2, y2, z2)).Edge());
+      continue;
+    }
+    const radial = normalizeVec3$2(subtractVec3(segment.start, segment.center));
+    if (!radial) throw new Error("Route3D sweep arc has a collapsed start radius");
+    const axis = new oc.gp_Ax2_2(
+      new oc.gp_Pnt_3(segment.center[0], segment.center[1], segment.center[2]),
+      new oc.gp_Dir_4(segment.axis[0], segment.axis[1], segment.axis[2]),
+      new oc.gp_Dir_4(radial[0], radial[1], radial[2])
+    );
+    const circle = new oc.gp_Circ_2(axis, segment.radius);
+    mkWire.Add_1(new oc.BRepBuilderAPI_MakeEdge_9(circle, 0, segment.sweepDeg * Math.PI / 180).Edge());
+  }
+  return mkWire.Wire();
+}
 function buildSpineWireFromPlan(oc, path, pathSamples) {
   switch (path.kind) {
     case "polyline":
       return buildPolylineSpineWire(oc, path.points);
+    case "route3d":
+      return buildRoute3DSpineWire(oc, path);
+    case "nurbs":
+      return new oc.BRepBuilderAPI_MakeWire_2(buildCurveEdgeFromSweepPathPlan(oc, path, "OCCT sweep path")).Wire();
     case "catmull-rom":
     case "hermite":
     case "quintic-hermite":
-    case "nurbs":
       return buildPolylineSpineWire(oc, sweepPathToPolyline(path, pathSamples ?? 48));
   }
 }
@@ -29418,18 +30025,18 @@ function faceAxes(face) {
   }
   return {};
 }
-function edgeKey$1(start, end) {
+function edgeKey$2(start, end) {
   const encode = (p2) => p2.map((value) => value.toFixed(9)).join(",");
   const a2 = encode(start);
   const b = encode(end);
   return a2 < b ? `${a2}|${b}` : `${b}|${a2}`;
 }
 function faceEdgeIndex(face, start, end) {
-  const target = edgeKey$1(start, end);
+  const target = edgeKey$2(start, end);
   for (let i = 0; i < face.vertices.length; i++) {
     const faceStart = face.vertices[i];
     const faceEnd = face.vertices[(i + 1) % face.vertices.length];
-    if (faceStart && faceEnd && edgeKey$1(faceStart, faceEnd) === target) return i;
+    if (faceStart && faceEnd && edgeKey$2(faceStart, faceEnd) === target) return i;
   }
   return null;
 }
@@ -29630,7 +30237,7 @@ function topologyPayloadToTopology(payload) {
     const start = explicitVertices[explicitEdge.vertices[0]];
     const end = explicitVertices[explicitEdge.vertices[1]];
     if (!isVec3(start) || !isVec3(end)) continue;
-    const key = edgeKey$1(start, end);
+    const key = edgeKey$2(start, end);
     if (seenEdges.has(key)) continue;
     seenEdges.set(key, edges.size);
     const display = explicitEdgeDisplayName(payload, explicitEdge, explicitEdgeIndex, start, end);
@@ -29650,7 +30257,7 @@ function topologyPayloadToTopology(payload) {
         const start = face.vertices[i];
         const end = face.vertices[(i + 1) % face.vertices.length];
         if (!start || !end) continue;
-        const key = edgeKey$1(start, end);
+        const key = edgeKey$2(start, end);
         if (seenEdges.has(key)) continue;
         seenEdges.set(key, edges.size);
         edges.set(`${face.id}:edge-${i}`, {
@@ -31521,7 +32128,7 @@ function nurbsSurfaceForPlan(plan) {
   return null;
 }
 function lowerImportedMeshPlan(plan) {
-  const parsed = parseMeshFile(plan.fileData, plan.format);
+  const parsed = parseMeshFile(plan.fileData, plan.format, { object: plan.object });
   if (parsed.numProp !== 3) {
     throw new Error(`importMesh("${plan.filePath}"): expected xyz vertex data`);
   }
@@ -31824,12 +32431,18 @@ function applyNativeTruckFilletTargets(initialShape, targets, radius, segments,
   }
 }
 function lowerFilletEdgesPlan(plan) {
+  if (plan.edgeQuery) {
+    throw new Error("filletEdges(): deferred edge queries are not supported by the Truck lowerer yet.");
+  }
   const shape = lowerShapeCompilePlanToTruckBackend(plan.base);
-  return applyNativeTruckFilletTargets(shape, plan.edgeTargets, plan.radius, plan.segments, "filletEdges()");
+  return applyNativeTruckFilletTargets(shape, plan.edgeTargets ?? [], plan.radius, plan.segments, "filletEdges()");
 }
 function lowerChamferEdgesPlan(plan) {
+  if (plan.edgeQuery) {
+    throw new Error("chamferEdges(): deferred edge queries are not supported by the Truck lowerer yet.");
+  }
   const shape = lowerShapeCompilePlanToTruckBackend(plan.base);
-  return applyNativeTruckChamferTargets(shape, plan.edgeTargets, plan.size, "chamferEdges()");
+  return applyNativeTruckChamferTargets(shape, plan.edgeTargets ?? [], plan.size, "chamferEdges()");
 }
 function resolvedEdgeFeatureSelectionToTarget(selection) {
   return {
@@ -37846,8 +38459,8 @@ function resolveShapeFace(plan, name) {
 const DEPRECATED_SIDE_NAMES = {
   "side-left": "left",
   "side-right": "right",
-  "side-top": "front",
-  "side-bottom": "back"
+  "side-top": "back",
+  "side-bottom": "front"
 };
 function explainMissingShapeFace(plan, name) {
   const table = resolveShapeFaceTable(plan);
@@ -38926,11 +39539,14 @@ class ShapeGroup {
   }
   /** Move the entire group by (x, y, z). All children move together as a unit. */
   translate(x2, y2, z2) {
-    const matrix = Transform.translation(x2, y2, z2).toArray();
+    const dx = requireFiniteNumber(x2, "ShapeGroup.translate() x");
+    const dy = requireFiniteNumber(y2, "ShapeGroup.translate() y");
+    const dz = requireFiniteNumber(z2, "ShapeGroup.translate() z");
+    const matrix = Transform.translation(dx, dy, dz).toArray();
     return this.mapChildrenTransform((c2) => {
-      if (c2 instanceof ShapeGroup) return c2.translate(x2, y2, z2);
-      if (c2 instanceof Shape) return c2.translate(x2, y2, z2);
-      return c2.translate(x2, y2);
+      if (c2 instanceof ShapeGroup) return c2.translate(dx, dy, dz);
+      if (c2 instanceof Shape) return c2.translate(dx, dy, dz);
+      return c2.translate(dx, dy);
     }, matrix);
   }
   /** Compute combined bounding box of all 3D children */
@@ -38966,17 +39582,23 @@ class ShapeGroup {
     return { min: bb.min, max: bb.max };
   }
   resolveRotatePoint(point) {
-    if (Array.isArray(point)) return [point[0], point[1], point[2]];
+    if (Array.isArray(point)) return requireFiniteVec3$1(point, "ShapeGroup.rotateAroundTo() point");
     const bb = this._bbox();
     return resolveAnchor3D(bb.min, bb.max, point);
   }
   /** Move the group so its bounding-box min corner lands at the given coordinate. */
   moveTo(x2, y2, z2) {
+    const targetX = requireFiniteNumber(x2, "ShapeGroup.moveTo() x");
+    const targetY = requireFiniteNumber(y2, "ShapeGroup.moveTo() y");
+    const targetZ = requireFiniteNumber(z2, "ShapeGroup.moveTo() z");
     const bb = this._bbox();
-    return this.translate(x2 - bb.min[0], y2 - bb.min[1], z2 - bb.min[2]);
+    return this.translate(targetX - bb.min[0], targetY - bb.min[1], targetZ - bb.min[2]);
   }
   /** Move the group relative to another part's bounding-box min corner. */
   moveToLocal(target, x2, y2, z2) {
+    const localX = requireFiniteNumber(x2, "ShapeGroup.moveToLocal() x");
+    const localY = requireFiniteNumber(y2, "ShapeGroup.moveToLocal() y");
+    const localZ = requireFiniteNumber(z2, "ShapeGroup.moveToLocal() z");
     let tbb;
     if (target instanceof ShapeGroup) {
       tbb = target._bbox();
@@ -38984,7 +39606,7 @@ class ShapeGroup {
       const bb = target.boundingBox();
       tbb = { min: bb.min };
     }
-    return this.moveTo(tbb.min[0] + x2, tbb.min[1] + y2, tbb.min[2] + z2);
+    return this.moveTo(tbb.min[0] + localX, tbb.min[1] + localY, tbb.min[2] + localZ);
   }
   /**
    * Attach this group to a face or anchor on another part.
@@ -39013,9 +39635,10 @@ class ShapeGroup {
     const sp = resolveAnchor3D(sbb.min, sbb.max, selfAnchor);
     let dx = tp[0] - sp[0], dy = tp[1] - sp[1], dz = tp[2] - sp[2];
     if (offset) {
-      dx += offset[0];
-      dy += offset[1];
-      dz += offset[2];
+      const offsetPoint = requireFiniteVec3$1(offset, "ShapeGroup.attachTo() offset");
+      dx += offsetPoint[0];
+      dy += offsetPoint[1];
+      dz += offsetPoint[2];
     }
     return this.translate(dx, dy, dz);
   }
@@ -39024,7 +39647,9 @@ class ShapeGroup {
    * See Shape.onFace() for full documentation.
    */
   onFace(parent, face, opts = {}) {
-    const u2 = opts.u ?? 0, v = opts.v ?? 0, p2 = opts.protrude ?? 0;
+    const u2 = requireFiniteNumber(opts.u ?? 0, "ShapeGroup.onFace() u");
+    const v = requireFiniteNumber(opts.v ?? 0, "ShapeGroup.onFace() v");
+    const p2 = requireFiniteNumber(opts.protrude ?? 0, "ShapeGroup.onFace() protrude");
     const opp = { front: "back", back: "front", left: "right", right: "left", top: "bottom", bottom: "top" };
     const uvMap = {
       front: (u22, v2, p22) => [u22, -p22, v2],
@@ -39063,20 +39688,31 @@ class ShapeGroup {
   }
   /** Rotate around an arbitrary axis, optionally through a pivot point. */
   rotateAroundAxis(axis, angleDeg, pivot = [0, 0, 0]) {
-    return this.transform(Transform.rotationAxis(axis, angleDeg, pivot));
+    const rotateAxis = requireNonZeroFiniteVec3(axis, "ShapeGroup.rotateAroundAxis() axis");
+    const degrees = requireFiniteNumber(angleDeg, "ShapeGroup.rotateAroundAxis() angleDeg");
+    const rotatePivot = requireFiniteVec3$1(pivot, "ShapeGroup.rotateAroundAxis() pivot");
+    return this.transform(Transform.rotationAxis(rotateAxis, degrees, rotatePivot));
   }
   /**
    * Rotate around an axis until a moving point reaches the target line/plane defined by the axis and target point.
    * ShapeGroup string points use built-in anchors only.
    */
   rotateAroundTo(axis, pivot, movingPoint, targetPoint, options = {}) {
+    const rotateAxis = requireNonZeroFiniteVec3(axis, "ShapeGroup.rotateAroundTo() axis");
+    const rotatePivot = requireFiniteVec3$1(pivot, "ShapeGroup.rotateAroundTo() pivot");
     return this.transform(
-      Transform.rotateAroundTo(axis, pivot, this.resolveRotatePoint(movingPoint), this.resolveRotatePoint(targetPoint), options)
+      Transform.rotateAroundTo(
+        rotateAxis,
+        rotatePivot,
+        this.resolveRotatePoint(movingPoint),
+        this.resolveRotatePoint(targetPoint),
+        options
+      )
     );
   }
   /** Reorient the group so its local Z axis points along `direction`. */
   pointAlong(direction) {
-    const [dx, dy, dz] = direction;
+    const [dx, dy, dz] = requireNonZeroFiniteVec3(direction, "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;
@@ -39091,11 +39727,11 @@ class ShapeGroup {
   }
   /** Apply a 4x4 transform matrix or `Transform` to all 3D children. */
   transform(m2) {
-    const matrix = m2 instanceof Transform ? m2.toArray() : m2;
+    const matrix = m2 instanceof Transform ? m2.toArray() : requireFiniteMat4(m2, "ShapeGroup.transform() matrix");
     const next = new ShapeGroup(
       this.children.map((c2) => {
-        if (c2 instanceof ShapeGroup) return c2.transform(m2);
-        if (c2 instanceof Shape) return c2.transform(m2);
+        if (c2 instanceof ShapeGroup) return c2.transform(matrix);
+        if (c2 instanceof Shape) return c2.transform(matrix);
         throw new Error(
           "ShapeGroup.transform only supports 3D children (Shape/ShapeGroup). For Sketch children, use 2D transforms (translate/rotate/scale/mirror)."
         );
@@ -39108,25 +39744,28 @@ class ShapeGroup {
   }
   /** Scale uniformly or per-axis from the group's bounding-box center. */
   scale(v) {
-    return this.scaleAround(this._bboxCenter(), v);
+    const scale2 = requireNonZeroFiniteScale3(v, "ShapeGroup.scale() scale");
+    return this.scaleAround(this._bboxCenter(), scale2);
   }
   /** Scale uniformly or per-axis from an explicit pivot point. */
   scaleAround(pivot, v) {
-    const matrix = Transform.scale(v).toArray();
-    if (pivot[0] === 0 && pivot[1] === 0 && pivot[2] === 0) {
+    const scale2 = requireNonZeroFiniteScale3(v, "ShapeGroup.scaleAround() scale");
+    const scalePivot = requireFiniteVec3$1(pivot, "ShapeGroup.scaleAround() pivot");
+    const matrix = Transform.scale(scale2).toArray();
+    if (scalePivot[0] === 0 && scalePivot[1] === 0 && scalePivot[2] === 0) {
       return this.mapChildrenTransform((c2) => {
-        if (c2 instanceof ShapeGroup) return c2.scaleAround([0, 0, 0], v);
-        if (c2 instanceof Shape) return c2.scaleAround([0, 0, 0], v);
-        return c2.scale(typeof v === "number" ? v : [v[0], v[1]]);
+        if (c2 instanceof ShapeGroup) return c2.scaleAround([0, 0, 0], scale2);
+        if (c2 instanceof Shape) return c2.scaleAround([0, 0, 0], scale2);
+        return c2.scale([scale2[0], scale2[1]]);
       }, matrix);
     }
-    const moved = this.translate(-pivot[0], -pivot[1], -pivot[2]);
+    const moved = this.translate(-scalePivot[0], -scalePivot[1], -scalePivot[2]);
     const scaled = moved.mapChildrenTransform((c2) => {
-      if (c2 instanceof ShapeGroup) return c2.scaleAround([0, 0, 0], v);
-      if (c2 instanceof Shape) return c2.scaleAround([0, 0, 0], v);
-      return c2.scale(typeof v === "number" ? v : [v[0], v[1]]);
+      if (c2 instanceof ShapeGroup) return c2.scaleAround([0, 0, 0], scale2);
+      if (c2 instanceof Shape) return c2.scaleAround([0, 0, 0], scale2);
+      return c2.scale([scale2[0], scale2[1]]);
     }, matrix);
-    return scaled.translate(pivot[0], pivot[1], pivot[2]);
+    return scaled.translate(scalePivot[0], scalePivot[1], scalePivot[2]);
   }
   /** Mirror across a plane through the group's bounding-box center. */
   mirror(normal) {
@@ -39134,21 +39773,23 @@ class ShapeGroup {
   }
   /** Mirror across a plane through an explicit point. */
   mirrorThrough(point, normal) {
-    const matrix = mirrorPlaneMatrix(normal);
-    if (point[0] === 0 && point[1] === 0 && point[2] === 0) {
+    const mirrorPoint = requireFiniteVec3$1(point, "ShapeGroup.mirrorThrough() point");
+    const mirrorNormal = requireNonZeroFiniteVec3(normal, "ShapeGroup.mirrorThrough() normal");
+    const matrix = mirrorPlaneMatrix(mirrorNormal);
+    if (mirrorPoint[0] === 0 && mirrorPoint[1] === 0 && mirrorPoint[2] === 0) {
       return this.mapChildrenTransform((c2) => {
-        if (c2 instanceof ShapeGroup) return c2.mirrorThrough([0, 0, 0], normal);
-        if (c2 instanceof Shape) return c2.mirrorThrough([0, 0, 0], normal);
-        return c2.mirror([normal[0], normal[1]]);
+        if (c2 instanceof ShapeGroup) return c2.mirrorThrough([0, 0, 0], mirrorNormal);
+        if (c2 instanceof Shape) return c2.mirrorThrough([0, 0, 0], mirrorNormal);
+        return c2.mirror([mirrorNormal[0], mirrorNormal[1]]);
       }, matrix);
     }
-    const moved = this.translate(-point[0], -point[1], -point[2]);
+    const moved = this.translate(-mirrorPoint[0], -mirrorPoint[1], -mirrorPoint[2]);
     const mirrored = moved.mapChildrenTransform((c2) => {
-      if (c2 instanceof ShapeGroup) return c2.mirrorThrough([0, 0, 0], normal);
-      if (c2 instanceof Shape) return c2.mirrorThrough([0, 0, 0], normal);
-      return c2.mirror([normal[0], normal[1]]);
+      if (c2 instanceof ShapeGroup) return c2.mirrorThrough([0, 0, 0], mirrorNormal);
+      if (c2 instanceof Shape) return c2.mirrorThrough([0, 0, 0], mirrorNormal);
+      return c2.mirror([mirrorNormal[0], mirrorNormal[1]]);
     }, matrix);
-    return mirrored.translate(point[0], point[1], point[2]);
+    return mirrored.translate(mirrorPoint[0], mirrorPoint[1], mirrorPoint[2]);
   }
   /** Return a copy of the group with the given display color applied to each child. */
   color(hex) {
@@ -39220,14 +39861,16 @@ class ShapeGroup {
    * ```
    */
   placeReference(ref, target, offset) {
+    const targetPoint = requireFiniteVec3$1(target, "ShapeGroup.placeReference() target");
+    const offsetPoint = offset === void 0 ? void 0 : requireFiniteVec3$1(offset, "ShapeGroup.placeReference() offset");
     const sourcePoint = this.referencePoint(ref);
-    let dx = target[0] - sourcePoint[0];
-    let dy = target[1] - sourcePoint[1];
-    let dz = target[2] - sourcePoint[2];
-    if (offset) {
-      dx += offset[0];
-      dy += offset[1];
-      dz += offset[2];
+    let dx = targetPoint[0] - sourcePoint[0];
+    let dy = targetPoint[1] - sourcePoint[1];
+    let dz = targetPoint[2] - sourcePoint[2];
+    if (offsetPoint) {
+      dx += offsetPoint[0];
+      dy += offsetPoint[1];
+      dz += offsetPoint[2];
     }
     return this.translate(dx, dy, dz);
   }
@@ -40159,14 +40802,21 @@ function attachTopologyRewritePropagation(plan, propagation) {
   }
   return cloneNodeWithPropagation(plan, propagation);
 }
+const DEFERRED_EDGE_SELECTION_MARKER = Symbol.for("forgecad.deferredEdgeSelection");
+function isDeferredEdgeSelection(value) {
+  return Boolean(value && typeof value === "object" && value[DEFERRED_EDGE_SELECTION_MARKER] === true);
+}
 function distSq$1(a2, b) {
-  const dx = a2[0] - b[0], dy = a2[1] - b[1], dz = a2[2] - b[2];
+  const dx = a2[0] - b[0];
+  const dy = a2[1] - b[1];
+  const dz = a2[2] - b[2];
   return dx * dx + dy * dy + dz * dz;
 }
 function absDot(a2, b) {
   return Math.abs(a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2]);
 }
 function coalesceEdges(segments, tolerance = 0.01) {
+  if (segments.some(isDeferredEdgeSelection)) return segments;
   if (segments.length <= 1) return segments;
   const used = new Uint8Array(segments.length);
   const result = [];
@@ -40889,16 +41539,6 @@ function mirrorMatrix(normal) {
   const m22 = 1 - 2 * nz * nz;
   return [m00, m10, m20, 0, m01, m11, m21, 0, m02, m12, m22, 0, 0, 0, 0, 1];
 }
-function normalizeShapeScale(v) {
-  const scale2 = typeof v === "number" ? [v, v, v] : v;
-  if (!Number.isFinite(scale2[0]) || !Number.isFinite(scale2[1]) || !Number.isFinite(scale2[2])) {
-    return null;
-  }
-  if (Math.abs(scale2[0]) < 1e-12 || Math.abs(scale2[1]) < 1e-12 || Math.abs(scale2[2]) < 1e-12) {
-    return null;
-  }
-  return [scale2[0], scale2[1], scale2[2]];
-}
 function dotVec3$1(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
@@ -42051,7 +42691,7 @@ function withBaseDimensionsAndMergedSourceSpans(base, sources, out, preserveOutp
   return result;
 }
 function resolveRotationPoint(shape, point) {
-  if (Array.isArray(point)) return [point[0], point[1], point[2]];
+  if (Array.isArray(point)) return requireFiniteVec3$1(point, "rotateAroundTo(): point");
   return shape.referencePoint(point);
 }
 function setShapePlacementReferences(shape, refs, options = {}) {
@@ -42779,7 +43419,9 @@ class Shape {
   edgesOf(faceLabel, options) {
     const faceRefs = this._resolveFaceLabels(faceLabel);
     const result = uniqueEdgeSegments(
-      faceRefs.flatMap((faceRef) => edgesOfFace(this, faceRef, options, (name) => this._resolveFaceLabel(name)))
+      faceRefs.flatMap((faceRef) => {
+        return edgesOfFace(this, faceRef, options, (name) => this._resolveFaceLabel(name));
+      })
     );
     if (result.length === 0) {
       throw new Error(
@@ -42827,7 +43469,11 @@ class Shape {
     const refsA = this._resolveFaceLabels(faceA);
     const bNames = Array.isArray(faceB) ? faceB : [faceB];
     const refBs = bNames.flatMap((name) => this._resolveFaceLabels(name));
-    const result = uniqueEdgeSegments(refsA.flatMap((refA) => edgesBetweenFaces(this, refA, refBs)));
+    const result = uniqueEdgeSegments(
+      refsA.flatMap((refA) => {
+        return edgesBetweenFaces(this, refA, refBs);
+      })
+    );
     if (result.length === 0) {
       const bStr = bNames.length === 1 ? `'${bNames[0]}'` : `[${bNames.map((n) => `'${n}'`).join(", ")}]`;
       throw new Error(
@@ -42891,14 +43537,16 @@ class Shape {
    * ```
    */
   placeReference(ref, target, offset) {
+    const targetPoint = requireFiniteVec3$1(target, "Shape.placeReference() target");
+    const offsetPoint = offset === void 0 ? void 0 : requireFiniteVec3$1(offset, "Shape.placeReference() offset");
     const sourcePoint = this.referencePoint(ref);
-    let dx = target[0] - sourcePoint[0];
-    let dy = target[1] - sourcePoint[1];
-    let dz = target[2] - sourcePoint[2];
-    if (offset) {
-      dx += offset[0];
-      dy += offset[1];
-      dz += offset[2];
+    let dx = targetPoint[0] - sourcePoint[0];
+    let dy = targetPoint[1] - sourcePoint[1];
+    let dz = targetPoint[2] - sourcePoint[2];
+    if (offsetPoint) {
+      dx += offsetPoint[0];
+      dy += offsetPoint[1];
+      dz += offsetPoint[2];
     }
     return this.translate(dx, dy, dz);
   }
@@ -42910,27 +43558,39 @@ class Shape {
    * Example: `shape.translatePolar(50, 30)` moves 50mm at 30 degrees from +X.
    */
   translatePolar(radius, angleDeg, z2 = 0) {
-    const rad = angleDeg * (Math.PI / 180);
-    return this.translate(radius * Math.cos(rad), radius * Math.sin(rad), z2);
+    const r = requireFiniteNumber(radius, "Shape.translatePolar() radius");
+    const angle = requireFiniteNumber(angleDeg, "Shape.translatePolar() angleDeg");
+    const zOffset = requireFiniteNumber(z2, "Shape.translatePolar() z");
+    const rad = angle * (Math.PI / 180);
+    return this.translate(r * Math.cos(rad), r * Math.sin(rad), zOffset);
   }
   /** Move the shape relative to its current position. All transforms are immutable and return new shapes. */
   translate(x2, y2, z2) {
-    const nextPlan = appendShapeCompileTransform(getShapeCompilePlanInternal(this), { kind: "translate", x: x2, y: y2, z: z2 });
+    const dx = requireFiniteNumber(x2, "Shape.translate() x");
+    const dy = requireFiniteNumber(y2, "Shape.translate() y");
+    const dz = requireFiniteNumber(z2, "Shape.translate() z");
+    const nextPlan = appendShapeCompileTransform(getShapeCompilePlanInternal(this), { kind: "translate", x: dx, y: dy, z: dz });
     return setShapeCompilePlanInternal(
-      withTransformedDimensions(this, buildShapeFromCompilePlan(nextPlan, this.colorHex), Transform.translation(x2, y2, z2).toArray()),
+      withTransformedDimensions(this, buildShapeFromCompilePlan(nextPlan, this.colorHex), Transform.translation(dx, dy, dz).toArray()),
       nextPlan
     );
   }
   /** Position the shape so its bounding box min corner is at the given global coordinate. */
   moveTo(x2, y2, z2) {
+    const targetX = requireFiniteNumber(x2, "Shape.moveTo() x");
+    const targetY = requireFiniteNumber(y2, "Shape.moveTo() y");
+    const targetZ = requireFiniteNumber(z2, "Shape.moveTo() z");
     const bb = this.boundingBox();
-    return this.translate(x2 - bb.min[0], y2 - bb.min[1], z2 - bb.min[2]);
+    return this.translate(targetX - bb.min[0], targetY - bb.min[1], targetZ - bb.min[2]);
   }
   /** Position the shape relative to another shape's local coordinate system (bounding box min corner). */
   moveToLocal(target, x2, y2, z2) {
+    const localX = requireFiniteNumber(x2, "Shape.moveToLocal() x");
+    const localY = requireFiniteNumber(y2, "Shape.moveToLocal() y");
+    const localZ = requireFiniteNumber(z2, "Shape.moveToLocal() z");
     const s = "toShape" in target ? target.toShape() : target;
     const tbb = s.boundingBox();
-    return this.moveTo(tbb.min[0] + x2, tbb.min[1] + y2, tbb.min[2] + z2);
+    return this.moveTo(tbb.min[0] + localX, tbb.min[1] + localY, tbb.min[2] + localZ);
   }
   /** Rotate around an arbitrary axis through the origin. */
   rotate(axis, angleDeg, options) {
@@ -42959,7 +43619,7 @@ class Shape {
   }
   /** Apply a 4x4 affine transform matrix (column-major) or a Transform object. */
   transform(m2) {
-    const mat = m2 instanceof Transform ? m2.toArray() : m2;
+    const mat = m2 instanceof Transform ? m2.toArray() : requireFiniteMat4(m2, "Shape.transform() matrix");
     const steps = rigidTransformStepsFromMatrix(mat);
     if (steps == null) {
       throw new Error(
@@ -42971,23 +43631,20 @@ class Shape {
   }
   /** Scale the shape uniformly or per-axis from the shape's bounding box center. Accepts a single number or [x, y, z] array. */
   scale(v) {
+    const scale2 = requireNonZeroFiniteScale3(v, "Shape.scale() scale");
     const bb = this.boundingBox();
     const center = [
       (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, v);
+    return this.scaleAround(center, scale2);
   }
   /** Scale the shape uniformly or per-axis from an explicit pivot point. */
   scaleAround(pivot, v) {
-    const scale2 = normalizeShapeScale(v);
-    if (!scale2) {
-      throw new Error(
-        `Shape.scaleAround() received a degenerate scale value (${JSON.stringify(v)}). All scale components must be finite and non-zero.`
-      );
-    }
-    if (pivot[0] === 0 && pivot[1] === 0 && pivot[2] === 0) {
+    const scale2 = requireNonZeroFiniteScale3(v, "Shape.scaleAround() scale");
+    const scalePivot = requireFiniteVec3$1(pivot, "Shape.scaleAround() pivot");
+    if (scalePivot[0] === 0 && scalePivot[1] === 0 && scalePivot[2] === 0) {
       const nextPlan2 = appendShapeCompileTransform(getShapeCompilePlanInternal(this), {
         kind: "scale",
         x: scale2[0],
@@ -42995,11 +43652,11 @@ class Shape {
         z: scale2[2]
       });
       return setShapeCompilePlanInternal(
-        withTransformedDimensions(this, buildShapeFromCompilePlan(nextPlan2, this.colorHex), Transform.scale(v).toArray()),
+        withTransformedDimensions(this, buildShapeFromCompilePlan(nextPlan2, this.colorHex), Transform.scale(scale2).toArray()),
         nextPlan2
       );
     }
-    const translated = this.translate(-pivot[0], -pivot[1], -pivot[2]);
+    const translated = this.translate(-scalePivot[0], -scalePivot[1], -scalePivot[2]);
     const nextPlan = appendShapeCompileTransform(getShapeCompilePlanInternal(translated), {
       kind: "scale",
       x: scale2[0],
@@ -43007,10 +43664,10 @@ class Shape {
       z: scale2[2]
     });
     const scaled = setShapeCompilePlanInternal(
-      withTransformedDimensions(translated, buildShapeFromCompilePlan(nextPlan, translated.colorHex), Transform.scale(v).toArray()),
+      withTransformedDimensions(translated, buildShapeFromCompilePlan(nextPlan, translated.colorHex), Transform.scale(scale2).toArray()),
       nextPlan
     );
-    return scaled.translate(pivot[0], pivot[1], pivot[2]);
+    return scaled.translate(scalePivot[0], scalePivot[1], scalePivot[2]);
   }
   /** Mirror across a plane through the shape's bounding box center, defined by its normal vector. */
   mirror(normal) {
@@ -43024,32 +43681,34 @@ class Shape {
   }
   /** Mirror across a plane through an explicit point, defined by its normal vector. */
   mirrorThrough(point, normal) {
-    if (point[0] === 0 && point[1] === 0 && point[2] === 0) {
+    const mirrorPoint = requireFiniteVec3$1(point, "Shape.mirrorThrough() point");
+    const mirrorNormal = requireNonZeroFiniteVec3(normal, "Shape.mirrorThrough() normal");
+    if (mirrorPoint[0] === 0 && mirrorPoint[1] === 0 && mirrorPoint[2] === 0) {
       const transformedPlan2 = appendShapeCompileTransform(getShapeCompilePlanInternal(this), {
         kind: "mirror",
-        normalX: normal[0],
-        normalY: normal[1],
-        normalZ: normal[2]
+        normalX: mirrorNormal[0],
+        normalY: mirrorNormal[1],
+        normalZ: mirrorNormal[2]
       });
       const nextPlan2 = wrapRepeatedShapeCompilePlan(transformedPlan2, "mirror");
       return setShapeCompilePlanInternal(
-        withTransformedDimensions(this, buildShapeFromCompilePlan(nextPlan2, this.colorHex), mirrorMatrix(normal)),
+        withTransformedDimensions(this, buildShapeFromCompilePlan(nextPlan2, this.colorHex), mirrorMatrix(mirrorNormal)),
         nextPlan2
       );
     }
-    const translated = this.translate(-point[0], -point[1], -point[2]);
+    const translated = this.translate(-mirrorPoint[0], -mirrorPoint[1], -mirrorPoint[2]);
     const transformedPlan = appendShapeCompileTransform(getShapeCompilePlanInternal(translated), {
       kind: "mirror",
-      normalX: normal[0],
-      normalY: normal[1],
-      normalZ: normal[2]
+      normalX: mirrorNormal[0],
+      normalY: mirrorNormal[1],
+      normalZ: mirrorNormal[2]
     });
     const nextPlan = wrapRepeatedShapeCompilePlan(transformedPlan, "mirror");
     const mirrored = setShapeCompilePlanInternal(
-      withTransformedDimensions(translated, buildShapeFromCompilePlan(nextPlan, translated.colorHex), mirrorMatrix(normal)),
+      withTransformedDimensions(translated, buildShapeFromCompilePlan(nextPlan, translated.colorHex), mirrorMatrix(mirrorNormal)),
       nextPlan
     );
-    return mirrored.translate(point[0], point[1], point[2]);
+    return mirrored.translate(mirrorPoint[0], mirrorPoint[1], mirrorPoint[2]);
   }
   /**
    * Reorient a shape so its primary axis (Z) points along the given direction.
@@ -43059,7 +43718,7 @@ class Shape {
    * Example: cylinder(40, 5).pointAlong([1, 0, 0]) — lays cylinder along X, starting at origin
    */
   pointAlong(direction) {
-    const [dx, dy, dz] = direction;
+    const [dx, dy, dz] = requireNonZeroFiniteVec3(direction, "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;
@@ -43078,18 +43737,21 @@ class Shape {
    * @internal Prefer rotate(), rotateX(), rotateY(), rotateZ() for public use.
    */
   rotateAroundAxis(axis, angleDeg, pivot = [0, 0, 0]) {
-    const len = Math.sqrt(axis[0] ** 2 + axis[1] ** 2 + axis[2] ** 2) || 1;
-    const normalizedAxis = [axis[0] / len, axis[1] / len, axis[2] / len];
-    const matrix = rotationAroundAxisMatrix(normalizedAxis, angleDeg, pivot);
+    const rotateAxis = requireNonZeroFiniteVec3(axis, "Shape.rotateAroundAxis() axis");
+    const degrees = requireFiniteNumber(angleDeg, "Shape.rotateAroundAxis() angleDeg");
+    const rotatePivot = requireFiniteVec3$1(pivot, "Shape.rotateAroundAxis() pivot");
+    const len = Math.sqrt(rotateAxis[0] ** 2 + rotateAxis[1] ** 2 + rotateAxis[2] ** 2) || 1;
+    const normalizedAxis = [rotateAxis[0] / len, rotateAxis[1] / len, rotateAxis[2] / len];
+    const matrix = rotationAroundAxisMatrix(normalizedAxis, degrees, rotatePivot);
     const nextPlan = appendShapeCompileTransform(getShapeCompilePlanInternal(this), {
       kind: "rotateAround",
       axisX: normalizedAxis[0],
       axisY: normalizedAxis[1],
       axisZ: normalizedAxis[2],
-      degrees: angleDeg,
-      pivotX: pivot[0],
-      pivotY: pivot[1],
-      pivotZ: pivot[2]
+      degrees,
+      pivotX: rotatePivot[0],
+      pivotY: rotatePivot[1],
+      pivotZ: rotatePivot[2]
     });
     return setShapeCompilePlanInternal(
       withTransformedDimensions(this, buildShapeFromCompilePlan(nextPlan, this.colorHex), matrix),
@@ -43101,10 +43763,12 @@ class Shape {
    * `movingPoint` / `targetPoint` may be raw world points or this shape's anchors/references.
    */
   rotateAroundTo(axis, pivot, movingPoint, targetPoint, options = {}) {
+    const rotateAxis = requireNonZeroFiniteVec3(axis, "Shape.rotateAroundTo() axis");
+    const rotatePivot = requireFiniteVec3$1(pivot, "Shape.rotateAroundTo() pivot");
     const moving = resolveRotationPoint(this, movingPoint);
     const target = resolveRotationPoint(this, targetPoint);
-    const angleDeg = solveRotateAroundAngle(axis, pivot, moving, target, options);
-    return this.rotateAroundAxis(axis, angleDeg, pivot);
+    const angleDeg = solveRotateAroundAngle(rotateAxis, rotatePivot, moving, target, options);
+    return this.rotateAroundAxis(rotateAxis, angleDeg, rotatePivot);
   }
   // --- Booleans ---
   /** Unwrap any object with toShape() without circular import. */
@@ -43268,17 +43932,19 @@ class Shape {
   }
   /** Split by infinite plane. Returns [positive-side, negative-side]. */
   splitByPlane(normal, originOffset = 0) {
+    const planeNormal = requireNonZeroFiniteVec3(normal, "Shape.splitByPlane() normal");
+    const planeOffset = requireFiniteNumber(originOffset, "Shape.splitByPlane() originOffset");
     const info = deriveGeometryInfo(getShapeGeometryInfoInternal(this), "boolean", {
       topology: _activeBackend === "truck" ? "kernel" : "none"
     });
     const basePlan = getShapeCompilePlanInternal(this);
     const firstPlan = createOwnedTopologyRewritePlan(
-      buildTrimByPlaneShapeCompilePlan(basePlan, normal, originOffset),
+      buildTrimByPlaneShapeCompilePlan(basePlan, planeNormal, planeOffset),
       "splitByPlane:positive",
       (owner) => buildTrimByPlaneTopologyRewritePropagation(owner, basePlan)
     );
     const secondPlan = createOwnedTopologyRewritePlan(
-      buildTrimByPlaneShapeCompilePlan(basePlan, [-normal[0], -normal[1], -normal[2]], -originOffset),
+      buildTrimByPlaneShapeCompilePlan(basePlan, [-planeNormal[0], -planeNormal[1], -planeNormal[2]], -planeOffset),
       "splitByPlane:opposite",
       (owner) => buildTrimByPlaneTopologyRewritePropagation(owner, basePlan)
     );
@@ -43296,9 +43962,11 @@ class Shape {
   }
   /** Keep the positive side of the plane and discard the opposite side. */
   trimByPlane(normal, originOffset = 0) {
+    const planeNormal = requireNonZeroFiniteVec3(normal, "Shape.trimByPlane() normal");
+    const planeOffset = requireFiniteNumber(originOffset, "Shape.trimByPlane() originOffset");
     const basePlan = getShapeCompilePlanInternal(this);
     const nextPlan = createOwnedTopologyRewritePlan(
-      buildTrimByPlaneShapeCompilePlan(basePlan, normal, originOffset),
+      buildTrimByPlaneShapeCompilePlan(basePlan, planeNormal, planeOffset),
       "trimByPlane",
       (owner) => buildTrimByPlaneTopologyRewritePropagation(owner, basePlan)
     );
@@ -43318,8 +43986,9 @@ class Shape {
    * `openFaces` names any subset of the base shape's labeled faces to leave open (no wall).
    */
   shell(thickness, opts = {}) {
+    const wallThickness = requirePositiveFiniteNumber(thickness, "Shape.shell() thickness");
     const basePlan = getShapeCompilePlanInternal(this);
-    const shellPlan = buildShellShapeCompilePlan(basePlan, thickness, opts.openFaces);
+    const shellPlan = buildShellShapeCompilePlan(basePlan, wallThickness, opts.openFaces);
     if (!shellPlan) {
       throw new Error(
         "Shape.shell() supports box(), cylinder(), straight extrude(), loft(), sweep(), and variableSweep() solids with optional face openings and rigid transforms."
@@ -43340,7 +44009,8 @@ class Shape {
   }
   /** Offset-thicken an exact open surface or shell into a solid. */
   thicken(thickness) {
-    if (!Number.isFinite(thickness) || thickness === 0) {
+    const wallThickness = requireFiniteNumber(thickness, "Shape.thicken() thickness");
+    if (wallThickness === 0) {
       throw new Error("Shape.thicken() requires a non-zero finite thickness.");
     }
     const info = getShapeGeometryInfoInternal(this);
@@ -43348,7 +44018,7 @@ class Shape {
       throw new Error("Shape.thicken() is only available on surface-representation shapes.");
     }
     const basePlan = getShapeCompilePlanInternal(this);
-    const nextPlan = buildSurfaceThickenShapeCompilePlan(basePlan, thickness);
+    const nextPlan = buildSurfaceThickenShapeCompilePlan(basePlan, wallThickness);
     const representation = info.backend === "occt" || info.backend === "truck" ? "brep-solid" : "mesh-solid";
     return setShapeCompilePlanInternal(
       setShapeGeometryInfoInternal(
@@ -43389,11 +44059,12 @@ class Shape {
   }
   /** Slice the runtime solid by a plane normal to local Z at the given offset. */
   slice(offset = 0) {
+    const planeOffset = requireFiniteNumber(offset, "Shape.slice() offset");
     if (getShapeGeometryInfoInternal(this).backend === "truck") {
-      const slicedProfile = lowerExactSlicedShapeCompilePlanToTruckProfileBackend(getShapeCompilePlanInternal(this), offset);
+      const slicedProfile = lowerExactSlicedShapeCompilePlanToTruckProfileBackend(getShapeCompilePlanInternal(this), planeOffset);
       if (slicedProfile) return slicedProfile;
     }
-    return getShapeRuntimeBackendInternal(this).slice(offset);
+    return getShapeRuntimeBackendInternal(this).slice(planeOffset);
   }
   /** Orthographically project the runtime solid onto the local XY plane. */
   project() {
@@ -43416,9 +44087,10 @@ class Shape {
     const sp = this.referencePoint(selfAnchor);
     let dx = tp[0] - sp[0], dy = tp[1] - sp[1], dz = tp[2] - sp[2];
     if (offset) {
-      dx += offset[0];
-      dy += offset[1];
-      dz += offset[2];
+      const offsetPoint = requireFiniteVec3$1(offset, "Shape.attachTo() offset");
+      dx += offsetPoint[0];
+      dy += offsetPoint[1];
+      dz += offsetPoint[2];
     }
     return this.translate(dx, dy, dz);
   }
@@ -43434,9 +44106,9 @@ class Shape {
    * - `protrude` = how far the child sticks out (positive = outward from face)
    */
   onFace(parent, face, opts = {}) {
-    const u2 = opts.u ?? 0;
-    const v = opts.v ?? 0;
-    const p2 = opts.protrude ?? 0;
+    const u2 = requireFiniteNumber(opts.u ?? 0, "Shape.onFace() u");
+    const v = requireFiniteNumber(opts.v ?? 0, "Shape.onFace() v");
+    const p2 = requireFiniteNumber(opts.protrude ?? 0, "Shape.onFace() protrude");
     const opposite = {
       front: "back",
       back: "front",
@@ -44015,6 +44687,8 @@ function sampleSweepPath(path, edgeLengthHint) {
         path,
         edgeLengthHint != null ? Math.max(16, Math.round(path.controlPoints.length * 12 / Math.max(0.1, edgeLengthHint))) : 48
       );
+    case "route3d":
+      return sweepPathToPolyline(path, resolveCurveSampleCount(edgeLengthHint, path.length));
   }
 }
 function clamp(v, lo, hi) {
@@ -45144,6 +45818,7 @@ function rotateVector(v, axis, c2, s) {
   ];
 }
 const OFFSET_SOLID_EPS = 1e-9;
+const OCCT_BACKEND_REQUIRED_HINT = "Select the OCCT backend in the editor or run the CLI with --backend occt.";
 function disposeWasmObject(value) {
   if (value != null && typeof value.delete === "function") value.delete();
 }
@@ -45628,7 +46303,7 @@ function profilePolygonLoopTopologyMatches(left, right) {
 }
 function lowerOffsetLoftCompilePlan(plan, thickness, wasm) {
   if (plan.profiles.length !== plan.heights.length || plan.profiles.length < 2) {
-    throw new Error("Offset solid requires the OCCT backend. Add setActiveBackend('occt') at the top of your script.");
+    throw new Error(`Offset solid requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
   }
   const heights = [...plan.heights];
   heights[0] -= thickness;
@@ -45639,7 +46314,7 @@ function lowerOffsetLoftCompilePlan(plan, thickness, wasm) {
   const offsetPolygons = plan.profiles.map((profile) => offsetProfilePolygonsForManifold(profile, thickness, wasm));
   const stitched = loftStitched(offsetPolygons, heights, wasm);
   if (!stitched) {
-    throw new Error("Offset solid requires the OCCT backend. Add setActiveBackend('occt') at the top of your script.");
+    throw new Error(`Offset solid requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
   }
   return stitched;
 }
@@ -45679,16 +46354,16 @@ function lowerOffsetSweepCompilePlan(plan, thickness, wasm) {
   const basePolygons = profilePolygonsForManifold(plan.profile, wasm);
   const offsetPolygons = offsetProfilePolygonsForManifold(plan.profile, thickness, wasm);
   if (!profilePolygonLoopTopologyMatches(basePolygons, offsetPolygons)) {
-    throw new Error("Offset solid requires the OCCT backend. Add setActiveBackend('occt') at the top of your script.");
+    throw new Error(`Offset solid requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
   }
   const pathPoints = sweepPathToPolylineAdaptive(plan.path, plan.pathSamples ?? 48);
   const extendedPath = extendedStraightSweepPathForManifold(pathPoints, thickness);
   if (!extendedPath) {
-    throw new Error("Offset solid requires the OCCT backend. Add setActiveBackend('occt') at the top of your script.");
+    throw new Error(`Offset solid requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
   }
   const stitched = sweepStitched(offsetPolygons, extendedPath, [plan.up[0], plan.up[1], plan.up[2]], wasm);
   if (!stitched) {
-    throw new Error("Offset solid requires the OCCT backend. Add setActiveBackend('occt') at the top of your script.");
+    throw new Error(`Offset solid requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
   }
   return stitched;
 }
@@ -45697,7 +46372,7 @@ function lowerTransformedOffsetSolidCompilePlan(plan, thickness, wasm) {
   for (const step of plan.steps) {
     const stepScale = offsetSolidTransformDistanceScaleForManifold(step);
     if (stepScale == null) {
-      throw new Error("Offset solid requires the OCCT backend. Add setActiveBackend('occt') at the top of your script.");
+      throw new Error(`Offset solid requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
     }
     distanceScale *= stepScale;
   }
@@ -45738,7 +46413,7 @@ function lowerOffsetSolidCompilePlan(plan, wasm) {
   }
   const base = verticalPrismOffsetBaseForManifold(basePlan);
   if (!base) {
-    throw new Error("Offset solid requires the OCCT backend. Add setActiveBackend('occt') at the top of your script.");
+    throw new Error(`Offset solid requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
   }
   const zMin = base.zMin - plan.thickness;
   const zMax = base.zMax + plan.thickness;
@@ -46263,6 +46938,18 @@ function matchEdgeSegmentByMidpoint(segments, target) {
   }
   return best;
 }
+function selectEdgeSegmentsForFeature(segments, plan) {
+  if (plan.edgeQuery) {
+    const selected = applyEdgeQueryFilters(segments, plan.edgeQuery);
+    return plan.edgeSelection === "first" ? selected.slice(0, 1) : selected;
+  }
+  const matched = [];
+  for (const target of plan.edgeTargets ?? []) {
+    const seg = matchEdgeSegmentByMidpoint(segments, target);
+    if (seg && seg.length >= 1e-6) matched.push(seg);
+  }
+  return matched;
+}
 function lowerFilletEdgesCompilePlan(plan, wasm) {
   let manifold = lowerShapeCompilePlanToManifold(plan.base, wasm);
   const mesh = manifold.getMesh();
@@ -46272,11 +46959,8 @@ function lowerFilletEdgesCompilePlan(plan, wasm) {
     triVerts: mesh.triVerts,
     vertProperties: mesh.vertProperties
   });
-  const matched = [];
-  for (const target of plan.edgeTargets) {
-    const seg = matchEdgeSegmentByMidpoint(segments, target);
-    if (seg && seg.length >= 1e-6) matched.push(seg);
-  }
+  const matched = selectEdgeSegmentsForFeature(segments, plan);
+  if (plan.edgeQuery && matched.length === 0) throw new Error("filletEdges(): no edges match the deferred edge query.");
   matched.sort((a2, b) => b.length - a2.length);
   for (const seg of matched) {
     try {
@@ -46299,11 +46983,8 @@ function lowerChamferEdgesCompilePlan(plan, wasm) {
     triVerts: mesh.triVerts,
     vertProperties: mesh.vertProperties
   });
-  const matched = [];
-  for (const target of plan.edgeTargets) {
-    const seg = matchEdgeSegmentByMidpoint(segments, target);
-    if (seg && seg.length >= 1e-6) matched.push(seg);
-  }
+  const matched = selectEdgeSegmentsForFeature(segments, plan);
+  if (plan.edgeQuery && matched.length === 0) throw new Error("chamferEdges(): no edges match the deferred edge query.");
   matched.sort((a2, b) => b.length - a2.length);
   for (const seg of matched) {
     try {
@@ -46405,20 +47086,20 @@ function lowerShapeCompilePlanToManifold(plan, wasm) {
     case "filletEdges":
       return lowerFilletEdgesCompilePlan(plan, wasm);
     case "cornerYBlend":
-      throw new Error("Blend.CornerY() requires the OCCT backend. Add setActiveBackend('occt') at the top of your script.");
+      throw new Error(`Blend.CornerY() requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
     case "chamferEdges":
       return lowerChamferEdgesCompilePlan(plan, wasm);
     case "draft": {
       const lowered = lowerDraftShapeCompilePlanToLoftPlan(plan);
       if (lowered) return lowerShapeCompilePlanToManifold(lowered, wasm);
-      throw new Error("Draft angle requires the OCCT backend. Add setActiveBackend('occt') at the top of your script.");
+      throw new Error(`Draft angle requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
     }
     case "offsetSolid":
       return lowerOffsetSolidCompilePlan(plan, wasm);
     case "trimByPlane":
       return lowerShapeTrimByPlaneCompilePlan(plan, wasm);
     case "importedMesh":
-      return lowerImportedMeshToManifold(plan.fileData, plan.format, plan.filePath, wasm);
+      return lowerImportedMeshToManifold(plan.fileData, plan.format, plan.filePath, wasm, plan.object);
     case "sdf": {
       const evaluator = compileSdfMaterializationEvaluator3(plan.tree);
       return lowerSdfToManifold(
@@ -46442,9 +47123,9 @@ function lowerShapeCompilePlanToManifold(plan, wasm) {
     case "surfaceExtend":
     case "surfaceThicken":
     case "surfaceSolid":
-      throw new Error("Exact surfacing operations require the OCCT backend. Add setActiveBackend('occt') at the top of your script.");
+      throw new Error(`Exact surfacing operations require the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
     case "importedStep":
-      throw new Error(`importStep("${plan.filePath}") requires the OCCT backend. Add setActiveBackend('occt') at the top of your script.`);
+      throw new Error(`importStep("${plan.filePath}") requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
     default:
       assertExhaustive(plan);
   }
@@ -46585,11 +47266,11 @@ function projectVerticesToSurfaceWithNormals(vertProperties, sdfFn, out6) {
 function lowerNurbsSurfaceToManifold(plan, wasm) {
   if (!plan.allowApproximation && plan.thickness === 0) {
     throw new Error(
-      "nurbsSurface() now defaults to an exact open sheet. The Manifold backend cannot represent exact open surfaces. Add setActiveBackend('occt') or pass { approximate: true } with a non-zero thickness if you explicitly want a sampled fallback."
+      `nurbsSurface() now defaults to an exact open sheet. The Manifold backend cannot represent exact open surfaces. ${OCCT_BACKEND_REQUIRED_HINT} Pass { approximate: true } with a non-zero thickness if you explicitly want a sampled fallback.`
     );
   }
   if (plan.thickness === 0) {
-    throw new Error("The Manifold backend cannot represent open sheet surfaces. Add setActiveBackend('occt') at the top of your script.");
+    throw new Error(`The Manifold backend cannot represent open sheet surfaces. ${OCCT_BACKEND_REQUIRED_HINT}`);
   }
   const surface = new NurbsSurface(plan.controlGrid, {
     degreeU: plan.degreeU,
@@ -46739,8 +47420,8 @@ function lowerTrimmedNurbsSurfaceToManifold(surface, plan, wasm) {
     disposeWasmObject(mesh);
   }
 }
-function lowerImportedMeshToManifold(fileData, format, filePath, wasm) {
-  const parsed = parseMeshFile(fileData, format);
+function lowerImportedMeshToManifold(fileData, format, filePath, wasm, object) {
+  const parsed = parseMeshFile(fileData, format, { object });
   if (parsed.triVerts.length === 0) {
     throw new Error(`importMesh("${filePath}"): file contains no triangles`);
   }
@@ -46762,7 +47443,11 @@ function lowerImportedMeshToManifold(fileData, format, filePath, wasm) {
   }
 }
 function lowerShapeCompilePlanToShapeBackend(plan, wasm) {
-  return lowerShapeBackendWithCache("manifold", plan, (basePlan) => wrapManifoldShapeBackend(lowerShapeCompilePlanToManifold(basePlan, wasm)));
+  return lowerShapeBackendWithCache(
+    "manifold",
+    plan,
+    (basePlan) => wrapManifoldShapeBackend(lowerShapeCompilePlanToManifold(basePlan, wasm))
+  );
 }
 const DEFAULT_LEAF_SIZE = 8;
 function cloneVec3$3(value) {
@@ -48104,6 +48789,92 @@ function percentile(sorted, q) {
   const index2 = MathUtils.clamp(Math.floor(sorted.length * q), 0, sorted.length - 1);
   return Number(sorted[index2].toFixed(2));
 }
+class DisjointSet {
+  constructor(size) {
+    __publicField(this, "parent");
+    __publicField(this, "rank");
+    this.parent = Array.from({ length: size }, (_2, index2) => index2);
+    this.rank = Array.from({ length: size }, () => 0);
+  }
+  find(index2) {
+    const parent = this.parent[index2];
+    if (parent === index2) return index2;
+    const root = this.find(parent);
+    this.parent[index2] = root;
+    return root;
+  }
+  union(a2, b) {
+    const rootA = this.find(a2);
+    const rootB = this.find(b);
+    if (rootA === rootB) return;
+    if (this.rank[rootA] < this.rank[rootB]) {
+      this.parent[rootA] = rootB;
+    } else if (this.rank[rootA] > this.rank[rootB]) {
+      this.parent[rootB] = rootA;
+    } else {
+      this.parent[rootB] = rootA;
+      this.rank[rootA] += 1;
+    }
+  }
+}
+function connectedCoplanarSurfacePatches(triangles) {
+  const snap = surfacePatchSnap(triangles);
+  const planeKeys = triangles.map((triangle) => planeKey(triangle, snap));
+  const edgeOwners = /* @__PURE__ */ new Map();
+  const sets = new DisjointSet(triangles.length);
+  triangles.forEach((triangle, index2) => {
+    for (const key of triangleEdgeKeys(triangle, snap)) {
+      const owners = edgeOwners.get(key);
+      if (owners) {
+        for (const owner of owners) {
+          if (planeKeys[owner] === planeKeys[index2]) sets.union(owner, index2);
+        }
+        owners.push(index2);
+      } else {
+        edgeOwners.set(key, [index2]);
+      }
+    }
+  });
+  const patchByRoot = /* @__PURE__ */ new Map();
+  triangles.forEach((triangle, index2) => {
+    const root = sets.find(index2);
+    const patch = patchByRoot.get(root) ?? { triangleIndexes: [], area: 0 };
+    patch.triangleIndexes.push(index2);
+    patch.area += triangle.area;
+    patchByRoot.set(root, patch);
+  });
+  return [...patchByRoot.values()];
+}
+function surfacePatchSnap(triangles) {
+  const bounds = new Box3();
+  for (const triangle of triangles) {
+    bounds.expandByPoint(triangle.a);
+    bounds.expandByPoint(triangle.b);
+    bounds.expandByPoint(triangle.c);
+  }
+  const size = bounds.getSize(new Vector3());
+  return Math.max(1e-6, size.length() * 1e-8);
+}
+function planeKey(triangle, snap) {
+  const normalSnap = 1e-6;
+  const distance = triangle.normal.dot(triangle.a);
+  return [
+    Math.round(triangle.normal.x / normalSnap),
+    Math.round(triangle.normal.y / normalSnap),
+    Math.round(triangle.normal.z / normalSnap),
+    Math.round(distance / snap)
+  ].join(",");
+}
+function triangleEdgeKeys(triangle, snap) {
+  const vertices = [vertexKey$2(triangle.a, snap), vertexKey$2(triangle.b, snap), vertexKey$2(triangle.c, snap)];
+  return [edgeKey$1(vertices[0], vertices[1]), edgeKey$1(vertices[1], vertices[2]), edgeKey$1(vertices[2], vertices[0])];
+}
+function vertexKey$2(point, snap) {
+  return `${Math.round(point.x / snap)},${Math.round(point.y / snap)},${Math.round(point.z / snap)}`;
+}
+function edgeKey$1(a2, b) {
+  return a2 < b ? `${a2}|${b}` : `${b}|${a2}`;
+}
 const MIN_TRIANGLE_AREA = 1e-12;
 const R2_ALPHA = 0.7548776662466927;
 const R2_BETA = 0.5698402909980532;
@@ -48156,7 +48927,7 @@ function allocateAreaSampleCounts(triangles, maxSamples) {
   return counts;
 }
 function sampleSurfaceTriangles(triangles, maxSamples) {
-  const counts = allocateAreaSampleCounts(triangles, maxSamples);
+  const counts = allocateSurfacePatchSampleCounts(triangles, maxSamples);
   const samples = [];
   const position = new Vector3();
   let sampleIndex = 0;
@@ -48181,6 +48952,35 @@ function sampleSurfaceTriangles(triangles, maxSamples) {
   });
   return samples;
 }
+function allocateSurfacePatchSampleCounts(triangles, maxSamples) {
+  const counts = new Array(triangles.length).fill(0);
+  if (triangles.length === 0) return counts;
+  const patches = connectedCoplanarSurfacePatches(triangles);
+  const patchCounts = allocateAreaSampleCounts(
+    patches.map((patch, index2) => {
+      var _a3, _b3, _c2, _d2;
+      return {
+        index: index2,
+        a: ((_a3 = triangles[patch.triangleIndexes[0]]) == null ? void 0 : _a3.a) ?? new Vector3(),
+        b: ((_b3 = triangles[patch.triangleIndexes[0]]) == null ? void 0 : _b3.b) ?? new Vector3(),
+        c: ((_c2 = triangles[patch.triangleIndexes[0]]) == null ? void 0 : _c2.c) ?? new Vector3(),
+        normal: ((_d2 = triangles[patch.triangleIndexes[0]]) == null ? void 0 : _d2.normal) ?? new Vector3(0, 0, 1),
+        area: patch.area
+      };
+    }),
+    maxSamples
+  );
+  patches.forEach((patch, patchIndex) => {
+    const patchBudget = patchCounts[patchIndex] ?? 0;
+    if (patchBudget <= 0) return;
+    const patchTriangles = patch.triangleIndexes.map((index2) => triangles[index2]);
+    const localCounts = allocateAreaSampleCounts(patchTriangles, patchBudget);
+    patch.triangleIndexes.forEach((triangleIndex, localIndex) => {
+      counts[triangleIndex] += localCounts[localIndex] ?? 0;
+    });
+  });
+  return counts;
+}
 function totalSurfaceArea(triangles) {
   return triangles.reduce((sum2, triangle) => sum2 + triangle.area, 0);
 }
@@ -48361,16 +49161,23 @@ const DEFAULT_THICKNESS_INSPECTION_OPTIONS = {
   minThickness: 1.2,
   warnThickness: 2,
   maxThickness: 6,
+  colorMinThickness: 0,
+  colorMaxThickness: 6,
   maxSamplesPerObject: 5e3,
   contactTolerance: DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.contactTolerance
 };
 const THICKNESS_COLORS = {
   critical: [255, 28, 28],
-  warning: [255, 150, 0],
   ok: [60, 220, 90],
   thick: [70, 145, 255],
   unknown: [90, 90, 90]
 };
+const THICKNESS_GRADIENT_COLORS = [
+  THICKNESS_COLORS.critical,
+  [255, 222, 0],
+  THICKNESS_COLORS.ok,
+  THICKNESS_COLORS.thick
+];
 function finitePositive(value, fallback, label) {
   if (value === void 0) return fallback;
   if (!Number.isFinite(value) || value <= 0) {
@@ -48389,6 +49196,16 @@ function resolveThicknessInspectionOptions(raw = {}) {
   const minThickness = finitePositive(raw.minThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.minThickness, "minThickness");
   const warnThickness = finitePositive(raw.warnThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.warnThickness, "warnThickness");
   const maxThickness = finitePositive(raw.maxThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxThickness, "maxThickness");
+  const colorMinThickness = finiteNonNegative(
+    raw.colorMinThickness,
+    DEFAULT_THICKNESS_INSPECTION_OPTIONS.colorMinThickness,
+    "colorMinThickness"
+  );
+  const colorMaxThickness = finitePositive(
+    raw.colorMaxThickness,
+    DEFAULT_THICKNESS_INSPECTION_OPTIONS.colorMaxThickness,
+    "colorMaxThickness"
+  );
   const maxSamplesPerObject = finitePositive(
     raw.maxSamplesPerObject,
     DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxSamplesPerObject,
@@ -48405,10 +49222,15 @@ function resolveThicknessInspectionOptions(raw = {}) {
   if (warnThickness > maxThickness) {
     throw new Error("warnThickness must be less than or equal to maxThickness.");
   }
+  if (colorMinThickness >= colorMaxThickness) {
+    throw new Error("colorMinThickness must be less than colorMaxThickness.");
+  }
   return {
     minThickness,
     warnThickness,
     maxThickness,
+    colorMinThickness,
+    colorMaxThickness,
     maxSamplesPerObject: Math.max(1, Math.floor(maxSamplesPerObject)),
     contactTolerance
   };
@@ -48419,6 +49241,16 @@ function lerp$1(a2, b, t) {
 function lerpColor(a2, b, t) {
   return [Math.round(lerp$1(a2[0], b[0], t)), Math.round(lerp$1(a2[1], b[1], t)), Math.round(lerp$1(a2[2], b[2], t))];
 }
+function gradientColor(stops, t) {
+  if (stops.length === 0) return THICKNESS_COLORS.unknown;
+  if (stops.length === 1) return stops[0] ?? THICKNESS_COLORS.unknown;
+  const clamped = Math.max(0, Math.min(1, t));
+  const scaled = clamped * (stops.length - 1);
+  const leftIndex = Math.min(stops.length - 2, Math.floor(scaled));
+  const left = stops[leftIndex] ?? THICKNESS_COLORS.unknown;
+  const right = stops[leftIndex + 1] ?? left;
+  return lerpColor(left, right, scaled - leftIndex);
+}
 function thicknessClass(thickness, options) {
   if (thickness == null || !Number.isFinite(thickness) || thickness <= 0) return "unknown";
   if (thickness <= options.minThickness) return "critical";
@@ -48427,18 +49259,9 @@ function thicknessClass(thickness, options) {
   return "thick";
 }
 function thicknessColor(thickness, options) {
-  const cls = thicknessClass(thickness, options);
-  if (cls === "unknown") return THICKNESS_COLORS.unknown;
-  if (cls === "critical") return THICKNESS_COLORS.critical;
-  if (cls === "warning") {
-    const span = Math.max(1e-9, options.warnThickness - options.minThickness);
-    return lerpColor(THICKNESS_COLORS.critical, THICKNESS_COLORS.warning, ((thickness ?? 0) - options.minThickness) / span);
-  }
-  if (cls === "ok") {
-    const span = Math.max(1e-9, options.maxThickness - options.warnThickness);
-    return lerpColor(THICKNESS_COLORS.ok, THICKNESS_COLORS.thick, ((thickness ?? 0) - options.warnThickness) / span);
-  }
-  return THICKNESS_COLORS.thick;
+  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);
 }
 function cloneGeometryForFaceColors(geometry) {
   return geometry.index ? geometry.toNonIndexed() : geometry.clone();
@@ -49302,7 +50125,7 @@ for (let radius = 0; radius <= MAX_SEARCH_RADIUS; radius += 1) {
 function gridKey(x2, y2, z2) {
   return `${x2},${y2},${z2}`;
 }
-function buildGeometryBounds(geometry) {
+function buildInspectHeatmapFieldBounds(geometry) {
   const position = geometry.getAttribute("position");
   if (!position || position.count === 0) return null;
   const bounds = new Box3().setFromBufferAttribute(position);
@@ -49310,7 +50133,11 @@ function buildGeometryBounds(geometry) {
   const size = bounds.getSize(new Vector3());
   const pad = Math.max(size.x, size.y, size.z, 1) * 1e-5;
   bounds.expandByScalar(pad);
-  return bounds;
+  const boundsSize = bounds.getSize(new Vector3());
+  return {
+    boundsMin: [bounds.min.x, bounds.min.y, bounds.min.z],
+    boundsSize: [boundsSize.x, boundsSize.y, boundsSize.z]
+  };
 }
 function buildSampleGrid(pointCloud) {
   const sampleCount = Math.floor(pointCloud.positions.length / 3);
@@ -49394,11 +50221,15 @@ function blendedColorAt(point, pointCloud, sampleGrid) {
   return [r / weightSum, g2 / weightSum, b / weightSum];
 }
 function buildInspectHeatmapFieldData(geometry, pointCloud) {
-  const bounds = buildGeometryBounds(geometry);
+  const bounds = buildInspectHeatmapFieldBounds(geometry);
+  return bounds ? buildInspectHeatmapFieldDataFromBounds(bounds, pointCloud) : null;
+}
+function buildInspectHeatmapFieldDataFromBounds(bounds, pointCloud) {
   const sampleGrid = buildSampleGrid(pointCloud);
   if (!bounds || !sampleGrid) return null;
   const gridSize = fieldGridSizeForSampleCount(Math.floor(pointCloud.positions.length / 3));
-  const boundsSize = bounds.getSize(new Vector3());
+  const boundsMin = new Vector3(...bounds.boundsMin);
+  const boundsSize = new Vector3(...bounds.boundsSize);
   const data = new Uint8Array(gridSize * gridSize * gridSize * 4);
   const point = new Vector3();
   let dataOffset = 0;
@@ -49406,9 +50237,9 @@ function buildInspectHeatmapFieldData(geometry, pointCloud) {
     for (let z2 = 0; z2 < gridSize; z2 += 1) {
       for (let x2 = 0; x2 < gridSize; x2 += 1) {
         point.set(
-          bounds.min.x + boundsSize.x * x2 / (gridSize - 1),
-          bounds.min.y + boundsSize.y * y2 / (gridSize - 1),
-          bounds.min.z + boundsSize.z * z2 / (gridSize - 1)
+          boundsMin.x + boundsSize.x * x2 / (gridSize - 1),
+          boundsMin.y + boundsSize.y * y2 / (gridSize - 1),
+          boundsMin.z + boundsSize.z * z2 / (gridSize - 1)
         );
         const [r, g2, b] = blendedColorAt(point, pointCloud, sampleGrid);
         data[dataOffset] = Math.max(0, Math.min(255, Math.round(r)));
@@ -49421,13 +50252,14 @@ function buildInspectHeatmapFieldData(geometry, pointCloud) {
   }
   return {
     data,
-    boundsMin: [bounds.min.x, bounds.min.y, bounds.min.z],
+    boundsMin: bounds.boundsMin,
     boundsSize: [boundsSize.x, boundsSize.y, boundsSize.z],
     gridSize
   };
 }
 const workerScope = self;
 let manifoldReadyPromise = null;
+let cachedThicknessColorizeAnalysis = null;
 function ensureManifoldReady() {
   if (!manifoldReadyPromise) manifoldReadyPromise = initKernelManifoldOnly();
   return manifoldReadyPromise;
@@ -49473,6 +50305,7 @@ function geometryFromPositions(positions) {
 function pointBuffers(samples) {
   const positions = new Float32Array(samples.length * 3);
   const colors = new Float32Array(samples.length * 3);
+  const values = new Float32Array(samples.length);
   samples.forEach((sample, index2) => {
     const base = index2 * 3;
     positions[base] = sample.position[0] + sample.normal[0] * 0.025;
@@ -49481,8 +50314,9 @@ function pointBuffers(samples) {
     colors[base] = sample.color[0] / 255;
     colors[base + 1] = sample.color[1] / 255;
     colors[base + 2] = sample.color[2] / 255;
+    values[index2] = sample.value ?? Number.NaN;
   });
-  return { positions, colors };
+  return { positions, colors, values };
 }
 function rgbFloatsForHex(hex) {
   const color = new Color(hex);
@@ -49507,6 +50341,7 @@ function analyzeScalarChannel(request) {
   const pointObjects = [];
   const heatmapFieldObjects = [];
   const warnings = [];
+  const thicknessCacheObjects = [];
   for (const object of request.objects) {
     if (!object.positions || object.positions.length < 9) continue;
     const geometry = geometryFromPositions(object.positions);
@@ -49514,13 +50349,22 @@ function analyzeScalarChannel(request) {
       const analysis = request.channel === "thickness" ? analyzeThicknessGeometry(geometry, request.thickness) : analyzeRoughnessGeometry(geometry, request.roughness);
       analysis.warnings.forEach((warning) => warnings.push(`${object.name}: ${warning}`));
       const buffers = pointBuffers(analysis.pointSamples);
-      const field = buildInspectHeatmapFieldData(analysis.geometry, buffers);
+      const heatmapBounds = buildInspectHeatmapFieldBounds(analysis.geometry);
+      const field = heatmapBounds ? buildInspectHeatmapFieldDataFromBounds(heatmapBounds, buffers) : buildInspectHeatmapFieldData(analysis.geometry, buffers);
       if (field) {
         heatmapFieldObjects.push({
           objectId: object.id,
           ...field
         });
       }
+      if (request.channel === "thickness" && buffers.values) {
+        thicknessCacheObjects.push({
+          objectId: object.id,
+          positions: new Float32Array(buffers.positions),
+          values: new Float32Array(buffers.values),
+          heatmapBounds
+        });
+      }
       pointObjects.push({
         objectId: object.id,
         sampleCount: analysis.pointSamples.length,
@@ -49531,7 +50375,9 @@ function analyzeScalarChannel(request) {
       geometry.dispose();
     }
   }
+  cachedThicknessColorizeAnalysis = request.channel === "thickness" ? { analysisId: request.reqId, objects: thicknessCacheObjects } : null;
   return {
+    analysisId: request.reqId,
     channel: request.channel,
     objectColors: {},
     pointObjects,
@@ -49541,6 +50387,47 @@ function analyzeScalarChannel(request) {
     warnings
   };
 }
+function thicknessColorsForValues(values, colorMinThickness, colorMaxThickness) {
+  const options = resolveThicknessInspectionOptions({ colorMinThickness, colorMaxThickness });
+  const colors = new Float32Array(values.length * 3);
+  for (let index2 = 0; index2 < values.length; index2 += 1) {
+    const color = thicknessColor(values[index2], options);
+    const offset = index2 * 3;
+    colors[offset] = color[0] / 255;
+    colors[offset + 1] = color[1] / 255;
+    colors[offset + 2] = color[2] / 255;
+  }
+  return colors;
+}
+function colorizeThicknessAnalysis(request) {
+  const cached = cachedThicknessColorizeAnalysis;
+  if (!cached || cached.analysisId !== request.analysisId) {
+    throw new Error("Thickness colorize cache is no longer available.");
+  }
+  const pointObjects = [];
+  const heatmapFieldObjects = [];
+  for (const object of cached.objects) {
+    const colors = thicknessColorsForValues(object.values, request.colorMinThickness, request.colorMaxThickness);
+    pointObjects.push({ objectId: object.objectId, colors });
+    if (object.heatmapBounds) {
+      const field = buildInspectHeatmapFieldDataFromBounds(object.heatmapBounds, {
+        positions: object.positions,
+        colors
+      });
+      if (field) {
+        heatmapFieldObjects.push({
+          objectId: object.objectId,
+          ...field
+        });
+      }
+    }
+  }
+  return {
+    analysisId: cached.analysisId,
+    pointObjects,
+    heatmapFieldObjects
+  };
+}
 function analyzeConnectivityChannel(request) {
   const bodyInput = buildMeshBodyConnectivityInput(
     request.objects.map((object) => ({
@@ -49707,7 +50594,11 @@ function analyzeCollisionChannel(request) {
 }
 function transferFor(result) {
   return [
-    ...result.pointObjects.flatMap((object) => [object.positions.buffer, object.colors.buffer]),
+    ...result.pointObjects.flatMap((object) => [
+      object.positions.buffer,
+      object.colors.buffer,
+      ...object.values ? [object.values.buffer] : []
+    ]),
     ...result.meshColorObjects.map((object) => object.colors.buffer),
     ...result.heatmapFieldObjects.map((object) => object.data.buffer),
     ...result.collisionGeometryObjects.flatMap((object) => [object.positions.buffer, object.normals.buffer, object.edgePositions.buffer])
@@ -49715,6 +50606,21 @@ function transferFor(result) {
 }
 async function handleRequest(request) {
   try {
+    if (request.type === "colorize-thickness") {
+      const result2 = colorizeThicknessAnalysis(request.payload);
+      const response2 = {
+        type: "inspect-colorize-success",
+        payload: {
+          reqId: request.payload.reqId,
+          result: result2
+        }
+      };
+      workerScope.postMessage(response2, [
+        ...result2.pointObjects.map((object) => object.colors.buffer),
+        ...result2.heatmapFieldObjects.map((object) => object.data.buffer)
+      ]);
+      return;
+    }
     if (request.payload.channel === "collisions") await ensureManifoldReady();
     const result = request.payload.channel === "thickness" || request.payload.channel === "roughness" ? analyzeScalarChannel(request.payload) : request.payload.channel === "collisions" ? analyzeCollisionChannel(request.payload) : analyzeConnectivityChannel(request.payload);
     const response = {