partforge 0.141.0 → 0.143.0

package/src/framework/lint/rules-place.js

@@ -1,10 +1,16 @@
-// 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,
+// Lint ids here: views-invalid (a sub-part whose views is neither form), place-not-rigid (legacy views-array + place() form), and for the views-map
+// form view-entry-invalid (an entry that is not true or a pose), views-and-place (an author
+// place beside a map) and view-pose-not-rigid (an entry that reshapes instead of moving).
+// 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
@@ -12,7 +18,9 @@
 // and stays silent. Readability, not `trusted`, gates the rules: the same reshape
 // on both purposes is allowed, so a reshaping place() must still be compared.
 import { err } from "./finding.js";
-import { probeSubPartPose } from "../pose-probe-core.js";
+import { probeSubPartPose, CANONICAL } from "../pose-probe-core.js";
+import { isViewsMap, inView, formOf } from "../sub-part-views.js";
+import { isSheetPart } from "../sheet/constants.js";
 
 const isPlainObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
 
@@ -21,46 +29,21 @@ const isPlainObject = (x) => x !== null && typeof x === "object" && !Array.isArr
 // imported from jobs.js, which would break the lint purity closure.
 function viewNames(part, view, p) {
   return Object.entries(isPlainObject(part?.parts) ? part.parts : {})
-    .filter(([, sp]) => Array.isArray(sp?.views) && sp.views.includes(view))
+    .filter(([, sp]) => inView(sp, view))
     .filter(([, sp]) => { try { return sp.enabled ? !!sp.enabled(p) : true; } catch { return false; } })
     .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 }) => {
       const out = [];
       for (const [name, sp] of Object.entries(isPlainObject(part?.parts) ? part.parts : {})) {
-        if (!sp?.place) continue;
+        if (!sp?.place || formOf(sp) === "map") continue;
         for (const view of Object.keys(isPlainObject(part?.views) ? part.views : {})) {
           if (!viewNames(part, view, p).includes(name)) continue;
           const display = probePlace(sp, { view, purpose: "display", p, d });
@@ -79,4 +62,77 @@ export const PLACE_RULES = [
       return out;
     },
   },
+  {
+    id: "views-invalid",
+    run: ({ part }) => {
+      const out = [];
+      for (const [name, sp] of Object.entries(isPlainObject(part?.parts) ? part.parts : {})) {
+        const v = sp?.views;
+        if (Array.isArray(v) || isPlainObject(v)) continue;
+        out.push(err("views-invalid",
+          `sub-part "${name}" has no usable \`views\` (it is ${v === undefined ? "missing" : JSON.stringify(v) ?? String(v)})`,
+          "Give the sub-part a `views` map — e.g. `views: { assembly: true }` — naming each view it appears in.",
+          `parts.${name}.views`,
+          "views-invalid"));
+      }
+      return out;
+    },
+  },
+  {
+    id: "view-entry-invalid",
+    run: ({ part }) => {
+      const out = [];
+      for (const [name, sp] of Object.entries(isPlainObject(part?.parts) ? part.parts : {})) {
+        if (!isViewsMap(sp?.views)) continue;
+        for (const [view, entry] of Object.entries(sp.views)) {
+          if (entry === true || typeof entry === "function") continue;
+          out.push(err("view-entry-invalid",
+            `sub-part "${name}" has ${JSON.stringify(entry) ?? String(entry)} for view "${view}"`,
+            `Each entry in a sub-part's \`views\` map is \`true\` (shown as built) or a pose \`(s, p, d) => s.translate(…)\`. To leave the piece out of "${view}", delete the key.`,
+            `parts.${name}.views.${view}`,
+            "view-entry-invalid"));
+        }
+      }
+      return out;
+    },
+  },
+  {
+    id: "views-and-place",
+    run: ({ part }) => {
+      const out = [];
+      for (const [name, sp] of Object.entries(isPlainObject(part?.parts) ? part.parts : {})) {
+        if (!isViewsMap(sp?.views) || typeof sp.place !== "function") continue;
+        const generated = isSheetPart(sp) && sp.place === sp.sheet.generatedPlace && sp.sheet.place == null;
+        if (generated) continue;
+        out.push(err("views-and-place",
+          `sub-part "${name}" has both a \`views\` map and \`place\``,
+          "Put each view's pose in its `views` entry and delete `place`. `build()` makes the piece as it prints — that is what exports.",
+          `parts.${name}.place`,
+          "views-and-place"));
+      }
+      return out;
+    },
+  },
+  {
+    id: "view-pose-not-rigid",
+    run: ({ part, p, d }) => {
+      const out = [];
+      for (const [name, sp] of Object.entries(isPlainObject(part?.parts) ? part.parts : {})) {
+        if (!isViewsMap(sp?.views)) continue;
+        for (const [view, entry] of Object.entries(sp.views)) {
+          if (typeof entry !== "function") continue;
+          // Display only: map poses never apply on export, so there is no second purpose to probe.
+          const probe = probePlace(sp, { view, purpose: "display", p, d });
+          if (!readable(probe) || probe.baseHash === CANONICAL) continue;
+          out.push(err("view-pose-not-rigid",
+            `sub-part "${name}"'s pose for view "${view}" reshapes the piece`,
+            "A view's pose may only translate or rotate its argument — no `scale`, `mirror` or boolean. Bake a resized or reflected form into `build()` so every view shows the same physical piece.",
+            `parts.${name}.views.${view}`,
+            "view-pose-not-rigid"));
+          break; // one finding per sub-part
+        }
+      }
+      return out;
+    },
+  },
 ];

package/src/framework/lint/rules-shape.js

@@ -3,6 +3,7 @@
 // defaults and build but not `views`, and had already drifted from the eval runner's
 // separate views check. One source of truth ends that split.
 import { err, warn } from "./finding.js";
+import { isViewsMap, viewsOf } from "../sub-part-views.js";
 import { SHEET_DOC_ID } from "../sheet/constants.js";
 
 // A sub-part that carries a `sheet` declaration but no build was meant to be a sheet
@@ -70,7 +71,7 @@ export const SHAPE_RULES = [
     id: "missing-views",
     run: ({ part }) => (isPlainObject(part?.views) && Object.keys(part.views).length > 0 ? [] : [
       err("missing-views", "the part has no `views` map",
-        "Add a top-level `views` object — e.g. `views: { main: { label: \"Main\" } }` — and list each view name in the owning sub-part's `views` array.",
+        "Add a top-level `views` object — e.g. `views: { main: { label: \"Main\" } }` — and give each sub-part a `views` map naming the views it appears in.",
         "views"),
     ]),
   },
@@ -81,15 +82,17 @@ export const SHAPE_RULES = [
       if (known.size === 0) return []; // missing-views already reported it; don't pile on
       const out = [];
       for (const [name, sp] of partEntries(part)) {
-        if (!Array.isArray(sp?.views)) continue;
-        sp.views.forEach((v, i) => {
+        const listed = Array.isArray(sp?.views) ? sp.views.map((v, i) => [v, `parts.${name}.views[${i}]`])
+          : isViewsMap(sp?.views) ? Object.keys(sp.views).map((v) => [v, `parts.${name}.views.${v}`])
+          : [];
+        for (const [v, path] of listed) {
           if (!known.has(v)) {
             out.push(err("part-view-unknown",
               `sub-part "${name}" lists view "${v}", which is not in the \`views\` map`,
               `Add "${v}" to the top-level \`views\` map, or correct the name to one of: ${[...known].join(", ")}.`,
-              `parts.${name}.views[${i}]`));
+              path));
           }
-        });
+        }
       }
       return out;
     },
