partforge 0.140.0 → 0.141.0

package/docs/AUTHORING-PARTS.md

@@ -105,6 +105,10 @@ export default {
   `"display"` or `"export"`; `ctx.view` is the active view. Default is identity, so simple
   parts omit it. **Display placement must not depend on `view`** — display meshes are built
   once per sub-part and cached across views (the viewer re-centres per view).
+  The viewer applies the display pose as a matrix over the canonical mesh, so `build()` may
+  query geometry freely; only `place()` has to stay a rigid motion of its argument, reading
+  `p` and `d`, for a pose-only param to play at frame rate and for layer lines to stay on
+  the part.
   **Any difference between the display and export pose must be a rigid motion** —
   `translate`/`rotate`/`rotateAbout`/`along`/`at` only. Never put a `mirror` or a
   non-identity `scale` on one purpose but not the other: the exported (printed) part is the
@@ -113,6 +117,8 @@ export default {
   ([place-not-rigid](ERROR-PATTERNS.md#place-not-rigid)). If a part genuinely needs a
   reflected or resized form (e.g. a block that seats flipped), bake that into `build` so
   both purposes share one canonical solid, then pose it rigidly.
+  Branch on `purpose` so the export pose is the print orientation: an export pose that
+  follows an animated param pins the layer lines to the pose at the last rebuild.
 - `enabled(p)` gates a conditional sub-part (e.g. only present when a feature is on).
 - A view's sub-parts are derived, never hard-coded: those whose `views` include the view
   and whose `enabled(p)` is true.
@@ -285,10 +291,11 @@ Rules (all lint-enforced):
       tracks: { lidOpen: [[0, 0], [1, 100]] } },
   ]
   ```
-- Playback drives params through the real param pipeline: a **pose-only**
-  param (feeds only rigid placement — see "Caching & determinism" below) plays
-  at frame rate; anything else rebuilds best-effort at worker cadence. `lint`
-  prints a note per track that can't take the fast path.
+- Playback drives params through the real param pipeline. A param read only
+  inside `place()` plays at frame rate whatever `build()` does. A param
+  `build()` reads rebuilds at worker cadence — except through a trailing
+  translate/rotate, which the viewer still re-poses by delta. `lint` notes a track whose
+  `place()` it cannot read (a query on the solid, a function argument).
 - Playback pauses when the user edits any control; Reset restores the values
   the animation found. Because animated values are real params, exporting
   while paused exports the posed state — by design.
@@ -788,7 +795,8 @@ lid's open angle, an exploded-view offset) therefore re-drags in ~0 ms even on t
 slow exact kernel — keep such transforms as the last ops in `build` (or in `place`)
 rather than baking them into the geometry earlier. In the app, such pose-only edits
 skip the worker entirely — the viewer re-poses the cached mesh — so they stay smooth
-even at animation rates (see `runtime.setParams`).
+even at animation rates (see `runtime.setParams`). `place()` needs no geometry: the viewer
+reads its pose off a geometry-free probe of `place()` alone, so `build()` may query freely.
 
 ---
 
@@ -3706,19 +3714,19 @@ key, which the runtime ignores), `animations-not-object`,
 `animation-autoplay-invalid` (all errors). One
 more rule does execute `build`, geometry-free: `animation-track-rebuilds` probes
 each track's endpoint values and emits a **note** when the animated param feeds
-real geometry (or the probe can't be trusted), because such a track plays
-best-effort rather than at frame rate. Notes are informational — they never
+real geometry, or when its `place()` can't be read (it queries the solid or
+passes a function), because such a track plays best-effort rather than at frame
+rate. Notes are informational — they never
 affect `ok`, `measure`, or `--strict`.
 
-**Place invariants**, found by running the geometry-free pose probe (the same
+**Place invariants**, found by running the geometry-free place probe (the same
 one animation's `animation-track-rebuilds` uses) against each sub-part's
-`place()` — `view-dependent-display-place` (display placement must not depend
+`place()`, even when `build()` queries the solid — `view-dependent-display-place` (display placement must not depend
 on the active view, since display meshes are cached across views) and
 `place-not-rigid` (display vs. export placement may differ only by a rigid
-motion — translate/rotate — never a reshape) (both errors). An untrusted probe
-(a query op or function selector reached during `build`/`place`) proves
-nothing either way and stays silent, matching `animation-track-rebuilds`'s own
-trust handling.
+motion — translate/rotate — never a reshape) (both errors). A `place()` the probe
+cannot read (it queries the solid or passes a function) stays silent for the two
+place rules and earns the `animation-track-rebuilds` note.
 
 **Appearance** (all warnings) — `unknown-material` (a `display.material` the
 library does not know; the viewer draws it as if it named none — a PLA print

package/docs/ERROR-PATTERNS.md

@@ -142,13 +142,13 @@ Variant literals under this entry: `extrude: unknown bevel option`, `extrude: be
 
 - **Symptom:** A sub-part renders correctly in one view but appears misplaced (usually in its other-view pose) after switching views.
 - **Cause:** A `place` that depends on `ctx.view` for `purpose: "display"` — display meshes are built once per sub-part and cached across views.
-- **Fix:** Make display placement view-independent; only `place(..., { purpose: "export" })` may branch on `view`. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "The `PartDefinition` contract".
+- **Fix:** Make display placement view-independent; only `place(..., { purpose: "export" })` may branch on `view`. The rule sees a `place()` behind any `build()`, including one that queries the solid; a `place()` it cannot read stays silent. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "The `PartDefinition` contract".
 
 ## place-not-rigid
 
 - **Symptom:** The exported/printed part is a mirror image of — or a different size than — the same part shown in the assembly/display view. Nothing throws: the preview looks right and only the STL/STEP is wrong, or vice-versa.
 - **Cause:** A `place` whose `purpose: "display"` and `"export"` branches differ by a non-rigid transform — `mirror` (flips handedness) or a non-identity `scale` (changes size) — so display and export are no longer the same solid, only its reflection/resize.
-- **Fix:** Keep the display-vs-export `place` difference a rigid motion (`translate`/`rotate`/`rotateAbout`/`along`/`at`) only. If the part genuinely needs a reflected or resized form, bake that into `build` so both purposes share one canonical solid and pose it rigidly. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "The `PartDefinition` contract".
+- **Fix:** Keep the display-vs-export `place` difference a rigid motion (`translate`/`rotate`/`rotateAbout`/`along`/`at`) only. If the part genuinely needs a reflected or resized form, bake that into `build` so both purposes share one canonical solid and pose it rigidly. The rule sees a `place()` behind any `build()`, including one that queries the solid; a `place()` it cannot read stays silent. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "The `PartDefinition` contract".
 
 ## wrong-node-version
 
@@ -485,8 +485,8 @@ Variant literal for a curve-adjacent corner: `filletProfile: corner <i> at (<x>,
 ## animation-plays-choppy
 
 - **Symptom:** An animation stutters or updates a few times a second instead of smoothly; `?debug` shows `rebuilt` counts climbing during playback.
-- **Cause:** A track drives a param that feeds real geometry (or a build the pose probe can't trust — a query op or function selector), so every frame is a worker rebuild instead of a pose repair.
-- **Fix:** Run `npx partforge lint <part>` — the `animation-track-rebuilds` note names the track. Restructure so the param only feeds rigid placement (`place()` or a trailing translate/rotate in `build`), or accept best-effort playback if geometry morphing is the intent. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Animations".
+- **Cause:** A track drives a param `build()` reads (that rebuilds at worker cadence — except through a trailing translate/rotate, which the viewer still re-poses by delta), or a `place()` the probe cannot read (it queries the solid or passes a function), so every frame is a worker rebuild instead of a matrix pose.
+- **Fix:** Run `npx partforge lint <part>` — the `animation-track-rebuilds` note names the track and says which case it is. Restructure so the param is read only by `place()` (a rigid translate/rotate of its argument, reading `p`/`d`), or accept best-effort playback if geometry morphing is the intent. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Animations".
 
 ## phantom-edges-on-curved-surface
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.140.0",
+  "version": "0.141.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/debug-overlay.js

@@ -47,17 +47,18 @@ export function createDebugOverlay({ initialCachingOn = true, onToggle } = {}) {
   // figure doesn't blank the others: a pose-only edit ran no build and no L2 ops,
   // and would otherwise wipe the last build's timing back to "—" on its way to
   // showing a posed count.
-  const shown = { ms: null, hits: 0, misses: 0, skipped: 0, rebuilt: 0, posed: 0 };
+  const shown = { ms: null, hits: 0, misses: 0, skipped: 0, rebuilt: 0, posed: 0, frame: null };
 
   return {
     update(counts = {}) {
       Object.assign(shown, counts);
-      const { ms, hits, misses, skipped, rebuilt, posed } = shown;
+      const { ms, hits, misses, skipped, rebuilt, posed, frame } = shown;
       const l2 = cb.checked ? `${hits} hit / ${misses} miss` : "off";
       readout.textContent =
         `build: ${ms != null ? Math.round(ms) + " ms" : "—"}\n` +
         `L2 ops: ${l2}\n` +
-        `L1 parts: ${skipped} skipped / ${rebuilt} rebuilt / ${posed} posed`;
+        `L1 parts: ${skipped} skipped / ${rebuilt} rebuilt / ${posed} posed` +
+        (frame ? ` · ${frame}` : ""); // delivery frames of the in-view meshes
     },
     detach: () => box.remove(),
   };

package/src/framework/geometry/pose.js

@@ -11,8 +11,9 @@
 
 const IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 
-// column-major 4x4 product: (A·B)[c][r] = Σk A[k][r]·B[c][k]
-function mulMat4(A, B) {
+// column-major 4x4 product: (A·B)[c][r] = Σk A[k][r]·B[c][k]. Exported for the
+// pose fast path, which composes a place pose over a build delta.
+export function mulMat4(A, B) {
   const o = new Array(16);
   for (let c = 0; c < 4; c++)
     for (let r = 0; r < 4; r++)

package/src/framework/jobs.js

@@ -16,6 +16,7 @@ import { vectorControlAllows, vectorSourceAllowed, isNoVectorSource } from "./ve
 import { vectorsFor, ensureVectors } from "./vectors.js";
 import { exportSubParts, resolveParamsAttributed, recordedParams, buildPosed } from "./part-model.js";
 import { newReadSink, expandReads } from "./read-recorder.js";
+import { probeSubPartPose } from "./pose-probe-core.js";
 
 export const FONT_SOURCE_CACHE_MAX = 4;
 
@@ -397,15 +398,23 @@ export async function handle(kernel, part, msg, post, opts = {}) {
     await ensureVectors(kernel, declaredVectors);
     // Local shorthand over the shared helper: kernel/part/view/p/d are fixed per job.
     const posed = (name, purpose, prog) => buildPosed(kernel, part, name, { purpose, view: msg.view, p, d, onProgress: prog });
-    // A display build plus the sorted raw keys it read (spec §1): its own p/d
-    // reads, derive-expanded, plus the job's asset-declaration reads.
-    const posedWithReads = (name) => {
+    // Canonical delivery (spec 2026-10-03 place-only pose, §2): when place() can be read
+    // off a token — rigid, no query, no function — the mesh is built WITHOUT it and
+    // stamped with build reads alone; the viewer applies the display pose as a matrix.
+    // Otherwise the pose is baked and both halves' reads are recorded, as before.
+    // The probe runs on the plain p/d, never the recorders, so place reads cannot
+    // land in a canonical stamp.
+    const displayWithReads = (name) => {
+      const sp = part.parts[name];
       const sink = newReadSink();
       sink.attribution = attribution;
       const rec = recordedParams({ p, d }, sink);
-      const solid = buildPosed(kernel, part, name, { purpose: "display", view: msg.view, p: rec.p, d: rec.d });
+      const canonical = probeSubPartPose(sp, { view: msg.view, purpose: "display", p, d }, { scope: "place" }).trusted === true;
+      const solid = canonical
+        ? sp.build(kernel, rec.p, rec.d)
+        : buildPosed(kernel, part, name, { purpose: "display", view: msg.view, p: rec.p, d: rec.d });
       for (const key of assetSink.raw) sink.raw.add(key);
-      return { solid, reads: expandReads(sink) };
+      return { solid, reads: expandReads(sink), frame: canonical ? "canonical" : "posed" };
     };
     // Explicit selection (headless exportParts) overrides view-derived selection.
     const selected = () =>
@@ -429,9 +438,9 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       for (const [i, name] of msg.subparts.entries()) {
         if (useCache) kernel.beginSubPart?.(name); // open the per-sub-part cache round
         try {
-          const { solid, reads } = posedWithReads(name);
+          const { solid, reads, frame } = displayWithReads(name);
           const m = solid.toMesh({ quality: "preview" });
-          meshes.push({ name, positions: m.positions, normals: m.normals, indices: m.indices, triangles: m.triangles, edges: m.edges, featureIds: m.featureIds, features: m.features, reads });
+          meshes.push({ name, positions: m.positions, normals: m.normals, indices: m.indices, triangles: m.triangles, edges: m.edges, featureIds: m.featureIds, features: m.features, reads, frame });
         } finally {
           for (const message of kernel.takeBuildWarnings?.() ?? []) warnings.push({ part: name, message });
           if (useCache) kernel.endSubPart?.(); // always close the bracket — a throw mid-build must not strand pinned solids

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

@@ -14,7 +14,8 @@ import { err, note } from "./finding.js";
 import { EASINGS } from "../animation.js";
 import { CANONICAL_VIEWS, CAMERA_CUE_VIEWS } from "../view-angles.js";
 import { probeSubPartPose } from "../pose-probe-core.js";
-import { resolveDerived } from "../derive.js";
+import { resolveDerivedAttributed } from "../derive.js";
+import { recorder, expandDerivedReads } from "../read-recorder.js";
 import { desugar } from "../panel/legacy.js";
 import { controlNodes } from "../panel/model.js";
 
@@ -467,8 +468,10 @@ export const ANIMATION_RULES = [
           out.push(note("animation-track-rebuilds",
             cls === "rebuild"
               ? `animation "${name}" track "${key}" rebuilds geometry — playback is best-effort, not frame-rate`
-              : `animation "${name}" track "${key}" cannot use the pose fast path (untrusted probe) — playback is best-effort`,
-            "Frame-rate playback needs the param to feed only rigid placement (translate/rotate in `place()` or at the end of `build`). If that's the intent, restructure so the param never feeds a geometry op, a query, or a function selector; if geometry morphing is the intent, this is expected.",
+              : `animation "${name}" track "${key}" — \`place()\` cannot be probed (it queries the solid or passes a function), so playback is best-effort`,
+            cls === "rebuild"
+              ? "Frame-rate playback needs the param to be read only by `place()` (or by a trailing translate/rotate in `build`) — if geometry morphing is the intent, this note is expected."
+              : "Keep `place()` to translate/rotate of its argument, reading `p`/`d` only; `build()` may query freely.",
             base));
         }
       }
