partforge 0.139.0 → 0.141.0

package/src/framework/mesh-cache.js

@@ -1,41 +1,40 @@
-import { subPartReadKeys, relevanceHash, RELEVANT_ALL } from "./param-deps.js";
+import { relevanceHash } from "./param-deps.js";
 
-// Tracks whether each sub-part's cached display mesh is still valid for the current
-// params ("Layer 1" of the cache — skipping regeneration of sub-parts whose inputs
-// didn't change). A sub-part's mesh is stamped with a relevance hash over just the
-// params that sub-part reads; it's current while that hash is unchanged and the mesh
-// is still in the viewer.
-//
-// The view/paramsVersion/caching state lives in mount and changes over time, so it's
-// passed as getters. `params` is a stable object mutated in place, so it's passed by
-// reference.
-export function createMeshCache(part, viewer, { params, getView, getParamsVersion, isCaching }) {
-  const cacheHash = {}; // name -> relevance hash the cached mesh was built at
+// Whether each sub-part's cached display mesh is still valid ("Layer 1": skip
+// regenerating sub-parts whose inputs didn't change). Each delivered mesh is
+// stamped with the params its REAL build read (recorded in the worker, jobs.js),
+// their values, and the view it was built for. It stays current while those are
+// unchanged — sound for a deterministic build: unchanged reads replay the same
+// 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, frame: "canonical" | "posed" }
 
-  // Memoize the per-sub-part read-key map per (paramsVersion, view): subPartReadKeys
-  // runs probe builds, so we compute it once per change, not per sub-part.
-  let readsKey = null, readsMap = null;
-  const readsFor = () => {
-    const key = `${getParamsVersion()}|${getView()}`;
-    if (readsKey !== key) { readsKey = key; readsMap = subPartReadKeys(part, getView(), params); }
-    return readsMap;
-  };
-
-  // The relevance hash for one sub-part at the current params (RELEVANT_ALL → hash
-  // over ALL params, so any edit invalidates it — the safe fallback).
-  const hashFor = (name) => {
-    if (!isCaching()) return `v${getParamsVersion()}`; // caching off: any edit invalidates every sub-part
-    const reads = readsFor();
-    const keys = reads === RELEVANT_ALL ? Object.keys(params) : [...(reads.get(name) ?? Object.keys(params))];
-    return relevanceHash(keys, params);
+  const hashOf = (keys) => {
+    if (!isCaching()) return `v${getParamsVersion()}`; // caching off: any edit invalidates
+    return relevanceHash(keys ?? Object.keys(params), params);
   };
 
   return {
-    // A cached sub-part is current only if its relevance hash is unchanged.
-    isCurrent: (name) => viewer.hasSubMesh(name) && cacheHash[name] === hashFor(name),
-    // Stamp a freshly built mesh with the hash it was built at.
-    record: (name) => { cacheHash[name] = hashFor(name); },
-    // Drop a sub-part's stamp so it rebuilds next generate.
-    forget: (name) => { delete cacheHash[name]; },
+    isCurrent: (name) => {
+      const s = stamps[name];
+      return viewer.hasSubMesh(name) && s != null && s.view === getView() && s.hash === hashOf(s.keys);
+    },
+    // Stamp a mesh built at the LIVE params (mount's fresh branch, or the pose
+    // 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.
+    // `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, 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

@@ -15,7 +15,7 @@ import { declaresMaterials, resolveMaterial } from "./materials/resolve.js";
 import { printFrameMatrix } from "./materials/print-frame.js";
 import { burnsFor, realisticDisplay, sheetFrameFor } from "./materials/sheet-look.js";
 import { buildControls } from "./controls.js";
-import { relevantParamKeys } from "./param-deps.js";
+import { recordedRelevantKeys, subPartParamKeys } from "./param-deps.js";
 import { createMeshCache } from "./mesh-cache.js";
 import { createGeometryService } from "./geometry-service.js";
 import { viewSubParts, resolveParams } from "./part-model.js";
@@ -69,7 +69,7 @@ const IMPORT_MESH_BROKEN_MESSAGE = "STEP import tessellation failed to satisfy t
 // carries the worker's own error text. See the correlated "error" case below.
 const importTessellateFailedMessage = (workerMessage) => `STEP import tessellation failed — ${workerMessage}`;
 
-export function makeHandle({ ready, dispose, viewer, setParams, listExportableParts, listExportFormats, exportParts, warmExportKernel, setHostPane, setRailLayout, animation, getView, setView, captureView, attachTooltips, measure, annotate, projection, pickMarker, getPanelState, getPanelErrors, renderMode, environment, declaresMaterials, renderViews }) {
+export function makeHandle({ ready, dispose, viewer, setParams, listExportableParts, listExportFormats, exportParts, warmExportKernel, setHostPane, setRailLayout, animation, getView, setView, captureView, attachTooltips, measure, annotate, projection, pickMarker, getPanelState, getPanelErrors, controlsFor, renderMode, environment, declaresMaterials, renderViews }) {
   return {
     ready, dispose, setParams,
     // Part-declared animation playback (spec 2026-08-02): animations are
@@ -129,6 +129,7 @@ export function makeHandle({ ready, dispose, viewer, setParams, listExportablePa
     // it back as mount()'s `panelState` and a remount comes up with the same
     // tile selected. {} when the mount resolved no panel.
     getPanelState: getPanelState ?? (() => ({})),
+    controlsFor: controlsFor ?? (() => []),
     // What custom controls reported failing this mount ({key, label, phase,
     // message}), for a host to relay to whoever authored the part.
     getPanelErrors: getPanelErrors ?? (() => []),
@@ -241,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
@@ -575,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);
       },
     });
@@ -589,15 +594,13 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
     // Measurement mode: in-scene dims + pins + dimension->controls reveal
     // (clicking a measurement flashes every control that can drive it). The
     // panel is built later in this function, so revealParams is a late-bound
-    // thunk — same idiom for getParamsVersion, which needs `loop` (created
-    // further below); readsFor's memo keys on it instead of hashing the whole
-    // params object per call, mirroring createMeshCache/createPoseFastPath.
+    // thunk. getReads reads the mesh cache (created further below) lazily.
     let panelRef = null;
     const measureMode = createMeasureMode(viewer, {
       part,
       getContext: () => ({ view: view(), params }),
       revealParams: (keys, focusKey) => panelRef?.revealParams(keys, focusKey),
-      getParamsVersion: () => loop.version(),
+      getReads: (name) => displayReadsOf(name),
     });
     cleanup.defer(() => measureMode.detach());
     // Annotation mode (spec 2026-08-18): freehand ink over the frozen view,
@@ -794,7 +797,7 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
       let derived = {};
       // A throwing derive must not crash the pick flow — proceed without derived context.
       try { derived = resolveDerived(part, { ...part.defaults, ...params }); } catch { /* derived stays {} */ }
-      return { view: view(), params, derived };
+      return { view: view(), params, derived, readsOf: (name) => displayReadsOf(name) };
     };
 
     // Click-to-select. Precedence (one click listener is ever live): the programmatic
@@ -850,13 +853,19 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
 
     // Per-sub-part cache-validity tracker (Layer 1): view/version/caching change over
     // time, so they're passed as getters; params is a stable in-place-mutated object.
-    const cache = createMeshCache(part, viewer, {
+    const cache = createMeshCache(viewer, {
       params,
       getView: view,
       getParamsVersion: () => loop.version(),
       isCaching: () => cachingOn,
     });
     const isCurrent = cache.isCurrent;
+    // Recorded reads for DISPLAY consumers (panel dimming, pickers, measure,
+    // controlsFor). A mesh the cache stamped every-param (its reply carried no
+    // reads) answers every param key, so the ladder never falls back to the
+    // probe for it; only a sub-part with no stamp at all gets the prediction.
+    // (cache.readsOf itself keeps null for both — the pose fast path needs that.)
+    const displayReadsOf = (name) => cache.readsOf(name) ?? (cache.hasStamp(name) ? new Set(Object.keys(params)) : null);
     const missingParts = () => viewSubParts(part, view(), params).filter((n) => !isCurrent(n));
 
     // The regenerate state machine (ready gating / debounce / stale-redo) lives in
@@ -871,6 +880,7 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
     // live ones have already left (see recordFrames). One cycle is in flight at a time,
     // so a sub-part's entry is its in-flight job's until the cycle's last reply.
     const dispatched = new Map(); // sub-part -> { view, params } its latest job was sent with
+    let updateRelevance = () => {}; // assigned once the panel exists; message handlers call it
     const loop = createRegenLoop({
       missingParts,
       send: (missing) => {
@@ -900,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).
@@ -984,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
         }
@@ -1003,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];
         }
       }
@@ -1062,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);
+              // 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
@@ -1075,12 +1102,20 @@ 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).
             if (missingParts().length === 0) ui.hideBusy();
             refreshView();
+            updateRelevance(); // dimming follows each delivery's recorded reads
             // After refreshView, like the error case: its all-current branch
             // clears the status line, and this message has to outlive that.
             if (missingParts().length === 0) {
@@ -1091,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)
@@ -1120,8 +1155,14 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
             for (const m of data.meshes) {
               viewer.setSubGeometry(m.name, m);
               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();
           }
@@ -1249,13 +1290,13 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
         files, panelState });
     cleanup.defer(() => panel.dispose());
     panelRef = panel;
