@things-factory/figure-ui 10.1.205 → 10.1.206

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.205",
+  "version": "10.1.206",
   "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.9.5",
+    "@hatiolab/figure-model": "^0.9.6",
     "@hatiolab/things-scene": "^10.1.95",
     "@material/web": "^2.0.0",
     "@operato/data-grist": "^10.29.43",
@@ -42,11 +42,11 @@
     "@operato/slot-layout-editor": "^10.29.43",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.29.43",
-    "@things-factory/ai-assistant": "^10.1.205",
-    "@things-factory/figure-service": "^10.1.205",
-    "@things-factory/figure-viewer": "^10.1.205",
-    "@things-factory/setting-base": "^10.1.205",
+    "@things-factory/ai-assistant": "^10.1.206",
+    "@things-factory/figure-service": "^10.1.206",
+    "@things-factory/figure-viewer": "^10.1.206",
+    "@things-factory/setting-base": "^10.1.206",
     "three": "^0.185.1"
   },
-  "gitHead": "7311492aa5eaa00993c0325053f5f7ae8b1fb024"
+  "gitHead": "18588a058a4a6cb21c379b2da5517e077c6442ba"
 }

package/test/browser/acceptance-page.js

@@ -162,7 +162,7 @@ export const MODELS = {
   ball: () => {
     let a = createFigureAsset('Ball')
     a.palette = { ...a.palette, ...PALETTE }
-    a = addFigurePrimitive(a, { id: 'ball', kind: 'sphere', dimensions: { radiusX: 200, radiusY: 200, radiusZ: 200 }, position: { x: 0, y: 500, z: 0 } })
+    a = addFigurePrimitive(a, { id: 'ball', kind: 'sphere', dimensions: { radius: 200, radiusY: 200 }, position: { x: 0, y: 500, z: 0 } })
     return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'set-placement', placement: 'floor' }))
   },
   /* 500 mm above the floor: keep the gap, or be brought onto it. */

package/test/browser/links.check.mjs

@@ -241,7 +241,7 @@ describe('a part made to follow the figure size, and let go of it', () => {
   })
 })
 
