partforge 0.41.0 → 0.45.0

package/src/framework/lint/index.js

@@ -13,8 +13,10 @@ import { SCHEMA_RULES } from "./rules-schema.js";
 import { runValidatingProbe } from "../geometry/probe.js";
 import { BUILD_RULES } from "./rules-build.js";
 import { VERIFY_RULES, resolveExpect } from "./rules-verify.js";
+import { ANIMATION_RULES } from "./rules-animations.js";
+import { PLACE_RULES } from "./rules-place.js";
 
-export const RULES = [...SHAPE_RULES, ...SCHEMA_RULES, ...BUILD_RULES, ...VERIFY_RULES];
+export const RULES = [...SHAPE_RULES, ...SCHEMA_RULES, ...BUILD_RULES, ...VERIFY_RULES, ...ANIMATION_RULES, ...PLACE_RULES];
 
 // Every rule runs inside a guard. lintPart is called on a user-facing hosted path
 // (partforge-cloud's sandbox), and a linter that takes down the preview it exists to
@@ -71,7 +73,7 @@ export function lintContext(part, params) {
  * Lint a PartDefinition. Never throws.
  * @param {object} part   the default-exported PartDefinition
  * @param {{params?: object}} [opts]  params layered over part.defaults for the probe pass
- * @returns {{ok: boolean, errors: object[], warnings: object[]}}
+ * @returns {{ok: boolean, errors: object[], warnings: object[], notes: object[]}}
  */
 export function lintPart(part, opts) {
   // `opts` is defaulted here, not via `= {}` on the parameter, because a default
@@ -95,6 +97,7 @@ export function lintPart(part, opts) {
         "This part is too malformed for lint to analyze safely — make sure `defaults`, `params`, and `verify`/`derive` are plain, side-effect-free data rather than throwing getters or hostile Proxies.",
         "")],
       warnings: [],
+      notes: [],
     };
   }
   const findings = runRules(RULES, ctx);
@@ -110,5 +113,6 @@ export function lintPart(part, opts) {
   }
   const errors = findings.filter((f) => f.severity === "error");
   const warnings = findings.filter((f) => f.severity === "warning");
-  return { ok: errors.length === 0, errors, warnings };
+  const notes = findings.filter((f) => f.severity === "note");
+  return { ok: errors.length === 0, errors, warnings, notes };
 }

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

