partforge 0.67.0 → 0.67.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.67.0",
+  "version": "0.67.2",
   "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/app-scott-label.js

@@ -0,0 +1,13 @@
+// Local test harness for the "Scott Layered Label" cloud part (feedback report
+// 41850ea2, part 0d47960f) — the reflex-rim-pivot fix's real-world fixture. The
+// part source is a verbatim copy from the cloud part's part.js into
+// src/parts/scott-label.js. `npm run dev`, then open /scott-label.html.
+import "@fontsource-variable/geist";
+import "@fontsource-variable/geist-mono";
+import part from "./parts/scott-label.js";
+import { mount } from "./framework/index.js";
+
+mount(part, {
+  createWorker: (name) =>
+    new Worker(new URL("./scott-label-worker.js", import.meta.url), { type: "module", name }),
+});

package/src/framework/geometry/creased-normals.js

@@ -8,7 +8,7 @@
 // near-tangent), and a surface's own sharp edges stay crisp too. Each original
 // surface may carry a shading policy (shading-policy.js); surfaces without one
 // use SMOOTH, which reproduces the pre-policy behavior exactly.
-import { SMOOTH, COPLANAR_ANGLE, MIN_EDGE, cosDeg } from "./shading-policy.js";
+import { SMOOTH, COPLANAR_ANGLE, MIN_EDGE, MIN_FACE, cosDeg } from "./shading-policy.js";
 
 const COPLANAR_COS = cosDeg(COPLANAR_ANGLE);
 const MIN_EDGE2 = MIN_EDGE * MIN_EDGE;
@@ -48,17 +48,43 @@ export function creasedNormals(g, { policies = null, featureLabels = null } = {}
     const vx = vp[c] - vp[a], vy = vp[c + 1] - vp[a + 1], vz = vp[c + 2] - vp[a + 2];
     const wx = vp[c] - vp[b], wy = vp[c + 1] - vp[b + 1], wz = vp[c + 2] - vp[b + 2];
     const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
-    const L = Math.hypot(nx, ny, nz) || 1;
+    const L0 = Math.hypot(nx, ny, nz), L = L0 || 1; // the || 1 is for the normal divide ONLY
     fn[t * 3] = nx / L; fn[t * 3 + 1] = ny / L; fn[t * 3 + 2] = nz / L;
     const longest = Math.max(ux * ux + uy * uy + uz * uz, vx * vx + vy * vy + vz * vz, wx * wx + wy * wy + wz * wz);
-    thin[t] = longest > 0 ? L / Math.sqrt(longest) : 0; // |cross| / maxEdge = min height
+    // |cross| / maxEdge = min height — from the RAW cross magnitude, never the
+    // guarded L: a zero-area triangle (two float32-coincident vertices — the
+    // render-precision collapse of a sub-micron boolean seam sliver) must report
+    // thin 0 so the feature-edge gate drops it. With L it reported 1/maxEdge and
+    // sailed past the gate, and its garbage (0,0,0) normal reads as a 90° crease
+    // against every neighbor — a full-weight line down an otherwise smooth wall
+    // at whatever seam produced it.
+    thin[t] = longest > 0 ? L0 / Math.sqrt(longest) : 0;
+  }
+
+  // Second-stage weld for SHADING adjacency only: a boolean seam whose two
+  // sides land sub-micron apart keeps two distinct vertex columns that the
+  // merge map does not join, yet at render (float32) precision they are the
+  // same point — without this weld the facets on either side average their
+  // normals separately and the seam shades as a lighting crease. The line
+  // pass below deliberately keeps `remap` (Manifold's own topology): welding
+  // its edge keys would make pairing at collapsed seams order-dependent and
+  // could pair a boundary ring's edges away.
+  const weld = Uint32Array.from(remap);
+  {
+    const byPos = new Map();
+    for (let i = 0; i < nVert; i++) {
+      const o = i * np;
+      const key = `${vp[o]}|${vp[o + 1]}|${vp[o + 2]}`;
+      const first = byPos.get(key);
+      if (first === undefined) byPos.set(key, weld[i]); else weld[i] = first;
+    }
   }
 
   // canonical vertex → incident triangles
   const incident = new Map();
   for (let t = 0; t < nTri; t++)
     for (let k = 0; k < 3; k++) {
-      const cv = remap[tris[t * 3 + k]];
+      const cv = weld[tris[t * 3 + k]];
       const arr = incident.get(cv);
       if (arr) arr.push(t); else incident.set(cv, [t]);
     }
