partforge 0.39.0 → 0.41.0

package/README.md

@@ -112,9 +112,28 @@ await runtime.ready;   // first successful build (rejects on a first-build error
 runtime.setHostPane("rail");  // narrow layout only: show just the controls
                                // rail ('stage' | 'rail'), suppressing the
                                // built-in tab bar. null hands selection back.
+runtime.setActive(false);      // park the viewer: stop the render loop, release the
+                               // drawing buffer. setActive(true) restores both.
+const off = runtime.onContextLost(() => {});  // WebGL context loss; returns an unsubscribe
 runtime.dispose();     // stops loops, workers, observers, listeners; frees GPU resources
 ```
 
+**Park the viewer when you hide it.** A host that hides the canvas with
+`display: none` needs nothing — the container collapses and the ResizeObserver
+shrinks the drawing buffer for free. A host that hides it any other way
+(`visibility: hidden`, an inactive tab, an off-screen pane) gets no such signal:
+the full-resolution MSAA buffer stays resident and the render loop keeps drawing
+an auto-rotating scene at 60fps that nobody can see. On a phone that is tens of
+megabytes plus continuous GPU work, and it has been enough on its own to get a
+tab killed. Call `runtime.setActive(false)` when the viewer goes off-screen and
+`setActive(true)` when it comes back.
+
+Parking releases both large GPU allocations — the drawing buffer and the cached
+1024² capture target — and stops the render loop. Offscreen captures
+(`captureCurrent`, `captureViews`) keep working while parked and framing is
+unchanged, so a host can still take a build screenshot of a hidden viewer; the
+first capture after parking just re-allocates its target.
+
 Every `elements` entry defaults to the legacy global ID (`#app`, `#controls`,
 `#panel` for `rail`, `#status`/`#busy`/`#phase`, `#part`,
 `#download`/`#download-step`/`#download-3mf`,

package/bin/cli.js

