partforge 0.67.2 → 0.67.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.67.2",
+  "version": "0.67.4",
   "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)) }))) })),
@@ -865,6 +901,31 @@ function dropSubresolutionPositiveLoops(out, delta) {
   });
 }
 
+// Positive dilation may also discard whole SUB-SLIVER rings — the multi-segment
+// sibling of the zero-chord splice loops above. The winding resolver can emit
+// entire junk rings a few segments long (measured on "Scott" size 28, delta 5:
+// 14 of 16 holes were resolver debris of 1e-8..1e-5 mm² beside two real ~6-8 mm²
+// counters), and every one of them extrudes into a degenerate fin or sliver face
+// that downstream mesh consumers trip over (the planar rim fillet's knife-edge
+// refusals). The bar is the corpus oracle's own SLIVER convention (1e-3 mm² —
+// test/offset-text.test.js, the fuzz suite): rings under it are "resolver
+// artifacts, not features". The proof this cannot eat real geometry is
+// dilation-only, in two halves: a genuine separate REGION of a dilation is at
+// least the dilation disc (area ≥ π·δ²), and a genuine HOLE under that bar is a
+// counter within a hair of closing — which the oracle already counts as closed.
+// Erosion keeps everything, same as dropSubresolutionPositiveLoops: a tiny
+// surviving island there is real geometry with no source-domain proof otherwise.
+const RING_SLIVER = 1e-3;   // mm² — the corpus oracle's sub-sliver bar
+function dropSubSliverRings(out, delta) {
+  if (delta <= 0) return out;
+  const tiny = (ring) => Math.abs(ringArea(tessellateContour(ring, VALIDATE_SEGS))) < RING_SLIVER;
+  return out.flatMap((rg) => {
+    if (tiny(rg.outer)) return [];
+    const holes = rg.holes.filter((h) => !tiny(h));
+    return [holes.length === rg.holes.length ? rg : { outer: rg.outer, holes }];
+  });
+}
+
 // Region-in / region-out offset: the engine behind Shape2D.offset on BOTH backends.
 // Fast path: raw per-ring offsets that validate cleanly are returned as-is (lines/arcs
 // exact). Cleanup path: anything dirty or invalid goes through resolveOffsetWinding
@@ -892,6 +953,7 @@ export function offsetRegions(regions, delta, { corners = "round" } = {}) {
   }
   out = sourceBackedPositiveRegions(regions, out, delta);
   out = dropSubresolutionPositiveLoops(out, delta);
+  out = dropSubSliverRings(out, delta);
   if (out.length === 0) throw new Error("Shape2D.offset: offset collapses the shape (reduce |delta|)");
   return out;
 }

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

@@ -15,7 +15,7 @@
 // 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";
-import { normalizeOpentype } from "./opentype-interop.js";
+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";
@@ -95,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;
   };
@@ -109,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/mesh-fillet.js

