@things-factory/figure-ui 10.1.200 → 10.1.202

package/test/links.test.ts

@@ -41,7 +41,7 @@ test('크기 — 제 치수 · 인스턴스 크기 · 다른 부품의 치수를
 test('붙이기 — 누구에게 붙었나, 붙일 수 있는 모양인가', () => {
   const asset = pair()
   assert.equal(fastenedTo(asset, 'block'), null)
-  const fastened = applyFigureAuthoring(asset, { kind: 'attach', part: 'block', face: 'bottom', to: { part: 'plate', face: 'top' } })
+  const fastened = applyFigureAuthoring(asset, { kind: 'attach', part: 'block', to: { part: 'plate', face: 'top' } })
   assert.equal(fastenedTo(fastened, 'block'), 'plate')
   assert.equal(fastenedTo(applyFigureAuthoring(fastened, { kind: 'detach', part: 'block' }), 'block'), null)
   const withDrum = addFigurePrimitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 100 }, position: { x: 0, y: 50, z: 0 } })
@@ -69,7 +69,7 @@ test('움직임 — 미끄러짐 · 돌기, 축, 무엇이 모느냐를 읽는
 
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
-import { alignRowsOf, choiceOf, followCommandOf, ownFacesOf } from '../client/modeller/links.ts'
+import { alignRowsOf, choiceOf, followCommandOf } from '../client/modeller/links.ts'
 import { faceViewOf } from '../client/modeller/fasten-geometry.ts'
 import { moving } from './joints.ts'
 
@@ -244,8 +244,8 @@ test('한 비율로 커지는 도형 — 자기 숫자인 길이를 세고, 한
   let asset = createFigureAsset('Probe')
   asset = addFigureBox(asset, { id: 'base', size: { x: 400, y: 100, z: 400 }, position: { x: 0, y: 0, z: 0 } })
   asset = addFigureBox(asset, { id: 'lamp', size: { x: 60, y: 60, z: 60 }, position: { x: 0, y: 0, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'base', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'lamp', face: 'bottom', to: { part: 'base', face: 'top' }, align: { x: { mm: 120 } } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'base', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'lamp', to: { part: 'base', face: 'top' }, align: { x: { mm: 120 } } })
   asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 40, max: 4000 }, y: { min: 16, max: 1600 }, z: { min: 40, max: 4000 } } })
   assert.equal(proportionToFollow(asset), undefined, '한 비율이 아니면 권하지 않는다')
   asset = applyFigureAuthoring(asset, { kind: 'scale-uniformly' })
@@ -271,20 +271,20 @@ test('붙일 때 면 위 어디에 — 그 면을 가로지르는 두 축만,
   two = addFigureBox(two, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 1050, z: 0 } })
   two = addFigureBox(two, { id: 'leaf', size: { x: 900, y: 2000, z: 40 }, position: { x: 600, y: 1000, z: 0 } })
   const right = { part: 'jamb', face: 'right' }
-  assert.deepEqual(alignAxesOf(two, 'leaf', right), [{ axis: 'y', edges: true }, { axis: 'z', edges: true }])
-  assert.deepEqual(alignAxesOf(two, 'leaf', 'plane'), [{ axis: 'x', edges: false }, { axis: 'z', edges: false }])
+  assert.deepEqual(alignAxesOf(two, right), [{ axis: 'y', edges: true }, { axis: 'z', edges: true }])
+  assert.deepEqual(alignAxesOf(two, 'plane'), [{ axis: 'x', edges: false }, { axis: 'z', edges: false }])
   /* A door on the jamb's right face: bottoms level, fronts level. The x choice is along the face and is not sent. */
-  assert.deepEqual(alignOf(two, 'leaf', right, { x: 'max', y: 'min', z: 'max' }, {}), { y: 'min', z: 'max' })
-  assert.deepEqual(alignOf(two, 'leaf', { part: 'jamb', face: 'top' }, { x: 'mm', z: 'centre' }, { x: 120 }), { x: { mm: 120 } })
-  assert.equal(alignOf(two, 'leaf', 'plane', { x: 'min' }, {}), undefined, '바닥에는 맞출 모서리가 없다')
-  assert.equal(alignOf(two, 'leaf', { part: 'jamb', face: 'top' }, {}, {}), undefined)
+  assert.deepEqual(alignOf(two, right, { x: 'max', y: 'min', z: 'max' }, {}), { y: 'min', z: 'max' })
+  assert.deepEqual(alignOf(two, { part: 'jamb', face: 'top' }, { x: 'mm', z: 'centre' }, { x: 120 }), { x: { mm: 120 } })
+  assert.equal(alignOf(two, 'plane', { x: 'min' }, {}), undefined, '바닥에는 맞출 모서리가 없다')
+  assert.equal(alignOf(two, { part: 'jamb', face: 'top' }, {}, {}), undefined)
 
   /* What the form sends is what hangs the part on the edge: the door's pivot is on the jamb's front edge line. */
   let asset = createFigureAsset('Door')
   asset = addFigureBox(asset, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 1050, z: 0 } })
   asset = addFigureBox(asset, { id: 'leaf', size: { x: 900, y: 2000, z: 40 }, position: { x: 600, y: 1000, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'leaf', face: 'left', to: { part: 'jamb', face: 'right' }, align: alignOf(asset, 'leaf', { part: 'jamb', face: 'right' }, { y: 'min', z: 'max' }, {}) })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'leaf', to: { part: 'jamb', face: 'right' }, align: alignOf(asset, { part: 'jamb', face: 'right' }, { y: 'min', z: 'max' }, {}) })
   const { compileFigureAsset } = await import('@hatiolab/figure-model')
   const leaf = compileFigureAsset(asset).evaluate().geometry.find(g => g.id === 'leaf')!
   assert.deepEqual(leaf.pose.t.map(Math.round), [500, 1000, 55], '문짝 아래가 문틀 아래에, 앞이 문틀 앞에')
@@ -295,13 +295,13 @@ test('the fastening form asks across the face in rows only where the drawing can
   asset = addFigureBox(asset, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 1050, z: 0 } })
   asset = addFigureBox(asset, { id: 'leaf', size: { x: 900, y: 2000, z: 40 }, position: { x: 600, y: 1000, z: 0 } })
   const right = { part: 'jamb', face: 'right' }
