@things-factory/figure-ui 10.1.223 → 10.1.225

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.223",
+  "version": "10.1.225",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -18,7 +18,7 @@
   "scripts": {
     "build": "npm run build:server && npm run build:client",
     "test": "FIGURE_FREEZE_COMPILED=1 node --import ./test/resolve-ts-siblings.mjs --test test/*.test.ts",
-    "test:browser": "node --test test/browser/build.check.mjs test/browser/modeller.check.mjs test/browser/modeller-revision.check.mjs test/browser/editing.check.mjs test/browser/links.check.mjs test/browser/section.check.mjs test/browser/screen.check.mjs test/browser/product-page.check.mjs test/browser/parts.check.mjs test/browser/places-mesh.check.mjs test/browser/part-ids.check.mjs test/browser/fix-alignment.check.mjs test/browser/mesh-select.check.mjs test/browser/row-preview.check.mjs test/browser/detail-tabs.check.mjs test/browser/props.check.mjs test/browser/retire.check.mjs test/browser/namespace.check.mjs test/browser/public.check.mjs test/browser/category.check.mjs test/browser/property-section.check.mjs test/browser/list.check.mjs test/browser/item.check.mjs",
+    "test:browser": "node --test test/browser/build.check.mjs test/browser/modeller.check.mjs test/browser/modeller-revision.check.mjs test/browser/editing.check.mjs test/browser/links.check.mjs test/browser/section.check.mjs test/browser/screen.check.mjs test/browser/product-page.check.mjs test/browser/parts.check.mjs test/browser/places-mesh.check.mjs test/browser/part-ids.check.mjs test/browser/fix-alignment.check.mjs test/browser/mesh-select.check.mjs test/browser/row-preview.check.mjs test/browser/detail-tabs.check.mjs test/browser/props.check.mjs test/browser/retire.check.mjs test/browser/namespace.check.mjs test/browser/public.check.mjs test/browser/category.check.mjs test/browser/property-section.check.mjs test/browser/list.check.mjs test/browser/item.check.mjs test/browser/side-panel-sweep.check.mjs",
     "copy:files": "copyfiles -e \"./client/**/*.{ts,js,json}\" -u 1 \"./client/**/*\" dist-client",
     "build:client": "npm run copy:files && npx tsc --p ./client/tsconfig.json",
     "build:server": "npx tsc --p ./server/tsconfig.json",
@@ -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.223",
-    "@things-factory/figure-service": "^10.1.223",
-    "@things-factory/figure-viewer": "^10.1.222",
+    "@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": "868f2026b8373371ad04f42b0a097964d0d0ed0f"
+  "gitHead": "9929ca76f614ff84bea1f61dabe0e1b7f00cd18a"
 }

package/test/ai-proposal.test.ts

@@ -157,7 +157,7 @@ test('the same new figure\'s card in another tab before the first save makes a s
     })
   const made = [{ kind: 'add-part', part: { id: 'lid', kind: 'box', dimensions: { width: 100, height: 10, depth: 100 } } }] as any[]
   const first = tab()
-  first.startNew()
+  first.startNew({ name: 'New' })
   const detail: FigureApplyDetail = { key: K, steps: made, create: true }
   const here = { ...taker({}), offer: (d: FigureApplyDetail) => (takeFigureOffer(first, d, { onSavedFigure: false, say }), d) }
   assert.equal((await runFigureProposal(detail, here, say)).verdict, 'accepted')
