partforge 0.144.0 → 0.144.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.144.0",
+  "version": "0.144.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/blend-surfaces.js

@@ -22,6 +22,12 @@
 //   { kind: "spine", pts, closed, r }
 //                                   general chain (mesh-fillet generalTool): the
 //                                   ball-centre polyline itself; r is the radius
+//   { kind: "planes", planes: [{ n, d }], tol }
+//                                   roundAll's flat faces (mesh-roundall.js
+//                                   flatFacePlanes): a point within tol of one plane
+//                                   (n·x = d) takes its normal; anywhere else — the
+//                                   rounded band off its seams — there is none, and
+//                                   creased-normals keeps the facet average
 //
 // A path's polyline usually STANDS FOR a smooth curve (a circle's rim, an outline's
 // rounded corner): its per-segment cylinders would shade faceted around the curve,
@@ -105,10 +111,32 @@ export function mapSurface(desc, M) {
         M[0] * (M[4] * M[8] - M[5] * M[7]) - M[3] * (M[1] * M[8] - M[2] * M[7]) + M[6] * (M[1] * M[5] - M[2] * M[4])));
       return { kind: "spine", closed: desc.closed, pts: desc.pts.map((p) => applyPt(M, p)), r: desc.r * s };
     }
+    case "planes": {
+      const s = Math.cbrt(Math.abs(
+        M[0] * (M[4] * M[8] - M[5] * M[7]) - M[3] * (M[1] * M[8] - M[2] * M[7]) + M[6] * (M[1] * M[5] - M[2] * M[4])));
+      return { kind: "planes", tol: desc.tol * s, planes: desc.planes.map(({ n, d }) => {
+        const n2 = norm(applyDir(M, n)) ?? n;
+        const p = applyPt(M, [n[0] * d, n[1] * d, n[2] * d]);
+        return { n: n2, d: n2[0] * p[0] + n2[1] * p[1] + n2[2] * p[2] };
+      }) };
+    }
     default: throw new Error(`blend surface: unknown kind ${desc.kind}`);
   }
 }
 