-  const view = faceViewOf(revisionOf(asset), 'leaf', right)
+  const view = faceViewOf(revisionOf(asset), 'leaf', right, 'meet')
   assert.deepEqual(view?.axes, ['y', 'z'])
-  assert.deepEqual(alignRowsOf(asset, 'leaf', right, view, false), [], 'the drawing sets both')
-  assert.deepEqual(alignRowsOf(asset, 'leaf', right, undefined, false), [{ axis: 'y', edges: true }, { axis: 'z', edges: true }], 'with no drawing, both are asked')
-  assert.deepEqual(alignRowsOf(asset, 'leaf', right, view, false, { y: 'leaf.position.y' }), [{ axis: 'y', edges: true }], 'the axis that follows a position field')
+  assert.deepEqual(alignRowsOf(asset, right, view), [], 'the drawing sets both')
+  assert.deepEqual(alignRowsOf(asset, right, undefined), [{ axis: 'y', edges: true }, { axis: 'z', edges: true }], 'with no drawing, both are asked')
+  assert.deepEqual(alignRowsOf(asset, right, view, { y: 'leaf.position.y' }), [{ axis: 'y', edges: true }], 'the axis that follows a position field')
   const sized = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 100, max: 5000 }, y: { min: 100, max: 5000 }, z: { min: 10, max: 500 } }, at: { x: 1000, y: 2100, z: 150 } })
-  assert.deepEqual(alignRowsOf(sized, 'leaf', right, faceViewOf(revisionOf(sized), 'leaf', right), true).map(r => r.axis), ['y', 'z'], 'the axes a share of the figure size may set')
+  assert.deepEqual(alignRowsOf(sized, right, faceViewOf(revisionOf(sized), 'leaf', right, 'meet')).map(r => r.axis), ['y', 'z'], 'the axes a share of the figure size may set')
 })
 
 test('붙여도 제자리 — 폼은 지금 서 있는 자리를 가운데서 거리로 채운다 (문짝이 문틀 앞 100 mm 에서 가운데로 옮겨졌다, 09-26)', async () => {
@@ -313,9 +313,9 @@ test('붙여도 제자리 — 폼은 지금 서 있는 자리를 가운데서
   const where = (a: FigureAsset) => compileFigureAsset(a).evaluate().geometry.find(g => g.id === 'leaf')!.pose.t.map(v => Math.round(v))
   for (const target of ['plane', { part: 'frame', face: 'top' }] as const) {
     const kept = placeKeptOf(revisionOf(asset), 'leaf', target)
-    const align = alignOf(asset, 'leaf', target, kept.align, kept.alignMm)
+    const align = alignOf(asset, target, kept.align, kept.alignMm)
     const to = target === 'plane' ? { plane: 'mounting-plane' as const } : target
-    const fastened = applyFigureAuthoring(asset, { kind: 'attach', part: 'leaf', face: 'bottom', to, ...(align ? { align } : {}) } as never)
+    const fastened = applyFigureAuthoring(asset, { kind: 'attach', part: 'leaf', to, ...(align ? { align } : {}) } as never)
     const [before, after] = [where(asset), where(fastened)]
     assert.deepEqual([after[0], after[2]], [before[0], before[2]], `${JSON.stringify(target)}: 앞뒤·좌우는 그대로`)
   }
@@ -328,8 +328,8 @@ test('붙여도 제자리 — 폼은 지금 서 있는 자리를 가운데서
   let row = addFigureBox(createFigureAsset('Row'), { id: 'plate', size: { x: 1000, y: 50, z: 400 }, position: { x: 0, y: 700, z: 0 } })
   row = addFigureBox(row, { id: 'roller', size: { x: 60, y: 60, z: 400 }, position: { x: 0, y: 760, z: 0 } })
   row = addFigureBox(row, { id: 'cap', size: { x: 20, y: 20, z: 20 }, position: { x: 0, y: 800, z: 0 } })
-  row = applyFigureAuthoring(row, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'plate', face: 'top' } })
-  row = applyFigureAuthoring(row, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'roller', face: 'top' } })
+  row = applyFigureAuthoring(row, { kind: 'attach', part: 'roller', to: { part: 'plate', face: 'top' } })
+  row = applyFigureAuthoring(row, { kind: 'attach', part: 'cap', to: { part: 'roller', face: 'top' } })
   assert.deepEqual([hangsFrom(row, 'roller', 'plate'), hangsFrom(row, 'cap', 'plate'), hangsFrom(row, 'plate', 'roller')], [true, true, false])
 })
 