-/* A base and a flange, sized; the height may be placed from 90 mm though the parts measure down to 1. */
+/* A base and a flange, sized, saved with ends on every axis: the height from 90 mm, the others from 1 mm. */
 function sizedPair(turning) {
   let a = box(createFigureAsset('Probe'), 'base', [200, 100, 200], [0, 50, 0])
   a = addFigurePrimitive(a, { id: 'flange', kind: 'cylinder', dimensions: { radius: 20, length: 10 }, position: { x: 0, y: 105, z: 0 } })
@@ -256,16 +256,11 @@ function sizedPair(turning) {
 }
 
 describe('the sizes a figure may be placed at, and how it grows', () => {
-  test('measured again, the declared range becomes the measured one in one step, and the offer goes', async () => {
+  test('a figure saved with ends reads them as typed, and nothing is offered to measure again', async () => {
     await mount('sized-pair', sizedPair(false))
     /* The figure's range is the 「반응형」 tab's. */
     await tab('response')
-    const start = await state()
-    await click(await at('button', 'figure.button.remeasure-range'), 'remeasure')
-    await oneStep(start)
-    const y = (await source()).document.model.inputs.find(i => i.id === 'size.y')
-    assert.deepEqual([y.min, y.max], [1, 1000], 'the height from 1 mm, as measured')
-    assert.equal(await at('button', 'figure.button.remeasure-range'), null, 'nothing left to measure again')
+    assert.equal(await at('button', 'figure.button.remeasure-range'), null, 'nothing to measure again')
   })
 
   test('a figure with no joint is not urged to grow by one ratio; declared, the rule is said', async () => {
@@ -282,6 +277,26 @@ describe('the sizes a figure may be placed at, and how it grows', () => {
   })
 })
 
+/*
+  A link that makes the height impossible below 95 mm is made, not refused (user 2026-10-21): the smallest height the
+  author narrowed to, 90 mm, moves in to 95 in the same step, and one line says from what to what (ADR-0087 decision 6).
+*/
+describe('a part change a narrowed end cannot hold', () => {
+  test('is one step; the end moves in, said in one line', async () => {
+    await mount('sized-pair-moved', sizedPair(false))
+    await pick('flange')
+    await read(() => look.hear('notify'))
+    const start = await state()
+    await read(() => look.tell('shape', 'command', { action: { kind: 'link-dimension', part: 'flange', axis: 'y', source: { of: 'instance', axis: 'y' }, plus: -95 } }))
+    await oneStep(start)
+    assert.equal((await state()).error, '', 'not refused')
+    const y = (await source()).document.model.inputs.find(i => i.id === 'size.y')
+    assert.ok(y.min > 95 && y.min < 95.001 && y.max === 1000, `the smallest height moved in: ${y.min}`)
+    const told = (await heard('notify')).filter(n => n?.level === 'info' && String(n.message).includes('figure.text.size-range-moved-min'))
+    assert.equal(told.length, 1, 'said once')
+  })
+})
+
 /* A conveyor's rollers in a row across its frame, 200 mm apart. */
 function conveyor() {
   let a = fasten(box(createFigureAsset('Conveyor'), 'frame', [2000, 100, 600], [0, 50, 0]), 'frame', 'plane')
@@ -399,9 +414,11 @@ describe('a new fastening for a door leaf: chosen in the window, seen before it
     assert.deepEqual(await read(() => probe.fastenPopup()), { title: 'figure.label.fastening', movable: true, backdrop: false, role: 'dialog' })
   })
 
-  test('the frame chosen: the editor is told the command, and the canvas draws where the leaf would go and the face it meets', async () => {
+  /* Chosen in the window, the gap is the distance the leaf stands at: it is fastened where it is (ADR-0140 stage 4, 「현재 상태로 붙이기」). */
+  test('the frame chosen: the editor is told the command, and the canvas draws the face it meets; the leaf stays where it stands', async () => {
     await aimAt('frame')
-    await until(() => look.drawn().includes('__preview:leaf') && look.drawn().includes('__target-face'), [], 'the leaf and the face drawn')
+    await until(() => look.drawn().includes('__target-face') && look.all('[preview-words]', 'figure.text.preview-stays').length > 0, [], 'the face drawn and the leaf said to stay')
+    assert.deepEqual(await ghosts(), [], 'nothing drawn where it would go: it does not move')
     const told = (await heard('preview-command')).filter(Boolean).at(-1)
     assert.equal(told?.action.kind, 'attach')
     assert.equal((await source()).joints?.some(j => j.body1.part === 'leaf') ?? false, false, 'nothing written')
@@ -443,7 +460,7 @@ describe('a new fastening for a door leaf: chosen in the window, seen before it
 
   test('Esc closes the window and tells the editor to clear what it tried; the leaf stays selected', async () => {
     await aimAt('frame')
-    await until(() => look.drawn().includes('__preview:leaf'), [], 'the leaf drawn where it would go')
+    await until(() => look.drawn().includes('__target-face'), [], 'the face it would meet drawn')
     await read(() => look.hear('preview-command', 'dialog'))
     await page().keyboard.press('Escape')
     await until(() => !probe.fastenTargets(), [], 'the window closed')
@@ -459,9 +476,9 @@ describe('a new fastening for a door leaf: chosen in the window, seen before it
     await aimAt('frame')
     /*
       The frame's faces are offered once the drawing has the frame: a press before that is not a choice. And the press is
-      aimed once the window has drawn what the choice brings -- the leaf where it would go -- or it lands where the face was.
+      aimed once the window has drawn what the choice brings -- the face it would meet -- or it lands where the face was.
     */
-    await until(() => look.face('front')?.pickable && look.drawn().includes('__preview:leaf'), [], 'the front face offered, the leaf drawn where it would go')
+    await until(() => look.face('front')?.pickable && look.drawn().includes('__target-face'), [], 'the front face offered, the face it would meet drawn')
     await settled()
     await sleep(200)
     await click(await at('path[face="front"]'), 'the front face in the drawing')

package/test/browser/modeller.check.mjs

@@ -452,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')
   })
 
   /*
@@ -467,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')
@@ -500,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 () => {
@@ -534,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()

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

@@ -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, aimFastenAt, 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'), [
@@ -107,7 +147,7 @@ test('the target list: every other part, the one hanging from this part listed a
 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: { radiusX: 100, radiusY: 100, radiusZ: 100 }, position: { x: 0, y: 0, z: 3000 } } 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])
 }

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')
@@ -159,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, '칸 안의 붙여넣기는 칸의 것')
+})

package/test/links.test.ts

@@ -10,7 +10,7 @@ import assert from 'node:assert/strict'
 import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, createFigureAsset } from '@hatiolab/figure-model'
 import type { FigureAsset } from '@hatiolab/figure-model'
 
-import { acceptsOf, canFasten, canFollow, dimensionNow, instanceRangeOf, proportionToFollow, rangeDiffers, rangeWith, turnsAboutAJoint, valueNow, fastenedTo, followableAxes, followOf, hasInstanceSize, positionIsShare, holdsThings, motionOf, placeFacesOf, placeIdFor, placesOn, positionsWorkedOut } from '../client/modeller/links.ts'
+import { acceptsOf, canFasten, canFollow, dimensionNow, instanceRangeOf, proportionToFollow, rangeWith, turnsAboutAJoint, valueNow, fastenedTo, followableAxes, followOf, hasInstanceSize, positionIsShare, holdsThings, motionOf, placeFacesOf, placeIdFor, placesOn, positionsWorkedOut } from '../client/modeller/links.ts'
 import { revisionOf } from './revision-of.ts'
 
 const pair = (): FigureAsset => {
@@ -49,6 +49,10 @@ test('붙이기 — 누구에게 붙었나, 붙일 수 있는 모양인가', ()
   assert.equal(canFasten(withDrum, 'drum'), true, '원기둥도 면으로 붙인다(figure-model 0.1.47)')
   assert.equal(canFollow(withDrum, 'drum'), true, '원기둥은 반지름(X)과 길이(Y)를 따를 수 있다')
   assert.deepEqual(followableAxes(withDrum, 'drum'), ['x', 'y'], '원기둥에는 제 Z 가 없다')
+  /* 구도 원기둥처럼 가로(X, Z 가 함께)와 높이(Y)를 따르고, 붙일 수 있다(사용자 2026-10-21). */
+  const withBall = addFigurePrimitive(asset, { id: 'ball', kind: 'sphere', dimensions: { radius: 50, radiusY: 50 }, position: { x: 0, y: 50, z: 0 } })
+  assert.deepEqual(followableAxes(withBall, 'ball'), ['x', 'y'], '구의 가로 반지름은 X 와 Z 가 한 값')
+  assert.equal(canFasten(withBall, 'ball'), true)
 })
 
 test('움직임 — 미끄러짐 · 돌기, 축, 무엇이 모느냐를 읽는다', () => {
@@ -206,38 +210,39 @@ test('made to follow in proportion, a measure is the share of the figure size it
   assert.deepEqual(followCommandOf(revisionOf(linked), 'flange', 'y', 'part:base:x', followOf(linked, 'flange', 'y')), { kind: 'link-dimension', part: 'flange', axis: 'y', source: { of: 'part', part: 'base', axis: 'x' }, replace: true })
 })
 
-test('놓일 수 있는 크기 — 남은 만큼 채우던 부품을 비례로 바꾸면 다시 재어 넓힌다', () => {
-  assert.equal(instanceRangeOf(createFigureAsset('Probe')), undefined, '크기를 선언하지 않은 도형에는 범위가 없다')
-  let asset = sizedPair()
+/* ADR-0087 결정 6(사용자 2026-10-21): 작성자가 좁힌 끝만 저장되고, 나머지는 부품에서 figure-model 이 계산한다. */
+const openSides = () => {
+  const asset = sizedPair()
   for (const axis of ['x', 'z'] as const) {
-    asset.document.model.inputs.push({ id: `size.${axis}`, unit: 'mm', min: 1, max: 20000, role: 'design' } as never)
+    asset.document.model.inputs.push({ id: `size.${axis}`, unit: 'mm', role: 'design' } as never)
     asset.designInputs[`size.${axis}`] = 200
   }
+  return asset
+}
+
+test('도면에서의 크기 — 좁히지 않은 끝은 부품에서 계산하고, 좁힌 끝은 작성자의 값이다', () => {
+  assert.equal(instanceRangeOf(createFigureAsset('Probe')), undefined, '크기를 선언하지 않은 도형에는 범위가 없다')
+  const asset = openSides()
   const y = asset.document.model.inputs.find(i => i.id === 'size.y')!
   y.min = 90
   y.max = 1000
   const range = instanceRangeOf(asset)!
-  assert.deepEqual(range.declared.y, { min: 90, max: 1000 })
-  assert.deepEqual(range.measured.y, { min: 1, max: 1000 }, '기본 범위: 1 mm 에서 열 배')
-  assert.equal(rangeDiffers(range.declared, range.measured), true)
-  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: range.measured, replace: true })
-  assert.equal(rangeDiffers(instanceRangeOf(asset)!.declared, instanceRangeOf(asset)!.measured), false, '다시 재면 같다')
+  assert.deepEqual(range.y, { min: 90, max: 1000, narrowed: { min: true, max: true } })
+  assert.deepEqual(range.x, { min: 0, max: Infinity, narrowed: { min: false, max: false } }, '막는 부품이 없으면 끝이 없다')
 })
 
-test('놓일 수 있는 크기 — 저작자가 끝을 적어 좁힌다(갠트리, 09-25)', () => {
-  let asset = sizedPair()
-  for (const axis of ['x', 'z'] as const) {
-    asset.document.model.inputs.push({ id: `size.${axis}`, unit: 'mm', min: 1, max: 20000, role: 'design' } as never)
-    asset.designInputs[`size.${axis}`] = 200
-  }
-  const declared = instanceRangeOf(asset)!.declared
-  assert.equal(rangeWith(declared, 'x', 'min', Number.NaN), undefined, '숫자가 아니면 명령이 없다')
-  const next = rangeWith(declared, 'x', 'min', 150)!
-  assert.deepEqual(next.x, { min: 150, max: 20000 })
-  assert.deepEqual(declared.x, { min: 1, max: 20000 }, '선언된 범위는 그대로')
-  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: next, replace: true })
-  assert.deepEqual(instanceRangeOf(asset)!.declared.x, { min: 150, max: 20000 })
-  assert.throws(() => applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: rangeWith(next, 'x', 'min', 300)!, replace: true }), (e: { code?: string }) => e.code === 'INSTANCE_SIZE_RANGE', '저작한 크기(200)를 벗어나면 거절')
+test('도면에서의 크기 — 숫자를 치면 그 끝을 좁히고, 칸을 비우면 다시 연다(갠트리, 09-25)', () => {
+  let asset = openSides()
+  const range = instanceRangeOf(asset)!
+  assert.deepEqual(rangeWith(range, 'x', 'min', 150), { x: { min: 150 }, y: { min: 1, max: 20000 } }, '다른 축의 좁힌 끝은 그대로')
+  assert.deepEqual(rangeWith(range, 'y', 'min', Number.NaN), { y: { max: 20000 } }, '비운 칸은 열린다')
+  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: rangeWith(range, 'x', 'min', 150), replace: true })
+  assert.deepEqual(instanceRangeOf(asset)!.x, { min: 150, max: Infinity, narrowed: { min: true, max: false } })
+  assert.throws(
+    () => applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: rangeWith(instanceRangeOf(asset)!, 'x', 'min', 300), replace: true }),
+    (e: { code?: string }) => e.code === 'INSTANCE_SIZE_RANGE',
+    '저작한 크기(200)를 벗어나면 거절'
+  )
 })
 
 test('한 비율로 커지는 도형 — 자기 숫자인 길이를 세고, 한 번에 따라가게 하며, 무엇이 남는지 이름을 댄다(아키텍트 판정 09-25)', () => {
@@ -376,7 +381,7 @@ test('면은 도형이 정한다 — 문틀(portal)은 바깥 여섯에 개구
     dimensions: { width: 1100, height: 2200, depth: 150, jamb: 100, head: 100 },
     position: { x: 0, y: 0, z: 0 }
   })
-  asset = addFigurePrimitive(asset, { id: 'ball', kind: 'sphere', dimensions: { radiusX: 50, radiusY: 50, radiusZ: 50 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigurePrimitive(asset, { id: 'ball', kind: 'sphere', dimensions: { radius: 50, radiusY: 50 }, position: { x: 0, y: 0, z: 0 } })
   asset = addFigurePrimitive(asset, { id: 'cone', kind: 'frustum', dimensions: { radiusTop: 20, radiusBottom: 60, height: 100 }, position: { x: 0, y: 0, z: 0 } })
   asset = addFigureBox(asset, { id: 'leaf', size: { x: 890, y: 2095, z: 40 }, position: { x: 0, y: 0, z: 0 } })
   asset = addFigurePrimitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 400 }, position: { x: 0, y: 0, z: 0 } })
@@ -427,18 +432,18 @@ test('돌려 놓인 부품에도 모서리 맞춤을 내놓는다 — 지금 자
 })
 
 test('모델러에서 만든 도형은 부품에서 재어 도형 크기를 선언한다 — 그 뒤에야 부품이 도형 크기를 따를 수 있다 (사용자 09-25)', async () => {
-  const { instanceRangeToDeclare, instanceRangeOf, hasInstanceSize } = await import('../client/modeller/links.ts')
+  const { instanceSizeToDeclare, instanceRangeOf, hasInstanceSize } = await import('../client/modeller/links.ts')
   const { compileFigureAsset } = await import('@hatiolab/figure-model')
   let asset = createFigureAsset('Conveyor')
-  assert.equal(instanceRangeToDeclare(asset), undefined, '부품이 없으면 잴 것이 없다')
+  assert.equal(instanceSizeToDeclare(asset), undefined, '부품이 없으면 잴 것이 없다')
   asset = addFigureBox(asset, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
   asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'frame', to: { plane: 'mounting-plane' } })
   assert.equal(hasInstanceSize(asset, 'x'), false, '새 도형에는 도형 크기가 없다')
-  const toDeclare = instanceRangeToDeclare(asset)!
+  const toDeclare = instanceSizeToDeclare(asset)!
   assert.deepEqual(toDeclare.at, { x: 2000, y: 100, z: 600 }, '지금 부품의 크기가 선언할 크기')
-  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: toDeclare.range, at: toDeclare.at })
-  assert.ok(instanceRangeOf(asset), '선언 뒤에는 놓일 수 있는 크기가 보인다')
-  assert.equal(instanceRangeToDeclare(asset), undefined, '이미 있으면 다시 권하지 않는다')
+  asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', at: toDeclare.at })
+  assert.ok(instanceRangeOf(asset), '선언 뒤에는 도면에서의 크기가 보인다')
+  assert.equal(instanceSizeToDeclare(asset), undefined, '이미 있으면 다시 권하지 않는다')
   assert.equal(hasInstanceSize(asset, 'x'), true, '부품이 도형 크기를 따르는 선택이 열린다')
   asset = applyFigureAuthoring(asset, { kind: 'link-dimension', part: 'frame', axis: 'x', source: { of: 'instance', axis: 'x' } } as never)
   const at = (size: number) => (compileFigureAsset({ ...asset, designInputs: { ...asset.designInputs, 'size.x': size } }).evaluate().geometry.find(g => g.id === 'frame')!.shape.dimensions as Record<string, number>)['size.x']
@@ -505,7 +510,7 @@ test('면 위 거리를 도형 크기 비율로 — 도형이 커지면 그 자
 })
 
 test('선언할 크기는 부품이 쉬고 있을 때의 크기 — 문짝이 도는 자리까지 재지 않는다 (2026-09-25)', async () => {
-  const { instanceRangeToDeclare } = await import('../client/modeller/links.ts')
+  const { instanceSizeToDeclare } = await import('../client/modeller/links.ts')
   let asset = createFigureAsset('Door')
   asset = addFigureBox(asset, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
   asset = addFigureBox(asset, { id: 'leaf', size: { x: 890, y: 2095, z: 40 }, position: { x: 0, y: 0, z: 0 } })
@@ -513,7 +518,7 @@ test('선언할 크기는 부품이 쉬고 있을 때의 크기 — 문짝이
   asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'leaf', to: { part: 'jamb', face: 'right' }, align: { y: 'min', z: 'max' }, gap: 5 })
   const j = asset.joints!.find(o => o.id === 'leaf')!
   asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', lowerLimit: -90, upperLimit: 0, state: { id: 'open' } } })
-  assert.deepEqual(instanceRangeToDeclare(asset)!.at, { x: 995, y: 2100, z: 150 })
+  assert.deepEqual(instanceSizeToDeclare(asset)!.at, { x: 995, y: 2100, z: 150 })
 })
 
 test('바닥에 선 부품도 도형 크기를 선언한 도형이면 도형의 옆면에 맞출 수 있다 (2026-09-25)', async () => {