@@ -100,12 +103,12 @@ export const SHAPE_RULES = [
       if (!isPlainObject(part?.views)) return [];
       const used = new Set();
       for (const [, sp] of partEntries(part)) {
-        if (Array.isArray(sp?.views)) for (const v of sp.views) used.add(v);
+        for (const v of viewsOf(sp)) used.add(v);
       }
       return Object.keys(part.views)
         .filter((v) => !used.has(v))
         .map((v) => warn("view-unused", `view "${v}" is not listed by any sub-part`,
-          `Either add "${v}" to a sub-part's \`views\` array or remove it from the \`views\` map — as it stands the view renders empty.`,
+          `Either add "${v}" to a sub-part's \`views\` or remove it from the \`views\` map — as it stands the view renders empty.`,
           `views.${v}`));
     },
   },

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

@@ -4,6 +4,7 @@
 // (lint place-not-rigid), and the geometry-free pose probe reports each as a
 // list of rigid steps — so the display→export map is E · D⁻¹, with no geometry.
 // Three-free and DOM-free: the pose probe and pose.js are pure.
+import { placeOf } from "../sub-part-views.js";
 import { probeSubPartPose } from "../pose-probe-core.js";
 import { poseDelta, composePose } from "../geometry/pose.js";
 
@@ -14,7 +15,7 @@ const IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 // build that queries its solid cannot make it untrusted); a "posed" mesh already carries the
 // display pose, so the map is E · D⁻¹.
 export function printFrameMatrix(subPart, { view, p, d, frame = "posed" }) {
-  if (!subPart?.place) return [...IDENTITY];
+  if (!placeOf(subPart)) return [...IDENTITY];
   if (frame === "canonical") {
     const exp = probeSubPartPose(subPart, { view, purpose: "export", p, d }, { scope: "place" });
     return exp.trusted ? composePose(exp.pose) : [...IDENTITY];
@@ -24,3 +25,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 (!placeOf(subPart)) 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/materials/sheet-look.js

@@ -17,6 +17,7 @@
 // (resolve.js's default for every other sub-part) but the sheet its stock label names —
 // realisticDisplay, from the ONE keyword table STOCK_LOOKS. Realistic-only, like the PLA
 // default: the CAD view, 3MF colours and declaresMaterials read sp.display itself.
+import { isViewsMap } from "../sub-part-views.js";
 import { isSheetPart, sheetMeta, MARK_DEPTH } from "../sheet/constants.js";
 import { poseSteps, validatePose } from "../sheet/pose.js";
 import { composePose, invertRigid } from "../geometry/pose.js";
@@ -145,6 +146,7 @@ export function burnsFor(sp) {
   if (sp.build !== sp.sheet.generatedBuild) return false;                   // a custom build is not the canonical sheet
   if (sp.sheet.place != null) return false;                                 // an author place moves it off its pose
   if ((sp.place ?? null) !== (sp.sheet.generatedPlace ?? null)) return false; // place replaced after sheetPart
+  if (isViewsMap(sp.views) && Object.values(sp.views).some((v) => typeof v === "function")) return false; // a pose entry moves it off its pose
   try { return lookOf(sp).params.pattern === "wood"; } catch { return false; }
 }
 

package/src/framework/mount.js

@@ -1027,6 +1027,8 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, pick
         // normal is enough to char a whole face. A print frame keeps its last value (the
         // worst it can do is run layer lines the wrong way).
         if (!resolved) { delete sheetFrames[n]; continue; }
+        // For a views-map sub-part the export pose is the build itself (plus a sheet pose), so a canonical
+        // delivery's print frame is identity — no special case, the probe reads the compiled placement.
         if (layerLined.has(n)) printFrames[n] = printFrameMatrix(part.parts[n], { view: at.view, ...resolved, frame });
         if (burning.has(n)) {
           const f = sheetFrameFor(part.parts[n], { ...resolved, frame });

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

package/src/framework/oracle/verify.js

@@ -290,7 +290,7 @@ export function evaluateCase(facts, { profile, expect, subPartNames, overhang =
       checks.push({ scope: "subpart", subpart: s.name, metric: "bbox", kind: "gate", expr: `<=[${profile.bed.join(",")}]`,
         actual: null, status: "skip", pass: null, unevaluated: true, note: PRINT_POSE_NOTE,
         message: `not measured: its print (export) pose did not build — ${s.printBboxError}`,
-        hint: "This printed part's place() failed for purpose \"export\", so its print size — and its STL/3MF export — is unavailable. Fix place() for the export pose; the bed check then runs." });
+        hint: "build() should make each piece as it prints — a printed piece shown in an assembly gets its assembled pose from its `views` entry, never from build(). Its export pose failed to build, so its print size — and its STL/3MF export — is unavailable. Fix the pose; the bed check then runs." });
     }
     const merged = {
       ...(profile?.minWall != null ? { minWall: `>=${profile.minWall}` } : {}),

package/src/framework/param-deps.js

@@ -3,6 +3,7 @@
 import { recorder, expandDerivedReads } from "./read-recorder.js";
 import { resolveDerivedAttributed } from "./derive.js";
 import { createProbeKernel } from "./geometry/probe.js";
+import { inView, placeOf } from "./sub-part-views.js";
 import { byteAwareReplacer } from "./geometry/solid-hash.js";
 import { viewSubParts } from "./part-model.js";
 
@@ -21,7 +22,7 @@ export function relevantParamKeys(part, view, params) {
     // sub-part is currently hidden (on-screen ones are already in `reads`).
     for (const name of Object.keys(part.parts)) {
       const sp = part.parts[name];
-      if (sp.views.includes(view) && sp.enabled) sp.enabled(recorder(params, relevant));
+      if (inView(sp, view) && sp.enabled) sp.enabled(recorder(params, relevant));
     }
     return relevant;
   } catch {
@@ -48,7 +49,8 @@ export function subPartReadKeys(part, view, params) {
       // place() shapes what's on screen too (display pose is baked into the cached
       // mesh), so its reads count — without this, a param consumed only by place()
       // would let the mesh cache skip a rebuild and leave the sub-part misplaced.
-      if (sp.place) sp.place(built, { view, purpose: "display", p: recorder(params, reads), d: recorder(derived, dSeen) });
+      const place = placeOf(sp);
+      if (place) place(built, { view, purpose: "display", p: recorder(params, reads), d: recorder(derived, dSeen) });
       map.set(name, expandDerivedReads(reads, dSeen, { depsOf, allInputs }));
     }
     return map;
@@ -102,7 +104,7 @@ export function recordedRelevantKeys(part, view, params, readsOf) {
     }
     for (const name of Object.keys(part.parts)) {
       const sp = part.parts[name];
-      if (sp.views.includes(view) && sp.enabled) sp.enabled(recorder(params, relevant));
+      if (inView(sp, view) && sp.enabled) sp.enabled(recorder(params, relevant));
     }
     return relevant;
   } catch {

package/src/framework/part-model.js

@@ -11,15 +11,15 @@
 // oracle depend on the part model without an import cycle back through the job loop.
 import { resolveDerived, resolveDerivedAttributed } from "./derive.js";
 import { recorder } from "./read-recorder.js";
+import { inView, placeOf } from "./sub-part-views.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;
+    return inView(sp, view) && on;
   });
 }
 
@@ -70,12 +70,13 @@ export function resolveParams(part, params, sanitize, reads) {
   return recordedParams(resolved, reads);
 }
 
-// Build one sub-part and apply its optional place() for the given purpose/view.
+// Build one sub-part and apply its placement (sub-part-views.js placeOf — a legacy place() or the compiled views map) 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;
+  const place = placeOf(sp);
+  return place ? place(solid, { view, purpose, p, d }) : solid;
 }

