forgecad 0.9.15 → 0.10.0

package/dist/assets/{constructionHistoryWorker-gpDo-uH2.js → constructionHistoryWorker-AwMMWSxg.js}

@@ -7603,7 +7603,7 @@ function requireNonZeroFiniteScale3(value, label) {
   }
   return scale2;
 }
-const EPS$4 = 1e-10;
+const EPS$3 = 1e-10;
 function subVec3(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
@@ -7629,7 +7629,7 @@ function projectRadial(v, axis) {
 function signedAngleAroundAxis(from, to, axis) {
   const fromLen = lengthVec3$1(from);
   const toLen = lengthVec3$1(to);
-  if (fromLen < EPS$4 || toLen < EPS$4) return 0;
+  if (fromLen < EPS$3 || toLen < EPS$3) return 0;
   const fn = scaleVec3(from, 1 / fromLen);
   const tn = scaleVec3(to, 1 / toLen);
   const sin2 = dotVec3$4(axis, crossVec3$2(fn, tn));
@@ -7650,19 +7650,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$4) {
-    if (mode === "line" && targetRadialLen >= EPS$4) {
+  if (movingRadialLen < EPS$3) {
+    if (mode === "line" && targetRadialLen >= EPS$3) {
       throw new Error("rotateAroundTo(...): moving point lies on the rotation axis, so line alignment is impossible");
     }
     return 0;
   }
   if (mode === "plane") {
-    if (targetRadialLen < EPS$4) {
+    if (targetRadialLen < EPS$3) {
       throw new Error("rotateAroundTo(...): target point lies on the rotation axis, so the target plane is undefined");
     }
     return signedAngleAroundAxis(movingDecomp.radial, targetDecomp.radial, unitAxis);
   }
-  if (targetRadialLen < EPS$4) {
+  if (targetRadialLen < EPS$3) {
     throw new Error("rotateAroundTo(...): target line lies on the rotation axis, but the moving point does not");
   }
   const axialTol = 1e-8 * Math.max(1, Math.abs(movingDecomp.axial), Math.abs(targetDecomp.axial));
@@ -7699,7 +7699,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$4) throw new Error("Axis must be non-zero");
+  if (len < EPS$3) throw new Error("Axis must be non-zero");
   return [v[0] / len, v[1] / len, v[2] / len];
 }
 function transformPoint(m2, p2, w2) {
@@ -7729,7 +7729,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$4) throw new Error("Transform matrix is not invertible");
+  if (Math.abs(det) < EPS$3) throw new Error("Transform matrix is not invertible");
   const invDet = 1 / det;
   out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet;
   out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * invDet;
@@ -7762,6 +7762,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([
@@ -7845,6 +7871,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));
   }
@@ -9020,6 +9047,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",
@@ -9104,7 +9133,7 @@ function cloneSdfNode(node) {
   }
 }
 const SHEET_METAL_EDGES = ["top", "right", "bottom", "left"];
-const EPS$3 = 1e-9;
+const EPS$2 = 1e-9;
 function isFinitePositive$1(value) {
   return Number.isFinite(value) && value > 0;
 }
@@ -9145,7 +9174,7 @@ function edgeDisplayName(edge) {
   return `sheetMetal().flange("${edge}", ...)`;
 }
 function normalizeAngle(angleDeg) {
-  return Math.abs(angleDeg) <= EPS$3 ? 0 : angleDeg;
+  return Math.abs(angleDeg) <= EPS$2 ? 0 : angleDeg;
 }
 function validateSheetMetalModel(model) {
   if (!isFinitePositive$1(model.panel.width) || !isFinitePositive$1(model.panel.height)) {
@@ -9157,7 +9186,7 @@ function validateSheetMetalModel(model) {
   if (!isFiniteNonNegative(model.bendRadius)) {
     return "sheetMetal() requires a finite non-negative bendRadius.";
   }
-  if (model.bendRadius <= EPS$3) {
+  if (model.bendRadius <= EPS$2) {
     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") {
@@ -9219,7 +9248,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$3)) {
+    if (!(span > EPS$2)) {
       throw new Error(
         `${edgeDisplayName(edge)} loses all usable span after applying the defended rectangular corner relief size ${model.cornerRelief.size}.`
       );
@@ -9265,7 +9294,7 @@ function transformPlacement(origin, u2, v, normal) {
   };
 }
 function translatePlan(plan, x2, y2, z2) {
-  if (Math.abs(x2) <= EPS$3 && Math.abs(y2) <= EPS$3 && Math.abs(z2) <= EPS$3) return cloneShapeCompilePlan(plan);
+  if (Math.abs(x2) <= EPS$2 && Math.abs(y2) <= EPS$2 && Math.abs(z2) <= EPS$2) return cloneShapeCompilePlan(plan);
   return appendShapeCompileTransform(cloneShapeCompilePlan(plan), {
     kind: "translate",
     x: x2,
@@ -10437,6 +10466,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
       };
@@ -10704,7 +10735,6 @@ function cloneShapeCompilePlan(plan) {
     default:
       assertExhaustive(plan);
   }
-  if (plan._occtCache) result._occtCache = plan._occtCache;
   return result;
 }
 function appendProfileCompileTransform(plan, step) {
@@ -10717,22 +10747,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;
@@ -10806,6 +10845,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
   };
 }
@@ -10907,14 +10948,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);
 }
@@ -11190,13 +11231,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) {
@@ -11275,7 +11316,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;
@@ -11572,7 +11613,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];
@@ -13511,7 +13552,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]) };
 }
