@hatiolab/figure-model 0.8.0 → 0.9.0

package/dist/authoring-fastening.d.ts

@@ -1,23 +1,32 @@
 import { type Axis } from './words.ts';
-import { type FigureJointPivot, type FigureMeasure, type FigureAuthoringAction, type FigureMotionRequest } from './authoring-types.ts';
+import { type FigureJoint, type FigureJointPivot, type FigureMeasure, type FigureMotionRequest } from './authoring-types.ts';
 type Dynamic = any;
 /**
- * A joint frame's own words, as `writeJoint` hands them to `attach` (ADR-0107, contract 2026-10-03): the pivot, the
- * offset and the parent end's rotation, and `back` -- the record's words turned into the parent's frame (B).
+ * A joint frame's own words, as `writeJoint` hands them on (ADR-0107, contract 2026-10-03): the pivot, the offset and
+ * the parent end's rotation.
  */
 export interface JointFrame {
     pivot?: FigureJointPivot;
     offset?: Partial<Record<Axis, FigureMeasure>>;
     parentRotate?: Partial<Record<Axis, number>>;
-    back: number[][];
     path: string;
 }
-export declare function attach(asset: Dynamic, a: Extract<FigureAuthoringAction, {
-    kind: 'attach';
-}>, twist?: {
-    axis: Axis;
-    deg: number;
-}, frame?: JointFrame): Dynamic;
+/**
+ * A part fastened, in the pose `childRotate` gives it, to a face of its parent or to the mounting plane (ADR-0140 3):
+ * its real shape meets the face -- by its outermost point toward it (`meet`), away from it (`flush`), or their middle
+ * (`centre`) -- and its real extent lines up across it. Everything is said in the parent's own frame (3.11), and
+ * written as graph nodes of the shapes' own values (3.3), so it holds as either is resized.
+ *
+ * Along the face's outward normal n (a coordinate c, the face at c_f, σ its sign on its axis):
+ *     meet    c = c_f + σ·(gap + e(−n))        flush   c = c_f − σ·(gap + e(+n))
+ *     centre  c = c_f + σ·(gap + (e(−n) − e(+n)) / 2)
+ * and across it on each axis u, by the reaches e(±u):
+ *     centre  c = mid + mm − (e(+u) − e(−u)) / 2      min  c = lo + e(−u)      max  c = hi − e(+u)
+ * where e(d) is how far the part reaches along d in its pose (figureShapeExtremeAlong). The seat -- the point it turns
+ * about -- is the point it is lined up by, on the face (3.10): the edge it is level with -- a hinge (ADR-0107 decision 1)
+ * -- or the middle of its real extent; or its pivot. The pose is the part's origin from there.
+ */
+export declare function placeOnFace(asset: Dynamic, j: FigureJoint, frame: JointFrame): void;
 /**
  * The seat turned by a joint frame's parent-end rotation (`rigid@1` turns X, then Y, then Z). Its angles are named by
  * the rotation the record gives, and by the parent's standing turn when that is not none -- not by their value, which

package/dist/authoring-fastening.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"authoring-fastening.d.ts","sourceRoot":"","sources":["../src/authoring-fastening.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,IAAI,EAAQ,MAAM,YAAY,CAAA;AAC5C,OAAO,EAGL,KAAK,gBAAgB,EAErB,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAA;AAqC7B,KAAK,OAAO,GAAG,GAAG,CAAA;AAElB;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,gBAAgB,CAAA;IACxB,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAA;IAC7C,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,IAAI,EAAE,MAAM,EAAE,EAAE,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;CACb;AAKD,wBAAgB,MAAM,CACpB,KAAK,EAAE,OAAO,EACd,CAAC,EAAE,OAAO,CAAC,qBAAqB,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,EACrD,KAAK,CAAC,EAAE;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACnC,KAAK,CAAC,EAAE,UAAU,GACjB,OAAO,CAoMT;AAyID;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,MAAM,EAAE,EAAE,EACb,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,EACrC,IAAI,EAAE,MAAM,EAAE,EAAE,QAkBjB;AAoHD;;;GAGG;AACH;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAuE/G;AAQD,wBAAgB,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,CAAC,EAAE,mBAAmB,EACtB,MAAM,CAAC,EAAE;IAAE,KAAK,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,EAC7E,IAAI,GAAE,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,EAAM,GAC1B,OAAO,CAiLT;AAED,qGAAqG;AACrG,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAsBhG"}
+{"version":3,"file":"authoring-fastening.d.ts","sourceRoot":"","sources":["../src/authoring-fastening.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,IAAI,EAAQ,MAAM,YAAY,CAAA;AAC5C,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAA;AAkC7B,KAAK,OAAO,GAAG,GAAG,CAAA;AAElB;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,gBAAgB,CAAA;IACxB,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAA;IAC7C,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,IAAI,EAAE,MAAM,CAAA;CACb;AAKD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CA2GnF;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,MAAM,EAAE,EAAE,EACb,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,EACrC,IAAI,EAAE,MAAM,EAAE,EAAE,QAkBjB;AAED;;;GAGG;AACH;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAuE/G;AAQD,wBAAgB,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,CAAC,EAAE,mBAAmB,EACtB,MAAM,CAAC,EAAE;IAAE,KAAK,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,EAC7E,IAAI,GAAE,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,EAAM,GAC1B,OAAO,CAiLT;AAED,qGAAqG;AACrG,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAsBhG"}

package/dist/authoring-fastening.js

@@ -7,289 +7,145 @@
  */
 import { figurePlacementOf } from "./asset.js";
 import { AXES } from "./words.js";