@@ -502,28 +505,54 @@ export const ANIMATION_RULES = [
   },
 ];
 
-// Classify one animated param by probing every sub-part the OWNING view can
-// show, at the track's two endpoint values: identical trusted baseHashes at
-// both ends → the param only re-poses ("pose"); differing hashes → real
-// geometry ("rebuild"); any untrusted probe → "untrusted" (the fast path will
-// decline it at runtime too). Mirrors the runtime trust model in
-// pose-probe-core.js. Sub-parts outside the owning view cannot be moved by this
-// animation, so probing them would only manufacture false notes.
+// Classify one animated param per sub-part the OWNING view can show, at the
+// track's two endpoint values (spec 2026-10-03-place-only-pose §8):
+//   1. place-scope probe unreadable at either end → "untrusted" — the only way
+//      the untrusted note fires: the viewer cannot pose that mesh without a rebuild.
+//   2. build-scope probe trusted at both ends with different baseHash → "rebuild".
+//   3. build-scope probe untrusted (build() queries) → "rebuild" when the build
+//      READ the key, recorded by the probe run itself and derive-expanded as
+//      subPartReadKeys does. A prediction: a read behind a dummy query branch is
+//      missed, which costs a missing note, never a wrong behaviour.
+//   4. otherwise → "pose".
+// A place() that is readable but RESHAPES (scale/mirror/boolean, so its baseHash
+// is not CANONICAL) is delivered posed and played by the full-scope delta fast
+// path, so it is classified as before that path changed: the full probe trusted
+// with equal hashes → "pose", anything else → "rebuild" (the runtime rebuilds it).
+// Sub-parts outside the owning view cannot be moved by this animation, so probing
+// them would only manufacture false notes.
 function classifyTrack(part, p, key, v0, v1, view) {
   let result = "pose";
   for (const sp of Object.values(isPlainObject(part?.parts) ? part.parts : {})) {
     if (!Array.isArray(sp?.views) || !sp.views.includes(view)) continue;
-    const probes = [];
+    const ends = [];
     for (const v of [v0, v1]) {
       const pv = { ...p, [key]: v };
-      let dv;
-      try { dv = resolveDerived(part, pv) ?? {}; } catch { return "untrusted"; }
-      try { if (sp.enabled && !sp.enabled(pv)) { probes.push(null); continue; } } catch { return "untrusted"; }
-      probes.push(probeSubPartPose(sp, { view, purpose: "display", p: pv, d: dv }));
+      // An endpoint whose derive() or enabled() throws cannot be shown to be
+      // pose-only; "best-effort" is the honest claim, and the untrusted note names
+      // place() specifically, so it would mislead here.
+      let attributed;
+      try { attributed = resolveDerivedAttributed(part, pv); } catch { return "rebuild"; }
+      const dv = attributed.d ?? {};
+      try { if (sp.enabled && !sp.enabled(pv)) { ends.push(null); continue; } } catch { return "rebuild"; }
+      const ctx = { view, purpose: "display", p: pv, d: dv };
+      const place = probeSubPartPose(sp, ctx, { scope: "place" });
+      if (place.baseHash === undefined) return "untrusted";
+      if (!place.trusted) { ends.push({ full: probeSubPartPose(sp, ctx) }); continue; }
+      const reads = new Set();
+      const dSeen = new Set();
+      const build = probeSubPartPose(sp, { ...ctx, p: recorder(pv, reads), d: recorder(dv, dSeen) }, { scope: "build" });
+      ends.push({ build, reads: expandDerivedReads(reads, dSeen, attributed) });
+    }
+    const [a, b] = ends;
+    if (!a || !b) continue;
+    if (a.full || b.full) {
+      if (!a.full?.trusted || !b.full?.trusted || a.full.baseHash !== b.full.baseHash) result = "rebuild";
+    } else if (a.build.trusted && b.build.trusted) {
+      if (a.build.baseHash !== b.build.baseHash) result = "rebuild";
+    } else if (a.reads.has(key) || b.reads.has(key)) {
+      result = "rebuild";
     }
-    if (probes.some((x) => x && !x.trusted)) return "untrusted";
-    const [a, b] = probes;
-    if (a && b && a.baseHash !== b.baseHash) result = "rebuild";
   }
   return result;
 }

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

