@things-factory/figure-ui 10.1.205 → 10.1.207

package/test/browser/screen.check.mjs

@@ -129,31 +129,10 @@ describe('the verdict tab over a figure, as the modeller page mounts it', () =>
     await until('the answer is shown', () => !!alone.verdict.shadowRoot.querySelector('p[clear]'))
   })
 
-  test('no 「부품에 맞추기」 over a figure with no parts; over one with parts, it is offered for the same finding', async () => {
-    const undeclared = await read(() => [alone.finding('occupancy-undeclared')])
-    await read((text, findings) => alone.mount(text, { findings }), await read(() => figureText('empty')), undeclared)
-    await until('the finding is shown', () => !!alone.verdict.shadowRoot.querySelector('li[finding]'))
-    assert.equal(await read(() => alone.verdict.shadowRoot.querySelectorAll('button[fit]').length), 0, 'nothing to measure, nothing offered')
-    await read((text, findings) => alone.mount(text, { findings }), await read(() => figureText('two')), undeclared)
-    await until('the finding is shown', () => !!alone.verdict.shadowRoot.querySelector('li[finding]'))
-    assert.equal(await read(() => alone.verdict.shadowRoot.querySelectorAll('li[finding] button[fit]').length), 1)
-  })
-
-  test('the verdict tab and the release history offer the fit for the same findings, from questions that ask the same fields', async () => {
-    const findings = await read(() => ['part-outside-occupancy', 'occupancy-undeclared', 'mounting-face-floating'].map(code => alone.finding(code)))
+  test('the verdict tab and the release history show the same findings, from questions that ask the same fields', async () => {
+    const findings = await read(() => ['off-mounting-plane', 'type-is-placeholder', 'mounting-face-floating'].map(code => alone.finding(code)))
     await read((text, findings) => alone.mount(text, { figureId: 'fig-1', findings, history: true }), await read(() => figureText('two')), findings)
-    const offered = (host, button) =>
-      read(
-        (host, button) => {
-          const root = document.querySelector(host)?.shadowRoot
-          return root ? [...root.querySelectorAll('li[finding]')].filter(li => li.querySelector(button)).map(li => li.querySelector('span[msg]').textContent.trim()).sort() : null
-        },
-        host,
-        button
-      )
     await until('both judged', () => ['figure-verdict', 'figure-history-panel'].every(host => document.querySelector(host)?.shadowRoot?.querySelectorAll('li[finding]').length === 3))
-    assert.deepEqual(await offered('figure-verdict', 'button[fit]'), ['occupancy-undeclared', 'part-outside-occupancy'])
-    assert.deepEqual(await offered('figure-history-panel', 'button[fit-base]'), await offered('figure-verdict', 'button[fit]'), 'the same two, in both places')
     const draft = await read(() => alone.fieldsAsked('inspectFigureDraft'))
     assert.ok(draft?.includes('why') && draft.includes('how'), `the draft's question asks why and how: ${draft}`)
     assert.equal(draft, await read(() => alone.fieldsAsked('inspectFigure')), 'the saved figure\'s question asks the same fields')
@@ -783,8 +762,8 @@ describe('the preview stands one figure the author stretches (first 15 minutes,
       slider.dispatchEvent(new Event('input'))
       slider.dispatchEvent(new Event('change'))
     })
-    /* The box is the space the figure takes at 6 m: the frame and its 100 mm padding either side. */
-    await until('the figure 6 m wide, in its space', () => Math.round(screenCheck.deep('figure-preview')[0].scene.root.components[0].model.width) === 6200)
+    /* The box is the figure's body at 6 m: the frame, as wide as asked (ADR-0145). */
+    await until('the figure 6 m wide, its body', () => Math.round(screenCheck.deep('figure-preview')[0].scene.root.components[0].model.width) === 6000)
     const said = await read(() => screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('div[sizes] p[said]').textContent.trim())
     assert.ok(said.startsWith('6,000 × '), said)
     const box = await read(() => { const m = screenCheck.deep('figure-preview')[0].scene.root.components[0].model; return m.left + m.width / 2 })
@@ -988,9 +967,9 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     await open('fig-a')
   })
 
-  /* First 15 minutes (2026-10-16): release was refused for a volume never declared, said only at the foot of the verdict tab. */
-  test('what blocks release is said beside 「발행」, with the way out at hand there', async () => {
-    const answer = blocked => read(blocked => product.answer('inspectFigureDraft', () => ({ __typename: 'FigureInspection', blocked, findings: blocked ? [alone.finding('occupancy-undeclared')] : [] })), blocked)
+  /* First 15 minutes (2026-10-16): what refused release was said only at the foot of the verdict tab. */
+  test('what blocks release is said beside 「발행」, the list under the bar', async () => {
+    const answer = blocked => read(blocked => product.answer('inspectFigureDraft', () => ({ __typename: 'FigureInspection', blocked, findings: blocked ? [alone.finding('type-is-placeholder')] : [] })), blocked)
     const bar = () => read(() => [...screenCheck.editor().shadowRoot.querySelectorAll('ox-canvas-bar > button[slot=commit]')].map(b => (b.hasAttribute('bar-overlay') ? 'overlay' : b.hasAttribute('release-blocked') ? 'blocked' : b.hasAttribute('publish') ? 'publish' : 'save')))
     await answer(true)
     await open('fig-block', 'two', 'probe-block')
@@ -998,12 +977,7 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     assert.deepEqual(await bar(), ['blocked', 'publish', 'save'])
     await press('what blocks release', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[release-blocked]'))
     await until('the list under the bar', () => !!screenCheck.editor().shadowRoot.querySelector('div[release-blockers] li[finding]'))
-    assert.equal(await read(() => !!screenCheck.editor().session.revisionNow().asset.occupancy), false)
     await answer(false)
-    await press('fit to the parts', () => screenCheck.editor().shadowRoot.querySelector('div[release-blockers] button[act]'))
-    await until('the space declared, in one step', () => !!screenCheck.editor().session.revisionNow().asset.occupancy)
-    await until('nothing blocks: the word is gone', () => !screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[release-blocked]'))
-    assert.deepEqual(await bar(), ['publish', 'save'])
     await read(() => product.answer('inspectFigureDraft'))
     await saved()
     await open('fig-a')
@@ -1011,7 +985,7 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
 
   /* First 15 minutes, again (2026-10-16 evening): a new figure, nothing in it yet, showed 「발행 막힘 1」 in red from the start. */
   test('a figure with no parts has nothing red beside 「발행」; the verdict still holds what blocks it', async () => {
-    const answer = blocked => read(blocked => product.answer('inspectFigureDraft', () => ({ __typename: 'FigureInspection', blocked, findings: blocked ? [alone.finding('occupancy-undeclared')] : [] })), blocked)
+    const answer = blocked => read(blocked => product.answer('inspectFigureDraft', () => ({ __typename: 'FigureInspection', blocked, findings: blocked ? [alone.finding('type-is-placeholder')] : [] })), blocked)
     await answer(true)
     try {
       await open('fig-empty-bar', 'empty', 'probe-empty-bar')
@@ -1120,37 +1094,6 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     await until('saved', () => !screenCheck.editor().session.read().dirty)
   })
 
-  test('the verdict\'s 「부품에 맞추기」 declares the space from the parts, in one step', async () => {
-    await read(finding => product.answer('inspectFigureDraft', () => ({ __typename: 'FigureInspection', blocked: true, findings: [finding] })), await read(() => alone.finding('occupancy-undeclared')))
-    try {
-      await open('fig-b', 'two')
-      assert.equal(await read(() => JSON.parse(screenCheck.editor().session.source()).occupancy), undefined, 'no space declared yet')
-      await pressTab(TAB('verdict'))
-      await until('offered', () => !!screenCheck.deep('figure-verdict')[0]?.shadowRoot?.querySelector('button[fit]'))
-      const before = await revision()
-      await press('fit to the parts', () => screenCheck.deep('figure-verdict')[0].shadowRoot.querySelector('button[fit]'))
-      await until('one step', was => screenCheck.editor().session.read().revision === was + 1, before)
-      assert.ok(await read(() => !!JSON.parse(screenCheck.editor().session.source()).occupancy), 'the space is declared')
-      await saved()
-    } finally {
-      await read(() => product.answer('inspectFigureDraft'))
-    }
-  })
-
-  test('fitting a figure with no parts says so in the app\'s words and leaves the editor standing', async () => {
-    await read(finding => product.answer('inspectFigure', () => ({ __typename: 'FigureInspection', blocked: true, findings: [finding] })), await read(() => alone.finding('occupancy-undeclared')))
-    try {
-      await open('fig-empty', 'empty')
-      await openOverlay('history')
-      await until('offered', () => !!screenCheck.deep('figure-history-panel')[0]?.shadowRoot?.querySelector('button[fit-base]'))
-      await press('fit to the parts', () => screenCheck.deep('figure-history-panel')[0].shadowRoot.querySelector('button[fit-base]'))
-      await until('said', () => screenCheck.deep('p[fit-error]')[0]?.textContent.trim() === 'figure.text.fit-needs-parts')
-      assert.equal(await read(() => !!screenCheck.editor()?.isConnected), true, 'the editor stands')
-    } finally {
-      await read(() => product.answer('inspectFigure'))
-    }
-  })
-
   test('the view set in the bar\'s menu holds for the next figure opened: its board is stood up with it', async () => {
     await openOverlay('view')
     const colour = await element('the sky colour', () => screenCheck.setting('figure.label.sky-color').querySelector('input[type=color]'))

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

@@ -1,7 +1,7 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
-import { addFigureBox, applyFigureAuthoring, applyFigureProposal, createFigureAsset, planFigureResize, proposeFigureOccupancy } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, applyFigureProposal, createFigureAsset, planFigureResize } from '@hatiolab/figure-model'
 import { followWordsOf, partSummaryOf } from '../client/modeller/links.js'
 
 /*
@@ -18,7 +18,7 @@ test('a selected part at the head: its kind, and what its size follows only when
   const ko = JSON.parse(read('../translations/ko.json')) as Record<string, string>
   const sayKo = (key: string, params: Record<string, string> = {}) => Object.entries(params).reduce((t, [k, v]) => t.split(`{${k}}`).join(v), ko[key] ?? key)
   let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  a = applyFigureAuthoring(a, { kind: 'set-placement', placement: 'floor' })
   /* As usual -- a size of its own, loose: nothing but what it is. */
   assert.deepEqual(partSummaryOf(a, 'box', say), { kind: 'figure.label.primitive-cube', size: '' })
   const only = applyFigureProposal(a, planFigureResize(a, { part: 'box', axes: ['x'] }).steps)
@@ -47,7 +47,6 @@ test('the start card and the figure panel choose the placement as the figure\'s
   const { createFigureAsset, applyFigureAuthoring } = await import('@hatiolab/figure-model')
   const hung = applyFigureAuthoring(createFigureAsset('New'), { kind: 'set-placement', placement: 'ceiling' })
   assert.equal(hung.placement, 'ceiling')
-  assert.equal(hung.occupancy, undefined)
   /* Chosen on the start card and in the figure panel, before any part: the browser check's (test/browser/screen.check.mjs). */
 })
 

package/test/fixtures/joint-column.json

@@ -88,11 +88,6 @@
           "unit": "ratio",
           "value": 0.3
         },
-        {
-          "id": "k.minusHalf",
-          "unit": "ratio",
-          "value": -0.5
-        },
         {
           "id": "k.zero",
           "unit": "mm",
@@ -379,50 +374,6 @@
             "value": "badge.y.fromBottom.value"
           }
         },
-        {
-          "id": "occupancy.x.min",
-          "op": "mul@1",
-          "args": [
-            "size.x",
-            "k.minusHalf"
-          ],
-          "outputs": {
-            "value": "occupancy.x.min.value"
-          }
-        },
-        {
-          "id": "occupancy.x.max",
-          "op": "mul@1",
-          "args": [
-            "size.x",
-            "k.half"
-          ],
-          "outputs": {
-            "value": "occupancy.x.max.value"
-          }
-        },
-        {
-          "id": "occupancy.z.min",
-          "op": "mul@1",
-          "args": [
-            "size.z",
-            "k.minusHalf"
-          ],
-          "outputs": {
-            "value": "occupancy.z.min.value"
-          }
-        },
-        {
-          "id": "occupancy.z.max",
-          "op": "mul@1",
-          "args": [
-            "size.z",
-            "k.half"
-          ],
-          "outputs": {
-            "value": "occupancy.z.max.value"
-          }
-        },
         {
           "id": "hinge.origin.x",
           "op": "add@1",
@@ -1213,21 +1164,5 @@
       }
     }
   ],
-  "occupancy": {
-    "bounds": {
-      "x": {
-        "min": "occupancy.x.min.value",
-        "max": "occupancy.x.max.value"
-      },
-      "y": {
-        "min": "k.zero",
-        "max": "size.y"
-      },
-      "z": {
-        "min": "occupancy.z.min.value",
-        "max": "occupancy.z.max.value"
-      }
-    },
-    "placement": "floor"
-  }
+  "placement": "floor"
 }

package/test/fixtures/joint-roller.json

@@ -83,11 +83,6 @@
           "unit": "ratio",
           "value": 0.25
         },
-        {
-          "id": "k.minusHalf",
-          "unit": "ratio",
-          "value": -0.5
-        },
         {
           "id": "k.zero",
           "unit": "mm",
@@ -293,50 +288,6 @@
             "value": "roller.y.fromBottom.value"
           }
         },
-        {
-          "id": "occupancy.x.min",
-          "op": "mul@1",
-          "args": [
-            "size.x",
-            "k.minusHalf"
-          ],
-          "outputs": {
-            "value": "occupancy.x.min.value"
-          }
-        },
-        {
-          "id": "occupancy.x.max",
-          "op": "mul@1",
-          "args": [
-            "size.x",
-            "k.half"
-          ],
-          "outputs": {
-            "value": "occupancy.x.max.value"
-          }
-        },
-        {
-          "id": "occupancy.z.min",
-          "op": "mul@1",
-          "args": [
-            "size.z",
-            "k.minusHalf"
-          ],
-          "outputs": {
-            "value": "occupancy.z.min.value"
-          }
-        },
-        {
-          "id": "occupancy.z.max",
-          "op": "mul@1",
-          "args": [
-            "size.z",
-            "k.half"
-          ],
-          "outputs": {
-            "value": "occupancy.z.max.value"
-          }
-        },
         {
           "id": "hinge.origin.x",
           "op": "add@1",
@@ -909,21 +860,5 @@
       }
     }
   ],
