partforge 0.67.1 → 0.67.3

package/package.json

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

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

@@ -8,7 +8,7 @@
 // The cubic subdivision approach is ported from glenzli/paperjs-offset
 // (https://github.com/glenzli/paperjs-offset, MIT License, Copyright (c) glenzli),
 // adapted from paper.js Segments to the partforge contour IR.
-import { arcCenterAndSweep } from "./paper-bridge.js";
+import { arcCenterAndSweep, booleanRegions } from "./paper-bridge.js";
 import { cubicAt, splitCubic, jointTangents, SMOOTH_JOINT_DEG } from "./contour-ops.js";
 import { tessellateContour, closeContourGap } from "./profile.js";
 import { ringArea, pointInRing } from "./shape2d-regions.js";
@@ -718,7 +718,11 @@ const flattenRing = (contour, segs) => {
 // All seven rescues are oracle-checked: median area error 0.0972 %, worst 1.663 %, with zero
 // region-count losses and zero complete arc losses. The ladder stays because those seven raw
 // arrangements remain numerically unclosable, not because the formerly parked comb/text
-// failures still exist.
+// failures still exist. Those seven are all erosion (negative delta) or single-region cases;
+// the per-region rung below is positive-delta-and-multi-region only, so it wins none of them
+// and the rates above are unchanged by its addition — its own coverage class (whole-word text
+// dilation, feedback 86970b00) sits outside this corpus, whose glyphs are single characters
+// and whose "Scott" case never reaches the delta band where the merged word fails to close.
 //
 // Rung ORDER is by fidelity of what survives, not by hit rate:
 //   1. delta perturbed by ±1e-9 relative. Escapes an exactly-degenerate arrangement (two
@@ -729,7 +733,13 @@ const flattenRing = (contour, segs) => {
 //      that radius apart onto one vertex. This can merge a genuine severing pinch, so the
 //      20x rung is not widened further even though the current seven rescues preserve the
 //      oracle's region count.
-//   3. the raw outline re-run as polylines (64/256/1024 facets per turn). Geometrically
+//   3. per-region-union (delta > 0, more than one region only). Offsets each region alone and
+//      unites the results through paper's curve-native boolean. EXACT, not approximate: a
+//      positive dilation distributes over union, so this equals the whole-region offset the
+//      resolver could not close — with arcs intact, above the polyline rungs. It is here rather
+//      than at #1 only because it costs a boolean per region and re-runs the earlier rungs on
+//      each; the two cheaper exact rungs get first refusal.
+//   4. the raw outline re-run as polylines (64/256/1024 facets per turn). Geometrically
 //      faithful to the chord error of that tessellation, but it DEGRADES THE IR: round joins
 //      come back as chords, so A STEP EXPORT OF A POLYLINE-RUNG RESULT LOSES ITS TRUE CIRCLES.
 //      No current corpus rescue loses every arc, but these rungs remain last because that
@@ -753,6 +763,25 @@ const flattenRing = (contour, segs) => {
 // (±1e-4 and ±1e-3 mm absolute rungs) was measured too: it bought ONE extra case out of 62 and
 // more than doubled the worst absolute error, 0.048 → 0.112 mm², so it is not here either.
 //
+// Offset each region on its own and unite the results through paper's planar boolean engine.
+// This is EXACT for a positive delta, not an approximation: Minkowski dilation distributes
+// over union, (⋃ Rᵢ) ⊕ B = ⋃ (Rᵢ ⊕ B), so the whole-region offset the winding resolver cannot
+// close as one merged arrangement equals the union of the single-region offsets. Each single
+// region is a far simpler arrangement — a lone glyph rather than a whole word's worth of offset
+// walls meeting near-tangentially — and its own base offset still gets the earlier rungs'
+// rescues, because the per-region call re-enters the public offsetRegions (which runs its own
+// ladder for that one region). booleanRegions unites through paper's CURVE-native engine rather
+// than a tessellation, so arcs stay arcs and a STEP export keeps its true circles — which is why
+// this rung sits ABOVE the polyline rungs, whose chord approximation is the fidelity floor.
+function perRegionUnion(regions, delta, corners) {
+  let out = [];
+  for (const rg of regions) {
+    const one = offsetRegions([rg], delta, { corners });   // single region: never re-enters this rung
+    out = out.length ? booleanRegions(out, one, "unite") : one;
+  }
+  return out;
+}
+
 // The ladder as named, LAZY rungs — one list, walked by chainFallback below and by
 // scripts/offset-rates.mjs, so a measurement of "what each rung costs" can never drift from
 // the ladder that actually ships. Every rung's whole body (including tessellating the outline
@@ -765,6 +794,13 @@ export function _ladderRungs(regions, raw, delta, corners) {
       run: () => resolveOrRaw(rawOffset(regions, delta * (1 + sign * 1e-9), corners)) })),
     ...[4, 20].map((mult) => ({ name: `clusterTol*${mult}`,
       run: () => resolveOffsetWinding(raw, { clusterTol: CLUSTER_TOL * mult }) })),
+    // Exact for positive dilation and arc-preserving, so it ranks above the polyline rungs but
+    // below the two cheaper exact rungs that need no boolean. Only meaningful when there is more
+    // than one region to decompose, and only distributive for a positive delta; the guard is
+    // also what bounds the recursion — a single-region offsetRegions call never reaches here.
+    ...(delta > 0 && regions.length > 1
+      ? [{ name: "per-region-union", run: () => perRegionUnion(regions, delta, corners) }]
+      : []),
     ...[64, 256, 1024].map((segs) => ({ name: `polyline@${segs}`,
       run: () => resolveOffsetWinding(raw.map((rg) => ({ outer: flattenRing(rg.outer, segs),
                                                          holes: rg.holes.map((h) => flattenRing(h, segs)) }))) })),

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, parseFont } 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";
@@ -100,7 +95,7 @@ export function finishKernel(k) {
       // EXACT byte range — arg.buffer alone spans the whole (possibly pooled) backing
       // buffer, which would feed opentype garbage for a byteOffset>0 view.
       const buf = ArrayBuffer.isView(arg) ? arg.buffer.slice(arg.byteOffset, arg.byteOffset + arg.byteLength) : arg;
-      f = opentype.parse(buf); byteCache.set(arg, f);
+      f = parseFont(opentype, buf); byteCache.set(arg, f);
     }
     return f;
   };