@@ -71,13 +97,19 @@ export function creasedNormals(g, { policies = null, featureLabels = null } = {}
     for (let k = 0; k < 3; k++) {
       const v = tris[t * 3 + k];
       let nx = 0, ny = 0, nz = 0;
-      for (const t2 of incident.get(remap[v])) {
-        // different cut surface → hard, EXCEPT two blend surfaces (boundaryLines on
-        // both): one band is many tool surfaces continuing each other tangentially,
-        // and hard normals at their handovers would put lighting seams along a band
-        // that used to shade as one re-originaled surface
+      for (const t2 of incident.get(weld[v])) {
+        // different cut surface → hard, EXCEPT when a blend surface (boundaryLines)
+        // is involved on either side. Blend↔blend: one band is many tool surfaces
+        // continuing each other tangentially, and hard normals at their handovers
+        // would put lighting seams along a band that used to shade as one
+        // re-originaled surface. Blend↔base: the band's start/end seams are TANGENT
+        // by construction (that is why the line pass needs boundaryLines to draw
+        // them at all), so shading them hard painted a permanent lighting ridge
+        // along every fillet boundary ring. Both cases still fall to the crease
+        // check below, so a genuinely sharp crossing (a chamfer's 45° shoulder, a
+        // band end-cap against a wall) stays hard.
         if (triOID[t2] !== oid &&
-          !(polFor(triOID[t2]).boundaryLines && polFor(oid).boundaryLines)) continue;
+          !(polFor(triOID[t2]).boundaryLines || polFor(oid).boundaryLines)) continue;
         if (fn[t2 * 3] * fx + fn[t2 * 3 + 1] * fy + fn[t2 * 3 + 2] * fz < sharpCos) continue; // sharp same-surface edge → hard
         nx += fn[t2 * 3]; ny += fn[t2 * 3 + 1]; nz += fn[t2 * 3 + 2];
       }
@@ -108,8 +140,12 @@ export function creasedNormals(g, { policies = null, featureLabels = null } = {}
       // independently tessellated tangent surfaces (e.g. a corner sphere meeting
       // its edge-fillet cylinders) can leave micron-wide wall strips whose FACES
       // are invisible but whose long boundary edges would otherwise draw at full
-      // line weight. A triangle thinner than MIN_EDGE cannot be seen, so its
-      // edges are noise by definition — same threshold the segment filter uses.
+      // line weight. A triangle thinner than MIN_FACE cannot carry a visible
+      // crease — the fan slivers a boolean face-split leaves near a tool
+      // crossing are 14-34µm wide with wildly tilted normals over sub-15µm of
+      // actual relief (see shading-policy.js) — so its edges are noise by
+      // definition. The gate is deliberately wider than the segment filter's
+      // MIN_EDGE below, which stays tight so short REAL segments survive.
       const sameOID = triOID[prev] === triOID[t];
       // Blend boundary: a cross-surface seam with a BLEND policy on EXACTLY one side
       // is the start/end of a fillet band — draw it even when tangent (the band's
@@ -121,7 +157,7 @@ export function creasedNormals(g, { policies = null, featureLabels = null } = {}
       // filter still drops the short ones).
       const boundary = !sameOID &&
         !!polFor(triOID[prev]).boundaryLines !== !!polFor(triOID[t]).boundaryLines;
-      if (!boundary && (thin[prev] < MIN_EDGE || thin[t] < MIN_EDGE)) continue;
+      if (!boundary && (thin[prev] < MIN_FACE || thin[t] < MIN_FACE)) continue;
       const dot = fn[prev * 3] * fn[t * 3] + fn[prev * 3 + 1] * fn[t * 3 + 1] + fn[prev * 3 + 2] * fn[t * 3 + 2];
       // A multi-hole cap triangulation can contain an opposite-wound bridge:
       // its two normals disagree by 180 degrees even though both triangles lie

package/src/framework/geometry/kernel-front.js

@@ -12,16 +12,11 @@
 //     capability (Manifold can't do toSTEP; both backends now define shape2d, so
 //     that stub is dead in practice — kept as a safety net for a future backend).
 // The per-Solid twin of this layer is addSugar() in solid-sugar.js.
-// opentype.js 2.x ships no `exports` map: bundlers take its `module` field (real
-// ESM, named `parse`), while Node ESM takes `main` (a UMD/CJS bundle, whose named
-// exports Node cannot statically detect — the namespace holds only `default`).
-// So `import * as opentype` gives a working `.parse` in the browser and `undefined`
-// under Node, which broke every headless text2d build (`opentype.parse is not a
-// function`) while the browser stayed green. Normalize both interop shapes here.
+// opentype.js's namespace shape differs between bundler and Node resolution —
+// see opentype-interop.js for the trap (it has bitten once in each direction).
 import * as opentypeNamespace from "opentype.js";
-const opentype = typeof opentypeNamespace.parse === "function"
-  ? opentypeNamespace
-  : (opentypeNamespace.default ?? opentypeNamespace);
+import { normalizeOpentype } from "./opentype-interop.js";
+const opentype = normalizeOpentype(opentypeNamespace);
 import { KernelCapabilityError } from "./errors.js";
 import { isPlainOptions, KERNEL_OP_SPECS } from "./op-options.js";
 import { textGlyphs } from "./text2d.js";

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

@@ -132,11 +132,20 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   // anything printable, so dropping it can never erase real geometry.
   const DEBRIS_VOL = 1e-6; // mm³
   const dropDebris = (m) => {
-    const parts = m.decompose();
-    if (parts.length <= 1) { for (const p of parts) T(p); return m; }
-    const kept = [];
-    for (const p of parts) { T(p); if (p.volume() >= DEBRIS_VOL) kept.push(p); }
-    return kept.length === parts.length ? m : T(Manifold.compose(kept));
+    // Iterated, not single-pass: compose() re-welds, and a sliver riding a kept
+    // component only as a vertex-weld can come apart as a FRESH femto-component
+    // in the composed result (measured on the melt fixture's grazing neck arcs:
+    // four needles dropped, two re-minted by the compose). Loop until a pass
+    // drops nothing; volumes shrink every round, so three passes is plenty.
+    for (let pass = 0; pass < 3; pass++) {
+      const parts = m.decompose();
+      if (parts.length <= 1) { for (const p of parts) T(p); return m; }
+      const kept = [];
+      for (const p of parts) { T(p); if (p.volume() >= DEBRIS_VOL) kept.push(p); }
+      if (kept.length === parts.length) return m;
+      m = T(Manifold.compose(kept));
+    }
+    return m;
   };
   // Blend surfaces KEEP their originalIDs, and every id the op introduced is
   // registered with the BLEND policy — that is what lets creased-normals draw the
@@ -189,20 +198,36 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       // the erosion consumes the whole plate below 2r, and just above it the two
       // rim bands graze each other — both belong to the reference morphology
       if (!(height > 2 * r * 1.05)) return null;
-      // MITER joins on all three offsets, deliberately: the true morphology mints
-      // outline corners of radius exactly r, and a rim fillet of radius r over an
-      // r-radius corner pinches its top tangent contour to a point — the planar
-      // sweep refuses, structurally. Miter keeps every corner SHARP instead, and
-      // the selector-free fillet below performs ALL the rounding: convex vertical
-      // edges (cutters at r — the same solid the round join would have produced),
-      // concave verticals (fillers), both rims, and the corner treatments. Melt
-      // and seal thresholds stay exact on straight stretches; corner-local
-      // thresholds and silhouettes differ from the ball morphology by the rim
-      // fillet's own corner tolerance (~0.25·r) — the documented corner trade.
+      // Join types are per-STEP, because a join only acts on the side an offset
+      // DIVERGES on. The two dilates diverge at SALIENT corners and use MITER,
+      // deliberately: the true morphology mints salient corners of radius
+      // exactly r, and a rim fillet of radius r over an r-radius salient corner
+      // pinches its top tangent contour to a point — the planar sweep refuses,
+      // structurally. Miter keeps them SHARP instead and the selector-free
+      // fillet below performs their rounding (cutters at r — the same solid the
+      // round join would have produced — plus the corner treatments). The erode
+      // diverges at REFLEX corners and uses ROUND: the ball morphology rounds a
+      // reflex corner into a radius-r concave arc (2r at the erode, halved by
+      // the re-dilate), and a concave arc offsets INWARD to 2r, so it cannot
+      // pinch the rim sweep — the rim rides it as an ordinary arc-in-planar
+      // chain. Keeping reflex corners sharp instead (all-Miter, the original
+      // design) handed the fillet a sharp vertical filler PLUS a sharp rim
+      // corner at once, and the filler — unioned after the cutters — re-covered
+      // the rim tools' corner cut, reintroducing the uncut-wedge point artifact
+      // the reflex pivot exists to remove. Melt and seal thresholds stay exact
+      // on straight stretches; salient-corner silhouettes differ from the ball
+      // morphology by the rim fillet's own corner tolerance (~0.25·r) — the
+      // documented corner trade — while reflex corners now match it exactly.
+      //
+      // Arc facets must stay well under the fillet's sharp-edge threshold
+      // (detectSharpEdges' 20° default) or the rounded wall would re-detect as a
+      // run of sharp vertical edges: floor the round join at 36 segments/360°
+      // (10° per facet) even when the sagitta rule alone would allow coarser.
+      const arcSegs = Math.max(roundAllSegs(2 * r, quality), 36);
       let cur = null;
       try {
         for (const delta of [r, -2 * r, r]) {
-          const next = (cur ?? cs).offset(delta, "Miter", 2);
+          const next = (cur ?? cs).offset(delta, delta > 0 ? "Miter" : "Round", 2, arcSegs);
           const cleaned = next.simplify(1e-6);
           next.delete?.();
           cur?.delete?.();
@@ -214,10 +239,30 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
         const wrapped = wrap(base, h("roundAllPrismBase", mHash, r, quality));
         // selector-free: every sharp edge of the mitered prism gets its radius here
         const filleted = wrapped.fillet(r);
-        // decouple from the fillet cache's pin: cached() will pin the object this
+        // Decouple from the fillet cache's pin: cached() will pin the object this
         // returns under the roundAll hash, and one WASM object must never sit
-        // under two cache entries (double-dispose on eviction)
-        return T(filleted._m.asOriginal());
+        // under two cache entries (double-dispose on eviction). The decouple is
+        // blend-AWARE, the same re-stamp label() performs: a blanket asOriginal()
+        // folded blend and base into one fresh surface, erasing the distinction
+        // the band-boundary lines need — a roundAll'd prism rendered with no
+        // feature lines at all, unlike the identical geometry from fillet().
+        // Re-stamp as two reserved ids instead (base stays unregistered → SMOOTH,
+        // the extruded section has no policy of its own) so the result draws
+        // exactly the lines the fillet drew.
+        const g0 = filleted._m.getMesh();
+        try {
+          const isBlend = (oid) => !!oidPolicies.get(oid)?.boundaryLines;
+          if (![...new Set(g0.runOriginalID)].some(isBlend)) return T(filleted._m.asOriginal());
+          const baseId = Manifold.reserveIDs(2), blendId = baseId + 1;
+          g0.runOriginalID = Uint32Array.from(g0.runOriginalID, (o) => (isBlend(o) ? blendId : baseId));
+          oidPolicies.set(blendId, BLEND);
+          // 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.
+          return dropDebris(T(new Manifold(g0)));
+        } finally {
+          g0.delete?.();
+        }
       } finally {
         cur?.delete?.();
       }

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

@@ -16,20 +16,25 @@
 // Anything else (helical edges, varying dihedral, branching curves) raises
 // UnsupportedEdgeError so a caller can reroute the build to the B-rep backend.
 //
-// Corner treatment: a salient two-chain corner in a common face plane is ROUNDED —
-// a small arc chain (radius ~1.05-1.25× the magnitude) replaces the mitre, its horn
-// block shaves the sharp corner down to band depth, and the band sweeps around with
-// no crease (see roundSalientCorners). The silhouette inside the band rounds by about
-// the blend radius at such corners; the flat shelf the horn leaves at the band's base
-// is the deliberate residue. A REFLEX corner in a common face plane gets the
-// rolling-ball PIVOT (reflexPivotAt/reflexPivotTool): the ball swings about the
-// corner's face-normal axis, touching the face and the vertical corner edge, and the
-// face's blend boundary rounds into an arc of radius r about the vertex — without it
-// the flush-ended neighbor tools leave a wedge of the original rim uncut and the face
-// keeps a point AT the corner (the label-part "artifacts" bug). Corners keep their
-// mitre only when too tight to host the salient setback (glyph-scale features smaller
-// than ~3× the magnitude), or when three or more chains meet (the spherical
-// cornerPatches below own the orthogonal three-chain case).
+// Corner treatment, by how sharp the corner is. A SHARP salient corner (turn past
+// SMOOTH_MAX_DEG — the same bar that makes chainEdges call it a corner at all) keeps
+// the honest MITRE: the two blends run to the vertex and cross in the classic
+// intersection seam every B-rep fillet shows; the seam is a real crease, its feature
+// line is correct, and the top face keeps its sharp corner (decided 2026-08-17 —
+// there is provably no band that hugs both walls around a salient corner without
+// creasing, and every lift-off construction strands a corner column that reads as an
+// artifact). A GENTLE salient corner (CORNER_ROUND_MIN_TURN..SMOOTH_MAX_DEG) is
+// steered instead — a small arc chain (radius ~1.05-1.25× the magnitude) replaces
+// the mitre and a horn block shaves the corner column to band depth — because a
+// shallow mitre's overlap wedge triangulates into junk lines while the steer's
+// silhouette cost is sub-visible at these angles. A REFLEX corner in a common face
+// plane gets the rolling-ball PIVOT (reflexPivotAt/reflexPivotTool): the ball swings
+// about the corner's face-normal axis, touching the face and the vertical corner
+// edge, and the face's blend boundary rounds into an arc of radius r about the
+// vertex — without it the flush-ended neighbor tools leave a wedge of the original
+// rim uncut and the face keeps a point AT the corner (the label-part "artifacts"
+// bug). Three-or-more-chain vertices go to the spherical cornerPatches below (the
+// orthogonal three-chain case).
 //
 // Known limits (documented, not bugs): radius feasibility is the caller's job (clamp
 // like filleted-box.js does — an oversized radius self-intersects the cutters).
@@ -54,10 +59,10 @@ export class UnsupportedEdgeError extends Error {
 // circles; spending it on a blend of radius r tessellates a 0.5 mm fillet to 0.2 µm
 // sagitta at preview quality — and a text rim's hundred-tool boolean then carries ~4×
 // the triangles it needs (measured 12 s / 4 GB on a lettering part before this cap).
-// BLEND_SAG (2 µm) is finer than preview quality's own ~4 µm sagitta at part scale;
+// BLEND_SAG (1 µm) is finer than preview quality's own ~4 µm sagitta at part scale;
 // the 0.02·r term keeps micro-blends sane, and the floor of 12 keeps every facet
 // angle (≤30°) under the viewer's 35° same-surface crease threshold.
-const BLEND_SAG = 2e-3; // mm — max chord sagitta of a blend cross-section
+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))));
@@ -68,6 +73,7 @@ function blendSegs(segs, r) {
 const cornerArcSegs = (segs, R, magnitude) => blendSegs(segs, R + magnitude);
 
 const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const pivotKey = (p) => `${Math.round(p[0] * WELD)},${Math.round(p[1] * WELD)},${Math.round(p[2] * WELD)}`;
 const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
 const scl = (a, s) => [a[0] * s, a[1] * s, a[2] * s];
 const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
@@ -260,11 +266,36 @@ export function chainEdges(edges) {
 // crossing) when sharp. Chains stitch only when they share an endpoint, the same face
 // plane, and the same convexity — the same-plane test is what keeps a top rim from ever
 // stitching to a bottom rim.
-function stitchPlanarChains(chains) {
+function stitchPlanarChains(chains, { absorbLines = false } = {}) {
   const open = [], out = [];
   for (const c of chains) (c.kind === "planar" && !c.closed ? open : out).push(c);
-  if (open.length < 2) return chains;
   const key = (p) => `${Math.round(p[0] * WELD)},${Math.round(p[1] * WELD)},${Math.round(p[2] * WELD)}`;
+  // Absorb LINE chains that continue an open planar chain — apply()'s re-stitch
+  // only, post-selection, so a dir/line selector still sees the line form. A
+  // straight run flanking a planarized arc otherwise keeps its prism tool, and
+  // the tangent junction between the two tools is exactly the overlap-seam
+  // category stitching exists to remove (measured: an exact rounded-rect rim
+  // with 0.5 mm corner arcs under a 0.3 mm fillet drew ~6 lines per junction).
+  // Absorbed into the sweep, the straight is geometrically identical — a prism
+  // IS the one-segment case of the sweep — and the junction becomes an interior
+  // tangent vertex the sweep miters.
+  if (absorbLines) {
+    for (let i = out.length - 1; i >= 0; i--) {
+      const c = out[i];
+      if (c.kind !== "line") continue;
+      const ends = [key(c.a), key(c.b)];
+      const partner = open.find((p) => p.convex === c.convex &&
+        [p.points[0], p.points[p.points.length - 1]].some((q) => ends.includes(key(q))));
+      if (!partner) continue;
+      const face = [c.n1, c.n2].find((n) => dot(n, partner.faceN) > FLANK_COS);
+      if (!face) continue;
+      const wall = face === c.n1 ? c.n2 : c.n1;
+      out.splice(i, 1);
+      open.push({ kind: "planar", points: [[...c.a], [...c.b]], closed: false,
+                  convex: c.convex, w: face, faceN: face, wallNs: [wall] });
+    }
+  }
+  if (open.length < 2) return [...out, ...open];
   const compatible = (a, b) => a.convex === b.convex && dot(a.faceN, b.faceN) > FLANK_COS &&
     Math.abs(dot(a.points[0], a.faceN) - dot(b.points[0], a.faceN)) <= TOL;
   const rev = (c) => ({ ...c, points: [...c.points].reverse(), wallNs: [...c.wallNs].reverse() });
@@ -739,9 +770,107 @@ function revolveTool(k, chain, magnitude, mode, segs, pSegs = segs) {
 // watertight). Any residual sweep refusal (float-edge fold the pre-split missed) is
 // converted to UnsupportedEdgeError so the caller reroutes to OCCT instead of failing
 // the build. Returns an ARRAY of tools — one per stretch.
-function planarTool(k, chain, magnitude, mode, segs, pSegs = segs) {
-  const { points, closed, convex, faceN, wallNs } = chain;
-  const pts = closed ? points.slice(0, -1) : points;   // drop the duplicated closure point
+// Collapse corner features smaller than the blend into virtual sharp corners.
+// A convex corner round with radius under the fold threshold (~0.37·magnitude at
+// the 1.1× reach) cannot be swept — the band's top tangent contour pinches — and
+// cannot be steered either (no setback room), so the fold guard breaks at EVERY
+// facet joint and the band shatters into overshot micro-tools. But such a feature
+// is geometrically a sharp corner blurred by less than the blend radius: replace
+// each maximal run of two or more consecutive breaking joints whose connecting
+// segments are shorter than the magnitude with the intersection of the flanking
+// edge lines, and the ordinary corner machinery (mitre / gentle steer / reflex
+// pivot) handles it downstream. The silhouette cost is bounded by the feature's
+// own radius — sub-blend by construction. Runs that have no usable intersection
+// (a ~180° cap, whose radius is stroke-scale and sweeps fine anyway) or whose
+// intersection lands implausibly far are left untouched.
+function collapseTightCorners(pts0, wallNs0, closed, magnitude) {
+  let pts = pts0, wallNs = wallNs0;
+  const m0 = pts.length, nSeg0 = closed ? m0 : m0 - 1;
+  if (nSeg0 < 3) return { pts, wallNs };
+  const reach = magnitude * 1.1, reachWall = 0.1 * magnitude;
+  const breaksAt = (pp, ww) => {
+    const m = pp.length, nSeg = closed ? m : m - 1;
+    const dir = [], sl = [];
+    for (let i = 0; i < nSeg; i++) {
+      const d = sub(pp[(i + 1) % m], pp[i]), l = len(d);
+      dir.push(scl(d, 1 / (l || 1))); sl.push(l);
+    }
+    const flags = new Array(m).fill(false);
+    for (let i = closed ? 0 : 1; i < (closed ? m : m - 1); i++) {
+      const iIn = (i - 1 + nSeg) % nSeg;
+      const c = clamp1(dot(dir[iIn], dir[i]));
+      const turn = Math.acos(c);
+      const bendIn = norm(sub(dir[i], dir[iIn]));
+      const reflexBend = dot(bendIn, ww[iIn]) + dot(bendIn, ww[i % nSeg]) > 0;
+      const r = reflexBend ? reachWall : reach;
+      flags[i] = c < -1 + 1e-6 || r * Math.tan(turn / 2) > 0.45 * Math.min(sl[iIn], sl[i]) ||
+        turn > (SMOOTH_MAX_DEG * Math.PI) / 180;
+    }
+    return { flags, dir, sl };
+  };
+  let { flags, dir, sl } = breaksAt(pts, wallNs);
+  // rotate a closed chain so runs never wrap; a chain breaking everywhere is left alone
+  if (closed) {
+    const pivot = flags.findIndex((b) => !b);
+    if (pivot === -1) return { pts, wallNs };
+    if (pivot > 0) {
+      pts = [...pts.slice(pivot), ...pts.slice(0, pivot)];
+      wallNs = [...wallNs.slice(pivot), ...wallNs.slice(0, pivot)];
+      ({ flags, dir, sl } = breaksAt(pts, wallNs));
+    }
+  }
+  const m = pts.length, nSeg = closed ? m : m - 1;
+  const out = [], outWalls = [];
+  let i = 0;
+  const pushPoint = (p, wallIdx) => {
+    out.push(p);
+    if (wallIdx != null) outWalls.push(wallNs[wallIdx]);
+  };
+  while (i < m) {
+    // maximal run of breaking joints chained by sub-magnitude segments
+    let j = i;
+    while (j + 1 < m && flags[j] && flags[j + 1] && sl[j] < magnitude) j++;
+    if (flags[i] && j > i) {
+      const iIn = (i - 1 + nSeg) % nSeg;
+      const d1 = dir[iIn], d2 = dir[j % nSeg];
+      const p1 = pts[i], p2 = pts[j];
+      // intersect the flanking edge lines: p1 + a·d1 = p2 − b·d2 (in-plane)
+      const c12 = dot(d1, d2);
+      const denom = 1 - c12 * c12;
+      let V = null;
+      if (denom > 1e-6) {
+        const w0 = sub(p2, p1);
+        const a = (dot(w0, d1) - c12 * dot(w0, d2)) / denom;
+        const cand = add(p1, scl(d1, a));
+        let extent = 0;
+        for (let t = i; t < j; t++) extent += sl[t];
+        if (len(sub(cand, p1)) < 2 * magnitude + extent) V = cand;
+      }
+      if (V) {
+        pushPoint(V, j % nSeg); // V starts the outgoing segment: wall of seg j
+        i = j + 1;
+        continue;
+      }
+    }
+    pushPoint(pts[i], i < nSeg ? i : null);
+    i++;
+  }
+  if (out.length < (closed ? 3 : 2)) return { pts: pts0, wallNs: wallNs0 };
+  return { pts: out, wallNs: outWalls };
+}
+
+function planarTool(k, chain, magnitude, mode, segs, pSegs = segs, endTins = null) {
+  const { points, closed, convex, faceN } = chain;
+  let { wallNs } = chain;
+  let pts = closed ? points.slice(0, -1) : points;   // drop the duplicated closure point
+  // Corner features SMALLER than the blend collapse to a virtual sharp corner
+  // BEFORE any tool is built (see collapseTightCorners) — a run of fold-breaking
+  // joints on a sub-blend-radius corner round otherwise shatters into per-facet
+  // micro-tools whose disagreements notch the band (the non-bold glyph "divot":
+  // a raw letter terminal's ~0.1-0.25 mm corner rounds under a 0.3 mm fillet;
+  // bold outlines never hit this because the 0.4 mm round offset pads every
+  // convex radius past the fold threshold).
+  if (convex) ({ pts, wallNs } = collapseTightCorners(pts, wallNs, closed, magnitude));
   const m = pts.length;
   const at = (i) => pts[((i % m) + m) % m];
   const nSeg = closed ? m : m - 1;
@@ -765,13 +894,35 @@ function planarTool(k, chain, magnitude, mode, segs, pSegs = segs) {
   // points; a reflex split gets the rolling-ball PIVOT (reflexPivotTool — without it
   // the flush stretch ends leave the corner wedge uncut and the face keeps its point);
   // too-tight salient splits keep the overshoot mitre.
-  const reach = magnitude * 1.5;
+  // The reach bound is SIDE-aware, mirroring the sweep's own direction-aware
+  // check: rings converge only on the inside of a bend, and only the profile's
+  // reach TOWARD the bend center matters. The bend axis of a planar chain is
+  // the face normal, so that reach is the profile's IN-PLANE extent — the
+  // face-tangency inset, magnitude (+2% corner delta; the arc between the
+  // tangencies never reaches past them on the corner side) — NOT the rigid
+  // 1.5× diagonal bound, whose extra 50% is the AXIAL extent that a bend about
+  // the face normal cannot consume. The old bound split any salient outline
+  // arc under ~1.7·magnitude into per-facet micro-tools (a bold glyph's 0.4 mm
+  // offset-round corners under a 0.3 mm rim fillet became a patchwork of
+  // ~20 µm tools whose disagreements notched the band — the "divot" artifact);
+  // with the in-plane bound those arcs ride the one continuous sweep, and
+  // splitting starts only near the genuine pinch (R ≈ 1.2·magnitude, where
+  // the top tangent contour is closing toward a point). A reflex bend curves
+  // past the wall, where the profile reaches only the corner delta — the
+  // symmetric bound there shattered concave arcs of the same radii (the
+  // roundAll fast path's reflex arcs exactly).
+  const reach = magnitude * 1.1;
+  const reachWall = 0.1 * magnitude;
   const breaks = [];
   for (let i = closed ? 0 : 1; i < (closed ? m : m - 1); i++) {
     const iIn = (i - 1 + nSeg) % nSeg;
     const c = clamp1(dot(segDir[iIn], segDir[i]));
     const turn = Math.acos(c);
-    const fold = c < -1 + 1e-6 || reach * Math.tan(turn / 2) > 0.45 * Math.min(segLen[iIn], segLen[i]);
+    // inside-of-bend direction ≈ change of travel; past the wall ⇒ reflex bend
+    const bendIn = norm(sub(segDir[i], segDir[iIn]));
+    const reflexBend = dot(bendIn, wallNs[iIn]) + dot(bendIn, wallNs[i % nSeg]) > 0;
+    const r = reflexBend ? reachWall : reach;
+    const fold = c < -1 + 1e-6 || r * Math.tan(turn / 2) > 0.45 * Math.min(segLen[iIn], segLen[i]);
     const sharp = turn > (SMOOTH_MAX_DEG * Math.PI) / 180;
     if (fold || sharp) breaks.push(i);
   }
@@ -794,8 +945,12 @@ function planarTool(k, chain, magnitude, mode, segs, pSegs = segs) {
       const nextB = closed
         ? breaks[(j + 1) % breaks.length] + (j + 1 === breaks.length ? m : 0)
         : (j + 1 < breaks.length ? breaks[j + 1] : m - 1);
+      // a SHARP corner may steer only when another selected chain leaves this
+      // vertex out of the face plane (see apply()'s endTins note) — otherwise
+      // it keeps the honest mitre and cornerArcAt's upper gate refuses it
+      const allowSharp = !!(endTins?.get(pivotKey(at(i)))?.some((t) => Math.abs(dot(t, faceN)) > 0.7));
       const got = cornerArcAt(at(i), faceN, scl(segDir[iIn], -1), segDir[i],
-        wallNs[iIn], wallNs[i], segSum(prevB, i), segSum(i, nextB), magnitude);
+        wallNs[iIn], wallNs[i], segSum(prevB, i), segSum(i, nextB), magnitude, allowSharp);
       if (got) { cornerArcs.set(i, got); continue; }
       const piv = reflexPivotAt(at(i), faceN, scl(segDir[iIn], -1), segDir[i], wallNs[iIn], wallNs[i]);
       if (piv) pivots.push(piv);
@@ -877,33 +1032,32 @@ function planarTool(k, chain, magnitude, mode, segs, pSegs = segs) {
 }
 
 // ---------------------------------------------------------------------------
-// Rounded corners. Where exactly TWO selected convex chains meet at a salient corner
-// in a common face plane (a letter corner, a polygon corner on a rim), the blend used
-// to continue straight through from both sides and the two tools crossed in a mitre.
-// That groove is a REAL crease — 76-90° dihedral, measured — so the feature-line
-// overlay faithfully drew a polyline ACROSS the blend band at every such corner, and
-// OCCT's native fillet produces the same intersection-and-trim crease. There is no
-// groove-free construction that keeps the silhouette sharp: the two straight blends
-// must either intersect or the blend must steer around the corner. This steers: the
-// corner is replaced by a small circular ARC chain (radius ~1.05-1.25× the blend
-// magnitude, tangent to both neighbors at a setback), the neighbors are trimmed to the
-// tangent points, and the existing revolveTool sweeps the arc — exactly the shape a
-// rounded-rectangle rim already has, which renders line-free today. The cost, stated
-// plainly: within the band the silhouette rounds by about the blend radius at corners
-// sharper than CORNER_ROUND_MIN_TURN; gentler corners keep their exact silhouette (a
-// mitre under the viewer\'s 35° line threshold draws nothing).
+// Steered corners. Where exactly TWO selected convex chains meet at a salient corner
+// in a common face plane (a letter corner, a polygon corner on a rim), the two blends
+// cross in a mitre — a REAL crease, 76-90° dihedral measured, the same
+// intersection-and-trim seam OCCT's native fillet produces. There is no groove-free
+// construction that keeps the silhouette sharp: a band tangent to both walls around a
+// salient corner must crease, and a band that lifts off the walls strands the corner
+// column (verified again 2026-08-17 — the reflex pivot's torus does NOT mirror to
+// salient corners; the ball never touches a convex corner edge, and the mitre groove
+// of the neighbor cylinders survives beyond any such patch). So the mitre IS the
+// treatment for corners sharp enough to read as corners — see cornerArcAt's upper
+// gate — and the steer below exists only for the GENTLE band
+// (CORNER_ROUND_MIN_TURN..SMOOTH_MAX_DEG): the corner is replaced by a small
+// circular ARC chain (radius ~1.05-1.25× the blend magnitude, tangent to both
+// neighbors at a setback), the neighbors are trimmed to the tangent points, and the
+// existing revolveTool sweeps the arc. At these angles a mitre's long shallow
+// overlap wedge triangulates into >35° junk lines (measured: a 20.7° mitre still
+// drew, an ~8° one does not) while the steer's silhouette cost — a sagitta of
+// ρ·(1−cos(turn/2)), plus the horn's sub-visible shelf — stays microns deep, so the
+// trade runs the opposite way to a sharp corner's.
 //
 // REFLEX corners take the rolling-ball PIVOT instead (reflexPivotAt below): steering
 // the band path around a reflex corner would ADD material, but the ball itself swings
 // about the corner touching the face and the vertical corner edge — see the reflex
-// pivot section. A salient corner whose neighbors are too short to host the setback
-// (tight glyph features) falls back to the mitre — that fallback is never a failure.
-// Corners gentler than this keep their mitre: the two blends there differ by less than
-// the mitre turn everywhere, far under the viewer's 35° line threshold, and the shallow
-// overlap sliver stays too flat for simplify() to fold into visible creases. Measured:
-// a 20.7° mitre still drew (its long shallow overlap wedge triangulates into >35°
-// junk), an ~8° one does not. The silhouette cost of rounding a gentle corner is a
-// sagitta of ρ·(1−cos(turn/2)) — sub-micron at these angles — so the gate is safe low.
+// pivot section. A gentle salient corner whose neighbors are too short to host the
+// setback (tight glyph features) falls back to the mitre — that fallback is never a
+// failure.
 const CORNER_ROUND_MIN_TURN = (8 * Math.PI) / 180;
 const RHO_MIN = 1.05;   // × magnitude — revolve floor: the profile reaches magnitude inward of the arc
 const RHO_PREF = 1.25;  // × magnitude — preferred corner radius, a hair over the floor for margin
@@ -912,10 +1066,24 @@ const RHO_PREF = 1.25;  // × magnitude — preferred corner radius, a hair over
 // wall1/wall2 are the sides\' outward wall normals at the vertex; len1/len2 bound the
 // setback. Returns { arc, t } (a synthetic kind:"arc" chain for revolveTool, plus the
 // setback to trim each side by) or null when the corner keeps its mitre.
-function cornerArcAt(vertex, f, tin1, tin2, wall1, wall2, len1, len2, magnitude) {
+function cornerArcAt(vertex, f, tin1, tin2, wall1, wall2, len1, len2, magnitude, allowSharp = false) {
   const tIn = scl(tin1, -1), tOut = tin2;         // travel: arrive along side 1, depart into 2
   const turn = Math.acos(clamp1(dot(tIn, tOut)));
   if (turn < CORNER_ROUND_MIN_TURN) return null;
+  // A corner past the chain-smoothness bar READS as a corner and keeps the honest
+  // mitre (decided 2026-08-17): the two blends run to the vertex and cross in the
+  // classic intersection seam every B-rep fillet shows — the seam is a real crease,
+  // its feature line is correct, and the top face keeps its sharp corner. The
+  // arc-steer below is only for gentle corners, where the sub-visible horn shelf is
+  // a fair price for killing the shallow-overlap junk lines a gentle mitre draws.
+  // Steering SHARP corners bought a clean band at the cost of a rounded in-band
+  // silhouette hovering over the sharp extrude corner with a flat shelf between —
+  // a mismatch no CAD user expects (the label part's non-bold letter terminals).
+  // `allowSharp` is the one exception: when the corner's vertical edge is being
+  // blended too (roundAll, a selector-free fillet), the column below the band is
+  // itself rounded at r — the steer approximates the ball's sphere corner there
+  // and nothing is left to mismatch (planarTool derives it from apply()'s endTins).
+  if (!allowSharp && turn > (SMOOTH_MAX_DEG * Math.PI) / 180) return null;
   const turnS = dot(cross(tIn, tOut), f);
   const matLeft = dot(wall1, cross(tIn, f)) > 0;
   if ((turnS > 0) !== matLeft) return null;       // reflex: the crease is real — keep the mitre
@@ -1246,12 +1414,28 @@ function roundSalientCorners(selected, magnitude) {
 // so the only new surface is the octant. Non-orthogonal corners keep the mitre
 // — the safe, documented default.
 function cornerPatches(k, selected, r, segs) {
-  const lines = selected.filter((ch) => ch.kind === "line" && ch.convex);
   const byVertex = new Map();
-  for (const ch of lines) {
-    for (const [pt, dirOut] of [[ch.a, ch.dir], [ch.b, scl(ch.dir, -1)]]) {
-      const key = pt.map((v) => Math.round(v * 1e4)).join(",");
-      (byVertex.get(key) ?? byVertex.set(key, []).get(key)).push({ pt, dirOut });
+  const push = (pt, dirOut) => {
+    const key = pt.map((v) => Math.round(v * 1e4)).join(",");
+    (byVertex.get(key) ?? byVertex.set(key, []).get(key)).push({ pt, dirOut });
+  };
+  for (const ch of selected) {
+    if (ch.convex !== true) continue;
+    if (ch.kind === "line") {
+      push(ch.a, ch.dir);
+      push(ch.b, scl(ch.dir, -1));
+    } else if (ch.kind === "planar" && !ch.closed) {
+      // A planar chain END whose end segment runs straight for ≥ r qualifies
+      // too: inside the corner cube the sweep is the same straight cylinder a
+      // line chain's prism tool would cut, so the octant construction holds
+      // unchanged. This is the roundAll fast path's mixed corner — a straight
+      // rim edge and a vertical edge (line chains) meeting a planar rim chain
+      // whose curvature lives far from the corner. Requiring the full r of
+      // straight run keeps the cube inside the cylinder-only zone.
+      const p = ch.points, n = p.length;
+      const d0 = sub(p[1], p[0]), dN = sub(p[n - 2], p[n - 1]);
+      if (len(d0) >= r) push(p[0], scl(d0, 1 / len(d0)));
+      if (len(dN) >= r) push(p[n - 1], scl(dN, 1 / len(dN)));
     }
   }
   const patches = [];
@@ -1305,12 +1489,27 @@ function apply(k, solid, mode, magnitude, { edges, segs = DEFAULT_SEGS, sharpDeg
   // Face-plane arc rims sweep their own polyline (see planarizeArc); re-stitch so a
   // converted arc joins its planar neighbors — chainEdges' own stitch pass ran before
   // these chains were planar, so their junctions are still open here.
-  const planarized = stitchPlanarChains(selected.map((ch) => planarizeArc(ch) ?? ch));
+  const planarized = stitchPlanarChains(selected.map((ch) => planarizeArc(ch) ?? ch), { absorbLines: true });
+  // Ends of selected chains, keyed by vertex — planarTool steers a SHARP break
+  // corner only when another selected chain leaves that vertex out of the face
+  // plane (a vertical edge being blended too, the roundAll/trihedral case where
+  // the corner column below the band is itself rounded and the steer's shelf is
+  // consumed by that blend). A sharp corner with nothing else selected there
+  // keeps the honest mitre — see the steered-corners section.
+  const endTins = new Map();
+  for (const ch of planarized) {
+    if (ch.closed || (ch.kind !== "line" && ch.kind !== "planar")) continue;
+    for (const end of ["start", "end"]) {
+      const info = chainEndInfo(ch, end);
+      const kk = pivotKey(info.v);
+      (endTins.get(kk) ?? endTins.set(kk, []).get(kk)).push(info.tin);
+    }
+  }
   const { chains: effective, arcs, horns, pivots } = roundSalientCorners(planarized, magnitude);
   const pSegs = blendSegs(segs, magnitude);
   const toolsFor = (ch) =>
     ch.kind === "planar"
-      ? planarTool(k, ch, magnitude, mode, segs, pSegs)
+      ? planarTool(k, ch, magnitude, mode, segs, pSegs, endTins)
       : [(ch.kind === "arc" ? revolveTool : 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)));

package/src/framework/geometry/opentype-interop.js

@@ -0,0 +1,13 @@
+// opentype.js 2.x ships no `exports` map, so what importing it yields splits by
+// resolver: bundlers take the `module` field (real ESM — named `parse`, NO
+// default export), while Node takes `main` (a UMD/CJS bundle whose named exports
+// Node's lexer cannot statically detect — the namespace holds ONLY `default`).
+// Reading `.default` unconditionally is therefore correct under Node and
+// `undefined` in every browser bundle; reading a named export is the reverse.
+// That asymmetry once broke headless text2d builds (kernel-front's static
+// import) and later broke every BROWSER build of a part declaring `fonts`
+// ("undefined is not an object (evaluating 'p.parse')") while headless tests
+// stayed green (jobs' dynamic import). Both call sites normalize through this
+// one function so the two interop shapes stay handled in one place.
+export const normalizeOpentype = (ns) =>
+  typeof ns?.parse === "function" ? ns : (ns?.default ?? ns);

package/src/framework/geometry/shading-policy.js

@@ -20,6 +20,15 @@ export const BLEND = Object.freeze({ creaseAngle: 35, sameSurfaceLines: true, bo
 export const COPLANAR_ANGLE = 5;  // deg — cut seams bending less than this are coplanar: no line
 export const TANGENT_ANGLE = 5;   // deg — B-rep edges whose faces agree within this are tangent: no line
 export const MIN_EDGE = 0.01;     // mm — drop shorter segments (degenerate slivers, pole edges)
+// mm — a feature-line's incident FACES must both be at least this wide (min height).
+// Wider than MIN_EDGE deliberately: a boolean face-split near a tool crossing (a
+// mitre corner, a pivot's angular overshoot) re-triangulates the split band quad
+// against seam vertices that sit microns off its plane — long fan slivers 14-34µm
+// wide whose normals tilt 40-56°, drawing a full-weight line down an otherwise
+// perfect band (total surface relief under 15µm — sub-visible at any scale this
+// kernel prints at). Real band facets at the sagitta-bounded density are ≥ ~70µm
+// wide; boundary rings bypass the gate entirely.
+export const MIN_FACE = 0.04;
 
 // Loft rings with at least this many sides read as an approximation of a smooth
 // surface (e.g. a 64-gon "circle"), not as 64 intentional facets.

package/src/framework/geometry/sweep.js

@@ -112,12 +112,22 @@ export function resolveSweepStations(profile2D, path3D, { closed = false, corner
           rodrigues(N, axis, ang), rodrigues(B, axis, ang)));
       }
     } else {                                              // sharp miter: one station in the bisecting plane
-      if (maxReach * Math.tan(theta / 2) > 0.5 * Math.min(lenIn, lenOut))
-        throw new Error(`sweep: profile too wide for the bend at vertex ${vtx} (turn too sharp / segment too short) — increase cornerRadius or lengthen the segment`);
       const Nh = rodrigues(N, axis, theta / 2), Bh = rodrigues(B, axis, theta / 2);
       const mDir = rodrigues(tIn, axis, theta / 2);       // ring-plane normal (average travel dir)
       const u = norm(cross(axis, mDir));                  // in-plane bend direction (stretch axis)
       const cosh = Math.cos(theta / 2);
+      // Fold check, DIRECTION-aware: consecutive mitered rings converge only on
+      // the inside of the bend (u points toward the bend center; the far side
+      // diverges), so what must fit is the profile's stretched reach along +u —
+      // not its symmetric max-|vertex| bound, which refused tight concave rim
+      // sweeps whose inside-of-bend extent is only the blend profile's ~2%-of-
+      // magnitude beyond-wall margin (mesh-fillet's planar chains over a
+      // radius≈magnitude concave outline arc are exactly that case).
+      const uN = dot(u, Nh), uB = dot(u, Bh);
+      let reachIn = 0;
+      for (const [x, y] of profile2D) reachIn = Math.max(reachIn, x * uN + y * uB);
+      if ((reachIn / cosh) * Math.tan(theta / 2) > 0.5 * Math.min(lenIn, lenOut))
+        throw new Error(`sweep: profile too wide for the bend at vertex ${vtx} (turn too sharp / segment too short) — increase cornerRadius or lengthen the segment`);
       stations.push(profile2D.map(([x, y]) => {
         const p = add(scl(Nh, x), scl(Bh, y));            // profile point in the miter plane (spanned by u, axis)
         return add(center, add(scl(axis, dot(p, axis)), scl(u, dot(p, u) / cosh))); // stretch the u component

package/src/framework/jobs.js

@@ -5,6 +5,7 @@
 import { meshTo3MF } from "./geometry/threemf.js";
 import { exportablePartNames } from "./export-select.js";
 import { resolveFonts } from "./fonts.js";
+import { normalizeOpentype } from "./geometry/opentype-interop.js";
 import { ensureImports, resolveImports } from "./imports.js";
 import { safeName } from "./safe-name.js";
 import { exportSubParts, resolveParams, buildPosed } from "./part-model.js";
@@ -100,9 +101,11 @@ export async function handle(kernel, part, msg, post, opts = {}) {
   try {
     // Preload any part-declared fonts into the kernel before building — once per
     // font name; a lazy dynamic import because this is async context (unlike the
-    // synchronous kernel-front), so it doesn't cost sync callers anything.
+    // synchronous kernel-front), so it doesn't cost sync callers anything. The
+    // namespace shape differs between bundler and Node resolution (a bare
+    // `.default` here is undefined in every browser bundle) — normalize it.
     if (part.fonts && kernel._fonts) {
-      const opentype = (await import("opentype.js")).default;
+      const opentype = normalizeOpentype(await import("opentype.js"));
       const bufs = await resolveFonts(part.fonts);
       for (const [name, buf] of bufs) if (!kernel._fonts.has(name)) kernel._fonts.set(name, opentype.parse(buf));
     }

package/src/parts/scott-label.js

@@ -0,0 +1,252 @@
+const FONT_URLS = {
+  pacifico: "https://raw.githubusercontent.com/google/fonts/main/ofl/pacifico/Pacifico-Regular.ttf",
+  dancing: "https://raw.githubusercontent.com/google/fonts/main/ofl/dancingscript/DancingScript%5Bwght%5D.ttf",
+  greatVibes: "https://raw.githubusercontent.com/google/fonts/main/ofl/greatvibes/GreatVibes-Regular.ttf",
+};
+
+const slantProfile = (k, profile, shear) => {
+  if (!shear) return profile;
+  const regions = profile.toRegions();
+  if (!Array.isArray(regions)) return profile;
+
+  let combined = null;
+  for (const region of regions) {
+    const outer = [];
+    for (const point of region.outer) {
+      outer.push([point[0] + shear * point[1], point[1]]);
+    }
+    const holes = [];
+    for (const hole of region.holes) {
+      const slantedHole = [];
+      for (const point of hole) {
+        slantedHole.push([point[0] + shear * point[1], point[1]]);
+      }
+      holes.push(slantedHole);
+    }
+    const slantedRegion = k.shape2d({ outer, holes });
+    combined = combined ? combined.union(slantedRegion) : slantedRegion;
+  }
+  return combined || profile;
+};
+
+const styleProfile = (k, profile, bold, italic) => {
+  let styled = slantProfile(k, profile, italic ? 0.2126 : 0);
+  if (bold) {
+    styled = styled.offset(0.4, { corners: "round", segs: 32 });
+  }
+  return styled;
+};
+
+const offsetGlyphContours = (k, profile, distance) => {
+  const options = { corners: "round", segs: 32 };
+  const regions = profile.regions();
+  if (!Array.isArray(regions)) return k.hull([profile]).offset(distance, options);
+  let combined = null;
+  for (const region of regions) {
+    const expanded = k.hull([region]).offset(distance, options);
+    combined = combined ? combined.union(expanded) : expanded;
+  }
+  return combined || k.hull([profile]).offset(distance, options);
+};
+
+const planarTopFillet = (solid, height, radius) => solid.fillet({
+  r: radius,
+  edges: { inPlane: "XY", at: height },
+});
+
+const filletGlyphRegions = (k, profile, height, radius) => {
+  const regions = profile.regions();
+  if (!Array.isArray(regions)) return profile.extrude({ h: height });
+  const rounded = [];
+  for (const region of regions) {
+    const glyph = region.extrude({ h: height });
+    rounded.push(planarTopFillet(glyph, height, radius));
+  }
+  if (rounded.length === 1) return rounded[0];
+  return k.union(rounded);
+};
+
+export default {
+  meta: {
+    title: "Editable Layered Label",
+    units: "mm",
+    background: 0x171a20,
+  },
+
+  parameters: [
+    {
+      id: "label",
+      title: "Label",
+      description: "Dimensions for the raised name and its larger lower backing layer.",
+      controls: [
+        {
+          key: "text",
+          type: "text",
+          label: "Label text",
+          description: "Text shown on the raised face; changes preview immediately.",
+        },
+        {
+          key: "fontStyle",
+          type: "select",
+          label: "Font",
+          options: [
+            { value: "roboto", label: "Roboto" },
+            { value: "pacifico", label: "Pacifico Script" },
+            { value: "dancing", label: "Dancing Script" },
+            { value: "greatVibes", label: "Great Vibes Script" },
+          ],
+          description: "Choose the bundled sans-serif or an elegant script font.",
+        },
+        {
+          key: "bold",
+          type: "checkbox",
+          label: "Bold",
+          description: "Adds 0.4 mm of weight around every letter stroke.",
+        },
+        {
+          key: "italic",
+          type: "checkbox",
+          label: "Italic",
+          description: "Slants the lettering 12 degrees to the right.",
+        },
+        {
+          key: "textSize",
+          label: "Letter height",
+          unit: "mm",
+          min: 10,
+          max: 60,
+          step: 1,
+          description: "Nominal height of the raised lettering.",
+        },
+        {
+          key: "backingStyle",
+          type: "select",
+          label: "Backing edge style",
+          options: [
+            { value: "fillet", label: "Top fillet (planar)" },
+            { value: "roundAll", label: "Round all edges" },
+          ],
+          description: "Top fillet rounds only the top rim; Round all rounds every edge of the backing (roundAll test).",
+        },
+        {
+          key: "border",
+          label: "Backing offset",
+          unit: "mm",
+          min: 2,
+          max: 20,
+          step: 0.5,
+          recommended: [4, 12],
+          description: "Distance the lower layer extends beyond the lettering.",
+        },
+        {
+          key: "backingThickness",
+          label: "Lower layer thickness",
+          unit: "mm",
+          min: 1.2,
+          max: 8,
+          step: 0.1,
+          recommended: [2, 4],
+          description: "Printable thickness of the larger backing layer.",
+        },
+        {
+          key: "letterThickness",
+          label: "Raised letter thickness",
+          unit: "mm",
+          min: 0.8,
+          max: 6,
+          step: 0.1,
+          recommended: [1.2, 3],
+          description: "Height of the raised lettering above the lower layer.",
+        },
+      ],
+    },
+  ],
+
+  defaults: {
+    text: "Scott",
+    fontStyle: "roboto",
+    bold: 0,
+    italic: 0,
+    backingStyle: "roundAll",
+    textSize: 31,
+    border: 5,
+    backingThickness: 2.5,
+    letterThickness: 2,
+  },
+
+  derive: (p) => ({
+    textValue: String(p.text ?? "").trim() || "Scott",
+    fontUrl: FONT_URLS[p.fontStyle],
+    topZ: p.backingThickness,
+    totalHeight: p.backingThickness + p.letterThickness,
+  }),
+
+  parts: {
+    backing: {
+      label: "Lower outer layer",
+      views: ["backing", "assembly"],
+      display: { color: 0x1e88e5 },
+      build: (k, p, d) => {
+        const rawTextProfile = k.text2d(d.textValue, {
+          size: p.textSize,
+          ...(d.fontUrl ? { font: d.fontUrl } : {}),
+          align: "center",
+          valign: "middle",
+        });
+        const textProfile = slantProfile(k, rawTextProfile, p.italic ? 0.2126 : 0);
+        const backingProfile = offsetGlyphContours(
+          k,
+          textProfile,
+          p.border + (p.bold ? 0.4 : 0),
+        );
+        const topRound = Math.min(0.3, p.backingThickness / 2 - 0.1);
+        const solid = p.backingStyle === "roundAll"
+          ? backingProfile.extrude({ h: p.backingThickness }).roundAll(topRound)
+          : filletGlyphRegions(k, backingProfile, p.backingThickness, topRound);
+        return solid.label("Letter contour backing");
+      },
+    },
+    lettering: {
+      label: "Editable lettering",
+      views: ["lettering", "assembly"],
+      display: { color: 0xfdd835 },
+      build: (k, p, d) => {
+        const rawLetteringProfile = k.text2d(d.textValue, {
+          size: p.textSize,
+          ...(d.fontUrl ? { font: d.fontUrl } : {}),
+          align: "center",
+          valign: "middle",
+        });
+        const letteringProfile = styleProfile(k, rawLetteringProfile, p.bold, p.italic);
+        const topRound = Math.min(0.3, p.letterThickness / 2 - 0.1, p.textSize * 0.015);
+        return filletGlyphRegions(k, letteringProfile, p.letterThickness, topRound)
+          .at([0, 0, d.topZ])
+          .label("Raised text");
+      },
+    },
+  },
+
+  views: {
+    backing: { label: "Lower layer" },
+    lettering: { label: "Lettering" },
+    assembly: { label: "Layered label" },
+  },
+
+  verify: {
+    process: "fdm-pla",
+    expect: {
+      backing: {
+        watertight: true,
+        bbox: "<=[*,*,8]",
+      },
+      lettering: {
+        watertight: true,
+        bbox: "<=[*,*,14]",
+      },
+      _view: {
+        overlaps: 0,
+        contacts: [["backing", "lettering"]],
+      },
+    },
+  },
+};

package/src/scott-label-worker.js

@@ -0,0 +1,3 @@
+import part from "./parts/scott-label.js";
+import { runWorker } from "./framework/worker.js";
+runWorker(part);

package/src/testing/manifold.js

@@ -4,6 +4,7 @@
 import Module from "manifold-3d";
 import { createManifoldKernel } from "../framework/geometry/manifold-backend.js";
 import { resolveFonts } from "../framework/fonts.js";
+import { normalizeOpentype } from "../framework/geometry/opentype-interop.js";
 import { ensureImports } from "../framework/imports.js";
 import { nodeAssetSources } from "./assets.js";
 import { tessellateStepAssets } from "./step-mesh.js";
@@ -12,7 +13,7 @@ export async function bootManifoldKernel({ quality = "preview", fonts, imports,
   const wasm = await Module();
   wasm.setup();
   const kernel = createManifoldKernel(wasm, { quality });
-  if (fonts) { const opentype = (await import("opentype.js")).default;
+  if (fonts) { const opentype = normalizeOpentype(await import("opentype.js"));
     for (const [name, buf] of await resolveFonts(nodeAssetSources(fonts))) kernel._fonts.set(name, opentype.parse(buf)); }
   if (imports) {
     const decl = nodeAssetSources(imports);

package/src/testing/occt.js

@@ -6,6 +6,7 @@ import path from "path";
 import fs from "fs";
 import { createOcctKernel } from "../framework/geometry/occt-backend.js";
 import { resolveFonts } from "../framework/fonts.js";
+import { normalizeOpentype } from "../framework/geometry/opentype-interop.js";
 import { ensureImports } from "../framework/imports.js";
 import { nodeAssetSources } from "./assets.js";
 
@@ -18,7 +19,7 @@ export async function bootOcctKernel({ fonts, imports, importMeshes } = {}) {
   const replicad = await import("replicad");
   replicad.setOC(OC);
   const kernel = createOcctKernel(replicad);
-  if (fonts) { const opentype = (await import("opentype.js")).default;
+  if (fonts) { const opentype = normalizeOpentype(await import("opentype.js"));
     for (const [name, buf] of await resolveFonts(nodeAssetSources(fonts))) kernel._fonts.set(name, opentype.parse(buf)); }
   if (imports) await ensureImports(kernel, nodeAssetSources(imports), importMeshes ?? null);
   return kernel;