partforge 0.64.0 → 0.64.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.64.0",
+  "version": "0.64.1",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/framework/geometry/contour-offset.js

@@ -826,14 +826,26 @@ function sourceBackedPositiveRegions(source, out, delta) {
 
 // Crossing clustering can snap both ends of a tiny curve run onto the same pool vertex.
 // The run then survives as a closed loop attached at one point (or as a whole one-segment
-// contour). It encloses only geometry inside the resolver's own 2*CLUSTER_TOL cluster-
-// diameter uncertainty, but a downstream cap triangulator may bridge that loop across the
-// face and expose the bridge as a bogus feature edge. Positive dilation may discard these
-// sub-resolution counter loops: they are collapsed negative boundaries, never new material.
-// Keep erosion unchanged; its tiny surviving islands have no equivalent source-domain proof.
+// contour). It encloses only geometry inside the resolver's own splice uncertainty, but a
+// downstream cap triangulator may bridge that loop across the face and expose the bridge
+// as a bogus feature edge — and a surviving zero-chord loop also breaks the NEXT offset or
+// boolean over this output (its crossing chaining reads the loop as an unclosable
+// arrangement: the "could not chain offset boundary" class of failure). Positive dilation
+// may discard these sub-resolution counter loops: they are collapsed negative boundaries,
+// never new material. Keep erosion unchanged; its tiny surviving islands have no
+// equivalent source-domain proof.
+//
+// The radius is 10*CLUSTER_TOL, not the 2*CLUSTER_TOL cluster-diameter bound this pass
+// shipped with: the CROSSINGS that got merged sit within one cluster, but the curve run
+// BETWEEN them wanders further before returning — measured on offset(6, round) of
+// "Scotty" size 24 (test/contour-cleanup.test.js), the surviving splice loops reached
+// 0.028 mm of control extent, 5.6x the old radius, and every one of them slipped this
+// pass. 10x (0.05 mm) covers them with margin while staying far below any printable
+// feature; a genuine pinch-off lobe bigger than that survives as its own region ring and
+// never presents as a single zero-chord segment in the first place.
 function dropSubresolutionPositiveLoops(out, delta) {
   if (delta <= 0) return out;
-  const radius = 2 * CLUSTER_TOL;
+  const radius = 10 * CLUSTER_TOL;
   const clean = (contour) => {
     const segments = [];
     let from = contour.start;

package/src/framework/geometry/contour-ops.js

@@ -656,7 +656,34 @@ function simplifyRun(scope, from, segs, tolerance) {
   return refitRunViaPaper(scope, from, segs, tolerance);
 }
 
-function simplifyContour(scope, contour, tolerance) {
+// Sweep segments whose ENTIRE extent (endpoint and every control point) stays within the
+// caller's tolerance of their own start — degenerate loop-backs and dust segments. These
+// are exactly the artifacts an upstream offset/boolean can leave behind (the winding
+// resolver's splice debris: zero-chord cubics with controls ~0.01-0.03 mm out), and
+// without this pass they DEFEAT simplify: contourCorners reads the loop's joints as real
+// corners, and the corner-preserving contract then pins the debris bit-exact, so
+// `.simplify(0.03)` used to return a 0.02 mm loop untouched. Dropping a segment moves the
+// path by at most its chord (≤ tolerance) — precisely the change the caller authorized.
+// Everything larger than the tolerance is geometry, not debris, and passes through.
+function sweepDegenerateSegments(contour, tolerance) {
+  const segments = [];
+  let from = contour.start;
+  for (const seg of contour.segments) {
+    const controls = [seg.via, seg.c1, seg.c2].filter(Boolean);
+    const extent = Math.max(
+      Math.hypot(seg.to[0] - from[0], seg.to[1] - from[1]),
+      ...controls.map((p) => Math.hypot(p[0] - from[0], p[1] - from[1])),
+    );
+    if (extent <= tolerance) continue;              // debris: path continues from `from`
+    segments.push(seg);
+    from = seg.to;
+  }
+  if (segments.length < 2) return contour;          // a ring of dust is not ours to delete
+  return closeContourGap({ start: [contour.start[0], contour.start[1]], segments });
+}
+
+function simplifyContour(scope, rawContour, tolerance) {
+  const contour = sweepDegenerateSegments(rawContour, tolerance);
   const corners = contourCorners(contour);
   if (corners.length === 0) {
     // Cornerless (smooth closed loop): simplify as ONE closed path — toPaperPath's default

package/src/framework/geometry/profile.js

@@ -118,14 +118,36 @@ export function sampleBezier(p0, c1, c2, p1, segs) {
   recurse(p0, c1, c2, p1, 0);
   if (out.length === 0) out.push([p1[0], p1[1]]);
   out[out.length - 1] = [p1[0], p1[1]];   // pin the exact endpoint
-  return out;
+  // Emit-if-moved: near a cusp (a degenerate loop-back cubic — e.g. the winding
+  // resolver's splice debris, start === end with controls ~0.01 mm out) the curve's
+  // SPEED collapses, so depth-capped parameter-uniform splits cluster spatially and
+  // the raw list carries runs of samples nanometers apart (measured min gap 2e-9 mm).
+  // Those land in tessellated rings as coincident points and poison every consumer
+  // (sliver wall facets, mesh edge chains, ring dedup). Keep a sample only once it has
+  // moved SAMPLE_EPS from the last kept one; the exact endpoint stays pinned — it
+  // replaces a final sample that stopped short of it, so the one pair flanking the pin
+  // may be tighter than SAMPLE_EPS, and that is the only pair allowed to be. 1e-6 mm is
+  // a nanometer: far below any legitimate facet spacing (a 1 µm-radius arc at segs 96
+  // still spaces ~6e-5), so no real curve loses a sample.
+  const SAMPLE_EPS = 1e-6;
+  const kept = [];
+  let last = p0;
+  for (const p of out) {
+    if (Math.hypot(p[0] - last[0], p[1] - last[1]) < SAMPLE_EPS) continue;
+    kept.push(p);
+    last = p;
+  }
+  if (kept.length && Math.hypot(kept[kept.length - 1][0] - p1[0], kept[kept.length - 1][1] - p1[1]) < SAMPLE_EPS)
+    kept[kept.length - 1] = [p1[0], p1[1]];
+  else kept.push([p1[0], p1[1]]);
+  return kept;
 }
 
 // Tessellate a single contour into a CCW point ring. A legacy array is returned unchanged
 // (identical to the former path); a path contour is walked start→segment→segment, lines
 // pushing their `to`, arcs and cubics pushing their sampled points (sampleArc/sampleBezier).
 export function tessellateContour(contour, segs) {
-  if (Array.isArray(contour)) return contour;
+  if (Array.isArray(contour)) return contour;   // legacy point list: caller's data, bit-exact
   const ring = [[contour.start[0], contour.start[1]]];
   let prev = contour.start;
   for (const seg of contour.segments) {
@@ -134,7 +156,27 @@ export function tessellateContour(contour, segs) {
     else ring.push([seg.to[0], seg.to[1]]);
     prev = seg.to;
   }
-  return ring;
+  // Coincident consecutive points never survive tessellation: a zero-length line segment
+  // (or a sampler edge case) would otherwise land verbatim in the ring and hand every
+  // consumer (extrude walls, mesh edge chains, silhouette masks) a degenerate edge. The
+  // very last point is kept unconditionally — it replaces a duplicate predecessor rather
+  // than being dropped — so the explicit-closure convention (final point lands exactly on
+  // `start`) survives the sweep.
+  const TESS_EPS = 1e-9;
+  const out = [ring[0]];
+  for (let i = 1; i < ring.length; i++) {
+    const p = ring[i], last = out[out.length - 1];
+    if (Math.hypot(p[0] - last[0], p[1] - last[1]) < TESS_EPS) {
+      if (i === ring.length - 1) out[out.length - 1] = p;   // keep the exact closure point
+      continue;
+    }
+    out.push(p);
+  }
+  // A path contour always tessellates to ≥2 points (start + arrival), even when the whole
+  // contour is degenerate — consumers walk poly EDGES (contour-winding's pieceSamples) and
+  // a single-point poly has none to walk.
+  if (out.length < 2) return [ring[0], ring[ring.length - 1]];
+  return out;
 }
 
 // Normalize + tessellate a whole region to { outer:[[x,y],…], holes:[[[x,y],…],…] } of