@things-factory/figure-ui 10.1.161 → 10.1.163

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.161",
+  "version": "10.1.163",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -27,8 +27,8 @@
     "clean": "npm run clean:server && npm run clean:client"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.6.5",
-    "@hatiolab/things-scene": "^10.1.85",
+    "@hatiolab/figure-model": "^0.6.6",
+    "@hatiolab/things-scene": "^10.1.86",
     "@material/web": "^2.0.0",
     "@operato/data-grist": "^10.0.0",
     "@operato/graphql": "^10.0.0",
@@ -42,10 +42,10 @@
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.0.0",
     "@things-factory/ai-assistant": "^10.1.161",
-    "@things-factory/figure-service": "^10.1.161",
-    "@things-factory/figure-viewer": "^10.1.155",
+    "@things-factory/figure-service": "^10.1.163",
+    "@things-factory/figure-viewer": "^10.1.163",
     "@things-factory/setting-base": "^10.1.159",
     "three": "^0.185.1"
   },
-  "gitHead": "d32fe0614ea40572787acd94e307cc18a681ab38"
+  "gitHead": "fe2a9c39294d64cd50e52b283105390bb0fa6cee"
 }

package/test/browser/product-page.check.mjs

@@ -698,7 +698,7 @@ describe('the catalogue preview', () => {
       product.forget()
       product.openDetail('a')
     })
-    await press('figure-detail-dock >>> footer button', 'edit')
+    await press('figure-detail-dock >>> button[edit]', 'edit')
     await until(() => product.navigations().length, 'the modeller opened')
     assert.deepEqual(await read(() => product.navigations().map(({ path, detailShown }) => ({ path, detailShown }))), [{ path: '/figure-modeller/a', detailShown: false }])
   })

package/test/browser/screen.check.mjs

