partforge 0.134.0 → 0.136.0

package/src/framework/materials/sheet-look.js

@@ -0,0 +1,204 @@
+// src/framework/materials/sheet-look.js
+// How a laser-cut sheet part looks in realistic mode — plain data and pure math, three-free
+// and DOM-free like resolve.js, so the viewer, mount, lint and the tests all read ONE
+// statement of it. patterns.js turns it into GLSL; nothing here knows about three.
+//
+// A laser sheetPart in a wood shows its burns: charred cut walls, scorched engrave and
+// score floors, faces untouched. The shader tells those surfaces apart in the sheet's
+// CANONICAL frame — profile in XY, material over z ∈ [0, t], laser face at z = t — but the
+// viewer holds the DELIVERED display mesh. With no author `place`, sheetPart's generated
+// place is exactly the rigid steps poseSteps(pose, t) (and there is no place at all with no
+// pose), so the delivered mesh is that motion applied to the canonical solid and the frame
+// is its inverse: computed from data, with no pose probe and no geometry. A sheet with an
+// author place, a replaced place or a custom build is not trusted with a frame — it draws
+// plain wood, never a frame that could char a face.
+//
+// It also says what a laser sheet part with no usable material looks like: not a PLA print
+// (resolve.js's default for every other sub-part) but the sheet its stock label names —
+// realisticDisplay, from the ONE keyword table STOCK_LOOKS. Realistic-only, like the PLA
+// default: the CAD view, 3MF colours and declaresMaterials read sp.display itself.
+import { isSheetPart, sheetMeta, MARK_DEPTH } from "../sheet/constants.js";
+import { poseSteps, validatePose } from "../sheet/pose.js";
+import { composePose, invertRigid } from "../geometry/pose.js";
+import { resolveMaterial } from "./resolve.js";
+import { PRESETS } from "./presets.js";
+
+const IDENTITY = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+
+// The burn's numbers, ONE statement: patterns.js templates the GLSL from them, and the JS
+// twins below (classifySheetSurface, burnAlbedo) read the same object.
+//   wallNz      a surface whose canonical |n.z| is below this band is a cut wall (the
+//               shader blends across the band; the JS twin splits at its middle). Creased
+//               normals are hard at a sheet's 90° arris, so real walls sit at n.z = 0.
+//   floorDepth  an up-facing surface at least this far below the laser face is an engrave
+//               or score floor: half the preview's MARK_DEPTH, so the laser face (z = t) is
+//               never one and a mark's floor (z = t − MARK_DEPTH) always is.
+// Char is RELATIVE to the face, all in linear RGB. A cut wall is the face's average colour
+// mixed toward a char TARGET by k — kThin at ≤ tThin mm, kThick at ≥ tThick (thick stock takes
+// a longer dwell) — plus up to `exit` more toward the exit side (z = 0); an engrave or score
+// floor mixes `engraveLess` less. The target is PER CHANNEL: min(charcoal_i, charOfDark ·
+// face_i) (burnAlbedo's `target`). For oak and plywood that is `charcoal` itself; charOfDark
+// takes a channel over wherever face_i < charcoal_i / charOfDark — walnut's green and blue —
+// so a dark or strongly tinted face still chars darker in every channel. Mixing toward
+// `charcoal` alone would RAISE walnut's near-black blue, since charcoal's is lighter. Char and
+// scorched floors take `roughness`, a matte finish, and shed any clearcoat; on plywood's cut
+// walls a cross ply is `crossPly` of a face-grain ply.
+//   grain       how much of the wood's grain shows through the char: each texel's ratio to
+//               the face average, blended in by `grain`, multiplies the average char (1, a
+//               pure multiply: every texel darkens by the same per-channel factor, so the
+//               average is unchanged and no texel comes out lighter; burnTexel is the twin).
+//   relief      the share of the wood's surface relief (its normal map) that char and
+//               scorched floors keep; the rest fades to the geometric normal.
+//
+// The numbers were tuned by eye on the contact sheet in all four environments, inside the
+// calibration floors test/framework/sheet-look.test.js holds them to. The twins see only the
+// albedo. The render adds specular reflection — the same at every thickness — which no albedo
+// can take away, and on walnut, whose char is near black, it is most of what a lit wall shows.
+// So judge a retune on captures (scripts/capture-contact-sheet.mjs) compared at the SAME place
+// on the sheet, never on the twins alone: swatches in different places reflect different
+// light. The design spec records the measurements.
+export const BURN = Object.freeze({
+  wallNz: Object.freeze([0.35, 0.65]),
+  floorDepth: MARK_DEPTH / 2,
+  charcoal: 0x262220,
+  kThin: 0.74,
+  kThick: 0.97,
+  tThin: 3,
+  tThick: 9,
+  exit: 0.1,
+  engraveLess: 0.1,
+  charOfDark: 0.37,
+  roughness: 0.68,
+  crossPly: 0.78,
+  grain: 1,
+  relief: 0.35,
+});
+
+// sRGB 0xRRGGBB → linear [r, g, b]: the conversion three applies to a colour uniform.
+export function srgbToLinear(hex) {
+  return [(hex >> 16) & 255, (hex >> 8) & 255, hex & 255].map((c) => {
+    const s = c / 255;
+    return s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  });
+}
+
+// Plies in a birch-plywood sheet t mm thick: 3 mm → 3, 6 → 5, 9 → 7, 12 → 9. Always odd, so
+// both outer plies run with the face grain.
+const PLY_STEPS = Object.freeze([[4.5, 3], [7.5, 5], [10.5, 7]]);
+export function plyCount(t) {
+  for (const [below, plies] of PLY_STEPS) if (t < below) return plies;
+  return 9;
+}
+
+// The material realistic mode draws this sub-part in.
+const lookOf = (sp) => resolveMaterial(realisticDisplay(sp));
+
+// A laser sheet with no usable material takes its look from its stock label: the first row
+// with a stem that STARTS a word of the label (ignoring case; a hyphenated word is also read
+// joined, so "poly-carbonate" is one word and "clear-acrylic" still has "acrylic"), else
+// DEFAULT_STOCK_LOOK — plywood for birch, basswood, poplar, MDF, hardboard or anything
+// unlabelled. Word starts, not substrings, so "Plexiglas" and "Acrylite" match while
+// "perplexing" does not. A residual, named in the guide: stock that is neither wood nor
+// acrylic (felt, leather, card, cork) takes the plywood look too, burns and all. Only a
+// string label is read: a (p, d) function would make a sub-part's look (and its program)
+// depend on the params it was first drawn at, so it counts as unlabelled.
+export const STOCK_LOOKS = Object.freeze([
+  Object.freeze({ look: "clear-acrylic", words: Object.freeze([
+    "acryl", "perspex", "plexi", "pmma", "methacryl", "polycarb", "lexan", "makrolon", "lucite",
+  ]) }),
+]);
+export const DEFAULT_STOCK_LOOK = "plywood";
+
+const labelWords = (label) => {
+  const lower = label.toLowerCase();
+  return [...lower.split(/[^\p{L}]+/u), ...lower.replace(/-/g, "").split(/[^\p{L}]+/u)].filter(Boolean);
+};
+
+export function stockLook(stock) {
+  if (typeof stock !== "string") return DEFAULT_STOCK_LOOK;
+  const words = labelWords(stock);
+  return STOCK_LOOKS.find((row) => row.words.some((stem) => words.some((w) => w.startsWith(stem))))?.look ?? DEFAULT_STOCK_LOOK;
+}
+
+// The stock's look for a laser sheet part, else null (lint names it in its fallback hint).
+export function sheetStockLook(sp) {
+  return isSheetPart(sp) && sp.sheet.process === "laser" ? stockLook(sp.sheet.material) : null;
+}
+
+// The display realistic mode draws: sp.display itself, except that a laser sheet part
+// naming no KNOWN material — none, or one the library does not know, the same "no usable
+// material" resolve.js treats as one case — gets its stock's look. A `color` rides along,
+// so a bare colour tints that look (stained plywood, coloured acrylic).
+export function realisticDisplay(sp) {
+  const display = sp?.display;
+  const look = sheetStockLook(sp);
+  if (!look) return display;
+  if (typeof display?.material === "string" && Object.hasOwn(PRESETS, display.material)) return display;
+  return { ...(display && typeof display === "object" ? display : {}), material: look };
+}
+
+// Does this sub-part carry the burn pass at all? Static — it reads no params — so the
+// viewer decides a sub-part's PROGRAM once, and every sub-part that answers false keeps
+// exactly the program it had before the burn existed.
+export function burnsFor(sp) {
+  if (!isSheetPart(sp) || sp.sheet.process !== "laser") return false;
+  if (sp.build !== sp.sheet.generatedBuild) return false;                   // a custom build is not the canonical sheet
+  if (sp.sheet.place != null) return false;                                 // an author place moves it off its pose
+  if ((sp.place ?? null) !== (sp.sheet.generatedPlace ?? null)) return false; // place replaced after sheetPart
+  try { return lookOf(sp).params.pattern === "wood"; } catch { return false; }
+}
+
+// At (p, d) — a delivery's params — the frame that maps the delivered display mesh's
+// object space into the canonical sheet frame, the sheet's thickness, and how many plies
+// its cut walls show (0 unless its preset is `laminated`). null when burnsFor says no or
+// the pose or thickness cannot be read (the build reports those).
+export function sheetFrameFor(sp, { p, d } = {}) {
+  if (!burnsFor(sp)) return null;
+  const meta = sheetMeta(sp, p, d);
+  if (!meta) return null;
+  const t = meta.thickness;
+  let pose;
+  try { pose = typeof sp.sheet.pose === "function" ? sp.sheet.pose(p, d) : sp.sheet.pose; } catch { return null; }
+  if (pose != null && validatePose(pose)) return null;
+  const frame = pose == null ? [...IDENTITY] : invertRigid(composePose(poseSteps(pose, t)));
+  return { frame, t, plies: lookOf(sp).preset.laminated ? plyCount(t) : 0 };
+}
+
+// The shader's surface classification, in JS: the frame tests hold real geometry to it.
+// `pos` and `normal` are canonical (after the frame); `t` is the thickness.
+export function classifySheetSurface(pos, normal, t) {
+  if (Math.abs(normal[2]) < (BURN.wallNz[0] + BURN.wallNz[1]) / 2) return "wall";
+  if (normal[2] < 0) return "back";
+  return pos[2] <= t - BURN.floorDepth ? "floor" : "face";
+}
+
+const clamp01 = (x) => Math.min(1, Math.max(0, x));
+
+// The shader's burnt albedo, in JS (the calibration test's twin — same numbers, same
+// formula): `face` is the unburnt face's average colour in linear RGB (the preset's texture
+// average times any tint), `t` the sheet thickness (mm), `kind` "edge" — a cut wall, `zFrac`
+// of the way from the exit side (0) up to the laser face (1) — or "engrave", a mark's floor.
+// Ply bands are left out: they only modulate an edge. It returns the AVERAGE char — what the
+// face's average colour burns to. The shader then multiplies that by each texel's ratio to
+// the face average (texel ÷ face, blended by BURN.grain), so the grain shows through;
+// burnTexel below is that step's twin.
+export function burnAlbedo(face, t, { kind = "edge", zFrac = 1 } = {}) {
+  const charcoal = srgbToLinear(BURN.charcoal);
+  // The mix target, PER CHANNEL: whichever is darker of raw charcoal or charOfDark of this
+  // channel's own face value — never one colour for the whole vector, which a channel darker
+  // than that colour would be pulled UP toward (the BURN comment above). Multiplicative in the
+  // channel that governs it, so charring a face darker than charcoal in that channel still
+  // only ever removes light from it.
+  const target = charcoal.map((c, i) => Math.min(c, BURN.charOfDark * face[i]));
+  const k = BURN.kThin + (BURN.kThick - BURN.kThin) * clamp01((t - BURN.tThin) / (BURN.tThick - BURN.tThin));
+  const amount = kind === "engrave" ? k - BURN.engraveLess : Math.min(1, k + BURN.exit * (1 - clamp01(zFrac)));
+  return face.map((f, i) => f + (target[i] - f) * amount);
+}
+
+// One texel's burnt albedo, in JS — the shader's pfGrain step on top of burnAlbedo: `texel`
+// is the unburnt texel in linear RGB (the wood texture times any tint), the rest is
+// burnAlbedo's. The average char times mix(1, texel ÷ face, BURN.grain), per channel, with
+// the shader's 1e-4 floor under the divide. At grain 1 that is texel × (char ÷ face).
+export function burnTexel(texel, face, t, opts) {
+  return burnAlbedo(face, t, opts).map((c, i) => c * (1 + (texel[i] / Math.max(face[i], 1e-4) - 1) * BURN.grain));
+}