@@ -13649,6 +13692,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_GEOMETRY_CACHE_KEY_VERSION = "shape-geometry-v1";
 const SHAPE_BUILD_CACHE_POLICY = "live-structural-lru-v1";
 const STRUCTURAL_CACHE_BUDGET_MB = 64;
@@ -13694,60 +13928,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;
@@ -13806,8 +14006,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);
 }
@@ -13825,26 +14024,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) {
@@ -14521,8 +14756,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":
@@ -15058,6 +15294,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 ?? {});
@@ -15551,6 +15792,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));
@@ -15699,6 +15944,7 @@ function getUnsupportedSdfProgramReason(node) {
     case "sdf:bend":
     case "sdf:repeat":
     case "sdf:shell":
+    case "sdf:offset":
     case "sdf:onion":
       return getUnsupportedSdfProgramReason(node.child);
     default:
@@ -16140,7 +16386,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,
@@ -17117,117 +17375,10 @@ function buildSweepLevelSetInput(profilePolygons, pathInput, options) {
     edgeLength: options.edgeLength
   };
 }
-const EPS$1 = 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$3(direction, edge);
-    if (Math.abs(denom) < EPS$1) continue;
-    const delta = [a2[0] - origin[0], a2[1] - origin[1]];
-    const rayT = cross$3(delta, edge) / denom;
-    const edgeT = cross$3(delta, direction) / denom;
-    if (rayT >= -EPS$1 && edgeT >= -EPS$1 && edgeT <= 1 + EPS$1 && 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$3(a2, b);
-    area2 += crossValue;
-    cx += (a2[0] + b[0]) * crossValue;
-    cy += (a2[1] + b[1]) * crossValue;
-  }
-  if (Math.abs(area2) < EPS$1) 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$3([b[0] - a2[0], b[1] - a2[1]], [c2[0] - b[0], c2[1] - b[1]]);
-    if (Math.abs(turn) < EPS$1) continue;
-    const currentSign = Math.sign(turn);
-    if (sign !== 0 && currentSign !== sign) return false;
-    sign = currentSign;
-  }
-  return sign !== 0;
-}
-function cross$3(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;
@@ -17242,7 +17393,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;
@@ -17259,7 +17410,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();
@@ -17345,68 +17496,527 @@ function signedArea$3(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$5(sub3$1(b, a2), sub3$1(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$1(sub3$1(stations[1][j], stations[0][j]), 1 / (t[1] - t[0]));
+  }
+  if (i === R - 1) {
+    return scale3$1(sub3$1(stations[R - 1][j], stations[R - 2][j]), 1 / (t[R - 1] - t[R - 2]));
+  }
+  const hPrev = t[i] - t[i - 1];
+  const hNext = t[i + 1] - t[i];
+  const dPrev = scale3$1(sub3$1(stations[i][j], stations[i - 1][j]), 1 / hPrev);
+  const dNext = scale3$1(sub3$1(stations[i + 1][j], stations[i][j]), 1 / hNext);
+  return scale3$1(add3$1(scale3$1(dPrev, hNext), scale3$1(dNext, hPrev)), 1 / (hPrev + hNext));
+}
+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$3(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$1(next, curr), tangents[j]);
+        const nBwd = surfaceNormal(sub3$1(curr, prev), tangents[j]);
+        fwd[j] = pushVert(curr, nFwd);
+        bwd[j] = pushVert(curr, nBwd);
+      } else {
+        const idx = pushVert(curr, surfaceNormal(sub3$1(next, prev), tangents[j]));
+        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$5(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$1(a2, b) {
+  return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
+}
+function add3$1(a2, b) {
+  return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
+}
+function scale3$1(a2, s) {
+  return [a2[0] * s, a2[1] * s, a2[2] * s];
+}
+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 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;
+}
 let _wasm$1 = null;
 async function initManifoldWasm() {
   if (_wasm$1) return _wasm$1;
@@ -17512,7 +18122,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);
@@ -17561,6 +18173,43 @@ function requireManifoldShapeBackend(backend, apiName = "requireManifoldShapeBac
   }
   throw new Error(`${apiName} currently requires a Manifold-backed runtime shape.`);
 }
+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;
@@ -18258,7 +18907,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}`);
   }
@@ -18393,12 +19042,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);
@@ -18663,7 +19312,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 {
@@ -19104,17 +19753,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,
@@ -19132,28 +19785,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) {
@@ -20367,11 +21094,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) {
@@ -36471,29 +37199,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 = [];
@@ -39346,7 +40056,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()");
@@ -39591,6 +40301,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?)`
@@ -41255,10 +41970,10 @@ function rigidTransformStepsFromMatrix(m2) {
   return [{ kind: "workplanePlacement", matrix: Array.from(m2) }];
 }
 async function initKernel() {
-  const [manifoldModule] = await Promise.all([initManifoldWasm(), initMeshoptimizer(), initTruckGeometryWasm()]);
+  const [manifoldModule] = await Promise.all([initManifoldWasm(), initMeshoptimizer()]);
   return manifoldModule;
 }