@@ -204,6 +204,9 @@ function printVerify(v) {
     for (const ch of c.checks) {
       const icon = ch.status === "pass" ? "✓" : ch.status === "fail" ? "✗" : ch.status === "warn" ? "⚠" : "·";
       console.log(`    ${icon} ${ch.subpart ?? "_view"} ${ch.metric} ${ch.expr}  (${ch.message})`);
+      // A measurement caveat prints whatever the verdict — "passed, but sampled"
+      // is precisely the line a reader must not miss.
+      if (ch.note) console.log(`        note: ${ch.note}`);
       if (ch.status === "fail" || ch.status === "warn") {
         if (ch.location) console.log(`        at [${ch.location.map((n) => n.toFixed(1)).join(", ")}]`);
         if (ch.hint) console.log(`        hint: ${ch.hint}${ch.pattern ? ` (ERROR-PATTERNS.md#${ch.pattern})` : ""}`);

package/docs/AUTHORING-PARTS.md

@@ -1032,6 +1032,9 @@ carries:
 - `hint` — one self-contained corrective sentence (always present),
 - `pattern` — a stable [ERROR-PATTERNS.md](ERROR-PATTERNS.md) entry ID when one
   applies (follow it with `ERROR-PATTERNS.md#<id>`),
+- `note` — an optional caveat about *how* the value was measured, attached
+  whatever the verdict. Today only `minWall` sets one, when the reading came
+  from a sample rather than every triangle (see below),
 - `location` — `[x, y, z]` in mm where the metric has one: `minWall` (thinnest
   sample point) and `overlaps` (the center of the first offending intersection's
   *bounding box* — a nearby indicator, not an exact point: when a pair overlaps in
@@ -1042,7 +1045,20 @@ carries:
 
 Subpart facts include `minWall` (number or `null` — null exactly when no reading
 exists, e.g. the OCCT backend or min-wall measurement turned off, matching
-`minWallAt`'s null) and `minWallAt` (`[x,y,z]` or `null`); overlap entries are
+`minWallAt`'s null) and `minWallAt` (`[x,y,z]` or `null`). Min wall casts one ray
+per triangle, which is unbounded work on a dense mesh, so past 50,000 triangles
+it casts from a spread, deterministic subset instead — `minWallSampled` (boolean)
+and `minWallSamples` (`{ sampled, total }` or `null`) say whether that happened.
+`sampled` is how many triangles the walk *selected*, not how many rays were
+cast: a degenerate (zero-area) triangle has no normal to cast along and is
+skipped. A sampled reading is an **upper bound**: it can miss a thin spot, never
+invent one — and a sampled run that found no wall at all still reports its
+`minWallSamples`, so a null `minWall` there is "we looked and found nothing",
+not "nobody looked". Everything in `src/parts/` is far below the budget and
+reads exactly. The report's top-level `measuredMinWall` says whether this run
+cast min-wall rays at all — the difference between a null `minWall` that means
+"no wall found" and one that means "not measured".
+Overlap entries are
 `{ a, b, volume, location }`. Pair-distance facts are `gaps` (every sub-part
 pair: `{ a, b, distance, at }`, distance 0 = touching or overlapping) and
 `nearMisses` (the pairs with an unintended-looking gap under 0.5 mm).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.39.0",
+  "version": "0.41.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/cutaway-gizmo.js

@@ -2,6 +2,7 @@ import * as THREE from "three";
 import {
   axisParameterFromRay,
   signedAngleAroundAxis,
+  snapQuaternionToAxis,
 } from "./cutaway-math.js";
 import { CUTAWAY_OVERLAY_RENDER_ORDER } from "./cutaway-render.js";
 
@@ -46,6 +47,7 @@ export function createCutawayGizmo({
   onPoseChange = () => {},
   onActivity = () => {},
   onHandleHoverChange = () => {},
+  onDragChange = () => {},
   pickHandle,
 }) {
   const group = new THREE.Group();
@@ -261,6 +263,7 @@ export function createCutawayGizmo({
   let activeAppearance = true;
   let themeMode = "dark";
   const raycaster = new THREE.Raycaster();
+  const _snapped = new THREE.Quaternion();
   const hitProxies = Object.values(handles);
 
   function rayFromEvent(event) {
@@ -326,6 +329,7 @@ export function createCutawayGizmo({
     drag = null;
     if (orbitControls) orbitControls.enabled = ending.orbitEnabled;
     safeRelease(ending.pointerId);
+    onDragChange(false);
   }
 
   function updateAppearance() {
@@ -361,6 +365,15 @@ export function createCutawayGizmo({
     onHandleHoverChange(normalized);
   }
 
+  // Rotation lands on a canonical axis when it gets close to one. Shift is read
+  // per move rather than latched at pointer-down, so it can be pressed and
+  // released mid-drag; it is unbound during a gizmo drag because orbit controls
+  // are already disabled.
+  function snapRotation(candidate, event) {
+    candidate.normalize();
+    return event.shiftKey ? candidate : snapQuaternionToAxis(candidate, undefined, _snapped);
+  }
+
   function notifyPose() {
     onPoseChange({
       position: group.position.clone(),
@@ -468,6 +481,7 @@ export function createCutawayGizmo({
     setHoveredHandle(handle);
     onActivity();
     drag = nextDrag;
+    onDragChange(true);
     if (orbitControls) orbitControls.enabled = false;
     safeCapture(event.pointerId);
     event.preventDefault();
@@ -512,7 +526,7 @@ export function createCutawayGizmo({
         * SCREEN_ROTATION_RADIANS_PER_PIXEL;
       if (!Number.isFinite(angle)) return;
       const delta = new THREE.Quaternion().setFromAxisAngle(drag.axis, angle);
-      group.quaternion.copy(delta.multiply(drag.startQuaternion)).normalize();
+      group.quaternion.copy(snapRotation(delta.multiply(drag.startQuaternion), event));
       group.position.copy(drag.startPosition);
       syncHandleTransform();
       notifyPose();
@@ -527,7 +541,7 @@ export function createCutawayGizmo({
     const angle = signedAngleAroundAxis(drag.startRadial, radial, drag.axis);
     if (!Number.isFinite(angle)) return;
     const delta = new THREE.Quaternion().setFromAxisAngle(drag.axis, angle);
-    group.quaternion.copy(delta.multiply(drag.startQuaternion)).normalize();
+    group.quaternion.copy(snapRotation(delta.multiply(drag.startQuaternion), event));
     group.position.copy(drag.startPosition);
     syncHandleTransform();
     notifyPose();

package/src/framework/cutaway-math.js

@@ -4,10 +4,38 @@ const PLANE_LOCAL_NORMAL = new THREE.Vector3(0, 0, 1);
 const POINT_EPSILON = 1e-6;
 const PARALLEL_EPSILON = 1e-6;
 
+// Nearest signed canonical axis (+/-X, +/-Y, +/-Z) to `direction`. Axes are
+// scanned X, Y, Z and replaced only on a strictly larger |component|, so a tie
+// resolves to the earlier axis — the default isometric framing is an exact tie
+// between -X and -Z and lands on -X. Degenerate input falls back to +Z.
+export function nearestCanonicalAxis(direction, target = new THREE.Vector3()) {
+  const components = [direction.x, direction.y, direction.z];
+  if (!components.every(Number.isFinite)) return target.set(0, 0, 1);
+
+  let bestIndex = -1;
+  let bestScore = 0;
+  for (let i = 0; i < 3; i++) {
+    const score = Math.abs(components[i]);
+    if (score > bestScore) {
+      bestScore = score;
+      bestIndex = i;
+    }
+  }
+  if (bestIndex < 0) return target.set(0, 0, 1);
+
+  // Built by setComponent rather than negating a unit axis: multiplying a zero
+  // component by -1 yields -0, and toEqual([0, -1, 0]) does not accept -0.
+  return target.set(0, 0, 0).setComponent(bestIndex, components[bestIndex] < 0 ? -1 : 1);
+}
+
 export function initialCutawayPose(box, camera) {
   const position = box.getCenter(new THREE.Vector3());
   const diagonal = Math.max(box.getSize(new THREE.Vector3()).length(), 1);
-  const normal = camera.getWorldDirection(new THREE.Vector3()).normalize();
+  // Square the cut plane up with the part rather than the camera: the axis
+  // nearest the view direction, so the near half is still what gets cut away.
+  const normal = nearestCanonicalAxis(
+    camera.getWorldDirection(new THREE.Vector3()).normalize(),
+  );
   const quaternion = new THREE.Quaternion().setFromUnitVectors(
     PLANE_LOCAL_NORMAL,
     normal,
@@ -20,6 +48,27 @@ export function initialCutawayPose(box, camera) {
   };
 }
 
+export const AXIS_SNAP_RADIANS = (7 * Math.PI) / 180;
+
+// Pull a plane pose onto the nearest canonical axis once its normal is within
+// `maxAngle` of one. The correction is the minimal rotation carrying the normal
+// onto the axis, not a rebuilt quaternion, so the plane's in-plane roll survives
+// and the gizmo rings do not visibly spin at the moment of snapping. Roll does
+// not affect the clip either way.
+export function snapQuaternionToAxis(
+  quaternion,
+  maxAngle = AXIS_SNAP_RADIANS,
+  target = new THREE.Quaternion(),
+) {
+  const normal = PLANE_LOCAL_NORMAL.clone().applyQuaternion(quaternion).normalize();
+  const axis = nearestCanonicalAxis(normal);
+  if (normal.angleTo(axis) > maxAngle) return target.copy(quaternion);
+  return target
+    .setFromUnitVectors(normal, axis)
+    .multiply(quaternion)
+    .normalize();
+}
+
 export function planeFromPose(plane, normalTarget, position, quaternion, flipped) {
   normalTarget.copy(PLANE_LOCAL_NORMAL).applyQuaternion(quaternion).normalize();
   if (flipped) normalTarget.negate();

package/src/framework/cutaway-outline.js

@@ -0,0 +1,233 @@
+import * as THREE from "three";
+import { LineMaterial } from "three/addons/lines/LineMaterial.js";
+import { LineSegments2 } from "three/addons/lines/LineSegments2.js";
+import { LineSegmentsGeometry } from "three/addons/lines/LineSegmentsGeometry.js";
+
+// Matches POINT_EPSILON in cutaway-math.js: a vertex this close to the plane
+// counts as lying on it, so a grazing plane produces neither duplicate nor
+// zero-length segments.
+const ON_PLANE_EPSILON = 1e-6;
+
+const _vertices = [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()];
+const _distances = [0, 0, 0];
+const _signs = [0, 0, 0];
+const _crossing = new THREE.Vector3();
+
+// Plane/triangle intersection over a BufferGeometry, in the geometry's own
+// frame. Emits one segment per crossing triangle. Handles indexed (OCCT) and
+// non-indexed (Manifold) geometry alike.
+//
+// Degenerate contact is resolved so each boundary edge is emitted exactly once:
+//   - a triangle lying in the plane emits nothing; its neighbours bound it;
+//   - a triangle touching the plane at one vertex only emits nothing;
+//   - a triangle with an edge in the plane emits that edge only when its third
+//     vertex is on the clipped side, so the two triangles sharing that edge do
+//     not both emit it.
+//
+// Known limitation: that last rule reads only its own triangle, so it cannot
+// tell "the neighbour is on the other side" (a real crossing, one emission)
+// from "the neighbour is also clipped" (a ridge merely tangent to the plane,
+// two emissions of the same edge). Telling them apart needs per-slice edge
+// bookkeeping on a path that runs every frame of a gizmo drag, and the payoff
+// is small: the duplicates are coincident, so they are invisible on opaque
+// parts and only slightly darken a translucent one, in the measure-zero case
+// where a plane lands exactly on a crease.
+export function sectionSegments(geometry, plane) {
+  const position = geometry?.getAttribute?.("position");
+  if (!position) return new Float32Array(0);
+
+  const index = geometry.getIndex?.() ?? null;
+  const count = index ? index.count : position.count;
+  const out = [];
+
+  for (let i = 0; i + 2 < count; i += 3) {
+    for (let k = 0; k < 3; k++) {
+      _vertices[k].fromBufferAttribute(position, index ? index.getX(i + k) : i + k);
+      const distance = plane.distanceToPoint(_vertices[k]);
+      _distances[k] = distance;
+      _signs[k] = distance > ON_PLANE_EPSILON
+        ? 1
+        : distance < -ON_PLANE_EPSILON ? -1 : 0;
+    }
+
+    const onPlane = (_signs[0] === 0 ? 1 : 0)
+      + (_signs[1] === 0 ? 1 : 0)
+      + (_signs[2] === 0 ? 1 : 0);
+
+    if (onPlane === 3) continue;
+
+    if (onPlane === 2) {
+      const solo = _signs[0] !== 0 ? 0 : _signs[1] !== 0 ? 1 : 2;
+      if (_signs[solo] !== -1) continue;
+      pushPoint(out, _vertices[(solo + 1) % 3]);
+      pushPoint(out, _vertices[(solo + 2) % 3]);
+      continue;
+    }
+
+    if (onPlane === 1) {
+      const zero = _signs[0] === 0 ? 0 : _signs[1] === 0 ? 1 : 2;
+      const a = (zero + 1) % 3;
+      const b = (zero + 2) % 3;
+      if (_signs[a] === _signs[b]) continue;
+      pushPoint(out, _vertices[zero]);
+      pushPoint(out, crossingPoint(a, b));
+      continue;
+    }
+
+    if (_signs[0] === _signs[1] && _signs[1] === _signs[2]) continue;
+    for (let k = 0; k < 3; k++) {
+      const a = k;
+      const b = (k + 1) % 3;
+      if (_signs[a] === _signs[b]) continue;
+      pushPoint(out, crossingPoint(a, b));
+    }
+  }
+
+  return new Float32Array(out);
+}
+
+function crossingPoint(a, b) {
+  const t = _distances[a] / (_distances[a] - _distances[b]);
+  return _crossing.copy(_vertices[a]).lerp(_vertices[b], t);
+}
+
+function pushPoint(out, point) {
+  out.push(point.x, point.y, point.z);
+}
+
+const defaultNow = () => (typeof performance !== "undefined" ? performance.now() : 0);
+
+// One cut-face outline for one subpart. The object is parented to the mesh, the
+// same trick the stencil helpers use, so it inherits every present and future
+// transform including the pose fast path — and it always slices whatever
+// `mesh.geometry` currently draws, so the outline cannot disagree with the
+// surface it bounds.
+//
+// The section moves for four unrelated reasons (plane pose, geometry swap,
+// frameTo recentring the assembly under a world-fixed plane, and setSubPose),
+// and only the first two notify the cutaway. Rather than thread invalidation
+// through all four, refresh() compares a signature and re-slices when it
+// differs — roughly 21 float compares per frame.
+export function createSectionOutline({ mesh, plane, inkColor, now = defaultNow }) {
+  const material = new LineMaterial({
+    color: inkColor,
+    linewidth: 1,
+    // The outline lies exactly in the cap plane; pull it toward the viewer so
+    // the coincident-depth line wins against the cap it sits in.
+    polygonOffset: true,
+    polygonOffsetFactor: -1,
+    polygonOffsetUnits: -1,
+  });
+  material.resolution.set(1, 1);
+  // Deliberately no clippingPlanes: the outline sits at distance ~0 from its
+  // own plane, and clipping it would speckle.
+
+  const object = new LineSegments2(new LineSegmentsGeometry(), material);
+  object.frustumCulled = false;
+  object.visible = false;
+  mesh.add(object);
+
+  const localPlane = new THREE.Plane();
+  const inverse = new THREE.Matrix4();
+  const lastNormal = new THREE.Vector3(NaN, NaN, NaN);
+  const lastMatrix = new THREE.Matrix4();
+  let lastConstant = NaN;
+  let lastGeometry = null;
+  let lastCost = 0;
+  let hasSegments = false;
+  let visible = false;
+  let suppressed = false;
+  let disposed = false;
+  // A show transition (setVisible(true) / setSuppressed(false)) must not put
+  // the last slice on screen if the plane or mesh moved while hidden - that
+  // slice belongs to a pose nobody asked to see. Cleared once slice() has
+  // caught up; markShown() below leaves it alone when nothing moved, so an
+  // ordinary show doesn't wait on a needless re-slice.
+  let needsSlice = true;
+
+  function applyVisibility() {
+    object.visible = visible && hasSegments && !suppressed && !disposed && !needsSlice;
+  }
+
+  // Same signature the plane/mesh state is judged by in refresh(), reused so
+  // a show transition can tell "still matches the last slice" from "moved
+  // while hidden" without duplicating that comparison.
+  function signatureMatches(geometry, matrixWorld) {
+    return geometry === lastGeometry
+      && plane.constant === lastConstant
+      && plane.normal.equals(lastNormal)
+      && matrixWorld.equals(lastMatrix);
+  }
+
+  function markShown() {
+    mesh.updateWorldMatrix(true, false);
+    if (!signatureMatches(mesh.geometry, mesh.matrixWorld)) needsSlice = true;
+  }
+
+  function slice(geometry, matrixWorld) {
+    const start = now();
+    localPlane.copy(plane).applyMatrix4(inverse.copy(matrixWorld).invert());
+    const segments = geometry
+      ? sectionSegments(geometry, localPlane)
+      : new Float32Array(0);
+    hasSegments = segments.length > 0;
+    const previous = object.geometry;
+    const next = new LineSegmentsGeometry();
+    if (hasSegments) next.setPositions(segments);
+    object.geometry = next;
+    previous?.dispose();
+    lastCost = now() - start;
+    needsSlice = false;
+    applyVisibility();
+  }
+
+  function refresh() {
+    if (disposed || !visible || suppressed) return false;
+    mesh.updateWorldMatrix(true, false);
+    const geometry = mesh.geometry;
+    if (signatureMatches(geometry, mesh.matrixWorld)) return false;
+    lastGeometry = geometry;
+    lastConstant = plane.constant;
+    lastNormal.copy(plane.normal);
+    lastMatrix.copy(mesh.matrixWorld);
+    slice(geometry, mesh.matrixWorld);
+    return true;
+  }
+
+  return {
+    object,
+    refresh,
+    sliceCost: () => lastCost,
+    setVisible(on) {
+      if (disposed) return;
+      visible = Boolean(on);
+      if (visible) markShown();
+      applyVisibility();
+    },
+    setSuppressed(on) {
+      if (disposed) return;
+      suppressed = Boolean(on);
+      if (!suppressed) markShown();
+      applyVisibility();
+    },
+    setInk(color) {
+      if (!disposed) material.color.set(color);
+    },
+    setTransparent(on) {
+      if (disposed || material.transparent === Boolean(on)) return;
+      material.transparent = Boolean(on);
+      material.needsUpdate = true;
+    },
+    setViewportSize(width, height) {
+      if (!disposed) material.resolution.set(width, height);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      object.visible = false;
+      mesh.remove(object);
+      object.geometry?.dispose();
+      material.dispose();
+    },
+  };
+}

package/src/framework/cutaway-render.js

@@ -1,5 +1,7 @@
 import * as THREE from "three";
 
+import { createSectionOutline } from "./cutaway-outline.js";
+
 export const HATCH_PERIOD_CSS_PX = 5;
 export const HATCH_LINE_CSS_PX = 1;
 
@@ -9,6 +11,7 @@ export const HATCH_LINE_CSS_PX = 1;
 const SURFACE_ORDER_BASE = 1_000_000;
 const EDGE_ORDER_BASE = 2_000_000;
 const SECTION_ORDER_STRIDE = 2;
+export const OUTLINE_ORDER_BASE = 2_500_000;
 export const CUTAWAY_OVERLAY_RENDER_ORDER = 3_000_000;
 
 export function createHatchMaterial({ color, opacity, inkColor }) {
@@ -122,6 +125,7 @@ export function createSectionRenderSet({
   capGeometry,
   order,
   inkColor,
+  now,
 }) {
   let originalMeshMaterial = mesh.material;
   let originalEdgeMaterial = edgeLines?.material;
@@ -187,6 +191,13 @@ export function createSectionRenderSet({
   front.renderOrder = stencilOrder;
   cap.renderOrder = stencilOrder + 1;
 
+  // Cut-face outline: real 3D segments sliced from the mesh, drawn with the
+  // same fat-line renderer as the viewer's feature edges. Ordered above the
+  // clipped edges so it wins the coincident depth against its own cap.
+  const outline = createSectionOutline({ mesh, plane, inkColor, now });
+  outline.object.renderOrder = OUTLINE_ORDER_BASE + order;
+  outline.setTransparent(capMaterial.transparent);
+
   let enabled = false;
   let visible = mesh.visible;
   let disposed = false;
@@ -196,6 +207,7 @@ export function createSectionRenderSet({
     back.visible = on;
     front.visible = on;
     cap.visible = on;
+    outline.setVisible(on);
   }
 
   back.visible = false;
@@ -245,12 +257,14 @@ export function createSectionRenderSet({
   function setHatchInk(color) {
     if (disposed) return;
     capMaterial.userData.setInkColor(color);
+    outline.setInk(color);
   }
 
   function setViewportSize(width, height, pixelRatio = 1) {
     if (disposed) return;
     viewportSize = { width, height, pixelRatio };
     setLineResolution(clippedEdgeMaterial, width, height);
+    outline.setViewportSize(width, height);
     capMaterial.userData.setScreenScale(pixelRatio);
   }
 
@@ -302,6 +316,7 @@ export function createSectionRenderSet({
     backMaterial.transparent = capMaterial.transparent;
     frontMaterial.transparent = capMaterial.transparent;
     if (clippedEdgeMaterial && capMaterial.transparent) makeTransparent(clippedEdgeMaterial);
+    outline.setTransparent(capMaterial.transparent);
 
     if (enabled) {
       mesh.material = clippedMeshMaterial;
@@ -319,6 +334,7 @@ export function createSectionRenderSet({
     disposed = true;
     mesh.remove(back, front);
     scene.remove(cap);
+    outline.dispose();
     for (const material of ownedMaterials) material.dispose();
   }
 
@@ -326,6 +342,7 @@ export function createSectionRenderSet({
     back,
     front,
     cap,
+    outline,
     setEnabled,
     setVisible,
     setGeometry,
@@ -333,6 +350,9 @@ export function createSectionRenderSet({
     setHatchInk,
     setViewportSize,
     refreshSourceMaterial,
+    refreshOutline: outline.refresh,
+    outlineSliceCost: outline.sliceCost,
+    setOutlineSuppressed: outline.setSuppressed,
     dispose,
   };
 }

package/src/framework/cutaway.js

@@ -10,6 +10,11 @@ import { createSectionRenderSet } from "./cutaway-render.js";
 
 const IDLE_DELAY_MS = 800;
 
+// Slicing rides on top of everything else in the frame, so the whole visible
+// assembly gets about an eighth of a 60 fps frame before outlines step aside
+// for the duration of a drag.
+export const OUTLINE_SLICE_BUDGET_MS = 2;
+
 function defaultSchedule(callback, delay) {
   const timer = setTimeout(callback, delay);
   return () => clearTimeout(timer);
@@ -33,6 +38,7 @@ export function createCutaway({
   getBounds,
   edgeColor,
   schedule = defaultSchedule,
+  now,
 }) {
   let supported = false;
   try {
@@ -61,6 +67,7 @@ export function createCutaway({
   let previousLocalClippingEnabled;
   let disposed = false;
   let disabling = false;
+  let outlinesSuppressed = false;
   let hoveredHandle = null;
   const handleHoverSubscribers = new Set();
   const pendingHandlePublications = [];
@@ -218,6 +225,7 @@ export function createCutaway({
     onPoseChange,
     onActivity: showActive,
     onHandleHoverChange: publishHandleHover,
+    onDragChange: setDragging,
   });
   gizmo.setVisible(false);
   gizmo.setTheme(theme);
@@ -236,6 +244,7 @@ export function createCutaway({
       capGeometry,
       order,
       inkColor: hatchInk,
+      now,
     });
     renderSets.set(name, { renderSet, mesh, edgeLines, order });
     if (viewportSize) {
@@ -248,6 +257,7 @@ export function createCutaway({
     applyCapPose(renderSet);
     renderSet.setVisible(enabled && selected(name));
     renderSet.setEnabled(enabled);
+    renderSet.setOutlineSuppressed(outlinesSuppressed);
     return true;
   }
 
@@ -402,8 +412,42 @@ export function createCutaway({
     };
   }
 
+  // Per-frame maintenance while the cutaway is on: the gizmo rescales for the
+  // camera, and every visible section re-slices its outline if anything it
+  // depends on moved. Both are cheap no-ops when nothing changed.
+  function refreshSections() {
+    for (const { renderSet } of renderSets.values()) renderSet.refreshOutline();
+  }
+
+  // Outlines re-slice on every frame of a gizmo drag. On heavy assemblies that
+  // is the one place the cost could show, so decide once at drag start — from
+  // costs already measured, so the drag never pays a spike to discover it is
+  // too expensive — and hide all of them or none. Half-outlined assemblies read
+  // as broken. Only sections that are actually showing count toward the budget:
+  // a hidden section's refresh() early-returns without slicing, so its cost
+  // entry is whatever was last measured while it *was* visible — stale, and
+  // irrelevant to what the drag will actually spend time on.
+  function setDragging(active) {
+    if (disposed) return;
+    if (active) {
+      let total = 0;
+      for (const [name, { renderSet }] of renderSets) {
+        if (enabled && selected(name)) total += renderSet.outlineSliceCost();
+      }
+      outlinesSuppressed = total > OUTLINE_SLICE_BUDGET_MS;
+    } else {
+      outlinesSuppressed = false;
+    }
+    for (const { renderSet } of renderSets.values()) {
+      renderSet.setOutlineSuppressed(outlinesSuppressed);
+    }
+    if (!active) refreshSections();
+  }
+
   function updateForCamera() {
-    if (enabled && !disposed) gizmo.updateForCamera();
+    if (!enabled || disposed) return;
+    gizmo.updateForCamera();
+    refreshSections();
   }
 
   function renderOverlay(targetRenderer, targetCamera) {
@@ -465,5 +509,7 @@ export function createCutaway({
     renderOverlay,
     onHandleHoverChange,
     dispose,
+    _renderSetFor: (name) => renderSets.get(name)?.renderSet ?? null,
+    _setDragging: setDragging,
   };
 }

package/src/framework/jobs.js

@@ -149,9 +149,21 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       // — the main thread only has mesh arrays, so this can only happen here.
       // measure/verify build their own solids via buildView and are cleaned up by
       // the `finally` below.
+      // The two halves overlap: verify always expands a "defaults" case, and for
+      // 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.
+      const measured = measure(kernel, part, msg.view, msg.params ?? {}, { minWall: true });
       const report = {
-        measure: measure(kernel, part, msg.view, msg.params ?? {}, { minWall: true }),
-        verify: verify(kernel, part, { view: msg.view }),
+        measure: measured,
+        verify: verify(kernel, part, {
+          view: msg.view,
+          seed: { params: msg.params ?? {}, result: measured },
+        }),
       };
       post({ type: "report", ...report });
     }