partforge 0.71.0 → 0.73.0

package/src/framework/camera-tween.js

@@ -1,18 +1,30 @@
 import * as THREE from "three";
 import { EASINGS } from "./animation.js";
 
-// Retargetable orbit-camera tween for animation camera cues: eased spherical
-// interpolation of {position, target} pairs about the (linearly moving) orbit
-// target, shortest-path in azimuth, clamped off the poles so OrbitControls
-// never gimbal-locks on a "top"/"bottom" cue. Pure math, no clock — the viewer
-// feeds dt seconds into update() each frame and applies the returned pose.
-const POLE_EPS = 0.01;
-
+// Retargetable orbit-camera tween for animation camera cues and view-cube
+// clicks: eased spherical interpolation of {position, target} pairs about the
+// (linearly moving) orbit target, shortest-path in azimuth. Pure math, no clock
+// — the viewer feeds dt seconds into update() each frame and applies the
+// returned pose.
+//
+// NOT clamped off the poles. It used to be, by 0.01 rad, to keep OrbitControls
+// off its gimbal — but the clamp applied to the DESTINATION too, so a "top" or
+// "bottom" cue landed 0.573° short of the axis every single time, in both
+// projections. That is the whole of the "clicking top doesn't view from the top"
+// bug: a spacer kept a sliver of side wall visible instead of reading as a flat
+// outline.
+//
+// Landing exactly on the pole is safe, because OrbitControls' own update() is
+// the backstop: Spherical.makeSafe() holds phi off 0 and PI by 1e-6 rad (a
+// 5.7e-5° tilt, three orders of magnitude under what the eye or a frustum can
+// resolve), so the camera is never left with a degenerate lookAt basis and the
+// roll stays deterministic. Azimuth at the pole is a no-op either way, and
+// atan2(0, 0) is 0 rather than NaN — which is also the azimuth the canonical
+// top/bottom poses ask for, so the roll OrbitControls derives there is exactly
+// the `up` view-angles.js names for them.
 function toSpherical(position, target) {
   const off = new THREE.Vector3().fromArray(position).sub(new THREE.Vector3().fromArray(target));
-  const sph = new THREE.Spherical().setFromVector3(off);
-  sph.phi = Math.min(Math.PI - POLE_EPS, Math.max(POLE_EPS, sph.phi));
-  return sph;
+  return new THREE.Spherical().setFromVector3(off);
 }
 
 export function createCameraTween() {

package/src/framework/chrome.css

@@ -225,9 +225,119 @@
    (background/border/radius/shadow) from app.css, so that chrome must live in
    app.css ungated — not be duplicated into a class the cloud never sets. This
    file owns where things sit; app.css owns what they look like. */
-.pf-float-tabs, .pf-float-viewbar { position: absolute; z-index: 15; }
-.pf-float-tabs { top: 12px; left: 50%; transform: translateX(-50%); }
-.pf-float-viewbar { bottom: 12px; right: 12px; }
+.pf-float-tabs, .pf-float-viewbar, .pf-float-rail-toggle { position: absolute; z-index: 15; }
+/* Every inset below is SHARED with whichever other float sits on that edge, so
+   the stage's margin is stated once per edge and not once per element. The rail
+   toggle (2026-08-20: out of #viewbar's pill, floating on its own at the top
+   right) is the tab strip's `top` with the viewbar's `right` — a corner
+   symmetric with the viewbar's, by construction rather than by two numbers that
+   happen to agree today. Retune the margin and all three corners follow.
+   Appearance, including the `[hidden]` guard that lets rail.js hide the toggle
+   below the narrow breakpoint, is in app.css. */
+.pf-float-tabs, .pf-float-rail-toggle { top: 12px; }
+.pf-float-viewbar, .pf-float-rail-toggle { right: 12px; }
+.pf-float-tabs { left: 50%; transform: translateX(-50%); }
+.pf-float-viewbar { bottom: 12px; }
+
+/* ---- view cube stack: PLACEMENT ONLY (see the rule above) ----------------
+   Bottom-right, stacked above #viewbar. The offset is measured, not
+   hardcoded: mount.js publishes --pf-viewbar-clear on the stage from a
+   ResizeObserver on #viewbar, mirroring --pf-anim-clear. It sits there rather
+   than in viewcube-controls.js (the precedent being animation-controls.js,
+   which publishes its own --pf-anim-clear) because the value describes the
+   VIEWBAR's vertical claim, not the cube's, and mount owns both elements. The
+   56px fallback is the standard viewbar's 12px bottom + 44px height, so the
+   stack still sits right if the observer never fires.
+
+   The projection toggle has moved twice. Through 2026-08-19 it sat in its own
+   `.pf-viewcube-pill` card BELOW the cube, making the stack a column. Earlier
+   on 2026-08-20 it became a bare circle BESIDE the cube, making the stack a
+   `row-reverse` flex row (`canvas + gap + button`, 167px wide at the full
+   135px cube). It now sits OVER the cube's bottom-right corner instead:
+   absolutely positioned within the stack, right edge on the stack's right edge
+   and bottom edge on its bottom baseline, so the stack's width collapses back
+   to the canvas alone (135px, or 101 below the narrow breakpoint).
+
+   That is also what satisfies "aligned with the right of the toolbar" without a
+   second offset: `.pf-float-viewbar` above is `right: 12px` too, so making the
+   button's right edge the STACK's right edge lines it up with the viewbar's by
+   construction — and it keeps doing so if that margin is ever retuned.
+
+   The button is a later sibling than the cube's wrapper, so it paints over the
+   canvas with no z-index of its own; 24px over the corner cell — the least
+   informative part of the drawing — is small enough not to hide anything worth
+   clicking, and the canvas keeps receiving pointer events everywhere else.
+
+   The 8px that used to sit between the stack and the viewbar is now 3px
+   (2026-08-20: "lower the whole box so it's closer to the bottom bar"). 3
+   rather than 0 because the stack's own box MUST NOT overlap #viewbar: the
+   stack is a later sibling at the same z-index, and its canvas is
+   pointer-events:auto across its whole footprint, so any vertical overlap
+   would silently swallow clicks on the viewbar's rightmost buttons (both are
+   right: 12px). --pf-viewbar-clear is published rounded to whole px, so a
+   fractional viewbar height can move this by half a pixel either way; 3px
+   absorbs that and still reads as a deliberate gap rather than a collision.
+   The other ~5px of the lowering comes from inside the canvas — see
+   cube-geom.js's CUBE_DOWN_BIAS_PX; that is where the rest of the perceived
+   gap actually lives, and it is capped by the axis labels' clearance, so
+   this pair (3 + 5) is the whole slack that exists without either overlapping
+   the viewbar or shrinking the cube.
+
+   The stack itself is pointer-transparent. With the button back inside the
+   canvas's footprint there is no dead gap left at all: the stack's box IS the
+   canvas's box, and both the canvas and the button opt back in below. The
+   declaration stays because the stack's own box is still an element over the
+   viewer, and a stray hit on it (its padding-free edges, or a future child
+   before it opts in) should reach the model behind rather than be swallowed. */
+.pf-viewcube-stack {
+  position: absolute;
+  right: 12px;
+  bottom: calc(var(--pf-viewbar-clear, 56px) + 3px);
+  z-index: 15;
+  display: flex;
+  pointer-events: none;
+}
+.pf-viewcube-stack[hidden] { display: none; }
+.pf-viewcube-canvas, .pf-viewcube-toggle { pointer-events: auto; }
+/* Over the cube's bottom-right corner. Absolute against the stack, which is
+   itself absolute and so already the containing block. */
+.pf-viewcube-toggle { position: absolute; right: 0; bottom: 0; }
+
+/* The keyboard surface: six per-view buttons standing in for the DOM focus a
+   canvas cannot give us. Visually hidden rather than display:none — the latter
+   takes them out of the tab order, which is the whole point of them.
+
+   The hiding properties are on the BUTTONS, not on their wrapper, so that
+   :focus-visible can undo them. A non-`none` clip-path clips the element's
+   whole SUBTREE and makes the element a containing block for fixed-position
+   descendants, so with the clip on the wrapper no rule on a focused child
+   could escape it — the reveal below was dead CSS, and six buttons sat in the
+   tab order with no visible focus indicator at all. On the buttons themselves
+   there is no clipping ancestor to get out of.
+
+   The wrapper keeps only `position: absolute`, which takes it out of the
+   stack's flex flow. That mattered when the stack had a gap (a zero-height
+   flex item still earned it, pushing the cube out of place); it still matters
+   now that it does not, because an in-flow second item would widen the stack
+   past the canvas — and the stack's width is what the crowding rule reads. */
+.pf-viewcube-key { position: absolute; }
+.pf-viewcube-key button {
+  position: absolute;
+  width: 1px; height: 1px;
+  margin: -1px; padding: 0;
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: nowrap;
+  border: 0;
+}
+.pf-viewcube-key button:focus-visible {
+  position: fixed;
+  width: auto; height: auto;
+  margin: 0; padding: 2px 6px;
+  overflow: visible;
+  clip-path: none;
+  pointer-events: auto; /* the stack is pointer-transparent; a revealed control is not */
+}
 
 /* --- animation transport bar (generated by animation-controls.js) ----------
    PLACEMENT ONLY, per the rule above; appearance lives in app.css next to

package/src/framework/cutaway-gizmo.js

@@ -44,7 +44,7 @@ const WHITE = new THREE.Color(0xffffff);
 export function createCutawayGizmo({
   scene,
   overlayScene,
-  camera,
+  camera: initialCamera,
   domElement,
   orbitControls,
   onPoseChange = () => {},
@@ -53,6 +53,10 @@ export function createCutawayGizmo({
   onDragChange = () => {},
   pickHandle,
 }) {
+  // Reassignable: the viewer swaps cameras when the projection toggle flips,
+  // and this module holds fifteen references to it. One binding to move beats
+  // threading a getter through all of them.
+  let camera = initialCamera;
   const sceneGraph = buildGizmoScene(THEMES.dark);
   const {
     group,
@@ -535,6 +539,7 @@ export function createCutawayGizmo({
     setActiveAppearance,
     setTheme,
     updateForCamera,
+    setCamera(next) { if (next) camera = next; },
     dispose,
   };
 }

package/src/framework/cutaway.js

@@ -32,7 +32,7 @@ function validBounds(getBounds) {
 export function createCutaway({
   renderer,
   scene,
-  camera,
+  camera: initialCamera,
   orbitControls,
   domElement,
   getBounds,
@@ -40,6 +40,9 @@ export function createCutaway({
   schedule = defaultSchedule,
   now,
 }) {
+  // Reassignable: a projection swap (perspective <-> ortho) hands the cutaway
+  // a new camera after construction, and the gizmo must follow it too.
+  let camera = initialCamera;
   let supported = false;
   try {
     supported = Boolean(
@@ -522,6 +525,11 @@ export function createCutaway({
     updateForCamera,
     renderOverlay,
     onHandleHoverChange,
+    setCamera(next) {
+      if (!next) return;
+      camera = next;
+      gizmo?.setCamera(next);
+    },
     dispose,
     _renderSetFor: (name) => renderSets.get(name)?.renderSet ?? null,
     _setDragging: setDragging,

package/src/framework/jobs.js

@@ -241,10 +241,11 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       // an unparameterized inspect that case IS this measurement. Seeding it in
       // (see verify.js's seeding block for the min-wall superset rule that makes
       // the reuse sound) stops the oracle from rebuilding the same geometry and
-      // re-casting the same min-wall rays a second time. Measuring `{ minWall:
-      // true }` here is what makes the seed usable by any verify run, min-wall
-      // gated or not — the result says so itself (`measuredMinWall`), so this
-      // call and the seed cannot drift apart.
+      // re-casting the same min-wall rays a second time. On a full lap the seed is
+      // usable by any verify run, min-wall gated or not, because the pass ran — and
+      // the result says so ITSELF (`measuredMinWall`/`measuredGaps`), never a claim
+      // by this caller, so the two cannot drift apart. On a quick lap the passes did
+      // not run, the stamps say false, and verify reports what it could not check.
       //
       // The view is built HERE rather than inside measure, and handed down through
       // `opts.built`, because optional match scoring needs the same meshes: one build
@@ -259,15 +260,31 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       // measure built internally and its own signature default hid this. Found by a
       // live browser check, not by tests: this suite passes explicit views, and the
       // cloud's unit tests fake the worker.
+      //
+      // `checks: "quick"` is the agent's fast lap. Min wall and pair distances are
+      // the oracle's two ray-casting passes and, profiled on a 460k-triangle
+      // assembly, 79% of its cost — and they SHARE the BVH those rays need, so
+      // skipping one leaves the index build standing and saves about half of what
+      // skipping both does. Everything else is derived from the build this job
+      // already paid for and stays: triangles, bbox, volume, genus, watertight,
+      // and the assembly overlap check. verify still runs — the gates that read
+      // those facts are free — and reports what it could not evaluate rather than
+      // passing it, which is why `quick` can be honoured on a gated part instead
+      // of refused. Anything other than the literal "quick" is the full lap: an
+      // unrecognized value must never quietly buy less checking than the caller
+      // asked for.
+      const quick = msg.checks === "quick";
       const view = msg.view ?? Object.keys(part.views)[0];
       const built = buildView(kernel, part, view, msg.params ?? {});
-      const measured = measure(kernel, part, view, msg.params ?? {}, { minWall: true, built });
+      const measured = measure(kernel, part, view, msg.params ?? {},
+        { minWall: !quick, gaps: !quick, built });
       const report = {
         measure: measured,
         verify: verify(kernel, part, {
           // The defaulted view, not msg.view: the seed below was measured on it, and
           // verify's seed reuse is only sound when both name the same view.
           view,
+          quick,
           seed: { params: msg.params ?? {}, result: measured },
         }),
       };

package/src/framework/measure/dim3-scene.js

@@ -58,6 +58,13 @@ export function worldPerPx(dist, fovDeg, viewportPx) {
   return (2 * dist * Math.tan((fovDeg * Math.PI) / 360)) / viewportPx;
 }
 
+// The orthographic twin of worldPerPx. An ortho camera's scale is a property of
+// its frustum and zoom alone — distance does not enter — which is exactly why
+// the perspective formula cannot be reused with a substituted fov.
+export function orthoWorldPerPx(top, bottom, zoom, viewportPx) {
+  return Math.abs(top - bottom) / Math.max(zoom, 1e-6) / Math.max(viewportPx, 1);
+}
+
 // Kept for compatibility with earlier callers/tests: the world height that
 // renders as `targetPx` on screen.
 export function labelWorldHeight(dist, fovDeg, viewportPx, targetPx = LABEL_SCREEN_PX) {
@@ -319,8 +326,14 @@ export function createDimScene(viewer, { paintLabel = defaultPaintLabel } = {})
     // One shared reference distance — camera to the dim group's origin (the
     // recentred model centre) — sizes the whole drawing.
     group.getWorldPosition(_gp);
-    const dist = viewer.camera.position.distanceTo(_gp);
-    const wpp = worldPerPx(dist, viewer.camera.fov ?? 45, h);
+    // `viewer.camera.fov ?? 45` was the bug this branch removes: under an ortho
+    // camera fov is undefined, so the fallback produced a plausible-but-wrong
+    // scale and every label, arrow and standoff drifted as the user dollied.
+    // The ortho formula matches cutaway-gizmo.js:485's worldUnitsPerPixelAt.
+    const cam = viewer.camera;
+    const wpp = cam.isOrthographicCamera
+      ? orthoWorldPerPx(cam.top, cam.bottom, cam.zoom, h)
+      : worldPerPx(cam.position.distanceTo(_gp), cam.fov ?? 45, h);
     if (wpp > 0) {
       const hStar = LABEL_SCREEN_PX * wpp;
       const aw = ARROW_SCREEN_PX * wpp;

package/src/framework/mount.js

@@ -6,7 +6,7 @@ import { attachCutawayControls } from "./cutaway-controls.js";
 import { attachRail } from "./rail.js";
 import { attachMobileTabs } from "./mobile-tabs.js";
 import { createTooltipPresenter, attachButtonTooltips } from "./tooltip.js";
-import { loadCamera } from "./view-state.js";
+import { loadCamera, loadProjection, saveProjection } from "./view-state.js";
 import { buildControls } from "./controls.js";
 import { relevantParamKeys } from "./param-deps.js";
 import { createMeshCache } from "./mesh-cache.js";
@@ -30,6 +30,7 @@ import { createMeasureMode } from "./measure/measure-mode.js";
 import { attachMeasureControls } from "./measure/measure-controls.js";
 import { createAnnotateMode } from "./annotate/annotate-mode.js";
 import { attachAnnotateControls } from "./annotate/annotate-controls.js";
+import { attachViewcubeControls } from "./viewcube/viewcube-controls.js";
 
 // The mount handle, factored out so its shape is unit-testable without booting
 // the full mount() pipeline (WASM + workers + DOM).
@@ -59,7 +60,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, exportParts, setHostPane, animation, getView, setView, captureView, attachTooltips, measure, annotate }) {
+export function makeHandle({ ready, dispose, viewer, setParams, listExportableParts, exportParts, setHostPane, animation, getView, setView, captureView, attachTooltips, measure, annotate, projection }) {
   return {
     ready, dispose, setParams,
     // Part-declared animation playback (spec 2026-08-02): animations are
@@ -106,6 +107,13 @@ export function makeHandle({ ready, dispose, viewer, setParams, listExportablePa
     // the built-in pencil button. send() delivers to onAnnotationSend and
     // returns false when there is no ink or the capture failed.
     annotate: annotate ?? NOOP_ANNOTATE,
+    // Projection is a viewer-wide display mode, not a part property — same
+    // shape as `measure` and `annotate` so a host reads one convention.
+    projection: projection ?? {
+      get: () => "perspective",
+      set: () => {},
+      onChange: () => () => {},
+    },
   };
 }
 
@@ -203,6 +211,10 @@ function createCleanupStack() {
 //                                 // subscribes return an unsubscribe; onInkChange fires on
 //                                 // every stroke/undo/clear, which is what a host driving its
 //                                 // own Send button gates that button on (strokeCount() > 0).
+//   runtime.projection: { get, set, onChange }
+//                                         // "perspective" | "orthographic". Drives the LIVE view
+//                                         // and captureCurrent only — captureCanonicalViews,
+//                                         // renderMeshPayloads and the CLI stay perspective.
 //   runtime.dispose();     // full teardown
 // onBuild fires per completed build, so it does NOT fire for a pose-only edit —
 // those are repaired in the viewer and produce no build at all.
@@ -412,6 +424,55 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
       annotate: els.chrome.annotate,
     }, { tooltip, escapeScope: els.viewer, send: annotateSend });
     cleanup.defer(() => annotateChrome.detach());
+    // Orientation cube + projection toggle. Generated chrome — no host markup
+    // declares it, so an embedder gets it for free. Restored BEFORE any framing
+    // happens so a reload into ortho frames once instead of framing in
+    // perspective and then visibly re-framing.
+    viewer.setProjection(loadProjection());
+    const viewcube = attachViewcubeControls(viewer, { stage: els.viewer }, { tooltip });
+    cleanup.defer(() => viewcube.detach());
+    cleanup.defer(viewer.onProjectionChange((mode) => saveProjection(mode)));
+    // setHidden takes one boolean, and there are two independent reasons to hide
+    // the cube: Sketch mode (below) and a crowded transport bar (wired into the
+    // animation controls further down). Applied straight, whichever fires last
+    // would win — leaving Sketch would reveal a cube that crowding still wants
+    // gone. Track a flag per reason and OR them through one place, the
+    // syncHoverSuppression precedent below.
+    let cubeHiddenForSketch = false;
+    let cubeHiddenForCrowding = false;
+    const syncViewcubeHidden = () =>
+      viewcube.setHidden(cubeHiddenForSketch || cubeHiddenForCrowding);
+    // Sketch freezes the view on purpose: ink is stored in screen space and is
+    // meaningful only against the pose it was drawn over. A live camera control
+    // on top of that — orbit OR a projection swap — invalidates the drawing.
+    if (annotateMode) {
+      cleanup.defer(annotateMode.onModeChange(() => {
+        cubeHiddenForSketch = annotateMode.isEnabled();
+        syncViewcubeHidden();
+      }));
+    }
+    // Publish the viewbar's vertical claim so chrome.css can stack the cube on
+    // top of it without hardcoding a height that cutaway/measure/annotate
+    // action rows can change.
+    const viewbarEl = els.viewer.querySelector("#viewbar");
+    if (viewbarEl && typeof ResizeObserver === "function") {
+      const publishViewbarClear = () => {
+        const stageRect = els.viewer.getBoundingClientRect();
+        const barRect = viewbarEl.getBoundingClientRect();
+        els.viewer.style.setProperty(
+          "--pf-viewbar-clear",
+          `${Math.max(0, Math.round(stageRect.bottom - barRect.top))}px`,
+        );
+      };
+      const viewbarObserver = new ResizeObserver(publishViewbarClear);
+      viewbarObserver.observe(viewbarEl);
+      viewbarObserver.observe(els.viewer);
+      publishViewbarClear();
+      cleanup.defer(() => {
+        viewbarObserver.disconnect();
+        els.viewer.style.removeProperty("--pf-viewbar-clear");
+      });
+    }
     // escapeScope: cutaway's Flip/Reset buttons are canvas SIBLINGS inside
     // #viewbar, not descendants of the canvas — attaching Escape to
     // viewer.domElement alone would leave a guarded Escape from those buttons
@@ -836,6 +897,17 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
       applyValues: applyAnimationValues,
       getParamValues: (keys) => Object.fromEntries(keys.map((k) => [k, params[k]])),
       getView: view,
+      // On a narrow stage the transport bar has to cap its own width to stay
+      // clear of the bottom-right cluster, and under that cap its controls fall
+      // below the 44px tap target. The cube gives way instead — it is the
+      // reclaimable half of that cluster. Nothing here keys on the viewport
+      // width: a part with no animations, or one whose bar fits, keeps its cube
+      // at every size. syncViewcubeHidden and the viewcube itself are both
+      // declared above this point, so this can never fire into a hole.
+      onCrowded: (crowded) => {
+        cubeHiddenForCrowding = crowded;
+        syncViewcubeHidden();
+      },
     });
     if (animCtl) cleanup.defer(() => animCtl.detach());
 
@@ -944,6 +1016,11 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
         onInkChange: annotateMode.onInkChange,
         onModeChange: annotateMode.onModeChange,
       } : null,
+      projection: {
+        get: () => viewer.getProjection(),
+        set: (mode) => viewer.setProjection(mode),
+        onChange: (cb) => viewer.onProjectionChange(cb),
+      },
     });
   } catch (error) {
     try {

package/src/framework/oracle/gates.js

@@ -0,0 +1,50 @@
+// Which declared gates a part actually has — the questions the oracle asks before
+// deciding how hard to work. Kept out of verify.js so measure() can ask the same
+// question without importing verify (which imports measure), and so there is ONE
+// definition of "does this part gate on min wall": measure sizes its sample budget
+// by it and verify decides whether to measure it at all. Two derivations that drift
+// would put a coarse reading behind a real gate, which is exactly the trap verify's
+// seeding block guards against.
+//
+// Every function here is TOTAL. A part whose profile name is unknown, or whose
+// `expect` function throws, is reported as GATED — the conservative direction, since
+// that is the full-resolution behaviour every part had before budgets existed. The
+// real error surfaces from verify, which is where a reader can act on it.
+import { resolveProfile } from "./dfm-profiles.js";
+import { expandCases } from "./cases.js";
+import { resolveParams } from "../part-model.js";
+
+// `expect` may be a function of a case's resolved params, so the answer is a property
+// of the EXPANDED cases, not of the raw spec — which means answering it costs a call
+// to the PART'S OWN code, once per case. Both callers here are on hot paths (verify
+// expands for its case loop; measure asks the gate question on every call, and verify
+// calls measure once per case), so an unmemoized expansion would invoke a part's
+// `expect` O(cases²) times per report. Memoized by part identity, and re-derived if
+// the spec object behind that identity was swapped — the realistic mutation, and the
+// one a bare WeakMap would serve staleness for.
+const expansions = new WeakMap();
+
+export function expandExpectations(part) {
+  const spec = part?.verify?.expect ?? {};
+  const hit = expansions.get(part);
+  if (hit && hit.spec === spec) return hit.expanded;
+  const expanded = typeof spec !== "function"
+    ? expandCases(part).map((c) => ({ ...c, expect: spec }))
+    : expandCases(part).map((c) => {
+      const { p, d } = resolveParams(part, c.params);
+      return { ...c, expect: spec(p, d) ?? {} };
+    });
+  if (part && typeof part === "object") expansions.set(part, { spec, expanded });
+  return expanded;
+}
+
+export function partGatesMinWall(part, { process, expanded } = {}) {
+  try {
+    const spec = process ?? part?.verify?.process;
+    if (spec && resolveProfile(spec)?.minWall != null) return true;
+    return (expanded ?? expandExpectations(part)).some(({ expect }) =>
+      Object.values(expect ?? {}).some((o) => o && typeof o === "object" && "minWall" in o));
+  } catch {
+    return true; // unresolvable → measure it properly and let verify report the error
+  }
+}

package/src/framework/oracle/measure.js

@@ -3,7 +3,8 @@ import { cachedBVH } from "./bvh.js";
 import { assemblyOverlaps } from "../assembly.js";
 import { meshGaps, pairKey, CONTACT_EPS, GAP_THRESHOLD } from "./gaps.js";
 import { bounds, meshArea, meshCentroid } from "./mesh.js";
-import { minWall } from "./min-wall.js";
+import { minWall, DIAGNOSTIC_SAMPLES } from "./min-wall.js";
+import { partGatesMinWall } from "./gates.js";
 
 const size = ({ min, max }) => [max[0] - min[0], max[1] - min[1], max[2] - min[2]];
 const unionBounds = (list) => list.reduce(
@@ -40,13 +41,20 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // the cache just fills it earlier. min-wall indexes exactly one mesh, so it is
   // handed the resolved BVH rather than the Map.
   const bvhCache = new Map();
+  // Sample budget for the min-wall pass. A part that declares a min-wall gate (a
+  // process profile or an `expect` mentioning it) gets the full resolution, because
+  // a gate's verdict rides on the reading. Everything else gets the diagnostic
+  // budget: min wall is the single most expensive thing the oracle does — one
+  // inward ray per sampled triangle plus the BVH those rays need — and on an
+  // ungated part it buys a fact nobody checks, at full price, on every agent edit.
+  const minWallSamples = partGatesMinWall(part) ? undefined : DIAGNOSTIC_SAMPLES;
   const subBounds = [];
   const subparts = built.map(({ name, solid, mesh }) => {
     const b = bounds(mesh.positions);
     subBounds.push(b);
     // Resolved lazily and only when asked for: without min-wall, a single-sub-part
     // view (no meshGaps) must still build no index at all.
-    const mw = opts.minWall ? minWall(mesh, { bvh: cachedBVH(mesh, bvhCache) }) : null;
+    const mw = opts.minWall ? minWall(mesh, { bvh: cachedBVH(mesh, bvhCache), maxSamples: minWallSamples }) : null;
     const vol = solid.volume();
     // Deviation-from-reference: only for a sub-part that declares `reference:
     // "<import name>"` (Task 12 — the gate that holds a parametric rebuild to
@@ -96,7 +104,13 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // so this reads on OCCT too. nearMisses = the issue-#29 signal: pairs that
   // *almost* touch; overlapping pairs are excluded by name (a fully-contained
   // sub-part has surface distance > 0 but is the overlap gate's business).
-  const gaps = built.length > 1 ? meshGaps(built, { bvhCache }) : [];
+  // `opts.gaps: false` is the quick lap's second half (see jobs.js): pair distances
+  // are the other ray-casting pass, and they and min-wall share the BVH, so skipping
+  // only one leaves the index build standing. The result is `undefined`, NEVER `[]`:
+  // pairGapChecks reads an empty table as "measured, and this pair has no distance"
+  // and fails a declared gate on it, while an absent table reads as no reading.
+  const measuredGaps = opts.gaps !== false;
+  const gaps = measuredGaps ? (built.length > 1 ? meshGaps(built, { bvhCache }) : []) : undefined;
 
   // Rebuilds with the same kernel and cleans up at its end — every solid fact
   // above is already read, so this is safe.
@@ -106,7 +120,7 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
 
   const overlapping = new Set(overlaps.map((o) => pairKey(o.a, o.b)));
   const gapThreshold = opts.gapThreshold ?? GAP_THRESHOLD;
-  const nearMisses = gaps.filter(
+  const nearMisses = (gaps ?? []).filter(
     (g) => g.distance > CONTACT_EPS && g.distance < gapThreshold && !overlapping.has(pairKey(g.a, g.b)),
   );
 
@@ -133,6 +147,9 @@ 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,
+    // Companion stamp to measuredMinWall, and read the same way: whether the pass
+    // ran, said by the pass itself rather than claimed by whoever holds the result.
+    measuredGaps,
     subparts,
     aggregate,
     overlaps,

package/src/framework/oracle/min-wall.js

@@ -33,6 +33,23 @@ import { buildBVH, readTriangleInto } from "./bvh.js";
 // are the only ones that engage it. Override per call with `{ maxSamples }`.
 const MAX_SAMPLES = 50_000;
 
+// The budget for a min-wall reading NOTHING GATES ON — a fact the report carries so
+// the model can notice a thin feature, rather than a number a declared minimum is
+// checked against. A tenth the rays, and the reading is stamped `sampled` either way,
+// so no consumer can mistake it for exact. measure() picks between the two by asking
+// gates.js whether the part declares a min-wall gate; a part that does gets
+// MAX_SAMPLES, unchanged.
+//
+// The win is real but bounded, and the bound is worth knowing before tuning this
+// number: the RAYS get ten times cheaper, the BVH they cast into does not, and it is
+// roughly half the pass. Measured on src/parts/screw.js (210k triangles, same code
+// path, gated vs not): measure() 837 ms → 458 ms, reporting the identical 0.008 mm.
+// Dropping the index too means not measuring min wall at all, which is the quick
+// lap's business (see jobs.js), not this constant's.
+const DIAGNOSTIC_SAMPLES = 5_000;
+
+export { MAX_SAMPLES, DIAGNOSTIC_SAMPLES };
+
 const gcd = (a, b) => { while (b) { const t = a % b; a = b; b = t; } return a; };
 
 // Stride for the sampling walk: near n/φ and coprime to n, so stepping by it visits