@things-factory/figure-ui 10.1.203 → 10.1.205

package/test/fasten-form.test.ts

@@ -6,10 +6,10 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { addFigureBox, applyFigureAuthoring, createFigureAsset } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
 import type { FigureAsset } from '@hatiolab/figure-model'
 
-import { aimFasten, fastenChanged, fastenDetailWordsOf, fastenFormOf, fastenPlanOf, fastenSentenceOf, fastenTargetsOf, freshFasten } from '../client/modeller/fasten-form.ts'
+import { aimFasten, aimFastenAt, fastenChanged, fastenDetailWordsOf, fastenFormOf, fastenPlanOf, fastenSentenceOf, fastenTargetsOf, freshFasten } 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]! } })
@@ -40,6 +40,25 @@ test('on the plane: a floor takes a part standing on it or hanging below it, a w
   assert.equal((fastenPlanOf(revisionOf(wall), 'lamp', hung).action as { facing?: string }).facing, undefined, 'a wall: standing out of it')
 })
 
+test('aimed at the plane, the way starts toward the side the placement uses: below a ceiling, on a floor, out of a wall', () => {
+  const lamp = (placement?: 'ceiling' | 'wall') => {
+    const loose = addFigureBox(createFigureAsset('Lamp'), { id: 'lamp', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 0, z: 0 } })
+    return revisionOf(placement ? applyFigureAuthoring(loose, { kind: 'set-placement', placement }) : loose)
+  }
+  const aimed = (r: ReturnType<typeof lamp>) => aimFasten(r, 'lamp', fastenFormOf(r, 'lamp'), { plane: true })
+  const ceiling = lamp('ceiling')
+  const form = aimed(ceiling)
+  assert.equal(form.facing, 'flush', 'a ceiling: hung below it')
+  const applied = applyFigureAuthoring(ceiling.asset, fastenPlanOf(ceiling, 'lamp', form).action!)
+  const at = (compileFigureAsset(applied).evaluate().geometry as Array<{ id: string; pose?: { t: number[] } }>).find(g => g.id === 'lamp')!.pose!.t
+  assert.equal(at[1], -50, 'at -h/2, below the ceiling')
+  assert.equal(aimed(lamp()).facing, 'meet', 'a floor: standing on it')
+  assert.equal(aimed(lamp('wall')).facing, 'meet', 'a wall: standing out of it')
+  /* Only where it starts: set on the ceiling plane when the author says so. */
+  const set = fastenChanged(ceiling, 'lamp', form, { mode: 'meet' })
+  assert.equal((fastenPlanOf(ceiling, 'lamp', set).action as { facing?: string }).facing, 'meet')
+})
+
 test('the one it has, unchanged, comes to the attach that replaces it with the same place across the face', () => {
   const r = conveyor()
   const plan = fastenPlanOf(r, 'roller', fastenFormOf(r, 'roller'))
@@ -83,3 +102,64 @@ test('the target list: every other part, the one hanging from this part listed a
   ])
   assert.deepEqual(fastenTargetsOf(r, 'lid').map(t => t.part), ['frame', 'roller'])
 })