+// The plane x lies on, or null — off every plane, or on two at once (where two
+// flat faces would meet, which a rounded result never shows, so no answer is right).
+function planeNormal(desc, x) {
+  let hit = null;
+  for (const pl of desc.planes) {
+    const n = pl.n;
+    if (Math.abs(n[0] * x[0] + n[1] * x[1] + n[2] * x[2] - pl.d) > desc.tol) continue;
+    if (hit) return null;
+    hit = n;
+  }
+  return hit;
+}
+
 // Nearest spine point to x, in the descriptor's own frame.
 function spinePoint(desc, x) {
   switch (desc.kind) {
@@ -240,6 +268,7 @@ function nearestSegment(desc, x) {
 // Unit spine→point direction at x in the descriptor's frame, or null where undefined.
 export function surfaceNormal(desc, x) {
   if (desc.kind === "path") return pathNormal(desc, x);
+  if (desc.kind === "planes") return planeNormal(desc, x);
   if (desc.kind === "spine") {
     const { bi, bt } = nearestSegment(desc, x);
     if (bi < 0) return null;

package/src/framework/geometry/manifold-backend.js

@@ -18,8 +18,8 @@ import { meshToStl } from "./mesh-stl.js";
 import { creasedNormals } from "./creased-normals.js";
 import { loftShadingPolicy, SMOOTH, BLEND } from "./shading-policy.js";
 import { meshFillet, meshChamfer, UnsupportedEdgeError } from "./mesh-fillet.js";
-import { affineAt, invertAffine, mapSurface } from "./blend-surfaces.js";
-import { meshRoundAll, prismSection, roundAllSegs } from "./mesh-roundall.js";
+import { affineAt, IDENTITY, invertAffine, mapSurface } from "./blend-surfaces.js";
+import { flatFacePlanes, meshRoundAll, prismSection, roundAllSegs } from "./mesh-roundall.js";
 import { SEGS, circleSegs, doubleCurvatureSegs } from "./circle-segs.js";
 import { checkBooleanResult } from "./boolean-gate.js";
 import { KernelCapabilityError } from "./errors.js";
@@ -294,12 +294,20 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   // round-trip, so the descriptor's original frame stays valid). Folding the band
   // into a single blend id, as this used to, lost every descriptor with it: a labeled
   // fillet shaded with facet normals again.
+  //
+  // "Blend" here is any surface that must keep an id of its own: a fillet band (the
+  // boundaryLines policy) or a surface carrying an analytic descriptor at all —
+  // roundAll's flat-face planes ride on a SMOOTH surface, and folding that into the
+  // base id would drop them and bring the flat-face shading gradient back on every
+  // labeled roundAll. Each keeps the policy it had (none, for the roundAll surface).
+  const keepsOwnId = (oid) => !!oidPolicies.get(oid)?.boundaryLines || blendSurfaces.has(oid);
   const reserveBlendRestamp = (oids) => {
-    const blends = [...oids].filter((oid) => !!oidPolicies.get(oid)?.boundaryLines);
+    const blends = [...oids].filter(keepsOwnId);
     const baseId = Manifold.reserveIDs(1 + blends.length);
     const blendIdFor = new Map(blends.map((oid, i) => [oid, baseId + 1 + i]));
     for (const [oid, id2] of blendIdFor) {
-      oidPolicies.set(id2, BLEND);
+      const pol = oidPolicies.get(oid);
+      if (pol !== undefined) oidPolicies.set(id2, pol);
       const surf = blendSurfaces.get(oid);
       if (surf) blendSurfaces.set(id2, surf);
     }
@@ -405,7 +413,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
           const isBlend = (oid) => !!oidPolicies.get(oid)?.boundaryLines;
           if (![...new Set(g0.runOriginalID)].some(isBlend)) return T(filleted._m.asOriginal());
           const { baseId, blendIdFor } = reserveBlendRestamp(new Set(g0.runOriginalID));
-          g0.runOriginalID = Uint32Array.from(g0.runOriginalID, (o) => (isBlend(o) ? blendIdFor.get(o) : baseId));
+          g0.runOriginalID = Uint32Array.from(g0.runOriginalID, (o) => blendIdFor.get(o) ?? baseId);
           // The constructor re-welds, and that can pinch a latent sliver off a
           // component as fresh femto-debris (the same rebirth dropDebris's own
           // compose() loop guards against) — sweep the reconstruction too.
@@ -423,6 +431,39 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     }
   };
 
+  // The reference roundAll's flat faces (mesh-roundall.js flatFacePlanes): the
+  // input's flat faces, which the chain returns exactly to their planes, become a
+  // "planes" descriptor on the result's surface so creased-normals shades them —
+  // and the band's seams beside them — with the plane's own normal. The tolerance
+  // sits well under the first ring of band vertices off each face (the same ring
+  // meshRoundAll's simplify tolerance protects), so only the face and its seam
+  // vertices are on a plane. Keyed on geometry like every descriptor (see
+  // blendSurfaces above), so it is never removed with the cache entry.
+  const markFlatFaces = (input, out, r) => {
+    const gi = input.getMesh();
+    let planes;
+    try {
+      planes = flatFacePlanes(gi, { policyFor: (oid) => oidPolicies.get(oid) });
+    } finally {
+      gi.delete?.();
+    }
+    if (!planes.length) return out;
+    const segs = roundAllSegs(2 * r, quality);
+    const tol = Math.min(1e-3, 0.25 * r * (1 - Math.cos((2 * Math.PI) / segs)));
+    const go = out.getMesh();
+    try {
+      const roid = go.runOriginalID, rt = go.runTransform;
+      for (let i = 0; i < roid.length; i++) {
+        // a fresh original carries no runTransform at all — identity, as creased-normals reads it
+        const inv = rt && rt.length >= (i + 1) * 12 ? invertAffine(affineAt(rt, i)) : IDENTITY;
+        if (inv) blendSurfaces.set(roid[i], mapSurface({ kind: "planes", planes, tol }, inv));
+      }
+    } finally {
+      go.delete?.();
+    }
+    return out;
+  };
+
   // Replay a recorded transform chain onto a solid. Each record maps back to the op
   // that produced it, so the replayed solid rebuilds the same chain on its own canon.
   const replay = (solid, chain) => chain.reduce(
@@ -503,7 +544,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       // key omits it for the same reason); it just spells out that the ball
       // tessellation, and so the result, is tier-dependent.
       return cached(h("roundAll", hash, r, quality), () =>
-        prismRoundAllFast(m, hash, r) ?? T(meshRoundAll(wasm, m, r, quality)));
+        prismRoundAllFast(m, hash, r) ?? markFlatFaces(m, T(meshRoundAll(wasm, m, r, quality)), r));
     },
     // batch difference: first minus the union of the rest, evaluated as one boolean
     // tree — no materialized intermediate union (the unionRaw memory note applies)
@@ -538,7 +579,6 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
         // fresh so cached-solid reuse under another label cannot collide — the same
         // guarantee asOriginal() gives the plain path below.
         const g0 = m.getMesh();
-        const isBlend = (oid) => !!oidPolicies.get(oid)?.boundaryLines;
         const oids0 = new Set(g0.runOriginalID);
         // Sector-aware re-stamp: a provenance-sectored loft (the `sector` policy
         // marker) must keep every run's identity — folding them (either the plain
@@ -561,14 +601,16 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
             featureLabels.set(newId, name);
             const pol = oidPolicies.get(oldId);
             if (pol !== undefined) oidPolicies.set(newId, pol);
+            const surf = blendSurfaces.get(oldId); // analytic normals ride the 1:1 stamp too
+            if (surf) blendSurfaces.set(newId, surf);
             setIds.push(newId);
           }
           return { value: wrap(o, lh), pin: o, dispose: () => {
-            for (const id2 of setIds) { featureLabels.delete(id2); oidPolicies.delete(id2); }
+            for (const id2 of setIds) { featureLabels.delete(id2); oidPolicies.delete(id2); blendSurfaces.delete(id2); }
             o.delete?.();
           } };
         }
-        if ([...oids0].some(isBlend)) {
+        if ([...oids0].some(keepsOwnId)) {
           const { baseId, blendIdFor, blendIds } = reserveBlendRestamp(oids0);
           // base-group policy: the same triangle-weighted majority vote as the plain
           // path, but over the NON-blend runs only — blend runs would elect BLEND for
@@ -578,7 +620,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
           const weightByKey = new Map();
           let bestWeight = -1, basePol;
           for (let r = 0; r < roid.length; r++) {
-            if (isBlend(roid[r])) continue;
+            if (blendIdFor.has(roid[r])) continue;
             const pol = oidPolicies.get(roid[r]) ?? SMOOTH;
             const key = `${pol.creaseAngle}/${pol.sameSurfaceLines}/${!!pol.boundaryLines}`;
             const weight = (weightByKey.get(key) || 0) + (ri[r + 1] / 3 - ri[r] / 3);
@@ -586,7 +628,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
             const better = weight > bestWeight || (weight === bestWeight && !pol.sameSurfaceLines && basePol?.sameSurfaceLines);
             if (better) { bestWeight = weight; basePol = pol; }
           }
-          g0.runOriginalID = Uint32Array.from(roid, (o2) => (isBlend(o2) ? blendIdFor.get(o2) : baseId));
+          g0.runOriginalID = Uint32Array.from(roid, (o2) => blendIdFor.get(o2) ?? baseId);
           const o = T(new Manifold(g0));
           g0.delete?.();
           featureLabels.set(baseId, name);

package/src/framework/geometry/mesh-roundall.js

@@ -29,6 +29,7 @@
 // the two facetings still meets the tier's sagitta tolerance.
 
 import { segsForSagitta } from "./circle-segs.js";
+import { SMOOTH, cosDeg } from "./shading-policy.js";
 
 // Sphere tessellation from the facet sagitta r·(1 − cos(π/segs)): pick the
 // fewest segments that keep it under the quality tier's tolerance — its own
@@ -83,6 +84,121 @@ export function meshRoundAll(wasm, m, r, quality) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Flat-face shading. The reference path's result is one fresh surface, shaded
+// SMOOTH (35° crease), and the rounding ball's facets bend far less than that, so
+// a flat face used to share its corner normals with the band facets around it.
+// The vertex sum is unweighted, so a large face split into two triangles — a
+// sloped palm plate's top — took a several-degree tilt at each corner and showed
+// it as a shading gradient across the whole face (cloud feedback #167).
+//
+// The cure rests on the invariant above: the chain returns every planar face of
+// the input to its own plane. So the input's flat faces, found here, say exactly
+// where the result is flat; the backend registers them as an analytic "planes"
+// descriptor (blend-surfaces.js), and creased-normals then shades every vertex on
+// one of those planes — the band's seam vertices too, since the band is tangent
+// there — with the plane's normal, the same way a fillet band's seam agrees with
+// its face.
+//
+// "Flat" means flat the way the INPUT shades it: a coplanar group counts only if
+// every edge bounding it is one creased-normals would shade hard (a bend past the
+// surface's crease angle, or a cut seam). A rod's wall facets, or a slot's sides
+// running tangentially into its round ends, meet their neighbours softly — the
+// input already shades them as part of a curved surface, and pinning them to
+// their own planes would facet the rounded result.
+//
+// `g` is a MeshGL (or the same fields on plain arrays); `policyFor(oid)` returns
+// that surface's shading policy. Returns [{ n, d }] with n·x = d on the plane.
+const PLANE_COS = cosDeg(0.05); // coplanar neighbours: a boolean split, not a bend
+export function flatFacePlanes(g, { policyFor = () => SMOOTH } = {}) {
+  const np = g.numProp, vp = g.vertProperties, tris = g.triVerts;
+  const nTri = (tris.length / 3) | 0, nVert = (vp.length / np) | 0;
+  const remap = new Uint32Array(nVert);
+  for (let i = 0; i < nVert; i++) remap[i] = i;
+  const mf = g.mergeFromVert, mt = g.mergeToVert;
+  if (mf && mt) for (let i = 0; i < mf.length; i++) remap[mf[i]] = mt[i];
+  const triOID = new Uint32Array(nTri);
+  const ri = g.runIndex, roid = g.runOriginalID;
+  if (ri && roid) for (let r = 0; r < roid.length; r++)
+    for (let t = ri[r] / 3; t < ri[r + 1] / 3; t++) triOID[t] = roid[r];
+
+  // facet normals, areas and centroids; a degenerate triangle has no normal and
+  // takes no part — it neither joins a face nor disqualifies one
+  const fn = new Float64Array(nTri * 3), area = new Float64Array(nTri), cen = new Float64Array(nTri * 3);
+  let span = 0;
+  for (let t = 0; t < nTri; t++) {
+    const a = tris[t * 3] * np, b = tris[t * 3 + 1] * np, c = tris[t * 3 + 2] * np;
+    const ux = vp[b] - vp[a], uy = vp[b + 1] - vp[a + 1], uz = vp[b + 2] - vp[a + 2];
+    const vx = vp[c] - vp[a], vy = vp[c + 1] - vp[a + 1], vz = vp[c + 2] - vp[a + 2];
+    const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+    const L = Math.hypot(nx, ny, nz);
+    area[t] = L / 2;
+    if (L > 0) { fn[t * 3] = nx / L; fn[t * 3 + 1] = ny / L; fn[t * 3 + 2] = nz / L; }
+    for (let k = 0; k < 3; k++) cen[t * 3 + k] = (vp[a + k] + vp[b + k] + vp[c + k]) / 3;
+    span = Math.max(span, Math.abs(vp[a]), Math.abs(vp[a + 1]), Math.abs(vp[a + 2]));
+  }
+  const live = (t) => area[t] > 1e-9;
+  const dot = (t, u) => fn[t * 3] * fn[u * 3] + fn[t * 3 + 1] * fn[u * 3 + 1] + fn[t * 3 + 2] * fn[u * 3 + 2];
+
+  // edge → incident triangles, on welded vertex ids
+  const edges = new Map();
+  for (let t = 0; t < nTri; t++) for (let k = 0; k < 3; k++) {
+    const p = remap[tris[t * 3 + k]], q = remap[tris[t * 3 + ((k + 1) % 3)]];
+    const key = p < q ? p * nVert + q : q * nVert + p;
+    const list = edges.get(key);
+    if (list) list.push(t); else edges.set(key, [t]);
+  }
+
+  // coplanar groups (union-find over shared edges)
+  const parent = new Int32Array(nTri);
+  for (let t = 0; t < nTri; t++) parent[t] = t;
+  const find = (t) => { while (parent[t] !== t) { parent[t] = parent[parent[t]]; t = parent[t]; } return t; };
+  for (const list of edges.values()) {
+    if (list.length !== 2) continue;
+    const [t, u] = list;
+    if (live(t) && live(u) && dot(t, u) > PLANE_COS) parent[find(t)] = find(u);
+  }
+
+  // a group is a flat face only if every edge leaving it would shade hard
+  const soft = new Uint8Array(nTri); // indexed by group root
+  const hard = (t, u) => {
+    const pt = policyFor(triOID[t]) ?? SMOOTH, pu = policyFor(triOID[u]) ?? SMOOTH;
+    if (triOID[t] !== triOID[u] && !(pt.boundaryLines || pu.boundaryLines)) return true;
+    return dot(t, u) < cosDeg(pt.creaseAngle);
+  };
+  for (const list of edges.values()) {
+    if (list.length !== 2) continue; // non-manifold: no smooth neighbour to share with
+    const [t, u] = list;
+    if (!live(t) || !live(u) || find(t) === find(u)) continue;
+    if (!hard(t, u)) soft[find(t)] = 1;
+    if (!hard(u, t)) soft[find(u)] = 1;
+  }
+
+  // one area-weighted plane per surviving group, merged where two groups share a
+  // plane (a degenerate triangle can split one face into two)
+  const acc = new Map();
+  for (let t = 0; t < nTri; t++) {
+    if (!live(t)) continue;
+    const root = find(t);
+    if (soft[root]) continue;
+    let e = acc.get(root);
+    if (!e) acc.set(root, (e = { n: [0, 0, 0], c: [0, 0, 0], a: 0 }));
+    for (let k = 0; k < 3; k++) { e.n[k] += fn[t * 3 + k] * area[t]; e.c[k] += cen[t * 3 + k] * area[t]; }
+    e.a += area[t];
+  }
+  const dTol = Math.max(1e-6, span * 1e-7);
+  const planes = [];
+  for (const e of acc.values()) {
+    const L = Math.hypot(...e.n);
+    if (!(L > 0)) continue;
+    const n = e.n.map((x) => x / L);
+    const d = (n[0] * e.c[0] + n[1] * e.c[1] + n[2] * e.c[2]) / e.a;
+    const dup = planes.find((p) => p.n[0] * n[0] + p.n[1] * n[1] + p.n[2] * n[2] > PLANE_COS && Math.abs(p.d - d) < dTol);
+    if (!dup) planes.push({ n, d });
+  }
+  return planes;
+}
+
 // ---------------------------------------------------------------------------
 // Prism detection for the fast path (manifold-backend.js). The Minkowski chain
 // above is seconds-per-thousand-triangles, but roundAll's expensive real-world