@things-factory/figure-ui 10.1.222 → 10.1.224

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.222",
+  "version": "10.1.224",
   "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.11.1",
-    "@hatiolab/things-scene": "^10.1.101",
+    "@hatiolab/figure-model": "^0.12.0",
+    "@hatiolab/things-scene": "^10.1.102",
     "@material/web": "^2.0.0",
     "@operato/data-grist": "^10.29.43",
     "@operato/graphql": "^10.29.43",
@@ -39,14 +39,14 @@
     "@operato/p13n": "^10.29.43",
     "@operato/popup": "^10.29.43",
     "@operato/shell": "^10.29.43",
-    "@operato/slot-layout-editor": "^10.29.43",
+    "@operato/slot-layout-editor": "^10.29.57",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.29.43",
-    "@things-factory/ai-assistant": "^10.1.222",
-    "@things-factory/figure-service": "^10.1.222",
-    "@things-factory/figure-viewer": "^10.1.222",
-    "@things-factory/setting-base": "^10.1.218",
+    "@things-factory/ai-assistant": "^10.1.223",
+    "@things-factory/figure-service": "^10.1.224",
+    "@things-factory/figure-viewer": "^10.1.224",
+    "@things-factory/setting-base": "^10.1.223",
     "three": "^0.185.1"
   },
-  "gitHead": "afdd6a9b1c8b440e39d4fec48bfbad1a0c02fccc"
+  "gitHead": "7edcdca6fc9862973e99048812e22f2aa9b2f9c9"
 }

package/test/browser/data-table-page.js

@@ -0,0 +1,9 @@
+/* Manual check of the data tab's tables (ADR-0166): the real editor on the robot dog, in Korean, over a store in memory. */
+import './modeller-page.js'
+import { i18next } from '@operato/i18n'
+import { robotDogFigure, serializeFigureAsset } from '@hatiolab/figure-model'
+
+const ko = await fetch('/ko.json').then(r => r.json())
+i18next.addResourceBundle('ko', 'translations', ko, true, true)
+await i18next.changeLanguage('ko')
+await window.harness.mount('dog', serializeFigureAsset(robotDogFigure().asset))

package/test/browser/links.check.mjs