-const DEFAULT_ACTIVE_BACKEND = "truck";
+const DEFAULT_ACTIVE_BACKEND = "manifold";
 let _activeBackend = DEFAULT_ACTIVE_BACKEND;
 let _runtimeWarn = (msg) => console.warn(msg);
 async function activateBackend(backend) {
@@ -41285,6 +42000,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();
@@ -41345,6 +42061,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.`);
@@ -41413,50 +42133,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;
@@ -41476,13 +42171,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);
     }
   }
 }
@@ -41517,7 +42219,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());
@@ -42209,6 +42911,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));
@@ -42223,6 +42949,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));
 }
@@ -42252,6 +42979,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));
 }
@@ -42679,6 +43407,7 @@ class Shape {
     this.colorHex = color;
     setShapeRuntimeBackendInternal(this, payload);
     setShapeGeometryInfoInternal(this, createGeometryInfo(geometryInfo));
+    _shapeLineageTokens.set(this, {});
   }
   /** @internal Use .color() instead. */
   setColor(value) {
@@ -42797,6 +43526,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.
@@ -43213,7 +43948,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()");
@@ -43400,7 +44135,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()) {
@@ -43413,8 +44148,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
           );
         }
       }
@@ -43474,7 +44216,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(). */
@@ -43877,6 +44619,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?)`
@@ -44254,15 +45001,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;