@things-factory/figure-ui 10.1.204 → 10.1.206

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)', () => {
@@ -367,8 +372,8 @@ test('따라 움직이는 관절 — 같은 방식으로 움직이고 제 조작
   assert.deepEqual(motionOf(asset, 'right')?.follows, { sum: [{ joint: 'left', multiplier: -1 }], offset: 0 }, '화면은 무엇을 따르는지 읽는다')
 })
 
-test('면은 도형이 정한다 — 문틀(portal)은 바깥 여섯에 개구부 셋, 공은 없음, 원뿔대는 위아래뿐 (2026-09-25)', async () => {
-  const { facesOf, faceAxisOf, canFasten, alignAxesOf } = await import('../client/modeller/links.ts')
+test('면은 도형이 정한다 — 문틀(portal)은 바깥 여섯에 개구부 셋, 공은 없고 곡면, 원뿔대는 위아래뿐, 원기둥 옆은 면이 아님 (2026-09-25, ADR-0140 3.9)', async () => {
+  const { facesOf, faceAxisOf, canFasten, alignAxesOf, surfaceOf } = await import('../client/modeller/links.ts')
   let asset = createFigureAsset('Doorway')
   asset = addFigurePrimitive(asset, {
     id: 'frame',
@@ -376,13 +381,18 @@ 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 } })
   assert.deepEqual(facesOf(asset, 'frame'), ['left', 'right', 'bottom', 'top', 'back', 'front', 'opening-left', 'opening-right', 'opening-top'])
   assert.equal(faceAxisOf(asset, 'frame', 'opening-top'), 'y')
   assert.deepEqual(facesOf(asset, 'ball'), [])
-  assert.equal(canFasten(asset, 'ball'), false, '공은 붙일 면이 없다')
+  assert.equal(canFasten(asset, 'ball'), true, '공은 면이 없어도 곡면 위 점에 붙인다')
+  assert.deepEqual(surfaceOf(asset, 'ball'), { form: 'toward', axis: 'y' })
+  assert.deepEqual(facesOf(asset, 'drum'), ['bottom', 'top'], '원기둥 옆은 곡면이라 면이 아니다')
+  assert.deepEqual(surfaceOf(asset, 'drum'), { form: 'around', axis: 'y' })
+  assert.equal(surfaceOf(asset, 'cone'), undefined, '원뿔대 옆은 아직 받지 않는다')
   assert.equal(canFasten(asset, 'frame'), true)
   assert.deepEqual(facesOf(asset, 'cone'), ['bottom', 'top'])
   assert.deepEqual(alignAxesOf(asset, { part: 'frame', face: 'opening-left' }), [{ axis: 'y', edges: true }, { axis: 'z', edges: true }])
@@ -422,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']
@@ -500,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 } })
@@ -508,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 () => {

package/test/refusals.test.ts

@@ -17,7 +17,6 @@ import {
   editRefusalOf,
   inDeclaredRoom,
   inputRangeRefusalOf,
-  narrowingRetryOf,
   partNameRefusalOf,
   partRefusalOf,
   placedRefusalOf,
@@ -26,6 +25,7 @@ import {
   refusalRecordOf,
   removalNoticeOf,
   repeatPitchRefusalOf,
+  sizeRangeFitsOf,
   sizeRangeRefusalOf
 } from '../client/modeller/refusals.ts'
 import { wordsOf } from './words.ts'
@@ -35,6 +35,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,32 +67,27 @@ 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)', () => {

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

@@ -117,22 +117,20 @@ test('a field only the room reads is taken out of the part\'s position row and s
 })
 
 /*
- * Designer 2026-09-27, 1: what the drag shows is what is written. The part component carries figure-model's anchor, and
- * the scene's gizmo keeps that face while dragging (things-scene `scaleAnchor`); the commit keeps the same face.
+ * ADR-0140 4.4: what the drag shows is what is written. The part component asks the scene to leave its place to the
+ * modeller (things-scene `scalePlacement: 'owner'`), which draws each frame from figure-model's one size function --
+ * whatever the placement; no face is named to the scene.
  */
