partforge 0.19.0 → 0.20.1

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

@@ -12,8 +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.
+import * as opentype from "opentype.js";
 import { KernelCapabilityError } from "./errors.js";
 import { isPlainOptions, KERNEL_OP_SPECS } from "./op-options.js";
+import { textGlyphs } from "./text2d.js";
+import { DEFAULT_FONT_BYTES } from "./fonts/default-font.js";
 
 export function finishKernel(k) {
   // Compound default: bored-through cylinder (tool overshoots 2 mm each end for
@@ -35,5 +38,55 @@ export function finishKernel(k) {
   k.toSTEP ??= () => { throw new KernelCapabilityError("toSTEP requires the OCCT backend"); };
   k.shape2d ??= () => { throw new KernelCapabilityError("shape2d requires the Manifold backend"); };
 
+  // 2-D text as a Shape2D. Backend-agnostic: builds per-glyph Shape2Ds and unions
+  // them. Fonts come from k._fonts (framework-preloaded by name) or inline bytes.
+  k._fonts ??= new Map();
+  // Parse inline bytes once per buffer, keyed by the buffer's own IDENTITY (a stable
+  // import yields the same ArrayBuffer each build). WeakMap-by-buffer avoids the
+  // wrong-font bug a byteLength key would cause. No separate text2d cache/fontId is
+  // needed: text2d builds k.shape2d(glyphContours)+union, and the Shape2D hash keys
+  // on the actual glyph coordinates — a different font → different geometry →
+  // different cache entry, automatically.
+  const byteCache = new WeakMap();                              // original view/buffer → parsed font
+  const parseBytes = (arg) => {
+    let f = byteCache.get(arg);
+    if (!f) {
+      // Key on the ORIGINAL arg (stable identity for the cache), but parse the view's
+      // 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);
+    }
+    return f;
+  };
+  const resolveFont = (font) => {
+    if (font == null) {
+      // Lazily parse + memoize the framework's bundled default (vendored Roboto,
+      // SIL OFL 1.1 — see fonts/Roboto-LICENSE.txt) so k.text2d works with zero
+      // setup when { font } is omitted. Slice to the exact byte range rather than
+      // handing opentype the raw .buffer — DEFAULT_FONT_BYTES is a Uint8Array and,
+      // while it spans its own freshly-allocated buffer today (byteOffset 0), slicing
+      // guards against that ever changing.
+      if (!k._defaultFont) {
+        const { buffer, byteOffset, byteLength } = DEFAULT_FONT_BYTES;
+        k._defaultFont = opentype.parse(buffer.slice(byteOffset, byteOffset + byteLength));
+      }
+      return k._defaultFont;
+    }
+    if (typeof font === "string") {
+      const f = k._fonts.get(font);
+      if (!f) throw new Error(`text2d: unknown font "${font}" — declare it in the part's \`fonts\` field`);
+      return f;
+    }
+    return parseBytes(font);
+  };
+  k.text2d = (string, opts = {}) => {
+    const { font, size = 10, align = "center", valign = "middle", lineHeight, tracking = 0, kerning = true } = opts;
+    const parsed = resolveFont(font);
+    const regions = textGlyphs(parsed, string, { size, align, valign, lineHeight, tracking, kerning });
+    if (regions.length === 0) throw new Error("text2d: string produced no glyph geometry (empty or all-whitespace?)");
+    return regions.map((r) => k.shape2d(r)).reduce((a, b) => a.union(b));
+  };
+
   return k;
 }

package/src/framework/geometry/kernel.js

@@ -19,7 +19,7 @@ export const CONTRACT_VERSION = 1;
 // Ops every backend kernel must implement.
 export const KERNEL_OPS = [
   "cylinder", "boredCylinder", "sphere", "box", "prism", "extrude", "revolve",
-  "loft", "sweep", "helixSweptTube", "union", "shape2d", "toSTEP",
+  "loft", "sweep", "helixSweptTube", "union", "shape2d", "text2d", "toSTEP",
 ];
 
 // Backend-optional kernel ops: the Manifold cache brackets + WASM lifetime hooks.

package/src/framework/geometry/text2d.js

@@ -0,0 +1,98 @@
+// Pure (kernel-free) text layout: an opentype.js font + string → per-glyph curve-
+// contour region specs ({outer, holes}, pathProfile contours), positioned + scaled
+// so uppercase letters are `size` mm tall, in math (y-up, CCW) coordinates. The
+// kernel's text2d maps these to k.shape2d and unions them. No WASM, no DOM.
+import { pathProfile } from "./polygon.js";
+import { resolveCurveFill } from "./curve-fill.js";
+
+const capHeightUnits = (font) =>
+  font.tables?.os2?.sCapHeight || font.charToGlyph("H").getBoundingBox().y2 || font.unitsPerEm * 0.7;
+
+// opentype path commands (font units, y-DOWN) → array of pathProfile contours
+// (y flipped to math up). Each M starts a new contour; Q elevates to cubic.
+function glyphContours(glyph, font) {
+  const cmds = glyph.getPath(0, 0, font.unitsPerEm).commands;
+  const contours = [];
+  let pen = null, cur = null, start = null;
+  const P = ([x, y]) => [x, -y];                       // y-down → y-up
+  for (const c of cmds) {
+    if (c.type === "M") { if (pen) contours.push(pen.close()); start = cur = P([c.x, c.y]); pen = pathProfile(start); }
+    else if (c.type === "L") { cur = P([c.x, c.y]); pen.lineTo(cur); }
+    else if (c.type === "C") { pen.cubicTo(P([c.x, c.y]), P([c.x1, c.y1]), P([c.x2, c.y2])); cur = P([c.x, c.y]); }
+    else if (c.type === "Q") {                          // quadratic → cubic elevation
+      const p0 = cur, q = P([c.x1, c.y1]), end = P([c.x, c.y]);
+      const c1 = [p0[0] + (2/3)*(q[0]-p0[0]), p0[1] + (2/3)*(q[1]-p0[1])];
+      const c2 = [end[0] + (2/3)*(q[0]-end[0]), end[1] + (2/3)*(q[1]-end[1])];
+      pen.cubicTo(end, c1, c2); cur = end;
+    }
+    else if (c.type === "Z") { if (pen) { contours.push(pen.close()); pen = null; } }
+  }
+  if (pen) contours.push(pen.close());
+  return contours;
+}
+
+// Translate a pathProfile contour by (dx,dy) and scale by s (about origin, post-translate order: scale then translate).
+const xform = (contour, s, dx, dy) => {
+  const T = ([x, y]) => [x * s + dx, y * s + dy];
+  const out = { start: T(contour.start), segments: contour.segments.map((seg) => {
+    const m = { to: T(seg.to) };
+    if (seg.via) m.via = T(seg.via);
+    if (seg.c1) { m.c1 = T(seg.c1); m.c2 = T(seg.c2); }
+    return m;
+  }) };
+  return out;
+};
+
+export function textGlyphs(font, string, { size = 10, align = "center", valign = "middle",
+    lineHeight, tracking = 0, kerning = true } = {}) {
+  const upm = font.unitsPerEm;
+  const s = size / capHeightUnits(font);                        // font units → mm (cap height)
+  const lineAdv = (lineHeight ?? (font.ascender - font.descender) / upm * size * 1.0);
+  const kern = (a, b) => { if (!kerning || !a || !b) return 0; try { return font.getKerningValue(a, b); } catch { return 0; } };
+  // Every OpenType outline format — TrueType (glyf) and PostScript (CFF/CFF2) — is filled
+  // with the NONZERO winding rule (the glyf / Type 2 charstring imaging model). even-odd is
+  // not an OpenType fill rule; the resolver keeps it only as a general capability.
+  const fillRule = "nonzero";
+
+  const lines = string.split("\n");
+  // 1) lay out each line in font-unit x, collect glyph region specs + line width (mm)
+  const laid = lines.map((line) => {
+    // One glyph per input character via font.charToGlyph, NOT font.stringToGlyphs.
+    // stringToGlyphs runs opentype.js's bidi/GSUB text-shaping engine (ligatures,
+    // and — unconditionally, regardless of the `features` option — ccmp glyph
+    // composition). That engine eagerly instantiates a lookup method for every
+    // subtable in play and throws for lookup types it hasn't implemented (e.g.
+    // "lookupType 6 - substFormat: 2", class-based chaining contextual
+    // substitution) even when the actual input never matches that subtable's
+    // coverage. Real-world fonts commonly carry such lookups in their ccmp
+    // feature (e.g. the bundled Roboto, for accent composition), so
+    // stringToGlyphs throws on almost any 2+ character string against them —
+    // this is a per-character CAD label generator, not a typesetting engine, so
+    // literal glyph-per-character mapping (no ligatures/substitution) is exactly
+    // the semantics wanted here anyway.
+    const glyphs = Array.from(line).map((ch) => font.charToGlyph(ch));
+    let penX = 0; const specs = [];
+    glyphs.forEach((g, i) => {
+      if (i > 0) penX += kern(glyphs[i - 1], g);
+      for (const region of resolveCurveFill(glyphContours(g, font), { fillRule }))
+        specs.push({ region, penX });                          // remember this glyph's pen origin (font units)
+      penX += g.advanceWidth + (tracking / s);                  // tracking is mm → font units
+    });
+    return { specs, widthMm: penX * s };
+  });
+
+  const totalH = (lines.length - 1) * lineAdv + size;          // block height (mm), caps as the line box
+  const blockDy = valign === "top" ? -size : valign === "bottom" ? totalH - size
+    : valign === "middle" ? (totalH / 2 - size) : 0;           // "baseline" → 0
+
+  const out = [];
+  laid.forEach(({ specs, widthMm }, li) => {
+    const alignDx = align === "center" ? -widthMm / 2 : align === "right" ? -widthMm : 0;
+    const dy = -li * lineAdv + blockDy;                         // lines stack downward
+    for (const { region, penX } of specs) {
+      const dx = penX * s + alignDx;
+      out.push({ outer: xform(region.outer, s, dx, dy), holes: region.holes.map((h) => xform(h, s, dx, dy)) });
+    }
+  });
+  return out;
+}

package/src/framework/geometry-service.js

@@ -5,8 +5,27 @@
 // `new Worker(new URL("./part-worker.js", import.meta.url), { type:"module", name })`
 // pattern INLINE — Vite only bundles a worker (and its backend chunks) when it sees
 // that literal call, so the framework can't construct it from a passed-in URL.
+function terminateWorkers(workers) {
+  const errors = [];
+  for (const worker of workers) {
+    try { worker.terminate(); } catch (error) { errors.push(error); }
+  }
+  if (errors.length === 1) throw errors[0];
+  if (errors.length > 1) {
+    throw new AggregateError(errors, "geometry worker termination failed");
+  }
+}
+
 export function createGeometryService({ createWorker, onMessage }) {
-  const workers = { manifold: createWorker("manifold"), occt: createWorker("occt") };
+  const manifold = createWorker("manifold");
+  let occt;
+  try {
+    occt = createWorker("occt");
+  } catch (error) {
+    try { terminateWorkers([manifold]); } catch { /* preserve the worker creation error */ }
+    throw error;
+  }
+  const workers = { manifold, occt };
   workers.manifold.onmessage = onMessage;
   workers.occt.onmessage = onMessage;
   // Post a job to the chosen backend's worker. The message's own `type` says what to
@@ -14,6 +33,6 @@ export function createGeometryService({ createWorker, onMessage }) {
   // — manifold for preview/STL/3MF, occt for STEP (the caller passes "occt" for that).
   return {
     send: (msg, backend = "manifold") => workers[backend].postMessage(msg),
-    terminate: () => { workers.manifold.terminate(); workers.occt.terminate(); },
+    terminate: () => terminateWorkers([workers.manifold, workers.occt]),
   };
 }

package/src/framework/jobs.js

@@ -1,5 +1,6 @@
 import { meshTo3MF } from "./geometry/threemf.js";
 import { resolveDerived } from "./derive.js";
+import { resolveFonts } from "./fonts.js";
 
 // Names of the sub-parts a view shows: declared in the view and enabled for these
 // params. Order follows Object.keys(part.parts) (definition order).
@@ -56,6 +57,14 @@ export async function handle(kernel, part, msg, post) {
   const exportName = (name) => part.parts[name].export?.name ?? name;
 
   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.
+    if (part.fonts && kernel._fonts) {
+      const opentype = (await import("opentype.js")).default;
+      const bufs = await resolveFonts(part.fonts);
+      for (const [name, buf] of bufs) if (!kernel._fonts.has(name)) kernel._fonts.set(name, opentype.parse(buf));
+    }
     // Inside the try so a throwing derive posts an error the UI can show,
     // instead of killing the worker turn silently (an endless spinner).
     const { p, d } = resolveParams(part, msg.params);