partforge 0.71.0 → 0.73.0

package/src/framework/oracle/verify.js

@@ -2,9 +2,8 @@ import { parseAssertion, evaluateAssertion } from "./assert-dsl.js";
 import { measure as defaultMeasure } from "./measure.js";
 import { pairKey, CONTACT_EPS } from "./gaps.js";
 import { resolveProfile } from "./dfm-profiles.js";
-import { expandCases } from "./cases.js";
+import { expandExpectations, partGatesMinWall } from "./gates.js";
 import { subPartReadKeys, relevanceHash, RELEVANT_ALL } from "../param-deps.js";
-import { resolveParams } from "../part-model.js";
 import { SUBPART_METRICS, VIEW_METRICS } from "../verify-metrics.js";
 
 // Re-exported for backwards compatibility: the registries moved to framework/ so
@@ -52,11 +51,19 @@ function pairGapChecks(facts, { contacts, clearance }, subPartNames) {
   // No gap table at all = legacy facts → skip. A table that MERELY LACKS the pair
   // = the sub-part built empty (meshGaps skips empty meshes) → a declared gate
   // must fail loudly, not skip, or verify.ok would vouch for an unverified pair.
+  // `measuredGaps === false` says the pass was deliberately skipped (a quick lap);
+  // an absent stamp is a legacy result, whose skip stays exactly as untagged as it
+  // has always been rather than retroactively withholding verdicts.
+  const gapsSkipped = facts.measuredGaps === false;
   const noReading = (base) => (facts.gaps
     ? { ...base, actual: null, status: "fail", pass: false,
         message: "no measured distance for the pair",
         hint: "one sub-part produced no mesh (an empty solid?) — fix the build before trusting this gate" }
-    : { ...base, actual: null, status: "skip", pass: null, message: "unavailable" });
+    : { ...base, actual: null, status: "skip", pass: null,
+        ...(gapsSkipped
+          ? { unevaluated: true, message: "not measured (quick check)",
+              hint: "re-run this check without `quick` to measure pair distances" }
+          : { message: "unavailable" }) });
 
   if (contacts != null && !Array.isArray(contacts)) {
     throw new Error(`contacts: must be an array of ["a", "b"] pairs, got ${JSON.stringify(contacts)}`);
@@ -157,12 +164,25 @@ export function evaluateCase(facts, { profile, expect, subPartNames }) {
   for (const [metric, expr] of Object.entries(viewExp)) checks.push(check("view", null, metric, expr, VIEW_METRICS, facts));
   checks.push(...pairGapChecks(facts, { contacts, clearance }, subPartNames));
 
+  // Same rule as gapsSkipped above, one metric over: a min-wall gate with no reading
+  // is a warn ("min wall unavailable"), which does not move `ok` — right when the
+  // rays were cast and all missed, wrong when they were never cast. The stamp is
+  // what tells those apart, and it is measure()'s own, never a caller's claim.
+  const minWallSkipped = facts.measuredMinWall === false;
   for (const s of facts.subparts) {
     const merged = {
       ...(profile?.minWall != null ? { minWall: `>=${profile.minWall}` } : {}),
       ...(expect?.[s.name] ?? {}),
     };
-    for (const [metric, expr] of Object.entries(merged)) checks.push(check("subpart", s.name, metric, expr, SUBPART_METRICS, s));
+    for (const [metric, expr] of Object.entries(merged)) {
+      const c = check("subpart", s.name, metric, expr, SUBPART_METRICS, s);
+      if (minWallSkipped && metric === "minWall" && c.actual == null) {
+        checks.push({ ...c, unevaluated: true, message: "not measured (quick check)",
+          hint: "re-run this check without `quick` to measure min wall" });
+        continue;
+      }
+      checks.push(c);
+    }
   }
   return checks;
 }
@@ -170,26 +190,23 @@ export function evaluateCase(facts, { profile, expect, subPartNames }) {
 // `seed` lets a caller that has ALREADY measured this part hand the result in so
 // verify does not recompute it — see the seeding block below for the shape and
 // the one correctness rule that governs it.
-export function verify(kernel, part, { process, view, measureFn = defaultMeasure, seed } = {}) {
+// `quick` is the fast lap (see jobs.js): evaluate everything the seed already
+// supports and MEASURE NOTHING. What that leaves unchecked is reported as
+// `unevaluated` rather than quietly downgraded, and one unevaluated gate withholds
+// `ok` — a fast lap yields facts, never a verdict.
+export function verify(kernel, part, { process, view, measureFn = defaultMeasure, seed, quick = false } = {}) {
   view = view ?? Object.keys(part.views)[0];
   const profileSpec = process ?? part.verify?.process;
   const profile = profileSpec ? resolveProfile(profileSpec) : null;
-  const expectSpec = part.verify?.expect ?? {};
 
-  const cases = expandCases(part);
   // `expect` can be a pure function of the case's resolved params — (p, d) →
   // expect object — so topology that legitimately changes with a preset (an
   // optional drain or bore flipping the genus) can be pinned per case instead
-  // of one static number that some presets must violate.
-  const resolveExpect = (params) => {
-    if (typeof expectSpec !== "function") return expectSpec;
-    const { p, d } = resolveParams(part, params);
-    return expectSpec(p, d) ?? {};
-  };
-  const expanded = cases.map((c) => ({ ...c, expect: resolveExpect(c.params) }));
-  const expectMentionsMinWall = expanded.some(({ expect }) =>
-    Object.values(expect).some((o) => o && typeof o === "object" && "minWall" in o));
-  const needMinWall = profile?.minWall != null || expectMentionsMinWall;
+  // of one static number that some presets must violate. The expansion lives in
+  // gates.js because measure() needs the same answer (it sizes the min-wall sample
+  // budget by it) and must not derive it separately — see there.
+  const expanded = expandExpectations(part);
+  const needMinWall = partGatesMinWall(part, { process, expanded });
   const readKeys = subPartReadKeys(part, view, part.defaults);
   const signature = (params) =>
     readKeys === RELEVANT_ALL
@@ -237,24 +254,48 @@ export function verify(kernel, part, { process, view, measureFn = defaultMeasure
   //
   // Non-default measure options (a custom `gapThreshold`) are the caller's
   // responsibility: seed only a measurement taken the way verify would take it.
-  if (seed?.result && (seed.result.measuredMinWall || !needMinWall) && seed.result.view === view) {
+  // Under `quick` the superset rule is not waived so much as satisfied differently:
+  // a min-wall-less seed is reused, and the min-wall gate it cannot answer becomes
+  // `unevaluated` instead of being re-measured. The rule exists to stop a coarse
+  // reading standing in for a gate's verdict, and a withheld verdict does that too.
+  if (seed?.result && (quick || seed.result.measuredMinWall || !needMinWall) && seed.result.view === view) {
     memo.set(signature({ ...part.defaults, ...(seed.params ?? {}) }), seed.result);
   }
 
   const measureCase = (params) => {
     const key = signature(params);
-    if (!memo.has(key)) memo.set(key, measureFn(kernel, part, view, params, { minWall: needMinWall }));
+    if (memo.has(key)) return memo.get(key);
+    if (quick) return null;   // a case the seed does not cover — reported, never built
+    memo.set(key, measureFn(kernel, part, view, params, { minWall: needMinWall }));
     return memo.get(key);
   };
 
   const subPartNames = Object.keys(part.parts);
-  const caseResults = expanded.map(({ name, params, expect }) => ({ name, params, checks: evaluateCase(measureCase(params), { profile, expect, subPartNames }) }));
+  // An unmeasured case gets ONE check standing for the whole case rather than a
+  // silent absence: "this preset was not checked" has to be visible in the same
+  // list every other verdict lives in, or a reader counting passes sees a shorter
+  // list and no reason.
+  const notMeasured = (name) => [{
+    scope: "case", subpart: null, metric: "measured", kind: "gate", expr: "measured",
+    actual: null, status: "skip", pass: null, unevaluated: true,
+    message: "not measured (quick check)",
+    hint: "re-run this check without `quick` to evaluate this case",
+  }];
+  const caseResults = expanded.map(({ name, params, expect }) => {
+    const facts = measureCase(params);
+    return { name, params, checks: facts ? evaluateCase(facts, { profile, expect, subPartNames }) : notMeasured(name) };
+  });
   const all = caseResults.flatMap((c) => c.checks.map((ch) => ({ case: c.name, ...ch })));
+  const failures = all.filter((c) => c.status === "fail");
+  const unevaluated = all.filter((c) => c.unevaluated);
   return {
-    ok: !all.some((c) => c.status === "fail"),
+    // Tri-state, and the order matters: a real failure is still a failure even on a
+    // lap that skipped other gates, so `false` outranks the withheld `null`.
+    ok: failures.length ? false : unevaluated.length ? null : true,
     view,
     cases: caseResults,
-    failures: all.filter((c) => c.status === "fail"),
+    failures,
     warnings: all.filter((c) => c.status === "warn"),
+    unevaluated,
   };
 }

package/src/framework/projection.js

@@ -0,0 +1,19 @@
+// The perspective <-> orthographic framing pair. Pure, so the swap's only
+// interesting property — that the part does not change size the instant the
+// user hits the toggle — is unit-testable without a renderer.
+//
+// Perspective frames by DISTANCE; orthographic frames by a frustum height plus
+// a zoom (OrbitControls dollies an ortho camera by changing camera.zoom, not by
+// moving it). These two functions convert between the two descriptions.
+
+const halfHeightAt = (fovDeg, distance) => distance * Math.tan((fovDeg * Math.PI) / 360);
+
+export function orthoFrustum({ fovDeg, distance, aspect = 1 }) {
+  const halfH = halfHeightAt(fovDeg, distance);
+  const halfW = halfH * aspect;
+  return { halfW, halfH, left: -halfW, right: halfW, top: halfH, bottom: -halfH };
+}
+
+export function perspectiveDistance({ halfH, zoom = 1, fovDeg }) {
+  return halfH / (zoom * Math.tan((fovDeg * Math.PI) / 360));
+}

package/src/framework/view-angles.js

@@ -15,13 +15,81 @@ const DIRS = {
   right:  { dir: [1, 0, 0],   up: [0, 1, 0] },
 };
 
+// The view cube's 26 orientations: 6 faces, 12 edges, 8 corners. Deliberately
+// SEPARATE from CANONICAL_VIEWS, which stays at 7 — captureViewsFromScene
+// slices against its length and the CLI names it, so growing that list would
+// change contracts the cube has no business touching. The seven canonical
+// names resolve to identical poses (iso === top-front-right).
+//
+// Face names are MODEL-frame (parts are authored Z-up); the world directions
+// below already carry the pivot's rotation.x = -PI/2, which maps model
+// (x, y, z) -> world (x, z, -y).
+const FACE_DIRS = {
+  right:  [1, 0, 0],   // model +X
+  left:   [-1, 0, 0],  // model -X
+  top:    [0, 1, 0],   // model +Z
+  bottom: [0, -1, 0],  // model -Z
+  front:  [0, 0, 1],   // model -Y
+  back:   [0, 0, -1],  // model +Y
+};
+
+// Canonical id ordering. A compound id always reads vertical, then depth, then
+// side — "top-front-right", never "right-front-top" — so cube-geom.js can
+// assemble an id from three independent axis choices and land on the same
+// string every time.
+const VERTICAL = ["top", "bottom"];
+const DEPTH = ["front", "back"];
+const SIDE = ["left", "right"];
+
+// A pure top or bottom view is degenerate against a +Y up vector, so those two
+// keep the special-cased ups DIRS already used. Every compound orientation has
+// a well-defined +Y up.
+//
+// These ups matter to the OFFSCREEN capture path, which builds a temp camera and
+// calls lookAt itself with no orbit frame to fall back on. The LIVE camera never
+// needs them: it is driven through OrbitControls, whose polar frame derives the
+// same roll on its own at azimuth 0 (a top cue lands with screen-up on world -Z,
+// which is exactly [0, 0, -1]). Handing the live camera a non-+Y `up` would also
+// re-base every subsequent orbit drag and would not survive getCameraState, so it
+// deliberately keeps the default.
+function upFor(parts) {
+  if (parts.length === 1 && parts[0] === "top") return [0, 0, -1];
+  if (parts.length === 1 && parts[0] === "bottom") return [0, 0, 1];
+  return [0, 1, 0];
+}
+
+function buildOrientations() {
+  const out = {};
+  const add = (parts) => {
+    const dir = [0, 0, 0];
+    for (const part of parts) {
+      const d = FACE_DIRS[part];
+      dir[0] += d[0];
+      dir[1] += d[1];
+      dir[2] += d[2];
+    }
+    const id = parts.join("-");
+    out[id] = { id, parts: [...parts], dir, up: upFor(parts) };
+  };
+  for (const face of Object.keys(FACE_DIRS)) add([face]);
+  for (const v of VERTICAL) for (const other of [...DEPTH, ...SIDE]) add([v, other]);
+  for (const d of DEPTH) for (const s of SIDE) add([d, s]);
+  for (const v of VERTICAL) for (const d of DEPTH) for (const s of SIDE) add([v, d, s]);
+  return out;
+}
+
+export const ORIENTATIONS = buildOrientations();
+export const ORIENTATION_IDS = Object.keys(ORIENTATIONS);
+
 const norm = (v) => {
   const l = Math.hypot(v[0], v[1], v[2]) || 1;
   return [v[0] / l, v[1] / l, v[2] / l];
 };
 
 export function cameraPoseForView(view, { center, radius }) {
-  const a = DIRS[view];
+  // DIRS first so the seven canonical names keep their exact existing poses;
+  // ORIENTATIONS covers the other nineteen the cube can reach.
+  const a = DIRS[view] ?? ORIENTATIONS[view];
   if (!a) throw new Error(`unknown canonical view "${view}"`);
   const d = norm(a.dir);
   const dist = radius * 2.6 + 6; // matches viewer.frameTo's framing distance

package/src/framework/view-state.js

@@ -11,6 +11,7 @@
 const KEY = {
   camera: "partforge:camera",
   theme: "partforge:theme",
+  projection: "partforge:projection",
 };
 
 const viewKey = (partKey) => `partforge:view:${partKey}`;
@@ -55,6 +56,14 @@ export function saveTheme(mode) {
   if (mode === "light" || mode === "dark") write(KEY.theme, mode);
 }
 
+export function loadProjection() {
+  return read(KEY.projection) === "orthographic" ? "orthographic" : "perspective";
+}
+
+export function saveProjection(mode) {
+  if (mode === "perspective" || mode === "orthographic") write(KEY.projection, mode);
+}
+
 // `partKey` identifies the part — createViewTabs passes `meta.title`. Without one
 // there is nothing safe to key on, so both calls no-op rather than falling back to a
 // shared key (the cross-part bleed this scoping exists to remove).