+
+/* A drum lying on the floor along Y and a ball, with a tag standing beside each (ADR-0140 3.9). */
+async function curved() {
+  const { addFigurePrimitive } = await import('@hatiolab/figure-model')
+  let a = addFigurePrimitive(createFigureAsset('Curved'), { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 1600 }, position: { x: 0, y: 0, z: 0 } } as never)
+  a = addFigurePrimitive(a, { id: 'ball', kind: 'sphere', dimensions: { radiusX: 100, radiusY: 100, radiusZ: 100 }, position: { x: 0, y: 0, z: 3000 } } as never)
+  a = box(a, 'tag', [40, 40, 40], [600, 600, 600])
+  return box(a, 'cap', [40, 40, 40], [0, 600, 3000])
+}
+
+test('aimed at a cylinder it stands beside, it goes on the side at the point it faces; aimed at a sphere, on its round', async () => {
+  const r = revisionOf(await curved())
+  const drum = aimFasten(r, 'tag', freshFasten(), { part: 'drum' })
+  assert.deepEqual(drum.surface, { around: 315, along: { mm: 600 } }, 'beside it, 600 up its length, toward +X +Z')
+  const plan = fastenPlanOf(r, 'tag', drum)
+  assert.deepEqual((plan.action as { to: unknown }).to, { part: 'drum', surface: { around: 315, along: { mm: 600 } } })
+  assert.equal((plan.action as { align?: unknown }).align, undefined, 'on a surface, where is its own words')
+  assert.deepEqual(plan.surface, { form: 'around', axis: 'y', place: { around: 315, along: { mm: 600 } } })
+  assert.equal(fastenSentenceOf(drum, plan, '바닥', say), 'figure.text.fasten-sentence-meet(to=drum의 figure.label.surface-around())')
+  const ball = aimFasten(r, 'cap', freshFasten(), { part: 'ball' })
+  assert.deepEqual(ball.surface, { toward: { x: 0, y: 1, z: 0 } }, 'straight above it')
+  /* Applied, and opened again: on the surface as it was. */
+  const done = applyFigureAuthoring(r.asset, plan.action!)
+  assert.deepEqual(fastenFormOf(revisionOf(done), 'tag').surface, { around: 315, along: { mm: 600 } })
+  const { rowBlockOf } = await import('../client/modeller/links.ts')
+  assert.equal(rowBlockOf(done, 'tag'), 'on-surface', 'a point of a curved surface has no face to lay a row across')
+})
+
+test('a face or the surface, as the drawing asks; the surface chosen starts where the part stands', async () => {
+  const r = revisionOf(await curved())
+  const side = aimFasten(r, 'tag', freshFasten(), { part: 'drum' })
+  const top = fastenChanged(r, 'tag', side, { targetFace: 'top' })
+  assert.equal(top.surface, undefined, 'its end disc is a face')
+  assert.deepEqual((fastenPlanOf(r, 'tag', top).action as { to: unknown }).to, { part: 'drum', face: 'top' })
+  const back = fastenChanged(r, 'tag', top, { onSurface: true })
+  assert.deepEqual(back.surface, { around: 315, along: { mm: 600 } })
+  const turned = fastenChanged(r, 'tag', back, { surface: { around: 90, along: 'max' } })
+  assert.deepEqual((fastenPlanOf(r, 'tag', turned).action as { to: unknown }).to, { part: 'drum', surface: { around: 90, along: 'max' } })
+})
+
+test("pressed on the canvas: the face or the point pressed, read in that part's own frame; itself and a curve with no fastening said (ADR-0140 stage 4)", async () => {
+  const { addFigurePrimitive } = await import('@hatiolab/figure-model')
+  /* A drum lying along X (turned a quarter about Z), a rounded box, and the tag to fasten. */
+  let a = addFigurePrimitive(createFigureAsset('Pressed'), { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 400 }, position: { x: 0, y: 500, z: 0 }, rotation: { x: 0, y: 0, z: 90 } } as never)
+  a = addFigurePrimitive(a, { id: 'soft', kind: 'rounded-box', dimensions: { width: 300, height: 200, depth: 300, round: 40 }, position: { x: 0, y: 100, z: 1500 } } as never)
+  const r = revisionOf(box(a, 'tag', [40, 40, 40], [900, 900, 900]))
+  const pose = (r.geometry as Array<{ id: string; pose: { r: number[][]; t: number[] } }>).find(g => g.id === 'drum')!.pose
+  const world = (v: number[], move = true) => [0, 1, 2].map(i => [0, 1, 2].reduce((s, c) => s + pose.r[i]![c]! * v[c]!, move ? pose.t[i]! : 0))
+  const rad = (d: number) => (d * Math.PI) / 180
+  const at = (deg: number) => [Math.cos(rad(deg)), 0, -Math.sin(rad(deg))]
+  /* A 12-sided drawing: the facet between 0° and 30°, pressed where the ray at 20° meets it, 50 up its own Y. */
+  const s = (100 * Math.cos(rad(15))) / Math.cos(rad(5))
+  const press = { id: 'drum', point: world(at(20).map((v, i) => (i === 1 ? 50 : v * s))), normal: world(at(15), false) }
+  const side = aimFastenAt(r, 'tag', freshFasten(), press)
+  assert.deepEqual([side.note, side.form?.target, side.form?.surface], [undefined, 'drum', { around: 20, along: { mm: 50 } }])
+  const end = aimFastenAt(r, 'tag', freshFasten(), { id: 'drum', point: world([10, 200, 20]), normal: world([0, 1, 0], false) })
+  assert.deepEqual([end.form?.surface, end.form?.targetFace, end.form?.align, end.form?.alignMm], [undefined, 'top', { x: 'mm', z: 'mm' }, { x: 10, z: 20 }], "its end, wherever the drum's own Y lies, its middle where pressed")
+  assert.deepEqual(aimFastenAt(r, 'tag', freshFasten(), { id: 'tag', point: [900, 920, 900], normal: [0, 1, 0] }), { note: 'aim-self', part: 'tag' })
+  const corner = aimFastenAt(r, 'tag', freshFasten(), { id: 'soft', point: [145, 100, 1645], normal: [Math.SQRT1_2, 0, Math.SQRT1_2] })
+  assert.deepEqual([corner.note, corner.form?.target], ['aim-not-here', 'soft'], 'a rounded corner: aimed at the part, said')
+})

