@things-factory/figure-ui 10.1.208 → 10.1.210

package/test/command-preview.test.ts

@@ -161,8 +161,8 @@ test('a motion is named by its parts, and drawn at both ends of its range -- onl
   a = applyFigureAuthoring(a, { kind: 'attach', part: 'gate', to: { part: 'frame', face: 'top' } })
   const j = (part: string) => a.joints!.find(k => k.body1.part === part)!
   assert.equal(motionEndsOf(revisionOf(a), 'leaf'), null, 'not moving: nothing drawn')
-  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j('leaf'), type: 'revolute', axis: 'Y', lowerLimit: 0, upperLimit: 90, state: { id: 'open' } } })
-  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j('gate'), type: 'prismatic', axis: 'X', lowerLimit: 0, upperLimit: 300, state: { id: 'slide' } } })
+  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j('leaf'), motion: [{ type: 'revolute', axis: 'Y', lowerLimit: 0, upperLimit: 90, state: { id: 'open' } }] } })
+  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j('gate'), motion: [{ type: 'prismatic', axis: 'X', lowerLimit: 0, upperLimit: 300, state: { id: 'slide' } }] } })
   /* At the version the screen holds, a design value typed since it was opened. */
   const held = revisionOf(a, { 'frame.size.x': 2400 })
   const turn = motionEndsOf(held, 'leaf')!
@@ -204,19 +204,19 @@ test('a moving part is made into a row, and a row given or relieved of a motion
   assert.deepEqual(rowAxesOf(now(), 'roller'), ['x', 'z'])
   s.command({ kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 })
   assert.equal(rollers(), 10)
-  assert.equal(jointOf().type, 'revolute')
+  assert.equal((jointOf().motion?.[0]?.type ?? 'fixed'), 'revolute')
   /* The motion changed by the form: the row stays. */
   s.command({ kind: 'set-joint', joint: motionJoint(jointOf(), { ...(turn as object), kind: 'slide', axis: 'z', min: 0, max: 100 } as never, 'roller') })
-  assert.deepEqual([jointOf().type, rollers()], ['prismatic', 10])
+  assert.deepEqual([(jointOf().motion?.[0]?.type ?? 'fixed'), rollers()], ['prismatic', 10])
   /* The motion taken away by its button: still a row. */
   s.command({ kind: 'set-joint', joint: fixedJointOf(jointOf()) })
-  assert.deepEqual([jointOf().type, rollers()], ['fixed', 10])
+  assert.deepEqual([(jointOf().motion?.[0]?.type ?? 'fixed'), rollers()], ['fixed', 10])
   /* Each undone once. */
   s.undo()
-  assert.deepEqual([jointOf().type, rollers()], ['prismatic', 10])
+  assert.deepEqual([(jointOf().motion?.[0]?.type ?? 'fixed'), rollers()], ['prismatic', 10])
   s.undo()
   s.undo()
-  assert.deepEqual([jointOf().type, rollers()], ['revolute', 1])
+  assert.deepEqual([(jointOf().motion?.[0]?.type ?? 'fixed'), rollers()], ['revolute', 1])
 })
 
 /* Designer 2026-09-27: wider than its face is not hidden -- a fact in the relation's details, off to one side said. */

package/test/joint-drag.test.ts

@@ -17,7 +17,7 @@ function column(joint: Partial<FigureJoint>): FigureAsset {
   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' }, ...joint } as FigureJoint
+    joint: { id: 'bend', motion: undefined, body0: { part: 'post', face: 'top' }, body1: { part: 'link' }, ...joint } as FigureJoint
   })
 }
 
