partforge 0.114.0 → 0.116.0

package/docs/AUTHORING-PARTS.md

@@ -3642,7 +3642,24 @@ symptom first** — it maps error text → cause → fix. The invariants, one li
   `slotPolygon`, `ringSectorPolygon` and `circleProfile`; mirror a symmetric half with
   `mirrorProfile`.
 - **Preview vs print quality:** Manifold bakes segment counts in at primitive creation,
-  so builds are quality-agnostic; the export path uses a separate high-res "print" kernel.
+  so builds are quality-agnostic; the export path uses a separate "print" kernel. Preview
+  facets every circle at 116 segments. Print sizes each circle by chord tolerance — the
+  fewest segments that keep the facet sagitta under 0.01 mm — never fewer than the
+  preview's 116 and never more than 480, so a small feature exports at exactly the density
+  you previewed and only circles wider than about 54 mm get finer. A part that previews
+  is a part that exports: the old flat 480 turned a 0.75 mm rivet into 115,200 triangles
+  and a body with a few hundred of them into an out-of-memory trap at export
+  ([export-kernel-out-of-memory](ERROR-PATTERNS.md#export-kernel-out-of-memory)).
+  **Spheres are the exception on both tiers:** a sphere spends the segment count
+  squared (6,728 triangles at 116, whatever its radius), so `k.sphere` is sized by chord
+  tolerance — 0.02 mm at preview, never fewer than 24 segments (288 triangles) and never
+  more than 116, so only spheres under about 60 mm radius get coarser and none get
+  finer. That is what keeps a body studded with a few hundred rivet spheres inside a
+  phone's memory ([preview-build-too-heavy-for-phones](ERROR-PATTERNS.md#preview-build-too-heavy-for-phones)).
+  Spheres are still the costliest way to add small detail: a domed rivet is 288
+  triangles where a short cylinder is 232 and a box is 12, and every one of them is a
+  boolean operand. Prefer instancing one union of a row over a chain of per-feature
+  booleans, and drop counts the print cannot show.
 - **Display placement is view-independent**; only `place(..., { purpose: "export" })` may
   depend on `view` ([view-dependent-display-place](ERROR-PATTERNS.md#view-dependent-display-place)).
 - **Keep geometry backend-agnostic** (kernel calls only); only STEP requires OCCT

package/docs/ERROR-PATTERNS.md

@@ -823,6 +823,18 @@ between the Manifold preview and the OCCT STEP export.
 - **Cause:** *(partforge ≥ 0.112.)* A hand-authored 2-D profile (a point list, a `pathProfile` contour, a `{outer, holes}` region — handed to a factory op, to `k.shape2d`, or as a `Shape2D` boolean operand) crosses itself. Manifold fills a point ring even-odd, so the crossing quietly inverts the fill on one side instead of failing. The usual author of the crossing is an arc sampled into points by hand (a `Math.cos` loop) whose sweep sign or endpoint order is wrong, or a mirrored half whose point order was not reversed. The kernel now runs `validateProfile` on the way in and reports each crossing on the build result's `warnings`; a `Shape2D` is not re-validated, `text2d`/`vector2d` lifts are trusted, and a profile over 4000 segments is skipped (for `loft`, the ceiling is the sum over all its rings). At most **three** crossings are reported per profile — the third reads `… (and N more crossings on this profile)` — so one badly-drawn star cannot evict every other warning in the build. A hole whose edge touches or runs along its outer is **not** reported: that builds exactly as drawn, and only a contour crossing itself inverts the fill.
 - **Fix:** Rebuild the curved parts of the outline with `pathProfile(start).lineTo(p).arcTo(to, via).close()` — a three-point arc sweeps through `via`, so its direction cannot flip — or with the `partforge/geometry` helpers (`roundedProfile`, `filletPolygon`, `slotPolygon`, `ringSectorPolygon`, `circleProfile`); build a symmetric half once and `mirrorProfile` it rather than writing the mirror by hand. Confirm with `validateProfile(profile).ok` before extruding. The reported coordinate is in the profile's own frame (before any `rotate`/`at`).
 
+## export-kernel-out-of-memory
+
+- **Symptom:** `Out of bounds memory access` (Safari) or `memory access out of bounds` (Chrome, Node) from an STL or 3MF export — or from a build — of a part whose preview renders fine; often followed, on every later build in the same session, by `Manifold instance already deleted`, `Out of bounds call_indirect`, `call_indirect to a signature that does not match`, `table index is out of bounds`, or `null function or function signature mismatch`.
+- **Cause:** The mesh kernel's WASM heap ran out while building the print-quality mesh, and a WASM trap leaves that kernel instance corrupt — every later call into it fails until the worker is replaced or the page reloaded. Before partforge 0.115 the print tier meshed every circle at a flat 480 segments whatever its radius, so a part with a few hundred small spheres or cylinders (a 0.75 mm rivet was 115,200 triangles — 176 of them are 20 M before a single boolean) exhausted a 4 GB heap on its first export while its whole unioned preview was a few hundred thousand triangles. Since 0.115 print sizes circles by a 0.01 mm chord tolerance, floored at the preview count, so a part that previews normally exports at roughly the preview's cost; a part that still traps is genuinely too heavy for the browser at ANY quality — usually thousands of repeated small features, or a boolean chain whose intermediates dwarf the result.
+- **Fix:** Reload the page (or let the host replace the kernel worker) before retrying anything — the trapped instance cannot recover. Then reduce what the export has to hold at once: build repeated detail as one union of instances rather than a chain of per-feature booleans, drop feature counts that exceed what the print can show (a 0.75 mm sphere prints as a dot), or pass `segs` to `revolve` where a coarser sweep is acceptable ([Preview vs print quality](AUTHORING-PARTS.md#conventions--gotchas)). Do NOT strip visible detail from the part to dodge a pre-0.115 trap — update partforge instead; the geometry was never the problem.
+
+## preview-build-too-heavy-for-phones
+
+- **Symptom:** A part that previews on a desktop crashes, reloads, or shows a blank viewer on phones — iOS Safari's "This webpage was reloaded because a problem occurred", a viewer that never finishes its first build, or (in partforge-cloud) a `sandbox_timeout` from a phone user agent — with no error text at all, because the browser killed the page rather than the build throwing.
+- **Cause:** Peak WASM memory during the preview build exceeded what the phone allows a page (roughly 1–1.5 GB on iOS; a desktop tolerates several GB). The usual shape is hundreds of repeated small features unioned into one body: before partforge 0.116 every sphere was 6,728 triangles regardless of radius (the flat 116-segment preview count, squared), so a body with ~250 rivet spheres carried 1.7 M triangles of rivets into its booleans — measured 10 s and a 2.7 GB peak on a desktop for a 400k-triangle sub-part, against 4 s and 500 MB with the rivets as 12-triangle boxes. A boolean chain whose intermediates dwarf the result (a full-body skin intersected per groove) is the other shape.
+- **Fix:** Update partforge (0.116 sizes spheres by chord tolerance: that body builds in ~550 MB and 120k triangles unchanged). Then keep the preview build's peak down the same ways the export needs: build repeated detail as one union of instances rather than a chain of per-feature booleans, cut grooves from a thin local skin rather than the whole envelope, and drop feature counts the print cannot show ([Preview vs print quality](AUTHORING-PARTS.md#conventions--gotchas)). `partforge measure` reports triangle counts per sub-part; a single preview sub-part past ~200k triangles, or a whole view past ~400k, is the range where phones start to fail.
+
 # Hardware library
 
 Reserved for `hardware-*` patterns (issue #30). No entries yet.

package/docs/KERNEL-CONTRACT.md

@@ -375,7 +375,20 @@ Normative signatures: `kernel.js`'s `@typedef Solid`.
 
 `quality` (`"preview"` | `"print"`) is **advisory**: it trades tessellation density for
 speed and a backend may bake it at kernel creation (Manifold does). A part must never
-depend on triangle counts, segment counts, or normals being present.
+depend on triangle counts, segment counts, or normals being present. The in-repo
+backends both define `print` as a **chord tolerance of 0.01 mm** (OCCT's linear
+deflection; Manifold's per-circle segment rule in `geometry/circle-segs.js`, floored at
+the preview's 116 segments so print is never coarser than preview and capped at 480), so
+a small feature costs the export exactly what its preview cost — the property that makes
+"if it previews, it exports" hold. Preview is a flat 116 on Manifold, a visual choice —
+with one exception: `sphere`, whose triangle count is quadratic in the segment count
+(8·(n/4)²), is sized by chord tolerance on BOTH tiers (`sphereSegs` in
+`geometry/circle-segs.js`: 0.02 mm at preview, floored at 24 segments and capped at
+the flat 116; 0.01 mm at print, floored at the preview count, capped at 480). At the
+flat count a 0.75 mm rivet sphere was 6,728 triangles, and a part carrying a few
+hundred of them was a 2.7 GB preview build that phones could not survive; at the
+floor it is 288. Circles in extrusions, revolves and outlines keep the flat count,
+which the mesh fillet's arc gate and the roundAll fast path are tuned to.
 
 ### Shading intent (toMesh normals and edges)
 
@@ -554,8 +567,9 @@ curve-exact (they integrate the real curves; they do not measure a tessellation)
 so it is backend-identical too, like everything else in this list.
 
 **Lazy materialization.** Backend geometry is built only where it is unavoidable.
-Three readbacks tessellate to point rings at the backend's own LOD (Manifold 116
-preview / 480 print, OCCT 64): `toRegions()`, `simple()` (its unwrapped form), and
+Three readbacks tessellate to point rings at the backend's own LOD (Manifold 116 per
+circle at preview and, at print, the fewest segments holding a 0.01 mm chord sagitta
+between 116 and 480 — per arc, by its radius; OCCT 64): `toRegions()`, `simple()` (its unwrapped form), and
 `regions()` — scission currently round-trips through `toRegions()`, so each returned
 `Shape2D` is a faceted copy, not a curve-native slice of the original. `extrude` and
 `revolve` materialize the shape into the backend's own form instead (Manifold: a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.114.0",
+  "version": "0.116.0",
   "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/circle-segs.js

@@ -0,0 +1,109 @@
+// Per-circle segment counts for the mesh backend's two quality tiers.
+//
+// `preview` is a flat count: 116 segments per full circle whatever the radius. It is
+// a VISUAL choice — the density every part is previewed, captured and thumbnailed
+// at — and it already holds a 0.05 mm chord sagitta out to a 136 mm radius, so
+// nothing is gained by scaling it.
+//
+// `print` used to be a flat 480, sized (whether anyone meant it or not) for a circle
+// nearly a metre across: 480 segments meet a 0.01 mm sagitta at r ≈ 467 mm. Spent on
+// a 0.75 mm rivet sphere that is 115,200 triangles for a chord error of 1.6e-5 mm —
+// a thousandth of any printer's resolution — and a part carrying 176 such rivets
+// (20 M triangles of rivets before a single boolean, against a preview whose whole
+// unioned body was 530k) trapped the WASM kernel with "memory access out of bounds"
+// on its first STL export, on a fresh 4 GB instance. So the print tier is now
+// tolerance-based: the fewest segments that keep the chord sagitta r·(1 − cos(π/n))
+// under SAGITTA_TOL.print — the same 0.01 mm the OCCT backend's print tessellation
+// uses, and the same formula `roundAllSegs` (mesh-roundall.js) and `blendSegs`
+// (mesh-fillet.js) already apply to their own circles. Those two keep their own
+// tolerances and clamps on purpose (roundAll has a preview tolerance and a 12..64
+// window; the fillet blends at 1 µm) — this table is not theirs to share, and
+// `roundAllSegs(r, "preview")` against it would collapse to a flat 12. Two clamps
+// make the rule here safe:
+//
+// - FLOOR at the preview count. An export must never be coarser than the preview the
+//   user approved on screen, so below the radius where 116 segments already meet the
+//   tolerance (r ≈ 27 mm) print and preview facet identically — which is also what
+//   makes "if it previews, it exports" true for small features: the export costs what
+//   the preview already paid.
+// - CAP at the old flat count. A circle large enough to need more than 480 keeps
+//   exactly the density it always had; nothing gets FINER than before.
+//
+// One rule, one place: every Manifold-backend site that facets a circle of known
+// radius — sphere, cylinder, boredCylinder, roundedBox, revolve, and the arc and
+// Bézier samplers behind prism/extrude/Shape2D — sizes through `circleSegs`. The
+// helix tube's station/ring counts (TUBE in manifold-backend.js) and mesh-fillet's
+// blend bands keep their own sizing; loft rings keep LOFT_SEGS.
+//
+// The one exception is `sphere`, which has its own rule at the bottom of this file.
+//
+// Pure, dependency-free: profile.js's samplers take a `(r) => n` function in place of
+// a count, and this is what the backend hands them.
+
+export const SEGS = { preview: 116, print: 480 };       // full-circle segments (flat / cap)
+export const SAGITTA_TOL = { print: 0.01 };             // mm — max chord sagitta per tier
+
+// THE formula, shared by every tolerance-sized circle in the mesh backend: the fewest
+// full-circle segments that keep the chord sagitta r·(1 − cos(π/n)) under `tol`,
+// clamped to [floor, cap]. acos(1 − tol/r) is the half-angle of a chord with sagitta
+// tol; π over it is the full-circle count. r = Infinity gives acos(1) = 0 → Infinity →
+// the cap. A degenerate radius (0, negative, NaN, undefined) or one no larger than the
+// tolerance takes the floor and never throws. The callers differ only in POLICY — which
+// tolerance, which clamps — and that is all they should ever add: `circleSegs` and
+// `sphereSegs` below, mesh-fillet's blendSegs and mesh-roundall's roundAllSegs.
+export function segsForSagitta(r, tol, floor, cap) {
+  if (!(r > tol)) return floor;
+  return Math.min(cap, Math.max(floor, Math.ceil(Math.PI / Math.acos(1 - tol / r))));
+}
+
+// Segments per full circle for a circle of radius `r` at `quality`. A tier with no
+// tolerance (preview, or an unknown tier) is flat; print is sized by tolerance, floored
+// at the preview count and capped at its own.
+export function circleSegs(r, quality) {
+  const cap = SEGS[quality] ?? SEGS.preview;
+  const tol = SAGITTA_TOL[quality];
+  if (tol === undefined) return cap;
+  return segsForSagitta(r, tol, SEGS.preview, cap);
+}
+
+// Spheres are the one primitive whose triangle count is QUADRATIC in the segment
+// count — Manifold.sphere(r, n) subdivides an octahedron n/4 times per edge, 8·(n/4)²
+// triangles — so the per-circle budget above, spent on a sphere, is spent squared:
+// at the flat preview 116 every sphere is 6,728 triangles whatever its radius, and a
+// 0.75 mm rivet sphere carries a chord error of 0.0003 mm, a hundredth of a screen
+// pixel at any zoom. A part carrying ~250 such rivets (the steampunk-spider feedback,
+// "not loading on phones") unioned 1.7 M triangles of rivets into a 100k body: 10 s
+// and a 2.7 GB peak on a desktop, which iOS Safari's content process does not
+// survive — with the rivets at 12 triangles each the same body was 4 s and 500 MB.
+//
+// So spheres are sized by chord tolerance on BOTH tiers, like print circles are:
+//
+// - preview holds SPHERE_SAGITTA_TOL.preview (0.02 mm — an absolute chord error is
+//   what screen pixels measure, so one tolerance reads equally smooth at every radius
+//   and every zoom; 0.02 mm is a fifth of a pixel at a typical 100 mm-part zoom),
+//   floored at SPHERE_FLOOR segments (24 — ~15° facets, so a tiny ball never reads as
+//   a polygon under close zoom, and 288 triangles instead of 6,728) and capped at the
+//   old flat count (nothing gets FINER than before; a sphere of 60 mm radius and up
+//   keeps exactly the density it always had).
+// - print holds the print tier's 0.01 mm, floored at the preview count for the same
+//   radius (never coarser than the preview the user approved — the same property the
+//   circle rule keeps) and capped at 480.
+//
+// Circles in extrusions, revolves, cylinders and 2-D outlines stay on the flat preview
+// count on purpose: their cost is linear in the count, and the mesh fillet's arc gate,
+// the roundAll prism fast path and the shading policies are all tuned to that density
+// — a spike that made EVERY preview circle tolerance-based (0.05 mm, floor 24) turned
+// bore-rim fillets from revolve tools into planar sweeps and drew 26 feature lines
+// across a roundAll band that had none. A sphere has no sharp edges of its own and roundAll
+// sizes its own balls (roundAllSegs), so this rule touches nothing tuned to 116.
+export const SPHERE_SAGITTA_TOL = { preview: 0.02, print: SAGITTA_TOL.print }; // mm
+export const SPHERE_FLOOR = 24;                                                  // segments
+
+// Segments for a sphere of radius `r` at `quality`: the fewest that keep the chord
+// sagitta under the tier's sphere tolerance, clamped as described above. An unknown
+// tier facets as preview; a degenerate radius takes the floor and never throws.
+export function sphereSegs(r, quality) {
+  const tier = Object.hasOwn(SPHERE_SAGITTA_TOL, quality ?? "") ? quality : "preview";
+  const floor = tier === "preview" ? SPHERE_FLOOR : sphereSegs(r, "preview");
+  return segsForSagitta(r, SPHERE_SAGITTA_TOL[tier], floor, SEGS[tier]);
+}

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

@@ -19,6 +19,7 @@ import { creasedNormals } from "./creased-normals.js";
 import { loftShadingPolicy, SMOOTH, BLEND } from "./shading-policy.js";
 import { meshFillet, meshChamfer, UnsupportedEdgeError } from "./mesh-fillet.js";
 import { meshRoundAll, prismSection, roundAllSegs } from "./mesh-roundall.js";
+import { SEGS, circleSegs, sphereSegs } from "./circle-segs.js";
 import { checkBooleanResult } from "./boolean-gate.js";
 import { KernelCapabilityError } from "./errors.js";
 import { heightfieldMesh, hashGridData } from "./heightfield.js";
@@ -26,7 +27,10 @@ import { heightfieldMesh, hashGridData } from "./heightfield.js";
 const PLANE_NORMAL = { XY: [0, 0, 1], XZ: [0, 1, 0], YZ: [1, 0, 0] };
 // 'preview' = interactive view (fast); 'print' = STL export (high-res, used only
 // by the export path — Manifold meshing is cheap, so we tessellate generously).
-const SEGS = { preview: 116, print: 480 };       // circular segments
+// Full-circle segment counts live in circle-segs.js: preview is a flat SEGS.preview,
+// print sizes each circle by chord tolerance through circleSegs (floored at the
+// preview count, capped at SEGS.print). `segs` below is the tier's cap — the hash
+// key and the count handed to consumers that size themselves (mesh-fillet, loft).
 const TUBE = { preview: { stationsPerTurn: 38, ringSegs: 24 }, print: { stationsPerTurn: 160, ringSegs: 40 } };
 
 // true axis-angle rotation as a column-major 4x4 (manifold Mat4), translation 0
@@ -44,6 +48,9 @@ function axisAngleMat4(axis, deg) {
 export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   const { Manifold, CrossSection } = wasm;
   const segs = SEGS[quality], tube = TUBE[quality];
+  // Per-radius count for every site that facets a circle it knows the radius of; the
+  // samplers behind prism/extrude/Shape2D take it as a function (profile.js).
+  const segsAt = (r) => circleSegs(r, quality);
 
   // Manifold/CrossSection are WASM objects with no garbage collection — every
   // primitive and boolean op allocates a new one. Track them all and free them
@@ -166,7 +173,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   // on it in pure JS; no CrossSection is built until a shape is handed to a kernel op.
   // `extrude`/`revolve` are thunks because `kernel` below is defined after this.
   const shape2d = makeShape2dFactory({
-    segs,
+    segs: segsAt, // the readbacks (toRegions/simple) tessellate at the same per-radius LOD as the kernel ops
     extrude: (o) => kernel.extrude(o),
     revolve: (o) => kernel.revolve(o),
     recordWarning,
@@ -177,7 +184,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   // once, and the cache's pin/dispose keeps the WASM object alive exactly as long as
   // the entry (cleanup() skips pinned objects).
   const csFor = (shape) => cache.lookup(h("cs2d", shape._hash, segs), () => {
-    const cs = T(CrossSection.ofPolygons(regionPolys(shape._regions, segs), "EvenOdd"));
+    const cs = T(CrossSection.ofPolygons(regionPolys(shape._regions, segsAt), "EvenOdd"));
     return { value: cs, pin: cs, dispose: () => cs.delete?.() };
   });
 
@@ -401,13 +408,13 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       if (typeof selector === "function") throw new KernelCapabilityError("fillet: function selectors need the OCCT backend");
       if (r === 0) return wrap(m, hash); // contract: zero magnitude is the identity
       return cached(h("fillet", hash, r, selector ?? null, segs), () =>
-        meshCadOp("fillet", m, () => meshFillet(kernel, wrap(m, hash), { r, edges: selector, segs })));
+        meshCadOp("fillet", m, () => meshFillet(kernel, wrap(m, hash), { r, edges: selector, segs, segsAt })));
     },
     _chamferRaw: (d, selector) => {
       if (typeof selector === "function") throw new KernelCapabilityError("chamfer: function selectors need the OCCT backend");
       if (d === 0) return wrap(m, hash);
       return cached(h("chamfer", hash, d, selector ?? null, segs), () =>
-        meshCadOp("chamfer", m, () => meshChamfer(kernel, wrap(m, hash), { d, edges: selector, segs })));
+        meshCadOp("chamfer", m, () => meshChamfer(kernel, wrap(m, hash), { d, edges: selector, segs, segsAt })));
     },
 
     // The AUTHOR-FACING ops degrade on failure instead of failing the build (the
@@ -628,14 +635,16 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   };
 
   const kernel = finishKernel({
-    cylinder: (rb, rt, h2, { center = false } = {}) =>
-      wrap(T(Manifold.cylinder(h2, rb, rt, segs, center)), h("cylinder", rb, rt, h2, center, segs)),
+    cylinder: (rb, rt, h2, { center = false } = {}) => {
+      const n = segsAt(Math.max(rb, rt)); // a cone is sized by its wider end
+      return wrap(T(Manifold.cylinder(h2, rb, rt, n, center)), h("cylinder", rb, rt, h2, center, n));
+    },
     // Compound op: hashed ATOMICALLY from its own args, so it is a single cache
     // node — its internal cylinders/cut are never retained. The template for
     // future compounds: build internals with T(), return the final tracked solid.
-    boredCylinder: ({ od, h: height, bore }) => cached(h("boredCylinder", od, height, bore, segs), () => {
-      const body = T(Manifold.cylinder(height, od / 2, od / 2, segs, false));
-      const tool0 = T(Manifold.cylinder(height + 4, bore / 2, bore / 2, segs, false));
+    boredCylinder: ({ od, h: height, bore }) => cached(h("boredCylinder", od, height, bore, segsAt(od / 2), segsAt(bore / 2)), () => {
+      const body = T(Manifold.cylinder(height, od / 2, od / 2, segsAt(od / 2), false));
+      const tool0 = T(Manifold.cylinder(height + 4, bore / 2, bore / 2, segsAt(bore / 2), false));
       const tool = T(tool0.translate([0, 0, -2])); // raw ops: track each result
       return T(body.subtract(tool));
     }),
@@ -644,19 +653,23 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     // spec). Reuses loftMesh's stitch/cap/winding machinery. Atomic cache
     // node hashed from its own args, like boredCylinder.
     roundedBox: ({ size, center, round }) => cached(
-      h("roundedBox", size, center, round.side, round.top, round.bottom, segs),
+      h("roundedBox", size, center, round.side, round.top, round.bottom, segsAt(Math.max(round.side, round.top, round.bottom))),
       () => {
-        const solid = T(loftMesh(wasm, roundedBoxRings(size, round, segs)));
+        // One count serves every corner and rim arc, so it is sized for the largest.
+        const solid = T(loftMesh(wasm, roundedBoxRings(size, round, segsAt(Math.max(round.side, round.top, round.bottom)))));
         return center ? T(solid.translate([0, 0, -size[2] / 2])) : solid;
       }),
-    sphere: (r) => wrap(T(Manifold.sphere(r, segs)), h("sphere", r, segs)),
+    // Sized by its own per-radius rule (circle-segs.js: a sphere spends the per-circle
+    // count squared), on both tiers — the hash carries the count, so a sphere built at
+    // one tier never masquerades as the other's in the cache.
+    sphere: (r) => wrap(T(Manifold.sphere(r, sphereSegs(r, quality))), h("sphere", r, sphereSegs(r, quality))),
     box: (min, max) => {
       const cube = T(Manifold.cube([max[0] - min[0], max[1] - min[1], max[2] - min[2]]));
       return wrap(T(cube.translate(min)), h("box", min, max));
     },
     prism: (pts, height, { twist = 0, scaleTop = 1 } = {}) =>
       cached(h("prism", pts, height, twist, scaleTop, segs), () => {
-        const cs = T(CrossSection.ofPolygons([tessellateContour(pts, segs)]));
+        const cs = T(CrossSection.ofPolygons([tessellateContour(pts, segsAt)]));
         if (twist === 0 && scaleTop === 1) return T(cs.extrude(height));
         const nDiv = Math.max(1, Math.ceil(Math.abs(twist) / 5));
         // Manifold's extrude scaleTop is a Vec2 — a scalar is NOT broadcast (it scales
@@ -711,7 +724,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       const shape = profile && profile._shape2d ? profile : null;
       return cached(h("extrude", shape ? shape._hash : profile, height, twist, scaleTop, segs), () => {
         const cs = shape ? csFor(shape) : (() => {
-          const { outer, holes } = tessellateProfile(profile, segs);
+          const { outer, holes } = tessellateProfile(profile, segsAt);
           return T(CrossSection.ofPolygons([outer, ...holes], "EvenOdd"));
         })();
         if (twist === 0 && scaleTop === 1) return T(cs.extrude(height));
@@ -757,10 +770,26 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     // opts.segs may only COARSEN below the kernel's quality (min), never exceed it:
     // callers use it where a small feature's sagitta bound needs fewer facets than
     // the per-circle quality would spend (mesh-fillet's free-standing corner arcs).
+    // Density around the axis: by default sized for the profile's outermost radius —
+    // the largest circle the revolve sweeps — through the tier's per-radius rule. An
+    // explicit `segs` is the caller's own sizing (mesh-fillet's blend tools compute
+    // theirs from a 1 µm sagitta bound and rely on getting exactly that count — the
+    // dephase and horn-containment arithmetic assume it), bounded only by the tier's
+    // cap: it may still never EXCEED kernel quality, but it is not re-bounded by the
+    // part-scale rule meant for circles nobody sized by hand.
     revolve: (pts, { degrees = 360, segs: segsOverride } = {}) => {
-      const density = Math.min(segs, segsOverride ?? segs);
-      if (pts && pts._shape2d)
-        return cached(h("revolve", pts._hash, degrees, density), () => T(csFor(pts).revolve(density, degrees)));
+      const densityFor = (maxR) => segsOverride != null ? Math.min(segs, segsOverride) : segsAt(maxR);
+      if (pts && pts._shape2d) {
+        // Keyed on the override, not the resolved density, so a cache hit never
+        // materializes the CrossSection just to measure its bounds.
+        return cached(h("revolve", pts._hash, degrees, segsOverride ?? null), () => {
+          const cs = csFor(pts);
+          const b = cs.bounds();
+          return T(cs.revolve(densityFor(Math.max(Math.abs(b.min[0]), Math.abs(b.max[0]))), degrees));
+        });
+      }
+      const maxR = Array.isArray(pts) ? pts.reduce((m, p) => Math.max(m, Math.abs(p?.[0] ?? 0)), 0) : 0;
+      const density = densityFor(maxR);
       return cached(h("revolve", pts, degrees, density), () => T(Manifold.revolve([pts], density, degrees)));
     },
     // A one-solid union is an identity — no new WASM / cache entry (avoids double-free):

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

@@ -43,6 +43,7 @@
 // `dir` only ever matches straight chains, like replicad's inDirection.
 // Pure module: no DOM, no node:, no three — safe anywhere in the worker graph.
 import { sweepSeedFrame } from "./sweep.js";
+import { segsForSagitta } from "./circle-segs.js";
 
 const TOL = 1e-4;            // selector / coplanarity tolerance (mm)
 const WELD = 1e6;            // vertex weld quantization (1/WELD mm grid)
@@ -64,8 +65,7 @@ export class UnsupportedEdgeError extends Error {
 // angle (≤30°) under the viewer's 35° same-surface crease threshold.
 const BLEND_SAG = 1e-3; // mm — max chord sagitta of a blend cross-section
 function blendSegs(segs, r) {
-  const s = Math.min(BLEND_SAG, 0.02 * r);
-  return Math.min(segs, Math.max(12, Math.ceil(Math.PI / Math.acos(1 - s / r))));
+  return segsForSagitta(r, Math.min(BLEND_SAG, 0.02 * r), 12, segs);
 }
 // One derivation for a synthetic corner arc's angular density, shared by revolveTool
 // (which sweeps at it) and cornerHornTool (whose apothem bound below depends on it) —
@@ -670,8 +670,12 @@ function prismTool(k, chain, magnitude, mode, segs, pSegs = segs) {
 // closed-revolve dephase, which are about matching the neighboring tessellation and
 // must not follow the blend cap. `pSegs` is the sagitta-bounded density for the blend
 // cross-section itself (blendSegs above).
-function revolveTool(k, chain, magnitude, mode, segs, pSegs = segs) {
+function revolveTool(k, chain, magnitude, mode, segs, pSegs = segs, flankAt = () => segs) {
   const { O, w, u0, v0, R, span, closed, n1, n2, convex } = chain;
+  // The count the flank's own circle was built at (see apply): the cap on a flat
+  // tier, the per-radius rule on print. Every "matching the neighbouring
+  // tessellation" figure below reads this, never `segs`.
+  const flankSegs = flankAt(R);
   // Seam-grazing guard. The edge circle passes through the flank tessellation's
   // VERTICES (circumradius) while its facets sit at the apothem, so a revolved
   // tool built exactly at R grazes every facet seam tangentially — Manifold
@@ -689,7 +693,7 @@ function revolveTool(k, chain, magnitude, mode, segs, pSegs = segs) {
   // and a radial knife-fin of wall survived both cutters, drawing a line along the
   // band (the label-backing bug). A synthetic corner arc measures nothing — its two
   // points span the whole corner, and its flanks are planes, not a tessellation.
-  const kernelSag = (R + magnitude) * (1 - Math.cos(Math.PI / segs));
+  const kernelSag = (R + magnitude) * (1 - Math.cos(Math.PI / flankSegs));
   let dip = 0;
   if (!chain.synthetic) {
     const pts = chain.points;
@@ -732,7 +736,7 @@ function revolveTool(k, chain, magnitude, mode, segs, pSegs = segs) {
   // with the flank's own tessellation of the same circle (the dephase note below).
   // A SYNTHETIC corner arc (cornerArcAt) is free-standing between planes, so its
   // angular density follows the same sagitta bound as the cross-section.
-  const aSegs = chain.synthetic ? cornerArcSegs(segs, R, magnitude) : segs;
+  const aSegs = chain.synthetic ? cornerArcSegs(segs, R, magnitude) : flankSegs;
   let tool = k.revolve(poly, { degrees, segs: aSegs });
   // pose: Z → w, then twist so the revolve's start azimuth (+X) lands on the
   // chain's start direction (backed off by the angular overshoot)
@@ -749,7 +753,7 @@ function revolveTool(k, chain, magnitude, mode, segs, pSegs = segs) {
   // vertex at every step (the degenerate-needle generator). Half a step lands
   // every crossing mid-facet. Partial arcs have a slightly different pitch
   // (degrees don't divide evenly) and never align in the first place.
-  const dephase = closed ? Math.PI / segs : 0;
+  const dephase = closed ? Math.PI / flankSegs : 0;
   const twist = Math.atan2(dot(w, cross(xImage, startDir)), dot(xImage, startDir)) + dephase;
   if (Math.abs(twist) > 1e-9) tool = tool.rotateAbout({ axis: w, deg: (twist * 180) / Math.PI });
   return tool.translate(O);
@@ -891,7 +895,7 @@ function weldChainPoints(pts, wallNs, closed) {
   return { pts: outP, wallNs: outW };
 }
 
-function planarTool(k, chain, magnitude, mode, segs, pSegs = segs, endTins = null) {
+function planarTool(k, chain, magnitude, mode, segs, pSegs = segs, endTins = null, flankAt = () => segs) {
   const { points, closed, convex, faceN } = chain;
   let { wallNs } = chain;
   let pts = closed ? points.slice(0, -1) : points;   // drop the duplicated closure point
@@ -1095,9 +1099,9 @@ function planarTool(k, chain, magnitude, mode, segs, pSegs = segs, endTins = nul
       tools.push(...buildStretch(path, wallNs[s % nSeg]));
     }
     for (const got of cornerArcs.values()) {
-      tools.push(revolveTool(k, got.arc, magnitude, mode, segs, pSegs));
+      tools.push(revolveTool(k, got.arc, magnitude, mode, segs, pSegs, flankAt));
       if (len(sub(got.vertex, got.arc.O)) - got.arc.R > 0.02 * magnitude)
-        tools.push(cornerHornTool(k, got, magnitude, segs));
+        tools.push(cornerHornTool(k, got, magnitude, segs, flankAt));
     }
     for (const piv of pivots) tools.push(reflexPivotTool(k, piv, magnitude, mode, segs, pSegs));
     return tools;
@@ -1211,7 +1215,7 @@ function cornerArcAt(vertex, f, tin1, tin2, wall1, wall2, len1, len2, magnitude,
 // of its step count, so its apothem ≥ R·cos(π/aSegs) > every horn vertex radius. The
 // cost is a micron-deep extra bite at the corner base, covered near the tangent lines
 // by the neighbors' own overshoot.
-function cornerHornTool(k, { vertex, f, arc }, magnitude, segs) {
+function cornerHornTool(k, { vertex, f, arc }, magnitude, segs, flankAt = () => segs) {
   const { O, w, u0, R, span } = arc;
   const delta = 0.02 * magnitude;
   const rH = R * Math.cos(Math.PI / cornerArcSegs(segs, R, magnitude)) - Math.min(1e-3, 0.02 * magnitude);
@@ -1488,7 +1492,7 @@ function roundSalientCorners(selected, magnitude) {
 // cube's outer walls land inside the material the edge cutters already remove,
 // so the only new surface is the octant. Non-orthogonal corners keep the mitre
 // — the safe, documented default.
-function cornerPatches(k, selected, r, segs) {
+function cornerPatches(k, selected, r, segs, flankAt = () => segs) {
   const byVertex = new Map();
   const push = (pt, dirOut) => {
     const key = pt.map((v) => Math.round(v * 1e4)).join(",");
@@ -1527,7 +1531,7 @@ function cornerPatches(k, selected, r, segs) {
     // is tangent to each flat face at a point and meets the edge-fillet
     // cylinders tangentially at the cube walls, and tessellated tangency
     // produces the same grazing-noise creases the edge tools guard against.
-    const bury = r * (1 - Math.cos(Math.PI / segs)) + 1e-3;
+    const bury = r * (1 - Math.cos(Math.PI / flankAt(r))) + 1e-3; // the kernel sphere below is built at flankAt(r)
     const inward = norm(add(add(e1, e2), e3));
     // corner block: cube spanned by the edge frame, oversized only outward
     let block = k.box({ min: [-dOut, -dOut, -dOut], max: [r, r, r] });
@@ -1554,8 +1558,17 @@ function cornerPatches(k, selected, r, segs) {
 export function meshFillet(k, solid, opts) { return apply(k, solid, "fillet", opts?.r, opts); }
 export function meshChamfer(k, solid, opts) { return apply(k, solid, "chamfer", opts?.d, opts); }
 
-function apply(k, solid, mode, magnitude, { edges, segs = DEFAULT_SEGS, sharpDeg = 20 } = {}) {
+// `segs` is the kernel's per-circle CAP: it bounds the blend densities (blendSegs)
+// and is what every circle was built at on a flat tier. `segsAt(r)` is what a circle
+// of radius r was ACTUALLY built at — the print tier sizes circles by chord tolerance
+// (circle-segs.js), so a flank's facet pitch is no longer the cap. The three places
+// that reason about the neighbouring tessellation (revolveTool's seam-grazing sag and
+// closed-revolve dephase, cornerHornTool's sphere burial) ask it; everything sized
+// from the blend's own sagitta bound keeps the cap. Absent, it is the cap — the
+// pre-print-rule behaviour, and byte-identical at preview either way.
+function apply(k, solid, mode, magnitude, { edges, segs = DEFAULT_SEGS, sharpDeg = 20, segsAt = null } = {}) {
   if (!(magnitude > 0)) throw new Error(`mesh ${mode}: magnitude must be > 0`);
+  const flankAt = segsAt ?? (() => segs);
   const chains = chainEdges(detectSharpEdges(solid.toIndexedMesh(), { sharpDeg }));
   const selected = chains.filter((ch) => matchesSelector(ch, edges));
   if (!selected.length) throw new UnsupportedEdgeError(`${mode} selector matched no sharp edges`);
@@ -1597,13 +1610,15 @@ function apply(k, solid, mode, magnitude, { edges, segs = DEFAULT_SEGS, sharpDeg
   const pSegs = blendSegs(segs, magnitude);
   const toolsFor = (ch) =>
     ch.kind === "planar"
-      ? planarTool(k, ch, magnitude, mode, segs, pSegs, endTins)
-      : [(ch.kind === "arc" ? revolveTool : prismTool)(k, ch, magnitude, mode, segs, pSegs)];
+      ? planarTool(k, ch, magnitude, mode, segs, pSegs, endTins, flankAt)
+      : ch.kind === "arc"
+        ? [revolveTool(k, ch, magnitude, mode, segs, pSegs, flankAt)]
+        : [prismTool(k, ch, magnitude, mode, segs, pSegs)];
   const cutters = [...effective, ...arcs].filter((ch) => ch.convex).flatMap(toolsFor);
-  cutters.push(...horns.map((h) => cornerHornTool(k, h, magnitude, segs)));
+  cutters.push(...horns.map((h) => cornerHornTool(k, h, magnitude, segs, flankAt)));
   cutters.push(...pivots.map((p) => reflexPivotTool(k, p, magnitude, mode, segs, pSegs)));
   const fillers = effective.filter((ch) => !ch.convex).flatMap(toolsFor);
-  if (mode === "fillet") cutters.push(...cornerPatches(k, effective, magnitude, segs));
+  if (mode === "fillet") cutters.push(...cornerPatches(k, effective, magnitude, segs, flankAt));
   let out = solid;
   if (cutters.length) out = out.cutAll(cutters);
   if (fillers.length) out = k.union([out, ...fillers]);

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

@@ -28,13 +28,14 @@
 // is sized from the erosion ball (2r), the larger of the two, so the coarser of
 // the two facetings still meets the tier's sagitta tolerance.
 
+import { segsForSagitta } from "./circle-segs.js";
+
 // Sphere tessellation from the facet sagitta r·(1 − cos(π/segs)): pick the
-// fewest segments that keep it under the quality tier's tolerance.
+// fewest segments that keep it under the quality tier's tolerance — its own
+// tolerance table and 12..64 window, on the shared formula.
 const SAGITTA_TOL = { preview: 0.05, print: 0.01 }; // mm
 export function roundAllSegs(r, quality) {
-  const tol = SAGITTA_TOL[quality] ?? SAGITTA_TOL.preview;
-  if (!(r > tol)) return 12;
-  return Math.min(64, Math.max(12, Math.ceil(Math.PI / Math.acos(1 - tol / r))));
+  return segsForSagitta(r, SAGITTA_TOL[quality] ?? SAGITTA_TOL.preview, 12, 64);
 }
 
 export function meshRoundAll(wasm, m, r, quality) {

package/src/framework/geometry/profile.js

@@ -79,13 +79,16 @@ export function arcGeometry(p0, via, p1) {
 // three points; the sweep direction is the one whose arc actually passes through `via`
 // (sign-free, winding-free). Facet count scales with the sweep's fraction of the kernel's
 // full-circle resolution `segs`, matching the piePolygon/circleProfile convention, so an
-// arc and a circleProfile of equal radius facet identically. A degenerate (collinear)
-// triple falls back to a single straight segment to p1 — the same "plain line" the OCCT
-// side gets when roundedProfile emits no `via`.
+// arc and a circleProfile of equal radius facet identically. `segs` is either that count
+// or a function of the arc's radius returning one — the mesh backend's print tier sizes
+// circles by chord tolerance (circle-segs.js) and hands the samplers the rule rather
+// than a number. A degenerate (collinear) triple falls back to a single straight segment
+// to p1 — the same "plain line" the OCCT side gets when roundedProfile emits no `via`.
 export function sampleArc(p0, via, p1, segs) {
   const g = arcGeometry(p0, via, p1);
   if (!g) return [[p1[0], p1[1]]];                        // collinear → straight line
-  const steps = Math.max(2, Math.ceil((segs * Math.abs(g.dA)) / (2 * Math.PI)));
+  const n = typeof segs === "function" ? segs(g.r) : segs;
+  const steps = Math.max(2, Math.ceil((n * Math.abs(g.dA)) / (2 * Math.PI)));
   const out = [];
   for (let s = 1; s <= steps; s++) {
     const ang = g.a0 + g.dA * (s / steps);
@@ -102,8 +105,26 @@ export function sampleArc(p0, via, p1, segs) {
 // cubic tracing a circular arc facets like the arc primitive at the same segs. Summing
 // |turn| at BOTH interior control points also catches S-curves a pure endpoint-tangent
 // test would miss. Depth cap guarantees termination. Pure in (args, segs).
+//
+// `segs` may be a function of radius (see sampleArc). A cubic has no single radius, so
+// the budget is decided per sub-curve from the radius it traces, recovered from its
+// chord c and turn t as the circle on which a chord c subtends t: r = c / (2·sin(t/2)).
+// That is EXACT for a circular arc. For any other cubic the control polygon's turn t
+// overstates the curve's, so r errs small and the count errs LOW — a slightly coarser
+// budget, not a finer one. The bias is bounded by the ratio of polygon turn to curve
+// turn, which the recursion drives to 1 as the pieces shrink, and at the turns that
+// pass (≤ 2π/116) it is under 0.02 % of the count. A cubic tracing a circle of radius
+// r therefore facets like the arc primitive of radius r under the same rule.
 export function sampleBezier(p0, c1, c2, p1, segs) {
-  const maxTurn = (2 * Math.PI) / Math.max(3, segs);
+  const segsAt = typeof segs === "function" ? segs : null;
+  const flatTurn = segsAt ? null : (2 * Math.PI) / Math.max(3, segs);
+  const maxTurnFor = (a, d, t) => {
+    if (!segsAt) return flatTurn;
+    const chord = Math.hypot(d[0] - a[0], d[1] - a[1]);
+    const half = Math.sin(t / 2);                    // t ≤ 2π here: two turns of ≤ π each
+    const r = half > 1e-9 ? chord / (2 * half) : Infinity; // straight (t ≈ 0): the cap, and t ≤ budget anyway
+    return (2 * Math.PI) / Math.max(3, segsAt(r));
+  };
   const out = [];
   const mid = (a, b) => [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
   const turn = (u, v) => {
@@ -117,7 +138,8 @@ export function sampleBezier(p0, c1, c2, p1, segs) {
     const ab = [b[0] - a[0], b[1] - a[1]];
     const bc = [c[0] - b[0], c[1] - b[1]];
     const cd = [d[0] - c[0], d[1] - c[1]];
-    if (depth >= 12 || turn(ab, bc) + turn(bc, cd) <= maxTurn) { out.push([d[0], d[1]]); return; }
+    const t = turn(ab, bc) + turn(bc, cd);
+    if (depth >= 12 || t <= maxTurnFor(a, d, t)) { out.push([d[0], d[1]]); return; }
     const p01 = mid(a, b), p12 = mid(b, c), p23 = mid(c, d);
     const p012 = mid(p01, p12), p123 = mid(p12, p23), m = mid(p012, p123);
     recurse(a, p01, p012, m, depth + 1);