package/src/framework/mount.js

@@ -13,6 +13,7 @@ import { attachViewStyleControls } from "./view-style-controls.js";
 import { ENVIRONMENTS } from "./materials/environments.js";
 import { declaresMaterials, resolveMaterial } from "./materials/resolve.js";
 import { printFrameMatrix } from "./materials/print-frame.js";
+import { burnsFor, realisticDisplay, sheetFrameFor } from "./materials/sheet-look.js";
 import { buildControls } from "./controls.js";
 import { relevantParamKeys } from "./param-deps.js";
 import { createMeshCache } from "./mesh-cache.js";
@@ -240,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
@@ -863,6 +865,12 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
     // to its own worker in parallel, so a mixed part previews its plain sub-parts at
     // Manifold speed while only the OCCT-routed ones wait. The return value is
     // the job count — the loop holds the cycle open until every group has replied.
+    // Each dispatched sub-part remembers the { view, params } its job was sent with
+    // (`dispatched`): the frames the realistic look reads must describe the geometry
+    // that job builds, and a delivery shown during playback was built at params the
+    // live ones have already left (see recordFrames). One cycle is in flight at a time,
+    // so a sub-part's entry is its in-flight job's until the cycle's last reply.
+    const dispatched = new Map(); // sub-part -> { view, params } its latest job was sent with
     const loop = createRegenLoop({
       missingParts,
       send: (missing) => {
@@ -870,6 +878,8 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
         // for the overlay; this build reports the poses repaired in its own cycle.
         lastGen = { skipped: needed.length - missing.length, rebuilt: missing.length, posed: pendingPosed.size };
         pendingPosed.clear(); // consumed — never counted against a second build
+        const at = { view: view(), params: { ...params } };
+        for (const n of missing) dispatched.set(n, at);
         ui.showBusy("generating");
         const backends = backendPolicy.backendsFor(params);
         let jobs = 0;
@@ -951,44 +961,58 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
       }
     }
 
-    // Print frames for the layer-line pattern: the display → export map of the
-    // geometry just delivered, so layers run the way the part is printed rather
-    // than the way it is displayed. Each frame describes the delivered mesh
-    // (which a later pose-only repair only moves), and only sub-parts whose
-    // material draws layer lines have one — which includes every
-    // sub-part naming no material, since realistic mode shows those as PLA
-    // (resolve.js). One without a place() is identity at once; one with it
-    // costs two geometry-free probe builds.
+    // Frames the realistic look reads, for the geometry just delivered:
+    //  - print frames for the layer-line pattern: the display → export map, so layers run
+    //    the way the part is printed rather than the way it is displayed. Only sub-parts
+    //    whose material draws layer lines have one — which includes every sub-part naming
+    //    no material, since realistic mode shows those as PLA (resolve.js) — except a laser
+    //    sheet part, which it shows as its stock (sheet-look.js realisticDisplay). One
+    //    without a place() is identity at once; one with it costs two geometry-free probe
+    //    builds.
+    //  - sheet frames for the burn pass (materials/sheet-look.js): a laser sheet in a wood,
+    //    mapped back into its canonical frame — from data, no probe.
+    // Each describes the delivered mesh (which a later pose-only repair only moves).
     const layerLined = new Set(Object.keys(part.parts).filter((n) => {
-      try { return resolveMaterial(part.parts[n].display).params.pattern === "layer-lines"; } catch { return false; }
+      try { return resolveMaterial(realisticDisplay(part.parts[n])).params.pattern === "layer-lines"; } catch { return false; }
     }));
-    // LAZY: a delivery only records the view and params it was built at; the
-    // viewer pulls the frames (computePrintFrames) when it is about to draw the
-    // realistic look — live, loading, or borrowed by a capture — so a CAD-only
-    // session never probes (viewer.js setPrintFrameSource). The snapshot keeps
-    // a late computation describing the mesh actually delivered.
+    const burning = new Set(Object.keys(part.parts).filter((n) => burnsFor(part.parts[n])));
+    // LAZY: a delivery only records the view and params its job was DISPATCHED with
+    // (`dispatched`, set where the loop sends) — not the live ones, which a delivery shown
+    // during playback was never built at; the viewer pulls the frames (computeFrames)
+    // when it is about to draw the realistic look — live, loading, or borrowed by a
+    // capture — so a CAD-only session computes nothing (viewer.js setFrameSource). The
+    // snapshot keeps a late computation describing the mesh actually delivered.
     const printFrames = {};
-    const undrawnFrames = new Map(); // sub-part -> { view, params } at its delivery
-    function recordPrintFrames(names) {
-      const wanted = names.filter((n) => layerLined.has(n));
+    const sheetFrames = {};
+    const undrawnFrames = new Map(); // sub-part -> { view, params } its delivered mesh was built at
+    function recordFrames(names) {
+      const wanted = names.filter((n) => layerLined.has(n) || burning.has(n));
       if (!wanted.length) return;
-      const at = { view: view(), params: { ...params } };
-      for (const n of wanted) undrawnFrames.set(n, at);
-      viewer.invalidatePrintFrames?.();
+      for (const n of wanted) undrawnFrames.set(n, dispatched.get(n) ?? null); // null: built at params nobody recorded
+      viewer.invalidateFrames?.();
     }
-    function computePrintFrames() {
+    function computeFrames() {
       const resolvedFor = new Map(); // one resolveParams per delivery, not per sub-part
       for (const [n, at] of undrawnFrames) {
-        if (!resolvedFor.has(at)) {
+        if (at && !resolvedFor.has(at)) {
           try { resolvedFor.set(at, resolveParams(part, at.params)); } catch { resolvedFor.set(at, null); } // diagnosed by the build
         }
-        const resolved = resolvedFor.get(at);
-        if (resolved) printFrames[n] = printFrameMatrix(part.parts[n], { view: at.view, ...resolved });
+        const resolved = at ? resolvedFor.get(at) : null;
+        // No params to frame this mesh by: a burning sheet draws plain wood rather than
+        // keep a frame that describes other geometry — a sub-millimetre lag along its
+        // normal is enough to char a whole face. A print frame keeps its last value (the
+        // worst it can do is run layer lines the wrong way).
+        if (!resolved) { delete sheetFrames[n]; continue; }
+        if (layerLined.has(n)) printFrames[n] = printFrameMatrix(part.parts[n], { view: at.view, ...resolved });
+        if (burning.has(n)) {
+          const f = sheetFrameFor(part.parts[n], resolved);
+          if (f) sheetFrames[n] = f; else delete sheetFrames[n];
+        }
       }
       undrawnFrames.clear();
-      return { ...printFrames };
+      return { print: { ...printFrames }, sheet: { ...sheetFrames } };
     }
-    viewer.setPrintFrameSource?.(computePrintFrames);
+    viewer.setFrameSource?.(computeFrames);
 
     // Sub-parts whose latest fresh delivery had zero triangles (see the `meshes` case).
     const emptySubParts = new Set();
@@ -1051,7 +1075,7 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
               // delivered, which buildDone() true guarantees is at the live params.
               fastPath.recordDelivered(m.name);
             }
-            recordPrintFrames(data.meshes.map((m) => m.name));
+            recordFrames(data.meshes.map((m) => m.name));
             // A split dispatch answers in two meshes replies; the busy spinner
             // stays up until the view has everything (the other worker's job may
             // still be running — often OCCT, the slow one).
@@ -1082,10 +1106,14 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
           } else if (lastAnimApplyVersion === loop.version()) {
             // Stale ONLY because animation frames kept bumping the version:
             // show the delivered meshes anyway — that IS best-effort playback —
-            // but record NOTHING. Cache and fast-path stamps must describe
-            // geometry built at the live params, and this delivery wasn't; the
-            // fast-path stamp is dropped too, so a later pose-only repair can
-            // never re-pose this newer geometry off an older delivery's stamp.
+            // but record nothing about the LIVE params. Cache and fast-path stamps
+            // must describe geometry built at the live params, and this delivery
+            // wasn't; the fast-path stamp is dropped too, so a later pose-only
+            // repair can never re-pose this newer geometry off an older delivery's
+            // stamp. Its material frames are the exception: those are recorded
+            // against the params its job was dispatched with, which is what it was
+            // built at — keeping the last fresh delivery's frame instead would lay a
+            // sheet's burn over geometry that has moved along its normal.
             // A user edit mid-play pauses playback and bumps the version WITHOUT
             // touching lastAnimApplyVersion, so a genuinely user-stale result
             // fails this test and is discarded exactly as before.
@@ -1093,6 +1121,7 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
               viewer.setSubGeometry(m.name, m);
               fastPath.forget(m.name);
             }
+            recordFrames(data.meshes.map((m) => m.name));
             ui.hideBusy();
             refreshView();
           }

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/sheet/part.js

@@ -9,6 +9,11 @@
 // `sp.sheet.generatedBuild` is the build made here; an author who replaces `build`
 // afterwards is detectable as `sp.build !== sp.sheet.generatedBuild`.
 //
+// Likewise `sp.sheet.generatedPlace` is the place made here (the pose, then the author's
+// own) and `sp.sheet.place` the author's own place, or null: the realistic look
+// (materials/sheet-look.js) trusts a sheet's canonical frame only with no author place
+// and `sp.place === sp.sheet.generatedPlace`.
+//
 // Placement (decision 10): the pose applies for display AND export, then the author's
 // own `place` — so STEP/3MF/STL files of a sheet forge come out assembled.
 import { RENAMED_KEYS, RESERVED_KEYS, SHEET_KEYS, SUBPART_PASSTHROUGH_KEYS } from "./constants.js";
@@ -67,32 +72,42 @@ export function sheetPart(spec) {
     const s = resolveSheet(k, sub, p, d);
     return (processById(s.process).preview ?? sheetPreview)(k, s);
   };
+
+  // Placement (decision 10): the pose applies for display AND export, then the author's own
+  // place. Made BEFORE the record is frozen, so the record can name it. Everything the
+  // place reads is taken NOW, into the same values the record freezes — never read off
+  // `spec` later, which an author may reuse and change for the next panel: the build and
+  // the burn's frame both read the frozen record, and a place that read the spec live would
+  // move the panel away from them.
+  const pose = spec.pose ?? null;
+  const thickness = spec.thickness;
+  const authorPlace = spec.place ?? null;
+  const generatedPlace = pose !== null || authorPlace ? (solid, ctx) => {
+    const resolved = typeof pose === "function" ? pose(ctx.p, ctx.d) : pose;
+    let posed = solid;
+    if (resolved !== null) {
+      const reason = validatePose(resolved);
+      if (reason) throw new Error(`sheet pose: ${reason}`);
+      const t = typeof thickness === "function" ? thickness(ctx.p, ctx.d) : thickness;
+      posed = applyPose(solid, resolved, t);
+    }
+    return authorPlace ? authorPlace(posed, ctx) : posed;
+  } : null;
+
   const sheet = Object.freeze({
     process,
     material: spec.material,
-    thickness: spec.thickness,
+    thickness,
     profile: spec.profile,
     score: spec.score ?? null,
     engrave: spec.engrave ?? null,
-    pose: spec.pose ?? null,
+    pose,
+    place: authorPlace,
     generatedBuild,
+    generatedPlace,
   });
   sub.build = generatedBuild;
-
-  const authorPlace = spec.place;
-  if (sheet.pose !== null || authorPlace) {
-    sub.place = (solid, ctx) => {
-      const pose = typeof sheet.pose === "function" ? sheet.pose(ctx.p, ctx.d) : sheet.pose;
-      let posed = solid;
-      if (pose !== null) {
-        const reason = validatePose(pose);
-        if (reason) throw new Error(`sheet pose: ${reason}`);
-        const t = typeof sheet.thickness === "function" ? sheet.thickness(ctx.p, ctx.d) : sheet.thickness;
-        posed = applyPose(solid, pose, t);
-      }
-      return authorPlace ? authorPlace(posed, ctx) : posed;
-    };
-  }
+  if (generatedPlace) sub.place = generatedPlace;
   sub.sheet = sheet;
   return sub;
 }

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.