@@ -4,9 +4,13 @@
 //   1. Display placement must not depend on the active view (display meshes
 //      are cached across views; a view-dependent pose serves stale geometry).
 //   2. Display vs export may differ only by a rigid motion (translate/rotate).
-// Both checks run the geometry-free pose probe; an untrusted probe (query op /
-// function selector in build or place) proves nothing and stays silent — the
-// runtime declines the fast path for those sub-parts anyway.
+// Both checks run the place-scope pose probe: place() alone, on a canonical token,
+// so build() may query freely without hiding a finding. A READABLE result carries
+// `baseHash` (CANONICAL for translate/rotate only, another hash when place()
+// reshapes) and `pose`; a place() the probe cannot read (it queries the solid or
+// passes a function) returns `{ trusted: false }` with no baseHash, proves nothing,
+// and stays silent. Readability, not `trusted`, gates the rules: the same reshape
+// on both purposes is allowed, so a reshaping place() must still be compared.
 import { err } from "./finding.js";
 import { probeSubPartPose } from "../pose-probe-core.js";
 
@@ -23,6 +27,8 @@ function viewNames(part, view, p) {
 }
 
 const poseKey = (pose) => JSON.stringify(pose);
+const readable = (probe) => probe.baseHash !== undefined;
+const probePlace = (sp, ctx) => probeSubPartPose(sp, ctx, { scope: "place" });
 
 export const PLACE_RULES = [
   {
@@ -34,8 +40,8 @@ export const PLACE_RULES = [
       for (const [name, sp] of Object.entries(isPlainObject(part?.parts) ? part.parts : {})) {
         const inViews = views.filter((v) => viewNames(part, v, p).includes(name));
         if (inViews.length < 2) continue;
-        const probes = inViews.map((view) => probeSubPartPose(sp, { view, purpose: "display", p, d }));
-        if (probes.some((x) => !x.trusted)) continue;
+        const probes = inViews.map((view) => probePlace(sp, { view, purpose: "display", p, d }));
+        if (!probes.every(readable)) continue;
         const first = probes[0];
         const differs = probes.some((x) => x.baseHash !== first.baseHash || poseKey(x.pose) !== poseKey(first.pose));
         if (differs) {
@@ -57,9 +63,9 @@ export const PLACE_RULES = [
         if (!sp?.place) continue;
         for (const view of Object.keys(isPlainObject(part?.views) ? part.views : {})) {
           if (!viewNames(part, view, p).includes(name)) continue;
-          const display = probeSubPartPose(sp, { view, purpose: "display", p, d });
-          const exportP = probeSubPartPose(sp, { view, purpose: "export", p, d });
-          if (!display.trusted || !exportP.trusted) continue;
+          const display = probePlace(sp, { view, purpose: "display", p, d });
+          const exportP = probePlace(sp, { view, purpose: "export", p, d });
+          if (!readable(display) || !readable(exportP)) continue;
           if (display.baseHash !== exportP.baseHash) {
             out.push(err("place-not-rigid",
               `sub-part "${name}" display and export placements differ by more than a rigid motion (view "${view}")`,

package/src/framework/materials/print-frame.js

@@ -5,12 +5,20 @@
 // list of rigid steps — so the display→export map is E · D⁻¹, with no geometry.
 // Three-free and DOM-free: the pose probe and pose.js are pure.
 import { probeSubPartPose } from "../pose-probe-core.js";
-import { poseDelta } from "../geometry/pose.js";
+import { poseDelta, composePose } from "../geometry/pose.js";
 
 const IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 
-export function printFrameMatrix(subPart, { view, p, d }) {
+// `frame` is the delivery's frame. A "canonical" mesh is the build before place(), so its
+// map to the printed part is the export pose itself (place-scope: no geometry is read, so a
+// build that queries its solid cannot make it untrusted); a "posed" mesh already carries the
+// display pose, so the map is E · D⁻¹.
+export function printFrameMatrix(subPart, { view, p, d, frame = "posed" }) {
   if (!subPart?.place) return [...IDENTITY];
+  if (frame === "canonical") {
+    const exp = probeSubPartPose(subPart, { view, purpose: "export", p, d }, { scope: "place" });
+    return exp.trusted ? composePose(exp.pose) : [...IDENTITY];
+  }
   const disp = probeSubPartPose(subPart, { view, purpose: "display", p, d });
   const exp = probeSubPartPose(subPart, { view, purpose: "export", p, d });
   if (!disp.trusted || !exp.trusted || disp.baseHash !== exp.baseHash) return [...IDENTITY];

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

@@ -152,7 +152,9 @@ export function burnsFor(sp) {
 // 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 } = {}) {
+// `frame` "canonical": the delivered mesh is the sheet's own canonical solid (place() not
+// applied), so no frame maps it — identity, same t and plies.
+export function sheetFrameFor(sp, { p, d, frame: delivered = "posed" } = {}) {
   if (!burnsFor(sp)) return null;
   const meta = sheetMeta(sp, p, d);
   if (!meta) return null;
@@ -160,7 +162,7 @@ export function sheetFrameFor(sp, { p, d } = {}) {
   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)));
+  const frame = delivered === "canonical" || pose == null ? [...IDENTITY] : invertRigid(composePose(poseSteps(pose, t)));
   return { frame, t, plies: lookOf(sp).preset.laminated ? plyCount(t) : 0 };
 }
 

package/src/framework/mesh-cache.js

@@ -8,7 +8,7 @@ import { relevanceHash } from "./param-deps.js";
 // path (spec 2026-10-03). Nothing is predicted; a sub-part with no stamp is not
 // current. `params` is a stable object mutated in place; the rest are getters.
 export function createMeshCache(viewer, { params, getView, getParamsVersion, isCaching }) {
-  const stamps = {}; // name -> { keys: string[] | null (null = every param), hash, view }
+  const stamps = {}; // name -> { keys: string[] | null (null = every param), hash, view, frame: "canonical" | "posed" }
 
   const hashOf = (keys) => {
     if (!isCaching()) return `v${getParamsVersion()}`; // caching off: any edit invalidates
@@ -24,14 +24,17 @@ export function createMeshCache(viewer, { params, getView, getParamsVersion, isC
     // fast path's in-place repair). `reads` undefined = unknown → every param.
     // `view` is the view the build was DISPATCHED for: a tab switch doesn't bump
     // the params version, so a reply can land fresh after the live view moved.
-    record: (name, reads, view = getView()) => {
+    // `frame` is the delivery frame: "canonical" for place-only rasterization,
+    // "posed" for posed delivery (default, for older worker replies).
+    record: (name, reads, view = getView(), frame = "posed") => {
       const keys = reads == null ? null : [...new Set(reads)].sort();
-      stamps[name] = { keys, hash: hashOf(keys), view };
+      stamps[name] = { keys, hash: hashOf(keys), view, frame };
     },
     // The recorded keys, or null for BOTH "no stamp" and "every-param stamp" —
     // the pose fast path relies on null meaning unknown. hasStamp tells them apart.
     readsOf: (name) => (stamps[name]?.keys ? new Set(stamps[name].keys) : null),
     hasStamp: (name) => stamps[name] != null,
+    frameOf: (name) => stamps[name]?.frame ?? null,
     forget: (name) => { delete stamps[name]; },
   };
 }

package/src/framework/mount.js

@@ -242,8 +242,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.136.0: the font control commits once per picker
-// session, on close, not per pick):
+// Embedding contract (0.141.0: a place()-able sub-part is delivered in its
+// canonical frame and posed by the viewer; pose-only edits never rebuild):
 //   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
@@ -576,7 +576,11 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
         // that reads params (refreshView / updateRelevance / the loop kick) must
         // run after it. autoplayKick stays LAST — it starts the new view's own.
         animCtl?.viewChanged();
-        pendingPosed.clear(); cutawayChrome.reset(); refreshView(); updateRelevance(); loop.kick(); animCtl?.autoplayKick();
+        pendingPosed.clear(); cutawayChrome.reset(); refreshView();
+        // place() may read `view`: re-pose the incoming view's canonical meshes
+        // (and clear the posed ones' matrices) before anything else reads them.
+        fastPath.apply(viewSubParts(part, view(), params));
+        updateRelevance(); loop.kick(); animCtl?.autoplayKick();
         onViewChange?.(name);
       },
     });
@@ -906,6 +910,16 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
       params, getView: view, getParamsVersion: () => loop.version(),
     });
 
+    // ?debug: how the in-view meshes were delivered, e.g. "3 canonical / 1 posed".
+    const frameSummary = () => {
+      const n = { canonical: 0, posed: 0 };
+      for (const name of viewSubParts(part, view(), params)) {
+        const f = cache.frameOf(name);
+        if (f in n) n[f]++;
+      }
+      return `${n.canonical} canonical / ${n.posed} posed`;
+    };
+
     // paramsVersion of the most recent animation-frame apply. It is what lets
     // the meshes handler tell "stale because playback moved on" (show it — that
     // IS best-effort playback) from "stale because the user edited" (discard).
@@ -990,16 +1004,20 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
     // snapshot keeps a late computation describing the mesh actually delivered.
     const printFrames = {};
     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));
+    const undrawnFrames = new Map(); // sub-part -> { at: { view, params } its delivered mesh was built at, frame }
+    // `meshes` are the reply's deliveries: each one's `frame` ("canonical" | "posed"; an older
+    // worker sends none, so posed) rides beside the view/params so the frames describe it.
+    function recordFrames(meshes) {
+      const wanted = meshes.filter((m) => layerLined.has(m.name) || burning.has(m.name));
       if (!wanted.length) return;
-      for (const n of wanted) undrawnFrames.set(n, dispatched.get(n) ?? null); // null: built at params nobody recorded
+      for (const m of wanted) {
+        undrawnFrames.set(m.name, { at: dispatched.get(m.name) ?? null, frame: m.frame ?? "posed" }); // at null: built at params nobody recorded
+      }
       viewer.invalidateFrames?.();
     }
     function computeFrames() {
       const resolvedFor = new Map(); // one resolveParams per delivery, not per sub-part
-      for (const [n, at] of undrawnFrames) {
+      for (const [n, { at, frame }] of undrawnFrames) {
         if (at && !resolvedFor.has(at)) {
           try { resolvedFor.set(at, resolveParams(part, at.params)); } catch { resolvedFor.set(at, null); } // diagnosed by the build
         }
@@ -1009,9 +1027,9 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
         // 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 (layerLined.has(n)) printFrames[n] = printFrameMatrix(part.parts[n], { view: at.view, ...resolved, frame });
         if (burning.has(n)) {
-          const f = sheetFrameFor(part.parts[n], resolved);
+          const f = sheetFrameFor(part.parts[n], { ...resolved, frame });
           if (f) sheetFrames[n] = f; else delete sheetFrames[n];
         }
       }
@@ -1068,7 +1086,10 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
           if (fresh) { // stale results (params changed mid-build) are discarded
             for (const m of data.meshes) {
               viewer.setSubGeometry(m.name, m); // disposes any previous mesh for this name
-              cache.record(m.name, m.reads, dispatched.get(m.name)?.view ?? view()); // the view its job was SENT for
+              // The view its job was SENT for, and the frame the worker delivered
+              // in: "canonical" (place() not applied — mount poses it below) or
+              // "posed". An older worker sends no frame; its meshes are posed.
+              cache.record(m.name, m.reads, dispatched.get(m.name)?.view ?? view(), m.frame ?? "posed");
               // A sub-part that built into NOTHING. Manifold booleans return an
               // empty solid rather than throwing (a bore wider than its body),
               // and typed values may sit outside the authored range, so a
@@ -1081,7 +1102,14 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
               // delivered, which buildDone() true guarantees is at the live params.
               fastPath.recordDelivered(m.name);
             }
-            recordFrames(data.meshes.map((m) => m.name));
+            // setSubGeometry reset every delivered mesh's matrix, so each one gets
+            // its display pose now, after its geometry landed: a canonical mesh
+            // place() at the live params, a posed one a cleared matrix. `fresh`:
+            // an untrusted live place() here clears the pose but keeps the stamp
+            // (host and worker probes agree by construction at these params;
+            // forgetting on a disagreement would rebuild at the same params forever).
+            fastPath.apply(data.meshes.map((m) => m.name), undefined, { fresh: true });
+            recordFrames(data.meshes);
             // 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).
@@ -1098,7 +1126,7 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
               const tris = viewSubParts(part, view(), params).reduce((s, n) => s + viewer.subTriangles(n), 0);
               console.debug(`partforge: built ${tris.toLocaleString()} triangles in ${(data.ms / 1000).toFixed(1)} s`);
             }
-            dbg?.update({ ms: data.ms, hits: data.cache?.hits ?? 0, misses: data.cache?.misses ?? 0, skipped: lastGen.skipped, rebuilt: lastGen.rebuilt, posed: lastGen.posed });
+            dbg?.update({ ms: data.ms, hits: data.cache?.hits ?? 0, misses: data.cache?.misses ?? 0, skipped: lastGen.skipped, rebuilt: lastGen.rebuilt, posed: lastGen.posed, frame: frameSummary() });
             onBuild?.({ status: "success", ms: data.ms });
             // ready/autoplay wait for the WHOLE view: a split dispatch delivers in
             // two replies, and a host acting on `ready` (screenshotting, measuring)
@@ -1129,7 +1157,12 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
               fastPath.forget(m.name);
               cache.forget(m.name); // the stamp described the last FRESH delivery; this mesh was built at other params, so no stamp may describe it (spec §2)
             }
-            recordFrames(data.meshes.map((m) => m.name));
+            // With the stamps gone the frame comes from the reply: a canonical
+            // mesh is posed by place() at the LIVE params (a rigid place() needs
+            // no geometry at those params), or cleared when the probe is untrusted.
+            fastPath.apply(data.meshes.map((m) => m.name),
+              Object.fromEntries(data.meshes.map((m) => [m.name, m.frame ?? "posed"])));
+            recordFrames(data.meshes);
             ui.hideBusy();
             refreshView();
           }

package/src/framework/pose-fast-path.js

@@ -1,31 +1,104 @@
-// Decision layer of the pose fast path (no DOM, no three.js — viewer/cache are
-// injected). At mesh delivery each subpart is STAMPED with its probe result at
-// the delivered params; on a later edit, a stale subpart whose baseHash is
-// unchanged gets its delivered mesh re-posed in the viewer (delta vs. the
-// delivered pose) and is re-stamped current — no worker job. Everything else
-// falls through to the normal regen loop.
+// The pose ladder: the decision layer that poses delivered meshes in the viewer
+// without a worker job (no DOM, no three.js — viewer/cache are injected). Every
+// matrix it applies is ABSOLUTE relative to the delivered mesh, so nothing
+// accumulates across frames and setSubGeometry's matrix reset stays correct.
+//
+// A mesh's delivery frame (the mesh cache's stamp, spec §3–4) picks the rung:
+// The applied matrix is place(now) · delta (canonical) or delta (posed), where
+// delta is the stamp's stored build/full delta: identity at every delivery (and
+// after forget), set only by a rung-2 or posed repair. Storing it is what keeps a
+// later rung-1 pose or apply() (an unrelated param, a view switch) from snapping
+// a delta-repaired mesh back to its delivered pose while the cache says current.
+//
+// - canonical + current — rung 1: posed by place() at the live params
+//   (place-scope probe) over the stored delta. An untrusted live place() clears
+//   the pose and forgets the cache stamp so the regen loop rebuilds it (posed, at
+//   those params) — except on mount's fresh-delivery apply ({ fresh: true }),
+//   where the mesh was just built at these params: there the pose is cleared and
+//   the stamp kept, so a host/worker probe disagreement cannot loop
+//   forget→rebuild. A matrix equal to the one last applied is never re-sent to
+//   the viewer (setSubPose restarts the contact shadow), and repair() reports a
+//   rung-1 name only when its matrix actually CHANGED, so the debug `posed`
+//   count ("produced a pose and no job") stays honest during playback: a
+//   sub-part whose place() ignores the animated param is not counted.
+// - canonical + stale — rung 2: a trailing transform INSIDE build. When the live
+//   build-scope probe is trusted with the delivered baseHash, the delta becomes
+//   delta(build now, build delivered), the matrix place(now) · delta, and the
+//   mesh is re-stamped with the build's reads alone (place() reads are rung 1's).
+//   An untrusted live place() refuses the rung (Ruling F): the regen loop rebuilds.
+// - posed (the worker baked place() in): today's full-scope delta; apply()
+//   re-applies the stored delta.
+// Anything else falls through to the normal regen loop.
 import { viewSubParts } from "./part-model.js";
 import { probePoses } from "./pose-probe.js";
-import { poseDelta } from "./geometry/pose.js";
+import { composePose, poseDelta, mulMat4 } from "./geometry/pose.js";
 
 export function createPoseFastPath(part, viewer, cache, { params, getView, getParamsVersion }) {
-  const stamps = {}; // name -> probe entry captured when that subpart's mesh was delivered
+  // name -> { frame, entry, delta }: the delivery frame; at the delivered params,
+  // the build-scope probe entry (canonical — rung 2's baseline) or the
+  // full-scope one (posed); and the delta the last repair applied (null =
+  // identity, as delivered).
+  const stamps = {};
 
-  // Memoize the probe per (paramsVersion, view), so it runs once per change
-  // rather than per sub-part; params is the live in-place-mutated object.
-  let probeKey = null, probeMap = null;
-  const probeFor = () => {
+  // Three probe maps memoized per (paramsVersion, view), each computed lazily on
+  // first use — a part with no canonical sub-parts never runs the place or build
+  // probe, and vice versa. params is the live in-place-mutated object.
+  let probeKey = null, probeMaps = {};
+  const probe = (scope) => {
     const key = `${getParamsVersion()}|${getView()}`;
-    if (probeKey !== key) { probeKey = key; probeMap = probePoses(part, getView(), params); }
-    return probeMap;
+    if (probeKey !== key) { probeKey = key; probeMaps = {}; }
+    return (probeMaps[scope] ??= probePoses(part, getView(), params, { scope }));
   };
 
+  // The matrix this module last applied per name (null = cleared, absent =
+  // never applied: unknown). An unchanged matrix never reaches the viewer:
+  // setSubPose bumps the match generation and restarts the realistic contact
+  // shadow, and rung 1 re-poses every current canonical sub-part on every param
+  // change. recordDelivered/forget set null because setSubGeometry reset the
+  // matrix, so a delivery's first non-identity pose always lands. Returns true
+  // only when a non-null matrix actually changed (repair's rung-1 count).
+  const shown = {};
+  const same = (a, b) => a === b || (a != null && b != null && a.every((v, i) => v === b[i]));
+  const setPose = (name, m) => {
+    if (name in shown && same(shown[name], m)) return false;
+    shown[name] = m;
+    viewer.setSubPose(name, m);
+    return m != null;
+  };
+
+  // Pose each in-view, meshed name from its frame (an override wins over the
+  // cache stamp's — mount's stale-shown branch forgets the stamp first).
+  // `fresh` (mount's fresh-delivery call only): an untrusted live place() clears
+  // the pose but keeps the cache stamp — the mesh was just built at these very
+  // params, so forgetting would rebuild at identical params and disagree again.
+  // Returns the names given a CHANGED place pose (used by repair's count).
+  function poseByFrame(names, frames, { fresh = false } = {}) {
+    const moved = [];
+    const inView = new Set(viewSubParts(part, getView(), params));
+    for (const name of names) {
+      if (!inView.has(name) || !viewer.hasSubMesh(name)) continue;
+      const frame = frames?.[name] ?? cache.frameOf(name);
+      const delta = stamps[name]?.delta ?? null; // no stamp (stale-shown): as delivered
+      if (frame === "posed") { setPose(name, delta); continue; }
+      if (frame !== "canonical") continue; // unknown frame: nothing to say about the mesh
+      const now = probe("place").get(name);
+      if (!now?.trusted) { if (!fresh) cache.forget(name); setPose(name, null); continue; }
+      const place = composePose(now.pose);
+      if (setPose(name, delta ? mulMat4(place, delta) : place)) moved.push(name);
+    }
+    return moved;
+  }
+  const apply = (names, frames, opts) => { poseByFrame(names, frames, opts); };
+
   return {
-    // Stamp a freshly delivered mesh with its probe result at the current params.
-    // (The caller only records on non-stale builds — buildDone() guarantees the
-    // live params are the ones the worker built with.)
+    // Stamp a freshly delivered mesh with its probe baseline at the current
+    // params, by the frame the cache recorded for it. (The caller only records on
+    // non-stale builds — buildDone() guarantees the live params are the ones the
+    // worker built with.)
     recordDelivered(name) {
-      stamps[name] = probeFor().get(name);
+      const frame = cache.frameOf(name) ?? "posed";
+      stamps[name] = { frame, entry: probe(frame === "canonical" ? "build" : "full").get(name), delta: null };
+      shown[name] = null; // setSubGeometry just reset the mesh's matrix
     },
 
     // Drop a subpart's stamp: the mesh in the viewer is no longer known to
@@ -37,28 +110,55 @@ export function createPoseFastPath(part, viewer, cache, { params, getView, getPa
     // apply a delta measured against geometry that is no longer on screen.
     forget(name) {
       delete stamps[name];
+      shown[name] = null; // the shown-unrecorded mesh arrived with its matrix reset
     },
 
-    // Re-pose every visible stale subpart whose base geometry is unchanged.
-    // Returns the NAMES repaired (empty = nothing pose-only to do). Names, not a
-    // count: a slider drag repairs the same subpart on every input event, so only
-    // the caller's set union across a drag is a meaningful "how many were posed".
+    // Pose names right after a delivery or a view switch. See the header.
+    apply,
+
+    // One call per param change. Re-poses every visible current canonical
+    // subpart from place() (rung 1) and every visible stale subpart whose base
+    // geometry is unchanged (rung 2, posed delta). Returns the NAMES that change
+    // posed without a job — rung 2 and posed repairs always, rung 1 only when
+    // its matrix moved (empty = nothing pose-only to do). Names, not a count: a
+    // slider drag poses the same subpart on every input event, so only the
+    // caller's set union across a drag is meaningful.
     repair() {
-      const posed = [];
-      const poses = probeFor();
+      const posed = [], placeOnly = [];
       for (const name of viewSubParts(part, getView(), params)) {
-        if (cache.isCurrent(name) || !viewer.hasSubMesh(name)) continue;
-        const now = poses.get(name), was = stamps[name];
-        if (!now?.trusted || !was?.trusted || now.baseHash !== was.baseHash) continue;
-        viewer.setSubPose(name, poseDelta(now.pose, was.pose));
-        // Same geometry, new pose: the delivered build's reads plus whatever
-        // place() read at THIS pose, re-hashed at the live params (spec §2).
-        // An unknown stamp stays unknown.
+        if (!viewer.hasSubMesh(name)) continue;
+        if (cache.isCurrent(name)) {
+          if (cache.frameOf(name) === "canonical") placeOnly.push(name);
+          continue;
+        }
+        const was = stamps[name];
+        if (!was?.entry?.trusted) continue;
+        let matrix, delta, now;
+        if (was.frame === "canonical") {
+          now = probe("build").get(name);
+          if (!now?.trusted || now.baseHash !== was.entry.baseHash) continue;
+          const place = probe("place").get(name);
+          if (!place?.trusted) continue;
+          delta = poseDelta(now.pose, was.entry.pose);
+          matrix = mulMat4(composePose(place.pose), delta);
+        } else {
+          now = probe("full").get(name);
+          if (!now?.trusted || now.baseHash !== was.entry.baseHash) continue;
+          matrix = delta = poseDelta(now.pose, was.entry.pose);
+        }
+        was.delta = delta;
+        setPose(name, matrix);
+        // Same geometry, new pose: the delivered build's reads plus whatever the
+        // probe read at THIS pose, re-hashed at the live params (spec §2), keeping
+        // the delivery frame. A canonical stamp takes the build-scope probe's
+        // reads only — place() reads stay out, since rung 1 owns them (spec §3:
+        // recorded keys are the build's); a posed one the full scope's. An
+        // unknown stamp stays unknown.
         const had = cache.readsOf(name);
-        cache.record(name, had ? [...had, ...(now.reads ?? [])] : undefined); // current again — regen loop sees nothing missing
+        cache.record(name, had ? [...had, ...(now.reads ?? [])] : undefined, getView(), was.frame); // current again — regen loop sees nothing missing
         posed.push(name);
       }
-      return posed;
+      return [...poseByFrame(placeOnly), ...posed];
     },
   };
 }

package/src/framework/pose-probe-core.js

@@ -5,7 +5,9 @@
 // are never compared to backend hashes, so they only need to be stable and to
 // fold every geometry-affecting argument.
 //
-// Trust model: any query op (boundingBox/volume/…) during a build marks that
+// Trust model (applies PER SCOPE — "full" = build+place, "build" = build alone,
+// "place" = place() alone on a canonical token whose rigidity test is its hash
+// staying CANONICAL): any query op (boundingBox/volume/…) during a build marks that
 // subpart untrusted — a query result could feed geometry OR pose, and the probe
 // returns dummies, so neither hash stability nor pose values can be believed.
 // A FUNCTION passed as (or nested inside) an op argument is untrusted for the
@@ -19,6 +21,9 @@ import { addSugar } from "./geometry/solid-sugar.js";
 import { SOLID_OPS, SOLID_OPTIONAL_OPS, SHAPE2D_OPS, OCCT_ONLY_OPS } from "./geometry/kernel.js";
 import { MAX_PROBE_OPS, ProbeRunawayError } from "./geometry/probe.js";
 
+// The fixed hash a place-scope probe starts from; a rigid place() leaves it unchanged.
+export const CANONICAL = h("canonical");
+
 const NAN3 = () => [NaN, NaN, NaN];
 
 function makeProbeSession() {
@@ -102,7 +107,7 @@ function makeProbeSession() {
     },
   });
 
-  return { kernel, state };
+  return { kernel, state, token };
 }
 
 const finiteVec = (v) => Array.isArray(v) && v.length === 3 && v.every(Number.isFinite);
@@ -111,16 +116,26 @@ const stepsFinite = (steps) => steps.every((st) =>
     ? finiteVec(st.v)
     : Number.isFinite(st.deg) && finiteVec(st.center) && finiteVec(st.axis));
 
-// Probe ONE sub-part's build+place at explicit params/purpose. The shared
-// primitive under probePoses (pose-probe.js) and the lint place/animation
-// rules — kept free of jobs.js imports so the lint import closure stays pure
-// (test/lint-purity.test.js). Never throws; a failing/queried/weird sub-part
-// yields { trusted: false }.
-export function probeSubPartPose(sp, { view, purpose = "display", p, d }) {
+// Probe ONE sub-part at explicit params/purpose. The shared primitive under
+// probePoses (pose-probe.js) and the lint place/animation rules — kept free of
+// jobs.js imports so the lint import closure stays pure (test/lint-purity.test.js).
+// Never throws; a failing/queried/weird sub-part yields { trusted: false }.
+// scope: "full" (build then place), "build" (build only), "place" (place() on a
+// canonical token; no build runs, so a querying build is irrelevant). In place
+// scope a readable but reshaping place() (scale/mirror/union) returns
+// { trusted: false, baseHash, pose } with baseHash !== CANONICAL — see Ruling A.
+export function probeSubPartPose(sp, { view, purpose = "display", p, d }, { scope = "full" } = {}) {
   try {
-    const { kernel, state } = makeProbeSession(); // fresh op budget + trust per subpart
+    const { kernel, state, token } = makeProbeSession(); // fresh op budget + trust per subpart
+    if (scope === "place") {
+      let s = token(CANONICAL, []);
+      if (!sp.place) return { trusted: true, baseHash: CANONICAL, pose: [] };
+      s = sp.place(s, { view, purpose, p, d });
+      if (!(s && s.__poseToken) || state.queried || state.unhashable || !stepsFinite(s._pose)) return { trusted: false };
+      return { trusted: s._hash === CANONICAL, baseHash: s._hash, pose: s._pose };
+    }
     let s = sp.build(kernel, p, d);
-    if (sp.place) s = sp.place(s, { view, purpose, p, d });
+    if (scope === "full" && sp.place) s = sp.place(s, { view, purpose, p, d });
     const ok = s && s.__poseToken && !state.queried && !state.unhashable && stepsFinite(s._pose);
     return ok ? { trusted: true, baseHash: s._hash, pose: s._pose } : { trusted: false };
   } catch {

package/src/framework/pose-probe.js

@@ -27,7 +27,7 @@ function assetSources(part, p) {
 
 // Probe every subpart the view shows. Never throws; a failing/queried/weird
 // subpart yields { trusted: false } and the others still probe.
-export function probePoses(part, view, params) {
+export function probePoses(part, view, params, { scope = "full", purpose = "display" } = {}) {
   const out = new Map();
   let resolved, assets;
   try {
@@ -41,9 +41,11 @@ export function probePoses(part, view, params) {
     const sink = newReadSink();
     sink.attribution = resolved.attribution;
     const rec = recordedParams(resolved, sink);
-    const entry = probeSubPartPose(part.parts[name], { view, purpose: "display", p: rec.p, d: rec.d });
+    const entry = probeSubPartPose(part.parts[name], { view, purpose, p: rec.p, d: rec.d }, { scope });
+    // Assets fold in only outside place scope: a place probe hashes nothing
+    // geometry-dependent, and the mesh cache's asset reads cover the font case.
     out.set(name, entry.trusted
-      ? { ...entry, baseHash: h("with-assets", entry.baseHash, assets), reads: expandReads(sink) }
+      ? { ...entry, baseHash: scope === "place" ? entry.baseHash : h("with-assets", entry.baseHash, assets), reads: expandReads(sink) }
       : entry);
   }
   return out;