@things-factory/figure-ui 10.1.151 → 10.1.153

package/test/browser/parts.check.mjs

@@ -202,6 +202,65 @@ describe('a removal is told: what it let go of as a notice, a refusal as an erro
   })
 })
 
+describe('a part renamed in its name field: one step, still selected; a name refused is said why', () => {
+  before(() => mount('box', 'three'))
+  const name = () => read(() => editing.fieldValue('figure.label.name'))
+  async function rename(to) {
+    await tab('properties')
+    const at = await read(() => probe.labelled('figure.label.name'))
+    assert.ok(at, 'the name field')
+    await page().mouse.click(at.x, at.y, { clickCount: 3 })
+    await page().keyboard.type(to)
+    await page().keyboard.press('Enter')
+    await sleep(400)
+  }
+
+  test('renamed: the list has the new name, it stays selected, in one step', async () => {
+    await pick('a')
+    const before = await revision()
+    await rename('left')
+    assert.deepEqual(await ids(), ['left', 'b', 'c'])
+    assert.equal((await state()).selected, 'left')
+    assert.equal(await revision(), before + 1)
+  })
+
+  test('a name another part has is refused: nothing written, the field shows the name it had, and why is said', async () => {
+    await pick('left')
+    await read(() => editing.told())
+    const before = await revision()
+    await rename('b')
+    assert.equal(await revision(), before, 'nothing written')
+    assert.deepEqual(await ids(), ['left', 'b', 'c'])
+    assert.equal(await name(), 'left')
+    const told = await read(() => editing.told())
+    assert.deepEqual(told.map(t => t.level), ['error'], JSON.stringify(told))
+    /* Said from the kernel's details (ADR-0127): the page loads no translations, so the words are the key. */
+    assert.equal(told[0].message, 'figure.text.part-name-taken')
+  })
+})
+
+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)))
@@ -221,11 +280,11 @@ describe('the list narrowed: the selected row keeps its name and its buttons in
 })
 
 describe('the palette: the starting shapes, locked at the detail level\'s limit', () => {
-  test('nine starting shapes, in order; a rounded box or a drum is made from the box', async () => {
+  test('nine starting shapes, in order, then a mesh brought from a file; a rounded box or a drum is made from the box', async () => {
     await mount('box', 'three')
     assert.deepEqual(
       (await read(() => parts.palette())).map(b => b.label),
-      ['cube', 'cylinder', 'sphere', 'frustum', 'polygon', 'pyramid', 'plate', 'wall', 'portal'].map(k => `figure.label.primitive-${k}`)
+      ['cube', 'cylinder', 'sphere', 'frustum', 'polygon', 'pyramid', 'plate', 'wall', 'portal'].map(k => `figure.label.primitive-${k}`).concat('figure.button.import-mesh')
     )
   })
 

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/row-preview.check.mjs

@@ -0,0 +1,81 @@
+/*
+ * A row's preview follows the row as it is set: a pitch refused, then 개수를 정함 chosen -- the pitch's refusal goes at
+ * once, not after the count is worked out (on :3300, 2026-10-11, it stayed under the count, as if the count were
+ * refused), and the count's own result is said.
+ *
+ * Run:  node --test test/browser/row-preview.check.mjs
+ */
+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'
+
+const sleep = ms => new Promise(done => setTimeout(done, ms))
+
+let opened
+before(async () => {
+  opened = await openPage(await buildPage('places-mesh-page.js'))
+})
+after(async () => {
+  await opened?.close()
+})
+
+const page = () => opened.page
+const read = (fn, ...args) => page().evaluate(fn, ...args)
+async function until(fn, args, what, ms = 8000) {
+  const deadline = Date.now() + ms
+  for (;;) {
+    if (await read(fn, ...args)) return
+    if (Date.now() > deadline) assert.fail(`waited for ${what}`)
+    await sleep(50)
+  }
+}
+const settled = () => read(() => document.querySelector('figure-editor').updateComplete)
+const handle = (selector, options = {}) => 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`)
+  await element.evaluate(e => e.scrollIntoView({ block: 'center' }))
+  await element.click()
+  await settled()
+}
+/** What the row's preview says now, line by line. */
+const said = () => read(() => [...(findDeep('section[row]')?.querySelectorAll('[preview-words], [preview-words] li') ?? [])].map(e => e.textContent.trim()))
+
+/* A 400 mm board, a 3 mm bin fastened on it: a row of it along X. */
+function board() {
+  let a = addFigureBox(createFigureAsset('Board'), { id: 'board', size: { x: 400, y: 50, z: 1000 }, position: { x: 0, y: 25, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'board', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = addFigureBox(a, { id: 'bin', size: { x: 3, y: 100, z: 100 }, position: { x: 0, y: 100, z: 0 } })
+  return applyFigureAuthoring(a, { kind: 'attach', part: 'bin', face: 'bottom', to: { part: 'board', face: 'top' } })
+}
+
+describe('a row\'s preview follows its basis', () => {
+  before(async () => {
+    await read(text => harness.mount('given', text), serializeFigureAsset(board()))
+    await until(() => look.drawn().length > 0, [], 'the board is drawn')
+    const at = await read(() => probe.row('bin'))
+    await page().mouse.click(at.x, at.y)
+    await until(() => probe.state().selected === 'bin', [], 'bin selected')
+    await click('details[row-fold] > summary', {}, 'the row\'s fold')
+  })
+
+  test('a 1 mm pitch: refused, said under the row', async () => {
+    const pitch = await handle('section[row] input[type=number]')
+    await pitch.evaluate(i => i.scrollIntoView({ block: 'center' }))
+    await pitch.click({ clickCount: 3 })
+    await page().keyboard.type('1')
+    await page().keyboard.press('Tab')
+    await until(() => [...(findDeep('section[row]')?.querySelectorAll('[preview-words]') ?? [])].some(e => e.textContent.includes('figure.text.preview-refused')), [], 'the pitch refused')
+  })
+
+  test('개수를 정함 chosen: the pitch\'s refusal is gone at once, and the count is said', async () => {
+    await click('section[row] input[type=radio]', { index: 1 }, 'by count')
+    /* Read before the count is worked out (it settles 150 ms after it is chosen). */
+    assert.ok(!(await said()).some(line => line.includes('preview-refused')), `not the pitch's: ${JSON.stringify(await said())}`)
+    await until(() => [...(findDeep('section[row]')?.querySelectorAll('[preview-words] li') ?? [])].some(e => e.textContent.includes('figure.text.row-count-pitch')), [], 'the count said')
+  })
+})

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'))
 