@@ -114,7 +109,7 @@ export function finishKernel(k) {
       // guards against that ever changing.
       if (!k._defaultFont) {
         const { buffer, byteOffset, byteLength } = DEFAULT_FONT_BYTES;
-        k._defaultFont = opentype.parse(buffer.slice(byteOffset, byteOffset + byteLength));
+        k._defaultFont = parseFont(opentype, buffer.slice(byteOffset, byteOffset + byteLength), "the bundled default");
       }
       return k._defaultFont;
     }

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

@@ -0,0 +1,35 @@
+// 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);
+
+// Parse font bytes into an opentype.Font, turning opentype.js's own low-level parse
+// failures into a NAMED, actionable error. A single unreadable font in a part's `fonts`
+// map otherwise kills the whole build with a message that names neither the font nor the
+// fix — a RangeError deep in the TrueType reader, or opentype.js's raw "WOFF2 require an
+// external decompressor library" URL — and the part just "won't build" with no clue which
+// font or why. This is the exact dead end a variable font or a WOFF/WOFF2 upload lands in:
+// opentype.js 2.x reads neither, so the guidance is always the same (supply a static TTF or
+// OTF). `label` is the declared font name where one is known (the `fonts` map key), and is
+// omitted for an inline-bytes font, which has no name to give. All parse sites route through
+// here so the message stays in one place.
+export function parseFont(opentype, buf, label) {
+  try {
+    return opentype.parse(buf);
+  } catch (err) {
+    const who = label ? `font "${label}"` : "an inline font";
+    throw new Error(
+      `text2d: ${who} could not be read as a TTF or OTF — a variable font or a WOFF/WOFF2 ` +
+      `file will fail here; supply a static TTF or OTF instead. (${err?.message ?? err})`,
+    );
+  }
+}

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, parseFont } 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,11 +101,13 @@ 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));
+      for (const [name, buf] of bufs) if (!kernel._fonts.has(name)) kernel._fonts.set(name, parseFont(opentype, buf, name));
     }
     // Register this part's declared imports on the kernel running this job — the
     // import-asset sibling of the fonts preload above. See ensureImports for the

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, parseFont } from "../framework/geometry/opentype-interop.js";
 import { ensureImports } from "../framework/imports.js";
 import { nodeAssetSources } from "./assets.js";
 import { tessellateStepAssets } from "./step-mesh.js";
@@ -12,8 +13,8 @@ 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;
-    for (const [name, buf] of await resolveFonts(nodeAssetSources(fonts))) kernel._fonts.set(name, opentype.parse(buf)); }
+  if (fonts) { const opentype = normalizeOpentype(await import("opentype.js"));
+    for (const [name, buf] of await resolveFonts(nodeAssetSources(fonts))) kernel._fonts.set(name, parseFont(opentype, buf, name)); }
   if (imports) {
     const decl = nodeAssetSources(imports);
     const { resolveImports } = await import("../framework/imports.js");

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, parseFont } from "../framework/geometry/opentype-interop.js";
 import { ensureImports } from "../framework/imports.js";
 import { nodeAssetSources } from "./assets.js";
 
@@ -18,8 +19,8 @@ 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;
-    for (const [name, buf] of await resolveFonts(nodeAssetSources(fonts))) kernel._fonts.set(name, opentype.parse(buf)); }
+  if (fonts) { const opentype = normalizeOpentype(await import("opentype.js"));
+    for (const [name, buf] of await resolveFonts(nodeAssetSources(fonts))) kernel._fonts.set(name, parseFont(opentype, buf, name)); }
   if (imports) await ensureImports(kernel, nodeAssetSources(imports), importMeshes ?? null);
   return kernel;
 }