@things-factory/figure-ui 10.1.200 → 10.1.201

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.200",
+  "version": "10.1.201",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -27,8 +27,8 @@
     "clean": "npm run clean:server && npm run clean:client"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.8.0",
-    "@hatiolab/things-scene": "^10.1.93",
+    "@hatiolab/figure-model": "^0.9.3",
+    "@hatiolab/things-scene": "^10.1.95",
     "@material/web": "^2.0.0",
     "@operato/data-grist": "^10.29.43",
     "@operato/graphql": "^10.29.43",
@@ -43,10 +43,10 @@
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.29.43",
     "@things-factory/ai-assistant": "^10.1.198",
-    "@things-factory/figure-service": "^10.1.200",
-    "@things-factory/figure-viewer": "^10.1.200",
+    "@things-factory/figure-service": "^10.1.201",
+    "@things-factory/figure-viewer": "^10.1.201",
     "@things-factory/setting-base": "^10.1.198",
     "three": "^0.185.1"
   },
-  "gitHead": "549b5b571862f9c52ab407fe85d117fd33bd8d1f"
+  "gitHead": "6d7a1ae96c2e21bc95b9913b0b32f9ad44c7f87a"
 }

package/test/ai-proposal.test.ts

@@ -26,7 +26,7 @@ const store = {
 }
 const steps = [
   { kind: 'add-part', part: { id: 'lid', kind: 'box', dimensions: { width: 100, height: 10, depth: 100 } } },
-  { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'body', face: 'top' } },
+  { kind: 'attach', part: 'lid', to: { part: 'body', face: 'top' } },
   { kind: 'rename', name: 'Box with lid' }
 ] as any[]
 

package/test/browser/acceptance-page.js

@@ -53,7 +53,7 @@ export const MODELS = {
     a.palette = { ...a.palette, ...PALETTE }
     a = addFigurePrimitive(a, { id: 'wedge', kind: 'polygon', dimensions: { height: 200 }, points: [{ x: -300, z: -200 }, { x: 300, z: -200 }, { x: 0, z: 250 }], position: { x: 0, y: 100, z: 0 } })
     a = addFigureBox(a, { id: 'cap', size: { x: 100, y: 20, z: 100 }, position: { x: 0, y: 0, z: 0 } })
-    a = applyFigureAuthoring(a, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'wedge', face: 'top' } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: 'cap', to: { part: 'wedge', face: 'top' } })
     return serializeFigureAsset(a)
   },
   /* A lid fastened to the top of a bin standing on the floor: the fastening drawn and dragged (user 2026-10-01). */
@@ -61,9 +61,9 @@ export const MODELS = {
     let a = createFigureAsset('Lid on bin')
     a.palette = { ...a.palette, ...PALETTE }
     a = addFigureBox(a, { 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 = addFigureBox(a, { id: 'lid', size: { x: 300, y: 20, z: 200 }, position: { x: 0, y: 0, z: 0 } })
-    a = applyFigureAuthoring(a, { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'bin', face: 'top' } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: 'lid', to: { part: 'bin', face: 'top' } })
     return serializeFigureAsset(a)
   },
   /* A divider standing on a tote's inside floor: opening the bottom asks where the divider goes (ADR-0100 A8). */
@@ -71,10 +71,10 @@ export const MODELS = {
     let a = createFigureAsset('Divider in tote')
     a.palette = { ...a.palette, ...PALETTE }
     a = addFigureBox(a, { 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 } })
-    a = applyFigureAuthoring(a, { kind: 'attach', part: 'divider', face: 'bottom', to: { part: 'bin', face: 'inside-bottom' } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: 'divider', to: { part: 'bin', face: 'inside-bottom' } })
     return serializeFigureAsset(a)
   },
   /* A box and a drum: rounded corners and an inside from the properties tab (ADR-0100 stage 1). */
@@ -110,7 +110,7 @@ export const MODELS = {
     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]]) {
       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 }] })