package/test/gizmo.test.ts

@@ -127,33 +127,31 @@ test('원기둥 · 구도 크기 기즈모가 먹는다 — 단면은 원으로'
 })
 
 /*
- * 높이를 숫자로 적거나 손잡이로 키워도, 도형의 배치가 지키는 면이 그 자리에 있다 — figure-model 의 한 규칙
- * (`figureSizeEditChanges`, ADR-0097). 전에는 화면이 제 산수로 배치와 상관없이 아랫면을 지켰다. 2200 을 적은 기둥이
- * 바닥 아래로 933 mm 묻혔던 일(09-26)은 바닥 도형에서 그대로 막힌다. 돌려 세운 부품은 그 높이가 위아래가 아니라 건드리지 않는다.
+ * 크기는 커널의 한 함수로 바뀐다(ADR-0140 4.1 · 4.2, `figureSizeEditOf`): 숫자 칸은 부품의 가운데를, 손잡이는 잡은
+ * 쪽의 반대편을 그 자리에 둔다 — 배치(바닥 · 천장)와 상관없이, 누운 원기둥이든 서 있는 기둥이든. 같은 치수 · 같은
+ * 기준이면 칸과 손잡이가 같은 결과다.
  */
-test('크기 칸과 손잡이 — 배치가 지키는 면을 지킨다, 커널의 한 규칙으로', async () => {
-  const { figureSizeEditChanges, applyFigureAuthoring, proposeFigureOccupancy } = await import('@hatiolab/figure-model')
+test('크기 칸은 가운데를, 손잡이는 반대쪽을 — 배치와 상관없이 커널의 한 함수로', async () => {
+  const { figureSizeEditOf, applyFigureAuthoring } = await import('@hatiolab/figure-model')
   let asset = createFigureAsset('Post')
   asset = addFigureBox(asset, { id: 'post', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-  asset = addFigurePrimitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 100 }, position: { x: 0, y: 300, z: 0 } })
   asset = addFigurePrimitive(asset, { id: 'roller', kind: 'cylinder', dimensions: { radius: 30, length: 500 }, position: { x: 0, y: 30, z: 0 }, rotation: { x: 90, y: 0, z: 0 } })
   const centreY = (a: typeof asset, part: string) => {
     const g = compileFigureAsset(a).evaluate().geometry.find(o => o.id === part)! as unknown as { pose: { t: number[] } }
     return g.pose.t[1]!
   }
   const set = (input: string, value: number) => ({ kind: 'set-design', input, unit: 'mm', value }) as never
-  const grow = (a: typeof asset, part: string, input: string, value: number) => apply(a, figureSizeEditChanges(a, part, [set(input, value)]))
+  const grow = (a: typeof asset, part: string, input: string, value: number, keep: never) => apply(a, figureSizeEditOf(a, part, [set(input, value)], keep).changes)
   const postH = gizmoReachOf(asset, 'post').sizes![1]
-  assert.equal(centreY(grow(asset, 'post', postH, 2200), 'post') - 2200 / 2, 0, '바닥 도형(선언 전 기본): 기둥 아랫면이 바닥에')
-  const drumH = gizmoReachOf(asset, 'drum').round!.along[0]!
-  assert.equal(centreY(grow(asset, 'drum', drumH, 300), 'drum') - 300 / 2, 300 - 100 / 2, '원기둥도 아랫면이 제자리')
+  assert.equal(centreY(grow(asset, 'post', postH, 2200, { keep: 'centre' } as never), 'post'), 50, '숫자 칸: 가운데가 그 자리')
+  assert.equal(centreY(grow(asset, 'post', postH, 2200, { keep: 'opposite', axis: 'y', side: 1 } as never), 'post') - 2200 / 2, 0, '위 손잡이: 아랫면이 그 자리')
+  assert.equal(centreY(grow(asset, 'post', postH, 2200, { keep: 'opposite', axis: 'y', side: -1 } as never), 'post') + 2200 / 2, 100, '아래 손잡이: 윗면이 그 자리')
   const rollerLength = gizmoReachOf(asset, 'roller').round!.along[0]!
-  assert.deepEqual(figureSizeEditChanges(asset, 'roller', [set(rollerLength, 800)]), [set(rollerLength, 800)], '누운 롤러의 길이는 위아래가 아니다')
-  assert.deepEqual(figureSizeEditChanges(asset, 'post', [set(gizmoReachOf(asset, 'post').sizes![0], 800)]), [set(gizmoReachOf(asset, 'post').sizes![0], 800)], '폭은 가운데 그대로')
-  /* 천장 도형이면 윗면을 지킨다 — 전에는 여기서도 아랫면을 지켜 천장을 뚫고 올라갔다. */
+  assert.deepEqual(figureSizeEditOf(asset, 'roller', [set(rollerLength, 800)], { keep: 'centre' }).changes, [set(rollerLength, 800)], '누운 롤러의 길이: 가운데가 원점이라 자리는 그대로')
+  /* 천장 도형도 같다 — 배치가 지키는 면을 따로 두지 않는다(ADR-0140 4.1 이 ADR-0097 §4.3 을 대신함). */
   let hung = addFigureBox(createFigureAsset('Lamp'), { id: 'lamp', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: -50, z: 0 } })
-  hung = applyFigureAuthoring(hung, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(hung), placement: 'ceiling' })
-  assert.equal(centreY(grow(hung, 'lamp', gizmoReachOf(hung, 'lamp').sizes![1], 300), 'lamp') + 300 / 2, 0, '천장 도형: 윗면이 천장에')
+  hung = applyFigureAuthoring(hung, { kind: 'set-placement', placement: 'ceiling' })
+  assert.equal(centreY(grow(hung, 'lamp', gizmoReachOf(hung, 'lamp').sizes![1], 300, { keep: 'centre' } as never), 'lamp'), -50, '천장 도형: 숫자 칸도 가운데')
 })
 
 /* 손잡이는 키를 몰라도 찾는다 — 도구 막대에 옮기기 · 돌리기 · 크기, 제 숫자로 놓인 부품에만 (09-26). */

