partforge 0.141.0 → 0.142.0

package/docs/AUTHORING-PARTS.md

@@ -103,8 +103,8 @@ export default {
 - `place(solid, ctx)` is an optional escape hatch for parts whose **display pose differs
   from their export pose** (e.g. positioning a sub-part in an assembly). `ctx.purpose` is
   `"display"` or `"export"`; `ctx.view` is the active view. Default is identity, so simple
-  parts omit it. **Display placement must not depend on `view`** — display meshes are built
-  once per sub-part and cached across views (the viewer re-centres per view).
+  parts omit it. Display placement may depend on `view`: the viewer re-poses each
+  sub-part when the tab changes, so one sub-part can sit differently in two views.
   The viewer applies the display pose as a matrix over the canonical mesh, so `build()` may
   query geometry freely; only `place()` has to stay a rigid motion of its argument, reading
   `p` and `d`, for a pose-only param to play at frame rate and for layer lines to stay on
@@ -3721,12 +3721,11 @@ affect `ok`, `measure`, or `--strict`.
 
 **Place invariants**, found by running the geometry-free place probe (the same
 one animation's `animation-track-rebuilds` uses) against each sub-part's
-`place()`, even when `build()` queries the solid — `view-dependent-display-place` (display placement must not depend
-on the active view, since display meshes are cached across views) and
-`place-not-rigid` (display vs. export placement may differ only by a rigid
-motion — translate/rotate — never a reshape) (both errors). A `place()` the probe
-cannot read (it queries the solid or passes a function) stays silent for the two
-place rules and earns the `animation-track-rebuilds` note.
+`place()`, even when `build()` queries the solid — `place-not-rigid` (display vs.
+export placement may differ only by a rigid motion — translate/rotate — never a
+reshape; an error). A `place()` the probe cannot read (it queries the solid or
+passes a function) stays silent for the place rule and earns the
+`animation-track-rebuilds` note.
 
 **Appearance** (all warnings) — `unknown-material` (a `display.material` the
 library does not know; the viewer draws it as if it named none — a PLA print
@@ -3994,7 +3993,9 @@ a **min-wall** warning, and — only for a part that also declares
 `orientation: "print"` — an **overhang** warning: `overhangArea` is the mm² of
 downward-facing surface steeper than the profile's `overhang` angle (45° from vertical
 on the FDM profiles; resin carries none, since it prints on supports), measured per
-sub-part with the bed at that sub-part's own lowest Z, and warned past 1 mm². The
+sub-part in its print (export) pose — not as the view shows it — with the bed at that
+pose's own lowest Z, and warned past 1 mm²; the reported location is where the face sits
+in the view. The
 opt-in is deliberate: a profile says what a process can print, the orientation key
 says this part is laid out for it, and a part still being shaped, or one bound for a
 different process, should not be nagged about its underside. Writing your own
@@ -4429,8 +4430,6 @@ symptom first** — it maps error text → cause → fix. The invariants, one li
   232 and a box is 12, and every one is a boolean operand — so prefer instancing one
   union of a row over a chain of per-feature booleans, and drop counts the print
   cannot show.
-- **Display placement is view-independent**; only `place(..., { purpose: "export" })` may
-  depend on `view` ([view-dependent-display-place](ERROR-PATTERNS.md#view-dependent-display-place)).
 - **Keep geometry backend-agnostic** (kernel calls only); only STEP requires OCCT
   ([probe-routed-to-occt](ERROR-PATTERNS.md#probe-routed-to-occt),
   [occt-holes-watertight-na](ERROR-PATTERNS.md#occt-holes-watertight-na)).

package/docs/ERROR-PATTERNS.md

@@ -138,12 +138,6 @@ Variant literals under this entry: `extrude: unknown bevel option`, `extrude: be
 - **Cause:** OCCT and Manifold WASM must not boot in the same process.
 - **Fix:** Keep OCCT-booting tests in their own files (vitest isolates per file) and boot via `bootOcctKernel()` in a `beforeAll`. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Testing a part".
 
-## view-dependent-display-place
-
-- **Symptom:** A sub-part renders correctly in one view but appears misplaced (usually in its other-view pose) after switching views.
-- **Cause:** A `place` that depends on `ctx.view` for `purpose: "display"` — display meshes are built once per sub-part and cached across views.
-- **Fix:** Make display placement view-independent; only `place(..., { purpose: "export" })` may branch on `view`. The rule sees a `place()` behind any `build()`, including one that queries the solid; a `place()` it cannot read stays silent. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "The `PartDefinition` contract".
-
 ## place-not-rigid
 
 - **Symptom:** The exported/printed part is a mirror image of — or a different size than — the same part shown in the assembly/display view. Nothing throws: the preview looks right and only the STL/STEP is wrong, or vice-versa.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.141.0",
+  "version": "0.142.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/lint/rules-place.js

@@ -1,10 +1,13 @@
-// Group 6 — the two place() invariants (docs/AUTHORING-PARTS.md "Display vs
-// export placement"), promoted from doc-only conventions to lint because the
-// animation system leans on place() for every pose-only track:
-//   1. Display placement must not depend on the active view (display meshes
-//      are cached across views; a view-dependent pose serves stale geometry).
-//   2. Display vs export may differ only by a rigid motion (translate/rotate).
-// Both checks run the place-scope pose probe: place() alone, on a canonical token,
+// Group 6 — the place() invariant (docs/AUTHORING-PARTS.md "Display vs export
+// placement"), promoted from a doc-only convention to lint because the animation
+// system leans on place() for every pose-only track: display vs export may differ
+// only by a rigid motion (translate/rotate). A second rule, view-dependent-display-
+// place, forbade a display pose that varies by view; it was retired in 0.142 — since
+// 0.141 the viewer meshes the canonical build once (the mesh cache stamps the view)
+// and re-poses it on every tab switch, so the stale-geometry hazard it named is gone,
+// and as a lint ERROR it refused to load the one-piece-per-sub-part shape a per-view
+// layout needs (partforge-cloud feedback #161/#162).
+// The check runs the place-scope pose probe: place() alone, on a canonical token,
 // so build() may query freely without hiding a finding. A READABLE result carries
 // `baseHash` (CANONICAL for translate/rotate only, another hash when place()
 // reshapes) and `pose`; a place() the probe cannot read (it queries the solid or
@@ -26,35 +29,10 @@ function viewNames(part, view, p) {
     .map(([name]) => name);
 }
 
-const poseKey = (pose) => JSON.stringify(pose);
 const readable = (probe) => probe.baseHash !== undefined;
 const probePlace = (sp, ctx) => probeSubPartPose(sp, ctx, { scope: "place" });
 
 export const PLACE_RULES = [
-  {
-    id: "view-dependent-display-place",
-    run: ({ part, p, d }) => {
-      const out = [];
-      const views = Object.keys(isPlainObject(part?.views) ? part.views : {});
-      if (views.length < 2) return out;
-      for (const [name, sp] of Object.entries(isPlainObject(part?.parts) ? part.parts : {})) {
-        const inViews = views.filter((v) => viewNames(part, v, p).includes(name));
-        if (inViews.length < 2) continue;
-        const probes = inViews.map((view) => probePlace(sp, { view, purpose: "display", p, d }));
-        if (!probes.every(readable)) continue;
-        const first = probes[0];
-        const differs = probes.some((x) => x.baseHash !== first.baseHash || poseKey(x.pose) !== poseKey(first.pose));
-        if (differs) {
-          out.push(err("view-dependent-display-place",
-            `sub-part "${name}" display placement differs between views (${inViews.join(", ")})`,
-            "Display meshes are built once per sub-part and cached across views, so a view-dependent display pose shows stale geometry after a tab switch. Only `place(..., { purpose: \"export\" })` may vary; keep the display branch view-independent.",
-            `parts.${name}.place`,
-            "view-dependent-display-place"));
-        }
-      }
-      return out;
-    },
-  },
   {
     id: "place-not-rigid",
     run: ({ part, p, d }) => {

package/src/framework/materials/print-frame.js

@@ -24,3 +24,21 @@ export function printFrameMatrix(subPart, { view, p, d, frame = "posed" }) {
   if (!disp.trusted || !exp.trusted || disp.baseHash !== exp.baseHash) return [...IDENTITY];
   return poseDelta(exp.pose, disp.pose);
 }
+
+const isIdentity = (m) => m.every((v, i) => Math.abs(v - IDENTITY[i]) < 1e-12);
+
+// The map from a DISPLAY-posed solid to the same piece in its print (export) pose, for
+// the oracle's overhang reading — or null when the two poses are the same (no place(),
+// or a place() that moves nothing between purposes) or cannot be read. Place-scope
+// probes first: both poses are place(build), so E · D⁻¹ needs only place() to be
+// readable, and a build that queries its solid cannot make it untrusted. A place()
+// that only the full-scope probe reads falls back to printFrameMatrix's posed branch.
+export function displayToPrintMatrix(subPart, { view, p, d }) {
+  if (!subPart?.place) return null;
+  const disp = probeSubPartPose(subPart, { view, purpose: "display", p, d }, { scope: "place" });
+  const exp = probeSubPartPose(subPart, { view, purpose: "export", p, d }, { scope: "place" });
+  const m = disp.trusted && exp.trusted
+    ? poseDelta(exp.pose, disp.pose)
+    : printFrameMatrix(subPart, { view, p, d, frame: "posed" });
+  return isIdentity(m) ? null : m;
+}

package/src/framework/oracle/measure.js

@@ -4,7 +4,8 @@ import { assemblyOverlaps } from "../assembly.js";
 import { resolveParams, buildPosed } from "../part-model.js";
 import { newReadSink, expandReads } from "../read-recorder.js";
 import { probeSubPartPose } from "../pose-probe-core.js";
-import { composePose } from "../geometry/pose.js";
+import { composePose, invertRigid, transformPositions } from "../geometry/pose.js";
+import { displayToPrintMatrix } from "../materials/print-frame.js";
 import { isSheetPart, sheetMeta, SHEET_CHECK_BUDGET_MS, MARK_DEPTH } from "../sheet/constants.js";
 import { resolveSheet } from "../sheet/resolve.js";
 import { processFor } from "../process/registry.js";
@@ -128,6 +129,21 @@ const transformPoint = (m, [x, y, z]) => [
   m[2] * x + m[6] * y + m[10] * z + m[14],
 ];
 
+// Overhang of one printed sub-part in its PRINT pose. measure builds the display pose,
+// and a piece shown assembled (a lid closed over its box) is not how it prints: judging
+// its underside there flagged the wrong faces and missed the real ones. The display mesh
+// is carried into the export pose by a rigid matrix — no second build — and the bed is
+// that pose's own lowest Z; `at` comes back in display coordinates, where every other
+// finding of this view sits. An unreadable or identical pose measures as shown.
+function printPoseOverhang(mesh, sp, { view, p, d, maxAngle, displayBedZ }) {
+  const m = p ? displayToPrintMatrix(sp, { view, p, d }) : null;
+  if (!m) return overhang(mesh, { maxAngle, bedZ: displayBedZ });
+  const positions = Float32Array.from(mesh.positions);
+  transformPositions(positions, m);
+  const out = overhang({ positions, indices: mesh.indices }, { maxAngle });
+  return out?.at ? { ...out, at: transformPoint(invertRigid(m), out.at) } : out;
+}
+
 // One sheet row's facts, within `budget.left` ms of 2-D work, which it spends (see
 // measure()). A 2-D location is lifted through the sub-part's DISPLAY pose, as the geometry-free
 // probe records it, at mid-thickness; a pose the probe cannot trust (a place() that
@@ -268,6 +284,10 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
   // declaration order). A view without a sheet part measures exactly as it always has.
   const sheetView = built.some(({ name }) => isSheetPart(part.parts[name]));
   const sheetParams = sheetView ? resolveParams(part, params, undefined, reads) : null;
+  // The overhang reading poses each piece for print (printPoseOverhang), which reads the
+  // resolved params through place() — recorded into the same sink, since the reading
+  // depends on them.
+  const poseParams = overhangAngle != null ? (sheetParams ?? resolveParams(part, params, undefined, reads)) : null;
   // The print-pose sizes are read by one check, the process bed (verify passes whether
   // its profile has one; alone, measure asks the part's own profile), and each costs a
   // second build of the part — so they are built only for a bed.
@@ -286,14 +306,14 @@ export function measure(kernel, part, view = Object.keys(part.views)[0], params
       ? minWall(mesh, { bvh: cachedBVH(mesh, bvhCache), maxSamples: minWallSamples, band: wallBands[name] ?? null })
       : null;
     // One pass over the triangles, no index — cheap enough for every lap. The bed
-    // is this sub-part's own lowest Z, already in hand from bounds(). A sub-part
-    // that is never printed (`exportable: false` — a reference ghost, a probe
-    // slab, a placeholder) is not judged. Judged in the DISPLAY pose, which is
-    // what measure builds; a part whose export pose differs (a lid that prints
-    // flat beside its base) is a known gap, stated in the authoring docs.
-    // A sheet part is laser-cut, never printed: no overhang reading for it either.
+    // is this sub-part's own lowest Z in its PRINT pose (printPoseOverhang). A
+    // sub-part that is never printed (`exportable: false` — a reference ghost, a
+    // probe slab, a placeholder) is not judged. A sheet part is laser-cut, never
+    // printed: no overhang reading for it either.
     const printed = part.parts[name]?.exportable !== false && !sheet;
-    const oh = overhangAngle != null && printed ? overhang(mesh, { maxAngle: overhangAngle, bedZ: b.min[2] }) : null;
+    const oh = overhangAngle != null && printed
+      ? printPoseOverhang(mesh, part.parts[name], { view, ...poseParams, maxAngle: overhangAngle, displayBedZ: b.min[2] })
+      : 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