@@ -572,7 +572,10 @@ export function matchesSelector(chain, sel) {
 const rot2 = ([x, y], th) => [x * Math.cos(th) - y * Math.sin(th), x * Math.sin(th) + y * Math.cos(th)];
 function profile2D({ P, n1, n2, magnitude, mode, convex, segs, ext = 0 }) {
   const c = clamp1(n1[0] * n2[0] + n1[1] * n2[1]);
-  if (1 + c < 1e-6) throw new UnsupportedEdgeError("~180° knife edge");
+  // `knifeEdge` marks the refusal as the anti-parallel-flank degeneracy, so the
+  // planar rim machinery can SKIP a noise stretch (a sliver facet's flipped
+  // normal) instead of failing the whole selection on it.
+  if (1 + c < 1e-6) throw Object.assign(new UnsupportedEdgeError("~180° knife edge"), { knifeEdge: true });
   const bl = Math.hypot(n1[0] + n2[0], n1[1] + n2[1]);
   const bis = [(n1[0] + n2[0]) / bl, (n1[1] + n2[1]) / bl];
   const delta = 0.02 * magnitude;
@@ -859,6 +862,35 @@ function collapseTightCorners(pts0, wallNs0, closed, magnitude) {
   return { pts: out, wallNs: outWalls };
 }
 
+// Weld consecutive coincident chain points (the module's own 1/WELD vertex-identity
+// grid, pivotKey's). collapseTightCorners can land a virtual corner V exactly ON a
+// flanking chain point — an offset outline's micro-spike doubles back through the
+// same vertex, so the flanking edge lines intersect AT it — and a coincident pair
+// becomes a zero-length sweep path segment that k.sweep rejects, failing the whole
+// fillet (the "Scott" offset-backing regression). Dropping the point drops the
+// degenerate segment's WALL, keeping walls one-per-surviving-segment.
+function weldChainPoints(pts, wallNs, closed) {
+  const eps = 1 / WELD;
+  const outP = [pts[0]], outW = [];
+  for (let i = 1; i < pts.length; i++) {
+    if (len(sub(pts[i], outP[outP.length - 1])) < eps) continue;
+    outP.push(pts[i]);
+    outW.push(wallNs[i - 1]);   // wall of the span arriving at pts[i]
+  }
+  if (closed) {
+    // The closing segment's wall: the original closing span's — unless the wrap
+    // itself welds (last ≈ first), where the popped point's arriving wall is the
+    // span that now closes the loop.
+    let closingW = wallNs[pts.length - 1];
+    while (outP.length > 1 && len(sub(outP[outP.length - 1], outP[0])) < eps) {
+      outP.pop();
+      closingW = outW.pop();
+    }
+    outW.push(closingW);
+  }
+  return { pts: outP, wallNs: outW };
+}
+
 function planarTool(k, chain, magnitude, mode, segs, pSegs = segs, endTins = null) {
   const { points, closed, convex, faceN } = chain;
   let { wallNs } = chain;
@@ -871,6 +903,10 @@ function planarTool(k, chain, magnitude, mode, segs, pSegs = segs, endTins = nul
   // 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));
+  ({ pts, wallNs } = weldChainPoints(pts, wallNs, closed));
+  // A chain welded below the grid (a sub-micron rim loop — offset-noise islands)
+  // has nothing a blend of this magnitude can attach to; skip it rather than fail.
+  if (pts.length < (closed ? 3 : 2)) return [];
   const m = pts.length;
   const at = (i) => pts[((i % m) + m) % m];
   const nSeg = closed ? m : m - 1;
@@ -999,9 +1035,48 @@ function planarTool(k, chain, magnitude, mode, segs, pSegs = segs, endTins = nul
     return k.sweep(poly, path3D, { closed: isClosed });
   };
 
+  // Sweep one open stretch; when the sweep refuses a VERTEX fold the pre-split
+  // guard let through — the guard classifies bends by the LOCAL wall normals,
+  // and an offset outline's micro-spike facets carry noise normals that can
+  // read reflex (lenient reach) where the sweep's frame-transported measure is
+  // salient (full magnitude) — split at that exact vertex and sweep the pieces.
+  // That is the same treatment the guard itself would have applied with the
+  // right classification: adjacent stretches mitre into each other across the
+  // split via their overshoots. The sweep is the oracle, so the two can never
+  // disagree into a failure.
+  const buildStretch = (path, wallN, depth = 0) => {
+    try {
+      return [toolFor(overshoot(path), false, wallN)];
+    } catch (e) {
+      // A knife PROFILE here means this stretch's wall is a degenerate sliver's
+      // flipped normal (anti-parallel to the face) — a real rim wall is ~90° to
+      // its face and cannot produce it. The rim piece is sub-resolution noise;
+      // skip it rather than fail every other stretch of the selection.
+      if (e?.knifeEdge) return [];
+      const v = e?.foldVertex;
+      // overshoot() prepended one point, so sweep index v is path index v-1
+      const i = v != null ? v - (over > 0 && path.length >= 2 ? 1 : 0) : null;
+      if (i == null || depth > 16 || !(i > 0 && i < path.length - 1)) throw e;
+      return [
+        ...buildStretch(path.slice(0, i + 1), wallN, depth + 1),
+        ...buildStretch(path.slice(i), wallN, depth + 1),
+      ];
+    }
+  };
+
   try {
     if (closed && breaks.length === 0) {
-      return [toolFor(pts.map((p) => [p[0], p[1], p[2]]), true, wallNs[nSeg - 1])];
+      const loop = pts.map((p) => [p[0], p[1], p[2]]);
+      try {
+        return [toolFor(loop, true, wallNs[nSeg - 1])];
+      } catch (e) {
+        if (e?.knifeEdge) return [];   // degenerate sliver loop — nothing to blend
+        const v = e?.foldVertex;
+        if (v == null) throw e;
+        // the loop folds at v with no break to split on: open it there and let
+        // buildStretch's splitting take over (the seam gets the overshoot mitre)
+        return buildStretch([...loop.slice(v), ...loop.slice(0, v + 1)], wallNs[v % nSeg]);
+      }
     }
     // Open stretches between breaks. An open chain's endpoints are implicit breaks; a
     // closed chain's stretches wrap from each break to the next.
@@ -1017,7 +1092,7 @@ function planarTool(k, chain, magnitude, mode, segs, pSegs = segs, endTins = nul
       const aS = arcAt(s), aE = arcAt(e);
       if (aS) path = pullBack(path, aS.t, false);
       if (aE) path = pullBack(path, aE.t, true);
-      tools.push(toolFor(overshoot(path), false, wallNs[s % nSeg]));
+      tools.push(...buildStretch(path, wallNs[s % nSeg]));
     }
     for (const got of cornerArcs.values()) {
       tools.push(revolveTool(k, got.arc, magnitude, mode, segs, pSegs));
@@ -1505,7 +1580,20 @@ function apply(k, solid, mode, magnitude, { edges, segs = DEFAULT_SEGS, sharpDeg
       (endTins.get(kk) ?? endTins.set(kk, []).get(kk)).push(info.tin);
     }
   }
-  const { chains: effective, arcs, horns, pivots } = roundSalientCorners(planarized, magnitude);
+  let { chains: effective, arcs, horns, pivots } = roundSalientCorners(planarized, magnitude);
+  // An edge whose two flanks fold back on themselves (anti-parallel normals) is a
+  // zero-thickness fin or slit rim — a self-touching offset outline extrudes these.
+  // There is no wedge between the flanks for a blend to live in (profile2D's own
+  // ~180° knife-edge refusal), so skip the chain rather than fail every OTHER edge
+  // of the selection with it.
+  // Planar variant of the same degeneracy: a zero-area sliver in the face
+  // triangulation flips its facet normal, classifying as a "wall" anti-parallel
+  // to the face — profile2D's projected normals then hit the same refusal.
+  const knife = (ch) => ch.kind === "planar"
+    ? ch.wallNs.every((wn) => dot(ch.faceN, wn) < -1 + 1e-6)
+    : ch.n1 && ch.n2 && dot(ch.n1, ch.n2) < -1 + 1e-6;
+  effective = effective.filter((ch) => !knife(ch));
+  arcs = arcs.filter((ch) => !knife(ch));
   const pSegs = blendSegs(segs, magnitude);
   const toolsFor = (ch) =>
     ch.kind === "planar"

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

@@ -11,3 +11,25 @@
 // 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/geometry/sweep.js

@@ -43,6 +43,13 @@ const rodrigues = (v, k, ang) => {
 const placeRing = (profile2D, center, N, B) =>
   profile2D.map(([x, y]) => add(center, add(scl(N, x), scl(B, y))));
 
+// A per-VERTEX fold refusal (miter would fold / reversal is ambiguous) carries the
+// offending path index as `foldVertex`, so a caller that owns the path can split it
+// there and sweep the pieces instead of failing — mesh-fillet's planar chains do
+// exactly that when their pre-split guard's wall-normal heuristic disagrees with
+// this module's direction-aware measure (offset-outline micro-noise walls).
+const foldError = (message, vtx) => Object.assign(new Error(message), { foldVertex: vtx });
+
 // The seed frame a sweep of `path3D` will start from — exported so a caller authoring a
 // profile FOR a sweep (mesh-fillet's planar-chain tool) can express it in exactly the
 // frame the sweep will use, instead of replicating the reference-vector pick and drifting
@@ -91,7 +98,7 @@ export function resolveSweepStations(profile2D, path3D, { closed = false, corner
     const axisRaw = cross(tIn, tOut), s = vlen(axisRaw);
     const cdot = Math.max(-1, Math.min(1, dot(tIn, tOut)));
     if (cdot < -1 + 1e-6)
-      throw new Error(`sweep: 180° reversal at vertex ${vtx} is ambiguous — insert an intermediate point or use cornerRadius`);
+      throw foldError(`sweep: 180° reversal at vertex ${vtx} is ambiguous — insert an intermediate point or use cornerRadius`, vtx);
     if (s < EPS) { stations.push(placeRing(profile2D, center, N, B)); return; } // collinear: no turn, frame unchanged
     const axis = scl(axisRaw, 1 / s);
     const theta = Math.atan2(s, cdot);                    // exterior turn angle
@@ -127,7 +134,7 @@ export function resolveSweepStations(profile2D, path3D, { closed = false, corner
       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`);
+        throw foldError(`sweep: profile too wide for the bend at vertex ${vtx} (turn too sharp / segment too short) — increase cornerRadius or lengthen the segment`, vtx);
       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,7 +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 { 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";
@@ -107,7 +107,7 @@ export async function handle(kernel, part, msg, post, opts = {}) {
     if (part.fonts && kernel._fonts) {
       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,7 +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 { 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";
@@ -14,7 +14,7 @@ export async function bootManifoldKernel({ quality = "preview", fonts, imports,
   wasm.setup();
   const kernel = createManifoldKernel(wasm, { quality });
   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)); }
+    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,7 +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 { normalizeOpentype, parseFont } from "../framework/geometry/opentype-interop.js";
 import { ensureImports } from "../framework/imports.js";
 import { nodeAssetSources } from "./assets.js";
 
@@ -20,7 +20,7 @@ export async function bootOcctKernel({ fonts, imports, importMeshes } = {}) {
   replicad.setOC(OC);
   const kernel = createOcctKernel(replicad);
   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)); }
+    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;
 }