@@ -166,7 +166,7 @@ test('the same new figure\'s card in another tab before the first save makes a s
   const there = {
     ...taker({}),
     async openNew(s: FigureProposalStep[], key?: string) {
-      second.startNew()
+      second.startNew({ name: 'New' })
       second.createUnder(key!)
       second.applyProposal(s, second.read().revision!, second.read().context!, key)
       return { applied: true }

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/browser/product-page.check.mjs

@@ -173,6 +173,11 @@ describe('the first save of a new figure', () => {
       return { first: popup.shadowRoot.querySelector('input')?.id, type: popup.shadowRoot.querySelector('#type').value, focused: active?.id }
     })
 
+  test('a new figure is named in the screen\'s words, the tab too (sweep 2026-10-27 U8)', async () => {
+    assert.equal(await read(() => product.page().session.read().name), 'figure.text.new-figure-name')
+    assert.equal(await read(() => product.page().context.title), 'figure.text.new-figure-name')
+  })
+
   test('before it is saved: the type can be written, held by the page, and the release waits', async () => {
     const field = await read(() => { const input = product.page().shadowRoot.querySelector('label[type-field] input'); return input && { disabled: input.disabled } })
     assert.deepEqual(field, { disabled: false })
@@ -242,6 +247,22 @@ describe('opening another figure', () => {
     })
   })
 
+  test('nothing open on the page: its properties say nothing of an empty figure (sweep 2026-10-27 U3)', async () => {
+    await open('a')
+    const empty = await read(async () => {
+      const page = product.page()
+      /* The state a page is in before it is told which figure, and after it is left: the session holds none. */
+      page.session.close()
+      const editor = product.deep('figure-editor')[0]
+      editor.requestUpdate()
+      await editor.updateComplete
+      return editor.shadowRoot.querySelectorAll('section[empty-figure]').length
+    })
+    /* Told another figure, the page opens it again: the checks after this one start from an open page. */
+    await open('b')
+    assert.equal(empty, 0)
+  })
+
   test('the row is emptied first: the type of the one before does not stand while the next one loads', async () => {
     const typeField = () => read(() => product.page().shadowRoot.querySelector('label[type-field] input')?.value)
     await open('a')
@@ -258,6 +279,10 @@ describe('opening another figure', () => {
     await until(() => !!window.letB, 'b asked for')
     await read(() => product.page().updateComplete)
     assert.equal(await typeField(), '')
+    /* Still loading, the figure is not an empty one: no 「add a part」 (sweep 2026-10-27 U3). */
+    await read(() => product.deep('figure-editor')[0].updateComplete)
+    assert.equal(await read(() => product.deep('figure-editor >>> section[empty-figure]').length), 0)
+    assert.equal(await read(() => product.page().context.title), 'figure.label.figure')
     await read(() => window.letB())
     await until(() => product.page().shadowRoot.querySelector('label[type-field] input')?.value === 'type-b', 'b\'s type')
   })

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

@@ -0,0 +1,182 @@
+/*
+ * What the modeller sweep of 2026-10-27 found on the side panel and the preview, in a real browser
+ * (operato-figure docs/audits/modeller-ux-sweep-2026-10-27.md, U1 U2 U4 U5 U6 U7): each as a person would meet it -- a
+ * box that reads as a box, a heading nothing is drawn over, a delete that looks like one, the empty animation said in
+ * its own words, a field added by Enter, the preview's values starting in one column and its help in the bar's look.
+ * The page loads no translations, so the words read are i18n keys.
+ *
+ * Run:  node --test test/browser/side-panel-sweep.check.mjs
+ */
+import { test, describe, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { addFigureBox, createFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
+
+import { buildPage } from './build.mjs'
+import { openPage } from './serve.mjs'
+
+const sleep = ms => new Promise(done => setTimeout(done, ms))
+
+let opened
+before(async () => {
+  opened = await openPage(await buildPage('links-page.js'))
+})
+after(async () => {
+  await opened?.close()
+})
+
+const page = () => opened.page
+const read = (fn, ...args) => page().evaluate(fn, ...args)
+const source = () => read(() => probe.source())
+const settled = () => read(() => document.querySelector('figure-editor').updateComplete)
+
+async function until(fn, args, what, ms = 8000) {
+  const deadline = Date.now() + ms
+  for (;;) {
+    const got = await read(fn, ...args)
+    if (got) return got
+    if (Date.now() > deadline) assert.fail(`waited for ${what}`)
+    await sleep(50)
+  }
+}
+async function mount(kind, text = null) {
+  await read((kind, text) => harness.mount(kind, text), kind, text)
+  await until(
+    () => {
+      try {
+        return probe.ids().some(id => !!probe.partOnPage(id))
+      } catch {
+        return false
+      }
+    },
+    [],
+    'the figure drawn in 3D',
+    15000
+  )
+}
+async function click(point, what) {
+  assert.ok(point, `${what} is on the page to click`)
+  await page().mouse.click(point.x, point.y)
+  await settled()
+}
+const tab = name => read(l => probe.tab(l), `figure.label.tab-short-${name}`)
+
+/** Every element matching the selector through every shadow root, shown on the page. */
+const DEEP = `(selector => {
+  const deep = (root = document) => [...root.querySelectorAll(selector)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+  return deep().filter(e => e.getBoundingClientRect().height > 0)
+})`
+
+describe('the side panel', () => {
+  before(() => mount('box'))
+
+  test('U1 the capability tab: the item box keeps its size beside its long note', async () => {
+    await click(await tab('capability'), 'the capability tab')
+    /* The note as Korean reads it: words that wrap (the key alone is one word that never does). */
+    const width = await read(DEEP => {
+      eval(DEEP)('label[item] em')[0].textContent = '홀더가 자리에 앉혀 나르는 물건의 모양입니다. 릴 · 트레이 · 매거진. 아이템 타입 표에서 이 피규어를 고를 수 있습니다.'
+      return eval(DEEP)('label[item] > input')[0]?.getBoundingClientRect().width
+    }, DEEP)
+    assert.ok(width >= 12, `the item box is ${width}px wide`)
+  })
+
+  test('U2 scrolled under the heading, the places chips are drawn below it, not over it', async () => {
+    /* A short window, so the panel scrolls. */
+    await page().setViewport({ width: 1400, height: 520 })
+    await click(await read(id => probe.row(id), 'box'), 'the box in the parts list')
+    await click(await tab('capability'), 'the capability tab')
+    const hit = await read(DEEP => {
+      const chips = eval(DEEP)('ox-input-select-buttons[places-by]')[0]
+      const subject = eval(DEEP)('div[subject]')[0]
+      if (!chips || !subject) return 'no chips or no heading'
+      let scroller = chips.parentNode
+      for (;;) {
+        if (!scroller) return 'nothing scrolls'
+        if (scroller instanceof ShadowRoot) scroller = scroller.host
+        else if (scroller instanceof Element && /auto|scroll/.test(getComputedStyle(scroller).overflowY) && scroller.scrollHeight > scroller.clientHeight) break
+        else scroller = scroller.parentNode
+      }
+      const head = subject.getBoundingClientRect()
+      const before = chips.getBoundingClientRect()
+      scroller.scrollTop += before.top - (head.top + head.height / 2) + 4
+      const at = chips.getBoundingClientRect()
+      const x = at.left + Math.min(40, at.width / 2),
+        y = at.top + 6
+      if (y > head.bottom || y < head.top) return `the chips stand at ${Math.round(y)}, the heading ${Math.round(head.top)}..${Math.round(head.bottom)}`
+      let el = document.elementFromPoint(x, y)
+      while (el?.shadowRoot) {
+        const inner = el.shadowRoot.elementFromPoint(x, y)
+        if (!inner || inner === el) break
+        el = inner
+      }
+      for (let n = el; n; n = n.parentNode instanceof ShadowRoot ? n.parentNode.host : n.parentNode) if (n === subject) return 'heading'
+      return el?.tagName.toLowerCase()
+    }, DEEP)
+    await page().setViewport({ width: 1400, height: 900 })
+    assert.equal(hit, 'heading')
+  })
+
+  test('U5 the motion tab: no animation yet is said in its own words, the controls\' words said once', async () => {
+    await click(await tab('motion'), 'the motion tab')
+    const hints = await read(DEEP => eval(DEEP)('p[hint]').map(p => p.textContent.trim()), DEEP)
+    assert.ok(hints.includes('figure.text.no-clips'), hints.join(' | '))
+    assert.equal(hints.filter(h => h === 'figure.text.no-controls').length, 1)
+  })
+
+  test('U6 the data tab: a field name and Enter adds the field', async () => {
+    await click(await tab('data'), 'the data tab')
+    await click(await read(() => look.at('input[aria-label="figure.label.data-name"]')), 'the field name')
+    await page().keyboard.type('speed')
+    await page().keyboard.press('Enter')
+    await settled()
+    await until(() => probe.source().dataInterface?.schema?.some(f => f.name === 'speed'), [], 'the field added')
+    assert.equal((await read(DEEP => eval(DEEP)('input[aria-label="figure.label.data-name"]')[0].value, DEEP)), '')
+  })
+
+  test('U4 a field opened: its delete is the bin, not a cross that reads as close', async () => {
+    await click(await read(() => look.at('button', 'speed')), 'the speed field')
+    const icon = await until(DEEP => eval(DEEP)('button[title="figure.button.remove-data-field"] md-icon')[0]?.textContent.trim(), [DEEP], 'the field opened')
+    assert.equal(icon, 'delete')
+    assert.ok((await source()).dataInterface.schema.some(f => f.name === 'speed'))
+  })
+})
+
+describe('the preview', () => {
+  /* A number and a text, of names far apart in length, each read by a table: the preview gives each a field. */
+  const asset = addFigureBox(createFigureAsset('Probe'), { id: 'box', size: { x: 400, y: 400, z: 400 }, position: { x: 0, y: 200, z: 0 } })
+  asset.dataInterface = {
+    version: 'figure-data-interface-2',
+    schema: [
+      { name: 'A', kind: 'number' },
+      { name: 'CARRIERSTATUS', kind: 'text' }
+    ],
+    bindings: [
+      { id: 'a', accessor: 'A', rule: 'table', lookup: 'ranges', targets: { parts: ['box'] }, table: { '~10': { color: '#ff0000' }, default: { color: '#0000ff' } } },
+      { id: 's', accessor: 'CARRIERSTATUS', rule: 'table', lookup: 'code', targets: { parts: ['box'] }, table: { X: { color: '#00ff00' } } }
+    ]
+  }
+  before(async () => {
+    await mount('box', serializeFigureAsset(asset))
+    await click(await read(() => probe.modeButton('preview')), 'the preview')
+    await until(DEEP => eval(DEEP)('figure-preview')[0]?.shadowRoot?.querySelectorAll('div[clips] input').length === 2, [DEEP], 'the two values in the preview')
+  })
+
+  test('U7 a number\'s field and a text\'s start in one column, whatever the names\' lengths', async () => {
+    const lefts = await read(DEEP => [...eval(DEEP)('figure-preview')[0].shadowRoot.querySelectorAll('div[clips] input')].map(i => Math.round(i.getBoundingClientRect().left)), DEEP)
+    assert.equal(lefts[0], lefts[1], `the fields start at ${lefts.join(' and ')}`)
+  })
+
+  test('U7 the size help\'s choice and button are in the bar\'s look, not the browser\'s grey', async () => {
+    const looks = await read(DEEP => {
+      const root = eval(DEEP)('figure-preview')[0].shadowRoot
+      return ['div[setup] select', 'div[setup] button', 'div[clips] input'].map(s => {
+        const c = getComputedStyle(root.querySelector(s))
+        return { radius: c.borderTopLeftRadius, background: c.backgroundColor }
+      })
+    }, DEEP)
+    assert.deepEqual(looks[0], looks[1])
+    assert.deepEqual(looks[0], looks[2])
+    assert.equal(looks[0].radius, '5px')
+    assert.notEqual(looks[0].background, 'rgb(239, 239, 239)')
+  })
+})

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