@@ -28,7 +28,7 @@ const drawn = (asset: FigureAsset, id: string, state: Record<string, number> = {
 const turnedZ = (deg: number) => [0, 0, deg] as [number, number, number]
 
 test('돌리면 관절값 — 관절 축 둘레로 돈 만큼, 범위 안으로', () => {
-  const asset = column({ type: 'revolute', axis: 'Z', lowerLimit: -90, upperLimit: 90 })
+  const asset = column({ motion: [{ type: 'revolute', axis: 'Z', lowerLimit: -90, upperLimit: 90 }] })
   const part = drawn(asset, 'link')
   assert.deepEqual(jointDragOf(asset, 'link', part as never, { rotation: turnedZ(30) }, {}), { kind: 'value', input: 'bend', unit: 'deg', value: 30 })
   assert.deepEqual(jointDragOf(asset, 'link', part as never, { rotation: turnedZ(120) }, {}), { kind: 'value', input: 'bend', unit: 'deg', value: 90 }, '범위 끝에서 멈춘다')
@@ -38,7 +38,7 @@ test('돌리면 관절값 — 관절 축 둘레로 돈 만큼, 범위 안으로'
 })
 
 test('끝없이 도는 관절은 −180..180 으로 감는다', () => {
-  const asset = column({ type: 'revolute', axis: 'Y' })
+  const asset = column({ motion: [{ type: 'revolute', axis: 'Y' }] })
   const at170 = drawn(asset, 'link', { bend: 170 })
   const drag = jointDragOf(asset, 'link', at170 as never, { rotation: [0, 190, 0] }, { bend: 170 })
   assert.equal(drag?.kind, 'value')
@@ -46,7 +46,7 @@ test('끝없이 도는 관절은 −180..180 으로 감는다', () => {
 })
 
 test('미끄러지는 관절은 축을 따라 옮긴 거리가 값', () => {
-  const asset = column({ type: 'prismatic', axis: 'X', lowerLimit: -100, upperLimit: 100 })
+  const asset = column({ motion: [{ type: 'prismatic', axis: 'X', lowerLimit: -100, upperLimit: 100 }] })
   const part = drawn(asset, 'link')
   const to = [part.pose.t[0]! + 40, part.pose.t[1]!, part.pose.t[2]!] as [number, number, number]
   assert.deepEqual(jointDragOf(asset, 'link', part as never, { position: to }, {}), { kind: 'value', input: 'bend', unit: 'mm', value: 40 })
@@ -76,7 +76,7 @@ test('관계를 끊는 끌기는 거절하고 까닭을 댄다', () => {
   const edge = column({ origin: { align: { x: 'min' } } })
   const part = drawn(edge, 'link')
   assert.deepEqual(jointDragOf(edge, 'link', part as never, { position: [part.pose.t[0]! + 30, part.pose.t[1]!, part.pose.t[2]!] }, {}), { kind: 'refused', reason: 'origin-follows', joint: 'bend' }, '모서리에 맞춘 자리는 그 모서리를 따른다')
-  const bend = column({ type: 'revolute', axis: 'Z', lowerLimit: -90, upperLimit: 90 })
+  const bend = column({ motion: [{ type: 'revolute', axis: 'Z', lowerLimit: -90, upperLimit: 90 }] })
   assert.deepEqual(jointDragOf(bend, 'link', drawn(bend, 'link') as never, { rotation: [25, 0, 0] }, {}), { kind: 'refused', reason: 'off-axis', joint: 'bend', axis: 'Z' }, '다른 축으로 돌린 것은 적지 않는다')
   const still = column({})
   assert.deepEqual(jointDragOf(still, 'link', drawn(still, 'link') as never, { rotation: turnedZ(20) }, {}), { kind: 'refused', reason: 'fixed-turn', joint: 'bend' })
@@ -90,7 +90,7 @@ test('관절이 없는 부품은 이 길로 오지 않는다 — 제 숫자를
 
 test('크기 끌기는 관절이 아니라 부품의 치수 — 따라가는 치수는 두고 제 치수만 쓴다 (사용자 09-25: 「R 모드에서 크기가 변하지 않는다」)', async () => {
   const { gizmoChanges, gizmoReachOf } = await import('../client/modeller/gizmo.ts')
-  let asset = column({ type: 'revolute', axis: 'Z', lowerLimit: -90, upperLimit: 90 })
+  let asset = column({ motion: [{ type: 'revolute', axis: 'Z', lowerLimit: -90, upperLimit: 90 }] })
   /* A square section: the link's depth follows its width. */
   asset = applyFigureAuthoring(asset, { kind: 'link-dimension', part: 'link', axis: 'z', source: { of: 'part', part: 'link', axis: 'x' } })
   const part = drawn(asset, 'link')

package/test/joint-frames.test.ts

@@ -32,25 +32,25 @@ 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' } })
-  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' }, origin: { offset: { y: 40 } } })
+  a = set(a, { id: 'base', body0: { plane: 'mounting-plane' }, body1: { part: 'base' } })
+  a = set(a, { id: 'link', body0: { part: 'base', face: 'top' }, body1: { part: 'link' }, origin: { pivot: 'child-face', offset: { x: 20 }, parentRotate: { x: 10 } }, motion: [{ type: 'revolute', axis: { x: 1, y: 1, z: 0 }, lowerLimit: -90, upperLimit: 90 }] })
+  a = set(a, { id: 'tool', 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 } }, motion: [{ type: 'revolute', axis: 'Z', lowerLimit: -45, upperLimit: 45 }] })
+  return set(a, { id: 'cap', 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' } })
-  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 })
+  a = set(a, { id: 'base', body0: { plane: 'mounting-plane' }, body1: { part: 'base' } })
+  return set(a, { id: 'link', body0: { part: 'base', face: 'top' }, body1: { part: 'link' }, origin: { gap: 5, align: { x: 'min' } }, motion: [{ type: 'revolute', axis: 'Y', lowerLimit: -90, upperLimit: 90 }] })
 }
 
 const reopen = (asset: FigureAsset) => parseFigureAsset(serializeFigureAsset(asset) as unknown as string)
 const jointOf = (asset: FigureAsset, id: string) => asset.joints!.find(j => j.id === id)! as Dynamic
 /** What the frames say of a joint: what no form path may change. */
 const frameOf = (j: Dynamic, keepType = true) => ({
-  ...(keepType ? { type: j.type, axis: j.axis } : {}),
+  ...(keepType ? { type: j.motion?.[0]?.type ?? 'fixed', axis: j.motion?.[0]?.axis } : {}),
   body0: j.body0,
   body1: j.body1,
   pivot: j.origin?.pivot,
@@ -80,7 +80,7 @@ function roundTrips(asset: FigureAsset, id: string) {
   const j = jointOf(asset, id)
   const part = j.body1.part
   const out: Record<string, FigureJoint> = {}
-  if (j.type !== 'fixed') out.motion = jointOf(reopen(set(asset, motionJoint(j, motionFormOf(j), part))), id)
+  if (j.motion?.length) out.motion = jointOf(reopen(set(asset, motionJoint(j, motionFormOf(j), part))), id)
   const fasten = fasteningSave(asset, part)
   if (fasten) out.fastening = jointOf(reopen(applyFigureAuthoring(asset, fasten)), id)
   out.fixed = jointOf(reopen(set(asset, fixedJointOf(j))), id)
@@ -113,24 +113,25 @@ 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' }, 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 } })
+  a = set(a, { id: 'a', body0: { plane: 'mounting-plane' }, body1: { part: 'a' }, motion: [{ type: 'revolute', axis: 'Y', lowerLimit: -90, upperLimit: 90 }] })
+  a = set(a, { id: 'b', body0: { part: 'a', face: 'top' }, body1: { part: 'b' }, motion: [{ type: 'revolute', axis: 'Y', mimic: { motion: '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' }, axis: 'Y' })
+  const free = set(a, { id: 'a', body0: { plane: 'mounting-plane' }, body1: { part: 'a' }, motion: [{ type: 'revolute', 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' } })
+  a = set(a, { id: 'a', body0: { plane: 'mounting-plane' }, body1: { part: 'a' }, motion: [{ type: 'revolute', axis: 'Y', lowerLimit: -90, upperLimit: 90 }] })
+  a = set(a, { id: 'b', body0: { part: 'a', face: 'top' }, body1: { part: 'b' }, origin: { gap: 5 }, motion: [{ type: 'revolute', 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.deepEqual(Object.keys(follower), ['id', 'body0', 'body1', 'origin', 'motion'])
+  assert.deepEqual(Object.keys(follower.motion[0]), ['type', 'axis', 'mimic'], 'its own limits and control gone')
   assert.doesNotThrow(() => set(a, follower))
-  assert.deepEqual(Object.keys(fixedJointOf(jointOf(a, 'b'))), ['id', 'type', 'body0', 'body1', 'origin'])
+  assert.deepEqual(Object.keys(fixedJointOf(jointOf(a, 'b'))), ['id', 'body0', 'body1', 'origin'])
 })
 
 test('a range need not hold 0; it needs its most above its least', () => {
@@ -145,7 +146,7 @@ test('a range need not hold 0; it needs its most above its least', () => {
   const still = set(plain(), fixedJointOf(jointOf(plain(), 'link')))
   const fixed = jointOf(still, 'link')
   const lifted = set(still, motionJoint(fixed, { ...motionFormOf(fixed), kind: 'turn', min: 10, max: 90 }, 'link'))
-  assert.equal(lifted.stateDefaults[jointOf(lifted, 'link').state.id], 10)
+  assert.equal(lifted.stateDefaults[jointOf(lifted, 'link').motion[0].state.id], 10)
   /* An existing control keeps its name and its stored value: a range that leaves that value out is the kernel's refusal (R1). */
   const j = jointOf(plain(), 'link')
   assert.throws(() => set(plain(), motionJoint(j, { ...motionFormOf(j), min: 10, max: 90 }, 'link')), /INPUT_RANGE/)
@@ -170,8 +171,8 @@ test('a vector axis: the form keeps it, the summary says it, saved and reopened
   assert.deepEqual(motionOf(asset, 'link')?.vector, { x: 1, y: 1, z: 0 })
   /* Changing the range leaves the axis alone. */
   const saved = reopen(set(asset, motionJoint(jointOf(asset, 'link'), { ...form, min: -30, max: 60 }, 'link')))
-  assert.deepEqual(jointOf(saved, 'link').axis, { x: 1, y: 1, z: 0 })
-  assert.equal(jointOf(saved, 'link').upperLimit, 60)
+  assert.deepEqual(jointOf(saved, 'link').motion[0].axis, { x: 1, y: 1, z: 0 })
+  assert.equal(jointOf(saved, 'link').motion[0].upperLimit, 60)
 })
 
 test('frames: every form path keeps the vector axis, pivot, offset (summed too), parentRotate and origin ends, saved and reopened', () => {
@@ -209,8 +210,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' } })
-  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 })
+  a = set(a, { id: 'post', body0: { plane: 'mounting-plane' }, body1: { part: 'post' } })
+  a = set(a, { id: 'head', body0: { part: 'post', face: 'top' }, body1: { part: 'head' }, motion: [{ type: 'revolute', 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,7 +224,7 @@ test('a drag about a vector axis sets the value; off it, it is refused and the v
   assert.deepEqual(jointDragOf(a, 'head', at as never, { rotation: deg }, {}), { kind: 'value', input: 'head', unit: 'deg', value: 30 })
   assert.deepEqual(jointDragOf(a, 'head', at as never, { rotation: [40, 0, 0] }, {}), { kind: 'refused', reason: 'off-axis', joint: 'head', axis: '(0, 3, 4)' })
   /* A slide along it: the distance along the vector. */
-  const slide = set(a, { ...jointOf(a, 'head'), type: 'prismatic', lowerLimit: -100, upperLimit: 100 })
+  const slide = set(a, { ...jointOf(a, 'head'), motion: [{ ...jointOf(a, 'head').motion[0], type: 'prismatic', lowerLimit: -100, upperLimit: 100 }] })
   const s = drawn(slide, 'head')
   assert.deepEqual(jointDragOf(slide, 'head', s as never, { position: [s.pose.t[0]!, s.pose.t[1]! + 30, s.pose.t[2]! + 40] }, {}), { kind: 'value', input: 'head', unit: 'mm', value: 50 })
 })
@@ -231,8 +232,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' } })
-  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 })
+  a = set(a, { id: 'post', body0: { plane: 'mounting-plane' }, body1: { part: 'post' } })
+  a = set(a, { id: 'bend', body0: { part: 'post', face: 'top' }, body1: { part: 'link' }, origin: { parentRotate: { x: 90 } }, motion: [{ type: 'revolute', 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
@@ -249,7 +250,7 @@ test('a rotated joint frame: a turn about its turned axis is its value, and a mo
   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: 30 })
   /* Held still, moved 30 along X: an offset across the post's top on X, not along the turned frame. */
-  const still = set(a, { ...jointOf(a, 'bend'), type: 'fixed', axis: undefined, lowerLimit: undefined, upperLimit: undefined })
+  const still = set(a, { ...jointOf(a, 'bend'), motion: undefined })
   const s = drawn(still, 'link')
   const moved = jointDragOf(still, 'link', s as never, { position: [s.pose.t[0]!, s.pose.t[1]!, s.pose.t[2]! + 30] }, {}) as { joint: Dynamic }
   assert.deepEqual(moved.joint.origin, { parentRotate: { x: 90 }, align: { z: { mm: 30 } } })
@@ -260,8 +261,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' } })
-  const arm = (axis: unknown) => set(a, { id: 'arm', type: 'revolute', body0: { part: 'base', face: 'top' }, body1: { part: 'arm' }, axis, lowerLimit: -45, upperLimit: 90 })
+  a = set(a, { id: 'base', body0: { plane: 'mounting-plane' }, body1: { part: 'base' } })
+  const arm = (axis: unknown) => set(a, { id: 'arm', body0: { part: 'base', face: 'top' }, body1: { part: 'arm' }, motion: [{ type: 'revolute', 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')
@@ -280,8 +281,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' } } })
-  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 } })
+  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'base', body0: { plane: 'mounting-plane' }, body1: { part: 'base' } } })
+  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'lid', body0: { part: 'base', face: 'top' }, body1: { part: 'lid' }, motion: [{ type: 'revolute', 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')
@@ -292,8 +293,8 @@ test('editing a motion keeps the control named after the joint when it has no st
 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 })
+  a = set(a, { id: 'post', body0: { plane: 'mounting-plane' }, body1: { part: 'post' } })
+  a = set(a, { id: 'bend', body0: { part: 'post', face: 'top' }, body1: { part: 'link' }, origin: { childRotate: { x: 30, z: 40 } }, motion: [{ type: 'revolute', 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]!)))
@@ -306,9 +307,9 @@ test("a child posed on two axes (childRotate, Rz·Ry·Rx): a turn about the join
 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' } })
+  a = set(a, { id: 'post', 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' }, origin: { childRotate: { x: 90 } }, axis: 'Y', lowerLimit: -90, upperLimit: 90 })
+  a = set(a, { id: 'bend', body0: { part: 'post', face: 'top' }, body1: { part: 'link' }, origin: { childRotate: { x: 90 } }, motion: [{ type: 'revolute', 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

@@ -14,7 +14,6 @@ export function moving(
   const at = (axis: 'x' | 'z') => ({ mm: asset.designInputs[`${part}.position.${axis}`] ?? 0 })
   const above: FigureJoint = asset.joints?.find(j => j.body1.part === part) ?? {
     id: part,
-    type: 'fixed',
     body0: { plane: 'mounting-plane' },
     body1: { part },
     origin: { align: { x: at('x'), z: at('z') } }
@@ -23,11 +22,7 @@ export function moving(
     kind: 'set-joint',
     joint: {
       ...above,
-      type: spec.kind === 'slide' ? 'prismatic' : 'revolute',
-      axis: spec.axis.toUpperCase() as 'X' | 'Y' | 'Z',
-      lowerLimit: spec.min,
-      upperLimit: spec.max,
-      state: { id: spec.id, ...(spec.start !== undefined ? { start: spec.start } : {}) }
+      motion: [{ type: spec.kind === 'slide' ? 'prismatic' : 'revolute', axis: spec.axis.toUpperCase() as 'X' | 'Y' | 'Z', lowerLimit: spec.min, upperLimit: spec.max, state: { id: spec.id, ...(spec.start !== undefined ? { start: spec.start } : {}) } }]
     }
   })
 }

package/test/links.test.ts

@@ -67,7 +67,7 @@ test('움직임 — 미끄러짐 · 돌기, 축, 무엇이 모느냐를 읽는
   const turning = moving(asset, 'block', { kind: 'turn', axis: 'y', id: 'swing', min: -90, max: 90, start: 0 })
   assert.deepEqual([motionOf(turning, 'block')!.kind, motionOf(turning, 'block')!.axis], ['turn', 'y'])
   const joint = sliding.joints!.find(j => j.body1.part === 'block')!
-  const still = applyFigureAuthoring(sliding, { kind: 'set-joint', joint: { id: joint.id, type: 'fixed', body0: joint.body0, body1: joint.body1 } })
+  const still = applyFigureAuthoring(sliding, { kind: 'set-joint', joint: { id: joint.id, body0: joint.body0, body1: joint.body1 } })
   assert.equal(motionOf(still, 'block'), undefined, 'a fixed joint does not move')
 })
 
@@ -256,7 +256,7 @@ test('한 비율로 커지는 도형 — 자기 숫자인 길이를 세고, 한
   asset = applyFigureAuthoring(asset, { kind: 'scale-uniformly' })
   assert.deepEqual(proportionToFollow(asset), { count: 3 + 3 + 1, kept: [] }, '치수 여섯과 자리 하나')
   const lamp = asset.joints!.find(j => j.id === 'lamp')!
-  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...lamp, type: 'prismatic', axis: 'Y', lowerLimit: 0, upperLimit: 50, state: { id: 'rise' } } })
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...lamp, motion: [{ type: 'prismatic', axis: 'Y', lowerLimit: 0, upperLimit: 50, state: { id: 'rise' } }] } })
   asset = applyFigureAuthoring(asset, { kind: 'follow-size-in-proportion' })
   assert.deepEqual(proportionToFollow(asset), { count: 0, kept: ['lamp.motion'] }, '다 따르고, mm 로 움직이는 것만 남는다')
   assert.equal(Math.round(valueNow(revisionOf(asset), 'lamp.dimension.x.value')! * 1e6) / 1e6, 60, '따르게 해도 지금 크기는 그대로')
@@ -359,9 +359,9 @@ test('따라 움직이는 관절 — 같은 방식으로 움직이고 제 조작
   assert.deepEqual(leadersFor(asset, 'left', 'slide'), [], '제 관절은 고르지 않는다')
 
   const follower = motionJoint(jointOf('right'), { ...form, id: 'ignored', follow: 'left', multiplier: -1 }, 'right')
-  assert.deepEqual(follower.mimic, { joint: 'left', multiplier: -1 })
-  assert.equal(follower.state, undefined, '따라가는 관절은 제 조작값이 없다')
-  assert.equal(follower.lowerLimit, undefined)
+  assert.deepEqual(follower.motion![0]!.mimic, { motion: 'left', multiplier: -1 })
+  assert.equal(follower.motion![0]!.state, undefined, '따라가는 관절은 제 조작값이 없다')
+  assert.equal(follower.motion![0]!.lowerLimit, undefined)
   asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: follower })
   assert.deepEqual(leadersFor(asset, 'wrist', 'slide').map(j => j.id), ['left'], '따라가는 관절은 앞장서지 않는다')
 
@@ -477,8 +477,8 @@ test('미끄러짐의 이동 거리가 부품 길이를 따른다 — 레일이
   const joint = asset.joints!.find(j => j.body1.part === 'bridge')!
   const form = { kind: 'slide' as const, axis: 'x' as const, id: 'x', min: 0, max: 500, follow: '', multiplier: 1, offset: 0, travel: 'rail:x', travelPlus: -160 }
   const record = motionJoint(joint, form, 'bridge')
-  assert.deepEqual(record.travel, { source: { of: 'part', part: 'rail', axis: 'x' }, plus: -160 })
-  assert.equal(record.lowerLimit, undefined, '거리는 레일이 정한다 — mm 범위는 없다')
+  assert.deepEqual(record.motion![0]!.travel, { source: { of: 'part', part: 'rail', axis: 'x' }, plus: -160 })
+  assert.equal(record.motion![0]!.lowerLimit, undefined, '거리는 레일이 정한다 — mm 범위는 없다')
   asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: record })
   assert.deepEqual(motionOf(asset, 'bridge')?.travel, { part: 'rail', axis: 'x', plus: -160 }, '화면은 무엇을 따르는지 읽는다')
   const end = (railLength: number) => {
@@ -517,7 +517,7 @@ test('선언할 크기는 부품이 쉬고 있을 때의 크기 — 문짝이
   asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', to: { plane: 'mounting-plane' } })
   asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'leaf', to: { part: 'jamb', face: 'right' }, align: { y: 'min', z: 'max' }, gap: 5 })
   const j = asset.joints!.find(o => o.id === 'leaf')!
-  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', lowerLimit: -90, upperLimit: 0, state: { id: 'open' } } })
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...j, motion: [{ type: 'revolute', axis: 'Y', lowerLimit: -90, upperLimit: 0, state: { id: 'open' } }] } })
   assert.deepEqual(instanceSizeToDeclare(asset)!.at, { x: 995, y: 2100, z: 150 })
 })
 
@@ -534,20 +534,21 @@ test('움직임은 그 자리에서 고친다 — 폼에 지금 관절을 채우
   const { motionFormOf, motionJoint } = await import('../client/modeller/links.ts')
   const base = { id: 'j', body0: { part: 'a', face: 'top' as const }, body1: { part: 'b' } }
   const joints = [
-    { ...base, type: 'prismatic' as const, axis: 'Z' as const, lowerLimit: 0, upperLimit: 2500, state: { id: 'extend' } },
-    { ...base, type: 'revolute' as const, axis: 'Y' as const, lowerLimit: -90, upperLimit: 0, state: { id: 'open' } },
-    { ...base, type: 'revolute' as const, axis: 'Y' as const, state: { id: 'spin' } },
-    { ...base, type: 'prismatic' as const, axis: 'X' as const, mimic: { joint: 'k', multiplier: -1 } },
-    { ...base, type: 'prismatic' as const, axis: 'X' as const, travel: { source: { of: 'part' as const, part: 'rail', axis: 'x' as const }, plus: -160 }, state: { id: 'x' } }
+    { ...base, motion: [{ type: 'prismatic' as const, axis: 'Z' as const, lowerLimit: 0, upperLimit: 2500, state: { id: 'extend' } }] },
+    { ...base, motion: [{ type: 'revolute' as const, axis: 'Y' as const, lowerLimit: -90, upperLimit: 0, state: { id: 'open' } }] },
+    { ...base, motion: [{ type: 'revolute' as const, axis: 'Y' as const, state: { id: 'spin' } }] },
+    { ...base, motion: [{ type: 'prismatic' as const, axis: 'X' as const, mimic: { motion: 'k', multiplier: -1 } }] },
+    { ...base, motion: [{ type: 'prismatic' as const, axis: 'X' as const, travel: { source: { of: 'part' as const, part: 'rail', axis: 'x' as const }, plus: -160 }, state: { id: 'x' } }] }
   ]
   for (const joint of joints) {
     const form = motionFormOf(joint)
-    assert.deepEqual(motionJoint(joint, form, 'b'), joint, `${joint.type} ${JSON.stringify(joint.mimic ?? joint.travel ?? joint.lowerLimit ?? 'endless')}`)
+    const a = joint.motion[0]!
+    assert.deepEqual(motionJoint(joint, form, 'b'), joint, `${a.type} ${JSON.stringify(a.mimic ?? a.travel ?? a.lowerLimit ?? 'endless')}`)
   }
   /* A leader's stroke made to follow the base's length, where it is. */
   const changed = motionJoint(joints[0]!, { ...motionFormOf(joints[0]!), travel: 'base:z', travelPlus: -400 }, 'b')
-  assert.deepEqual(changed.travel, { source: { of: 'part', part: 'base', axis: 'z' }, plus: -400 })
-  assert.equal(changed.state?.id, 'extend', '같은 조작값 이름')
+  assert.deepEqual(changed.motion![0]!.travel, { source: { of: 'part', part: 'base', axis: 'z' }, plus: -400 })
+  assert.equal(changed.motion![0]!.state?.id, 'extend', '같은 조작값 이름')
 })
 
 test('바닥에 선 부품도 무엇에 붙어 있는지 읽는다 — 그래야 옮겨 붙일 수 있다 (문설주, 2026-09-25)', async () => {
@@ -693,12 +694,12 @@ test('a follower of several leaders and a stroke that is a sum of lengths are wr
   assert.equal(form.follow, '', 'no single leader to pick')
   assert.deepEqual(form.followSum, [{ joint: 'j2', multiplier: -1 }, { joint: 'j3', multiplier: -1 }])
   const saved = motionJoint(wrist, { ...form, axis: form.axis }, 'wrist')
-  assert.deepEqual(saved.mimic, { sum: [{ joint: 'j2', multiplier: -1 }, { joint: 'j3', multiplier: -1 }] }, 'saving the form keeps the follower a follower')
-  assert.equal(saved.state, undefined, 'and gives it no control of its own')
+  assert.deepEqual(saved.motion![0]!.mimic, { sum: [{ motion: 'j2', multiplier: -1 }, { motion: 'j3', multiplier: -1 }] }, 'saving the form keeps the follower a follower')
+  assert.equal(saved.motion![0]!.state, undefined, 'and gives it no control of its own')
   assert.deepEqual(motionOf(asset, 'wrist')?.follows, { sum: [{ joint: 'j2', multiplier: -1 }, { joint: 'j3', multiplier: -1 }], offset: 0 })
 
-  const reach = { ...wrist, id: 'reach', type: 'prismatic' as const, mimic: undefined, axis: 'X' as const, travel: { sum: [{ from: { of: 'part' as const, part: 'base', axis: 'x' as const } }, { from: { of: 'part' as const, part: 'turret', axis: 'x' as const }, times: 0.5 }] } }
+  const reach = { ...wrist, id: 'reach', motion: [{ ...(wrist).motion![0]!, type: 'prismatic' as const, mimic: undefined, axis: 'X' as const, travel: { sum: [{ from: { of: 'part' as const, part: 'base', axis: 'x' as const } }, { from: { of: 'part' as const, part: 'turret', axis: 'x' as const }, times: 0.5 }] } }] }
   const slide = motionFormOf(reach)
   assert.equal(slide.travel, '')
-  assert.deepEqual(motionJoint(reach, slide, 'wrist').travel, reach.travel, 'saving keeps the summed stroke')
+  assert.deepEqual(motionJoint(reach, slide, 'wrist').motion![0]!.travel, reach.motion[0]!.travel, 'saving keeps the summed stroke')
 })

package/test/multipart-response-fixture.js

@@ -0,0 +1,17 @@
+import { addFigureBox, applyFigureAuthoring, createFigureAsset } from '@hatiolab/figure-model'
+
+// A relation audit fixture, not a replacement for testing the authoring workflow.
+export function multipartResponseFixture() {
+  let a = addFigureBox(createFigureAsset('부품 관계 점검'), {
+    id: 'tabletop', size: { x: 1500, y: 80, z: 600 }, position: { x: 0, y: 740, z: 0 }
+  })
+  a = applyFigureAuthoring(a, { kind: 'follow-size', part: 'tabletop', axes: ['x'] })
+  a = addFigureBox(a, { id: 'brace', size: { x: 1300, y: 60, z: 40 }, position: { x: 0, y: 0, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'link-dimension', part: 'brace', axis: 'x', source: { of: 'part', part: 'tabletop', axis: 'x' }, plus: -200 })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'brace', to: { part: 'tabletop', face: 'bottom' }, align: { z: 'min' } })
+  for (const [id, x] of [['legLeft', 'min'], ['legRight', 'max']]) {
+    a = addFigureBox(a, { id, size: { x: 80, y: 700, z: 80 }, position: { x: 0, y: 0, z: 0 } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: id, to: { part: 'tabletop', face: 'bottom' }, align: { x, z: 'max' } })
+  }
+  return a
+}

package/test/multipart-response.test.ts

@@ -0,0 +1,37 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { compileFigureAsset, applyFigureAuthoring, figureFollowOf } from '@hatiolab/figure-model'
+import { multipartResponseFixture } from './multipart-response-fixture.js'
+const part = (a: ReturnType<typeof multipartResponseFixture>, width: number, id: string) =>
+  compileFigureAsset({ ...a, designInputs: { ...a.designInputs, 'size.x': width } }).evaluate().geometry.find(g => g.id === id)!
+
+test('linked brace keeps a 200 mm difference while the tabletop responds to figure width', () => {
+  const a = multipartResponseFixture()
+  assert.deepEqual(figureFollowOf(a, 'brace', 'x'), { of: 'part', part: 'tabletop', axis: 'x', plus: -200 })
+  for (const width of [1500, 2000, 3000]) {
+    assert.equal(part(a, width, 'tabletop').shape.dimensions['size.x'], width)
+    assert.equal(part(a, width, 'brace').shape.dimensions['size.x'], width - 200)
+  }
+})
+
+test('fixed leg dimensions do not imply fixed position: attachment follows the tabletop edge', () => {
+  const a = multipartResponseFixture()
+  for (const id of ['legLeft', 'legRight']) {
+    for (const axis of ['x', 'y', 'z'] as const) assert.equal(figureFollowOf(a, id, axis).of, 'own')
+    assert.deepEqual(part(a, 1500, id).shape, part(a, 3000, id).shape)
+    const sign = id === 'legLeft' ? -1 : 1
+    assert.equal(part(a, 1500, id).pose.t[0], sign * 710)
+    assert.equal(part(a, 3000, id).pose.t[0], sign * 1460)
+    assert.equal(part(a, 3000, id).pose.t[1], 350)
+  }
+})
+
+test('a fixed difference and a proportional relation are not interchangeable', () => {
+  const a = multipartResponseFixture()
+  // Characterize the command currently invoked by the bulk button, not an endorsement of that UI.
+  const proportional = applyFigureAuthoring(a, { kind: 'follow-size', part: 'brace' })
+  assert.equal(figureFollowOf(proportional, 'brace', 'x').of, 'instance')
+  assert.equal(part(a, 3000, 'brace').shape.dimensions['size.x'], 2800)
+  assert.ok(Math.abs(part(proportional, 3000, 'brace').shape.dimensions['size.x']! - 2600) < 0.01)
+  assert.deepEqual(proportional.joints, a.joints, 'attachment remains while dimension reference is replaced')
+})

package/test/refusals.test.ts

@@ -99,9 +99,9 @@ test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그
   a = act(a, { kind: 'attach', part: 'top', to: { part: 'leg', face: 'top' } })
   a = act(a, { kind: 'attach', part: 'lamp', to: { part: 'top', face: 'top' }, align: { x: { mm: -300 } } })
   a = act(a, { kind: 'attach', part: 'shade', to: { part: 'top', face: 'top' }, align: { x: { mm: 300 } } })
-  const turn = (asset: typeof a, part: string, extra: object) => act(asset, { kind: 'set-joint', joint: { ...asset.joints!.find(j => j.body1.part === part)!, type: 'revolute', axis: 'Y', ...extra } })
+  const turn = (asset: typeof a, part: string, extra: object) => act(asset, { kind: 'set-joint', joint: { ...asset.joints!.find(j => j.body1.part === part)!, motion: [{ type: 'revolute', axis: 'Y', ...extra }] } })
   a = turn(a, 'lamp', { state: { id: 'lamp-turn' } })
-  a = turn(a, 'shade', { mimic: { joint: 'lamp', multiplier: 1 } })
+  a = turn(a, 'shade', { mimic: { motion: 'lamp', multiplier: 1 } })
 
   const top = fm.removePart(a, { kind: 'remove-part', target: 'top' })
   const told = removalNoticeOf(top.notice, keyed)!

package/test/resize-with-placement.test.ts

@@ -156,7 +156,7 @@ test('a part fastened at any angle is sized by the gizmo too: its fastening keep
   const { gizmoReachOf } = await import('../client/modeller/gizmo.js')
   let a = addFigureBox(createFigureAsset('UX'), { id: 'hub', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
   a = addFigureBox(a, { id: 'blade', size: { x: 300, y: 20, z: 60 }, position: { x: 0, y: 110, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'blade', type: 'fixed', body0: { part: 'hub', face: 'top' }, body1: { part: 'blade' }, origin: { childRotate: { z: 30 } } } })
+  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'blade', body0: { part: 'hub', face: 'top' }, body1: { part: 'blade' }, origin: { childRotate: { z: 30 } } } })
   assert.ok(gizmoReachOf(a, 'blade').scale, 'offered')
   const size = [{ kind: 'set-design', input: 'blade.size.x', unit: 'mm', value: 400 }] as never
   assert.deepEqual(figureSizeEditOf(a, 'blade', size, { keep: 'opposite', axis: 'x', side: 1 }), { changes: size, kept: 'relation' })
@@ -193,3 +193,25 @@ test('the fastening form keeps a place that follows a position field, and fasten
   assert.ok('box.position.x' in again.designInputs && 'box.position.z' in again.designInputs, 'the fields stay')
   assert.deepEqual(JSON.stringify(again.joints), JSON.stringify(kept.joints), 'the same fastening')
 })
+
+test('fresh frame: width follows without changing height, depth or pose; one undo restores the undeclared figure', async () => {
+  const initial = addFigureBox(createFigureAsset('Frame'), { id: 'frame', size: { x: 1500, y: 80, z: 600 }, position: { x: 0, y: 50, z: 0 } })
+  const source = serializeFigureAsset(initial)
+  const session = createFigureProductSession({ load: async () => ({ id: 'frame', source }), save: async q => ({ id: 'frame', source: q.source }) })
+  await session.open('frame')
+  const before = session.source()
+  session.command({ kind: 'follow-size', part: 'frame', axes: ['x'] })
+  const after = session.source()
+  const asset = parseFigureAsset(after)
+  assert.equal(figureFollowOf(asset, 'frame', 'x').of, 'instance')
+  for (const axis of ['y', 'z'] as const) assert.equal(figureFollowOf(asset, 'frame', axis).of, 'own')
+  const geometry = (a: typeof asset) => compileFigureAsset(a).evaluate().geometry.find(g => g.id === 'frame')!
+  assert.deepEqual(geometry(asset), geometry(initial), 'enabling response preserves the current geometry and pose')
+  const enlarged = geometry({ ...asset, designInputs: { ...asset.designInputs, 'size.x': asset.designInputs['size.x']! * 2, 'size.y': asset.designInputs['size.y']! * 2, 'size.z': asset.designInputs['size.z']! * 2 } })
+  const expected = geometry(addFigureBox(createFigureAsset('Frame'), { id: 'frame', size: { x: 3000, y: 80, z: 600 }, position: { x: 0, y: 50, z: 0 } }))
+  assert.deepEqual(enlarged, expected, 'only width doubles even when every figure dimension doubles')
+  session.undo()
+  assert.equal(session.source(), before, 'one undo also removes the automatically declared figure size')
+  session.redo()
+  assert.equal(session.source(), after)
+})

package/test/size-response.test.ts

@@ -0,0 +1,49 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { applyFigureAuthoring, compileFigureAsset, figureRowOf, figureFollowOf } from '@hatiolab/figure-model'
+import { sizeRelationSteps, sizeRelationOf, sizeInputOf } from '../client/modeller/size-response.ts'
+import type { FigureRevision } from '../client/modeller/revision.ts'
+import { multipartResponseFixture } from './multipart-response-fixture.js'
+const revision = (asset: ReturnType<typeof multipartResponseFixture>) => ({ asset, inputs: asset.designInputs } as FigureRevision)
+const width = (a: ReturnType<typeof multipartResponseFixture>, id: string) => compileFigureAsset(a).evaluate().geometry.find(g => g.id === id)!.shape.dimensions['size.x']
+
+test('switching difference to ratio preserves current size, changes future response, and leaves attachment intact', () => {
+ const a = multipartResponseFixture()
+ assert.equal(sizeRelationOf(revision(a), 'brace', 'x').mode, 'difference')
+ const b = sizeRelationSteps(revision(a), 'brace', 'x', {of:'part',part:'tabletop',axis:'x'}, 'ratio').reduce(applyFigureAuthoring, a)
+ assert.equal(width(b,'brace'),1300)
+ assert.deepEqual(b.joints,a.joints)
+ assert.equal(sizeRelationOf(revision(b),'brace','x').mode,'ratio')
+ assert.equal(width({...b,designInputs:{...b.designInputs,'size.x':3000}},'brace'),2600)
+})
+test('own X can keep a difference from another part Y; switching source preserves its current size', () => {
+ const a = multipartResponseFixture()
+ const b = sizeRelationSteps(revision(a),'brace','x',{of:'part',part:'tabletop',axis:'y'},'difference').reduce(applyFigureAuthoring,a)
+ assert.equal(width(b,'brace'),1300)
+ assert.deepEqual(figureFollowOf(b,'brace','x'),{of:'part',part:'tabletop',axis:'y',plus:1220})
+ assert.deepEqual(b.joints,a.joints)
+})
+test('editing a linked size updates its difference without changing the reference', () => {
+ const a=multipartResponseFixture()
+ const b=sizeRelationSteps(revision(a),'brace','x',{of:'part',part:'tabletop',axis:'x'},'difference',1250.25).reduce(applyFigureAuthoring,a)
+ assert.equal(width(b,'brace'),1250.25)
+ assert.equal(width({...b,designInputs:{...b.designInputs,'size.x':3000}},'brace'),2750.25)
+ assert.equal(sizeInputOf(a,'brace','x'),undefined)
+ assert.ok(sizeInputOf(a,'legLeft','x'))
+ assert.throws(()=>sizeRelationSteps(revision(a),'brace','x',{of:'part',part:'brace',axis:'x'},'ratio'),/SIZE_SOURCE/)
+})
+
+test('repeat settings can change count, direction and mode without losing the attachment or size relation', () => {
+ let a=applyFigureAuthoring(multipartResponseFixture(), {kind:'make-repeat',part:'legLeft',axis:'x',pitch:200})
+ const initial=a.joints!.find(j=>j.body1.part==='legLeft')!
+ a=applyFigureAuthoring(a,{kind:'set-joint',joint:{...initial,repeat:{...initial.repeat!,count:5}}})
+ assert.equal(figureRowOf(a,'legLeft')!.count,5)
+ const current=a.joints!.find(j=>j.body1.part==='legLeft')!
+ a=applyFigureAuthoring(a,{kind:'set-joint',joint:{...current,repeat:{...current.repeat!,axis:'Z',count:3}}})
+ assert.equal(figureRowOf(a,'legLeft')!.count,3)
+ const last=a.joints!.find(j=>j.body1.part==='legLeft')!
+ a=applyFigureAuthoring(a,{kind:'set-joint',joint:{...last,repeat:{...last.repeat!,count:undefined,pitch:200}}})
+ assert.equal(a.joints!.find(j=>j.body1.part==='legLeft')!.repeat!.count,undefined)
+ assert.deepEqual(a.joints!.find(j=>j.body1.part==='legLeft')!.body0,initial.body0)
+ assert.deepEqual(figureFollowOf(a,'brace','x'),{of:'part',part:'tabletop',axis:'x',plus:-200})
+})