partforge 0.40.0 → 0.44.0

package/src/framework/cutaway-gizmo.js

@@ -4,8 +4,11 @@ import {
   signedAngleAroundAxis,
   snapQuaternionToAxis,
 } from "./cutaway-math.js";
-import { CUTAWAY_OVERLAY_RENDER_ORDER } from "./cutaway-render.js";
+import { buildGizmoScene } from "./cutaway-gizmo-scene.js";
 
+// The single source of truth for gizmo colors: the scene is constructed from
+// `dark` and `updateAppearance` re-derives from whichever mode is active, so a
+// palette edit here reaches the first frame as well as every later one.
 const THEMES = {
   dark: {
     fill: 0x65bff5,
@@ -23,6 +26,8 @@ const THEMES = {
   },
 };
 
+export { THEMES as CUTAWAY_GIZMO_THEMES };
+
 const TRANSLATION_SCREEN_ALIGNMENT = 0.9;
 const ROTATION_SCREEN_ALIGNMENT = 0.15;
 // A 120 px perpendicular drag rotates the plane by 90 degrees.
@@ -30,11 +35,9 @@ const SCREEN_ROTATION_RADIANS_PER_PIXEL = Math.PI / 240;
 const SCREEN_AXIS_EPSILON_SQ = 1e-8;
 // Reserve the visually shared center for the end-on translation handle.
 const TRANSLATE_CENTER_RADIUS_PX = 22;
-const GIZMO_RENDER_ORDER = CUTAWAY_OVERLAY_RENDER_ORDER + 1;
 const GHOST_OFFSET_FACTOR = 0.001;
 const MIN_GHOST_OFFSET = 0.01;
 const MAX_GHOST_OFFSET = 0.25;
-const HANDLE_HOVER_THICKNESS = 1.6;
 const HANDLE_HOVER_WHITE_MIX = 0.28;
 const WHITE = new THREE.Color(0xffffff);
 
@@ -50,211 +53,20 @@ export function createCutawayGizmo({
   onDragChange = () => {},
   pickHandle,
 }) {
-  const group = new THREE.Group();
-  const geometries = new Set();
-  const materials = new Set();
-
-  const fill = new THREE.Mesh(
-    new THREE.PlaneGeometry(1, 1),
-    new THREE.MeshBasicMaterial({
-      color: 0x65bff5,
-      opacity: 0.18,
-      transparent: true,
-      depthTest: true,
-      depthWrite: false,
-      side: THREE.DoubleSide,
-    }),
-  );
-  geometries.add(fill.geometry);
-  materials.add(fill.material);
-
-  const borderGeometry = new THREE.BufferGeometry().setFromPoints([
-    new THREE.Vector3(-0.5, -0.5, 0),
-    new THREE.Vector3(0.5, -0.5, 0),
-    new THREE.Vector3(0.5, 0.5, 0),
-    new THREE.Vector3(-0.5, 0.5, 0),
-  ]);
-  const borderMaterial = new THREE.LineBasicMaterial({
-    color: 0xa8dcff,
-    opacity: 1,
-    transparent: true,
-    depthTest: false,
-    depthWrite: false,
-  });
-  const border = new THREE.LineLoop(borderGeometry, borderMaterial);
-  border.renderOrder = GIZMO_RENDER_ORDER;
-  geometries.add(borderGeometry);
-  materials.add(borderMaterial);
-
-  const handleRoot = new THREE.Group();
-  const translateVisualRoot = new THREE.Group();
-  const arcRoot = new THREE.Group();
-  const translateMaterial = new THREE.MeshBasicMaterial({
-    color: 0x36d399,
-    transparent: true,
-    depthTest: true,
-    depthWrite: true,
-  });
-  const rotateXMaterial = new THREE.MeshBasicMaterial({
-    color: 0xff6b7a,
-    transparent: true,
-    depthTest: true,
-    depthWrite: true,
-  });
-  const rotateYMaterial = new THREE.MeshBasicMaterial({
-    color: 0x5aa9ff,
-    transparent: true,
-    depthTest: true,
-    depthWrite: true,
-  });
-  materials.add(translateMaterial);
-  materials.add(rotateXMaterial);
-  materials.add(rotateYMaterial);
-
-  const shaftGeometry = new THREE.CylinderGeometry(0.025, 0.025, 0.58, 12);
-  const shaftHoverGeometry = new THREE.CylinderGeometry(
-    0.025 * HANDLE_HOVER_THICKNESS,
-    0.025 * HANDLE_HOVER_THICKNESS,
-    0.58,
-    12,
-  );
-  const shaft = new THREE.Mesh(shaftGeometry, translateMaterial);
-  shaft.rotation.x = Math.PI / 2;
-  shaft.position.z = 0.29;
-  const coneGeometry = new THREE.ConeGeometry(0.075, 0.2, 16);
-  const coneHoverGeometry = new THREE.ConeGeometry(
-    0.075 * HANDLE_HOVER_THICKNESS,
-    0.2,
-    16,
-  );
-  const cone = new THREE.Mesh(coneGeometry, translateMaterial);
-  cone.rotation.x = Math.PI / 2;
-  cone.position.z = 0.68;
-  geometries.add(shaftGeometry);
-  geometries.add(shaftHoverGeometry);
-  geometries.add(coneGeometry);
-  geometries.add(coneHoverGeometry);
-
-  const ringXGeometry = new THREE.TorusGeometry(
-    0.42,
-    0.015,
-    8,
-    64,
-    Math.PI,
-  );
-  const ringX = new THREE.Mesh(ringXGeometry, rotateXMaterial);
-  const ringXHoverGeometry = new THREE.TorusGeometry(
-    0.42,
-    0.015 * HANDLE_HOVER_THICKNESS,
-    8,
-    64,
-    Math.PI,
-  );
-  ringX.quaternion
-    .setFromAxisAngle(new THREE.Vector3(1, 0, 0), -Math.PI / 2)
-    .multiply(new THREE.Quaternion().setFromAxisAngle(
-      new THREE.Vector3(0, 1, 0),
-      Math.PI / 2,
-    ));
-  const ringYGeometry = new THREE.TorusGeometry(
-    0.42,
-    0.015,
-    8,
-    64,
-    Math.PI,
-  );
-  const ringY = new THREE.Mesh(ringYGeometry, rotateYMaterial);
-  const ringYHoverGeometry = new THREE.TorusGeometry(
-    0.42,
-    0.015 * HANDLE_HOVER_THICKNESS,
-    8,
-    64,
-    Math.PI,
-  );
-  ringY.rotation.x = -Math.PI / 2;
-  geometries.add(ringXGeometry);
-  geometries.add(ringXHoverGeometry);
-  geometries.add(ringYGeometry);
-  geometries.add(ringYHoverGeometry);
-
-  const hitMaterial = new THREE.MeshBasicMaterial({
-    color: 0xffffff,
-    opacity: 0,
-    transparent: true,
-    depthWrite: false,
-  });
-  materials.add(hitMaterial);
-  const translateHitGeometry = new THREE.CylinderGeometry(0.1, 0.1, 0.95, 10);
-  const translateHit = new THREE.Mesh(translateHitGeometry, hitMaterial);
-  translateHit.rotation.x = Math.PI / 2;
-  translateHit.position.z = 0.38;
-  translateHit.userData.cutawayHandle = "translate";
-  const rotateXHitGeometry = new THREE.TorusGeometry(
-    0.42,
-    0.12,
-    8,
-    48,
-    Math.PI,
-  );
-  const rotateXHit = new THREE.Mesh(rotateXHitGeometry, hitMaterial);
-  rotateXHit.quaternion.copy(ringX.quaternion);
-  rotateXHit.userData.cutawayHandle = "rotate-x";
-  const rotateYHitGeometry = new THREE.TorusGeometry(
-    0.42,
-    0.12,
-    8,
-    48,
-    Math.PI,
-  );
-  const rotateYHit = new THREE.Mesh(rotateYHitGeometry, hitMaterial);
-  rotateYHit.quaternion.copy(ringY.quaternion);
-  rotateYHit.userData.cutawayHandle = "rotate-y";
-  geometries.add(translateHitGeometry);
-  geometries.add(rotateXHitGeometry);
-  geometries.add(rotateYHitGeometry);
-
-  translateVisualRoot.add(shaft, cone);
-  arcRoot.add(ringX, ringY, rotateXHit, rotateYHit);
-  handleRoot.add(translateVisualRoot, translateHit, arcRoot);
-  group.add(fill, border);
+  const sceneGraph = buildGizmoScene(THEMES.dark);
+  const {
+    group,
+    fill,
+    border,
+    handleRoot,
+    arcRoot,
+    handles,
+    handleVisuals,
+    handleAppearance,
+  } = sceneGraph;
   scene.add(group);
   overlayScene.add(handleRoot);
 
-  const handles = {
-    translate: translateHit,
-    rotateX: rotateXHit,
-    rotateY: rotateYHit,
-  };
-  const handleVisuals = {
-    translate: translateVisualRoot,
-    rotateX: ringX,
-    rotateY: ringY,
-  };
-  const handleAppearance = {
-    translate: {
-      visual: translateVisualRoot,
-      material: translateMaterial,
-      geometryPairs: [
-        { mesh: shaft, normal: shaftGeometry, hovered: shaftHoverGeometry },
-        { mesh: cone, normal: coneGeometry, hovered: coneHoverGeometry },
-      ],
-    },
-    "rotate-x": {
-      visual: ringX,
-      material: rotateXMaterial,
-      geometryPairs: [
-        { mesh: ringX, normal: ringXGeometry, hovered: ringXHoverGeometry },
-      ],
-    },
-    "rotate-y": {
-      visual: ringY,
-      material: rotateYMaterial,
-      geometryPairs: [
-        { mesh: ringY, normal: ringYGeometry, hovered: ringYHoverGeometry },
-      ],
-    },
-  };
-
   let disposed = false;
   let poseSize = 1;
   let flipped = false;
@@ -336,8 +148,8 @@ export function createCutawayGizmo({
     const theme = THEMES[themeMode] ?? THEMES.dark;
     fill.material.color.set(theme.fill);
     fill.material.opacity = activeAppearance ? 0.18 : 0.055;
-    borderMaterial.color.set(theme.border);
-    borderMaterial.opacity = activeAppearance ? 1 : 0.72;
+    border.material.color.set(theme.border);
+    border.material.opacity = activeAppearance ? 1 : 0.72;
 
     for (const [handle, { visual, material, geometryPairs }] of Object.entries(handleAppearance)) {
       const hovered = handle === hoveredHandle;
@@ -396,6 +208,12 @@ export function createCutawayGizmo({
     return camera.getWorldDirection(new THREE.Vector3()).normalize();
   }
 
+  // |axis . view|: 1 when we are staring straight down the axis, 0 when the
+  // axis lies flat in the screen plane. Both drag families branch on it.
+  function axisViewAlignment(position, axis) {
+    return Math.abs(axis.dot(viewDirectionAt(position)));
+  }
+
   function projectToClient(point) {
     const rect = domElement.getBoundingClientRect();
     if (rect.width <= 0 || rect.height <= 0) return null;
@@ -419,13 +237,9 @@ export function createCutawayGizmo({
     return new THREE.Vector2(-screenAxis.y, screenAxis.x);
   }
 
-  function onPointerDown(event) {
-    if (disposed || drag || !group.visible || (event.button != null && event.button !== 0)) return;
-    const ray = rayFromEvent(event);
-    if (!ray) return;
-    const handle = pick(event, ray);
-    if (!handle) return;
-
+  // The fields every drag carries, before the mode-specific ones are filled in
+  // by beginTranslateDrag / beginRotateDrag.
+  function baseDrag(event, handle) {
     const startPosition = group.position.clone();
     const startQuaternion = group.quaternion.clone();
     const localAxis = handle === "rotate-x"
@@ -433,10 +247,7 @@ export function createCutawayGizmo({
       : handle === "rotate-y"
         ? new THREE.Vector3(0, 1, 0)
         : new THREE.Vector3(0, 0, 1);
-    const axis = localAxis.applyQuaternion(startQuaternion).normalize();
-    const viewDirection = viewDirectionAt(startPosition);
-    const alignment = Math.abs(axis.dot(viewDirection));
-    const nextDrag = {
+    return {
       pointerId: event.pointerId,
       handle,
       orbitEnabled: orbitControls?.enabled,
@@ -445,38 +256,65 @@ export function createCutawayGizmo({
       startClientX: event.clientX,
       startClientY: event.clientY,
       unitsPerPixel: worldUnitsPerPixelAt(startPosition),
-      axis,
+      axis: localAxis.applyQuaternion(startQuaternion).normalize(),
       mode: null,
       startParameter: null,
       rotationPlane: null,
       startRadial: null,
       screenRotationDirection: null,
     };
+  }
 
-    if (handle === "translate") {
-      nextDrag.startParameter = axisParameterFromRay(ray, startPosition, axis);
-      nextDrag.mode = alignment > TRANSLATION_SCREEN_ALIGNMENT
-        || nextDrag.startParameter == null
-        ? "screen-translate"
-        : "axis-translate";
-    } else {
-      const useScreenRotation = alignment < ROTATION_SCREEN_ALIGNMENT;
-      if (!useScreenRotation) {
-        const plane = new THREE.Plane().setFromNormalAndCoplanarPoint(axis, startPosition);
-        const point = ray.intersectPlane(plane, new THREE.Vector3());
-        const radial = point?.sub(startPosition);
-        if (radial && radial.lengthSq() >= 1e-12) {
-          nextDrag.mode = "plane-rotate";
-          nextDrag.rotationPlane = plane;
-          nextDrag.startRadial = radial.normalize();
-        }
-      }
-      if (nextDrag.mode !== "plane-rotate") {
-        nextDrag.screenRotationDirection = screenRotationDirection(startPosition, axis);
-        if (!nextDrag.screenRotationDirection) return;
-        nextDrag.mode = "screen-rotate";
+  // Sliding along the plane normal. Pointing the normal at the camera leaves
+  // the axis almost no screen travel to slide along - and the ray may miss it
+  // outright - so vertical pointer motion drives the offset instead.
+  function beginTranslateDrag(record, ray) {
+    const alignment = axisViewAlignment(record.startPosition, record.axis);
+    record.startParameter = axisParameterFromRay(ray, record.startPosition, record.axis);
+    record.mode = alignment > TRANSLATION_SCREEN_ALIGNMENT
+      || record.startParameter == null
+      ? "screen-translate"
+      : "axis-translate";
+    return record;
+  }
+
+  // Spinning about a ring axis. Resolving the drag geometrically against the
+  // rotation plane only works when we are looking down that axis; edge-on, the
+  // plane is nearly parallel to the view and the intersection is useless, so
+  // the angle comes from pointer travel perpendicular to the on-screen axis.
+  // Returns null when neither route is usable, which aborts the press.
+  function beginRotateDrag(record, ray) {
+    const alignment = axisViewAlignment(record.startPosition, record.axis);
+    if (alignment >= ROTATION_SCREEN_ALIGNMENT) {
+      const plane = new THREE.Plane()
+        .setFromNormalAndCoplanarPoint(record.axis, record.startPosition);
+      const point = ray.intersectPlane(plane, new THREE.Vector3());
+      const radial = point?.sub(record.startPosition);
+      if (radial && radial.lengthSq() >= 1e-12) {
+        record.mode = "plane-rotate";
+        record.rotationPlane = plane;
+        record.startRadial = radial.normalize();
+        return record;
       }
     }
+    record.screenRotationDirection = screenRotationDirection(record.startPosition, record.axis);
+    if (!record.screenRotationDirection) return null;
+    record.mode = "screen-rotate";
+    return record;
+  }
+
+  function onPointerDown(event) {
+    if (disposed || drag || !group.visible || (event.button != null && event.button !== 0)) return;
+    const ray = rayFromEvent(event);
+    if (!ray) return;
+    const handle = pick(event, ray);
+    if (!handle) return;
+
+    const record = baseDrag(event, handle);
+    const nextDrag = handle === "translate"
+      ? beginTranslateDrag(record, ray)
+      : beginRotateDrag(record, ray);
+    if (!nextDrag) return;
 
     setHoveredHandle(handle);
     onActivity();
@@ -680,8 +518,7 @@ export function createCutawayGizmo({
       }
       scene.remove(group);
       overlayScene.remove(handleRoot);
-      for (const geometry of geometries) geometry.dispose();
-      for (const material of materials) material.dispose();
+      sceneGraph.dispose();
     }
   }
 

package/src/framework/default-view.js

@@ -0,0 +1,46 @@
+// Which view a part opens on. The rule is independent of display order: an author
+// can flag a view `default: true` wherever it sits in the tab bar, and when nobody
+// flags one, the biggest view wins — the one placing the most sub-parts at the
+// part's defaults, which for a multi-view part is the assembly. Ties fall back to
+// declaration order, so every part written before this existed resolves to the view
+// it has always opened on.
+//
+// Pure: no DOM, no storage, no kernel, no build. The headless surfaces (measure /
+// verify / renderViews) deliberately do NOT use this — they stay on
+// Object.keys(part.views)[0], where a mechanically obvious rule matters more than a
+// convenient one.
+
+const isPlainObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
+
+// A sub-part counts toward a view when it lists that view and is enabled at the
+// part's defaults. A throwing `enabled` counts as present: the same instinct as
+// mount's throwing-`derive` handling, and an unrelated predicate bug shouldn't
+// silently demote a whole view.
+function placedCount(part, view, defaults) {
+  const parts = isPlainObject(part?.parts) ? part.parts : {};
+  let n = 0;
+  for (const sp of Object.values(parts)) {
+    if (!Array.isArray(sp?.views) || !sp.views.includes(view)) continue;
+    if (typeof sp.enabled !== "function") { n++; continue; }
+    try { if (sp.enabled(defaults)) n++; } catch { n++; }
+  }
+  return n;
+}
+
+export function resolveDefaultView(part) {
+  if (!isPlainObject(part?.views)) return null;
+  const keys = Object.keys(part.views);
+  if (keys.length === 0) return null;
+
+  const flagged = keys.find((k) => part.views[k]?.default === true);
+  if (flagged) return flagged;
+
+  const defaults = isPlainObject(part?.defaults) ? part.defaults : {};
+  let best = keys[0];
+  let bestCount = placedCount(part, best, defaults);
+  for (const k of keys.slice(1)) {
+    const n = placedCount(part, k, defaults);
+    if (n > bestCount) { best = k; bestCount = n; } // strict > keeps a tie on the earlier key
+  }
+  return best;
+}

package/src/framework/download.js

@@ -1,4 +1,5 @@
 import { zipSync } from "fflate";
+import { safeName } from "./safe-name.js";
 
 // Browser file-download helpers. Pure DOM/Blob utilities with no app state — the
 // worker produces the bytes; these just hand them to the browser as a download.
@@ -23,9 +24,13 @@ export function triggerDownload(data, filename, mime, sink) {
 // Download a set of built parts: a single part downloads directly; multiple parts
 // are bundled into one flat, store-only (level 0) zip named `zipName`. `sink`, if
 // given, is forwarded to triggerDownload so it receives the final bytes.
+//
+// Sub-part names come from the part's `export.name` — untrusted data — and become
+// zip entry names, so they go through safeName(): the zip must stay flat, and an
+// entry like "../evil.stl" would escape the target directory in naive extractors.
 export function downloadParts({ parts, ext, mime }, zipName, sink) {
-  if (parts.length === 1) return triggerDownload(parts[0].data, `${parts[0].name}.${ext}`, mime, sink);
+  if (parts.length === 1) return triggerDownload(parts[0].data, `${safeName(parts[0].name)}.${ext}`, mime, sink);
   const entries = {};
-  for (const p of parts) entries[`${p.name}.${ext}`] = new Uint8Array(p.data);
+  for (const p of parts) entries[`${safeName(p.name)}.${ext}`] = new Uint8Array(p.data);
   triggerDownload(zipSync(entries, { level: 0 }), zipName, "application/zip", sink);
 }

package/src/framework/export-controller.js

@@ -3,6 +3,17 @@
 // replies (progress/download/error) back to the Promise that started them.
 // Pure — no DOM, no worker; `send` and the sink are injected.
 import { triggerDownload, downloadParts } from "./download.js";
+import { safeName } from "./safe-name.js";
+
+// The one place the "which backend does this export format need" policy lives.
+// STEP is always OCCT — only OCCT (OpenCASCADE) emits exact B-rep; Manifold's mesh
+// CSG has no STEP writer. Every other format is free to use whichever backend the
+// caller is already using for preview. Both the UI export buttons (mount.js) and
+// the headless exportParts() API route through this so the rule is never encoded
+// twice.
+export function backendForFormat(format, defaultBackend) {
+  return format === "step" ? "occt" : defaultBackend();
+}
 
 export function createExportController({ send, currentView, title, defaultBackend = () => "manifold", currentParams = () => ({}) }) {
   const pending = new Map(); // jobId -> { resolve, reject, onProgress }
@@ -11,7 +22,7 @@ export function createExportController({ send, currentView, title, defaultBacken
   function exportParts({ parts, format, quality = "print", onProgress } = {}) {
     const jobId = nextId++;
     const type = `export-${format}`;
-    const backend = format === "step" ? "occt" : defaultBackend();
+    const backend = backendForFormat(format, defaultBackend);
     return new Promise((resolve, reject) => {
       pending.set(jobId, { resolve, reject, onProgress });
       send({ type, jobId, parts, view: currentView(), params: currentParams(), name: title(), quality }, backend);
@@ -32,7 +43,7 @@ export function createExportController({ send, currentView, title, defaultBacken
     }
     if (m.type === "download-parts") {
       pending.delete(m.jobId);
-      const zipName = `${title() ?? "parts"}.zip`.toLowerCase().replace(/\s+/g, "-");
+      const zipName = `${safeName(title(), "parts")}.zip`; // title() is the part's meta.title — untrusted
       downloadParts(m, zipName, sink);
       entry.resolve();
       return true;

package/src/framework/geometry/probe.js

@@ -1,7 +1,7 @@
 // Geometry-free build execution. Two consumers share one Proxy implementation:
 //
-//  • createProbeKernel() — records op NAMES so detectBackend() can route a part to
-//    OCCT when it uses fillet/chamfer/shell.
+//  • createProbeKernel() — records op NAMES so ../backend-select.js's
+//    detectBackend() can route a part to OCCT when it uses fillet/chamfer/shell.
 //  • createValidatingProbe() — additionally checks op names against the kernel
 //    contract's op lists and routes options-form calls through the same op-options
 //    normalizers the real backends use, so partforge/lint can catch a bad call in
@@ -14,13 +14,10 @@
 // validating probe DOES need an allowlist, so it takes one from kernel.js's op
 // lists, which test/kernel-contract.test.js pins to both backend implementations.
 import {
-  OCCT_ONLY_OPS, KERNEL_OPS, KERNEL_OPTIONAL_OPS,
+  KERNEL_OPS, KERNEL_OPTIONAL_OPS,
   SOLID_OPS, SOLID_OPTIONAL_OPS, SHAPE2D_OPS,
 } from "./kernel.js";
 import { KERNEL_OP_SPECS, SOLID_OP_SPECS, isPlainOptions } from "./op-options.js";
-import { resolveDerived } from "../derive.js";
-
-const OCCT_ONLY = new Set(OCCT_ONLY_OPS);
 
 // The probe returns ONE chainable handle for every non-query op, so it cannot tell a
 // Solid from a Shape2D — k.box() and k.shape2d() yield the same object. The solid-scope
@@ -145,19 +142,3 @@ export function runValidatingProbe(part, p, d, { maxOps = MAX_PROBE_OPS } = {})
   }
   return { calls: probe.calls, issues: probe.issues, used: probe.used, throws, runaway };
 }
-
-export function detectBackend(part, params = {}) {
-  if (part.meta?.backend) return part.meta.backend;
-  const p = { ...part.defaults, ...params };
-  let d = {};
-  // A throwing derive must not escape here — this runs on the main thread mid
-  // regen (after the busy spinner goes up). Probe with an empty `d`; the worker
-  // build hits the same throw and posts a proper error for the UI.
-  try { d = resolveDerived(part, p); } catch { /* fall through with d = {} */ }
-  const { kernel, used } = createProbeKernel();
-  for (const name of Object.keys(part.parts)) {
-    try { part.parts[name].build(kernel, p, d); } catch { /* probe miss → capability backstop covers it */ }
-  }
-  for (const op of used) if (OCCT_ONLY.has(op)) return "occt";
-  return "manifold";
-}

package/src/framework/jobs.js

@@ -1,45 +1,14 @@
+// The worker's job protocol. The pure part model it runs over — viewSubParts /
+// exportSubParts / resolveParams / buildPosed — lives in part-model.js, a leaf, so
+// the oracle and the collision check can share it without importing this async,
+// kernel-bound module back.
 import { meshTo3MF } from "./geometry/threemf.js";
 import { exportablePartNames } from "./export-select.js";
-import { resolveDerived } from "./derive.js";
 import { resolveFonts } from "./fonts.js";
-import { measure } from "../testing/measure.js";
-import { verify } from "../testing/verify.js";
-
-// Names of the sub-parts a view shows: declared in the view and enabled for these
-// params. Order follows Object.keys(part.parts) (definition order).
-export function viewSubParts(part, view, params) {
-  return Object.keys(part.parts).filter((name) => {
-    const sp = part.parts[name];
-    const inView = sp.views.includes(view);
-    const on = sp.enabled ? !!sp.enabled(params) : true;
-    return inView && on;
-  });
-}
-
-// Sub-parts to include in an EXPORT of this view: the visible sub-parts, minus any
-// flagged `exportable: false` (reference/preview-only parts — motor ghosts, bearing
-// placeholders, etc.). They still show in the viewer; they're just never written to
-// an STL/STEP/3MF file, so the user never has to toggle them off before exporting.
-export function exportSubParts(part, view, params) {
-  return viewSubParts(part, view, params).filter((name) => part.parts[name].exportable !== false);
-}
-
-// Resolve a part's effective params + derived values for a build: the user's params
-// layered over the part defaults, and derive() run once over the result.
-export function resolveParams(part, params) {
-  const p = { ...part.defaults, ...params };
-  return { p, d: resolveDerived(part, p) };
-}
-
-// Build one sub-part and apply its optional place() for the given purpose/view.
-// `p`/`d` come from resolveParams(). This is the SINGLE definition of "a posed
-// sub-part solid" — the worker, the collision check, and the test harness all call
-// it, so display/export poses can never drift between the app and its tests.
-export function buildPosed(kernel, part, name, { purpose, view, p, d, onProgress } = {}) {
-  const sp = part.parts[name];
-  const solid = sp.build(kernel, p, d, onProgress);
-  return sp.place ? sp.place(solid, { view, purpose, p, d }) : solid;
-}
+import { safeName } from "./safe-name.js";
+import { exportSubParts, resolveParams, buildPosed } from "./part-model.js";
+import { measure } from "./oracle/measure.js";
+import { verify } from "./oracle/verify.js";
 
 // Handle one geometry job, posting results/progress via `post(msg, transfer?)`.
 // Backend-agnostic and part-agnostic: every part specific comes through `part`.
@@ -82,7 +51,7 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       msg.parts
         ? exportablePartNames(part, p).filter((name) => msg.parts.includes(name))
         : exportSubParts(part, msg.view, p);
-    const fileBase = msg.name ?? msg.view; // STEP/3MF single-file name base
+    const fileBase = safeName(msg.name ?? msg.view); // STEP/3MF single-file name base (part-derived → untrusted)
 
     if (msg.type === "generate") {
       const t0 = Date.now();
@@ -149,9 +118,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 });
     }

package/src/framework/lint/finding.js

@@ -18,3 +18,7 @@ const make = (severity) => (rule, message, hint, path = "", pattern) => ({
 export const err = make("error");
 // warning → suspicious or lossy, but the part behaves as authored.
 export const warn = make("warning");
+// note → neither broken nor suspicious; informational context an authoring
+// agent should see (e.g. "this animated track rebuilds geometry"). Notes never
+// gate measure or --strict.
+export const note = make("note");