@things-factory/figure-ui 10.1.151 → 10.1.152

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.151",
+  "version": "10.1.152",
   "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.2",
     "@hatiolab/things-scene": "^10.1.83",
     "@material/web": "^2.0.0",
     "@operato/data-grist": "^10.0.0",
@@ -45,5 +45,5 @@
     "@things-factory/figure-service": "^10.1.151",
     "three": "^0.185.1"
   },
-  "gitHead": "495d06ef9ecf4d19fc9bf45ebc3cff4fdfefca53"
+  "gitHead": "67dd923b0d431d726b7f60866bb005a3660852b3"
 }

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,101 @@
+/*
+ * 정렬·간격 고치기, 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)
+  }
+}
+const settled = () => read(() => document.querySelector('figure-editor').updateComplete)
+async function click(selector, options = {}, what = selector) {
+  const element = await page().evaluateHandle((s, o) => findDeep(s, o), selector, options)
+  assert.ok(await element.evaluate(e => !!e), `${what} is on the page`)
+  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

@@ -113,7 +113,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()
@@ -369,8 +386,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()
@@ -395,11 +418,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')
+    const start = await state()
     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')
+    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 +432,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 click(await at('div[overhang] button', 'figure.button.fix-alignment'), 'fix alignment')
+    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 () => {

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/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.check.mjs

@@ -202,6 +202,43 @@ describe('a removal is told: what it let go of as a notice, a refusal as an erro
   })
 })
 
+describe('a part renamed in its name field: one step, still selected; a name refused is said why', () => {
+  before(() => mount('box', 'three'))
+  const name = () => read(() => editing.fieldValue('figure.label.name'))
+  async function rename(to) {
+    await tab('properties')
+    const at = await read(() => probe.labelled('figure.label.name'))
+    assert.ok(at, 'the name field')
+    await page().mouse.click(at.x, at.y, { clickCount: 3 })
+    await page().keyboard.type(to)
+    await page().keyboard.press('Enter')
+    await sleep(400)
+  }
+
+  test('renamed: the list has the new name, it stays selected, in one step', async () => {
+    await pick('a')
+    const before = await revision()
+    await rename('left')
+    assert.deepEqual(await ids(), ['left', 'b', 'c'])
+    assert.equal((await state()).selected, 'left')
+    assert.equal(await revision(), before + 1)
+  })
+
+  test('a name another part has is refused: nothing written, the field shows the name it had, and why is said', async () => {
+    await pick('left')
+    await read(() => editing.told())
+    const before = await revision()
+    await rename('b')
+    assert.equal(await revision(), before, 'nothing written')
+    assert.deepEqual(await ids(), ['left', 'b', 'c'])
+    assert.equal(await name(), 'left')
+    const told = await read(() => editing.told())
+    assert.deepEqual(told.map(t => t.level), ['error'], JSON.stringify(told))
+    /* Said from the kernel's details (ADR-0127): the page loads no translations, so the words are the key. */
+    assert.equal(told[0].message, 'figure.text.part-name-taken')
+  })
+})
+
 describe('the list narrowed: the selected row keeps its name and its buttons in sight', () => {
   before(() => mount('box', 'three'))
   after(() => read(() => parts.narrow(0)))
@@ -221,11 +258,11 @@ describe('the list narrowed: the selected row keeps its name and its buttons in
 })
 
 describe('the palette: the starting shapes, locked at the detail level\'s limit', () => {
-  test('nine starting shapes, in order; a rounded box or a drum is made from the box', async () => {
+  test('nine starting shapes, in order, then a mesh brought from a file; a rounded box or a drum is made from the box', async () => {
     await mount('box', 'three')
     assert.deepEqual(
       (await read(() => parts.palette())).map(b => b.label),
-      ['cube', 'cylinder', 'sphere', 'frustum', 'polygon', 'pyramid', 'plate', 'wall', 'portal'].map(k => `figure.label.primitive-${k}`)
+      ['cube', 'cylinder', 'sphere', 'frustum', 'polygon', 'pyramid', 'plate', 'wall', 'portal'].map(k => `figure.label.primitive-${k}`).concat('figure.button.import-mesh')
     )
   })
 

package/test/browser/row-preview.check.mjs

@@ -0,0 +1,81 @@
+/*
+ * A row's preview follows the row as it is set: a pitch refused, then 개수를 정함 chosen -- the pitch's refusal goes at
+ * once, not after the count is worked out (on :3300, 2026-10-11, it stayed under the count, as if the count were
+ * refused), and the count's own result is said.
+ *
+ * Run:  node --test test/browser/row-preview.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)
+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)
+  }
+}
+const settled = () => read(() => document.querySelector('figure-editor').updateComplete)
+const handle = (selector, options = {}) => page().evaluateHandle((s, o) => findDeep(s, o), selector, options)
+async function click(selector, options = {}, what = selector) {
+  const element = await handle(selector, options)
+  assert.ok(await element.evaluate(e => !!e), `${what} is on the page`)
+  await element.evaluate(e => e.scrollIntoView({ block: 'center' }))
+  await element.click()
+  await settled()
+}
+/** What the row's preview says now, line by line. */
+const said = () => read(() => [...(findDeep('section[row]')?.querySelectorAll('[preview-words], [preview-words] li') ?? [])].map(e => e.textContent.trim()))
+
+/* A 400 mm board, a 3 mm bin fastened on it: a row of it along X. */
+function board() {
+  let a = addFigureBox(createFigureAsset('Board'), { id: 'board', size: { x: 400, y: 50, z: 1000 }, position: { x: 0, y: 25, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'board', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = addFigureBox(a, { id: 'bin', size: { x: 3, y: 100, z: 100 }, position: { x: 0, y: 100, z: 0 } })
+  return applyFigureAuthoring(a, { kind: 'attach', part: 'bin', face: 'bottom', to: { part: 'board', face: 'top' } })
+}
+
+describe('a row\'s preview follows its basis', () => {
+  before(async () => {
+    await read(text => harness.mount('given', text), serializeFigureAsset(board()))
+    await until(() => look.drawn().length > 0, [], 'the board is drawn')
+    const at = await read(() => probe.row('bin'))
+    await page().mouse.click(at.x, at.y)
+    await until(() => probe.state().selected === 'bin', [], 'bin selected')
+    await click('details[row-fold] > summary', {}, 'the row\'s fold')
+  })
+
+  test('a 1 mm pitch: refused, said under the row', async () => {
+    const pitch = await handle('section[row] input[type=number]')
+    await pitch.evaluate(i => i.scrollIntoView({ block: 'center' }))
+    await pitch.click({ clickCount: 3 })
+    await page().keyboard.type('1')
+    await page().keyboard.press('Tab')
+    await until(() => [...(findDeep('section[row]')?.querySelectorAll('[preview-words]') ?? [])].some(e => e.textContent.includes('figure.text.preview-refused')), [], 'the pitch refused')
+  })
+
+  test('개수를 정함 chosen: the pitch\'s refusal is gone at once, and the count is said', async () => {
+    await click('section[row] input[type=radio]', { index: 1 }, 'by count')
+    /* Read before the count is worked out (it settles 150 ms after it is chosen). */
+    assert.ok(!(await said()).some(line => line.includes('preview-refused')), `not the pitch's: ${JSON.stringify(await said())}`)
+    await until(() => [...(findDeep('section[row]')?.querySelectorAll('[preview-words] li') ?? [])].some(e => e.textContent.includes('figure.text.row-count-pitch')), [], 'the count said')
+  })
+})