@things-factory/figure-ui 10.1.168 → 10.1.170

package/test/browser/screen.check.mjs

@@ -82,6 +82,12 @@ const tabOn = () => read(() => screenCheck.editor().shadowRoot.querySelector('bu
 const pressBar = action => press(action, a => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar').shadowRoot.querySelector(`button[data-action=${a}]`), action)
 const pressTab = name => press(name, name => screenCheck.editor().shadowRoot.querySelector(`button[tab][aria-label="${name}"]`), name)
 const TAB = name => `figure.label.tab-short-${name}`
+/** The view settings or the release history, opened from the bar over the work (they were tabs once); left open if open. */
+async function openOverlay(which) {
+  if (await read(w => screenCheck.editor().shadowRoot.querySelector(`ox-canvas-bar button[bar-overlay=${w}]`)?.getAttribute('aria-pressed') === 'true', which)) return
+  await press(`the ${which} button`, w => screenCheck.editor().shadowRoot.querySelector(`ox-canvas-bar button[bar-overlay=${w}]`), which)
+  await until(`${which} open`, w => screenCheck.editor().shadowRoot.querySelector(`div[bar-overlay-panel=${w}]`)?.getBoundingClientRect().height > 0, which)
+}
 /** A row of the parts list, by the part's name. */
 const pressRow = id => press(`the ${id} row`, id => screenCheck.deep('span[label]').find(s => s.getAttribute('title') === id), id)
 
@@ -185,13 +191,13 @@ describe('the frame: parts · canvas · one side of seven tabs, and the bar over
     assert.equal(await read(() => getComputedStyle(screenCheck.editor()).containerType), 'inline-size')
   })
 
-  test('the side\'s seven tabs, in order, each saying its name under its icon -- the name it is read by', async () => {
+  test('the side\'s four tabs, in order, each saying its name under its icon -- the name it is read by', async () => {
     const tabs = await read(() =>
       [...screenCheck.editor().shadowRoot.querySelectorAll('aside button[tab]')].map(b => ({ label: b.getAttribute('aria-label'), shows: b.querySelector('span[tab-label]')?.textContent.trim() }))
     )
     assert.deepEqual(
       tabs.map(t => t.label),
-      ['properties', 'capability', 'motion', 'data', 'verdict', 'view', 'history'].map(TAB)
+      ['properties', 'motion', 'data', 'verdict'].map(TAB)
     )
     for (const tab of tabs) assert.equal(tab.shows, tab.label, `${tab.label} shows its name`)
     assert.equal(await read(() => screenCheck.editor().shadowRoot.querySelector('aside').firstElementChild.matches('div[tabs]')), true, 'the tabs are the side\'s first row')
@@ -200,12 +206,12 @@ describe('the frame: parts · canvas · one side of seven tabs, and the bar over
   test('a tab shows its panel and hides the others without taking them down -- the verdict keeps what it holds', async () => {
     const panels = () =>
       read(() => [...screenCheck.editor().shadowRoot.querySelectorAll('aside > div[panel]')].map(p => ({ seen: p.getBoundingClientRect().height > 0, connected: p.isConnected, verdict: !!p.querySelector('slot[name=verdict]') })))
-    const tabs = ['properties', 'capability', 'motion', 'data', 'verdict', 'view', 'history']
+    const tabs = ['properties', 'motion', 'data', 'verdict']
     for (const [at, tab] of tabs.entries()) {
       await pressTab(TAB(tab))
       await until(`${tab} on`, name => screenCheck.editor().shadowRoot.querySelector('button[tab][on]')?.getAttribute('aria-label') === name, TAB(tab))
       const now = await panels()
-      assert.equal(now.length, 7, 'seven panels, all standing')
+      assert.equal(now.length, 4, 'four panels, all standing')
       assert.deepEqual(now.map(p => p.seen), tabs.map((_, i) => i === at), `${tab}: its panel seen, the rest hidden`)
       assert.ok(now.every(p => p.connected))
       assert.ok(now[tabs.indexOf('verdict')].verdict, 'the verdict panel holds the verdict slot whichever tab is on')
@@ -323,7 +329,7 @@ describe('the editor is drawn in the shell\'s tokens (2026-09-27)', () => {
 describe('a part chosen: each tab in its place, the figure-wide tabs give way, the list\'s root goes back', () => {
   before(() => mount('arm'))
 
-  test('properties hold the part\'s shape and material, capability its places, motion its motion and controls -- each under the part\'s head', async () => {
+  test('properties hold the part\'s size, place, material and, folded, its places; motion its motion and controls -- each under the part\'s head', async () => {
     await pressRow('upper-arm')
     await until('upper-arm chosen', () => screenCheck.editor().selected === 'upper-arm')
     const holds = () =>
@@ -341,13 +347,18 @@ describe('a part chosen: each tab in its place, the figure-wide tabs give way, t
     await pressTab(TAB('properties'))
     let now = await holds()
     assert.ok(now.subject, 'the part\'s head')
-    assert.ok(now.links.includes('figure.label.resize-intent') && now.links.includes('figure.label.placement'), `the shape's links: ${now.links}`)
+    assert.ok(now.links.includes('figure.label.group-size') && now.links.includes('figure.label.group-place'), `the shape's links: ${now.links}`)
     assert.ok(now.material, 'its material')
-    await pressTab(TAB('capability'))
-    now = await holds()
-    assert.ok(now.subject, 'the part\'s head')
-    assert.ok(now.links.length === 1 && now.links[0].startsWith('figure.label.places-on-part'), `the places on the part: ${now.links}`)
-    assert.ok(now.capability, 'its capabilities')
+    /* What it does is a folded group of the properties now (chief architect 2026-10-16), its places inside. */
+    await press('the capability fold', () => screenCheck.shownPanel().querySelector('section[capability] > details > summary'))
+    const places = await read(() => {
+      const fold = screenCheck.shownPanel().querySelector('section[capability] > details')
+      const links = fold.querySelector('figure-links')
+      return { open: fold.open, heads: links ? [...links.shadowRoot.querySelectorAll('section > h3')].map(h => screenCheck.ownText(h)) : [], capability: !!fold.querySelector('figure-capability-panel') }
+    })
+    assert.ok(places.open, 'the fold opened')
+    assert.ok(places.heads.length === 1 && places.heads[0].startsWith('figure.label.places-on-part'), `the places on the part: ${places.heads}`)
+    assert.ok(places.capability, 'its capabilities')
     await pressTab(TAB('motion'))
     now = await holds()
     assert.ok(now.subject, 'the part\'s head')
@@ -355,8 +366,8 @@ describe('a part chosen: each tab in its place, the figure-wide tabs give way, t
     assert.ok(now.controls > 0, 'the controls that pose it')
   })
 
-  test('choosing a part from the verdict, view or history tab opens its properties; from a part\'s own tab, that tab stays', async () => {
-    for (const tab of ['verdict', 'view', 'history']) {
+  test('choosing a part from the verdict tab opens its properties; from a part\'s own tab, that tab stays', async () => {
+    for (const tab of ['verdict']) {
       await pressTab(TAB(tab))
       await pressRow((await selected()) === 'forearm' ? 'elbow' : 'forearm')
       await until(`from ${tab}, the properties`, () => screenCheck.editor().shadowRoot.querySelector('button[tab][on]')?.getAttribute('aria-label') === 'figure.label.tab-short-properties')
@@ -563,8 +574,8 @@ describe('the view tab: the workbench\'s settings, in the board\'s own names, ke
     assert.equal(now.pixelRatio, await read(() => Math.min(3, (window.devicePixelRatio || 1) * 2)))
   })
 
-  test('the coordinate ground switched off in the tab: the board follows, the browser keeps it, the figure is untouched', async () => {
-    await pressTab(TAB('view'))
+  test('the coordinate ground switched off in the view menu: the board follows, the browser keeps it, the figure is untouched', async () => {
+    await openOverlay('view')
     assert.ok((await read(() => screenCheck.deep('figure-settings')[0].shadowRoot.textContent)).includes('figure.text.view-settings-are-not-saved'), 'it says these are not saved')
     const before = { revision: await revision(), source: await source(), grid: (await board()).grid }
     assert.equal(before.grid, true)
@@ -640,7 +651,7 @@ describe('the preview: registered as a board registers it, posed and played, the
     const now = await clip()
     assert.equal(now.shown, now.value.toFixed(2))
     const given = await read(() => screenCheck.deep('figure-preview')[0].scene.root.components.map(c => c.state.clips?.cycle))
-    assert.equal(given.length, 8, 'eight instances')
+    assert.equal(given.length, 1, 'the one figure the preview stands')
     assert.ok(given.every(v => v === now.value), `each given the speed shown: ${given}`)
   })
 
@@ -714,12 +725,64 @@ describe('the preview of a figure that does not declare every size', () => {
     await mount('tower')
     await press('the preview mode', () => screenCheck.deep('button[mode]').find(b => b.title === 'figure.text.mode-preview-explained'))
     await until('the legend', () => !!screenCheck.deep('figure-preview')[0]?.shadowRoot?.querySelector('div[legend]'))
+    /* The eight ways side by side are a choice in the legend; the one figure stands first. */
+    await press('the eight sizes', () => screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('button[way=eight]'))
+    await until('the eight', () => screenCheck.deep('figure-preview')[0].scene?.root?.components?.length === 8)
     const clamped = await read(() => [...screenCheck.deep('figure-preview')[0].shadowRoot.querySelectorAll('div[legend] small[clamp]')].map(s => s.textContent.trim()))
     assert.ok(clamped.length > 0 && clamped.every(c => c.startsWith('figure.text.preview-clamped')), `said: ${clamped}`)
     await boardsUp()
   })
 })
 
+describe('the camera follows a size typed far from the view (first 15 minutes, 2026-10-16)', () => {
+  test('a width typed ten times larger fits the view again; a little wider leaves the camera where it is', async () => {
+    await mount('box')
+    await pressRow('box')
+    await read(() => {
+      const canvas = screenCheck.deep('figure-canvas')[0]
+      const fit = canvas.fit.bind(canvas)
+      window.fits = 0
+      canvas.fit = () => (window.fits++, fit())
+    })
+    const typeWidth = async mm => {
+      const width = await element('the width field', () => screenCheck.deep('input').find(i => i.getAttribute('aria-label') === 'box.size.x'))
+      await width.click({ clickCount: 3 })
+      await page().keyboard.type(String(mm))
+      await page().keyboard.press('Enter')
+      await until(`the width is ${mm}`, mm => probe.value('box.size.x') === mm, mm)
+      /* The camera judges once the figure has stood still (REFIT_SETTLE_MS, 400 ms). */
+      await new Promise(done => setTimeout(done, 700))
+    }
+    await typeWidth(500)
+    assert.equal(await read(() => window.fits), 0, 'a little wider: the camera stays')
+    await typeWidth(4000)
+    await until('the view fitted to it', () => window.fits >= 1)
+    await boardsUp()
+  })
+})
+
+describe('the preview stands one figure the author stretches (first 15 minutes, 2026-10-16)', () => {
+  const preview = () => screenCheck.deep('figure-preview')[0]
+  test('a slider per axis the figure lets change; the figure grows in place and its size is said beside it', async () => {
+    await mount('stretch')
+    await press('the preview mode', () => screenCheck.deep('button[mode]').find(b => b.title === 'figure.text.mode-preview-explained'))
+    await until('one figure, its sizes', () => screenCheck.deep('figure-preview')[0]?.scene?.root?.components?.length === 1 && !!screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('div[sizes] input'))
+    assert.equal(await read(() => screenCheck.deep('figure-preview')[0].shadowRoot.querySelectorAll('div[sizes] input').length), 3, 'each axis the figure declares a range for')
+    await read(() => {
+      const slider = screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('div[sizes] input')
+      slider.value = '6000'
+      slider.dispatchEvent(new Event('input'))
+      slider.dispatchEvent(new Event('change'))
+    })
+    await until('the figure 6 m wide', () => Math.round(screenCheck.deep('figure-preview')[0].scene.root.components[0].model.width) === 6000)
+    const said = await read(() => screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('div[sizes] p[said]').textContent.trim())
+    assert.ok(said.startsWith('6,000 × '), said)
+    const box = await read(() => { const m = screenCheck.deep('figure-preview')[0].scene.root.components[0].model; return m.left + m.width / 2 })
+    assert.equal(Math.round(box), await read(() => screenCheck.deep('figure-preview')[0].board.width / 2), 'grown about the board\'s centre')
+    await boardsUp()
+  })
+})
+
 describe('a part\'s size row: a rule\'s numbers only where a rule sets every side', () => {
   /* The size row of the part chosen, and how many of its cells a rule holds. */
   const sizeRow = () =>
@@ -809,11 +872,14 @@ describe('the fastening form says whether it changes the fastening the part has
     assert.equal(await revision(), before, 'nothing done until it is pressed')
   })
 
-  test('a part already fastened: no 「새로 붙이기」, no 붙이기 -- another target is taken at once, in one step', async () => {
+  test('a part already fastened: said in one line with 「바꾸기」; opened, no 「새로 붙이기」, no 붙이기 -- another target is taken at once, in one step', async () => {
     await mount('arm')
     await pressRow('forearm')
     await until('forearm chosen', () => screenCheck.editor().selected === 'forearm')
     await until('the sentence', () => screenCheck.deep('p[fasten-sentence]').length === 1)
+    assert.equal(await read(() => screenCheck.deep('figure-fasten-drawing').length + screenCheck.deep('select').filter(s => s.closest('section[fastening]')).length), 0, 'one line: no drawing, no target to choose')
+    await press('change the fastening', () => screenCheck.deep('button[change-fastening]')[0])
+    await until('the drawing', () => screenCheck.deep('figure-fasten-drawing').length === 1)
     assert.equal(await read(() => screenCheck.deep('p[fasten-mode]').length), 0, 'the one it has is not said to be new')
     assert.equal(await fastenButton(), 0, 'no 붙이기')
     await until('the fastening seen before it is done: its face lit on the canvas', () => !!screenCheck.deep('figure-canvas')[0].highlight)
@@ -852,6 +918,71 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     assert.deepEqual(asides, [true], 'the editor\'s side, and no other')
   })
 
+  /*
+   * The side's buttons (user 2026-10-16: 「버튼 박스도 과하게 사용되어서」): a word button stands as tall as the fields beside
+   * it, whichever panel drew it, and taking something back -- detach, clear, back to fixed, remove -- draws no box.
+   */
+  test('the side panel\'s word buttons are one height with its fields, and taking back draws no box', async () => {
+    await open('fig-stack', 'stack')
+    await pressTab(TAB('properties'))
+    const buttons = () =>
+      read(() => {
+        const all = []
+        const walk = root => {
+          for (const e of root.querySelectorAll('*')) {
+            if (e.shadowRoot) walk(e.shadowRoot)
+            if (e.localName === 'slot') for (const a of e.assignedElements({ flatten: true })) all.push(a, ...a.querySelectorAll('*')), a.shadowRoot && walk(a.shadowRoot)
+            all.push(e)
+          }
+        }
+        walk(screenCheck.shownPanel())
+        const field = [...new Set(all)].find(e => e.localName === 'input' && e.type !== 'checkbox' && e.type !== 'range' && e.getBoundingClientRect().height > 0)
+        return {
+          field: Math.round(field.getBoundingClientRect().height),
+          words: [...new Set(all)]
+            .filter(e => e.localName === 'button' && (e.hasAttribute('act') || e.hasAttribute('quiet') || e.parentElement?.hasAttribute('tools')))
+            .filter(e => e.getBoundingClientRect().height > 0)
+            .map(e => {
+              const s = getComputedStyle(e)
+              return { kind: e.hasAttribute('quiet') ? 'quiet' : 'boxed', height: Math.round(e.getBoundingClientRect().height), border: s.borderTopStyle === 'none' ? 0 : parseFloat(s.borderTopWidth) }
+            })
+        }
+      })
+    const seen = []
+    for (const part of [null, 'base', 'top']) {
+      if (part) await pressRow(part), await until(`${part} chosen`, id => screenCheck.editor().selected === id, part)
+      const { field, words } = await buttons()
+      assert.ok(words.length > 0, `${part ?? 'the figure'}: buttons to measure`)
+      for (const one of words) assert.equal(one.height, field, `${part ?? 'the figure'}: a ${one.kind} button as tall as a field`)
+      for (const one of words.filter(w => w.kind === 'quiet')) assert.equal(one.border, 0, `${part ?? 'the figure'}: taking back draws no box`)
+      seen.push(...words.map(w => w.kind))
+    }
+    assert.ok(seen.includes('quiet'), 'a taking-back button was measured')
+    /* The tests after this one read the figure the first opened. */
+    await open('fig-a')
+  })
+
+  /* First 15 minutes (2026-10-16): release was refused for a volume never declared, said only at the foot of the verdict tab. */
+  test('what blocks release is said beside 「발행」, with the way out at hand there', async () => {
+    const answer = blocked => read(blocked => product.answer('inspectFigureDraft', () => ({ __typename: 'FigureInspection', blocked, findings: blocked ? [alone.finding('occupancy-undeclared')] : [] })), blocked)
+    const bar = () => read(() => [...screenCheck.editor().shadowRoot.querySelectorAll('ox-canvas-bar > button[slot=commit]')].map(b => (b.hasAttribute('bar-overlay') ? 'history' : b.hasAttribute('release-blocked') ? 'blocked' : b.hasAttribute('publish') ? 'publish' : 'save')))
+    await answer(true)
+    await open('fig-block', 'two', 'probe-block')
+    await until('said beside 발행', () => !!screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[release-blocked]'))
+    assert.deepEqual(await bar(), ['history', 'blocked', 'publish', 'save'])
+    await press('what blocks release', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[release-blocked]'))
+    await until('the list under the bar', () => !!screenCheck.editor().shadowRoot.querySelector('div[release-blockers] li[finding]'))
+    assert.equal(await read(() => !!screenCheck.editor().session.revisionNow().asset.occupancy), false)
+    await answer(false)
+    await press('fit to the parts', () => screenCheck.editor().shadowRoot.querySelector('div[release-blockers] button[act]'))
+    await until('the space declared, in one step', () => !!screenCheck.editor().session.revisionNow().asset.occupancy)
+    await until('nothing blocks: the word is gone', () => !screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[release-blocked]'))
+    assert.deepEqual(await bar(), ['history', 'publish', 'save'])
+    await read(() => product.answer('inspectFigureDraft'))
+    await saved()
+    await open('fig-a')
+  })
+
   test('the figure\'s type is the first field of the figure panel, under its heading', async () => {
     await pressTab(TAB('properties'))
     const first = await read(() => {
@@ -870,14 +1001,21 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     assert.deepEqual(first, { heading: 'figure.label.group-figure', assigned: true, order: [true, true] })
   })
 
-  test('the verdict and history tabs show the page\'s verdict and release history', async () => {
-    for (const [tab, host] of [['verdict', 'figure-verdict'], ['history', 'figure-history-panel']]) {
-      await pressTab(TAB(tab))
-      const shown = await read(() => screenCheck.shownPanel().querySelector('slot')?.assignedElements().map(e => ({ tag: e.localName, height: Math.round(e.getBoundingClientRect().height) })))
-      assert.equal(shown?.length, 1, tab)
-      assert.equal(shown[0].tag, host)
-      assert.ok(shown[0].height > 0, `${host} is shown`)
-    }
+  test('the verdict tab shows the page\'s verdict, and the bar\'s history button its release history', async () => {
+    const assigned = within =>
+      read(w => (w ? screenCheck.editor().shadowRoot.querySelector(w) : screenCheck.shownPanel()).querySelector('slot')?.assignedElements().map(e => ({ tag: e.localName, height: Math.round(e.getBoundingClientRect().height) })), within)
+    await pressTab(TAB('verdict'))
+    let shown = await assigned(null)
+    assert.equal(shown?.length, 1, 'verdict')
+    assert.equal(shown[0].tag, 'figure-verdict')
+    assert.ok(shown[0].height > 0, 'figure-verdict is shown')
+    await openOverlay('history')
+    shown = await assigned('div[bar-overlay-panel=history]')
+    assert.equal(shown?.length, 1, 'history')
+    assert.equal(shown[0].tag, 'figure-history-panel')
+    assert.ok(shown[0].height > 0, 'figure-history-panel is shown')
+    /* Closed again: it lies over the side, and the checks after this press there. */
+    await press('the history button', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[bar-overlay=history]'))
   })
 
   test('the verdict tab\'s count is the report\'s, measured by the verdict', async () => {
@@ -946,7 +1084,7 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     await read(finding => product.answer('inspectFigure', () => ({ __typename: 'FigureInspection', blocked: true, findings: [finding] })), await read(() => alone.finding('occupancy-undeclared')))
     try {
       await open('fig-empty', 'empty')
-      await pressTab(TAB('history'))
+      await openOverlay('history')
       await until('offered', () => !!screenCheck.deep('figure-history-panel')[0]?.shadowRoot?.querySelector('button[fit-base]'))
       await press('fit to the parts', () => screenCheck.deep('figure-history-panel')[0].shadowRoot.querySelector('button[fit-base]'))
       await until('said', () => screenCheck.deep('p[fit-error]')[0]?.textContent.trim() === 'figure.text.fit-needs-parts')
@@ -956,8 +1094,8 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     }
   })
 
-  test('the view set in the tab holds for the next figure opened: its board is stood up with it', async () => {
-    await pressTab(TAB('view'))
+  test('the view set in the bar\'s menu holds for the next figure opened: its board is stood up with it', async () => {
+    await openOverlay('view')
     const colour = await element('the sky colour', () => screenCheck.setting('figure.label.sky-color').querySelector('input[type=color]'))
     /* A colour picker is the browser's own window; its value is set as the picker sets it, and changed. */
     await colour.evaluate(input => {
@@ -968,9 +1106,11 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     try {
       assert.equal(await read(() => screenCheck.deep('figure-canvas')[0].scene.root.state.skyColor), '#336699', 'the new board\'s sky')
     } finally {
-      await pressTab(TAB('view'))
+      await openOverlay('view')
       await press('reset the view', () => screenCheck.deep('figure-settings')[0].shadowRoot.querySelector('button[reset]'))
       await until('the view as it was', () => screenCheck.deep('figure-canvas')[0].scene.root.state.skyColor === '#7c7c7c')
+      /* Closed again: it lies over the side, and the next check presses there. */
+      await press('the view button', () => screenCheck.editor().shadowRoot.querySelector('ox-canvas-bar button[bar-overlay=view]'))
     }
   })
 
@@ -978,6 +1118,8 @@ describe('the modeller page: the editor with the page\'s figure panel, verdict a
     await open('fig-p', 'arm-clip')
     await pressRow('upper-arm')
     await until('upper-arm chosen', () => screenCheck.editor().selected === 'upper-arm')
+    /* The part's panel fits the side now; its places opened make it long enough to scroll. */
+    await press('the capability fold', () => screenCheck.shownPanel().querySelector('section[capability] > details:not([open]) > summary'))
     const at = await read(() => {
       const r = screenCheck.shownPanel().getBoundingClientRect()
       return { x: r.left + r.width / 2, y: r.top + r.height / 2 }

package/test/browser/section-page.js

@@ -3,6 +3,7 @@
  * editor, the section panel, the inside's drawing, the fastening drawing and the face choice are tried on, and what the
  * check reads of them. Only reading here: every change the check makes goes through the mouse and the keyboard.
  */
+import './more-open.js'
 import './modeller-page.js'
 import { html, render } from 'lit'
 import { setOpenPopupImplementation } from '@operato/popup'

package/test/browser/section.check.mjs

@@ -524,10 +524,13 @@ describe('the inside\'s drawing in the 단면 group', () => {
 describe('the fastening drawing in the fastening form', () => {
   const labels = () => read(() => probe.fastenForm().map(s => s.label))
   const target = () => read(() => probe.fastenForm().find(s => s.label === 'figure.label.target-part'))
+  /* A fastening the part has is said in one line; 「바꾸기」 opens the drawing (chief architect 2026-10-16). */
+  const change = () => press('button[change-fastening]')
 
   test('the part\'s own face and the facing are not asked: the target, its face and how are drawn', async () => {
     await mount('arm')
     await pick('forearm')
+    await change()
     const asked = await labels()
     assert.ok(asked.includes('figure.label.target-part'))
     assert.ok(!asked.includes('figure.label.my-face') && !asked.includes('figure.label.facing'), `asked: ${asked}`)
@@ -570,6 +573,7 @@ describe('the fastening drawing in the fastening form', () => {
   test('fastened to the plane: the plane is named by the placement, chosen, and set on only', async () => {
     await mount('rollers')
     await pick('bed')
+    await change()
     const list = await target()
     assert.equal(list.value, '__plane')
     assert.equal(list.options.find(o => o.value === '__plane').text, 'figure.label.resize-place-floor')
@@ -578,8 +582,10 @@ describe('the fastening drawing in the fastening form', () => {
 
   test('a part that turns in place may have its centre on the face; a part that does not, not', async () => {
     await pick('roller')
+    await change()
     assert.deepEqual((await read(() => probe.fastenDrawing())).modes, ['meet', 'flush', 'centre'])
     await pick('mark')
+    await change()
     assert.deepEqual((await read(() => probe.fastenDrawing())).modes, ['meet', 'flush'])
   })
 

package/test/command-preview.test.ts

@@ -110,11 +110,11 @@ test('a row is seen before it is made, read as figure-model draws it -- and said
   assert.equal(rowBlockOf(a, 'roller'), undefined)
   const seen = previewFigureCommand(a, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 } as never)
   const held: HeldPreview = { context: 'c', revision: 0, key: 'k', geometry: seen.geometry, moves: seen.moves, added: seen.added, row: figureRowOf(seen.asset, 'roller') }
-  assert.deepEqual(previewWordsOf(held, 'roller', say), ['roller 10개 · X 방향 · pitch 200 mm (중심 간격)', '가운데 정렬 · 양 끝에 70 mm씩 남음'])
+  assert.deepEqual(previewWordsOf(held, 'roller', say), ['roller 10개 · X 방향 · 피치 200 mm', '가운데 정렬 · 양 끝에 70 mm씩 남음'])
   assert.equal(ghostPartsOf(held).length, 10, 'the copies it would draw, translucent')
   /* A set count is spread over the length: said as drawn, 970 apart, nothing left at the ends. */
   const three = figureRowOf(applyFigureAuthoring(a, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 1, count: 3 }), 'roller')
-  assert.deepEqual(rowWordsOf(three, say), ['roller 3개 · X 방향 · pitch 970 mm (중심 간격)', '가운데 정렬 · 양 끝에 0 mm씩 남음'])
+  assert.deepEqual(rowWordsOf(three, say), ['roller 3개 · X 방향 · 피치 970 mm', '가운데 정렬 · 양 끝에 0 mm씩 남음'])
   for (const lang of ['en', 'ja', 'ko', 'ms', 'zh', 'es']) {
     const t = JSON.parse(read(`../translations/${lang}.json`))
     for (const key of ['row-count-pitch', 'row-count-uneven', 'row-ends-centred', 'row-ends', 'row-ends-unknown', 'row-companions', 'row-count-spreads', 'row-blocked-unfastened', 'row-blocked-on-plane', 'row-blocked-holds-parts'])

package/test/fasten-geometry.test.ts

@@ -78,3 +78,18 @@ test('면은 서 있는 대로 보인다: 앞면은 X 가로·Y 위로, 옆면
   assert.deepEqual(screenOf(['y', 'z']), { h: 'z', v: 'y', sign: { x: 1, y: -1, z: 1 } })
   assert.deepEqual(screenOf(['x', 'z']), { h: 'x', v: 'z', sign: { x: 1, y: 1, z: 1 } })
 })
+
+test('the drawing\'s two names do not lie over each other (user 2026-10-16: 「roller」 on its bar, the face\'s name cut by it)', async () => {
+  const { fastenLabelsOf } = await import('../client/modeller/fasten-geometry.ts')
+  const face = { x: 20, y: 60, w: 300, h: 90 }
+  /* A thin roller across the face: its name goes under it, the face's above the face. */
+  const thin = fastenLabelsOf(face, { x: 165, y: 63, w: 6, h: 84 }, 'roller', 180)
+  assert.deepEqual(thin.face, { x: 20, y: 55 })
+  assert.equal(thin.part.inside, false)
+  assert.ok(thin.part.y > 63 + 84 || thin.part.y < 63, 'outside the part')
+  /* A wide block: its name in it. */
+  const wide = fastenLabelsOf(face, { x: 120, y: 80, w: 100, h: 40 }, 'lid', 180)
+  assert.deepEqual(wide.part, { x: 170, y: 104, inside: true })
+  /* A face that fills the drawing: its name inside its top edge. */
+  assert.deepEqual(fastenLabelsOf({ x: 4, y: 4, w: 300, h: 170 }, { x: 100, y: 60, w: 100, h: 40 }, 'lid', 180).face, { x: 8, y: 18 })
+})

package/test/fields.test.ts

@@ -70,8 +70,10 @@ test('pitch 는 한 곳에서 하나의 값이고, 늘 set-repeat 로 바꿔 최
   /* Offered once and set by the row in one step: the browser check's (test/browser/parts.check.mjs). */
   for (const lang of ['ko', 'en', 'ja', 'zh', 'ms', 'es']) {
     const table = JSON.parse(readFileSync(fileURLToPath(new URL(`../translations/${lang}.json`, import.meta.url)), 'utf8'))
-    /* The term stays pitch; what it measures is said beside it (ADR-0097 §5.5: centre to centre). */
-    assert.ok(table['figure.label.repeat-gap'].startsWith('pitch') && table['figure.label.repeat-gap'].length > 'pitch'.length, lang)
+    /* The term stays pitch -- in Korean written as the trade writes it, 피치 (user 2026-10-16: no English names on the
+       panel); what it measures is said beside it (ADR-0097 §5.5: centre to centre). */
+    const term = lang === 'ko' ? '피치' : 'pitch'
+    assert.ok(table['figure.label.repeat-gap'].startsWith(term) && table['figure.label.repeat-gap'].length > term.length, lang)
     assert.ok(['{length}', '{count}', '{longest}', '{limit}'].every(k => table['figure.text.repeat-what-pitch-gives']?.includes(k)), lang)
   }
 })

package/test/figure-assistant-surface.test.ts

@@ -43,6 +43,44 @@ test('the dock applies a proposal through the page, on the version the model saw
   assert.equal(create.applied, undefined)
 })
 
+/*
+  The dock reads the draft when the person sends (figure audit 2026-10-16 N5). A save in flight is no edit: reading the
+  draft then was refused with the edit guard's Korean "save first" line, which the dock showed as the turn's error.
+*/
+test('the draft is read while a save is in flight', async () => {
+  const source = serializeFigureAsset(addFigureBox(createFigureAsset('A'), { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } }))
+  let finish: (value: { id: string; source: string }) => void = () => {}
+  const session = createFigureProductSession({
+    load: async (id: string) => ({ id, source }),
+    save: (q: { id?: string; source: string }) => new Promise(resolve => (finish = () => resolve({ id: q.id ?? 'a', source: q.source })))
+  })
+  await session.open('a')
+  session.command({ kind: 'rename', name: 'B' } as never)
+  const saving = session.save()
+  assert.equal(session.read().saving, true)
+  assert.equal(JSON.parse(session.source()).name, 'B')
+  finish({ id: 'a', source })
+  await saving
+})
+
+/*
+  A revision is for the figure the model read, and a page with another figure open leaves it untaken (figure audit
+  2026-10-16 N3): the handler then says it needs that figure open. The version alone did not tell them apart -- two
+  figures opened in two page loads were both at their first context and revision 0.
+*/
+test('a revision made for another figure is left untaken, whatever version it names', async () => {
+  const source = serializeFigureAsset(addFigureBox(createFigureAsset('A'), { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } }))
+  const session = createFigureProductSession({ load: async (id: string) => ({ id, source }), save: async (q: { id?: string; source: string }) => ({ id: q.id ?? 'a', source: q.source }) })
+  await session.open('a')
+  const now = session.read()
+  const other: FigureApplyDetail = { key: K1, steps: lid, create: false, figureId: 'b', context: now.context, revision: now.revision }
+  assert.equal(takeFigureOffer(session, other, { onSavedFigure: true, say }), false)
+  assert.equal(other.applied, undefined)
+  assert.equal(session.read().revision, now.revision)
+  const mine: FigureApplyDetail = { key: K1, steps: lid, create: false, figureId: 'a', context: now.context, revision: now.revision }
+  assert.equal(takeFigureOffer(session, mine, { onSavedFigure: true, say }), true)
+})
+
 /*
   A figure not saved yet is a subject too (ADR-0061 decision 3): its conversation is anchored on the creation id the
   first save inserts the row under, so the anchor is the same before and after that save. Taking a new figure's

package/test/first-minute.test.ts

@@ -2,7 +2,7 @@ import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { addFigureBox, applyFigureAuthoring, applyFigureProposal, createFigureAsset, planFigureResize, proposeFigureOccupancy } from '@hatiolab/figure-model'
-import { partSummaryOf } from '../client/modeller/links.js'
+import { followWordsOf, partSummaryOf } from '../client/modeller/links.js'
 
 /*
  * ADR-0097 B, the first minute (designer 2026-09-27, U04 · U05 · U09 · U11): a new figure asks what to start with; a
@@ -22,7 +22,10 @@ test('a selected part at the head: its kind, and what its size follows only when
   /* As usual -- a size of its own, loose: nothing but what it is. */
   assert.deepEqual(partSummaryOf(a, 'box', say), { kind: 'figure.label.primitive-cube', size: '' })
   const only = applyFigureProposal(a, planFigureResize(a, { part: 'box', axes: ['x'] }).steps)
-  assert.equal(partSummaryOf(only, 'box', sayKo).size, '너비는 모델 크기를 따라 바뀝니다.')
+  assert.equal(partSummaryOf(only, 'box', sayKo).size, '너비는 도형 크기를 따라 바뀝니다.')
+  /* Every side following the figure's own: one sentence, not one per side (user 2026-10-16). */
+  const every = applyFigureProposal(a, planFigureResize(a, { part: 'box', axes: ['x', 'y', 'z'] }).steps)
+  assert.equal(partSummaryOf(every, 'box', sayKo).size, '너비 · 높이 · 깊이는 도형 크기를 따라 바뀝니다.')
   /* Another part's measure, said by name -- not 「규칙을 따름」. */
   let two = addFigureBox(a, { id: 'bed', size: { x: 800, y: 50, z: 400 }, position: { x: 0, y: 25, z: 0 } })
   two = applyFigureAuthoring(two, { kind: 'link-dimension', part: 'box', axis: 'y', source: { of: 'part', part: 'bed', axis: 'x' } } as never)
@@ -55,3 +58,13 @@ test('the fastening form says whether it edits the current relation or fastens a
   assert.equal(ko['figure.text.fasten-new'], '새로 붙이기')
   assert.equal(ko['figure.button.fasten-update'], undefined)
 })
+
+test('a measure that follows something says what, where the row once said 「다른 규칙에 연결됨」 (user 2026-10-16)', () => {
+  const ko = JSON.parse(read('../translations/ko.json')) as Record<string, string>
+  const sayKo = (key: string, params: Record<string, string> = {}) => Object.entries(params).reduce((t, [k, v]) => t.split(`{${k}}`).join(v), ko[key] ?? key)
+  assert.equal(followWordsOf({ of: 'part', part: 'bed', axis: 'x', times: 1 } as never, sayKo), 'bed의 X')
+  assert.equal(followWordsOf({ of: 'instance', axis: 'y', times: 0.5 } as never, sayKo), '도형 Y 크기에 비례')
+  assert.equal(followWordsOf({ of: 'instance', axis: 'z', times: 1 } as never, sayKo), '도형 Z 크기와 같게')
+  assert.ok(!Object.values(ko).some(v => /\((floor|ceiling|center|wall|inverted|space)\)/.test(v)), 'no placement keeps its English name in brackets')
+  assert.ok(!/AGV_LIFTER|대문자/.test(ko['figure.text.type-name-will-not-release']!), 'the identifier rule is the format\'s: lower case and hyphens')
+})

package/test/layout.test.ts

@@ -32,7 +32,7 @@ test('맞추기는 글자 단추로 — 옮기는 넷(가운데 X·Z, 면에 대
   const ko = wordsOf('ko') as Record<string, string>
   assert.deepEqual(
     ['center-x', 'center-z', 'align-to-floor', 'snap', 'mirror-x'].map(k => ko[`figure.button.${k}`]),
-    ['X 가운데로', 'Z 가운데로', '바닥에 내려놓기', '눈금에 맞추기', 'X 반대편에']
+    ['X 가운데로', 'Z 가운데로', '바닥에 내려놓기', '눈금에 정렬', 'X 반대편에']
   )
   assert.ok(!ko['figure.text.center-on-x']!.includes('기준 상자'), 'says what the centre is')
 })

package/test/preview-size.test.ts

@@ -0,0 +1,33 @@
+/*
+ * The preview's one figure, stretched (first 15 minutes, 2026-10-16): the author drags the width and reads what the
+ * figure is there -- its size and how many rollers its row holds -- beside the figure that grew.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, createFigureAsset, type FigureAsset } from '@hatiolab/figure-model'
+
+import { previewSizeWordsOf, rowCountsAt } from '../client/modeller/preview-size.ts'
+
+/** A 2 m frame that follows the figure's width, with a roller every 200 mm along its top. */
+function conveyor(): FigureAsset {
+  let asset = addFigureBox(createFigureAsset('Conveyor'), { id: 'frame', size: { x: 2000, y: 100, z: 600 }, position: { x: 0, y: 50, z: 0 } })
+  asset = addFigurePrimitive(asset, { id: 'roller', kind: 'cylinder', dimensions: { radius: 30, length: 560 }, position: { x: 0, y: 0, z: 0 }, rotation: { x: 90, y: 0, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'roller', face: 'bottom', to: { part: 'frame', face: 'top' } })
+  asset = applyFigureAuthoring(asset, { kind: 'follow-size', part: 'frame', axes: ['x'] })
+  return applyFigureAuthoring(asset, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 })
+}
+
+test('a row\'s count at each size tried is figure-model\'s reading of what it draws there', () => {
+  const asset = conveyor()
+  const at = (x: number) => rowCountsAt(asset, { x, y: 160, z: 600 })
+  assert.deepEqual(at(2000), [{ part: 'roller', count: 10 }])
+  assert.deepEqual(at(6000), [{ part: 'roller', count: 30 }], 'three times as long, three times as many')
+  assert.deepEqual(rowCountsAt(addFigureBox(createFigureAsset('Plain'), { id: 'box', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } }), { x: 100, y: 100, z: 100 }), [], 'no row, nothing counted')
+})
+
+test('the line beside the figure: its size in millimetres, then each row\'s count', () => {
+  const ko = JSON.parse(readFileSync(new URL('../translations/ko.json', import.meta.url), 'utf8')) as Record<string, string>
+  const say = (key: string, params: Record<string, string> = {}) => Object.entries(params).reduce((t, [k, v]) => t.split(`{${k}}`).join(v), ko[key] ?? key)
+  assert.equal(previewSizeWordsOf(conveyor(), { x: 6000, y: 160, z: 600 }, say), '6,000 × 160 × 600 mm · roller 30개')
+})

package/test/refusals.test.ts

@@ -149,7 +149,7 @@ test('배치를 바꿀 수 없는 까닭 — 평면에 붙은 부품과 새 평
   })
   const refused = refusalOf(() => act(a, { kind: 'declare-occupancy', proposal: fm.proposeFigureOccupancy(a), placement: 'wall' }))
   const said = placementRefusalOf(refused, say)!
-  assert.ok(said.includes('post (bottom)') && said.includes('벽 기반') && said.includes('back'), said)
+  assert.ok(said.includes('post (bottom)') && said.includes('벽') && said.includes('back'), said)
   assert.equal(editRefusalOf(refused, say), said, '편집 거절의 말도 같다')
   assert.equal(placementRefusalOf(refusalOf(() => act(box(), declaring({ min: 0, max: 4000 }))), say), null)
   /* The placement list sends its command through the page: said there in words, and the list back on the placement it has (product-page.check.mjs). */

package/test/resize-with-placement.test.ts

@@ -94,7 +94,7 @@ test('fresh, width only, and all set back to fixed are three different answers',
   assert.deepEqual(resizeAxesOf(following, 'box'), { axes: ['y'], basis: 'chosen' })
   assert.deepEqual(resizeAxesOf(following, 'box', ['x']), { axes: ['x', 'y'], basis: 'chosen' })
   const ko = JSON.parse(readFileSync(new URL('../translations/ko.json', import.meta.url), 'utf-8'))
-  assert.equal(ko['figure.button.follow-size'], '모델 크기에 맞추기')
+  assert.equal(ko['figure.button.follow-size'], '도형 크기에 맞추기')
 })
 
 test('a part off the floor is not moved by choosing its size response', () => {

package/test/stage-model.test.ts

@@ -9,7 +9,7 @@ import assert from 'node:assert/strict'
 import { addFigureBox, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
 
 import { drawableFigureParts } from '../client/modeller/renderer.ts'
-import { boardFor } from '../client/modeller/stage-model.ts'
+import { boardFor, needsRefit } from '../client/modeller/stage-model.ts'
 
 const partsOf = (height: number) =>
   drawableFigureParts(
@@ -23,3 +23,13 @@ test('the board keeps the height it had: a part that shrinks back does not stand
   assert.equal(after.depth, tall.depth)
   assert.ok(boardFor(partsOf(3000), tall).depth > tall.depth, 'it still grows')
 })
+
+test('a size typed far from the view brings the camera to it; a nudge does not (first 15 minutes, 2026-10-16)', () => {
+  const parts = (x: number, y: number, z: number) =>
+    drawableFigureParts(compileFigureAsset(addFigureBox(createFigureAsset('B'), { id: 'box', size: { x, y, z }, position: { x: 0, y: y / 2, z: 0 } })).evaluate().geometry)
+  const fitted = boardFor(parts(100, 100, 100))
+  assert.equal(needsRefit(fitted, boardFor(parts(3000, 800, 600))), true, 'a 100 mm box typed to 3 m')
+  assert.equal(needsRefit(fitted, boardFor(parts(120, 100, 100))), false, 'a little wider stays in view')
+  assert.equal(needsRefit(boardFor(parts(3000, 800, 600)), boardFor(parts(100, 100, 100))), true, 'shrunk far: fitted again')
+  assert.equal(needsRefit(undefined, boardFor(parts(3000, 800, 600))), false, 'never fitted: the first standing fits it')
+})

package/test/verdict.test.ts

@@ -92,3 +92,10 @@ test('감춘 부품도 「부품에 맞추기」가 잴 수 있는 부품이다'
   assert.equal(verdictMeasureOf(asset).bodies, 2, '그려지는 하나와 감춘 하나')
   assert.equal(verdictMeasureOf(createFigureAsset('Empty')).bodies, 0, '부품이 없으면 잴 것이 없다')
 })
+
+test('a finding\'s affected parts are the figure\'s part names, not the format\'s words (user 2026-10-16: 「occupancy · roller-row-1-roller」)', async () => {
+  const { affectedPartsOf } = await import('../client/modeller/affected-parts.ts')
+  assert.deepEqual(affectedPartsOf('occupancy · roller-row-1-roller', ['box', 'roller-row-1-roller']), ['roller-row-1-roller'])
+  assert.deepEqual(affectedPartsOf('occupancy', ['box']), [], 'nothing of the figure: no line of affected parts')
+  assert.deepEqual(affectedPartsOf('box · lid', ['box', 'lid']), ['box', 'lid'])
+})