@hatiolab/figure-model 0.1.85 → 0.1.87

package/dist/v3-authoring-actions.js

@@ -45,10 +45,18 @@ const clone = (asset) => structuredClone(asset);
 const nodeById = (m, id) => m.nodes.find((n) => n.id === id);
 const writerOf = (m, ref) => m.nodes.find((n) => Object.values(n.outputs).includes(ref));
 /** A part an authoring command can work with, and the pieces of it those commands need. */
+/** The part whose row carries this one -- fastened to it, however far down -- or undefined. */
+function rowHolding(m, id) {
+    const place = nodeById(m, id);
+    if (place?.op !== 'member@1' || nodeById(m, `${id}.repeat`))
+        return undefined;
+    const assembly = m.nodes.find((n) => n.op === 'assembly@1' && n.args.includes(place.outputs.placed));
+    return assembly ? String(assembly.id).replace(/\.assembly$/, '') : undefined;
+}
 function partOf(m, id, path) {
     const place = nodeById(m, id);
     /* A row's template is the part too: it is placed through its row (`repeatPart`). */
-    const rowTemplate = place?.op === 'member@1' && !!nodeById(m, `${id}.repeat`);
+    const rowTemplate = place?.op === 'member@1' && (!!nodeById(m, `${id}.repeat`) || rowHolding(m, id) !== undefined);
     if (!place || (place.op !== 'place@1' && !rowTemplate))
         fail('TARGET_ABSENT', path, `${id} is not a placed part`);
     const shape = writerOf(m, place.args[0]);
@@ -168,6 +176,25 @@ function facesOfPart(m, id, path) {
         fail('EDIT_TARGET', path, `${id} is a ${shape.op}; it has no flat face to fasten by`);
     return { shape, faces: faces };
 }
+/**
+ * The face a joint's child is measured by: its own, or for `centre` the face that would meet the parent's -- the part is
+ * measured and turned as that face, and only where its middle sits differs (\`attach\`).
+ */
+function childFaceOf(m, j) {
+    if (j.body1.face !== 'centre')
+        return j.body1.face;
+    const path = `joints.${j.id}.body1.face`;
+    if (!('part' in j.body0))
+        fail('JOINT_SCHEMA', path, 'a part stands on the mounting plane by a face of its own, not by its centre');
+    /* One of the six, in the record's words: the face across from it. An opening's face, read from the parent's shape. */
+    const named = j.body0.face;
+    if (Object.hasOwn(V3_FACES, named))
+        return Object.keys(V3_FACES).find(f => V3_FACES[f] === V3_FACES[named] && SIGN[f] === -SIGN[named]);
+    const theirs = facesOfPart(m, j.body0.part, path).faces[j.body0.face];
+    if (!theirs)
+        fail('JOINT_SCHEMA', path, `${j.body0.part} has no face ${j.body0.face}`);
+    return Object.keys(V3_FACES).find(f => V3_FACES[f] === theirs.axis && SIGN[f] === -theirs.normal);
+}
 const planeOf = (shape, face) => face.plane.map(p => ({ ref: shape.args[p.arg], k: p.k }));
 /** The part's outer faces on each axis in its own frame; an axis without a pair of flat faces has none. */
 function ownSpansOf(m, id, path) {
@@ -447,7 +474,8 @@ function attach(asset, a, twist) {
         return standOnPlane(asset, a, path);
     if (a.part === to.part)
         fail('ATTACH_CYCLE', path, 'a part cannot be fastened to itself');
-    if (!Object.hasOwn(V3_FACES, String(a.face)))
+    const byCentre = a.face === 'centre';
+    if (!byCentre && !Object.hasOwn(V3_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);
@@ -459,6 +487,11 @@ function attach(asset, a, twist) {
         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(V3_FACES).find(f => V3_FACES[f] === axis && SIGN[f] === -sign) };
     if (V3_FACES[a.face] !== axis)
         fail('ATTACH_FACE', path, `${a.face} faces along ${V3_FACES[a.face]} and ${to.face} along ${axis}; fastening them would need a turn, which this command does not do`);
     const wanted = Object.keys(V3_FACES).find(f => V3_FACES[f] === axis && SIGN[f] === (facing === 'meet' ? -sign : sign));
@@ -480,7 +513,7 @@ function attach(asset, a, twist) {
     const theirs = ownSpansOf(m, to.part, path);
     const mine = standingSpansOf(m, asset, a.part, path);
     const mineAlong = mine[axis];
-    if (!mineAlong)
+    if (!mineAlong && !byCentre)
         fail('EDIT_TARGET', path, `${a.part} has no flat ${a.face} face`);
     const name = namer(m, `${a.part}.on.${to.part}`);
     /*
@@ -496,9 +529,10 @@ function attach(asset, a, twist) {
     const zero = constantOf(m, 'mm', 0, 'd');
     const translation = { x: '', y: '', z: '' };
     const offset = { x: zero, y: zero, z: zero };
-    translation[axis] = sumOf(m, name, planeOf(target.shape, theirFace), `seat.${axis}`);
-    const ownFace = SIGN[a.face] > 0 ? mineAlong.hi : mineAlong.lo;
-    offset[axis] = sumOf(m, name, [...neg(ownFace), { ref: gap, k: outward }], `along.${axis}`);
+    /* By its centre, the gap goes into the seat: the point fastened at -- and turned about -- is the part's middle. */
+    translation[axis] = sumOf(m, name, [...planeOf(target.shape, theirFace), ...(byCentre ? [{ ref: gap, k: outward }] : [])], `seat.${axis}`);
+    const ownFace = byCentre ? (mineAlong && !mineAlong.centred ? [...half(mineAlong.lo), ...half(mineAlong.hi)] : []) : SIGN[a.face] > 0 ? mineAlong.hi : mineAlong.lo;
+    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
@@ -610,8 +644,8 @@ function standOnPlane(asset, a, path) {
     const normal = placement === 'wall' ? 'z' : 'y';
     if (!takes.includes(a.face))
         fail('ATTACH_FACE', path, placement === 'wall'
-            ? `${String(a.face)} faces along ${V3_FACES[a.face] ?? '?'}; 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 ${V3_FACES[a.face] ?? '?'}; the plane faces along y, so a part stands on it by its bottom or hangs from it by its top`);
+            ? `${String(a.face)} faces along ${V3_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 ${V3_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);
@@ -772,7 +806,11 @@ function reseat(asset, id, to, place) {
     const parent = /^(.*)\.local$/.exec(to);
     let world = nodeById(m, `${id}.world`);
     if (parent && parent[1] !== id) {
-        const above = nodeById(m, `${parent[1]}.world`)?.outputs?.pose ?? nodeById(m, `${parent[1]}.chain`)?.outputs?.pose ?? nodeById(m, `${parent[1]}.pose`).outputs.pose;
+        /* A row's template has no chain of its own: what hangs from it hangs in its copy's frame, turned as it turns. */
+        const above = nodeById(m, `${parent[1]}.world`)?.outputs?.pose ??
+            nodeById(m, `${parent[1]}.chain`)?.outputs?.pose ??
+            nodeById(m, `${parent[1]}.turned`)?.outputs?.pose ??
+            nodeById(m, `${parent[1]}.pose`).outputs.pose;
         if (!world) {
             world = { id: `${id}.world`, op: 'compose@1', args: [above, chain.outputs.pose], outputs: { pose: `${id}.world.value` } };
             m.nodes.push(world);
@@ -1128,20 +1166,36 @@ function checkJoint(asset, j) {
         fail('JOINT_SCHEMA', `${path}.origin.twist`, 'a twist is a number of degrees');
     if (j.origin?.turn && Object.values(j.origin.turn).some(t => !Number.isFinite(t) || Math.abs(t / 90 - Math.round(t / 90)) > 1e-9))
         fail('JOINT_SCHEMA', `${path}.origin.turn`, 'a turn is in quarter turns; an angle about the face\'s normal is its twist');
-    /* A part in a row is its copies: nothing can hang from one place of it. */
-    const repeatedParent = 'part' in j.body0 ? others.find(o => o.repeat && o.body1.part === j.body0.part) : undefined;
-    if (repeatedParent)
-        fail('JOINT_SCHEMA', path, `${repeatedParent.body1.part} is repeated; its copies have no one place for ${j.body1.part} to hang from`);
+    /*
+      A row repeats its part and everything fastened to it (ADR-0093, 2026-09-26): a part fastened to a part in a row is
+      on every copy. A row inside a row is a grid; it runs along another axis than the rows around it.
+    */
+    const all = [...others, j];
+    const upOf = (part) => all.find(o => o.body1.part === part && 'part' in o.body0);
+    const rowAbove = (part) => {
+        for (let up = upOf(part); up; up = upOf(up.body0.part))
+            if (up.repeat)
+                return up;
+        return undefined;
+    };
+    if (j.repeat) {
+        const below = (part) => all.filter(o => 'part' in o.body0 && o.body0.part === part).flatMap(o => [o.body1.part, ...below(o.body1.part)]);
+        const around = [];
+        for (let up = ('part' in j.body0 ? rowAbove(j.body0.part) : undefined); up; up = ('part' in up.body0 ? rowAbove(up.body0.part) : undefined))
+            around.push(up);
+        const inside = below(j.body1.part).map(p => all.find(o => o.body1.part === p)).filter(o => o.repeat);
+        const same = [...around, ...inside].find(o => o.repeat.axis === j.repeat.axis);
+        if (same)
+            fail('JOINT_SCHEMA', `${path}.repeat`, `${same.body1.part}'s row runs along ${same.repeat.axis} too; a row inside a row runs along another axis`);
+    }
     if (j.repeat) {
         const r = j.repeat;
         const row = `${path}.repeat`;
-        if (j.type !== 'fixed')
-            fail('JOINT_SCHEMA', row, 'a part in a row does not move on a joint of its own (ADR-0093); fasten it fixed to repeat it');
         if (!('part' in j.body0))
             fail('JOINT_SCHEMA', row, 'a row fills the part it is fastened to; the mounting plane has no length to fill');
         if (!['X', 'Y', 'Z'].includes(r.axis))
             fail('JOINT_SCHEMA', row, `a row runs along X, Y or Z, not ${String(r.axis)}`);
-        if (r.axis.toLowerCase() === V3_FACES[j.body1.face])
+        if (r.axis.toLowerCase() === V3_FACES[childFaceOf(asset.document.model, j)])
             fail('JOINT_SCHEMA', row, `a row runs across the face it is fastened to; ${r.axis} is out of that face`);
         if (typeof r.pitch === 'number' ? !(Number.isFinite(r.pitch) && r.pitch > 0) : !(r.pitch && typeof r.pitch === 'object' && r.pitch.from))
             fail('GEOMETRY_DOMAIN', row, 'a row has a positive pitch, or one that follows a length');
@@ -1153,11 +1207,6 @@ function checkJoint(asset, j) {
             if (!(Number.isFinite(r.rise.mm) && r.rise.mm !== 0))
                 fail('GEOMETRY_DOMAIN', `${row}.rise`, 'a rise is a length in mm, not zero');
         }
-        const held = others.filter(o => 'part' in o.body0 && o.body0.part === j.body1.part).map(o => o.body1.part);
-        if (held.length)
-            fail('JOINT_SCHEMA', row, `${j.body1.part} holds ${held.join(', ')}; a part in a row holds nothing`);
-        if (others.some(o => o.mimic?.joint === j.id))
-            fail('JOINT_SCHEMA', row, `a joint follows ${j.id}; a part in a row does not move`);
     }
 }
 /**
@@ -1180,11 +1229,12 @@ function writeJoint(asset, j) {
     const turned = !isIdentity(back);
     const own = AXES.map(a => j.origin?.turn?.[a] ?? 0);
     /* The child as it stands: its quarter turn, then its twist about the normal of the face it is fastened by. */
-    const normal = V3_FACES[j.body1.face];
+    const childFace = childFaceOf(m, j);
+    const normal = V3_FACES[childFace];
     const standing = j.origin?.twist ? mul3(axisTurn(normal, j.origin.twist), turnMatrix(own)) : turnMatrix(own);
     /* In the parent's frame: its twist about the face's normal there, and the quarter turn that is left. */
     const inParent = mul3(back, standing);
-    const localNormal = axisOf(mv3(back, FACE_VECTOR[j.body1.face]), `${j.body1.part}'s ${j.body1.face}`, parent ?? '', back, path);
+    const localNormal = axisOf(mv3(back, FACE_VECTOR[childFace]), `${j.body1.part}'s ${childFace}`, parent ?? '', back, path);
     /* The record's twist, about the normal as it lies in the parent's frame; what is left is a quarter turn. */
     /*
       In the parent's frame the child stands twisted about the face's normal -- by its own twist, and back by its
@@ -1219,13 +1269,14 @@ function writeJoint(asset, j) {
         for (const ref of now)
             dropIfUnused(asset, ref);
     }
-    if (j.repeat) {
-        if (turned)
-            fail('JOINT_SCHEMA', `joints.${j.id}.repeat`, `${parent} stands turned; a row across a turned part is not covered yet`);
-        return repeatPart(asset, j);
-    }
-    if (j.type === 'fixed')
+    if (j.repeat && turned)
+        fail('JOINT_SCHEMA', `joints.${j.id}.repeat`, `${parent} stands turned; a row across a turned part is not covered yet`);
+    /* A row is laid out last, once its part's motion is written: every copy moves on it (a roller row spinning). */
+    if (j.type === 'fixed') {
+        if (j.repeat)
+            repeatPart(asset, j);
         return;
+    }
     const kind = j.type === 'prismatic' ? 'slide' : 'turn';
     const unit = j.type === 'prismatic' ? (j.travel ? 'ratio' : 'mm') : 'deg';
     const range = j.lowerLimit !== undefined && j.upperLimit !== undefined ? { min: j.lowerLimit, max: j.upperLimit } : j.type === 'revolute' ? { min: -180, max: 180 } : { min: 0, max: 1 };
@@ -1249,6 +1300,8 @@ function writeJoint(asset, j) {
       (the telescopic conveyor, 2026-09-25). For a leader whose control is its distance the two are one value.
     */
     leader ? { of: nodeById(m, `${leader.body1.part}.motion`)?.args[3] ?? stateIdOf(leader), k: j.mimic.multiplier, c: j.mimic.offset ?? 0 } : undefined, along[axisIndex] > 0 ? 1 : -1);
+    if (j.repeat)
+        repeatPart(asset, j);
 }
 const IDENTITY = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
 const isIdentity = (r) => r.every((row, i) => row.every((v, k) => Math.abs(v - (i === k ? 1 : 0)) < 1e-12));
@@ -1268,7 +1321,7 @@ function standingTurnOf(asset, part, path) {
         fail('EDIT_TARGET', path, `${part} is turned (${saidTurn(turn)}); fastening to a turned part by its faces is covered only for quarter turns`);
     const quarter = turn.every(t => t === 0) ? IDENTITY : turnMatrix(turn);
     /* A twisted part stands twisted about the normal of the face it is fastened by. */
-    return record?.origin?.twist ? mul3(axisTurn(V3_FACES[record.body1.face], record.origin.twist), quarter) : quarter;
+    return record?.origin?.twist ? mul3(axisTurn(V3_FACES[childFaceOf(asset.document.model, record)], record.origin.twist), quarter) : quarter;
 }
 /** How a part stands before its twist: its quarter turn only. */
 function standingQuarterOf(asset, part, path) {
@@ -1396,7 +1449,9 @@ function repeatPart(asset, j) {
     if (!theirs)
         fail('EDIT_TARGET', path, `${parent} has no two faces along ${axis}; there is no length to fill`);
     const mine = standingSpansOf(m, asset, part, path)[axis];
-    if (!mine)
+    /* A frustum has no faces across its axis; it is as wide there as its wider end (G6). */
+    const widest = mine ? undefined : frustumWidthAlong(m, asset, part, axis, path);
+    if (!mine && !widest)
         fail('EDIT_TARGET', path, `${part} has no two faces along ${axis}; its copies cannot be spaced`);
     const { place, pose } = partOf(m, part, path);
     const seat = nodeById(m, `${part}.seat.rigid`);
@@ -1404,22 +1459,25 @@ function repeatPart(asset, j) {
     const zero = constantOf(m, 'mm', 0, 'd');
     /* The seat moves to the row's start; each copy's centre is where the layout puts it from there. */
     seat.args = seat.args.map((ref, i) => (i === k ? sumOf(m, name, theirs.lo, 'start') : ref));
-    const own = mine.centred ? zero : sumOf(m, name, neg([...half(mine.lo), ...half(mine.hi)]), 'own-centre');
+    const own = widest || mine.centred ? zero : sumOf(m, name, neg([...half(mine.lo), ...half(mine.hi)]), 'own-centre');
     pose.args = pose.args.map((ref, i) => (i === k ? own : ref));
     const length = sumOf(m, name, [...theirs.hi, ...neg(theirs.lo)], 'length');
-    const extent = sumOf(m, name, [...mine.hi, ...neg(mine.lo)], 'extent');
+    const extent = widest ?? sumOf(m, name, [...mine.hi, ...neg(mine.lo)], 'extent');
     const centred = constantOf(m, 'ratio', 0.5, 'k');
     const limit = constantOf(m, 'count', REPEAT_LIMIT, 'limit');
     const count = j.repeat.count;
     m.nodes.push(count === undefined
         ? { id: `${part}.layout`, op: 'fit-pitch@1', args: [length, zero, zero, extent, measureRef(m, asset, name, j.repeat.pitch, 'pitch', path), centred, limit], outputs: { layout: `${part}.layout.value` } }
         : { id: `${part}.layout`, op: 'fixed-count@1', args: [constantOf(m, 'count', count, 'count'), length, zero, zero, extent, centred, limit], outputs: { layout: `${part}.layout.value` } });
-    /* The part is the row's template now: a member, drawn only through the row. */
+    /* The part is the row's template now: a member, drawn only through the row -- turned by its motion, if it moves. */
     place.op = 'member@1';
-    place.args = [place.args[0], pose.outputs.pose];
+    place.args = [place.args[0], nodeById(m, `${part}.turned`)?.outputs?.pose ?? pose.outputs.pose];
     m.nodes.push({ id: `${part}.assembly`, op: 'assembly@1', args: [place.outputs.placed], outputs: { assembly: `${part}.assembly.value` } });
     /* Where the parent stands, as `attach` finds it: fastened (its world or chain), or placed by its own numbers. */
-    const above = nodeById(m, `${parent}.world`)?.outputs?.pose ?? nodeById(m, `${parent}.chain`)?.outputs?.pose ?? nodeById(m, `${parent}.pose`)?.outputs?.pose;
+    const above = nodeById(m, `${parent}.world`)?.outputs?.pose ??
+        nodeById(m, `${parent}.chain`)?.outputs?.pose ??
+        nodeById(m, `${parent}.turned`)?.outputs?.pose ??
+        nodeById(m, `${parent}.pose`)?.outputs?.pose;
     let root = seat.outputs.pose;
     if (above) {
         m.nodes.push({ id: `${part}.row`, op: 'compose@1', args: [above, seat.outputs.pose], outputs: { pose: `${part}.row.value` } });
@@ -1435,6 +1493,61 @@ function repeatPart(asset, j) {
         params: { axis, ...(rise ? { riseAxis: rise.axis.toLowerCase() } : {}) }
     });
 }
+/**
+ * Everything fastened to a row's part, however far down, goes into the row's assembly: each copy carries it (ADR-0093,
+ * 2026-09-26). Its placement already reads its copy's frame -- it hangs from the part's pose, not from a chain.
+ */
+function gatherRows(asset, joints) {
+    const m = asset.document.model;
+    for (const row of joints.filter(j => j.repeat)) {
+        const assembly = nodeById(m, `${row.body1.part}.assembly`);
+        /* Down to the next row: a row inside this one joins as its copies, and what hangs from its part is its own. */
+        const gather = (part) => {
+            for (const o of joints.filter(o => 'part' in o.body0 && o.body0.part === part)) {
+                if (o.repeat) {
+                    const inner = nodeById(m, `${o.body1.part}.repeat`);
+                    inner.params = { ...inner.params, within: `${row.body1.part}.repeat` };
+                    assembly.args.push(inner.outputs.collection);
+                    continue;
+                }
+                const place = nodeById(m, o.body1.part);
+                place.op = 'member@1';
+                assembly.args.push(place.outputs.placed);
+                gather(o.body1.part);
+            }
+        };
+        gather(row.body1.part);
+    }
+}
+/**
+ * How wide a frustum is across its own axis, where the row runs: the larger of its two diameters, as the bounds of two
+ * candidates (\`affine-bounds@1\`) -- the room's own way to take the larger of sums, so the gate still reads it as a sum
+ * (chief architect, 2026-09-26). Undefined for any other shape, or a row along the frustum's own axis.
+ */
+function frustumWidthAlong(m, asset, part, axis, path) {
+    const { shape } = partOf(m, part, path);
+    if (shape.op !== 'frustum-shape@1')
+        return undefined;
+    const r = quarterTurnOf(m, asset, part, path, true);
+    const own = AXES[r[AXES.indexOf(axis)].findIndex(v => v !== 0)];
+    if (own === 'y')
+        return undefined;
+    const id = `${part}.width.${own}`;
+    if (!nodeById(m, id)) {
+        const zero = constantOf(m, 'mm', 0, 'd');
+        const two = constantOf(m, 'ratio', 2, 'k');
+        const [top, bottom] = shape.args;
+        /* xmin, xmax, ymin, ymax, zmin, zmax: only the one maximum is read; the others hold a zero each. */
+        m.nodes.push({
+            id,
+            op: 'affine-bounds@1',
+            args: [zero, zero, top, two, zero, bottom, two, zero, zero, zero, zero],
+            outputs: { xmin: `${id}.unused.xmin`, xmax: `${id}.value`, ymin: `${id}.unused.ymin`, ymax: `${id}.unused.ymax`, zmin: `${id}.unused.zmin`, zmax: `${id}.unused.zmax` },
+            params: { layout: 'L0.1_1.0.0.0.0' }
+        });
+    }
+    return `${id}.value`;
+}
 /** A row made back into its one part, so its fastening can be taken away or written again. */
 function unrepeatPart(asset, part) {
     const m = asset.document.model;
@@ -1504,10 +1617,15 @@ function rewriteJoints(asset) {
             stableDimension(asset.document.model, j.travel.source.part, j.travel.source.axis, `joints.${j.id}.travel`);
     const order = writingOrder(joints);
     const keep = { ...asset.stateDefaults };
+    /* What hangs from a row's part is drawn through the row; it is a part of its own again while the joints are written. */
+    for (const n of asset.document.model.nodes)
+        if (n.op === 'member@1' && !nodeById(asset.document.model, `${n.id}.repeat`))
+            n.op = 'place@1';
     for (const j of [...order].reverse())
         stripJoint(asset, j);
     for (const j of order)
         writeJoint(asset, j);
+    gatherRows(asset, joints);
     // A joint's value as the author left it (「지금 자세를 기본으로」) is theirs, not the record's.
     for (const j of order)
         if (j.type !== 'fixed' && !j.mimic && keep[stateIdOf(j)] !== undefined)
@@ -1653,7 +1771,7 @@ function setJoint(asset, joint) {
     if (!jointAbove(asset, j.body1.part) && !j.origin?.turn) {
         const turn = turnOf(asset.document.model, asset, j.body1.part, j.body1.part);
         /* A part turned by any angle about the normal of the face it is fastened by keeps that angle as its twist. */
-        const n = AXES.indexOf(V3_FACES[j.body1.face]);
+        const n = AXES.indexOf(V3_FACES[childFaceOf(asset.document.model, j)]);
         const quarter = (t) => t !== null && Number.isFinite(t) && Math.abs(t / 90 - Math.round(t / 90)) < 1e-9;
         const twist = !quarter(turn[n]) && turn.every((t, i) => i === n || t === 0) ? turn[n] : undefined;
         if (twist !== undefined && !j.origin?.twist)
@@ -2279,34 +2397,122 @@ function occupancyLins(asset, over) {
     const balls = new Map();
     /* A row's template stands for its copies (`repeatPart`): leaving it out left a conveyor's rollers out of its room. */
     const rowOf = (id) => nodeById(m, `${id}.repeat`);
-    for (const place of m.nodes.filter((n) => n.op === 'place@1' || (n.op === 'member@1' && rowOf(n.id)))) {
+    const ends = over === 'rest' ? ['start'] : ['min', 'max'];
+    /* A part's size along the figure's axes, whichever quarter turns it and what carries it stand in. */
+    const sizesOf = (id, turns) => {
+        /* A turned chain's reach is read from one size per axis (reachOf), so a part there must have one. */
+        const own = occupiedExtentsOf(m, id, id, turns);
+        const c = turns ? IDENTITY : worldTurnOf(m, asset, id);
+        if (!c)
+            throw new V3ContractError('EDIT_TARGET', id, `${id} is turned by other than quarter turns`);
+        return Object.fromEntries(AXES.map((axis, i) => [axis, own[AXES[c[i].findIndex(v => v !== 0)]]]));
+    };
+    /*
+      A row runs from its parent's one edge to the other along its axis, every copy inside (fit-pitch and fixed-count lay
+      them out within that length). What it spans there, how long its part is along it, and how far a rising row climbs.
+    */
+    const runOf = (part) => {
+        const row = rowOf(part);
+        const axis = String(row.params?.axis ?? '').toLowerCase();
+        const parent = parentOf(m, part);
+        const straight = parent && worldTurnOf(m, asset, parent);
+        if (!parent || !AXES.includes(axis) || !straight || AXES.some((_, i) => straight[i][i] !== 1))
+            return `${part} is a row whose run this command cannot read`;
+        const theirs = standingRefsOf(m, asset, parent, parent, false)[axis];
+        const half = { terms: [{ ref: theirs.ref, k: 0.5 * theirs.k }], c: 0 };
+        const centres = ends.map(end => centreLin(m, asset, parent, axis, end));
+        const bad = centres.find(c => typeof c === 'string');
+        if (bad)
+            return String(bad);
+        const mine = sizesOf(part, false)[axis][0];
+        const extent = { terms: [{ ref: mine.ref, k: mine.k }], c: 0 };
+        const record = (asset.joints ?? []).find(o => o.body1.part === part && o.repeat)?.repeat;
+        let climb;
+        if (record?.rise) {
+            /*
+              The last copy is (count − 1) rises past the first. A row that fills its length has at most
+              (length − one copy) / pitch copies past the first, so that many rises bound it and follow the parent's size;
+              a counted row has exactly count − 1.
+            */
+            const per = record.rise.mm;
+            let reach;
+            if (record.count !== undefined)
+                reach = { terms: [], c: (record.count - 1) * per };
+            else if (typeof record.pitch === 'number')
+                reach = { terms: [{ ref: theirs.ref, k: (theirs.k * per) / record.pitch }, { ref: mine.ref, k: (-mine.k * per) / record.pitch }], c: 0 };
+            else
+                return `${part} is a rising row whose pitch follows a length; how far it rises is not added up`;
+            climb = { axis: record.rise.axis.toLowerCase(), up: per > 0, reach };
+        }
+        return { axis, lows: centres.map(c => linAdd(c, half, -1)), highs: centres.map(c => linAdd(c, half, 1)), extent, climb };
+    };
+    /* A part in a row, or fastened to one: each copy carries it (ADR-0093, 2026-09-26). */
+    for (const place of m.nodes.filter((n) => n.op === 'place@1' || (n.op === 'member@1' && (rowOf(n.id) || rowHolding(m, n.id))))) {
         const turns = carriedByATurn(m, asset, place.id);
         let sizes = {};
         try {
-            /* A turned chain's reach is read from one size per axis (reachOf), so a part there must have one. */
-            const own = turns ? occupiedExtentsOf(m, place.id, place.id, true) : occupiedExtentsOf(m, place.id, place.id);
-            /* Its size along the figure's axes, whichever quarter turns it and what carries it stand in. */
-            const c = turns ? IDENTITY : worldTurnOf(m, asset, place.id);
-            if (!c)
-                throw new V3ContractError('EDIT_TARGET', place.id, `${place.id} is turned by other than quarter turns`);
-            AXES.forEach((axis, i) => (sizes[axis] = own[AXES[c[i].findIndex(v => v !== 0)]]));
+            sizes = sizesOf(place.id, turns);
         }
         catch (e) {
             skipped.push({ part: place.id, reason: e instanceof V3ContractError ? e.message : 'not a part whose size this command can read' });
             continue;
         }
-        const row = place.op === 'member@1' ? rowOf(place.id) : undefined;
-        if (turns && row) {
-            skipped.push({ part: place.id, reason: `${place.id} is a row carried by a turn; where its copies reach is not added up` });
+        /*
+          The rows around this part, nearest first: its own if it is a row's part, then the row of each part it hangs from
+          (a grid is a row inside a row, each along its own axis).
+        */
+        const rows = [];
+        let unread;
+        for (let up = place.op === 'member@1' ? place.id : null; up; up = parentOf(m, up)) {
+            if (!rowOf(up))
+                continue;
+            const run = runOf(up);
+            if (typeof run === 'string') {
+                unread = run;
+                break;
+            }
+            rows.push({ part: up, run });
+        }
+        if (unread) {
+            skipped.push({ part: place.id, reason: unread });
             continue;
         }
+        const rowAxes = new Set(rows.map(r => r.run.axis));
+        /* How far the rows around it climb, along an axis and a way, added up: each copy of each row is further up. */
+        const climbed = (at, side, onto, axis) => {
+            const climbs = rows.map(r => r.run.climb).filter(c => c && c.axis === axis && (c.up ? 1 : -1) === side);
+            if (climbs.length)
+                onto[axis].push(climbs.reduce((sum, c) => linAdd(sum, c.reach), at));
+        };
         if (turns) {
-            const reach = reachOf(m, asset, place.id, over === 'rest' ? ['start'] : ['min', 'max']);
+            const reach = reachOf(m, asset, place.id, ends);
             if (typeof reach === 'string') {
                 skipped.push({ part: place.id, reason: reach });
                 continue;
             }
             parts.push(place.id);
+            if (rows.length) {
+                /*
+                  Each copy turns about its own pivot, which lies on its rows' runs: along a row the copies reach the run's
+                  ends and the turn's reach past them; across them, the turn's reach about the pivot.
+                */
+                for (const { run } of rows) {
+                    for (const l of run.lows)
+                        low[run.axis].push(linAdd(l, reach.radius, -1));
+                    for (const h of run.highs)
+                        high[run.axis].push(linAdd(h, reach.radius, 1));
+                }
+                for (const at of reach.centres)
+                    for (const axis of AXES.filter(a => !rowAxes.has(a))) {
+                        const lo = linAdd(at[axis], reach.radius, -1);
+                        const hi = linAdd(at[axis], reach.radius, 1);
+                        low[axis].push(lo);
+                        high[axis].push(hi);
+                        climbed(lo, -1, low, axis);
+                        climbed(hi, 1, high, axis);
+                    }
+                continue;
+            }
             for (const at of reach.centres) {
                 const centre = Object.fromEntries(AXES.map(a => [a, linNorm(at[a])]));
                 const key = JSON.stringify(centre);
@@ -2322,64 +2528,50 @@ function occupancyLins(asset, over) {
           max, so the answer holds whichever way the travel runs, and holds at every design size, because the
           choice is made when the graph is evaluated rather than when the proposal is written.
         */
-        const ends = over === 'rest' ? ['start'] : ['min', 'max'];
         const readings = AXES.map(axis => ({ axis, at: ends.map(end => centreLin(m, asset, place.id, axis, end)) }));
         const bad = readings.flatMap(r => r.at).find(v => typeof v === 'string');
         if (bad) {
             skipped.push({ part: place.id, reason: String(bad) });
             continue;
         }
-        /*
-          A row runs from its parent's one edge to the other along its axis, every copy inside (fit-pitch and fixed-count
-          lay them out within that length): along it the row takes the parent's room, across it the template's.
-        */
-        let rowAxis;
-        /* A rising row (G2): how much further the last copy stands than the first, along the axis it rises on. */
-        let climb;
-        if (row) {
-            rowAxis = String(row.params?.axis ?? '').toLowerCase();
-            const parent = parentOf(m, place.id);
-            const straight = parent && worldTurnOf(m, asset, parent);
-            if (!parent || !AXES.includes(rowAxis) || !straight || AXES.some((_, i) => straight[i][i] !== 1)) {
-                skipped.push({ part: place.id, reason: `${place.id} is a row whose run this command cannot read` });
+        let offRun;
+        for (const { part: template, run } of rows) {
+            if (template === place.id) {
+                /* The row's own part: along the row it takes the run. */
+                low[run.axis].push(...run.lows);
+                high[run.axis].push(...run.highs);
                 continue;
             }
-            const theirs = standingRefsOf(m, asset, parent, parent, false)[rowAxis];
-            const half = { terms: [{ ref: theirs.ref, k: 0.5 * theirs.k }], c: 0 };
-            const centres = ends.map(end => centreLin(m, asset, parent, rowAxis, end));
-            if (centres.some(c => typeof c === 'string')) {
-                skipped.push({ part: place.id, reason: String(centres.find(c => typeof c === 'string')) });
-                continue;
+            /*
+              Carried by a row's part: its copies stand where that part's copies do, offset as it is from it. That part's
+              centres lie half its length in from the run's ends.
+            */
+            const theirs = ends.map(end => centreLin(m, asset, template, run.axis, end));
+            const bad = theirs.find(c => typeof c === 'string');
+            if (bad) {
+                offRun = String(bad);
+                break;
             }
-            const record = (asset.joints ?? []).find(o => o.body1.part === place.id && o.repeat)?.repeat;
-            if (record?.rise) {
-                /*
-                  The last copy is (count − 1) rises past the first. A row that fills its length has at most
-                  (length − one copy) / pitch copies past the first, so that many rises bound it and follow the parent's size;
-                  a counted row has exactly count − 1.
-                */
-                const per = record.rise.mm;
-                let reach;
-                if (record.count !== undefined)
-                    reach = { terms: [], c: (record.count - 1) * per };
-                else if (typeof record.pitch === 'number') {
-                    const mine = sizes[rowAxis][0];
-                    reach = { terms: [{ ref: theirs.ref, k: (theirs.k * per) / record.pitch }, { ref: mine.ref, k: (-mine.k * per) / record.pitch }], c: 0 };
-                }
-                else {
-                    skipped.push({ part: place.id, reason: `${place.id} is a rising row whose pitch follows a length; how far it rises is not added up` });
-                    continue;
+            const along = readings.find(r => r.axis === run.axis).at;
+            const inset = linAdd({ terms: [], c: 0 }, run.extent, 0.5);
+            for (const [i, mine] of along.entries()) {
+                const offset = linAdd(mine, theirs[i], -1);
+                for (const e of sizes[run.axis]) {
+                    const half = { terms: [{ ref: e.ref, k: 0.5 * e.k }], c: 0 };
+                    for (const l of run.lows)
+                        low[run.axis].push(linAdd(linAdd(linAdd(l, inset), offset), half, -1));
+                    for (const h of run.highs)
+                        high[run.axis].push(linAdd(linAdd(linAdd(h, inset, -1), offset), half));
                 }
-                climb = { axis: record.rise.axis.toLowerCase(), up: per > 0, reach };
-            }
-            for (const centre of centres) {
-                low[rowAxis].push(linAdd(centre, half, -1));
-                high[rowAxis].push(linAdd(centre, half, 1));
             }
         }
+        if (offRun) {
+            skipped.push({ part: place.id, reason: offRun });
+            continue;
+        }
         parts.push(place.id);
         for (const r of readings) {
-            if (r.axis === rowAxis)
+            if (rowAxes.has(r.axis))
                 continue;
             const halves = sizes[r.axis].map(e => ({ terms: [{ ref: e.ref, k: 0.5 * e.k }], c: 0 }));
             const seen = new Set();
@@ -2389,10 +2581,12 @@ function occupancyLins(asset, over) {
                     continue; // a part that does not move gives the same candidate twice
                 seen.add(key);
                 for (const half of halves) {
-                    low[r.axis].push(linAdd(centre, half, -1));
-                    high[r.axis].push(linAdd(centre, half, 1));
-                    if (climb?.axis === r.axis)
-                        (climb.up ? high : low)[r.axis].push(linAdd(linAdd(centre, half, climb.up ? 1 : -1), climb.reach));
+                    const lo = linAdd(centre, half, -1);
+                    const hi = linAdd(centre, half, 1);
+                    low[r.axis].push(lo);
+                    high[r.axis].push(hi);
+                    climbed(lo, -1, low, r.axis);
+                    climbed(hi, 1, high, r.axis);
                 }
             }
         }
@@ -2846,7 +3040,7 @@ function proportionPlan(asset) {
             plan.skipped.push({ what: `${part}.place`, reason: 'stands by no fastening; fasten it for its place to follow' });
     }
     for (const j of (asset.joints ?? [])) {
-        const faceAxis = V3_FACES[j.body1.face];
+        const faceAxis = V3_FACES[childFaceOf(m, j)];
         const gap = j.origin?.gap;
         if (typeof gap === 'number' && gap !== 0)
             plan.lengths.push({ joint: j.id, at: 'gap', axis: faceAxis, times: share(gap, faceAxis) });