partforge 0.135.0 → 0.136.0

package/package.json

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

package/src/framework/fonts.js

@@ -31,3 +31,11 @@ export async function resolveFonts(fontsDecl) {
   }
   return resolveDecl(fontsDecl, resolveOne);
 }
+
+// Drop one source's memo entry. jobs.js calls this once a font is PARSED: the
+// parsed Font is what the kernel keeps (kernel._fontsBySource, bounded), so
+// holding the raw ArrayBuffer here as well doubled the cost of every font a
+// session ever auditioned and released none of it (spec 2026-10-01 §3).
+export function forgetFontSource(source) {
+  cache.delete(source);
+}

package/src/framework/jobs.js

@@ -6,7 +6,7 @@ import { meshTo3MF } from "./geometry/threemf.js";
 import { printColor } from "./materials/resolve.js";
 import { exportablePartNames } from "./export-select.js";
 import { fontControlAllows, fontSourceAllowed, isNoFontSource } from "./font-source.js";
-import { fontsFor, resolveFonts } from "./fonts.js";
+import { fontsFor, resolveFonts, forgetFontSource } from "./fonts.js";
 import { normalizeOpentype, parseFont } from "./geometry/opentype-interop.js";
 import { imageControlAllows, imageSourceAllowed, isNoImageSource } from "./image-source.js";
 import { imagesFor, ensureImages } from "./images.js";
@@ -16,6 +16,8 @@ import { vectorControlAllows, vectorSourceAllowed, isNoVectorSource } from "./ve
 import { vectorsFor, ensureVectors } from "./vectors.js";
 import { exportSubParts, resolveParams, buildPosed } from "./part-model.js";
 
+export const FONT_SOURCE_CACHE_MAX = 4;
+
 // The oracle loads LAZILY, per job family, never at worker boot. It is the largest
 // JS payload in the worker's graph (measure/verify/build and silhouette/match), and
 // only the `inspect` job runs any of it — the generate/export hot path touches none.
