@things-factory/figure-ui 10.1.203 → 10.1.205

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. */
@@ -388,17 +388,15 @@ 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 () => {
@@ -424,15 +422,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 () => {
@@ -490,13 +488,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 +522,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 +624,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 +657,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 +671,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 +785,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 +793,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 +844,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'))
 

package/test/browser/modeller.check.mjs

@@ -388,6 +388,18 @@ describe('a figure made in the modeller is given its size from its parts (user 2
     await tab('response')
   })
 
+  /* In words a person reads (user 2026-10-20): what the figure does on a drawing, not the range behind it. */
+  const sizeGroup = () =>
+    page().evaluate(() => {
+      const deep = (root = document) => [...root.querySelectorAll('section[board-size]')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      const s = deep()[0]
+      return s ? { title: [...(s.querySelector('h3')?.childNodes ?? [])].filter(n => n.nodeType === 3).map(n => n.textContent).join('').trim(), fixed: s.querySelector('p[fixed-size]')?.textContent.trim() ?? null, followers: s.querySelector('p[followers]')?.textContent.trim() ?? null, dashes: s.querySelectorAll('div[pair][range] > span[dash]').length } : null
+    })
+
+  test('fixed: the size it is always drawn at, in one sentence, and the way to let a drawing resize it', async () => {
+    assert.deepEqual(await sizeGroup(), { title: 'figure.label.board-size', fixed: 'figure.text.board-size-fixed', followers: null, dashes: 0 })
+  })
+
   test('with nothing picked, the figure offers to declare its size; clicked, its size fields appear', async () => {
     const button = await page().evaluateHandle(() => {
       const deep = (root = document) => [...root.querySelectorAll('button')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
@@ -407,6 +419,10 @@ describe('a figure made in the modeller is given its size from its parts (user 2
     assert.deepEqual(await read(() => probe.fields('size.')), { 'size.x': 400, 'size.y': 400, 'size.z': 400 }, 'the size it is authored at: its parts now')
   })
 
+  test('resizable: each axis reads smallest – largest, and which parts change with it (none on a lone box)', async () => {
+    assert.deepEqual(await sizeGroup(), { title: 'figure.label.board-size', fixed: null, followers: 'figure.text.board-size-no-followers', dashes: 3 })
+  })
+
   test('the sizes it may be placed at are typed: the largest width, one step, and a smallest past its size refused', async () => {
     const field = id =>
       page().evaluateHandle(id => {
@@ -615,9 +631,15 @@ describe('the modeller made easier to find and to keep (2026-09-26 baseline)', (
     assert.equal(await resize.evaluate(b => b.getAttribute('aria-pressed')), 'false')
   })
 
-  test('a height typed into its field keeps the bottom on the floor, as the gizmo does', async () => {
+  test('a height typed into its field keeps the part\'s middle, and the size group says so (ADR-0140 4.1)', async () => {
     await mount('box')
     await click(await read(() => probe.partOnPage('box')))
+    const was = await body('box')
+    const middleOf = b => b.t[1] + b.dimensions.start + b.dimensions.length / 2
+    assert.ok(await read(() => {
+      const deep = (root = document) => [...root.querySelectorAll('p[size-keeps]')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      return deep().some(p => p.textContent.trim() === 'figure.text.size-keeps-centre')
+    }), 'said beside the size fields')
     const height = await find('input', 'box.size.y')
     assert.ok(await height.evaluate(i => !!i), 'the height field')
     const at = await centre(height)
@@ -626,8 +648,8 @@ describe('the modeller made easier to find and to keep (2026-09-26 baseline)', (
     await page().keyboard.press('Enter')
     await sleep(600)
     const now = await body('box')
-    /* The box is drawn up y from its start: its bottom is its centre plus the start. */
-    assert.equal(Math.round(now.t[1] + now.dimensions.start), 0, `bottom on the floor: centre ${now.t[1]}, starts at ${now.dimensions.start}`)
+    /* The box is drawn along y from its start: its middle is its origin plus the start plus half the length. */
+    assert.equal(Math.round(middleOf(now)), Math.round(middleOf(was)), `its middle where it was: ${middleOf(was)} -> ${middleOf(now)}`)
     assert.equal(now.dimensions.length, 1000)
   })
 
@@ -895,14 +917,14 @@ describe('a row that carries a part (ADR-0093, 2026-09-26)', () => {
 
 describe('the row section opens on one click', () => {
   test('a part that can be made a row: one click on the folded heading opens it, a second folds it', async () => {
-    await mount('rollers')
-    await click(await read(() => probe.row('mark')))
+    await mount('shelf')
+    await click(await read(() => probe.row('slat')))
     await tab('response')
     const summary = await page().evaluateHandle(() => {
       const deep = (root = document) => [...root.querySelectorAll('details[row-fold] > summary')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
       return deep()[0] ?? null
     })
-    assert.ok(await summary.evaluate(s => !!s && !!s.parentElement.querySelector('button[act]')), 'the mark is offered a row to make')
+    assert.ok(await summary.evaluate(s => !!s && !!s.parentElement.querySelector('button[act]')), 'the slat is offered a row to make')
     const at = await summary.evaluate(s => {
       s.scrollIntoView({ block: 'center' })
       const r = s.getBoundingClientRect()
@@ -915,9 +937,9 @@ describe('the row section opens on one click', () => {
   })
 
   test('a part picked again: a fold opened at once stays open -- the folds kept for the part are put back first', async () => {
-    await mount('rollers')
-    await click(await read(() => probe.row('mark')))
-    await click(await read(() => probe.row('roller')))
+    await mount('shelf')
+    await click(await read(() => probe.row('slat')))
+    await click(await read(() => probe.row('bed')))
     const open = await read(async () => {
       const deep = (selector, root = document) => [...root.querySelectorAll(selector)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(selector, e.shadowRoot)))
       const editor = deep('figure-editor')[0]
@@ -925,7 +947,7 @@ describe('the row section opens on one click', () => {
         The panel is drawn for the part once the editor and its links have updated; a click can come any time after
         that, before a frame is drawn. Here it comes right then.
       */
-      editor.selected = 'mark'
+      editor.selected = 'slat'
       await editor.updateComplete
       await Promise.all(deep('figure-links').map(links => links.updateComplete))
       await null

package/test/browser/screen-page.js

@@ -8,7 +8,6 @@ import './modeller-page.js'
 import { captureFigureThumbnail } from 'figure-ui-client/modeller/thumbnail.js'
 import { drawableFigureParts } from 'figure-ui-client/modeller/renderer.js'
 import { previewTypeOf } from '@things-factory/figure-viewer/dist-client/preview-model.js'
-import { figureReportOf } from 'figure-ui-client/modeller/maturity.js'
 import { hasFigure } from '@hatiolab/things-scene'
 import {
   addFigureBox,
@@ -118,7 +117,6 @@ window.screenCheck = {
   registered: type => hasFigure(type),
   previewTypeOf,
   /** The report the verdict tab measures, for the figure the editor holds. */
-  capacityNow: () => figureReportOf(window.screenCheck.editor().session.revisionNow().asset)?.capacity.instances,
   /** The card's picture of a figure (saved text), as a save takes it. */
   async picture(text) {
     const asset = JSON.parse(text)

package/test/browser/screen.check.mjs

@@ -223,9 +223,9 @@ describe('the frame: parts · canvas · one side of seven tabs, and the bar over
     await pressTab(TAB('properties'))
   })
 
-  test('the verdict tab carries the count the page measured', async () => {
-    await read(() => (screenCheck.editor().instances = 42))
-    await until('the count on the tab', () => screenCheck.editor().shadowRoot.querySelector(`button[tab][aria-label="figure.label.tab-short-verdict"] span[badge]`)?.textContent.trim() === '42')
+  /* The count once drawn on the verdict tab covered its icon and was not something to act on (2026-10-20): none. */
+  test('the verdict tab carries no count over its icon', async () => {
+    assert.equal(await read(() => screenCheck.editor().shadowRoot.querySelectorAll('button[tab] span[badge]').length), 0)
   })
 
   test('nothing chosen: the properties panel opens on the figure\'s own settings, with no part head', async () => {
@@ -240,8 +240,11 @@ describe('the frame: parts · canvas · one side of seven tabs, and the bar over
     assert.equal(await read(() => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar').pane === screenCheck.editor().shadowRoot.querySelector('ox-three-pane')), true, 'the bar folds the editor\'s own frame')
     const titles = await read(() => ['undo', 'redo'].map(a => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar').shadowRoot.querySelector(`button[data-action=${a}]`).title))
     assert.ok(titles[0].endsWith('(Ctrl+Z)') && titles[1].endsWith('(Ctrl+Y)'), `the keys in the titles: ${titles}`)
-    const status = () => read(() => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar [role=status]')?.textContent.trim())
-    assert.equal(await status(), 'figure.text.saved')
+    /* Saved or not is the save button's: pressable with something to save, dimmed without -- no words beside it. */
+    const status = () => read(() => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar [role=status]')?.textContent.trim() ?? null)
+    const saveOn = () => read(() => !screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[save]').disabled)
+    assert.equal(await status(), null, 'nothing said while nothing is under way')
+    assert.equal(await saveOn(), false, 'saved: the save button is dimmed')
 
     await pressRow('box')
     const height = await element('the height field', () => screenCheck.deep('input').find(i => i.getAttribute('aria-label') === 'box.size.y'))
@@ -249,14 +252,15 @@ describe('the frame: parts · canvas · one side of seven tabs, and the bar over
     await page().keyboard.type('600')
     await page().keyboard.press('Enter')
     await until('the height is 600', () => probe.value('box.size.y') === 600)
-    await until('said unsaved', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar [role=status]')?.textContent.trim() === 'figure.text.unsaved-changes')
+    await until('something to save', () => !screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[save]').disabled)
+    assert.equal(await status(), null, 'and still no words beside it')
 
     await pressBar('undo')
     await until('undone', () => probe.value('box.size.y') === 400)
     await pressBar('redo')
     await until('redone', () => probe.value('box.size.y') === 600)
     await press('save', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[save]'))
-    await until('said saved', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar [role=status]')?.textContent.trim() === 'figure.text.saved')
+    await until('saved: dimmed again', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[save]').disabled)
 
     const width = () => read(() => Math.round(screenCheck.deep('figure-canvas')[0].getBoundingClientRect().width))
     const was = await width()
@@ -1077,12 +1081,6 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     await press('the release button', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[publish]'))
   })
 
-  test('the verdict tab\'s count is the report\'s, measured by the verdict', async () => {
-    const expected = await read(() => screenCheck.capacityNow())
-    assert.ok(expected > 0)
-    await until('the count on the tab', expected => screenCheck.editor().shadowRoot.querySelector('button[tab][aria-label="figure.label.tab-short-verdict"] span[badge]')?.textContent.trim() === expected.toLocaleString(), expected)
-  })
-
   test('a new type asks the verdict again', async () => {
     await pressTab(TAB('properties'))
     await pressRow('left')

package/test/browser/section.check.mjs

@@ -291,11 +291,11 @@ describe('the section editor on a box: what follows, what is kept, and a figure
     await openEditor()
   })
 
-  test('the length says the face its placement keeps', async () => {
+  test('the length says what a length typed keeps: the part\'s middle (ADR-0140 4.1)', async () => {
     const now = await editorNow()
     assert.equal(now.length.label, 'figure.label.section-editor-length')
     assert.equal(now.length.disabled, false)
-    assert.equal(now.length.note, 'figure.text.section-editor-keeps')
+    assert.equal(now.length.note, 'figure.text.size-keeps-centre')
   })
 
   test('the figure changed while the editor is open: apply is refused, and closing does not offer it', async () => {