@@ -0,0 +1,441 @@
+// Group 5 — the `animations` block (spec 2026-08-02-model-animation-design.md).
+// Everything but the last rule is static data validation: the block is pure
+// keyframe data by design, so lint can hold every track to the schema without
+// executing author code. `animation-track-rebuilds` is the exception — it runs
+// the geometry-free pose probe to classify each track as pose-only or
+// geometry-rebuilding, and reports the latter at the note tier.
+import { err, note } from "./finding.js";
+import { EASINGS } from "../animation.js";
+import { CANONICAL_VIEWS } from "../view-angles.js";
+import { probeSubPartPose } from "../pose-probe-core.js";
+import { resolveDerived } from "../derive.js";
+
+const isPlainObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
+
+// [name, spec] pairs, only when the block is well-shaped enough to walk.
+const animEntries = (part) =>
+  isPlainObject(part?.animations)
+    ? Object.entries(part.animations).filter(([, a]) => isPlainObject(a))
+    : [];
+
+// Steps in normalized-adjacent form for rule walks (does NOT validate — each
+// rule checks its own slice). A bare-tracks animation is one anonymous step.
+const rawSteps = (a) => (Array.isArray(a.steps) ? a.steps.filter(isPlainObject) : [{ ...a, label: null }]);
+
+// The control descriptor ranges, for value-in-range checks. Mirrors
+// rules-schema.js's collectDescriptors walk (not shared: each group owns its
+// own walk by design — see lint/index.js header).
+function paramRanges(part) {
+  const ranges = new Map();
+  const secs = Array.isArray(part?.parameters) ? part.parameters : [];
+  const add = (d) => {
+    if (d && typeof d.key === "string" && !ranges.has(d.key)) ranges.set(d.key, { min: d.min, max: d.max });
+  };
+  for (const sec of secs) {
+    for (const d of Array.isArray(sec?.advanced) ? sec.advanced : []) add(d);
+    for (const f of Array.isArray(sec?.features) ? sec.features : []) {
+      for (const s of Array.isArray(f?.sliders) ? f.sliders : []) add(s);
+    }
+  }
+  return ranges;
+}
+
+const validKeyframes = (kf) =>
+  Array.isArray(kf) && kf.length >= 2
+  && kf.every((e) => Array.isArray(e) && e.length === 2 && Number.isFinite(e[0]) && Number.isFinite(e[1]))
+  && kf[0][0] === 0 && kf[kf.length - 1][0] === 1
+  && kf.every((e, i) => i === 0 || e[0] > kf[i - 1][0]);
+
+export const ANIMATION_RULES = [
+  {
+    id: "animations-not-object",
+    run: ({ part }) => {
+      if (part?.animations === undefined) return [];
+      if (!isPlainObject(part.animations)) {
+        return [err("animations-not-object", "`animations` is not a plain object",
+          "Declare animations as `animations: { <name>: { duration, tracks } }` — see docs/AUTHORING-PARTS.md \"Animations\".",
+          "animations")];
+      }
+      return Object.entries(part.animations)
+        .filter(([, a]) => !isPlainObject(a))
+        .map(([name]) => err("animations-not-object", `animation "${name}" is not a plain object`,
+          "Each animations entry must be an object with `duration` + `tracks`, or `steps`.",
+          `animations.${name}`));
+    },
+  },
+  {
+    id: "animation-tracks-or-steps",
+    run: ({ part }) => {
+      const out = [];
+      for (const [name, a] of animEntries(part)) {
+        const hasTracks = a.tracks !== undefined;
+        const hasSteps = a.steps !== undefined;
+        if (hasTracks === hasSteps) {
+          out.push(err("animation-tracks-or-steps",
+            `animation "${name}" must have exactly one of \`tracks\` or \`steps\``,
+            "A single-phase animation declares `tracks` directly; a stepped one declares `steps: [{ label, duration, tracks }]`. Never both, never neither.",
+            `animations.${name}`));
+          continue;
+        }
+        if (hasSteps && (!Array.isArray(a.steps) || a.steps.length === 0 || !a.steps.every(isPlainObject))) {
+          out.push(err("animation-tracks-or-steps",
+            `animation "${name}" has an empty or malformed \`steps\` array`,
+            "`steps` must be a non-empty array of `{ label, duration, tracks }` objects.",
+            `animations.${name}.steps`));
+          continue;
+        }
+        const steps = rawSteps(a);
+        const trackful = (s) => isPlainObject(s.tracks) && Object.keys(s.tracks).length > 0;
+        if (!steps.some(trackful)) {
+          out.push(err("animation-tracks-or-steps",
+            `animation "${name}" animates nothing`,
+            "At least one step needs a non-empty `tracks` object mapping a param key to keyframes.",
+            hasSteps ? `animations.${name}.steps` : `animations.${name}.tracks`));
+          continue;
+        }
+        steps.forEach((s, i) => {
+          if (trackful(s)) return;
+          // A camera-only step is legal: it holds the pose and just moves the
+          // camera — an establishing shot before the motion starts. The runtime
+          // emits its cue and evaluate() holds the surrounding values, so lint
+          // must not reject what plays correctly.
+          if (hasSteps && s.camera != null) return;
+          out.push(err("animation-tracks-or-steps",
+            `animation "${name}"${hasSteps ? ` step ${i}` : ""} has no tracks`,
+            "Every step needs a non-empty `tracks` object mapping a param key to keyframes — or, for a step that only moves the camera, a `camera` angle.",
+            hasSteps ? `animations.${name}.steps[${i}].tracks` : `animations.${name}.tracks`));
+        });
+      }
+      return out;
+    },
+  },
+  {
+    id: "animation-unknown-param",
+    run: ({ part }) => {
+      if (!isPlainObject(part?.defaults)) return [];
+      const known = new Set(Object.keys(part.defaults));
+      const out = [];
+      for (const [name, a] of animEntries(part)) {
+        rawSteps(a).forEach((s, i) => {
+          for (const key of Object.keys(isPlainObject(s.tracks) ? s.tracks : {})) {
+            if (!known.has(key)) {
+              out.push(err("animation-unknown-param",
+                `animation "${name}" tracks "${key}", which is not in \`defaults\``,
+                `Animations drive existing params — add "${key}" to \`defaults\` (and a control for it), or correct the key.`,
+                `animations.${name}${a.steps ? `.steps[${i}]` : ""}.tracks.${key}`));
+            }
+          }
+        });
+      }
+      return out;
+    },
+  },
+  {
+    id: "animation-param-not-numeric",
+    run: ({ part }) => {
+      if (!isPlainObject(part?.defaults)) return [];
+      const out = [];
+      for (const [name, a] of animEntries(part)) {
+        rawSteps(a).forEach((s, i) => {
+          for (const key of Object.keys(isPlainObject(s.tracks) ? s.tracks : {})) {
+            if (key in part.defaults && typeof part.defaults[key] !== "number") {
+              out.push(err("animation-param-not-numeric",
+                `animation "${name}" tracks "${key}", whose default is not a number`,
+                "v1 animations interpolate numeric params only — text/choice params cannot be keyframed.",
+                `animations.${name}${a.steps ? `.steps[${i}]` : ""}.tracks.${key}`));
+            }
+          }
+        });
+      }
+      return out;
+    },
+  },
+  {
+    id: "animation-keyframes-invalid",
+    run: ({ part }) => {
+      const out = [];
+      for (const [name, a] of animEntries(part)) {
+        rawSteps(a).forEach((s, i) => {
+          for (const [key, kf] of Object.entries(isPlainObject(s.tracks) ? s.tracks : {})) {
+            if (!validKeyframes(kf)) {
+              out.push(err("animation-keyframes-invalid",
+                `animation "${name}" track "${key}" has invalid keyframes`,
+                "Keyframes are `[[t, value], …]` with finite numbers, at least two entries, `t` strictly ascending from exactly 0 to exactly 1.",
+                `animations.${name}${a.steps ? `.steps[${i}]` : ""}.tracks.${key}`));
+            }
+          }
+        });
+      }
+      return out;
+    },
+  },
+  {
+    id: "animation-value-out-of-range",
+    run: ({ part }) => {
+      const ranges = paramRanges(part);
+      const out = [];
+      for (const [name, a] of animEntries(part)) {
+        rawSteps(a).forEach((s, i) => {
+          for (const [key, kf] of Object.entries(isPlainObject(s.tracks) ? s.tracks : {})) {
+            const r = ranges.get(key);
+            if (!r || !validKeyframes(kf)) continue;
+            for (const [, v] of kf) {
+              if ((typeof r.min === "number" && v < r.min) || (typeof r.max === "number" && v > r.max)) {
+                out.push(err("animation-value-out-of-range",
+                  `animation "${name}" track "${key}" keyframe value ${v}, outside the control's range ${r.min ?? "-∞"}..${r.max ?? "∞"}`,
+                  "Keyframe values are applied as-is (the engine does not clamp) — widen the control's range or move the keyframe inside it.",
+                  `animations.${name}${a.steps ? `.steps[${i}]` : ""}.tracks.${key}`));
+                break; // one finding per track
+              }
+            }
+          }
+        });
+      }
+      return out;
+    },
+  },
+  {
+    id: "animation-duration-invalid",
+    run: ({ part }) => {
+      const out = [];
+      for (const [name, a] of animEntries(part)) {
+        rawSteps(a).forEach((s, i) => {
+          if (!(typeof s.duration === "number" && Number.isFinite(s.duration) && s.duration > 0)) {
+            out.push(err("animation-duration-invalid",
+              `animation "${name}"${a.steps ? ` step ${i}` : ""} has no positive \`duration\``,
+              "Every animation (or step) needs a finite `duration` in seconds, greater than 0.",
+              `animations.${name}${a.steps ? `.steps[${i}]` : ""}.duration`));
+          }
+        });
+      }
+      return out;
+    },
+  },
+  {
+    id: "animation-loop-invalid",
+    run: ({ part }) => {
+      const out = [];
+      for (const [name, a] of animEntries(part)) {
+        if (a.loop === undefined) continue;
+        // Type first, like `autoplay`. The runtime fails closed (normalizeAnimation
+        // reads `spec.loop === true`), so a truthy non-boolean does NOT loop — it
+        // silently means `false`. That is the safe default but not an obvious one,
+        // so the author has to hear about it here rather than wonder why `loop: 1`
+        // does nothing.
+        if (typeof a.loop !== "boolean") {
+          out.push(err("animation-loop-invalid",
+            `animation "${name}" has a non-boolean \`loop\``,
+            "`loop` must be `true` or `false`. Any other truthy value still loops at runtime, so it cannot be left to mean something else.",
+            `animations.${name}.loop`));
+          continue; // one error per field: the check below assumes a real boolean
+        }
+        if (a.loop && Array.isArray(a.steps) && a.steps.length > 1) {
+          out.push(err("animation-loop-invalid",
+            `animation "${name}" sets \`loop: true\` on a multi-step animation`,
+            "Loop is for continuous single-phase motion (gears). A stepped sequence replays via the transport instead — drop `loop` or collapse to one step.",
+            `animations.${name}.loop`));
+        }
+      }
+      return out;
+    },
+  },
+  {
+    id: "animation-step-label-duplicate",
+    run: ({ part }) => {
+      const out = [];
+      for (const [name, a] of animEntries(part)) {
+        if (!Array.isArray(a.steps)) continue;
+        const seen = new Set();
+        a.steps.forEach((s, i) => {
+          const label = s?.label;
+          if (typeof label !== "string") return;
+          if (seen.has(label)) {
+            out.push(err("animation-step-label-duplicate",
+              `animation "${name}" repeats the step label "${label}"`,
+              "Step labels identify steps in the transport UI and the CLI's `--step <label>` — make each unique.",
+              `animations.${name}.steps[${i}].label`));
+          }
+          seen.add(label);
+        });
+      }
+      return out;
+    },
+  },
+  {
+    id: "animation-easing-unknown",
+    run: ({ part }) => {
+      const out = [];
+      const check = (easing, path) => {
+        // Own-key test, not `in`: `"toString" in EASINGS` is true, so `in` would
+        // wave through every Object.prototype member. The runtime (easingFor)
+        // applies the same test and falls back to the default, so these names are
+        // caught here rather than silently mis-animating or throwing mid-frame.
+        if (easing !== undefined && !Object.hasOwn(EASINGS, easing)) {
+          out.push(err("animation-easing-unknown",
+            `unknown easing "${easing}"`,
+            `Use one of: ${Object.keys(EASINGS).join(", ")}.`,
+            path));
+        }
+      };
+      for (const [name, a] of animEntries(part)) {
+        check(a.easing, `animations.${name}.easing`);
+        if (Array.isArray(a.steps)) a.steps.forEach((s, i) => check(s?.easing, `animations.${name}.steps[${i}].easing`));
+      }
+      return out;
+    },
+  },
+  {
+    id: "animation-camera-invalid",
+    run: ({ part }) => {
+      const out = [];
+      const badName = (v) => typeof v !== "string" || !CANONICAL_VIEWS.includes(v);
+      for (const [name, a] of animEntries(part)) {
+        const stepCameras = Array.isArray(a.steps)
+          ? a.steps.map((s, i) => [s?.camera, i]).filter(([c]) => c !== undefined && c !== null)
+          : [];
+        if (a.camera != null && stepCameras.length) {
+          out.push(err("animation-camera-invalid",
+            `animation "${name}" mixes an animation-level \`camera\` with per-step cameras`,
+            "One camera mechanism per animation: either the animation-level name/cue-list, or per-step names — not both.",
+            `animations.${name}.camera`));
+        }
+        for (const [cam, i] of stepCameras) {
+          if (badName(cam)) {
+            out.push(err("animation-camera-invalid",
+              `animation "${name}" step ${i} camera "${cam}" is not a canonical angle`,
+              `Camera cues use the canonical angles: ${CANONICAL_VIEWS.join(", ")}.`,
+              `animations.${name}.steps[${i}].camera`));
+          }
+        }
+        // An explicit `camera: null` is "no camera", which is how
+        // normalizeAnimation reads it — not a malformed value to report.
+        if (a.camera == null) continue;
+        if (typeof a.camera === "string") {
+          if (badName(a.camera)) {
+            out.push(err("animation-camera-invalid",
+              `animation "${name}" camera "${a.camera}" is not a canonical angle`,
+              `Camera cues use the canonical angles: ${CANONICAL_VIEWS.join(", ")}.`,
+              `animations.${name}.camera`));
+          }
+        } else if (Array.isArray(a.camera)) {
+          const cues = a.camera;
+          const wellFormed = cues.length > 0 && cues.every((c) =>
+            Array.isArray(c) && c.length === 2 && Number.isFinite(c[0]) && c[0] >= 0 && c[0] <= 1 && !badName(c[1]));
+          const sorted = cues.every((c, i) => i === 0 || (Array.isArray(c) && Array.isArray(cues[i - 1]) && c[0] > cues[i - 1][0]));
+          if (!wellFormed || !sorted) {
+            out.push(err("animation-camera-invalid",
+              `animation "${name}" has an invalid camera cue list`,
+              `Cues are \`[[t, angle], …]\` with t strictly ascending in 0..1 and angles from: ${CANONICAL_VIEWS.join(", ")}.`,
+              `animations.${name}.camera`));
+          }
+        } else {
+          out.push(err("animation-camera-invalid",
+            `animation "${name}" \`camera\` is neither an angle name nor a cue list`,
+            "Use a canonical angle string, or `[[t, angle], …]` cues.",
+            `animations.${name}.camera`));
+        }
+      }
+      return out;
+    },
+  },
+  {
+    id: "animation-description-invalid",
+    run: ({ part }) => animEntries(part)
+      .filter(([, a]) => a.description !== undefined && typeof a.description !== "string")
+      .map(([name]) => err("animation-description-invalid",
+        `animation "${name}" \`description\` is not a string`,
+        "The description is CommonMark shown behind the ⓘ glyph — supply a string or omit it.",
+        `animations.${name}.description`)),
+  },
+  {
+    // note tier: performance shape, not correctness. A track whose param feeds
+    // real geometry still plays — just best-effort at worker cadence instead
+    // of frame rate — and the authoring agent should know which it wrote.
+    id: "animation-track-rebuilds",
+    run: ({ part, p }) => {
+      const out = [];
+      for (const [name, a] of animEntries(part)) {
+        const steps = rawSteps(a);
+        // value range per key: the min and max across every keyframe value the
+        // key ever takes, over every step that tracks it — not just the first
+        // and last keyframe, so an out-and-back track (e.g. a hinge cycle that
+        // returns to its start) still compares two genuinely different values.
+        const valueRange = new Map();
+        for (const s of steps) {
+          for (const [key, kf] of Object.entries(isPlainObject(s.tracks) ? s.tracks : {})) {
+            if (!validKeyframes(kf)) continue; // keyframes rule already reported it
+            for (const [, v] of kf) {
+              if (!valueRange.has(key)) valueRange.set(key, [v, v]);
+              else {
+                const range = valueRange.get(key);
+                if (v < range[0]) range[0] = v;
+                if (v > range[1]) range[1] = v;
+              }
+            }
+          }
+        }
+        for (const [key, [v0, v1]] of valueRange) {
+          if (typeof part?.defaults?.[key] !== "number") continue; // other rules own that
+          const cls = classifyTrack(part, p, key, v0, v1);
+          if (cls === "pose") continue;
+          out.push(note("animation-track-rebuilds",
+            cls === "rebuild"
+              ? `animation "${name}" track "${key}" rebuilds geometry — playback is best-effort, not frame-rate`
+              : `animation "${name}" track "${key}" cannot use the pose fast path (untrusted probe) — playback is best-effort`,
+            "Frame-rate playback needs the param to feed only rigid placement (translate/rotate in `place()` or at the end of `build`). If that's the intent, restructure so the param never feeds a geometry op, a query, or a function selector; if geometry morphing is the intent, this is expected.",
+            `animations.${name}`));
+        }
+      }
+      return out;
+    },
+  },
+  {
+    id: "animation-autoplay-invalid",
+    run: ({ part }) => {
+      const out = [];
+      let first = null;
+      for (const [name, a] of animEntries(part)) {
+        if (a.autoplay !== undefined && typeof a.autoplay !== "boolean") {
+          out.push(err("animation-autoplay-invalid",
+            `animation "${name}" \`autoplay\` is not a boolean`,
+            "Use `autoplay: true` on the one animation that should start on its own.",
+            `animations.${name}.autoplay`));
+          continue;
+        }
+        if (a.autoplay !== true) continue;
+        if (first == null) { first = name; continue; }
+        out.push(err("animation-autoplay-invalid",
+          `animations "${first}" and "${name}" both declare \`autoplay\``,
+          "Only one animation can auto-start — remove `autoplay` from all but one.",
+          `animations.${name}.autoplay`));
+      }
+      return out;
+    },
+  },
+];
+
+// Classify one animated param by probing every sub-part it can show, at the
+// track's two endpoint values: identical trusted baseHashes at both ends →
+// the param only re-poses ("pose"); differing hashes → real geometry
+// ("rebuild"); any untrusted probe → "untrusted" (the fast path will decline
+// it at runtime too). Mirrors the runtime trust model in pose-probe-core.js.
+function classifyTrack(part, p, key, v0, v1) {
+  let result = "pose";
+  for (const view of Object.keys(isPlainObject(part?.views) ? part.views : {})) {
+    for (const sp of Object.values(isPlainObject(part?.parts) ? part.parts : {})) {
+      if (!Array.isArray(sp?.views) || !sp.views.includes(view)) continue;
+      const probes = [];
+      for (const v of [v0, v1]) {
+        const pv = { ...p, [key]: v };
+        let dv;
+        try { dv = resolveDerived(part, pv) ?? {}; } catch { return "untrusted"; }
+        try { if (sp.enabled && !sp.enabled(pv)) { probes.push(null); continue; } } catch { return "untrusted"; }
+        probes.push(probeSubPartPose(sp, { view, purpose: "display", p: pv, d: dv }));
+      }
+      if (probes.some((x) => x && !x.trusted)) return "untrusted";
+      const [a, b] = probes;
+      if (a && b && a.baseHash !== b.baseHash) result = "rebuild";
+    }
+  }
+  return result;
+}

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