package/test/links.test.ts

@@ -367,8 +367,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',
@@ -379,10 +379,15 @@ test('면은 도형이 정한다 — 문틀(portal)은 바깥 여섯에 개구
   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: '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 }])

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)
+})

package/translations/en.json

@@ -201,8 +201,11 @@
   "figure.label.section-editor-across": "{axis} width (mm)",
   "figure.label.section-editor-diameter": "diameter (mm)",
   "figure.text.section-editor-linked": "Follows another value.",
-  "figure.text.section-editor-keeps": "keeps {face}",
-  "figure.text.section-editor-keeps-centre": "keeps the centre",
+  "figure.text.size-keeps-centre": "keeps the centre",
+  "figure.text.size-keeps-fastening": "keeps where it is fastened",
+  "figure.text.size-keeps-none": "keeps its worked-out position",
+  "figure.text.size-through-plane": "{part} goes {mm} mm past the {plane}.",
+  "figure.button.fasten-to-plane": "Fasten to the {plane}",
   "figure.text.section-issue-corner": "At this width the corner radius can be at most {max} mm. Widen it or make the corner smaller.",
   "figure.text.section-issue-length": "The push length must be more than 0.",
   "figure.text.section-issue-cavity-walls": "The inside walls take the whole width. Widen it or make the walls thinner.",