package/src/framework/pose-probe-core.js

@@ -16,6 +16,7 @@
 // same source text at every value of `p.z`, so hashing it would hold baseHash
 // stable while the real geometry changed — precisely the false-positive the fast
 // path must never make. Untrusted subparts simply take the normal regen path.
+import { placeOf } from "./sub-part-views.js";
 import { h } from "./geometry/solid-hash.js";
 import { addSugar } from "./geometry/solid-sugar.js";
 import { SOLID_OPS, SOLID_OPTIONAL_OPS, SHAPE2D_OPS, OCCT_ONLY_OPS } from "./geometry/kernel.js";
@@ -127,15 +128,16 @@ const stepsFinite = (steps) => steps.every((st) =>
 export function probeSubPartPose(sp, { view, purpose = "display", p, d }, { scope = "full" } = {}) {
   try {
     const { kernel, state, token } = makeProbeSession(); // fresh op budget + trust per subpart
+    const place = placeOf(sp);
     if (scope === "place") {
       let s = token(CANONICAL, []);
-      if (!sp.place) return { trusted: true, baseHash: CANONICAL, pose: [] };
-      s = sp.place(s, { view, purpose, p, d });
+      if (!place) return { trusted: true, baseHash: CANONICAL, pose: [] };
+      s = place(s, { view, purpose, p, d });
       if (!(s && s.__poseToken) || state.queried || state.unhashable || !stepsFinite(s._pose)) return { trusted: false };
       return { trusted: s._hash === CANONICAL, baseHash: s._hash, pose: s._pose };
     }
     let s = sp.build(kernel, p, d);
-    if (scope === "full" && sp.place) s = sp.place(s, { view, purpose, p, d });
+    if (scope === "full" && place) s = place(s, { view, purpose, p, d });
     const ok = s && s.__poseToken && !state.queried && !state.unhashable && stepsFinite(s._pose);
     return ok ? { trusted: true, baseHash: s._hash, pose: s._pose } : { trusted: false };
   } catch {

package/src/framework/sheet/part.js

@@ -15,7 +15,11 @@
 // and `sp.place === sp.sheet.generatedPlace`.
 //
 // Placement (decision 10): the pose applies for display AND export, then the author's
-// own `place` — so STEP/3MF/STL files of a sheet forge come out assembled.
+// own `place` — so STEP/3MF/STL files of a sheet forge come out assembled. With a views
+// map, the generated place is the BASE of the compiled placement (sub-part-views.js
+// placeOf): the pose applies for display and export, then the view's entry for display
+// only. Sheet entries are taught as `true`; a pose entry is allowed but drops the burn
+// pass (sheet-look.js burnsFor).
 import { RENAMED_KEYS, RESERVED_KEYS, SHEET_KEYS, SUBPART_PASSTHROUGH_KEYS } from "./constants.js";
 import { validatePose } from "./pose.js";
 import { applyPose, resolveSheet, sheetPreview } from "./resolve.js";

package/src/framework/sub-part-views.js

@@ -0,0 +1,56 @@
+// One sub-part's views and placement, in either authoring form.
+//
+//   map form:    views: { assembly: (s, p, d) => s.translate(…), lid: true }
+//   legacy form: views: ["assembly", "lid"], place: (s, { view, purpose, p, d }) => s
+//
+// Every reader of a sub-part's views or placement asks here, so the map form compiles to
+// the same place(s, { view, purpose, p, d }) the pose probe, the pose ladder, print frames
+// and the oracle already understand (spec 2026-10-04 "Compilation"). A map entry is `true`
+// (shown as built) or a rigid pose; anything else leaves the piece out of that view and is
+// lint's view-entry-invalid. Export never applies an entry: a map-form piece exports as
+// built. A base `place` on a map-form sub-part can only be sheetPart's generated pose
+// (lint's views-and-place refuses an author's), and it runs first for both purposes, as
+// sheet poses always have.
+//
+// Pure and import-free: lint rules import it (test/lint-purity.test.js).
+
+const isPlainObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
+const isEntry = (v) => v === true || typeof v === "function";
+
+export const isViewsMap = (views) => isPlainObject(views);
+
+export function viewsOf(sp) {
+  const v = sp?.views;
+  if (Array.isArray(v)) return v;
+  if (isPlainObject(v)) return Object.keys(v).filter((name) => isEntry(v[name]));
+  return [];
+}
+
+export const inView = (sp, view) => viewsOf(sp).includes(view);
+
+export const formOf = (sp) => (isViewsMap(sp?.views) ? "map" : "legacy");
+
+// Memo only: never identity-compared across module instances (the cloud worker loads two).
+const compiled = new WeakMap();
+
+export function placeOf(sp) {
+  if (!sp) return null;
+  if (compiled.has(sp)) return compiled.get(sp);
+  if (!isViewsMap(sp.views)) {
+    // A wrapper, so a method-style place keeps `this` when callers invoke it detached.
+    const legacy = typeof sp.place === "function" ? (s, ctx) => sp.place(s, ctx) : null;
+    compiled.set(sp, legacy);
+    return legacy;
+  }
+  const base = typeof sp.place === "function" ? sp.place : null;
+  const entries = sp.views;
+  const anyPose = Object.values(entries).some((v) => typeof v === "function");
+  const fn = !base && !anyPose ? null : (s, ctx) => {
+    const posed = base ? base(s, ctx) : s;
+    if (ctx.purpose === "export") return posed;
+    const entry = entries[ctx.view];
+    return typeof entry === "function" ? entry(posed, ctx.p, ctx.d) : posed;
+  };
+  compiled.set(sp, fn);
+  return fn;
+}

package/src/parts/hinged-box.js

@@ -1,7 +1,7 @@
 // Animation reference part — a box with a hinged lid. Worked example for
 // docs/AUTHORING-PARTS.md "Animations": animations are VIEW-OWNED (declared
 // under `views.box.animations`, so the transport bar belongs to that view),
-// they drive pose-only params (lidAngle, lidLift) through place(), and
+// they drive pose-only params (lidAngle, lidLift) through the lid's `views` entry, and
 // `assemble` opens with an OPACITY fade that brings the lid in from nothing
 // before any motion. Also shown: an intro camera + markdown description on
 // `open`, a looping autoplay `cycle`, and per-step cameras on `assemble`.
@@ -39,7 +39,7 @@ export default {
   parts: {
     base: {
       label: "Base",
-      views: ["box"],
+      views: { box: true },
       export: { name: "base" },
       display: { material: "walnut" },
       build: (k, p) =>
@@ -48,19 +48,18 @@ export default {
     },
     lid: {
       label: "Lid",
-      views: ["box"],
       export: { name: "lid" },
       display: { material: "walnut" },
-      build: (k, p) => k.box({ min: [0, 0, p.height], max: [p.width, p.depth, p.height + p.wall] }),
-      // Display: swing about the hinge line (rear top edge, axis +X through
-      // [0, depth, height]; negative angle opens upward), then the assembly
-      // lift. Export: the lid prints flat beside the base. Both poses are
-      // rigid motions of the same solid, and neither reads `view` — the two
-      // invariants lint's place rules hold every part to.
-      place: (s, { purpose, p }) =>
-        purpose === "export"
-          ? s.translate([p.width + 10, 0, -p.height])
-          : s.rotate(-p.lidAngle, [0, p.depth, p.height], [1, 0, 0]).translate([0, 0, p.lidLift]),
+      // Built as it prints: a flat plate at the origin. The `box` view sets it on the
+      // base, swings it about the hinge line (rear top edge, axis +X through
+      // [0, depth, height]; negative angle opens upward) and applies the assembly
+      // lift. lidAngle and lidLift are read only here, so both animate at frame rate.
+      build: (k, p) => k.box({ min: [0, 0, 0], max: [p.width, p.depth, p.wall] }),
+      views: {
+        box: (s, p) => s.translate([0, 0, p.height])
+          .rotate(-p.lidAngle, [0, p.depth, p.height], [1, 0, 0])
+          .translate([0, 0, p.lidLift]),
+      },
     },
   },
   views: {

package/src/parts/laser-box.js

@@ -32,17 +32,16 @@ function hinge(k, p, d) {
   return k.union([fixed, moving]);
 }
 
-// Display: flat hinge against the back panel's outside face, knuckles above the wall.
-// Export: the print pose, untouched — both hinges export the same solid.
-const hingePlace = (i) => (s, { purpose, p, d }) => (purpose === "export" ? s
-  : s.rotateX(90).at([d.hingeX[i], p.depth / 2 + HINGE.leafT, d.axisZ]));
+// Each hinge is built in its PRINT pose (above); the box view stands it up on the back
+// panel. Identical builds, so the kit still prints "hinge" ×2.
+const hingePose = (i) => (s, p, d) => s.rotateX(90).at([d.hingeX[i], p.depth / 2 + HINGE.leafT, d.axisZ]);
 
 // Tongue slots for both hinges, cut where the tongues really land (world → sheet).
 const hingeSlots = (k, p, d, pose, z) => d.hingeX.flatMap((hx) =>
   [hx - HINGE.tongueX, hx + HINGE.tongueX].map((x) =>
     k.shape2d(tab(p).slot).translate(worldToSheet(pose, [x, p.depth / 2, z]))));
 
-const PLY = { views: ["box"], display: { material: "plywood" }, material: "birch plywood", thickness: (p) => p.t };
+const PLY = { views: { box: true }, display: { material: "plywood" }, material: "birch plywood", thickness: (p) => p.t };
 const panel = (name, label, extra = {}) => sheetPart({
   ...PLY, label,
   profile: (k, p, d) => d.box[name].outline,       // drawn as seen from outside
@@ -97,10 +96,10 @@ export default {
         .cutAll(hingeSlots(k, p, d, d.lidPose, d.axisZ + d.tongueY)),
       pose: (p, d) => d.lidPose,
     }),
-    hingeL: { label: "Hinge (left)", views: ["box"], display: { material: "pla-print" },
-      export: { name: "hinge" }, build: hinge, place: hingePlace(0) },
-    hingeR: { label: "Hinge (right)", views: ["box"], display: { material: "pla-print" },
-      build: hinge, place: hingePlace(1) },    // identical solid: the kit prints "hinge" ×2
+    hingeL: { label: "Hinge (left)", views: { box: hingePose(0) }, display: { material: "pla-print" },
+      export: { name: "hinge" }, build: hinge },
+    hingeR: { label: "Hinge (right)", views: { box: hingePose(1) }, display: { material: "pla-print" },
+      build: hinge },    // identical solid: the kit prints "hinge" ×2
   },
   views: { box: { label: "Box" } },
   // `process` = the PRINTED parts' profile; sheet parts get the laser checks instead.