@@ -1,5 +1,5 @@
 /*
- * The modeller's screen in a real browser: its frame (three panes, the side's six tabs, the bar over the work), a new
+ * The modeller's screen in a real browser: its frame (three panes, the side's seven tabs, the bar over the work), a new
  * figure's first minute, the side panel as parts are chosen, the view tab, the preview, the verdict tab and the card's
  * picture -- each read as a person meets it, after doing what a person does (a click, a key, a narrower window).
  *
@@ -150,7 +150,7 @@ describe('the verdict tab over a figure, as the modeller page mounts it', () =>
   })
 })
 
-describe('the frame: parts · canvas · one side of six tabs, and the bar over the work', () => {
+describe('the frame: parts · canvas · one side of seven tabs, and the bar over the work', () => {
   before(() => mount('box'))
 
   test('three panes: the parts list on the left, the canvas in the middle, the side on the right -- one side, nothing under the canvas', async () => {
@@ -185,13 +185,13 @@ describe('the frame: parts · canvas · one side of six tabs, and the bar over t
     assert.equal(await read(() => getComputedStyle(screenCheck.editor()).containerType), 'inline-size')
   })
 
-  test('the side\'s six tabs, in order, each saying its name under its icon -- the name it is read by', async () => {
+  test('the side\'s seven tabs, in order, each saying its name under its icon -- the name it is read by', async () => {
     const tabs = await read(() =>
       [...screenCheck.editor().shadowRoot.querySelectorAll('aside button[tab]')].map(b => ({ label: b.getAttribute('aria-label'), shows: b.querySelector('span[tab-label]')?.textContent.trim() }))
     )
     assert.deepEqual(
       tabs.map(t => t.label),
-      ['properties', 'capability', 'motion', 'verdict', 'view', 'history'].map(TAB)
+      ['properties', 'capability', 'motion', 'data', 'verdict', 'view', 'history'].map(TAB)
     )
     for (const tab of tabs) assert.equal(tab.shows, tab.label, `${tab.label} shows its name`)
     assert.equal(await read(() => screenCheck.editor().shadowRoot.querySelector('aside').firstElementChild.matches('div[tabs]')), true, 'the tabs are the side\'s first row')
@@ -200,15 +200,15 @@ describe('the frame: parts · canvas · one side of six tabs, and the bar over t
   test('a tab shows its panel and hides the others without taking them down -- the verdict keeps what it holds', async () => {
     const panels = () =>
       read(() => [...screenCheck.editor().shadowRoot.querySelectorAll('aside > div[panel]')].map(p => ({ seen: p.getBoundingClientRect().height > 0, connected: p.isConnected, verdict: !!p.querySelector('slot[name=verdict]') })))
-    const tabs = ['properties', 'capability', 'motion', 'verdict', 'view', 'history']
+    const tabs = ['properties', 'capability', 'motion', 'data', 'verdict', 'view', 'history']
     for (const [at, tab] of tabs.entries()) {
       await pressTab(TAB(tab))
       await until(`${tab} on`, name => screenCheck.editor().shadowRoot.querySelector('button[tab][on]')?.getAttribute('aria-label') === name, TAB(tab))
       const now = await panels()
-      assert.equal(now.length, 6, 'six panels, all standing')
+      assert.equal(now.length, 7, 'seven panels, all standing')
       assert.deepEqual(now.map(p => p.seen), tabs.map((_, i) => i === at), `${tab}: its panel seen, the rest hidden`)
       assert.ok(now.every(p => p.connected))
-      assert.ok(now[3].verdict, 'the verdict panel holds the verdict slot whichever tab is on')
+      assert.ok(now[tabs.indexOf('verdict')].verdict, 'the verdict panel holds the verdict slot whichever tab is on')
     }
     await pressTab(TAB('properties'))
   })

package/test/data-motion.test.ts

@@ -1,8 +1,8 @@
 /*
- * **데이터 속성 · 동작 그룹** (ADR-0051 §2.2 · §3.2, 2026-10-13).
+ * **데이터 형식 · 연결 · 동작 그룹** (ADR-0051 §8 · §3.2, 데이터 바인딩 설계 결정 4, 2026-10-15).
  *
  * 데이터 탭과 클립 패널이 고를 수 있게 내놓는 것과, 그 초안을 figure-model 이 받는지를 로봇 개(robotDogFigure) 위에서 본다.
- * 규칙은 커널의 것이다 -- 여기는 목록과 초안과 문구만 시험한다.
+ * 규칙은 커널의 것이고 데이터 읽기는 things-scene 의 것이다 -- 여기는 목록과 초안과 문구만 시험한다.
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
@@ -10,10 +10,25 @@ import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
 import { editFigurePart, quadrupedRobotFigure, robotDogFigure } from '@hatiolab/figure-model'
-import type { FigureAsset, FigureDataProperty } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureDataField } from '@hatiolab/figure-model'
 
 import { clipGroupsOf, freeGroupIdOf, groupEdit, undrivenOf } from '../client/modeller/clips.ts'
-import { connectionDraftOf, dataSampleOf, dataTargetsOf, freeDataIdOf, propertyDraftOf, sampleValueOf } from '../client/modeller/data-interface.ts'
+import {
+  accessorOfRow,
+  behaviorsOf,
+  bindingDraftOf,
+  fieldAt,
+  fieldOfKind,
+  fitsField,
+  freeIdOf,
+  motionWrittenByData,
+  portDraftOf,
+  sampleOf,
+  schemaWithField,
+  schemaWithoutField,
+  typedValueOf,
+  valueRowsOf
+} from '../client/modeller/data-interface.ts'
 import { editRefusalOf } from '../client/modeller/refusals.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
@@ -56,81 +71,159 @@ test('그룹 목록과 빈 클립 · 그룹 id 는 사람이 적은 이름에서
   assert.deepEqual([two.motionGroups![0]!.transitionSeconds, two.motionGroups![0]!.defaultClip], [0.5, 'walk'])
 })
 
-test('속성 종류마다 고를 수 있는 대상과, 첫 연결 초안을 커널이 받는다', () => {
-  const kinds = (kind: FigureDataProperty['kind']) => [...new Set(dataTargetsOf(DOG, kind).map(t => t.target.kind))]
-  assert.deepEqual(kinds('number'), ['state', 'motion-speed'])
-  assert.deepEqual(kinds('enum'), ['state', 'palette', 'motion-clip'])
-  let asset: FigureAsset = DOG
-  const load: FigureDataProperty = propertyDraftOf(asset, 'load level', 'number')
-  assert.deepEqual([load.id, load.kind], ['load-level', 'number'])
-  asset = editFigurePart(asset, { kind: 'set-data-property', property: { ...load, unit: 'deg', min: -30, max: 30 } as FigureDataProperty })
-  const hip = dataTargetsOf(asset, 'number').find(t => t.target.kind === 'state' && t.target.input === 'fl-hip')!
-  const draft = connectionDraftOf(asset, asset.dataInterface!.properties.find(p => p.id === 'load-level')!, hip)
-  assert.deepEqual(draft.transform, { kind: 'identity' }, '같은 단위는 그대로')
-  const cadence = asset.dataInterface!.properties.find(p => p.id === 'cadence')!
-  assert.deepEqual(connectionDraftOf(asset, cadence, hip).transform, { kind: 'affine', scale: 1, offset: 0 }, '다른 단위는 배율로 -- 단위를 짐작하지 않는다')
-  asset = editFigurePart(asset, { kind: 'set-data-connection', connection: draft })
-  /* 선택값 하나를 색에: 값마다 지금 색으로 시작한다. */
-  const mode = asset.dataInterface!.properties.find(p => p.id === 'mode')!
-  const body = dataTargetsOf(asset, 'enum').find(t => t.target.kind === 'palette' && t.target.token === 'palette.body')!
-  const colour = connectionDraftOf(asset, mode, body)
-  assert.deepEqual(colour.transform, { kind: 'lookup', cases: ['idle', 'walk', 'run'].map(when => ({ when, value: DOG.palette['palette.body'] })) })
-  editFigurePart(asset, { kind: 'set-data-connection', connection: colour })
-  assert.equal(freeDataIdOf(['mode', 'mode-2'], 'mode'), 'mode-3')
-  assert.equal(freeDataIdOf([], '배터리'), 'data', '영문 id 가 남지 않으면 data')
+/** The dog with one more top field, the way the data tab adds one. */
+const withField = (asset: FigureAsset, field: FigureDataField) => editFigurePart(asset, { kind: 'set-data-schema', schema: schemaWithField(asset.dataInterface!.schema, '', field) })
+const choice = (asset: FigureAsset, key: string) => behaviorsOf(asset).find(c => c.key === key)!
+const draft = (asset: FigureAsset, path: string, key: string) => bindingDraftOf(asset, accessorOfRow(path), fieldAt(asset.dataInterface!.schema, path)!, choice(asset, key))
+
+test('작동 목록: 이 Figure 가 할 수 있는 것 전부, 값의 종류마다 맞는 것만', () => {
+  const kinds = [...new Set(behaviorsOf(DOG).map(c => c.kind))]
+  assert.deepEqual(kinds, ['state', 'palette', 'motion-clip', 'motion-speed', 'motion-paused', 'status', 'pose', 'items'])
+  const fits = (field: FigureDataField) => [...new Set(behaviorsOf(DOG).filter(c => fitsField(field, c)).map(c => c.kind))]
+  assert.deepEqual(fits({ name: 'n', kind: 'number' }), ['state', 'palette', 'motion-clip', 'motion-speed', 'status', 'pose', 'items'])
+  assert.deepEqual(fits({ name: 'b', kind: 'boolean' }), ['state', 'palette', 'motion-clip', 'motion-speed', 'motion-paused'])
+  assert.deepEqual(fits({ name: 'o', kind: 'object', fields: [] }), [])
+  assert.deepEqual(fits({ name: 'l', kind: 'list', item: { kind: 'object', fields: [] } }), ['items'])
+})
+
+test('첫 연결 초안: 맞으면 값 그대로, 범위·단위만 다르면 배율, 닫힌 값은 값마다 -- 커널이 받는다', () => {
+  let asset = withField(DOG, { name: 'lean', kind: 'number', unit: 'deg', min: -30, max: 30 })
+  const lean = draft(asset, 'lean', 'state:fl-hip')
+  assert.deepEqual([lean.id, lean.rule, lean.param], ['lean-fl-hip', 'value', undefined], '같은 단위·범위 안은 그대로')
+  asset = editFigurePart(asset, { kind: 'set-data-binding', binding: lean })
+  /* 0~100 % 를 배속 0~3 에 -- 범위를 겹쳐 놓는 배율. */
+  asset = withField(asset, { name: 'pct', kind: 'number', min: 0, max: 100 })
+  const pct = draft({ ...asset, dataInterface: { ...asset.dataInterface!, bindings: asset.dataInterface!.bindings.filter(b => b.id !== 'cadence-locomotion') } }, 'pct', 'motion-speed:locomotion')
+  assert.deepEqual([pct.rule, pct.param], ['scale', { scale: 0.03, offset: 0 }])
+  /* m 로 오는 위치는 mm 로. */
+  asset = withField(asset, { name: 'east', kind: 'number', unit: 'm' })
+  const east = draft({ ...asset, dataInterface: { ...asset.dataInterface!, bindings: asset.dataInterface!.bindings.filter(b => b.id !== 'at-x') } }, 'east', 'pose:x')
+  assert.deepEqual([east.rule, east.param], ['scale', { scale: 1000, offset: 0 }])
+  /* 닫힌 글자를 색에: 값마다 지금 색으로 시작한다. */
+  const body = draft(asset, 'mode', 'palette:palette.body')
+  assert.deepEqual([body.rule, body.param], ['map', Object.fromEntries(['idle', 'walk', 'run'].map(v => [v, DOG.palette['palette.body']]))])
+  editFigurePart(asset, { kind: 'set-data-binding', binding: body })
+  /* 열린 숫자를 색에: 구간마다, 그 밖은 지금 색. */
+  assert.deepEqual(draft(asset, 'lean', 'palette:palette.body').param, { default: DOG.palette['palette.body'] })
+  assert.equal(freeIdOf(['mode', 'mode-2'], 'mode'), 'mode-3')
+  assert.equal(freeIdOf([], '배터리'), 'binding', '영문 id 가 남지 않으면 binding')
+})
+
+test('아이템 연결: 목록 통째로, 요소의 id·자리 필드를 이름으로 짚는다', () => {
+  const asset = withField({ ...DOG, dataInterface: { ...DOG.dataInterface!, bindings: DOG.dataInterface!.bindings.filter(b => b.id !== 'back-load') } }, {
+    name: 'carriers',
+    kind: 'list',
+    item: { kind: 'object', fields: [{ name: 'carrierId', kind: 'text' }, { name: 'carrierType', kind: 'text' }, { name: 'slotNo', kind: 'text' }] }
+  })
+  const items = bindingDraftOf(asset, 'carriers', fieldAt(asset.dataInterface!.schema, 'carriers')!, choice(asset, 'items:'))
+  assert.deepEqual(items.behavior, { kind: 'items', id: 'carrierId', type: 'carrierType', place: 'slotNo' })
+  editFigurePart(asset, { kind: 'set-data-binding', binding: items })
 })
 