-test('the part component carries the face a size drag keeps, for each placement', async () => {
+test('the part component leaves its place in a size drag to the modeller, for each placement', async () => {
   const { componentOf } = await import('../client/modeller/stage-model.js')
-  const { figureScaleAnchorOf } = await import('@hatiolab/figure-model')
-  const expected = { floor: { x: 0, y: 1, z: 0 }, ceiling: { x: 0, y: -1, z: 0 }, wall: { x: 0, y: 0, z: 1 }, center: { x: 0, y: 0, z: 0 } } as const
   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 })
-    const anchor = figureScaleAnchorOf(a, 'box')!
-    assert.deepEqual(anchor, expected[mode], mode)
     const body = compileFigureAsset(a).evaluate().geometry.find(g => g.id === 'box') as never
-    const state = componentOf(body, {}, { width: 1000, height: 1000 }, anchor)!
-    assert.deepEqual(state.scaleAnchor, expected[mode])
-    assert.equal(componentOf(body, {}, { width: 1000, height: 1000 })!.scaleAnchor, undefined, 'none given, none set')
+    const state = componentOf(body, {}, { width: 1000, height: 1000 }, true)!
+    assert.equal(state.scalePlacement, 'owner', mode)
+    assert.equal(state.scaleAnchor, undefined, `${mode}: no face named to the scene`)
+    assert.equal(componentOf(body, {}, { width: 1000, height: 1000 })!.scalePlacement, undefined, 'a shown-only body is not')
   }
 })
 
@@ -155,12 +153,15 @@ test('size response and attachment are separate screen paths', () => {
   assert.equal(ko['figure.text.held-on-plane'].replace('{place}', '바닥').replace('{gap}', '0'), '바닥에 붙어 있음 (간격 0 mm)')
 })
 
-test('a part fastened tilted off a quarter turn has no side figure-model can keep for a drag, so the size gizmo is withheld', async () => {
-  const { figureScaleAnchorOf } = await import('@hatiolab/figure-model')
+test('a part fastened at any angle is sized by the gizmo too: its fastening keeps it, and nothing else is written', async () => {
+  const { figureSizeEditOf } = await import('@hatiolab/figure-model')
+  const { gizmoReachOf } = await import('../client/modeller/gizmo.js')
   let a = addFigureBox(createFigureAsset('UX'), { id: 'hub', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
   a = addFigureBox(a, { id: 'blade', size: { x: 300, y: 20, z: 60 }, position: { x: 0, y: 110, z: 0 } })
   a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'blade', type: 'fixed', body0: { part: 'hub', face: 'top' }, body1: { part: 'blade' }, origin: { childRotate: { z: 30 } } } })
-  assert.equal(figureScaleAnchorOf(a, 'blade'), undefined)
+  assert.ok(gizmoReachOf(a, 'blade').scale, 'offered')
+  const size = [{ kind: 'set-design', input: 'blade.size.x', unit: 'mm', value: 400 }] as never
+  assert.deepEqual(figureSizeEditOf(a, 'blade', size, { keep: 'opposite', axis: 'x', side: 1 }), { changes: size, kept: 'relation' })
 })
 
 /*

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, figureScaleAnchorOf, measureFigureWork, serializeFigureAsset } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, figureFaceOverhangOf, figurePartFaceOf, figurePlaneAlignChanges, figureRoomOnlyInputsOf, figureRowOf, measureFigureWork, serializeFigureAsset } from '@hatiolab/figure-model'
 import type { FigureAsset } from '@hatiolab/figure-model'
 
 import { createFigureProductSession } from '../client/modeller/product-session.ts'
@@ -24,6 +24,7 @@ import { faceViewOf } from '../client/modeller/fasten-geometry.ts'
 import { motionEndsOf } from '../client/modeller/motion-ends.ts'
 import { figureFigureFacts } from '../client/modeller/figure-facts.ts'
 import { gizmoReachOf } from '../client/modeller/gizmo.ts'
+import { keptBySizeOf } from '../client/modeller/size-drag.ts'
 import { moving } from './joints.ts'
 import { revisionOf } from './revision-of.ts'
 
@@ -82,7 +83,7 @@ test('a version is readable while it is saved, and a save hands out the same tex
 function selectionQuestions(shown: FigureRevision, part: string) {
   const asset = shown.asset
   const reach = gizmoReachOf(asset as never, part)
-  figureScaleAnchorOf(asset, part)
+  keptBySizeOf(asset, part)
   boxOf(shown, part)
   gridStepOf(shown)
   jointFanOf(shown, part)

package/test/section-editor.test.ts

@@ -173,7 +173,7 @@ test('사각형·원도 같은 창에서 — 폭·지름·길이를 한 명령
   const next = applyFigureAuthoring(box, { kind: 'set-section', part: 'b', across: { x: 500 }, length: 260 })
   const b = (compileFigureAsset(next).evaluate().geometry.find(g => (g as { id: string }).id === 'b') as unknown as { shape: FigureEvaluatedShape; pose: { t: number[] } })
   assert.deepEqual(b.shape.extrusion!.section, { kind: 'rectangle', size: { x: 500, z: 300 } })
-  assert.equal(b.pose.t[1]! + b.shape.extrusion!.start, 0, 'a floor figure keeps its bottom')
+  assert.deepEqual([b.pose.t[1]! + b.shape.extrusion!.start, b.pose.t[1]! + b.shape.extrusion!.end], [-30, 230], 'a free part keeps its middle (ADR-0140 4.1)')
   /* A corner that no longer fits, and a length of 0, are said before anything is sent. */
   const rounded = applyFigureAuthoring(box, { kind: 'set-section-corner', part: 'b', corner: 100 })
   const r = (compileFigureAsset(rounded).evaluate().geometry.find(g => (g as { id: string }).id === 'b') as unknown as { shape: FigureEvaluatedShape }).shape
@@ -217,15 +217,14 @@ test('창 안에서 폭과 속 공간을 함께 — 넓힌 폭에서만 들어
   assert.deepEqual(sectionActionOf('t', 'rectangle', w, { ...w, cavity: null }), { kind: 'set-section', part: 't', cavity: null })
 })
 