@@ -648,7 +681,8 @@ describe('the preview: registered as a board registers it, posed and played, the
     await mode('preview')
     await until('the preview stands', () => !!screenCheck.deep('figure-preview')[0]?.shadowRoot?.querySelector('div[clips]'))
     const type = await read(() => screenCheck.previewTypeOf(screenCheck.editor().session.read().context))
-    assert.equal(await read(type => screenCheck.registered(type), type), true, `registered as ${type}`)
+    /* The preview made earlier stands hidden and is shown again first: registered once it has the figure as it is now. */
+    await until(`registered as ${type}`, type => screenCheck.registered(type), type)
     assert.equal(await read(() => screenCheck.registered('figure-preview-new') && screenCheck.editor().session.read().context !== ''), false, 'not under another figure\'s type')
     await boardsUp()
     await read(() => {

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

@@ -76,12 +76,8 @@ test('pitch 는 한 곳에서 하나의 값이고, 늘 set-repeat 로 바꿔 최
   }
 })
 
-test('기즈모로 끈, 규칙이 자리를 정하는 부품은 규칙을 지킨 채 옮겨지고, 관절·붙이기가 정하는 부품은 까닭을 말한다 — 튕겨 돌아가지 않는다', () => {
-  const editor = readFileSync(fileURLToPath(new URL('../client/modeller/editor.ts', import.meta.url)), 'utf8')
-  const moved = editor.slice(editor.indexOf('  private transformed('), editor.indexOf('  /** 맞추기'))
-  assert.ok(moved.includes("kind: 'nudge-part',"), '사용자 2026-09-24: 「기즈모 컨트롤도 전혀 작동이 안되는군」')
-  assert.ok(moved.includes('...(Object.keys(grow).length ? { grow } : {})'), '크기 끌기도 배율로 — 「되는 듯하다가 다시 원래 크기로 돌아간다」')
-  /* Which of the two places it is said from the refusal's details (refusals.test.ts makes both with the kernel, ADR-0127). */
-  assert.ok(moved.includes('placedRefusalOf(error, partLabelOf(id)'), moved)
-})
-
+/*
+ * A gizmo drag on a part a rule places is written as the rule's nudge, growing by a ratio on a scale drag
+ * (modeller.check.mjs, the gizmo on a part placed by worked-out rules); one a joint places is refused in words from the
+ * kernel's details (editing.check.mjs).
+ */

package/test/fix-alignment.test.ts

@@ -0,0 +1,32 @@
+/*
+ * 정렬·간격 고치기 (fasten-geometry `insideAlignmentOf`): the alignment that brings a part inside the face it is fastened
+ * on -- the least move on each side it is out, the centre when it is wider -- or why there is nothing to move.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { insideAlignmentOf, type FaceView } from '../client/modeller/fasten-geometry.js'
+
+/* A 400 × 1000 top, a 100 × 100 footprint on it; edges offered on X, a distance only on Z. */
+const view = (part = { x: 100, y: 100, z: 100 }): FaceView => ({ axes: ['x', 'z'], face: { x: 400, z: 1000 }, part, edges: { x: true, y: true, z: false } })
+
+test('out past the low edge: moved to that edge from inside, the other axis left as it was', () => {
+  const fixed = insideAlignmentOf(view(), { x: 'mm', z: 'centre' }, { x: -1000 })
+  assert.deepEqual(fixed, { align: { x: 'min', z: 'centre' }, alignMm: { x: -1000 }, moved: ['x'] })
+})
+
+test('out past the high edge where edges are not offered: that edge as a distance', () => {
+  const fixed = insideAlignmentOf(view(), { x: 'centre', z: 'mm' }, { z: 900 })
+  assert.deepEqual(fixed, { align: { x: 'centre', z: 'mm' }, alignMm: { z: 450 }, moved: ['z'] })
+})
+
+test('wider than the face: centred, the most of it on the face', () => {
+  const fixed = insideAlignmentOf(view({ x: 600, y: 100, z: 100 }), { x: 'max' }, {})
+  assert.deepEqual(fixed, { align: { x: 'centre' }, alignMm: {}, moved: ['x'] })
+})
+
+test('nothing of it out: inside -- what is out is fastened on it; no face size: unmeasured', () => {
+  assert.deepEqual(insideAlignmentOf(view(), { x: 'max', z: 'centre' }, {}), { cannot: 'inside' })
+  assert.deepEqual(insideAlignmentOf(undefined, {}, {}), { cannot: 'unmeasured' })
+  assert.deepEqual(insideAlignmentOf({ ...view(), face: { x: 400 } }, {}, {}), { cannot: 'unmeasured' })
+})

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/mesh-import.test.ts

@@ -8,7 +8,7 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
-import { meshChoicesOf, meshPartIdOf, meshPartOf, type MeshUpload } from '../client/modeller/mesh-import.js'
+import { meshChoicesOf, meshPartOf, type MeshUpload } from '../client/modeller/mesh-import.js'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 const HASH = 'c'.repeat(64)
@@ -59,13 +59,6 @@ test('a node: its own bounds and counts, standing and turned where the file had
   assert.throws(() => meshPartOf(upload, { node: 3 }, 'x'), 'a node that cannot be a part is not made one')
 })
 
