@things-factory/figure-ui 10.1.200 → 10.1.202

package/test/fasten-form.test.ts

@@ -14,7 +14,7 @@ import { revisionOf } from './revision-of.ts'
 
 const box = (asset: FigureAsset, id: string, [x, y, z]: number[], at = [0, 0, 0]) => addFigureBox(asset, { id, size: { x, y, z }, position: { x: at[0]!, y: at[1]!, z: at[2]! } })
 const fasten = (asset: FigureAsset, part: string, to: string, more = {}) =>
-  applyFigureAuthoring(asset, { kind: 'attach', part, face: 'bottom', to: to === 'plane' ? { plane: 'mounting-plane' } : { part: to, face: 'top' }, ...more } as never)
+  applyFigureAuthoring(asset, { kind: 'attach', part, to: to === 'plane' ? { plane: 'mounting-plane' } : { part: to, face: 'top' }, ...more } as never)
 
 /* A frame on the floor, a roller on the frame 300 mm off its centre, a loose lid beside them. */
 function conveyor() {
@@ -32,12 +32,20 @@ test('opened on what the part has; a loose part opens on nothing chosen', () =>
   assert.equal(fastenPlanOf(r, 'lid', fastenFormOf(r, 'lid')).action, undefined, 'nothing to apply until something is chosen')
 })
 
