@things-factory/figure-ui 10.1.204 → 10.1.206

package/test/browser/links.check.mjs

@@ -93,7 +93,7 @@ const tab = name => read(l => probe.tab(l), `figure.label.tab-short-${name}`).th
 /** A fastening the part has is said in one line; 「바꾸기」 opens the fastening window on it. */
 async function changeFastening() {
   await until(() => look.all('button[change-fastening]').length === 1, [], 'the fastening said in one line')
-  await (await handle('button[change-fastening]')).click()
+  await press('button[change-fastening]')
   await until(() => !!probe.fastenTargets(), [], 'the fastening window open')
 }
 /** The window's list: each row's part and words, whether chosen, whether it can be. Null while the window is closed. */
@@ -241,7 +241,7 @@ describe('a part made to follow the figure size, and let go of it', () => {
   })
 })
 
-/* A base and a flange, sized; the height may be placed from 90 mm though the parts measure down to 1. */
+/* A base and a flange, sized, saved with ends on every axis: the height from 90 mm, the others from 1 mm. */
 function sizedPair(turning) {
   let a = box(createFigureAsset('Probe'), 'base', [200, 100, 200], [0, 50, 0])
   a = addFigurePrimitive(a, { id: 'flange', kind: 'cylinder', dimensions: { radius: 20, length: 10 }, position: { x: 0, y: 105, z: 0 } })
@@ -256,16 +256,11 @@ function sizedPair(turning) {
 }
 
 describe('the sizes a figure may be placed at, and how it grows', () => {
-  test('measured again, the declared range becomes the measured one in one step, and the offer goes', async () => {
+  test('a figure saved with ends reads them as typed, and nothing is offered to measure again', async () => {
     await mount('sized-pair', sizedPair(false))
     /* The figure's range is the 「반응형」 tab's. */
     await tab('response')
-    const start = await state()
-    await click(await at('button', 'figure.button.remeasure-range'), 'remeasure')
-    await oneStep(start)
-    const y = (await source()).document.model.inputs.find(i => i.id === 'size.y')
-    assert.deepEqual([y.min, y.max], [1, 1000], 'the height from 1 mm, as measured')
-    assert.equal(await at('button', 'figure.button.remeasure-range'), null, 'nothing left to measure again')
+    assert.equal(await at('button', 'figure.button.remeasure-range'), null, 'nothing to measure again')
   })
 
   test('a figure with no joint is not urged to grow by one ratio; declared, the rule is said', async () => {
@@ -282,6 +277,26 @@ describe('the sizes a figure may be placed at, and how it grows', () => {
   })
 })
 
+/*
+  A link that makes the height impossible below 95 mm is made, not refused (user 2026-10-21): the smallest height the
+  author narrowed to, 90 mm, moves in to 95 in the same step, and one line says from what to what (ADR-0087 decision 6).
+*/
+describe('a part change a narrowed end cannot hold', () => {
+  test('is one step; the end moves in, said in one line', async () => {
+    await mount('sized-pair-moved', sizedPair(false))
+    await pick('flange')
+    await read(() => look.hear('notify'))
+    const start = await state()
+    await read(() => look.tell('shape', 'command', { action: { kind: 'link-dimension', part: 'flange', axis: 'y', source: { of: 'instance', axis: 'y' }, plus: -95 } }))
+    await oneStep(start)
+    assert.equal((await state()).error, '', 'not refused')
+    const y = (await source()).document.model.inputs.find(i => i.id === 'size.y')
+    assert.ok(y.min > 95 && y.min < 95.001 && y.max === 1000, `the smallest height moved in: ${y.min}`)
+    const told = (await heard('notify')).filter(n => n?.level === 'info' && String(n.message).includes('figure.text.size-range-moved-min'))
+    assert.equal(told.length, 1, 'said once')
+  })
+})
+
 /* A conveyor's rollers in a row across its frame, 200 mm apart. */
 function conveyor() {
   let a = fasten(box(createFigureAsset('Conveyor'), 'frame', [2000, 100, 600], [0, 50, 0]), 'frame', 'plane')
@@ -388,22 +403,22 @@ describe('a new fastening for a door leaf: chosen in the window, seen before it
   })
   const ghosts = () => read(() => look.drawn().filter(n => n.startsWith('__preview')))
 
-  test('started, the window opens over the side panel, asking what to fasten to, nothing chosen; the canvas stays in sight', async () => {
+  test('started, the window opens in the standard popup, asking what to fasten to, nothing chosen', async () => {
     await pick('leaf')
     await press('button[fasten-start]')
     const list = await until(() => probe.fastenTargets(), [], 'the fastening window')
     assert.deepEqual(list.filter(t => t.selected), [], 'nothing chosen')
     assert.ok(list.some(t => t.target === 'frame' && !t.disabled), 'the frame offered')
     assert.deepEqual((await all('[apply]')).map(b => b.disabled), [true], 'nothing to apply yet')
-    /* Not the modal popup (user 2026-10-19: it covered the 3D it was choosing for): over the side panel, at most its edge over the canvas. */
-    const panel = await read(() => probe.fastenPanel())
-    assert.deepEqual({ ...panel, overCanvas: undefined }, { title: 'figure.label.fastening', role: 'dialog', popup: false, overCanvas: undefined })
-    assert.ok(panel.overCanvas <= 0.1, `the canvas stays in sight: ${panel.overCanvas} of its width covered`)
+    /* The standard popup, moved by its head, with no backdrop: the canvas can be pressed while it is open (ADR-0140 stage 4). */
+    assert.deepEqual(await read(() => probe.fastenPopup()), { title: 'figure.label.fastening', movable: true, backdrop: false, role: 'dialog' })
   })
 
-  test('the frame chosen: the editor is told the command, and the canvas draws where the leaf would go and the face it meets', async () => {
+  /* Chosen in the window, the gap is the distance the leaf stands at: it is fastened where it is (ADR-0140 stage 4, 「현재 상태로 붙이기」). */
+  test('the frame chosen: the editor is told the command, and the canvas draws the face it meets; the leaf stays where it stands', async () => {
     await aimAt('frame')
-    await until(() => look.drawn().includes('__preview:leaf') && look.drawn().includes('__target-face'), [], 'the leaf and the face drawn')
+    await until(() => look.drawn().includes('__target-face') && look.all('[preview-words]', 'figure.text.preview-stays').length > 0, [], 'the face drawn and the leaf said to stay')
+    assert.deepEqual(await ghosts(), [], 'nothing drawn where it would go: it does not move')
     const told = (await heard('preview-command')).filter(Boolean).at(-1)
     assert.equal(told?.action.kind, 'attach')
     assert.equal((await source()).joints?.some(j => j.body1.part === 'leaf') ?? false, false, 'nothing written')
@@ -424,15 +439,15 @@ describe('a new fastening for a door leaf: chosen in the window, seen before it
     assert.deepEqual(await ghosts(), [], 'nothing of the earlier result drawn')
   })
 
-  test('another part picked in the list closes the window with nothing written, and nothing it tried is drawn', async () => {
+  test('another tab pressed closes the window with nothing written, and nothing it tried is drawn', async () => {
     const start = await state()
-    /* No backdrop over the page: the parts list stays reachable. The window stands over the side panel, its tabs too, as the view settings do. */
-    assert.ok((await read(() => probe.fastenPanel())).overCanvas <= 0.1)
-    await pick('frame')
+    /* No backdrop: the press reaches the tab, and the window, which is the properties tab's, closes. */
+    await click(await read(l => probe.tab(l), 'figure.label.tab-short-motion'), 'the motion tab')
     await until(() => !probe.fastenTargets(), [], 'the window closed')
     await until(() => !look.drawn().some(n => n.startsWith('__preview')), [], 'nothing it tried drawn')
+    assert.equal(await read(() => look.tab()), 'figure.label.tab-short-motion', 'the press reached the tab')
     assert.equal((await state()).revision, start.revision, 'nothing written')
-    await pick('leaf')
+    await tab('properties')
   })
 
   test('"fasten it first" from the motion tab opens this part\'s window, on what it has, on the properties tab', async () => {
@@ -445,7 +460,7 @@ describe('a new fastening for a door leaf: chosen in the window, seen before it
 
   test('Esc closes the window and tells the editor to clear what it tried; the leaf stays selected', async () => {
     await aimAt('frame')
-    await until(() => look.drawn().includes('__preview:leaf'), [], 'the leaf drawn where it would go')
+    await until(() => look.drawn().includes('__target-face'), [], 'the face it would meet drawn')
     await read(() => look.hear('preview-command', 'dialog'))
     await page().keyboard.press('Escape')
     await until(() => !probe.fastenTargets(), [], 'the window closed')
@@ -461,9 +476,9 @@ describe('a new fastening for a door leaf: chosen in the window, seen before it
     await aimAt('frame')
     /*
       The frame's faces are offered once the drawing has the frame: a press before that is not a choice. And the press is
-      aimed once the window has drawn what the choice brings -- the leaf where it would go -- or it lands where the face was.
+      aimed once the window has drawn what the choice brings -- the face it would meet -- or it lands where the face was.
     */
-    await until(() => look.face('front')?.pickable && look.drawn().includes('__preview:leaf'), [], 'the front face offered, the leaf drawn where it would go')
+    await until(() => look.face('front')?.pickable && look.drawn().includes('__target-face'), [], 'the front face offered, the face it would meet drawn')
     await settled()
     await sleep(200)
     await click(await at('path[face="front"]'), 'the front face in the drawing')
@@ -490,13 +505,13 @@ 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; a mesh turned on it, its box past the edge; 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, within its square and past its rim; wider than the frame, off to one side. */
     a = fasten(box(a, 'out', [100, 100, 100]), 'out', 'frame', { align: { x: { mm: 480 } } })
     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')
+    a = fasten(box(a, 'cap', [50, 50, 50]), 'cap', 'drum', { align: { x: { mm: 70 }, z: { mm: 70 } } })
     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))
@@ -524,13 +539,13 @@ describe('past the edge of the face a part is fastened to', () => {
     await until(() => look.all('div[overhang] p', 'figure.text.overhang-possible').length === 1, [], 'said it may be')
   })
 
-  test('on a round face it is not known: said so, and "fix alignment" says why it cannot', async () => {
+  test('on a round face, measured on the disc itself: past its rim though within its square, and "fix alignment" brings it in (ADR-0140 3.9)', async () => {
     await pick('cap')
-    await until(() => look.all('div[overhang] p', 'figure.text.overhang-unknown').length === 1, [], 'said not known')
+    await until(() => look.all('div[overhang] p', 'figure.text.overhang-out').length === 1, [], 'said past the rim')
     const start = await state()
     await pressFixAlignment()
-    await until(() => look.all('p[fix-note]', 'figure.text.fix-alignment-unmeasured').length === 1, [], 'why it cannot')
-    assert.equal((await state()).revision, start.revision, 'nothing written')
+    await until(r => probe.state().revision === r + 1, [start.revision], 'one step')
+    await until(() => look.all('div[overhang] p', 'figure.text.overhang-out').length === 0, [], 'within the rim')
   })
 
   test('wider than the face: said in the relation with which side, not as a warning', async () => {
@@ -626,41 +641,32 @@ function twistedFollowingSize() {
   return applyFigureAuthoring(twisted(), { kind: 'follow-size', part: 'blade' })
 }
 
-describe('a part fastened twisted is not sized by a drag', () => {
-  test('the resize tool is off, and a size drag that still arrives is not written: a notice says why, in one line, with the way to its size', async () => {
+/*
+  ADR-0140 4.1 · 4.4: a part fastened at any angle is sized by a drag too -- its size alone is written, and its fastening
+  keeps it. Before, the drag was withheld and a notice sent the author to the size fields.
+*/
+describe('a part fastened twisted is sized by a drag: its size alone, its fastening keeps it', () => {
+  test('the resize tool is on, and a size drag writes its size in one step, the fastening as it was, with nothing said', async () => {
     await mount('twisted', twisted())
     await pick('blade')
-    assert.equal((await at('button[tool]', 'figure.button.gizmo-scale'))?.disabled, true, 'the resize tool is off')
+    assert.equal((await at('button[tool]', 'figure.button.gizmo-scale'))?.disabled, false, 'the resize tool is on')
     await read(() => probe.told())
     const start = await state()
-    await read(() => look.transformed('blade', { scale: [1.5, 1, 1] }))
-    await settled()
-    assert.equal((await state()).revision, start.revision, 'not written')
-    /* A notice, not the error's red (user 2026-10-19: the reason read as a fault, and was not understood). */
-    assert.deepEqual(await read(() => probe.told()), [{ level: 'info', message: 'figure.text.gizmo-size-turned-fastening', action: 'figure.button.to-size-fields' }])
-    assert.equal((await state()).error, '', 'no error')
-  })
-
-  test('the R key says why, and the notice\'s button puts the cursor in the part\'s size field', async () => {
-    await mount('twisted', twisted())
-    await pick('blade')
-    await read(() => probe.told())
-    await page().keyboard.press('KeyR')
-    await until(() => probe.told().some(n => n.message === 'figure.text.gizmo-size-turned-fastening' && n.action === 'figure.button.to-size-fields'), [], 'the reason said with its way on')
+    const joint = await read(() => probe.joint('blade'))
+    await read(() => look.transformed('blade', { scale: [1.5, 1, 1], grab: { x: 1, y: 0, z: 0 } }))
+    await until(r => probe.state().revision === r + 1, [start.revision], 'one step')
+    assert.equal(await read(() => probe.value('blade.size.x')), 450, 'its size')
+    assert.deepEqual(await read(() => probe.joint('blade')), joint, 'its fastening as it was')
+    assert.deepEqual(await read(() => probe.told()), [], 'nothing to say')
     assert.equal((await state()).error, '', 'no error')
-    /* From another tab: the button brings the properties tab and the size field. */
-    await tab('motion')
-    assert.equal(await read(() => probe.pressNoticeButton()), true)
-    await until(() => probe.focused()?.label?.startsWith('blade.size.'), [], 'the blade\'s size field focused')
-    assert.equal(await read(() => look.tab()), 'figure.label.tab-short-properties')
   })
 
   /*
-    :3300, 2026-10-19 (the fan's blade-2): a part whose size is not its own to type was told it was attached turned and
-    offered a way to size fields it could not type in. Its size is worked out, so it is said so, with no button.
+    :3300, 2026-10-19 (the fan's blade-2): a part whose size is not its own to type has the resize tool off; R says the
+    tool's own words, and puts no gizmo on it.
   */
   for (const [label, make] of [['another part', 'twistedFollowing'], ['the figure\'s size', 'twistedFollowingSize']])
-    test(`a part whose size follows ${label} is not told it is attached turned, nor sent to size fields it cannot type in`, async () => {
+    test(`a part whose size follows ${label} is not sent to size fields it cannot type in`, async () => {
       await mount(`twisted-${make}`, make === 'twistedFollowing' ? twistedFollowing() : twistedFollowingSize())
       await pick('blade')
       await read(() => probe.told())
@@ -668,12 +674,10 @@ describe('a part fastened twisted is not sized by a drag', () => {
       await sleep(400)
       const told = await read(() => probe.told())
       assert.deepEqual(told.filter(n => n.action), [], `no way to size fields: ${JSON.stringify(told)}`)
-      assert.ok(!told.some(n => n.message === 'figure.text.gizmo-size-turned-fastening'), 'not said to be attached turned')
       /* R does what the bar's resize tool does, off for this part: no gizmo it cannot use, and the tool's own words (:3300, 10.1.196). */
       assert.equal((await state()).attached, null, 'no gizmo on it')
       assert.deepEqual(told, [{ level: 'info', message: 'figure.text.gizmo-not-own', action: null }])
     })
-
 })
 
 describe('a box made to follow the figure size on the floor', () => {
@@ -684,14 +688,14 @@ describe('a box made to follow the figure size on the floor', () => {
     await pick('box')
   })
 
-  test('its height is the room\'s only, shown apart; its row shows the number the floor gives; a size drag keeps the bottom', async () => {
+  test('its height is the room\'s only, shown apart; its row shows the number the floor gives; a size drag is drawn by the modeller', async () => {
     const roomOnly = await all('input[aria-label="box.position.y"]')
     assert.equal(roomOnly.length, 1, 'one field for it, apart from the position row')
     assert.equal(roomOnly[0].disabled, true, 'not typed into')
     assert.equal((await all('section[room-only] input[aria-label="box.position.y"]')).length, 1, 'in the room\'s section')
     const held = (await all('div[vector-row] input[readonly]')).filter(i => i.label?.startsWith('position.y'))
     assert.deepEqual(held.map(i => i.value), ['50'], 'the height the floor gives, read-only')
-    assert.deepEqual(await read(() => look.scaleAnchor('box')), { x: 0, y: 1, z: 0 }, 'the bottom kept')
+    assert.equal(await read(() => look.scalePlacement('box')), 'owner', 'its place in a size drag is the modeller\'s (ADR-0140 4.4)')
   })
 
   test('the room is declared again only when the author confirms', async () => {
@@ -798,7 +802,7 @@ describe('the fastening window: tried freely, written once', () => {
     await until(w => JSON.stringify(JSON.parse(document.querySelector('figure-editor').session.source()).joints.find(j => j.body1.part === 'lamp')) === w, [JSON.stringify(was)], 'one undo: the fastening as it was')
   })
 
-  test('the canvas is turned with the window open: nothing written, still open, the window where it was', async () => {
+  test('moved by the popup\'s head out of the way of the canvas: nothing written, still open', async () => {
     await pick('lamp')
     await changeFastening()
     const rect = () => read(() => {
@@ -806,21 +810,21 @@ describe('the fastening window: tried freely, written once', () => {
       return r ? { x: Math.round(r.left), y: Math.round(r.top) } : null
     })
     const was = await rect()
-    /* A drag on the empty canvas, left of the parts: the camera turns, nothing is picked. */
-    const box = await read(() => {
-      const r = document.querySelector('figure-editor').shadowRoot.querySelector('figure-canvas').getBoundingClientRect()
-      return { x: r.left + 40, y: r.top + r.height / 2 }
+    const head = await read(() => {
+      const h = window.fastenDialog().closest('ox-floating-overlay').shadowRoot.querySelector('[header] h1').getBoundingClientRect()
+      return { x: h.left + h.width / 2, y: h.top + h.height / 2 }
     })
     const start = await state()
-    await page().mouse.move(box.x, box.y)
+    await page().mouse.move(head.x, head.y)
     await page().mouse.down()
-    for (let i = 1; i <= 6; i++) await page().mouse.move(box.x + 20 * i, box.y + 5 * i)
+    for (let i = 1; i <= 6; i++) await page().mouse.move(head.x - 30 * i, head.y + 20 * i)
     await page().mouse.up()
-    await settled()
+    const moved = await rect()
+    assert.deepEqual([moved.x - was.x, moved.y - was.y], [-180, 120], `moved with the pointer: ${JSON.stringify([was, moved])}`)
     assert.equal(await windowOpen(), true, 'still open')
-    assert.deepEqual(await rect(), was, 'the window where it was')
     assert.equal((await state()).revision, start.revision, 'nothing written')
-    await press('[cancel]')
+    /* Moved down, its foot may be past the page's: closed by Esc, as the window takes it. */
+    await page().keyboard.press('Escape')
     await until(() => !probe.fastenTargets(), [], 'the window closed')
   })
 
@@ -857,6 +861,57 @@ describe('a motion on the motion tab', () => {
   })
 })
 
+describe('pressed on the canvas while the fastening window is open (ADR-0140 stage 4)', () => {
+  before(async () => {
+    /* A drum standing at (0, 600, 0), radius 100; a tag on the floor, its fastening to change. */
+    let a = addFigurePrimitive(createFigureAsset('Pressed'), { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 400 }, position: { x: 0, y: 600, z: 0 } })
+    a = fasten(box(a, 'tag', [40, 40, 40], [600, 20, 600]), 'tag', 'plane')
+    await mount('pressed', a)
+  })
+
+  test("the drum's side pressed: the window aims at the point pressed, and the tag stays chosen", async () => {
+    await pick('tag')
+    await changeFastening()
+    /* The scene's click, as a press on the drum's side facing +Z, 50 mm above its middle, tells it (`pickedAt`). */
+    const said = await read(async () => {
+      const deep = (s, root = document) => [...root.querySelectorAll(s)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(s, e.shadowRoot)))
+      const canvas = deep('figure-canvas')[0]
+      const layer = canvas.scene.root
+      const drum = layer.components.find(c => c.state.name === 'drum')
+      drum.realObject.pickedAt = { point: [0, 650, 100], normal: [0, 0, 1] }
+      /* As the scene's click does: told on the component, it comes up to the board with the component as its origin. */
+      drum.trigger('click', new MouseEvent('click'))
+      await new Promise(done => setTimeout(done, 300))
+      const dialog = deep('figure-fasten-dialog')[0]
+      await dialog.updateComplete
+      return { target: dialog.form.target, surface: dialog.form.surface, selected: deep('figure-editor')[0].selected }
+    })
+    assert.deepEqual(said, { target: 'drum', surface: { around: 270, along: { mm: 50 } }, selected: 'tag' })
+  })
+
+  test('the window open, the drum pressed with the mouse on the canvas: aimed at, the window still open', async () => {
+    await press('[cancel]')
+    await until(() => !probe.fastenTargets(), [], 'the window closed')
+    await changeFastening()
+    /* Moved by its head off the drum, as a hand does, then the drum pressed where it is drawn. */
+    const head = await read(() => {
+      const h = window.fastenDialog().closest('ox-floating-overlay').shadowRoot.querySelector('[header] h1').getBoundingClientRect()
+      return { x: h.left + h.width / 2, y: h.top + h.height / 2 }
+    })
+    await page().mouse.move(head.x, head.y)
+    await page().mouse.down()
+    for (let i = 1; i <= 10; i++) await page().mouse.move(head.x + 35 * i, head.y)
+    await page().mouse.up()
+    await settled()
+    const drum = await read(() => probe.partOnPage('drum'))
+    assert.ok(await read(p => { const r = window.fastenDialog().getBoundingClientRect(); return p.x < r.left || p.x > r.right || p.y < r.top || p.y > r.bottom }, drum), 'the drum clear of the window')
+    await click(drum, 'the drum on the canvas')
+    await until(() => probe.fastenTargets()?.some(t => t.target === 'drum' && t.selected), [], 'the drum aimed at in the window')
+    assert.equal(await windowOpen(), true, 'still open: no backdrop took the press')
+    assert.equal((await state()).selected, 'tag', 'the tag still chosen')
+  })
+})
+
 test('the page raised no error', () => {
   assert.deepEqual(opened.errors, [])
 })

package/test/browser/modeller-page.js

@@ -62,6 +62,15 @@ function sourceOf(kind, text) {
     asset.palette = { ...asset.palette, ...PALETTE }
     return serializeFigureAsset(addFigureBox(asset, { id: 'room', size: { x: 4000, y: 3000, z: 6000 }, position: { x: 0, y: 1500, z: 0 } }))
   }
+  if (kind === 'shelf') {
+    /* A bed on the floor and a slat on its top: a part that can be made a row (the fold checks). */
+    let asset = createFigureAsset('Shelf')
+    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', to: { plane: 'mounting-plane' } })
+    asset = addFigureBox(asset, { id: 'slat', size: { x: 60, y: 20, z: 600 }, position: { x: 0, y: 410, z: 0 } })
+    return serializeFigureAsset(applyFigureAuthoring(asset, { kind: 'attach', part: 'slat', to: { part: 'bed', face: 'top' } }))
+  }
   if (kind === 'rollers') {
     /* A roller row whose rollers spin in place, each carrying a mark (ADR-0093, 2026-09-26). */
     let asset = createFigureAsset('Rollers')
@@ -71,7 +80,8 @@ function sourceOf(kind, text) {
     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', 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', to: { part: 'roller', face: 'right' } })
+    /* On the roller's side at 0° round its own Y -- its own +X (ADR-0140 3.9). */
+    asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'mark', to: { part: 'roller', surface: { around: 0, along: 'centre' } } })
     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 }))
@@ -232,23 +242,10 @@ window.probe = {
     const chip = deep('figure-fasten-dialog')[0]?.shadowRoot.querySelector('ox-input-select-buttons')?.shadowRoot?.querySelector(`md-filter-chip[data-value="${CSS.escape(part)}"]`)
     return chip ? centreOf(chip) : null
   },
-  /**
-   * The fastening window as it stands: its title, its role, whether a popup or its backdrop is anywhere on the page, and
-   * how much of the canvas it covers (a share of the canvas's width).
-   */
-  fastenPanel() {
-    const dialog = deep('figure-fasten-dialog')[0]
-    const panel = dialog?.closest('[fasten-panel]')
-    if (!panel) return null
-    const p = panel.getBoundingClientRect(),
-      c = canvas().getBoundingClientRect()
-    const across = Math.max(0, Math.min(p.right, c.right) - Math.max(p.left, c.left))
-    return {
-      title: panel.querySelector('h3')?.textContent.trim(),
-      role: dialog.getAttribute('role'),
-      popup: deep('ox-floating-overlay').length > 0,
-      overCanvas: Math.round((across / c.width) * 100) / 100
-    }
+  /** The fastening window's popup, as the standard overlay holds it: its title, whether its head moves it, its backdrop. */
+  fastenPopup() {
+    const overlay = deep('figure-fasten-dialog')[0]?.closest('ox-floating-overlay')
+    return overlay ? { title: overlay.title, movable: overlay.movable, backdrop: !!overlay.backdrop, role: overlay.querySelector('figure-fasten-dialog').getAttribute('role') } : null
   },
   /** What the notification surface was handed since the last call: its level, its words, its button's label. */
   told() {
@@ -380,6 +377,21 @@ window.probe = {
     const b = deep('button[mode]').find(b => b.title === `figure.text.mode-${mode}-explained`)
     return b ? centreOf(b) : null
   },
+  /**
+   * A size drag as the scene tells it (ADR-0140 4.4): a frame of it -- the part grown by `scale` along its own axes, the
+   * handle `grab` held -- or its release. The scene's own gizmo is not driven: what the canvas tells the editor is.
+   */
+  sizeFrame(id, scale, grab) {
+    canvas().dispatchEvent(new CustomEvent('part-sizing', { detail: { id, result: { scale, grab } }, bubbles: true, composed: true }))
+  },
+  sizeRelease(id, scale, grab) {
+    canvas().dispatchEvent(new CustomEvent('part-transformed', { detail: { id, result: { scale, grab } }, bubbles: true, composed: true }))
+  },
+  /** Where the canvas is told to draw a part now: its pose as given to the canvas. */
+  drawnPose(id) {
+    const part = canvas().parts.find(p => p.id === id)
+    return part ? { t: [...part.pose.t], r: part.pose.r.map(row => [...row]) } : null
+  },
   /** The drawn position of a part's component, as the canvas shows it now. */
   drawn(id) {
     const c = canvas().scene.root.components.find(c => c.state.name === id)

package/test/browser/modeller-revision.check.mjs

@@ -109,6 +109,45 @@ describe('work counted on the robot arm', () => {
   })
 })
 
+/*
+  ADR-0140 4.4: a size drag is drawn from figure-model frame by frame -- the figure compiled once when the drag begins, the
+  instance evaluator stepped each frame -- and the release writes what the last frame drew: no position differs, and the
+  release compiles no more than a release with no frames before it.
+*/
+describe('a size drag drawn frame by frame on the robot arm', () => {
+  const grab = { x: 0, y: 1, z: 0 }
+  const far = (a, b) => Math.max(...a.t.map((v, i) => Math.abs(v - b.t[i])), ...a.r.flat().map((v, i) => Math.abs(v - b.r.flat()[i])))
+
+  test('each frame compiles no figure, and moves what hangs from the part', async () => {
+    await mount('arm')
+    await click(await read(id => probe.partOnPage(id), 'upper-arm'))
+    await settled()
+    const still = await read(() => probe.drawnPose('forearm'))
+    await read(() => probe.sizeFrame('upper-arm', [1, 1.1, 1], { x: 0, y: 1, z: 0 }))
+    await drawn()
+    for (const s of [1.2, 1.3]) {
+      const { spent } = await counted(() => read(s => probe.sizeFrame('upper-arm', [1, s, 1], { x: 0, y: 1, z: 0 }), s))
+      assert.equal(spent.compiles, 0, `${s}: ${JSON.stringify(spent)}`)
+    }
+    assert.ok((await read(() => probe.drawnPose('forearm'))).t[1] > still.t[1] + 1, 'the forearm rides up with it')
+  })
+
+  test('the release writes what the last frame drew: no position differs', async () => {
+    const before = await read(() => probe.drawnPose('forearm'))
+    const revision = (await read(() => probe.state())).revision
+    const { spent } = await counted(() => read(g => probe.sizeRelease('upper-arm', [1, 1.3, 1], g), grab))
+    assert.equal((await read(() => probe.state())).revision, revision + 1, 'one step')
+    const written = await read(() => probe.body('forearm'))
+    assert.ok(far(before, written) < 1e-6, `the forearm where the last frame drew it: ${far(before, written)}`)
+    /* Released with no frames before it, on the same figure: the release costs the same or more. */
+    await mount('arm')
+    await click(await read(id => probe.partOnPage(id), 'upper-arm'))
+    await settled()
+    const bare = await counted(() => read(g => probe.sizeRelease('upper-arm', [1, 1.3, 1], g), grab))
+    assert.ok(spent.compiles <= bare.spent.compiles, `released after frames ${JSON.stringify(spent)}, without ${JSON.stringify(bare.spent)}`)
+  })
+})
+
 describe('the edit canvas and the preview stay standing', () => {
   before(() => mount('box'))