@things-factory/figure-ui 10.1.152 → 10.1.153

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.152",
+  "version": "10.1.153",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -27,7 +27,7 @@
     "clean": "npm run clean:server && npm run clean:client"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.6.2",
+    "@hatiolab/figure-model": "^0.6.3",
     "@hatiolab/things-scene": "^10.1.83",
     "@material/web": "^2.0.0",
     "@operato/data-grist": "^10.0.0",
@@ -42,8 +42,8 @@
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.0.0",
     "@things-factory/ai-assistant": "^10.1.150",
-    "@things-factory/figure-service": "^10.1.151",
+    "@things-factory/figure-service": "^10.1.153",
     "three": "^0.185.1"
   },
-  "gitHead": "67dd923b0d431d726b7f60866bb005a3660852b3"
+  "gitHead": "54b3e985a55d5d0b01622d87f385f07518fb5d16"
 }

package/test/browser/fix-alignment.check.mjs

@@ -35,10 +35,21 @@ async function until(fn, args, what, ms = 8000) {
     await sleep(50)
   }
 }
-const settled = () => read(() => document.querySelector('figure-editor').updateComplete)
+/* The editor and the part's panels have drawn what they were last told: a read never meets the draw before. */
+const settled = () =>
+  read(async () => {
+    const deep = (s, root = document) => [...root.querySelectorAll(s)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(s, e.shadowRoot)))
+    const drawing = () => [document.querySelector('figure-editor'), ...deep('figure-links')].filter(Boolean)
+    for (let round = 0; round < 20; round++) {
+      await Promise.all(drawing().map(e => e.updateComplete))
+      if (!drawing().some(e => e.isUpdatePending)) return
+    }
+  })
+/** Pressed once it is on the page and the panels have drawn -- waited for, not looked up once. */
 async function click(selector, options = {}, what = selector) {
+  await settled()
+  await until((s, o) => !!findDeep(s, o), [selector, options], `${what} on the page`)
   const element = await page().evaluateHandle((s, o) => findDeep(s, o), selector, options)
-  assert.ok(await element.evaluate(e => !!e), `${what} is on the page`)
   await element.evaluate(e => e.scrollIntoView({ block: 'center' }))
   await element.click()
   await settled()

package/test/browser/links.check.mjs

@@ -101,6 +101,28 @@ const handle = (selector, test) =>
     selector,
     test
   )
