@hatiolab/figure-model 0.1.36 → 0.1.38

package/dist/v3-gate.d.ts

@@ -1,7 +1,7 @@
 import type { Axis, Vec3 } from './types.ts';
 import type { V3Asset } from './v3-asset-types.ts';
 import type { V3Geometry } from './v3-graph-types.ts';
-import { type Point } from './v3-mesh-compare.ts';
+import { type Point } from './v3-shape-sampling.ts';
 /** One placed body in the asset frame: its centre, axis-aligned world extents and rotation. */
 export interface V3WorldBox {
     part: string;
@@ -18,15 +18,24 @@ export interface V3WorldBox {
 export declare function v3WorldBoxesOf(geometry: readonly V3Geometry[], writers: ReadonlyMap<string, string>, options?: {
     points?: boolean;
 }): V3WorldBox[];
+/**
+ * Every placed body including the ones that are not drawn. The declared occupancy does not shrink or grow with
+ * visibility (V3 designer's ruling 2026-09-22), so the gate measures against this, not against the drawn set.
+ */
+export declare function v3OccupiedBoxesOf(geometry: readonly V3Geometry[], writers: ReadonlyMap<string, string>, options?: {
+    points?: boolean;
+}): V3WorldBox[];
 /** Who writes each graph value, by node id. */
 export declare function v3WritersOf(asset: V3Asset): Map<string, string>;
 export interface V3Violation {
-    code: 'OCCUPANCY_UNDECLARED' | 'PART_OUTSIDE_OCCUPANCY' | 'PARTS_OFF_PLACEMENT_FACE';
-    /** The part that is out, or the lowest / highest part for the placement face. */
+    code: 'OCCUPANCY_UNDECLARED' | 'PART_OUTSIDE_OCCUPANCY' | 'PARTS_OFF_PLACEMENT_FACE' | 'PLACEMENT_FACE_TILTED';
+    /** The part that is out, or the one whose face the asset declares as what it is mounted on. */
     part?: string;
     axis?: Axis;
-    /** How far, in mm, rounded to 0.1 µm as V2 does. */
+    /** How far, in mm, rounded to 0.1 µm as V2 does. A distance, never an angle. */
     mm?: number;
+    /** How far off parallel, in degrees. Kept apart from `mm` so a reader never adds the two. */
+    degrees?: number;
     detail: string;
 }
 /**
@@ -53,6 +62,23 @@ export interface V3Coverage {
     unprovable?: string[];
     detail: string;
 }
+/**
+ * What each operator does to a value's extremes over the state box. Every operator in the kernel is listed by
+ * name — no pattern, no default — so a new one has no classification until someone writes its basis down, and
+ * `v3-state-dimension.test.ts` fails until they do.
+ *
+ *  - `multilinear`: degree one in each state input given multilinear arguments, so the extreme sits at a corner
+ *    however the value is later combined. Sums; products and quotients under the conditions checked in
+ *    `cornerExtremalBasis`; poses and the structural operators, which translate and select but never bend a
+ *    coordinate; the shape providers, whose extents are linear in their arguments; `feature@1`, whose pose is a
+ *    linear combination of the shape's dimensions with an axis fixed by the feature's name, not by its size.
+ *  - `monotone`: monotone in each argument, and not multilinear. Such a value may be a final coordinate on its
+ *    own, and combining it with anything else that moves with the same state input is refused. Each carries its
+ *    own condition in `cornerExtremalBasis`: `min`/`max` refuse arguments that share an input, `curve` refuses
+ *    keys that move or turn around, `geomean` refuses factors that share an input.
+ *  - `unknown`: nothing is claimed. A state-dependent argument here means the coverage falls back to sampling.
+ */
+export declare const V3_STATE_EXTREME_BASIS: Readonly<Record<string, 'multilinear' | 'monotone' | 'unknown'>>;
 /**
  * Why the extremes of every state-dependent coordinate lie at the corners of the state box, or why that cannot be
  * shown. The basis: a value that is multilinear in the state inputs (each input to degree one) or a monotone
@@ -61,11 +87,38 @@ export interface V3Coverage {
  * denominator, and through translations in `rigid`. It does not hold through `sin`, `axis-turn`, a
  * state-dependent rotation angle in `rigid`, a state-dependent denominator, or a product of two values that share
  * an input. Returns the reasons it fails, empty when it holds.
+ *
+ * Monotone in each argument is not the same as monotone in a state input the arguments share, and a value that
+ * is merely monotone cannot be combined further. Both were found by the V3 designer, 2026-09-23:
+ * `10 + 100·min(q, 1−q)` is widest in the middle, and `10 + 100·(√q − q)` is widest at q = ¼. The gate called
+ * both proven.
+ *
+ * So the property is named rather than the operators that break it. A value is *multilinear* when it is degree
+ * one in each state input, which is what makes its extreme sit at a corner however it is later combined. Only
+ * the operators in `KEEPS_MULTILINEAR` below carry that property forward, and only under the conditions in the
+ * switch — a product of two values sharing an input, or a state-dependent denominator, does not. Every other
+ * operator, named or not, yields a value *bent* in each state input it depends on: at best monotone in that
+ * input, so it may stand as a final coordinate, but combining it with anything else that moves with the same
+ * input — a sum, a product, a pose composed onto it — is refused. A new operator is bent until someone shows
+ * it preserves multilinearity and adds it to the list.
  */
 export declare function cornerExtremalBasis(asset: V3Asset, dependence: Record<string, string[]>): string[];
 export interface V3Inspection {
-    /** The declared volume as evaluated, when declared. Centred on X and Z, from 0 to y on Y. */
-    extent?: Vec3;
+    /** The declared volume as evaluated, when declared: the reach on each side of the asset origin. */
+    bounds?: {
+        x: {
+            min: number;
+            max: number;
+        };
+        y: {
+            min: number;
+            max: number;
+        };
+        z: {
+            min: number;
+            max: number;
+        };
+    };
     placement?: 'floor' | 'ceiling' | 'center';
     coverage: V3Coverage;
     violations: V3Violation[];

package/dist/v3-gate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3-gate.d.ts","sourceRoot":"","sources":["../src/v3-gate.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAkC,KAAK,KAAK,EAAE,MAAM,sBAAsB,CAAA;AAEjF,+FAA+F;AAC/F,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,IAAI,CAAA;IACZ,oEAAoE;IACpE,MAAM,EAAE,IAAI,CAAA;IACZ,sGAAsG;IACtG,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAA;IACpB,yGAAyG;IACzG,MAAM,CAAC,EAAE,KAAK,EAAE,CAAA;CACjB;AAED,yHAAyH;AACzH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,UAAU,EAAE,CA6BtJ;AAED,+CAA+C;AAC/C,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAI/D;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,sBAAsB,GAAG,wBAAwB,GAAG,0BAA0B,CAAA;IACpF,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,oDAAoD;IACpD,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAA;IACzC,uDAAuD;IACvD,MAAM,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACvD,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAA;IACd,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IACrB,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM,EAAE,CA4DlG;AAED,MAAM,WAAW,YAAY;IAC3B,6FAA6F;IAC7F,MAAM,CAAC,EAAE,IAAI,CAAA;IACb,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,QAAQ,CAAA;IAC1C,QAAQ,EAAE,UAAU,CAAA;IACpB,UAAU,EAAE,WAAW,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,gHAAgH;IAChH,EAAE,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3B,mFAAmF;IACnF,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,0GAA0G;IAC1G,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAOD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAAG,YAAY,CAsFpH"}
+{"version":3,"file":"v3-gate.d.ts","sourceRoot":"","sources":["../src/v3-gate.ts"],"names":[],"mappings":"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"}

package/dist/v3-gate.js

@@ -20,14 +20,21 @@
  */
 import { compileV3Asset } from "./v3-asset.js";
 import { compileV3Graph } from "./v3-graph.js";
+import { resolveV3Surface, evaluateV3Surface } from "./v3-surface.js";
 import { AXES, SKIN } from "./types.js";
-import { transformPoints, v3ShapePoints } from "./v3-mesh-compare.js";
+/** How far a declared mounting face may lean off the plane before it is not that plane any more. */
+const CONTACT_TILT_DEG = 0.1;
+import { transformPoints, v3ShapePoints } from "./v3-shape-sampling.js";
 /** Axis-aligned world boxes of evaluated geometry. `part` is the placing node: a `place@1` id or the repeated member. */
 export function v3WorldBoxesOf(geometry, writers, options = {}) {
     const out = [];
     for (const g of geometry) {
         if (!('pose' in g))
             continue;
+        // A part whose visibility flag is off is not drawn, so it is not a drawn body here. It is still evaluated and
+        // still placed; `v3OccupiedBoxesOf` is the reader that wants it (the occupancy does not move with visibility).
+        if (g.visible === false)
+            continue;
         const part = g.key ? writers.get(g.key) : g.id;
         const d = g.shape.dimensions;
         const local = g.shape.provider === 'cylinder'
@@ -40,7 +47,38 @@ export function v3WorldBoxesOf(geometry, writers, options = {}) {
                         ? [d.radiusX * 2, d.length, d.radiusZ * 2]
                         : [d.width, d.height, d.depth];
         const r = g.pose.r;
-        const extent = AXES.map((_, a) => local.reduce((s, v, i) => s + Math.abs(r[a][i]) * v, 0));
+        /*
+          How far the body reaches along each world axis.
+    
+          A box is bounded by summing its turned sides, and that is what the sum below does. A round body is not:
+          measuring a spinning wheel as a turning square says it dips below the floor, which it does not. The
+          forklift's wheel read 70 mm under the floor at 45° for exactly this reason — 340·(cos45 + sin45) is the
+          square's diagonal, not the wheel's. The V2 gate measures it the same way, so the two agreeing said nothing
+          about whether either was right (the V3 designer's caution, 2026-09-22).
+    
+          For a round body the reach is its support along the axis: the axis half-length times how much the body's
+          axis points that way, plus the cross-section's own reach. Written per provider below; a box keeps the sum.
+        */
+        const round = (() => {
+            const axis = (a) => r[a][1], // where the body's own Y axis points
+            across = (a, i) => r[a][i];
+            const support = (a, half, rx, rz) => 2 * (half * Math.abs(axis(a)) + Math.hypot(rx * across(a, 0), rz * across(a, 2)));
+            switch (g.shape.provider) {
+                case 'cylinder':
+                    return (a) => support(a, d.length / 2, d.radius, d.radius);
+                case 'ellipticCylinder':
+                    return (a) => support(a, d.length / 2, d.radiusX, d.radiusZ);
+                case 'frustum': {
+                    const widest = Math.max(d.radiusTop, d.radiusBottom);
+                    return (a) => support(a, d.height / 2, widest, widest);
+                }
+                case 'sphere':
+                    return (a) => 2 * Math.hypot(d.radiusX * across(a, 0), d.radiusY * axis(a), d.radiusZ * across(a, 2));
+                default:
+                    return null;
+            }
+        })();
+        const extent = AXES.map((_, a) => (round ? round(a) : local.reduce((s, v, i) => s + Math.abs(r[a][i]) * v, 0)));
         const box = {
             part,
             centre: { x: g.pose.t[0], y: g.pose.t[1], z: g.pose.t[2] },
@@ -54,6 +92,13 @@ export function v3WorldBoxesOf(geometry, writers, options = {}) {
     }
     return out;
 }
+/**
+ * Every placed body including the ones that are not drawn. The declared occupancy does not shrink or grow with
+ * visibility (V3 designer's ruling 2026-09-22), so the gate measures against this, not against the drawn set.
+ */
+export function v3OccupiedBoxesOf(geometry, writers, options = {}) {
+    return v3WorldBoxesOf(geometry.map(g => ('pose' in g ? { ...g, visible: true } : g)), writers, options);
+}
 /** Who writes each graph value, by node id. */
 export function v3WritersOf(asset) {
     const writers = new Map();
@@ -62,6 +107,65 @@ export function v3WritersOf(asset) {
             writers.set(ref, n.id);
     return writers;
 }
+/**
+ * What each operator does to a value's extremes over the state box. Every operator in the kernel is listed by
+ * name — no pattern, no default — so a new one has no classification until someone writes its basis down, and
+ * `v3-state-dimension.test.ts` fails until they do.
+ *
+ *  - `multilinear`: degree one in each state input given multilinear arguments, so the extreme sits at a corner
+ *    however the value is later combined. Sums; products and quotients under the conditions checked in
+ *    `cornerExtremalBasis`; poses and the structural operators, which translate and select but never bend a
+ *    coordinate; the shape providers, whose extents are linear in their arguments; `feature@1`, whose pose is a
+ *    linear combination of the shape's dimensions with an axis fixed by the feature's name, not by its size.
+ *  - `monotone`: monotone in each argument, and not multilinear. Such a value may be a final coordinate on its
+ *    own, and combining it with anything else that moves with the same state input is refused. Each carries its
+ *    own condition in `cornerExtremalBasis`: `min`/`max` refuse arguments that share an input, `curve` refuses
+ *    keys that move or turn around, `geomean` refuses factors that share an input.
+ *  - `unknown`: nothing is claimed. A state-dependent argument here means the coverage falls back to sampling.
+ */
+export const V3_STATE_EXTREME_BASIS = Object.freeze({
+    'add@1': 'multilinear',
+    'mul@1': 'multilinear',
+    'div@1': 'multilinear',
+    'rigid@1': 'multilinear',
+    'compose@1': 'multilinear',
+    'attach@1': 'multilinear',
+    'map-point@1': 'multilinear',
+    'place@1': 'multilinear',
+    'member@1': 'multilinear',
+    'assembly@1': 'multilinear',
+    'repeat@1': 'multilinear',
+    'select-item@1': 'multilinear',
+    'point@1': 'multilinear',
+    'feature@1': 'multilinear',
+    'between@1': 'multilinear',
+    'box@1': 'multilinear',
+    'cylinder@1': 'multilinear',
+    'axis-slide@1': 'multilinear',
+    'at-least@1': 'multilinear',
+    'box-shape@1': 'multilinear',
+    'cylinder-shape@1': 'multilinear',
+    'cylinder-shape@2': 'multilinear',
+    'sphere-shape@1': 'multilinear',
+    'frustum-shape@1': 'multilinear',
+    'rounded-box@1': 'multilinear',
+    'rounded-box@2': 'multilinear',
+    'hollow-box@1': 'multilinear',
+    'hollow-box@2': 'multilinear',
+    'portal-profile@1': 'multilinear',
+    'fit-pitch@1': 'multilinear',
+    'fixed-count@1': 'multilinear',
+    'min@1': 'monotone',
+    'max@1': 'monotone',
+    'curve@1': 'monotone',
+    'geomean@1': 'monotone',
+    // A polygon's world box is the largest of its vertex coordinates. Two vertices moving with one input fold it,
+    // the same way min@1 folds, and the vertices are arguments of one node rather than values of their own.
+    'polygon-shape@1': 'unknown',
+    'axis-turn@1': 'unknown',
+    'distance@1': 'unknown',
+    'sin@1': 'unknown'
+});
 /**
  * Why the extremes of every state-dependent coordinate lie at the corners of the state box, or why that cannot be
  * shown. The basis: a value that is multilinear in the state inputs (each input to degree one) or a monotone
@@ -70,26 +174,97 @@ export function v3WritersOf(asset) {
  * denominator, and through translations in `rigid`. It does not hold through `sin`, `axis-turn`, a
  * state-dependent rotation angle in `rigid`, a state-dependent denominator, or a product of two values that share
  * an input. Returns the reasons it fails, empty when it holds.
+ *
+ * Monotone in each argument is not the same as monotone in a state input the arguments share, and a value that
+ * is merely monotone cannot be combined further. Both were found by the V3 designer, 2026-09-23:
+ * `10 + 100·min(q, 1−q)` is widest in the middle, and `10 + 100·(√q − q)` is widest at q = ¼. The gate called
+ * both proven.
+ *
+ * So the property is named rather than the operators that break it. A value is *multilinear* when it is degree
+ * one in each state input, which is what makes its extreme sit at a corner however it is later combined. Only
+ * the operators in `KEEPS_MULTILINEAR` below carry that property forward, and only under the conditions in the
+ * switch — a product of two values sharing an input, or a state-dependent denominator, does not. Every other
+ * operator, named or not, yields a value *bent* in each state input it depends on: at best monotone in that
+ * input, so it may stand as a final coordinate, but combining it with anything else that moves with the same
+ * input — a sum, a product, a pose composed onto it — is refused. A new operator is bent until someone shows
+ * it preserves multilinearity and adds it to the list.
  */
 export function cornerExtremalBasis(asset, dependence) {
     const reasons = [];
     const dep = (ref) => dependence[ref] ?? [];
     const shares = (a, b) => dep(a).some(x => dep(b).includes(x));
+    const keepsMultilinear = (op) => V3_STATE_EXTREME_BASIS[op] === 'multilinear';
+    // Which state inputs a value is bent in. Nodes may be written in any order, so this follows the arguments.
+    const writer = new Map();
+    for (const n of asset.document.model.nodes)
+        for (const ref of Object.values(n.outputs))
+            writer.set(ref, n);
+    /*
+      `compose(a, b)` is `{ r: a.r·b.r, t: a.r·b.t + a.t }`, and `attach(a, o, b)` is `compose(compose(a, o),
+      inverse(b))`, where `inverse(b).t` is `−b.rᵀ·b.t`. Every translation in those is the input translations
+      multiplied by rotation matrices. That is multilinear only while the matrices hold still: a state-dependent
+      rotation times a state-dependent translation is a product of two things moving with the same input. So the
+      rotation component of every pose that reaches a composition must be state-free, and this says when it is.
+      A `rigid@1` says so through its three angle arguments; `axis-slide@1` carries no rotation; `feature@1`'s
+      axes are fixed by the feature's name, not by the shape's size. Anything else is not established.
+    */
+    const rotationFreeCache = new Map();
+    const rotationStateFree = (ref) => {
+        const done = rotationFreeCache.get(ref);
+        if (done !== undefined)
+            return done;
+        rotationFreeCache.set(ref, false);
+        const n = writer.get(ref);
+        let out;
+        if (!n)
+            out = true; // an input or a constant is not a pose
+        else if (n.op === 'rigid@1')
+            out = !n.args.slice(3, 6).some(a => dep(a).length);
+        else if (n.op === 'axis-slide@1')
+            out = true;
+        else if (n.op === 'feature@1')
+            out = true;
+        else if (n.op === 'compose@1' || n.op === 'attach@1')
+            out = n.args.every(rotationStateFree);
+        else
+            out = false;
+        rotationFreeCache.set(ref, out);
+        return out;
+    };
+    const bentCache = new Map();
+    const bent = (ref) => {
+        const done = bentCache.get(ref);
+        if (done)
+            return done;
+        bentCache.set(ref, []); // a cycle is the compiler's error to report, not this one's
+        const n = writer.get(ref);
+        if (!n)
+            return [];
+        const out = keepsMultilinear(n.op) ? [...new Set(n.args.flatMap(bent))] : dep(ref);
+        bentCache.set(ref, out);
+        return out;
+    };
     for (const n of asset.document.model.nodes) {
         const stateful = n.args.filter(a => dep(a).length);
         if (!stateful.length)
             continue;
+        // A bent value meeting anything else that moves with the same input, whatever the operator does with them.
+        // `at-least@1` is left out: it yields a flag, which reaches no dimension, pose or occupancy.
+        if (n.op !== 'at-least@1')
+            for (let i = 0; i < n.args.length; i++)
+                for (let j = i + 1; j < n.args.length; j++) {
+                    const clash = [...new Set([...bent(n.args[i]).filter(x => dep(n.args[j]).includes(x)), ...bent(n.args[j]).filter(x => dep(n.args[i]).includes(x))])];
+                    if (clash.length)
+                        reasons.push(`${n.id}: ${n.op} combines a value bent in ${clash.join(', ')} with another that moves with ${clash.join(', ')}, so the extreme may lie inside the range`);
+                }
         switch (n.op) {
             case 'add@1':
-            case 'compose@1':
-            case 'attach@1':
             case 'place@1':
             case 'member@1':
             case 'feature@1':
             case 'assembly@1':
             case 'repeat@1':
             case 'select-item@1':
-            case 'map-point@1':
             case 'point@1':
                 break;
             case 'mul@1':
@@ -112,6 +287,27 @@ export function cornerExtremalBasis(asset, dependence) {
                 if (n.args.slice(0, 3).some(a => dep(a).length))
                     reasons.push(`${n.id}: the slide axis depends on state`);
                 break;
+            case 'compose@1':
+            case 'attach@1':
+            case 'map-point@1':
+                for (const a of n.args)
+                    if (dep(a).length && !rotationStateFree(a))
+                        reasons.push(`${n.id}: ${n.op} turns a translation by a rotation that depends on ${dep(a).join(', ')}`);
+                break;
+            case 'max@1':
+            case 'min@1':
+                // Monotone in each argument. Two arguments moving with the same input turn that into a fold: min(q, 1−q)
+                // rises then falls, and its largest value is in the middle, not at either end.
+                for (let i = 0; i < n.args.length; i++)
+                    for (let j = i + 1; j < n.args.length; j++)
+                        if (shares(n.args[i], n.args[j]))
+                            reasons.push(`${n.id}: ${n.op} of two values that both depend on ${dep(n.args[i]).filter(x => dep(n.args[j]).includes(x)).join(', ')}`);
+                break;
+            case 'at-least@1':
+                // A flag cannot reach a dimension, a pose or the occupancy, so a step here moves no world coordinate.
+                // Visibility never changes the declared volume either (designer's ruling), so the gate checks hidden
+                // parts exactly as it checks shown ones.
+                break;
             case 'curve@1': {
                 // A piecewise-linear curve is monotone in x when its key values never change direction; then its extremes
                 // are at x's extremes. Keys that depend on state, or a curve that rises and falls, are not covered.
@@ -132,16 +328,45 @@ export function cornerExtremalBasis(asset, dependence) {
                 break;
             }
             default:
-                // sin, axis-turn, layout operators, distance, providers with a state-dependent argument are not corner-extremal
-                // by this basis; providers are shapes whose extents are the arguments themselves, which is fine only when the
-                // arguments are (handled by their own nodes), so treat shape providers as pass-through.
-                if (n.op.endsWith('-shape@1') || n.op.endsWith('-shape@2') || n.op === 'rounded-box@1' || n.op === 'rounded-box@2' || n.op === 'hollow-box@1' || n.op === 'hollow-box@2' || n.op === 'portal-profile@1')
+                // Everything with no condition of its own: the registry decides. An operator it does not list is unknown,
+                // so a kernel that grows without writing a basis down loses coverage rather than claiming one.
+                if (V3_STATE_EXTREME_BASIS[n.op] === 'multilinear')
                     break;
-                reasons.push(`${n.id}: ${n.op} with a state-dependent argument (${[...new Set(stateful.flatMap(dep))].join(', ')})`);
+                reasons.push(`${n.id}: ${n.op} (${V3_STATE_EXTREME_BASIS[n.op] ?? 'unclassified'}) with a state-dependent argument (${[...new Set(stateful.flatMap(dep))].join(', ')})`);
         }
     }
     return reasons;
 }
+/*
+  Holding every part inside the declared volume and touching the plane the figure is mounted on are two
+  different claims, and corner extremality only settles the first. Whether the figure touches used to be read as
+  the *smallest* gap over its parts, and a smallest folds the way `min@1` folds: two boxes at 20q and 20(1−q) mm
+  above the floor each touch at one end of q and both float 10 mm at the middle (V3 designer's counterexample
+  2026-09-23). The gate evaluated the two ends, found a part on the floor at each, and said proven.
+
+  The declaration names one face now, so there is no smallest to fold: the check is a single equality. What is
+  left is whether that face stays put. A face whose placement does not move with state sits in the same place at
+  every state, so one evaluation settles it. A face that moves is not settled at the corners — the equality has
+  to hold at every state in between, and corner extremality says nothing about an equality — so the asset is
+  sampled, which checks more states and reports the distance it finds without calling it a bound.
+
+  An asset that does not name a mounting face is not asked to touch anything, and nothing here applies to it.
+*/
+function unprovenContact(asset, graph) {
+    const contact = asset.occupancy?.contact;
+    if (!contact)
+        return [];
+    const moving = [contact.surface.placement, contact.surface.feature].filter(ref => (graph.dependence[ref] ?? []).length);
+    if (!moving.length)
+        return [];
+    return [
+        `the mounting face ${contact.surface.placement}/${contact.surface.feature} moves with ${[...new Set(moving.flatMap(ref => graph.dependence[ref] ?? []))].join(', ')}; it has to lie on the plane at every state, and corners do not settle an equality`
+    ];
+}
+/** Which node writes each graph output, the shape the surface reader wants. */
+function nodeWriters(asset) {
+    return new Map(asset.document.model.nodes.flatMap(n => Object.values(n.outputs).map(ref => [ref, n])));
+}
 /** The state inputs of an asset with their declared bounds. */
 function stateInputs(asset) {
     return asset.document.model.inputs.filter(i => i.role === 'state').map(i => ({ id: i.id, min: i.min, max: i.max }));
@@ -188,6 +413,7 @@ export function inspectV3Asset(asset, options = {}) {
     }
     else {
         const unprovable = cornerExtremalBasis(asset, graph.dependence);
+        unprovable.push(...unprovenContact(asset, graph));
         const maxCorners = opts.maxCornerInputs ?? 10;
         const allCorners = inputs.length <= maxCorners;
         const corners = [];
@@ -237,30 +463,36 @@ export function inspectV3Asset(asset, options = {}) {
         inspectOne(asset, graph, evaluated.geometry, state, push);
     }
     const values = graph.evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values;
-    const extent = {
-        x: values[asset.occupancy.extent.x],
-        y: values[asset.occupancy.extent.y],
-        z: values[asset.occupancy.extent.z]
-    };
-    return { extent, placement: asset.occupancy.placement, coverage, violations };
+    const read = (a) => ({
+        min: values[asset.occupancy.bounds[a].min],
+        max: values[asset.occupancy.bounds[a].max]
+    });
+    return { bounds: { x: read('x'), y: read('y'), z: read('z') }, placement: asset.occupancy.placement, coverage, violations };
 }
 function inspectOne(asset, graph, geometry, state, push) {
     const occupancy = asset.occupancy;
     // The asset evaluation returns geometry only; the declared lengths are graph values, so read the graph itself.
     const values = graph.evaluate({ ...asset.designInputs, ...asset.stateDefaults, ...state }).values;
-    const extent = {
-        x: values[occupancy.extent.x],
-        y: values[occupancy.extent.y],
-        z: values[occupancy.extent.z]
-    };
     const placement = occupancy.placement;
-    const boxes = v3WorldBoxesOf(geometry, v3WritersOf(asset));
+    const boxes = v3OccupiedBoxesOf(geometry, v3WritersOf(asset));
     const round = (v) => Math.round(v * 1e4) / 1e4;
-    // The declared box: X and Z centred, Y from the floor (ADR-0065).
-    const low = { x: -extent.x / 2, y: 0, z: -extent.z / 2 };
-    const high = { x: extent.x / 2, y: extent.y, z: extent.z / 2 };
-    let lowest;
-    let highest;
+    /*
+      The declared volume is the reach on each side of the asset origin, so it can sit anywhere around it. The
+      origin is where the figure is mounted, which is a coordinate reference and not a surface nothing may pass:
+      an arm on a bench reaches below the bench, and that is the machine working (V3 designer's ruling 2026-09-23).
+    */
+    const low = { x: 0, y: 0, z: 0 };
+    const high = { x: 0, y: 0, z: 0 };
+    for (const axis of AXES) {
+        low[axis] = values[occupancy.bounds[axis].min];
+        high[axis] = values[occupancy.bounds[axis].max];
+        if (!(high[axis] > low[axis]))
+            push({
+                code: 'OCCUPANCY_UNDECLARED',
+                axis,
+                detail: `the declared volume on ${axis.toUpperCase()} runs from ${low[axis]} to ${high[axis]}, which encloses nothing`
+            });
+    }
     for (const box of boxes) {
         for (const axis of AXES) {
             const reach = box.extent[axis] / 2;
@@ -276,31 +508,45 @@ function inspectOne(asset, graph, geometry, state, push) {
                 });
             }
         }
-        if (!lowest || box.centre.y - box.extent.y / 2 < lowest.centre.y - lowest.extent.y / 2)
-            lowest = box;
-        if (!highest || box.centre.y + box.extent.y / 2 > highest.centre.y + highest.extent.y / 2)
-            highest = box;
     }
-    if (lowest && placement === 'floor') {
-        const gap = lowest.centre.y - lowest.extent.y / 2 - low.y;
-        if (gap > SKIN)
+    /*
+      Only an asset that names the face it is mounted on is asked to make the contact, and two things have to hold
+      for that face to lie in the mounting plane: its reference point is on the plane, and its plane is the same
+      plane. Checking the point alone passed a box stood on its side with the right-hand face declared as the
+      mounting face, because that face's centre happened to sit at Y = 0 (V3 designer's counterexample
+      2026-09-23). A vertical face and a horizontal floor are not the same plane.
+  
+      Whether the face points into the plane or away from it is a separate question — which way up the figure is
+      mounted — and is not asked here. Only that the two planes coincide.
+  
+      The plane is Y = 0 in the asset frame, for a floor figure and a ceiling one alike. The origin is where the
+      figure is fastened (V3 designer's ruling 2026-09-23); a ceiling figure hangs from it and names its top face.
+      Reading the plane off `occupancy.bounds.y.max` moved the thing the figure is mounted on whenever someone
+      widened the volume it takes up, which are two unrelated declarations.
+    */
+    if (occupancy.contact && (placement === 'floor' || placement === 'ceiling')) {
+        const surface = evaluateV3Surface(values, resolveV3Surface({ types: graph.outputTypes, writers: nodeWriters(asset), model: asset.document.model, assetFrame: asset.document.capabilities.assetFrame }, occupancy.contact.surface, 'occupancy.contact.surface'));
+        const part = v3WritersOf(asset).get(surface.placement) ?? surface.placement;
+        const off = surface.pose.t[1];
+        if (Math.abs(off) > SKIN)
             push({
                 code: 'PARTS_OFF_PLACEMENT_FACE',
-                part: lowest.part,
+                part,
                 axis: 'y',
-                mm: round(gap),
-                detail: `the lowest part '${lowest.part}' floats ${round(gap)} mm above the floor the figure is declared to stand on`
+                mm: round(Math.abs(off)),
+                detail: `the ${surface.face} face of '${part}', which the asset declares as what it is mounted on, sits ${round(Math.abs(off))} mm ${off > 0 ? 'above' : 'below'} the plane the figure is mounted on`
             });
-    }
-    if (highest && placement === 'ceiling') {
-        const gap = high.y - (highest.centre.y + highest.extent.y / 2);
-        if (gap > SKIN)
+        // The plane's own normal is Y. Parallel either way: coincident planes, not a mounting direction.
+        const n = surface.normal;
+        const length = Math.hypot(n[0], n[1], n[2]);
+        const tilt = length > 0 ? (Math.acos(Math.min(1, Math.abs(n[1]) / length)) * 180) / Math.PI : 90;
+        if (tilt > CONTACT_TILT_DEG)
             push({
-                code: 'PARTS_OFF_PLACEMENT_FACE',
-                part: highest.part,
+                code: 'PLACEMENT_FACE_TILTED',
+                part,
                 axis: 'y',
-                mm: round(gap),
-                detail: `the highest part '${highest.part}' hangs ${round(gap)} mm below the ceiling the figure is declared to hang from`
+                degrees: round(tilt),
+                detail: `the ${surface.face} face of '${part}' is declared as what the figure is mounted on, and it stands ${round(tilt)}° away from that plane; a face that is not parallel to it does not lie in it`
             });
     }
 }