-test('치수 칸 밑의 말: 다른 값을 따르면 그렇다고, 길이는 관계가 남기는 면을 — 말할 것이 없으면 아무것도', () => {
-  assert.deepEqual(measureNoteOf('linked', 1, 'y'), { key: 'figure.text.section-editor-linked' }, 'following another value is said first')
-  assert.deepEqual(measureNoteOf('editable', 1, 'y'), { key: 'figure.text.section-editor-keeps', face: 'bottom' }, 'a floor part keeps its start: the bottom')
-  assert.deepEqual(measureNoteOf('editable', -1, 'y'), { key: 'figure.text.section-editor-keeps', face: 'top' })
-  assert.deepEqual(measureNoteOf('editable', -1, 'x'), { key: 'figure.text.section-editor-keeps', face: 'right' })
-  assert.deepEqual(measureNoteOf('editable', 0, 'y'), { key: 'figure.text.section-editor-keeps-centre' })
-  assert.equal(measureNoteOf('editable', undefined, 'y'), null, 'the relations cannot say: nothing')
-  assert.equal(measureNoteOf(undefined, undefined, 'x'), null, 'a width across says only that it follows')
-  assert.equal(say('figure.text.section-editor-keeps', { face: ko['figure.label.face-bottom']! }), '아랫면 유지')
+test('치수 칸 밑의 말: 다른 값을 따르면 그렇다고, 길이는 가운데나 붙인 위치를 지킨다고 — 말할 것이 없으면 아무것도', () => {
+  assert.deepEqual(measureNoteOf('linked', 'centre'), { key: 'figure.text.section-editor-linked' }, 'following another value is said first')
+  assert.deepEqual(measureNoteOf('editable', 'centre'), { key: 'figure.text.size-keeps-centre' }, 'a free part keeps its middle (ADR-0140 4.1)')
+  assert.deepEqual(measureNoteOf('editable', 'relation'), { key: 'figure.text.size-keeps-fastening' }, 'a fastened part keeps where it is fastened')
+  assert.deepEqual(measureNoteOf('editable', 'none'), { key: 'figure.text.size-keeps-none' }, 'a position worked out: the size alone changes')
+  assert.equal(measureNoteOf('editable', undefined), null, 'nothing known: nothing')
+  assert.equal(measureNoteOf(undefined, undefined), null, 'a width across says only that it follows')
+  assert.deepEqual([say('figure.text.size-keeps-centre', {}), say('figure.text.size-keeps-fastening', {})], ['가운데 유지', '붙인 위치 유지'])
 })
 
 test('ADR-0100 A1: 상자·판·벽은 같은 돌출에 처음 치수만 다르고, 더해도 숨은 부착이나 연결이 생기지 않는다', async () => {

package/test/size-drag.test.ts

@@ -0,0 +1,114 @@
+/*
+ * A size drag drawn from figure-model frame by frame (ADR-0140 4.4, `size-drag.ts`): each frame is what its release
+ * writes -- the same changes, and every body where the committed figure puts it, to the bit. A free part keeps the
+ * side opposite the handle; a fastened one moves what hangs from it, by its fastening.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAsset, figureSizeEditOf } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureInputChange, FigureSizeKeep } from '@hatiolab/figure-model'
+
+import { partsAtFrame, startSizeDrag } from '../client/modeller/size-drag.ts'
+import { drawableFigureParts, type FigureRenderPart } from '../client/modeller/renderer.ts'
+
+const set = (input: string, value: number): FigureInputChange => ({ kind: 'set-design', input, unit: 'mm', value })
+const committed = (asset: FigureAsset, changes: FigureInputChange[]) =>
+  drawableFigureParts(compileFigureAsset({ ...asset, designInputs: { ...asset.designInputs, ...Object.fromEntries(changes.map(c => [c.input, c.value])) } }).evaluate().geometry)
+const drawn = (asset: FigureAsset) => drawableFigureParts(compileFigureAsset(asset).evaluate().geometry)
+const posesOf = (parts: FigureRenderPart[]) => Object.fromEntries(parts.map(p => [p.id, { r: p.pose.r, t: p.pose.t, dimensions: p.shape.dimensions }]))
+
+/* A turned box on the floor, and a lid fastened on its top. */
+function figure() {
+  let a = addFigureBox(createFigureAsset('Drag'), { id: 'box', size: { x: 200, y: 100, z: 150 }, position: { x: 40, y: 300, z: -20 }, rotation: { x: 10, y: 30, z: 0 } })
+  a = addFigureBox(a, { id: 'base', size: { x: 400, y: 100, z: 300 }, position: { x: 0, y: 50, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'base', to: { plane: 'mounting-plane' } })
+  a = addFigureBox(a, { id: 'lid', size: { x: 100, y: 20, z: 100 }, position: { x: 0, y: 0, z: 0 } })
+  return applyFigureAuthoring(a, { kind: 'attach', part: 'lid', to: { part: 'base', face: 'top' } })
+}
+
+test('each frame of a free part is what its release writes: the same changes, every body where the commit puts it', () => {
+  const asset = figure()
+  const keep: FigureSizeKeep = { keep: 'opposite', axis: 'x', side: 1 }
+  const drag = startSizeDrag(asset, 'box', {}, keep)
+  for (const width of [230, 300, 180]) {
+    const sizes = [set('box.size.x', width)]
+    const frame = drag.frame(sizes)
+    assert.deepEqual(frame.changes, figureSizeEditOf(asset, 'box', sizes, keep).changes, `${width}: the changes`)
+    assert.deepEqual(posesOf(partsAtFrame(drawn(asset), frame.moved)), posesOf(committed(asset, frame.changes)), `${width}: the bodies`)
+  }
+})
+
+test('a fastened part dragged: what hangs from it moves by its fastening, frame by frame, as the commit puts it', () => {
+  const asset = figure()
+  const drag = startSizeDrag(asset, 'base', {}, { keep: 'opposite', axis: 'y', side: 1 })
+  for (const height of [140, 220]) {
+    const frame = drag.frame([set('base.size.y', height)])
+    assert.equal(frame.changes.length, 1, 'its size alone: its fastening places it')
+    assert.ok(frame.moved.has('lid'), 'the lid on its top moves with it')
+    assert.deepEqual(posesOf(partsAtFrame(drawn(asset), frame.moved)), posesOf(committed(asset, frame.changes)), `${height}`)
+  }
+})
+
+test('a body that moved and then stood still is drawn where it stopped, not where the drag began', () => {
+  const asset = figure()
+  const drag = startSizeDrag(asset, 'base', {}, { keep: 'centre' })
+  drag.frame([set('base.size.y', 200)])
+  /* The same height again: nothing changes in this frame, and the lid stays up where the last frame put it. */
+  const frame = drag.frame([set('base.size.y', 200)])
+  assert.deepEqual(posesOf(partsAtFrame(drawn(asset), frame.moved)), posesOf(committed(asset, frame.changes)))
+})
+
+test('the handle held is what is kept from: one axis keeps the side opposite it; the uniform handle, or none, the middle', async () => {
+  const { sizeKeepOf } = await import('../client/modeller/gizmo.ts')
+  assert.deepEqual(sizeKeepOf({ x: 0, y: 1, z: 0 }), { keep: 'opposite', axis: 'y', side: 1 })
+  assert.deepEqual(sizeKeepOf({ x: -1, y: 0, z: 0 }), { keep: 'opposite', axis: 'x', side: -1 })
+  assert.deepEqual(sizeKeepOf({ x: 1, y: 1, z: 1 }), { keep: 'centre' }, 'the uniform handle')
+  assert.deepEqual(sizeKeepOf(undefined), { keep: 'centre' }, 'no handle known')
+})
+
+test('what a size typed keeps, as the panel says it: the middle of a free part, the fastening of a fastened one', async () => {
+  const { keptBySizeOf } = await import('../client/modeller/size-drag.ts')
+  const asset = figure()
+  assert.deepEqual(['box', 'base', 'lid'].map(part => keptBySizeOf(asset, part)), ['centre', 'relation', 'relation'])
+  /* Its height placed by a rule: no point is kept, only the size changes -- said as such (chief architect 10-20). */
+  const ruled = structuredClone(asset) as FigureAsset
+  ;(ruled.document.model as unknown as { nodes: Array<{ id: string; args: string[] }> }).nodes.find(n => n.id === 'box.pose')!.args[1] = 'box.position.x'
+  assert.equal(keptBySizeOf(ruled, 'box'), 'none')
+})
+
+test('how far a free part goes past its mounting plane: its real extreme against the side its placement uses', async () => {
+  const { throughPlaneOf } = await import('../client/modeller/size-drag.ts')
+  const box = (placement: 'floor' | 'ceiling' | 'wall' | 'center', position: { x: number; y: number; z: number }, rotation = { x: 0, y: 0, z: 0 }) =>
+    applyFigureAuthoring(addFigureBox(createFigureAsset('P'), { id: 'b', size: { x: 100, y: 100, z: 100 }, position, rotation }), { kind: 'set-placement', placement })
+  assert.equal(throughPlaneOf(box('floor', { x: 0, y: 20, z: 0 }), drawn(box('floor', { x: 0, y: 20, z: 0 })), 'b'), 30, 'its bottom 30 under the floor')
+  assert.equal(throughPlaneOf(box('floor', { x: 0, y: 50, z: 0 }), drawn(box('floor', { x: 0, y: 50, z: 0 })), 'b'), 0, 'standing on it')
+  assert.equal(throughPlaneOf(box('ceiling', { x: 0, y: -40, z: 0 }), drawn(box('ceiling', { x: 0, y: -40, z: 0 })), 'b'), 10, 'its top 10 above the ceiling')
+  assert.equal(throughPlaneOf(box('wall', { x: 0, y: 0, z: 45 }), drawn(box('wall', { x: 0, y: 0, z: 45 })), 'b'), 5, 'its back 5 into the wall')
+  assert.equal(throughPlaneOf(box('center', { x: 0, y: -500, z: 0 }), drawn(box('center', { x: 0, y: -500, z: 0 })), 'b'), 0, 'a figure placed by its centre has no plane')
+  /* Turned 45° about Z, its lowest corner is √2·50 under its middle. */
+  const turned = box('floor', { x: 0, y: 60, z: 0 }, { x: 0, y: 0, z: 45 })
+  assert.equal(throughPlaneOf(turned, drawn(turned), 'b'), Math.round((50 * Math.SQRT2 - 60) * 10) / 10, 'its real corner, not its upright box')
+  const fastened = applyFigureAuthoring(box('floor', { x: 0, y: 20, z: 0 }), { kind: 'attach', part: 'b', to: { plane: 'mounting-plane' } })
+  assert.equal(throughPlaneOf(fastened, drawn(fastened), 'b'), 0, 'its fastening places it')
+})
+
+/*
+  A part whose height is placed by a rule keeps nothing a handle could keep (kept 'none'): only its size is written. The
+  drag draws exactly that, frame by frame -- it does not look held at the opposite side and then land elsewhere (ADR-0097
+  §4.3: a drag whose frames differ from its release is not done; chief architect 10-20).
+*/
+test('a position placed by a rule: each frame draws what the release writes -- the size alone, kept none', () => {
+  /* A command's result is sealed (ADR-0119): the rule goes into a copy. Its height now reads its x. */
+  const ruled = structuredClone(figure()) as FigureAsset
+  ;(ruled.document.model as unknown as { nodes: Array<{ id: string; args: string[] }> }).nodes.find(n => n.id === 'box.pose')!.args[1] = 'box.position.x'
+  const keep: FigureSizeKeep = { keep: 'opposite', axis: 'y', side: 1 }
+  const drag = startSizeDrag(ruled, 'box', {}, keep)
+  for (const height of [160, 240]) {
+    const sizes = [set('box.size.y', height)]
+    const frame = drag.frame(sizes)
+    assert.deepEqual(figureSizeEditOf(ruled, 'box', sizes, keep), { changes: sizes, kept: 'none' }, `${height}: the size alone`)
+    assert.deepEqual(frame.changes, sizes, `${height}: the frame writes the same`)
+    assert.deepEqual(posesOf(partsAtFrame(drawn(ruled), frame.moved)), posesOf(committed(ruled, frame.changes)), `${height}: drawn as written`)
+  }
+})

package/test/slot-layout-host.test.ts

@@ -37,22 +37,21 @@ test("no layout yet: a form on the selected part's top, and the equipment preset
   assert.equal(layout, undefined)
   const faces = anchorFacesOf(form.anchors, compileFigureAsset(asset).evaluate().geometry as never)
   assert.deepEqual(faces, { fork: { width: 1200, depth: 900 } })
-  const say = (key: string) => key
-  const presets = slotPresetsOf(form.anchors, say)
+  const presets = slotPresetsOf(form.anchors)
   assert.deepEqual(presets.map(p => p.key)[0], 'single', 'a single slot first: where an author starts')
   assert.equal(presets.length, 9)
   const size = { ...faces.fork!, slotHeight: 1000 }
   const single = presets[0]!.build(size, {})
   assert.deepEqual(single.tiers[0]!, { tierNo: 1, anchorId: 'fork', mount: 'ON', position: { x: 0, y: 0, z: 0 }, rotation: 0, layout: { pattern: 'SINGLE', slot: { allowed: { width: 1200, depth: 900, height: 1000 } } } })
   assert.deepEqual(presets.find(p => p.key === 'floorBlock')!.params, [
-    { key: 'rows', label: 'figure.label.slot-preset-param-rows', integer: true },
-    { key: 'cols', label: 'figure.label.slot-preset-param-cols', integer: true },
-    { key: 'stackLimit', label: 'figure.label.slot-preset-param-stackLimit', integer: true }
+    { key: 'rows', integer: true },
+    { key: 'cols', integer: true },
+    { key: 'stackLimit', integer: true }
   ])
   /* Two anchors: the twin fork stands one tier on each. A bottom anchor hangs its single slot. */
-  const twin = slotPresetsOf([{ id: 'left', part: 'a', face: 'top' }, { id: 'right', part: 'b', face: 'top' }], say)
+  const twin = slotPresetsOf([{ id: 'left', part: 'a', face: 'top' }, { id: 'right', part: 'b', face: 'top' }])
   assert.deepEqual(twin.find(p => p.key === 'craneTwinFork')!.build(size, {}).tiers.map(t => t.anchorId), ['left', 'right'])
-  assert.equal(slotPresetsOf([{ id: 'under', part: 'fork', face: 'bottom' }], say)[0]!.build(size, {}).tiers[0]!.mount, 'HANG')
+  assert.equal(slotPresetsOf([{ id: 'under', part: 'fork', face: 'bottom' }])[0]!.build(size, {}).tiers[0]!.mount, 'HANG')
 })
 
 test('the editor is told what figure-model asks beyond its own checks: every slot names a type', () => {
@@ -103,7 +102,7 @@ test('refusals are said from their details, never the kernel\'s sentence', () =>
 })
 
 test('the slot layout panel starts from presets that keep where they started as a record', () => {
-  const [single] = slotPresetsOf([{ id: 'fork', part: 'fork', face: 'top' }], k => k)
+  const [single] = slotPresetsOf([{ id: 'fork', part: 'fork', face: 'top' }])
   assert.deepEqual(single!.build({ width: 1200, depth: 900, slotHeight: 1000 }, {}).preset, { key: 'single', size: { width: 1200, depth: 900, slotHeight: 1000 }, params: {} })
 })
 
@@ -115,3 +114,9 @@ test('the places words are in every language', () => {
       assert.ok(t[key], `${lang} ${key}`)
   }
 })
+
+/* A preset's name is the shared editor's (label.slot-layout.preset.*): figure-ui keeps no second copy of it. */
+test('the preset names are the slot layout editor\'s, not a copy here', () => {
+  for (const lang of ['en', 'es', 'ja', 'ko', 'ms', 'zh'])
+    assert.deepEqual(Object.keys(JSON.parse(read(`../translations/${lang}.json`))).filter(key => key.includes('slot-preset')), [], lang)
+})