@@ -264,26 +266,51 @@ export async function handle(kernel, part, msg, post, opts = {}) {
     if (part.fonts && kernel._fonts) {
       const declared = fontsToResolve ?? {};
       if (Object.keys(declared).length) {
-        onProgress("resolving fonts");
-        const opentype = normalizeOpentype(await import("opentype.js"));
-        const bufs = await resolveFonts(declared);
         // Keyed on the SOURCE, not the name. A name is not a font identity: one
         // worker outlives many parts (worker-rebind) and, once a font can come
         // from a param, many picks — all of which reuse the same declared name.
         // The old `if (!_fonts.has(name))` made the first bytes ever seen under a
         // name permanent for the life of the worker.
         //
-        // The source, not the resolved buffer: the two agree only because the
-        // resolver's own memo is unbounded and hands back the identical object
-        // every time. Key on that and this memo silently degrades to per-fetch
-        // identity — a re-parse per build — the day eviction is added there.
+        // The parse cache keys on the source and is the ONLY holder of a font:
+        // the resolver's memo is transient (forgotten once a font is parsed).
         kernel._fontsBySource ??= new Map();
-        for (const [name, buf] of bufs) {
-          const source = declared[name];
+        // Resolve only what this kernel has not parsed yet: a source already in
+        // the parse cache needs no bytes at all, which is what lets the resolver
+        // forget a buffer the moment its font is parsed (below).
+        const unparsed = Object.fromEntries(
+          Object.entries(declared).filter(([, src]) => !kernel._fontsBySource.has(src)),
+        );
+        let bufs = new Map();
+        if (Object.keys(unparsed).length) {
+          onProgress("resolving fonts");
+          bufs = await resolveFonts(unparsed);
+        }
+        const opentype = bufs.size ? normalizeOpentype(await import("opentype.js")) : null;
+        for (const [name, source] of Object.entries(declared)) {
           let font = kernel._fontsBySource.get(source);
-          if (!font) { font = parseFont(opentype, buf, name); kernel._fontsBySource.set(source, font); }
+          if (font) {
+            kernel._fontsBySource.delete(source);              // re-insert = most recent
+          } else {
+            font = parseFont(opentype, bufs.get(name), name);
+            forgetFontSource(source);                           // the parsed Font is what we keep
+          }
+          kernel._fontsBySource.set(source, font);
           kernel._fonts.set(name, font);
         }
+        // Bounded (spec 2026-10-01 §3): auditioning fonts in the picker
+        // otherwise kept every face ever tried, per kernel, for the worker's
+        // life. Map order is recency (re-inserted on use above), so eviction
+        // takes the oldest. A source THIS build declared is never evicted — a
+        // part declaring more than the bound would otherwise evict its own
+        // fonts and refetch/reparse them on every build — so the bound is
+        // max(FONT_SOURCE_CACHE_MAX, this build's distinct sources).
+        const keep = new Set(Object.values(declared));
+        const limit = Math.max(FONT_SOURCE_CACHE_MAX, keep.size);
+        for (const src of kernel._fontsBySource.keys()) {
+          if (kernel._fontsBySource.size <= limit) break;
+          if (!keep.has(src)) kernel._fontsBySource.delete(src);
+        }
       }
       // Drop every name this build's declaration does not supply. `_fonts` is
       // the kernel's, and the kernel outlives the job: without this, a face the

package/src/framework/mount.js

@@ -241,7 +241,8 @@ function createCleanupStack() {
 // mesh-validity cache, and the geometry workers. The app supplies `createWorker(name)`
 // so Vite can bundle the worker (see geometry-service.js).
 //
-// Embedding contract (0.45.0):
+// Embedding contract (0.136.0: the font control commits once per picker
+// session, on close, not per pick):
 //   const runtime = mount(part, { createWorker, elements, onBuild, onPick, onDownload, onViewChange });
 //   await runtime.ready;   // first successful build of the default view
 //   runtime.setParams({ openAngle: 45 }); // programmatic edit; pose-only changes apply instantly

package/src/framework/panel/font-picker.js

@@ -52,7 +52,19 @@ const listVariant = (f) =>
 // through here.
 let openPicker = null;
 
-export function openFontPicker({ node, params, allow, fontCatalog, anchor, onPicked }) {
+// At most this many weights beyond the selected one load their real face per
+// family opened (the previous family's variant faces are released when another
+// opens, so resident variant faces stay <= 1 + this). A COUNT, not bytes: the cloud catalog reports `bytes: 0` for every
+// variant, so a byte budget would never bind (spec 2026-10-01 §3). Rows past
+// the budget render in the menu face with the weight synthesized.
+export const VARIANT_FACE_BUDGET = 6;
+
+// The menu face the last closed picker chose to keep (the widget label renders
+// in it). The next picker adopts it, so a session neither re-fetches that face
+// nor orphans it: its own close() deletes it if the selection moved on.
+let keptFace = null;
+
+export function openFontPicker({ node, params, allow, fontCatalog, anchor, onPicked, onClose }) {
   // Takeover: the picker covers the rail on desktop and the single visible pane
   // below the narrow breakpoint. One layout for both widths (spec §6).
   const host = anchor?.closest?.(".pf-rail") ?? anchor?.parentElement ?? document.body;
@@ -148,6 +160,33 @@ export function openFontPicker({ node, params, allow, fontCatalog, anchor, onPic
   // missing one must degrade to un-styled rows, never throw.
   const canLoadFaces = () => typeof FontFace === "function" && typeof document.fonts?.add === "function";
 
+  const addedFaces = [];           // every FontFace this picker put in document.fonts
+  let variantBudget = VARIANT_FACE_BUDGET;
+  const variantList = [];          // {face, url} for the ONE family whose variants are open
+  let variantFamily = null;
+  if (keptFace) {
+    addedFaces.push(keptFace);
+    faceRequested.add(keptFace.family);
+    faceSettled.add(keptFace.family);
+    keptFace = null;
+  }
+  // A face that finishes loading after close() would otherwise land in
+  // document.fonts with nobody left to delete it. The selected family's menu
+  // face is the one exception: it is kept on close by design.
+  const track = (loaded) => {
+    if (closed && (loaded.family !== selFamily || keptFace)) return;
+    document.fonts.add(loaded);
+    if (!closed) addedFaces.push(loaded);
+    else keptFace = loaded;                    // landed after close: hand it on
+  };
+  function releaseVariantFaces() {
+    for (const { face, url } of variantList) {
+      variantFaces.delete(url);
+      try { document.fonts.delete?.(face); } catch { /* already gone */ }
+    }
+    variantList.length = 0;
+  }
+
   function settle(family) {
     faceSettled.add(family);
     if (closed) return;
@@ -167,7 +206,7 @@ export function openFontPicker({ node, params, allow, fontCatalog, anchor, onPic
       let face;
       try { face = new FontFace(f.family, `url(${f.menuUrl})`); } catch { settle(f.family); continue; }
       face.load()
-        .then((loaded) => { document.fonts.add(loaded); })
+        .then((loaded) => { track(loaded); })
         .catch(() => { /* a family that will not load stays in the panel font */ })
         .then(() => settle(f.family));
     }
@@ -177,14 +216,22 @@ export function openFontPicker({ node, params, allow, fontCatalog, anchor, onPic
   // family name's glyphs at one weight, so it cannot show what 700 looks like.
   // Each face is registered under `<family> <variant>` so the weights do not
   // collide with each other or with the menu face.
-  function requestVariantFace(family, v) {
+  function requestVariantFace(family, v, { selected = false } = {}) {
     if (!canLoadFaces()) return;
     if (variantFaces.has(v.url) || !fontSourceAllowed(v.url, allow)) return;
     if (Number.isFinite(v.bytes) && v.bytes > VARIANT_FACE_MAX_BYTES) return;
+    if (!selected) {
+      if (variantBudget <= 0) return;
+      variantBudget -= 1;
+    }
     variantFaces.add(v.url);
     let face;
     try { face = new FontFace(`${family} ${v.variant}`, `url(${v.url})`); } catch { return; }
-    face.load().then((loaded) => document.fonts.add(loaded)).catch(() => {});
+    face.load().then((loaded) => {
+      if (closed || variantFamily !== family) { variantFaces.delete(v.url); return; }
+      document.fonts.add(loaded);
+      variantList.push({ face: loaded, url: v.url });
+    }).catch(() => {});
   }
 
   // ── the list ────────────────────────────────────────────────────────────
@@ -337,6 +384,11 @@ export function openFontPicker({ node, params, allow, fontCatalog, anchor, onPic
 
   function openVariants(f) {
     openFamily = f;
+    if (variantFamily !== f.family) {
+      releaseVariantFaces();
+      variantFamily = f.family;
+      variantBudget = VARIANT_FACE_BUDGET;
+    }
     vtitle.textContent = f.family;
     vlist.textContent = "";
     for (const v of f.variants) {
@@ -351,9 +403,15 @@ export function openFontPicker({ node, params, allow, fontCatalog, anchor, onPic
       // Commit WITHOUT leaving — you audition weights against the live
       // geometry, so committing and navigating are separate actions (spec §6).
       b.addEventListener("click", () => commit(f, v));
-      requestVariantFace(f.family, v);
       vlist.append(b);
     }
+    // Nearest weight to the selected one first, so the budget lands on the
+    // weights the user is most likely to compare.
+    const weightOf = (v) => Number(String(v.variant).replace(/i(talic)?$/, "")) || 400;
+    const selV = pickVariant(f);
+    const order = [...f.variants].sort((a, b) =>
+      (a === selV ? -1 : b === selV ? 1 : Math.abs(weightOf(a) - weightOf(selV)) - Math.abs(weightOf(b) - weightOf(selV))));
+    for (const v of order) requestVariantFace(f.family, v, { selected: v === selV });
     vlist.scrollTop = 0;
     picker.classList.add("at-variants");
   }
@@ -378,8 +436,21 @@ export function openFontPicker({ node, params, allow, fontCatalog, anchor, onPic
     closed = true;
     clearTimeout(debounce);
     document.removeEventListener("keydown", onKey);
+    // Faces are the picker's, not the page's: every one auditioned would
+    // otherwise stay resident until the iframe dies (the 2026-10 Safari tab
+    // kill). Keep only the selected family's MENU face — the widget's button
+    // label renders in it.
+    if (typeof document.fonts?.delete === "function") {
+      for (const face of addedFaces) {
+        if (face.family === selFamily && !keptFace) { keptFace = face; continue; }
+        try { document.fonts.delete(face); } catch { /* already gone */ }
+      }
+    }
+    releaseVariantFaces();
     picker.remove();
     if (openPicker === handle) openPicker = null;
+    // After removal, so a host reacting to the close sees the rail as it will be.
+    try { onClose?.(); } catch { /* host's problem, not the picker's */ }
   }
   function onKey(ev) {
     if (ev.key !== "Escape") return;

package/src/framework/panel/widgets/font.js

@@ -145,9 +145,21 @@ export function makeFont(node, params, { onChange, onCommit, info, fontCatalog,
   // the rail, outside the panel root, so tearing the panel down does not take it
   // with it. Without dispose() the element — and the `document` keydown listener
   // that only close() unhooks — would outlive the panel holding a stale `params`.
+  //
+  // A picker SESSION is one commit (spec 2026-10-01 §2): every pick rebuilds
+  // live through onChange, and the commit — "the user finished", the same
+  // split the slider makes on release — fires once, when the picker closes
+  // (Done, ×, Escape, a re-open superseding it, or dispose), and only if the
+  // value actually moved. A host that persists on commit (partforge-cloud
+  // vendors and saves) then pays once per session instead of once per pick.
   let picker = null;
   btn.addEventListener("click", () => {
-    picker = openFontPicker?.({ node, params, allow, fontCatalog, anchor: wrap, onPicked: () => { paint(); onChange?.(); onCommit?.(); } }) ?? null;
+    const atOpen = params[node.key];
+    picker = openFontPicker?.({
+      node, params, allow, fontCatalog, anchor: wrap,
+      onPicked: () => { paint(); onChange?.(); },
+      onClose: () => { picker = null; if (params[node.key] !== atOpen) onCommit?.(); },
+    }) ?? null;
   });
 
   // Ambient: this branch already has the catalog button as its visible way in, so

package/src/framework/vectors.js

@@ -19,8 +19,9 @@ const cache = new Map();   // source → Promise<Uint8Array> (raw bytes)
 // source → { units, shapes }. The bytes memo above stops a refetch; this stops a re-PARSE
 // (UTF-8 decode + JSON.parse + validation + a bbox recomputation that tessellates
 // every contour). Without it every regen of a part with artwork redoes all of that.
-// Fonts solve the same problem with kernel._fontsBySource (jobs.js:206-212) and
-// imports with a digest comparison; this is the third pipeline's version of it.
+// Fonts solve the same problem with kernel._fontsBySource (jobs.js:277-312), a bounded
+// LRU keyed by source and the only holder of a parsed font (the resolver's memo is
+// transient); imports use a digest comparison. This is the third pipeline's version.
 // Keyed on the SOURCE, not the name: one worker outlives many parts, and a name is
 // not an identity. Only successes are cached — a parse failure must throw again
 // under the next name that declares it, with that name in the message.