@@ -123,7 +123,7 @@ export const MODELS = {
     a.palette = { ...a.palette, ...PALETTE }
     a = addFigureBox(a, { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 400, z: 0 } })
     a = addFigureBox(a, { id: 'roller', size: { x: 60, y: 60, z: 560 }, position: { x: 0, y: 480, 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' } })
     return serializeFigureAsset(a)
   },
   /* A device fastened on a bench top 300 mm off centre: the top narrowed on the screen brings it past the edge (C, scenario 1, Q3). */
@@ -133,8 +133,8 @@ export const MODELS = {
     a = addFigureBox(a, { id: 'leg', size: { x: 60, y: 700, z: 60 }, position: { x: 0, y: 350, z: 0 } })
     a = addFigureBox(a, { id: 'top', size: { x: 1200, y: 40, z: 600 }, position: { x: 0, y: 720, z: 0 } })
     a = addFigureBox(a, { id: 'device', size: { x: 100, y: 100, z: 100 }, position: { x: 300, y: 790, z: 100 } })
-    a = applyFigureAuthoring(a, { kind: 'attach', part: 'top', face: 'bottom', to: { part: 'leg', face: 'top' } })
-    a = applyFigureAuthoring(a, { kind: 'attach', part: 'device', face: 'bottom', to: { part: 'top', face: 'top' }, align: { x: { mm: 300 }, z: { mm: 100 } } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: 'top', to: { part: 'leg', face: 'top' } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: 'device', to: { part: 'top', face: 'top' }, align: { x: { mm: 300 }, z: { mm: 100 } } })
     return serializeFigureAsset(a)
   },
   /* A door leaf fastened to its frame, not moving yet: its motion is set on the screen (C, scenario 3). */
@@ -144,8 +144,8 @@ export const MODELS = {
     a = addFigureBox(a, { id: 'frame', size: { x: 1200, 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: 'handle', size: { x: 30, y: 150, z: 60 }, position: { x: 350, y: 1000, z: 50 } })
-    a = applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', face: 'bottom', to: { part: 'frame', face: 'top' } })
-    a = applyFigureAuthoring(a, { kind: 'attach', part: 'handle', face: 'back', to: { part: 'leaf', face: 'front' }, align: { x: { mm: 350 } } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', to: { part: 'frame', face: 'top' } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: 'handle', to: { part: 'leaf', face: 'front' }, align: { x: { mm: 350 } } })
     return serializeFigureAsset(a)
   },
   /* A ball: no face to lay on the floor, and not said to be tilted. */

package/test/browser/detail-page.js

@@ -11,7 +11,7 @@ async function start() {
   asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 50, max: 400 }, y: { min: 50, max: 400 }, z: { min: 50, max: 400 } }, at: { x: 100, y: 100, z: 100 } })
   asset = applyFigureAuthoring(asset, { kind: 'follow-size', part: 'block', axes: ['x', 'y', 'z'] })
   asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: {
-    id: 'block', type: 'prismatic', body0: { plane: 'mounting-plane' }, body1: { part: 'block', face: 'bottom' }, axis: 'X', lowerLimit: 0, upperLimit: 200, state: { id: 'shift', start: 0 }
+    id: 'block', type: 'prismatic', body0: { plane: 'mounting-plane' }, body1: { part: 'block' }, axis: 'X', lowerLimit: 0, upperLimit: 200, state: { id: 'shift', start: 0 }
   } })
   asset = editFigurePart(asset, { kind: 'set-driver', state: 'shift', clip: 'cycle', duration: 4, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 200 }, { seconds: 4, value: 0 }] })
   /* Its room declared from its parts over the whole motion, as the modeller does before a release. */

package/test/browser/detail-tabs-page.js

@@ -13,7 +13,7 @@ for (let i = 0; i < PARTS; i++) {
   const id = `slide-${i}`
   asset = addFigureBox(asset, { id, size: { x: 40, y: 40, z: 40 }, position: { x: i * 60, y: 20, z: 0 } })
   asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: {
-    id, type: 'prismatic', body0: { plane: 'mounting-plane' }, body1: { part: id, face: 'bottom' }, axis: 'Z', lowerLimit: 0, upperLimit: 100, state: { id: `${id}-z`, start: 0 }
+    id, type: 'prismatic', body0: { plane: 'mounting-plane' }, body1: { part: id }, axis: 'Z', lowerLimit: 0, upperLimit: 100, state: { id: `${id}-z`, start: 0 }
   } })
   asset = editFigurePart(asset, { kind: 'set-driver', state: `${id}-z`, clip: `cycle-${i}`, duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 1, value: 100 }, { seconds: 2, value: 0 }] })
 }

package/test/browser/editing-page.js