@@ -340,10 +340,10 @@ test('따라 움직이는 관절 — 같은 방식으로 움직이고 제 조작
   asset = addFigureBox(asset, { id: 'palm', size: { x: 240, y: 70, z: 160 }, position: { x: 0, y: 35, z: 0 } })
   for (const id of ['left', 'right']) asset = addFigureBox(asset, { id, size: { x: 30, y: 140, z: 100 }, position: { x: 0, y: 200, z: 0 } })
   asset = addFigureBox(asset, { id: 'wrist', size: { x: 60, y: 60, z: 60 }, position: { x: 0, y: 400, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'palm', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'left', face: 'bottom', to: { part: 'palm', face: 'top' }, align: { x: 'min' } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'right', face: 'bottom', to: { part: 'palm', face: 'top' }, align: { x: 'max' } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'wrist', face: 'top', to: { part: 'palm', face: 'bottom' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'palm', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'left', to: { part: 'palm', face: 'top' }, align: { x: 'min' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'right', to: { part: 'palm', face: 'top' }, align: { x: 'max' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'wrist', to: { part: 'palm', face: 'bottom' } })
   const form = { kind: 'slide' as const, axis: 'x' as const, id: 'grip', min: 0, max: 60, follow: '', multiplier: 1, offset: 0 }
   const jointOf = (part: string) => asset.joints!.find(j => j.body1.part === part)!
   asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: motionJoint(jointOf('left'), form, 'left') })
@@ -385,8 +385,8 @@ test('면은 도형이 정한다 — 문틀(portal)은 바깥 여섯에 개구
   assert.equal(canFasten(asset, 'ball'), false, '공은 붙일 면이 없다')
   assert.equal(canFasten(asset, 'frame'), true)
   assert.deepEqual(facesOf(asset, 'cone'), ['bottom', 'top'])
-  assert.deepEqual(alignAxesOf(asset, 'leaf', { part: 'frame', face: 'opening-left' }), [{ axis: 'y', edges: true }, { axis: 'z', edges: true }])
-  assert.deepEqual(alignAxesOf(asset, 'leaf', { part: 'cone', face: 'top' }), [{ axis: 'x', edges: false }, { axis: 'z', edges: false }], '옆면이 평면이 아니면 모서리도 없다')
+  assert.deepEqual(alignAxesOf(asset, { part: 'frame', face: 'opening-left' }), [{ axis: 'y', edges: true }, { axis: 'z', edges: true }])
+  assert.deepEqual(alignAxesOf(asset, { part: 'cone', face: 'top' }), [{ axis: 'x', edges: false }, { axis: 'z', edges: false }], '옆면이 평면이 아니면 모서리도 없다')
 })
 
 test('되풀이는 붙어 있고 움직이지 않고 아무것도 매달지 않은 부품에 — 붙인 면을 가로지르는 축으로 (빈틈 B, 2026-09-25)', async () => {
@@ -395,24 +395,30 @@ test('되풀이는 붙어 있고 움직이지 않고 아무것도 매달지 않
   asset = addFigureBox(asset, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
   asset = addFigureBox(asset, { id: 'slat', size: { x: 60, y: 20, z: 560 }, position: { x: 0, y: 0, z: 0 } })
   assert.deepEqual(rowAxesOf(asset, 'slat'), [], '붙지 않은 부품은 되풀이를 권하지 않는다')
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'slat', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'frame', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'slat', to: { part: 'frame', face: 'top' } })
   assert.deepEqual(rowAxesOf(asset, 'frame'), [], '바닥에 선 부품은 채울 길이가 없다')
   assert.deepEqual(rowAxesOf(asset, 'slat'), ['x', 'z'], '윗면을 가로지르는 두 축')
+  assert.deepEqual(rowAxesOf(applyFigureAuthoring(asset, { kind: 'attach', part: 'slat', to: { part: 'frame', face: 'front' }, replace: true }), 'slat'), ['x', 'y'], '앞면이면 앞면을 가로지르는 두 축')
   asset = applyFigureAuthoring(asset, { kind: 'make-repeat', part: 'slat', axis: 'x', pitch: 100 })
   assert.deepEqual(rowOf(asset, 'slat'), { axis: 'X', pitch: 100 })
   assert.deepEqual(rowAxesOf(asset, 'slat'), [], '이미 되풀이면 다시 권하지 않는다')
 })
 
-test('비튼 부품에는 모서리 맞춤을 내놓지도 보내지도 않는다 — 가운데서 거리만 (빈틈 F, 2026-09-25)', async () => {
+test('돌려 놓인 부품에도 모서리 맞춤을 내놓는다 — 지금 자세의 실제 끝으로 맞춘다 (ADR-0140 3.4)', async () => {
   const { alignAxesOf, alignOf } = await import('../client/modeller/links.ts')
   let asset = createFigureAsset('Fan')
   asset = addFigureBox(asset, { id: 'hub', size: { x: 120, y: 120, z: 80 }, position: { x: 0, y: 0, z: 0 } })
-  asset = addFigureBox(asset, { id: 'blade', size: { x: 300, y: 60, z: 8 }, position: { x: 0, y: 0, z: 0 } })
+  asset = addFigureBox(asset, { id: 'blade', size: { x: 300, y: 60, z: 8 }, position: { x: 0, y: 0, z: 0 }, rotation: { x: 0, y: 0, z: 30 } })
   const front = { part: 'hub', face: 'front' }
-  assert.deepEqual(alignAxesOf(asset, 'blade', front, true), [{ axis: 'x', edges: false }, { axis: 'y', edges: false }])
-  assert.deepEqual(alignOf(asset, 'blade', front, { x: 'max', y: 'mm' }, { y: 50 }, true), { y: { mm: 50 } }, '끝 맞춤은 빠지고 거리만 간다')
-  assert.deepEqual(alignOf(asset, 'blade', front, { x: 'max' }, {}), { x: 'max' }, '비틀지 않으면 그대로')
+  assert.deepEqual(alignAxesOf(asset, front), [{ axis: 'x', edges: true }, { axis: 'y', edges: true }])
+  assert.deepEqual(alignOf(asset, front, { x: 'max', y: 'mm' }, { y: 50 }), { x: 'max', y: { mm: 50 } })
+  /* Fastened so, its real reach is level with the hub's right side, turned as it is. */
+  const { compileFigureAsset, figureFaceOverhangOf } = await import('@hatiolab/figure-model')
+  const on = applyFigureAuthoring(asset, { kind: 'attach', part: 'blade', to: front, align: { x: 'max' } })
+  assert.equal(figureFaceOverhangOf(on, 'blade')!.state, 'larger', 'wider than the hub: past its left edge, level with its right')
+  assert.deepEqual(figureFaceOverhangOf(on, 'blade')!.sides.filter(s => s.axis === 'x').map(s => s.side), ['low'])
+  void compileFigureAsset
 })
 
 test('모델러에서 만든 도형은 부품에서 재어 도형 크기를 선언한다 — 그 뒤에야 부품이 도형 크기를 따를 수 있다 (사용자 09-25)', async () => {
@@ -421,7 +427,7 @@ test('모델러에서 만든 도형은 부품에서 재어 도형 크기를 선
   let asset = createFigureAsset('Conveyor')
   assert.equal(instanceRangeToDeclare(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', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'frame', to: { plane: 'mounting-plane' } })
   assert.equal(hasInstanceSize(asset, 'x'), false, '새 도형에는 도형 크기가 없다')
   const toDeclare = instanceRangeToDeclare(asset)!
   assert.deepEqual(toDeclare.at, { x: 2000, y: 100, z: 600 }, '지금 부품의 크기가 선언할 크기')
@@ -456,8 +462,8 @@ test('미끄러짐의 이동 거리가 부품 길이를 따른다 — 레일이
   let asset = createFigureAsset('Gantry')
   asset = addFigureBox(asset, { id: 'rail', size: { x: 3000, y: 120, z: 120 }, position: { x: 0, y: 0, z: 0 } })
   asset = addFigureBox(asset, { id: 'bridge', size: { x: 160, y: 160, z: 1300 }, position: { x: 0, y: 0, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'rail', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'bridge', face: 'bottom', to: { part: 'rail', face: 'top' }, align: { x: 'min' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'rail', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'bridge', to: { part: 'rail', face: 'top' }, align: { x: 'min' } })
   const joint = asset.joints!.find(j => j.body1.part === 'bridge')!
   const form = { kind: 'slide' as const, axis: 'x' as const, id: 'x', min: 0, max: 500, follow: '', multiplier: 1, offset: 0, travel: 'rail:x', travelPlus: -160 }
   const record = motionJoint(joint, form, 'bridge')
@@ -480,14 +486,14 @@ test('면 위 거리를 도형 크기 비율로 — 도형이 커지면 그 자
   let asset = createFigureAsset('Panel')
   asset = addFigureBox(asset, { id: 'panel', size: { x: 1000, y: 800, z: 40 }, position: { x: 0, y: 0, z: 0 } })
   asset = addFigureBox(asset, { id: 'lamp', size: { x: 60, y: 60, z: 30 }, position: { x: 0, y: 0, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'panel', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'panel', to: { plane: 'mounting-plane' } })
   const front = { part: 'panel', face: 'front' }
-  assert.deepEqual(alignOf(asset, 'lamp', front, { x: 'share' }, { x: 300 }), undefined, '도형 크기가 없으면 비율을 보낼 수 없다')
+  assert.deepEqual(alignOf(asset, front, { x: 'share' }, { x: 300 }), undefined, '도형 크기가 없으면 비율을 보낼 수 없다')
   asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 200, max: 5000 }, y: { min: 200, max: 5000 }, z: { min: 10, max: 500 } }, at: { x: 1000, y: 800, z: 40 } })
   asset = applyFigureAuthoring(asset, { kind: 'link-dimension', part: 'panel', axis: 'x', source: { of: 'instance', axis: 'x' } })
-  const align = alignOf(asset, 'lamp', front, { x: 'share' }, { x: 300 })!
+  const align = alignOf(asset, front, { x: 'share' }, { x: 300 })!
   assert.deepEqual(align, { x: { mm: { from: { of: 'instance', axis: 'x' }, times: 0.3 } } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'lamp', face: 'back', to: front, align })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'lamp', to: front, align })
   const x = (size: number) => Math.round(compileFigureAsset({ ...asset, designInputs: { ...asset.designInputs, 'size.x': size } }).evaluate().geometry.find(g => g.id === 'lamp')!.pose.t[0]!)
   assert.equal(x(1000), 300)
   assert.equal(x(2000), 600, '도형이 두 배면 거리도 두 배')
@@ -498,8 +504,8 @@ test('선언할 크기는 부품이 쉬고 있을 때의 크기 — 문짝이
   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 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'leaf', face: 'left', to: { part: 'jamb', face: 'right' }, align: { y: 'min', z: 'max' }, gap: 5 })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', to: { plane: 'mounting-plane' } })
+  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 })
@@ -508,15 +514,15 @@ test('선언할 크기는 부품이 쉬고 있을 때의 크기 — 문짝이
 test('바닥에 선 부품도 도형 크기를 선언한 도형이면 도형의 옆면에 맞출 수 있다 (2026-09-25)', async () => {
   const { alignAxesOf, alignOf } = await import('../client/modeller/links.ts')
   let asset = addFigureBox(createFigureAsset('Gate'), { id: 'post', size: { x: 100, y: 2000, z: 150 }, position: { x: 0, y: 0, z: 0 } })
-  assert.deepEqual(alignAxesOf(asset, 'post', 'plane'), [{ axis: 'x', edges: false }, { axis: 'z', edges: false }], '크기가 없으면 옆면도 없다')
+  assert.deepEqual(alignAxesOf(asset, 'plane'), [{ axis: 'x', edges: false }, { axis: 'z', edges: false }], '크기가 없으면 옆면도 없다')
   asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 200, max: 5000 }, y: { min: 500, max: 5000 }, z: { min: 50, max: 500 } }, at: { x: 1100, y: 2000, z: 150 } })
-  assert.deepEqual(alignAxesOf(asset, 'post', 'plane'), [{ axis: 'x', edges: true }, { axis: 'z', edges: true }])
-  assert.deepEqual(alignOf(asset, 'post', 'plane', { x: 'min' }, {}), { x: 'min' })
+  assert.deepEqual(alignAxesOf(asset, 'plane'), [{ axis: 'x', edges: true }, { axis: 'z', edges: true }])
+  assert.deepEqual(alignOf(asset, 'plane', { x: 'min' }, {}), { x: 'min' })
 })
 
 test('움직임은 그 자리에서 고친다 — 폼에 지금 관절을 채우고, 그대로 보내면 같은 관절이다 (2026-09-25)', async () => {
   const { motionFormOf, motionJoint } = await import('../client/modeller/links.ts')
-  const base = { id: 'j', body0: { part: 'a', face: 'top' as const }, body1: { part: 'b', face: 'bottom' as const } }
+  const base = { id: 'j', body0: { part: 'a', face: 'top' as const }, body1: { part: 'b' } }
   const joints = [
     { ...base, type: 'prismatic' as const, axis: 'Z' as const, lowerLimit: 0, upperLimit: 2500, state: { id: 'extend' } },
     { ...base, type: 'revolute' as const, axis: 'Y' as const, lowerLimit: -90, upperLimit: 0, state: { id: 'open' } },
@@ -540,25 +546,21 @@ test('바닥에 선 부품도 무엇에 붙어 있는지 읽는다 — 그래야
   asset = addFigureBox(asset, { id: 'jamb', size: { x: 100, y: 2100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
   asset = addFigureBox(asset, { id: 'head', size: { x: 1100, y: 100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
   assert.equal(heldBy(asset, 'jamb'), null)
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'head', face: 'bottom', to: { part: 'jamb', face: 'top' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'head', to: { part: 'jamb', face: 'top' } })
   assert.deepEqual(heldBy(asset, 'jamb'), { plane: true }, '장착 평면')
   assert.deepEqual(heldBy(asset, 'head'), { part: 'jamb' })
   /* What the form then sends: a fastening that replaces the one there. */
-  assert.doesNotThrow(() => applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', face: 'bottom', to: { plane: 'mounting-plane' }, align: { x: { mm: -500 } }, replace: !!heldBy(asset, 'jamb') }))
+  assert.doesNotThrow(() => applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', to: { plane: 'mounting-plane' }, align: { x: { mm: -500 } }, replace: !!heldBy(asset, 'jamb') }))
 })
 
-test('벽 배치 — 장착 평면은 Z = 0, 등으로 붙이고 가로질러 X · Y 로 맞춘다(사용자 · 아키텍트 09-25)', async () => {
+test('벽 배치 — 장착 평면은 Z = 0, 벽에서 나와 서고 가로질러 X · Y 로 맞춘다(사용자 · 아키텍트 09-25, ADR-0140 3.11)', async () => {
   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', faces: ['bottom', 'top'] }, '배치 선언 전에는 바닥')
+  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 })
-  assert.deepEqual(mountingPlaneOf(a), { normal: 'z', faces: ['back'] })
-  assert.deepEqual(alignAxesOf(a, 'plate', 'plane').map(x => x.axis), ['x', 'y'])
-  assert.deepEqual(ownFacesOf(a, 'plate', true), ['back'], 'on the plane, only the face the plane takes')
-  assert.deepEqual(ownFacesOf(a, 'plate', false), ['left', 'right', 'bottom', 'top', 'back', 'front', 'centre'], 'to a part, its six outer faces and its centre')
-  const floor = addFigureBox(createFigureAsset('Floor'), { id: 'plate', size: { x: 200, y: 300, z: 20 }, position: { x: 0, y: 0, z: 0 } })
-  assert.deepEqual(ownFacesOf(floor, 'plate', true), ['bottom', 'top'], 'on the floor, its bottom or its top')
+  assert.deepEqual(mountingPlaneOf(a), { normal: 'z', facings: ['meet'] })
+  assert.deepEqual(alignAxesOf(a, 'plane').map(x => x.axis), ['x', 'y'])
 })
 
 test('부품 칸의 두 제목이 같은 말이 아니다 — 자리 숫자는 「위치와 크기」, 붙이기 칸은 「붙이기」 (09-26)', () => {
@@ -578,8 +580,8 @@ test('보이는 때 — 명령이 남긴 것을 읽고, 폼은 그 명령을 낸
   asset = addFigureBox(asset, { id: 'frame', size: { x: 1200, y: 60, z: 200 }, position: { x: 0, y: 30, z: 0 } })
   asset = addFigureBox(asset, { id: 'door', size: { x: 1000, y: 2000, z: 40 }, position: { x: 0, y: 1060, z: 0 } })
   asset = addFigureBox(asset, { id: 'lamp', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 2200, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'door', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'frame', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'door', to: { part: 'frame', face: 'top' } })
   assert.deepEqual(visibilityControlsOf(asset), [], '조작값이 없으면 고를 것도 없다')
   asset = moving(asset, 'door', { kind: 'slide', axis: 'x', id: 'gate-open', min: 0, max: 900 })
   assert.deepEqual(visibilityControlsOf(asset).map(c => [c.id, c.min, c.max, c.unit]), [['gate-open', 0, 900, 'mm']])
@@ -629,20 +631,18 @@ import { wordsOf } from './words.ts'
 
 test('붙이기 칸은 부품 제 붙임으로 열린다 — 가운데로 붙은 롤러는 가운데 · 상대 · 간격 그대로', () => {
   let asset = addFigureBox(createFigureAsset('Rollers'), { id: 'bed', size: { x: 2000, y: 400, z: 600 }, position: { x: 0, y: 200, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'bed', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'bed', to: { plane: 'mounting-plane' } })
   asset = addFigurePrimitive(asset, { id: 'roller', kind: 'cylinder', dimensions: { radius: 40, length: 560 }, position: { x: 0, y: 0, z: 0 }, rotation: { x: 90, y: 0, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'roller', face: 'centre', to: { part: 'bed', face: 'top' }, gap: 40, align: { x: 'min' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'roller', facing: 'centre', to: { part: 'bed', face: 'top' }, gap: 40, align: { x: 'min' } })
   const roller = fasteningOf(revisionOf(asset), 'roller')!
-  assert.equal(roller.face, 'centre')
+  assert.equal(roller.facing, 'centre')
   assert.equal(roller.target, 'bed')
   assert.equal(roller.targetFace, 'top')
   assert.equal(roller.gap, 40)
   assert.equal(roller.align.x, 'min', '기록의 정렬')
   const bed = fasteningOf(revisionOf(asset), 'bed')!
-  assert.deepEqual([bed.face, bed.toPlane], ['bottom', true])
+  assert.deepEqual([bed.facing, bed.toPlane], ['meet', true])
   assert.equal(fasteningOf(revisionOf(addFigureBox(createFigureAsset('Loose'), { id: 'b', size: { x: 1, y: 1, z: 1 }, position: { x: 0, y: 0, z: 0 } })), 'b'), null, '안 붙은 부품은 기본값으로')
-  assert.equal(ownFacesOf(asset, 'roller', false).at(-1), 'centre', 'its own faces include its centre')
-  assert.ok(!ownFacesOf(asset, 'roller', true).includes('centre'), 'on the floor, by a face only')
 })
 
 test('a worked-out gap is kept by the fastening form: opening it on the part moves nothing (the robot dog, the forklift, 2026-10-13)', async () => {
@@ -652,7 +652,7 @@ test('a worked-out gap is kept by the fastening form: opening it on the part mov
     Object.fromEntries((compileFigureAsset(asset).evaluate().geometry as unknown as Array<{ id: string; pose?: { t: number[] } }>).map(g => [g.id, g.pose?.t.map(v => Math.round(v * 1000) / 1000)]))
   /* What the form sends when nothing in it is changed: the attach it would make of the part's own fastening. */
   const reattach = (asset: FigureAsset, part: string, form: Parameters<typeof fastenGapOf>[0]) =>
-    applyFigureAuthoring(asset, { kind: 'attach', part, face: 'bottom', to: { plane: 'mounting-plane' }, ...fastenGapOf(form), twist: 0, replace: true } as never)
+    applyFigureAuthoring(asset, { kind: 'attach', part, to: { plane: 'mounting-plane' }, ...fastenGapOf(form), replace: true } as never)
 
   const dog = robotDogFigure().asset
   const body = fasteningOf(revisionOf(dog), 'body')!
@@ -665,7 +665,7 @@ test('a worked-out gap is kept by the fastening form: opening it on the part mov
   let lift = addFigureBox(createFigureAsset('Lift'), { id: 'body', size: { x: 1000, y: 800, z: 600 }, position: { x: 0, y: 500, z: 0 } })
   lift.document.model.inputs.push({ id: 'size.y', unit: 'mm', min: 100, max: 20000, role: 'design' } as never)
   lift.designInputs['size.y'] = 1800
-  lift = applyFigureAuthoring(lift, { kind: 'attach', part: 'body', face: 'bottom', to: { plane: 'mounting-plane' }, gap: { from: { of: 'instance', axis: 'y' }, times: 0.05 } } as never)
+  lift = applyFigureAuthoring(lift, { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' }, gap: { from: { of: 'instance', axis: 'y' }, times: 0.05 } } as never)
   const kept = fasteningOf(revisionOf(lift), 'body')!
   assert.deepEqual(kept.gapKept, { from: { of: 'instance', axis: 'y' }, times: 0.05 })
   assert.deepEqual(posesOf(reattach(lift, 'body', kept)), posesOf(lift))

package/test/live.test.ts

@@ -70,9 +70,9 @@ test('끄는 동안은 세션이 지금 든 자세 위에 그린다 — 다른
   let asset = slider()
   /* An arm on a post of its own, turning about the post's left edge -- so a swing moves it, and the slide does not. */
   asset = addFigureBox(asset, { id: 'post', size: { x: 100, y: 100, z: 100 }, position: { x: 400, y: 50, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'post', face: 'bottom', to: { plane: 'mounting-plane' }, align: { x: { mm: 400 } } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'post', to: { plane: 'mounting-plane' }, align: { x: { mm: 400 } } })
   asset = addFigureBox(asset, { id: 'arm', size: { x: 100, y: 20, z: 20 }, position: { x: 400, y: 110, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'arm', face: 'bottom', to: { part: 'post', face: 'top' }, align: { x: 'min' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'arm', to: { part: 'post', face: 'top' }, align: { x: 'min' } })
   asset = moving(asset, 'arm', { kind: 'turn', axis: 'y', id: 'swing', min: -180, max: 180 })
   const armAt = (parts: { id: string; pose: { t: number[] } }[]) => parts.find(p => p.id === 'arm')!.pose.t.map(v => Math.round(v))
   const committed = armAt(compileFigureAsset({ ...asset, stateDefaults: { ...asset.stateDefaults, swing: 90 } }).evaluate().geometry as never)

package/test/preview-size.test.ts

@@ -13,7 +13,7 @@ import { previewSizeWordsOf, rowCountsAt } from '../client/modeller/preview-size
 function conveyor(): FigureAsset {
   let asset = addFigureBox(createFigureAsset('Conveyor'), { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 50, z: 0 } })
   asset = addFigurePrimitive(asset, { id: 'roller', kind: 'cylinder', dimensions: { radius: 30, length: 560 }, position: { x: 0, y: 0, z: 0 }, rotation: { x: 90, y: 0, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' } })
   asset = applyFigureAuthoring(asset, { kind: 'follow-size', part: 'frame', axes: ['x'] })
   return applyFigureAuthoring(asset, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 })
 }

package/test/refusals.test.ts

@@ -61,8 +61,8 @@ function conveyor(): FigureAsset {
   let a = fm.createFigureAsset('Conveyor')
   a = fm.addFigureBox(a, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
   a = fm.addFigureBox(a, { id: 'roller', size: { x: 60, y: 60, z: 560 }, position: { x: 0, y: 0, z: 0 } })
-  a = act(a, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
-  a = act(a, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  a = act(a, { kind: 'attach', part: 'frame', to: { plane: 'mounting-plane' } })
+  a = act(a, { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' } })
   return act(a, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 })
 }
 
@@ -100,10 +100,10 @@ test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그
   a = fm.addFigureBox(a, { id: 'top', size: { x: 1200, y: 40, z: 600 }, position: { x: 0, y: 0, z: 0 } })
   a = fm.addFigureBox(a, { id: 'lamp', size: { x: 80, y: 80, z: 80 }, position: { x: 0, y: 0, z: 0 } })
   a = fm.addFigureBox(a, { id: 'shade', size: { x: 40, y: 40, z: 40 }, position: { x: 0, y: 0, z: 0 } })
-  a = act(a, { kind: 'attach', part: 'leg', face: 'bottom', to: { plane: 'mounting-plane' } })
-  a = act(a, { kind: 'attach', part: 'top', face: 'bottom', to: { part: 'leg', face: 'top' } })
-  a = act(a, { kind: 'attach', part: 'lamp', face: 'bottom', to: { part: 'top', face: 'top' }, align: { x: { mm: -300 } } })
-  a = act(a, { kind: 'attach', part: 'shade', face: 'bottom', to: { part: 'top', face: 'top' }, align: { x: { mm: 300 } } })
+  a = act(a, { kind: 'attach', part: 'leg', to: { plane: 'mounting-plane' } })
+  a = act(a, { kind: 'attach', part: 'top', to: { part: 'leg', face: 'top' } })
+  a = act(a, { kind: 'attach', part: 'lamp', to: { part: 'top', face: 'top' }, align: { x: { mm: -300 } } })
+  a = act(a, { kind: 'attach', part: 'shade', to: { part: 'top', face: 'top' }, align: { x: { mm: 300 } } })
   const turn = (asset: typeof a, part: string, extra: object) => act(asset, { kind: 'set-joint', joint: { ...asset.joints!.find(j => j.body1.part === part)!, type: 'revolute', axis: 'Y', ...extra } })
   a = turn(a, 'lamp', { state: { id: 'lamp-turn' } })
   a = turn(a, 'shade', { mimic: { joint: 'lamp', multiplier: 1 } })
@@ -121,15 +121,15 @@ test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그
   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', face: 'bottom', to: { part: 'roller', face: 'top' } })
+  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', face: 'bottom', to: { plane: 'mounting-plane' } })
-  a = act(a, { kind: 'attach', part: 'stray', face: 'bottom', to: { plane: 'mounting-plane' } })
+  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, '줄은 이 길이 아니다')
@@ -144,12 +144,11 @@ test('배치를 바꿀 수 없는 까닭 — 평면에 붙은 부품과 새 평
   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',
-    face: 'bottom',
     to: { plane: 'mounting-plane' }
   })
   const refused = refusalOf(() => act(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'wall' }))
   const said = placementRefusalOf(refused, say)!
-  assert.ok(said.includes('post (bottom)') && said.includes('벽') && said.includes('back'), said)
+  assert.equal(said, '장착 평면에 붙은 부품이 있어 놓이는 곳을 바꿀 수 없습니다: post. 먼저 이 부품을 떼어 주십시오.')
   assert.equal(editRefusalOf(refused, say), said, '편집 거절의 말도 같다')
   assert.equal(placementRefusalOf(refusalOf(() => act(box(), declaring({ min: 0, max: 4000 }))), say), null)
   /* The placement list sends its command through the page: said there in words, and the list back on the placement it has (product-page.check.mjs). */
@@ -191,13 +190,13 @@ test('줄이 한도를 넘으면 몇 개가 되는지와 한도를 말한다 —
   let a = fm.createFigureAsset('Conveyor')
   a = fm.addFigureBox(a, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 0, z: 0 } })
   a = fm.addFigureBox(a, { id: 'roller', size: { x: 10, y: 60, z: 560 }, position: { x: 0, y: 0, z: 0 } })
-  a = act(a, { kind: 'attach', part: 'frame', face: 'bottom', to: { plane: 'mounting-plane' } })
-  a = act(a, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  a = act(a, { kind: 'attach', part: 'frame', to: { plane: 'mounting-plane' } })
+  a = act(a, { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' } })
   const many = editRefusalOf(refusalOf(() => act(a, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 12, count: 150 })), say)
   assert.ok(many.includes('150') && many.includes('1~100') && !many.includes('GEOMETRY_DOMAIN'), many)
   /* A saved figure whose row would expand past what a figure draws: ten thousand copies, each a roller and its cap. */
   let capped = fm.addFigureBox(conveyor(), { id: 'cap', size: { x: 20, y: 20, z: 20 }, position: { x: 0, y: 0, z: 0 } })
-  capped = structuredClone(act(capped, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'roller', face: 'top' } }))
+  capped = structuredClone(act(capped, { kind: 'attach', part: 'cap', to: { part: 'roller', face: 'top' } }))
   const m = capped.document.model as unknown as { constants: Array<{ id: string; value: number }> }
   m.constants.find(c => c.id === 'limit.count.100')!.value = 10000
   m.constants.find(c => c.id === 'd.mm.200')!.value = 0.2
@@ -209,15 +208,15 @@ test('일상에서 코드로만 보이던 거절 넷 — 줄이 안 들어감 ·
   const shelf = () => {
     let a = fm.addFigureBox(fm.createFigureAsset('Shelf'), { id: 'board', size: { x: 400, y: 50, z: 1000 }, position: { x: 0, y: 0, z: 0 } })
     a = fm.addFigureBox(a, { id: 'bin', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 0, z: 0 } })
-    a = act(a, { kind: 'attach', part: 'board', face: 'bottom', to: { plane: 'mounting-plane' } })
-    return act(a, { kind: 'attach', part: 'bin', face: 'bottom', to: { part: 'board', face: 'top' } })
+    a = act(a, { kind: 'attach', part: 'board', to: { plane: 'mounting-plane' } })
+    return act(a, { kind: 'attach', part: 'bin', to: { part: 'board', face: 'top' } })
   }
   /* Five 100 mm bins asked for on 400 mm. */
   const fit = editRefusalOf(refusalOf(() => act(shelf(), { kind: 'make-repeat', part: 'bin', axis: 'x', pitch: 1, count: 5 })), keyed)
   assert.match(fit, /row-does-not-fit .*"count":"5".*"length":"400".*"extent":"100"/)
   /* A cap on the roller made a row along X, as the roller's row is. */
   let capped = fm.addFigureBox(conveyor(), { id: 'cap', size: { x: 20, y: 20, z: 20 }, position: { x: 0, y: 0, z: 0 } })
-  capped = act(capped, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'roller', face: 'top' } })
+  capped = act(capped, { kind: 'attach', part: 'cap', to: { part: 'roller', face: 'top' } })
   assert.match(editRefusalOf(refusalOf(() => act(capped, { kind: 'make-repeat', part: 'cap', axis: 'x', pitch: 10 })), keyed), /row-same-axis .*"part":"cap","outer":"roller","axis":"X"/)
   /* The bin's top holds the slot layout: made a row, the layout would stand on no one bin. */
   const slotted = act(shelf(), {
@@ -243,7 +242,6 @@ test('옮겨 적은 거절 — 기록은 커널의 거절과 같은 모양이라
   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',
-    face: 'bottom',
     to: { plane: 'mounting-plane' }
   })
   const refused = refusalOf(() => act(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'wall' }))
@@ -271,7 +269,7 @@ test('단면 · 속 공간 — 모서리, 벽, 막힌 끝, 붙은 면을 거절
   assert.match(editRefusalOf(refusalOf(() => act(box(), { kind: 'set-cavity', part: 'box', cavity: { wall: 10, start: { closed: 200 }, end: { closed: 200 } } })), keyed), /^figure\.text\.section-ends-too-thick/)
   let tray = act(box(), { kind: 'set-cavity', part: 'box', cavity: { wall: 10, start: { closed: 15 }, end: 'open' } })
   tray = fm.addFigureBox(tray, { id: 'divider', size: { x: 10, y: 100, z: 150 }, position: { x: 0, y: 0, z: 0 } })
-  tray = act(tray, { kind: 'attach', part: 'divider', face: 'bottom', to: { part: 'box', face: 'inside-bottom' } })
+  tray = act(tray, { kind: 'attach', part: 'divider', to: { part: 'box', face: 'inside-bottom' } })
   const faces = editRefusalOf(refusalOf(() => act(tray, { kind: 'set-cavity', part: 'box', cavity: { wall: 10, start: 'open', end: 'open' } })), say)
   assert.ok(faces.includes(ko['figure.label.face-inside-bottom']), faces)
   /* A section finding the screen has no words for is said with its code. */
@@ -309,7 +307,7 @@ test('도형의 한도 — 노드 수, 저장 크기, 중첩 깊이를 숫자로
 })
 
 test('레시피가 막히면 몇 번째 단계에서 왜 막혔는지 사람의 말로 — 단계 안의 거절도 값을 잃지 않는다 (2026-09-27)', () => {
-  const refused = refusalOf(() => fm.applyFigureProposal(box(), [{ kind: 'attach', part: 'nowhere', face: 'bottom', to: { plane: 'mounting-plane' } }, declaring({ min: 500, max: 4000 })] as never))
+  const refused = refusalOf(() => fm.applyFigureProposal(box(), [{ kind: 'attach', part: 'nowhere', to: { plane: 'mounting-plane' } }, declaring({ min: 500, max: 4000 })] as never))
   assert.match(recipeRefusalOf(refused, keyed)!, /^figure\.text\.recipe-step-refused .*"step":"1"/, '첫째 단계, 코드와 함께')
   const sized = refusalOf(() => fm.applyFigureProposal(box(), [declaring({ min: 500, max: 4000 })] as never))
   const told = recipeRefusalOf(sized, say)!

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

@@ -152,14 +152,14 @@ test('a fastened part keeps its position and turn rows, with the numbers the rul
 
 test('size response and attachment are separate screen paths', () => {
   const ko = JSON.parse(readFileSync(new URL('../translations/ko.json', import.meta.url), 'utf-8'))
-  assert.equal(ko['figure.text.held-on-plane'].replace('{face}', '아랫면').replace('{place}', '바닥').replace('{gap}', '0'), '아랫면을 바닥에 유지 중 (간격 0 mm)')
+  assert.equal(ko['figure.text.held-on-plane'].replace('{place}', '바닥').replace('{gap}', '0'), '바닥에 붙어 있음 (간격 0 mm)')
 })
 
-test('a part fastened twisted has no face figure-model can keep for a drag, so the size gizmo is withheld', async () => {
+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')
   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: 'attach', part: 'blade', face: 'bottom', to: { part: 'hub', face: 'top' }, twist: 30 })
+  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)
 })
 
@@ -174,7 +174,7 @@ test('"open attachment settings" opens this part\'s fastening, as it is now, and
   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')
-  assert.equal(form.face, 'bottom')
+  assert.equal(form.facing, 'meet')
   assert.equal(form.gap, 100, 'the gap it keeps')
 })
 
@@ -189,8 +189,8 @@ test('the fastening form keeps a place that follows a position field, and fasten
   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'])
-  const align = alignOf(kept, 'box', 'plane', form.align, form.alignMm, false, form.alignInput)
-  const again = applyFigureAuthoring(kept, { kind: 'attach', part: 'box', face: 'bottom', to: { plane: 'mounting-plane' }, ...(align ? { align } : {}), replace: true } as never)
+  const align = alignOf(kept, 'plane', form.align, form.alignMm, form.alignInput)
+  const again = applyFigureAuthoring(kept, { kind: 'attach', part: 'box', to: { plane: 'mounting-plane' }, ...(align ? { align } : {}), replace: true } as never)
   assert.ok('box.position.x' in again.designInputs && 'box.position.z' in again.designInputs, 'the fields stay')
   assert.deepEqual(JSON.stringify(again.joints), JSON.stringify(kept.joints), 'the same fastening')
 })

package/test/revision.test.ts

@@ -20,7 +20,7 @@ import { derivedHeld, derivedOf, type FigureRevision } from '../client/modeller/
 import { alignChanges, boxOf, canMirror, gridStepOf } from '../client/modeller/align.ts'
 import { jointFanOf } from '../client/modeller/joint-fan.ts'
 import { fasteningOf, measureNow, partSummaryOf, placeKeptOf } from '../client/modeller/links.ts'
-import { faceViewOf, myFaceFor } from '../client/modeller/fasten-geometry.ts'
+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'
@@ -96,8 +96,7 @@ function selectionQuestions(shown: FigureRevision, part: string) {
   figureRowOf(asset, part, shown.inputs)
   fasteningOf(shown, part)
   placeKeptOf(shown, part, 'plane')
-  myFaceFor(shown, part, 'plane', 'meet')
-  faceViewOf(shown, part, 'plane')
+  faceViewOf(shown, part, 'plane', 'meet')
   figureFigureFacts(shown)
 }
 
@@ -144,7 +143,7 @@ test('a value changed, read again as the next version, is two compiles at most:
 function slide(): FigureAsset {
   let a = addFigureBox(createFigureAsset('Slide'), { id: 'rail', size: { x: 1000, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
   a = addFigureBox(a, { id: 'carriage', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 150, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'carriage', face: 'bottom', to: { part: 'rail', face: 'top' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'carriage', to: { part: 'rail', face: 'top' } })
   a = moving(a, 'carriage', { kind: 'slide', axis: 'x', id: 'travel', min: 0, max: 400 })
   return addFigureBox(a, { id: 'tag', size: { x: 50, y: 50, z: 50 }, position: { x: 300, y: 225, z: 0 } })
 }
@@ -159,7 +158,7 @@ test('fastening keeps a part where it stands against what is drawn: a target mov
   return w.open('x').then(() => {
     w.apply([{ kind: 'set-state', input: 'travel', unit: 'mm', value: 250 }])
     const before = boxOf(w.revisionNow()!, 'tag')!.centre.x
-    w.command({ kind: 'attach', part: 'tag', face: 'bottom', to: { part: 'carriage', face: 'top' }, align: { x: { mm: placeKeptOf(shown, 'tag', { part: 'carriage', face: 'top' }).alignMm.x! } } })
+    w.command({ kind: 'attach', part: 'tag', to: { part: 'carriage', face: 'top' }, align: { x: { mm: placeKeptOf(shown, 'tag', { part: 'carriage', face: 'top' }).alignMm.x! } } })
     assert.equal(Math.round(boxOf(w.revisionNow()!, 'tag')!.centre.x), Math.round(before))
   })
 })

package/test/section-panel.test.ts

@@ -164,7 +164,7 @@ test('다각 단면에는 속 공간을 만들 수 없다고 그 자리에서
 test('붙어 있는 것이 기대는 면을 없애는 편집은 거절되고, 그 면을 사람의 말로 부른다', () => {
   let asset = applyFigureAuthoring(probe(), { kind: 'set-cavity', part: 'body', cavity: { wall: 10, start: { closed: 15 }, end: 'open' } })
   asset = addFigureBox(asset, { id: 'divider', size: { x: 10, y: 100, z: 200 }, position: { x: 0, y: 0, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'divider', face: 'bottom', to: { part: 'body', face: 'inside-bottom' as never } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'divider', to: { part: 'body', face: 'inside-bottom' as never } })
   const said = refusal(() => applyFigureAuthoring(asset, { kind: 'set-cavity', part: 'body', cavity: { wall: 10, start: 'open', end: 'open' } }))
   assert.equal(said, say('figure.text.section-face-in-use', { faces: ko['figure.label.face-inside-bottom']! }))
 })