+test('on the plane: a floor takes a part standing on it or hanging below it, a wall only one standing out of it', () => {
+  const loose = addFigureBox(createFigureAsset('Lamp'), { id: 'lamp', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 0, z: 0 } })
+  const hung = { ...freshFasten(), toPlane: true, facing: 'flush' as const }
+  assert.equal((fastenPlanOf(revisionOf(loose), 'lamp', hung).action as { facing?: string }).facing, 'flush')
+  const wall = { ...loose, placement: 'wall' as const }
+  assert.equal((fastenPlanOf(revisionOf(wall), 'lamp', hung).action as { facing?: string }).facing, undefined, 'a wall: standing out of it')
+})
+
 test('the one it has, unchanged, comes to the attach that replaces it with the same place across the face', () => {
   const r = conveyor()
   const plan = fastenPlanOf(r, 'roller', fastenFormOf(r, 'roller'))
-  assert.deepEqual(plan.action, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' }, facing: 'meet', twist: 0, align: { x: { mm: 300 } }, replace: true })
+  assert.deepEqual(plan.action, { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' }, facing: 'meet', align: { x: { mm: 300 } }, replace: true })
   assert.deepEqual(plan.face, { part: 'frame', face: 'top' }, 'the face it meets, lit while tried')
-  assert.equal(fastenSentenceOf('roller', fastenFormOf(r, 'roller'), plan, '바닥', say), 'figure.text.fasten-sentence-meet(part=roller,face=figure.label.face-bottom(),to=frame의 figure.label.face-top())')
+  assert.equal(fastenSentenceOf(fastenFormOf(r, 'roller'), plan, '바닥', say), 'figure.text.fasten-sentence-meet(to=frame의 figure.label.face-top())')
 })
 
 test('aimed at a part, the loose lid keeps its place across the face; aimed at the plane, nothing is said of a part face', () => {

package/test/fasten-geometry.test.ts

@@ -1,52 +1,43 @@
 /*
  * **붙이기 그림이 읽는 것** (사용자 2026-10-01: 「면을 선택하는 것이 복잡해보인다」).
  *
- * 붙이기는 상대 면과 방식(올려놓기 · 같은 면 · 가운데를 면에)만 고른다. 부품의 면은 거기서 정해진다 — 돌려 놓인 부품이면
- * 지금 그 방향을 보는 면이다. 면 위에 놓은 자리는 가운데·안쪽 끝·바깥 끝에 붙고, 그 밖은 mm 다. figure-model 이 그 명령을
- * 받아 부품을 정말 그 자리에 두는지까지 잰다.
+ * 붙이기는 상대 면과 방식(올려놓기 · 같은 면 · 가운데를 면에)만 고른다. 부품은 제 면 없이 지금 자세의 실제 모양으로 닿는다
+ * (ADR-0140 3.2) — 그림의 발자국도 그 모양을 면 위 두 축으로 잰 것이다(figure-model `figureFaceMeasureOf`). 면 위에 놓은 자리는
+ * 가운데·안쪽 끝·바깥 끝에 붙고, 그 밖은 mm 다. figure-model 이 그 명령을 받아 부품을 정말 그 자리에 두는지까지 잰다.
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAsset, figurePartFaceOf } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureAuthoringAction } from '@hatiolab/figure-model'
 
-import { alignmentAt, faceViewOf, myFaceFor, offsetOf, overhangOf, screenOf } from '../client/modeller/fasten-geometry.ts'
+import { alignmentAt, faceViewOf, offsetOf, overhangOf, screenOf } from '../client/modeller/fasten-geometry.ts'
 import { revisionOf } from './revision-of.ts'
 
 const scene = (lidRotation?: { x: number; y: number; z: number }): FigureAsset => {
   let a = addFigureBox(createFigureAsset('Box'), { id: 'bin', size: { x: 600, y: 300, z: 400 }, position: { x: 0, y: 150, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'bin', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'bin', to: { plane: 'mounting-plane' } })
   return addFigureBox(a, { id: 'lid', size: { x: 300, y: 20, z: 200 }, position: { x: 0, y: 400, z: 0 }, ...(lidRotation ? { rotation: lidRotation } : {}) })
 }
 const at = (a: FigureAsset, id: string) => (compileFigureAsset(a).evaluate().geometry.find(g => (g as { id: string }).id === id) as unknown as { pose: { t: number[] } }).pose.t
 
-test('부품의 면은 상대 면과 방식으로 정해진다: 올려놓기는 마주 보는 면, 같은 면은 같은 면, 가운데는 가운데', () => {
-  const a = scene()
-  assert.equal(myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'top' }, 'meet'), 'bottom')
-  assert.equal(myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'top' }, 'flush'), 'top')
-  assert.equal(myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'front' }, 'meet'), 'back')
-  assert.equal(myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'top' }, 'centre'), 'centre')
-  assert.equal(myFaceFor(revisionOf(a), 'lid', 'plane', 'meet'), 'bottom', 'on a floor: the face looking down')
-  assert.equal(myFaceFor(revisionOf(a), 'lid', 'plane', 'centre'), undefined, 'the plane takes a face, never a centre')
-})
-
-test('돌려 놓인 부품이면 지금 아래를 보는 면이다 — 이름이 아니라 방향으로', () => {
-  const a = scene({ x: 90, y: 0, z: 0 })
-  const face = myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'top' }, 'meet')!
-  assert.notEqual(face, 'bottom', 'turned a quarter about X, its bottom no longer looks down')
-  const n = figurePartFaceOf(a, 'lid', face)!.normal
-  assert.ok(Math.abs(n[1]! + 1) < 1e-6, `${face} looks down: ${n}`)
-})
-
 test('면 그림: 상대 면의 크기와 부품 발자국, 가장자리 맞춤이 되는 축', () => {
-  const v = faceViewOf(revisionOf(scene()), 'lid', { part: 'bin', face: 'top' })!
+  const v = faceViewOf(revisionOf(scene()), 'lid', { part: 'bin', face: 'top' }, 'meet')!
   assert.deepEqual(v.axes, ['x', 'z'])
   assert.deepEqual([v.face.x, v.face.z], [600, 400])
   assert.deepEqual([v.part.x, v.part.z], [300, 200])
   assert.deepEqual(v.edges, { x: true, z: true })
 })
 
+test('돌려 놓인 부품의 발자국은 지금 자세의 실제 모양이다 — 제 면 이름이 아니라', () => {
+  /* Turned a quarter about X: its 20 mm thickness now lies along Z across the face. */
+  const v = faceViewOf(revisionOf(scene({ x: 90, y: 0, z: 0 })), 'lid', { part: 'bin', face: 'top' }, 'meet')!
+  assert.deepEqual([v.part.x, v.part.z].map(Math.round), [300, 20])
+  /* Turned 30° about Y: its footprint is the turned box's reach, 300 cos 30 + 200 sin 30 across X. */
+  const turned = faceViewOf(revisionOf(scene({ x: 0, y: 30, z: 0 })), 'lid', { part: 'bin', face: 'top' }, 'meet')!
+  assert.ok(Math.abs(turned.part.x - (300 * Math.cos(Math.PI / 6) + 200 * 0.5)) < 1e-6, String(turned.part.x))
+})
+
 test('놓은 자리: 가운데, 안쪽 끝(가장자리와 나란히), 바깥 끝(가장자리에 닿게), 그 밖은 mm', () => {
   assert.deepEqual(alignmentAt(4, 600, 300, true, 10), { how: 'centre', caught: 'centre' })
   assert.deepEqual(alignmentAt(146, 600, 300, true, 10), { how: 'max', caught: 'inside' })
@@ -58,18 +49,18 @@ test('놓은 자리: 가운데, 안쪽 끝(가장자리와 나란히), 바깥
 })
 
 test('면 밖으로 나온 곳과 닿지 않는 것을 말한다', () => {
-  const v = faceViewOf(revisionOf(scene()), 'lid', { part: 'bin', face: 'top' })!
-  assert.deepEqual(overhangOf(v, { x: 0, y: 0, z: 0 }), { touching: true, sides: [] })
-  assert.deepEqual(overhangOf(v, { x: 200, y: 0, z: 0 }), { touching: true, sides: [{ axis: 'x', side: 'high', mm: 50 }] })
-  assert.equal(overhangOf(v, { x: 460, y: 0, z: 0 }).touching, false)
+  const v = faceViewOf(revisionOf(scene()), 'lid', { part: 'bin', face: 'top' }, 'meet')!
+  assert.deepEqual(overhangOf(v, { x: 0, y: 0, z: 0 }), { touching: true, contact: 'on', sides: [] })
+  assert.deepEqual(overhangOf(v, { x: 200, y: 0, z: 0 }), { touching: true, contact: 'on', sides: [{ axis: 'x', side: 'high', mm: 50 }] })
+  assert.deepEqual(overhangOf(v, { x: 460, y: 0, z: 0 }), { touching: false, contact: 'off', sides: [{ axis: 'x', side: 'high', mm: 310 }] })
 })
 
 test('그 자리가 명령이 되면 figure-model 이 부품을 정말 거기 둔다: 오른쪽 끝, 같은 면, 바깥 끝', () => {
   const a = scene()
   const attach = (extra: Partial<Extract<FigureAuthoringAction, { kind: 'attach' }>>) =>
-    applyFigureAuthoring(a, { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'bin', face: 'top' }, ...extra } as FigureAuthoringAction)
+    applyFigureAuthoring(a, { kind: 'attach', part: 'lid', to: { part: 'bin', face: 'top' }, ...extra } as FigureAuthoringAction)
   assert.deepEqual(at(attach({ align: { x: 'max' } }), 'lid').map(Math.round), [150, 310, 0])
-  assert.deepEqual(at(attach({ face: 'top', facing: 'flush' }), 'lid').map(Math.round), [0, 290, 0])
+  assert.deepEqual(at(attach({ facing: 'flush' }), 'lid').map(Math.round), [0, 290, 0])
   assert.deepEqual(at(attach({ align: { x: { mm: 450 } } }), 'lid').map(Math.round), [450, 310, 0], 'past the edge: fastened all the same')
 })
 

package/test/fix-alignment.test.ts

@@ -1,14 +1,24 @@
 /*
  * 정렬·간격 고치기 (fasten-geometry `insideAlignmentOf`): the alignment that brings a part inside the face it is fastened
- * on -- the least move on each side it is out, the centre when it is wider -- or why there is nothing to move.
+ * on -- the least move on each side it is out, the centre when it is wider -- or why there is nothing to move. The move
+ * is figure-model's (`figureFaceInsideAlignOf`), measured on the part's real shape; this reads it in the form's words.
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { insideAlignmentOf, type FaceView } from '../client/modeller/fasten-geometry.js'
+import { addFigureBox, applyFigureAuthoring, createFigureAsset } from '@hatiolab/figure-model'
+
+import { faceViewOf, insideAlignmentOf, type FaceView } from '../client/modeller/fasten-geometry.js'
+import { revisionOf } from './revision-of.ts'
 
 /* A 400 × 1000 top, a 100 × 100 footprint on it; edges offered on X, a distance only on Z. */
-const view = (part = { x: 100, y: 100, z: 100 }): FaceView => ({ axes: ['x', 'z'], face: { x: 400, z: 1000 }, part, edges: { x: true, y: true, z: false } })
+const view = (part = { x: 100, y: 100, z: 100 }): FaceView => {
+  let a = addFigureBox(createFigureAsset('Top'), { id: 'top', size: { x: 400, y: 40, z: 1000 }, position: { x: 0, y: 20, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'top', to: { plane: 'mounting-plane' } })
+  a = addFigureBox(a, { id: 'box', size: part, position: { x: 0, y: 200, z: 0 } })
+  const v = faceViewOf(revisionOf(a), 'box', { part: 'top', face: 'top' }, 'meet')!
+  return { ...v, edges: { x: true, y: true, z: false } }
+}
 
 test('out past the low edge: moved to that edge from inside, the other axis left as it was', () => {
   const fixed = insideAlignmentOf(view(), { x: 'mm', z: 'centre' }, { x: -1000 })
@@ -28,5 +38,7 @@ test('wider than the face: centred, the most of it on the face', () => {
 test('nothing of it out: inside -- what is out is fastened on it; no face size: unmeasured', () => {
   assert.deepEqual(insideAlignmentOf(view(), { x: 'max', z: 'centre' }, {}), { cannot: 'inside' })
   assert.deepEqual(insideAlignmentOf(undefined, {}, {}), { cannot: 'unmeasured' })
-  assert.deepEqual(insideAlignmentOf({ ...view(), face: { x: 400 } }, {}, {}), { cannot: 'unmeasured' })
+  /* The plane of a figure that declares no size has no edges to measure against. */
+  const loose = addFigureBox(createFigureAsset('Loose'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+  assert.deepEqual(insideAlignmentOf(faceViewOf(revisionOf(loose), 'box', 'plane', 'meet'), {}, {}), { cannot: 'unmeasured' })
 })

package/test/gizmo.test.ts

@@ -53,7 +53,7 @@ test('다른 부품에 붙인 부품은 옮기지 않는다 — 다음 평가가
   /* attach takes box-shaped parts only. */
   const lidded = addFigureBox(probe(), { id: 'lid', size: { x: 100, y: 20, z: 100 }, position: { x: 0, y: 300, z: 0 } })
   assert.equal(gizmoReachOf(lidded as never, 'lid').translate, true, '전제: 붙이기 전에는 옮길 수 있다')
-  const fastened = applyFigureAuthoring(lidded, { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'body', face: 'top' } })
+  const fastened = applyFigureAuthoring(lidded, { kind: 'attach', part: 'lid', to: { part: 'body', face: 'top' } })
   assert.equal(gizmoReachOf(fastened as never, 'lid').translate, false)
 })
 
@@ -98,7 +98,7 @@ test('기즈모의 말은 다섯 말 모두에 있다', () => {
 test('떼어 낸 부품은 다시 옮길 수 있다 — 움직임이 있는 부품은 아니다', () => {
   let asset = probe()
   asset = addFigureBox(asset, { id: 'lid', size: { x: 100, y: 20, z: 100 }, position: { x: 0, y: 300, z: 0 } })
-  const fastened = applyFigureAuthoring(asset, { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'body', face: 'top' } })
+  const fastened = applyFigureAuthoring(asset, { kind: 'attach', part: 'lid', to: { part: 'body', face: 'top' } })
   const free = applyFigureAuthoring(fastened, { kind: 'detach', part: 'lid' })
   assert.equal(gizmoReachOf(free as never, 'lid').translate, true)
   const slid = moving(free, 'lid', { kind: 'slide', axis: 'x', id: 'lid-slide', min: 0, max: 100, start: 0 })

package/test/joint-drag.test.ts

@@ -14,10 +14,10 @@ function column(joint: Partial<FigureJoint>): FigureAsset {
   let asset = createFigureAsset('Column')
   asset = addFigureBox(asset, { id: 'post', size: { x: 100, y: 200, z: 100 }, position: { x: 0, y: 100, z: 0 } })
   asset = addFigureBox(asset, { id: 'link', size: { x: 60, y: 300, z: 60 }, position: { x: 0, y: 350, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'post', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'post', to: { plane: 'mounting-plane' } })
   return applyFigureAuthoring(asset, {
     kind: 'set-joint',
-    joint: { id: 'bend', type: 'fixed', body0: { part: 'post', face: 'top' }, body1: { part: 'link', face: 'bottom' }, ...joint } as FigureJoint
+    joint: { id: 'bend', type: 'fixed', body0: { part: 'post', face: 'top' }, body1: { part: 'link' }, ...joint } as FigureJoint
   })
 }
 
@@ -61,6 +61,17 @@ test('고정 관절에 달린 부품을 옮기면 관절이 놓인 자리 —
   assert.deepEqual((aside as { joint: FigureJoint }).joint.origin, { align: { x: { mm: 30 } } })
 })
 
+test('면 밖으로 끈 만큼 따라온다 — 맞닿음 · 가운데는 간격이 늘고, 같은 면은 줄어든다 (ADR-0140 3.11)', () => {
+  for (const facing of ['meet', 'flush', 'centre'] as const) {
+    const asset = column({ origin: { facing } })
+    const part = drawn(asset, 'link')
+    const up = jointDragOf(asset, 'link', part as never, { position: [part.pose.t[0]!, part.pose.t[1]! + 25, part.pose.t[2]!] }, {}) as { joint: FigureJoint }
+    assert.equal(up.joint.origin!.gap, facing === 'flush' ? -25 : 25, facing)
+    const moved = drawn(applyFigureAuthoring(asset, { kind: 'set-joint', joint: up.joint }), 'link')
+    assert.ok(Math.abs(moved.pose.t[1]! - (part.pose.t[1]! + 25)) < 1e-6, `${facing}: the link where it was dragged to`)
+  }
+})
+
 test('관계를 끊는 끌기는 거절하고 까닭을 댄다', () => {
   const edge = column({ origin: { align: { x: 'min' } } })
   const part = drawn(edge, 'link')

package/test/joint-fan.test.ts

@@ -21,7 +21,7 @@ function arm(): FigureAsset {
   asset = addFigureBox(asset, { id: 'base', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
   asset = addFigureBox(asset, { id: 'arm', size: { x: 400, y: 50, z: 50 }, position: { x: 200, y: 125, z: 0 } })
   /* On the base's top, level with its left edge: it turns about that edge, at x = -100. */
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'arm', face: 'bottom', to: { part: 'base', face: 'top' }, align: { x: 'min' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'arm', to: { part: 'base', face: 'top' }, align: { x: 'min' } })
   return moving(asset, 'arm', { kind: 'turn', axis: 'y', id: 'arm.turn', min: -45, max: 90 })
 }
 const PIVOT = [-100, 100, 0]

package/test/joint-frames.test.ts

@@ -32,18 +32,18 @@ function framed(): FigureAsset {
   a = box(a, 'link', 100, 400, 100, 300)
   a = box(a, 'tool', 60, 120, 40)
   a = box(a, 'cap', 20, 20, 20)
-  a = set(a, { id: 'base', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'base', face: 'bottom' } })
-  a = set(a, { id: 'link', type: 'revolute', body0: { part: 'base', face: 'top' }, body1: { part: 'link', face: 'bottom' }, origin: { pivot: 'child-face', offset: { x: 20 }, parentRotate: { x: 10 } }, axis: { x: 1, y: 1, z: 0 }, lowerLimit: -90, upperLimit: 90 })
+  a = set(a, { id: 'base', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'base' } })
+  a = set(a, { id: 'link', type: 'revolute', body0: { part: 'base', face: 'top' }, body1: { part: 'link' }, origin: { pivot: 'child-face', offset: { x: 20 }, parentRotate: { x: 10 } }, axis: { x: 1, y: 1, z: 0 }, lowerLimit: -90, upperLimit: 90 })
   a = set(a, { id: 'tool', type: 'revolute', body0: { part: 'link', at: 'origin' }, body1: { part: 'tool', at: 'origin' }, origin: { offset: { x: 120, y: SUMMED, z: -30 }, parentRotate: { x: 15, y: -30, z: 60 } }, axis: 'Z', lowerLimit: -45, upperLimit: 45 })
-  return set(a, { id: 'cap', type: 'fixed', body0: { part: 'tool', at: 'origin' }, body1: { part: 'cap', face: 'centre' }, origin: { offset: { y: 40 } } })
+  return set(a, { id: 'cap', type: 'fixed', body0: { part: 'tool', at: 'origin' }, body1: { part: 'cap' }, origin: { offset: { y: 40 } } })
 }
 
 /** The old shapes only: a token axis, face ends, a gap and an edge. */
 function plain(): FigureAsset {
   let a = box(createFigureAsset('Plain'), 'base', 300, 100, 300, 50)
   a = box(a, 'link', 100, 400, 100, 300)
-  a = set(a, { id: 'base', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'base', face: 'bottom' } })
-  return set(a, { id: 'link', type: 'revolute', body0: { part: 'base', face: 'top' }, body1: { part: 'link', face: 'bottom' }, origin: { gap: 5, align: { x: 'min' } }, axis: 'Y', lowerLimit: -90, upperLimit: 90 })
+  a = set(a, { id: 'base', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'base' } })
+  return set(a, { id: 'link', type: 'revolute', body0: { part: 'base', face: 'top' }, body1: { part: 'link' }, origin: { gap: 5, align: { x: 'min' } }, axis: 'Y', lowerLimit: -90, upperLimit: 90 })
 }
 
 const reopen = (asset: FigureAsset) => parseFigureAsset(serializeFigureAsset(asset) as unknown as string)
@@ -63,15 +63,13 @@ function fasteningSave(asset: FigureAsset, part: string): FigureAuthoringAction
   const f = fasteningOf(revisionOf(asset), part) as Dynamic
   if (!f || f.atOrigin) return null
   const aim = f.toPlane ? ('plane' as const) : { part: f.target, face: f.targetFace }
-  const align = alignOf(asset, part, aim, f.align, f.alignMm, !!f.twist, f.alignInput)
+  const align = alignOf(asset, aim, f.align, f.alignMm, f.alignInput)
   return {
     kind: 'attach',
     part,
-    face: f.face,
     to: f.toPlane ? { plane: 'mounting-plane' } : { part: f.target, face: f.targetFace },
-    ...(f.toPlane ? {} : { facing: f.facing }),
+    ...(f.toPlane ? (f.facing === 'flush' ? { facing: f.facing } : {}) : { facing: f.facing }),
     ...(f.gap ? { gap: f.gap } : {}),
-    twist: f.twist,
     ...(align ? { align } : {}),
     replace: true
   } as FigureAuthoringAction
@@ -115,15 +113,26 @@ test('the axis reader: a token is its axis, a vector its unit vector, unrounded;
 test('a follower is not a turn without end: it has no limits because its leader gives its range', () => {
   let a = box(createFigureAsset('Pair'), 'a', 100, 100, 100, 50)
   a = box(a, 'b', 50, 50, 50, 125)
-  a = set(a, { id: 'a', type: 'revolute', body0: { plane: 'mounting-plane' }, body1: { part: 'a', face: 'bottom' }, axis: 'Y', lowerLimit: -90, upperLimit: 90 })
-  a = set(a, { id: 'b', type: 'revolute', body0: { part: 'a', face: 'top' }, body1: { part: 'b', face: 'bottom' }, axis: 'Y', mimic: { joint: 'a', multiplier: -1 } })
+  a = set(a, { id: 'a', type: 'revolute', body0: { plane: 'mounting-plane' }, body1: { part: 'a' }, axis: 'Y', lowerLimit: -90, upperLimit: 90 })
+  a = set(a, { id: 'b', type: 'revolute', body0: { part: 'a', face: 'top' }, body1: { part: 'b' }, axis: 'Y', mimic: { joint: 'a', multiplier: -1 } })
   assert.equal(motionOf(a, 'b')?.kind, 'turn')
   assert.equal(motionFormOf(jointOf(a, 'b')).kind, 'turn')
   assert.equal(motionOf(a, 'a')?.kind, 'turn')
-  const free = set(a, { id: 'a', type: 'revolute', body0: { plane: 'mounting-plane' }, body1: { part: 'a', face: 'bottom' }, axis: 'Y' })
+  const free = set(a, { id: 'a', type: 'revolute', body0: { plane: 'mounting-plane' }, body1: { part: 'a' }, axis: 'Y' })
   assert.equal(motionOf(free, 'a')?.kind, 'continuous', 'a joint of its own without limits still turns without end')
 })
 
+test('a new motion replaces the old one whole: made a follower, its own limits and control go; made still, its axis goes (ADR-0140 D6)', () => {
+  let a = box(createFigureAsset('Pair'), 'a', 100, 100, 100, 50)
+  a = box(a, 'b', 50, 50, 50, 125)
+  a = set(a, { id: 'a', type: 'revolute', body0: { plane: 'mounting-plane' }, body1: { part: 'a' }, axis: 'Y', lowerLimit: -90, upperLimit: 90 })
+  a = set(a, { id: 'b', type: 'revolute', body0: { part: 'a', face: 'top' }, body1: { part: 'b' }, origin: { gap: 5 }, axis: 'Y', lowerLimit: -30, upperLimit: 30, state: { id: 'b-turn' } })
+  const follower = motionJoint(jointOf(a, 'b'), { ...motionFormOf(jointOf(a, 'b')), follow: 'a', multiplier: -1 } as Dynamic, 'b') as Dynamic
+  assert.deepEqual(Object.keys(follower), ['id', 'body0', 'body1', 'origin', 'type', 'axis', 'mimic'])
+  assert.doesNotThrow(() => set(a, follower))
+  assert.deepEqual(Object.keys(fixedJointOf(jointOf(a, 'b'))), ['id', 'type', 'body0', 'body1', 'origin'])
+})
+
 test('a range need not hold 0; it needs its most above its least', () => {
   const form = motionFormOf(jointOf(plain(), 'link'))
   assert.equal(motionFormRefusalOf({ ...form, min: 10, max: 90 }, ''), undefined)
@@ -191,7 +200,6 @@ test('placed by an origin: said as the origin, no row offered, and the fastening
   assert.equal(endPlaceKeyOf(jointOf(asset, 'link').body0), 'figure.label.face-top')
   assert.equal((fasteningOf(revisionOf(asset), 'tool') as Dynamic).atOrigin, true)
   assert.equal((fasteningOf(revisionOf(asset), 'cap') as Dynamic).atOrigin, true)
-  assert.equal((fasteningOf(revisionOf(asset), 'cap') as Dynamic).face, 'centre')
   assert.equal((fasteningOf(revisionOf(asset), 'link') as Dynamic).atOrigin, undefined)
   assert.equal(fasteningSave(asset, 'tool'), null)
   assert.deepEqual(rowAxesOf(asset, 'cap'), [])
@@ -201,8 +209,8 @@ test('placed by an origin: said as the origin, no row offered, and the fastening
 test('a drag about a vector axis sets the value; off it, it is refused and the vector said', () => {
   let a = box(createFigureAsset('Tilt'), 'post', 100, 200, 100, 100)
   a = box(a, 'head', 60, 60, 60, 230)
-  a = set(a, { id: 'post', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'post', face: 'bottom' } })
-  a = set(a, { id: 'head', type: 'revolute', body0: { part: 'post', face: 'top' }, body1: { part: 'head', face: 'bottom' }, axis: { x: 0, y: 3, z: 4 }, lowerLimit: -90, upperLimit: 90 })
+  a = set(a, { id: 'post', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'post' } })
+  a = set(a, { id: 'head', type: 'revolute', body0: { part: 'post', face: 'top' }, body1: { part: 'head' }, axis: { x: 0, y: 3, z: 4 }, lowerLimit: -90, upperLimit: 90 })
   const at = drawn(a, 'head')
   /* 30° about (0, 0.6, 0.8), as XYZ degrees. */
   const q = [0, 0.6, 0.8].map(v => v * Math.sin(Math.PI / 12))
@@ -223,8 +231,8 @@ test('a drag about a vector axis sets the value; off it, it is refused and the v
 test('a rotated joint frame: a turn about its turned axis is its value, and a move is measured before the rotation', () => {
   let a = box(createFigureAsset('Rotated'), 'post', 100, 200, 100, 100)
   a = box(a, 'link', 60, 300, 60, 350)
-  a = set(a, { id: 'post', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'post', face: 'bottom' } })
-  a = set(a, { id: 'bend', type: 'revolute', body0: { part: 'post', face: 'top' }, body1: { part: 'link', face: 'bottom' }, origin: { parentRotate: { x: 90 } }, axis: 'Z', lowerLimit: -90, upperLimit: 90 })
+  a = set(a, { id: 'post', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'post' } })
+  a = set(a, { id: 'bend', type: 'revolute', body0: { part: 'post', face: 'top' }, body1: { part: 'link' }, origin: { parentRotate: { x: 90 } }, axis: 'Z', lowerLimit: -90, upperLimit: 90 })
   /* Turned 90° about X, the frame's Z is the figure's -Y: 20° about -Y is 20 on the joint. */
   const at = drawn(a, 'link', { bend: 10 })
   const before = at.pose.r
@@ -252,8 +260,8 @@ test('a rotated joint frame: a turn about its turned axis is its value, and a mo
 test('a fan stands about a vector axis, as it does about the same token', () => {
   let a = box(createFigureAsset('Fan'), 'base', 200, 100, 200, 50)
   a = box(a, 'arm', 400, 50, 50, 125)
-  a = set(a, { id: 'base', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'base', face: 'bottom' } })
-  const arm = (axis: unknown) => set(a, { id: 'arm', type: 'revolute', body0: { part: 'base', face: 'top' }, body1: { part: 'arm', face: 'bottom' }, axis, lowerLimit: -45, upperLimit: 90 })
+  a = set(a, { id: 'base', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'base' } })
+  const arm = (axis: unknown) => set(a, { id: 'arm', type: 'revolute', body0: { part: 'base', face: 'top' }, body1: { part: 'arm' }, axis, lowerLimit: -45, upperLimit: 90 })
   const token = jointFanOf(revisionOf(arm('Y')), 'arm') as never as { pose: { t: number[]; r: number[][] } }
   const vector = jointFanOf(revisionOf(arm({ x: 0, y: 2, z: 0 })), 'arm') as never as { pose: { t: number[]; r: number[][] } }
   assert.ok(token && vector, 'a fan for both')
@@ -272,8 +280,8 @@ test('editing a motion keeps the control named after the joint when it has no st
   let a = createFigureAsset('Hinge')
   a = addFigureBox(a, { id: 'base', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 0, z: 0 } })
   a = addFigureBox(a, { id: 'lid', size: { x: 200, y: 20, z: 200 }, position: { x: 0, y: 0, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'base', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'base', face: 'bottom' } } })
-  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'lid', type: 'revolute', body0: { part: 'base', face: 'top' }, body1: { part: 'lid', face: 'bottom' }, axis: 'X', lowerLimit: -90, upperLimit: 90 } })
+  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'base', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'base' } } })
+  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'lid', type: 'revolute', body0: { part: 'base', face: 'top' }, body1: { part: 'lid' }, axis: 'X', lowerLimit: -90, upperLimit: 90 } })
   const lid = a.joints!.find(j => j.id === 'lid')!
   const form = motionFormOf(lid)
   assert.equal(form.id, 'lid', 'the form starts from the input the joint is driven by')
@@ -281,12 +289,26 @@ test('editing a motion keeps the control named after the joint when it has no st
   assert.deepEqual(edited.document.model.inputs.filter(i => i.role === 'state').map(i => i.id), ['lid'], 'the control keeps its name after the edit')
 })
 
+test("a child posed on two axes (childRotate, Rz·Ry·Rx): a turn about the joint's axis is its value, whatever its pose", () => {
+  let a = box(createFigureAsset('Leaning'), 'post', 100, 200, 100, 100)
+  a = box(a, 'link', 60, 300, 60, 350)
+  a = set(a, { id: 'post', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'post' } })
+  a = set(a, { id: 'bend', type: 'revolute', body0: { part: 'post', face: 'top' }, body1: { part: 'link' }, origin: { childRotate: { x: 30, z: 40 } }, axis: 'Y', lowerLimit: -90, upperLimit: 90 })
+  const at = drawn(a, 'link', { bend: 10 })
+  const after = drawn(a, 'link', { bend: 35 }).pose.r
+  const ry = Math.asin(Math.max(-1, Math.min(1, after[0]![2]!)))
+  const rx = Math.atan2(-after[1]![2]!, after[2]![2]!)
+  const rz = Math.atan2(-after[0]![1]!, after[0]![0]!)
+  const drag = jointDragOf(a, 'link', at as never, { rotation: [rx, ry, rz].map(v => (v * 180) / Math.PI) as [number, number, number] }, { bend: 10 })
+  assert.deepEqual(drag, { kind: 'value', input: 'bend', unit: 'deg', value: 35 })
+})
+
 test("a child turned on its own end (childRotate): a turn about the joint's axis is its value -- the child's own turn is not the joint's", () => {
   let a = box(createFigureAsset('Laid'), 'post', 100, 200, 100, 100)
   a = box(a, 'link', 60, 300, 60, 350)
-  a = set(a, { id: 'post', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'post', face: 'bottom' } })
+  a = set(a, { id: 'post', type: 'fixed', body0: { plane: 'mounting-plane' }, body1: { part: 'post' } })
   /* The link laid on its side on the post's top (a quarter turn about X), turning about the figure's Y. */
-  a = set(a, { id: 'bend', type: 'revolute', body0: { part: 'post', face: 'top' }, body1: { part: 'link', face: 'bottom' }, origin: { childRotate: { x: 90 } }, axis: 'Y', lowerLimit: -90, upperLimit: 90 })
+  a = set(a, { id: 'bend', type: 'revolute', body0: { part: 'post', face: 'top' }, body1: { part: 'link' }, origin: { childRotate: { x: 90 } }, axis: 'Y', lowerLimit: -90, upperLimit: 90 })
   const at = drawn(a, 'link', { bend: 10 })
   const before = at.pose.r
   const c = Math.cos((20 * Math.PI) / 180),

package/test/joints.ts

@@ -16,7 +16,7 @@ export function moving(
     id: part,
     type: 'fixed',
     body0: { plane: 'mounting-plane' },
-    body1: { part, face: 'bottom' },
+    body1: { part },
     origin: { align: { x: at('x'), z: at('z') } }
   }
   return applyFigureAuthoring(asset, {