-  "occupancy": {
-    "bounds": {
-      "x": {
-        "min": "occupancy.x.min.value",
-        "max": "occupancy.x.max.value"
-      },
-      "y": {
-        "min": "k.zero",
-        "max": "size.y"
-      },
-      "z": {
-        "min": "occupancy.z.min.value",
-        "max": "occupancy.z.max.value"
-      }
-    },
-    "placement": "floor"
-  }
+  "placement": "floor"
 }

package/test/fixtures/robot-arm-6dof.json

@@ -148,11 +148,6 @@
           "unit": "ratio",
           "value": 0.058333
         },
-        {
-          "id": "k.minusHalf",
-          "unit": "ratio",
-          "value": -0.5
-        },
         {
           "id": "k.zero",
           "unit": "mm",
@@ -777,50 +772,6 @@
             "value": "finger-right.y.fromBottom.value"
           }
         },
-        {
-          "id": "occupancy.x.min",
-          "op": "mul@1",
-          "args": [
-            "size.x",
-            "k.minusHalf"
-          ],
-          "outputs": {
-            "value": "occupancy.x.min.value"
-          }
-        },
-        {
-          "id": "occupancy.x.max",
-          "op": "mul@1",
-          "args": [
-            "size.x",
-            "k.half"
-          ],
-          "outputs": {
-            "value": "occupancy.x.max.value"
-          }
-        },
-        {
-          "id": "occupancy.z.min",
-          "op": "mul@1",
-          "args": [
-            "size.z",
-            "k.minusHalf"
-          ],
-          "outputs": {
-            "value": "occupancy.z.min.value"
-          }
-        },
-        {
-          "id": "occupancy.z.max",
-          "op": "mul@1",
-          "args": [
-            "size.z",
-            "k.half"
-          ],
-          "outputs": {
-            "value": "occupancy.z.max.value"
-          }
-        },
         {
           "id": "gripper.finger-left.translation.u",
           "op": "add@1",
@@ -2901,23 +2852,6 @@
       }
     }
   ],
-  "occupancy": {
-    "bounds": {
-      "x": {
-        "min": "occupancy.x.min.value",
-        "max": "occupancy.x.max.value"
-      },
-      "y": {
-        "min": "k.zero",
-        "max": "size.y"
-      },
-      "z": {
-        "min": "occupancy.z.min.value",
-        "max": "occupancy.z.max.value"
-      }
-    },
-    "placement": "floor"
-  },
   "detailLevel": "L",
   "stateInputs": {
     "base-pan": {
@@ -2948,5 +2882,6 @@
       "label": "Gripper stroke",
       "sweep": 1
     }
-  }
+  },
+  "placement": "floor"
 }

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