+/**
+ * Pressed as the panels stand once drawn: no fastening panel with an update still to draw, then the element itself, not a
+ * point read before. A point read too early is pressed after the panel has moved under it (2026-10-11: the door leaf's
+ * "fasten" read, then its scroll put back a frame later, and the click fell on another button).
+ */
+async function press(selector, text, what = text ?? selector) {
+  await read(async () => {
+    const deep = (s, root = document) => [...root.querySelectorAll(s)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(s, e.shadowRoot)))
+    for (let round = 0; round < 20 && deep('figure-links').some(e => e.isUpdatePending); round++) await Promise.all(deep('figure-links').map(e => e.updateComplete))
+  })
+  const element = await page().evaluateHandle(
+    (selector, text) => {
+      const deep = (s, root = document) => [...root.querySelectorAll(s)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(s, e.shadowRoot)))
+      return deep(selector).find(e => text === undefined || e.textContent.replace(/\s+/g, ' ').trim().includes(text)) ?? null
+    },
+    selector,
+    text
+  )
+  assert.ok(await element.evaluate(e => !!e), `${what} is on the page`)
+  await element.click()
+  await settled()
+}
 /** Chooses an option of the select labelled `label`, as a person does: the select changes, once. */
 async function choose(label, value, selector = 'select') {
   const select = await handle(selector, label)
@@ -322,7 +344,7 @@ describe('a new fastening for a door leaf: seen before it is done', () => {
 
   test('started, it asks what to fasten to, with nothing chosen', async () => {
     await pick('leaf')
-    await click(await at('button[act]', 'figure.button.fasten-start'), 'fasten-start')
+    await press('button[act]', 'figure.button.fasten-start')
     /* The form is the panel's, drawn after the editor's update. */
     const target = await until(() => look.select('figure.label.target-part'), [], 'the fastening form')
     assert.deepEqual([target.value, target.options[0].text], ['', 'figure.label.target-part-placeholder'])
@@ -368,7 +390,7 @@ describe('a new fastening for a door leaf: seen before it is done', () => {
 
   test('"fasten it first" from the motion tab opens this part\'s fastening, as it is now, in view, on the properties tab', async () => {
     await pick('leaf')
-    await click(await at('button[act]', 'figure.button.fasten-start'), 'fasten-start')
+    await press('button[act]', 'figure.button.fasten-start')
     await choose('figure.label.target-part', 'frame')
     /* The panel scrolled back to its head, the fastening below the fold. */
     const panel = await at('section[fastening]')
@@ -406,6 +428,14 @@ describe('a new fastening for a door leaf: seen before it is done', () => {
   })
 })
 
+/*
+ * 정렬·간격 고치기 pressed as the panel stands once it has drawn: a point read before it has, then clicked, can land where
+ * the button was, and nothing happens.
+ */
+async function pressFixAlignment() {
+  await press('div[overhang] button[fix-alignment]', undefined, 'fix alignment')
+}
+
 describe('past the edge of the face a part is fastened to', () => {
   before(async () => {
     let a = fasten(box(createFigureAsset('Overhangs'), 'frame', [1000, 100, 400], [0, 50, 0]), 'frame', 'plane')
@@ -422,7 +452,7 @@ describe('past the edge of the face a part is fastened to', () => {
     await pick('out')
     await until(() => look.all('div[overhang] p', 'figure.text.overhang-out').length === 1, [], 'said past the edge')
     const start = await state()
-    await click(await at('div[overhang] button', 'figure.button.fix-alignment'), 'fix alignment')
+    await pressFixAlignment()
     await until(r => probe.state().revision === r + 1, [start.revision], 'one step')
     await until(() => look.all('div[overhang] p', 'figure.text.overhang-out').length === 0, [], 'no longer past the edge')
   })
@@ -436,7 +466,7 @@ describe('past the edge of the face a part is fastened to', () => {
     await pick('cap')
     await until(() => look.all('div[overhang] p', 'figure.text.overhang-unknown').length === 1, [], 'said not known')
     const start = await state()
-    await click(await at('div[overhang] button', 'figure.button.fix-alignment'), 'fix alignment')
+    await pressFixAlignment()
     await until(() => look.all('p[fix-note]', 'figure.text.fix-alignment-unmeasured').length === 1, [], 'why it cannot')
     assert.equal((await state()).revision, start.revision, 'nothing written')
   })
@@ -489,11 +519,8 @@ describe('a bench: what each part is fastened to, what detaching would do, a row
     await pick('lamp')
     assert.deepEqual((await all('details[row-fold]')).map(d => d.open), [false], 'folded')
     await read(() => look.hear('preview-command'))
-    /*
-      Clicked until it is open: the first click puts the focus in the row, which opens the fold, and the summary's own
-      toggle then closes it again -- two clicks open it (seen 2026-10-11).
-    */
-    for (let i = 0; i < 2 && !(await all('details[row-fold]'))[0].open; i++) await click(await at('details[row-fold] > summary'), 'the row')
+    /* One click opens it, and it stays open while the row is worked. */
+    await click(await at('details[row-fold] > summary'), 'the row')
     assert.deepEqual((await all('details[row-fold]')).map(d => d.open), [true], 'open while it is worked')
     await until(() => look.all('section[row] input[type=number]').length > 0, [], 'the pitch field in the open row')
     await type(await handle('section[row] input[type=number]'), '250')

package/test/browser/modeller.check.mjs

@@ -900,6 +900,31 @@ describe('the row section opens on one click', () => {
     await click(at)
     assert.equal(await summary.evaluate(s => s.parentElement.open), false, 'folded after a second')
   })
+
+  test('a part picked again: a fold opened at once stays open -- the folds kept for the part are put back first', async () => {
+    await mount('rollers')
+    await click(await read(() => probe.row('mark')))
+    await click(await read(() => probe.row('roller')))
+    const open = await read(async () => {
+      const deep = (selector, root = document) => [...root.querySelectorAll(selector)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(selector, e.shadowRoot)))
+      const editor = deep('figure-editor')[0]
+      /*
+        The panel is drawn for the part once the editor and its links have updated; a click can come any time after
+        that, before a frame is drawn. Here it comes right then.
+      */
+      editor.selected = 'mark'
+      await editor.updateComplete
+      await Promise.all(deep('figure-links').map(links => links.updateComplete))
+      await null
+      const summary = deep('details[row-fold] > summary')[0]
+      summary.click()
+      const fold = summary.parentElement
+      const opened = fold.open
+      await new Promise(done => requestAnimationFrame(() => requestAnimationFrame(done)))
+      return [opened, fold.open]
+    })
+    assert.deepEqual(open, [true, true], 'opened by the click, and still open a frame later')
+  })
 })
 
 test('the page raised no error', () => {

package/test/browser/parts-page.js

@@ -5,7 +5,7 @@
  * Only reading: every change the check makes goes through the mouse and the keyboard.
  */
 import './editing-page.js'
-import { addFigureBox, applyFigureAuthoring, createFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, proposeFigureOccupancy, serializeFigureAsset } from '@hatiolab/figure-model'
 
 const PALETTE = {
   'palette.dark': '#2b2b2b',
@@ -36,6 +36,14 @@ Object.assign(window.figures, {
     return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', face: 'bottom', to: { part: 'frame', face: 'top' } }))
   },
   /* A box with rounded corners: made from the box, still called what it is. */
+  /* A housing and a stray part on the floor, the space the figure takes declared from both. */
+  gate: () => {
+    let a = figure('Gate')
+    a = addFigureBox(a, { id: 'housing', size: { x: 300, y: 1000, z: 300 }, position: { x: 0, y: 500, z: 0 } })
+    a = addFigureBox(a, { id: 'stray', size: { x: 100, y: 100, z: 100 }, position: { x: 600, y: 50, z: 0 } })
+    for (const part of ['housing', 'stray']) a = applyFigureAuthoring(a, { kind: 'attach', part, face: 'bottom', to: { plane: 'mounting-plane' } })
+    return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' }))
+  },
   rounded: () => {
     let a = figure('Rounded')
     a = addFigureBox(a, { id: 'tray', size: { x: 600, y: 200, z: 400 }, position: { x: 0, y: 100, z: 0 } })

package/test/browser/parts.check.mjs

@@ -239,6 +239,28 @@ describe('a part renamed in its name field: one step, still selected; a name ref
   })
 })
 
+describe('a part in the declared space removed: at once, the space fitted to the parts left, and said so (2026-09-27)', () => {
+  test('one step, nothing asked, the space still declared, and one notice that it was fitted again', async () => {
+    await mount('box', 'gate')
+    await pick('stray')
+    const before = await revision()
+    const space = () => read(() => JSON.parse(document.querySelector('figure-editor').session.source()).occupancy ?? null)
+    const was = await space()
+    assert.ok(was, 'declared to begin with')
+    await click(await read(() => parts.op('remove-part')), 'remove')
+    assert.deepEqual(await ids(), ['housing'])
+    assert.equal(await revision(), before + 1, 'one step')
+    assert.equal(await read(() => editing.prompt()), null, 'nothing asked')
+    const now = await space()
+    assert.ok(now, 'the space is still declared')
+    assert.notDeepEqual(now, was, 'fitted to the part left')
+    const told = await read(() => editing.told())
+    assert.deepEqual(told.map(t => t.level), ['info'], JSON.stringify(told))
+    /* The page loads no translations: the words are the key. */
+    assert.ok(told[0].message.includes('figure.text.removal-space-refitted'), told[0].message)
+  })
+})
+
 describe('the list narrowed: the selected row keeps its name and its buttons in sight', () => {
   before(() => mount('box', 'three'))
   after(() => read(() => parts.narrow(0)))

package/test/browser/places-mesh.check.mjs

@@ -42,24 +42,38 @@ async function until(fn, args, what, ms = 8000) {
     await sleep(50)
   }
 }
-const settled = () => read(() => document.querySelector('figure-editor').updateComplete)
+/*
+ * Every element the check reads has drawn what it was last told: the editor, and the places panel and the shared slot
+ * layout editor inside it, which draw after the editor does -- awaited until none of them has a draw pending, so a read
+ * never meets the one before.
+ */
+const settled = () =>
+  read(async () => {
+    const deep = (s, root = document) => [...root.querySelectorAll(s)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(s, e.shadowRoot)))
+    const drawing = () => [document.querySelector('figure-editor'), ...deep('figure-links, figure-slot-layout-panel, ox-slot-layout-editor')].filter(Boolean)
+    for (let round = 0; round < 20; round++) {
+      await Promise.all(drawing().map(e => e.updateComplete))
+      if (!drawing().some(e => e.isUpdatePending)) return
+    }
+  })
 
 async function mount(asset) {
   await read(text => harness.mount('given', text), serializeFigureAsset(asset))
   await until(() => look.drawn().length > 0, [], 'the board is drawn')
 }
-/** The element `findDeep` finds, as a handle the mouse and keyboard act on. */
-const handle = (selector, options = {}) => page().evaluateHandle((s, o) => findDeep(s, o), selector, options)
+/** The element `findDeep` finds, once it is on the page -- waited for, not looked up once -- as a handle to act on. */
+async function handle(selector, options = {}, what = selector) {
+  await until((s, o) => !!findDeep(s, o), [selector, options], `${what} on the page`)
+  return page().evaluateHandle((s, o) => findDeep(s, o), selector, options)
+}
 async function click(selector, options = {}, what = selector) {
-  const element = await handle(selector, options)
-  assert.ok(await element.evaluate(e => !!e), `${what} is on the page`)
+  const element = await handle(selector, options, what)
   await element.evaluate(e => e.scrollIntoView({ block: 'center' }))
   await element.click()
   await settled()
 }
 async function type(selector, options, text) {
   const field = await handle(selector, options)
-  assert.ok(await field.evaluate(e => !!e), `${selector} is on the page`)
   await field.evaluate(e => e.scrollIntoView({ block: 'center' }))
   await field.click({ clickCount: 3 })
   await page().keyboard.type(text)
@@ -68,7 +82,6 @@ async function type(selector, options, text) {
 }
 async function choose(selector, options, value) {
   const select = await handle(selector, options)
-  assert.ok(await select.evaluate(e => !!e), `${selector} is on the page`)
   await select.select(value)
   await settled()
 }
@@ -120,7 +133,8 @@ describe('a GLB made into a mesh part', () => {
   })
 
   test('the file chooser takes GLB files', async () => {
-    assert.equal(await read(() => findDeep('input[mesh-file]').accept), '.glb,model/gltf-binary')
+    const input = await handle('input[mesh-file]', {}, 'the palette\'s file input')
+    assert.equal(await input.evaluate(i => i.accept), '.glb,model/gltf-binary')
   })
 
   test('a file with one node: uploaded, added at once as one step, named by the file, selected', async () => {
@@ -142,7 +156,7 @@ describe('a GLB made into a mesh part', () => {
     await read(a => meshServer.answer({ upload: a }), crane)
     const start = await state()
     await importFile()
-    await until(() => !!findDeep('figure-mesh-choice'), [], 'the question')
+    await until(() => (findDeep('figure-mesh-choice')?.shadowRoot?.querySelectorAll('li button').length ?? 0) === 3, [], 'the question and its three choices')
     const choices = await read(() => [...findDeep('figure-mesh-choice').shadowRoot.querySelectorAll('li button')].map(b => b.textContent.replace(/\s+/g, ' ').trim()))
     assert.equal(choices.length, 3)
     assert.match(choices[0], /^figure\.text\.mesh-whole-file/)
@@ -186,6 +200,7 @@ describe('places made by a rule: the shared slot layout editor on a part\'s face
     await pick('fork')
     const tab = await read(l => probe.tab(l), 'figure.label.tab-short-capability')
     await page().mouse.click(tab.x, tab.y)
+    await until(() => look.tab() === 'figure.label.tab-short-capability', [], 'the capability tab on')
     await settled()
   })
 
@@ -193,6 +208,7 @@ describe('places made by a rule: the shared slot layout editor on a part\'s face
     assert.equal(await has('figure-slot-layout-panel'), false)
     await click('md-filter-chip[data-value="rule"]', {}, 'the by-a-rule choice')
     await until(() => !!findDeep('ox-slot-layout-editor'), [], 'the editor')
+    await settled()
     assert.equal(await has('button[data-action="use-default"]'), false, 'no default: the figure\'s layout is the only one')
   })
 

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

@@ -10,6 +10,8 @@
 import { test, describe, before, after } from 'node:test'
 import assert from 'node:assert/strict'
 
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
+
 import { buildPage } from './build.mjs'
 import { openPage } from './serve.mjs'
 
@@ -203,7 +205,9 @@ describe('the first save of a new figure', () => {
     await until(() => !product.deep('figure-first-save').length, 'the question closed')
     await press('button[save]', 'save')
     await until(() => product.deep('figure-first-save')[0]?.shadowRoot.querySelector('#type'), 'asked again')
-    assert.equal((await firstSave()).type, 'my-lift')
+    /* Asked again, the name is focused again: the browser honours `autofocus` once per document. */
+    await until(() => { let a = document.activeElement; while (a?.shadowRoot?.activeElement) a = a.shadowRoot.activeElement; return a?.id === 'name' }, 'the name focused again')
+    assert.deepEqual(await firstSave(), { first: 'name', type: 'my-lift', focused: 'name' })
     await read(() => {
       const name = product.deep('figure-first-save >>> #name')[0]
       name.focus()
@@ -566,6 +570,42 @@ describe('the page around the figure: the shell, the dock, the properties', () =
   })
 })
 
+describe('a placement the figure\'s parts refuse, chosen on the properties tab (wall placement, 09-25)', () => {
+  /* A post standing on the floor's plane by its bottom: a wall takes the back face, so the wall is refused. */
+  const post = () => {
+    const a = addFigureBox(createFigureAsset('Post'), { id: 'post', size: { x: 100, y: 1000, z: 100 }, position: { x: 0, y: 500, z: 0 } })
+    return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'attach', part: 'post', face: 'bottom', to: { plane: 'mounting-plane' } }))
+  }
+  const placement = () =>
+    read(() => {
+      const select = product.deep('figure-modeller-page >>> figure-properties >>> select').find(s => s.previousElementSibling?.textContent.trim() === 'figure.label.figure-placement')
+      return select ? select.value : null
+    })
+  const revision = () => read(() => product.page().session.read().revision)
+
+  before(async () => {
+    await fresh()
+    await read(text => product.seed({ id: 'p', type: 'post', source: text }), post())
+    await open('p')
+  })
+
+  test('refused: nothing written, the reason said in words beside the tabs, and the list back on the placement it has', async () => {
+    assert.equal(await placement(), 'floor')
+    const start = await revision()
+    await read(() => {
+      const select = product.deep('figure-modeller-page >>> figure-properties >>> select').find(s => s.previousElementSibling?.textContent.trim() === 'figure.label.figure-placement')
+      select.value = 'wall'
+      select.dispatchEvent(new Event('change', { bubbles: true }))
+    })
+    const said = await until(() => product.deep('figure-modeller-page >>> p[fit-error]')[0]?.textContent.trim(), 'the refusal said')
+    /* Said from the kernel's details (ADR-0127): the page loads no translations, so the words are the key with its values. */
+    assert.match(said, /^figure\.text\./, said)
+    assert.ok(said.includes('post') && said.includes('back'), `names the part and the face the wall takes: ${said}`)
+    assert.equal(await revision(), start, 'nothing written')
+    assert.equal(await placement(), 'floor', 'the list says the placement the figure has')
+  })
+})
+
 describe('AI proposals reaching the page', () => {
   before(async () => {
     await fresh()
@@ -593,7 +633,7 @@ describe('AI proposals reaching the page', () => {
   test('a proposal that would stop a clip is refused whole, the clip named', async () => {
     const before = await read(() => product.view())
     const refused = await offer({ steps: [{ kind: 'remove-part', target: 'leaf' }], create: false, context: before.context, revision: before.revision })
-    assert.deepEqual({ applied: refused.applied, code: refused.code, clips: refused.clips }, { applied: false, code: 'CLIPS_DROPPED', clips: ['swing'] })
+    assert.deepEqual({ applied: refused.applied, code: refused.code, clips: refused.clips?.map(c => c.clip) }, { applied: false, code: 'CLIPS_DROPPED', clips: ['swing'] })
     const after = await read(() => product.view())
     assert.deepEqual({ source: after.source, revision: after.revision }, { source: before.source, revision: before.revision })
   })

package/test/browser/screen.check.mjs

@@ -287,6 +287,39 @@ describe('the frame: parts · canvas · one side of six tabs, and the bar over t
   })
 })
 
+describe('the editor is drawn in the shell\'s tokens (2026-09-27)', () => {
+  /* Set apart from any theme, so a colour read back can only have come from the token named. */
+  const TOKENS = { '--md-sys-color-secondary-container': 'rgb(1, 2, 3)', '--md-sys-color-on-secondary-container': 'rgb(4, 5, 6)', '--md-sys-color-primary': 'rgb(7, 8, 9)' }
+  before(async () => {
+    await mount('box')
+    await read(tokens => Object.entries(tokens).forEach(([name, value]) => screenCheck.editor().style.setProperty(name, value)), TOKENS)
+  })
+  after(() => read(tokens => Object.keys(tokens).forEach(name => screenCheck.editor().style.removeProperty(name)), TOKENS))
+
+  test('a pressed button is drawn in the container the shell matched for both themes', async () => {
+    await pressRow('box')
+    await press('the move tool', () => screenCheck.editor().shadowRoot.querySelector('button[tool][aria-label="figure.button.gizmo-translate"]'))
+    await until('the move tool pressed', () => screenCheck.editor().shadowRoot.querySelector('button[tool][aria-pressed="true"]'))
+    /* Off the button: under the pointer it is drawn as hovered. */
+    await page().mouse.move(0, 0)
+    const drawn = await read(() => {
+      const root = screenCheck.editor().shadowRoot
+      const tool = getComputedStyle(root.querySelector('button[tool][aria-pressed="true"]'))
+      const mode = getComputedStyle(root.querySelector('button[mode][aria-pressed="true"]'))
+      return { tool: { background: tool.backgroundColor, color: tool.color }, mode: { color: mode.color, border: mode.borderTopColor } }
+    })
+    assert.deepEqual(drawn, { tool: { background: 'rgb(1, 2, 3)', color: 'rgb(4, 5, 6)' }, mode: { color: 'rgb(4, 5, 6)', border: 'rgb(7, 8, 9)' } })
+  })
+
+  test('the side draws no edge of its own and stacks over nothing: the frame draws the line between panes', async () => {
+    const aside = await read(() => {
+      const style = getComputedStyle(screenCheck.editor().shadowRoot.querySelector('aside'))
+      return { zIndex: style.zIndex, borderLeft: style.borderLeftWidth }
+    })
+    assert.deepEqual(aside, { zIndex: 'auto', borderLeft: '0px' })
+  })
+})
+
 describe('a part chosen: each tab in its place, the figure-wide tabs give way, the list\'s root goes back', () => {
   before(() => mount('arm'))
 

package/test/clip-ai-proposal.test.ts

@@ -10,6 +10,7 @@ import { addFigureBox, applyFigureAuthoring, createFigureAsset, editFigurePart,
 
 import { createFigureProductSession } from '../client/modeller/product-session.js'
 import { runFigureProposal, takeFigureOffer, type FigureApplyDetail } from '../client/modeller/ai-proposal.js'
+import { clipLossOf } from '../client/modeller/refusals.js'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 const ko = JSON.parse(read('../translations/ko.json'))
@@ -45,7 +46,7 @@ test('a proposal that would stop a clip is refused whole: nothing written, nothi
   const out = await runFigureProposal({ steps, context: context!, revision: revision! }, pageOf(s), say)
   assert.equal(out.verdict, 'refused')
   assert.equal(out.errorCode, 'CLIPS_DROPPED')
-  assert.match(out.note!, /swing/)
+  assert.equal(out.note, say('figure.text.proposal-would-drop-clips', { clips: 'swing' }), 'said as the clips it would stop, not the kernel\'s English')
   assert.equal(s.source(), before, 'not even the rename before it: refused whole')
   assert.equal(s.read().revision, revision)
   assert.equal(s.read().dirty, false, 'nothing to save')
@@ -93,6 +94,8 @@ test('an AI proposal made while a person\'s consent is held is refused; clips, f
   s.withConsent({ dropClips: ['swing/open'], context: context!, revision: revision! }, () => takeFigureOffer(s, detail, { onSavedFigure: false, say }))
   assert.equal(detail.applied, false)
   assert.equal(detail.code, 'CLIPS_DROPPED')
+  /* Recorded as figure-model refused it, and read where every refusal is read. */
+  assert.deepEqual(clipLossOf(detail)?.map(c => `${c.clip} ${c.why}`), ['swing gone'])
   assert.equal(s.source(), before)
   assert.equal(s.read().revision, revision)
   assert.equal(s.read().dirty, false)

package/test/clip-consent.test.ts

@@ -10,6 +10,7 @@ import { fileURLToPath } from 'node:url'
 import { addFigureBox, applyFigureAuthoring, createFigureAsset, editFigurePart, parseFigureAsset, serializeFigureAsset, type FigureAsset } from '@hatiolab/figure-model'
 
 import { createFigureProductSession } from '../client/modeller/product-session.js'
+import { clipLossOf } from '../client/modeller/refusals.js'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 
@@ -37,9 +38,15 @@ test('refused and named first; agreed, exactly those go in one step; undo brings
   const s = createFigureProductSession(store)
   await s.open('doors')
   const revision = s.read().revision
-  assert.throws(() => s.command(fixed(s, 'left')), (e: { code?: string; clips?: Array<{ id: string; clip: string; why: string }> }) =>
-    e.code === 'CLIPS_DROPPED' && e.clips?.map(c => `${c.clip} ${c.why}`).join() === 'left-swing gone')
+  assert.throws(() => s.command(fixed(s, 'left')), (e: { code?: string; details?: { reason?: string; clips?: Array<{ id: string; clip: string; why: string }> } }) =>
+    e.code === 'CLIPS_DROPPED' && e.details?.reason === 'clips-dropped' && e.details.clips?.map(c => `${c.clip} ${c.why}`).join() === 'left-swing gone')
   assert.equal(s.read().revision, revision, 'nothing written')
+  /* The screen reads the refusal in one place: the clips to ask about, and nothing for any other refusal. */
+  const refusalOf = (run: () => unknown) => { try { run() } catch (error) { return error } }
+  assert.deepEqual(clipLossOf(refusalOf(() => s.command(fixed(s, 'left'))))?.map(c => `${c.clip} ${c.why}`), ['left-swing gone'])
+  const other = refusalOf(() => s.edit({ kind: 'remove-part', target: 'nowhere' }))
+  assert.ok((other as { code?: string })?.code, 'another refusal')
+  assert.equal(clipLossOf(other), null)
   assert.deepEqual(clipsOf(s), ['left-swing', 'right-swing'])
   const ids = ['left-swing/left-open']
   const at = () => ({ context: s.read().context!, revision: s.read().revision! })

package/test/layout.test.ts

@@ -16,7 +16,9 @@ const renderBody = editor.slice(editor.indexOf('  render() {'), editor.indexOf('
 test('띠 — 칸 접기 · 되돌리기 · 전체 보기 · 저장 상태 · 저장, 말은 번역에서', () => {
   /* The bar itself -- its folds, undo · redo · fit, the status and save -- is the browser check's (test/browser/screen.check.mjs). */
   assert.doesNotMatch(renderBody, /[가-힣]/, '편집기의 화면 말에 한국어가 박혀 있지 않다')
-  const keys = [...editor.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1])
+  /* The editor's words, and those of the parts it hands its work to. */
+  const said = [editor, ...['pane-fold', 'refusal-teller', 'command-preview-controller'].map(name => read(`../client/modeller/${name}.ts`))].join('\n')
+  const keys = [...said.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1])
   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}`)

package/test/refusals.test.ts

@@ -13,6 +13,7 @@ import { fileURLToPath } from 'node:url'
 import * as fm from '@hatiolab/figure-model'
 import type { FigureAsset } from '@hatiolab/figure-model'
 import {
+  clipLossOf,
   editRefusalOf,
   inDeclaredRoom,
   inputRangeRefusalOf,
@@ -22,6 +23,7 @@ import {
   placedRefusalOf,
   placementRefusalOf,
   recipeRefusalOf,
+  refusalRecordOf,
   removalNoticeOf,
   repeatPitchRefusalOf,
   sizeRangeRefusalOf
@@ -133,11 +135,7 @@ test('공간 선언에 든 부품 — 한 번 눌러 지우고, 공간은 남은
   const after = fm.editFigurePart(a, { kind: 'remove-part', target: 'stray', refitRoom: true })
   assert.equal(after.document.model.nodes.some(n => n.id === 'stray'), false)
   assert.ok(after.occupancy?.bounds, '공간은 남은 부품으로 다시 선언된다')
-  const editor = readFileSync(fileURLToPath(new URL('../client/modeller/editor.ts', import.meta.url)), 'utf8')
-  const remove = editor.slice(editor.indexOf('  private removePart('), editor.indexOf('  private toggleHiddenPart('))
-  assert.match(remove, /if \(!refitRoom && inDeclaredRoom\(error\)\) \{\s*this\.removePart\(id, true\)/, '거절 없이 곧바로 다시 맞춰 지운다')
-  assert.match(remove, /figure\.text\.removal-space-refitted/, '그렇다고 한 줄')
-  assert.doesNotMatch(remove, /this\.retry = \{/, '묻거나 권하지 않는다')
+  /* Removed in one click, nothing asked, the space fitted to the parts left and said so: parts.check.mjs. */
   assert.ok(ko['figure.text.removal-space-refitted'])
 })
 
@@ -153,11 +151,7 @@ test('배치를 바꿀 수 없는 까닭 — 평면에 붙은 부품과 새 평
   assert.ok(said.includes('post (bottom)') && said.includes('벽 기반') && said.includes('back'), said)
   assert.equal(editRefusalOf(refused, say), said, '편집 거절의 말도 같다')
   assert.equal(placementRefusalOf(refusalOf(() => act(box(), declaring({ min: 0, max: 4000 }))), say), null)
-  /* The placement list sends its command through the page, not the editor: the page says it in words too, and the list goes back. */
-  const page = readFileSync(fileURLToPath(new URL('../client/pages/figure-modeller-page.ts', import.meta.url)), 'utf8')
-  assert.ok(page.includes('editRefusalOf(error, (key, params) => i18next.t(key, params))'), '페이지 경로도 사람의 말로')
-  const props = readFileSync(fileURLToPath(new URL('../client/modeller/figure-properties.ts', import.meta.url)), 'utf8')
-  assert.ok(props.includes('select.value = current'), '거절되면 목록이 원래 배치로 돌아온다')
+  /* The placement list sends its command through the page: said there in words, and the list back on the placement it has (product-page.check.mjs). */
 })
 
 test('범위 밖 값은 받을 수 있는 범위를 숫자로 말한다 — 커널의 영어가 아니다 (Figure 레인 :3300, 2026-09-26)', () => {
@@ -244,6 +238,20 @@ test('기즈모로 옮길 수 없는 부품 — 관절이 자리를 정하는지
   assert.equal(placedRefusalOf(refusalOf(() => act(conveyor(), { kind: 'set-repeat', part: 'frame', pitch: 10 })), '프레임', keyed), null, '다른 EDIT_TARGET 은 이 말이 아니다')
 })
 
+test('옮겨 적은 거절 — 기록은 커널의 거절과 같은 모양이라 같은 말로 읽힌다 (ADR-0127)', () => {
+  const a = act(fm.addFigureBox(fm.createFigureAsset('Post'), { id: 'post', size: { x: 100, y: 1000, z: 100 }, position: { x: 0, y: 0, z: 0 } }), {
+    kind: 'attach',
+    part: 'post',
+    face: 'bottom',
+    to: { plane: 'mounting-plane' }
+  })
+  const refused = refusalOf(() => act(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'wall' }))
+  const record = refusalRecordOf(refused)
+  assert.ok(record.details, 'its details kept')
+  assert.equal(editRefusalOf(record, say), editRefusalOf(refused, say))
+  assert.equal(clipLossOf(record), null, 'no clips to ask about')
+})
+
 test('부품 이름 — 이름 규칙은 커널 한 벌이고, 화면은 거절의 값으로 말한다 (ADR-0127)', () => {
   const rename = (asset: FigureAsset, target: string, name: string) => refusalOf(() => fm.editFigurePart(asset, { kind: 'rename-part', target, name } as never))
   assert.match(partNameRefusalOf(rename(conveyor(), 'frame', '1x'), keyed)!, /part-name-invalid .*"name":"1x"/)

package/test/theme.test.ts

@@ -14,6 +14,7 @@ import { DEFAULT_VIEW, WORKBENCH } from '../client/modeller/figure-view.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 const editor = read('../client/modeller/editor.ts')
+const styles = read('../client/modeller/editor-styles.ts')
 
 /** Hex colours that are not a `var(--token, #fallback)` fallback. */
 const fixed = (text: string) =>
@@ -23,6 +24,7 @@ const fixed = (text: string) =>
 
 test('편집기에 박힌 색이 없다 — 토큰의 대체값만 남는다', () => {
   assert.deepEqual(fixed(editor), [], 'editor.ts')
+  assert.deepEqual(fixed(styles), [], 'editor-styles.ts')
 })
 
 test('캔버스 바탕은 작업대 회색 — 판의 하늘색이라 환경 탭에서 바꾼다', () => {
@@ -30,23 +32,11 @@ test('캔버스 바탕은 작업대 회색 — 판의 하늘색이라 환경 탭
   assert.equal(DEFAULT_VIEW.skyColor, WORKBENCH, '3D 바탕의 처음 값도 작업대 회색')
 })
 
-test('눌린 단추는 셸이 두 테마 대비를 맞춘 칸을 쓴다 — 오류는 앱의 알림이 그린다 (2026-09-27)', () => {
-  const pressed = editor.slice(editor.indexOf("button[aria-pressed='true']"), editor.indexOf('}', editor.indexOf("button[aria-pressed='true']")))
-  assert.match(pressed, /--md-sys-color-secondary-container\)/)
-  assert.match(pressed, /--md-sys-color-on-secondary-container\)/)
-  assert.match(pressed, /border-color: var\(--md-sys-color-primary\)/)
-})
-
 test('편집기는 창이 아니라 자기 폭으로 접는다 — 레일이 폭을 먼저 가져간다', () => {
   /* The widths - 200 | 1fr | 340, 160 | 300 under 860px, one column with the canvas first under 560px - are
      ox-three-pane's, measured in @operato/layout's own test. The editor must not write the grid again. */
-  assert.doesNotMatch(editor, /@media \(max-width/, '창 폭 기준이 남아 있다 — 레일을 펼치면 편집기가 넘친다')
-  assert.doesNotMatch(editor, /grid-template-columns/, '편집기가 격자를 다시 쓰지 않는다')
+  assert.doesNotMatch(editor + styles, /@media \(max-width/, '창 폭 기준이 남아 있다 — 레일을 펼치면 편집기가 넘친다')
+  assert.doesNotMatch(editor + styles, /grid-template-columns/, '편집기가 격자를 다시 쓰지 않는다')
 })
 
-test('양쪽 칸은 띠에서 접는다 — 접으면 캔버스가 그 폭을 갖고, 오른쪽 칸은 무엇도 가리지 않는다', () => {
-  /* The bar folding the editor's own frame, and the canvas taking the width, are the browser check's (test/browser/screen.check.mjs). */
-  const aside = editor.slice(editor.indexOf('    aside {'), editor.indexOf('}', editor.indexOf('    aside {')))
-  assert.doesNotMatch(aside, /z-index/)
-  assert.doesNotMatch(aside, /border-left/, '칸 경계선은 틀이 긋는다 — 두 줄이 되지 않게')
-})
+/* A pressed button drawn in the shell's containers, and the side drawing no edge and stacking over nothing, are the browser check's (test/browser/screen.check.mjs). */