forgecad 0.9.15 → 0.10.0

package/dist/assets/{inspectWorker-COyp8XXA.js → inspectWorker-CZsCFtQT.js}

@@ -11609,6 +11609,8 @@ function cloneSdfNode(node) {
       return { kind: "sdf:circularArray", child: cloneSdfNode(node.child), count: node.count, offset: node.offset };
     case "sdf:shell":
       return { kind: "sdf:shell", child: cloneSdfNode(node.child), thickness: node.thickness };
+    case "sdf:offset":
+      return { kind: "sdf:offset", child: cloneSdfNode(node.child), distance: node.distance };
     case "sdf:displace":
       return {
         kind: "sdf:displace",
@@ -11693,7 +11695,7 @@ function cloneSdfNode(node) {
   }
 }
 const SHEET_METAL_EDGES = ["top", "right", "bottom", "left"];
-const EPS$4 = 1e-9;
+const EPS$3 = 1e-9;
 function isFinitePositive$1(value) {
   return Number.isFinite(value) && value > 0;
 }
@@ -11734,7 +11736,7 @@ function edgeDisplayName(edge) {
   return `sheetMetal().flange("${edge}", ...)`;
 }
 function normalizeAngle(angleDeg) {
-  return Math.abs(angleDeg) <= EPS$4 ? 0 : angleDeg;
+  return Math.abs(angleDeg) <= EPS$3 ? 0 : angleDeg;
 }
 function validateSheetMetalModel(model) {
   if (!isFinitePositive$1(model.panel.width) || !isFinitePositive$1(model.panel.height)) {
@@ -11746,7 +11748,7 @@ function validateSheetMetalModel(model) {
   if (!isFiniteNonNegative(model.bendRadius)) {
     return "sheetMetal() requires a finite non-negative bendRadius.";
   }
-  if (model.bendRadius <= EPS$4) {
+  if (model.bendRadius <= EPS$3) {
     return "sheetMetal() v1 requires a positive bendRadius so the bend region stays explicit instead of collapsing into a sharp fold.";
   }
   if (model.bendAllowance.kind !== "k-factor") {
@@ -11808,7 +11810,7 @@ function deriveSheetMetalModel(model) {
     const trimEnd = flanges.has(adjacent.end) ? model.cornerRelief.size : 0;
     const fullLength = edge === "top" || edge === "bottom" ? model.panel.width : model.panel.height;
     const span = fullLength - trimStart - trimEnd;
-    if (!(span > EPS$4)) {
+    if (!(span > EPS$3)) {
       throw new Error(
         `${edgeDisplayName(edge)} loses all usable span after applying the defended rectangular corner relief size ${model.cornerRelief.size}.`
       );
@@ -11854,7 +11856,7 @@ function transformPlacement(origin, u2, v, normal) {
   };
 }
 function translatePlan(plan, x2, y2, z2) {
-  if (Math.abs(x2) <= EPS$4 && Math.abs(y2) <= EPS$4 && Math.abs(z2) <= EPS$4) return cloneShapeCompilePlan(plan);
+  if (Math.abs(x2) <= EPS$3 && Math.abs(y2) <= EPS$3 && Math.abs(z2) <= EPS$3) return cloneShapeCompilePlan(plan);
   return appendShapeCompileTransform(cloneShapeCompilePlan(plan), {
     kind: "translate",
     x: x2,
@@ -12347,7 +12349,7 @@ function requireNonZeroFiniteScale3(value, label) {
   }
   return scale2;
 }
-const EPS$3 = 1e-10;
+const EPS$2 = 1e-10;
 function subVec3(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
@@ -12373,7 +12375,7 @@ function projectRadial(v, axis) {
 function signedAngleAroundAxis(from, to, axis) {
   const fromLen = lengthVec3$1(from);
   const toLen = lengthVec3$1(to);
-  if (fromLen < EPS$3 || toLen < EPS$3) return 0;
+  if (fromLen < EPS$2 || toLen < EPS$2) return 0;
   const fn = scaleVec3(from, 1 / fromLen);
   const tn = scaleVec3(to, 1 / toLen);
   const sin2 = dotVec3$4(axis, crossVec3$2(fn, tn));
@@ -12394,19 +12396,19 @@ function solveRotateAroundAngle(axis, pivot, movingPoint, targetPoint, options =
   const targetDecomp = projectRadial(target, unitAxis);
   const movingRadialLen = lengthVec3$1(movingDecomp.radial);
   const targetRadialLen = lengthVec3$1(targetDecomp.radial);
-  if (movingRadialLen < EPS$3) {
-    if (mode === "line" && targetRadialLen >= EPS$3) {
+  if (movingRadialLen < EPS$2) {
+    if (mode === "line" && targetRadialLen >= EPS$2) {
       throw new Error("rotateAroundTo(...): moving point lies on the rotation axis, so line alignment is impossible");
     }
     return 0;
   }
   if (mode === "plane") {
-    if (targetRadialLen < EPS$3) {
+    if (targetRadialLen < EPS$2) {
       throw new Error("rotateAroundTo(...): target point lies on the rotation axis, so the target plane is undefined");
     }
     return signedAngleAroundAxis(movingDecomp.radial, targetDecomp.radial, unitAxis);
   }
-  if (targetRadialLen < EPS$3) {
+  if (targetRadialLen < EPS$2) {
     throw new Error("rotateAroundTo(...): target line lies on the rotation axis, but the moving point does not");
   }
   const axialTol = 1e-8 * Math.max(1, Math.abs(movingDecomp.axial), Math.abs(targetDecomp.axial));
@@ -12443,7 +12445,7 @@ function multiplyMat4(a2, b) {
 }
 function normalizeVec3$3(v) {
   const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-  if (len < EPS$3) throw new Error("Axis must be non-zero");
+  if (len < EPS$2) throw new Error("Axis must be non-zero");
   return [v[0] / len, v[1] / len, v[2] / len];
 }
 function transformPoint$1(m2, p2, w2) {
@@ -12473,7 +12475,7 @@ function invertMat4(m2) {
   const b10 = a21 * a33 - a23 * a31;
   const b11 = a22 * a33 - a23 * a32;
   const det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-  if (Math.abs(det) < EPS$3) throw new Error("Transform matrix is not invertible");
+  if (Math.abs(det) < EPS$2) throw new Error("Transform matrix is not invertible");
   const invDet = 1 / det;
   out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet;
   out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * invDet;
@@ -12506,6 +12508,32 @@ class Transform {
   static from(input) {
     return input instanceof Transform ? input : new Transform(requireFiniteMat4(input, "Transform.from() matrix"));
   }
+  /**
+   * Compose transforms in chain order: `Transform.compose(a, b, c)` applies
+   * `a`, then `b`, then `c` — the same left-to-right order as
+   * `Transform.from(a).mul(b).mul(c)`.
+   *
+   * Prefer this over manual `.mul()` chains when composing 3+ transforms
+   * (e.g. kinematics: `local -> childBase -> jointMotion -> jointFrame ->
+   * parentWorld`); the variadic form makes the application order explicit and
+   * prevents order mistakes.
+   *
+   * **Example**
+   *
+   * ```ts
+   * const world = Transform.compose(childBase, jointMotion, jointFrame, parentWorld);
+   * ```
+   *
+   * @param steps Transforms (or raw 4x4 matrices) applied left to right.
+   * @returns The composed transform. With no arguments, the identity.
+   */
+  static compose(...steps) {
+    let acc = Transform.identity();
+    for (const step of steps) {
+      acc = acc.mul(step);
+    }
+    return acc;
+  }
   /** Create a translation transform. */
   static translation(x2, y2, z2) {
     return new Transform([
@@ -12589,6 +12617,7 @@ class Transform {
     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));
   }
@@ -13340,6 +13369,8 @@ function cloneShapeCompilePlan(plan) {
         heights: plan.heights.map((height) => height),
         edgeLength: plan.edgeLength,
         boundsPadding: plan.boundsPadding,
+        ...plan.forceField ? { forceField: true } : {},
+        ...plan.meshing ? { meshing: cloneSdfCompileMeshingSettings(plan.meshing) } : {},
         edgeLabels: plan.edgeLabels ? { ...plan.edgeLabels } : void 0,
         capLabels: plan.capLabels ? { ...plan.capLabels } : void 0
       };
@@ -13607,7 +13638,6 @@ function cloneShapeCompilePlan(plan) {
     default:
       assertExhaustive(plan);
   }
-  if (plan._occtCache) result._occtCache = plan._occtCache;
   return result;
 }
 function appendProfileCompileTransform(plan, step) {
@@ -13620,22 +13650,31 @@ function appendShapeCompileTransform(plan, step) {
   if (plan.kind === "transform") {
     return {
       kind: "transform",
-      base: cloneShapeCompilePlan(plan.base),
-      steps: [...plan.steps.map(cloneShapeTransform), cloneShapeTransform(step)]
+      base: plan.base,
+      steps: [...plan.steps, cloneShapeTransform(step)]
     };
   }
   return {
     kind: "transform",
-    base: cloneShapeCompilePlan(plan),
+    base: plan,
     steps: [cloneShapeTransform(step)]
   };
 }
 function appendShapeCompileTransforms(plan, steps) {
-  let out = cloneShapeCompilePlan(plan);
-  for (const step of steps) {
-    out = appendShapeCompileTransform(out, step);
+  if (!plan) return null;
+  if (steps.length === 0) return plan;
+  if (plan.kind === "transform") {
+    return {
+      kind: "transform",
+      base: plan.base,
+      steps: [...plan.steps, ...steps.map(cloneShapeTransform)]
+    };
   }
-  return out;
+  return {
+    kind: "transform",
+    base: plan,
+    steps: steps.map(cloneShapeTransform)
+  };
 }
 function wrapShapeCompilePlanWithQueryOwner(plan, owner) {
   if (!plan) return null;
@@ -13709,6 +13748,8 @@ function buildLoftShapeCompilePlan(profiles, heights, options) {
     heights: heights.map((height) => canonicalNumber(height)),
     edgeLength: canonicalNumber(options.edgeLength),
     boundsPadding: canonicalNumber(options.boundsPadding),
+    ...options.forceField ? { forceField: true } : {},
+    ...options.meshing ? { meshing: cloneSdfCompileMeshingSettings(options.meshing) } : {},
     edgeLabels: options.edgeLabels ? { ...options.edgeLabels } : void 0
   };
 }
@@ -13810,14 +13851,14 @@ function sub$2(a2, b) {
 function dot$3(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function cross$4(a2, b) {
+function cross$3(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
 function 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 term2 = scale$2(cross$3(axis, v), s);
   const term3 = scale$2(axis, dot$3(axis, v) * (1 - c2));
   return add$2(add$2(term1, term2), term3);
 }
@@ -14093,13 +14134,13 @@ function sweepPathToPolylineAdaptive(path, baseSamples = 48) {
   pts.push(evalPathAt(path, 1));
   return pts;
 }
-const EPS$2 = 1e-8;
+const EPS$1 = 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$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");
+  if (len <= EPS$1) throw new Error("Edge feature selection requires a non-zero direction vector");
   return [v[0] / len, v[1] / len, v[2] / len];
 }
 function subtract(a2, b) {
@@ -14178,7 +14219,7 @@ function rigidTransformForEdgeStep(step) {
     case "mirror": {
       const [nx0, ny0, nz0] = [step.normalX, step.normalY, step.normalZ];
       const len = Math.hypot(nx0, ny0, nz0);
-      if (len <= EPS$2) return Transform.identity();
+      if (len <= EPS$1) return Transform.identity();
       const nx = nx0 / len;
       const ny = ny0 / len;
       const nz = nz0 / len;
@@ -14475,7 +14516,7 @@ function isRectangleProfile(points) {
     return [next[0] - point[0], next[1] - point[1]];
   });
   const lengths = vectors.map(([x2, y2]) => Math.hypot(x2, y2));
-  if (lengths.some((length4) => length4 <= EPS$2)) return false;
+  if (lengths.some((length4) => length4 <= EPS$1)) return false;
   const dot01 = vectors[0][0] * vectors[1][0] + vectors[0][1] * vectors[1][1];
   const dot12 = vectors[1][0] * vectors[2][0] + vectors[1][1] * vectors[2][1];
   const dot23 = vectors[2][0] * vectors[3][0] + vectors[2][1] * vectors[3][1];
@@ -16414,7 +16455,9 @@ function lowerLoftShellToConcretePlan(plan, thickness, openFaces) {
     profiles: innerProfiles,
     heights: innerHeights,
     edgeLength: plan.edgeLength,
-    boundsPadding: plan.boundsPadding
+    boundsPadding: plan.boundsPadding,
+    ...plan.forceField ? { forceField: true } : {},
+    ...plan.meshing ? { meshing: { ...plan.meshing } } : {}
   };
   return { ok: true, plan: buildBooleanShapeCompilePlan("difference", [plan, inner]) };
 }
@@ -16552,6 +16595,197 @@ function lowerShellShapeCompilePlanToConcretePlan(plan) {
   }
   return lowerBaseShellPlanToConcretePlan(plan.base, plan.thickness, normalizeShellOpenFaces(plan.openFaces));
 }
+function cyrb53(str, seed) {
+  let h1 = 3735928559 ^ seed;
+  let h2 = 1103547991 ^ seed;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+  h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+  h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+}
+function hash128(str) {
+  return cyrb53(str, 2654435769).toString(36) + cyrb53(str, 2246822507).toString(36);
+}
+function isPlainValue(value) {
+  return value === null || typeof value === "number" || typeof value === "boolean" || typeof value === "string";
+}
+function createStructuralHasher(normalize2) {
+  const memo = /* @__PURE__ */ new WeakMap();
+  const skipKey = normalize2 == null ? void 0 : normalize2.skipKey;
+  const unwrap = normalize2 == null ? void 0 : normalize2.unwrap;
+  const entriesSource = normalize2 == null ? void 0 : normalize2.entriesSource;
+  return function hashValue(root) {
+    if (isPlainValue(root)) return JSON.stringify(root);
+    if (root === void 0 || typeof root === "function" || typeof root === "symbol") return "null";
+    const inProgress = /* @__PURE__ */ new Set();
+    const stack = [];
+    const attach = (frame, key, token) => {
+      if (frame.isArray) frame.parts.push(token);
+      else frame.parts.push(`${JSON.stringify(key)}:${token}`);
+    };
+    const open = (objIn, key) => {
+      const aliases = [];
+      let current = objIn;
+      while (current !== null && typeof current === "object" && !Array.isArray(current) && unwrap) {
+        const cached2 = memo.get(current);
+        if (cached2 !== void 0) {
+          for (const alias of aliases) memo.set(alias, cached2);
+          return cached2;
+        }
+        const replaced = unwrap(current);
+        if (replaced === void 0 || replaced === current) break;
+        aliases.push(current);
+        if (aliases.includes(replaced)) {
+          throw new Error("planHash: cycle detected through unwrap chain");
+        }
+        current = replaced;
+      }
+      if (isPlainValue(current)) {
+        const token = JSON.stringify(current);
+        for (const alias of aliases) memo.set(alias, token);
+        return token;
+      }
+      if (current === void 0 || typeof current === "function" || typeof current === "symbol") {
+        for (const alias of aliases) memo.set(alias, "null");
+        return "null";
+      }
+      const obj = current;
+      const cached = memo.get(obj);
+      if (cached !== void 0) {
+        for (const alias of aliases) memo.set(alias, cached);
+        return cached;
+      }
+      if (inProgress.has(obj)) {
+        throw new Error(`planHash: cycle detected in plan data (kind=${String(obj.kind)})`);
+      }
+      inProgress.add(obj);
+      aliases.push(obj);
+      let entriesNode = obj;
+      if (!Array.isArray(obj) && entriesSource) {
+        const substitute = entriesSource(obj);
+        if (substitute) entriesNode = substitute;
+      }
+      let pending;
+      if (Array.isArray(entriesNode)) {
+        pending = entriesNode.map((value) => ({ value })).reverse();
+      } else {
+        const entries = Object.entries(entriesNode).sort(([left], [right]) => left.localeCompare(right));
+        pending = [];
+        for (let i = entries.length - 1; i >= 0; i--) {
+          const [entryKey, value] = entries[i];
+          if (skipKey == null ? void 0 : skipKey(entryKey)) continue;
+          pending.push({ value, key: entryKey });
+        }
+      }
+      stack.push({ pending, parts: [], isArray: Array.isArray(entriesNode), aliases, key });
+      return null;
+    };
+    const rootToken = open(root, void 0);
+    if (rootToken !== null) return rootToken;
+    let result = "null";
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      const next = frame.pending.pop();
+      if (next) {
+        if (isPlainValue(next.value)) {
+          attach(frame, next.key, JSON.stringify(next.value));
+          continue;
+        }
+        if (next.value === void 0 || typeof next.value === "function" || typeof next.value === "symbol") {
+          if (frame.isArray) frame.parts.push("null");
+          continue;
+        }
+        const token2 = open(next.value, next.key);
+        if (token2 !== null) attach(frame, next.key, token2);
+        continue;
+      }
+      const canonical = frame.isArray ? `[${frame.parts.join(",")}]` : `{${frame.parts.join(",")}}`;
+      const token = "#" + hash128(canonical);
+      for (const alias of frame.aliases) {
+        memo.set(alias, token);
+        inProgress.delete(alias);
+      }
+      stack.pop();
+      if (stack.length === 0) result = token;
+      else attach(stack[stack.length - 1], frame.key, token);
+    }
+    return result;
+  };
+}
+const PLAN_BOOKKEEPING_KEY = (key) => key.startsWith("_") || key === "owner" || key === "queryPropagation";
+const encodedLengthMemo = /* @__PURE__ */ new WeakMap();
+function estimatePlanEncodedLength(value) {
+  if (value === void 0 || typeof value === "function" || typeof value === "symbol") return 4;
+  if (value === null || typeof value === "boolean") return 5;
+  if (typeof value === "number") return 8;
+  if (typeof value === "string") return value.length + 2;
+  const root = value;
+  const known = encodedLengthMemo.get(root);
+  if (known !== void 0) return known;
+  const childValues = (node) => {
+    if (Array.isArray(node)) return node;
+    const values = [];
+    for (const [key, item] of Object.entries(node)) {
+      if (PLAN_BOOKKEEPING_KEY(key)) continue;
+      values.push(item);
+    }
+    return values;
+  };
+  const order = [];
+  const seen = /* @__PURE__ */ new Set();
+  const discover = [root];
+  while (discover.length > 0) {
+    const node = discover.pop();
+    if (seen.has(node) || encodedLengthMemo.has(node)) continue;
+    seen.add(node);
+    order.push(node);
+    for (const child of childValues(node)) {
+      if (child !== null && typeof child === "object") discover.push(child);
+    }
+  }
+  for (let i = order.length - 1; i >= 0; i--) {
+    const node = order[i];
+    let total = 2;
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        total += 1 + (item !== null && typeof item === "object" ? encodedLengthMemo.get(item) : estimatePlanEncodedLength(item));
+      }
+    } else {
+      for (const [key, item] of Object.entries(node)) {
+        if (PLAN_BOOKKEEPING_KEY(key)) continue;
+        total += key.length + 4 + (item !== null && typeof item === "object" ? encodedLengthMemo.get(item) : estimatePlanEncodedLength(item));
+      }
+    }
+    encodedLengthMemo.set(node, total);
+  }
+  return encodedLengthMemo.get(root);
+}
+function deepFreezePlanData(value) {
+  if (value === null || typeof value !== "object") return value;
+  const stack = [value];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (Object.isFrozen(node)) continue;
+    Object.freeze(node);
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        if (item !== null && typeof item === "object") stack.push(item);
+      }
+      continue;
+    }
+    for (const [key, item] of Object.entries(node)) {
+      if (PLAN_BOOKKEEPING_KEY(key)) continue;
+      if (item !== null && typeof item === "object") stack.push(item);
+    }
+  }
+  return value;
+}
 const SHAPE_BACKEND_MARKER = Symbol.for("forgecad.shapeBackend");
 function isShapeBackend(value) {
   return Boolean(value && typeof value === "object" && value[SHAPE_BACKEND_MARKER] === true);
@@ -16605,60 +16839,26 @@ function recordEvent(event) {
   runEvents.push(next);
   if (runEvents.length > MAX_RECORDED_EVENTS) runEvents = runEvents.slice(-MAX_RECORDED_EVENTS);
 }
-function stableGeometryEncode(value, arrayMember) {
-  if (value === void 0 || typeof value === "function" || typeof value === "symbol") {
-    return arrayMember ? "null" : void 0;
-  }
-  if (value === null || typeof value === "number" || typeof value === "boolean" || typeof value === "string") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableGeometryEncode(item, true) ?? "null").join(",")}]`;
-  }
-  const record = value;
-  if (record.kind === "queryOwner" && record.base) {
-    return stableGeometryEncode(record.base, arrayMember);
-  }
-  const entries = Object.entries(record).sort(([left], [right]) => left.localeCompare(right));
-  const encodedEntries = [];
-  for (const [key, item] of entries) {
-    if (key.startsWith("_") || key === "owner" || key === "queryPropagation") continue;
-    const encoded = stableGeometryEncode(item, false);
-    if (encoded !== void 0) encodedEntries.push(`${JSON.stringify(key)}:${encoded}`);
-  }
-  return `{${encodedEntries.join(",")}}`;
-}
-function stableCacheOpportunityEncode(value, arrayMember) {
-  if (value === void 0 || typeof value === "function" || typeof value === "symbol") {
-    return arrayMember ? "null" : void 0;
-  }
-  if (value === null || typeof value === "number" || typeof value === "boolean" || typeof value === "string") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableCacheOpportunityEncode(item, true) ?? "null").join(",")}]`;
-  }
-  const record = value;
-  if (record.kind === "queryOwner" && record.base) {
-    return stableCacheOpportunityEncode(record.base, arrayMember);
-  }
-  let encodedRecord = record;
-  if (record.kind === "transform" && record.base) {
-    const retainedSteps = Array.isArray(record.steps) ? record.steps.filter((step) => step.kind === "scale") : [];
-    if (retainedSteps.length === 0) return stableCacheOpportunityEncode(record.base, arrayMember);
-    encodedRecord = { kind: "transform", base: record.base, steps: retainedSteps };
-  }
-  const entries = Object.entries(encodedRecord).sort(([left], [right]) => left.localeCompare(right));
-  const encodedEntries = [];
-  for (const [key, item] of entries) {
-    if (key.startsWith("_") || key === "owner" || key === "queryPropagation") continue;
-    const encoded = stableCacheOpportunityEncode(item, false);
-    if (encoded !== void 0) encodedEntries.push(`${JSON.stringify(key)}:${encoded}`);
+const skipBookkeepingKey = (key) => key.startsWith("_") || key === "owner" || key === "queryPropagation";
+const geometryPlanHasher = createStructuralHasher({
+  skipKey: skipBookkeepingKey,
+  unwrap: (record) => record.kind === "queryOwner" && record.base ? record.base : void 0
+});
+const scaleOnlySteps = (record) => Array.isArray(record.steps) ? record.steps.filter((step) => step.kind === "scale") : [];
+createStructuralHasher({
+  skipKey: skipBookkeepingKey,
+  unwrap: (record) => {
+    if (record.kind === "queryOwner" && record.base) return record.base;
+    if (record.kind === "transform" && record.base && scaleOnlySteps(record).length === 0) return record.base;
+    return void 0;
+  },
+  entriesSource: (record) => {
+    if (record.kind !== "transform" || !record.base) return void 0;
+    return { kind: "transform", base: record.base, steps: scaleOnlySteps(record) };
   }
-  return `{${encodedEntries.join(",")}}`;
-}
+});
 function shapeGeometryCacheKey(plan) {
-  return `${SHAPE_GEOMETRY_CACHE_KEY_VERSION}:${stableGeometryEncode(plan, false) ?? "null"}`;
+  return `${SHAPE_GEOMETRY_CACHE_KEY_VERSION}:${geometryPlanHasher(plan)}`;
 }
 function planComplexityScore(value) {
   if (!value || typeof value !== "object") return 0;
@@ -16717,8 +16917,7 @@ function planComplexityScore(value) {
   }
 }
 function estimateCacheRetainedMb(plan) {
-  var _a3;
-  const encodedLength = ((_a3 = stableCacheOpportunityEncode(plan, false)) == null ? void 0 : _a3.length) ?? 0;
+  const encodedLength = estimatePlanEncodedLength(plan);
   const serializedComplexityMb = encodedLength / 24e3;
   return round2(0.08 + planComplexityScore(plan) * 0.09 + serializedComplexityMb);
 }
@@ -16736,26 +16935,62 @@ function splitCacheablePlacement(plan) {
   }
   return { basePlan: plan, placementSteps: [] };
 }
+const uncacheableReasonMemo = /* @__PURE__ */ new WeakMap();
 function findUncacheableReason(value) {
   if (value === void 0 || value === null) return null;
   if (typeof value === "function" || typeof value === "symbol") return "plan contains runtime-only values";
   if (typeof value !== "object") return null;
-  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return "plan contains binary file data";
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      const reason = findUncacheableReason(item);
-      if (reason) return reason;
+  const root = value;
+  const known = uncacheableReasonMemo.get(root);
+  if (known !== void 0) return known;
+  const order = [];
+  const seen = /* @__PURE__ */ new Set();
+  const discover = [root];
+  let reason = null;
+  while (discover.length > 0 && reason === null) {
+    const node = discover.pop();
+    if (seen.has(node)) continue;
+    const cached = uncacheableReasonMemo.get(node);
+    if (cached !== void 0) {
+      if (cached !== null) reason = cached;
+      continue;
+    }
+    seen.add(node);
+    if (ArrayBuffer.isView(node) || node instanceof ArrayBuffer) {
+      reason = "plan contains binary file data";
+      break;
+    }
+    order.push(node);
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        if (typeof item === "function" || typeof item === "symbol") {
+          reason = "plan contains runtime-only values";
+          break;
+        }
+        if (item !== null && typeof item === "object") discover.push(item);
+      }
+      continue;
+    }
+    const record = node;
+    if (record.kind === "importedMesh" || record.kind === "importedStep") {
+      reason = "plan depends on imported file contents";
+      break;
+    }
+    for (const [key, item] of Object.entries(record)) {
+      if (skipBookkeepingKey(key)) continue;
+      if (typeof item === "function" || typeof item === "symbol") {
+        reason = "plan contains runtime-only values";
+        break;
+      }
+      if (item !== null && typeof item === "object") discover.push(item);
     }
-    return null;
   }
-  const record = value;
-  if (record.kind === "importedMesh" || record.kind === "importedStep") return "plan depends on imported file contents";
-  for (const [key, item] of Object.entries(record)) {
-    if (key.startsWith("_")) continue;
-    const reason = findUncacheableReason(item);
-    if (reason) return reason;
+  if (reason === null) {
+    for (const node of order) uncacheableReasonMemo.set(node, null);
+  } else {
+    uncacheableReasonMemo.set(root, reason);
   }
-  return null;
+  return reason;
 }
 function applyPlacementStep(backend, step) {
   switch (step.kind) {
@@ -17432,8 +17667,9 @@ function analyzeNodeUV(node, toLocal) {
       if (result.majorRadius !== void 0) result.majorRadius *= node.factor;
       return result;
     }
-    // ── Shell — UV comes from the inner shape ──
+    // ── Shell / offset — UV comes from the inner shape ──
     case "sdf:shell":
+    case "sdf:offset":
       return analyzeNodeUV(node.child, toLocal);
     // ── CSG — take UV from the first (primary) child ──
     case "sdf:union":
@@ -17969,6 +18205,11 @@ function compileSdfNode3(node) {
       const t = node.thickness * 0.5;
       return (x2, y2, z2) => abs(fn(x2, y2, z2)) - t;
     }
+    case "sdf:offset": {
+      const fn = compileSdfNode3(node.child);
+      const d2 = node.distance;
+      return (x2, y2, z2) => fn(x2, y2, z2) - d2;
+    }
     case "sdf:displace": {
       const fn = compileSdfNode3(node.child);
       const constEntries = Object.entries(node.constants ?? {});
@@ -18462,6 +18703,10 @@ function emitSdfProgramNode(b, node, x2, y2, z2) {
       const child = emitSdfProgramNode(b, node.child, x2, y2, z2);
       return b.sub(b.abs(child), b.constant(node.thickness * 0.5));
     }
+    case "sdf:offset": {
+      const child = emitSdfProgramNode(b, node.child, x2, y2, z2);
+      return b.sub(child, b.constant(node.distance));
+    }
     case "sdf:onion": {
       let d2 = emitSdfProgramNode(b, node.child, x2, y2, z2);
       for (let i = 0; i < node.layers; i++) d2 = b.sub(b.abs(d2), b.constant(node.thickness));
@@ -18610,6 +18855,7 @@ function getUnsupportedSdfProgramReason(node) {
     case "sdf:bend":
     case "sdf:repeat":
     case "sdf:shell":
+    case "sdf:offset":
     case "sdf:onion":
       return getUnsupportedSdfProgramReason(node.child);
     default:
@@ -18813,7 +19059,19 @@ function simplifyMesh(triVerts, vertProperties, targetRatio, maxError) {
   if (!_simplifier) {
     throw new Error("meshoptimizer not initialized — call initMeshoptimizer() first");
   }
-  const targetIndexCount = Math.max(3, Math.floor(triVerts.length * targetRatio));
+  if (triVerts.length === 0 || triVerts.length % 3 !== 0) {
+    throw new Error("Mesh simplification requires triangle indices in groups of 3");
+  }
+  if (!Number.isFinite(targetRatio) || targetRatio <= 0) {
+    throw new Error("Mesh simplification targetRatio must be a positive finite number");
+  }
+  if (!Number.isFinite(maxError) || maxError < 0) {
+    throw new Error("Mesh simplification maxError must be a non-negative finite number");
+  }
+  const inputTriangleCount = triVerts.length / 3;
+  const targetTriangleCount = Math.max(1, Math.min(inputTriangleCount, Math.floor(inputTriangleCount * targetRatio)));
+  if (targetTriangleCount >= inputTriangleCount) return triVerts;
+  const targetIndexCount = targetTriangleCount * 3;
   const [simplified] = _simplifier.simplify(
     triVerts,
     vertProperties,
@@ -20223,11 +20481,12 @@ function profileMayContainInteriorLoopsForOCCT(plan) {
       return false;
   }
 }
+const occtLoweredCache = /* @__PURE__ */ new WeakMap();
 function lowerShapeCompilePlanToOCCT(plan, oc) {
-  const cached = plan._occtCache;
+  const cached = occtLoweredCache.get(plan);
   if (cached) return cached;
   const shape = _lowerShapeCompilePlanToOCCTInner(plan, oc);
-  plan._occtCache = shape;
+  occtLoweredCache.set(plan, shape);
   return shape;
 }
 function _lowerShapeCompilePlanToOCCTInner(plan, oc) {
@@ -28765,16 +29024,16 @@ function surfaceNets(sdfFn, bounds, edgeLength2) {
     numTris: faces.length / 3
   };
 }
-const EPS$1 = 1e-9;
+const EPS = 1e-9;
 function finitePositive$1(value) {
-  return Number.isFinite(value) && value > EPS$1;
+  return Number.isFinite(value) && value > EPS;
 }
 function clampNonNegative(value) {
-  return Math.abs(value) <= EPS$1 ? 0 : value;
+  return Math.abs(value) <= EPS ? 0 : value;
 }
 function distancePreservingMatrixScale(matrix) {
   if (matrix.length !== 16 || matrix.some((value) => !Number.isFinite(value))) return null;
-  if (Math.abs(matrix[3]) > EPS$1 || Math.abs(matrix[7]) > EPS$1 || Math.abs(matrix[11]) > EPS$1 || Math.abs(matrix[15] - 1) > EPS$1) {
+  if (Math.abs(matrix[3]) > EPS || Math.abs(matrix[7]) > EPS || Math.abs(matrix[11]) > EPS || Math.abs(matrix[15] - 1) > EPS) {
     return null;
   }
   const col0 = [matrix[0], matrix[1], matrix[2]];
@@ -28786,8 +29045,8 @@ function distancePreservingMatrixScale(matrix) {
   const sy = length4(col1);
   const sz = length4(col2);
   if (!finitePositive$1(sx) || !finitePositive$1(sy) || !finitePositive$1(sz)) return null;
-  if (Math.abs(sx - sy) > EPS$1 || Math.abs(sx - sz) > EPS$1) return null;
-  if (Math.abs(dot2(col0, col1)) > EPS$1 || Math.abs(dot2(col0, col2)) > EPS$1 || Math.abs(dot2(col1, col2)) > EPS$1) return null;
+  if (Math.abs(sx - sy) > EPS || Math.abs(sx - sz) > EPS) return null;
+  if (Math.abs(dot2(col0, col1)) > EPS || Math.abs(dot2(col0, col2)) > EPS || Math.abs(dot2(col1, col2)) > EPS) return null;
   return sx;
 }
 function transformStepDistanceScale(step) {
@@ -28803,7 +29062,7 @@ function transformStepDistanceScale(step) {
       const sy = Math.abs(step.y);
       const sz = Math.abs(step.z);
       if (!finitePositive$1(sx) || !finitePositive$1(sy) || !finitePositive$1(sz)) return null;
-      return Math.abs(sx - sy) <= EPS$1 && Math.abs(sx - sz) <= EPS$1 ? sx : null;
+      return Math.abs(sx - sy) <= EPS && Math.abs(sx - sz) <= EPS ? sx : null;
     }
   }
 }
@@ -28834,7 +29093,7 @@ function cloneTransformStep(step) {
   }
 }
 function translatedPlan(base, z2) {
-  if (Math.abs(z2) <= EPS$1) return base;
+  if (Math.abs(z2) <= EPS) return base;
   return {
     kind: "transform",
     base,
@@ -28851,7 +29110,7 @@ function offsetCylinderDimensions(plan, thickness) {
   const height = zMax - zMin;
   const radiusBottom = plan.radius + thickness * (normalScale - slope);
   const offsetRadiusTop = radiusTop + thickness * (normalScale + slope);
-  if (!finitePositive$1(height) || radiusBottom < -EPS$1 || offsetRadiusTop < -EPS$1) return null;
+  if (!finitePositive$1(height) || radiusBottom < -EPS || offsetRadiusTop < -EPS) return null;
   return {
     zMin,
     height,
@@ -28875,7 +29134,7 @@ function transformProfilePoint(point, transform) {
       const nx = transform.normalX;
       const ny = transform.normalY;
       const len = Math.hypot(nx, ny);
-      if (len <= EPS$1) return point;
+      if (len <= EPS) return point;
       const ux = nx / len;
       const uy = ny / len;
       const d2 = point[0] * ux + point[1] * uy;
@@ -28889,7 +29148,7 @@ function transformProfilePointThrough(point, transforms) {
   return out;
 }
 function sameScalar$2(a2, b) {
-  return Math.abs(a2 - b) <= EPS$1;
+  return Math.abs(a2 - b) <= EPS;
 }
 function sameProfilePoint(a2, b) {
   return sameScalar$2(a2[0], b[0]) && sameScalar$2(a2[1], b[1]);
@@ -28943,7 +29202,7 @@ function rectangleFootprintFromProfile(plan) {
   const [xMin, xMax] = xs;
   const [zMin, zMax] = zs;
   if (xMin == null || xMax == null || zMin == null || zMax == null) return null;
-  if (xMin < -EPS$1 || !finitePositive$1(xMax) || !finitePositive$1(zMax - zMin)) return null;
+  if (xMin < -EPS || !finitePositive$1(xMax) || !finitePositive$1(zMax - zMin)) return null;
   const hasCorner = (x2, z2) => points.some(([px, pz]) => sameScalar$2(px, x2) && sameScalar$2(pz, z2));
   if (!hasCorner(xMin, zMin) || !hasCorner(xMax, zMin) || !hasCorner(xMax, zMax) || !hasCorner(xMin, zMax)) return null;
   return {
@@ -28966,7 +29225,7 @@ function circleFootprintFromProfile(plan) {
   const yScale = Math.hypot(yAxis[0], yAxis[1]);
   const dot2 = xAxis[0] * yAxis[0] + xAxis[1] * yAxis[1];
   if (!finitePositive$1(xScale) || !finitePositive$1(yScale)) return null;
-  if (Math.abs(xScale - yScale) > EPS$1 || Math.abs(dot2) > EPS$1 * xScale * yScale) return null;
+  if (Math.abs(xScale - yScale) > EPS || Math.abs(dot2) > EPS * xScale * yScale) return null;
   return {
     center,
     radius: radius * xScale,
@@ -28974,11 +29233,11 @@ function circleFootprintFromProfile(plan) {
   };
 }
 function fullCircleRevolveTorusPlan(plan, minorRadiusOffset = 0) {
-  if (Math.abs(plan.degrees - 360) > EPS$1) return null;
+  if (Math.abs(plan.degrees - 360) > EPS) return null;
   const circle = circleFootprintFromProfile(plan.profile);
-  if (!circle || circle.center[0] <= EPS$1) return null;
+  if (!circle || circle.center[0] <= EPS) return null;
   const minorRadius = circle.radius + minorRadiusOffset;
-  if (!finitePositive$1(minorRadius) || minorRadius >= circle.center[0] - EPS$1) return null;
+  if (!finitePositive$1(minorRadius) || minorRadius >= circle.center[0] - EPS) return null;
   return translatedPlan(
     {
       kind: "torus",
@@ -28991,7 +29250,7 @@ function fullCircleRevolveTorusPlan(plan, minorRadiusOffset = 0) {
 }
 function fullAxisRectRevolveCylinderPlan(plan) {
   const rectangle = fullRectRevolveSurfacePlan(plan);
-  if (!rectangle || rectangle.innerRadius > EPS$1) return null;
+  if (!rectangle || rectangle.innerRadius > EPS) return null;
   return translatedPlan(
     {
       kind: "cylinder",
@@ -29014,20 +29273,20 @@ function rectRevolveSurfacePlan(plan) {
   };
 }
 function fullRectRevolveSurfacePlan(plan) {
-  if (Math.abs(plan.degrees - 360) > EPS$1) return null;
+  if (Math.abs(plan.degrees - 360) > EPS) return null;
   return rectRevolveSurfacePlan(plan);
 }
 function offsetFullRectRevolvePlan(plan, thickness) {
   const cylinderPlan = fullAxisRectRevolveCylinderPlan(plan);
   if (cylinderPlan) return offsetSolidAnalyticPrimitivePlan(cylinderPlan, thickness);
   const rectangle = fullRectRevolveSurfacePlan(plan);
-  if (!rectangle || rectangle.innerRadius <= EPS$1) return null;
+  if (!rectangle || rectangle.innerRadius <= EPS) return null;
   const innerRadius = rectangle.innerRadius - thickness;
   const outerRadius = rectangle.outerRadius + thickness;
   const height = rectangle.zMax - rectangle.zMin + 2 * thickness;
-  if (innerRadius < -EPS$1 || !finitePositive$1(outerRadius) || !finitePositive$1(height) || outerRadius <= innerRadius + EPS$1) return null;
+  if (innerRadius < -EPS || !finitePositive$1(outerRadius) || !finitePositive$1(height) || outerRadius <= innerRadius + EPS) return null;
   const zCenter = (rectangle.zMin + rectangle.zMax) / 2;
-  if (innerRadius <= EPS$1) {
+  if (innerRadius <= EPS) {
     return translatedPlan(
       {
         kind: "cylinder",
@@ -29106,7 +29365,7 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
     }
     case "torus": {
       const minorRadius = base.minorRadius + thickness;
-      if (!finitePositive$1(minorRadius) || minorRadius >= base.majorRadius - EPS$1) return null;
+      if (!finitePositive$1(minorRadius) || minorRadius >= base.majorRadius - EPS) return null;
       return {
         kind: "torus",
         majorRadius: base.majorRadius,
@@ -29710,7 +29969,7 @@ function sub$1(a2, b) {
 function scale$1(v, scalar) {
   return [v[0] * scalar, v[1] * scalar, v[2] * scalar];
 }
-function cross$3(a2, b) {
+function cross$2(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
 function isFiniteNumber(value) {
@@ -29946,8 +30205,8 @@ function boundsCorners(bounds) {
 }
 function perpendicularAxes(normal) {
   const seed = Math.abs(normal[2]) < 0.9 ? [0, 0, 1] : [0, 1, 0];
-  const uAxis = normalizeVec3$1(cross$3(seed, normal));
-  const vAxis = normalizeVec3$1(cross$3(normal, uAxis));
+  const uAxis = normalizeVec3$1(cross$2(seed, normal));
+  const vAxis = normalizeVec3$1(cross$2(normal, uAxis));
   return { uAxis, vAxis };
 }
 function createBoundedHalfSpace(bounds, normal, originOffset) {
@@ -30015,7 +30274,7 @@ function faceAxes(face) {
   for (const vertex of face.vertices.slice(1)) {
     const uAxis = normalizeVec3$1([vertex[0] - origin[0], vertex[1] - origin[1], vertex[2] - origin[2]]);
     if (Math.hypot(...uAxis) <= 1e-12) continue;
-    const vAxis = normalizeVec3$1(cross$3(face.normal, uAxis));
+    const vAxis = normalizeVec3$1(cross$2(face.normal, uAxis));
     if (Math.hypot(...vAxis) <= 1e-12) continue;
     return {
       uAxis,
@@ -30024,18 +30283,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;
 }
@@ -30236,7 +30495,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);
@@ -30256,7 +30515,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}`, {
@@ -32576,7 +32835,7 @@ function isStraightMonotonePolyline(points) {
   for (const point of points) {
     const offset = subtract3$1(point, start);
     const projection = dot3$3(offset, axis) / axisLengthSq;
-    const lineDistance = vectorLength3$1(cross3$4(offset, axis)) / axisLength;
+    const lineDistance = vectorLength3$1(cross3$5(offset, axis)) / axisLength;
     if (lineDistance > 1e-5 || projection < -1e-6 || projection > 1 + 1e-6 || projection + 1e-6 < previousProjection) {
       return false;
     }
@@ -32652,7 +32911,7 @@ function isDistancePreservingMatrix$1(matrix) {
   const col0 = [matrix[0], matrix[1], matrix[2]];
   const col1 = [matrix[4], matrix[5], matrix[6]];
   const col2 = [matrix[8], matrix[9], matrix[10]];
-  const det = dot3$3(col0, cross3$4(col1, col2));
+  const det = dot3$3(col0, cross3$5(col1, col2));
   return Math.abs(vectorLength3$1(col0) - 1) <= eps && Math.abs(vectorLength3$1(col1) - 1) <= eps && Math.abs(vectorLength3$1(col2) - 1) <= eps && Math.abs(dot3$3(col0, col1)) <= eps && Math.abs(dot3$3(col0, col2)) <= eps && Math.abs(dot3$3(col1, col2)) <= eps && Math.abs(Math.abs(det) - 1) <= eps;
 }
 function offsetSolidTransformDistanceScale(step) {
@@ -32897,41 +33156,41 @@ function surfaceGridForFillPlan(plan) {
   }
   return grid;
 }
-function add3(a2, b) {
+function add3$1(a2, b) {
   return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
 }
-function scale3(v, s) {
+function scale3$1(v, s) {
   return [v[0] * s, v[1] * s, v[2] * s];
 }
 function analyticYForFrame(axis, xAxis) {
-  return normalizedVector3(cross3$4(axis, xAxis), "analytic surface yAxis");
+  return normalizedVector3(cross3$5(axis, xAxis), "analytic surface yAxis");
 }
 function radialPoint(xAxis, yAxis, u2, radius) {
-  return add3(scale3(xAxis, Math.cos(u2) * radius), scale3(yAxis, Math.sin(u2) * radius));
+  return add3$1(scale3$1(xAxis, Math.cos(u2) * radius), scale3$1(yAxis, Math.sin(u2) * radius));
 }
 function analyticSurfacePoint(plan, u2, v) {
   switch (plan.kind) {
     case "plane":
-      return add3(add3(plan.origin, scale3(plan.uAxis, u2)), scale3(plan.vAxis, v));
+      return add3$1(add3$1(plan.origin, scale3$1(plan.uAxis, u2)), scale3$1(plan.vAxis, v));
     case "cylinder": {
       const yAxis = analyticYForFrame(plan.axis, plan.xAxis);
-      return add3(add3(plan.origin, scale3(plan.axis, v)), radialPoint(plan.xAxis, yAxis, u2, plan.radius));
+      return add3$1(add3$1(plan.origin, scale3$1(plan.axis, v)), radialPoint(plan.xAxis, yAxis, u2, plan.radius));
     }
     case "cone": {
       const yAxis = analyticYForFrame(plan.axis, plan.xAxis);
       const t = (v - plan.vMin) / (plan.vMax - plan.vMin);
       const radius = plan.radiusBottom + (plan.radiusTop - plan.radiusBottom) * t;
-      return add3(add3(plan.origin, scale3(plan.axis, v)), radialPoint(plan.xAxis, yAxis, u2, radius));
+      return add3$1(add3$1(plan.origin, scale3$1(plan.axis, v)), radialPoint(plan.xAxis, yAxis, u2, radius));
     }
     case "sphere": {
       const yAxis = analyticYForFrame(plan.axis, plan.xAxis);
       const radial = radialPoint(plan.xAxis, yAxis, u2, plan.radius * Math.cos(v));
-      return add3(add3(plan.center, radial), scale3(plan.axis, plan.radius * Math.sin(v)));
+      return add3$1(add3$1(plan.center, radial), scale3$1(plan.axis, plan.radius * Math.sin(v)));
     }
     case "torus": {
       const yAxis = analyticYForFrame(plan.axis, plan.xAxis);
       const radial = radialPoint(plan.xAxis, yAxis, u2, plan.majorRadius + plan.minorRadius * Math.cos(v));
-      return add3(add3(plan.center, radial), scale3(plan.axis, plan.minorRadius * Math.sin(v)));
+      return add3$1(add3$1(plan.center, radial), scale3$1(plan.axis, plan.minorRadius * Math.sin(v)));
     }
     default:
       return assertExhaustive(plan);
@@ -33049,7 +33308,7 @@ function triangleNormal(vertices, triangle) {
   const c2 = vertices[triangle[2]];
   const ab = [b[0] - a2[0], b[1] - a2[1], b[2] - a2[2]];
   const ac = [c2[0] - a2[0], c2[1] - a2[1], c2[2] - a2[2]];
-  const normal = cross3$4(ab, ac);
+  const normal = cross3$5(ab, ac);
   const len = Math.hypot(normal[0], normal[1], normal[2]);
   if (len <= 1e-12) return null;
   return [normal[0] / len, normal[1] / len, normal[2] / len];
@@ -33195,7 +33454,7 @@ function lowerSurfaceSolidPlan(plan) {
     );
   }
 }
-function cross3$4(a2, b) {
+function cross3$5(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
 function fromSlicesPlaneFrame(normalInput) {
@@ -33211,8 +33470,8 @@ function fromSlicesPlaneFrame(normalInput) {
     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 = normalizedVector3(cross3$4(reference, normal), "Shape.fromSlices profile u axis");
-  return { u: u2, v: cross3$4(normal, u2), normal };
+  const u2 = normalizedVector3(cross3$5(reference, normal), "Shape.fromSlices profile u axis");
+  return { u: u2, v: cross3$5(normal, u2), normal };
 }
 function fromSlicesLocalToWorldMatrix(normal) {
   const frame = fromSlicesPlaneFrame(normal);
@@ -36631,29 +36890,11 @@ function lowerExactSlicedShapeCompilePlanToTruckProfileBackend(plan, offset) {
   return profilePlan ? lowerProfileCompilePlanToTruckProfileBackend(profilePlan) : null;
 }
 const SHAPE_COMPILE_PLAN_CACHE_KEY_VERSION = "shape-plan-v1";
-function stableJsonEncode(value, arrayMember) {
-  if (value === void 0 || typeof value === "function" || typeof value === "symbol") {
-    return arrayMember ? "null" : void 0;
-  }
-  if (value === null || typeof value === "number" || typeof value === "boolean" || typeof value === "string") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableJsonEncode(item, true) ?? "null").join(",")}]`;
-  }
-  const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
-  const encodedEntries = [];
-  for (const [key, item] of entries) {
-    const encoded = stableJsonEncode(item, false);
-    if (encoded !== void 0) encodedEntries.push(`${JSON.stringify(key)}:${encoded}`);
-  }
-  return `{${encodedEntries.join(",")}}`;
-}
-function stableJsonStringify(value) {
-  return stableJsonEncode(value, false) ?? "null";
-}
+const exactPlanHasher = createStructuralHasher({
+  skipKey: (key) => key.startsWith("_") || key === "owner" || key === "queryPropagation"
+});
 function shapeCompilePlanCacheKey(plan) {
-  return `${SHAPE_COMPILE_PLAN_CACHE_KEY_VERSION}:${stableJsonStringify(plan)}`;
+  return `${SHAPE_COMPILE_PLAN_CACHE_KEY_VERSION}:${exactPlanHasher(plan)}`;
 }
 function formatFaceQuery(query) {
   const parts = [];
@@ -36983,7 +37224,7 @@ function normalizeFaceSelector(selector) {
   }
   return { compilePlanName: null, query: selector };
 }
-function cross$2(a2, b) {
+function cross$1(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 dot$1(a2, b) {
@@ -36996,8 +37237,8 @@ function normVec3(v) {
 }
 function tangentFrame(normal) {
   const ref = Math.abs(normal[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
-  const v = normVec3(cross$2(normal, ref));
-  const u2 = normVec3(cross$2(v, normal));
+  const v = normVec3(cross$1(normal, ref));
+  const u2 = normVec3(cross$1(v, normal));
   return { u: u2, v };
 }
 const NORMAL_COS_EPS$1 = 0.9998;
@@ -37016,7 +37257,7 @@ function clusterMeshFaces(shape) {
     const v2 = [vertProperties[i2 * numProp], vertProperties[i2 * numProp + 1], vertProperties[i2 * numProp + 2]];
     const e1 = [v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]];
     const e2 = [v2[0] - v0[0], v2[1] - v0[1], v2[2] - v0[2]];
-    const rawCross = cross$2(e1, e2);
+    const rawCross = cross$1(e1, e2);
     const normal = normVec3(rawCross);
     if (!normal) continue;
     const crossLen = Math.sqrt(rawCross[0] * rawCross[0] + rawCross[1] * rawCross[1] + rawCross[2] * rawCross[2]);
@@ -37426,14 +37667,14 @@ function normalize2d(vec2) {
   if (len < 1e-12) return [1, 0];
   return [vec2[0] / len, vec2[1] / len];
 }
-function cross3$3(a2, b) {
+function cross3$4(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
 function orthonormalBasisFromNormal(normal) {
   const n = normalizeAxis(normal);
   const seed = Math.abs(n[2]) < 0.9 ? [0, 0, 1] : [0, 1, 0];
-  const u2 = normalizeAxis(cross3$3(seed, n));
-  const v = normalizeAxis(cross3$3(n, u2));
+  const u2 = normalizeAxis(cross3$4(seed, n));
+  const v = normalizeAxis(cross3$4(n, u2));
   return { u: u2, v };
 }
 function faceFrom2DEdge(name, start, end, zMid, ownerQuery) {
@@ -38270,7 +38511,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
             forwardStart3[1] - reverseStart3[1],
             forwardStart3[2] - reverseStart3[2]
           ]);
-          const normal = normalizeAxis(cross3$3(edgeVec, depthVec));
+          const normal = normalizeAxis(cross3$4(edgeVec, depthVec));
           registerFace(table, {
             name: wall.name,
             normal,
@@ -38756,14 +38997,14 @@ function normalize3$1(v) {
 function dot3$2(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function cross3$2(a2, b) {
+function cross3$3(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
 function perpendicularTo(axis) {
   const absX = Math.abs(axis[0]);
   const absZ = Math.abs(axis[2]);
   const seed = absX < absZ ? [1, 0, 0] : [0, 0, 1];
-  return normalize3$1(cross3$2(axis, seed));
+  return normalize3$1(cross3$3(axis, seed));
 }
 function normalizePortInput(input) {
   let origin;
@@ -38944,18 +39185,18 @@ function normalize3(v) {
   if (l < 1e-10) throw new Error("Cannot normalize zero-length vector");
   return [v[0] / l, v[1] / l, v[2] / l];
 }
-function cross3$1(a2, b) {
+function cross3$2(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
-function sub3(a2, b) {
+function sub3$1(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function negate3(v) {
   return [-v[0], -v[1], -v[2]];
 }
 function alignmentMatrix(childOrigin, childAxis, childUp, parentOrigin, parentAxis, parentUp) {
-  const cRight = normalize3(cross3$1(childAxis, childUp));
-  const pRight = normalize3(cross3$1(parentAxis, parentUp));
+  const cRight = normalize3(cross3$2(childAxis, childUp));
+  const pRight = normalize3(cross3$2(parentAxis, parentUp));
   const r00 = pRight[0] * cRight[0] + parentUp[0] * childUp[0] + parentAxis[0] * childAxis[0];
   const r01 = pRight[0] * cRight[1] + parentUp[0] * childUp[1] + parentAxis[0] * childAxis[1];
   const r02 = pRight[0] * cRight[2] + parentUp[0] * childUp[2] + parentAxis[0] * childAxis[2];
@@ -38970,7 +39211,7 @@ function alignmentMatrix(childOrigin, childAxis, childUp, parentOrigin, parentAx
     r10 * childOrigin[0] + r11 * childOrigin[1] + r12 * childOrigin[2],
     r20 * childOrigin[0] + r21 * childOrigin[1] + r22 * childOrigin[2]
   ];
-  const t = sub3(parentOrigin, rc);
+  const t = sub3$1(parentOrigin, rc);
   return Transform.from([r00, r10, r20, 0, r01, r11, r21, 0, r02, r12, r22, 0, t[0], t[1], t[2], 1]);
 }
 function computeSinglePairAlignment(childPort, targetPort) {
@@ -39009,8 +39250,8 @@ function computeMultiPairAlignment(pairs, childPorts, targetPorts, tolerance = 0
     [0, 0, 0]
   ];
   for (const p2 of pairs) {
-    const s = sub3(p2.childOrigin, srcCentroid);
-    const t2 = sub3(p2.targetOrigin, tgtCentroid);
+    const s = sub3$1(p2.childOrigin, srcCentroid);
+    const t2 = sub3$1(p2.targetOrigin, tgtCentroid);
     for (let i = 0; i < 3; i++) {
       for (let j = 0; j < 3; j++) {
         h[i][j] += s[i] * t2[j];
@@ -39023,7 +39264,7 @@ function computeMultiPairAlignment(pairs, childPorts, targetPorts, tolerance = 0
     R[1][0] * srcCentroid[0] + R[1][1] * srcCentroid[1] + R[1][2] * srcCentroid[2],
     R[2][0] * srcCentroid[0] + R[2][1] * srcCentroid[1] + R[2][2] * srcCentroid[2]
   ];
-  const t = sub3(tgtCentroid, rSrc);
+  const t = sub3$1(tgtCentroid, rSrc);
   const transform = Transform.from([
     R[0][0],
     R[1][0],
@@ -39045,7 +39286,7 @@ function computeMultiPairAlignment(pairs, childPorts, targetPorts, tolerance = 0
   const residuals = [];
   for (const p2 of pairs) {
     const transformed = transform.point(p2.childOrigin);
-    const diff = sub3(transformed, p2.targetOrigin);
+    const diff = sub3$1(transformed, p2.targetOrigin);
     residuals.push(len3(diff));
   }
   const maxResidual = Math.max(...residuals);
@@ -39246,7 +39487,7 @@ function getConnectorDistance(ports, nameA, nameB) {
   const b = ports[nameB];
   if (!a2) throw new Error(`connectorDistance: unknown connector "${nameA}"`);
   if (!b) throw new Error(`connectorDistance: unknown connector "${nameB}"`);
-  const d2 = sub3(a2.origin, b.origin);
+  const d2 = sub3$1(a2.origin, b.origin);
   return len3(d2);
 }
 function getConnectorMeasurements(ports, name) {
@@ -39359,7 +39600,9 @@ const _ManifoldShapeBackend = class _ManifoldShapeBackend {
     return this.getLiveManifold("numTri()").numTri();
   }
   getMesh() {
-    return this.getLiveManifold("getMesh()").getMesh();
+    const manifold = this.getLiveManifold("getMesh()");
+    const mesh = manifold.numProp() >= 3 ? manifold.getMesh(0) : manifold.getMesh();
+    return mesh;
   }
   slice(offset) {
     return this.getLiveManifold("slice()").slice(offset);
@@ -39660,7 +39903,7 @@ class ShapeGroup {
     };
     return this.attachTo(parent, face, opp[face], uvMap[face](u2, v, p2));
   }
-  /** Rotate the group around an arbitrary axis through the origin. */
+  /** Rotate the group around an arbitrary axis through the origin. Unlike `scale()`/`mirror()` (bounding-box center) and `Sketch.rotate()`, this pivots at the world origin — pass `options.pivot` to rotate in place. */
   rotate(axis, angleDeg, options) {
     requireRotateAxis(axis, "ShapeGroup.rotate()");
     requireFiniteAngle(angleDeg, "ShapeGroup.rotate()");
@@ -39905,6 +40148,11 @@ class ShapeGroup {
    * Position this group by matching connectors to a target.
    * Connector names support dotted paths into named children: "ChildName.connectorName".
    *
+   * Alignment: with a single connector pair, the group translates and rotates so the connector
+   * origins coincide and the axes oppose (plug-in model); `up` pins the roll. With multiple pairs,
+   * the connector origins define the rigid transform — still author meaningful `axis`/`up` values
+   * so the same connectors remain useful for `connect()`, audits, and future matching.
+   *
    * Overloads:
    * - Single pair: `matchTo(target, selfConn, targetConn, options?)`
    * - Dictionary (same target): `matchTo(target, { selfConn: targetConn, ... }, options?)`
@@ -41644,7 +41892,7 @@ async function initKernelManifoldOnly() {
   _activeBackend = "manifold";
   return manifoldModule;
 }
-const DEFAULT_ACTIVE_BACKEND = "truck";
+const DEFAULT_ACTIVE_BACKEND = "manifold";
 let _activeBackend = DEFAULT_ACTIVE_BACKEND;
 let _runtimeWarn = (msg) => console.warn(msg);
 function unwrapShapeLike(value) {
@@ -41663,6 +41911,7 @@ const _shapePlacementRefs = /* @__PURE__ */ new WeakMap();
 const _shapeExplodeHint = /* @__PURE__ */ new WeakMap();
 const _shapeRuntimeBackends = /* @__PURE__ */ new WeakMap();
 const _shapeTopology = /* @__PURE__ */ new WeakMap();
+const _shapeLineageTokens = /* @__PURE__ */ new WeakMap();
 const _shapeFaceLabels = /* @__PURE__ */ new WeakMap();
 const _shapeReferenceNames = /* @__PURE__ */ new WeakMap();
 const _shapeReferenceAliases = /* @__PURE__ */ new WeakMap();
@@ -41723,6 +41972,10 @@ function copyShapeReferenceMetadata(source, target) {
   const aliases = cloneReferenceAliases(_shapeReferenceAliases.get(source));
   if (aliases && aliases.size > 0) _shapeReferenceAliases.set(target, aliases);
 }
+function copyShapeLineage(source, target) {
+  const token = _shapeLineageTokens.get(source);
+  if (token) _shapeLineageTokens.set(target, token);
+}
 function assertNonEmptyReferenceName(name, apiName) {
   const trimmed = name.trim();
   if (!trimmed) throw new Error(`${apiName} requires a non-empty reference name.`);
@@ -41791,50 +42044,25 @@ function setShapeRuntimeBackendInternal(shape, payload) {
   return shape;
 }
 function setShapeCompilePlanInternal(shape, plan) {
-  _shapeCompilePlans.set(shape, cloneShapeCompilePlan(plan));
+  _shapeCompilePlans.set(shape, deepFreezePlanData(plan));
   recordShapeSourceSpanInternal(shape, plan);
   return shape;
 }
-function cloneShapeSourceSpanRecords(records) {
-  return (records ?? []).map((record) => ({
-    planCacheKey: record.planCacheKey,
-    sourceSpan: { ...record.sourceSpan }
-  }));
-}
 function upsertShapeSourceSpanRecord(shape, record) {
-  const records = cloneShapeSourceSpanRecords(_shapeSourceSpans.get(shape));
-  if (records.some((existing) => existing.planCacheKey === record.planCacheKey)) return;
-  records.push({
-    planCacheKey: record.planCacheKey,
-    sourceSpan: { ...record.sourceSpan }
-  });
-  _shapeSourceSpans.set(shape, records);
-}
-function stableTraceSourcePlanEncode(value, arrayMember) {
-  if (value === void 0 || typeof value === "function" || typeof value === "symbol") {
-    return arrayMember ? "null" : void 0;
-  }
-  if (value === null || typeof value === "number" || typeof value === "boolean" || typeof value === "string") {
-    return JSON.stringify(value);
+  let records = _shapeSourceSpans.get(shape);
+  if (!records) {
+    records = /* @__PURE__ */ new Map();
+    _shapeSourceSpans.set(shape, records);
   }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableTraceSourcePlanEncode(item, true) ?? "null").join(",")}]`;
-  }
-  const record = value;
-  if (record.kind === "queryOwner" && record.base) {
-    return stableTraceSourcePlanEncode(record.base, arrayMember);
-  }
-  const entries = Object.entries(record).sort(([left], [right]) => left.localeCompare(right));
-  const encodedEntries = [];
-  for (const [key, item] of entries) {
-    if (key.startsWith("_") || key === "owner" || key === "queryPropagation") continue;
-    const encoded = stableTraceSourcePlanEncode(item, false);
-    if (encoded !== void 0) encodedEntries.push(`${JSON.stringify(key)}:${encoded}`);
-  }
-  return `{${encodedEntries.join(",")}}`;
+  if (records.has(record.planCacheKey)) return;
+  records.set(record.planCacheKey, Object.freeze({ ...record.sourceSpan }));
 }
+const traceSourcePlanHasher = createStructuralHasher({
+  skipKey: (key) => key.startsWith("_") || key === "owner" || key === "queryPropagation",
+  unwrap: (record) => record.kind === "queryOwner" && record.base ? record.base : void 0
+});
 function normalizedTraceSourcePlanCacheKey(plan) {
-  return `shape-plan-v1:${stableTraceSourcePlanEncode(plan, false) ?? "null"}`;
+  return `shape-plan-v1:${traceSourcePlanHasher(plan)}`;
 }
 function recordShapeSourceSpanInternal(shape, plan) {
   if (!hasActiveRuntimeSourceResolver()) return;
@@ -41854,13 +42082,20 @@ function recordShapeSourceSpanInternal(shape, plan) {
   }
 }
 function copyShapeSourceSpans(source, target) {
-  const records = cloneShapeSourceSpanRecords(_shapeSourceSpans.get(source));
-  if (records.length > 0) _shapeSourceSpans.set(target, records);
+  const records = _shapeSourceSpans.get(source);
+  if (records && records.size > 0) _shapeSourceSpans.set(target, new Map(records));
 }
 function mergeShapeSourceSpans(sources, target) {
+  let records = _shapeSourceSpans.get(target);
   for (const source of sources) {
-    for (const record of _shapeSourceSpans.get(source) ?? []) {
-      upsertShapeSourceSpanRecord(target, record);
+    const sourceRecords = _shapeSourceSpans.get(source);
+    if (!sourceRecords) continue;
+    if (!records) {
+      records = /* @__PURE__ */ new Map();
+      _shapeSourceSpans.set(target, records);
+    }
+    for (const [key, span] of sourceRecords) {
+      if (!records.has(key)) records.set(key, span);
     }
   }
 }
@@ -41895,7 +42130,7 @@ function getShapeRuntimeBackendInternal(shape) {
 function getShapeCompilePlanInternal(shape) {
   const stored = _shapeCompilePlans.get(shape);
   if (!stored) throw new Error("Shape has no compile plan — every Shape must have an explicit plan set via setShapeCompilePlanInternal()");
-  return cloneShapeCompilePlan(stored);
+  return stored;
 }
 function getShapePlacementRefsInternal(shape) {
   return clonePlacementReferences(_shapePlacementRefs.get(shape) ?? createPlacementReferences());
@@ -42587,6 +42822,30 @@ function checkLabelCollisions(operation2, plans) {
     seen.push(...labels);
   }
 }
+function formatDiagnosticNumber(value) {
+  if (!Number.isFinite(value)) return String(value);
+  const rounded = Math.abs(value) < 5e-4 ? 0 : value;
+  return Number(rounded.toFixed(3)).toString();
+}
+function formatDiagnosticVec(values) {
+  return `[${values.slice(0, 3).map(formatDiagnosticNumber).join(",")}]`;
+}
+function formatShapeBoundsForDiagnostic(shape) {
+  try {
+    const bounds = shape.boundingBox();
+    return `bounds=${formatDiagnosticVec(bounds.min)}..${formatDiagnosticVec(bounds.max)}`;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `bounds=unavailable(${message})`;
+  }
+}
+function formatShapeOperandForDiagnostic(role, shape) {
+  const name = _shapeReferenceNames.get(shape);
+  return `${role}=${name ? `${name} ` : ""}${formatShapeBoundsForDiagnostic(shape)}`;
+}
+function formatSourceSpanForDiagnostic(sourceSpan) {
+  return sourceSpan ? ` source=${sourceSpan.fileName}:${sourceSpan.line}:${sourceSpan.column}` : "";
+}
 function withCopiedDimensions(source, out) {
   setShapeDimensionsInternal(out, cloneDimensions(getShapeDimensionsInternal(source), true));
   setShapeGeometryInfoInternal(out, getShapeGeometryInfoInternal(source));
@@ -42601,6 +42860,7 @@ function withCopiedDimensions(source, out) {
   const sourceLabels = cloneFaceLabelMap(_shapeFaceLabels.get(source));
   if (sourceLabels) _shapeFaceLabels.set(out, sourceLabels);
   copyShapeReferenceMetadata(source, out);
+  copyShapeLineage(source, out);
   copyShapeSourceSpans(source, out);
   return setShapeCompilePlanInternal(out, getShapeCompilePlanInternal(source));
 }
@@ -42630,6 +42890,7 @@ function withTransformedDimensions(source, out, m2) {
   const sourceLabelsT = cloneFaceLabelMap(_shapeFaceLabels.get(source));
   if (sourceLabelsT) _shapeFaceLabels.set(out, sourceLabelsT);
   copyShapeReferenceMetadata(source, out);
+  copyShapeLineage(source, out);
   copyShapeSourceSpans(source, out);
   return setShapeCompilePlanInternal(out, getShapeCompilePlanInternal(source));
 }
@@ -43057,6 +43318,7 @@ class Shape {
     this.colorHex = color;
     setShapeRuntimeBackendInternal(this, payload);
     setShapeGeometryInfoInternal(this, createGeometryInfo(geometryInfo));
+    _shapeLineageTokens.set(this, {});
   }
   /** @internal Use .color() instead. */
   setColor(value) {
@@ -43175,6 +43437,12 @@ class Shape {
    * with `union()` / `difference()` to avoid collisions. Collision detection throws a
    * clear error with a fix suggestion.
    *
+   * Boolean survival: `union()` and `intersection()` carry labels from every operand;
+   * `difference()` carries only the base (first) operand's labels — cutter labels are
+   * dropped. A surviving label addresses whatever portion of its face survives the
+   * boolean; cutters may split or erase it, and a lineage shared by multiple union
+   * operands resolves as a face set rather than a single face.
+   *
    * For compile-covered shapes (extrude, loft, etc.) the lookup resolves via the shape's
    * compile plan. As a fallback, planar-faced mesh shapes (e.g. results of boolean ops)
    * are resolved via coplanar triangle clustering.
@@ -43591,7 +43859,7 @@ class Shape {
     const tbb = s.boundingBox();
     return this.moveTo(tbb.min[0] + localX, tbb.min[1] + localY, tbb.min[2] + localZ);
   }
-  /** Rotate around an arbitrary axis through the origin. */
+  /** Rotate around an arbitrary axis through the origin. Unlike `Sketch.rotate()` (bounding-box center), this pivots at the world origin — pass `options.pivot` to rotate in place. */
   rotate(axis, angleDeg, options) {
     validateRotateAxis(axis, "Shape.rotate()");
     validateRotateAngle(angleDeg, "Shape.rotate()");
@@ -43778,7 +44046,7 @@ class Shape {
    * Warn if a boolean operation had no geometric effect.
    * Compares volumes before and after; if they match within tolerance, the operation was a no-op.
    */
-  static _checkBooleanNoOp(op, base, result) {
+  static _checkBooleanNoOp(op, base, result, tools = []) {
     try {
       if (op === "intersection") {
         if (result.isEmpty()) {
@@ -43791,8 +44059,15 @@ class Shape {
         const volAfter = result.volume();
         const tol = Math.max(volBefore * 1e-4, 1e-3);
         if (Math.abs(volBefore - volAfter) < tol) {
+          const sourceSpan = captureRuntimeSourceSpan();
+          const operandContext = [
+            formatShapeOperandForDiagnostic("base", base),
+            ...tools.map((tool, index2) => formatShapeOperandForDiagnostic(`tool[${index2 + 1}]`, tool))
+          ].join(" ");
           _runtimeWarn(
-            `subtract() had no effect — the tool may not overlap the base shape. Base vol=${volBefore.toFixed(1)}mm³, result vol=${volAfter.toFixed(1)}mm³`
+            `subtract() had no effect — the tool may not overlap the base shape. Base vol=${volBefore.toFixed(1)}mm³, result vol=${volAfter.toFixed(1)}mm³.${formatSourceSpanForDiagnostic(sourceSpan)} ${operandContext}`,
+            "boolean.difference.noEffect",
+            sourceSpan ? { sourceSpan } : void 0
           );
         }
       }
@@ -43852,7 +44127,7 @@ class Shape {
       ),
       nextPlan
     );
-    Shape._checkBooleanNoOp("difference", this, resultShape);
+    Shape._checkBooleanNoOp("difference", this, resultShape, shapes.slice(1));
     return resultShape;
   }
   /** Keep only the overlap with other shapes. Method form of intersection(). */
@@ -44255,6 +44530,11 @@ class Shape {
   /**
    * Position this shape by matching connectors to a target.
    *
+   * Alignment: with a single connector pair, the shape translates and rotates so the connector
+   * origins coincide and the axes oppose (plug-in model); `up` pins the roll. With multiple pairs,
+   * the connector origins define the rigid transform — still author meaningful `axis`/`up` values
+   * so the same connectors remain useful for `connect()`, audits, and future matching.
+   *
    * Overloads:
    * - Single pair: `matchTo(target, selfConn, targetConn, options?)`
    * - Dictionary (same target): `matchTo(target, { selfConn: targetConn, ... }, options?)`
@@ -45324,117 +45604,10 @@ function buildSweepLevelSetInput(profilePolygons, pathInput, options) {
     edgeLength: options.edgeLength
   };
 }
-const EPS = 1e-9;
-function resamplePolygon(poly, targetCount) {
-  if (poly.length < 2) return poly;
-  if (targetCount <= 0) return [];
-  const dists = [0];
-  for (let i = 0; i < poly.length; i++) {
-    const p1 = poly[i];
-    const p2 = poly[(i + 1) % poly.length];
-    const dx = p2[0] - p1[0];
-    const dy = p2[1] - p1[1];
-    const d2 = Math.sqrt(dx * dx + dy * dy);
-    dists.push(dists[dists.length - 1] + d2);
-  }
-  const totalDist = dists[dists.length - 1];
-  if (totalDist < 1e-12) {
-    return Array.from({ length: targetCount }, () => [poly[0][0], poly[0][1]]);
-  }
-  const out = [];
-  for (let i = 0; i < targetCount; i++) {
-    const targetDist = i / targetCount * totalDist;
-    let low = 0;
-    let high = dists.length - 1;
-    while (low < high) {
-      const mid = low + high >> 1;
-      if (dists[mid] <= targetDist) {
-        low = mid + 1;
-      } else {
-        high = mid;
-      }
-    }
-    const seg = low - 1;
-    const t = (targetDist - dists[seg]) / (dists[seg + 1] - dists[seg]);
-    const p1 = poly[seg % poly.length];
-    const p2 = poly[(seg + 1) % poly.length];
-    out.push([p1[0] + (p2[0] - p1[0]) * t, p1[1] + (p2[1] - p1[1]) * t]);
-  }
-  return out;
-}
-function resamplePolygonByAngle(poly, targetCount, center = polygonCentroid(poly)) {
-  if (poly.length < 3 || targetCount <= 0) return null;
-  if (!isConvexPolygon(poly)) return null;
-  const out = [];
-  for (let index2 = 0; index2 < targetCount; index2 += 1) {
-    const angle = index2 / targetCount * Math.PI * 2;
-    const point = rayPolygonIntersection(center, [Math.cos(angle), Math.sin(angle)], poly);
-    if (!point) return null;
-    out.push(point);
-  }
-  return out;
-}
-function rayPolygonIntersection(origin, direction, poly) {
-  let bestT = Infinity;
-  let best = null;
-  for (let index2 = 0; index2 < poly.length; index2 += 1) {
-    const a2 = poly[index2];
-    const b = poly[(index2 + 1) % poly.length];
-    const edge = [b[0] - a2[0], b[1] - a2[1]];
-    const denom = cross$1(direction, edge);
-    if (Math.abs(denom) < EPS) continue;
-    const delta = [a2[0] - origin[0], a2[1] - origin[1]];
-    const rayT = cross$1(delta, edge) / denom;
-    const edgeT = cross$1(delta, direction) / denom;
-    if (rayT >= -EPS && edgeT >= -EPS && edgeT <= 1 + EPS && rayT < bestT) {
-      bestT = rayT;
-      best = [origin[0] + direction[0] * rayT, origin[1] + direction[1] * rayT];
-    }
-  }
-  return best;
-}
-function polygonCentroid(poly) {
-  let area2 = 0;
-  let cx = 0;
-  let cy = 0;
-  for (let index2 = 0; index2 < poly.length; index2 += 1) {
-    const a2 = poly[index2];
-    const b = poly[(index2 + 1) % poly.length];
-    const crossValue = cross$1(a2, b);
-    area2 += crossValue;
-    cx += (a2[0] + b[0]) * crossValue;
-    cy += (a2[1] + b[1]) * crossValue;
-  }
-  if (Math.abs(area2) < EPS) return averagePoint(poly);
-  return [cx / (3 * area2), cy / (3 * area2)];
-}
-function averagePoint(poly) {
-  let x2 = 0;
-  let y2 = 0;
-  for (const point of poly) {
-    x2 += point[0];
-    y2 += point[1];
-  }
-  return [x2 / poly.length, y2 / poly.length];
-}
-function isConvexPolygon(poly) {
-  let sign = 0;
-  for (let index2 = 0; index2 < poly.length; index2 += 1) {
-    const a2 = poly[index2];
-    const b = poly[(index2 + 1) % poly.length];
-    const c2 = poly[(index2 + 2) % poly.length];
-    const turn = cross$1([b[0] - a2[0], b[1] - a2[1]], [c2[0] - b[0], c2[1] - b[1]]);
-    if (Math.abs(turn) < EPS) continue;
-    const currentSign = Math.sign(turn);
-    if (sign !== 0 && currentSign !== sign) return false;
-    sign = currentSign;
-  }
-  return sign !== 0;
-}
-function cross$1(a2, b) {
-  return a2[0] * b[1] - a2[1] * b[0];
-}
-function loftStitched(profiles, heights, wasm) {
+const CORNER_TURN_DEG = 30;
+const SPAN_ANGLE_PER_RING_DEG = 3;
+const MAX_SPAN_SUBDIVISION = 24;
+function loftStitched(profiles, heights, wasm, options = {}) {
   if (profiles.length < 2) return null;
   const classified = profiles.map((loops) => classifyLoops(loops));
   const outerCount = classified[0].outers.length;
@@ -45449,7 +45622,7 @@ function loftStitched(profiles, heights, wasm) {
   const holeGroups = holeCount > 0 ? matchLoopsAcrossProfiles(classified.map((c2) => c2.holes)) : [];
   const outerSolids = [];
   for (const group of outerGroups) {
-    const solid = stitchSingleLoopLoft(group, heights, wasm);
+    const solid = stitchSingleLoopLoft(group, heights, wasm, options);
     if (!solid) {
       for (const s of outerSolids) s.delete();
       return null;
@@ -45466,7 +45639,7 @@ function loftStitched(profiles, heights, wasm) {
   if (holeGroups.length > 0) {
     const holeSolids = [];
     for (const group of holeGroups) {
-      const solid = stitchSingleLoopLoft(group, heights, wasm);
+      const solid = stitchSingleLoopLoft(group, heights, wasm, options);
       if (!solid) {
         result.delete();
         for (const s of holeSolids) s.delete();
@@ -45552,68 +45725,564 @@ function signedArea$1(loop) {
   }
   return area * 0.5;
 }
-function stitchSingleLoopLoft(loops, heights, wasm) {
+function detectCorners(loop) {
+  const corners = [];
+  const n = loop.length;
+  const threshold = CORNER_TURN_DEG * Math.PI / 180;
+  for (let i = 0; i < n; i++) {
+    const prev = loop[(i - 1 + n) % n];
+    const curr = loop[i];
+    const next = loop[(i + 1) % n];
+    const ax = curr[0] - prev[0];
+    const ay = curr[1] - prev[1];
+    const bx = next[0] - curr[0];
+    const by = next[1] - curr[1];
+    const la = Math.hypot(ax, ay);
+    const lb = Math.hypot(bx, by);
+    if (la < 1e-12 || lb < 1e-12) continue;
+    const dot2 = (ax * bx + ay * by) / (la * lb);
+    const turn = Math.acos(Math.min(1, Math.max(-1, dot2)));
+    if (turn > threshold) corners.push(i);
+  }
+  return corners;
+}
+function cumulativeArcLength(loop) {
+  const dists = [0];
+  for (let i = 0; i < loop.length; i++) {
+    const p1 = loop[i];
+    const p2 = loop[(i + 1) % loop.length];
+    dists.push(dists[i] + Math.hypot(p2[0] - p1[0], p2[1] - p1[1]));
+  }
+  return { dists, total: dists[loop.length] };
+}
+function pointAtArcLength(loop, dists, total, s) {
+  if (total < 1e-12) return [loop[0][0], loop[0][1]];
+  let target = s % total;
+  if (target < 0) target += total;
+  let low = 0;
+  let high = dists.length - 1;
+  while (low < high) {
+    const mid = low + high >> 1;
+    if (dists[mid] <= target) low = mid + 1;
+    else high = mid;
+  }
+  const seg = low - 1;
+  const segLen = dists[seg + 1] - dists[seg];
+  const t = segLen < 1e-12 ? 0 : (target - dists[seg]) / segLen;
+  const p1 = loop[seg % loop.length];
+  const p2 = loop[(seg + 1) % loop.length];
+  return [p1[0] + (p2[0] - p1[0]) * t, p1[1] + (p2[1] - p1[1]) * t];
+}
+function refineParams(params, rangeEnd, maxGap) {
+  if (!Number.isFinite(maxGap)) return params;
+  const out = [];
+  for (let i = 0; i < params.length; i++) {
+    const a2 = params[i];
+    const b = i + 1 < params.length ? params[i + 1] : rangeEnd;
+    out.push(a2);
+    const gap = b - a2;
+    if (gap > maxGap) {
+      const pieces = Math.min(64, Math.ceil(gap / maxGap));
+      for (let k2 = 1; k2 < pieces; k2++) out.push(a2 + gap * k2 / pieces);
+    }
+  }
+  return out;
+}
+function turnAngle(prev, curr, next) {
+  const ax = curr[0] - prev[0];
+  const ay = curr[1] - prev[1];
+  const bx = next[0] - curr[0];
+  const by = next[1] - curr[1];
+  const la = Math.hypot(ax, ay);
+  const lb = Math.hypot(bx, by);
+  if (la < 1e-12 || lb < 1e-12) return 0;
+  const dot2 = (ax * bx + ay * by) / (la * lb);
+  return Math.acos(Math.min(1, Math.max(-1, dot2)));
+}
+function maxTurnPerColumn(rings) {
+  const N = rings[0].length;
+  const out = new Float64Array(N);
+  for (const ring of rings) {
+    for (let j = 0; j < N; j++) {
+      const turn = turnAngle(ring[(j - 1 + N) % N], ring[j], ring[(j + 1) % N]);
+      if (turn > out[j]) out[j] = turn;
+    }
+  }
+  return out;
+}
+const CURVE_TURN_EPS = 0.5 * Math.PI / 180;
+function maxQuadDeviation(rings, heights, colA, colB) {
+  let worst = 0;
+  for (let i = 0; i < rings.length - 1; i++) {
+    const a2 = [rings[i][colA][0], rings[i][colA][1], heights[i]];
+    const b = [rings[i][colB][0], rings[i][colB][1], heights[i]];
+    const c2 = [rings[i + 1][colB][0], rings[i + 1][colB][1], heights[i + 1]];
+    const d2 = [rings[i + 1][colA][0], rings[i + 1][colA][1], heights[i + 1]];
+    const n = cross3$1(sub3(b, a2), sub3(d2, a2));
+    const len = Math.hypot(n[0], n[1], n[2]);
+    if (len < 1e-12) continue;
+    const deviation = Math.abs((n[0] * (c2[0] - a2[0]) + n[1] * (c2[1] - a2[1]) + n[2] * (c2[2] - a2[2])) / len);
+    if (deviation > worst) worst = deviation;
+  }
+  return worst;
+}
+function buildCompatibleRings(loops, heights, edgeLength2) {
+  const cornerSets = loops.map(detectCorners);
+  const cornerCount = cornerSets[0].length;
+  const cornersMatch = cornerCount > 0 && cornerSets.every((c2) => c2.length === cornerCount);
+  if (cornersMatch) {
+    const anchored = buildCornerAnchoredRings(loops, heights, cornerSets, edgeLength2);
+    if (anchored) return anchored;
+  }
+  return buildSeamAlignedRings(loops, heights, edgeLength2);
+}
+function buildCornerAnchoredRings(loops, heights, cornerSets, edgeLength2) {
+  const cornerCount = cornerSets[0].length;
+  const arcs = loops.map((loop) => cumulativeArcLength(loop));
+  const alignedCorners = [cornerSets[0]];
+  for (let i = 1; i < loops.length; i++) {
+    const prev = alignedCorners[i - 1];
+    const prevLoop = loops[i - 1];
+    const curr = cornerSets[i];
+    const loop = loops[i];
+    let best = curr;
+    let bestCost = Infinity;
+    for (let r = 0; r < cornerCount; r++) {
+      const rotated = curr.map((_2, k2) => curr[(k2 + r) % cornerCount]);
+      let cost = 0;
+      for (let k2 = 0; k2 < cornerCount; k2++) {
+        const a2 = prevLoop[prev[k2]];
+        const b = loop[rotated[k2]];
+        cost += (a2[0] - b[0]) ** 2 + (a2[1] - b[1]) ** 2;
+      }
+      if (cost < bestCost) {
+        bestCost = cost;
+        best = rotated;
+      }
+    }
+    alignedCorners.push(best);
+  }
+  const segParams = [];
+  const segLengths = [];
+  for (let i = 0; i < loops.length; i++) {
+    const loop = loops[i];
+    const { dists, total } = arcs[i];
+    if (total < 1e-9) return null;
+    const corners = alignedCorners[i];
+    const stationSegs = [];
+    const stationLens = [];
+    for (let s = 0; s < cornerCount; s++) {
+      const from = corners[s];
+      const to = corners[(s + 1) % cornerCount];
+      const start = dists[from];
+      let end = dists[to];
+      if (to <= from) end += total;
+      const len = end - start;
+      if (len < 1e-9) return null;
+      const interior = [];
+      const n = loop.length;
+      for (let v = (from + 1) % n; v !== to; v = (v + 1) % n) {
+        let d2 = dists[v];
+        if (d2 < start) d2 += total;
+        const p2 = (d2 - start) / len;
+        if (p2 > 1e-9 && p2 < 1 - 1e-9) interior.push(p2);
+      }
+      stationSegs.push(interior);
+      stationLens.push(len);
+    }
+    segParams.push(stationSegs);
+    segLengths.push(stationLens);
+  }
+  let masterParams = [];
+  for (let s = 0; s < cornerCount; s++) {
+    let bestStation = 0;
+    for (let i = 1; i < loops.length; i++) {
+      if (segParams[i][s].length > segParams[bestStation][s].length) bestStation = i;
+    }
+    masterParams.push([0, ...segParams[bestStation][s]]);
+  }
+  const sampleRings = (paramsBySegment) => {
+    const rings2 = [];
+    for (let i = 0; i < loops.length; i++) {
+      const loop = loops[i];
+      const { dists, total } = arcs[i];
+      const corners = alignedCorners[i];
+      const ring = [];
+      for (let s = 0; s < cornerCount; s++) {
+        const from = corners[s];
+        const to = corners[(s + 1) % cornerCount];
+        const start = dists[from];
+        let end = dists[to];
+        if (to <= from) end += total;
+        const len = end - start;
+        for (const p2 of paramsBySegment[s]) {
+          if (p2 === 0) {
+            ring.push([loop[from][0], loop[from][1]]);
+          } else {
+            ring.push(pointAtArcLength(loop, dists, total, start + p2 * len));
+          }
+        }
+      }
+      rings2.push(ring);
+    }
+    return rings2;
+  };
+  let rings = sampleRings(masterParams);
+  if (edgeLength2 && edgeLength2 > 0) {
+    const ringLength = rings[0].length;
+    const turns = maxTurnPerColumn(rings);
+    const segStart = [];
+    {
+      let col = 0;
+      for (let s = 0; s < cornerCount; s++) {
+        segStart.push(col);
+        col += masterParams[s].length;
+      }
+    }
+    let changed = false;
+    const refined = [];
+    for (let s = 0; s < cornerCount; s++) {
+      const params = masterParams[s];
+      let maxLen = 0;
+      for (let i = 0; i < loops.length; i++) maxLen = Math.max(maxLen, segLengths[i][s]);
+      const out = [];
+      for (let k2 = 0; k2 < params.length; k2++) {
+        const a2 = params[k2];
+        const b = k2 + 1 < params.length ? params[k2 + 1] : 1;
+        out.push(a2);
+        const gapLen = (b - a2) * maxLen;
+        if (gapLen <= edgeLength2) continue;
+        const colA = segStart[s] + k2;
+        const colB = k2 + 1 < params.length ? colA + 1 : segStart[(s + 1) % cornerCount] % ringLength;
+        const curved = k2 > 0 && turns[colA] > CURVE_TURN_EPS || k2 + 1 < params.length && turns[colB] > CURVE_TURN_EPS;
+        const twisted = !curved && maxQuadDeviation(rings, heights, colA, colB) > edgeLength2 * 0.05;
+        if (!curved && !twisted) continue;
+        const pieces = Math.min(64, Math.ceil(gapLen / edgeLength2));
+        for (let p2 = 1; p2 < pieces; p2++) out.push(a2 + (b - a2) * p2 / pieces);
+        changed = true;
+      }
+      refined.push(out);
+    }
+    if (changed) {
+      masterParams = refined;
+      rings = sampleRings(masterParams);
+    }
+  }
+  const cornerColumns = [];
+  {
+    let col = 0;
+    for (let s = 0; s < cornerCount; s++) {
+      cornerColumns.push(col);
+      col += masterParams[s].length;
+    }
+  }
+  return { rings, cornerColumns };
+}
+function buildSeamAlignedRings(loops, _heights, edgeLength2) {
+  const arcs = loops.map((loop) => cumulativeArcLength(loop));
+  let bestStation = 0;
+  for (let i = 1; i < loops.length; i++) {
+    if (loops[i].length > loops[bestStation].length) bestStation = i;
+  }
+  const { dists: masterDists, total: masterTotal } = arcs[bestStation];
+  if (masterTotal < 1e-9) return null;
+  let params = loops[bestStation].map((_2, v) => masterDists[v] / masterTotal);
+  if (params.length < 24) {
+    params = refineParams(params, 1, 1 / 24);
+  }
+  const sampleRings = (paramList) => loops.map((loop, i) => {
+    const { dists, total } = arcs[i];
+    if (total < 1e-9) {
+      return paramList.map(() => [loop[0][0], loop[0][1]]);
+    }
+    return paramList.map((p2) => pointAtArcLength(loop, dists, total, p2 * total));
+  });
+  let rings = sampleRings(params);
+  if (edgeLength2 && edgeLength2 > 0) {
+    let maxPerimeter = 0;
+    for (const { total } of arcs) maxPerimeter = Math.max(maxPerimeter, total);
+    const turns = maxTurnPerColumn(rings);
+    const N0 = params.length;
+    const out = [];
+    let changed = false;
+    for (let k2 = 0; k2 < N0; k2++) {
+      const a2 = params[k2];
+      const b = k2 + 1 < N0 ? params[k2 + 1] : 1;
+      out.push(a2);
+      const gapLen = (b - a2) * maxPerimeter;
+      if (gapLen <= edgeLength2) continue;
+      if (turns[k2] <= CURVE_TURN_EPS && turns[(k2 + 1) % N0] <= CURVE_TURN_EPS) continue;
+      const pieces = Math.min(64, Math.ceil(gapLen / edgeLength2));
+      for (let p2 = 1; p2 < pieces; p2++) out.push(a2 + (b - a2) * p2 / pieces);
+      changed = true;
+    }
+    if (changed) {
+      params = out;
+      rings = sampleRings(params);
+    }
+  }
+  const N = params.length;
+  for (let i = 1; i < rings.length; i++) {
+    const prev = rings[i - 1];
+    const curr = rings[i];
+    let bestShift = 0;
+    let bestCost = Infinity;
+    for (let shift = 0; shift < N; shift++) {
+      let cost = 0;
+      for (let j = 0; j < N; j++) {
+        const a2 = prev[j];
+        const b = curr[(j + shift) % N];
+        cost += (a2[0] - b[0]) ** 2 + (a2[1] - b[1]) ** 2;
+        if (cost >= bestCost) break;
+      }
+      if (cost < bestCost) {
+        bestCost = cost;
+        bestShift = shift;
+      }
+    }
+    if (bestShift !== 0) {
+      rings[i] = curr.map((_2, j) => curr[(j + bestShift) % N]);
+    }
+  }
+  return { rings, cornerColumns: [] };
+}
+function buildSpanRows(rings, heights) {
+  const R = rings.length;
+  const N = rings[0].length;
+  const stations = rings.map((ring, i) => ring.map(([x2, y2]) => [x2, y2, heights[i]]));
+  const t = [0];
+  for (let i = 0; i < R - 1; i++) {
+    let sum2 = 0;
+    for (let j = 0; j < N; j++) {
+      sum2 += dist3(stations[i][j], stations[i + 1][j]);
+    }
+    const avg = Math.max(sum2 / N, 1e-9);
+    t.push(t[i] + Math.sqrt(avg));
+  }
+  const tangents = [];
+  for (let i = 0; i < R; i++) {
+    const row = [];
+    for (let j = 0; j < N; j++) {
+      row.push(stationTangent(stations, t, i, j));
+    }
+    tangents.push(row);
+  }
+  const rows = [{ points: stations[0], tangents: tangents[0], isStation: true }];
+  for (let i = 0; i < R - 1; i++) {
+    const h = t[i + 1] - t[i];
+    let maxAngle = 0;
+    const stride = Math.max(1, Math.floor(N / 16));
+    for (let j = 0; j < N; j += stride) {
+      maxAngle = Math.max(maxAngle, angleBetween(tangents[i][j], tangents[i + 1][j]));
+    }
+    const k2 = Math.min(MAX_SPAN_SUBDIVISION, Math.max(1, Math.ceil(maxAngle / SPAN_ANGLE_PER_RING_DEG)));
+    for (let s = 1; s < k2; s++) {
+      const u2 = s / k2;
+      const points = [];
+      const rowTangents = [];
+      for (let j = 0; j < N; j++) {
+        const { point, tangent } = hermite(stations[i][j], tangents[i][j], stations[i + 1][j], tangents[i + 1][j], h, u2);
+        points.push(point);
+        rowTangents.push(tangent);
+      }
+      rows.push({ points, tangents: rowTangents, isStation: false });
+    }
+    rows.push({ points: stations[i + 1], tangents: tangents[i + 1], isStation: true });
+  }
+  return rows;
+}
+function stationTangent(stations, t, i, j) {
+  const R = stations.length;
+  if (i === 0) {
+    return scale3(sub3(stations[1][j], stations[0][j]), 1 / (t[1] - t[0]));
+  }
+  if (i === R - 1) {
+    return scale3(sub3(stations[R - 1][j], stations[R - 2][j]), 1 / (t[R - 1] - t[R - 2]));
+  }
+  const hPrev = t[i] - t[i - 1];
+  const hNext = t[i + 1] - t[i];
+  const dPrev = scale3(sub3(stations[i][j], stations[i - 1][j]), 1 / hPrev);
+  const dNext = scale3(sub3(stations[i + 1][j], stations[i][j]), 1 / hNext);
+  return scale3(add3(scale3(dPrev, hNext), scale3(dNext, hPrev)), 1 / (hPrev + hNext));
+}
+function hermite(p0, m0, p1, m1, h, u2) {
+  const u22 = u2 * u2;
+  const u3 = u22 * u2;
+  const h00 = 2 * u3 - 3 * u22 + 1;
+  const h10 = u3 - 2 * u22 + u2;
+  const h01 = -2 * u3 + 3 * u22;
+  const h11 = u3 - u22;
+  const d00 = 6 * u22 - 6 * u2;
+  const d10 = 3 * u22 - 4 * u2 + 1;
+  const d01 = -6 * u22 + 6 * u2;
+  const d11 = 3 * u22 - 2 * u2;
+  const point = [
+    h00 * p0[0] + h10 * h * m0[0] + h01 * p1[0] + h11 * h * m1[0],
+    h00 * p0[1] + h10 * h * m0[1] + h01 * p1[1] + h11 * h * m1[1],
+    h00 * p0[2] + h10 * h * m0[2] + h01 * p1[2] + h11 * h * m1[2]
+  ];
+  const tangent = [
+    d00 * p0[0] / h + d10 * m0[0] + d01 * p1[0] / h + d11 * m1[0],
+    d00 * p0[1] / h + d10 * m0[1] + d01 * p1[1] / h + d11 * m1[1],
+    d00 * p0[2] / h + d10 * m0[2] + d01 * p1[2] / h + d11 * m1[2]
+  ];
+  return { point, tangent };
+}
+function stitchSingleLoopLoft(loops, heights, wasm, options) {
   const normalizedLoops = loops.map((loop) => {
     const area = signedArea$1(loop);
     return area < 0 ? [...loop].reverse() : loop;
   });
-  let maxPoints = 0;
-  for (const loop of normalizedLoops) {
-    maxPoints = Math.max(maxPoints, loop.length);
-  }
-  const N = Math.max(maxPoints, 24);
-  const angularSamples = normalizedLoops.map((loop) => resamplePolygonByAngle(loop, N));
-  const useAngularSamples = angularSamples.every((samples) => samples != null);
-  const resampled = normalizedLoops.map((loop, i) => {
-    const pts2d = useAngularSamples ? angularSamples[i] : resamplePolygon(loop, N);
-    const z2 = heights[i];
-    return pts2d.map(([x2, y2]) => [x2, y2, z2]);
-  });
-  const vertices = [];
-  const triangles = [];
-  for (const layer of resampled) {
-    for (const [x2, y2, z2] of layer) {
-      vertices.push(x2, y2, z2);
+  const compatible = buildCompatibleRings(normalizedLoops, heights, options.edgeLength);
+  if (!compatible) return null;
+  const { rings, cornerColumns } = compatible;
+  const N = rings[0].length;
+  if (N < 3) return null;
+  const rows = buildSpanRows(rings, heights);
+  const R = rows.length;
+  const cornerSet = new Set(cornerColumns);
+  const vertProps = [];
+  let vertCount = 0;
+  const fwdIdx = [];
+  const bwdIdx = [];
+  const pushVert = (p2, n) => {
+    vertProps.push(p2[0], p2[1], p2[2], n[0], n[1], n[2]);
+    return vertCount++;
+  };
+  for (let r = 0; r < R; r++) {
+    const { points, tangents } = rows[r];
+    const fwd = new Array(N);
+    const bwd = new Array(N);
+    for (let j = 0; j < N; j++) {
+      const prev = points[(j - 1 + N) % N];
+      const curr = points[j];
+      const next = points[(j + 1) % N];
+      if (cornerSet.has(j)) {
+        const nFwd = surfaceNormal(sub3(next, curr), tangents[j]);
+        const nBwd = surfaceNormal(sub3(curr, prev), tangents[j]);
+        fwd[j] = pushVert(curr, nFwd);
+        bwd[j] = pushVert(curr, nBwd);
+      } else {
+        const idx = pushVert(curr, surfaceNormal(sub3(next, prev), tangents[j]));
+        fwd[j] = idx;
+        bwd[j] = idx;
+      }
     }
+    fwdIdx.push(fwd);
+    bwdIdx.push(bwd);
   }
-  for (let i = 0; i < resampled.length - 1; i++) {
-    const baseIdx = i * N;
-    const nextIdx = (i + 1) * N;
+  const triangles = [];
+  for (let r = 0; r < R - 1; r++) {
     for (let j = 0; j < N; j++) {
       const j1 = (j + 1) % N;
-      const v0 = baseIdx + j;
-      const v1 = nextIdx + j;
-      const v2 = nextIdx + j1;
-      const v3 = baseIdx + j1;
+      const v0 = fwdIdx[r][j];
+      const v3 = bwdIdx[r][j1];
+      const v2 = bwdIdx[r + 1][j1];
+      const v1 = fwdIdx[r + 1][j];
       triangles.push(v0, v3, v2);
       triangles.push(v0, v2, v1);
     }
   }
-  const bottomResampled2D = resampled[0].map(([x2, y2]) => [x2, y2]);
-  const bottomTrisResampled = wasm.triangulate([bottomResampled2D]);
-  for (const tri of bottomTrisResampled) {
+  const bottomRing = rows[0].points;
+  const topRing = rows[R - 1].points;
+  const bottom2D = bottomRing.map(([x2, y2]) => [x2, y2]);
+  const bottomTris = wasm.triangulate([bottom2D]);
+  const bottomBase = vertCount;
+  for (const p2 of bottomRing) pushVert(p2, [0, 0, -1]);
+  for (const tri of bottomTris) {
     const [v0, v1, v2] = Array.isArray(tri) ? tri : [tri[0], tri[1], tri[2]];
-    triangles.push(v0, v2, v1);
+    triangles.push(bottomBase + v0, bottomBase + v2, bottomBase + v1);
   }
-  const topResampled2D = resampled[resampled.length - 1].map(([x2, y2]) => [x2, y2]);
-  const topTrisResampled = wasm.triangulate([topResampled2D]);
-  const topStartIdx = (resampled.length - 1) * N;
-  for (const tri of topTrisResampled) {
+  const top2D = topRing.map(([x2, y2]) => [x2, y2]);
+  const topTris = wasm.triangulate([top2D]);
+  const topBase = vertCount;
+  for (const p2 of topRing) pushVert(p2, [0, 0, 1]);
+  for (const tri of topTris) {
     const [v0, v1, v2] = Array.isArray(tri) ? tri : [tri[0], tri[1], tri[2]];
-    triangles.push(topStartIdx + v0, topStartIdx + v1, topStartIdx + v2);
+    triangles.push(topBase + v0, topBase + v1, topBase + v2);
   }
   const mesh = new wasm.Mesh({
-    numProp: 3,
-    vertProperties: new Float32Array(vertices),
+    numProp: 6,
+    vertProperties: new Float32Array(vertProps),
     triVerts: new Uint32Array(triangles)
   });
   try {
+    mesh.merge();
     const manifold = new wasm.Manifold(mesh);
     return manifold;
   } catch (_e2) {
     return null;
   }
 }
+function surfaceNormal(chord, span) {
+  const n = cross3$1(chord, span);
+  const len = Math.hypot(n[0], n[1], n[2]);
+  if (len < 1e-12) {
+    const radial = Math.hypot(chord[0], chord[1]);
+    if (radial > 1e-12) return [chord[1] / radial, -chord[0] / radial, 0];
+    return [0, 0, 1];
+  }
+  return [n[0] / len, n[1] / len, n[2] / len];
+}
+function sub3(a2, b) {
+  return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
+}
+function add3(a2, b) {
+  return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
+}
+function scale3(a2, s) {
+  return [a2[0] * s, a2[1] * s, a2[2] * s];
+}
+function cross3$1(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 dist3(a2, b) {
+  return Math.hypot(a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]);
+}
+function angleBetween(a2, b) {
+  const la = Math.hypot(a2[0], a2[1], a2[2]);
+  const lb = Math.hypot(b[0], b[1], b[2]);
+  if (la < 1e-12 || lb < 1e-12) return 0;
+  const dot2 = (a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2]) / (la * lb);
+  return Math.acos(Math.min(1, Math.max(-1, dot2))) * 180 / Math.PI;
+}
+function resamplePolygon(poly, targetCount) {
+  if (poly.length < 2) return poly;
+  if (targetCount <= 0) return [];
+  const dists = [0];
+  for (let i = 0; i < poly.length; i++) {
+    const p1 = poly[i];
+    const p2 = poly[(i + 1) % poly.length];
+    const dx = p2[0] - p1[0];
+    const dy = p2[1] - p1[1];
+    const d2 = Math.sqrt(dx * dx + dy * dy);
+    dists.push(dists[dists.length - 1] + d2);
+  }
+  const totalDist = dists[dists.length - 1];
+  if (totalDist < 1e-12) {
+    return Array.from({ length: targetCount }, () => [poly[0][0], poly[0][1]]);
+  }
+  const out = [];
+  for (let i = 0; i < targetCount; i++) {
+    const targetDist = i / targetCount * totalDist;
+    let low = 0;
+    let high = dists.length - 1;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (dists[mid] <= targetDist) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    const seg = low - 1;
+    const t = (targetDist - dists[seg]) / (dists[seg + 1] - dists[seg]);
+    const p1 = poly[seg % poly.length];
+    const p2 = poly[(seg + 1) % poly.length];
+    out.push([p1[0] + (p2[0] - p1[0]) * t, p1[1] + (p2[1] - p1[1]) * t]);
+  }
+  return out;
+}
 function sweepStitched(profilePolygons, pathPoints, up, wasm) {
   if (pathPoints.length < 2) return null;
   if (profilePolygons.length === 0) return null;
@@ -46311,7 +46980,7 @@ function lowerOffsetLoftCompilePlan(plan, thickness, wasm) {
     throw new Error("offsetSolid() collapsed the compatible-loft height span.");
   }
   const offsetPolygons = plan.profiles.map((profile) => offsetProfilePolygonsForManifold(profile, thickness, wasm));
-  const stitched = loftStitched(offsetPolygons, heights, wasm);
+  const stitched = loftStitched(offsetPolygons, heights, wasm, { edgeLength: plan.edgeLength });
   if (!stitched) {
     throw new Error(`Offset solid requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
   }
@@ -46446,12 +47115,12 @@ function lowerShapeLoftCompilePlan(plan, wasm) {
       disposeWasmObject(crossSection);
     }
   });
-  if (inputPolygons.length >= 2) {
-    const stitched = loftStitched(inputPolygons, plan.heights, wasm);
+  if (!plan.forceField && inputPolygons.length >= 2) {
+    const stitched = loftStitched(inputPolygons, plan.heights, wasm, { edgeLength: plan.edgeLength });
     if (stitched) return stitched;
   }
   const input = buildLoftLevelSetInput(inputPolygons, plan.heights, { edgeLength: plan.edgeLength, boundsPadding: plan.boundsPadding });
-  return lowerSdfToManifold(levelSetFieldToStandardSdf3(input.sdf), input.bounds, input.edgeLength, wasm);
+  return lowerSdfToManifold(levelSetFieldToStandardSdf3(input.sdf), input.bounds, input.edgeLength, wasm, plan.meshing);
 }
 function lowerShapeSweepCompilePlan(plan, wasm) {
   const crossSection = lowerProfileCompilePlanToCrossSection(plan.profile, wasm);
@@ -46716,7 +47385,7 @@ function lowerFromSlicesToManifold(plan, wasm) {
       }
     });
     const heights = sorted.map((s) => s.offset);
-    const stitched = polygons.length >= 2 ? loftStitched(polygons, heights, wasm) : null;
+    const stitched = polygons.length >= 2 ? loftStitched(polygons, heights, wasm, { edgeLength: plan.edgeLength }) : null;
     if (stitched) {
       solid = stitched;
     } else {
@@ -47157,17 +47826,21 @@ function lowerSdfToManifold(evalFn, bounds, edgeLength2, wasm, meshing, evaluato
   if (diagnostics) diagnostics.projectionMs = nowMs() - projectionStart;
   const simplificationStart = nowMs();
   if (((meshing == null ? void 0 : meshing.simplify) ?? "safe") !== "off" && snMesh.numTris > 100) {
-    triVerts = simplifySdfMesh(triVerts, snMesh.vertProperties, edgeLength2, wasm, meshing == null ? void 0 : meshing.maxTriangles);
+    triVerts = simplifySdfMesh(triVerts, snMesh.vertProperties, vertProps6, edgeLength2, meshing == null ? void 0 : meshing.maxTriangles);
   }
   if (diagnostics) {
     diagnostics.simplificationMs = nowMs() - simplificationStart;
     diagnostics.trianglesAfterSimplification = triVerts.length / 3;
   }
   if ((meshing == null ? void 0 : meshing.maxTriangles) !== void 0 && triVerts.length / 3 > meshing.maxTriangles) {
+    const verb = (meshing.simplify ?? "safe") === "off" ? "produced" : "could only simplify to";
     throw new Error(
-      `SDF meshing produced ${triVerts.length / 3} triangles, above maxTriangles=${meshing.maxTriangles}. Increase maxTriangles, use a larger edgeLength, or choose quality: "draft".`
+      `SDF meshing ${verb} ${triVerts.length / 3} safe triangles, above maxTriangles=${meshing.maxTriangles}. Increase maxTriangles or use a larger edgeLength.`
     );
   }
+  if (!isClosedConsistentlyWoundTriangleMesh(triVerts, vertProps6.length / 6)) {
+    throw new Error("SDF meshing produced an open, non-manifold, or inconsistently wound triangle mesh.");
+  }
   const wasmMesh = new wasm.Mesh({
     numProp: 6,
     vertProperties: vertProps6,
@@ -47185,28 +47858,102 @@ function lowerSdfToManifold(evalFn, bounds, edgeLength2, wasm, meshing, evaluato
     disposeWasmObject(wasmMesh);
   }
 }
-function simplifySdfMesh(triVerts, vertProperties, edgeLength2, wasm, maxTriangles) {
+function simplifySdfMesh(triVerts, vertProperties, finalVertProperties, edgeLength2, maxTriangles) {
   const maxError = edgeLength2 * 0.15;
   const inputTriangles = triVerts.length / 3;
-  const requestedRatio = maxTriangles && maxTriangles < inputTriangles ? maxTriangles / inputTriangles : 0.5;
-  const ratios = Array.from(/* @__PURE__ */ new Set([Math.max(0.05, Math.min(0.5, requestedRatio)), 0.75]));
+  const ratios = buildSimplificationRatios(inputTriangles, maxTriangles);
+  const vertexCount = finalVertProperties.length / 6;
+  let bestValid = null;
   for (const ratio of ratios) {
-    let simplified = simplifyMesh(triVerts, vertProperties, ratio, maxError);
-    simplified = filterDegenerateTriangles(simplified);
-    let mesh = null;
-    let manifold = null;
+    let simplified;
     try {
-      mesh = new wasm.Mesh({ numProp: 3, vertProperties, triVerts: simplified });
-      manifold = new wasm.Manifold(mesh);
-      return simplified;
+      simplified = simplifyMesh(triVerts, vertProperties, ratio, maxError);
     } catch {
-    } finally {
-      disposeWasmObject(manifold);
-      disposeWasmObject(mesh);
+      continue;
+    }
+    simplified = filterDegenerateTriangles(simplified);
+    if (isClosedConsistentlyWoundTriangleMesh(simplified, vertexCount)) {
+      if (maxTriangles === void 0 || simplified.length / 3 <= maxTriangles) {
+        return simplified;
+      }
+      if (!bestValid || simplified.length < bestValid.length) {
+        bestValid = simplified;
+      }
     }
   }
+  if (bestValid) {
+    return bestValid;
+  }
   return triVerts;
 }
+function buildSimplificationRatios(inputTriangles, maxTriangles) {
+  if (maxTriangles === void 0 || maxTriangles >= inputTriangles) {
+    return [0.5, 0.75];
+  }
+  const requestedRatio = Math.max(1 / inputTriangles, Math.min(0.5, maxTriangles / inputTriangles));
+  const candidates = [
+    requestedRatio,
+    0.05,
+    0.04,
+    0.03,
+    0.02,
+    0.015,
+    0.01,
+    5e-3,
+    requestedRatio * 0.85,
+    requestedRatio * 0.7,
+    requestedRatio * 0.55,
+    requestedRatio * 0.4,
+    requestedRatio * 0.25,
+    requestedRatio * 0.1,
+    0.5,
+    0.75
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const ratios = [];
+  for (const ratio of candidates) {
+    const rounded = Number(Math.max(1 / inputTriangles, Math.min(0.75, ratio)).toFixed(6));
+    if (seen.has(rounded)) continue;
+    seen.add(rounded);
+    ratios.push(rounded);
+  }
+  return ratios;
+}
+function isClosedConsistentlyWoundTriangleMesh(triVerts, vertexCount) {
+  if (triVerts.length === 0 || triVerts.length % 3 !== 0) return false;
+  const edgeUse = /* @__PURE__ */ new Map();
+  for (let i = 0; i < triVerts.length; i += 3) {
+    const a2 = triVerts[i];
+    const b = triVerts[i + 1];
+    const c2 = triVerts[i + 2];
+    if (!isValidMeshIndex(a2, vertexCount) || !isValidMeshIndex(b, vertexCount) || !isValidMeshIndex(c2, vertexCount)) return false;
+    if (a2 === b || b === c2 || a2 === c2) return false;
+    for (const [from, to] of [
+      [a2, b],
+      [b, c2],
+      [c2, a2]
+    ]) {
+      const lo = Math.min(from, to);
+      const hi = Math.max(from, to);
+      const key = `${lo}/${hi}`;
+      const winding = from === lo ? 1 : -1;
+      const entry = edgeUse.get(key);
+      if (entry) {
+        entry.count += 1;
+        entry.winding += winding;
+      } else {
+        edgeUse.set(key, { count: 1, winding });
+      }
+    }
+  }
+  for (const entry of edgeUse.values()) {
+    if (entry.count !== 2 || entry.winding !== 0) return false;
+  }
+  return true;
+}
+function isValidMeshIndex(value, vertexCount) {
+  return Number.isInteger(value) && value >= 0 && value < vertexCount;
+}
 function filterDegenerateTriangles(triVerts) {
   let writeIdx = 0;
   for (let i = 0; i < triVerts.length; i += 3) {
@@ -48788,6 +49535,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;
@@ -48840,7 +49673,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;
@@ -48865,6 +49698,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);
 }
@@ -49045,16 +49907,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) {
@@ -49073,6 +49942,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,
@@ -49089,10 +49968,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
   };
@@ -49103,6 +49987,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";
@@ -49111,18 +50005,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();
@@ -49508,15 +50393,23 @@ function computeGeometryArrays(mesh, options = {}) {
       normals[o + 7] = vertNormals[i2 * 3 + 1];
       normals[o + 8] = vertNormals[i2 * 3 + 2];
     } else if (numProp >= 6) {
-      normals[o] = vertProperties[i0 * numProp + 3];
-      normals[o + 1] = vertProperties[i0 * numProp + 4];
-      normals[o + 2] = vertProperties[i0 * numProp + 5];
-      normals[o + 3] = vertProperties[i1 * numProp + 3];
-      normals[o + 4] = vertProperties[i1 * numProp + 4];
-      normals[o + 5] = vertProperties[i1 * numProp + 5];
-      normals[o + 6] = vertProperties[i2 * numProp + 3];
-      normals[o + 7] = vertProperties[i2 * numProp + 4];
-      normals[o + 8] = vertProperties[i2 * numProp + 5];
+      const corners = [i0, i1, i2];
+      for (let v = 0; v < 3; v++) {
+        const base = corners[v] * numProp;
+        const nx = vertProperties[base + 3];
+        const ny = vertProperties[base + 4];
+        const nz = vertProperties[base + 5];
+        const oc = o + v * 3;
+        if (nx * nx + ny * ny + nz * nz > 1e-12) {
+          normals[oc] = nx;
+          normals[oc + 1] = ny;
+          normals[oc + 2] = nz;
+        } else {
+          normals[oc] = fnx;
+          normals[oc + 1] = fny;
+          normals[oc + 2] = fnz;
+        }
+      }
     } else {
       normals[o] = fnx;
       normals[o + 1] = fny;
@@ -49986,7 +50879,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);
@@ -49994,7 +50887,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);
@@ -50078,11 +50975,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;
@@ -50090,9 +50991,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)));
@@ -50105,13 +51006,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;
@@ -50157,6 +51059,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;
@@ -50165,8 +51068,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);
@@ -50191,6 +51095,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);
@@ -50198,13 +51103,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,
@@ -50215,7 +51129,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,
@@ -50225,6 +51141,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) => ({
@@ -50391,7 +51348,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])
@@ -50399,6 +51360,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 = {