-import { FIGURE_FACES, SIGN } from "./authoring-types.js";
+import { FIGURE_FACINGS } from "./authoring-types.js";
+import { figureShapeExtremeAlong, lin, plus, times, writeFigureReach } from "./shape-extreme.js";
 import { fail, nodeById, writerOf, partOf, namer, constantOf, scaled, measureRef, termRefs, sumOf, sourceRef, ownInput, dropIfUnused, parentOf, round6, sizeInputOf } from "./authoring-nodes.js";
-import { neg, half, facesOfPart, planeOf, ownSpansOf, standingSpansOf, planeFacesOf, ACROSS, mul3, transpose3, isIdentity, eulerOfAny, rpyMatrix } from "./authoring-geometry.js";
-export function attach(asset, a, twist, frame) {
+import { half, facesOfPart, planeOf, ownSpansOf, transpose3, isIdentity, eulerOfAny, rpyMatrix, mv3, IDENTITY } from "./authoring-geometry.js";
+const unitAlong = (axis, sign) => AXES.map(x => (x === axis ? sign : 0));
+/**
+ * A part fastened, in the pose `childRotate` gives it, to a face of its parent or to the mounting plane (ADR-0140 3):
+ * its real shape meets the face -- by its outermost point toward it (`meet`), away from it (`flush`), or their middle
+ * (`centre`) -- and its real extent lines up across it. Everything is said in the parent's own frame (3.11), and
+ * written as graph nodes of the shapes' own values (3.3), so it holds as either is resized.
+ *
+ * Along the face's outward normal n (a coordinate c, the face at c_f, σ its sign on its axis):
+ *     meet    c = c_f + σ·(gap + e(−n))        flush   c = c_f − σ·(gap + e(+n))
+ *     centre  c = c_f + σ·(gap + (e(−n) − e(+n)) / 2)
+ * and across it on each axis u, by the reaches e(±u):
+ *     centre  c = mid + mm − (e(+u) − e(−u)) / 2      min  c = lo + e(−u)      max  c = hi − e(+u)
+ * where e(d) is how far the part reaches along d in its pose (figureShapeExtremeAlong). The seat -- the point it turns
+ * about -- is the point it is lined up by, on the face (3.10): the edge it is level with -- a hinge (ADR-0107 decision 1)
+ * -- or the middle of its real extent; or its pivot. The pose is the part's origin from there.
+ */
+export function placeOnFace(asset, j, frame) {
     const m = asset.document.model;
-    const to = a.to;
-    const path = `${a.part} to ${to?.plane ?? to?.part}`;
-    if (!to || typeof to !== 'object')
-        fail('SCHEMA', path, 'a target face, or the plane the figure is mounted on, is required');
-    if (to.plane !== undefined)
-        return standOnPlane(asset, a, path, twist, frame);
-    if (a.part === to.part)
-        fail('ATTACH_CYCLE', path, 'a part cannot be fastened to itself');
-    const byCentre = a.face === 'centre';
-    if (!byCentre && !Object.hasOwn(FIGURE_FACES, String(a.face)))
-        fail('SCHEMA', path, `${String(a.face)} is not a face`);
-    /* The target's faces are the ones its shape declares: a portal's opening as well as its outer faces. */
-    const target = facesOfPart(m, to.part, path);
-    const theirFace = Object.hasOwn(target.faces, String(to.face)) ? target.faces[to.face] : undefined;
-    if (!theirFace)
-        fail('SCHEMA', path, `${to.part} has no face ${String(to.face)}; it has ${Object.keys(target.faces).join(', ')}`);
-    const facing = a.facing ?? 'meet';
-    if (facing !== 'meet' && facing !== 'flush')
-        fail('SCHEMA', path, `${String(facing)} is neither meet nor flush`);
-    const axis = theirFace.axis;
-    const sign = theirFace.normal;
-    if (byCentre && facing !== 'meet')
-        fail('ATTACH_FACE', path, `${a.part} fastened by its centre sits on ${to.face}; flush has no meaning for a centre`);
-    /* By its centre, the part is measured as the face that would meet the target's; only its offset differs. */
-    if (byCentre)
-        a = {
-            ...a,
-            face: Object.keys(FIGURE_FACES).find(f => FIGURE_FACES[f] === axis && SIGN[f] === -sign)
-        };
-    if (FIGURE_FACES[a.face] !== axis)
-        fail('ATTACH_FACE', path, `${a.face} faces along ${FIGURE_FACES[a.face]} and ${to.face} along ${axis}; fastening them would need a turn, which this command does not do`);
-    const wanted = Object.keys(FIGURE_FACES).find(f => FIGURE_FACES[f] === axis && SIGN[f] === (facing === 'meet' ? -sign : sign));
-    if (facing === 'meet' && a.face !== wanted)
-        fail('ATTACH_FACE', path, `to meet ${to.face}, ${a.part} offers its ${wanted}; pass flush to lay ${a.face} in the same plane instead`);
-    if (facing === 'flush' && a.face !== wanted)
-        fail('ATTACH_FACE', path, `to lie flush with ${to.face}, ${a.part} offers its ${wanted}`);
-    if (parentOf(m, a.part) && !a.replace)
-        fail('ATTACH_REPLACED', path, `${a.part} is already fastened to ${parentOf(m, a.part)}; pass replace to move it, or detach it first`);
-    // A part cannot end up its own ancestor.
-    for (let up = to.part; up; up = parentOf(m, up))
-        if (up === a.part)
-            fail('ATTACH_CYCLE', path, `${to.part} already hangs from ${a.part}`);
-    /*
-      Measured in the target's own frame, where its faces are the planes its shape declares: the seat is written into
-      that frame. A target standing turned is met there too -- the joint record's words are turned into that frame
-      before this runs (`writeJoint`).
-    */
-    const theirs = ownSpansOf(m, to.part, path);
-    const mine = standingSpansOf(m, asset, a.part, path);
-    const mineAlong = mine[axis];
-    if ((!mineAlong || !Object.hasOwn(facesOfPart(m, a.part, path).faces, a.face)) && !byCentre)
-        fail('EDIT_TARGET', path, `${a.part} has no flat ${a.face} face`);
-    const name = namer(m, `${a.part}.on.${to.part}`);
-    /*
-      Along the face's own axis. `meet`: the part's centre is half its own depth past the target's face, plus the
-      gap. `flush`: the part's centre is half its own depth back from that face, so its named face lies in it.
-    */
-    const outward = facing === 'meet' ? sign : -sign;
-    const gap = measureRef(m, asset, name, a.gap, `gap.${axis}`, path);
-    /*
-      Split at the point fastened at: the seat is on the target's face (its centre, or level with an edge), the part's
-      centre is half its own depth and the gap past it. A turn added later turns about that point.
-    */
-    const zero = constantOf(m, 'mm', 0, 'd');
-    const translation = { x: '', y: '', z: '' };
-    const offset = { x: zero, y: zero, z: zero };
-    /* The same two as sums, for a pivot that is not the seat: it is worked out from them (`jointFrameOf`). */
-    const seatTerms = { x: [], y: [], z: [] };
-    const offsetTerms = { x: [], y: [], z: [] };
-    /* By its centre, the gap goes into the seat: the point fastened at -- and turned about -- is the part's middle. */
-    seatTerms[axis] = [...planeOf(target.shape, theirFace), ...(byCentre ? [{ ref: gap, k: outward }] : [])];
-    translation[axis] = sumOf(m, name, seatTerms[axis], `seat.${axis}`);
-    const ownFace = byCentre
-        ? mineAlong && !mineAlong.centred
-            ? [...half(mineAlong.lo), ...half(mineAlong.hi)]
-            : []
-        : SIGN[a.face] > 0
-            ? mineAlong.hi
-            : mineAlong.lo;
-    offsetTerms[axis] = byCentre ? neg(ownFace) : [...neg(ownFace), { ref: gap, k: outward }];
-    offset[axis] = byCentre
-        ? ownFace.length
-            ? sumOf(m, name, neg(ownFace), `along.${axis}`)
-            : zero
-        : sumOf(m, name, [...neg(ownFace), { ref: gap, k: outward }], `along.${axis}`);
-    /*
-      Across the face. Centred by default; min and max keep the two parts' edges level as either is resized -- and the
-      point fastened at is where those edges meet: the seat on the target's edge, the part's own edge on it. A door
-      fastened level with the frame's min edge turns about that edge, as a hinge does (2026-09-25); centred, the point
-      is the middle of the face. A shape not centred on its origin (a portal stands on its bottom) is centred by its
-      faces, not by its origin.
-    */
-    for (const other of AXES.filter(x => x !== axis)) {
-        const how = a.align?.[other] ?? 'centre';
-        const t = theirs[other], o = mine[other];
-        const middle = (span) => (span && !span.centred ? [...half(span.lo), ...half(span.hi)] : []);
-        const centreOf = (span, hint) => middle(span).length ? sumOf(m, name, middle(span), hint) : constantOf(m, 'mm', 0, 'd');
-        const ownCentre = () => (middle(o).length ? sumOf(m, name, neg(middle(o)), `own-centre.${other}`) : zero);
-        offsetTerms[other] = neg(middle(o));
-        if (how === 'centre') {
-            seatTerms[other] = middle(t);
-            translation[other] = centreOf(t, `centre.${other}`);
-            offset[other] = ownCentre();
-        }
-        else if (typeof how === 'object' && how && Object.hasOwn(how, 'mm')) {
-            const mm = measureRef(m, asset, name, how.mm, `align.${other}`, path);
-            seatTerms[other] = [...middle(t), { ref: mm, k: 1 }];
-            translation[other] = middle(t).length
-                ? sumOf(m, name, [...middle(t), { ref: mm, k: 1 }], `align.${other}.from-centre`)
-                : mm;
-            offset[other] = ownCentre();
+    const child = j.body1.part;
+    const path = frame.path;
+    const to = j.body0;
+    const o = j.origin ?? {};
+    const facing = o.facing ?? 'meet';
+    if (!FIGURE_FACINGS.includes(facing))
+        fail('JOINT_SCHEMA', `${path}.origin.facing`, `${String(facing)} is not a facing; ${FIGURE_FACINGS.join(', ')}`);
+    const onPlane = 'plane' in to;
+    const name = namer(m, `${child}.on.${onPlane ? 'plane' : to.part}`);
+    /* The face: its axis, its outward sign and where it lies, in the parent's own frame; across it, the parent's edges. */
+    let axis, sign, plane;
+    const edges = {};
+    if (onPlane) {
+        const placement = figurePlacementOf(asset);
+        axis = placement === 'wall' ? 'z' : 'y';
+        sign = 1;
+        plane = [];
+        if (placement === 'wall' && facing !== 'meet')
+            fail('ATTACH_FACE', path, `the figure hangs on a wall; ${child} stands out of it (meet), not ${facing}`);
+        if (facing === 'centre')
+            fail('JOINT_SCHEMA', `${path}.origin.facing`, 'a part stands on the mounting plane or hangs from it; its middle is not on it');
+        for (const x of AXES.filter(x => x !== axis))
+            if (sizeInputOf(m, x)) {
+                const size = sourceRef(m, asset, { of: 'instance', axis: x }, path);
+                edges[x] = { lo: [{ ref: size, k: -0.5 }], hi: [{ ref: size, k: 0.5 }] };
+            }
+    }
+    else {
+        if (to.part === child)
+            fail('ATTACH_CYCLE', path, 'a part cannot be fastened to itself');
+        const target = facesOfPart(m, to.part, path);
+        const face = Object.hasOwn(target.faces, String(to.face)) ? target.faces[to.face] : undefined;
+        if (!face)
+            fail('SCHEMA', path, `${to.part} has no face ${String(to.face)}; it has ${Object.keys(target.faces).join(', ')}`);
+        axis = face.axis;
+        sign = face.normal;
+        plane = planeOf(target.shape, face);
+        const spans = ownSpansOf(m, to.part, path);
+        for (const x of AXES.filter(x => x !== axis))
+            if (spans[x])
+                edges[x] = { lo: spans[x].lo, hi: spans[x].hi };
+    }
+    /* The child's pose in the parent's frame, and how far its real shape reaches along a direction there. */
+    const rotate = o.childRotate ?? {};
+    const C = rpyMatrix(rotate);
+    const reach = (d) => figureShapeExtremeAlong(m, child, mv3(transpose3(C), d), path);
+    const gap = o.gap === undefined ? lin([]) : lin([{ ref: measureRef(m, asset, name, o.gap, `gap.${axis}`, path), k: 1 }]);
+    const [toward, away] = [reach(unitAlong(axis, -sign)), reach(unitAlong(axis, sign))];
+    const at = {};
+    const seat = {};
+    const face = lin(plane);
+    at[axis] =
+        facing === 'meet'
+            ? plus(face, times(plus(gap, toward), sign))
+            : facing === 'flush'
+                ? plus(face, times(plus(gap, away), -sign))
+                : plus(face, times(plus(gap, times(plus(toward, times(away, -1)), 0.5)), sign));
+    /* On the face; by its middle (centre), at that middle, gap and all -- it turns in place, a roller spinning. */
+    seat[axis] = facing === 'centre' ? plus(at[axis], times(plus(reach(unitAlong(axis, 1)), times(reach(unitAlong(axis, -1)), -1)), 0.5)) : face;
+    for (const u of AXES.filter(x => x !== axis)) {
+        const [hi, lo] = [reach(unitAlong(u, 1)), reach(unitAlong(u, -1))];
+        /* The middle of its real extent, from its origin: (e(+u) − e(−u)) / 2. */
+        const middle = times(plus(hi, times(lo, -1)), 0.5);
+        const how = o.align?.[u] ?? 'centre';
+        const edge = edges[u];
+        if (how === 'min' || how === 'max') {
+            if (!edge)
+                fail(onPlane ? 'SCHEMA' : 'ATTACH_FACE', path, onPlane ? `the plane has no edges to line ${child} up with on ${u}; declare the figure's size, or give the centre or a measured offset` : `${to.part} has no edges along ${u} to line ${child} up with; give the centre or a measured offset`);
+            at[u] = how === 'min' ? plus(lin(edge.lo), lo) : plus(lin(edge.hi), times(hi, -1));
+            /* Level with an edge, it turns about that edge, as a hinge does (ADR-0107 decision 1). */
+            seat[u] = lin(how === 'min' ? edge.lo : edge.hi);
+            continue;
         }
-        else if (how === 'min' || how === 'max') {
-            if (!t)
-                fail('ATTACH_FACE', path, `${to.part} has no edges along ${other} to line ${a.part} up with; give the centre or a measured offset`);
-            if (!o)
-                fail('ATTACH_FACE', path, `${a.part} has no edges along ${other} to line up; give the centre or a measured offset`);
-            seatTerms[other] = how === 'min' ? t.lo : t.hi;
-            offsetTerms[other] = neg(how === 'min' ? o.lo : o.hi);
-            translation[other] = sumOf(m, name, how === 'min' ? t.lo : t.hi, `edge.${other}`);
-            offset[other] = sumOf(m, name, neg(how === 'min' ? o.lo : o.hi), `own-edge.${other}`);
+        else if (how === 'centre' || (typeof how === 'object' && how && Object.hasOwn(how, 'mm'))) {
+            const mid = edge ? lin([...half(edge.lo), ...half(edge.hi)]) : lin([]);
+            const off = typeof how === 'object' ? lin([{ ref: measureRef(m, asset, name, how.mm, `align.${u}`, path), k: 1 }]) : lin([]);
+            at[u] = plus(mid, off, times(middle, -1));
         }
         else
             fail('SCHEMA', path, `${String(how)} is not an alignment`);
+        seat[u] = plus(at[u], middle);
     }
-    /*
-      Twisted about the face's normal: the seat is the face's centre, and the part's own offset across the face -- its
-      distance and its own centre -- turns with it, so a blade set out along X and twisted 120° stands out along the
-      blade, about the hub. With no twist this is the same place written as before.
-    */
-    let twisted;
-    if (twist && twist.deg) {
-        const [p, q] = ACROSS[axis];
-        for (const other of [p, q]) {
-            const how = a.align?.[other] ?? 'centre';
-            if (how === 'min' || how === 'max')
-                fail('ATTACH_FACE', path, `${a.part} is twisted ${round6(twist.deg)}° about ${axis}; its sides are not level with ${to.part}'s edges -- place it by the centre or a distance`);
-        }
-        const across = (other) => {
-            const how = a.align?.[other] ?? 'centre';
-            const o = mine[other];
-            const own = o && !o.centred ? neg([...half(o.lo), ...half(o.hi)]) : [];
-            return typeof how === 'object' && how && Object.hasOwn(how, 'mm')
-                ? [{ ref: measureRef(m, asset, name, how.mm, `twist.${other}`, path), k: 1 }, ...own]
-                : own;
-        };
-        const [vp, vq] = [across(p), across(q)];
-        for (const other of [p, q]) {
-            const t = theirs[other];
-            seatTerms[other] = t && !t.centred ? [...half(t.lo), ...half(t.hi)] : [];
-            translation[other] =
-                t && !t.centred
-                    ? sumOf(m, name, [...half(t.lo), ...half(t.hi)], `twist-centre.${other}`)
-                    : constantOf(m, 'mm', 0, 'd');
-        }
-        twisted = twistRotator(m, name, axis, twist.deg);
-        [offset[p], offset[q]] = twisted.rotate(vp, vq, 'twist');
-        offsetTerms[p] = [{ ref: offset[p], k: 1 }];
-        offsetTerms[q] = [{ ref: offset[q], k: 1 }];
-    }
-    const placed = jointFrameOf(asset, name, a.part, { seat: translation, pose: offset, seatTerms, offsetTerms, normal: axis, face: a.face, mine, twisted }, frame);
-    reseat(asset, a.part, `${to.part}.local`, { seat: placed.seat, pose: placed.pose });
-    placed.finish();
-    return asset;
-}
-/**
- * A vector across a face, as sums, turned by a twist about the face's normal: its two components as nodes. The turn's
- * factors are named by the angle, as the record gives it -- not by their value, which may carry float noise that
- * depends on how it was computed, so a rewrite named them apart (JOINT_DRIFT, the architect's fan, 2026-09-25). Their
- * values are rounded to twelve places, which is the second defence.
- */
-function twistRotator(m, name, axis, deg) {
-    const [p, q] = ACROSS[axis];
-    const exact = (v) => {
-        const r = Math.round(v * 1e12) / 1e12;
-        return r === 0 ? 0 : r;
-    };
-    const tag = String(round6(deg)).replace('-', 'm').replace('.', '_');
-    const factor = (fn) => {
-        const id = `twist.${fn}.${tag}`;
-        const rad = (deg * Math.PI) / 180;
-        if (!m.constants.some((c) => c.id === id))
-            m.constants.push({
-                id,
-                unit: 'ratio',
-                value: exact(fn === 'cos' ? Math.cos(rad) : fn === 'sin' ? Math.sin(rad) : -Math.sin(rad))
-            });
-        return id;
-    };
-    const node = (op, args, hint) => {
-        const id = name(hint);
-        m.nodes.push({ id, op, args, outputs: { value: `${id}.value` } });
-        return `${id}.value`;
-    };
-    const rotate = (up, uq, hint) => {
-        const sp = sumOf(m, name, up, `${hint}-own.${p}`), sq = sumOf(m, name, uq, `${hint}-own.${q}`);
-        return [
-            node('add@1', [node('mul@1', [sp, factor('cos')], `${hint}ed.${p}.cos`), node('mul@1', [sq, factor('nsin')], `${hint}ed.${p}.sin`)], `${hint}ed.${p}`),
-            node('add@1', [node('mul@1', [sp, factor('sin')], `${hint}ed.${q}.sin`), node('mul@1', [sq, factor('cos')], `${hint}ed.${q}.cos`)], `${hint}ed.${q}`)
-        ];
-    };
-    return { p, q, rotate };
-}
-/**
- * The seat and the child's offset from it, moved for the joint frame's own words (ADR-0107, contract 2026-10-03). A
- * is the seat `attach` worked out (the point fastened at), o the offset, c the child's point to turn about, as it stands:
- *
- *     pivot P = A (seat), or A + o + c (child-face, child-centre)
- *     seat  = P + B·offset, turned by B·Rpy·Bᵀ        (F_parent = T(P)·B·T(δ)·Rpy)
- *     pose  = A − P + o, turned as before             (inverse(F_child) = T(Bᵀ(A−P))·[R_c | Bᵀo])
- *
- * With none of them nothing is written but what `attach` wrote. `finish` turns the seat once it is written, and drops
- * what the seat and pose no longer read.
- */
-function jointFrameOf(asset, name, part, at, frame) {
-    const m = asset.document.model;
-    const seat = AXES.map(x => at.seat[x]);
-    const pose = AXES.map(x => at.pose[x]);
-    const pivot = frame?.pivot ?? 'seat';
-    const shift = frame?.offset ?? {};
-    const turned = !!frame && AXES.some(x => (frame.parentRotate?.[x] ?? 0) !== 0);
-    if (!frame || (pivot === 'seat' && !AXES.some(x => shift[x] !== undefined && shift[x] !== 0) && !turned))
-        return { seat, pose, finish: () => { } };
-    const superseded = new Set();
-    if (pivot !== 'seat') {
-        /* c: the child's fastened face's centre, or its middle, in the seat frame -- turned by its quarter turn, then its twist. */
-        const middle = (span) => (span && !span.centred ? [...half(span.lo), ...half(span.hi)] : []);
-        const c = { x: [], y: [], z: [] };
+    /* Where it turns (3.10): its lined-up middle on the face, the middle of its real extent, or the centre of its flat face on the face. */
+    const pivot = frame.pivot ?? 'seat';
+    if (pivot === 'child-centre')
         for (const x of AXES)
-            c[x] = middle(at.mine[x]);
-        if (pivot === 'child-face') {
-            const along = at.mine[at.normal];
-            c[at.normal] = SIGN[at.face] > 0 ? along.hi : along.lo;
-        }
-        const cRef = {};
-        if (at.twisted && (c[at.twisted.p].length || c[at.twisted.q].length))
-            [cRef[at.twisted.p], cRef[at.twisted.q]] = at.twisted.rotate(c[at.twisted.p], c[at.twisted.q], 'pivot-twist');
-        const cTerms = (x) => (cRef[x] ? [{ ref: cRef[x], k: 1 }] : c[x]);
-        for (const [i, x] of AXES.entries()) {
-            superseded.add(seat[i]).add(pose[i]);
-            seat[i] = sumOf(m, name, combined(m, [...at.seatTerms[x], ...at.offsetTerms[x], ...cTerms(x)]), `pivot.${x}`);
-            pose[i] = sumOf(m, name, neg(cTerms(x)), `from-pivot.${x}`);
-        }
+            seat[x] = plus(at[x], times(plus(reach(unitAlong(x, 1)), times(reach(unitAlong(x, -1)), -1)), 0.5));
+    if (pivot === 'child-face') {
+        const own = mv3(transpose3(C), unitAlong(axis, -sign));
+        const k = own.findIndex(v => Math.abs(Math.abs(v) - 1) < 1e-9);
+        const spans = facing === 'meet' && k >= 0 ? ownSpansOf(m, child, path) : {};
+        const along = k >= 0 ? spans[AXES[k]] : undefined;
+        if (!along)
+            fail('JOINT_SCHEMA', `${path}.origin.pivot`, `${child} meets ${onPlane ? 'the plane' : `${to.part}'s ${to.face}`} at a point or a line${facing === 'meet' ? '' : ` (${facing})`}, not by a face of its own; child-face has no face to turn about -- child-centre or seat`);
+        /* The face's centre in the child's own frame, turned into the parent's and placed with the child. */
+        const centre = AXES.map((x, i) => (i === k ? (own[k] > 0 ? along.hi : along.lo) : spans[x] ? [...half(spans[x].lo), ...half(spans[x].hi)] : []));
+        AXES.forEach((x, i) => {
+            seat[x] = plus(at[x], ...AXES.map((_, c) => lin(centre[c].map(t => ({ ref: t.ref, k: t.k * C[i][c] })))));
+        });
     }
-    /* The offset, said on the standing axes, into the parent's frame: B·δ. */
-    const back = frame.back;
-    const moved = AXES.map((x, i) => {
-        const terms = [];
-        for (const [j, y] of AXES.entries()) {
-            const d = shift[y];
-            if (d === undefined || d === 0 || Math.abs(back[i][j]) < 1e-12)
-                continue;
-            terms.push({ ref: measureRef(m, asset, name, d, `offset.${y}`, `${frame.path}.origin.offset.${y}`), k: back[i][j] });
-        }
-        return terms;
+    /* The pose is the child's origin from the seat; the seat moves by the frame's offset (3.10, ADR-0107). */
+    const pose = AXES.map(x => plus(at[x], times(seat[x], -1)));
+    const shift = frame.offset ?? {};
+    const seatAt = AXES.map(x => (shift[x] === undefined || shift[x] === 0 ? seat[x] : plus(seat[x], lin([{ ref: measureRef(m, asset, name, shift[x], `offset.${x}`, `${path}.origin.offset.${x}`), k: 1 }]))));
+    const write = (r, h) => writeFigureReach(m, name, r, h);
+    reseat(asset, child, onPlane ? asset.document.capabilities.assetFrame : `${to.part}.local`, {
+        seat: seatAt.map((r, i) => write(r, `seat.${AXES[i]}`)),
+        pose: pose.map((r, i) => write(r, `pose.${AXES[i]}`))
     });
-    for (const i of [0, 1, 2])
-        if (moved[i].length)
-            seat[i] = sumOf(m, name, [{ ref: seat[i], k: 1 }, ...moved[i]], `offset.${AXES[i]}`);
-    return {
-        seat,
-        pose,
-        finish: () => {
-            if (turned)
-                turnSeat(asset, part, mul3(mul3(back, rpyMatrix(frame.parentRotate)), transpose3(back)), frame.parentRotate, back);
-            for (const ref of superseded)
-                if (!seat.includes(ref) && !pose.includes(ref))
-                    dropIfUnused(asset, ref);
-        }
-    };
-}
-/** Terms with one entry per reference, their factors added; a reference whose factors cancel, or a constant 0, is gone. */
-function combined(m, terms) {
-    const by = new Map();
-    for (const t of terms)
-        by.set(t.ref, (by.get(t.ref) ?? 0) + t.k);
-    const nought = (ref) => m.constants.find((c) => c.id === ref)?.value === 0;
-    return [...by].filter(([ref, k]) => Math.abs(k) > 1e-12 && !nought(ref)).map(([ref, k]) => ({ ref, k }));
+    /* The child's own pose: childRotate is Rz·Ry·Rx (3.6); rigid@1 takes its angles X then Y then Z, so they are worked out. */
+    const { pose: node } = partOf(m, child, path);
+    const old = node.args.slice(3, 6);
+    node.args = [...node.args.slice(0, 3), ...eulerOfAny(C, true).map(t => constantOf(m, 'deg', t, 'a'))];
+    for (const ref of old)
+        dropIfUnused(asset, ref, ownInput(m, child, ref) ? ref : undefined);
+    if (AXES.some(x => (frame.parentRotate?.[x] ?? 0) !== 0))
+        turnSeat(asset, child, rpyMatrix(frame.parentRotate), frame.parentRotate, IDENTITY);
 }
 /**
  * The seat turned by a joint frame's parent-end rotation (`rigid@1` turns X, then Y, then Z). Its angles are named by
@@ -316,89 +172,6 @@ export function turnSeat(asset, part, r, rotate, back) {
     for (const ref of old)
         dropIfUnused(asset, ref);
 }
-function standOnPlane(asset, a, path, twist, frame) {
-    const m = asset.document.model;
-    const to = a.to;
-    if (to.plane !== 'mounting-plane')
-        fail('SCHEMA', path, `${String(to.plane)} is not a plane a part can stand on`);
-    if (a.facing !== undefined && a.facing !== 'meet')
-        fail('SCHEMA', path, 'a part standing on the plane meets it; flush says nothing here');
-    /* Which plane it is, the figure's placement says: the floor or the ceiling is Y = 0, a wall is Z = 0 (ADR-0093). */
-    const placement = figurePlacementOf(asset);
-    const takes = planeFacesOf(placement);
-    const normal = placement === 'wall' ? 'z' : 'y';
-    if (!takes.includes(a.face))
-        fail('ATTACH_FACE', path, placement === 'wall'
-            ? `${String(a.face)} faces along ${FIGURE_FACES[a.face] ?? 'no axis'}; the figure hangs on a wall, the plane Z = 0, so a part is fastened to it by its back`
-            : `${String(a.face)} faces along ${FIGURE_FACES[a.face] ?? 'no axis'}; the plane faces along y, so a part stands on it by its bottom or hangs from it by its top`);
-    if (parentOf(m, a.part) && !a.replace)
-        fail('ATTACH_REPLACED', path, `${a.part} is already fastened to ${parentOf(m, a.part)}; pass replace to stand it on the plane instead`);
-    const mine = standingSpansOf(m, asset, a.part, path);
-    if (!mine[normal] || !Object.hasOwn(facesOfPart(m, a.part, path).faces, a.face))
-        fail('EDIT_TARGET', path, `${a.part} has no flat ${a.face} face`);
-    const name = namer(m, `${a.part}.on.plane`);
-    /* Out of the plane: a bottom stands up from the floor, a back comes out of the wall, a top hangs down. */
-    const outward = a.face === 'top' ? -1 : 1;
-    const gap = measureRef(m, asset, name, a.gap, `gap.${normal}`, path);
-    const translation = { x: '', y: '', z: '' };
-    /* The same as sums, for a pivot that is not the seat (`jointFrameOf`). */
-    const seatTerms = { x: [], y: [], z: [] };
-    const offsetTerms = { x: [], y: [], z: [] };
-    offsetTerms[normal] = [...neg(outward > 0 ? mine[normal].lo : mine[normal].hi), { ref: gap, k: outward }];
-    translation[normal] = sumOf(m, name, [...neg(outward > 0 ? mine[normal].lo : mine[normal].hi), { ref: gap, k: outward }], `stand.${normal}`);
-    const zero = constantOf(m, 'mm', 0, 'd');
-    const pose = { x: zero, y: zero, z: zero };
-    pose[normal] = translation[normal];
-    for (const other of AXES.filter(x => x !== normal)) {
-        const how = a.align?.[other] ?? 'centre';
-        const span = mine[other];
-        if (how === 'centre')
-            translation[other] = constantOf(m, 'mm', 0, 'd');
-        else if (typeof how === 'object' && how && Object.hasOwn(how, 'mm')) {
-            translation[other] = measureRef(m, asset, name, how.mm, `align.${other}`, path);
-            seatTerms[other] = [{ ref: translation[other], k: 1 }];
-        }
-        else if ((how === 'min' || how === 'max') && sizeInputOf(m, other)) {
-            /*
-              The plane has no edges, but a figure that declares its size has a box on it: its sides are half the size
-              either way of the origin. A part level with one keeps to it when the figure is resized -- a door's post at
-              the figure's left, a gantry's legs at its corners (2026-09-25).
-            */
-            if (!span)
-                fail('ATTACH_FACE', path, `${a.part} has no edges along ${other} to line up with the figure's side`);
-            const s = how === 'min' ? -1 : 1;
-            seatTerms[other] = [{ ref: sourceRef(m, asset, { of: 'instance', axis: other }, path), k: s * 0.5 }];
-            offsetTerms[other] = neg(how === 'min' ? span.lo : span.hi);
-            translation[other] = sumOf(m, name, [{ ref: sourceRef(m, asset, { of: 'instance', axis: other }, path), k: s * 0.5 }], `figure-edge.${other}`);
-            pose[other] = sumOf(m, name, neg(how === 'min' ? span.lo : span.hi), `own-edge.${other}`);
-            continue;
-        }
-        else
-            fail('SCHEMA', path, `the plane has no edges to line ${a.part} up with on ${other}; declare the figure's size, or give the centre or a measured offset`);
-        /* A shape not centred on its origin stands centred by its faces. */
-        if (span && !span.centred) {
-            offsetTerms[other] = neg([...half(span.lo), ...half(span.hi)]);
-            pose[other] = sumOf(m, name, neg([...half(span.lo), ...half(span.hi)]), `own-centre.${other}`);
-        }
-    }
-    // The point it stands on is on the plane, under its centre: a turn about the plane's normal turns it where it stands.
-    const seat = AXES.map(x => (x === normal ? zero : translation[x]));
-    /* Its pose turns it about its centre, twist and all (`writeJoint`): a point of it to turn about turns with it. */
-    const twisted = frame?.pivot && frame.pivot !== 'seat' && twist?.deg ? twistRotator(m, name, twist.axis, twist.deg) : undefined;
-    const placed = jointFrameOf(asset, name, a.part, {
-        seat: { x: seat[0], y: seat[1], z: seat[2] },
-        pose,
-        seatTerms,
-        offsetTerms,
-        normal,
-        face: a.face,
-        mine,
-        twisted
-    }, frame);
-    reseat(asset, a.part, asset.document.capabilities.assetFrame, { seat: placed.seat, pose: placed.pose });
-    placed.finish();
-    return asset;
-}
 /**
  * Put a part's pose on a new frame with a new translation, and rebuild the chain that carries it to the asset.
  * The part's own id, its shape and its `placed` reference all stay as they were.