@things-factory/figure-ui 10.1.271 → 10.1.273

package/test/browser/side-panel-sweep.check.mjs

@@ -10,7 +10,7 @@
 import { test, describe, before, after } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { addFigureBox, createFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
 
 import { buildPage } from './build.mjs'
 import { openPage } from './serve.mjs'
@@ -116,6 +116,17 @@ describe('the side panel', () => {
     assert.equal(hit, 'heading')
   })
 
+  test('the heading is one line, the part\'s name and kind side by side, on a ground the rows under it do not show through (user 2026-11-12)', async () => {
+    const head = await read(DEEP => {
+      const subject = eval(DEEP)('div[subject]')[0]
+      const [name, kind] = [subject.querySelector('b'), subject.querySelector('small')]
+      const middle = el => { const r = el.getBoundingClientRect(); return Math.round(r.top + r.height / 2) }
+      return { oneLine: Math.abs(middle(name) - middle(kind)) <= 3, ground: getComputedStyle(subject).backgroundColor }
+    }, DEEP)
+    assert.equal(head.oneLine, true)
+    assert.ok(!/rgba\(.*, 0\)$|transparent/.test(head.ground), `a solid ground: ${head.ground}`)
+  })
+
   test('U5 the motion tab: no animation yet is said in its own words, the controls\' words said once', async () => {
     await click(await tab('motion'), 'the motion tab')
     const hints = await read(DEEP => eval(DEEP)('p[hint]').map(p => p.textContent.trim()), DEEP)
@@ -125,6 +136,7 @@ describe('the side panel', () => {
 
   test('U6 the data tab: a field name and Enter adds the field', async () => {
     await click(await tab('data'), 'the data tab')
+    assert.equal(await read(DEEP => eval(DEEP)('details[add-field]')[0]?.open, DEEP), true, 'no field yet: the form stands open')
     await click(await read(() => look.at('input[aria-label="figure.label.data-name"]')), 'the field name')
     await page().keyboard.type('speed')
     await page().keyboard.press('Enter')
@@ -143,27 +155,49 @@ describe('the side panel', () => {
 
 describe('the preview', () => {
   /* A number and a text, of names far apart in length, each read by a table: the preview gives each a field. */
-  const asset = addFigureBox(createFigureAsset('Probe'), { id: 'box', size: { x: 400, y: 400, z: 400 }, position: { x: 0, y: 200, z: 0 } })
+  /* Its size declared, so the preview offers the size help over it (shown only where the size can change). */
+  const asset = applyFigureAuthoring(addFigureBox(createFigureAsset('Probe'), { id: 'box', size: { x: 400, y: 400, z: 400 }, position: { x: 0, y: 200, z: 0 } }), { kind: 'declare-instance-size', at: { x: 400, y: 400, z: 400 } })
   asset.dataInterface = {
     version: 'figure-data-interface-2',
     schema: [
       { name: 'A', kind: 'number' },
-      { name: 'CARRIERSTATUS', kind: 'text' }
+      { name: 'CARRIERSTATUS', kind: 'text' },
+      { name: 'LOW', kind: 'boolean' },
+      { name: 'HEADING', kind: 'number', unit: 'deg' }
     ],
     bindings: [
       { id: 'a', accessor: 'A', rule: 'table', lookup: 'ranges', targets: { parts: ['box'] }, table: { '~10': { color: '#ff0000' }, default: { color: '#0000ff' } } },
+      { id: 'h', accessor: 'HEADING', rule: 'table', lookup: 'ranges', targets: { parts: ['box'] }, table: { '~180': { color: '#00ffff' }, default: { color: '#ffff00' } } },
+      { id: 'l', accessor: 'LOW', rule: 'table', lookup: 'code', targets: { parts: ['box'] }, table: { true: { color: '#ff00ff' }, default: { color: '#0000ff' } } },
       { id: 's', accessor: 'CARRIERSTATUS', rule: 'table', lookup: 'code', targets: { parts: ['box'] }, table: { X: { color: '#00ff00' } } }
     ]
   }
   before(async () => {
     await mount('box', serializeFigureAsset(asset))
     await click(await read(() => probe.modeButton('preview')), 'the preview')
-    await until(DEEP => eval(DEEP)('figure-preview')[0]?.shadowRoot?.querySelectorAll('div[clips] input').length === 2, [DEEP], 'the two values in the preview')
+    await until(DEEP => eval(DEEP)('figure-preview')[0]?.shadowRoot?.querySelectorAll('div[clips] label input').length === 5, [DEEP], 'the four values in the preview')
   })
 
-  test('U7 a number\'s field and a text\'s start in one column, whatever the names\' lengths', async () => {
-    const lefts = await read(DEEP => [...eval(DEEP)('figure-preview')[0].shadowRoot.querySelectorAll('div[clips] input')].map(i => Math.round(i.getBoundingClientRect().left)), DEEP)
-    assert.equal(lefts[0], lefts[1], `the fields start at ${lefts.join(' and ')}`)
+  test('U7 a number\'s field and a text\'s start in one column, whatever the names\' lengths -- and end in one, with the help', async () => {
+    const edges = await read(DEEP => {
+      const root = eval(DEEP)('figure-preview')[0].shadowRoot
+      return [...root.querySelectorAll('div[clips] label input:not([type=checkbox]):not([type=range]):not([typed])'), root.querySelector('div[clips] div[setup] > button')].map(i => {
+        const r = i.getBoundingClientRect()
+        return { left: Math.round(r.left), right: Math.round(r.right) }
+      })
+    }, DEEP)
+    assert.equal(edges[0].left, edges[1].left, `the fields start at ${JSON.stringify(edges)}`)
+    /* A number with no range and a text are as wide as each other, to the help's right edge (user 2026-11-12: every width differed). */
+    assert.equal(edges[0].right, edges[1].right, `the fields end at ${JSON.stringify(edges)}`)
+    assert.equal(edges[0].right, edges[2].right, `the help ends where they do: ${JSON.stringify(edges)}`)
+  })
+  test('the names stay on one line: a unit is not put under its name (user 2026-11-12)', async () => {
+    const tall = await read(DEEP => [...eval(DEEP)('figure-preview')[0].shadowRoot.querySelectorAll('div[clips] label > span:first-child')].map(s => {
+      const range = document.createRange()
+      range.selectNodeContents(s)
+      return new Set([...range.getClientRects()].map(r => Math.round(r.bottom))).size
+    }), DEEP)
+    assert.ok(tall.every(n => n === 1), `lines per name: ${tall}`)
   })
 
   test('U7 the size help\'s choice and button are in the bar\'s look, not the browser\'s grey', async () => {
@@ -183,13 +217,140 @@ describe('the preview', () => {
   test('a value the sample gives is shown as the sample\'s, not offered as a field; the sample off, the field is back', async () => {
     const rows = () => read(DEEP => {
       const root = eval(DEEP)('figure-preview')[0].shadowRoot
-      return { fields: root.querySelectorAll('div[clips] input, div[clips] select').length, sampled: [...root.querySelectorAll('div[clips] label[sampled] output')].map(o => o.textContent.trim()) }
+      return { fields: root.querySelectorAll('div[clips] label input, div[clips] label select').length, sampled: [...root.querySelectorAll('div[clips] label[sampled] output')].map(o => o.textContent.trim()) }
     }, DEEP)
     await read(DEEP => (eval(DEEP)('figure-preview')[0].sample = { A: 4 }), DEEP)
     await until(DEEP => eval(DEEP)('figure-preview')[0].shadowRoot.querySelector('div[clips] label[sampled]'), [DEEP], 'the sampled row')
-    assert.deepEqual(await rows(), { fields: 1, sampled: ['4'] }, 'A from the sample, CARRIERSTATUS still a field')
+    assert.deepEqual(await rows(), { fields: 4, sampled: ['4'] }, 'A from the sample, the others still fields')
     await read(DEEP => (eval(DEEP)('figure-preview')[0].sample = null), DEEP)
     await until(DEEP => !eval(DEEP)('figure-preview')[0].shadowRoot.querySelector('div[clips] label[sampled]'), [DEEP], 'the field back')
-    assert.deepEqual(await rows(), { fields: 2, sampled: [] })
+    assert.deepEqual(await rows(), { fields: 5, sampled: [] })
+  })
+  test('an angle with no range is a dial, a slider over one turn and a box, as the controls\' angles are (user 2026-11-12)', async () => {
+    const row = await read(DEEP => {
+      const label = [...eval(DEEP)('figure-preview')[0].shadowRoot.querySelectorAll('div[clips] label')].find(l => l.querySelector('span').textContent.trim().startsWith('HEADING'))
+      const slider = label.querySelector('input[type=range]')
+      return { dial: !!label.querySelector('svg[dial]'), min: slider?.min, max: slider?.max, box: !!label.querySelector('input[typed]') }
+    }, DEEP)
+    assert.deepEqual(row, { dial: true, min: '0', max: '360', box: true })
+  })
+  test('a click on a number\'s name gives it nothing; dragged, it gives the value dragged to (user 2026-11-12)', async () => {
+    const name = () => read(DEEP => {
+      const label = [...eval(DEEP)('figure-preview')[0].shadowRoot.querySelectorAll('div[clips] label')].find(l => l.querySelector('span').textContent.trim() === 'A')
+      const r = label.querySelector('span[scrub]').getBoundingClientRect()
+      return { x: r.left + 4, y: r.top + r.height / 2 }
+    }, DEEP)
+    const valuing = () => read(DEEP => eval(DEEP)('figure-preview')[0].valuing.A, DEEP)
+    const at = await name()
+    await page().mouse.click(at.x, at.y)
+    assert.equal(await valuing(), undefined, 'a click is not a value')
+    await page().mouse.move(at.x, at.y)
+    await page().mouse.down()
+    await page().mouse.move(at.x + 15, at.y)
+    await page().mouse.up()
+    assert.equal(await valuing(), 15, 'dragged 15 pixels from nothing given')
+  })
+  test('the data tab\'s fields are a table -- field, kind, what each moves -- one row a field (user 2026-11-12)', async () => {
+    await click(await tab('data'), 'the data tab')
+    const table = await until(DEEP => {
+      const fields = eval(DEEP)('div[fields]')[0]
+      if (!fields) return undefined
+      const cells = row => [...row.querySelectorAll(':scope > span')].map(c => c.textContent.trim().replace(/\s+/g, ' '))
+      return { head: cells(fields.querySelector(':scope > div[head]')), rows: [...fields.querySelectorAll(':scope > button[row]')].map(cells) }
+    }, [DEEP], 'the fields table')
+    assert.deepEqual(table.head, ['figure.label.data-column-field', 'figure.label.data-column-kind', 'figure.label.data-column-moves'])
+    assert.equal(table.rows.length, 4, 'one row a field')
+    assert.ok(table.rows.every(r => r.length === 3), JSON.stringify(table.rows))
+    /* What a field moves is named, not counted. */
+    assert.ok(table.rows.every(r => !r[2].includes('figure.label.data-bound')), JSON.stringify(table.rows))
+    const tops = await read(DEEP => [...eval(DEEP)('div[fields]')[0].querySelectorAll(':scope > button[row]')].map(r => [...r.children].map(c => Math.round(c.getBoundingClientRect().left))), DEEP)
+    assert.equal(new Set(tops.map(t => t.join())).size, 1, `the columns line up: ${JSON.stringify(tops)}`)
+    /* With fields there, the form to add one is folded under its summary; on a figure with none it stands open (U6). */
+    assert.equal(await read(DEEP => eval(DEEP)('details[add-field]')[0]?.open, DEEP), false, 'folded')
+  })
+  test('a field\'s row opened holds its bindings and a folded form to add one; no list of bindings apart (user 2026-11-12)', async () => {
+    await read(DEEP => [...eval(DEEP)('div[fields]')[0].querySelectorAll(':scope > button[row]')].find(r => r.textContent.trim().startsWith('A')).click(), DEEP)
+    const detail = await until(DEEP => {
+      const fields = eval(DEEP)('div[fields]')[0]
+      const d = fields.querySelector(':scope > div[detail]')
+      if (!d) return undefined
+      return {
+        lines: [...d.querySelectorAll('div[bindings] button[line] strong')].map(s => s.textContent.trim()),
+        folded: d.querySelector('details[add-binding]')?.open === false,
+        apart: [...fields.getRootNode().querySelectorAll('section > h3')].map(h => h.textContent.trim()).filter(t => t.startsWith('figure.label.data-bindings'))
+      }
+    }, [DEEP], 'the A row opened')
+    assert.deepEqual(detail, { lines: ['A'], folded: true, apart: [] })
+  })
+  test('a table\'s targets are a property list and each value a box of its settings, one under another (user 2026-11-12)', async () => {
+    /* The A row is open from the test before: open its binding. */
+    await read(DEEP => eval(DEEP)('div[fields]')[0].querySelector(':scope > div[detail] button[line]').click(), DEEP)
+    const editor = await until(DEEP => {
+      const d = eval(DEEP)('div[fields]')[0].querySelector(':scope > div[detail]')
+      const targets = d.querySelector('div[targets]')
+      if (!targets) return undefined
+      const cases = [...d.querySelectorAll('div[cases] > div[case]')].map(c => Math.round(c.getBoundingClientRect().left))
+      const names = [...d.querySelectorAll('div[props] > span:nth-child(odd)')].map(n => Math.round(n.getBoundingClientRect().height))
+      return {
+        targets: [...targets.querySelectorAll(':scope > span:not([none])')].map(t => t.textContent.trim()),
+        ticks: targets.querySelectorAll('input[type=checkbox]').length + d.querySelectorAll('div[chips]').length,
+        stacked: cases.length >= 2 && new Set(cases).size === 1,
+        oneLine: names.length > 0 && new Set(names).size === 1
+      }
+    }, [DEEP], 'the table editor')
+    assert.deepEqual(editor, { targets: ['figure.label.data-target-parts', 'box'], ticks: 0, stacked: true, oneLine: true })
+  })
+  test('a sample typed as JSON5 is read, in a box with room for it (user 2026-11-12)', async () => {
+    await click(await tab('data'), 'the data tab')
+    const box = await until(DEEP => eval(DEEP)('textarea[sample]')[0], [DEEP], 'the sample box')
+    assert.ok(box)
+    const seen = await read(async DEEP => {
+      const area = eval(DEEP)('textarea[sample]')[0]
+      area.value = "{ A: 7, CARRIERSTATUS: 'X', }"
+      area.dispatchEvent(new Event('input'))
+      const panel = area.getRootNode().host
+      await panel.updateComplete
+      return {
+        height: Math.round(area.getBoundingClientRect().height),
+        refused: [...panel.shadowRoot.querySelectorAll('p[hint]')].some(p => p.textContent.includes('figure.text.data-not-json'))
+      }
+    }, DEEP)
+    assert.equal(seen.refused, false, 'read, not refused as not JSON')
+    assert.ok(seen.height >= 240, `room for a record: ${seen.height}px`)
+  })
+  test('a yes or no is a check box in the fields\' column; checked, the figure is given true (user 2026-11-12)', async () => {
+    const box = await read(DEEP => {
+      const root = eval(DEEP)('figure-preview')[0].shadowRoot
+      const check = root.querySelector('div[clips] label input[type=checkbox]')
+      return { found: !!check, choices: root.querySelectorAll('div[clips] label select').length, left: Math.round(check.getBoundingClientRect().left), fields: Math.round(root.querySelector('div[clips] label input:not([type=checkbox])').getBoundingClientRect().left) }
+    }, DEEP)
+    assert.deepEqual(box, { found: true, choices: 0, left: box.fields, fields: box.fields }, 'no list of two words; the box where the fields start')
+    await read(DEEP => eval(DEEP)('figure-preview')[0].shadowRoot.querySelector('div[clips] label input[type=checkbox]').click(), DEEP)
+    assert.equal(await read(DEEP => eval(DEEP)('figure-preview')[0].valuing.LOW, DEEP), true)
+  })
+})
+
+describe('the data table\'s kind column', () => {
+  before(async () => {
+    const asset = addFigureBox(createFigureAsset('Kinds'), { id: 'box', size: { x: 400, y: 400, z: 400 }, position: { x: 0, y: 200, z: 0 } })
+    asset.dataInterface = {
+      version: 'figure-data-interface-2',
+      schema: [
+        { name: 'MODE', kind: 'text', values: ['idle', 'walk', 'run'] },
+        { name: 'ANGLE', kind: 'number', unit: 'deg', min: -45, max: 45 }
+      ],
+      bindings: []
+    }
+    await mount('box', serializeFigureAsset(asset))
+  })
+
+  test('says the kind and unit on one line; the values and range in its title (user 2026-11-12)', async () => {
+    await click(await tab('data'), 'the data tab')
+    const cells = await until(DEEP => {
+      const rows = [...(eval(DEEP)('div[fields]')[0]?.querySelectorAll(':scope > button[row]') ?? [])]
+      return rows.length === 2 ? rows.map(r => { const c = r.children[1]; return { text: c.textContent.trim(), title: c.title } }) : undefined
+    }, [DEEP], 'the two rows')
+    assert.ok(cells.every(c => !/[~(]/.test(c.text)), `no range or values in the cell: ${JSON.stringify(cells)}`)
+    assert.ok(cells[0].title.includes('idle, walk, run') && cells[1].title.includes('-45~45'), `said in the title: ${JSON.stringify(cells)}`)
   })
 })

package/test/clips.test.ts

@@ -93,7 +93,7 @@ test('a track copied onto another control a while later; a clip copy takes a fre
 })
 
 /* Review 2026-11-09: a track starts from the pose, a pose is kept in one step, a clip on a played control joins a group. */
-import { newClipEdits, newTrackKeys, rememberedPoseEdits } from '../client/modeller/clips.ts'
+import { copyClipEdits, newClipEdits, newTrackKeys, rememberedPoseEdits } from '../client/modeller/clips.ts'
 
 const applied = (asset: FigureAsset, edits: unknown[]) => edits.reduce<FigureAsset>((a, e) => editFigurePart(a, e as never), asset)
 
@@ -103,7 +103,7 @@ test('새 트랙은 지금 자세를 처음부터 끝까지 유지 — 범위
   assert.deepEqual(newTrackKeys({ min: 5, max: 9 }, undefined, 2), [{ seconds: 0, value: 5 }, { seconds: 2, value: 5 }], '값을 모르면 범위의 시작')
   /* The panel's wiring: the default button holds the pose, the range one is the preset. */
   const panel = read('../client/modeller/figure-clips.ts')
-  assert.match(panel, /newTrackKeys\(input!, this\.values\[stateId!\], duration\)\)/)
+  assert.match(panel, /newTrackKeys\(input!, this\.values\[stateId!\], duration\), 'smooth'\)/)
   assert.match(panel, /newTrackKeys\(input!, this\.values\[stateId!\], duration, 'range'\)/)
   /* Several edits go up as one step, and the editor applies them as one. */
   assert.match(read('../client/modeller/editor.ts'), /<figure-clips[\s\S]*?@part-edits=\$\{\(e: CustomEvent\) => this\.run\(\(\) => this\.session!\.applyRecipe\(e\.detail\.edits\)\)\}[\s\S]*?<\/figure-clips>/)
@@ -128,13 +128,36 @@ test('재생 중인 조작값에 새 클립 — 그룹 없는 클립과 새 동
   assert.deepEqual(applied(grouped, half.edits).motionGroups!.map(g => g.clips), [['닫기', '열기', '반열기']])
 })
 
+test('이 자세 기억하기 — 되풀이 트랙의 처음과 끝은 한 순간: 둘 중 어디서 기억해도 두 키가 함께 바뀐다', () => {
+  const asset = editFigurePart(machine(), { kind: 'set-driver', state: 'shift', clip: 'walk', duration: 4, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 60 }, { seconds: 4, value: 0 }] })
+  const keysOf = (a: FigureAsset) => clipsOf(a)[0]!.tracks[0]!.keys
+  assert.equal(clipsOf(asset)[0]!.tracks[0]!.loop, 'wrap')
+
+  /* Kept at the end: the end reads as the start, yet the pose is kept -- at both ends, so the loop does not jump. */
+  const atEnd = rememberedPoseEdits(asset, 'walk', 4, { shift: 20, spin: 0 }, { shift: 0, spin: 0 })
+  assert.equal(atEnd.edits.length, 1)
+  assert.deepEqual(keysOf(applied(asset, atEnd.edits)), [{ seconds: 0, value: 20 }, { seconds: 2, value: 60 }, { seconds: 4, value: 20 }])
+
+  /* Kept at 0: the end key follows. */
+  const atStart = rememberedPoseEdits(asset, 'walk', 0, { shift: 10, spin: 0 }, { shift: 0, spin: 0 })
+  assert.deepEqual(keysOf(applied(asset, atStart.edits)), [{ seconds: 0, value: 10 }, { seconds: 2, value: 60 }, { seconds: 4, value: 10 }])
+
+  /* Both ends already there: nothing to keep. */
+  assert.deepEqual(rememberedPoseEdits(asset, 'walk', 4, { shift: 0, spin: 0 }, { shift: 0, spin: 0 }).edits, [])
+
+  /* A loop left open on purpose -- a ramp that starts over -- keeps its other end. */
+  const ramp = editFigurePart(machine(), { kind: 'set-driver', state: 'shift', clip: 'walk', duration: 4, keys: [{ seconds: 0, value: 0 }, { seconds: 4, value: 60 }] })
+  assert.deepEqual(keysOf(applied(ramp, rememberedPoseEdits(ramp, 'walk', 4, { shift: 50, spin: 0 }, { shift: 0, spin: 0 }).edits)), [{ seconds: 0, value: 0 }, { seconds: 4, value: 50 }])
+  assert.deepEqual(keysOf(applied(ramp, rememberedPoseEdits(ramp, 'walk', 0, { shift: 10, spin: 0 }, { shift: 0, spin: 0 }).edits)), [{ seconds: 0, value: 10 }, { seconds: 4, value: 60 }])
+})
+
 test('이 자세 기억하기 — 바뀐 조작값만, 한 묶음으로; 다른 동작이 쓰는 조작값은 이름만', () => {
   const asset = editFigurePart(machine(), { kind: 'set-driver', state: 'shift', clip: 'cycle', duration: 4, keys: [{ seconds: 0, value: 0 }, { seconds: 4, value: 60 }] })
   const base = { shift: 30, spin: 0 }
   /* At 2 s the clip has shift at 30: unchanged, no key. spin moved to 45 since: a new track from 0 to 45 at 2 s. */
   const kept = rememberedPoseEdits(asset, 'cycle', 2, { shift: 30, spin: 45 }, base)
   assert.deepEqual(kept.skipped, [])
-  assert.deepEqual(kept.edits, [{ kind: 'set-driver', state: 'spin', clip: 'cycle', keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 45 }] }])
+  assert.deepEqual(kept.edits, [{ kind: 'set-driver', state: 'spin', clip: 'cycle', keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 45 }], interpolation: 'smooth' }])
   const after = applied(asset, kept.edits)
   assert.equal(poseAt(after, 'cycle', 2).find(c => c.input === 'spin')!.value, 45)
 
@@ -148,7 +171,7 @@ test('이 자세 기억하기 — 바뀐 조작값만, 한 묶음으로; 다른
   assert.deepEqual(rememberedPoseEdits(after, 'cycle', 2, { shift: 30, spin: 45 }, { shift: 30, spin: 45 }).edits, [])
 
   /* At 0 a new track holds the pose throughout. */
-  assert.deepEqual(rememberedPoseEdits(asset, 'cycle', 0, { shift: 0, spin: 10 }, base).edits, [{ kind: 'set-driver', state: 'spin', clip: 'cycle', keys: [{ seconds: 0, value: 10 }, { seconds: 4, value: 10 }] }])
+  assert.deepEqual(rememberedPoseEdits(asset, 'cycle', 0, { shift: 0, spin: 10 }, base).edits, [{ kind: 'set-driver', state: 'spin', clip: 'cycle', keys: [{ seconds: 0, value: 10 }, { seconds: 4, value: 10 }], interpolation: 'smooth' }])
 
   /* spin played by another clip in no group: not taken, named. */
   const other = editFigurePart(asset, { kind: 'set-driver', state: 'spin', clip: 'turn', duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 90 }] })
@@ -174,3 +197,25 @@ test('키 사이 움직임 — 트랙마다 일정한 속도 · 부드럽게 ·
   assert.match(panel, /\['linear', 'smooth', 'step'\] as const/)
   assert.match(panel, /\?disabled=\$\{this\.locked \|\| same \|\| !!fits\}/)
 })
+
+test('a clip in no group is copied in one step: a group is made with a name of its own, and both are in it (review 2026-11-11)', () => {
+  const asset = editFigurePart(machine(), { kind: 'set-driver', state: 'shift', clip: 'walk', duration: 4, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 60 }, { seconds: 4, value: 0 }] })
+  const after = applied(asset, copyClipEdits(asset, 'walk'))
+  assert.deepEqual(clipsOf(after).map(c => c.name), ['walk', 'walk-copy'])
+  assert.deepEqual(after.motionGroups!.map(g => [g.label, g.clips, g.defaultClip]), [['motion', ['walk', 'walk-copy'], 'walk']])
+  /* A second group takes the next free name. */
+  const taken = { ...asset, motionGroups: [{ id: 'motion', label: 'motion', clips: ['lift'], defaultClip: 'lift', transitionSeconds: 0.2 }] }
+  assert.equal((copyClipEdits(taken, 'walk', 'motion')[0] as { group: { label: string } }).group.label, 'motion 2')
+  /* Already in a group: only the copy. */
+  assert.equal(copyClipEdits(after, 'walk').length, 1)
+})
+
+test('a clip lists its tracks in the order of the controls, however its drivers were last written (tutorial 2026-11-12)', () => {
+  const keys = [{ seconds: 0, value: 0 }, { seconds: 2, value: 10 }]
+  let asset = editFigurePart(machine(), { kind: 'set-driver', state: 'shift', clip: 'walk', duration: 2, keys })
+  asset = editFigurePart(asset, { kind: 'set-driver', state: 'spin', clip: 'walk', duration: 2, keys })
+  /* The first track keyed again: its driver is written anew. */
+  const shift = clipsOf(asset)[0]!.tracks.find(t => t.state === 'shift')!
+  asset = editFigurePart(asset, trackEdit(clipsOf(asset)[0]!, shift, { keys: withKey(shift.keys, { seconds: 1, value: 5 }) }) as never)
+  assert.deepEqual(clipsOf(asset)[0]!.tracks.map(t => t.state), ['shift', 'spin'])
+})

package/test/data-motion.test.ts

@@ -22,6 +22,7 @@ import {
   fieldOfKind,
   fitsField,
   freeIdOf,
+  freeNumberCodeOf,
   legendRoleOf,
   methodsOf,
   motionWrittenByData,
@@ -29,6 +30,7 @@ import {
   schemaFollowingCodes,
   tableColumnsOf,
   tableDraftOf,
+  tableWithKeep,
   tableWithKeys,
   tableWithLook,
   tableWithTargets,
@@ -97,7 +99,7 @@ test('작동 목록과 방법: 값 그대로 · 배율이 움직일 수 있는
   assert.deepEqual(fits({ name: 'o', kind: 'object', fields: [] }), [])
   assert.deepEqual(fits({ name: 'l', kind: 'list', item: { kind: 'object', fields: [] } }), ['items'])
   const choices = behaviorsOf(DOG)
-  assert.deepEqual(methodsOf({ kind: 'number' }, choices), ['value', 'scale', 'ranges'])
+  assert.deepEqual(methodsOf({ kind: 'number' }, choices), ['value', 'scale', 'code', 'ranges'], '숫자도 코드 표 (ADR-0166 개정 1)')
   assert.deepEqual(methodsOf({ kind: 'text' }, choices), ['value', 'code'])
   assert.deepEqual(methodsOf({ kind: 'boolean' }, choices), ['value', 'code'])
   assert.deepEqual(methodsOf({ kind: 'list', item: { kind: 'text' } }, choices), ['value'])
@@ -169,21 +171,20 @@ test('샘플: 보드의 Figure 와 같은 읽기로 -- 무엇을 움직이는지
   assert.ok(Number.isNaN(typedValueOf(row('cadence'), '') as number), '빈 칸은 0 이 아니다')
 })
 
-test('표 초안: 닫힌 칸은 값마다 줄, 열린 칸은 줄 없이, 숫자는 한 구간 -- 새 필드는 표가 만든다 (ADR-0166 10)', () => {
+test('표 초안: 닫힌 칸은 값마다 줄, 열린 칸은 줄 없이, 숫자는 한 구간 (ADR-0166 10)', () => {
   const mode = tableDraftOf(DOG, { path: 'mode', node: fieldAt(DOG.dataInterface!.schema, 'mode')! }, 'code', { parts: ['body'] })
-  assert.deepEqual([mode.binding.id, mode.binding.accessor, mode.binding.table, mode.schema], ['mode', 'mode', { idle: {}, walk: {}, run: {} }, undefined])
+  assert.deepEqual([mode.binding.id, mode.binding.accessor, mode.binding.table], ['mode', 'mode', { idle: {}, walk: {}, run: {} }])
   editFigurePart(DOG, { kind: 'set-data-binding', binding: mode.binding })
   const open = tableDraftOf(DOG, { path: 'status', node: fieldAt(DOG.dataInterface!.schema, 'status')! }, 'code', { parts: ['head'] })
   assert.deepEqual(open.binding.table, {})
   const pct = tableDraftOf(DOG, { path: 'cadence', node: fieldAt(DOG.dataInterface!.schema, 'cadence')! }, 'ranges', { parts: ['body'] })
   assert.deepEqual(pct.binding.table, { '0~': {} })
   editFigurePart(DOG, { kind: 'set-data-binding', binding: pct.binding })
-  /* 새 이름이면 필드를 만든다: 코드 표는 값 목록이 표의 키인 글자, 구간 표는 숫자. 한 걸음에 둘 다. */
-  const made = tableDraftOf(DOG, { name: 'EMPTYTYPE' }, 'code', { parts: ['body'] })
-  assert.deepEqual(made.schema!.at(-1), { name: 'EMPTYTYPE', kind: 'text', values: ['CODE'] })
+  /* 표는 표의 행이 연 필드에 붙는다: 필드는 먼저 등록한다 (데이터 탭이 필드마다 연결을 둔다, 2026-11-12). */
+  const typed = withField(DOG, { name: 'EMPTYTYPE', kind: 'text', values: ['CODE'] })
+  const made = tableDraftOf(typed, { path: 'EMPTYTYPE', node: fieldAt(typed.dataInterface!.schema, 'EMPTYTYPE')! }, 'code', { parts: ['body'] })
   assert.deepEqual(made.binding.table, { CODE: {} })
-  const asset = editFigurePart(DOG, { kind: 'set-data-binding', binding: made.binding, schema: made.schema })
-  assert.deepEqual(tableDraftOf(DOG, { name: 'RATE' }, 'ranges', { parts: ['body'] }).schema!.at(-1), { name: 'RATE', kind: 'number' })
+  const asset = editFigurePart(typed, { kind: 'set-data-binding', binding: made.binding })
   /* 닫힌 필드의 값 목록은 표의 키를 따라간다: 코드를 더하면 필드에도. */
   const b = asset.dataInterface!.bindings.find(x => x.id === 'emptytype')! as never
   const grown = tableWithKeys(b, [['FULL', { color: '#3b6d11' }], ['EMPTY', {}]])
@@ -194,6 +195,25 @@ test('표 초안: 닫힌 칸은 값마다 줄, 열린 칸은 줄 없이, 숫자
   assert.equal(legendRoleOf('Body_Status'), 'body-status')
 })
 
+/*
+ * ADR-0166 개정 1 (2026-11-12, 튜토리얼): MCS 는 STATUS 를 숫자(4002)로 보낸다. 숫자 칸에도 코드 표를 만들고, 「그 밖의 값」은
+ * 표가 마지막으로 보인 모양을 그대로 둘 수 있다 -- 4004(이동 중)에 포크가 내려가지 않는다.
+ */
+test('숫자 칸의 코드 표: 키는 숫자, 새 코드도 숫자 -- 그 밖의 값은 「그대로 둠」, 대상을 바꿔도 남는다 (ADR-0166 개정 1)', () => {
+  const draft = tableDraftOf(DOG, { path: 'cadence', node: fieldAt(DOG.dataInterface!.schema, 'cadence')! }, 'code', { parts: ['body'] })
+  assert.deepEqual(draft.binding.table, { 0: {} }, '숫자 칸의 첫 코드는 0')
+  assert.equal(draft.binding.lookup, 'code')
+  editFigurePart(DOG, { kind: 'set-data-binding', binding: draft.binding })
+  assert.equal(freeNumberCodeOf([]), '0')
+  assert.equal(freeNumberCodeOf(['4002', '4003']), '4004')
+  assert.equal(freeNumberCodeOf(['-1', 'x']), '0')
+  const kept = tableWithKeep(tableWithKeys(draft.binding, [['4002', { color: '#3b6d11' }], ['4003', {}]]), true)
+  assert.deepEqual(kept.table, { 4002: { color: '#3b6d11' }, 4003: {}, default: { keep: true } })
+  editFigurePart(DOG, { kind: 'set-data-binding', binding: kept })
+  assert.deepEqual(tableWithTargets(kept, { parts: ['head'] }).table.default, { keep: true }, '대상을 바꿔도 그대로 둠은 남는다')
+  assert.deepEqual(tableWithKeep(kept, false).table.default, {}, '끄면 빈 모양(기본값)')
+})
+
 test('표의 대상과 열: 부품은 색·효과, 조작값은 값 하나씩, 동작 그룹은 클립·배속·멈춤 -- 대상을 빼면 그 열도 빠진다', () => {
   const free = editFigurePart(DOG, { kind: 'remove-data-binding', id: 'mode-locomotion' })
   const draftTable = tableDraftOf(free, { path: 'mode', node: fieldAt(free.dataInterface!.schema, 'mode')! }, 'code', { parts: ['body'], inputs: ['fl-knee'], group: 'locomotion' }).binding
@@ -295,6 +315,17 @@ test('데이터 탭 · 클립 패널 · 미리보기의 배선과 문구', () =>
   assert.match(editor, /<figure-data-panel/)
   assert.match(editor, /\.sample=\$\{this\.dataSample\}/)
   assert.match(editor, /this\.dataSample = e\.detail\.data/)
+  /*
+   * 견본 데이터는 미리보기에서만 보인다: 편집 화면에서 「미리보기에 적용」을 켜면 그렇게 말하고, 단추 하나로 미리보기로 간다
+   * (튜토리얼 2026-11-12: 켜도 편집 화면이 그대로라 적용이 안 된 것처럼 보였다). 편집 화면은 기본 자세 그대로다.
+   */
+  assert.match(editor, /\?previewing=\$\{this\.middle === 'preview'\}/)
+  assert.match(editor, /@show-preview=\$\{\(\) => \(this\.middle = 'preview'\)\}/)
+  const panel = read('../client/modeller/figure-data-panel.ts')
+  assert.match(panel, /this\.sampling && !this\.previewing/)
+  assert.match(panel, /'figure\.text\.data-sample-shown-in-preview'/)
+  assert.match(panel, /'figure\.button\.data-sample-show-preview'/)
+  assert.match(panel, /new CustomEvent\('show-preview'/)
   /* 「＋ 회전」은 여러 명령을 되돌리기 한 단계로: 하나가 거절되면 아무것도 바뀌지 않는다. */
   assert.match(editor, /@part-edits=\$\{\(e: CustomEvent\) => this\.run\(\(\) => this\.session!\.applyRecipe\(e\.detail\.edits\)\)\}/)
   const preview = read('../client/modeller/figure-preview.ts')

package/test/fasten-form.test.ts

@@ -134,6 +134,31 @@ test('another way of meeting works the gap out again; a number typed stays; a pr
   assert.equal(fastenChanged(r, 'lid', pressed, { mode: 'flush' }).gap, 0, 'pressed: left at 0')
 })
 
+/*
+ * A part already fastened, aimed again through 「바꾸기」, goes where it is aimed with its fastening as it was -- the
+ * gap and the place across the face carried to the new face or part (tutorial 2026-11-12: a pillar copied from the front
+ * one and turned to the body's back face stayed in front, its gap worked out as the whole body's depth). 「현재 상태로
+ * 붙이기」 is a loose part's: fastening it does not move it.
+ */
+test('a fastened part aimed again goes there with its gap and its place across the face; a loose one stays where it stands', () => {
+  const r = conveyor()
+  const own = fastenFormOf(r, 'roller')
+  const under = fastenChanged(r, 'roller', own, { targetFace: 'bottom' })
+  assert.deepEqual([under.targetFace, under.gap, under.align.x, under.alignMm.x], ['bottom', 0, 'mm', 300], 'its own gap and place, not where it stands')
+  const moved = applyFigureAuthoring(r.asset, fastenPlanOf(r, 'roller', under).action as never)
+  const [x, y] = centreOf(moved, 'roller')
+  assert.ok(Math.abs(x! - 300) < 1e-6, `still 300 mm across: ${x}`)
+  assert.ok(y! < 0, `under the frame now: ${y}`)
+  /* Another part: on it, as fastened before. */
+  const onLid = aimFasten(r, 'roller', own, { part: 'lid' })
+  assert.deepEqual([onLid.target, onLid.gap, onLid.alignMm.x], ['lid', 0, 300])
+  /* A mode changed keeps its gap too; a number typed is the author's. */
+  assert.equal(fastenChanged(r, 'roller', own, { mode: 'flush' }).gap, 0)
+  /* The loose lid is fastened where it stands, as before. */
+  const loose = keptGapOf(floating(), 'lid', aimFasten(floating(), 'lid', fastenFormOf(floating(), 'lid'), { part: 'plate' }))
+  assert.equal(loose.gap, 40)
+})
+
 test('the target list: every other part, the one hanging from this part listed as a loop', () => {
   const r = conveyor()
   assert.deepEqual(fastenTargetsOf(r, 'frame'), [
@@ -204,6 +229,23 @@ test("pressed on the canvas: the face or the point pressed, read in that part's
   assert.deepEqual([corner.note, corner.form?.target], ['aim-not-here', 'soft'], 'a rounded corner: aimed at the part, said')
 })
 
+test('a part still where the palette put it goes to the centre of the face; one the author moved keeps its place across it (review 2026-11-11)', () => {
+  /* A thigh 85 mm left of the middle of a pelvis 880 mm up; a shin and an arm added from the palette at (0, 50, 0). */
+  let a = fasten(box(createFigureAsset('Humanoid'), 'pelvis', [300, 180, 200], [0, 970, 0]), 'pelvis', 'plane', { gap: 880 })
+  a = applyFigureAuthoring(box(a, 'thigh', [130, 420, 140], [-85, 670, 0]), { kind: 'attach', part: 'thigh', to: { part: 'pelvis', face: 'bottom' }, facing: 'meet', align: { x: { mm: -85 } } } as never)
+  a = box(box(a, 'shin', [110, 420, 120], [0, 50, 0]), 'arm', [90, 300, 90], [0, 50, 0])
+  const r = revisionOf(a)
+  const shin = aimFasten(r, 'shin', fastenFormOf(r, 'shin'), { part: 'thigh' })
+  const onBottom = aimFasten(r, 'shin', shin, { targetFace: 'bottom' })
+  assert.deepEqual([onBottom.align, onBottom.alignMm], [{}, {}], 'on the centre of the thigh, not 85 mm off it')
+  const arm = aimFasten(r, 'arm', aimFasten(r, 'arm', fastenFormOf(r, 'arm'), { part: 'pelvis' }), { targetFace: 'left' })
+  assert.deepEqual([arm.align, arm.alignMm], [{}, {}], 'on the side, not 920 mm below it')
+  /* Moved by the author first, it keeps where it stands across the face. */
+  const moved = revisionOf(box(a, 'tag', [40, 40, 40], [-60, 500, 30]))
+  const kept = aimFasten(moved, 'tag', aimFasten(moved, 'tag', fastenFormOf(moved, 'tag'), { part: 'thigh' }), { targetFace: 'bottom' })
+  assert.deepEqual(kept.alignMm, { x: 25, z: 30 })
+})
+
 test('a part still where the palette put it is fastened on the face; one the author moved keeps its place (tutorial 2026-11-11)', () => {
   /* A body on the floor; a mast added from the palette stands inside it, at the palette's place (0, 50, 0). */
   let a = fasten(box(createFigureAsset('Fork AGV'), 'body', [1000, 300, 700], [0, 150, 0]), 'body', 'plane')
@@ -216,3 +258,30 @@ test('a part still where the palette put it is fastened on the face; one the aut
   const kept = keptGapOf(moved, 'mast', aimFasten(moved, 'mast', fastenFormOf(moved, 'mast'), { part: 'body' }))
   assert.equal(kept.gap, 50, 'the 50 mm its bottom stands above the body')
 })
+
+test('aimed at a part, the form starts on a face nothing is fastened to yet (review 2026-11-11)', () => {
+  let a = fasten(box(createFigureAsset('Humanoid'), 'pelvis', [300, 180, 200], [0, 970, 0]), 'pelvis', 'plane', { gap: 880 })
+  a = applyFigureAuthoring(box(a, 'torso', [340, 500, 200], [0, 50, 0]), { kind: 'attach', part: 'torso', to: { part: 'pelvis', face: 'top' } } as never)
+  a = box(a, 'thigh', [130, 420, 140], [0, 50, 0])
+  const r = revisionOf(a)
+  const thigh = aimFasten(r, 'thigh', fastenFormOf(r, 'thigh'), { part: 'pelvis' })
+  assert.equal(thigh.targetFace, 'bottom', 'across from the top, where the body stands')
+  assert.equal(aimFasten(r, 'torso', fastenFormOf(r, 'torso'), { part: 'pelvis' }).targetFace, 'top', 'a part keeps the face it is fastened to')
+  const head = aimFasten(r, 'thigh', fastenFormOf(r, 'thigh'), { part: 'torso' })
+  assert.equal(head.targetFace, 'top', 'a free top is taken as asked')
+  /* A shin aimed at a thigh hung under the pelvis: the thigh's top touches the pelvis, so the shin goes under it. */
+  let b = applyFigureAuthoring(a, { kind: 'attach', part: 'thigh', to: { part: 'pelvis', face: 'bottom' } } as never)
+  b = box(b, 'shin', [110, 420, 120], [0, 50, 0])
+  const rb = revisionOf(b)
+  assert.equal(aimFasten(rb, 'shin', fastenFormOf(rb, 'shin'), { part: 'thigh' }).targetFace, 'bottom')
+  /* A forearm aimed at an upper arm hung by its side from the torso: on down, under the arm (tutorial run 2026-11-12). */
+  let c = applyFigureAuthoring(box(a, 'upperarm', [90, 300, 90], [0, 50, 0]), { kind: 'attach', part: 'upperarm', to: { part: 'torso', face: 'left' } } as never)
+  c = box(c, 'forearm', [80, 280, 80], [0, 50, 0])
+  const rc = revisionOf(c)
+  assert.equal(aimFasten(rc, 'forearm', fastenFormOf(rc, 'forearm'), { part: 'upperarm' }).targetFace, 'bottom')
+  /* A flat part hung by its side is not a limb: what goes on it keeps the face asked. */
+  let d = applyFigureAuthoring(box(a, 'shelf', [300, 40, 200], [0, 50, 0]), { kind: 'attach', part: 'shelf', to: { part: 'torso', face: 'left' } } as never)
+  d = box(d, 'cup', [60, 80, 60], [0, 50, 0])
+  const rd = revisionOf(d)
+  assert.equal(aimFasten(rd, 'cup', fastenFormOf(rd, 'cup'), { part: 'shelf' }).targetFace, 'top')
+})

package/test/fasten-geometry.test.ts

@@ -121,3 +121,16 @@ test('the face drawing shows a part bigger than the face whole when lined up wit
   assert.equal(drawingSpanOf(600, 300), 900)
   assert.equal(drawingSpanOf(undefined, 200), 600)
 })
+
+/*
+ * A part far off the face's centre -- a palette box left 1500 mm up, aimed at a body's front -- is drawn whole with its
+ * size label: the drawing reaches it, not only the face and the part's own size (roll cradle tutorial 2026-11-12: the
+ * label was cut off the drawing's top and could not be pressed).
+ */
+test('the face drawing reaches a part standing far off the face, its far edge inside', () => {
+  const span = drawingSpanOf(1200, 300, 1500)
+  assert.ok(span / 2 >= 1500 + 300 / 2, `span ${span}`)
+  assert.equal(drawingSpanOf(1200, 300, -1500), span, 'either side alike')
+  /* Near the centre it keeps the room it had. */
+  assert.equal(drawingSpanOf(600, 300, 100), 900)
+})

package/test/first-save.test.ts

@@ -5,7 +5,7 @@ import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
 import { placeholderType } from '@hatiolab/figure-model'
-import { firstSaveRefusalOf, releasableType, typeOf } from '../client/modeller/first-save.ts'
+import { firstSaveRefusalOf, releasableType, typeOf, typingTypeOf } from '../client/modeller/first-save.ts'
 import { createFigureProductSession, type FigureProductStore } from '../client/modeller/product-session.ts'
 
 test('치는 대로 타입의 모양이 된다 — 소문자 · 숫자 · 하이픈 하나', () => {
@@ -14,6 +14,16 @@ test('치는 대로 타입의 모양이 된다 — 소문자 · 숫자 · 하이
   assert.equal(typeOf('-Roller  Conveyor-'), 'roller-conveyor')
 })
 
+test('하이픈을 칠 수 있다 — 한 글자씩 쳐도 끝의 하이픈이 남고, 저장할 때 다듬는다', () => {
+  let typed = ''
+  for (const key of 'fork-agv-tutorial') typed = typingTypeOf(typed + key)
+  assert.equal(typed, 'fork-agv-tutorial')
+  let trailing = ''
+  for (const key of 'Fork AGV ') trailing = typingTypeOf(trailing + key)
+  assert.equal(trailing, 'fork-agv-')
+  assert.equal(typeOf(trailing), 'fork-agv')
+})
+
 test('발행할 수 없는 이름은 미리 말한다 — 임시 이름 · 형식 · 길이', () => {
   assert.equal(releasableType('agv-lifter'), true)
   assert.equal(releasableType(placeholderType()), false, '서버가 붙이는 임시 이름')

package/test/pivot.test.ts

@@ -0,0 +1,57 @@
+/*
+ * Named points a turn's axis may pass (`pivot.ts`): worked out from the part as it rests, they keep the named point
+ * still as the joint turns -- whatever the face, the alignment, the slider.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { addFigureBox, applyFigureAuthoring, createFigureAsset } from '@hatiolab/figure-model'
+import type { FigureAsset } from '@hatiolab/figure-model'
+
+import { motionJoint } from '../client/modeller/links.ts'
+import { pivotPointOf, pivotPointsOf } from '../client/modeller/pivot.ts'
+import { revisionOf } from './revision-of.ts'
+
+const box = (a: FigureAsset, id: string, [x, y, z]: number[], at = [0, 0, 0]) => addFigureBox(a, { id, size: { x, y, z }, position: { x: at[0]!, y: at[1]!, z: at[2]! } })
+const turn = (through = {}) => ({ kind: 'turn', axis: 'x', id: 'sh', min: -90, max: 90, follow: '', multiplier: 1, offset: 0, travel: '', travelPlus: 0, through }) as never
+
+/* An arm of 300 mm hung by its side from a torso, level with its top -- the lesson's upper arm -- or under it. */
+function arm(face: 'left' | 'bottom', align?: object) {
+  const a = box(createFigureAsset('H'), 'torso', [340, 500, 200], [0, 1000, 0])
+  return applyFigureAuthoring(box(a, 'arm', [90, 300, 90], [0, 50, 0]), { kind: 'attach', part: 'arm', to: { part: 'torso', face }, ...(align ? { align } : {}) } as never)
+}
+const endsAt = (a: FigureAsset, through: object, value: number) => {
+  const joint = a.joints!.find(j => j.body1.part === 'arm')!
+  const b = applyFigureAuthoring(a, { kind: 'set-joint', joint: motionJoint(joint, turn(through), 'arm') } as never)
+  const g = (revisionOf(b, { sh: value }).geometry as Array<{ id: string; pose: { r: number[][]; t: number[] } }>).find(p => p.id === 'arm')!.pose
+  /* The arm's top and bottom end centres in the figure's frame. */
+  return [150, -150].map(y => [0, 1, 2].map(i => g.r[i]![1]! * y + g.t[i]!))
+}
+const near = (a: number[], b: number[]) => a.every((v, i) => Math.abs(v - b[i]!) < 0.5)
+
+test('a named pivot stays where it is as the joint turns: top, middle, bottom of a side-hung or an under-hung arm (tutorial 2026-11-12)', () => {
+  for (const [face, align] of [['left', { y: 'max' }], ['left', undefined], ['bottom', undefined]] as const) {
+    const a = arm(face, align)
+    const points = pivotPointsOf(revisionOf(a), 'arm', 'x')!
+    assert.ok(points, `${face}: points`)
+    const [top0, bottom0] = endsAt(a, points.top, 0)
+    assert.ok(near(endsAt(a, points.top, 70)[0]!, top0!), `${face} ${JSON.stringify(align)}: the top end stays`)
+    assert.ok(near(endsAt(a, points.bottom, 70)[1]!, bottom0!), `${face} ${JSON.stringify(align)}: the bottom end stays`)
+    assert.ok(!near(endsAt(a, points.middle, 70)[0]!, top0!), `${face}: about the middle the top end moves`)
+  }
+})
+
+test('the lesson upper arm, level with the torso top, already turns about its top end: no number is needed', () => {
+  const points = pivotPointsOf(revisionOf(arm('left', { y: 'max' })), 'arm', 'x')!
+  assert.deepEqual(points, { top: {}, middle: { y: -150 }, bottom: { y: -300 } })
+  assert.equal(pivotPointOf(points, {}, 'x'), 'top')
+  assert.equal(pivotPointOf(points, { y: 120 }, 'x'), undefined, 'Y 120 put the axis above the shoulder')
+})
+
+test('a part fastened to nothing, or a slider left turned, has no wrong points', () => {
+  assert.equal(pivotPointsOf(revisionOf(box(createFigureAsset('H'), 'solo', [10, 10, 10])), 'solo'), null)
+  const a = arm('bottom')
+  const joint = a.joints!.find(j => j.body1.part === 'arm')!
+  const b = applyFigureAuthoring(a, { kind: 'set-joint', joint: motionJoint(joint, turn(), 'arm') } as never)
+  assert.deepEqual(pivotPointsOf(revisionOf(b, { sh: 60 }), 'arm'), pivotPointsOf(revisionOf(b), 'arm'))
+})