@@ -559,6 +562,7 @@
   "figure.label.fasten-what": "Which part",
   "figure.label.fasten-face-on-part": "Which face of {part}",
   "figure.label.fasten-face-on-plane": "Where on the {plane}",
+  "figure.label.fasten-face-on-surface": "Where on {part}",
   "figure.label.fasten-how": "How it sits",
   "figure.label.facing": "How faces meet",
   "figure.text.fasten-summary-gap": "gap {mm} mm",
@@ -576,6 +580,11 @@
   "figure.label.face-top": "top",
   "figure.label.face-back": "back",
   "figure.label.face-front": "front",
+  "figure.label.surface-around": "curved side",
+  "figure.label.surface-toward": "curved surface",
+  "figure.label.surface-seen-end": "{part} seen from its end",
+  "figure.label.surface-seen-above": "from above",
+  "figure.label.surface-seen-side": "from the side",
   "figure.text.motion-explained": "How this part moves. Added on top of its fastening, never instead of it.",
   "figure.label.motion-none": "does not move",
   "figure.label.motion-slide": "slide",
@@ -702,6 +711,10 @@
   "figure.text.row-blocked-on-plane": "Fasten it to another part, not the mounting plane, to arrange it in a row along that part.",
   "figure.text.row-blocked-at-origin": "It stands at another part's origin. Fasten it to a face of that part to arrange it in a row along it.",
   "figure.text.row-blocked-holds-parts": "Parts are fastened to this part, so it cannot be arranged in a row. Arrange it first; parts fastened after ride every copy.",
+  "figure.text.row-blocked-on-surface": "It is fastened to a point on a curved surface, so it cannot be arranged in a row. Fasten it to a face to arrange it in a row.",
+  "figure.text.aim-self": "{part} cannot be fastened to itself.",
+  "figure.text.aim-cannot": "{part} has no face or curved surface to fasten to.",
+  "figure.text.aim-not-here": "That spot on {part} cannot be fastened to; choose a face.",
   "figure.button.go-fasten": "go to fastening",
   "figure.text.row-count-pitch": "{count} × {part} · along {axis} · pitch {pitch} mm (centre to centre)",
   "figure.text.row-count-uneven": "{count} × {part} · along {axis} · unevenly spaced",
@@ -709,8 +722,7 @@
   "figure.text.row-ends": "{low} mm left at the low end · {high} mm at the high end",
   "figure.text.row-ends-unknown": "What is left at the ends could not be read.",
   "figure.text.row-companions": "copied along: {parts}",
-  "figure.text.instance-size-undeclared": "set a range and a drawing can resize it.",
-  "figure.button.declare-instance-size": "set the range it stretches over",
+  "figure.button.declare-instance-size": "let a drawing resize it",
   "figure.text.proposal-applied": "applied {n} commands as one step.",
   "figure.text.proposal-saved-into": "Saved into: {names}",
   "figure.text.proposal-needs-modeller": "this proposal can be applied only while its figure is open in the modeller.",
