@things-factory/figure-ui 10.1.204 → 10.1.206

package/test/browser/modeller.check.mjs

@@ -388,6 +388,18 @@ describe('a figure made in the modeller is given its size from its parts (user 2
     await tab('response')
   })
 
+  /* In words a person reads (user 2026-10-20): what the figure does on a drawing, not the range behind it. */
+  const sizeGroup = () =>
+    page().evaluate(() => {
+      const deep = (root = document) => [...root.querySelectorAll('section[board-size]')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      const s = deep()[0]
+      return s ? { title: [...(s.querySelector('h3')?.childNodes ?? [])].filter(n => n.nodeType === 3).map(n => n.textContent).join('').trim(), fixed: s.querySelector('p[fixed-size]')?.textContent.trim() ?? null, followers: s.querySelector('p[followers]')?.textContent.trim() ?? null, dashes: s.querySelectorAll('div[pair][range] > span[dash]').length } : null
+    })
+
+  test('fixed: the size it is always drawn at, in one sentence, and the way to let a drawing resize it', async () => {
+    assert.deepEqual(await sizeGroup(), { title: 'figure.label.board-size', fixed: 'figure.text.board-size-fixed', followers: null, dashes: 0 })
+  })
+
   test('with nothing picked, the figure offers to declare its size; clicked, its size fields appear', async () => {
     const button = await page().evaluateHandle(() => {
       const deep = (root = document) => [...root.querySelectorAll('button')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
@@ -407,6 +419,10 @@ describe('a figure made in the modeller is given its size from its parts (user 2
     assert.deepEqual(await read(() => probe.fields('size.')), { 'size.x': 400, 'size.y': 400, 'size.z': 400 }, 'the size it is authored at: its parts now')
   })
 
+  test('resizable: each axis reads smallest – largest, and which parts change with it (none on a lone box)', async () => {
+    assert.deepEqual(await sizeGroup(), { title: 'figure.label.board-size', fixed: null, followers: 'figure.text.board-size-no-followers', dashes: 3 })
+  })
+
   test('the sizes it may be placed at are typed: the largest width, one step, and a smallest past its size refused', async () => {
     const field = id =>
       page().evaluateHandle(id => {
@@ -436,8 +452,8 @@ describe('a figure made in the modeller is given its size from its parts (user 2
     assert.equal((await declared())['size.x'][1], 3000, 'the largest width is what was typed')
     await type('size.x.min', '500')
     assert.notEqual((await state()).error, '', 'the figure is 400 wide: a smallest of 500 is refused')
-    assert.equal((await declared())['size.x'][0] < 400, true, 'and the range is as it was')
-    assert.equal(await (await field('size.x.min')).evaluate(i => Number(i.value) < 400), true, 'the field shows the range it still has')
+    assert.equal((await declared())['size.x'][0] ?? null, null, 'and the smallest is still open (ADR-0087 decision 6)')
+    assert.deepEqual(await (await field('size.x.min')).evaluate(i => [i.value, i.placeholder]), ['', '0'], 'the field empty again, what the parts allow written faintly in it')
   })
 
   /*
@@ -451,6 +467,34 @@ describe('a figure made in the modeller is given its size from its parts (user 2
     assert.notEqual(said, 'figure.text.edit-refused', `said in its own words: ${said}`)
   })
 
+  test('a field emptied opens its end again, in one step: the largest is what the parts allow, nothing', async () => {
+    const field = () =>
+      page().evaluateHandle(() => {
+        const deep = (root = document) => [...root.querySelectorAll('input')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+        return deep().find(i => i.getAttribute('aria-label') === 'size.x.max') ?? null
+      })
+    /* Selected where it is drawn, as a person does, then typed over. */
+    const typeOver = async keys => {
+      const at = await (await field()).evaluate(i => {
+        i.scrollIntoView({ block: 'center' })
+        const r = i.getBoundingClientRect()
+        return { x: r.left + r.width / 2, y: r.top + r.height / 2 }
+      })
+      await page().mouse.click(at.x, at.y, { clickCount: 3 })
+      await keys()
+      await page().keyboard.press('Tab')
+      await sleep(600)
+    }
+    await typeOver(() => page().keyboard.type('3000'))
+    assert.equal(await (await field()).evaluate(i => i.value), '3000', 'narrowed first')
+    const start = await state()
+    await typeOver(() => page().keyboard.press('Backspace'))
+    const after = await state()
+    assert.equal(after.error, '', 'not refused')
+    assert.equal(after.revision, start.revision + 1, 'one step')
+    assert.deepEqual(await (await field()).evaluate(i => [i.value, i.placeholder]), ['', '∞'], 'empty, and nothing limits it')
+  })
+
   test('a part follows the figure\'s width less a difference: chosen and typed, the width is the size less it', async () => {
     await click(await read(() => probe.partOnPage('box')))
     assert.equal((await state()).selected, 'box')
@@ -484,23 +528,17 @@ describe('a figure made in the modeller is given its size from its parts (user 2
     await page().keyboard.type('-50')
     await page().keyboard.press('Tab')
     await sleep(600)
-    /* The declared sizes start at 1 mm: less 50 the box would be gone below 50, so the link is refused -- with the way on. */
-    assert.match((await state()).error, /figure.text.link-needs-smaller-range/, 'refused, said in words')
-    /* A refusal with a way on is asked in the app's prompt (OxPrompt): confirmed, the narrowed link is made. */
+    /*
+      The sizes the figure may be drawn at are worked out from its parts (ADR-0087 decision 6), not refused against a
+      range nobody chose: the link is taken as typed, with nothing asked.
+    */
+    assert.equal((await state()).error, '', 'taken')
+    assert.equal((await body('box')).dimensions['size.x'], 350, 'the figure\'s 400 less 50')
     const asked = await read(() => {
       const deep = (root = document) => [...root.querySelectorAll('ox-prompt')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
-      const prompt = deep().at(-1)
-      const confirm = prompt?.shadowRoot?.querySelector('#confirm')
-      if (!confirm) return null
-      const r = confirm.getBoundingClientRect()
-      return { text: prompt.text, label: confirm.textContent.trim(), x: r.left + r.width / 2, y: r.top + r.height / 2 }
+      return deep().length
     })
-    assert.match(asked?.text ?? '', /figure.text.link-needs-smaller-range/, 'asked in the app\'s prompt')
-    assert.match(asked.label, /figure.button.narrow-range-from/, 'the same link is offered with the sizes narrowed')
-    await click(asked)
-    await sleep(600)
-    assert.equal((await state()).error, '', 'taken')
-    assert.equal((await body('box')).dimensions['size.x'], 350, 'the figure\'s 400 less 50')
+    assert.equal(asked, 0, 'nothing asked')
   })
 
   test('grown by one ratio, every part is made to follow it in one step, and the offer goes', async () => {
@@ -518,8 +556,15 @@ describe('a figure made in the modeller is given its size from its parts (user 2
         return { x: r.left + r.width / 2, y: r.top + r.height / 2 }
       }))
     }
+    /* Back to the whole figure: a key in a field is the field's, so the field typed in is left first, then Esc. */
+    await page().evaluate(() => {
+      let focused = document.activeElement
+      while (focused?.shadowRoot?.activeElement) focused = focused.shadowRoot.activeElement
+      focused?.blur()
+    })
     await page().keyboard.press('Escape')
     await sleep(300)
+    assert.equal((await state()).selected, '', 'nothing picked')
     await press('figure.button.scale-uniformly')
     assert.equal((await state()).error, '', 'grows by one ratio')
     const start = await state()
@@ -615,9 +660,15 @@ describe('the modeller made easier to find and to keep (2026-09-26 baseline)', (
     assert.equal(await resize.evaluate(b => b.getAttribute('aria-pressed')), 'false')
   })
 
-  test('a height typed into its field keeps the bottom on the floor, as the gizmo does', async () => {
+  test('a height typed into its field keeps the part\'s middle, and the size group says so (ADR-0140 4.1)', async () => {
     await mount('box')
     await click(await read(() => probe.partOnPage('box')))
+    const was = await body('box')
+    const middleOf = b => b.t[1] + b.dimensions.start + b.dimensions.length / 2
+    assert.ok(await read(() => {
+      const deep = (root = document) => [...root.querySelectorAll('p[size-keeps]')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      return deep().some(p => p.textContent.trim() === 'figure.text.size-keeps-centre')
+    }), 'said beside the size fields')
     const height = await find('input', 'box.size.y')
     assert.ok(await height.evaluate(i => !!i), 'the height field')
     const at = await centre(height)
@@ -626,8 +677,8 @@ describe('the modeller made easier to find and to keep (2026-09-26 baseline)', (
     await page().keyboard.press('Enter')
     await sleep(600)
     const now = await body('box')
-    /* The box is drawn up y from its start: its bottom is its centre plus the start. */
-    assert.equal(Math.round(now.t[1] + now.dimensions.start), 0, `bottom on the floor: centre ${now.t[1]}, starts at ${now.dimensions.start}`)
+    /* The box is drawn along y from its start: its middle is its origin plus the start plus half the length. */
+    assert.equal(Math.round(middleOf(now)), Math.round(middleOf(was)), `its middle where it was: ${middleOf(was)} -> ${middleOf(now)}`)
     assert.equal(now.dimensions.length, 1000)
   })
 
@@ -895,14 +946,14 @@ describe('a row that carries a part (ADR-0093, 2026-09-26)', () => {
 
 describe('the row section opens on one click', () => {
   test('a part that can be made a row: one click on the folded heading opens it, a second folds it', async () => {
-    await mount('rollers')
-    await click(await read(() => probe.row('mark')))
+    await mount('shelf')
+    await click(await read(() => probe.row('slat')))
     await tab('response')
     const summary = await page().evaluateHandle(() => {
       const deep = (root = document) => [...root.querySelectorAll('details[row-fold] > summary')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
       return deep()[0] ?? null
     })
-    assert.ok(await summary.evaluate(s => !!s && !!s.parentElement.querySelector('button[act]')), 'the mark is offered a row to make')
+    assert.ok(await summary.evaluate(s => !!s && !!s.parentElement.querySelector('button[act]')), 'the slat is offered a row to make')
     const at = await summary.evaluate(s => {
       s.scrollIntoView({ block: 'center' })
       const r = s.getBoundingClientRect()
@@ -915,9 +966,9 @@ describe('the row section opens on one click', () => {
   })
 
   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')))
+    await mount('shelf')
+    await click(await read(() => probe.row('slat')))
+    await click(await read(() => probe.row('bed')))
     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]
@@ -925,7 +976,7 @@ describe('the row section opens on one click', () => {
         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'
+      editor.selected = 'slat'
       await editor.updateComplete
       await Promise.all(deep('figure-links').map(links => links.updateComplete))
       await null

package/test/browser/parts.check.mjs

@@ -141,6 +141,55 @@ describe('the parts list: each button does what it says, one step of the session
   })
 })
 
+/*
+  Copy and paste with the canvas focused (user 2026-10-21): left to the scene, Ctrl+C / Ctrl+V copied the canvas object
+  with the part's name -- two objects of one name, the copy moving the original and never a part of its own.
+*/
+describe('copy and paste on the canvas: a part of its own, named by figure-model', () => {
+  before(() => mount('box', 'three'))
+
+  const withControl = async code => {
+    await page().keyboard.down('Control')
+    await page().keyboard.press(code)
+    await page().keyboard.up('Control')
+    await sleep(400)
+  }
+
+  test('Ctrl+C then Ctrl+V on the canvas: one step, a new row with a name of its own, one canvas object per name', async () => {
+    await click(await read(() => probe.partOnPage('b')), 'b on the canvas')
+    assert.equal((await state()).selected, 'b', 'picked on the canvas, the canvas focused')
+    const was = await ids()
+    const step = await revision()
+    await withControl('KeyC')
+    await withControl('KeyV')
+    const now = await ids()
+    const made = now.filter(id => !was.includes(id))
+    assert.equal(made.length, 1, `one new part: ${now}`)
+    assert.notEqual(made[0], 'b')
+    assert.equal(await revision(), step + 1, 'one step')
+    assert.equal((await state()).selected, made[0], 'the copy is the part selected')
+    const drawn = await read(() => parts.drawn())
+    assert.equal(new Set(drawn).size, drawn.length, `no two canvas objects of one name: ${drawn}`)
+  })
+
+  test('Ctrl+X and Ctrl+Shift+V are kept from the scene: nothing cut or pasted on the canvas alone', async () => {
+    await click(await read(() => probe.partOnPage('b')), 'b on the canvas')
+    const was = await ids()
+    const step = await revision()
+    await withControl('KeyX')
+    await page().keyboard.down('Control')
+    await page().keyboard.down('Shift')
+    await page().keyboard.press('KeyV')
+    await page().keyboard.up('Shift')
+    await page().keyboard.up('Control')
+    await sleep(400)
+    assert.deepEqual(await ids(), was)
+    assert.equal(await revision(), step)
+    const drawn = await read(() => parts.drawn())
+    assert.deepEqual([...drawn].sort(), [...was].sort(), 'the canvas draws the figure\'s parts, no more, no fewer')
+  })
+})
+
 describe('hidden on the workbench: off the canvas, not out of the figure, and let go when another figure opens', () => {
   before(() => mount('box', 'three'))
 

package/test/browser/screen-page.js

@@ -8,7 +8,6 @@ import './modeller-page.js'
 import { captureFigureThumbnail } from 'figure-ui-client/modeller/thumbnail.js'
 import { drawableFigureParts } from 'figure-ui-client/modeller/renderer.js'
 import { previewTypeOf } from '@things-factory/figure-viewer/dist-client/preview-model.js'
-import { figureReportOf } from 'figure-ui-client/modeller/maturity.js'
 import { hasFigure } from '@hatiolab/things-scene'
 import {
   addFigureBox,
@@ -118,7 +117,6 @@ window.screenCheck = {
   registered: type => hasFigure(type),
   previewTypeOf,
   /** The report the verdict tab measures, for the figure the editor holds. */
-  capacityNow: () => figureReportOf(window.screenCheck.editor().session.revisionNow().asset)?.capacity.instances,
   /** The card's picture of a figure (saved text), as a save takes it. */
   async picture(text) {
     const asset = JSON.parse(text)

package/test/browser/screen.check.mjs

@@ -223,9 +223,9 @@ describe('the frame: parts · canvas · one side of seven tabs, and the bar over
     await pressTab(TAB('properties'))
   })
 
-  test('the verdict tab carries the count the page measured', async () => {
-    await read(() => (screenCheck.editor().instances = 42))
-    await until('the count on the tab', () => screenCheck.editor().shadowRoot.querySelector(`button[tab][aria-label="figure.label.tab-short-verdict"] span[badge]`)?.textContent.trim() === '42')
+  /* The count once drawn on the verdict tab covered its icon and was not something to act on (2026-10-20): none. */
+  test('the verdict tab carries no count over its icon', async () => {
+    assert.equal(await read(() => screenCheck.editor().shadowRoot.querySelectorAll('button[tab] span[badge]').length), 0)
   })
 
   test('nothing chosen: the properties panel opens on the figure\'s own settings, with no part head', async () => {
@@ -240,8 +240,11 @@ describe('the frame: parts · canvas · one side of seven tabs, and the bar over
     assert.equal(await read(() => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar').pane === screenCheck.editor().shadowRoot.querySelector('ox-three-pane')), true, 'the bar folds the editor\'s own frame')
     const titles = await read(() => ['undo', 'redo'].map(a => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar').shadowRoot.querySelector(`button[data-action=${a}]`).title))
     assert.ok(titles[0].endsWith('(Ctrl+Z)') && titles[1].endsWith('(Ctrl+Y)'), `the keys in the titles: ${titles}`)
-    const status = () => read(() => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar [role=status]')?.textContent.trim())
-    assert.equal(await status(), 'figure.text.saved')
+    /* Saved or not is the save button's: pressable with something to save, dimmed without -- no words beside it. */
+    const status = () => read(() => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar [role=status]')?.textContent.trim() ?? null)
+    const saveOn = () => read(() => !screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[save]').disabled)
+    assert.equal(await status(), null, 'nothing said while nothing is under way')
+    assert.equal(await saveOn(), false, 'saved: the save button is dimmed')
 
     await pressRow('box')
     const height = await element('the height field', () => screenCheck.deep('input').find(i => i.getAttribute('aria-label') === 'box.size.y'))
@@ -249,14 +252,15 @@ describe('the frame: parts · canvas · one side of seven tabs, and the bar over
     await page().keyboard.type('600')
     await page().keyboard.press('Enter')
     await until('the height is 600', () => probe.value('box.size.y') === 600)
-    await until('said unsaved', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar [role=status]')?.textContent.trim() === 'figure.text.unsaved-changes')
+    await until('something to save', () => !screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[save]').disabled)
+    assert.equal(await status(), null, 'and still no words beside it')
 
     await pressBar('undo')
     await until('undone', () => probe.value('box.size.y') === 400)
     await pressBar('redo')
     await until('redone', () => probe.value('box.size.y') === 600)
     await press('save', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[save]'))
-    await until('said saved', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar [role=status]')?.textContent.trim() === 'figure.text.saved')
+    await until('saved: dimmed again', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[save]').disabled)
 
     const width = () => read(() => Math.round(screenCheck.deep('figure-canvas')[0].getBoundingClientRect().width))
     const was = await width()
@@ -1077,12 +1081,6 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     await press('the release button', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[publish]'))
   })
 
-  test('the verdict tab\'s count is the report\'s, measured by the verdict', async () => {
-    const expected = await read(() => screenCheck.capacityNow())
-    assert.ok(expected > 0)
-    await until('the count on the tab', expected => screenCheck.editor().shadowRoot.querySelector('button[tab][aria-label="figure.label.tab-short-verdict"] span[badge]')?.textContent.trim() === expected.toLocaleString(), expected)
-  })
-
   test('a new type asks the verdict again', async () => {
     await pressTab(TAB('properties'))
     await pressRow('left')

package/test/browser/section.check.mjs

@@ -291,11 +291,11 @@ describe('the section editor on a box: what follows, what is kept, and a figure
     await openEditor()
   })
 
-  test('the length says the face its placement keeps', async () => {
+  test('the length says what a length typed keeps: the part\'s middle (ADR-0140 4.1)', async () => {
     const now = await editorNow()
     assert.equal(now.length.label, 'figure.label.section-editor-length')
     assert.equal(now.length.disabled, false)
-    assert.equal(now.length.note, 'figure.text.section-editor-keeps')
+    assert.equal(now.length.note, 'figure.text.size-keeps-centre')
   })
 
   test('the figure changed while the editor is open: apply is refused, and closing does not offer it', async () => {
@@ -330,6 +330,33 @@ describe('the section editor on a box whose sizes follow the figure', () => {
   })
 })
 
+/*
+ * The user's case (2026-10-21, 「수정본 검증 - 기본 버튼 상자」): 「속 공간 만들기」 ticked on a box whose sizes follow the
+ * figure's was refused, for a 1 mm the figure had never been asked to go to. Now it is one step and nothing is refused:
+ * how small the figure can then be is computed from the walls (ADR-0087 decision 6).
+ */
+describe('the inside made on a box whose sizes follow the figure', () => {
+  before(async () => {
+    await mount('follows')
+    await pick('box')
+  })
+
+  test('ticked, it is one step, drawn, and not refused', async () => {
+    const start = await state()
+    /* Clicked where it is drawn, as a person does. */
+    const at = await (await element('label[toggle] input', { within: 'figure-section-panel' })).evaluate(e => {
+      e.scrollIntoView({ block: 'center' })
+      const r = e.getBoundingClientRect()
+      return { x: r.left + r.width / 2, y: r.top + r.height / 2 }
+    })
+    await page().mouse.click(at.x, at.y)
+    await until(r => probe.state().revision === r + 1, 'one step', start.revision)
+    assert.equal((await state()).error, '', 'not refused')
+    await until(() => probe.sectionPanel()?.cavityDrawing, 'the inside drawn')
+    assert.ok((await held('box')).cavity, 'the box has its inside')
+  })
+})
+
 describe('a drawn section\'s end drawn to one point', () => {
   test('turned on, the length is called the height', async () => {
     await mount('wedge')

package/test/fasten-form.test.ts

@@ -9,7 +9,7 @@ import assert from 'node:assert/strict'
 import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
 import type { FigureAsset } from '@hatiolab/figure-model'
 
-import { aimFasten, fastenChanged, fastenDetailWordsOf, fastenFormOf, fastenPlanOf, fastenSentenceOf, fastenTargetsOf, freshFasten } from '../client/modeller/fasten-form.ts'
+import { aimFasten, aimFastenAt, fastenChanged, fastenDetailWordsOf, fastenFormOf, fastenPlanOf, fastenSentenceOf, fastenTargetsOf, freshFasten, keptGapOf } from '../client/modeller/fasten-form.ts'
 import { revisionOf } from './revision-of.ts'
 
 const box = (asset: FigureAsset, id: string, [x, y, z]: number[], at = [0, 0, 0]) => addFigureBox(asset, { id, size: { x, y, z }, position: { x: at[0]!, y: at[1]!, z: at[2]! } })
@@ -94,6 +94,46 @@ test('the drawing\'s changes: another face aims again, the way, the gap, a place
   assert.equal(fastenPlanOf(r, 'roller', f).targetFace, 'front')
 })
 
+/*
+ * 「현재 상태로 붙이기」(ADR-0140 stage 4, user 2026-10-20): aimed at a face, the gap starts at the distance the part
+ * stands from it, so fastening does not move it. Changing how it meets the face works it out again; a number typed is
+ * the author's and stays; a press on the canvas puts the part there, with no gap.
+ */
+const centreOf = (asset: FigureAsset, id: string) => (compileFigureAsset(asset).evaluate().geometry as Array<{ id: string; pose?: { t: number[] } }>).find(g => g.id === id)!.pose!.t
+/* A plate on the floor, its top at 20 mm, and a lid 40 mm above it. */
+function floating() {
+  let a = fasten(box(createFigureAsset('Lift'), 'plate', [600, 20, 600], [0, 10, 0]), 'plate', 'plane')
+  return revisionOf(box(a, 'lid', [100, 20, 100], [0, 70, 0]))
+}
+
+test('aimed at a face, the gap is where the part stands, and fastening it does not move it', () => {
+  const r = floating()
+  const f = keptGapOf(r, 'lid', aimFasten(r, 'lid', fastenFormOf(r, 'lid'), { part: 'plate' }))
+  assert.deepEqual([f.gap, f.gapFrom], [40, 'kept'])
+  const applied = applyFigureAuthoring(r.asset, fastenPlanOf(r, 'lid', f).action!)
+  assert.deepEqual(centreOf(applied, 'lid'), centreOf(r.asset, 'lid'), 'the lid where it was')
+  const onPlane = keptGapOf(r, 'lid', aimFasten(r, 'lid', f, { plane: true }))
+  assert.equal(onPlane.gap, 60, 'aimed at the floor instead: 60 mm above it')
+})
+
+test('another way of meeting works the gap out again; a number typed stays; a press on the canvas puts it there', () => {
+  const r = floating()
+  const aimed = keptGapOf(r, 'lid', aimFasten(r, 'lid', fastenFormOf(r, 'lid'), { part: 'plate' }))
+  const flush = fastenChanged(r, 'lid', aimed, { mode: 'flush' })
+  const applied = applyFigureAuthoring(r.asset, fastenPlanOf(r, 'lid', flush).action!)
+  assert.deepEqual(centreOf(applied, 'lid'), centreOf(r.asset, 'lid'), 'flush, and still where it was')
+  assert.deepEqual(fastenDetailWordsOf(aimed, say), [], 'the gap it stands at is the default: nothing said on the fold')
+  const typed = fastenChanged(r, 'lid', aimed, { gap: 5 })
+  assert.equal(typed.gapFrom, 'typed')
+  assert.deepEqual(fastenDetailWordsOf(typed, say), ['figure.text.fasten-summary-gap(mm=5)'])
+  assert.equal(fastenChanged(r, 'lid', typed, { mode: 'flush' }).gap, 5, 'the author\'s number is left')
+  assert.equal(keptGapOf(r, 'lid', aimFasten(r, 'lid', typed, { plane: true })).gap, 5)
+  const plate = (r.geometry as Array<{ id: string }>).find(g => g.id === 'plate')!.id
+  const pressed = aimFastenAt(r, 'lid', aimed, { id: plate, point: [0, 20, 0], normal: [0, 1, 0] }).form!
+  assert.deepEqual([pressed.gap, pressed.gapFrom], [0, 'pressed'])
+  assert.equal(fastenChanged(r, 'lid', pressed, { mode: 'flush' }).gap, 0, 'pressed: left at 0')
+})
+
 test('the target list: every other part, the one hanging from this part listed as a loop', () => {
   const r = conveyor()
   assert.deepEqual(fastenTargetsOf(r, 'frame'), [
@@ -102,3 +142,64 @@ test('the target list: every other part, the one hanging from this part listed a
   ])
   assert.deepEqual(fastenTargetsOf(r, 'lid').map(t => t.part), ['frame', 'roller'])
 })
+
+/* A drum lying on the floor along Y and a ball, with a tag standing beside each (ADR-0140 3.9). */
+async function curved() {
+  const { addFigurePrimitive } = await import('@hatiolab/figure-model')
+  let a = addFigurePrimitive(createFigureAsset('Curved'), { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 1600 }, position: { x: 0, y: 0, z: 0 } } as never)
+  a = addFigurePrimitive(a, { id: 'ball', kind: 'sphere', dimensions: { radius: 100, radiusY: 100 }, position: { x: 0, y: 0, z: 3000 } } as never)
+  a = box(a, 'tag', [40, 40, 40], [600, 600, 600])
+  return box(a, 'cap', [40, 40, 40], [0, 600, 3000])
+}
+
+test('aimed at a cylinder it stands beside, it goes on the side at the point it faces; aimed at a sphere, on its round', async () => {
+  const r = revisionOf(await curved())
+  const drum = aimFasten(r, 'tag', freshFasten(), { part: 'drum' })
+  assert.deepEqual(drum.surface, { around: 315, along: { mm: 600 } }, 'beside it, 600 up its length, toward +X +Z')
+  const plan = fastenPlanOf(r, 'tag', drum)
+  assert.deepEqual((plan.action as { to: unknown }).to, { part: 'drum', surface: { around: 315, along: { mm: 600 } } })
+  assert.equal((plan.action as { align?: unknown }).align, undefined, 'on a surface, where is its own words')
+  assert.deepEqual(plan.surface, { form: 'around', axis: 'y', place: { around: 315, along: { mm: 600 } } })
+  assert.equal(fastenSentenceOf(drum, plan, '바닥', say), 'figure.text.fasten-sentence-meet(to=drum의 figure.label.surface-around())')
+  const ball = aimFasten(r, 'cap', freshFasten(), { part: 'ball' })
+  assert.deepEqual(ball.surface, { toward: { x: 0, y: 1, z: 0 } }, 'straight above it')
+  /* Applied, and opened again: on the surface as it was. */
+  const done = applyFigureAuthoring(r.asset, plan.action!)
+  assert.deepEqual(fastenFormOf(revisionOf(done), 'tag').surface, { around: 315, along: { mm: 600 } })
+  const { rowBlockOf } = await import('../client/modeller/links.ts')
+  assert.equal(rowBlockOf(done, 'tag'), 'on-surface', 'a point of a curved surface has no face to lay a row across')
+})
+
+test('a face or the surface, as the drawing asks; the surface chosen starts where the part stands', async () => {
+  const r = revisionOf(await curved())
+  const side = aimFasten(r, 'tag', freshFasten(), { part: 'drum' })
+  const top = fastenChanged(r, 'tag', side, { targetFace: 'top' })
+  assert.equal(top.surface, undefined, 'its end disc is a face')
+  assert.deepEqual((fastenPlanOf(r, 'tag', top).action as { to: unknown }).to, { part: 'drum', face: 'top' })
+  const back = fastenChanged(r, 'tag', top, { onSurface: true })
+  assert.deepEqual(back.surface, { around: 315, along: { mm: 600 } })
+  const turned = fastenChanged(r, 'tag', back, { surface: { around: 90, along: 'max' } })
+  assert.deepEqual((fastenPlanOf(r, 'tag', turned).action as { to: unknown }).to, { part: 'drum', surface: { around: 90, along: 'max' } })
+})
+
+test("pressed on the canvas: the face or the point pressed, read in that part's own frame; itself and a curve with no fastening said (ADR-0140 stage 4)", async () => {
+  const { addFigurePrimitive } = await import('@hatiolab/figure-model')
+  /* A drum lying along X (turned a quarter about Z), a rounded box, and the tag to fasten. */
+  let a = addFigurePrimitive(createFigureAsset('Pressed'), { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 400 }, position: { x: 0, y: 500, z: 0 }, rotation: { x: 0, y: 0, z: 90 } } as never)
+  a = addFigurePrimitive(a, { id: 'soft', kind: 'rounded-box', dimensions: { width: 300, height: 200, depth: 300, round: 40 }, position: { x: 0, y: 100, z: 1500 } } as never)
+  const r = revisionOf(box(a, 'tag', [40, 40, 40], [900, 900, 900]))
+  const pose = (r.geometry as Array<{ id: string; pose: { r: number[][]; t: number[] } }>).find(g => g.id === 'drum')!.pose
+  const world = (v: number[], move = true) => [0, 1, 2].map(i => [0, 1, 2].reduce((s, c) => s + pose.r[i]![c]! * v[c]!, move ? pose.t[i]! : 0))
+  const rad = (d: number) => (d * Math.PI) / 180
+  const at = (deg: number) => [Math.cos(rad(deg)), 0, -Math.sin(rad(deg))]
+  /* A 12-sided drawing: the facet between 0° and 30°, pressed where the ray at 20° meets it, 50 up its own Y. */
+  const s = (100 * Math.cos(rad(15))) / Math.cos(rad(5))
+  const press = { id: 'drum', point: world(at(20).map((v, i) => (i === 1 ? 50 : v * s))), normal: world(at(15), false) }
+  const side = aimFastenAt(r, 'tag', freshFasten(), press)
+  assert.deepEqual([side.note, side.form?.target, side.form?.surface], [undefined, 'drum', { around: 20, along: { mm: 50 } }])
+  const end = aimFastenAt(r, 'tag', freshFasten(), { id: 'drum', point: world([10, 200, 20]), normal: world([0, 1, 0], false) })
+  assert.deepEqual([end.form?.surface, end.form?.targetFace, end.form?.align, end.form?.alignMm], [undefined, 'top', { x: 'mm', z: 'mm' }, { x: 10, z: 20 }], "its end, wherever the drum's own Y lies, its middle where pressed")
+  assert.deepEqual(aimFastenAt(r, 'tag', freshFasten(), { id: 'tag', point: [900, 920, 900], normal: [0, 1, 0] }), { note: 'aim-self', part: 'tag' })
+  const corner = aimFastenAt(r, 'tag', freshFasten(), { id: 'soft', point: [145, 100, 1645], normal: [Math.SQRT1_2, 0, Math.SQRT1_2] })
+  assert.deepEqual([corner.note, corner.form?.target], ['aim-not-here', 'soft'], 'a rounded corner: aimed at the part, said')
+})

package/test/gizmo.test.ts

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url'
 
 import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, compileFigureAsset, createFigureAsset, createFigureEditorWorkspace } from '@hatiolab/figure-model'
 
-import { gizmoChanges, gizmoReachOf } from '../client/modeller/gizmo.ts'
+import { gizmoChanges, gizmoReachOf, sameMeasureAxesOf } from '../client/modeller/gizmo.ts'
 import { moving } from './joints.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
@@ -127,33 +127,31 @@ test('원기둥 · 구도 크기 기즈모가 먹는다 — 단면은 원으로'
 })
 
 /*
- * 높이를 숫자로 적거나 손잡이로 키워도, 도형의 배치가 지키는 면이 그 자리에 있다 — figure-model 의 한 규칙
- * (`figureSizeEditChanges`, ADR-0097). 전에는 화면이 제 산수로 배치와 상관없이 아랫면을 지켰다. 2200 을 적은 기둥이
- * 바닥 아래로 933 mm 묻혔던 일(09-26)은 바닥 도형에서 그대로 막힌다. 돌려 세운 부품은 그 높이가 위아래가 아니라 건드리지 않는다.
+ * 크기는 커널의 한 함수로 바뀐다(ADR-0140 4.1 · 4.2, `figureSizeEditOf`): 숫자 칸은 부품의 가운데를, 손잡이는 잡은
+ * 쪽의 반대편을 그 자리에 둔다 — 배치(바닥 · 천장)와 상관없이, 누운 원기둥이든 서 있는 기둥이든. 같은 치수 · 같은
+ * 기준이면 칸과 손잡이가 같은 결과다.
  */
-test('크기 칸과 손잡이 — 배치가 지키는 면을 지킨다, 커널의 한 규칙으로', async () => {
-  const { figureSizeEditChanges, applyFigureAuthoring, proposeFigureOccupancy } = await import('@hatiolab/figure-model')
+test('크기 칸은 가운데를, 손잡이는 반대쪽을 — 배치와 상관없이 커널의 한 함수로', async () => {
+  const { figureSizeEditOf, applyFigureAuthoring } = await import('@hatiolab/figure-model')
   let asset = createFigureAsset('Post')
   asset = addFigureBox(asset, { id: 'post', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-  asset = addFigurePrimitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 100 }, position: { x: 0, y: 300, z: 0 } })
   asset = addFigurePrimitive(asset, { id: 'roller', kind: 'cylinder', dimensions: { radius: 30, length: 500 }, position: { x: 0, y: 30, z: 0 }, rotation: { x: 90, y: 0, z: 0 } })
   const centreY = (a: typeof asset, part: string) => {
     const g = compileFigureAsset(a).evaluate().geometry.find(o => o.id === part)! as unknown as { pose: { t: number[] } }
     return g.pose.t[1]!
   }
   const set = (input: string, value: number) => ({ kind: 'set-design', input, unit: 'mm', value }) as never
-  const grow = (a: typeof asset, part: string, input: string, value: number) => apply(a, figureSizeEditChanges(a, part, [set(input, value)]))
+  const grow = (a: typeof asset, part: string, input: string, value: number, keep: never) => apply(a, figureSizeEditOf(a, part, [set(input, value)], keep).changes)
   const postH = gizmoReachOf(asset, 'post').sizes![1]
-  assert.equal(centreY(grow(asset, 'post', postH, 2200), 'post') - 2200 / 2, 0, '바닥 도형(선언 전 기본): 기둥 아랫면이 바닥에')
-  const drumH = gizmoReachOf(asset, 'drum').round!.along[0]!
-  assert.equal(centreY(grow(asset, 'drum', drumH, 300), 'drum') - 300 / 2, 300 - 100 / 2, '원기둥도 아랫면이 제자리')
+  assert.equal(centreY(grow(asset, 'post', postH, 2200, { keep: 'centre' } as never), 'post'), 50, '숫자 칸: 가운데가 그 자리')
+  assert.equal(centreY(grow(asset, 'post', postH, 2200, { keep: 'opposite', axis: 'y', side: 1 } as never), 'post') - 2200 / 2, 0, '위 손잡이: 아랫면이 그 자리')
+  assert.equal(centreY(grow(asset, 'post', postH, 2200, { keep: 'opposite', axis: 'y', side: -1 } as never), 'post') + 2200 / 2, 100, '아래 손잡이: 윗면이 그 자리')
   const rollerLength = gizmoReachOf(asset, 'roller').round!.along[0]!
-  assert.deepEqual(figureSizeEditChanges(asset, 'roller', [set(rollerLength, 800)]), [set(rollerLength, 800)], '누운 롤러의 길이는 위아래가 아니다')
-  assert.deepEqual(figureSizeEditChanges(asset, 'post', [set(gizmoReachOf(asset, 'post').sizes![0], 800)]), [set(gizmoReachOf(asset, 'post').sizes![0], 800)], '폭은 가운데 그대로')
-  /* 천장 도형이면 윗면을 지킨다 — 전에는 여기서도 아랫면을 지켜 천장을 뚫고 올라갔다. */
+  assert.deepEqual(figureSizeEditOf(asset, 'roller', [set(rollerLength, 800)], { keep: 'centre' }).changes, [set(rollerLength, 800)], '누운 롤러의 길이: 가운데가 원점이라 자리는 그대로')
+  /* 천장 도형도 같다 — 배치가 지키는 면을 따로 두지 않는다(ADR-0140 4.1 이 ADR-0097 §4.3 을 대신함). */
   let hung = addFigureBox(createFigureAsset('Lamp'), { id: 'lamp', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: -50, z: 0 } })
-  hung = applyFigureAuthoring(hung, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(hung), placement: 'ceiling' })
-  assert.equal(centreY(grow(hung, 'lamp', gizmoReachOf(hung, 'lamp').sizes![1], 300), 'lamp') + 300 / 2, 0, '천장 도형: 윗면이 천장에')
+  hung = applyFigureAuthoring(hung, { kind: 'set-placement', placement: 'ceiling' })
+  assert.equal(centreY(grow(hung, 'lamp', gizmoReachOf(hung, 'lamp').sizes![1], 300, { keep: 'centre' } as never), 'lamp'), -50, '천장 도형: 숫자 칸도 가운데')
 })
 
 /* 손잡이는 키를 몰라도 찾는다 — 도구 막대에 옮기기 · 돌리기 · 크기, 제 숫자로 놓인 부품에만 (09-26). */
@@ -161,3 +159,14 @@ test('도구 막대의 옮기기 · 돌리기 · 크기 — 키와 같은 길,
   const ko = JSON.parse(read('../translations/ko.json'))
   assert.deepEqual(['translate', 'rotate', 'scale'].map(m => ko['figure.button.gizmo-' + m]), ['옮기기', '돌리기', '크기 바꾸기'])
 })
+
+/* ADR-0140 4.1: the size handles that change one measure are said while the size tool is on. */
+test('같은 치수 — 원기둥의 X · Z 핸들은 한 지름, 구는 셋이 하나, 상자는 따로', () => {
+  const at = { x: 0, y: 0, z: 0 }
+  const drum = addFigurePrimitive(createFigureAsset('Drum'), { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 200 }, position: at })
+  const ball = addFigurePrimitive(createFigureAsset('Ball'), { id: 'ball', kind: 'sphere', dimensions: { radius: 50, radiusY: 50 }, position: at })
+  const crate = addFigureBox(createFigureAsset('Crate'), { id: 'crate', size: { x: 100, y: 100, z: 100 }, position: at })
+  assert.deepEqual(sameMeasureAxesOf(gizmoReachOf(drum, 'drum')), ['x', 'z'])
+  assert.deepEqual(sameMeasureAxesOf(gizmoReachOf(ball, 'ball')), ['x', 'y', 'z'])
+  assert.equal(sameMeasureAxesOf(gizmoReachOf(crate, 'crate')), undefined)
+})

package/test/keys.test.ts

@@ -41,3 +41,14 @@ test('캔버스에서 누른 W · E · R 은 씬이 이미 받았다 — 또 넘
   for (const key of ['w', 'e', 'r']) assert.equal(keyActionOf({ key, inScene: true }, 'arm'), null, key)
   assert.equal(keyActionOf({ key: 'Delete', inScene: true }, 'arm'), 'remove', '다른 키는 그대로')
 })
+
+/* Ctrl+C · Ctrl+V are the modeller's: the scene's copied the canvas object with the part's name (user 2026-10-21). */
+test('복사 · 붙여넣기는 모델러의 것 — 고른 부품의 Ctrl+C 는 복사, Ctrl+V 는 붙여넣기, 씬의 잘라내기 · 여러 개 붙여넣기는 막는다', () => {
+  assert.equal(keyActionOf({ key: 'c', ctrlKey: true }, 'arm'), 'copy')
+  assert.equal(keyActionOf({ key: 'C', metaKey: true }, 'arm'), 'copy')
+  assert.equal(keyActionOf({ key: 'c', ctrlKey: true }, ''), 'hold', '고른 것이 없어도 씬에 넘기지 않는다')
+  assert.equal(keyActionOf({ key: 'v', ctrlKey: true }, ''), 'paste', '고른 것이 없어도 붙여넣기')
+  assert.equal(keyActionOf({ key: 'V', ctrlKey: true, shiftKey: true }, 'arm'), 'hold')
+  assert.equal(keyActionOf({ key: 'x', ctrlKey: true }, 'arm'), 'hold')
+  assert.equal(keyActionOf({ key: 'v', ctrlKey: true, target: { tagName: 'INPUT' } }, ''), null, '칸 안의 붙여넣기는 칸의 것')
+})