@things-factory/figure-ui 10.1.151 → 10.1.153

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.151",
+  "version": "10.1.153",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -18,7 +18,7 @@
   "scripts": {
     "build": "npm run build:server && npm run build:client",
     "test": "FIGURE_FREEZE_COMPILED=1 node --import ./test/resolve-ts-siblings.mjs --test test/*.test.ts",
-    "test:browser": "node --test test/browser/build.check.mjs test/browser/modeller.check.mjs test/browser/modeller-revision.check.mjs test/browser/editing.check.mjs test/browser/links.check.mjs test/browser/section.check.mjs test/browser/screen.check.mjs test/browser/product-page.check.mjs test/browser/parts.check.mjs test/browser/places-mesh.check.mjs test/browser/part-ids.check.mjs",
+    "test:browser": "node --test test/browser/build.check.mjs test/browser/modeller.check.mjs test/browser/modeller-revision.check.mjs test/browser/editing.check.mjs test/browser/links.check.mjs test/browser/section.check.mjs test/browser/screen.check.mjs test/browser/product-page.check.mjs test/browser/parts.check.mjs test/browser/places-mesh.check.mjs test/browser/part-ids.check.mjs test/browser/fix-alignment.check.mjs test/browser/mesh-select.check.mjs test/browser/row-preview.check.mjs",
     "copy:files": "copyfiles -e \"./client/**/*.{ts,js,json}\" -u 1 \"./client/**/*\" dist-client",
     "build:client": "npm run copy:files && npx tsc --p ./client/tsconfig.json",
     "build:server": "npx tsc --p ./server/tsconfig.json",
@@ -27,7 +27,7 @@
     "clean": "npm run clean:server && npm run clean:client"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.6.0",
+    "@hatiolab/figure-model": "^0.6.3",
     "@hatiolab/things-scene": "^10.1.83",
     "@material/web": "^2.0.0",
     "@operato/data-grist": "^10.0.0",
@@ -42,8 +42,8 @@
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.0.0",
     "@things-factory/ai-assistant": "^10.1.150",
-    "@things-factory/figure-service": "^10.1.151",
+    "@things-factory/figure-service": "^10.1.153",
     "three": "^0.185.1"
   },
-  "gitHead": "495d06ef9ecf4d19fc9bf45ebc3cff4fdfefca53"
+  "gitHead": "54b3e985a55d5d0b01622d87f385f07518fb5d16"
 }

package/test/browser/build.mjs

@@ -7,7 +7,7 @@
  * (its browser bundle, `things-scene.mjs`).
  */
 import { execFileSync } from 'node:child_process'
-import { mkdtempSync, rmSync, existsSync } from 'node:fs'
+import { mkdtempSync, realpathSync, rmSync, existsSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { dirname, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -41,7 +41,12 @@ for (const signal of ['SIGINT', 'SIGTERM'])
  * assistant dock needs the whole app's tool bar), a stand-in that records what the product asked of it.
  */
 export async function buildPage(page = 'modeller-page.js', { standIns = {} } = {}) {
-  const out = mkdtempSync(join(tmpdir(), 'figure-ui-browser-' + page.replace(/\W+/g, '-') + '-'))
+  /*
+    The real path: on macOS the temp dir is a link (/var -> /private/var). A module named both through
+    `figure-ui-client/...` and by a relative import was bundled twice, once under each path, and a page that imports one
+    both ways (product-page.js: the modeller page and the history panel) defined its element twice and never came up.
+  */
+  const out = mkdtempSync(join(realpathSync(tmpdir()), 'figure-ui-browser-' + page.replace(/\W+/g, '-') + '-'))
   made.push(out)
   const emitted = join(out, 'client')
 

package/test/browser/editing.check.mjs

@@ -218,6 +218,20 @@ describe('a part a joint places is not moved by the bar, nor put on the plane',
   })
 })
 
