@things-factory/figure-ui 10.1.198 → 10.1.201

package/test/browser/row-preview.check.mjs

@@ -48,9 +48,9 @@ const said = () => read(() => [...(findDeep('section[row]')?.querySelectorAll('[
 /* A 400 mm board, a 3 mm bin fastened on it: a row of it along X. */
 function board() {
   let a = addFigureBox(createFigureAsset('Board'), { id: 'board', size: { x: 400, y: 50, z: 1000 }, position: { x: 0, y: 25, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'board', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'board', to: { plane: 'mounting-plane' } })
   a = addFigureBox(a, { id: 'bin', size: { x: 3, y: 100, z: 100 }, position: { x: 0, y: 100, z: 0 } })
-  return applyFigureAuthoring(a, { kind: 'attach', part: 'bin', face: 'bottom', to: { part: 'board', face: 'top' } })
+  return applyFigureAuthoring(a, { kind: 'attach', part: 'bin', to: { part: 'board', face: 'top' } })
 }
 
 describe('a row\'s preview follows its basis', () => {

package/test/browser/screen-page.js

@@ -57,7 +57,7 @@ const FIGURES = {
   /* A lighting tower that follows its height only: the wider variants ask a width it does not declare. */
   tower: () => {
     let a = addFigureBox(named('Tower'), { id: 'mast', size: { x: 200, y: 2000, z: 300 }, position: { x: 0, y: 0, z: 0 } })
-    a = applyFigureAuthoring(a, { kind: 'attach', part: 'mast', face: 'bottom', to: { plane: 'mounting-plane' } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: 'mast', to: { plane: 'mounting-plane' } })
     return applyFigureAuthoring(a, { kind: 'declare-instance-size', range: { x: { min: 200, max: 200 }, y: { min: 1000, max: 3000 }, z: { min: 300, max: 300 } } })
   },
   /*
@@ -67,7 +67,7 @@ const FIGURES = {
   stack: () => {
     let a = addFigureBox(named('Stack'), { id: 'base', size: { x: 1000, y: 200, z: 600 }, position: { x: 0, y: 100, z: 0 } })
     a = addFigureBox(a, { id: 'top', size: { x: 200, y: 200, z: 200 }, position: { x: 0, y: 300, z: 0 } })
-    a = applyFigureAuthoring(a, { kind: 'attach', part: 'top', face: 'bottom', to: { part: 'base', face: 'top' } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: 'top', to: { part: 'base', face: 'top' } })
     a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a) })
     return applyFigureAuthoring(a, { kind: 'set-mounting-face', part: 'base', face: 'bottom' })
   },
@@ -75,7 +75,7 @@ const FIGURES = {
   stretch: () => {
     let a = addFigureBox(named('Stretch'), { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 50, z: 0 } })
     a = addFigurePrimitive(a, { id: 'roller', kind: 'cylinder', dimensions: { radius: 30, length: 560 }, position: { x: 0, y: 0, z: 0 }, rotation: { x: 90, y: 0, z: 0 } })
-    a = applyFigureAuthoring(a, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' } })
     a = applyFigureAuthoring(a, { kind: 'follow-size', part: 'frame', axes: ['x'] })
     a = applyFigureAuthoring(a, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 })
     /* A space wider than the parts, as a spin swept or a padding gives: the box is the space, not the size (2026-10-16). */

package/test/browser/section-page.js

@@ -27,7 +27,7 @@ const FIGURES = {
   /* The triangle with a plate on its top: its end cannot be drawn to one point while the plate stands there (A5-1). */
   'capped-wedge': () => {
     const a = addFigureBox(polygon(figure('Capped'), 'wedge', TRIANGLE), { id: 'cap', size: { x: 100, y: 20, z: 100 }, position: { x: 0, y: 0, z: 0 } })
-    return applyFigureAuthoring(a, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'wedge', face: 'top' } })
+    return applyFigureAuthoring(a, { kind: 'attach', part: 'cap', to: { part: 'wedge', face: 'top' } })
   },
   pyramid: () => applyFigureAuthoring(polygon(figure('Pyramid'), 'wedge', TRIANGLE), { kind: 'set-section', part: 'wedge', apex: { x: 0, z: 0 } }),
   /* A box standing on the floor: a length change keeps its bottom. */
@@ -51,10 +51,10 @@ const FIGURES = {
   /* A tote on the floor with a divider standing on its inside floor, and a box beside it (ADR-0100 A8). */
   tote: () => {
     let a = addFigureBox(figure('Tote'), { id: 'bin', size: { x: 600, y: 300, z: 400 }, position: { x: 0, y: 150, z: 0 } })
-    a = applyFigureAuthoring(a, { kind: 'attach', part: 'bin', face: 'bottom', to: { plane: 'mounting-plane' } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: 'bin', to: { plane: 'mounting-plane' } })
     a = applyFigureAuthoring(a, { kind: 'set-cavity', part: 'bin', cavity: { wall: 10, start: { closed: 15 }, end: 'open' } })
     a = addFigureBox(a, { id: 'divider', size: { x: 10, y: 200, z: 380 }, position: { x: 0, y: 0, z: 0 } })
-    return beside(applyFigureAuthoring(a, { kind: 'attach', part: 'divider', face: 'bottom', to: { part: 'bin', face: 'inside-bottom' } }))
+    return beside(applyFigureAuthoring(a, { kind: 'attach', part: 'divider', to: { part: 'bin', face: 'inside-bottom' } }))
   }
 }
 

package/test/browser/section.check.mjs

@@ -574,7 +574,7 @@ describe('the fastening drawing in the fastening window', () => {
     assert.deepEqual([now.body0.face, now.origin?.facing], [face, 'flush'])
   })
 
-  test('fastened to the plane: the plane is named by the placement, chosen, and set on only', async () => {
+  test('fastened to the plane: the plane is named by the placement, chosen, and set on it or hung below it', async () => {
     await mount('rollers')
     await pick('bed')
     await change()
@@ -582,7 +582,7 @@ describe('the fastening drawing in the fastening window', () => {
     const plane = list.find(t => t.target === '__plane')
     assert.deepEqual([plane.selected, plane.text], [true, 'figure.label.resize-place-floor'])
     assert.equal((await labels())[1], 'figure.label.fasten-face-on-plane', 'the face asked on the floor, not of a part')
-    assert.deepEqual((await read(() => probe.fastenDrawing())).modes, [], 'one way only: no choice offered')
+    assert.deepEqual((await read(() => probe.fastenDrawing())).modes, ['meet', 'flush'], 'the floor: stood on, or hung below (ADR-0140 3.11)')
   })
 
   /* The window is a popup over the work: closed, nothing written, before another part is picked. */
@@ -602,7 +602,7 @@ describe('the fastening drawing in the fastening window', () => {
     assert.deepEqual((await read(() => probe.fastenDrawing())).modes, ['meet', 'flush'])
   })
 
-  test('a new fastening waits for 붙이기; the part\'s own face follows the target\'s face and how', async () => {
+  test('a new fastening waits for 붙이기; the part meets the target\'s face, by no face of its own', async () => {
     await mount('door')
     await pick('leaf')
     await press('button[fasten-start]')
@@ -617,7 +617,7 @@ describe('the fastening drawing in the fastening window', () => {
     await until(r => probe.state().revision === r + 1, 'one step', start.revision)
     const joint = await read(() => probe.fastening('leaf'))
     assert.deepEqual(joint.body0, { part: 'frame', face: 'front' })
-    assert.equal(joint.body1.face, 'back', 'set on the front, by its back')
+    assert.deepEqual([joint.body1, joint.origin?.facing], [{ part: 'leaf' }, 'meet'], 'set on the front by its real shape (ADR-0140 3.2)')
   })
 })
 

package/test/clip-ai-proposal.test.ts

@@ -21,7 +21,7 @@ function door(): string {
   a = addFigureBox(a, { id: 'frame', size: { x: 1000, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
   a = addFigureBox(a, { id: 'leaf', size: { x: 900, y: 1800, z: 40 }, position: { x: 0, y: 1000, z: 0 } })
   a = addFigureBox(a, { id: 'sign', size: { x: 200, y: 100, z: 10 }, position: { x: 0, y: 2200, z: 200 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', to: { part: 'frame', face: 'top' } })
   const j = a.joints!.find(k => k.body1.part === 'leaf')!
   a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', state: { id: 'open' } } })
   a = editFigurePart(a, { kind: 'set-driver', state: 'open', clip: 'swing', duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 80 }] })

package/test/clip-consent.test.ts

@@ -20,7 +20,7 @@ function doors(): string {
   a = addFigureBox(a, { id: 'frame', size: { x: 2000, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
   for (const [id, x] of [['left', -500], ['right', 500]] as const) {
     a = addFigureBox(a, { id, size: { x: 900, y: 1800, z: 40 }, position: { x, y: 1000, z: 0 } })
-    a = applyFigureAuthoring(a, { kind: 'attach', part: id, face: 'bottom', to: { part: 'frame', face: 'top' } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: id, to: { part: 'frame', face: 'top' } })
     const j = a.joints!.find(k => k.body1.part === id)!
     a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', state: { id: `${id}-open` } } })
     a = editFigurePart(a, { kind: 'set-driver', state: `${id}-open`, clip: `${id}-swing`, duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 80 }] })

package/test/command-preview.test.ts

@@ -26,11 +26,11 @@ function bench(): string {
   a = addFigureBox(a, { id: 'leg', size: { x: 60, y: 700, z: 60 }, position: { x: -400, y: 350, z: 0 } })
   a = addFigureBox(a, { id: 'top', size: { x: 1200, y: 40, z: 600 }, position: { x: 0, y: 900, z: 0 } })
   a = addFigureBox(a, { id: 'lamp', size: { x: 80, y: 80, z: 80 }, position: { x: 200, y: 960, z: 100 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'lamp', face: 'bottom', to: { part: 'top', face: 'top' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'lamp', to: { part: 'top', face: 'top' } })
   return serializeFigureAsset(a)
 }
 const store = { load: async (id: string) => ({ id, source: bench() }), save: async (q: { id?: string; source: string }) => ({ id: q.id ?? 'x', source: q.source }) }
-const onLeg = { kind: 'attach', part: 'top', face: 'bottom', to: { part: 'leg', face: 'top' } } as never
+const onLeg = { kind: 'attach', part: 'top', to: { part: 'leg', face: 'top' } } as never
 
 test('seen, not done: the session\'s preview writes nothing, and names the version it was worked out on', async () => {
   const s = createFigureProductSession(store)
@@ -78,7 +78,7 @@ test('the face it would meet is lit where attaching reads it, just off the face'
 test('the details fold, and what they hold that is not the default stays said -- nothing for the default', () => {
   for (const lang of ['en', 'ja', 'ko', 'ms', 'zh', 'es']) {
     const t = JSON.parse(read(`../translations/${lang}.json`))
-    for (const key of ['preview-refused', 'preview-stays', 'preview-moves', 'preview-turns-named', 'preview-turns-slanted', 'preview-carries', 'preview-copies', 'preview-clips', 'preview-face-unknown', 'target-would-loop', 'fasten-summary-gap', 'fasten-summary-twist'])
+    for (const key of ['preview-refused', 'preview-stays', 'preview-moves', 'preview-turns-named', 'preview-turns-slanted', 'preview-carries', 'preview-copies', 'preview-clips', 'preview-face-unknown', 'target-would-loop', 'fasten-summary-gap'])
       assert.ok(t[`figure.text.${key}`], `${lang} ${key}`)
     assert.ok(t['figure.label.fasten-detail'] && t['figure.label.facing'], lang)
   }
@@ -106,7 +106,7 @@ test('a row is seen before it is made, read as figure-model draws it -- and said
   a = addFigureBox(a, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 50, z: 0 } })
   a = addFigureBox(a, { id: 'roller', size: { x: 60, y: 60, z: 560 }, position: { x: 0, y: 130, z: 0 } })
   assert.equal(rowBlockOf(a, 'roller'), 'unfastened')
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' } })
   assert.equal(rowBlockOf(a, 'roller'), undefined)
   const seen = previewFigureCommand(a, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 } as never)
   const held: HeldPreview = { context: 'c', revision: 0, key: 'k', geometry: seen.geometry, moves: seen.moves, added: seen.added, row: figureRowOf(seen.asset, 'roller') }
@@ -127,7 +127,7 @@ test('a published pitch typed into its field is one edit, undone once', async ()
   let a = createFigureAsset('Conveyor')
   a = addFigureBox(a, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 50, z: 0 } })
   a = addFigureBox(a, { id: 'roller', size: { x: 60, y: 60, z: 560 }, position: { x: 0, y: 130, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' } })
   a = applyFigureAuthoring(a, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 })
   const source = serializeFigureAsset(a)
   const s = createFigureProductSession({ load: async (id: string) => ({ id, source }), save: async (q: { id?: string; source: string }) => ({ id: q.id ?? 'x', source: q.source }) })
@@ -157,8 +157,8 @@ test('a motion is named by its parts, and drawn at both ends of its range -- onl
   a = addFigureBox(a, { id: 'frame', size: { x: 2000, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
   a = addFigureBox(a, { id: 'leaf', size: { x: 900, y: 1800, z: 40 }, position: { x: 0, y: 1000, z: 0 } })
   a = addFigureBox(a, { id: 'gate', size: { x: 400, y: 400, z: 40 }, position: { x: 700, y: 300, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', face: 'bottom', to: { part: 'frame', face: 'top' } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'gate', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', to: { part: 'frame', face: 'top' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'gate', to: { part: 'frame', face: 'top' } })
   const j = (part: string) => a.joints!.find(k => k.body1.part === part)!
   assert.equal(motionEndsOf(revisionOf(a), 'leaf'), null, 'not moving: nothing drawn')
   a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j('leaf'), type: 'revolute', axis: 'Y', lowerLimit: 0, upperLimit: 90, state: { id: 'open' } } })
@@ -190,7 +190,7 @@ test('a moving part is made into a row, and a row given or relieved of a motion
   let a = createFigureAsset('Conveyor')
   a = addFigureBox(a, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 50, z: 0 } })
   a = addFigureBox(a, { id: 'roller', size: { x: 60, y: 60, z: 560 }, position: { x: 0, y: 130, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' } })
   const source = serializeFigureAsset(a)
   const s = createFigureProductSession({ load: async (id: string) => ({ id, source }), save: async (q: { id?: string; source: string }) => ({ id: q.id ?? 'x', source: q.source }) })
   await s.open('conveyor')

package/test/face-mapping.test.ts

@@ -17,10 +17,10 @@ import { DETACH, faceMappingRowsOf, remapOf, rowKey } from '../client/modeller/f
 /** A tote with a floor inside and a divider standing on it. */
 function tote(): FigureAsset {
   let asset = addFigureBox(createFigureAsset('Tote'), { id: 'bin', size: { x: 600, y: 300, z: 400 }, position: { x: 0, y: 150, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'bin', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'bin', to: { plane: 'mounting-plane' } })
   asset = applyFigureAuthoring(asset, { kind: 'set-cavity', part: 'bin', cavity: { wall: 10, start: { closed: 15 }, end: 'open' } })
   asset = addFigureBox(asset, { id: 'divider', size: { x: 10, y: 200, z: 380 }, position: { x: 0, y: 0, z: 0 } })
-  return applyFigureAuthoring(asset, { kind: 'attach', part: 'divider', face: 'bottom', to: { part: 'bin', face: 'inside-bottom' as never } })
+  return applyFigureAuthoring(asset, { kind: 'attach', part: 'divider', to: { part: 'bin', face: 'inside-bottom' as never } })
 }
 const open = { kind: 'set-cavity', part: 'bin', cavity: { wall: 10, start: 'open', end: 'open' } } as const
 const needOf = (asset: FigureAsset): FigureFaceMappingNeed => {

package/test/fasten-drawing.test.ts

@@ -14,9 +14,21 @@ const ko = JSON.parse(read('../translations/ko.json')) as Record<string, string>
 const say = (key: string, params: Record<string, string>) => Object.entries(params).reduce((s, [k, v]) => s.replace(`{${k}}`, v), ko[key] ?? key)
 
 test('화면 문구는 결과와 예외만 — 한 줄 요약, 가장자리 밖, 닿지 않음', () => {
-  assert.equal(say('figure.text.fasten-sentence-meet', { part: 'lid', face: '아랫면', to: 'bin의 윗면' }), 'lid의 아랫면을 bin의 윗면에 맞닿게')
-  assert.equal(say('figure.text.fasten-sentence-centre', { part: 'roller', face: '', to: 'frame의 앞면' }), 'roller의 가운데를 frame의 앞면 위에')
+  assert.equal(say('figure.text.fasten-sentence-meet', { to: 'bin의 윗면' }), 'bin의 윗면에 올려놓기')
+  assert.equal(say('figure.text.fasten-sentence-flush', { to: 'bin의 윗면' }), 'bin의 윗면과 같은 면에 붙이기')
+  assert.equal(say('figure.text.fasten-sentence-centre', { to: 'frame의 앞면' }), 'frame의 앞면 가운데에 붙이기')
   for (const key of ['figure.text.fasten-off-face', 'figure.text.fasten-past-edges', 'figure.label.fasten-mode-meet', 'figure.label.fasten-mode-flush', 'figure.label.fasten-mode-centre'])
     for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es']) assert.ok((JSON.parse(read(`../translations/${lang}.json`)) as Record<string, string>)[key], `${lang} ${key}`)
   assert.ok(!/끌어 옮깁니다|면 밖으로도/.test(JSON.stringify(ko)), 'no instructions on the screen')
+  /* The part meets by its real shape, by no face of its own (ADR-0140 3.2): no sentence names one, in any language (UX lane 10-19). */
+  for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es']) {
+    const t = JSON.parse(read(`../translations/${lang}.json`)) as Record<string, string>
+    for (const key of ['fasten-sentence-meet', 'fasten-sentence-flush', 'fasten-sentence-centre', 'held-on-part', 'held-on-plane', 'held-on-plane-worked-out'])
+      assert.ok(!t[`figure.text.${key}`]!.includes('{face}'), `${lang} ${key}`)
+    /* The part the window is open on is not named again: a name's last letter picks the particle (원기둥를, 판를). */
+    for (const key of ['fasten-sentence-meet', 'fasten-sentence-flush', 'fasten-sentence-centre']) assert.ok(!t[`figure.text.${key}`]!.includes('{part}'), `${lang} ${key}`)
+    /* No particle or bracket stuck to a placeholder in the placement refusal: the parts are listed after a colon. */
+    assert.deepEqual(t['figure.text.placement-plane-refused']!.match(/\{[a-z]+\}/g), ['{parts}'], lang)
+    assert.ok(!('figure.text.fasten-editing' in t), `${lang}: a key no screen says is not kept`)
+  }
 })

package/test/fasten-form.test.ts

@@ -14,7 +14,7 @@ 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]! } })
 const fasten = (asset: FigureAsset, part: string, to: string, more = {}) =>
-  applyFigureAuthoring(asset, { kind: 'attach', part, face: 'bottom', to: to === 'plane' ? { plane: 'mounting-plane' } : { part: to, face: 'top' }, ...more } as never)
+  applyFigureAuthoring(asset, { kind: 'attach', part, to: to === 'plane' ? { plane: 'mounting-plane' } : { part: to, face: 'top' }, ...more } as never)
 
 /* A frame on the floor, a roller on the frame 300 mm off its centre, a loose lid beside them. */
 function conveyor() {
@@ -32,12 +32,20 @@ test('opened on what the part has; a loose part opens on nothing chosen', () =>
   assert.equal(fastenPlanOf(r, 'lid', fastenFormOf(r, 'lid')).action, undefined, 'nothing to apply until something is chosen')
 })
 
+test('on the plane: a floor takes a part standing on it or hanging below it, a wall only one standing out of it', () => {
+  const loose = addFigureBox(createFigureAsset('Lamp'), { id: 'lamp', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 0, z: 0 } })
+  const hung = { ...freshFasten(), toPlane: true, facing: 'flush' as const }
+  assert.equal((fastenPlanOf(revisionOf(loose), 'lamp', hung).action as { facing?: string }).facing, 'flush')
+  const wall = { ...loose, placement: 'wall' as const }
+  assert.equal((fastenPlanOf(revisionOf(wall), 'lamp', hung).action as { facing?: string }).facing, undefined, 'a wall: standing out of it')
+})
+
 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'))
-  assert.deepEqual(plan.action, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' }, facing: 'meet', twist: 0, align: { x: { mm: 300 } }, replace: true })
+  assert.deepEqual(plan.action, { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' }, facing: 'meet', align: { x: { mm: 300 } }, replace: true })
   assert.deepEqual(plan.face, { part: 'frame', face: 'top' }, 'the face it meets, lit while tried')
-  assert.equal(fastenSentenceOf('roller', fastenFormOf(r, 'roller'), plan, '바닥', say), 'figure.text.fasten-sentence-meet(part=roller,face=figure.label.face-bottom(),to=frame의 figure.label.face-top())')
+  assert.equal(fastenSentenceOf(fastenFormOf(r, 'roller'), plan, '바닥', say), 'figure.text.fasten-sentence-meet(to=frame의 figure.label.face-top())')
 })
 
 test('aimed at a part, the loose lid keeps its place across the face; aimed at the plane, nothing is said of a part face', () => {

package/test/fasten-geometry.test.ts

@@ -1,52 +1,43 @@
 /*
  * **붙이기 그림이 읽는 것** (사용자 2026-10-01: 「면을 선택하는 것이 복잡해보인다」).
  *
- * 붙이기는 상대 면과 방식(올려놓기 · 같은 면 · 가운데를 면에)만 고른다. 부품의 면은 거기서 정해진다 — 돌려 놓인 부품이면
- * 지금 그 방향을 보는 면이다. 면 위에 놓은 자리는 가운데·안쪽 끝·바깥 끝에 붙고, 그 밖은 mm 다. figure-model 이 그 명령을
- * 받아 부품을 정말 그 자리에 두는지까지 잰다.
+ * 붙이기는 상대 면과 방식(올려놓기 · 같은 면 · 가운데를 면에)만 고른다. 부품은 제 면 없이 지금 자세의 실제 모양으로 닿는다
+ * (ADR-0140 3.2) — 그림의 발자국도 그 모양을 면 위 두 축으로 잰 것이다(figure-model `figureFaceMeasureOf`). 면 위에 놓은 자리는
+ * 가운데·안쪽 끝·바깥 끝에 붙고, 그 밖은 mm 다. figure-model 이 그 명령을 받아 부품을 정말 그 자리에 두는지까지 잰다.
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAsset, figurePartFaceOf } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureAuthoringAction } from '@hatiolab/figure-model'
 
-import { alignmentAt, faceViewOf, myFaceFor, offsetOf, overhangOf, screenOf } from '../client/modeller/fasten-geometry.ts'
+import { alignmentAt, faceViewOf, offsetOf, overhangOf, screenOf } from '../client/modeller/fasten-geometry.ts'
 import { revisionOf } from './revision-of.ts'
 
 const scene = (lidRotation?: { x: number; y: number; z: number }): FigureAsset => {
   let a = addFigureBox(createFigureAsset('Box'), { id: 'bin', size: { x: 600, y: 300, z: 400 }, position: { x: 0, y: 150, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'bin', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'bin', to: { plane: 'mounting-plane' } })
   return addFigureBox(a, { id: 'lid', size: { x: 300, y: 20, z: 200 }, position: { x: 0, y: 400, z: 0 }, ...(lidRotation ? { rotation: lidRotation } : {}) })
 }
 const at = (a: FigureAsset, id: string) => (compileFigureAsset(a).evaluate().geometry.find(g => (g as { id: string }).id === id) as unknown as { pose: { t: number[] } }).pose.t
 
-test('부품의 면은 상대 면과 방식으로 정해진다: 올려놓기는 마주 보는 면, 같은 면은 같은 면, 가운데는 가운데', () => {
-  const a = scene()
-  assert.equal(myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'top' }, 'meet'), 'bottom')
-  assert.equal(myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'top' }, 'flush'), 'top')
-  assert.equal(myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'front' }, 'meet'), 'back')
-  assert.equal(myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'top' }, 'centre'), 'centre')
-  assert.equal(myFaceFor(revisionOf(a), 'lid', 'plane', 'meet'), 'bottom', 'on a floor: the face looking down')
-  assert.equal(myFaceFor(revisionOf(a), 'lid', 'plane', 'centre'), undefined, 'the plane takes a face, never a centre')
-})
-
-test('돌려 놓인 부품이면 지금 아래를 보는 면이다 — 이름이 아니라 방향으로', () => {
-  const a = scene({ x: 90, y: 0, z: 0 })
-  const face = myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'top' }, 'meet')!
-  assert.notEqual(face, 'bottom', 'turned a quarter about X, its bottom no longer looks down')
-  const n = figurePartFaceOf(a, 'lid', face)!.normal
-  assert.ok(Math.abs(n[1]! + 1) < 1e-6, `${face} looks down: ${n}`)
-})
-
 test('면 그림: 상대 면의 크기와 부품 발자국, 가장자리 맞춤이 되는 축', () => {
-  const v = faceViewOf(revisionOf(scene()), 'lid', { part: 'bin', face: 'top' })!
+  const v = faceViewOf(revisionOf(scene()), 'lid', { part: 'bin', face: 'top' }, 'meet')!
   assert.deepEqual(v.axes, ['x', 'z'])
   assert.deepEqual([v.face.x, v.face.z], [600, 400])
   assert.deepEqual([v.part.x, v.part.z], [300, 200])
   assert.deepEqual(v.edges, { x: true, z: true })
 })
 
+test('돌려 놓인 부품의 발자국은 지금 자세의 실제 모양이다 — 제 면 이름이 아니라', () => {
+  /* Turned a quarter about X: its 20 mm thickness now lies along Z across the face. */
+  const v = faceViewOf(revisionOf(scene({ x: 90, y: 0, z: 0 })), 'lid', { part: 'bin', face: 'top' }, 'meet')!
+  assert.deepEqual([v.part.x, v.part.z].map(Math.round), [300, 20])
+  /* Turned 30° about Y: its footprint is the turned box's reach, 300 cos 30 + 200 sin 30 across X. */
+  const turned = faceViewOf(revisionOf(scene({ x: 0, y: 30, z: 0 })), 'lid', { part: 'bin', face: 'top' }, 'meet')!
+  assert.ok(Math.abs(turned.part.x - (300 * Math.cos(Math.PI / 6) + 200 * 0.5)) < 1e-6, String(turned.part.x))
+})
+
 test('놓은 자리: 가운데, 안쪽 끝(가장자리와 나란히), 바깥 끝(가장자리에 닿게), 그 밖은 mm', () => {
   assert.deepEqual(alignmentAt(4, 600, 300, true, 10), { how: 'centre', caught: 'centre' })
   assert.deepEqual(alignmentAt(146, 600, 300, true, 10), { how: 'max', caught: 'inside' })
@@ -58,18 +49,18 @@ test('놓은 자리: 가운데, 안쪽 끝(가장자리와 나란히), 바깥
 })
 
 test('면 밖으로 나온 곳과 닿지 않는 것을 말한다', () => {
-  const v = faceViewOf(revisionOf(scene()), 'lid', { part: 'bin', face: 'top' })!
-  assert.deepEqual(overhangOf(v, { x: 0, y: 0, z: 0 }), { touching: true, sides: [] })
-  assert.deepEqual(overhangOf(v, { x: 200, y: 0, z: 0 }), { touching: true, sides: [{ axis: 'x', side: 'high', mm: 50 }] })
-  assert.equal(overhangOf(v, { x: 460, y: 0, z: 0 }).touching, false)
+  const v = faceViewOf(revisionOf(scene()), 'lid', { part: 'bin', face: 'top' }, 'meet')!
+  assert.deepEqual(overhangOf(v, { x: 0, y: 0, z: 0 }), { touching: true, contact: 'on', sides: [] })
+  assert.deepEqual(overhangOf(v, { x: 200, y: 0, z: 0 }), { touching: true, contact: 'on', sides: [{ axis: 'x', side: 'high', mm: 50 }] })
+  assert.deepEqual(overhangOf(v, { x: 460, y: 0, z: 0 }), { touching: false, contact: 'off', sides: [{ axis: 'x', side: 'high', mm: 310 }] })
 })
 
 test('그 자리가 명령이 되면 figure-model 이 부품을 정말 거기 둔다: 오른쪽 끝, 같은 면, 바깥 끝', () => {
   const a = scene()
   const attach = (extra: Partial<Extract<FigureAuthoringAction, { kind: 'attach' }>>) =>
-    applyFigureAuthoring(a, { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'bin', face: 'top' }, ...extra } as FigureAuthoringAction)
+    applyFigureAuthoring(a, { kind: 'attach', part: 'lid', to: { part: 'bin', face: 'top' }, ...extra } as FigureAuthoringAction)
   assert.deepEqual(at(attach({ align: { x: 'max' } }), 'lid').map(Math.round), [150, 310, 0])
-  assert.deepEqual(at(attach({ face: 'top', facing: 'flush' }), 'lid').map(Math.round), [0, 290, 0])
+  assert.deepEqual(at(attach({ facing: 'flush' }), 'lid').map(Math.round), [0, 290, 0])
   assert.deepEqual(at(attach({ align: { x: { mm: 450 } } }), 'lid').map(Math.round), [450, 310, 0], 'past the edge: fastened all the same')
 })
 

package/test/fix-alignment.test.ts

@@ -1,14 +1,24 @@
 /*
  * 정렬·간격 고치기 (fasten-geometry `insideAlignmentOf`): the alignment that brings a part inside the face it is fastened
- * on -- the least move on each side it is out, the centre when it is wider -- or why there is nothing to move.
+ * on -- the least move on each side it is out, the centre when it is wider -- or why there is nothing to move. The move
+ * is figure-model's (`figureFaceInsideAlignOf`), measured on the part's real shape; this reads it in the form's words.
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { insideAlignmentOf, type FaceView } from '../client/modeller/fasten-geometry.js'
+import { addFigureBox, applyFigureAuthoring, createFigureAsset } from '@hatiolab/figure-model'
+
+import { faceViewOf, insideAlignmentOf, type FaceView } from '../client/modeller/fasten-geometry.js'
+import { revisionOf } from './revision-of.ts'
 
 /* A 400 × 1000 top, a 100 × 100 footprint on it; edges offered on X, a distance only on Z. */
-const view = (part = { x: 100, y: 100, z: 100 }): FaceView => ({ axes: ['x', 'z'], face: { x: 400, z: 1000 }, part, edges: { x: true, y: true, z: false } })
+const view = (part = { x: 100, y: 100, z: 100 }): FaceView => {
+  let a = addFigureBox(createFigureAsset('Top'), { id: 'top', size: { x: 400, y: 40, z: 1000 }, position: { x: 0, y: 20, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'top', to: { plane: 'mounting-plane' } })
+  a = addFigureBox(a, { id: 'box', size: part, position: { x: 0, y: 200, z: 0 } })
+  const v = faceViewOf(revisionOf(a), 'box', { part: 'top', face: 'top' }, 'meet')!
+  return { ...v, edges: { x: true, y: true, z: false } }
+}
 
 test('out past the low edge: moved to that edge from inside, the other axis left as it was', () => {
   const fixed = insideAlignmentOf(view(), { x: 'mm', z: 'centre' }, { x: -1000 })
@@ -28,5 +38,7 @@ test('wider than the face: centred, the most of it on the face', () => {
 test('nothing of it out: inside -- what is out is fastened on it; no face size: unmeasured', () => {
   assert.deepEqual(insideAlignmentOf(view(), { x: 'max', z: 'centre' }, {}), { cannot: 'inside' })
   assert.deepEqual(insideAlignmentOf(undefined, {}, {}), { cannot: 'unmeasured' })
-  assert.deepEqual(insideAlignmentOf({ ...view(), face: { x: 400 } }, {}, {}), { cannot: 'unmeasured' })
+  /* The plane of a figure that declares no size has no edges to measure against. */
+  const loose = addFigureBox(createFigureAsset('Loose'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+  assert.deepEqual(insideAlignmentOf(faceViewOf(revisionOf(loose), 'box', 'plane', 'meet'), {}, {}), { cannot: 'unmeasured' })
 })

package/test/gizmo.test.ts

@@ -53,7 +53,7 @@ test('다른 부품에 붙인 부품은 옮기지 않는다 — 다음 평가가
   /* attach takes box-shaped parts only. */
   const lidded = addFigureBox(probe(), { id: 'lid', size: { x: 100, y: 20, z: 100 }, position: { x: 0, y: 300, z: 0 } })
   assert.equal(gizmoReachOf(lidded as never, 'lid').translate, true, '전제: 붙이기 전에는 옮길 수 있다')
-  const fastened = applyFigureAuthoring(lidded, { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'body', face: 'top' } })
+  const fastened = applyFigureAuthoring(lidded, { kind: 'attach', part: 'lid', to: { part: 'body', face: 'top' } })
   assert.equal(gizmoReachOf(fastened as never, 'lid').translate, false)
 })
 
@@ -98,7 +98,7 @@ test('기즈모의 말은 다섯 말 모두에 있다', () => {
 test('떼어 낸 부품은 다시 옮길 수 있다 — 움직임이 있는 부품은 아니다', () => {
   let asset = probe()
   asset = addFigureBox(asset, { id: 'lid', size: { x: 100, y: 20, z: 100 }, position: { x: 0, y: 300, z: 0 } })
-  const fastened = applyFigureAuthoring(asset, { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'body', face: 'top' } })
+  const fastened = applyFigureAuthoring(asset, { kind: 'attach', part: 'lid', to: { part: 'body', face: 'top' } })
   const free = applyFigureAuthoring(fastened, { kind: 'detach', part: 'lid' })
   assert.equal(gizmoReachOf(free as never, 'lid').translate, true)
   const slid = moving(free, 'lid', { kind: 'slide', axis: 'x', id: 'lid-slide', min: 0, max: 100, start: 0 })

package/test/joint-drag.test.ts

@@ -14,10 +14,10 @@ function column(joint: Partial<FigureJoint>): FigureAsset {
   let asset = createFigureAsset('Column')
   asset = addFigureBox(asset, { id: 'post', size: { x: 100, y: 200, z: 100 }, position: { x: 0, y: 100, z: 0 } })
   asset = addFigureBox(asset, { id: 'link', size: { x: 60, y: 300, z: 60 }, position: { x: 0, y: 350, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'post', face: 'bottom', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'post', to: { plane: 'mounting-plane' } })
   return applyFigureAuthoring(asset, {
     kind: 'set-joint',
-    joint: { id: 'bend', type: 'fixed', body0: { part: 'post', face: 'top' }, body1: { part: 'link', face: 'bottom' }, ...joint } as FigureJoint
+    joint: { id: 'bend', type: 'fixed', body0: { part: 'post', face: 'top' }, body1: { part: 'link' }, ...joint } as FigureJoint
   })
 }
 
@@ -61,6 +61,17 @@ test('고정 관절에 달린 부품을 옮기면 관절이 놓인 자리 —
   assert.deepEqual((aside as { joint: FigureJoint }).joint.origin, { align: { x: { mm: 30 } } })
 })
 
+test('면 밖으로 끈 만큼 따라온다 — 맞닿음 · 가운데는 간격이 늘고, 같은 면은 줄어든다 (ADR-0140 3.11)', () => {
+  for (const facing of ['meet', 'flush', 'centre'] as const) {
+    const asset = column({ origin: { facing } })
+    const part = drawn(asset, 'link')
+    const up = jointDragOf(asset, 'link', part as never, { position: [part.pose.t[0]!, part.pose.t[1]! + 25, part.pose.t[2]!] }, {}) as { joint: FigureJoint }
+    assert.equal(up.joint.origin!.gap, facing === 'flush' ? -25 : 25, facing)
+    const moved = drawn(applyFigureAuthoring(asset, { kind: 'set-joint', joint: up.joint }), 'link')
+    assert.ok(Math.abs(moved.pose.t[1]! - (part.pose.t[1]! + 25)) < 1e-6, `${facing}: the link where it was dragged to`)
+  }
+})
+
 test('관계를 끊는 끌기는 거절하고 까닭을 댄다', () => {
   const edge = column({ origin: { align: { x: 'min' } } })
   const part = drawn(edge, 'link')

package/test/joint-fan.test.ts

@@ -21,7 +21,7 @@ function arm(): FigureAsset {
   asset = addFigureBox(asset, { id: 'base', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
   asset = addFigureBox(asset, { id: 'arm', size: { x: 400, y: 50, z: 50 }, position: { x: 200, y: 125, z: 0 } })
   /* On the base's top, level with its left edge: it turns about that edge, at x = -100. */
-  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'arm', face: 'bottom', to: { part: 'base', face: 'top' }, align: { x: 'min' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'arm', to: { part: 'base', face: 'top' }, align: { x: 'min' } })
   return moving(asset, 'arm', { kind: 'turn', axis: 'y', id: 'arm.turn', min: -45, max: 90 })
 }
 const PIVOT = [-100, 100, 0]