@@ -350,13 +350,14 @@ describe('a row\'s pitch', () => {
 })
 
 describe('holding places on a part', () => {
-  test('a place needs kinds it takes; a figure that holds nothing says so, and declaring it holds things is one step', async () => {
+  test('a place takes any item until kinds are named; a figure that holds nothing says so, and declaring it holds things is one step', async () => {
     await mount('box')
     await pick('box')
     /* What the figure does is a tab again (user 2026-10-17). */
     await tab('capability')
-    assert.equal((await at('button[act]', 'figure.button.add-place'))?.disabled, true, 'no kinds: no place')
-    await type(await handle('input[placeholder="BOX, TOTE"]'), 'BOX')
+    /* No kinds named: it takes any item (ADR-0051 §4.1 decision 5, 2026-10-27). */
+    assert.equal((await at('button[act]', 'figure.button.add-place'))?.disabled, false, 'no kinds: a place for any item')
+    await type(await handle('input[placeholder="figure.text.place-accepts-any"]'), 'BOX')
     assert.equal((await at('button[act]', 'figure.button.add-place'))?.disabled, false, 'a kind: a place may be made')
     assert.equal((await all('p[hint]', 'figure.text.place-needs-holding')).length, 1, 'said: nothing is passed without holding')
     const start = await state()
@@ -365,6 +366,27 @@ describe('holding places on a part', () => {
     assert.ok((await source()).document.capabilities.names.includes('Capacity'))
     assert.deepEqual(await all('p[hint]', 'figure.text.place-needs-holding'), [], 'not said again')
   })
+
+  test('a place is changed under its own id: its types emptied, it takes any item, in one step', async () => {
+    let a = box(createFigureAsset('Gripper'), 'box', [200, 100, 200], [0, 50, 0])
+    a = applyFigureAuthoring(a, { kind: 'add-binding', id: 'box-grip-old', label: 'Grip', role: 'grip', part: 'box', face: 'top', accepts: ['BOX', 'WORKPIECE'], capacity: 1 })
+    await mount('box', a)
+    await pick('box')
+    await tab('capability')
+    await click(await at('button[edit-place]'), 'change the place')
+    const field = await handle('input[placeholder="figure.text.place-accepts-any"]')
+    assert.equal(await field.evaluate(i => i.value), 'BOX, WORKPIECE', 'its types are in the form')
+    await field.click({ clickCount: 3 })
+    await page().keyboard.press('Backspace')
+    await page().keyboard.press('Tab')
+    await settled()
+    const start = await state()
+    await click(await at('button[act]', 'figure.button.save-place'), 'save the place')
+    await oneStep(start)
+    const places = (await source()).document.capabilities.bindings
+    assert.deepEqual(places.map(b => [b.id, b.label, b.role, Object.hasOwn(b, 'accepts')]), [['box-grip-old', 'Grip', 'grip', false]])
+    assert.ok(await at('button[act]', 'figure.button.add-place'), 'the form adds again')
+  })
 })
 
 describe('a position worked out from the figure size', () => {

package/test/consumer-capabilities.test.ts

@@ -0,0 +1,116 @@
+/*
+ * A product's capabilities in the modeller (ADR-0167 3, 9, 12): the registered descriptors, what each still needs, its
+ * settings as the descriptor draws them, and the kernel taking what the panel writes.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+import { addFigureBox, addFigurePrimitive, createFigureAsset, editFigurePart } from '@hatiolab/figure-model'
+import { figureBindingsTakenOver, registerFigureCapability } from '@hatiolab/things-scene'
+import {
+  consumerDescriptors,
+  inputTableAt,
+  namesWith,
+  needsMissing,
+  partsAt,
+  settingsIssues,
+  settingsOf,
+  unknownConsumerNames,
+  withInputTable,
+  withParts
+} from '../client/modeller/consumer-capabilities.ts'
+
+const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
+const FILL = { key: 'fill', kind: 'input-table', label: '적재량', keys: ['FULL', 'EMPTY', 'EMPTYEMPTY'], start: { FULL: 100, EMPTY: 0, EMPTYEMPTY: 0 } } as const
+const CARRIER = {
+  name: 'acme.Carrier',
+  label: 'Carrier',
+  note: '캐리어',
+  version: '1',
+  needs: ['item'],
+  settings: [{ key: 'loadParts', kind: 'parts', label: '적재물', required: true }, FILL],
+  data: [{ name: 'EMPTYTYPE' }, { name: 'CARRIERSTATUS' }],
+  check: (settings: Record<string, unknown> | undefined) => (Array.isArray(settings?.loadParts) && settings.loadParts.length ? [] : ['적재물 부품을 고릅니다.'])
+} as never
+
+function reel() {
+  let asset = addFigurePrimitive(createFigureAsset('Reel'), { id: 'wound', kind: 'cylinder', dimensions: { radius: 400, length: 300 }, position: { x: 0, y: 400, z: 0 } })
+  asset.document.model.inputs.push({ id: 'fill', unit: 'percent', min: 0, max: 100, role: 'state' })
+  asset.stateDefaults['fill'] = 100
+  return asset
+}
+
+test('the registered products\' descriptors; one the figure wears that this modeller does not know is said', () => {
+  const off = registerFigureCapability(CARRIER)
+  try {
+    assert.deepEqual(consumerDescriptors().map(d => d.name), ['acme.Carrier'], 'the shared four are the ladder, not here')
+    const asset = editFigurePart(reel(), { kind: 'set-capabilities', names: ['acme.Carrier', 'other.Gauge'] })
+    assert.deepEqual(unknownConsumerNames(asset), ['other.Gauge'])
+  } finally {
+    off()
+  }
+})
+
+test('what a capability still needs: the item mark, a name; put on and off keeps the other names', () => {
+  const asset = reel()
+  assert.deepEqual(needsMissing(CARRIER, asset), ['item'])
+  assert.deepEqual(needsMissing(CARRIER, { ...asset, item: true }), [])
+  assert.deepEqual(needsMissing({ ...(CARRIER as object), needs: ['Holdable', ['Capacity', 'FlowNode']] } as never, asset), ['Holdable', 'Capacity | FlowNode'])
+  const held = editFigurePart(asset, { kind: 'set-capabilities', names: ['Capacity', 'Holdable'] })
+  assert.deepEqual(namesWith(held, 'acme.Carrier', true), ['Capacity', 'Holdable', 'acme.Carrier'])
+  assert.deepEqual(namesWith(editFigurePart(held, { kind: 'set-capabilities', names: namesWith(held, 'acme.Carrier', true) }), 'acme.Carrier', false), ['Capacity', 'Holdable'])
+})
+
+test('settings as the descriptor draws them: parts picked, an input with a value per fixed key; the kernel takes them', () => {
+  let asset = editFigurePart({ ...reel(), item: true }, { kind: 'set-capabilities', names: ['acme.Carrier'] })
+  assert.deepEqual(settingsIssues(CARRIER, asset), ['적재물 부품을 고릅니다.'])
+  let settings = withParts(settingsOf(asset, 'acme.Carrier'), 'loadParts', ['wound'])
+  assert.deepEqual(partsAt(settings, 'loadParts'), ['wound'])
+  /* No input yet: the fixed keys start at the descriptor's values. */
+  assert.deepEqual(inputTableAt(settings, FILL), { values: { FULL: 100, EMPTY: 0, EMPTYEMPTY: 0 } })
+  settings = withInputTable(settings, FILL, 'fill', { ...inputTableAt(settings, FILL).values, EMPTY: 5 })
+  assert.deepEqual(settings, { loadParts: ['wound'], fill: { input: 'fill', values: { FULL: 100, EMPTY: 5, EMPTYEMPTY: 0 } } })
+  asset = editFigurePart(asset, { kind: 'set-capability-settings', name: 'acme.Carrier', settings })
+  assert.deepEqual(settingsIssues(CARRIER, asset), [])
+  assert.deepEqual(inputTableAt(settingsOf(asset, 'acme.Carrier'), FILL), { input: 'fill', values: { FULL: 100, EMPTY: 5, EMPTYEMPTY: 0 } })
+  /* No input: the table goes; no parts: the key goes. */
+  assert.deepEqual(withInputTable(settings, FILL, undefined, {}), { loadParts: ['wound'] })
+  assert.deepEqual(withParts(settings, 'loadParts', []), { fill: settings.fill })
+})
+
+test('the panel writes through the kernel\'s commands, the ladder keeps a product\'s names, and every word is there', () => {
+  const panel = read('../client/modeller/figure-capability-panel.ts')
+  assert.match(panel, /kind: 'set-capability-settings', name: d\.name/)
+  assert.match(panel, /\[\.\.\.RUNGS\[which\], \.\.\.consumers\]/)
+  const keys = [read('../client/modeller/figure-capability-panel.ts'), read('../client/modeller/figure-data-panel.ts')].flatMap(src => [...src.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1]!)).filter(k => /product-capabilit|data-capability|data-add-selected-part/.test(k))
+  for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es']) {
+    const table = JSON.parse(read(`../translations/${lang}.json`))
+    for (const key of keys) assert.ok(table[key], `${lang}: ${key}`)
+  }
+})
+
+test('a binding a product capability takes over is marked where it rests, whole or for the targets named (ADR-0167 17)', () => {
+  const off = registerFigureCapability({ name: 'acme.Lamp', label: 'Lamp', note: '', version: '1', needs: [], takes: settings => ({ parts: (settings?.parts as string[]) ?? [] }) })
+  try {
+    let asset = addFigureBox(addFigureBox(createFigureAsset('Lamp post'), { id: 'head', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 450, z: 0 } }), { id: 'pole', size: { x: 20, y: 400, z: 20 }, position: { x: 0, y: 200, z: 0 } })
+    asset = editFigurePart(asset, { kind: 'set-capabilities', names: ['acme.Lamp'] })
+    asset = editFigurePart(asset, { kind: 'set-capability-settings', name: 'acme.Lamp', settings: { parts: ['head'] } })
+    asset = editFigurePart(asset, {
+      kind: 'set-data-binding',
+      schema: [{ name: 'mode', kind: 'text' }],
+      binding: { id: 'look', accessor: 'mode', rule: 'table', lookup: 'code', targets: { parts: ['head', 'pole'] }, table: { default: { color: '#111111' } } }
+    })
+    assert.deepEqual(figureBindingsTakenOver(asset), [{ id: 'look', capability: 'acme.Lamp', whole: false, parts: ['head'], inputs: [] }])
+  } finally {
+    off()
+  }
+  const panel = read('../client/modeller/figure-data-panel.ts')
+  assert.match(panel, /const resting = figureBindingsTakenOver\(asset\)/)
+  assert.match(panel, /resting\.filter\(r => r\.id === b\.id\)\.map\(r => this\.renderResting\(r\)\)/)
+  for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es']) {
+    const table = JSON.parse(read(`../translations/${lang}.json`))
+    for (const key of ['figure.text.data-binding-rests', 'figure.text.data-binding-rests-targets']) assert.match(table[key], /\{where\}.*\{name\}/, `${lang}: ${key}`)
+  }
+})