@@ -50,7 +50,7 @@ window.figures = {
     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]]) {
       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/browser/fix-alignment.check.mjs

@@ -66,13 +66,13 @@ const words = () => read(() => [...(findDeep('div[overhang]')?.querySelectorAll(
 /* A 400 × 1000 deck; a 100 mm block on it, fastened 1000 mm off its centre along X -- past its low edge. */
 function figure(withChild = false) {
   let a = addFigureBox(createFigureAsset('Deck'), { id: 'deck', size: { x: 400, y: 50, z: 1000 }, position: { x: 0, y: 25, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'deck', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'deck', to: { plane: 'mounting-plane' } })
   a = addFigureBox(a, { id: 'block', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 100, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'block', face: 'bottom', to: { part: 'deck', face: 'top' }, ...(withChild ? {} : { align: { x: { mm: -1000 } } }) })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'block', to: { part: 'deck', face: 'top' }, ...(withChild ? {} : { align: { x: { mm: -1000 } } }) })
   if (!withChild) return a
   /* The block inside; a cap on it, past the block's edge. */
   a = addFigureBox(a, { id: 'cap', size: { x: 40, y: 40, z: 40 }, position: { x: 0, y: 170, z: 0 } })
-  return applyFigureAuthoring(a, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'block', face: 'top' }, align: { x: { mm: 300 } } })
+  return applyFigureAuthoring(a, { kind: 'attach', part: 'cap', to: { part: 'block', face: 'top' }, align: { x: { mm: 300 } } })
 }
 
 describe('정렬·간격 고치기 moves a part inside the face it is fastened on', () => {

package/test/browser/links.check.mjs

@@ -179,7 +179,7 @@ async function type(field, text) {
 }
 
 const box = (asset, id, [x, y, z], at = [0, 0, 0]) => addFigureBox(asset, { id, size: { x, y, z }, position: { x: at[0], y: at[1], z: at[2] } })
-const fasten = (asset, part, to, more = {}) => applyFigureAuthoring(asset, { kind: 'attach', part, face: 'bottom', to: to === 'plane' ? { plane: 'mounting-plane' } : { part: to, face: 'top' }, ...more })
+const fasten = (asset, part, to, more = {}) => applyFigureAuthoring(asset, { kind: 'attach', part, to: to === 'plane' ? { plane: 'mounting-plane' } : { part: to, face: 'top' }, ...more })
 const SIZE = { x: { min: 100, max: 4000 }, y: { min: 100, max: 4000 }, z: { min: 100, max: 4000 } }
 
 describe('a size rule that would follow itself, and a fastening that would hang from itself, are refused and said', () => {
@@ -202,7 +202,7 @@ describe('a size rule that would follow itself, and a fastening that would hang
   test('a fastened to b, which hangs from it: refused, said as a loop, nothing written', async () => {
     await pick('a')
     const start = await state()
-    await read(() => look.tell('shape', 'command', { action: { kind: 'attach', part: 'a', face: 'bottom', to: { part: 'b', face: 'top' } } }))
+    await read(() => look.tell('shape', 'command', { action: { kind: 'attach', part: 'a', to: { part: 'b', face: 'top' } } }))
     await until(() => probe.state().error === 'figure.text.fasten-would-loop', [], 'the loop said')
     assert.equal((await state()).revision, start.revision, 'nothing written')
   })
@@ -419,7 +419,7 @@ describe('a new fastening for a door leaf: chosen in the window, seen before it
   })
 
   test('a refused command clears what was drawn and says why, in the window', async () => {
-    await read(() => look.tell('dialog', 'preview-command', { action: { kind: 'attach', part: 'leaf', face: 'bottom', to: { part: 'frame', face: 'nowhere' } } }))
+    await read(() => look.tell('dialog', 'preview-command', { action: { kind: 'attach', part: 'leaf', to: { part: 'frame', face: 'nowhere' } } }))
     await until(() => look.all('[preview-words]', 'figure.text.preview-refused').length > 0, [], 'the refusal said')
     assert.deepEqual(await ghosts(), [], 'nothing of the earlier result drawn')
   })
@@ -490,15 +490,26 @@ async function pressFixAlignment() {
 describe('past the edge of the face a part is fastened to', () => {
   before(async () => {
     let a = fasten(box(createFigureAsset('Overhangs'), 'frame', [1000, 100, 400], [0, 50, 0]), 'frame', 'plane')
-    /* Pushed 30 mm past the frame's right edge; the same, turned; on a drum's round end; wider than the frame, off to one side. */
+    /* Pushed 30 mm past the frame's right edge; a mesh turned on it, its box past the edge; on a drum's round end; wider than the frame, off to one side. */
     a = fasten(box(a, 'out', [100, 100, 100]), 'out', 'frame', { align: { x: { mm: 480 } } })
-    a = fasten(box(a, 'tilted', [100, 100, 100]), 'tilted', 'frame', { align: { x: { mm: 460 } }, twist: 30 })
+    const mesh = { asset: 'a'.repeat(64), format: 'glb', unit: 'mm', bounds: { min: { x: -50, y: -50, z: -50 }, max: { x: 50, y: 50, z: 50 } }, triangles: 12, primitives: 1 }
+    a = addFigurePrimitive(a, { id: 'tilted', kind: 'mesh', dimensions: { size: 100 }, mesh, position: { x: 0, y: 0, z: 0 } })
+    a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'tilted', type: 'fixed', body0: { part: 'frame', face: 'top' }, body1: { part: 'tilted' }, origin: { align: { x: { mm: 460 } }, childRotate: { y: 30 } } } })
     a = fasten(addFigurePrimitive(a, { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 200 }, position: { x: 0, y: 0, z: 0 } }), 'drum', 'frame')
     a = fasten(box(a, 'cap', [50, 50, 50]), 'cap', 'drum')
     await mount('overhangs', fasten(box(a, 'plate', [1600, 20, 200]), 'plate', 'frame', { align: { x: { mm: 200 } } }))
   })
   const overhang = () => read(() => look.all('div[overhang] p').map(p => p.text))
 
+  test('the face a part is held on is lit while the panel names it, whichever part is chosen (UX lane, ADR-0140 3.11)', async () => {
+    const litAt = y => Math.abs((document.querySelector('figure-editor').shadowRoot.querySelector('figure-canvas').highlight?.pose.t[1] ?? 0) - y) < 2
+    await pick('out')
+    await until(() => look.all('div[fastened] p', 'figure.text.held-on-part').length + look.all('p[fasten-sentence]').length > 0, [], 'the panel names where it is held')
+    await until(litAt, [102], "the frame's top lit (the lit plate a little over it)")
+    await pick('cap')
+    await until(litAt, [302], "the drum's top lit")
+  })
+
   test('past it: said, and "fix alignment" moves it inside the face as one step', async () => {
     await pick('out')
     await until(() => look.all('div[overhang] p', 'figure.text.overhang-out').length === 1, [], 'said past the edge')
@@ -508,7 +519,7 @@ describe('past the edge of the face a part is fastened to', () => {
     await until(() => look.all('div[overhang] p', 'figure.text.overhang-out').length === 0, [], 'no longer past the edge')
   })
 
-  test('turned, it may be past it: said so', async () => {
+  test('a mesh turned on the face, its box past it, may be past it: said so', async () => {
     await pick('tilted')
     await until(() => look.all('div[overhang] p', 'figure.text.overhang-possible').length === 1, [], 'said it may be')
   })
@@ -596,10 +607,11 @@ describe('a bench: what each part is fastened to, what detaching would do, a row
   })
 })
 
-/* A blade fastened twisted on a hub: no face figure-model can keep for a size drag. */
+/* A blade fastened tilted on a hub (off a quarter turn): no side of its own figure-model can keep for a size drag. */
 function twisted() {
   const a = fasten(box(createFigureAsset('Fan'), 'hub', [200, 100, 200], [0, 50, 0]), 'hub', 'plane')
-  return fasten(box(a, 'blade', [300, 20, 60], [0, 110, 0]), 'blade', 'hub', { twist: 30 })
+  const on = fasten(box(a, 'blade', [300, 20, 60], [0, 110, 0]), 'blade', 'hub')
+  return applyFigureAuthoring(on, { kind: 'set-joint', joint: { ...on.joints.find(j => j.id === 'blade'), origin: { childRotate: { z: 30 } } } })
 }
 
 /* The same blade, every side of it following the hub's (as the fan's blade-2 on :3300): no size of its own to type. */

package/test/browser/modeller-page.js

@@ -67,11 +67,11 @@ function sourceOf(kind, text) {
     let asset = createFigureAsset('Rollers')
     asset.palette = { ...asset.palette, ...PALETTE }
     asset = addFigureBox(asset, { 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 })
+    asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'roller', facing: 'centre', to: { part: 'bed', face: 'top' }, gap: 40 })
     asset = addFigureBox(asset, { id: 'mark', size: { x: 30, y: 30, z: 560 }, position: { x: 0, y: 0, z: 0 } })
-    asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'mark', face: 'left', to: { part: 'roller', face: 'right' } })
+    asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'mark', to: { part: 'roller', face: 'right' } })
     const j = asset.joints.find(o => o.body1.part === 'roller')
     asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Z', lowerLimit: -360, upperLimit: 360, state: { id: 'spin' } } })
     return serializeFigureAsset(applyFigureAuthoring(asset, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 }))