@@ -0,0 +1,76 @@
+// 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 geometry-free pose probe; an untrusted probe (query op /
+// function selector in build or place) proves nothing and stays silent — the
+// runtime declines the fast path for those sub-parts anyway.
+import { err } from "./finding.js";
+import { probeSubPartPose } from "../pose-probe-core.js";
+
+const isPlainObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
+
+// The sub-part names visible in a view at params p — restated locally (like
+// rules-schema.js restates controls.js's visibility predicates) rather than
+// 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]) => { try { return sp.enabled ? !!sp.enabled(p) : true; } catch { return false; } })
+    .map(([name]) => name);
+}
+
+const poseKey = (pose) => JSON.stringify(pose);
+
+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) => probeSubPartPose(sp, { view, purpose: "display", p, d }));
+        if (probes.some((x) => !x.trusted)) 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;
+        for (const view of Object.keys(isPlainObject(part?.views) ? part.views : {})) {
+          if (!viewNames(part, view, p).includes(name)) continue;
+          const display = probeSubPartPose(sp, { view, purpose: "display", p, d });
+          const exportP = probeSubPartPose(sp, { view, purpose: "export", p, d });
+          if (!display.trusted || !exportP.trusted) continue;
+          if (display.baseHash !== exportP.baseHash) {
+            out.push(err("place-not-rigid",
+              `sub-part "${name}" display and export placements differ by more than a rigid motion (view "${view}")`,
+              "place() may move a solid between purposes (translate/rotate) but never reshape it — a geometry op on one branch means the exported part is not the previewed part. Move the op into build().",
+              `parts.${name}.place`,
+              "place-not-rigid"));
+            break; // one finding per sub-part — further views add nothing
+          }
+        }
+      }
+      return out;
+    },
+  },
+];

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