-test("a part's id from a node's name: letter-led and clean, another number when taken", () => {
-  assert.equal(meshPartIdOf('Hoist Unit #2', new Set()), 'Hoist-Unit-2')
-  assert.equal(meshPartIdOf('2nd beam', new Set()), 'nd-beam')
-  assert.equal(meshPartIdOf('###', new Set()), 'mesh')
-  assert.equal(meshPartIdOf('hoist', new Set(['hoist', 'hoist-2'])), 'hoist-3')
-})
-
 /* The screen itself -- the palette's button, the upload, the question, the step added -- is driven in browser/places-mesh.check.mjs. */
 test('the mesh words are in every language', () => {
   for (const lang of ['en', 'es', 'ja', 'ko', 'ms', 'zh']) {

package/test/parts-wiring.test.ts

@@ -11,7 +11,6 @@ import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
-const editor = read('../client/modeller/editor.ts')
 
 /*
  * Each event the panel sends answered by the editor -- picked, moved, duplicated, removed, added, hidden -- as one step
@@ -37,10 +36,7 @@ test('팔레트는 시작 모양만 낸다 — 둥근 상자와 통은 상자의
 })
 
 test('부품 이름은 figure-model 의 rename-part 로 바꾸고, 거절은 까닭별로 사람의 말로 한다', () => {
-  assert.match(editor, /this\.session!\.edit\(\{ kind: 'rename-part', target: from, name \}\)/)
-  assert.match(editor, /this\.selected = name/, '바꾼 이름의 부품이 그대로 골라져 있다')
-  /* The reason is the kernel's refusal (ADR-0127): the screen does not check the name again (refusals.test.ts makes all three). */
-  assert.match(editor, /this\.error = partNameRefusalOf\(error, /)
+  /* Renamed in one step and still selected, and a refused name said from the kernel's details: parts.check.mjs. */
   for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es']) {
     const table = JSON.parse(read(`../translations/${lang}.json`))
     for (const key of ['figure.text.part-name-taken', 'figure.text.part-name-invalid']) assert.ok(table[key]?.includes('{name}'), `${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)', () => {
@@ -210,12 +204,54 @@ test('줄이 한도를 넘으면 몇 개가 되는지와 한도를 말한다 —
   assert.ok(bodies.includes('19,402') && bodies.includes('10,000'), bodies)
 })
 
+test('일상에서 코드로만 보이던 거절 넷 — 줄이 안 들어감 · 같은 축의 줄 안의 줄 · 기준면이 걸린 부품의 줄 · 쓰인 부품 id (:3300, 2026-10-11)', () => {
+  const shelf = () => {
+    let a = fm.addFigureBox(fm.createFigureAsset('Shelf'), { id: 'board', size: { x: 400, y: 50, z: 1000 }, position: { x: 0, y: 0, z: 0 } })
+    a = fm.addFigureBox(a, { id: 'bin', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 0, z: 0 } })
+    a = act(a, { kind: 'attach', part: 'board', face: 'bottom', to: { plane: 'mounting-plane' } })
+    return act(a, { kind: 'attach', part: 'bin', face: 'bottom', to: { part: 'board', face: 'top' } })
+  }
+  /* Five 100 mm bins asked for on 400 mm. */
+  const fit = editRefusalOf(refusalOf(() => act(shelf(), { kind: 'make-repeat', part: 'bin', axis: 'x', pitch: 1, count: 5 })), keyed)
+  assert.match(fit, /row-does-not-fit .*"count":"5".*"length":"400".*"extent":"100"/)
+  /* A cap on the roller made a row along X, as the roller's row is. */
+  let capped = fm.addFigureBox(conveyor(), { id: 'cap', size: { x: 20, y: 20, z: 20 }, position: { x: 0, y: 0, z: 0 } })
+  capped = act(capped, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'roller', face: 'top' } })
+  assert.match(editRefusalOf(refusalOf(() => act(capped, { kind: 'make-repeat', part: 'cap', axis: 'x', pitch: 10 })), keyed), /row-same-axis .*"part":"cap","outer":"roller","axis":"X"/)
+  /* The bin's top holds the slot layout: made a row, the layout would stand on no one bin. */
+  const slotted = act(shelf(), {
+    kind: 'set-slot-layout',
+    label: 'Bin',
+    role: 'seat',
+    anchors: [{ id: 'bin', part: 'bin', face: 'top' }],
+    layout: { tiers: [{ tierNo: 1, anchorId: 'bin', mount: 'ON', position: { x: 0, y: 0, z: 0 }, rotation: 0, layout: { pattern: 'SINGLE', slot: { allowed: { width: 100, depth: 100, height: 100 }, accepts: ['TOTE'] } } }] }
+  })
+  const held = editRefusalOf(refusalOf(() => act(slotted, { kind: 'make-repeat', part: 'bin', axis: 'x', pitch: 150 })), say)
+  assert.ok(held.includes('bin') && held.includes('자리 배치') && !held.includes('SURFACE_PROVENANCE'), held)
+  /* A new part named as the row's part is (its copies drawn under ids of their own): the same words as a rename. */
+  assert.match(editRefusalOf(refusalOf(() => fm.addFigureBox(conveyor(), { id: 'roller', size: { x: 1, y: 1, z: 1 }, position: { x: 0, y: 0, z: 0 } })), keyed), /part-name-taken .*"name":"roller"/)
+})
+
 test('기즈모로 옮길 수 없는 부품 — 관절이 자리를 정하는지, 붙은 면이 정하는지', () => {
   assert.match(placedRefusalOf(refusalOf(() => act(conveyor(), { kind: 'nudge-part', part: 'roller', by: { x: 10 } })), '롤러', keyed)!, /gizmo-joint-places .*"part":"롤러"/)
   assert.match(placedRefusalOf(refusalOf(() => act(conveyor(), { kind: 'scale-position', part: 'roller', axis: 'x' })), '롤러', keyed)!, /gizmo-fastening-places .*"part":"롤러"/)
   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"/)