-    const updateRelevance = () => {
+    updateRelevance = () => {
       // A throwing derive() must not break every slider drag — mount's pick
       // flow already guards its own resolveDerived call the same way
       // (mount.js ~:250). Readouts simply stay em-dashed.
       let derived = {};
       try { derived = resolveDerived(part, params); } catch { /* diagnosed by lint/build */ }
-      panel.refresh({ relevant: relevantParamKeys(part, view(), params), derived });
+      panel.refresh({ relevant: recordedRelevantKeys(part, view(), params, displayReadsOf), derived });
     };
     updateRelevance(); // initial view
 
@@ -1426,6 +1467,9 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
       captureView,
       getPanelState: () => panelRef?.getState() ?? {},
       getPanelErrors: () => panelRef?.errors() ?? [],
+      // The param keys relevant to a pick — today the clicked sub-part's recorded
+      // reads (spec §5). The one place a host asks "which controls shape this?".
+      controlsFor: (selection) => subPartParamKeys(part, view(), params, displayReadsOf, selection?.subPart),
       // A sheet part's row carries its stock, evaluated here on the main thread at the
       // live params the way enabled() is, and omitted when it cannot be (export-rows.js).
       listExportableParts: () => exportableRows(part, params),

package/src/framework/oracle/build.js

@@ -5,8 +5,8 @@ import { viewSubParts, resolveParams, buildPosed } from "../part-model.js";
 // `generate` path in jobs.js, but keeps solids LIVE (does NOT call
 // kernel.cleanup()) so callers can read exact solid facts (volume/genus/empty)
 // before they free the kernel. Meshes are JS-owned arrays and survive cleanup.
-export function buildView(kernel, part, view, params = {}) {
-  const { p, d } = resolveParams(part, params);
+export function buildView(kernel, part, view, params = {}, { reads } = {}) {
+  const { p, d } = resolveParams(part, params, undefined, reads);
   // Cache round for the whole view. The name is the ORACLE's, deliberately not the
   // display sub-part names the generate path brackets under: a distinct partition
   // still reuses those solids (the cache indexes entries by content hash across

package/src/framework/oracle/gates.js

@@ -87,12 +87,12 @@ export function partHasBed(part, { process } = {}) {
 // spec and already lets that throw surface from `verify()` — reporting it a second
 // time here, mid-measure, would be a confusing duplicate. Swallow it and answer "no
 // bands", the same as a part that declares none.
-export function partWallBands(part, params = {}) {
+export function partWallBands(part, params = {}, reads) {
   const spec = part?.verify?.expect;
   if (!spec) return {};
   let expect;
   if (typeof spec === "function") {
-    const { p, d } = resolveParams(part, params);
+    const { p, d } = resolveParams(part, params, undefined, reads);
     try { expect = spec(p, d) ?? {}; } catch { return {}; }
   } else {
     expect = spec;

package/src/framework/oracle/measure.js

@@ -2,6 +2,7 @@ import { buildView } from "./build.js";
 import { cachedBVH } from "./bvh.js";
 import { assemblyOverlaps } from "../assembly.js";
 import { resolveParams, buildPosed } from "../part-model.js";
+import { newReadSink, expandReads } from "../read-recorder.js";
 import { probeSubPartPose } from "../pose-probe-core.js";
 import { composePose } from "../geometry/pose.js";
 import { isSheetPart, sheetMeta, SHEET_CHECK_BUDGET_MS, MARK_DEPTH } from "../sheet/constants.js";
@@ -95,8 +96,8 @@ function resolveProbeValue(v, depth = 0) {
 // Evaluate every declared probe with resolved (p, d). Reads all solid facts
 // eagerly, so the caller may free the kernel's objects afterwards. Never
 // throws: each probe's failure is its own `{ error }` entry.
-function evaluateProbes(kernel, part, params) {
-  const { p, d } = resolveParams(part, params);
+function evaluateProbes(kernel, part, params, reads) {
+  const { p, d } = resolveParams(part, params, undefined, reads);
   // Oracle-owned cache round, same reasoning as buildView's: probe geometry must
   // not evict what the viewer is showing, and the next round evicts this one.
   kernel.beginSubPart?.("oracle:probes");
@@ -220,7 +221,14 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // needs those meshes anyway — it rasterizes them for silhouette match scoring —
   // and a second buildView here would be a whole duplicate build of the part for
   // nothing. Absent, this measures its own build exactly as it always did.
-  const built = opts.built ?? buildView(kernel, part, view, params);
+  // Every param this measurement depends on (spec §4): one sink through every
+  // place it resolves params. A caller-supplied view (`opts.built`) is only
+  // covered when the caller recorded its build into the same sink (opts.reads);
+  // otherwise the result claims no reads and verify reuses it only on identical
+  // params.
+  const reads = opts.reads ?? newReadSink();
+  const readsKnown = !opts.built || !!opts.reads;
+  const built = opts.built ?? buildView(kernel, part, view, params, { reads });
   // ONE BVH per sub-part mesh for this call, shared by the two passes that need
   // one: min-wall (inward rays per triangle) and meshGaps (pair distances). They
   // used to index the same mesh objects independently, so every sub-part of a
@@ -242,7 +250,7 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   const minWallSamples = partGatesMinWall(part) ? undefined : DIAGNOSTIC_SAMPLES;
   // Declared wall bands, per sub-part, for exactly these params (Task 5). Resolved
   // once per measure; a bad declaration throws here, which is a measure error.
-  const wallBands = opts.minWall ? partWallBands(part, params) : {};
+  const wallBands = opts.minWall ? partWallBands(part, params, reads) : {};
   // Overhang is measured only for a part that opted in (dfm-profiles.js
   // overhangAngleFor) — everything else reads null. verify hands the angle it
   // resolved in (a `process` override changes it); `null` there is an explicit
@@ -259,7 +267,7 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // row's min-wall rays between two sheets spend it (the verdict used to depend on
   // declaration order). A view without a sheet part measures exactly as it always has.
   const sheetView = built.some(({ name }) => isSheetPart(part.parts[name]));
-  const sheetParams = sheetView ? resolveParams(part, params) : null;
+  const sheetParams = sheetView ? resolveParams(part, params, undefined, reads) : null;
   // The print-pose sizes are read by one check, the process bed (verify passes whether
   // its profile has one; alone, measure asks the part's own profile), and each costs a
   // second build of the part — so they are built only for a bed.
@@ -353,7 +361,7 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // false` skips them: verify's per-case re-measures pass it because no gate
   // reads probe values, so re-running their booleans per case buys nothing.
   const probes = opts.probes !== false && part.probes && Object.keys(part.probes).length
-    ? evaluateProbes(kernel, part, params)
+    ? evaluateProbes(kernel, part, params, reads)
     : undefined;
 
   // Pair surface distances from the meshes already built — no kernel dependency,
@@ -371,7 +379,7 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // Rebuilds with the same kernel and cleans up at its end — every solid fact
   // above is already read, so this is safe.
   const canIntersect = built.length > 0 && typeof built[0].solid.intersect === "function";
-  const overlaps = canIntersect ? assemblyOverlaps(kernel, part, view, params) : [];
+  const overlaps = canIntersect ? assemblyOverlaps(kernel, part, view, params, { reads }) : [];
   kernel.cleanup?.();
 
   const overlapping = new Set(overlaps.map((o) => pairKey(o.a, o.b)));
@@ -403,6 +411,8 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
     // nothing measured it, which reads identically to "no reading available";
     // verify's seeding rule turns on exactly this distinction (see verify.js).
     measuredMinWall: !!opts.minWall,
+    // Params this measurement read (undefined = unknown: a caller-built view).
+    reads: readsKnown ? expandReads(reads) : undefined,
     // The overhang angle every sub-part's `overhangArea` was measured against,
     // or null when the pass did not run — read by verify's seed gate, never a
     // caller's claim.

package/src/framework/oracle/verify.js

@@ -3,8 +3,7 @@ import { measure as defaultMeasure } from "./measure.js";
 import { pairKey, CONTACT_EPS } from "./gaps.js";
 import { resolveProfile, overhangAngleFor } from "./dfm-profiles.js";
 import { expandExpectations, partGatesMinWall } from "./gates.js";
-import { subPartReadKeys, relevanceHash, RELEVANT_ALL } from "../param-deps.js";
-import { byteAwareReplacer } from "../geometry/solid-hash.js";
+import { relevanceHash } from "../param-deps.js";
 import { SUBPART_METRICS, VIEW_METRICS } from "../verify-metrics.js";
 import { processById } from "../process/registry.js";
 import { SHEET_DOC_ID, SHEET_CHECKS_NOTICE, SHEET_READ_ERROR_HINT } from "../sheet/constants.js";
@@ -338,17 +337,20 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   const needMinWall = partGatesMinWall(part, { process, expanded });
   // Throws on a bad `verify.orientation`, the same loudness as a bad profile name.
   const overhangAngle = overhangAngleFor(part, process, { expanded });
-  const readKeys = subPartReadKeys(part, view, part.defaults);
-  // byteAwareReplacer on the RELEVANT_ALL branch too: an unattributable derive()
-  // still might read a byte-valued image param, and this memo key gates whether
-  // a case's geometry gets rebuilt or an earlier result reused (see the seeding
-  // block below) — the same collision the relevanceHash branch guards against.
-  const signature = (params) =>
-    readKeys === RELEVANT_ALL
-      ? JSON.stringify(params, byteAwareReplacer)
-      : [...readKeys.entries()].map(([name, keys]) => `${name}:${relevanceHash([...keys], params)}`).join("|");
-
-  const memo = new Map();
+  // Reuse rule (spec §4): case B may reuse a measurement taken at params A when
+  // B agrees with A on every param that measurement READ (recorded by measure()
+  // itself). Sound for the same reason the mesh cache is: a deterministic build
+  // whose reads are unchanged replays the same path. A result with no recorded
+  // reads (a stub measureFn, or a caller-built view) is reused on identical
+  // params only.
+  const full = (params) => ({ ...part.defaults, ...(params ?? {}) });
+  const entries = []; // { params: full params, result }
+  const findEntry = (params) => entries.find((e) => {
+    // A key the entry was never measured with can't be judged by its reads.
+    if (Object.keys(params).some((k) => !(k in e.params))) return false;
+    const keys = e.result?.reads ?? Object.keys({ ...e.params, ...params });
+    return relevanceHash(keys, params) === relevanceHash(keys, e.params);
+  });
 
   // SEEDING. expandCases always yields a "defaults" case, and the inspect job
   // (framework/jobs.js) measures those exact params immediately before calling
@@ -377,10 +379,9 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   // mutates facts (evaluateCase only reads), and that is what makes the sharing
   // safe; a future check that wants to annotate a fact must copy first.
   //
-  // Keyed through the SAME signature() the memo uses, never a JSON compare of the
-  // raw params — a separate compare would miss cases that share a signature (a
-  // preset touching only params the build never reads) and, worse, could hit on
-  // params that merely look equal. The seed's params are layered over
+  // Matched through the SAME reads rule every case uses, never a JSON compare of the
+  // raw params — a separate compare would miss cases that agree on everything the
+  // measurement read (a preset touching only unread params). The seed's params are layered over
   // part.defaults first because a caller's `{}` and the defaults case's
   // `{...part.defaults}` build identical geometry but hash differently
   // (JSON.stringify({}) is not JSON.stringify(defaults), and relevanceHash reads
@@ -405,19 +406,21 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   const printBboxesMatch = !needPrintBboxes || seed?.result?.measuredPrintBboxes !== false;
   if (seed?.result && (quick || seed.result.measuredMinWall || !needMinWall) && (quick || overhangMatches) && printBboxesMatch
     && seed.result.view === view) {
-    memo.set(signature({ ...part.defaults, ...(seed.params ?? {}) }), seed.result);
+    entries.push({ params: full(seed.params), result: seed.result });
   }
 
   const measureCase = (params) => {
-    const key = signature(params);
-    if (memo.has(key)) return memo.get(key);
+    const fp = full(params);
+    const hit = findEntry(fp);
+    if (hit) return hit.result;
     if (quick) return null;   // a case the seed does not cover — reported, never built
     // `probes: false` — no gate reads probe values, so re-running their booleans
     // for every case buys nothing. (A seed measured WITH probes is a superset in
     // the same way a min-wall seed is: the extra key is simply never read here.)
-    memo.set(key, measureFn(kernel, part, view, params,
-      { minWall: needMinWall, probes: false, overhang: overhangAngle, printBboxes: needPrintBboxes }));
-    return memo.get(key);
+    const result = measureFn(kernel, part, view, params,
+      { minWall: needMinWall, probes: false, overhang: overhangAngle, printBboxes: needPrintBboxes });
+    entries.push({ params: fp, result });
+    return result;
   };
 
   const subPartNames = Object.keys(part.parts);