@@ -83,6 +83,28 @@ export const SCHEMA_RULES = [
       return out;
     },
   },
+  {
+    id: "features-requires-on",
+    run: ({ part }) => {
+      const out = [];
+      sections(part).forEach((sec, si) => {
+        if (!sectionRenders(sec)) return;
+        arr(sec?.features).forEach((f, i) => {
+          // The panel treats "enabled" as `params[key] > 0`, so `on` has to be a
+          // positive number: a missing one writes undefined (NaN in the build),
+          // and 0 or a negative writes a value the panel reads straight back as
+          // "still off", leaving a checkbox that won't stay ticked.
+          if (f && !f.hidden && !(typeof f.on === "number" && f.on > 0)) {
+            out.push(err("features-requires-on",
+              `section "${sec.id ?? si}" feature ${i}${f.key ? ` ("${f.key}")` : ""} has no positive numeric \`on\` value`,
+              "Ticking a feature's checkbox writes `on` into the feature's own parameter, so a missing one writes `undefined` and the build reads it as NaN. Unlike a `toggles` entry — a plain flag that falls back to 1 — a feature's `on` is the real value the parameter takes when enabled (a diameter, a count), so there is no safe default to guess. It must be greater than 0, because the panel reads `> 0` as \"enabled\". Give the feature the value it should switch on to.",
+              `parameters[${si}].features[${i}]`));
+          }
+        });
+      });
+      return out;
+    },
+  },
   {
     id: "control-key-not-in-defaults",
     run: ({ part }) => {

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

@@ -83,4 +83,16 @@ export const SHAPE_RULES = [
           `views.${v}`));
     },
   },