package/test/browser/part-ids.check.mjs

@@ -50,9 +50,9 @@ async function click(selector, options = {}, what = selector) {
 /* box-1 on the floor, box-2 on it made into a row 300 apart: box-2's id is drawn nowhere as it is. */
 function rowed() {
   let a = addFigureBox(createFigureAsset('Rowed'), { id: 'box-1', size: { x: 1000, y: 100, z: 400 }, position: { x: 0, y: 50, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'box-1', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'box-1', to: { plane: 'mounting-plane' } })
   a = addFigureBox(a, { id: 'box-2', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 150, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'attach', part: 'box-2', face: 'bottom', to: { part: 'box-1', face: 'top' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'box-2', to: { part: 'box-1', face: 'top' } })
   a = applyFigureAuthoring(a, { kind: 'make-repeat', part: 'box-2', axis: 'x', pitch: 300 })
   /* A part off to one side, free: its mirrored copy lands on the other side. */
   return addFigureBox(a, { id: 'side', size: { x: 100, y: 100, z: 100 }, position: { x: 900, y: 50, z: 0 } })

package/test/browser/parts-page.js

@@ -33,7 +33,7 @@ Object.assign(window.figures, {
     let a = figure('Fastened')
     a = addFigureBox(a, { id: 'frame', size: { x: 1600, y: 100, z: 150 }, position: { x: 0, y: 50, z: 0 } })
     a = addFigureBox(a, { id: 'leaf', size: { x: 1400, y: 1000, z: 40 }, position: { x: 0, y: 600, z: 0 } })
-    return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', face: 'bottom', to: { part: 'frame', face: 'top' } }))
+    return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', to: { part: 'frame', face: 'top' } }))
   },
   /* A box with rounded corners: made from the box, still called what it is. */
   /* A housing and a stray part on the floor, the space the figure takes declared from both. */
@@ -41,7 +41,7 @@ Object.assign(window.figures, {
     let a = figure('Gate')
     a = addFigureBox(a, { id: 'housing', size: { x: 300, y: 1000, z: 300 }, position: { x: 0, y: 500, z: 0 } })
     a = addFigureBox(a, { id: 'stray', size: { x: 100, y: 100, z: 100 }, position: { x: 600, y: 50, z: 0 } })
-    for (const part of ['housing', 'stray']) a = applyFigureAuthoring(a, { kind: 'attach', part, face: 'bottom', to: { plane: 'mounting-plane' } })
+    for (const part of ['housing', 'stray']) a = applyFigureAuthoring(a, { kind: 'attach', part, to: { plane: 'mounting-plane' } })
     return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' }))
   },
   rounded: () => {

package/test/browser/product-page.check.mjs

@@ -611,10 +611,10 @@ describe('the page around the figure: the shell, the dock, the properties', () =
 })
 
 describe('a placement the figure\'s parts refuse, chosen on the properties tab (wall placement, 09-25)', () => {
-  /* A post standing on the floor's plane by its bottom: a wall takes the back face, so the wall is refused. */
+  /* A post standing on the floor's plane: a wall's plane faces another way, so the post is named and the wall refused. */
   const post = () => {
     const a = addFigureBox(createFigureAsset('Post'), { id: 'post', size: { x: 100, y: 1000, z: 100 }, position: { x: 0, y: 500, z: 0 } })
-    return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'attach', part: 'post', face: 'bottom', to: { plane: 'mounting-plane' } }))
+    return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'attach', part: 'post', to: { plane: 'mounting-plane' } }))
   }
   const placement = () =>
     read(() => {
@@ -640,7 +640,7 @@ describe('a placement the figure\'s parts refuse, chosen on the properties tab (
     const said = await until(() => product.deep('figure-modeller-page >>> p[fit-error]')[0]?.textContent.trim(), 'the refusal said')
     /* Said from the kernel's details (ADR-0127): the page loads no translations, so the words are the key with its values. */
     assert.match(said, /^figure\.text\./, said)
-    assert.ok(said.includes('post') && said.includes('back'), `names the part and the face the wall takes: ${said}`)
+    assert.ok(said.includes('post'), `names the part to fasten again: ${said}`)
     assert.equal(await revision(), start, 'nothing written')
     assert.equal(await placement(), 'floor', 'the list says the placement the figure has')
   })

package/test/browser/product-page.js

@@ -45,7 +45,7 @@ export function doorSource() {
   a.palette = { ...a.palette, ...PALETTE }
   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 = 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/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`)
+  }
 })