@things-factory/figure-ui 10.1.223 → 10.1.225

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/figure-assistant-surface.test.ts

@@ -95,7 +95,7 @@ test('a new figure keeps its creation id through a new figure\'s proposal and th
       return { id: q.id ?? q.creationId!, source: q.source }
     }
   })
-  session.startNew()
+  session.startNew({ name: 'New' })
   const creationId = session.read().creationId
   assert.match(creationId ?? '', /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/)
   const create: FigureApplyDetail = { key: K1, steps: lid, create: true }

package/test/first-save.test.ts

@@ -47,7 +47,7 @@ function recording() {
 test('타입은 새 피규어를 만드는 저장에만 실린다 — 이미 있는 피규어의 저장은 타입을 보내지 않는다', async () => {
   const { store, requests } = recording()
   const session = createFigureProductSession(store)
-  session.startNew()
+  session.startNew({ name: 'New' })
   await session.save({ type: 'agv-lifter' })
   assert.equal(requests[0]!.type, 'agv-lifter')
   assert.equal(requests[0]!.id, undefined, '만드는 저장')
@@ -61,7 +61,7 @@ test('타입은 새 피규어를 만드는 저장에만 실린다 — 이미 있
 test('타입을 주지 않으면 싣지 않는다 — 서버가 임시 이름을 붙인다', async () => {
   const { store, requests } = recording()
   const session = createFigureProductSession(store)
-  session.startNew()
+  session.startNew({ name: 'New' })
   await session.save()
   assert.equal('type' in requests[0]!, false)
 })

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/product-session.test.ts

@@ -28,7 +28,7 @@ test('existing model -> new clears geometry, ID, history and derived state', asy
   const s = createFigureProductSession(store)
   await s.open('A')
   assert.equal(s.read().geometry.length, 1)
-  const v = s.startNew()
+  const v = s.startNew({ name: 'New' })
   assert.equal(v.id, undefined)
   assert.equal(v.geometry.length, 0)
   assert.equal(v.canUndo, false)
@@ -46,7 +46,7 @@ test('late load cannot overwrite another model or a new figure', async () => {
   const p = deferred<FigureProductRecord>(),
     t = createFigureProductSession({ ...store, load: () => p.promise })
   const loading = t.open('A')
-  t.startNew()
+  t.startNew({ name: 'New' })
   p.resolve({ id: 'A', source: source() })
   await loading
   assert.equal(t.read().id, undefined)
@@ -95,10 +95,10 @@ test('save carries exact baseline and acknowledges only matching response', asyn
 test('pending save locks edits/navigation and duplicate create', async () => {
   const p = deferred<FigureProductRecord>(),
     s = createFigureProductSession({ ...store, save: () => p.promise })
-  s.startNew()
+  s.startNew({ name: 'New' })
   const text = s.source(),
     saving = s.save()
-  assert.throws(() => s.startNew())
+  assert.throws(() => s.startNew({ name: 'New' }))
   assert.throws(() => s.undo())
   await assert.rejects(s.save())
   p.resolve({ id: 'new', source: text })
@@ -124,7 +124,7 @@ test('retry after a lost create response reuses the same creation identity', asy
       return { id: q.creationId!, source: q.source }
     }
   })
-  s.startNew()
+  s.startNew({ name: 'New' })
   await assert.rejects(s.save())
   await s.save()
   assert.equal(keys.length, 2)

package/test/proposal-record.test.ts

@@ -67,14 +67,14 @@ test('a save names the proposals its text holds: undone, not; redone, again; und
 test('a new figure opened for a proposal is created under its key; one taken on the open new figure keeps its id', async () => {
   const { store, saves } = server()
   const s = createFigureProductSession(store)
-  s.startNew()
+  s.startNew({ name: 'New' })
   s.createUnder(K1)
   s.applyProposal(lid, s.read().revision!, s.read().context!, K1)
   await s.save({ type: 'LIDDED' })
   assert.equal(saves.at(-1)!.creationId, K1, 'created under the proposal key: taken twice, it meets the first figure')
   assert.deepEqual(saves.at(-1)!.proposalKeys, [K1])
 
-  s.startNew({ discard: true })
+  s.startNew({ discard: true, name: 'New' })
   const own = s.read().creationId
   const detail: FigureApplyDetail = { key: K2, steps: lid, create: true }
   assert.equal(takeFigureOffer(s, detail, { onSavedFigure: false, say }), true)
@@ -82,7 +82,7 @@ test('a new figure opened for a proposal is created under its key; one taken on
   assert.deepEqual({ creationId: saves.at(-1)!.creationId, proposalKeys: saves.at(-1)!.proposalKeys }, { creationId: own, proposalKeys: [K2] })
 
   /* A new figure the person has touched is theirs: the proposal is not put on it (NEW_FIGURE_UNSAVED), its id stays. */
-  s.startNew({ discard: true })
+  s.startNew({ discard: true, name: 'New' })
   s.command({ kind: 'rename', name: 'Mine' } as never)
   assert.throws(() => s.createUnder(K2))
   /* Nor on a saved one. */

package/test/revert-keeping.test.ts

@@ -50,7 +50,7 @@ test('the source a revert expects is what the server is confirmed to hold -- not
       return { id: q.id ?? 'a', source: row }
     }
   })
-  session.startNew()
+  session.startNew({ name: 'New' })
   assert.equal(session.confirmedSource(), undefined, 'nothing saved: nothing to revert over')
   await session.open('a')
   const loaded = row

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}`)
   }
 })