-test('샘플 값: 무엇을 움직이는지 커널의 평가로, 틀린 값 하나면 통째로 거절한다', () => {
-  const ok = dataSampleOf(DOG, { mode: 'run', cadence: 2, headAngle: 10, batteryLow: true })
-  assert.ok('result' in ok)
+test('데이터 형식 트리: 필드를 아래에 더하고, 지우고, 종류를 바꾼다 -- 원본은 그대로', () => {
+  const schema = DOG.dataInterface!.schema
+  const more = schemaWithField(schema, 'load[]', { name: 'weight', kind: 'number', unit: 'kg' } as FigureDataField)
+  assert.equal(fieldAt(more, 'load[].weight')?.kind, 'number')
+  assert.equal(fieldAt(schema, 'load[].weight'), undefined, '원본 형식은 바뀌지 않는다')
+  assert.equal(fieldAt(schemaWithoutField(more, 'load[].weight'), 'load[].weight'), undefined)
+  assert.deepEqual(fieldOfKind({ name: 'heading', label: '방향', kind: 'number', unit: 'deg' }, 'text'), { name: 'heading', label: '방향', kind: 'text' })
+  /* 읽는 연결이 있는 필드를 지우면 커널이 거절한다. */
+  assert.match(refusalOf(() => editFigurePart(DOG, { kind: 'set-data-schema', schema: schemaWithoutField(schema, 'mode') })), /^figure\.text\.data-accessor-invalid-absent .*"accessor":"mode"/)
+  /* 목록 밖 필드는 읽는 연결과 함께 이름이 바뀐다. */
+  const renamed = editFigurePart(DOG, { kind: 'rename-data-field', accessor: 'mode', to: 'MODE' })
+  assert.equal(renamed.dataInterface!.bindings.find(b => b.id === 'mode-locomotion')!.accessor, 'MODE')
+})
+
+test('샘플: 보드의 Figure 와 같은 읽기로 -- 무엇을 움직이는지, 틀린 값이 있으면 통째로 거절', () => {
+  const ok = sampleOf(DOG, { mode: 'run', cadence: 2, headAngle: 10, batteryLow: true, status: 'RUN', position: { x: 100, z: 50 }, heading: 90, load: [{ id: 'B1', slot: 't1_s1' }] })
+  assert.deepEqual(ok.issues, [])
   assert.deepEqual(JSON.parse(JSON.stringify(ok.result.motion)), { locomotion: { clip: 'run', speed: 2 } })
-  const bad = dataSampleOf(DOG, { mode: 'run', headAngle: 90 })
-  assert.ok('issues' in bad)
-  assert.deepEqual(bad.issues.map(i => `${i.property} ${i.reason}`), ['headAngle out-of-range'])
-  const mode = DOG.dataInterface!.properties.find(p => p.id === 'mode')!
-  const low = DOG.dataInterface!.properties.find(p => p.id === 'batteryLow')!
-  const cadence = DOG.dataInterface!.properties.find(p => p.id === 'cadence')!
-  assert.deepEqual([sampleValueOf(mode, 'walk'), sampleValueOf(low, 'false'), sampleValueOf(cadence, '0')], ['walk', false, 0])
-  assert.ok(Number.isNaN(sampleValueOf(cadence, '') as number), '빈 칸은 0 이 아니다')
+  assert.deepEqual(ok.result.status, { state: 'RUN' })
+  assert.deepEqual(ok.result.items.map(i => i.records), [[{ id: 'B1', place: 't1_s1' }]])
+  const bad = sampleOf(DOG, { mode: 'fly', headAngle: 90 })
+  assert.deepEqual(bad.issues.map(i => `${i.path} ${i.reason}`), ['mode value-unknown', 'headAngle out-of-range'])
+  /* 손으로 주는 값: 연결이 읽는 값 하나, 목록 밖. */
+  assert.deepEqual(valueRowsOf(DOG).map(r => r.path), ['mode', 'cadence', 'headAngle', 'batteryLow', 'status', 'position.x', 'position.z', 'heading'])
+  const row = (path: string) => valueRowsOf(DOG).find(r => r.path === path)!.node
+  assert.deepEqual([typedValueOf(row('mode'), 'walk'), typedValueOf(row('batteryLow'), 'false'), typedValueOf(row('cadence'), '0')], ['walk', false, 0])
+  assert.ok(Number.isNaN(typedValueOf(row('cadence'), '') as number), '빈 칸은 0 이 아니다')
+})
+
+test('상태 표시 초안: 첫 색 토큰에 -- 커널이 받는다', () => {
+  const port = portDraftOf(DOG, 'lamp')
+  assert.deepEqual(port, { id: 'lamp', label: 'lamp', tokens: ['palette.body'], parts: [] })
+  editFigurePart(DOG, { kind: 'set-status-port', port })
+  assert.equal(portDraftOf(DOG, 'state').id, 'state-2')
 })
 
 test('데이터 · 동작 거절은 커널 문장이 아니라 reason 과 값으로 말한다', () => {
-  assert.match(refusalOf(() => editFigurePart(DOG, { kind: 'remove-data-property', id: 'mode' })), /^figure\.text\.data-property-connected .*mode-locomotion/)
-  assert.match(refusalOf(() => editFigurePart(DOG, { kind: 'remove-driver', state: 'fl-knee' })), /^figure\.text\.driver-clip-required .*walk/)
   assert.match(
-    refusalOf(() => editFigurePart(DOG, { kind: 'set-data-connection', connection: { id: 'head-2', property: 'headAngle', transform: { kind: 'affine', scale: 2, offset: 0 }, target: { kind: 'state', input: 'head', sourceMode: 'observed' } } })),
-    /^figure\.text\.data-transform-range .*"min":"-90".*"low":"-45"/
+    refusalOf(() =>
+      editFigurePart(DOG, { kind: 'set-data-binding', binding: { id: 'head-2', accessor: 'headAngle', behavior: { kind: 'state', input: 'head', sourceMode: 'observed' }, rule: 'scale', param: { scale: 2, offset: 0 } } })
+    ),
+    /^figure\.text\.data-rule-range .*"min":"-90".*"low":"-45"/
+  )
+  assert.match(
+    refusalOf(() => editFigurePart(DOG, { kind: 'set-data-binding', binding: { id: 'lamp-2', accessor: 'mode', behavior: { kind: 'palette', token: 'palette.battery' }, rule: 'map', param: { default: '#000000' } } })),
+    /^figure\.text\.data-behavior-duplicate .*battery-colour/
   )
+  assert.match(refusalOf(() => editFigurePart(DOG, { kind: 'remove-status-port', id: 'state' })), /^figure\.text\.data-port-bound .*body-status/)
+  assert.match(refusalOf(() => editFigurePart(DOG, { kind: 'remove-driver', state: 'fl-knee' })), /^figure\.text\.driver-clip-required .*walk/)
   const lone = editFigurePart(quadrupedRobotFigure().asset, { kind: 'set-driver', state: 'fl-knee', clip: 'walk', duration: 1, keys: [{ seconds: 0, value: 0 }, { seconds: 1, value: 10 }] })
   assert.match(refusalOf(() => editFigurePart(lone, { kind: 'set-driver', state: 'fl-knee', clip: 'run', duration: 1, keys: [{ seconds: 0, value: 0 }, { seconds: 1, value: 10 }] })), /^figure\.text\.driver-writers /)
 })
 
+test('미리보기: 데이터가 정하는 그룹 필드는 그룹 칸이 아니라 데이터 값으로 움직인다 (2026-10-14, 로봇 개)', () => {
+  /* The dog's clip and speed are both written by data (mode, cadence): a clip chosen on the group moved nothing. */
+  assert.deepEqual(motionWrittenByData(DOG), { locomotion: { clip: true, speed: true } })
+  /* Only the speed bound: the clip stays the group's to choose. */
+  const speedOnly = { ...DOG, dataInterface: { ...DOG.dataInterface!, bindings: DOG.dataInterface!.bindings.filter(b => b.behavior.kind !== 'motion-clip') } }
+  assert.deepEqual(motionWrittenByData(speedOnly), { locomotion: { clip: false, speed: true } })
+  /* No data interface: every group field is the group's own. */
+  const { dataInterface: _gone, ...bare } = DOG
+  assert.deepEqual(motionWrittenByData(bare as FigureAsset), {})
+  const preview = read('../client/modeller/figure-preview.ts')
+  assert.match(preview, /tellInstances\('figureValues', this\.valuing\)/)
+  assert.match(preview, /byData\.clip\s*\? nothing/)
+  assert.match(preview, /byData\.speed\s*\? nothing/)
+})
+
 test('데이터 탭 · 클립 패널 · 미리보기의 배선과 문구', () => {
   const editor = read('../client/modeller/editor.ts')
   assert.match(editor, /renderTab\('data'/)
   assert.match(editor, /<figure-data-panel/)
   assert.match(editor, /\.sample=\$\{this\.dataSample\}/)
+  assert.match(editor, /this\.dataSample = e\.detail\.data/)
   const preview = read('../client/modeller/figure-preview.ts')
-  /* 라이브 스냅숏은 저장 모델이 아니라 Figure 의 figureData 접근자로 간다. */
-  assert.match(preview, /\.figureData = value/)
+  /* 샘플은 보드의 데이터 소스처럼 Figure 의 data 로 간다 -- 저장 모델에는 쓰지 않는다. */
+  assert.match(preview, /component\.set\?\.\('data', /)
+  assert.doesNotMatch(preview, /figureData/)
   assert.match(preview, /tellInstances\('motion'/)
   const clips = read('../client/modeller/figure-clips.ts')
   assert.match(clips, /kind: 'remove-driver', state: track\.state, clip: clip\.name/)
   /* A key's value is shown to three decimals: a slider's 14.399999999999999 is not what a person typed. */
   assert.match(clips, /value: current === undefined \? '' : shown\(current\)/)
   assert.match(clips, /\$\{key\.seconds\}s → \$\{shown\(key\.value\)\}/)
-  const keys = [read('../client/modeller/figure-data-panel.ts'), clips, read('../client/modeller/refusals.ts')].flatMap(src => [...src.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1]!))
-  /* Keys made from a value: each value the kernel can give has its words. */
+  const keys = [read('../client/modeller/figure-data-panel.ts'), clips, read('../client/modeller/refusals.ts')].flatMap(src =>
+    [...src.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1]!)
+  )
+  /* Keys made from a value: each value the kernel or the reader can give has its words. */
   const made = [
     /* The tab's short name, the one it shows under its icon (renderTab reads figure.label.tab-short-<tab>). */
     'figure.label.tab-short-data',
-    ...['number', 'boolean', 'enum'].map(k => `figure.label.data-kind-${k}`),
-    ...['state', 'palette', 'motion-clip', 'motion-speed'].flatMap(k => [`figure.label.data-target-${k}`, `figure.text.data-target-absent-${k}`]),
+    ...['number', 'boolean', 'text', 'object', 'list'].map(k => `figure.label.data-kind-${k}`),
+    ...['state', 'palette', 'motion-clip', 'motion-speed', 'motion-paused', 'status', 'pose', 'items'].map(k => `figure.label.data-behavior-${k}`),
+    ...['state', 'palette', 'motion-clip', 'motion-speed', 'motion-paused', 'status', 'items'].map(k => `figure.text.data-behavior-absent-${k}`),
+    ...['x', 'y', 'z', 'heading'].map(k => `figure.label.data-axis-${k}`),
+    ...['value', 'map', 'range', 'scale'].map(k => `figure.label.data-rule-${k}`),
+    ...['id', 'type', 'place', 'stack', 'status'].map(k => `figure.label.data-item-${k}`),
     ...['observed', 'commanded'].map(k => `figure.label.data-${k}`),
-    ...['label', 'unit', 'min', 'default', 'values'].map(k => `figure.text.data-property-invalid-${k}`),
-    ...['kind', 'unit', 'range', 'cases', 'output'].map(k => `figure.text.data-transform-${k}`),
+    ...['name', 'label', 'json', 'unit', 'min', 'max', 'default', 'values'].map(k => `figure.text.data-field-invalid-${k}`),
+    ...['syntax', 'absent', 'not-a-list', 'not-a-value', 'list-needs-index', 'item-id-required'].map(k => `figure.text.data-accessor-invalid-${k}`),
+    ...['kind', 'unit', 'range', 'cases', 'output', 'default'].map(k => `figure.text.data-rule-${k}`),
+    ...['label', 'token', 'part', 'group'].map(k => `figure.text.data-port-invalid-${k}`),
     ...['group-unknown', 'clip-not-in-group', 'speed-out-of-range', 'group-selection-required'].map(k => `figure.text.motion-setting-${k}`),
-    ...['not-a-record', 'property-unknown', 'type-mismatch', 'out-of-range', 'enum-unknown'].map(k => `figure.text.data-value-${k}`)
+    ...['not-a-record', 'not-a-list', 'type-mismatch', 'out-of-range', 'value-unknown', 'json-unreadable', 'item-id-missing'].map(k => `figure.text.data-value-${k}`)
   ]
   for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es']) {
     const table = JSON.parse(read(`../translations/${lang}.json`))

package/translations/en.json

@@ -1039,16 +1039,9 @@
   "figure.button.add-clip-to-group": "add a clip",
   "figure.text.motion-groups-explained": "Clips of one group play one at a time. For several clips to move the same control, put them in one group. A change of clip blends from the pose left to the new clip over the transition time.",
   "figure.label.tab-data": "data",
-  "figure.label.data-properties": "data properties",
-  "figure.text.data-properties-explained": "Values the site data gives this figure. A board maps its data onto these ids, never onto a part or an inner name.",
-  "figure.label.data-connections": "connections",
-  "figure.text.data-connections-explained": "What a data property moves: a control, a colour, or a motion group's clip and speed. Every value the property can take must land inside what the target takes.",
-  "figure.text.data-no-properties": "Add a data property first.",
   "figure.label.data-kind": "kind",
   "figure.label.data-kind-number": "number",
   "figure.label.data-kind-boolean": "true/false",
-  "figure.label.data-kind-enum": "choice",
-  "figure.label.data-id": "id",
   "figure.label.data-unit": "unit",
   "figure.label.data-min": "min",
   "figure.label.data-max": "max",
@@ -1056,51 +1049,124 @@
   "figure.label.data-values": "values (comma-separated)",
   "figure.label.data-true": "true",
   "figure.label.data-false": "false",
-  "figure.button.add-data-property": "add a data property",
-  "figure.button.remove-data-property": "remove the data property",
-  "figure.label.data-property": "data property",
-  "figure.label.data-target": "target",
-  "figure.label.data-target-state": "control {name}",
-  "figure.label.data-target-palette": "colour {name}",
-  "figure.label.data-target-motion-clip": "{name} clip",
-  "figure.label.data-target-motion-speed": "{name} speed",
-  "figure.button.add-data-connection": "add a connection",
-  "figure.button.remove-data-connection": "remove the connection",
   "figure.label.data-source-mode": "applies",
   "figure.label.data-observed": "measured (at once)",
   "figure.label.data-commanded": "commanded (travels at the sweep)",
-  "figure.label.data-transform": "transform",
-  "figure.label.data-identity": "as it is",
-  "figure.label.data-affine": "scale and offset",
   "figure.label.data-scale": "scale",
   "figure.label.data-offset": "offset",
   "figure.label.data-sample": "sample data",
-  "figure.text.data-sample-explained": "Try values to see what they move. Not saved. Applied to the preview, the preview's figure runs on them.",
+  "figure.text.data-sample-explained": "Enter one record as JSON to see what it moves. It is read the way a figure on a board reads its data, and not saved.",
+  "figure.text.data-sample-moves-all": "A position in the data moves every figure in the preview to it; on a board, figures given the same value stand in the same place too.",
   "figure.label.data-sample-in-preview": "apply to the preview",
-  "figure.text.data-value-not-a-record": "The sample is not a set of values.",
-  "figure.text.data-value-property-unknown": "{property} is not a data property of this figure.",
-  "figure.text.data-value-type-mismatch": "The value of {property} is of the wrong kind.",
-  "figure.text.data-value-out-of-range": "The value of {property} is outside its range.",
-  "figure.text.data-value-enum-unknown": "{property} does not take this value.",
+  "figure.label.data-schema": "data shape",
+  "figure.text.data-schema-explained": "The shape of the data a site sends this figure. Name each field as the site's data names it; group fields in objects and lists.",
+  "figure.label.data-bound": "{count} bound",
+  "figure.text.data-no-fields": "Add a field to the data shape first.",
+  "figure.label.data-name": "field name",
+  "figure.label.data-label": "display name",
+  "figure.label.data-json": "also read as JSON text",
+  "figure.label.data-item-kind": "element kind",
+  "figure.label.data-kind-text": "text",
+  "figure.label.data-kind-object": "object",
+  "figure.label.data-kind-list": "list",
+  "figure.button.add-data-field": "add a field",
+  "figure.button.add-data-child": "add a field under {parent}",
+  "figure.button.remove-data-field": "remove the field",
+  "figure.label.data-from-sample": "make from a sample",
+  "figure.text.data-from-sample-explained": "Paste one record of the site's data to guess its fields. Units, ranges and value lists are not guessed; set them after.",
+  "figure.text.data-not-json": "This is not JSON.",
+  "figure.text.data-guessed": "{count} fields found.",
+  "figure.text.data-guessed-replaces": "{count} fields found. Using them replaces the current data shape.",
+  "figure.button.data-use-guessed": "use this shape",
+  "figure.label.data-bindings": "bindings",
+  "figure.text.data-bindings-explained": "One data value moves one thing the figure does: as it is, one result per value, per interval, or scaled. Click a line to edit how.",
+  "figure.label.data-field": "data value",
+  "figure.label.data-behavior": "behaviour",
+  "figure.label.data-behavior-state": "control {name}",
+  "figure.label.data-behavior-palette": "colour {name}",
+  "figure.label.data-behavior-motion-clip": "{name} clip",
+  "figure.label.data-behavior-motion-speed": "{name} speed",
+  "figure.label.data-behavior-motion-paused": "{name} paused",
+  "figure.label.data-behavior-status": "status {name}",
+  "figure.label.data-behavior-pose": "position {name}",
+  "figure.label.data-behavior-items": "items {name}",
+  "figure.label.data-axis-x": "X",
+  "figure.label.data-axis-y": "height (Y)",
+  "figure.label.data-axis-z": "Z",
+  "figure.label.data-axis-heading": "heading",
+  "figure.label.data-rule": "rule",
+  "figure.label.data-rule-value": "as it is",
+  "figure.label.data-rule-map": "per value",
+  "figure.label.data-rule-range": "per interval",
+  "figure.label.data-rule-scale": "scale and offset",
+  "figure.label.data-seconds": "travel time (s)",
+  "figure.label.data-paused": "paused",
+  "figure.label.data-playing": "playing",
+  "figure.label.data-otherwise": "any other value",
+  "figure.label.data-range-from": "from",
+  "figure.label.data-range-to": "below",
+  "figure.button.add-data-range": "add an interval",
+  "figure.button.data-set-result": "set",
+  "figure.button.remove-data-range": "remove the interval",
+  "figure.label.data-item-id": "item id",
+  "figure.label.data-item-type": "item type",
+  "figure.label.data-item-place": "place",
+  "figure.label.data-item-stack": "stack order",
+  "figure.label.data-item-status": "status",
+  "figure.label.data-item-slot": "default place",
+  "figure.text.data-no-behavior": "Nothing of this figure can be moved by this value.",
+  "figure.button.add-data-binding": "add a binding",
+  "figure.button.remove-data-binding": "remove the binding",
+  "figure.label.data-ports": "status display",
+  "figure.text.data-ports-explained": "Where a status code shows. The board's status template picks the colour; here you choose the colour tokens that take it and the parts that blink or glow.",
+  "figure.label.data-port-tokens": "colour tokens",
+  "figure.label.data-port-parts": "parts",
+  "figure.button.add-data-port": "add a status display",
+  "figure.button.remove-data-port": "remove the status display",
+  "figure.label.data-items-count": "{count} items",
+  "figure.text.data-value-not-a-list": "{path}: not a list.",
+  "figure.text.data-value-value-unknown": "{path}: not one of its values.",
+  "figure.text.data-value-json-unreadable": "{path}: the JSON text cannot be read.",
+  "figure.text.data-value-item-id-missing": "{path}: the item has no id.",
+  "figure.text.data-field-invalid-name": "A field name starts with a letter or _, then letters, digits, _ and -.",
+  "figure.text.data-field-invalid-label": "Write a display name, or leave it empty.",
+  "figure.text.data-field-invalid-json": "Only an object or a list may come as JSON text.",
+  "figure.text.data-field-invalid-unit": "The unit is not one the figure knows.",
+  "figure.text.data-field-invalid-min": "Write the range from the smaller number to the larger.",
+  "figure.text.data-field-invalid-max": "Write the max as a number.",
+  "figure.text.data-field-invalid-default": "The default must lie in the range or the value list.",
+  "figure.text.data-field-invalid-values": "The value list needs one or more values, each once.",
+  "figure.text.data-field-duplicate": "There is already a field {name}.",
+  "figure.text.data-accessor-invalid-syntax": "{accessor} is not a data path.",
+  "figure.text.data-accessor-invalid-absent": "The data shape has no field {accessor}.",
+  "figure.text.data-accessor-invalid-not-a-list": "{accessor} is not a list.",
+  "figure.text.data-accessor-invalid-not-a-value": "{accessor} is not one value; choose a field under it.",
+  "figure.text.data-accessor-invalid-list-needs-index": "{accessor} is a list; choose a value of one element.",
+  "figure.text.data-accessor-invalid-item-id-required": "A list of items needs an id field in each element.",
+  "figure.text.data-behavior-absent-state": "This figure has no control {id}.",
+  "figure.text.data-behavior-absent-palette": "This figure has no colour {id}.",
+  "figure.text.data-behavior-absent-motion-clip": "There is no motion group {id}.",
+  "figure.text.data-behavior-absent-motion-speed": "There is no motion group {id}.",
+  "figure.text.data-behavior-absent-motion-paused": "There is no motion group {id}.",
+  "figure.text.data-behavior-absent-status": "There is no status display {id}.",
+  "figure.text.data-behavior-absent-items": "There is no place {id}.",
+  "figure.text.data-behavior-duplicate": "The bindings {a} and {b} both move {id}; one binding per behaviour.",
+  "figure.text.data-rule-kind": "This rule does not fit this value and behaviour.",
+  "figure.text.data-rule-unit": "The units differ ({from} → {to}); convert with scale and offset.",
+  "figure.text.data-rule-range": "It gives {min} to {max}; the behaviour takes {low} to {high}.",
+  "figure.text.data-rule-cases": "{value} is not one of this value's values.",
+  "figure.text.data-rule-output": "{value} is not something the behaviour takes.",
+  "figure.text.data-rule-default": "Set a result for any other value, so every value has one.",
+  "figure.text.data-port-invalid-label": "Write a name for the status display.",
+  "figure.text.data-port-invalid-token": "Choose one or more of this figure's colour tokens or parts.",
+  "figure.text.data-port-invalid-part": "{id} is not a part of this figure.",
+  "figure.text.data-port-invalid-group": "There is no motion group {id}.",
+  "figure.text.data-port-bound": "First remove the bindings that read the status display {port}: {bindings}.",
+  "figure.text.data-value-not-a-record": "{path}: not an object.",
+  "figure.text.data-value-type-mismatch": "{path}: the value is of the wrong kind.",
+  "figure.text.data-value-out-of-range": "{path}: outside its range.",
   "figure.text.data-id-invalid": "The id {id} cannot be used: a letter first, then letters, digits, - and _.",
   "figure.text.data-id-duplicate": "The id {id} is already used.",
-  "figure.text.data-property-invalid-label": "Give {property} a name.",
-  "figure.text.data-property-invalid-unit": "The unit of {property} is not a unit.",
-  "figure.text.data-property-invalid-min": "The range of {property} runs from a smaller number to a larger one.",
-  "figure.text.data-property-invalid-default": "The default of {property} must be within its range or its values.",
-  "figure.text.data-property-invalid-values": "The values of {property} are one or more, each once.",
-  "figure.text.data-property-absent": "{property} is not a data property of this figure.",
-  "figure.text.data-target-absent-state": "There is no control {id}. Remove the connection that writes it first.",
-  "figure.text.data-target-absent-palette": "There is no colour {id}.",
-  "figure.text.data-target-absent-motion-clip": "There is no motion group {id}.",
-  "figure.text.data-target-absent-motion-speed": "There is no motion group {id}.",
-  "figure.text.data-target-duplicate": "Connections {a} and {b} both write {id}; one connection per target.",
-  "figure.text.data-transform-kind": "This transform does not fit this property and target: a number goes as it is or scaled, a choice or true/false case by case.",
-  "figure.text.data-transform-unit": "The units differ ({from} → {to}). Say how one becomes the other with a scale and offset.",
-  "figure.text.data-transform-range": "It gives {min} to {max}; the target takes {low} to {high}.",
-  "figure.text.data-transform-cases": "Give each value once: {value} is missing, given twice, or not a value of the property.",
-  "figure.text.data-transform-output": "{value} is not a value the target takes.",
-  "figure.text.data-property-connected": "Remove the connections that read {property} first: {connections}.",
   "figure.text.motion-clip-absent": "{clip} is not a clip {group} can hold.",
   "figure.text.motion-clip-shared": "{clip} is already in {group}; a clip is in one group.",
   "figure.text.driver-writers": "Clips {clips} all move {state}. Clips that move one control go in one motion group.",