@things-factory/figure-ui 10.1.208 → 10.1.211

package/test/browser/screen.check.mjs

@@ -82,6 +82,8 @@ const tabOn = () => read(() => screenCheck.editor().shadowRoot.querySelector('bu
 const pressBar = action => press(action, a => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar').shadowRoot.querySelector(`button[data-action=${a}]`), action)
 const pressTab = name => press(name, name => screenCheck.editor().shadowRoot.querySelector(`button[tab][aria-label="${name}"]`), name)
 const TAB = name => `figure.label.tab-short-${name}`
+/* 「반응형」 while a part is chosen: named by what it holds for the part, its size and arrangement (2026-10-24). */
+const ARRANGEMENT = 'figure.label.tab-arrangement'
 /*
   The view settings or the releases, opened from the bar over the work (they were tabs once); left open if open. The
   releases open from 「발행」, the bar's one way to them (user 2026-10-18).
@@ -226,7 +228,9 @@ describe('the frame: parts · canvas · one side of seven tabs, and the bar over
     assert.equal(await saveOn(), false, 'saved: the save button is dimmed')
 
     await pressRow('box')
-    const height = await element('the height field', () => screenCheck.deep('input').find(i => i.getAttribute('aria-label') === 'box.size.y'))
+    /* A part's size is the 「배치」 tab's (2026-10-24). */
+    await pressTab(ARRANGEMENT)
+    const height = await element('the height field', () => screenCheck.deep('input').find(i => i.getAttribute('aria-label') === 'box Y figure.label.size-measure'))
     await height.click({ clickCount: 3 })
     await page().keyboard.type('600')
     await page().keyboard.press('Enter')
@@ -240,6 +244,7 @@ describe('the frame: parts · canvas · one side of seven tabs, and the bar over
     await until('redone', () => probe.value('box.size.y') === 600)
     await press('save', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[save]'))
     await until('saved: dimmed again', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[save]').disabled)
+    await pressTab(TAB('properties'))
 
     const width = () => read(() => Math.round(screenCheck.deep('figure-canvas')[0].getBoundingClientRect().width))
     const was = await width()
@@ -316,7 +321,7 @@ describe('the editor is drawn in the shell\'s tokens (2026-09-27)', () => {
 describe('a part chosen: each tab in its place, the figure-wide tabs give way, the list\'s root goes back', () => {
   before(() => mount('arm'))
 
-  test('properties hold the part\'s size and place; 「반응형」 how it answers a size; capability its places; motion its motion and controls -- each under the part\'s head', async () => {
+  test('properties hold the part\'s place; 「반응형」 its size and how it answers one; capability its places; motion its motion and controls -- each under the part\'s head', async () => {
     await pressRow('upper-arm')
     await until('upper-arm chosen', () => screenCheck.editor().selected === 'upper-arm')
     const holds = () =>
@@ -334,10 +339,11 @@ describe('a part chosen: each tab in its place, the figure-wide tabs give way, t
     await pressTab(TAB('properties'))
     let now = await holds()
     assert.ok(now.subject, 'the part\'s head')
-    assert.ok(now.links.includes('figure.label.group-size') && now.links.includes('figure.label.group-place'), `the shape's links: ${now.links}`)
+    /* A box's size is the 「배치」 tab's, in its size editor (2026-10-24): the properties keep its place. */
+    assert.ok(now.links.includes('figure.label.group-place') && !now.links.includes('figure.label.group-size'), `the shape's links: ${now.links}`)
     assert.ok(now.material, 'its material')
-    /* How it answers a size has a tab of its own (user 2026-10-17, 「반응형」). */
-    await pressTab(TAB('response'))
+    /* How it answers a size has a tab of its own (user 2026-10-17, 「반응형」), named 「배치」 while a part is chosen. */
+    await pressTab(ARRANGEMENT)
     now = await holds()
     assert.ok(now.subject, 'the part\'s head')
     assert.ok(now.links.includes('figure.label.group-size'), `the response's links: ${now.links}`)
@@ -726,6 +732,8 @@ describe('the camera follows a size typed far from the view (first 15 minutes, 2
   test('a width typed ten times larger fits the view again; a little wider leaves the camera where it is', async () => {
     await mount('box')
     await pressRow('box')
+    /* A part's size is the 「배치」 tab's (2026-10-24). */
+    await pressTab(ARRANGEMENT)
     await read(() => {
       const canvas = screenCheck.deep('figure-canvas')[0]
       const fit = canvas.fit.bind(canvas)
@@ -733,7 +741,7 @@ describe('the camera follows a size typed far from the view (first 15 minutes, 2
       canvas.fit = () => (window.fits++, fit())
     })
     const typeWidth = async mm => {
-      const width = await element('the width field', () => screenCheck.deep('input').find(i => i.getAttribute('aria-label') === 'box.size.x'))
+      const width = await element('the width field', () => screenCheck.deep('input').find(i => i.getAttribute('aria-label') === 'box X figure.label.size-measure'))
       await width.click({ clickCount: 3 })
       await page().keyboard.type(String(mm))
       await page().keyboard.press('Enter')
@@ -745,6 +753,7 @@ describe('the camera follows a size typed far from the view (first 15 minutes, 2
     assert.equal(await read(() => window.fits), 0, 'a little wider: the camera stays')
     await typeWidth(4000)
     await until('the view fitted to it', () => window.fits >= 1)
+    await pressTab(TAB('properties'))
     await boardsUp()
   })
 })
@@ -796,16 +805,25 @@ describe('a part\'s size row: a rule\'s numbers only where a rule sets every sid
     assert.equal(await sizeRow(), null)
   })
 
+  /*
+    A box's size is the 「배치」 tab's size editor (2026-10-24), one row a side: made to follow on every side, each row
+    shows the size the rule gives it, and the properties draw no size row.
+  */
   test('a box made to follow the figure\'s size on every side shows the size the rule gives it', async () => {
     await mount('box')
     await pressRow('box')
     await until('box chosen', () => screenCheck.editor().selected === 'box')
-    /* Following the figure's size is the 「반응형」 tab's; the size row it gives is the properties'. */
-    await pressTab(TAB('response'))
-    await press('follow the figure\'s size', () => screenCheck.deep('button[follow-size]').find(b => b.checkVisibility()))
+    await pressTab(ARRANGEMENT)
+    for (const axis of ['X', 'Y', 'Z']) {
+      const before = await revision()
+      await press(`${axis} made to follow`, axis => screenCheck.deep('input').find(i => i.getAttribute('aria-label') === `box ${axis} figure.label.size-follows`), axis)
+      await until(`${axis} following`, before => screenCheck.editor().session.read().revision > before, before)
+    }
     await until('following', () => ['x', 'y', 'z'].every(axis => !screenCheck.editor().session.read().fields.some(f => f.id === `box.size.${axis}`)))
+    const measures = await read(() => ['X', 'Y', 'Z'].map(axis => screenCheck.deep('input').find(i => i.getAttribute('aria-label') === `box ${axis} figure.label.size-measure`)?.value))
+    assert.deepEqual(measures, ['400', '400', '400'], 'each side the size the rule gives it')
     await pressTab(TAB('properties'))
-    assert.deepEqual(await sizeRow(), { held: 3 }, 'three sides, each held by the rule')
+    assert.equal(await sizeRow(), null, 'no size row on the properties')
   })
 })
 
@@ -829,7 +847,20 @@ describe('the side panel is found as it was left, per part', () => {
   }
   before(() => mount('arm'))
 
+  /*
+    The part's properties fit a tall window since its size moved to 「배치」 (2026-10-24): a shorter one gives the panel
+    something to scroll.
+  */
   test('scrolled and a fold opened on one part; another part opens at its top; back, the first is as it was left', async () => {
+    const viewport = page().viewport()
+    await page().setViewport({ ...viewport, height: 600 })
+    try {
+      await scrolledAndBack()
+    } finally {
+      await page().setViewport(viewport)
+    }
+  })
+  async function scrolledAndBack() {
     await pressRow('upper-arm')
     await until('upper-arm chosen', () => screenCheck.editor().selected === 'upper-arm')
     /* 「더 보기」 starts open on this page: folded first, so the fold opened below is one this part leaves open. */
@@ -854,7 +885,7 @@ describe('the side panel is found as it was left, per part', () => {
     await pressRow('upper-arm')
     await until('upper-arm as it was left', top => screenCheck.editor().selected === 'upper-arm' && Math.abs(screenCheck.shownPanel().scrollTop - top) <= 2, top)
     assert.deepEqual(await folds(), opened, 'its folds as they were')
-  })
+  }
 })
 
 describe('the fastening window says whether it changes the fastening the part has or fastens it anew', () => {
@@ -1075,12 +1106,15 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
 
   test('an edit is judged as it stands on screen: the source the server is sent is the one edited', async () => {
     await pressRow('left')
-    const height = await element('the height field', () => screenCheck.deep('input').find(i => i.getAttribute('aria-label') === 'left.size.y'))
+    /* A part's size is the 「배치」 tab's (2026-10-24). */
+    await pressTab(ARRANGEMENT)
+    const height = await element('the height field', () => screenCheck.deep('input').find(i => i.getAttribute('aria-label') === 'left Y figure.label.size-measure'))
     await height.click({ clickCount: 3 })
     await page().keyboard.type('600')
     await page().keyboard.press('Enter')
     await until('the edit made', () => screenCheck.editor().session.read().fields.find(f => f.id === 'left.size.y')?.value === 600)
     await until('the edited source judged', () => product.calls().filter(c => c.field === 'inspectFigureDraft').at(-1)?.variables.source === screenCheck.editor().session.revisionNow().text)
+    await pressTab(TAB('properties'))
   })
 
   test('a save sends the card\'s picture with the figure', async () => {
@@ -1114,7 +1148,17 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     }
   })
 
+  /* The part's properties fit a tall window since its size moved to 「배치」 (2026-10-24): a shorter one scrolls. */
   test('another figure opened starts its panels clean: a part of the same name opens at its top', async () => {
+    const viewport = page().viewport()
+    await page().setViewport({ ...viewport, height: 600 })
+    try {
+      await anotherFigureClean()
+    } finally {
+      await page().setViewport(viewport)
+    }
+  })
+  async function anotherFigureClean() {
     await open('fig-p', 'arm-clip')
     await pressRow('upper-arm')
     await until('upper-arm chosen', () => screenCheck.editor().selected === 'upper-arm')
@@ -1136,7 +1180,7 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     await until('upper-arm chosen', () => screenCheck.editor().selected === 'upper-arm')
     for (let i = 0; i < 3; i++) await page().waitForFunction(() => new Promise(done => requestAnimationFrame(() => requestAnimationFrame(() => done(true)))))
     assert.equal(await read(() => screenCheck.shownPanel().scrollTop), 0, 'not where the other figure\'s part was left')
-  })
+  }
 
   test('a new figure\'s AI draft puts a request in the assistant\'s input, and sends nothing', async () => {
     await read(() => assistant.forget())

package/test/browser/serve-response.mjs

@@ -0,0 +1,24 @@
+/* Manual browser verification. Uses buildPage's FIGURE_MODEL / THINGS_SCENE overrides when provided. */
+import { buildPage } from './build.mjs'
+import { createServer } from 'node:http'
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { createRequire } from 'node:module'
+const require = createRequire(import.meta.url)
+const bundle = await buildPage(process.argv[2] ?? 'response-page.js')
+const routes = new Map([
+  ['/page.js', [bundle, 'application/javascript']],
+  ['/ko.json', [new URL('../../translations/ko.json', import.meta.url), 'application/json']],
+  ['/icons.woff2', [require.resolve('material-symbols/material-symbols-outlined.woff2'), 'font/woff2']],
+  ['/workers/markdown-webworker.js', [join(dirname(bundle), 'workers/markdown-webworker.js'), 'application/javascript']]
+])
+const html = `<!doctype html><html lang="ko"><meta charset="utf-8"><title>반응형 치수 — 실제 편집기 로컬 검증</title><style>
+@font-face{font-family:"Material Symbols Outlined";src:url(/icons.woff2)}
+html,body{margin:0;height:100%;font-family:sans-serif}body{display:flex}figure-editor{flex:1;min-width:0;min-height:0}
+</style><body><script type="module" src="/page.js"></script></body></html>`
+createServer((req, res) => {
+  const file = routes.get(req.url)
+  if (!file && req.url !== '/') { res.writeHead(404); res.end(); return }
+  res.setHeader('Content-Type', file ? file[1] : 'text/html; charset=utf-8')
+  res.end(file ? readFileSync(file[0]) : html)
+}).listen(Number(process.env.PORT ?? 4391), '127.0.0.1', function () { console.log(`Ready http://127.0.0.1:${this.address().port}/`) })

package/test/clip-ai-proposal.test.ts

@@ -23,7 +23,7 @@ function door(): string {
   a = addFigureBox(a, { id: 'sign', size: { x: 200, y: 100, z: 10 }, position: { x: 0, y: 2200, z: 200 } })
   a = applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', to: { part: 'frame', face: 'top' } })
   const j = a.joints!.find(k => k.body1.part === 'leaf')!
-  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', state: { id: 'open' } } })
+  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, motion: [{ type: 'revolute', axis: 'Y', state: { id: 'open' } }] } })
   a = editFigurePart(a, { kind: 'set-driver', state: 'open', clip: 'swing', duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 80 }] })
   return serializeFigureAsset(a)
 }

package/test/clip-consent.test.ts

@@ -22,7 +22,7 @@ function doors(): string {
     a = addFigureBox(a, { id, size: { x: 900, y: 1800, z: 40 }, position: { x, y: 1000, z: 0 } })
     a = applyFigureAuthoring(a, { kind: 'attach', part: id, to: { part: 'frame', face: 'top' } })
     const j = a.joints!.find(k => k.body1.part === id)!
-    a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', state: { id: `${id}-open` } } })
+    a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, motion: [{ type: 'revolute', axis: 'Y', state: { id: `${id}-open` } }] } })
     a = editFigurePart(a, { kind: 'set-driver', state: `${id}-open`, clip: `${id}-swing`, duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 80 }] })
   }
   return serializeFigureAsset(a)
@@ -31,7 +31,7 @@ const store = { load: async (id: string) => ({ id, source: doors() }), save: asy
 const clipsOf = (s: ReturnType<typeof createFigureProductSession>) => (parseFigureAsset(s.source()) as FigureAsset).drivers?.map(d => d.clip) ?? []
 const fixed = (s: ReturnType<typeof createFigureProductSession>, part: string) => {
   const j = (parseFigureAsset(s.source()) as FigureAsset).joints!.find(k => k.body1.part === part)!
-  return { kind: 'set-joint', joint: { id: j.id, type: 'fixed', body0: j.body0, body1: j.body1, origin: j.origin } } as never
+  return { kind: 'set-joint', joint: { id: j.id, body0: j.body0, body1: j.body1, origin: j.origin } } as never
 }
 
 test('refused and named first; agreed, exactly those go in one step; undo brings them back; consent does not outlive it', async () => {

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 } : {}) } }]
     }
   })
 }