@things-factory/figure-ui 10.1.205 → 10.1.207

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 () => {
@@ -563,7 +568,7 @@ test('벽 배치 — 장착 평면은 Z = 0, 벽에서 나와 서고 가로질
   const { mountingPlaneOf, alignAxesOf } = await import('../client/modeller/links.ts')
   let a = addFigureBox(createFigureAsset('Lamp'), { id: 'plate', size: { x: 200, y: 300, z: 20 }, position: { x: 0, y: 0, z: 0 } })
   assert.deepEqual(mountingPlaneOf(a), { normal: 'y', facings: ['meet', 'flush'] }, '배치 선언 전에는 바닥 — 올려 서거나 아래에 매달림')
-  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: (await import('@hatiolab/figure-model')).proposeFigureOccupancy(a), placement: 'wall' as never })
+  a = applyFigureAuthoring(a, { kind: 'set-placement', placement: 'wall' as never })
   assert.deepEqual(mountingPlaneOf(a), { normal: 'z', facings: ['meet'] })
   assert.deepEqual(alignAxesOf(a, 'plane').map(x => x.axis), ['x', 'y'])
 })

package/test/parts-wiring.test.ts

@@ -21,7 +21,7 @@ test('지울 수 없는 부품은 사람의 말로 거절하고, 지우며 풀
   /* The reason is told apart in refusals.test.ts; that the editor tells it, and what a removal let go of, is parts.check.mjs's. */
   for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es']) {
     const table = JSON.parse(read(`../translations/${lang}.json`))
-    for (const key of ['part-is-referenced', 'part-in-declared-space', 'part-row-along', 'part-row-carries'])
+    for (const key of ['part-is-referenced', 'part-row-along', 'part-row-carries'])
       assert.ok(table[`figure.text.${key}`]?.includes('{part}'), `${lang} ${key}`)
     /* What a removal let go of, in every language, with the names it carries. */
     for (const [key, word] of [['removal-released', '{parts}'], ['removal-released-motion', '{control}'], ['removal-own-control', '{max}'], ['removal-fixed', '{parts}'], ['removal-bindings', '{places}'], ['edit-refused', '{code}'], ['edit-refused-node-limit', '{max}']])

package/test/properties.test.ts

@@ -9,10 +9,9 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
-import { addFigureBox, applyFigureAuthoring, createFigureAsset, inspectFigureAsset, parseFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, parseFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
 
 import { tagsOf, figureFigureFacts } from '../client/modeller/figure-facts.ts'
-import { occupancyFromParts } from '../client/modeller/occupancy.ts'
 import { revisionOf } from './revision-of.ts'
 import { wordsOf } from './words.ts'
 
@@ -32,18 +31,16 @@ test('탭이 읽는 사실 — 이름, 놓이는 곳, 이름 붙은 장착면뿐
   assert.equal(read.mounting, undefined)
 })
 
-test('배치 기준을 고르면 그 기준으로 공간을 선언한다 — 판정도 풀린다', () => {
+test('배치 기준을 고르면 탭이 그 기준을 다시 읽는다', () => {
   const source = serializeFigureAsset(probe())
-  const declared = applyFigureAuthoring(parseFigureAsset(source), occupancyFromParts(parseFigureAsset(source), 'ceiling'))
+  const placed = applyFigureAuthoring(parseFigureAsset(source), { kind: 'set-placement', placement: 'ceiling' })
 
-  assert.equal(facts(declared).placement, 'ceiling')
-  assert.ok(!inspectFigureAsset(declared).violations.some(v => v.code === 'OCCUPANCY_UNDECLARED'))
+  assert.equal(facts(placed).placement, 'ceiling')
 })
 
 test('장착면을 정하면 탭이 그 부품과 면을 다시 읽고, 해제하면 없어진다', () => {
   const source = serializeFigureAsset(probe())
-  const declared = applyFigureAuthoring(parseFigureAsset(source), occupancyFromParts(parseFigureAsset(source)))
-  const mounted = applyFigureAuthoring(declared, { kind: 'set-mounting-face', part: 'body', face: 'bottom' })
+  const mounted = applyFigureAuthoring(parseFigureAsset(source), { kind: 'set-mounting-face', part: 'body', face: 'bottom' })
 
   assert.deepEqual(facts(mounted).mounting, { part: 'body', face: 'bottom' })
   assert.equal(facts(applyFigureAuthoring(mounted, { kind: 'clear-mounting-face' })).mounting, undefined)
@@ -76,12 +73,12 @@ test('속성 탭의 말은 다섯 말 모두에 있다', () => {
 })
 
 /*
- * The walk without the standing group (user 2026-10-18): nothing on the tab declares the room or names a face. The
- * room is declared where release asks for it; whether the figure meets its plane the release check says from the parts.
+ * The walk without the standing group (user 2026-10-18): nothing on the tab names a face. Whether the figure meets its
+ * plane the release check says from the parts.
  */
-test('속성 탭에는 공간을 정하거나 장착면을 고르는 명령이 없다 — 이름 붙은 장착면을 떼는 것만 있다', () => {
+test('속성 탭에는 장착면을 고르는 명령이 없다 — 이름 붙은 장착면을 떼는 것만 있다', () => {
   const tab = read('../client/modeller/figure-properties.ts')
   const kinds = [...tab.matchAll(/kind: '([a-z-]+)'/g)].map(m => m[1]).sort()
   assert.deepEqual(kinds, ['clear-mounting-face', 'rename', 'set-placement'])
-  assert.doesNotMatch(tab, /occupancyFromParts|declare-occupancy|set-mounting-face/)
+  assert.doesNotMatch(tab, /set-mounting-face/)
 })

package/test/refusals.test.ts

@@ -15,9 +15,7 @@ import type { FigureAsset } from '@hatiolab/figure-model'
 import {
   clipLossOf,
   editRefusalOf,
-  inDeclaredRoom,
   inputRangeRefusalOf,
-  narrowingRetryOf,
   partNameRefusalOf,
   partRefusalOf,
   placedRefusalOf,
@@ -26,6 +24,7 @@ import {
   refusalRecordOf,
   removalNoticeOf,
   repeatPitchRefusalOf,
+  sizeRangeFitsOf,
   sizeRangeRefusalOf
 } from '../client/modeller/refusals.ts'
 import { wordsOf } from './words.ts'
@@ -35,6 +34,7 @@ const say = (key: string, params: Record<string, string>) => {
   assert.ok(key in ko, `no words for ${key}`)
   return ko[key].replace(/\{(\w+)\}/g, (_: string, k: string) => params[k] ?? '')
 }
+
 /** The key and its values, to see which words were chosen. */
 const keyed = (key: string, p: Record<string, string>) => `${key} ${JSON.stringify(p)}`
 
@@ -66,35 +66,30 @@ function conveyor(): FigureAsset {
   return act(a, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 })
 }
 
-test('크기 범위의 거절 다섯 — 축 · 숫자 · 부품을 커널이 넘긴 값으로 말한다', () => {
-  const small = sizeRangeRefusalOf(refusalOf(() => act(panel(), followsWidth(-50))), say)!
-  assert.ok(small.includes('X 축을') && small.includes('50 mm') && small.includes('panel 부품') && small.includes('다시 재기'), small)
-  const large = sizeRangeRefusalOf(refusalOf(() => act(panel(), followsWidth(1000, { times: -1 }))), say)!
-  assert.ok(large.includes('X 축을') && large.includes('1,000 mm') && large.includes('그릴 수 없는데'), large)
+/*
+ * 크기 범위로 남은 거절은 둘 — 작성자가 친 끝이 지금 크기를 빼거나 0 에서 시작할 때(ADR-0087 결정 6). 부품을 바꾸는 명령은
+ * 범위 때문에 거절되지 않고, 작성자가 좁힌 끝이 부품이 허락하는 데까지 옮겨진 것을 한 줄로 말한다(사용자 2026-10-21).
+ */
+test('크기 범위의 거절 둘 — 축 이름 · 숫자를 커널이 넘긴 값으로 말한다', () => {
   const outside = sizeRangeRefusalOf(refusalOf(() => act(box(), declaring({ min: 500, max: 4000 }))), say)!
-  assert.ok(outside.includes('X') && outside.includes('400 mm') && outside.includes('500') && outside.includes('4,000'), outside)
+  assert.equal(outside, '도면에서의 너비 (X) 범위 500 – 4,000 mm 에 지금 크기 400 mm 가 들어가지 않습니다.')
+  const open = sizeRangeRefusalOf(refusalOf(() => act(box(), { kind: 'declare-instance-size', range: { x: { min: 500 } } })), say)!
+  assert.equal(open, '도면에서의 너비 (X) 범위 500 – ∞ mm 에 지금 크기 400 mm 가 들어가지 않습니다.', '한쪽 끝만 친 범위')
   const zero = sizeRangeRefusalOf(refusalOf(() => act(box(), declaring({ min: 0, max: 4000 }))), say)!
-  assert.ok(zero.includes('X') && zero.includes('0 보다'), zero)
-  const gone = sizeRangeRefusalOf(refusalOf(() => act(panel(), followsWidth(-399.9999995, { narrowRange: true }))), say)!
-  assert.ok(gone.includes('X') && gone.includes('400 mm') && gone.includes('이미 0'), gone)
-  for (const said of [small, large, outside, zero, gone]) assert.doesNotMatch(said, /below|above|declare|authored|INSTANCE_SIZE_RANGE/)
+  assert.equal(zero, '도면에서의 너비 (X) 최소는 0 보다 커야 합니다.')
+  for (const said of [outside, open, zero]) assert.doesNotMatch(said, /below|above|declare|authored|INSTANCE_SIZE_RANGE|다시 재기/)
   assert.equal(sizeRangeRefusalOf(refusalOf(() => act(conveyor(), { kind: 'set-repeat', part: 'frame', pitch: 10 })), say), null, '다른 거절은 건드리지 않는다')
 })
 
-test('범위가 받을 수 없는 연결은 같은 연결을 범위를 좁혀 다시 권한다 — 다시 재기로는 풀리지 않는다 (사이징, 2026-09-25)', () => {
+test('부품을 줄이는 연결은 거절되지 않고, 좁혀 둔 끝이 옮겨진 것을 한 줄로 말한다 (사용자 2026-10-21)', () => {
   const asset = panel()
-  const link = followsWidth(-50)
-  const error = refusalOf(() => act(asset, link))
-  const offer = narrowingRetryOf(link, error, keyed)!
-  assert.ok(offer, '권한다')
-  assert.match(offer.label, /figure.button.narrow-range-from .*"axis":"X"/)
-  assert.match(offer.message, /link-needs-smaller-range .*"part":"panel"/)
-  assert.deepEqual(offer.retry, { ...link, narrowRange: true })
-  assert.doesNotThrow(() => act(asset, offer.retry), '권한 것은 받아들여진다')
-  assert.equal(narrowingRetryOf({ kind: 'attach' }, error, keyed), null, '연결이 아닌 명령에는 권하지 않는다')
+  const linked = act(asset, followsWidth(-50))
+  const fits = fm.figureSizeRangeFitsOf(asset, linked)
+  assert.equal(sizeRangeFitsOf(fits, say), '도면에서의 너비 (X) 최소를 1 mm 에서 50 mm 로 바꿨습니다.')
+  assert.equal(sizeRangeFitsOf([], say), '', '옮긴 것이 없으면 말하지 않는다')
 })
 
-test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그 이름을 한 줄로 말한다; 남는 거절은 공간 선언과 줄 (아키텍트 판정 2026-09-27)', () => {
+test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그 이름을 한 줄로 말한다; 남는 거절은 줄 (아키텍트 판정 2026-09-27)', () => {
   let a = fm.createFigureAsset('Bench')
   a = fm.addFigureBox(a, { id: 'leg', size: { x: 60, y: 700, z: 60 }, position: { x: 0, y: 0, z: 0 } })
   a = fm.addFigureBox(a, { id: 'top', size: { x: 1200, y: 40, z: 600 }, position: { x: 0, y: 0, z: 0 } })
@@ -116,37 +111,20 @@ test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그
   assert.match(lamp, /removal-own-control .*"part":"shade".*"control":"shade".*"min":"-180".*"max":"180"/, '따르던 것은 제 조작값을 받는다')
   assert.equal(removalNoticeOf(fm.removePart(a, { kind: 'remove-part', target: 'shade' }).notice, keyed), null, '아무것도 풀지 않았으면 말하지 않는다')
 
-  const declared = act(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'floor' })
   const why = (asset: FigureAsset, part: string) => partRefusalOf(refusalOf(() => fm.editFigurePart(asset, { kind: 'remove-part', target: part })), part, keyed)
-  assert.match(why(declared, 'shade')!, /part-in-declared-space .*"part":"shade"/, '잎인데 공간 선언에 들어 있다')
   assert.match(why(conveyor(), 'frame')!, /part-row-along .*"part":"frame".*"rows":"roller"/, '줄이 따라 놓인 부품')
   let hung = fm.addFigureBox(conveyor(), { id: 'cap', size: { x: 20, y: 20, z: 20 }, position: { x: 0, y: 0, z: 0 } })
   hung = act(hung, { kind: 'attach', part: 'cap', to: { part: 'roller', face: 'top' } })
   assert.match(why(hung, 'roller')!, /part-row-carries .*"part":"roller".*"others":"cap"/, '줄에 매달린 것')
 })
 
-test('공간 선언에 든 부품 — 한 번 눌러 지우고, 공간은 남은 부품에 다시 맞추며 그렇다고 한 줄 말한다(묻지 않는다, 2026-09-27)', () => {
-  let a = fm.addFigureBox(fm.createFigureAsset('Gate'), { id: 'housing', size: { x: 300, y: 1000, z: 300 }, position: { x: 0, y: 0, z: 0 } })
-  a = fm.addFigureBox(a, { id: 'stray', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-  a = act(a, { kind: 'attach', part: 'housing', to: { plane: 'mounting-plane' } })
-  a = act(a, { kind: 'attach', part: 'stray', to: { plane: 'mounting-plane' } })
-  a = act(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'floor' })
-  assert.equal(inDeclaredRoom(refusalOf(() => fm.editFigurePart(a, { kind: 'remove-part', target: 'stray' }))), true)
-  assert.equal(inDeclaredRoom(refusalOf(() => fm.editFigurePart(conveyor(), { kind: 'remove-part', target: 'frame' }))), false, '줄은 이 길이 아니다')
-  const after = fm.editFigurePart(a, { kind: 'remove-part', target: 'stray', refitRoom: true })
-  assert.equal(after.document.model.nodes.some(n => n.id === 'stray'), false)
-  assert.ok(after.occupancy?.bounds, '공간은 남은 부품으로 다시 선언된다')
-  /* Removed in one click, nothing asked, the space fitted to the parts left and said so: parts.check.mjs. */
-  assert.ok(ko['figure.text.removal-space-refitted'])
-})
-
 test('배치를 바꿀 수 없는 까닭 — 평면에 붙은 부품과 새 평면이 받는 면을 말한다(벽 배치, 09-25)', () => {
   const a = act(fm.addFigureBox(fm.createFigureAsset('Post'), { id: 'post', size: { x: 100, y: 1000, z: 100 }, position: { x: 0, y: 0, z: 0 } }), {
     kind: 'attach',
     part: 'post',
     to: { plane: 'mounting-plane' }
   })
-  const refused = refusalOf(() => act(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'wall' }))
+  const refused = refusalOf(() => act(a, { kind: 'set-placement', placement: 'wall' }))
   const said = placementRefusalOf(refused, say)!
   assert.equal(said, '장착 평면에 붙은 부품이 있어 놓이는 곳을 바꿀 수 없습니다: post. 먼저 이 부품을 떼어 주십시오.')
   assert.equal(editRefusalOf(refused, say), said, '편집 거절의 말도 같다')
@@ -244,7 +222,7 @@ test('옮겨 적은 거절 — 기록은 커널의 거절과 같은 모양이라
     part: 'post',
     to: { plane: 'mounting-plane' }
   })
-  const refused = refusalOf(() => act(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'wall' }))
+  const refused = refusalOf(() => act(a, { kind: 'set-placement', placement: 'wall' }))
   const record = refusalRecordOf(refused)
   assert.ok(record.details, 'its details kept')
   assert.equal(editRefusalOf(record, say), editRefusalOf(refused, say))

package/test/resize-with-placement.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
-import { addFigureBox, createFigureAsset, applyFigureAuthoring, applyFigureProposal, compileFigureAsset, figureFollowOf, figureRoomOnlyInputsOf, proposeFigureOccupancy, parseFigureAsset, planFigureResize, serializeFigureAsset } from '@hatiolab/figure-model'
+import { addFigureBox, createFigureAsset, applyFigureAuthoring, applyFigureProposal, compileFigureAsset, figureFollowOf, parseFigureAsset, planFigureResize, serializeFigureAsset } from '@hatiolab/figure-model'
 import type { FigurePlacement } from '@hatiolab/figure-model'
 import { createFigureProductSession } from '../client/modeller/product-session.js'
 import { resizeRefusalOf } from '../client/modeller/refusals.js'
@@ -26,7 +26,7 @@ const START: Record<FigurePlacement, { x: number; y: number; z: number }> = {
 for (const mode of ['floor', 'ceiling', 'wall', 'center'] as const) {
   test(`${mode}: one step through the session -- undo, redo, save and open again`, async () => {
     let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: START[mode] })
-    a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: mode })
+    a = applyFigureAuthoring(a, { kind: 'set-placement', placement: mode })
     const before = serializeFigureAsset(a)
     let record = { id: 'ux', source: before }
     const session = createFigureProductSession({ load: async () => record, save: async q => (record = { id: 'ux', source: q.source }) })
@@ -60,7 +60,7 @@ for (const mode of ['floor', 'ceiling', 'wall', 'center'] as const) {
 test('a refusal is said in the author\'s words, never the kernel\'s English', () => {
   const said: Array<[string, Record<string, string>]> = []
   const say = (key: string, params: Record<string, string>) => (said.push([key, params]), key)
-  /* No room declared: the figure stands on the floor by default. */
+  /* No placement set: the figure stands on the floor by default. */
   const a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 }, rotation: { x: 0, y: 30, z: 0 } })
   assert.equal(resizeRefusalOf(planFigureResize(a, { part: 'box' }), 'box', say), 'figure.text.resize-refused-turned')
   assert.deepEqual(said.at(-1)![1].place, 'figure.label.resize-place-floor')
@@ -74,7 +74,7 @@ test('a refusal is said in the author\'s words, never the kernel\'s English', ()
  */
 test('fresh, width only, and all set back to fixed are three different answers', async () => {
   let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 20, y: 50, z: 30 } })
-  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  a = applyFigureAuthoring(a, { kind: 'set-placement', placement: 'floor' })
   /* Fresh: all three are suggested -- and the button says "all three", never passing it off as the author's choice. */
   assert.deepEqual(resizeAxesOf(a, 'box'), { axes: ['x', 'y', 'z'], basis: 'suggested' })
   /* Width only ticked: width alone is planned, and height and depth stay fixed. */
@@ -99,19 +99,17 @@ test('fresh, width only, and all set back to fixed are three different answers',
 
 test('a part off the floor is not moved by choosing its size response', () => {
   let a = addFigureBox(createFigureAsset('UX'), { id: 'shelf', size: { x: 400, y: 40, z: 300 }, position: { x: 0, y: 520, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  a = applyFigureAuthoring(a, { kind: 'set-placement', placement: 'floor' })
   const asked = planFigureResize(a, { part: 'shelf', axes: resizeAxesOf(a, 'shelf').axes })
   assert.deepEqual([asked.refusal?.code, asked.refusal?.mm], ['GAP_CHOICE', 500])
 })
 
-test('a field only the room reads is taken out of the part\'s position row and shown apart', () => {
+test('a part held by the floor shows X and Z in its position row, not Y', () => {
   let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 20, y: 50, z: 30 } })
-  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  a = applyFigureAuthoring(a, { kind: 'set-placement', placement: 'floor' })
   const resized = applyFigureProposal(a, planFigureResize(a, { part: 'box' }).steps)
-  const roomOnly = figureRoomOnlyInputsOf(resized, 'box')
-  assert.ok(roomOnly.includes('box.position.y'))
   const fields = Object.entries(resized.designInputs).filter(([id]) => id.startsWith('box.')).map(([id, value]) => ({ id, unit: 'mm', role: 'design', value }))
-  const { vectors } = groupFields(fields.filter(f => !roomOnly.includes(f.id)), 'box')
+  const { vectors } = groupFields(fields, 'box')
   const position = vectors.find(v => v.kind === 'vector' && v.name === 'position')!
   assert.ok(position.kind === 'vector' && position.cells.x && !position.cells.y && position.cells.z, 'X and Z still move it; Y is held by the floor')
 })
@@ -125,7 +123,7 @@ test('the part component leaves its place in a size drag to the modeller, for ea
   const { componentOf } = await import('../client/modeller/stage-model.js')
   for (const mode of ['floor', 'ceiling', 'wall', 'center'] as const) {
     let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: START[mode] })
-    a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: mode })
+    a = applyFigureAuthoring(a, { kind: 'set-placement', placement: mode })
     const body = compileFigureAsset(a).evaluate().geometry.find(g => g.id === 'box') as never
     const state = componentOf(body, {}, { width: 1000, height: 1000 }, true)!
     assert.equal(state.scalePlacement, 'owner', mode)
@@ -138,9 +136,9 @@ test('the part component leaves its place in a size drag to the modeller, for ea
 test('a fastened part keeps its position and turn rows, with the numbers the rule gives', async () => {
   const { placementOf } = await import('../client/modeller/stage-model.js')
   let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 20, y: 50, z: 30 } })
-  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  a = applyFigureAuthoring(a, { kind: 'set-placement', placement: 'floor' })
   const resized = applyFigureProposal(a, planFigureResize(a, { part: 'box' }).steps)
-  const fields = Object.entries(resized.designInputs).filter(([id]) => id.startsWith('box.') && !figureRoomOnlyInputsOf(resized, 'box').includes(id)).map(([id, value]) => ({ id, unit: 'mm', role: 'design', value }))
+  const fields = Object.entries(resized.designInputs).filter(([id]) => id.startsWith('box.')).map(([id, value]) => ({ id, unit: 'mm', role: 'design', value }))
   const { vectors } = groupFields(fields, 'box')
   const rows = Object.fromEntries(vectors.map(v => [v.name, v]))
   assert.ok(rows.rotation && rows.position, 'the turn row stands though every turn axis is the joint\'s')
@@ -171,7 +169,7 @@ test('a part fastened at any angle is sized by the gizmo too: its fastening keep
 test('"open attachment settings" opens this part\'s fastening, as it is now, and not another tab', async () => {
   const { fasteningOf } = await import('../client/modeller/links.js')
   let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 20, y: 150, z: 30 } })
-  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  a = applyFigureAuthoring(a, { kind: 'set-placement', placement: 'floor' })
   const kept = applyFigureProposal(a, planFigureResize(a, { part: 'box', gap: 'keep' }).steps)
   const form = fasteningOf(revisionOf(kept), 'box')!
   assert.equal(form.toPlane, true, 'on the plane')
@@ -186,7 +184,7 @@ test('"open attachment settings" opens this part\'s fastening, as it is now, and
 test('the fastening form keeps a place that follows a position field, and fastening again keeps the field', async () => {
   const { fasteningOf, alignOf } = await import('../client/modeller/links.js')
   let a = addFigureBox(createFigureAsset('UX'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 200, y: 50, z: 150 } })
-  a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+  a = applyFigureAuthoring(a, { kind: 'set-placement', placement: 'floor' })
   const kept = applyFigureProposal(a, planFigureResize(a, { part: 'box' }).steps)
   const form = fasteningOf(revisionOf(kept), 'box')!
   assert.deepEqual([form.align.x, form.alignInput.x, form.align.z, form.alignInput.z], ['input', 'box.position.x', 'input', 'box.position.z'])

package/test/revision.test.ts

@@ -12,7 +12,7 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
-import { addFigureBox, applyFigureAuthoring, createFigureAsset, figureFaceOverhangOf, figurePartFaceOf, figurePlaneAlignChanges, figureRoomOnlyInputsOf, figureRowOf, measureFigureWork, serializeFigureAsset } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, figureFaceOverhangOf, figurePartFaceOf, figurePlaneAlignChanges, figureRowOf, measureFigureWork, serializeFigureAsset } from '@hatiolab/figure-model'
 import type { FigureAsset } from '@hatiolab/figure-model'
 
 import { createFigureProductSession } from '../client/modeller/product-session.ts'
@@ -88,7 +88,6 @@ function selectionQuestions(shown: FigureRevision, part: string) {
   gridStepOf(shown)
   jointFanOf(shown, part)
   partSummaryOf(asset, part, key => key, 'ko')
-  figureRoomOnlyInputsOf(asset, part)
   for (const axis of ['x', 'y', 'z'] as const) measureNow(shown, part, axis)
   for (const axis of ['x', 'z'] as const) canMirror(shown, part, axis, reach)
   figurePlaneAlignChanges(asset, part)

package/test/verdict.test.ts

@@ -17,7 +17,6 @@ import { addFigureBox, createFigureAsset, editFigurePart, figureCostOf } from '@
 import { budgetOf, figureReportOf, verdictMeasureOf } from '../client/modeller/maturity.ts'
 import { newestAnswer, type FigureOutcome } from '../client/modeller/newest-answer.ts'
 import { capacityFrom, SCENE_BUDGET } from '../client/modeller/scene-budget.ts'
-import { moving } from './joints.ts'
 import { wordsOf } from './words.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
@@ -37,7 +36,7 @@ test('개수는 목록 카드와 같은 셈이다 — 원가를 같은 capacityF
   assert.deepEqual(measured.report, figureReportOf(asset), '탭은 그 셈을 부르고 보여 줄 뿐이다')
   assert.equal(measured.told.instances, capacityFrom(cost.groups, cost.triangles)!.instances, '탭 이름표의 개수도 같은 셈에서 온다')
   assert.deepEqual(measured.told.budget, budgetOf(figureReportOf(asset)), '부품 목록 머리의 줄도 같은 보고서에서 온다')
-  assert.deepEqual(verdictMeasureOf(undefined), { report: undefined, bodies: 0, told: { instances: undefined, budget: undefined } }, '연 도형이 없으면 잴 것도 알릴 개수도 없다')
+  assert.deepEqual(verdictMeasureOf(undefined), { report: undefined, told: { instances: undefined, budget: undefined } }, '연 도형이 없으면 잴 것도 알릴 개수도 없다')
 })
 
 test('판정은 발행 패널과 같은 서버 문에서 온다 — 화면이 따로 판정하지 않는다', () => {
@@ -80,19 +79,6 @@ test('판정 탭의 말은 다섯 말 모두에 있다 — 없으면 키가 그
   }
 })
 
-test('감춘 부품도 「부품에 맞추기」가 잴 수 있는 부품이다', () => {
-  /* 새 도형은 부품 없이도 「공간 선언 없음」으로 막힌다. 그때 맞추기는 OCCUPANCY_NO_PARTS 로 던진다 — 단추는 잴 부품이 있을 때만. */
-  let asset = createFigureAsset('Probe')
-  asset = addFigureBox(asset, { id: 'base', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-  asset = addFigureBox(asset, { id: 'lamp', size: { x: 100, y: 100, z: 100 }, position: { x: 200, y: 50, z: 0 } })
-  asset = moving(asset, 'base', { kind: 'turn', axis: 'y', id: 'base.turn', min: 0, max: 90 })
-  asset = editFigurePart(asset, { kind: 'set-visibility', target: 'lamp', shownWhen: { input: 'base.turn', atLeast: 80 } })
-  const cost = figureCostOf(asset)
-  assert.equal(cost.hidden, 1, '전제: 등은 지금 감춰져 있다')
-  assert.equal(verdictMeasureOf(asset).bodies, 2, '그려지는 하나와 감춘 하나')
-  assert.equal(verdictMeasureOf(createFigureAsset('Empty')).bodies, 0, '부품이 없으면 잴 것이 없다')
-})
-
 test('a finding\'s affected parts are the figure\'s part names, not the format\'s words (user 2026-10-16: 「occupancy · roller-row-1-roller」)', async () => {
   const { affectedPartsOf } = await import('../client/modeller/affected-parts.ts')
   assert.deepEqual(affectedPartsOf('occupancy · roller-row-1-roller', ['box', 'roller-row-1-roller']), ['roller-row-1-roller'])