+  {
+    id: "default-view-ambiguous",
+    run: ({ part }) => {
+      if (!isPlainObject(part?.views)) return [];
+      const flagged = Object.keys(part.views).filter((v) => part.views[v]?.default === true);
+      if (flagged.length < 2) return [];
+      return [warn("default-view-ambiguous",
+        `${flagged.length} views set \`default: true\`: ${flagged.map((v) => `"${v}"`).join(", ")}`,
+        `Only one view can open by default. The viewer takes the first one declared — "${flagged[0]}" — and ignores the rest; remove \`default: true\` from the others.`,
+        `views.${flagged[1]}.default`)];
+    },
+  },
 ];

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

@@ -4,8 +4,8 @@
 // Catching them statically removes both the wasted boot and the stdout caveat.
 import { err } from "./finding.js";
 import { SUBPART_METRICS, VIEW_METRICS } from "../verify-metrics.js";
-import { PROFILES } from "../../testing/dfm-profiles.js";
-import { parseAssertion } from "../../testing/assert-dsl.js";
+import { PROFILES } from "../oracle/dfm-profiles.js";
+import { parseAssertion } from "../oracle/assert-dsl.js";
 import { suggest } from "../geometry/op-options.js";
 
 // Resolve `expect` to a plain object. The function form (p, d) => ({…}) is invoked