+describe('a part a joint places, dragged with the move handle all the same (the six-axis arm, a saved asset)', () => {
+  before(() => mount('six-axis'))
+
+  test('nothing written, and the refusal says the joint places it', async () => {
+    await pick('upper-arm')
+    const start = await revision()
+    await dragHandle('upper-arm', 'translate', 'X', 80)
+    await until(async () => (await state()).error !== '', 'the refusal said')
+    assert.equal(await revision(), start, 'nothing written')
+    /* Said from the kernel's details (ADR-0127): the page loads no translations, so the words are the key. */
+    assert.equal((await state()).error, 'figure.text.gizmo-joint-places')
+  })
+})
+
 describe('put on the plane by the figure\'s placement: once, not fastened (designer 2026-09-27)', () => {
   test('a box 500 mm above the floor is put on it by its bottom, in one step', async () => {
     await mount('box', 'raised')

package/test/browser/fix-alignment.check.mjs

@@ -0,0 +1,112 @@
+/*
+ * 정렬·간격 고치기, in a real browser: a part fastened past the edge of the face it stands on is moved inside by the
+ * button, as one step; when nothing of the part itself is out, the button says why instead of doing nothing (on :3300,
+ * 2026-10-11, it only scrolled to the drawing, which was already in view).
+ *
+ * Run:  node --test test/browser/fix-alignment.check.mjs
+ */
+import { test, describe, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, 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('places-mesh-page.js'))
+})
+after(async () => {
+  await opened?.close()
+})
+
+const page = () => opened.page
+const read = (fn, ...args) => page().evaluate(fn, ...args)
+const state = () => read(() => probe.state())
+
+async function until(fn, args, what, ms = 8000) {
+  const deadline = Date.now() + ms
+  for (;;) {
+    if (await read(fn, ...args)) return
+    if (Date.now() > deadline) assert.fail(`waited for ${what}`)
+    await sleep(50)
+  }
+}
+/* The editor and the part's panels have drawn what they were last told: a read never meets the draw before. */
+const settled = () =>
+  read(async () => {
+    const deep = (s, root = document) => [...root.querySelectorAll(s)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(s, e.shadowRoot)))
+    const drawing = () => [document.querySelector('figure-editor'), ...deep('figure-links')].filter(Boolean)
+    for (let round = 0; round < 20; round++) {
+      await Promise.all(drawing().map(e => e.updateComplete))
+      if (!drawing().some(e => e.isUpdatePending)) return
+    }
+  })
+/** Pressed once it is on the page and the panels have drawn -- waited for, not looked up once. */
+async function click(selector, options = {}, what = selector) {
+  await settled()
+  await until((s, o) => !!findDeep(s, o), [selector, options], `${what} on the page`)
+  const element = await page().evaluateHandle((s, o) => findDeep(s, o), selector, options)
+  await element.evaluate(e => e.scrollIntoView({ block: 'center' }))
+  await element.click()
+  await settled()
+}
+async function pick(part) {
+  const at = await read(id => probe.row(id), part)
+  assert.ok(at, `the row of ${part}`)
+  await page().mouse.click(at.x, at.y)
+  await until(id => probe.state().selected === id, [part], `${part} selected`)
+}
+const jointOf = part => read(p => probe.source().joints.find(j => j.body1.part === p), part)
+const words = () => read(() => [...(findDeep('div[overhang]')?.querySelectorAll('p') ?? [])].map(p => p.textContent.trim()))
+
+/* A 400 × 1000 deck; a 100 mm block on it, fastened 1000 mm off its centre along X -- past its low edge. */
+function figure(withChild = false) {
+  let a = addFigureBox(createFigureAsset('Deck'), { id: 'deck', size: { x: 400, y: 50, z: 1000 }, position: { x: 0, y: 25, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'deck', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = addFigureBox(a, { id: 'block', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 100, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'block', face: 'bottom', to: { part: 'deck', face: 'top' }, ...(withChild ? {} : { align: { x: { mm: -1000 } } }) })
+  if (!withChild) return a
+  /* The block inside; a cap on it, past the block's edge. */
+  a = addFigureBox(a, { id: 'cap', size: { x: 40, y: 40, z: 40 }, position: { x: 0, y: 170, z: 0 } })
+  return applyFigureAuthoring(a, { kind: 'attach', part: 'cap', face: 'bottom', to: { part: 'block', face: 'top' }, align: { x: { mm: 300 } } })
+}
+
+describe('정렬·간격 고치기 moves a part inside the face it is fastened on', () => {
+  before(async () => {
+    await read(text => harness.mount('given', text), serializeFigureAsset(figure()))
+    await until(() => look.drawn().length > 0, [], 'the board is drawn')
+    await pick('block')
+  })
+
+  test('out past the low edge: said, then moved to that edge as one step, and no longer said', async () => {
+    await until(() => !!findDeep('button[fix-alignment]'), [], 'the button')
+    assert.ok((await words()).length > 0, 'the overhang is said')
+    const start = await state()
+    await click('button[fix-alignment]')
+    await until(r => probe.state().revision === r + 1, [start.revision], 'one step')
+    assert.deepEqual((await jointOf('block')).origin.align?.x, 'min')
+    await until(() => !findDeep('div[overhang]'), [], 'nothing said of an overhang')
+    assert.equal((await state()).error, '')
+  })
+})
+
+describe('when nothing of the part is out, the button says why', () => {
+  before(async () => {
+    await read(text => harness.mount('given', text), serializeFigureAsset(figure(true)))
+    await until(() => look.drawn().length > 0, [], 'the board is drawn')
+    await pick('block')
+  })
+
+  test('what is out is the cap fastened on it: said under the button, nothing written', async () => {
+    await until(() => !!findDeep('button[fix-alignment]'), [], 'the button')
+    const start = await state()
+    await click('button[fix-alignment]')
+    await until(() => !!findDeep('p[fix-note]'), [], 'the note')
+    assert.match(await read(() => findDeep('p[fix-note]').textContent.trim()), /^figure\.text\.fix-alignment-inside/)
+    assert.equal((await state()).revision, start.revision)
+  })
+})

package/test/browser/links.check.mjs

@@ -101,6 +101,28 @@ const handle = (selector, test) =>
     selector,
     test
   )
+/**
+ * Pressed as the panels stand once drawn: no fastening panel with an update still to draw, then the element itself, not a
+ * point read before. A point read too early is pressed after the panel has moved under it (2026-10-11: the door leaf's
+ * "fasten" read, then its scroll put back a frame later, and the click fell on another button).
+ */
+async function press(selector, text, what = text ?? selector) {
+  await read(async () => {
+    const deep = (s, root = document) => [...root.querySelectorAll(s)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(s, e.shadowRoot)))
+    for (let round = 0; round < 20 && deep('figure-links').some(e => e.isUpdatePending); round++) await Promise.all(deep('figure-links').map(e => e.updateComplete))
+  })
+  const element = await page().evaluateHandle(
+    (selector, text) => {
+      const deep = (s, root = document) => [...root.querySelectorAll(s)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(s, e.shadowRoot)))
+      return deep(selector).find(e => text === undefined || e.textContent.replace(/\s+/g, ' ').trim().includes(text)) ?? null
+    },
+    selector,
+    text
+  )
+  assert.ok(await element.evaluate(e => !!e), `${what} is on the page`)
+  await element.click()
+  await settled()
+}
 /** 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)
@@ -113,7 +135,24 @@ async function choose(label, value, selector = 'select') {
 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' }))
+  /*
+    Pressed where it stands once the panel has stopped moving: what a fold opening or a preview's words bring is drawn
+    after the click that brought it, and a press aimed before that lands on whatever moved under it.
+  */
+  const where = () => field.evaluate(i => JSON.stringify(i.getBoundingClientRect()))
+  for (let last = await where(), i = 0; i < 40; i++) {
+    await sleep(100)
+    const now = await where()
+    if (now === last) break
+    last = now
+  }
   await field.click({ clickCount: 3 })
+  const focused = await field.evaluate(i => {
+    let at = document.activeElement
+    while (at?.shadowRoot?.activeElement) at = at.shadowRoot.activeElement
+    return at === i
+  })
+  assert.ok(focused, 'the press lands in the field')
   await page().keyboard.type(text)
   await page().keyboard.press('Tab')
   await settled()
@@ -305,7 +344,7 @@ describe('a new fastening for a door leaf: seen before it is done', () => {
 
   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')
+    await press('button[act]', 'figure.button.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'])
@@ -351,7 +390,7 @@ describe('a new fastening for a door leaf: seen before it is done', () => {
 
   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 press('button[act]', 'figure.button.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]')
@@ -369,8 +408,14 @@ describe('a new fastening for a door leaf: seen before it is done', () => {
   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')
+    /*
+      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 form has drawn what the choice brings -- the leaf where it would go, and the words above the drawing
+      that move it down -- 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 settled()
+    await sleep(200)
     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()
@@ -383,6 +428,14 @@ describe('a new fastening for a door leaf: seen before it is done', () => {
   })
 })
 
+/*
+ * 정렬·간격 고치기 pressed as the panel stands once it has drawn: a point read before it has, then clicked, can land where
+ * the button was, and nothing happens.
+ */
+async function pressFixAlignment() {
+  await press('div[overhang] button[fix-alignment]', undefined, 'fix alignment')
+}
+
 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')
@@ -395,11 +448,13 @@ describe('past the edge of the face a part is fastened to', () => {
   })
   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 () => {
+  test('past it: said, and "fix alignment" moves it inside the face as one step', async () => {
     await pick('out')
     await until(() => look.all('div[overhang] p', 'figure.text.overhang-out').length === 1, [], 'said past the edge')
-    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')
+    const start = await state()
+    await pressFixAlignment()
+    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, [], 'no longer past the edge')
   })
 
   test('turned, it may be past it: said so', async () => {
@@ -407,9 +462,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', async () => {
+  test('on a round face it is not known: said so, and "fix alignment" says why it cannot', async () => {
     await pick('cap')
     await until(() => look.all('div[overhang] p', 'figure.text.overhang-unknown').length === 1, [], 'said not known')
+    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')
   })
 
   test('wider than the face: said in the relation with which side, not as a warning', async () => {
@@ -460,11 +519,8 @@ describe('a bench: what each part is fastened to, what detaching would do, a row
     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')
+    /* One click opens it, and it stays open while the row is worked. */
+    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')

package/test/browser/mesh-select.check.mjs

@@ -0,0 +1,91 @@
+/*
+ * A GLB imported on the modeller page as the shell mounts it (product-page.js), with the mouse as a person uses it: the
+ * palette's file chooser, the question drawn as the layout draws popups, a choice clicked in it. The part made is the
+ * one selected (on :3300, 2026-10-11, the part selected before the import stayed selected; the editor alone said
+ * otherwise, so this follows the page's own path).
+ *
+ * Run:  node --test test/browser/mesh-select.check.mjs
+ */
+import { test, describe, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { writeFileSync, mkdtempSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { addFigureBox, createFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
+
+import { buildPage } from './build.mjs'
+import { openPage } from './serve.mjs'
+
+const STAND_INS = {
+  '@things-factory/ai-assistant/dist-client/index.js': 'assistant-stand-in.js',
+  '@things-factory/ai-assistant/dist-client/components/assistant-dock.js': 'assistant-stand-in.js'
+}
+
+let opened
+before(async () => {
+  opened = await openPage(await buildPage('product-page.js', { standIns: STAND_INS }))
+})
+after(async () => {
+  await opened?.close()
+})
+
+const page = () => opened.page
+const read = (fn, ...args) => page().evaluate(fn, ...args)
+async function until(fn, label, ...args) {
+  try {
+    return await (await page().waitForFunction(fn, { timeout: 15000, polling: 50 }, ...args)).jsonValue()
+  } catch (error) {
+    throw Error(`waited in vain: ${label} (${error.message})`)
+  }
+}
+const editor = () => read(() => ({ selected: product.deep('figure-editor')[0]?.selected, revision: product.view()?.revision }))
+/** The page point of the first element the selector finds, scrolled into view. */
+const pointOf = selector =>
+  read(s => {
+    const e = product.deep(s)[0]
+    if (!e) return null
+    e.scrollIntoView({ block: 'center' })
+    const r = e.getBoundingClientRect()
+    return { x: r.left + r.width / 2, y: r.top + r.height / 2 }
+  }, selector)
+async function clickAt(selector, label = selector) {
+  await until(s => !!product.deep(s)[0], label, selector)
+  const at = await pointOf(selector)
+  await page().mouse.click(at.x, at.y)
+}
+
+const HASH = 'c'.repeat(64)
+const bounds = (x0, y0, z0, x1, y1, z1) => ({ min: { x: x0, y: y0, z: z0 }, max: { x: x1, y: y1, z: z1 } })
+const node = (index, name, b, triangles) => ({ index, name, parent: index ? 0 : null, bounds: b, triangles, primitives: 1, position: { x: 0, y: 0, z: 0 }, rotation: { x: 0, y: 0, z: 0 } })
+const girder = bounds(-1000, -150, -200, 1000, 150, 200)
+const UPLOAD = { hash: HASH, summary: { bounds: girder, triangles: 24, primitives: 2, unit: 'm', nodes: [node(0, 'Girder', girder, 24), node(1, 'Hoist', bounds(-150, -200, -150, 150, 200, 150), 12)] } }
+
+/* A wide slab filling the middle of the view, selected: what lies under the question when it is answered. */
+const slab = () => serializeFigureAsset(addFigureBox(createFigureAsset('Slab'), { id: 'slab', size: { x: 4000, y: 100, z: 4000 }, position: { x: 0, y: 50, z: 0 } }))
+
+describe('a GLB imported on the modeller page: the part made is the one selected', () => {
+  before(async () => {
+    await page().waitForFunction(() => !!window.product, { timeout: 30000 })
+    await read(s => product.seed({ id: 'f', type: 'slab', source: s }), slab())
+    await read(u => product.answer('uploadFigureMesh', () => u), UPLOAD)
+    await read(() => product.open('f'))
+    await until(() => { const v = product.view(); return v && v.context && !product.page().session.read().loading }, 'the figure open')
+    await clickAt('figure-parts >>> span[label][title="slab"]', 'the slab\'s row')
+    await until(() => product.deep('figure-editor')[0]?.selected === 'slab', 'the slab selected')
+  })
+
+  test('the whole file chosen in the question: added as one step, and selected', async () => {
+    const file = join(mkdtempSync(join(tmpdir(), 'figure-glb-')), 'crane.glb')
+    writeFileSync(file, Buffer.from('glTF'))
+    const start = await editor()
+    const [chooser] = await Promise.all([page().waitForFileChooser({ timeout: 4000 }), clickAt('figure-parts >>> button[shape][title="figure.text.import-mesh-hint"]', 'the import button')])
+    await chooser.accept([file])
+    await until(() => !!product.deep('figure-mesh-choice')[0], 'the question')
+    await clickAt('figure-mesh-choice >>> li button', 'the whole file')
+    await until(r => product.view().revision === r + 1, 'one step', start.revision)
+    /* Read a second later too: anything that takes the selection back after the step would have done so by then. */
+    await new Promise(done => setTimeout(done, 1000))
+    assert.equal((await editor()).selected, 'crane', 'the part made is the one selected')
+  })
+})

package/test/browser/modeller-page.js

@@ -8,6 +8,30 @@ import { budgetOf, figureReportOf } from 'figure-ui-client/modeller/maturity.js'
 import { createFigureProductSession } from 'figure-ui-client/modeller/product-session.js'
 import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, createFigureAsset, figureWork, robotArmFigure, serializeFigureAsset } from '@hatiolab/figure-model'
 
+/*
+  The work the modeller puts off until the screen rests (a timer of 100 ms or more: 150 ms for a pick's previews, 200 ms
+  for the verdict) can be held while a check counts what an event and its render did, and let run after (holdRest,
+  releaseRest). The count then does not lean on time: on a busy machine the put-off work ran before the check read the
+  count, and a pick counted 3 compiles and 8 evaluations (modeller-revision, 2026-10-11, the full test:browser only).
+  Shorter timers run as ever, so work moved off the event into one is still counted as the event's.
+*/
+const REST_MS = 100
+const setTimer = window.setTimeout.bind(window)
+const clearTimer = window.clearTimeout.bind(window)
+let holding = false
+let held = []
+let heldIds = 0
+window.setTimeout = (callback, ms, ...args) => {
+  if (!holding || typeof callback !== 'function' || !(Number(ms) >= REST_MS)) return setTimer(callback, ms, ...args)
+  const id = -++heldIds
+  held.push({ id, callback, ms, args })
+  return id
+}
+window.clearTimeout = id => {
+  if (typeof id === 'number' && id < 0) held = held.filter(h => h.id !== id)
+  else clearTimer(id)
+}
+
 const PALETTE = {
   'palette.dark': '#2b2b2b',
   'palette.neutral': '#9a9a9a',
@@ -248,6 +272,18 @@ window.probe = {
   work() {
     return { ...figureWork }
   },
+  /** From now the work put off until the screen rests waits (see REST_MS). */
+  holdRest() {
+    holding = true
+  },
+  /** The work held runs, each after its own delay from now; how many were held. */
+  releaseRest() {
+    holding = false
+    const due = held
+    held = []
+    for (const h of due) setTimer(h.callback, h.ms, ...h.args)
+    return due.length
+  },
   /**
    * The two middles -- the edit canvas and the preview -- marked, so a later look says whether each is the same element
    * with the same scene, or was made again.

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

@@ -16,6 +16,21 @@ import { openPage } from './serve.mjs'
 const sleep = ms => new Promise(done => setTimeout(done, ms))
 /* The event handled and the render it asked for done -- not the work told to wait until the screen rests (150 ms). */
 const drawn = () => page().evaluate(() => document.querySelector('figure-editor').updateComplete.then(() => probe.work()))
+/*
+  What an event and its render cost, counted with the work put off until the screen rests held (probe.holdRest), so the
+  count does not lean on time; then that work is let run, and what it cost is the screen at rest's (2026-10-11: on a
+  busy machine it ran before the count was read, and a pick counted 3 compiles and 8 evaluations).
+*/
+async function counted(event) {
+  const before = await work()
+  await read(() => probe.holdRest())
+  try {
+    await event()
+    return { before, spent: since(before, await drawn()) }
+  } finally {
+    await read(() => probe.releaseRest())
+  }
+}
 
 let opened
 before(async () => {
@@ -60,9 +75,8 @@ describe('work counted on the robot arm', () => {
   /* The motion tab is drawn out of sight with the rest: the selected part's motion is evaluated at its two ends. */
   test('picking a part on the canvas compiles nothing; it evaluates only the two ends of the part\'s motion', async () => {
     const part = 'upper-arm'
-    const before = await work()
-    await click(await read(id => probe.partOnPage(id), part))
-    const spent = since(before, await drawn())
+    const point = await read(id => probe.partOnPage(id), part)
+    const { before, spent } = await counted(() => click(point))
     assert.equal((await read(() => probe.state())).selected, part)
     assert.deepEqual(spent, { compiles: 0, evaluations: 2 })
     /*
@@ -89,9 +103,7 @@ describe('work counted on the robot arm', () => {
     const revision = (await read(() => probe.state())).revision
     await page().mouse.click(field.x, field.y, { clickCount: 3 })
     await page().keyboard.type(String(field.value + 10))
-    const before = await work()
-    await page().keyboard.press('Enter')
-    const spent = since(before, await drawn())
+    const { spent } = await counted(() => page().keyboard.press('Enter'))
     assert.equal((await read(() => probe.state())).revision, revision + 1, `${field.label} is one step`)
     assert.ok(spent.compiles <= 2 && spent.evaluations <= 5, JSON.stringify(spent))
   })

package/test/browser/modeller.check.mjs

@@ -900,6 +900,31 @@ describe('the row section opens on one click', () => {
     await click(at)
     assert.equal(await summary.evaluate(s => s.parentElement.open), false, 'folded after a second')
   })
+
+  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')))
+    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]
+      /*
+        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'
+      await editor.updateComplete
+      await Promise.all(deep('figure-links').map(links => links.updateComplete))
+      await null
+      const summary = deep('details[row-fold] > summary')[0]
+      summary.click()
+      const fold = summary.parentElement
+      const opened = fold.open
+      await new Promise(done => requestAnimationFrame(() => requestAnimationFrame(done)))
+      return [opened, fold.open]
+    })
+    assert.deepEqual(open, [true, true], 'opened by the click, and still open a frame later')
+  })
 })
 
 test('the page raised no error', () => {

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

@@ -1,7 +1,8 @@
 /*
  * A new part's id, in a real browser, on a figure with a row: the palette's box, a copy from the parts list. A row's
  * copies are drawn under ids of their own; the part made into the row still holds its id, and the next part is not
- * offered it (on :3300, 2026-10-11, a box added after a row was refused with DUPLICATE_PART).
+ * offered it (on :3300, 2026-10-11, a box added after a row was refused with DUPLICATE_PART). The id is figure-model's
+ * to choose (figurePartIdFor): read here as whatever new part there is.
  *
  * Run:  node --test test/browser/part-ids.check.mjs
  */
@@ -52,7 +53,9 @@ function rowed() {
   a = applyFigureAuthoring(a, { kind: 'attach', part: 'box-1', face: 'bottom', to: { plane: 'mounting-plane' } })
   a = addFigureBox(a, { id: 'box-2', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 150, z: 0 } })
   a = applyFigureAuthoring(a, { kind: 'attach', part: 'box-2', face: 'bottom', to: { part: 'box-1', face: 'top' } })
-  return applyFigureAuthoring(a, { kind: 'make-repeat', part: 'box-2', axis: 'x', pitch: 300 })
+  a = applyFigureAuthoring(a, { kind: 'make-repeat', part: 'box-2', axis: 'x', pitch: 300 })
+  /* A part off to one side, free: its mirrored copy lands on the other side. */
+  return addFigureBox(a, { id: 'side', size: { x: 100, y: 100, z: 100 }, position: { x: 900, y: 50, z: 0 } })
 }
 
 describe('a new part on a figure with a row takes an id no part holds', () => {
@@ -62,14 +65,17 @@ describe('a new part on a figure with a row takes an id no part holds', () => {
     assert.equal((await read(() => probe.ids())).includes('box-2'), false, 'the row is drawn under its copies\' ids')
   })
 
-  test('a box from the palette: added as box-3, one step, selected', async () => {
+  test('a box from the palette: added under an id no part holds, one step, selected', async () => {
     const start = await state()
     await click('button[shape]', { has: 'figure.label.primitive-cube' }, 'the palette\'s box')
-    await until(() => probe.state().selected === 'box-3', [], 'box-3 selected')
+    await until(r => probe.state().revision === r + 1, [start.revision], 'one step')
     const after = await state()
     assert.equal(after.error, '')
-    assert.equal(after.revision, start.revision + 1)
-    assert.deepEqual(await parts(), ['box-1', 'box-2', 'box-3'])
+    const now = await parts()
+    assert.equal(now.length, 4)
+    const added = now.find(id => !['box-1', 'box-2', 'side'].includes(id))
+    assert.ok(added, now.join())
+    assert.equal(after.selected, added)
   })
 
   test('the row\'s part copied from the list: the copy is a part, and it is what is selected', async () => {
@@ -83,4 +89,16 @@ describe('a new part on a figure with a row takes an id no part holds', () => {
     assert.equal((await state()).selected, copy)
     assert.equal((await state()).error, '')
   })
+
+  test('a part mirrored: the copy, on the other side, is what is selected', async () => {
+    const at = await read(() => probe.row('side'))
+    await page().mouse.click(at.x, at.y)
+    await until(() => probe.state().selected === 'side', [], 'side selected')
+    const before = await parts()
+    await click('button', { text: 'figure.button.mirror-x' }, 'mirror across X')
+    await until(n => probe.source().appearance.length === n, [before.length + 1], 'the copy')
+    const copy = (await parts()).find(id => !before.includes(id))
+    assert.equal((await state()).selected, copy)
+    assert.equal(Math.round((await read(id => probe.body(id), copy)).t[0]), -900, 'on the other side')
+  })
 })

package/test/browser/parts-page.js

@@ -5,7 +5,7 @@
  * Only reading: every change the check makes goes through the mouse and the keyboard.
  */
 import './editing-page.js'
-import { addFigureBox, applyFigureAuthoring, createFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, proposeFigureOccupancy, serializeFigureAsset } from '@hatiolab/figure-model'
 
 const PALETTE = {
   'palette.dark': '#2b2b2b',
@@ -36,6 +36,14 @@ Object.assign(window.figures, {
     return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', face: 'bottom', to: { part: 'frame', face: 'top' } }))
   },
   /* A box with rounded corners: made from the box, still called what it is. */
+  /* A housing and a stray part on the floor, the space the figure takes declared from both. */
+  gate: () => {
+    let a = figure('Gate')
+    a = addFigureBox(a, { id: 'housing', size: { x: 300, y: 1000, z: 300 }, position: { x: 0, y: 500, z: 0 } })
+    a = addFigureBox(a, { id: 'stray', size: { x: 100, y: 100, z: 100 }, position: { x: 600, y: 50, z: 0 } })
+    for (const part of ['housing', 'stray']) a = applyFigureAuthoring(a, { kind: 'attach', part, face: 'bottom', to: { plane: 'mounting-plane' } })
+    return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a), placement: 'floor' }))
+  },
   rounded: () => {
     let a = figure('Rounded')
     a = addFigureBox(a, { id: 'tray', size: { x: 600, y: 200, z: 400 }, position: { x: 0, y: 100, z: 0 } })