@things-factory/figure-ui 10.1.244 → 10.1.246

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.244",
+  "version": "10.1.246",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -27,8 +27,8 @@
     "clean": "npm run clean:server && npm run clean:client"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.12.1",
-    "@hatiolab/things-scene": "^10.1.104",
+    "@hatiolab/figure-model": "^0.12.2",
+    "@hatiolab/things-scene": "^10.1.109",
     "@material/web": "^2.0.0",
     "@operato/data-grist": "^10.29.43",
     "@operato/graphql": "^10.29.43",
@@ -42,11 +42,11 @@
     "@operato/slot-layout-editor": "^10.29.58",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.29.43",
-    "@things-factory/ai-assistant": "^10.1.244",
-    "@things-factory/figure-service": "^10.1.244",
-    "@things-factory/figure-viewer": "^10.1.227",
-    "@things-factory/setting-base": "^10.1.244",
+    "@things-factory/ai-assistant": "^10.1.246",
+    "@things-factory/figure-service": "^10.1.246",
+    "@things-factory/figure-viewer": "^10.1.246",
+    "@things-factory/setting-base": "^10.1.246",
     "three": "^0.185.1"
   },
-  "gitHead": "f80402ed4e682642b9dfb3ce68d8b00d591d44ee"
+  "gitHead": "46c0d3c93edf765cc1f13040b1f9d03fd1d9e60b"
 }

package/test/align.test.ts

@@ -9,9 +9,9 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
-import { addFigureBox, createFigureAsset, editFigurePart } from '@hatiolab/figure-model'
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, editFigurePart } from '@hatiolab/figure-model'
 
-import { alignChanges, boxOf, canMirror, gridStepOf, mirrorChanges, niceStep } from '../client/modeller/align.ts'
+import { alignChanges, boxOf, canMirror, gridStepOf, mirrorEditOf, mirrorPlanOf, niceStep } from '../client/modeller/align.ts'
 import { gizmoReachOf } from '../client/modeller/gizmo.ts'
 import { revisionOf } from './revision-of.ts'
 
@@ -61,12 +61,18 @@ test('눈금은 1 · 2 · 5 간격으로 자리와 크기를 맞추고, 크기
   assert.ok(['x', 'y', 'z'].every(a => snapped.designInputs[`body.size.${a}`]! >= step))
 })
 