package/test/data-motion.test.ts

@@ -22,9 +22,16 @@ import {
   fieldOfKind,
   fitsField,
   freeIdOf,
+  legendRoleOf,
+  methodsOf,
   motionWrittenByData,
-  portDraftOf,
   rotationStepsOf,
+  schemaFollowingCodes,
+  tableColumnsOf,
+  tableDraftOf,
+  tableWithKeys,
+  tableWithLook,
+  tableWithTargets,
   sampleOf,
   schemaWithField,
   schemaWithoutField,
@@ -78,14 +85,24 @@ const withField = (asset: FigureAsset, field: FigureDataField) => editFigurePart
 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 가 할 수 있는 것 전부, 값의 종류마다 맞는 것만', () => {
+test('작동 목록과 방법: 값 그대로 · 배율이 움직일 수 있는 것, 칸 종류가 허락하는 방법만 (ADR-0166 2)', () => {
   const kinds = [...new Set(behaviorsOf(DOG).map(c => c.kind))]
-  assert.deepEqual(kinds, ['state', 'palette', 'motion-clip', 'motion-speed', 'motion-paused', 'status', 'pose', 'items'])
+  assert.deepEqual(kinds, ['state', 'palette', 'motion-clip', 'motion-speed', 'motion-paused', '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: 'n', kind: 'number' }), ['state', 'motion-speed', 'pose', 'items'])
+  assert.deepEqual(fits({ name: 'b', kind: 'boolean' }), ['motion-paused'])
+  assert.deepEqual(fits({ name: 'g', kind: 'text', values: ['idle', 'walk'] }), ['motion-clip', 'items'], '클립 이름만 든 닫힌 글자는 클립 그대로')
+  assert.deepEqual(fits({ name: 't', kind: 'text', values: ['RUN', 'DOWN'] }), ['items'])
   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: 'text' }, choices), ['value', 'code'])
+  assert.deepEqual(methodsOf({ kind: 'boolean' }, choices), ['value', 'code'])
+  assert.deepEqual(methodsOf({ kind: 'list', item: { kind: 'text' } }, choices), ['value'])
+  assert.deepEqual(methodsOf(null, choices), ['code', 'ranges'], '새 필드는 표가 만든다')
+  const plain = behaviorsOf({ ...DOG, motionGroups: undefined, drivers: undefined, document: { ...DOG.document, capabilities: {} } } as FigureAsset)
+  assert.deepEqual(methodsOf({ kind: 'boolean' }, plain), ['code'], '움직일 것이 없으면 코드 표만')
 })
 
 test('첫 연결 초안: 맞으면 값 그대로, 범위·단위만 다르면 배율, 닫힌 값은 값마다 -- 커널이 받는다', () => {
@@ -101,12 +118,6 @@ test('첫 연결 초안: 맞으면 값 그대로, 범위·단위만 다르면
   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')
 })
@@ -137,10 +148,16 @@ test('데이터 형식 트리: 필드를 아래에 더하고, 지우고, 종류
 })
 
 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' }] })
