partforge 0.124.0 → 0.126.0

package/README.md

@@ -108,6 +108,7 @@ const runtime = mount(part, {
   },
   onBuild: ({ status, ms, error }) => {},   // per accepted build: "success" | "error"
   onPick: ({ selection, label, prompt, token }) => {}, // programmatic click-to-select
+  pickHint: "Click to edit",                // hover-tooltip nudge while onPick is set (null = none)
 });
 await runtime.ready;   // first successful build (rejects on a first-build error)
 runtime.setHostPane("rail");  // narrow layout only: show just the controls
@@ -221,7 +222,10 @@ full contract.
 back to the sub-part label/name) for compact UI, `prompt` is the LLM-ready
 sentence, `token` the compact form, `selection` the raw object. When `onPick` is
 set, the `?pick` / `?pickserver` URL modes are ignored (one click listener ever
-live); hover labels stay always-on.
+live); hover labels stay always-on, and gain a `pickHint` line under the name
+("Click to edit" by default; pass your own wording, or `null` for none). Hover
+never tints the surface under the pointer — a per-face highlight read as "only
+this spot is clickable".
 
 ## Authoring guide
 

package/docs/AUTHORING-PARTS.md

@@ -309,8 +309,14 @@ parts: {
 meta: { title: "…", units: "mm", environment: "studio" },
 ```
 
-- `material` — a preset id from the table below. Without one the sub-part keeps
-  the default look.
+- `material` — a preset id from the table below. Without one (or with one the
+  library does not know) the sub-part keeps the CAD view's look — its `color`,
+  else the viewer's blue-grey — and **realistic mode shows it as a PLA print**
+  (`pla-print`'s finish and layer lines) in that same colour. So an untouched
+  part looks printed in realistic mode; name a material when it is made some
+  other way. The PLA look is realistic-only: the CAD view, 3MF colours and
+  `declaresMaterials` are unaffected, and a part that names no material is not
+  treated as declaring one.
 - `color` — the base colour (`0xRRGGBB`). With a preset it is the TINT. Presets
   marked tintable are normally coloured this way (anodizing, plastic, paint);
   the others have an intrinsic colour (brass) but still accept one.
@@ -2740,7 +2746,10 @@ pane's pixel size:
   target are restored after the render. Measurement-mode dimensions render directly
   in the scene, so a dimensioned capture needs no special handling — enable measure
   mode (`runtime.measure.setEnabled(true)`) and call `captureCurrent()`; the dims are
-  just part of the rendered frame.
+  just part of the rendered frame. With the cutaway on, the capture shows the section
+  the way the user sees it — the part clipped, its cut faces hatched — but never the
+  cutaway's translucent plane or its handles, which are controls, not the part (the
+  same holds for `captureViews` and the view style popover's thumbnails).
   `recenter: true` centres the part: the capture becomes the largest centred
   sub-window of the current framing that still holds every visible vertex (equal
   margins on both axes, rendered at the full `size` resolution through a view
@@ -2815,8 +2824,8 @@ addition to) the generated view style button above:
   revert too.
 - `runtime.declaresMaterials` — `true` when any sub-part names a
   `display.material`. A part with none still supports realistic mode (every
-  sub-part just renders under the library's `default` look), so use this to
-  decide whether to surface your own realistic control at all, not whether it works.
+  sub-part renders as a PLA print in its CAD colour), so use this to decide
+  whether to surface your own realistic control at all, not whether it works.
   Feature lines are not a preference: they draw whenever `runtime.renderMode`
   reads `"cad"` and never while it reads `"realistic"` — there is no switch
   to drive independently of it.
@@ -3302,7 +3311,8 @@ nothing either way and stays silent, matching `animation-track-rebuilds`'s own
 trust handling.
 
 **Appearance** (all warnings) — `unknown-material` (a `display.material` the
-library does not know; the viewer shows the default look), `unknown-environment`
+library does not know; the viewer draws it as if it named none — a PLA print
+in realistic mode), `unknown-environment`
 (`meta.environment` not known; realistic mode uses `studio`),
 `material-key-unknown` (a `display` key that is not colour, opacity, material
 or one of the six overrides; ignored), `material-override-clamped` (an override

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.124.0",
+  "version": "0.126.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/app.css

@@ -1039,6 +1039,10 @@ button.action:focus-visible, .adv-toggle:focus-visible, .sec-title:focus-visible
 .pf-hover-tip .pf-hover-sub { color: var(--pf-muted); font-size: 11px; margin-left: 7px; }
 #pf-hover-tip .pf-hover-sub:empty,
 .pf-hover-tip .pf-hover-sub:empty { display: none; }
+#pf-hover-tip .pf-hover-hint,
+.pf-hover-tip .pf-hover-hint { color: var(--pf-muted); font-size: 10.5px; margin-top: 1px; }
+#pf-hover-tip .pf-hover-hint:empty,
+.pf-hover-tip .pf-hover-hint:empty { display: none; }
 
 /* request-a-pick: agent prompt banner, floated top-centre well below the part tabs,
    laid out like a chat message (avatar + text). Slides/fades in when shown; themed. */

package/src/framework/cutaway.js

@@ -144,6 +144,29 @@ export function createCutaway({
     handleHoverSubscribers.clear();
   }
 
+  // "What the section looks like changed": the mode went on or off, or the
+  // plane moved (a drag, flip, reset or restore). For anything that caches a
+  // picture of the part — the view style popover's thumbnails — which would
+  // otherwise keep showing a section the user has since moved or closed.
+  // Fires often during a drag, so a listener must be cheap; no argument, since
+  // every caller only needs to know that it happened. A throwing listener is
+  // reported, never allowed to interrupt the controller work that fired it.
+  const changeListeners = new Set();
+  function notifyChange() {
+    for (const listener of [...changeListeners]) {
+      try {
+        listener();
+      } catch (error) {
+        try { console.error("Cutaway change listener failed", error); } catch { /* reporting only */ }
+      }
+    }
+  }
+  function onChange(listener) {
+    if (disposed || typeof listener !== "function") return () => {};
+    changeListeners.add(listener);
+    return () => changeListeners.delete(listener);
+  }
+
   function selected(name) {
     return selectedNames == null || selectedNames.has(name);
   }
@@ -213,6 +236,7 @@ export function createCutaway({
     gizmo.setFlipped(flipped);
     gizmo.setPose(pose);
     if (activeAppearance) showActive();
+    notifyChange();
   }
 
   function onPoseChange(nextPose) {
@@ -314,6 +338,7 @@ export function createCutaway({
     } finally {
       disabling = false;
     }
+    if (wasEnabled) notifyChange();
     if (firstError) throw firstError;
     return true;
   }
@@ -340,6 +365,7 @@ export function createCutaway({
     gizmo.setVisible(true);
     gizmo.updateForCamera();
     showActive();
+    notifyChange(); // applyPose above fired too, but before `enabled` meant on
     return true;
   }
 
@@ -360,6 +386,7 @@ export function createCutaway({
     planeFromPose(plane, planeNormal, pose.position, pose.quaternion, flipped);
     gizmo.setFlipped(flipped);
     showActive();
+    notifyChange();
     return true;
   }
 
@@ -579,6 +606,7 @@ export function createCutaway({
     publishHandleHover(null);
     drainHandleHoverPublications();
     clearHandleHoverSubscribers();
+    changeListeners.clear();
     attempt(() => overlayScene.clear());
     attempt(() => capGeometry.dispose());
     if (firstError) throw firstError;
@@ -605,6 +633,11 @@ export function createCutaway({
     updateForCamera,
     renderOverlay,
     onHandleHoverChange,
+    onChange,
+    // The gizmo's in-scene half (the ghost plane and its border). It is
+    // interactive UI drawn in the part's own scene, so the viewer keeps it out
+    // of every offscreen render (viewer.js's captureHidden).
+    captureExcluded: [gizmo.group],
     setCamera(next) {
       if (!next) return;
       camera = next;

package/src/framework/geometry/threemf.js

@@ -69,8 +69,9 @@ function weld(positions, indices) {
 }
 
 // Default for an uncoloured object in an export where some other object IS
-// coloured: the viewer's own default look (presets.js "default"). Written as a
-// literal so this module keeps its fflate-only import closure.
+// coloured: the viewer's own no-material colour (resolve.js
+// NO_MATERIAL_COLOR). Written as a literal so this module keeps its
+// fflate-only import closure; viewer-materials.test.js pins the copies equal.
 const DEFAULT_DISPLAY_COLOR = 0x9fb4cc;
 // Base-material group id: outside the object id range (objects are 1..n).
 const BASE_MATERIALS_ID = 1000;

package/src/framework/lint/rules-materials.js

@@ -3,12 +3,12 @@
 // block geometry, and the viewer already falls back (resolve.js). Pure — imports
 // only the three-free materials data (test/lint-purity.test.js).
 import { warn } from "./finding.js";
-import { PRESETS, DEFAULT_PRESET_ID } from "../materials/presets.js";
+import { PRESETS } from "../materials/presets.js";
 import { ENVIRONMENTS } from "../materials/environments.js";
 import { resolveMaterial, resolveEnvironmentId, OVERRIDE_RANGES } from "../materials/resolve.js";
 import { suggest } from "../geometry/op-options.js";
 
-const listedPresets = () => Object.keys(PRESETS).filter((id) => id !== DEFAULT_PRESET_ID);
+const listedPresets = () => Object.keys(PRESETS);
 const subParts = (part) => Object.entries(part?.parts ?? {}).filter(([, sp]) => sp && typeof sp === "object");
 const issuesOf = (part, kind) => subParts(part).flatMap(([name, sp]) =>
   resolveMaterial(sp.display).issues.filter((i) => i.kind === kind).map((i) => ({ name, ...i })));
@@ -20,7 +20,7 @@ export const MATERIAL_RULES = [
       const near = typeof value === "string" ? suggest(value, listedPresets()) : null;
       return warn("unknown-material",
         `sub-part "${name}" names material ${JSON.stringify(value)}, which is not in the library`,
-        `${near ? `Did you mean "${near}"? ` : ""}The viewer shows the default look instead. Known materials: ${listedPresets().join(", ")}.`,
+        `${near ? `Did you mean "${near}"? ` : ""}The viewer draws it as if it named no material instead (a PLA print in realistic mode). Known materials: ${listedPresets().join(", ")}.`,
         `parts.${name}.display.material`);
     }),
   },

package/src/framework/materials/contact-shadow.js

@@ -110,7 +110,12 @@ export function createContactShadow({ renderer, sizeMm = 400 }) {
   // While a part moves (lowRes) only the soft layer is redrawn and the tight
   // one is hidden: an outline left where the part WAS would be wrong, and the
   // settle render that follows brings it back.
-  function render(scene, casters, { lowRes = false } = {}) {
+  //
+  // `clippingPlanes` (world space) clip the casters the way the cutaway clips
+  // what is on screen. The depth pass draws every caster with the one override
+  // material, which carries none of the casters' own clipping planes, so
+  // without this the half the cutaway removed still cast its shadow.
+  function render(scene, casters, { lowRes = false, clippingPlanes = null } = {}) {
     const bg = scene.background;
     const overrideBefore = scene.overrideMaterial;
     const clear = renderer.getClearAlpha();
@@ -123,6 +128,7 @@ export function createContactShadow({ renderer, sizeMm = 400 }) {
       renderer.setClearAlpha(0);
       for (const l of layers) {
         if (lowRes && l.spec.name === "tight") continue;
+        setClipping(l.depthMaterial, clippingPlanes);
         scene.overrideMaterial = l.depthMaterial;
         renderer.setRenderTarget(l.rt);
         renderer.render(scene, cam);
@@ -143,6 +149,27 @@ export function createContactShadow({ renderer, sizeMm = 400 }) {
     }
   }
 
+  // A new plane count needs a new program; the same planes moved do not (three
+  // reads their values every frame).
+  //
+  // A clipped pass also draws BOTH sides, depth-tested. The pass looks UP at
+  // the casters, and a cut that removes a part's underside (a kept side facing
+  // up, e.g. a top-view cut after Flip) leaves no downward-facing faces at the
+  // cut — from below only back faces remain, which FrontSide culls, and the
+  // shadow shrinks to a faint ring of side walls. The interior back faces fill
+  // the silhouette instead, and the depth test keeps the LOWEST surface under
+  // each texel (the one the ground's darkness is measured from) rather than
+  // whichever face drew last. Unclipped, the pass is exactly as before:
+  // front faces, no depth test.
+  function setClipping(material, planes) {
+    const next = planes?.length ? planes : null;
+    const side = next ? THREE.DoubleSide : THREE.FrontSide;
+    if ((material.clippingPlanes?.length ?? 0) !== (next?.length ?? 0) || material.side !== side) material.needsUpdate = true;
+    material.clippingPlanes = next;
+    material.side = side;
+    material.depthTest = material.depthWrite = !!next;
+  }
+
   return {
     group,
     render,

package/src/framework/materials/presets.js

@@ -8,15 +8,12 @@
 // converted to sRGB. Adding a preset is one record here plus a look at the
 // contact sheet (materials.html) in every environment.
 
-export const DEFAULT_PRESET_ID = "default";
-
 const P = (id, label, category, use, fields) => ({ id, label, category, use, tintable: false, ...fields });
 
 export const PRESETS = {
-  // The viewer's look before this library existed. Not documented as a choice:
-  // it is what a sub-part with no `material` renders as.
-  default: P("default", "Default", "default", "The viewer's neutral blue-grey, used when a sub-part names no material.",
-    { color: 0x9fb4cc, metalness: 0.25, roughness: 0.55 }),
+  // Every record here is a documented, nameable material. A sub-part that names
+  // none is drawn by resolve.js (the blue-grey CAD look; a PLA print in that
+  // colour in realistic mode) — there is no hidden "default" record any more.
 
   "machined-aluminum": P("machined-aluminum", "Machined aluminium", "aluminium", "Bare CNC-milled aluminium, fine tool marks, satin sheen.",
     { color: 0xf5f6f6, metalness: 1, roughness: 0.32 }),

package/src/framework/materials/resolve.js

@@ -1,10 +1,11 @@
 // src/framework/materials/resolve.js
 // Pure resolution of a sub-part's `display` block against the library. Never
-// throws and never rejects a value: an unknown preset falls back to the default,
+// throws and never rejects a value: an unknown preset falls back to the
+// no-material look (below),
 // an out-of-range override clamps, an unknown key is ignored — and every one of
 // those is returned as an `issue` so lint can warn about it. Appearance must
 // never be able to fail a build.
-import { PRESETS, DEFAULT_PRESET_ID } from "./presets.js";
+import { PRESETS } from "./presets.js";
 import { ENVIRONMENTS, DEFAULT_ENVIRONMENT_ID } from "./environments.js";
 
 export const OVERRIDE_RANGES = {
@@ -20,16 +21,34 @@ export const DISPLAY_KEYS = ["color", "opacity", "material", ...Object.keys(OVER
 
 const isColor = (v) => Number.isInteger(v) && v >= 0 && v <= 0xffffff;
 
+// A sub-part with no usable material — none named, or one the library does not
+// know. The CAD view draws it in the viewer's neutral blue-grey drafting look
+// (the look every part had before the library existed; viewer.js's base
+// material and threemf.js's uncoloured-object colour are the same literal).
+// Realistic mode draws it as a PLA print — the pla-print finish, layer lines
+// and all — in that same colour, or the part's own `color`, so a part is the
+// same colour in both views, just printed. `declaresMaterials` still counts
+// only a NAMED material: this default never makes a part "declare" one.
+export const NO_MATERIAL_COLOR = 0x9fb4cc;
+export const NO_MATERIAL_PRESET_ID = "pla-print";
+const NO_MATERIAL_CAD = { color: NO_MATERIAL_COLOR, metalness: 0.25, roughness: 0.55 };
+
+const knownMaterial = (m) => typeof m === "string" && Object.hasOwn(PRESETS, m);
+
 export function resolveMaterial(display) {
   const d = display && typeof display === "object" ? display : {};
   const issues = [];
-  let preset = PRESETS[DEFAULT_PRESET_ID];
-  if (d.material != null) {
-    if (typeof d.material === "string" && Object.hasOwn(PRESETS, d.material)) preset = PRESETS[d.material];
-    else issues.push({ kind: "unknown-material", key: "material", value: d.material });
-  }
+  if (d.material != null && !knownMaterial(d.material)) issues.push({ kind: "unknown-material", key: "material", value: d.material });
+  const preset = knownMaterial(d.material) ? PRESETS[d.material] : PRESETS[NO_MATERIAL_PRESET_ID];
+  const baseColor = knownMaterial(d.material) ? preset.color : NO_MATERIAL_COLOR;
+  return { preset, ...applyDisplay(d, preset, baseColor, issues) };
+}
+
+// A preset record's numbers with the display block's colour, opacity and clamped
+// overrides applied. Pushes onto `issues`; returns them with the params.
+function applyDisplay(d, preset, baseColor, issues) {
   const params = {
-    color: preset.color,
+    color: baseColor,
     metalness: preset.metalness,
     roughness: preset.roughness,
     clearcoat: preset.clearcoat ?? 0,
@@ -63,7 +82,7 @@ export function resolveMaterial(display) {
   }
   // `tinted`: the author named a colour. A textured preset's colour map carries
   // its own colour, so only an explicit tint multiplies it (physical.js).
-  return { preset, params, issues, tinted: isColor(d.color) };
+  return { params, issues, tinted: isColor(d.color) };
 }
 
 // CAD-view appearance: the resolved colour on the CAD MeshStandardMaterial,
@@ -73,11 +92,15 @@ export function resolveMaterial(display) {
 const MIN_CAD_LUMA = 60; // 0..255, Rec. 709
 export function cadAppearance(display) {
   const d = display && typeof display === "object" ? display : {};
-  const { params } = resolveMaterial(d);
   if (d.material == null) {
-    // Byte-for-byte today's behaviour for a part without `material`.
-    return { color: params.color, metalness: 0.25, roughness: 0.55, opacity: params.opacity };
+    // The drafting look, untouched by overrides — as it always was.
+    const { params } = resolveMaterial(d);
+    return { color: params.color, metalness: NO_MATERIAL_CAD.metalness, roughness: NO_MATERIAL_CAD.roughness, opacity: params.opacity };
   }
+  // An unknown material flattens the drafting look rather than the realistic
+  // PLA default, exactly as it did when it fell back to the retired "default"
+  // preset.
+  const { params } = knownMaterial(d.material) ? resolveMaterial(d) : applyDisplay(d, NO_MATERIAL_CAD, NO_MATERIAL_COLOR, []);
   return {
     color: liftLuma(params.color, MIN_CAD_LUMA),
     metalness: Math.min(params.metalness, 0.5),
@@ -97,8 +120,9 @@ function liftLuma(color, min) {
 }
 
 // The colour a 3MF object carries: the explicit tint, else the preset's own
-// colour. Null when the sub-part says nothing about appearance, which is what
-// keeps an appearance-free export byte-for-byte unchanged.
+// colour (the blue-grey for an unknown material, never the realistic PLA
+// default's). Null when the sub-part says nothing about appearance, which is
+// what keeps an appearance-free export byte-for-byte unchanged.
 export function printColor(display) {
   if (!display || typeof display !== "object") return null;
   if (isColor(display.color)) return display.color;

package/src/framework/mount.js

@@ -419,7 +419,7 @@ function createCleanupStack() {
 // Every `elements` entry defaults to the legacy global-ID lookup (below), resolved
 // exactly once here — submodules take element refs and never query the document.
 // `container`/`controls` remain as deprecated aliases for elements.viewer/.controls.
-export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDownload, onViewChange, onParamsCommit, onAnnotationSend,
+export function mount(part, { createWorker, elements = {}, onBuild, onPick, pickHint = "Click to edit", onDownload, onViewChange, onParamsCommit, onAnnotationSend,
                               fontCatalog,
                               imageCatalog,
                               onAssetUpload,
@@ -497,7 +497,10 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
       onRailLayout: () => railChrome.layoutChanged?.(),
     });
     cleanup.defer(() => paneTabs.detach());
-    const hover = attachHoverLabels(viewer, { part, tooltip }); // always-on hover inspection (no-op on touch-only devices)
+    // Always-on hover inspection (no-op on touch-only devices). With onPick the
+    // host acts on a click, so the tooltip nudges toward it with `pickHint`
+    // (a host passes its own wording, or null for none).
+    const hover = attachHoverLabels(viewer, { part, tooltip, hint: onPick ? pickHint : null });
     cleanup.defer(() => hover.detach());
     const ui = createStatusUi({ ...els.status, exports: [els.exports.stl, els.exports.step, els.exports.threeMf] });
     cleanup.defer(() => ui.setStatus(""));
@@ -943,22 +946,42 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
 
     // 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. Computed at delivery (the frame describes
-    // the delivered mesh, which a later pose-only repair only moves) and only
-    // for sub-parts whose material draws layer lines — each one costs two
-    // geometry-free probe builds.
+    // 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.
     const layerLined = new Set(Object.keys(part.parts).filter((n) => {
       try { return resolveMaterial(part.parts[n].display).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 printFrames = {};
+    const undrawnFrames = new Map(); // sub-part -> { view, params } at its delivery
     function recordPrintFrames(names) {
       const wanted = names.filter((n) => layerLined.has(n));
       if (!wanted.length) return;
-      let resolved;
-      try { resolved = resolveParams(part, params); } catch { return; } // diagnosed by the build
-      for (const n of wanted) printFrames[n] = printFrameMatrix(part.parts[n], { view: view(), ...resolved });
-      viewer.setPrintFrames({ ...printFrames });
+      const at = { view: view(), params: { ...params } };
+      for (const n of wanted) undrawnFrames.set(n, at);
+      viewer.invalidatePrintFrames?.();
     }
+    function computePrintFrames() {
+      const resolvedFor = new Map(); // one resolveParams per delivery, not per sub-part
+      for (const [n, at] of undrawnFrames) {
+        if (!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 });
+      }
+      undrawnFrames.clear();
+      return { ...printFrames };
+    }
+    viewer.setPrintFrameSource?.(computePrintFrames);
 
     // Sub-parts whose latest fresh delivery had zero triangles (see the `meshes` case).
     const emptySubParts = new Set();

package/src/framework/selection/hover.js

@@ -1,15 +1,19 @@
 // Always-on hover inspection: a cursor-following tooltip naming the feature +
-// sub-part under the pointer, and an overlay mesh highlighting the feature's
-// surface. Feature names come from Solid.label() in the part's build, carried
-// per-triangle in the mesh payload (geometry.userData.featureIds/features).
+// sub-part under the pointer. Feature names come from Solid.label() in the
+// part's build, carried per-triangle in the mesh payload
+// (geometry.userData.featureIds/features).
+//
+// There is deliberately NO surface highlight: tinting just the feature under
+// the pointer read as "only this face is clickable", and people stopped
+// clicking elsewhere on the part. `hint` (e.g. "Click to edit") adds a line
+// under the name when a click does something — mount passes it with onPick.
 import { createTooltipPresenter } from "../tooltip.js";
 import { raycastViewer } from "./raycast.js";
-import { createFeatureHighlight } from "./feature-highlight.js";
 import { runCleanupSteps } from "../teardown.js";
 
 export function attachHoverLabels(
   viewer,
-  { part, schedule = (cb) => requestAnimationFrame(cb), tooltip } = {},
+  { part, schedule = (cb) => requestAnimationFrame(cb), tooltip, hint = null } = {},
 ) {
   // Hover is a mouse idiom — skip entirely on touch-only devices. The stub
   // still answers the WHOLE interface: mount.js calls setSuppressed from the
@@ -25,8 +29,6 @@ export function attachHoverLabels(
   let presentationToken;
   let hasPresented = false;
 
-  const highlight = createFeatureHighlight(viewer);
-
   const subLabel = (name) => part.parts[name]?.label ?? name;
 
   function hide() {
@@ -35,7 +37,6 @@ export function attachHoverLabels(
       tooltipPresenter.hide(presentationToken);
       presentationToken = undefined;
     }
-    highlight.clear();
   }
 
   function show(hit, x, y) {
@@ -45,7 +46,7 @@ export function attachHoverLabels(
     } else {
       content = { title: subLabel(hit.subPart), subtitle: "" };
     }
-    highlight.show(hit);
+    if (hint) content.hint = hint;
     if (hasPresented) {
       hasPresented = false;
       tooltipPresenter.hide(presentationToken);
@@ -119,7 +120,6 @@ export function attachHoverLabels(
         () => viewer.domElement.removeEventListener("pointerup", onUp),
         () => viewer.domElement.removeEventListener("pointerleave", onLeave),
         hide,
-        () => highlight.dispose(),
         () => { if (ownsTooltip) tooltipPresenter.dispose(); },
       ], "feature hover cleanup failed");
     },

package/src/framework/tooltip.js

@@ -14,7 +14,10 @@ export function createTooltipPresenter({ id = "pf-hover-tip" } = {}) {
   const title = document.createElement("b");
   const subtitle = document.createElement("span");
   subtitle.className = "pf-hover-sub";
-  element.append(title, subtitle);
+  // A call-to-action line under the name ("Click to edit"); empty = hidden.
+  const hint = document.createElement("div");
+  hint.className = "pf-hover-hint";
+  element.append(title, subtitle, hint);
   document.body.appendChild(element);
   let disposed = false;
   const claims = [];
@@ -22,6 +25,7 @@ export function createTooltipPresenter({ id = "pf-hover-tip" } = {}) {
   function setContent(content) {
     title.textContent = content.title;
     subtitle.textContent = content.subtitle ?? "";
+    hint.textContent = content.hint ?? "";
   }
 
   function measureVisible(content, anchored) {

package/src/framework/view-style-controls.js

@@ -150,6 +150,7 @@ export function attachViewStyleControls(viewer, { stage, toolbar = null, anchor
     if (!cache.isStale()) return;
     cache.markFresh();
     const token = ++loopToken;
+    let missed = false;
     // One at a time: each realistic style may load an environment.
     for (const s of STYLES) {
       if (detached || token !== loopToken) return;
@@ -161,9 +162,15 @@ export function attachViewStyleControls(viewer, { stage, toolbar = null, anchor
       let url = null;
       try { url = await viewer.renderStyleThumbnail(s.id, { size: 256 }); } catch { url = null; }
       if (detached || token !== loopToken) return;
+      // A failed or empty render (null) blanks its tile rather than leaving an
+      // older picture up, and leaves the cache stale so the next open tries
+      // again: caching it made one bad moment permanent until a part or theme
+      // change came along.
       cache.set(s.id, url);
+      if (!url) missed = true;
       paint(s.id);
     }
+    if (missed && token === loopToken) cache.invalidate();
   }
 
   // --- open / close ------------------------------------------------------------
@@ -225,6 +232,10 @@ export function attachViewStyleControls(viewer, { stage, toolbar = null, anchor
     viewer.onEnvironmentChange(() => render()),
     viewer.onAssemblyChange?.(() => cache.invalidate()) ?? (() => {}),
     viewer.onThemeChange?.(() => cache.invalidate()) ?? (() => {}),
+    // A thumbnail shows the section as it was when it was taken, so turning
+    // the cutaway on or off, or moving its plane, stales them all — without
+    // this a set taken with the cutaway on outlived the cutaway itself.
+    viewer.onCutawayChange?.(() => cache.invalidate()) ?? (() => {}),
   ];
   render();
   // The popover closes whenever the button's host is hidden: #viewbar hides

package/src/framework/view-style-state.js

@@ -11,8 +11,8 @@ export const STYLES = [
 
 export const styleFor = (renderMode, environmentId) => (renderMode === "realistic" ? environmentId : "cad");
 
-// Thumbnails are rendered on OPEN and cached. `invalidate` (a part or theme
-// change) only marks them stale — the next open re-renders. A render already
+// Thumbnails are rendered on OPEN and cached. `invalidate` (a part, theme or
+// cutaway change, or a render that came back empty) only marks them stale — the next open re-renders. A render already
 // in flight keeps painting (view-style-controls.js says why).
 export function createThumbnailCache() {
   const images = new Map();

package/src/framework/viewer.js

@@ -562,6 +562,8 @@ export function createViewer(container, part) {
   const textureLoader = new THREE.TextureLoader();
   let pmrem = null;
   let printFrames = {};
+  let printFrameSource = null;       // () => frames; mount's lazy provider (setPrintFrameSource)
+  let printFramesStale = false;      // the source has frames the materials have not seen
   const modeListeners = new Set();
   const envListeners = new Set();
   const SHADOW_LOWRES_MS = 100;      // at most one low-res shadow per this, while a part moves
@@ -750,11 +752,14 @@ export function createViewer(container, part) {
     .map((n) => subMesh[n]);
   // `force` renders even while parked: a capture is offscreen work a parked
   // viewer still does, and it must not bake a stale (or absent) shadow.
+  // The cutaway's plane clips the shadow's casters too, so the half it cut
+  // away casts no shadow (cutaway.onChange below re-renders it as it moves).
+  const _shadowClipPlane = new THREE.Plane();
   function renderShadow(opts, { force = false } = {}) {
     if (!realisticRig || (!active && !force)) return;
     try {
-      if (opts) realisticRig.shadow.render(scene, castersNow(), opts);
-      else realisticRig.shadow.render(scene, castersNow());
+      const plane = cutaway.getPlane?.(_shadowClipPlane) ?? null;
+      realisticRig.shadow.render(scene, castersNow(), { ...opts, clippingPlanes: plane ? [plane] : null });
     } catch (e) {
       console.warn("partforge: contact shadow failed", e);
     }
@@ -787,6 +792,10 @@ export function createViewer(container, part) {
       renderShadow({ lowRes: true });
     }
   }
+  // A cutaway turned on or off, or its plane moved, changes what casts the
+  // contact shadow: low-res while the plane is dragged, full once it settles —
+  // the same schedule as a moving sub-part.
+  cutaway.onChange?.(() => { if (realisticRig) shadowMovedAt = performance.now(); });
 
   const livePixelRatio = (mode) =>
     Math.min(devicePixelRatio, mode === "realistic" && isCoarsePointer() ? 1.5 : 2);
@@ -805,6 +814,7 @@ export function createViewer(container, part) {
   // ground only moves on showAssembly, never because a capture happened.
   function enterRealistic(rig, { live = true, reground = true } = {}) {
     try {
+      syncPrintFrames(); // before the swap: the first realistic frame has the export-pose layers
       renderMode = "realistic";
       // A regen can land between the proxy compile and here, while the mode
       // was still CAD, so setSubGeometry skipped the UVs. Idempotent.
@@ -874,6 +884,7 @@ export function createViewer(container, part) {
   // target bound — each only for the synchronous compile() inside
   // compileAsync, so the view on screen is untouched while it waits.
   function compileRealistic(rig, { forCapture = false } = {}) {
+    syncPrintFrames();
     const proxy = new THREE.Scene();
     proxy.environment = rig.envMap;
     for (const n of names) {
@@ -974,6 +985,32 @@ export function createViewer(container, part) {
     for (const [n, m] of physicalMats) m.userData.patternUniforms?.pfPrintFrame.value.fromArray(printFrames[n] ?? identity);
   }
 
+  // The lazy form mount uses. Computing a frame runs the sub-part's pose probe
+  // (two geometry-free builds for a placed sub-part), and every sub-part with
+  // no material draws layer lines, so frames are PULLED only when something is
+  // about to draw the realistic look: the live view (or a switch loading),
+  // and any capture that borrows it — compileRealistic and enterRealistic are
+  // the two doors every such path goes through. A delivery just marks them
+  // stale (invalidatePrintFrames); in CAD nothing is computed.
+  function setPrintFrameSource(source) {
+    printFrameSource = typeof source === "function" ? source : null;
+    invalidatePrintFrames();
+  }
+  function invalidatePrintFrames() {
+    printFramesStale = true;
+    if (renderMode === "realistic" || realisticPending) syncPrintFrames();
+  }
+  function syncPrintFrames() {
+    if (!printFrameSource || !printFramesStale) return;
+    printFramesStale = false;
+    let frames;
+    try { frames = printFrameSource(); } catch (e) {
+      console.warn("partforge: computing print frames failed", e);
+      return;
+    }
+    setPrintFrames(frames);
+  }
+
   // Resolves once the current environment's rig is loaded (captures wait on it).
   const whenRealisticReady = () => rigFor(environmentId).then(() => {});
 
@@ -1825,7 +1862,7 @@ export function createViewer(container, part) {
     for (const dot of [...flashDots, ...captureHidden]) if (dot.visible) { dot.visible = false; reshowFlashDots.push(dot); }
     try {
       renderer.setRenderTarget(rt);
-      renderer.render(renderScene, cam);
+      renderWithBackdrop(renderScene, cam);
       // render() resolves the multisample renderbuffer into the target texture, so this
       // reads antialiased pixels.
       renderer.readRenderTargetPixels(rt, 0, 0, width, height, buf);
@@ -1860,6 +1897,14 @@ export function createViewer(container, part) {
   // Pointer feedback excluded from EVERY offscreen render (renderOffscreen),
   // showcase captures included — unlike canonicalCaptureHidden below.
   const captureHidden = new Set();
+  // The cutaway's ghost plane is its gizmo, not its section: the part as the
+  // user sees it (clipped, with its hatched caps) goes into a capture, the
+  // translucent plane in front of it does not. It sits between the camera and
+  // everything the cut keeps, and a capture blends it in linear light, where
+  // it lands several times stronger than on the canvas — the view style
+  // popover's thumbnails came back with the part washed out behind a blue
+  // sheet, a dark part all but gone.
+  for (const obj of cutaway.captureExcluded ?? []) captureHidden.add(obj);
   function registerCaptureHidden(obj) {
     captureHidden.add(obj);
     return () => captureHidden.delete(obj);
@@ -2144,6 +2189,64 @@ export function createViewer(container, part) {
     }
   }
 
+  // --- the environment backdrop under an orthographic camera ---------------
+  // three draws a texture `scene.background` (the realistic environment photo)
+  // as a unit box around the camera, projected through the camera's own
+  // projection (WebGLBackground + the backgroundCube shader). Under a
+  // PerspectiveCamera that box fills the frame; under an OrthographicCamera it
+  // projects to a one-unit square in a frustum tens of millimetres wide or
+  // more — a speck behind the part — so an ortho face view (the view cube
+  // settles into one) lost its whole backdrop to the clear colour, on the
+  // canvas and in every capture of that framing. So under ortho the backdrop is
+  // its own pass: three's own background draw (same PMREM, blur, intensity,
+  // rotation) through a perspective camera with the ortho camera's orientation
+  // and the live perspective camera's fov, then the scene through the ortho
+  // camera on top, clearing depth and stencil but not colour. The backdrop is
+  // exactly what perspective shows looking the same way. A colour background
+  // (CAD) clears the same under either projection and keeps the one pass.
+  // Residual: a transmissive material in the scene pass refracts the clear
+  // colour rather than the environment (its transmission pass reads
+  // scene.background, which is null for that pass) — under ortho only.
+  const _backdropCam = new THREE.PerspectiveCamera(45, 1, 0.1, 10);
+  const _backdropScene = new THREE.Scene();
+  function renderWithBackdrop(renderScene, cam) {
+    const background = renderScene.background;
+    if (!cam.isOrthographicCamera || !background?.isTexture) {
+      renderer.render(renderScene, cam);
+      return;
+    }
+    cam.updateMatrixWorld();
+    cam.matrixWorld.decompose(_backdropCam.position, _backdropCam.quaternion, _backdropCam.scale);
+    _backdropCam.up.copy(cam.up);
+    _backdropCam.fov = camera.fov;
+    _backdropCam.aspect = (cam.right - cam.left) / (cam.top - cam.bottom) || 1;
+    // A recentred capture renders a sub-window of a larger frame: the backdrop
+    // is cropped the same way, so it lines up with the scene pass.
+    if (cam.view?.enabled) {
+      const { fullWidth, fullHeight, offsetX, offsetY, width, height } = cam.view;
+      _backdropCam.setViewOffset(fullWidth, fullHeight, offsetX, offsetY, width, height);
+    } else {
+      _backdropCam.clearViewOffset();
+    }
+    _backdropCam.updateProjectionMatrix();
+    _backdropCam.updateMatrixWorld(true);
+    _backdropScene.background = background;
+    _backdropScene.backgroundBlurriness = renderScene.backgroundBlurriness;
+    _backdropScene.backgroundIntensity = renderScene.backgroundIntensity;
+    _backdropScene.backgroundRotation.copy(renderScene.backgroundRotation);
+    const clearColorWas = renderer.autoClearColor;
+    try {
+      renderer.render(_backdropScene, _backdropCam);
+      renderScene.background = null;
+      renderer.autoClearColor = false;
+      renderer.render(renderScene, cam);
+    } finally {
+      renderScene.background = background;
+      renderer.autoClearColor = clearColorWas;
+      _backdropScene.background = null; // hold no reference to a rig's texture
+    }
+  }
+
   // --- render loop ----------------------------------------------------------
   // The tween is applied after controls.update() so the cue wins the frame, and
   // the frame listeners run before render so a playback frame draws its own pose.
@@ -2181,7 +2284,7 @@ export function createViewer(container, part) {
       const next = projectPoint([anchorDot.position.x, anchorDot.position.y, anchorDot.position.z]);
       if (anchorMoved(lastAnchor, next)) publishAnchor(next);
     }
-    renderer.render(scene, activeCamera);
+    renderWithBackdrop(scene, activeCamera);
     cutaway.renderOverlay(renderer, activeCamera);
   }
   renderer.setAnimationLoop(renderFrame);
@@ -2543,6 +2646,8 @@ export function createViewer(container, part) {
     registerCanonicalCaptureHidden,
     registerCaptureHidden,
     onCutawayHandleHover: cutaway.onHandleHoverChange,
+    // The section changed: on, off, or the plane moved. Listener gets no args.
+    onCutawayChange: cutaway.onChange,
     setRenderMode,
     getRenderMode: () => renderMode,
     onRenderModeChange: (cb) => { modeListeners.add(cb); return () => modeListeners.delete(cb); },
@@ -2557,6 +2662,8 @@ export function createViewer(container, part) {
     isRealisticPending: () => realisticPending,
     onEnvironmentChange: (cb) => { envListeners.add(cb); return () => envListeners.delete(cb); },
     setPrintFrames,
+    setPrintFrameSource,
+    invalidatePrintFrames,
     whenRealisticReady,
     dispose,
   };

package/src/parts/material-swatches.js

@@ -3,7 +3,7 @@
 // judged by eye in every environment (materials.html). Not a reference part.
 import { PRESETS } from "../framework/materials/presets.js";
 
-const ids = Object.keys(PRESETS).filter((id) => id !== "default");
+const ids = Object.keys(PRESETS);
 const COLS = 6, PITCH = 40;
 
 const withHole = (k) =>
@@ -20,6 +20,13 @@ export default {
       build: (k) => withHole(k).translate([(i % COLS) * PITCH, -Math.floor(i / COLS) * PITCH, 0]),
       display: { material: id },
     }])),
+    // No material at all: the blue-grey CAD look, a PLA print in that colour in
+    // realistic mode (resolve.js).
+    no_material: {
+      label: "No material",
+      views: ["all"],
+      build: (k) => withHole(k).translate([(ids.length % COLS) * PITCH, -Math.floor(ids.length / COLS) * PITCH, 0]),
+    },
     upright_pla: {
       label: "PLA, displayed upright, printed flat",
       views: ["print"],