-test('대칭은 복제본을 가운데 면 반대편 같은 거리에 둔다 · 가운데에 있으면 내지 않는다', () => {
+test('대칭은 한 단계로 가운데 면 반대편에 복사하고, 붙인 부품에도 낸다 · 가운데에 있으면 내지 않는다', () => {
   const asset = probe()
-  const copied = editFigurePart(asset, { kind: 'duplicate-part', target: 'body' })
-  const mirrored = applied(copied, mirrorChanges(revisionOf(copied), 'body', 'body-copy', 'x'))
+  const mirrored = editFigurePart(asset, { kind: 'mirror-part', target: 'body', axis: 'x' })
   assert.equal(Math.round(box(mirrored, 'body-copy')!.centre.x), -Math.round(box(mirrored, 'body')!.centre.x))
-  assert.equal(canMirror(revisionOf(probe({ x: 0, y: 50, z: 0 })), 'body', 'x', gizmoReachOf(probe() as never, 'body')), false)
+  assert.equal(canMirror(revisionOf(probe({ x: 0, y: 50, z: 0 })), 'body', 'x'), false)
+  /* A part fastened to a face: the gizmo does not move it, and its mirrored copy is still offered. */
+  let fastened = addFigureBox(probe({ x: 0, y: 50, z: 0 }), { id: 'arm', size: { x: 40, y: 40, z: 40 }, position: { x: 0, y: 0, z: 0 } })
+  fastened = applyFigureAuthoring(fastened, { kind: 'attach', part: 'arm', to: { part: 'body', face: 'right' } })
+  assert.equal(gizmoReachOf(fastened as never, 'arm').translate, false)
+  assert.equal(canMirror(revisionOf(fastened), 'arm', 'x'), true)
+  const copied = editFigurePart(fastened, { kind: 'mirror-part', target: 'arm', axis: 'x' })
+  assert.equal(Math.round(box(copied, 'arm-copy')!.centre.x), -Math.round(box(copied, 'arm')!.centre.x))
 })
 
 test('붙인 부품처럼 옮길 수 없는 것은 맞추기도 없다', () => {
@@ -109,3 +115,19 @@ test('no size drag is refused for a turn; what a size typed keeps is said, in ev
   const ko = JSON.parse(read('../translations/ko.json'))
   assert.deepEqual([ko['figure.text.size-keeps-centre'], ko['figure.text.size-keeps-fastening']], ['가운데 유지', '붙인 위치 유지'])
 })
+
+test('다리처럼 아래 붙은 것이 있으면 대칭 전에 묻는다 — 함께 가져갈 것, 이름 앞머리 짐작(X 는 좌우, Z 는 앞뒤), 움직임 (로봇개 2026-11-03)', () => {
+  let a = probe({ x: 0, y: 300, z: 0 })
+  for (const id of ['fl-hip', 'fl-shin']) a = addFigureBox(a, { id, size: { x: 40, y: 100, z: 40 }, position: { x: 0, y: 0, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'fl-hip', to: { part: 'body', face: 'bottom' }, align: { x: { mm: 60 } } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'fl-shin', to: { part: 'fl-hip', face: 'bottom' } })
+  const across = mirrorPlanOf(a, 'fl-hip', 'x')
+  assert.deepEqual([across.hanging, across.moves, across.asks], [['fl-shin'], false, true])
+  assert.deepEqual([across.form.from, across.form.to, across.form.chain], ['fl-', 'fr-', true], 'X 는 피규어의 왼쪽·오른쪽')
+  assert.deepEqual([mirrorPlanOf(a, 'fl-hip', 'z').form.to], ['bl-'], 'Z 는 앞·뒤')
+  assert.deepEqual(mirrorEditOf('fl-hip', across.form), { kind: 'mirror-part', target: 'fl-hip', axis: 'x', chain: true, prefix: { from: 'fl-', to: 'fr-' } })
+  assert.equal(mirrorPlanOf(a, 'fl-shin', 'x').asks, false, '아래 붙은 것도 움직임도 없으면 묻지 않는다')
+  const made = editFigurePart(a, mirrorEditOf('fl-hip', across.form))
+  assert.deepEqual(made.appearance.map(x => x.target).filter(t => t.startsWith('fr-')).sort(), ['fr-hip', 'fr-shin'])
+})

package/test/browser/editing-page.js

@@ -8,7 +8,7 @@ import './more-open.js'
 import './modeller-page.js'
 import { i18next } from '@operato/i18n'
 import { Raycaster, Vector2 } from 'three'
-import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, createFigureAsset, editFigurePart, serializeFigureAsset } from '@hatiolab/figure-model'
+import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, compileFigureAsset, createFigureAsset, editFigurePart, figureOccupiedBoxesOf, figureWritersOf, parseFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
 
 const PALETTE = {
   'palette.dark': '#2b2b2b',
@@ -30,7 +30,20 @@ function box(placement, position, rotation) {
   return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'set-placement', placement }))
 }
 
+/* A leg hung under the box, turned 40 degrees in the saved pose: its lowest corner, not the box, is what reaches the floor. */
+function legged(a) {
+  a = addFigureBox(a, { id: 'leg', size: { x: 60, y: 500, z: 60 }, position: { x: 0, y: 0, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'leg', to: { part: 'box', face: 'bottom' } })
+  const j = a.joints.find(k => k.body1.part === 'leg')
+  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, motion: [{ type: 'revolute', axis: 'Z', lowerLimit: -60, upperLimit: 60 }] } })
+  return serializeFigureAsset({ ...a, stateDefaults: { ...a.stateDefaults, [j.id]: 40 } })
+}
+
 window.figures = {
+  /* A body standing by its position, a leg under it (robot dog 2026-11-03). */
+  legged: () => legged(parseFigureAsset(box('floor', { x: 0, y: 1500, z: 0 }))),
+  /* The same body fastened to the floor plane 1200 mm up. */
+  'legged-on-plane': () => legged(applyFigureAuthoring(parseFigureAsset(box('floor', { x: 0, y: 0, z: 0 })), { kind: 'attach', part: 'box', to: { plane: 'mounting-plane' }, gap: 1200 })),
   /* 500 mm above the floor. */
   raised: () => box('floor', { x: 0, y: 700, z: 0 }),
   /* Turned 45 degrees about Z, off the floor: it meets the floor by an edge. */
@@ -44,6 +57,8 @@ window.figures = {
     a = addFigurePrimitive(a, { id: 'drum', kind: 'cylinder', dimensions: { radius: 200, length: 500 }, position: { x: 400, y: 250, z: 0 } })
     return serializeFigureAsset(a)
   },
+  /* The doors, the right one's clip in a motion group: a clip of a group can be copied. */
+  'doors-grouped': () => serializeFigureAsset(editFigurePart(parseFigureAsset(window.figures.doors()), { kind: 'set-motion-group', group: { id: 'motion', label: 'swing', clips: ['right-swing'], defaultClip: 'right-swing', transitionSeconds: 0.2 } })),
   /* Two doors on a frame, each swinging on a clip of its own. */
   doors: () => {
     let a = figure('Doors')
@@ -168,6 +183,11 @@ window.editing = {
   told() {
     return told.splice(0).map(n => ({ level: n.level, message: n.message }))
   },
+  /** The lowest point of every part, in the figure's saved pose, as the session holds it. */
+  lowest() {
+    const a = parseFigureAsset(editor().session.source())
+    return Math.round(Math.min(...figureOccupiedBoxesOf(compileFigureAsset(a).evaluate().geometry, figureWritersOf(a)).map(b => b.centre.y - b.extent.y / 2)))
+  },
   /** A part's material as the session holds it. */
   material(id) {
     return editor().session.read().geometry.find(g => g.id === id)?.material ?? null

package/test/browser/editing.check.mjs

@@ -264,6 +264,23 @@ describe('put on the plane by the figure\'s placement: once, not fastened (desig
   })
 })
 
+describe('put down as it stands: a body by what hangs from it (robot dog 2026-11-03)', () => {
+  for (const [figure, how] of [['legged', 'its position'], ['legged-on-plane', 'its gap to the plane']])
+    test(`${figure}: the leg's lowest point reaches the floor in one step, by ${how}`, async () => {
+      await mount('box', figure)
+      await pick('box')
+      const tool = await read(() => editing.at('button[plane-align]'))
+      assert.ok(tool, 'the tool is offered')
+      assert.equal(tool.title, 'figure.text.align-to-floor-hanging')
+      assert.ok((await read(() => editing.lowest())) > 100, 'it starts off the floor')
+      const start = await revision()
+      await click(tool)
+      assert.equal(await revision(), start + 1, 'one step')
+      assert.equal(await read(() => editing.lowest()), 0)
+      assert.ok((await bottomOf('box')) > 300, 'the body stands on its leg, not on the floor')
+    })
+})
+
 describe('the material: colours by purpose, one step each, a glow drawn while dragged, segments for round bodies only', () => {
   before(() => mount('box', 'shapes'))
 
@@ -286,6 +303,22 @@ describe('the material: colours by purpose, one step each, a glow drawn while dr
     assert.equal((await read(() => editing.material('bin'))).token, 'palette.accent')
   })
 
+  test('a colour of its own, picked by its value, is one step: the part takes it and the palette carries it (robot dog, 2026-11-03)', async () => {
+    const start = await revision()
+    const found = await read(() => {
+      const panel = [...document.querySelectorAll('*')].flatMap(function all(e) { return e.shadowRoot ? [e, ...[...e.shadowRoot.querySelectorAll('*')].flatMap(all)] : [e] }).find(e => e.localName === 'figure-material-panel' && e.shadowRoot?.querySelector('label[own-colour] input'))
+      const input = panel?.shadowRoot.querySelector('label[own-colour] input')
+      if (!input) return false
+      input.value = '#ffd400'
+      input.dispatchEvent(new Event('change', { bubbles: true }))
+      return true
+    })
+    assert.ok(found, 'the own colour field beside the swatches')
+    await until(async () => (await revision()) === start + 1, 'one step')
+    assert.equal((await read(() => editing.material('bin'))).token, 'colour.ffd400')
+    assert.equal(await read(() => probe.source().palette['colour.ffd400']), '#ffd400')
+  })
+
   test('the glow is drawn while its slider is held, nothing written; the release writes it once', async () => {
     const start = await revision()
     const thumb = await read(() => editing.range('figure-material-panel'))
@@ -477,6 +510,42 @@ describe('a clip scrubbed and keyed (2026-09-24)', () => {
     assert.deepEqual(Object.fromEntries((await read(() => editing.clips())).map(c => [c.clip, c.keys])), { 'left-swing': 3, 'right-swing': 2 })
   })
 
+  /* A field of the clip panel by its label: the moment, or a key's time or value (proposal 18, 2026-11-03). */
+  const typeInClips = async (label, text) => {
+    const field = await page().evaluateHandle(label => {
+      const deep = (root = document) => [...root.querySelectorAll('input')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      return deep().find(i => i.type === 'number' && i.getAttribute('aria-label') === label && i.getRootNode().host?.localName === 'figure-clips') ?? null
+    }, label)
+    assert.ok(await field.evaluate(i => !!i), `${label} in the clips`)
+    await field.evaluate(i => i.scrollIntoView({ block: 'center' }))
+    await field.click({ clickCount: 3 })
+    await page().keyboard.type(text)
+    await page().keyboard.press('Tab')
+    return field
+  }
+
+  test('a moment typed is posed as the bar would pose it, not on the bar\'s hundredths', async () => {
+    const start = await revision()
+    await typeInClips('figure.label.clip-time', '1.37')
+    await until(async () => (await revision()) === start + 1, 'one step')
+    /* The first clip on the panel is the right door's: 80 degrees over 2 seconds, so 1.37 s is 54.8. */
+    const value = await read(() => probe.value('right-open'))
+    assert.ok(Math.abs(value - 40 * 1.37) < 1e-6, `the pose at 1.37 s: ${value}`)
+  })
+
+  test('a key\'s value typed in its chip is one step of the track; the first key\'s time stays at 0', async () => {
+    const start = await revision()
+    await typeInClips('figure.label.key-value 2', '55')
+    await until(async () => (await revision()) === start + 1, 'one step')
+    /* The first track's second key: whichever clip the panel lists first. */
+    const keys = await read(() => JSON.parse(document.querySelector('figure-editor').session.source()).drivers.flatMap(d => d.keys))
+    assert.ok(keys.some(k => k.value === 55), `a key at 55: ${JSON.stringify(keys)}`)
+    assert.equal(await read(() => {
+      const deep = (root = document) => [...root.querySelectorAll('input')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      return deep().find(i => i.getAttribute('aria-label') === 'figure.label.key-seconds 1')?.readOnly
+    }), true)
+  })
+
   test('a track\'s name stands on its own line, the repeat choice and a small remove button under it', async () => {
     const head = await read(() => editing.trackHead())
     assert.ok(head, 'a track')
@@ -487,6 +556,61 @@ describe('a clip scrubbed and keyed (2026-09-24)', () => {
   })
 })
 
+describe('a track moved round its loop, a clip copied (robot dog 2026-11-03)', () => {
+  before(async () => {
+    await mount('box', 'doors-grouped')
+    await click(await read(() => probe.tab('figure.label.tab-short-motion')))
+  })
+  const drivers = () => read(() => JSON.parse(document.querySelector('figure-editor').session.source()).drivers)
+  const inClips = selector => read(selector => {
+    const deep = (root = document) => [...root.querySelectorAll(selector)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+    return deep().filter(e => e.getRootNode().host?.localName === 'figure-clips').length
+  }, selector)
+  const pressIn = async (selector, index = 0) => {
+    const button = await page().evaluateHandle(({ selector, index }) => {
+      const deep = (root = document) => [...root.querySelectorAll(selector)].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      return deep().filter(e => e.getRootNode().host?.localName === 'figure-clips')[index] ?? null
+    }, { selector, index })
+    assert.ok(await button.evaluate(b => !!b), selector)
+    await button.evaluate(b => b.scrollIntoView({ block: 'center' }))
+    await button.click()
+  }
+
+  test('a clip in a group is copied in one step; one in none is not offered', async () => {
+    /* The left door's clip is in no group, the right one's is in one. */
+    assert.equal(await read(() => {
+      const deep = (root = document) => [...root.querySelectorAll('button[copy-clip]')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      return deep().map(b => b.disabled).join()
+    }), 'true,false')
+    const start = await revision()
+    await pressIn('button[copy-clip]', 1)
+    await until(async () => (await revision()) === start + 1, 'one step')
+    const copy = (await drivers()).find(d => d.clip === 'right-swing-copy')
+    assert.deepEqual(copy?.keys, (await drivers()).find(d => d.clip === 'right-swing').keys)
+    assert.ok(await read(() => JSON.parse(document.querySelector('figure-editor').session.source()).motionGroups[0].clips.includes('right-swing-copy')), 'in the group')
+  })
+
+  test('a track moved one second round its two-second loop starts where it stood at one second', async () => {
+    const start = await revision()
+    await pressIn('button[copy-track]')
+    assert.equal(await inClips('div[copy-form]'), 1, 'the form under the track')
+    const later = await page().evaluateHandle(() => {
+      const deep = (root = document) => [...root.querySelectorAll('input')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      return deep().find(i => i.getAttribute('aria-label') === 'figure.label.copy-track-later')
+    })
+    await later.click({ clickCount: 3 })
+    await page().keyboard.type('1')
+    await page().keyboard.press('Tab')
+    await pressIn('div[copy-form] button[act]')
+    await until(async () => (await revision()) === start + 1, 'one step')
+    const moved = (await drivers()).find(d => d.clip === 'left-swing' && d.state === 'left-open')
+    /* 0 to 80 over 2 s: a second later it starts at 40, reaches 80 at 1 s, leaps back to 0 there. */
+    assert.equal(moved.keys[0].value, 40)
+    assert.ok(moved.keys.some(k => Math.abs(k.at - 0.5) < 1e-6 && k.value === 0), JSON.stringify(moved.keys))
+    assert.equal(await inClips('div[copy-form]'), 0, 'the form closes')
+  })
+})
+
 describe('an edit that would stop a clip is asked first (designer 2026-09-27)', () => {
   before(() => mount('box', 'doors'))
 

package/test/browser/links.check.mjs

@@ -174,12 +174,17 @@ async function type(field, text) {
     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
-  })
+  /* Under the whole suite's load the window can still be settling after that: a press that missed is made again where it stands now. */
+  let focused = false
+  for (let tries = 0; tries < 5 && !focused; tries++) {
+    if (tries) await sleep(200)
+    await field.click({ clickCount: 3 })
+    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')
@@ -340,8 +345,15 @@ describe('a row\'s pitch', () => {
     await pick('roller')
     await tab('response')
     const start = await state()
-    await type(await handle('input[aria-label="figure.label.repeat-gap"]'), '300')
-    await oneStep(start)
+    const field = await handle('input[aria-label="figure.label.repeat-gap"]')
+    await type(field, '300')
+    /* Unsteady under the whole suite's load once in a while (2026-11-01, 11-03): said with what the field and the editor hold when it does. */
+    try {
+      await oneStep(start)
+    } catch (error) {
+      const seen = { field: await field.evaluate(i => ({ value: i.value, connected: i.isConnected })), state: await state() }
+      throw new Error(`${error.message}: ${JSON.stringify(seen)}`)
+    }
     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')
@@ -434,6 +446,35 @@ describe('the fastening window on the robot arm', () => {
   })
 })
 
+describe('the drawing of a turned target shows its faces where they are drawn (robot dog, 2026-11-03)', () => {
+  before(async () => {
+    let a = addFigurePrimitive(createFigureAsset('Laid'), { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 400 }, position: { x: 0, y: 500, z: 0 }, rotation: { x: 0, y: 0, z: 90 } })
+    a = addFigureBox(a, { id: 'cap', size: { x: 40, y: 40, z: 40 }, position: { x: 500, y: 500, z: 0 } })
+    await mount('laid-drum', a)
+  })
+
+  test('a cylinder laid on its side: its end faces stand left and right, and the top drawn is no face of it', async () => {
+    await pick('cap')
+    await press('button[fasten-start]')
+    await until(() => probe.fastenTargets(), [], 'the fastening window')
+    await aimAt('drum')
+    const placed = () =>
+      read(() => {
+        const deep = (root = document) => [...root.querySelectorAll('[place]')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+        return Object.fromEntries(deep().map(e => [e.getAttribute('place'), { face: e.getAttribute('face'), pickable: (e.getAttribute('style') ?? '').includes('cursor:pointer') }]))
+      })
+    await until(() => {
+      const deep = (root = document) => [...root.querySelectorAll('[place]')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      return deep().length === 6
+    }, [], 'the six places drawn')
+    const drawn = await placed()
+    assert.deepEqual([drawn.left.face, drawn.right.face], ['top', 'bottom'], 'its ends, where they are seen')
+    assert.equal(drawn.right.pickable, true)
+    assert.equal(drawn.top.pickable, false, 'the round side drawn on top is no face to fasten to')
+    await page().keyboard.press('Escape')
+  })
+})
+
 describe('a new fastening for a door leaf: chosen in the window, seen before it is done', () => {
   before(async () => {
     await mount('door')

package/test/browser/modeller.check.mjs

@@ -612,7 +612,11 @@ describe('a motion is changed where it is (2026-09-25)', () => {
     await click(await button('figure.button.change-motion'))
     const max = await page().evaluateHandle(() => {
       const deep = (root = document) => [...root.querySelectorAll('input[type=number]')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
-      const inputs = deep().filter(i => i.closest('div[pair]') && i.getRootNode().host?.tagName === 'FIGURE-LINKS')
+      /*
+        The motion form's range: the pair under its range label in degrees. The size-by-state form below it has a range
+        of its own (in percent, 2026-10-27), which the last pair on the panel had become.
+      */
+      const inputs = deep().filter(i => i.closest('div[pair]') && i.getRootNode().host?.tagName === 'FIGURE-LINKS' && i.closest('div[pair]').previousElementSibling?.textContent.includes('figure.label.control-range (deg)'))
       return inputs[inputs.length - 1] ?? null
     })
     assert.ok(await max.evaluate(i => !!i), 'the form is open with the range')
@@ -685,6 +689,28 @@ describe('a motion is changed where it is (2026-09-25)', () => {
     assert.deepEqual(now.motion, [was.motion[0]], 'the first axis alone, as it was')
     assert.equal(await rows(), 1)
   })
+
+  test('the point a turn passes is typed in the motion form: one step, the axis\'s through, the part not moved at rest (robot dog, 2026-11-03)', async () => {
+    const rest = await read(() => probe.body('upper-arm'))
+    await click(await button('figure.button.change-motion'), 'change the motion')
+    const x = await page().evaluateHandle(() => {
+      const deep = (root = document) => [...root.querySelectorAll('input')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      return deep().find(i => i.getAttribute('aria-label') === 'figure.label.motion-through X') ?? null
+    })
+    assert.ok(await x.evaluate(i => !!i), 'the through cells under a turn')
+    await x.evaluate(i => i.scrollIntoView({ block: 'center' }))
+    await x.click({ clickCount: 3 })
+    await page().keyboard.type('50')
+    await page().keyboard.press('Tab')
+    const start = await state()
+    await click(await button('figure.button.apply-motion-change'), 'apply')
+    const after = await state()
+    assert.equal(after.error, '', 'not refused')
+    assert.equal(after.revision, start.revision + 1, 'one step')
+    assert.deepEqual((await jointOf('upper-arm')).motion[0].through, { x: 50 })
+    const moved = await read(() => probe.body('upper-arm'))
+    assert.deepEqual(moved.t.map(Math.round), rest.t.map(Math.round), 'at its pose now, the part where it was')
+  })
 })
 
 describe('the modeller made easier to find and to keep (2026-09-26 baseline)', () => {

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

@@ -14,6 +14,7 @@ import { addFigureBox, applyFigureAuthoring, createFigureAsset, serializeFigureA
 import { buildPage } from './build.mjs'
 import { openPage } from './serve.mjs'
 
+const probeJoint = (source, part) => source.joints.find(j => j.body1.part === part).body0
 const sleep = ms => new Promise(done => setTimeout(done, ms))
 
 let opened
@@ -55,7 +56,14 @@ function rowed() {
   a = applyFigureAuthoring(a, { kind: 'attach', part: 'box-2', to: { part: 'box-1', face: 'top' } })
   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 } })
+  a = addFigureBox(a, { id: 'side', size: { x: 100, y: 100, z: 100 }, position: { x: 900, y: 50, z: 0 } })
+  /* A part fastened to the floor box's right face: no gizmo moves it, and it is mirrored to the left face (robot dog, 2026-11-03). */
+  a = addFigureBox(a, { id: 'ear', size: { x: 60, y: 60, z: 60 }, position: { x: 0, y: 0, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'ear', to: { part: 'box-1', face: 'right' }, align: { z: { mm: 100 } } })
+  /* A leg on the floor box's front, a shin under its hip: mirrored whole, named fr- (robot dog, 2026-11-03). */
+  for (const id of ['fl-hip', 'fl-shin']) a = addFigureBox(a, { id, size: { x: 40, y: 40, z: 40 }, position: { x: 0, y: 0, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'fl-hip', to: { part: 'box-1', face: 'front' }, align: { x: { mm: 300 } } })
+  return applyFigureAuthoring(a, { kind: 'attach', part: 'fl-shin', to: { part: 'fl-hip', face: 'bottom' } })
 }
 
 describe('a new part on a figure with a row takes an id no part holds', () => {
@@ -72,8 +80,8 @@ describe('a new part on a figure with a row takes an id no part holds', () => {
     const after = await state()
     assert.equal(after.error, '')
     const now = await parts()
-    assert.equal(now.length, 4)
-    const added = now.find(id => !['box-1', 'box-2', 'side'].includes(id))
+    assert.equal(now.length, 7)
+    const added = now.find(id => !['box-1', 'box-2', 'side', 'ear', 'fl-hip', 'fl-shin'].includes(id))
     assert.ok(added, now.join())
     assert.equal(after.selected, added)
   })
@@ -101,4 +109,53 @@ describe('a new part on a figure with a row takes an id no part holds', () => {
     assert.equal((await state()).selected, copy)
     assert.equal(Math.round((await read(id => probe.body(id), copy)).t[0]), -900, 'on the other side')
   })
+
+  test('a fastened part mirrored: one step, fastened to the opposite face, no refusal', async () => {
+    const at = await read(() => probe.row('ear'))
+    await page().mouse.click(at.x, at.y)
+    await until(() => probe.state().selected === 'ear', [], 'ear selected')
+    const start = await state()
+    const was = await read(() => probe.body('ear'))
+    await click('button', { text: 'figure.button.mirror-x' }, 'mirror across X')
+    await until(r => probe.state().revision === r + 1, [start.revision], 'one step')
+    const after = await state()
+    assert.equal(after.error, '')
+    assert.equal(after.selected, 'ear-copy')
+    const copy = await read(() => probe.body('ear-copy'))
+    assert.equal(Math.round(copy.t[0]), -Math.round(was.t[0]), 'on the other side')
+    assert.equal(Math.round(copy.t[2]), Math.round(was.t[2]), 'as far along the face')
+    assert.deepEqual(probeJoint(await read(() => probe.source()), 'ear-copy'), { part: 'box-1', face: 'left' })
+  })
+
+  test('the unlimited level is offered with no part limit; chosen, one step, saved, and the list counts no limit (user 2026-11-03)', async () => {
+    const offered = await read(() => [...findDeep('select#detail-level').options].map(o => [o.value, o.textContent.replace(/\s+/g, ' ').trim()]))
+    assert.deepEqual(offered.find(([v]) => v === 'UNLIMITED'), ['UNLIMITED', 'figure.label.detail-UNLIMITED · figure.text.no-part-limit'])
+    const start = await state()
+    await read(() => {
+      const select = findDeep('select#detail-level')
+      select.value = 'UNLIMITED'
+      select.dispatchEvent(new Event('change', { bubbles: true }))
+    })
+    await until(r => probe.state().revision === r + 1, [start.revision], 'one step')
+    assert.equal((await read(() => probe.source())).detailLevel, 'UNLIMITED')
+    assert.equal(await read(() => findDeep('span[room]')?.textContent.trim()), String((await parts()).length), 'the parts counted, no limit beside them')
+  })
+
+  test('a leg mirrored from its hip: asked first, the shin with it, named fr-, one step', async () => {
+    const at = await read(() => probe.row('fl-hip'))
+    await page().mouse.click(at.x, at.y)
+    await until(() => probe.state().selected === 'fl-hip', [], 'fl-hip selected')
+    const start = await state()
+    await click('button', { text: 'figure.button.mirror-x' }, 'mirror across X')
+    await until(() => !!findDeep('div[mirror-form]'), [], 'the mirror asked about')
+    assert.equal((await state()).revision, start.revision, 'nothing made yet')
+    assert.deepEqual(await read(() => [...findDeep('div[mirror-form]').querySelectorAll('input')].filter(i => i.type !== 'checkbox').map(i => i.value)), ['fl-', 'fr-'], 'the names guessed')
+    await click('div[mirror-form] button', { text: 'figure.button.mirror-x' }, 'the form\'s mirror')
+    await until(r => probe.state().revision === r + 1, [start.revision], 'one step')
+    const after = await state()
+    assert.equal(after.error, '')
+    assert.equal(after.selected, 'fr-hip')
+    assert.deepEqual(probeJoint(await read(() => probe.source()), 'fr-shin'), { part: 'fr-hip', face: 'bottom' }, 'the shin under the copy')
+    assert.equal(Math.round((await read(() => probe.body('fr-hip'))).t[0]), -Math.round((await read(() => probe.body('fl-hip'))).t[0]))
+  })
 })

package/test/browser/parts.check.mjs

@@ -320,11 +320,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, then a mesh brought from a file; a rounded box or a drum is made from the box', async () => {
+  test('ten starting shapes, in order -- the pipe (ADR-0100 §16.2) among them -- 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}`).concat('figure.button.import-mesh')
+      ['cube', 'cylinder', 'sphere', 'frustum', 'polygon', 'pyramid', 'pipe', 'plate', 'wall', 'portal'].map(k => `figure.label.primitive-${k}`).concat('figure.button.import-mesh')
     )
   })
 

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

@@ -241,24 +241,30 @@ describe('places made by a rule: the shared slot layout editor on a part\'s face
     assert.equal(await has('button[data-action="use-default"]'), false, 'no default: the figure\'s layout is the only one')
   })
 
-  test('a preset on the fork\'s top: a slot that names no type is held back with the figure\'s words', async () => {
-    assert.equal(await read(() => findDeep('input[data-preset="width"]').value), '1200', 'the face\'s size is where the preset starts')
-    await type('input[data-preset="slotHeight"]', {}, '1000')
-    await click('button[data-action="start-preset"]')
-    assert.equal(await read(() => findDeep('button[data-action="apply"]').disabled), true)
-    assert.equal(await has('*', { within: 'ox-slot-layout-editor', has: 'figure.text.slot-accepts-required' }), true)
+  /*
+    The editor of 2026-10-26: with no layout yet the face is one slot at once, sized by the face and the room over it, put
+    in on Apply; a slot that names no type takes any item (ADR-0051 decisions 5 and 7, 2026-10-27). The preset's typed
+    size and the held-back slot that names no type this check once pressed are gone.
+  */
+  test('with no layout yet, the fork\'s top is one slot at once, sized by the face; nothing written until Apply', async () => {
+    const start = await state()
+    await until(() => !!findDeep('button[data-action="apply"]') && !findDeep('button[data-action="apply"]').disabled, [], 'Apply offered for the one slot')
+    assert.equal((await state()).revision, start.revision, 'nothing written yet')
+    assert.equal(await has('*', { within: 'ox-slot-layout-editor', has: 'figure.text.slot-accepts-required' }), false, 'a slot that names no type takes any item')
   })
 
   test('the slot names a type; Apply is one step, the layout the figure holds, its slots drawn on the fork', async () => {
     const start = await state()
-    await choose('select[data-field="accepts-mode"]', {}, 'LIST')
+    await click('[data-field="accepts-mode"] button[data-value="LIST"]', {}, 'listed types only')
     await type('input[data-field="accepts"]', {}, 'PALLET')
     await click('button[data-action="apply"]')
     await until(r => probe.state().revision === r + 1, [start.revision], 'the layout written')
     const held = (await source()).document.capabilities.slotLayout
     assert.equal(held.role, 'seat')
     assert.deepEqual(held.anchors.map(a => [a.id, a.frame]), [['fork', 'fork.face.top.frame']], 'on the fork\'s top')
-    assert.deepEqual(held.layout.tiers[0].layout.slot, { allowed: { width: 1200, depth: 900, height: 1000 }, accepts: ['PALLET'] })
+    const slot = held.layout.tiers[0].layout.slot
+    assert.deepEqual([slot.allowed.width, slot.allowed.depth, slot.accepts], [1200, 900, ['PALLET']], 'the face\'s size, the type named')
+    assert.ok(slot.allowed.height > 0, 'a height from the room over the face')
     assert.equal(held.layout.preset.key, 'single')
     await until(() => look.drawn().includes('__slot:t1_s1'), [], 'the slot drawn')
   })