@things-factory/figure-ui 10.1.147 → 10.1.149

package/test/browser/links.check.mjs

@@ -0,0 +1,568 @@
+/*
+ * The part's ties in a real browser -- its size rules, its fastening, its row, its motion, what detaching and a size
+ * drag would do -- driven as a person does: a row in the parts list clicked, a tab, a select chosen, a number typed.
+ * Then what is on the page and what the session holds are read. The page loads no translations, so the words read are
+ * i18n keys. Where no control on the page sends a command (a loop the target list does not offer, a refused preview, a
+ * size drag that still arrives) the event a panel or the canvas sends the editor is sent as they send it.
+ *
+ * Run:  node --test test/browser/links.check.mjs
+ */
+import { test, describe, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  addFigureBox,
+  addFigurePrimitive,
+  applyFigureAuthoring,
+  applyFigureProposal,
+  createFigureAsset,
+  planFigureResize,
+  proposeFigureOccupancy,
+  serializeFigureAsset
+} from '@hatiolab/figure-model'
+
+import { buildPage } from './build.mjs'
+import { openPage } from './serve.mjs'
+
+const sleep = ms => new Promise(done => setTimeout(done, ms))
+
+let opened
+before(async () => {
+  opened = await openPage(await buildPage('links-page.js'))
+})
+after(async () => {
+  await opened?.close()
+})
+
+const page = () => opened.page
+const read = (fn, ...args) => page().evaluate(fn, ...args)
+const state = () => read(() => probe.state())
+const source = () => read(() => probe.source())
+const at = (selector, text) => read((s, t) => look.at(s, t), selector, text)
+const all = (selector, text) => read((s, t) => look.all(s, t), selector, text)
+const drawn = () => read(() => look.drawn())
+const heard = (type, section) => read((t, s) => look.heard(t, s), type, section)
+
+/** Polls the page until `fn` gives something truthy, and gives it; or fails saying what was waited for. */
+async function until(fn, args, what, ms = 8000) {
+  const deadline = Date.now() + ms
+  for (;;) {
+    const got = await read(fn, ...args)
+    if (got) return got
+    if (Date.now() > deadline) assert.fail(`waited for ${what}`)
+    await sleep(50)
+  }
+}
+/** Exactly one step written since `start`: waited for, since the panel's command reaches the session after the click. */
+async function oneStep(start) {
+  await until(from => probe.state().revision > from, [start.revision], 'the step written')
+  await settled()
+  await sleep(150)
+  assert.equal((await state()).revision, start.revision + 1, 'one step')
+}
+/** The editor has handled what it was told and drawn it. */
+const settled = () => read(() => document.querySelector('figure-editor').updateComplete)
+
+async function mount(kind, asset) {
+  await read((kind, text) => harness.mount(kind, text), kind, asset ? serializeFigureAsset(asset) : null)
+  /* Drawn in 3D before anything else: a board taken down while its 3D is still coming up throws in things-scene. */
+  await until(
+    () => {
+      /* Not drawn yet is not an error: until the canvas stands, reading it throws. */
+      try {
+        return probe.ids().some(id => !!probe.partOnPage(id))
+      } catch {
+        return false
+      }
+    },
+    [],
+    'the figure drawn in 3D',
+    15000
+  )
+}
+async function click(point, what = 'something') {
+  assert.ok(point, `${what} is on the page to click`)
+  await page().mouse.click(point.x, point.y)
+  await settled()
+}
+async function pick(part) {
+  await click(await read(id => probe.row(id), part), `the row of ${part}`)
+  await until(id => probe.state().selected === id, [part], `${part} selected`)
+}
+const tab = name => read(l => probe.tab(l), `figure.label.tab-short-${name}`).then(point => click(point, `the ${name} tab`))
+/** An element handle found through every shadow root. */
+const handle = (selector, test) =>
+  page().evaluateHandle(
+    (selector, test) => {
+      const deep = (root = document) => [...root.querySelectorAll(selector)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      const label = e => e.previousElementSibling?.textContent.replace(/\s+/g, ' ').trim()
+      return deep().find(e => !test || label(e) === test) ?? null
+    },
+    selector,
+    test
+  )
+/** Chooses an option of the select labelled `label`, as a person does: the select changes, once. */
+async function choose(label, value, selector = 'select') {
+  const select = await handle(selector, label)
+  assert.ok(await select.evaluate(s => !!s), `the select ${label}`)
+  await select.evaluate(s => s.scrollIntoView({ block: 'center' }))
+  await select.select(value)
+  await settled()
+}
+/** Types into the field: selected whole, the text, Tab. */
+async function type(field, text) {
+  assert.ok(await field.evaluate(i => !!i), 'the field is on the page')
+  await field.evaluate(i => i.scrollIntoView({ block: 'center' }))
+  await field.click({ clickCount: 3 })
+  await page().keyboard.type(text)
+  await page().keyboard.press('Tab')
+  await settled()
+}
+
+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 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', () => {
+  before(async () => {
+    /* a's width follows b's; b stands fastened on a. */
+    let a = box(box(createFigureAsset('Linked'), 'a', [200, 100, 200], [0, 50, 0]), 'b', [300, 100, 200], [0, 150, 0])
+    a = applyFigureAuthoring(a, { kind: 'link-dimension', part: 'a', axis: 'x', source: { of: 'part', part: 'b', axis: 'x' } })
+    await mount('linked', fasten(a, 'b', 'a'))
+  })
+
+  test('b made to follow a\'s width: refused, said as a loop, nothing written', async () => {
+    await pick('b')
+    await click(await at('details[resize-choice] > summary'), 'the advanced size choice')
+    const start = await state()
+    await choose('X', 'part:a:x', 'details[resize-choice] select')
+    await until(() => probe.state().error === 'figure.text.follow-would-loop', [], 'the loop said')
+    assert.equal((await state()).revision, start.revision, 'nothing written')
+  })
+
+  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 until(() => probe.state().error === 'figure.text.fasten-would-loop', [], 'the loop said')
+    assert.equal((await state()).revision, start.revision, 'nothing written')
+  })
+})
+
+describe('a part made to follow the figure size, and let go of it', () => {
+  before(async () => {
+    let a = box(createFigureAsset('Sized'), 'box', [400, 400, 400], [0, 200, 0])
+    a = applyFigureAuthoring(a, { kind: 'declare-instance-size', range: SIZE, at: { x: 400, y: 400, z: 400 } })
+    await mount('sized', applyFigureAuthoring(a, { kind: 'link-dimension', part: 'box', axis: 'x', source: { of: 'instance', axis: 'x' } }))
+    await pick('box')
+  })
+
+  test('on a figure with a size, follow-size is one step, says nothing of a size declared, and is not offered again', async () => {
+    await read(() => look.hear('notify'))
+    const start = await state()
+    await click(await at('button[follow-size]'), 'follow-size')
+    await oneStep(start)
+    await until(() => !look.at('button[follow-size]'), [], 'the button gone once every side follows')
+    assert.equal((await all('p[hint]', 'figure.text.resize-all-following')).length, 1, 'said that every side follows')
+    const told = (await heard('notify')).filter(n => n?.level === 'info' && String(n.message).includes('figure.text.size-declared-to-follow'))
+    assert.deepEqual(told, [], 'the figure had its size: no line says it was declared')
+  })
+
+  test('a side let go is one step and keeps the size it had', async () => {
+    const start = await state()
+    await click(await at('button[resize-unfollow="x"]'), 'let go of X')
+    await oneStep(start)
+    assert.equal(await read(() => probe.value('box.size.x')), 400, 'its own width is the 400 it was')
+    assert.equal(Math.round((await read(() => probe.body('box'))).dimensions['size.x']), 400)
+    assert.ok(await at('button[follow-size]'), 'follow-size is offered again')
+  })
+})
+
+/* A base and a flange, sized; the height may be placed from 90 mm though the parts measure down to 1. */
+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 } })
+  for (const axis of ['x', 'y', 'z']) {
+    a.document.model.inputs.push({ id: `size.${axis}`, unit: 'mm', min: axis === 'y' ? 90 : 1, max: axis === 'y' ? 1000 : 20000, role: 'design' })
+    a.designInputs[`size.${axis}`] = axis === 'y' ? 100 : 200
+  }
+  if (!turning) return a
+  a = fasten(fasten(a, 'base', 'plane'), 'flange', 'base')
+  const j = a.joints.find(o => o.body1.part === 'flange')
+  return applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', lowerLimit: 0, upperLimit: 90, state: { id: 'flange-turn' } } })
+}
+
+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 () => {
+    await mount('sized-pair', sizedPair(false))
+    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')
+  })
+
+  test('a figure with no joint is not urged to grow by one ratio; declared, the rule is said', async () => {
+    assert.deepEqual(await all('p[hint]', 'figure.text.sizing-uniform-proposed'), [], 'not urged')
+    assert.deepEqual(await all('div[inline-field] span', 'figure.label.sizing-uniform'), [], 'no rule yet')
+    await click(await at('button', 'figure.button.scale-uniformly'), 'scale uniformly')
+    assert.equal((await all('div[inline-field] span', 'figure.label.sizing-uniform')).length, 1, 'the rule said')
+  })
+
+  test('a figure that turns about a joint is urged to grow by one ratio', async () => {
+    await mount('turning', sizedPair(true))
+    assert.equal((await all('p[hint]', 'figure.text.sizing-uniform-proposed')).length, 1)
+  })
+})
+
+/* 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')
+  a = fasten(box(a, 'roller', [60, 60, 560], [0, 130, 0]), 'roller', 'frame')
+  return applyFigureAuthoring(a, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 })
+}
+
+describe('a row\'s pitch', () => {
+  test('a pitch that follows the frame\'s length shows as the number it comes to, and the row is said as drawn', async () => {
+    await mount('pitch-follows', applyFigureAuthoring(conveyor(), { kind: 'set-repeat', part: 'roller', pitch: { from: { of: 'part', part: 'frame', axis: 'x' }, times: 0.1 } }))
+    await pick('roller')
+    assert.deepEqual((await all('input[aria-label="roller.repeat.pitch"]')).map(i => i.value), ['200'], 'a tenth of 2000')
+    assert.ok((await all('ul[row-reading] li')).length > 0, 'the row said as it stands')
+  })
+
+  test('a pitch the board may set, typed into its field, is one edit of the input it reads', async () => {
+    const published = applyFigureProposal(conveyor(), [
+      { kind: 'add-design-input', id: 'pitch', unit: 'mm', min: 100, max: 400, value: 200 },
+      { kind: 'set-repeat', part: 'roller', pitch: { from: { of: 'input', input: 'pitch' } } },
+      { kind: 'publish-input', input: 'pitch', label: 'pitch' }
+    ])
+    await mount('published-pitch', published)
+    await pick('roller')
+    const start = await state()
+    await type(await handle('input[aria-label="roller.repeat.pitch"]'), '300')
+    await oneStep(start)
+    const now = await source()
+    assert.equal(now.designInputs.pitch, 300, 'the input is 300')
+    assert.deepEqual(now.joints.find(j => j.body1.part === 'roller').repeat.pitch, { from: { of: 'input', input: 'pitch' } }, 'the row still reads it')
+  })
+})
+
+describe('holding places on a part', () => {
+  test('a place needs kinds it takes; a figure that holds nothing says so, and declaring it holds things is one step', async () => {
+    await mount('box')
+    await pick('box')
+    await tab('capability')
+    assert.equal((await at('button[act]', 'figure.button.add-place'))?.disabled, true, 'no kinds: no place')
+    await type(await handle('input[placeholder="BOX, TOTE"]'), 'BOX')
+    assert.equal((await at('button[act]', 'figure.button.add-place'))?.disabled, false, 'a kind: a place may be made')
+    assert.equal((await all('p[hint]', 'figure.text.place-needs-holding')).length, 1, 'said: nothing is passed without holding')
+    const start = await state()
+    await click(await at('button[act]', 'figure.button.declare-holding'), 'declare holding')
+    await oneStep(start)
+    assert.ok((await source()).document.capabilities.names.includes('Capacity'))
+    assert.deepEqual(await all('p[hint]', 'figure.text.place-needs-holding'), [], 'not said again')
+  })
+})
+
+describe('a position worked out from the figure size', () => {
+  test('offered to keep its share of the size; taken, one step, said so and not offered again', async () => {
+    let a = box(createFigureAsset('Lifted'), 'plate', [600, 100, 400], [0, 50, 0])
+    a = applyFigureAuthoring(a, { kind: 'declare-instance-size', range: { x: { min: 100, max: 6000 }, y: { min: 50, max: 1000 }, z: { min: 100, max: 4000 } }, at: { x: 600, y: 100, z: 400 } })
+    a = box(a, 'lamp', [40, 20, 40], [0, 10, 0])
+    /* The lamp stands the figure's height above its own number. */
+    a.document.model.nodes.push({ id: 'lamp.lift', op: 'add@1', args: ['size.y', 'lamp.position.y'], outputs: { value: 'lamp.lift.value' } })
+    a.document.model.nodes.find(n => n.id === 'lamp.pose').args[1] = 'lamp.lift.value'
+    await mount('lifted', a)
+    await pick('lamp')
+    assert.equal((await all('div[pair] span', 'figure.label.position-worked-out')).length, 1)
+    const start = await state()
+    await click(await at('button[act]', 'figure.button.scale-position'), 'scale position')
+    await oneStep(start)
+    assert.equal((await all('div[pair] span', 'figure.label.position-in-proportion')).length, 1, 'said in proportion')
+    assert.equal(await at('button[act]', 'figure.button.scale-position'), null, 'not offered again')
+  })
+})
+
+describe('the fastening form on the robot arm', () => {
+  test('the upper arm opens on what it is fastened to; a part hanging from it is listed, not choosable, with the reason', async () => {
+    await mount('arm')
+    await pick('upper-arm')
+    const own = (await source()).joints.find(j => j.body1.part === 'upper-arm').body0.part
+    const target = await read(() => look.select('figure.label.target-part'))
+    assert.equal(target.value, own, 'its own fastening')
+    const forearm = target.options.find(o => o.value === 'forearm')
+    assert.deepEqual(forearm, { value: 'forearm', text: 'figure.text.target-would-loop', disabled: true })
+  })
+})
+
+describe('a new fastening for a door leaf: seen before it is done', () => {
+  before(async () => {
+    await mount('door')
+    await read(() => look.hear('preview-command'))
+  })
+  const ghosts = () => read(() => look.drawn().filter(n => n.startsWith('__preview')))
+
+  test('started, it asks what to fasten to, with nothing chosen', async () => {
+    await pick('leaf')
+    await click(await at('button[act]', 'figure.button.fasten-start'), 'fasten-start')
+    /* The form is the panel's, drawn after the editor's update. */
+    const target = await until(() => look.select('figure.label.target-part'), [], 'the fastening form')
+    assert.deepEqual([target.value, target.options[0].text], ['', 'figure.label.target-part-placeholder'])
+  })
+
+  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 () => {
+    await choose('figure.label.target-part', 'frame')
+    await until(() => look.drawn().includes('__preview:leaf') && look.drawn().includes('__target-face'), [], 'the leaf and the face drawn')
+    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')
+  })
+
+  test('the details fold; a gap set in them is said on the fold, nothing at the default', async () => {
+    const details = await all('details[fasten-detail]')
+    assert.deepEqual(details.map(d => d.open), [false], 'folded')
+    assert.deepEqual(await all('span[fasten-summary]'), [], 'nothing said at the default')
+    await click(await at('details[fasten-detail] > summary'), 'the details')
+    await type(await handle('details[fasten-detail] input', 'figure.label.gap'), '40')
+    assert.deepEqual((await all('span[fasten-summary]')).map(s => s.text), ['figure.text.fasten-summary-gap'])
+  })
+
+  test('on another tab it is not drawn; back on the properties it is', async () => {
+    await tab('motion')
+    await until(() => !look.drawn().some(n => n.startsWith('__preview')), [], 'nothing drawn on the motion tab')
+    await tab('properties')
+    await until(() => look.drawn().includes('__preview:leaf'), [], 'drawn again')
+  })
+
+  test('a refused command clears what was drawn and says why', async () => {
+    await read(() => look.tell('shape', 'preview-command', { action: { kind: 'attach', part: 'leaf', face: 'bottom', 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')
+  })
+
+  test('the part let go of, the panel leaving tells the editor to clear it', async () => {
+    await read(() => look.hear('preview-command', 'shape'))
+    await click(await read(id => probe.row(id), 'leaf'), 'the leaf row')
+    await page().keyboard.press('Escape')
+    await until(() => probe.state().selected === '', [], 'nothing selected')
+    assert.deepEqual(await heard('preview-command', 'shape'), [null], 'told once: nothing to show')
+  })
+
+  test('"fasten it first" from the motion tab opens this part\'s fastening, as it is now, in view, on the properties tab', async () => {
+    await pick('leaf')
+    await click(await at('button[act]', 'figure.button.fasten-start'), 'fasten-start')
+    await choose('figure.label.target-part', 'frame')
+    /* The panel scrolled back to its head, the fastening below the fold. */
+    const panel = await at('section[fastening]')
+    await page().mouse.move(panel.x, panel.y)
+    await page().mouse.wheel({ deltaY: -5000 })
+    await until(() => !look.inView('section[fastening]'), [], 'the fastening section scrolled out of view')
+    await tab('motion')
+    await click(await at('button[go-fasten]'), 'go-fasten')
+    await until(() => look.all('section[fastening]').some(s => s.spotlit), [], 'the fastening section marked')
+    assert.equal(await read(() => look.tab()), 'figure.label.tab-short-properties', 'on the properties tab, not another')
+    assert.equal((await read(() => look.select('figure.label.target-part'))).value, '', 'the form is the fastening it has: none')
+    await until(() => look.inView('section[fastening]'), [], 'the section in view')
+  })
+
+  test('the frame\'s front chosen in the drawing, fastened: the leaf keeps its place across that face', async () => {
+    const was = (await read(() => probe.body('leaf'))).t.map(Math.round)
+    await choose('figure.label.target-part', 'frame')
+    /* The frame's faces are offered once the drawing has the frame: a press before that is not a choice. */
+    await until(() => look.face('front')?.pickable, [], 'the front face offered')
+    await click(await at('path[face="front"]'), 'the front face in the drawing')
+    await until(() => look.face('front').chosen, [], 'the front face drawn as the one chosen')
+    const start = await state()
+    await click(await at('button[act]', 'figure.button.fasten'), 'fasten')
+    assert.equal((await state()).error, '', 'not refused')
+    await oneStep(start)
+    assert.equal((await source()).joints.find(j => j.body1.part === 'leaf').body0.face, 'front')
+    const now = (await read(() => probe.body('leaf'))).t.map(Math.round)
+    assert.deepEqual([now[0], now[1]], [was[0], was[1]], `left-right and height kept: was ${was}, now ${now}`)
+  })
+})
+
+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. */
+    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 })
+    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('past it: said, and "fix alignment" puts the focus on the face in the drawing', async () => {
+    await pick('out')
+    await until(() => look.all('div[overhang] p', 'figure.text.overhang-out').length === 1, [], 'said past the edge')
+    await click(await at('div[overhang] button', 'figure.button.fix-alignment'), 'fix alignment')
+    await until(() => look.focusedIn('figure-fasten-drawing', 'div[where]'), [], 'the face in the drawing focused')
+  })
+
+  test('turned, 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')
+  })
+
+  test('on a round face it is not known: said so', async () => {
+    await pick('cap')
+    await until(() => look.all('div[overhang] p', 'figure.text.overhang-unknown').length === 1, [], 'said not known')
+  })
+
+  test('wider than the face: said in the relation with which side, not as a warning', async () => {
+    await pick('plate')
+    await until(() => look.all('p[overhang-note]').length === 1, [], 'the note')
+    const note = (await all('p[overhang-note]'))[0].text
+    assert.ok(note.includes('figure.text.overhang-larger') && note.includes('figure.text.overhang-lopsided'), note)
+    assert.deepEqual(await overhang(), [], 'no warning')
+  })
+})
+
+describe('a bench: what each part is fastened to, what detaching would do, a row seen before it is made', () => {
+  before(async () => {
+    let a = fasten(box(createFigureAsset('Bench'), 'leg', [60, 700, 60], [-400, 350, 0]), 'leg', 'plane')
+    a = fasten(box(a, 'top', [1200, 40, 600], [0, 900, 0]), 'top', 'leg')
+    a = fasten(box(a, 'lamp', [80, 80, 80], [200, 960, 100]), 'lamp', 'top')
+    await mount('bench', box(a, 'loose', [100, 100, 100], [800, 50, 0]))
+    await read(() => look.hear('preview-command'))
+  })
+
+  test('the list names what each part is fastened to, beside its name', async () => {
+    const said = await read(() => ['leg', 'top', 'lamp', 'loose'].map(id => look.fastenedTo(id)))
+    assert.deepEqual(said, ['figure.label.mounting-plane', 'leg · figure.label.face-top', 'top · figure.label.face-top', null])
+  })
+
+  test('a fastened part picked: the face it is fastened to is lit, and taking it off is said to keep what hangs from it', async () => {
+    await pick('top')
+    await until(() => look.drawn().includes('__target-face'), [], 'the leg\'s top lit')
+    await until(() => look.all('div[fastened] [detach-words]', 'figure.text.detach-keeps-children').length === 1, [], 'said beside the detach button')
+  })
+
+  test('a part that would stay where it stands: nothing is said beside the detach button', async () => {
+    await pick('lamp')
+    await until(() => look.all('section[fastening] button[act]', 'figure.button.detach').length === 1, [], 'the lamp\'s detach button')
+    /* What detaching would do is worked out once the figure rests (150 ms after the pick). */
+    await sleep(500)
+    assert.deepEqual(await all('[detach-words]'), [])
+  })
+
+  test('a part fastened to nothing: the row is folded under its head and says why', async () => {
+    await pick('loose')
+    assert.deepEqual((await all('details[row-fold] > summary h3')).map(h => h.text), ['figure.label.repeat'])
+    assert.deepEqual((await all('details[row-fold]')).map(d => d.open), [false], 'folded')
+    assert.deepEqual((await all('p[row-blocked]')).map(p => p.text), ['figure.text.row-blocked-unfastened'])
+  })
+
+  test('the row worked on is the one seen: its copies drawn and said; back on the fastening, it folds', async () => {
+    await pick('lamp')
+    assert.deepEqual((await all('details[row-fold]')).map(d => d.open), [false], 'folded')
+    await read(() => look.hear('preview-command'))
+    /*
+      Clicked until it is open: the first click puts the focus in the row, which opens the fold, and the summary's own
+      toggle then closes it again -- two clicks open it (seen 2026-10-11).
+    */
+    for (let i = 0; i < 2 && !(await all('details[row-fold]'))[0].open; i++) await click(await at('details[row-fold] > summary'), 'the row')
+    assert.deepEqual((await all('details[row-fold]')).map(d => d.open), [true], 'open while it is worked')
+    await until(() => look.all('section[row] input[type=number]').length > 0, [], 'the pitch field in the open row')
+    await type(await handle('section[row] input[type=number]'), '250')
+    await until(() => look.heard('preview-command').filter(Boolean).at(-1)?.action.pitch === 250, [], 'the row told')
+    assert.equal((await heard('preview-command')).filter(Boolean).at(-1).action.kind, 'make-repeat')
+    await until(() => look.drawn().filter(n => n.startsWith('__preview')).length > 1, [], 'the copies drawn')
+    await until(() => look.all('section[row] [preview-words]', 'figure.text.row-count-pitch').length === 1, [], 'the row said')
+    await click(await at('section[fastening] h3 button'), 'the fastening section')
+    await until(() => look.all('details[row-fold]').every(d => !d.open), [], 'the row folded again')
+  })
+})
+
+/* A blade fastened twisted on a hub: no face 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 })
+}
+
+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 and is 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')
+    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')
+    assert.equal((await state()).error, 'figure.text.gizmo-size-turned-fastening')
+  })
+
+  test('the R key says why', async () => {
+    await mount('twisted', twisted())
+    await pick('blade')
+    assert.equal((await state()).error, '')
+    await page().keyboard.press('KeyR')
+    await until(() => probe.state().error === 'figure.text.gizmo-size-turned-fastening', [], 'the reason said')
+  })
+})
+
+describe('a box made to follow the figure size on the floor', () => {
+  before(async () => {
+    let a = box(createFigureAsset('Floor'), 'box', [100, 100, 100], [20, 50, 30])
+    a = applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' })
+    await mount('floor', applyFigureProposal(a, planFigureResize(a, { part: 'box' }).steps))
+    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 () => {
+    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')
+  })
+
+  test('the room is declared again only when the author confirms', async () => {
+    const prompt = id =>
+      read(id => {
+        const deep = (root = document) => [...root.querySelectorAll('ox-prompt')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+        const button = deep().at(-1)?.shadowRoot?.querySelector(`#${id}`)
+        if (!button) return null
+        const r = button.getBoundingClientRect()
+        return r.width ? { x: r.left + r.width / 2, y: r.top + r.height / 2 } : null
+      }, id)
+    const start = await state()
+    await click(await at('button[room-refit]'), 'declare the room again')
+    await until(() => !!document.querySelector('ox-prompt'), [], 'asked')
+    await click(await poll(() => prompt('cancel')), 'cancel')
+    await until(() => !document.querySelector('ox-prompt'), [], 'the question gone')
+    assert.equal((await state()).revision, start.revision, 'cancelled: nothing written')
+    await click(await at('button[room-refit]'), 'declare the room again')
+    await click(await poll(() => prompt('confirm')), 'confirm')
+    await until(r => probe.state().revision === r + 1, [start.revision], 'confirmed: one step')
+  })
+})
+
+/** Asks until the answer is something, for a few seconds. */
+async function poll(ask, ms = 5000) {
+  const deadline = Date.now() + ms
+  for (;;) {
+    const answer = await ask()
+    if (answer || Date.now() > deadline) return answer
+    await sleep(50)
+  }
+}
+
+describe('a motion on the motion tab', () => {
+  test('named by its parts, and drawn at both ends of its range', async () => {
+    await mount('arm')
+    await pick('upper-arm')
+    await tab('motion')
+    await until(() => look.drawn().includes('__preview:min:upper-arm') && look.drawn().includes('__preview:max:upper-arm'), [], 'both ends drawn')
+    assert.equal((await all('p[motion-summary]', 'figure.text.motion-summary')).length, 1)
+  })
+})
+
+test('the page raised no error', () => {
+  assert.deepEqual(opened.errors, [])
+})

package/test/browser/modeller.check.mjs

@@ -881,6 +881,27 @@ 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')))
+    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')
+    const at = await summary.evaluate(s => {
+      s.scrollIntoView({ block: 'center' })
+      const r = s.getBoundingClientRect()
+      return { x: r.left + r.width / 2, y: r.top + r.height / 2 }
+    })
+    await click(at)
+    assert.equal(await summary.evaluate(s => s.parentElement.open), true, 'open after one click')
+    await click(at)
+    assert.equal(await summary.evaluate(s => s.parentElement.open), false, 'folded after a second')
+  })
+})
+
 test('the page raised no error', () => {
   assert.deepEqual(opened.errors, [])
 })