@@ -842,9 +854,6 @@
   "figure.text.held-on-part": "Attached to the {otherFace} of {other}",
   "figure.button.open-fastening": "Open attachment settings",
   "figure.button.detach-held": "Detach",
-  "figure.text.gizmo-size-turned-fastening": "{part} is attached turned, so its size cannot be dragged.",
-  "figure.text.gizmo-size-tilted": "{part} is tilted, so its size cannot be dragged.",
-  "figure.button.to-size-fields": "Go to size",
   "figure.label.align-input": "Follows its field ({field})",
   "figure.label.tab-short-properties": "Properties",
   "figure.label.tab-short-capability": "Capability",
@@ -1004,19 +1013,6 @@
   "figure.text.slot-layout-issues": "the value at {path} in the slot layout is not valid.",
   "figure.text.slot-accepts-empty": "slot {slot} takes no type.",
   "figure.text.slot-id-taken": "{slot} is already the name of a place in this figure.",
-  "figure.label.slot-preset-single": "single slot",
-  "figure.label.slot-preset-agvTandem": "AGV tandem (front/rear)",
-  "figure.label.slot-preset-agvParallel": "AGV parallel (left/right)",
-  "figure.label.slot-preset-agv2x2": "AGV 2×2",
-  "figure.label.slot-preset-bufferPort2x2": "buffer port 2×2",
-  "figure.label.slot-preset-multiBufferPort": "multi-buffer port (4)",
-  "figure.label.slot-preset-dualTierConveyor": "dual-tier conveyor",
-  "figure.label.slot-preset-craneTwinFork": "crane twin fork",
-  "figure.label.slot-preset-floorBlock": "floor block",
-  "figure.label.slot-preset-param-upperElevation": "upper tier elevation (mm)",
-  "figure.label.slot-preset-param-rows": "rows",
-  "figure.label.slot-preset-param-cols": "columns",
-  "figure.label.slot-preset-param-stackLimit": "stack limit",
   "figure.label.placement": "fastening",
   "figure.label.motion-groups": "motion groups",
   "figure.label.motion-group": "motion group",
@@ -1187,7 +1183,7 @@
   "figure.text.size-and-space-declared-to-follow": "the figure size was set from its parts, {x} × {y} × {z} mm, and the space it takes was fitted to them.",
   "figure.button.release-blocked": "{count} blocks release",
   "figure.label.preview-way-one": "one",
-  "figure.label.preview-way-eight": "eight sizes",
+  "figure.label.preview-way-eight": "various sizes",
   "figure.text.preview-needs-space": "set the space it takes to try other sizes.",
   "figure.text.released-figure-not-deletable": "{name} has been released and cannot be deleted. retire it in its details.",
   "figure.label.retired": "retired",
@@ -1205,5 +1201,12 @@
   "figure.button.make-public": "make public",
   "figure.button.make-private": "make private",
   "figure.text.category-choose": "choose a category",
-  "figure.text.property-section-failed": "the section {section} could not be drawn: {reason}"
+  "figure.text.property-section-failed": "the section {section} could not be drawn: {reason}",
+  "figure.label.board-size": "size on a drawing",
+  "figure.text.board-size-fixed": "On a drawing it is always drawn at {x} × {y} × {z} mm.",
+  "figure.text.board-size-fixed-explained": "Press it to let a drawing resize this figure. Pick a part and press 「fit to the figure size」 to make that part grow with it.",
+  "figure.text.board-size-range-explained": "A drawing can resize it within these ranges. Only the parts that follow its size grow with it; the rest stay as they are.",
+  "figure.text.board-size-followers": "parts that change with its size: {parts}",
+  "figure.text.board-size-followers-more": "{first} and {rest} more",
+  "figure.text.board-size-no-followers": "no part changes with its size"
 }