+  const ok = sampleOf(DOG, { mode: 'run', cadence: 2, headAngle: 10, batteryLow: true, status: 'ALARM', 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 } })
-  assert.deepEqual(ok.result.status, { state: 'RUN' })
+  assert.deepEqual(ok.result.parts.body, { color: '#e24b4a', effect: { kind: 'blink', hz: 2 } })
+  assert.deepEqual(ok.uses['body-status'], { value: 'ALARM', key: 'ALARM', source: 'figure' })
+  /* 견본 범례는 그 역할의 표를 통째로 대신한다: 모르는 코드는 맞는 줄 없음으로 말한다. */
+  const legend = sampleOf(DOG, { status: 'ALARM' }, { 'robot-condition': { RUN: '#22c55e' } })
+  assert.equal(legend.result.parts.body, undefined)
+  assert.deepEqual(legend.notes.map(n => n.reason), ['code-unmatched'])
+  assert.deepEqual(sampleOf(DOG, { status: 'RUN' }, { 'robot-condition': { RUN: '#22c55e' } }).uses['body-status'], { value: 'RUN', key: 'RUN', source: 'domain', legend: 'robot-condition' })
   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'])
@@ -151,11 +168,42 @@ test('샘플: 보드의 Figure 와 같은 읽기로 -- 무엇을 움직이는지
   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('표 초안: 닫힌 칸은 값마다 줄, 열린 칸은 줄 없이, 숫자는 한 구간 -- 새 필드는 표가 만든다 (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])
+  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'] })
+  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 b = asset.dataInterface!.bindings.find(x => x.id === 'emptytype')! as never
+  const grown = tableWithKeys(b, [['FULL', { color: '#3b6d11' }], ['EMPTY', {}]])
+  const schema = schemaFollowingCodes(asset, grown, ['FULL', 'EMPTY'])
+  assert.deepEqual(fieldAt(schema!, 'EMPTYTYPE'), { name: 'EMPTYTYPE', kind: 'text', values: ['FULL', 'EMPTY'] })
+  editFigurePart(asset, { kind: 'set-data-binding', binding: grown, schema })
+  assert.equal(schemaFollowingCodes(DOG, open.binding, ['RUN']), undefined, '열린 필드는 그대로')
+  assert.equal(legendRoleOf('Body_Status'), 'body-status')
+})
+
+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
+  assert.deepEqual(tableColumnsOf(free, draftTable).map(c => c.kind), ['color', 'effect', 'value', 'clip', 'speed', 'paused'])
+  const looked = tableWithLook(draftTable, 'run', { color: '#e24b4a', effect: { kind: 'blink' }, values: { 'fl-knee': 30 }, clip: 'run' })
+  editFigurePart(free, { kind: 'set-data-binding', binding: looked })
+  const fewer = tableWithTargets(looked, { inputs: ['fl-knee'] })
+  assert.deepEqual([fewer.targets, fewer.table.run], [{ inputs: ['fl-knee'] }, { values: { 'fl-knee': 30 } }])
+  editFigurePart(free, { kind: 'set-data-binding', binding: fewer })
+  /* 대상 밖의 열은 줄에 들어가지 않는다. */
+  assert.deepEqual(tableWithLook(fewer, 'walk', { color: '#000000', values: { 'fl-knee': 10, head: 5 } }).table.walk, { values: { 'fl-knee': 10 } })
 })
 
 test('「＋ 회전」: 끝없이 도는 관절에 쌓이는 클립·그룹·연결을 한 번에 -- 최대 rpm 이 배속 3', () => {
@@ -179,6 +227,11 @@ test('「＋ 회전」: 끝없이 도는 관절에 쌓이는 클립·그룹·연
   assert.deepEqual(spun.motionGroups, [{ id: 'j6-tool-roll-spin', label: '툴 회전', clips: ['j6-tool-roll-spin', 'j6-tool-roll-spin-reverse'], defaultClip: 'j6-tool-roll-spin', transitionSeconds: 0 }])
   /* 범위가 없던 속도 필드는 0..최대 rpm 으로. */
   assert.deepEqual(spun.dataInterface!.schema.find(f => f.name === 'rpm'), { name: 'rpm', kind: 'number', min: 0, max: 120 })
+  /* 켜짐·방향은 표: 켜짐은 멈춤을, 방향은 클립을 정한다. */
+  assert.deepEqual(
+    spun.dataInterface!.bindings.map(b => [b.id, b.rule]),
+    [['j6-tool-roll-spin-on', 'table'], ['j6-tool-roll-spin-speed', 'scale'], ['j6-tool-roll-spin-direction', 'table']]
+  )
   /* 120 rpm 이 배속 3, 60 rpm 이 1.5; REV 는 역회전, 꺼짐은 멈춤, 목록 밖 HOLD 는 정회전. */
   const at = (data: unknown) => JSON.parse(JSON.stringify(sampleOf(spun, data).result.motion))
   assert.deepEqual(at({ running: true, rpm: 120, dir: 'FWD' }), { 'j6-tool-roll-spin': { clip: 'j6-tool-roll-spin', speed: 3, paused: false } })
@@ -204,10 +257,17 @@ test('데이터 · 동작 거절은 커널 문장이 아니라 reason 과 값으
     /^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/
+    refusalOf(() => editFigurePart(DOG, { kind: 'set-data-binding', binding: { id: 'head-2', accessor: 'mode', rule: 'table', lookup: 'code', targets: { inputs: ['head'] }, table: { default: {} } } })),
+    /^figure\.text\.data-behavior-duplicate .*head-angle/
   )
-  assert.match(refusalOf(() => editFigurePart(DOG, { kind: 'remove-status-port', id: 'state' })), /^figure\.text\.data-port-bound .*body-status/)
+  const table = (t: object) => ({ id: 'look', accessor: 'mode', rule: 'table' as const, lookup: 'code' as const, targets: { parts: ['body'] }, table: { default: {} }, ...t })
+  assert.match(refusalOf(() => editFigurePart(DOG, { kind: 'set-data-binding', binding: table({ targets: {} }) })), /^figure\.text\.data-table-target-none /)
+  assert.match(refusalOf(() => editFigurePart(DOG, { kind: 'set-data-binding', binding: table({ targets: { parts: ['tail'] } }) })), /^figure\.text\.data-table-target-part .*"id":"tail"/)
+  assert.match(refusalOf(() => editFigurePart(DOG, { kind: 'set-data-binding', binding: table({ table: { run: { color: 'red' }, default: {} } }) })), /^figure\.text\.data-table-entry-color .*"key":"run"/)
+  assert.match(refusalOf(() => editFigurePart(DOG, { kind: 'set-data-binding', binding: table({ table: { default: { clip: 'run' } } }) })), /^figure\.text\.data-table-entry-column .*"key":"figure\.label\.data-otherwise.*"id":"clip"/)
+  assert.match(refusalOf(() => editFigurePart(DOG, { kind: 'set-data-binding', binding: table({ legend: { role: 'Body' } }) })), /^figure\.text\.data-legend-invalid .*"role":"Body"/)
+  const rate = editFigurePart(DOG, { kind: 'set-data-schema', schema: [...DOG.dataInterface!.schema, { name: 'RATE', kind: 'number' }] })
+  assert.match(refusalOf(() => editFigurePart(rate, { kind: 'set-data-binding', binding: table({ accessor: 'RATE', lookup: 'ranges', table: { '~30': {}, '20~': {} } }) })), /^figure\.text\.data-rule-overlap .*"value":"20~"/)
   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 /)
@@ -217,7 +277,7 @@ test('미리보기: 데이터가 정하는 그룹 필드는 그룹 칸이 아니
   /* 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') } }
+  const speedOnly = { ...DOG, dataInterface: { ...DOG.dataInterface!, bindings: DOG.dataInterface!.bindings.filter(b => b.rule === 'table' || 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
@@ -240,6 +300,9 @@ test('데이터 탭 · 클립 패널 · 미리보기의 배선과 문구', () =>
   /* 샘플은 보드의 데이터 소스처럼 Figure 의 data 로 간다 -- 저장 모델에는 쓰지 않는다. */
   assert.match(preview, /component\.set\?\.\('data', /)
   assert.doesNotMatch(preview, /figureData/)
+  /* A sample legend is the scene's, on its root container where a board's legends are -- not on the model's root. */
+  assert.match(preview, /container\.style = \{ \.\.\.this\.legends \}/)
+  assert.match(preview, /style: \{ \.\.\.this\.legends \}/)
   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/)
@@ -254,16 +317,20 @@ test('데이터 탭 · 클립 패널 · 미리보기의 배선과 문구', () =>
     /* 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', '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}`),
+    ...['state', 'palette', 'motion-clip', 'motion-speed', 'motion-paused', 'pose', 'items'].map(k => `figure.label.data-behavior-${k}`),
+    ...['state', 'palette', 'motion-clip', 'motion-speed', 'motion-paused', '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}`),
+    ...['value', 'scale', 'code', 'ranges'].map(k => `figure.label.data-method-${k}`),
+    ...['color', 'effect', 'values', 'clip', 'speed', 'paused'].map(k => `figure.label.data-column-${k}`),
+    ...['none', 'blink', 'glow'].map(k => `figure.label.data-effect-${k}`),
+    ...['none', 'part', 'input', 'group'].map(k => `figure.text.data-table-target-${k}`),
+    ...['color', 'effect', 'values', 'clip', 'speed', 'paused', 'column'].map(k => `figure.text.data-table-entry-${k}`),
+    ...['legend-absent', 'resolver-failed', 'not-a-table', 'not-an-interval', 'code-unmatched', 'not-a-look', 'not-taken'].map(k => `figure.text.data-note-${k}`),
     ...['id', 'type', 'place', 'stack', 'status'].map(k => `figure.label.data-item-${k}`),
     ...['observed', 'commanded'].map(k => `figure.label.data-${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}`),
+    ...['kind', 'unit', 'range', 'cases', 'output', 'default', 'overlap'].map(k => `figure.text.data-rule-${k}`),
     ...['group-unknown', 'clip-not-in-group', 'speed-out-of-range', 'group-selection-required'].map(k => `figure.text.motion-setting-${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}`)
   ]

package/test/links.test.ts

@@ -742,3 +742,18 @@ test('어깨는 축 둘 — 축 추가는 쓰지 않은 축으로 시작하고,
   )
   assert.notDeepEqual(turned({ 'arm-turn-2': 30 }), turned({}), '남은 축은 같은 조작값으로 움직인다')
 })
+
+test('상태에 따라 크기 — 지름으로 적은 두 끝이 반지름 명령이 되고, 읽어서 고정으로 되돌린다', async () => {
+  const { stateSizeCommandOf, stateSizeFixedOf, stateSizeIdFor, freshStateSize } = await import('../client/modeller/links.ts')
+  let asset = addFigurePrimitive(createFigureAsset('Roll'), { id: 'wound', kind: 'cylinder', dimensions: { radius: 450, length: 270 }, position: { x: 0, y: 500, z: 0 } })
+  assert.equal(stateSizeIdFor(asset, 'wound'), 'fill')
+  const form = { ...freshStateSize(), axis: 'x' as const, atMin: 200, atMax: 900 }
+  const command = stateSizeCommandOf(asset, 'wound', form, 2, 'fill')
+  assert.deepEqual(command, { kind: 'size-by-state', part: 'wound', axis: 'x', state: { id: 'fill', unit: 'percent', min: 0, max: 100 }, at: { min: 100, max: 450 } }, '지름 200 · 900 은 반지름 100 · 450')
+  assert.equal(stateSizeCommandOf(asset, 'wound', { ...form, atMin: NaN }, 2, 'fill'), undefined, '한 끝이 비면 보내지 않는다')
+  assert.equal(stateSizeCommandOf(asset, 'wound', { ...form, min: 100, max: 0 }, 2, 'fill'), undefined, '범위가 거꾸로면 보내지 않는다')
+  asset = applyFigureAuthoring(asset, command!)
+  assert.deepEqual(followOf(asset, 'wound', 'x'), { of: 'state', input: 'fill', at: { min: 100, max: 450 } })
+  assert.deepEqual(stateSizeFixedOf(asset, 'wound', 'x'), { kind: 'unlink-dimension', part: 'wound', axis: 'x', mm: 450 }, '쉬는 값(100 %)의 반지름으로 고정')
+  assert.equal(stateSizeFixedOf(asset, 'wound', 'y'), undefined)
+})

package/test/slot-layout-host.test.ts

@@ -15,9 +15,13 @@ import {
   figureSlotIssues,
   slotLayoutCommandOf,
   slotLayoutFormOf,
+  placeMarksOf,
   slotMarksOf,
   slotPresetsOf,
-  SLOT_MARK
+  SLOT_MARK,
+  SLOT_MARK_CHOSEN,
+  startSizeOf,
+  anchorRoomOf
 } from '../client/modeller/slot-layout-host.js'
 import { editRefusalOf, slotLayoutRefusalOf } from '../client/modeller/refusals.js'
 
@@ -54,11 +58,13 @@ test("no layout yet: a form on the selected part's top, and the equipment preset
   assert.equal(slotPresetsOf([{ id: 'under', part: 'fork', face: 'bottom' }])[0]!.build(size, {}).tiers[0]!.mount, 'HANG')
 })
 
-test('the editor is told what figure-model asks beyond its own checks: every slot names a type', () => {
+test('the editor is told what figure-model asks beyond its own checks: a slot names its types or takes any item, never an empty list', () => {
   assert.deepEqual(figureSlotIssues(twoAcross()), [])
-  assert.deepEqual(figureSlotIssues(twoAcross([])), [{ code: 'ACCEPTS_REQUIRED', path: 'tiers[0].layout.slot.accepts' }])
+  assert.deepEqual(figureSlotIssues(twoAcross([])), [{ code: 'ACCEPTS_EMPTY', path: 'tiers[0].layout.slot.accepts' }])
   const custom: SlotLayout = { tiers: [{ ...twoAcross().tiers[0]!, layout: { pattern: 'CUSTOM', slots: [{ slotNo: 1, offset: { x: 0, z: 0 }, allowed: { width: 1, depth: 1, height: 1 } }] } }] }
-  assert.deepEqual(figureSlotIssues(custom), [{ code: 'ACCEPTS_REQUIRED', path: 'tiers[0].layout.slots[0].accepts' }])
+  assert.deepEqual(figureSlotIssues(custom), [])
+  const empty: SlotLayout = { tiers: [{ ...twoAcross().tiers[0]!, layout: { pattern: 'CUSTOM', slots: [{ slotNo: 1, offset: { x: 0, z: 0 }, allowed: { width: 1, depth: 1, height: 1 }, accepts: [] }] } }] }
+  assert.deepEqual(figureSlotIssues(empty), [{ code: 'ACCEPTS_EMPTY', path: 'tiers[0].layout.slots[0].accepts' }])
 })
 
 test('applied, it is one command that figure-model takes, and the figure reads back as the form it came from', () => {
@@ -91,6 +97,42 @@ test('the unfolded slots are drawn as boxes of what they allow, on the fork, nev
   assert.deepEqual(slotMarksOf(evaluation.bindings as never, undefined), [])
 })
 
+test('places held one by one are drawn too: a sized one as its box out of its face, one without as its face raised as high as a slot would start there, the selected part\'s in the primary colour', () => {
+  let asset = addFigureBox(createFigureAsset('Lift'), { id: 'plate', size: { x: 800, y: 50, z: 1000 }, position: { x: 0, y: 225, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'add-binding', id: 'seat', label: 'Seat', role: 'seat', part: 'plate', face: 'top', capacity: 1 } as never)
+  asset = applyFigureAuthoring(asset, { kind: 'add-binding', id: 'under', label: 'Under', role: 'grip', part: 'plate', face: 'bottom', capacity: 1 } as never)
+  asset = applyFigureAuthoring(asset, { kind: 'add-binding', id: 'side', label: 'Side', role: 'seat', part: 'plate', face: 'right', capacity: 1, region: { x: 100, y: 200, z: 300 } } as never)
+  const evaluation = compileFigureAsset(asset).evaluate()
+  const marks = placeMarksOf(evaluation.bindings as never, asset, evaluation.geometry as never) as any[]
+  assert.deepEqual(marks.map(m => m.id), [`${SLOT_MARK}:seat`, `${SLOT_MARK}:under`, `${SLOT_MARK}:side`])
+  const [seat, under, side] = marks
+  /* The plate's top, the figure's top: as wide and deep as the face, as high as its shorter side, standing on it. */
+  assert.deepEqual(seat.shape.extrusion.section.size, { x: 800, z: 1000 })
+  assert.deepEqual([seat.shape.extrusion.start, seat.shape.extrusion.end], [0, 800])
+  assert.equal(Math.round(seat.pose.t[1]), 250)
+  /* Its bottom: the same box, under the face. */
+  assert.deepEqual([under.shape.extrusion.start, under.shape.extrusion.end], [-800, 0])
+  assert.equal(Math.round(under.pose.t[1]), 200)
+  /* A sized place on the right face: its own box, out along +X. */
+  assert.equal(side.shape.extrusion.axis, 'x')
+  assert.deepEqual(side.shape.extrusion.section.size, { y: 200, z: 300 })
+  assert.deepEqual([side.shape.extrusion.start, side.shape.extrusion.end], [0, 100])
+  assert.ok(marks.every(m => m.material.token === SLOT_MARK && m.material.transparent))
+  const chosen = placeMarksOf(evaluation.bindings as never, asset, evaluation.geometry as never, 'plate') as any[]
+  assert.ok(chosen.every(m => m.material.token === SLOT_MARK_CHOSEN))
+  /* With room over the face -- a mast over a fork -- the place is as high as that room, as a slot would start. */
+  let mast = addFigureBox(createFigureAsset('Truck'), { id: 'fork', size: { x: 1000, y: 50, z: 800 }, position: { x: 0, y: 25, z: 0 } })
+  mast = addFigureBox(mast, { id: 'mast', size: { x: 100, y: 2000, z: 100 }, position: { x: 0, y: 1000, z: -600 } })
+  mast = applyFigureAuthoring(mast, { kind: 'add-binding', id: 'forks', label: 'Forks', role: 'seat', part: 'fork', face: 'top', capacity: 1 } as never)
+  const truck = compileFigureAsset(mast).evaluate()
+  const [forks] = placeMarksOf(truck.bindings as never, mast, truck.geometry as never) as any[]
+  assert.deepEqual([forks.shape.extrusion.start, forks.shape.extrusion.end], [0, 1950])
+  /* The slot layout's places are its own marks', not drawn twice. */
+  const slotted = applyFigureAuthoring(stacker(), slotLayoutCommandOf({ label: 'Forks', role: 'seat', anchors: [{ id: 'fork', part: 'fork', face: 'top' }] }, twoAcross(), '') as never)
+  const unfolded = compileFigureAsset(slotted).evaluate()
+  assert.deepEqual(placeMarksOf(unfolded.bindings as never, slotted, unfolded.geometry as never), [])
+})
+
 test('refusals are said from their details, never the kernel\'s sentence', () => {
   const refusal = (details: object) => Object.assign(new Error('KERNEL ENGLISH'), { code: 'X', details })
   assert.equal(slotLayoutRefusalOf(refusal({ reason: 'slot-anchor-not-flat', anchor: 'a', part: 'fork', face: 'front' }), say), 'figure.text.slot-anchor-not-flat{"anchor":"a","part":"fork"}')
@@ -101,6 +143,22 @@ test('refusals are said from their details, never the kernel\'s sentence', () =>
   assert.equal(editRefusalOf(Object.assign(refusal({ reason: 'slot-id-taken', slot: 't1_s1' }), { code: 'SLOT_LAYOUT' }), say), 'figure.text.slot-id-taken{"slot":"t1_s1"}')
 })
 
+test('where an author starts with no numbers: the first face, a slot as high as the room over it, the face\'s shorter side at the figure\'s top', () => {
+  const plain = stacker()
+  const anchors = [{ id: 'fork', part: 'fork', face: 'top' as const }]
+  const geometry = (asset: typeof plain) => compileFigureAsset(asset).evaluate().geometry as never
+  /* The fork is the stacker's top: no room over it, so the face's shorter side. */
+  assert.deepEqual(startSizeOf(anchors, anchorFacesOf(anchors, geometry(plain)), anchorRoomOf(anchors, geometry(plain))), { width: 1200, depth: 900, slotHeight: 900 })
+  /* A mast 1500 high behind it: the slot is as high as the room up to the mast's top. */
+  const masted = addFigureBox(plain, { id: 'mast', size: { x: 100, y: 1500, z: 100 }, position: { x: 0, y: 750, z: -500 } })
+  assert.deepEqual(startSizeOf(anchors, anchorFacesOf(anchors, geometry(masted)), anchorRoomOf(anchors, geometry(masted))), { width: 1200, depth: 900, slotHeight: 1450 })
+  assert.deepEqual(startSizeOf(anchors, {}, {}), {})
+  /* The panel gives the editor that size and starts it from the single slot. */
+  const panel = read('../client/modeller/figure-slot-layout-panel.ts')
+  assert.match(panel, /presetSize: startSizeOf\(form\.anchors, anchorFaces, anchorRoomOf\(form\.anchors, geometry\)\)/)
+  assert.match(panel, /startFrom: 'single'/)
+})
+
 test('the slot layout panel starts from presets that keep where they started as a record', () => {
   const [single] = slotPresetsOf([{ id: 'fork', part: 'fork', face: 'top' }])
   assert.deepEqual(single!.build({ width: 1200, depth: 900, slotHeight: 1000 }, {}).preset, { key: 'single', size: { width: 1200, depth: 900, slotHeight: 1000 }, params: {} })
@@ -110,7 +168,7 @@ test('the slot layout panel starts from presets that keep where they started as
 test('the places words are in every language', () => {
   for (const lang of ['en', 'es', 'ja', 'ko', 'ms', 'zh']) {
     const t = JSON.parse(read(`../translations/${lang}.json`))
-    for (const key of ['figure.label.places-one', 'figure.label.places-by-rule', 'figure.text.slot-accepts-required', 'figure.text.slot-anchor-not-flat', 'figure.text.slot-id-taken', 'figure.button.remove-slot-layout'])
+    for (const key of ['figure.label.places-one', 'figure.label.places-by-rule', 'figure.text.slot-accepts-empty-list', 'figure.text.slot-anchor-not-flat', 'figure.text.slot-id-taken', 'figure.button.remove-slot-layout'])
       assert.ok(t[key], `${lang} ${key}`)
   }
 })