@things-factory/figure-ui 10.1.128 → 10.1.141

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.128",
+  "version": "10.1.141",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -17,8 +17,8 @@
   },
   "scripts": {
     "build": "npm run build:server && npm run build:client",
-    "test": "node --import ./test/resolve-ts-siblings.mjs --test --test-force-exit test/*.test.ts",
-    "test:browser": "node --test --test-force-exit test/browser/modeller.check.mjs",
+    "test": "FIGURE_FREEZE_COMPILED=1 node --import ./test/resolve-ts-siblings.mjs --test --test-force-exit test/*.test.ts",
+    "test:browser": "node --test --test-force-exit test/browser/modeller.check.mjs test/browser/modeller-revision.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.4.1",
+    "@hatiolab/figure-model": "^0.5.0",
     "@hatiolab/things-scene": "^10.1.74",
     "@material/web": "^2.0.0",
     "@operato/data-grist": "^10.0.0",
@@ -40,9 +40,9 @@
     "@operato/shell": "^10.0.0",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.0.0",
-    "@things-factory/ai-assistant": "^10.1.127",
-    "@things-factory/figure-service": "^10.1.123",
+    "@things-factory/ai-assistant": "^10.1.141",
+    "@things-factory/figure-service": "^10.1.141",
     "three": "^0.185.1"
   },
-  "gitHead": "2df4c35fbc0eb3dc7bc24882b2d94cdd9c65aa63"
+  "gitHead": "931866a13b9149be42a294f207e245aba11e57f8"
 }

package/test/align.test.ts

@@ -13,6 +13,7 @@ import { addFigureBox, createFigureAsset, editFigurePart } from '@hatiolab/figur
 
 import { alignChanges, boxOf, canMirror, gridStepOf, mirrorChanges, niceStep } from '../client/modeller/align.ts'
 import { gizmoReachOf } from '../client/modeller/gizmo.ts'
+import { revisionOf } from './revision-of.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 const probe = (at = { x: 130, y: 90, z: -70 }, rotation?: { x: number; y: number; z: number }) => {
@@ -26,11 +27,12 @@ const applied = (asset: ReturnType<typeof probe>, changes: ReturnType<typeof ali
   return next
 }
 const run = (asset: ReturnType<typeof probe>, tool: Parameters<typeof alignChanges>[3]) =>
-  applied(asset, alignChanges(asset, 'body', gizmoReachOf(asset as never, 'body'), tool))
+  applied(asset, alignChanges(revisionOf(asset), 'body', gizmoReachOf(asset as never, 'body'), tool))
+const box = (asset: ReturnType<typeof probe>, part: string) => boxOf(revisionOf(asset), part)
 
 test('가운데 X · Z 는 부품 상자의 가운데를 0 에 둔다', () => {
-  assert.equal(Math.round(boxOf(run(probe(), 'centre-x'), 'body')!.centre.x), 0)
-  assert.equal(Math.round(boxOf(run(probe(), 'centre-z'), 'body')!.centre.z), 0)
+  assert.equal(Math.round(box(run(probe(), 'centre-x'), 'body')!.centre.x), 0)
+  assert.equal(Math.round(box(run(probe(), 'centre-z'), 'body')!.centre.z), 0)
 })
 
 /*
@@ -40,13 +42,13 @@ test('가운데 X · Z 는 부품 상자의 가운데를 0 에 둔다', () => {
 test('기준면 맞추기 — 배치를 따르고, 한 번 옮길 뿐 붙이지 않는다', async () => {
   const { figurePlaneAlignChanges, applyFigureAuthoring } = await import('@hatiolab/figure-model')
   const floor = probe()
-  const flat = boxOf(applied(floor, figurePlaneAlignChanges(floor, 'body').changes), 'body')!
+  const flat = box(applied(floor, figurePlaneAlignChanges(floor, 'body').changes), 'body')!
   assert.equal(Math.round(flat.centre.y - flat.extent.y / 2), 0, '바닥: 아랫면이 y 0')
   const turned = probe({ x: 0, y: 300, z: 0 }, { x: 0, y: 0, z: 45 })
-  const landed = boxOf(applied(turned, figurePlaneAlignChanges(turned, 'body').changes), 'body')!
+  const landed = box(applied(turned, figurePlaneAlignChanges(turned, 'body').changes), 'body')!
   assert.ok(Math.abs(landed.centre.y - landed.extent.y / 2) <= 1, `45° 돈 부품의 모서리가 바닥에 닿는다 (${landed.centre.y - landed.extent.y / 2})`)
   const hung = applyFigureAuthoring(probe({ x: 0, y: -300, z: 0 }), { kind: 'set-placement', placement: 'ceiling' })
-  const top = boxOf(applied(hung, figurePlaneAlignChanges(hung, 'body').changes), 'body')!
+  const top = box(applied(hung, figurePlaneAlignChanges(hung, 'body').changes), 'body')!
   assert.equal(Math.round(top.centre.y + top.extent.y / 2), 0, '천장: 윗면이 y 0')
   const editor = read('../client/modeller/editor.ts')
   assert.ok(editor.includes('const { changes, contact, refusal } = figurePlaneAlignChanges(asset, this.selected)'))
@@ -55,7 +57,7 @@ test('기준면 맞추기 — 배치를 따르고, 한 번 옮길 뿐 붙이지
 
 test('눈금은 1 · 2 · 5 간격으로 자리와 크기를 맞추고, 크기를 0 으로 만들지 않는다', () => {
   const asset = probe({ x: 133, y: 47, z: -71 })
-  const step = gridStepOf(asset)
+  const step = gridStepOf(revisionOf(asset))
   assert.equal(step, 50, '가장 긴 폭 200 을 다섯 칸으로 — 40 이 아니라 50')
   const snapped = run(asset, 'snap')
   assert.deepEqual(['x', 'y', 'z'].map(a => snapped.designInputs[`body.position.${a}`]), [150, 50, -50])
@@ -65,14 +67,14 @@ test('눈금은 1 · 2 · 5 간격으로 자리와 크기를 맞추고, 크기
 test('대칭은 복제본을 가운데 면 반대편 같은 거리에 둔다 · 가운데에 있으면 내지 않는다', () => {
   const asset = probe()
   const copied = editFigurePart(asset, { kind: 'duplicate-part', target: 'body' })
-  const mirrored = applied(copied, mirrorChanges(copied, 'body', 'body-copy', 'x'))
-  assert.equal(Math.round(boxOf(mirrored, 'body-copy')!.centre.x), -Math.round(boxOf(mirrored, 'body')!.centre.x))
-  assert.equal(canMirror(probe({ x: 0, y: 50, z: 0 }) as never, 'body', 'x', gizmoReachOf(probe() as never, 'body')), false)
+  const mirrored = applied(copied, mirrorChanges(revisionOf(copied), 'body', 'body-copy', '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)
 })
 
 test('붙인 부품처럼 옮길 수 없는 것은 맞추기도 없다', () => {
-  assert.deepEqual(alignChanges(probe(), 'body', { translate: false, rotate: false, scale: false }, 'centre-x'), [])
-  assert.match(read('../client/modeller/editor.ts'), /if \(!this\.selected \|\| !reach\.translate\) return null/)
+  assert.deepEqual(alignChanges(revisionOf(probe()), 'body', { translate: false, rotate: false, scale: false }, 'centre-x'), [])
+  assert.match(read('../client/modeller/editor.ts'), /if \(!this\.selected \|\| !reach\.translate \|\| !shown\) return null/)
 })
 
 test('the grid step reads well -- 27 or 33 would make coordinates unreadable -- and is never 0', () => {

package/test/browser/modeller-page.js

@@ -6,7 +6,7 @@
 import 'figure-ui-client/modeller/editor.js'
 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, parseFigureAsset, robotArmFigure, serializeFigureAsset } from '@hatiolab/figure-model'
+import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, createFigureAsset, figureWork, robotArmFigure, serializeFigureAsset } from '@hatiolab/figure-model'
 
 const PALETTE = {
   'palette.dark': '#2b2b2b',
@@ -234,6 +234,49 @@ window.probe = {
   fan() {
     return canvas().scene.root.components.some(c => c.state.name === '__joint-fan')
   },
+  trace() {
+    const stacks = (window.__stacks = [])
+    for (const key of ['compiles', 'evaluations']) {
+      let v = figureWork[key]
+      Object.defineProperty(figureWork, key, { configurable: true, get: () => v, set: n => { v = n; stacks.push(key + ' ' + new Error().stack.split('\n').slice(2, 9).map(l => l.trim().replace(/\(http.*?page\.js/, '(').replace(/^at /, '')).join(' < ')) } })
+    }
+  },
+  traced() {
+    return window.__stacks
+  },
+  /** Whole-figure work done so far (figure-model's count): compiles and evaluations. */
+  work() {
+    return { ...figureWork }
+  },
+  /**
+   * 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.
+   */
+  markMiddles() {
+    const preview = deep('figure-preview')[0]
+    for (const one of [canvas(), canvas()?.scene, preview, preview?.scene]) if (one) one.__mark = true
+  },
+  middles() {
+    const preview = deep('figure-preview')[0]
+    const area = deep('div[middle]')[0]
+    const size = canvas()?.scene?.root?._threeCapability?.rendererManager?.domElement
+    return {
+      canvas: !!canvas()?.__mark,
+      canvasScene: !!canvas()?.scene?.__mark,
+      editHidden: !!area?.hidden && getComputedStyle(area).display === 'none',
+      editSize: size ? [size.width, size.height] : null,
+      preview: preview ? { marked: !!preview.__mark, scene: !!preview.scene, sceneMarked: !!preview.scene?.__mark, hidden: preview.hidden, stale: preview.stale } : null
+    }
+  },
+  /** Whether the edit canvas gives the card a picture now. */
+  async editPicture() {
+    return !!(await canvas().snapshot())
+  },
+  /** The page point of the edit / preview switch. */
+  modeButton(mode) {
+    const b = deep('button[mode]').find(b => b.title === `figure.text.mode-${mode}-explained`)
+    return b ? centreOf(b) : null
+  },
   /** The drawn position of a part's component, as the canvas shows it now. */
   drawn(id) {
     const c = canvas().scene.root.components.find(c => c.state.name === id)
@@ -251,16 +294,21 @@ window.harness = {
     await session.open('probe')
     const editor = document.createElement('figure-editor')
     editor.session = session
-    /* The cost line as the modeller page gives it: the maturity report of what is authored (figure-verdict). */
+    /* The cost line as the modeller page gives it: the maturity report of the version on screen (figure-verdict). */
     const report = () => {
       try {
-        return budgetOf(figureReportOf(parseFigureAsset(session.source())))
+        return budgetOf(figureReportOf(session.revisionNow().asset))
       } catch {
         return undefined
       }
     }
     editor.budget = report()
-    editor.addEventListener('changed', () => (editor.budget = report()))
+    /* Measured once the figure has settled, as the page's verdict measures it. */
+    let settle
+    editor.addEventListener('changed', () => {
+      clearTimeout(settle)
+      settle = setTimeout(() => (editor.budget = report()), 200)
+    })
     editor.templates = templates
     editor.guideOf = async name => guides[name] ?? ''
     editor.revision = 0

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

@@ -0,0 +1,144 @@
+/*
+ * The modeller in a real browser, counted: what a selection, a value typed and going to the preview and back cost in
+ * whole-figure work (figure-model's compiles and evaluations), and that the two middles -- the edit canvas and the
+ * preview -- stay standing rather than being made again. A count is the same on every machine; the milliseconds are
+ * measured on the app (figure-model docs/modeller-interaction-performance-2026-10-07.md).
+ *
+ * Run:  npm run test:browser
+ *       FIGURE_MODEL=<a figure-model build> npm run test:browser   (a figure-model not published yet)
+ */
+import { test, describe, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { buildPage } from './build.mjs'
+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()))
+
+let opened
+before(async () => {
+  opened = await openPage(await buildPage())
+})
+after(async () => {
+  await opened?.close()
+})
+
+const page = () => opened.page
+const read = (fn, ...args) => page().evaluate(fn, ...args)
+const work = () => read(() => probe.work())
+const since = (a, b) => ({ compiles: b.compiles - a.compiles, evaluations: b.evaluations - a.evaluations })
+
+/* Nothing still being worked out from before: the count stands still for half a second. */
+async function settled() {
+  for (let last = await work(), i = 0; i < 20; i++) {
+    await sleep(500)
+    const now = await work()
+    if (now.compiles === last.compiles && now.evaluations === last.evaluations) return
+    last = now
+  }
+  assert.fail('the modeller kept working')
+}
+async function mount(kind) {
+  await read(kind => harness.mount(kind, null), kind)
+  await sleep(2500)
+  await settled()
+}
+async function click(point) {
+  assert.ok(point, 'nothing on the page to click')
+  await page().mouse.click(point.x, point.y)
+}
+async function mode(which) {
+  await click(await read(m => probe.modeButton(m), which))
+  await sleep(1500)
+}
+
+describe('work counted on the robot arm', () => {
+  before(() => mount('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())
+    assert.equal((await read(() => probe.state())).selected, part)
+    assert.deepEqual(spent, { compiles: 0, evaluations: 2 })
+    /*
+      Once the screen rests, two commands are seen on copies (ADR-0097 §5.5): taking the part off (its step without the
+      joint, and its result) and the fastening the form opens on (its result). Each compiles only what it makes; the
+      figure as it stands is not compiled again.
+    */
+    await settled()
+    const rested = since(before, await work())
+    assert.ok(rested.compiles <= 3, JSON.stringify(rested))
+  })
+
+  /* The edit and its read are the kernel's two compiles (its version's asset is the edit's own); then the part's motion ends. */
+  test('a value typed into its field: the edit and its read, and nothing else while it is drawn', async () => {
+    const field = await read(() => {
+      const deep = (root = document) => [...root.querySelectorAll('input[type=number]')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
+      const input = deep().find(i => !i.disabled && /\.size\.|\.dimension\./.test(i.getAttribute('aria-label') ?? ''))
+      if (!input) return null
+      input.scrollIntoView({ block: 'center' })
+      const r = input.getBoundingClientRect()
+      return { x: r.left + r.width / 2, y: r.top + r.height / 2, label: input.getAttribute('aria-label'), value: Number(input.value) }
+    })
+    assert.ok(field, 'a size field of the part')
+    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())
+    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))
+  })
+})
+
+describe('the edit canvas and the preview stay standing', () => {
+  before(() => mount('box'))
+
+  test('the preview is made when first asked for; going back, the edit canvas is the one that was there', async () => {
+    assert.equal((await read(() => probe.middles())).preview, null, 'no preview before it is asked for')
+    await read(() => probe.markMiddles())
+    await mode('preview')
+    let m = await read(() => probe.middles())
+    assert.ok(m.preview?.scene && !m.preview.hidden, 'the preview stands in front')
+    assert.ok(m.editHidden, 'the edit area is out of sight, not taken down')
+    assert.ok(m.editSize && m.editSize[0] > 0 && m.editSize[1] > 0, 'and not resized to nothing')
+    assert.equal(await read(() => probe.editPicture()), false, 'out of sight it takes no picture, as when there was no canvas')
+    await read(() => probe.markMiddles())
+    await mode('edit')
+    m = await read(() => probe.middles())
+    assert.ok(m.canvas && m.canvasScene, 'the same edit canvas, the same scene')
+    assert.ok(m.preview?.marked && m.preview.hidden, 'the preview stays, out of sight')
+  })
+
+  test('shown again unchanged, the preview is the one that stood, and nothing is worked out', async () => {
+    const before = await work()
+    await mode('preview')
+    const m = await read(() => probe.middles())
+    assert.ok(m.preview?.marked && m.preview.sceneMarked, 'the same preview and scene')
+    assert.deepEqual(since(before, await work()), { compiles: 0, evaluations: 0 })
+  })
+
+  test('a value changed beside the preview is drawn inside the scene that stands', async () => {
+    await click(await read(() => probe.row('box')))
+    await sleep(300)
+    const field = await read(() => probe.labelled('box.size.y'))
+    assert.ok(field, 'the height field')
+    await page().mouse.click(field.x, field.y, { clickCount: 3 })
+    await page().keyboard.type('600')
+    await page().keyboard.press('Enter')
+    await sleep(1500)
+    const m = await read(() => probe.middles())
+    assert.ok(m.preview?.sceneMarked, 'the same 3D scene')
+    assert.equal(await read(() => probe.value('box.size.y')), 600)
+  })
+})
+
+test('the page raised no error', () => {
+  assert.deepEqual(opened.errors, [])
+})

package/test/command-preview.test.ts

@@ -12,6 +12,7 @@ import { addFigureBox, applyFigureAuthoring, createFigureAsset, figurePartFaceOf
 import { createFigureProductSession } from '../client/modeller/product-session.js'
 import { faceHighlightOf, ghostPartsOf, previewWordsOf, type HeldPreview } from '../client/modeller/command-preview.js'
 import { boxShape } from '../client/modeller/drawn-shapes.ts'
+import { revisionOf } from './revision-of.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 const ko = JSON.parse(read('../translations/ko.json'))
@@ -118,7 +119,7 @@ test('detaching says what it would do: stays, what stays fastened to it, the cli
   assert.equal(seen.moves.length, 0, 'the lamp stays where it stands')
   assert.equal(s.read().revision, 0)
   const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes("const own = seen.moves.some(m => m.body === this.selected)"))
+  assert.ok(editor.includes("const own = seen.moves.some(m => m.body === part)"))
   /* Staying where it is is as expected: nothing is said then (user 2026-10-01); a move, a child kept, a clip lost are. */
   assert.ok(editor.includes(': /* It stays where it is: as expected, so nothing is said (user 2026-10-01). */ []'), 'nothing said when it stays')
   const links = read('../client/modeller/figure-links.ts')
@@ -161,8 +162,8 @@ test('a row is seen before it is made, read as figure-model draws it -- and said
   assert.ok(links.includes("<section row><details row-fold>") && links.includes("<details row-fold ?open=${this.working === 'row'}>"))
   assert.ok(links.includes("this.candidate = this.working === 'row' && this.rowCandidate ? { action: this.rowCandidate } : this.fastenCandidate"), 'the form being worked on is the one seen')
   const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes("const row = candidate.action.kind === 'make-repeat' ? figureRowOf(seen.asset, this.selected, this.currentInputs()) : undefined"))
-  assert.ok(editor.includes('<ul row-reading>${rowWordsOf(this.rowNow(asset)'), 'a row made says the same, as it stands')
+  assert.ok(editor.includes("const row = candidate.action.kind === 'make-repeat' ? figureRowOf(seen.asset, this.selected, this.shown()!.inputs) : undefined"))
+  assert.ok(editor.includes('<ul row-reading>${rowWordsOf(this.rowNow(shown)'), 'a row made says the same, as it stands')
   for (const lang of ['en', 'ja', 'ko', 'ms', 'zh']) {
     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'])
@@ -210,15 +211,15 @@ test('a motion is named by its parts, and drawn at both ends of its range -- onl
   a = applyFigureAuthoring(a, { kind: 'attach', part: 'leaf', face: 'bottom', to: { part: 'frame', face: 'top' } })
   a = applyFigureAuthoring(a, { kind: 'attach', part: 'gate', face: 'bottom', to: { part: 'frame', face: 'top' } })
   const j = (part: string) => a.joints!.find(k => k.body1.part === part)!
-  assert.equal(motionEndsOf(a, 'leaf'), null, 'not moving: nothing drawn')
+  assert.equal(motionEndsOf(revisionOf(a), 'leaf'), null, 'not moving: nothing drawn')
   a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j('leaf'), type: 'revolute', axis: 'Y', lowerLimit: 0, upperLimit: 90, state: { id: 'open' } } })
   a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j('gate'), type: 'prismatic', axis: 'X', lowerLimit: 0, upperLimit: 300, state: { id: 'slide' } } })
-  /* With the values the screen holds -- design and control alike -- as the editor passes them. */
-  const held = { ...a.designInputs, ...a.stateDefaults, 'frame.size.x': 2400 }
-  const turn = motionEndsOf(a, 'leaf', held)!
+  /* At the version the screen holds, a design value typed since it was opened. */
+  const held = revisionOf(a, { 'frame.size.x': 2400 })
+  const turn = motionEndsOf(held, 'leaf')!
   assert.deepEqual([turn.control, turn.min, turn.max], ['open', 0, 90])
   assert.deepEqual(turn.ghost.map(g => g.id).sort(), ['__preview:max:leaf', '__preview:min:leaf'], 'the leaf at 0 and at 90, nothing else')
-  const slide = motionEndsOf(a, 'gate', held)!
+  const slide = motionEndsOf(held, 'gate')!
   const line = slide.ghost.find(g => g.id === '__target-face:slide')!
   assert.equal(Math.round((line.shape as unknown as { extrusion: { section: { size: { x: number } } } }).extrusion.section.size.x), 300, 'the line it travels, its whole stroke')
   const editor = read('../client/modeller/editor.ts')

package/test/fasten-drawing.test.ts

@@ -21,7 +21,7 @@ test('부품의 면·맞닿기 고르기 칸이 없고, 그 자리에 그림이
   assert.ok(!form.includes("i18next.t('figure.label.facing')"), 'no facing list')
   has(form, /<figure-fasten-drawing[\s\S]*?\.modes=\$\{f\.toPlane \? \(\['meet'\] as FastenMode\[\]\)/, 'the plane is set on only')
   has(form, /turnsInPlace\(asset, this\.partId\) \? \(\['centre'\] as FastenMode\[\]\) : \[\]/, 'centre on it only for a part that turns')
-  has(form, /const derived = f\.toPlane \|\| f\.target \? myFaceFor\(asset, this\.partId, aim, mode\) : undefined/, 'the part\'s face follows the target and how')
+  has(form, /const derived = f\.toPlane \|\| f\.target \? myFaceFor\(this\.revision!, this\.partId, aim, mode\) : undefined/, 'the part\'s face follows the target and how')
 })
 
 test('상대 목록에 배치 기준의 면이 이름으로 있다: 바닥 · 천장 · 벽 · 중심', () => {

package/test/fasten-geometry.test.ts

@@ -12,6 +12,7 @@ import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAss
 import type { FigureAsset, FigureAuthoringAction } from '@hatiolab/figure-model'
 
 import { alignmentAt, faceViewOf, myFaceFor, offsetOf, overhangOf, screenOf } from '../client/modeller/fasten-geometry.ts'
+import { revisionOf } from './revision-of.ts'
 
 const scene = (lidRotation?: { x: number; y: number; z: number }): FigureAsset => {
   let a = addFigureBox(createFigureAsset('Box'), { id: 'bin', size: { x: 600, y: 300, z: 400 }, position: { x: 0, y: 150, z: 0 } })
@@ -22,24 +23,24 @@ const at = (a: FigureAsset, id: string) => (compileFigureAsset(a).evaluate().geo
 
 test('부품의 면은 상대 면과 방식으로 정해진다: 올려놓기는 마주 보는 면, 같은 면은 같은 면, 가운데는 가운데', () => {
   const a = scene()
-  assert.equal(myFaceFor(a, 'lid', { part: 'bin', face: 'top' }, 'meet'), 'bottom')
-  assert.equal(myFaceFor(a, 'lid', { part: 'bin', face: 'top' }, 'flush'), 'top')
-  assert.equal(myFaceFor(a, 'lid', { part: 'bin', face: 'front' }, 'meet'), 'back')
-  assert.equal(myFaceFor(a, 'lid', { part: 'bin', face: 'top' }, 'centre'), 'centre')
-  assert.equal(myFaceFor(a, 'lid', 'plane', 'meet'), 'bottom', 'on a floor: the face looking down')
-  assert.equal(myFaceFor(a, 'lid', 'plane', 'centre'), undefined, 'the plane takes a face, never a centre')
+  assert.equal(myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'top' }, 'meet'), 'bottom')
+  assert.equal(myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'top' }, 'flush'), 'top')
+  assert.equal(myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'front' }, 'meet'), 'back')
+  assert.equal(myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'top' }, 'centre'), 'centre')
+  assert.equal(myFaceFor(revisionOf(a), 'lid', 'plane', 'meet'), 'bottom', 'on a floor: the face looking down')
+  assert.equal(myFaceFor(revisionOf(a), 'lid', 'plane', 'centre'), undefined, 'the plane takes a face, never a centre')
 })
 
 test('돌려 놓인 부품이면 지금 아래를 보는 면이다 — 이름이 아니라 방향으로', () => {
   const a = scene({ x: 90, y: 0, z: 0 })
-  const face = myFaceFor(a, 'lid', { part: 'bin', face: 'top' }, 'meet')!
+  const face = myFaceFor(revisionOf(a), 'lid', { part: 'bin', face: 'top' }, 'meet')!
   assert.notEqual(face, 'bottom', 'turned a quarter about X, its bottom no longer looks down')
   const n = figurePartFaceOf(a, 'lid', face)!.normal
   assert.ok(Math.abs(n[1]! + 1) < 1e-6, `${face} looks down: ${n}`)
 })
 
 test('면 그림: 상대 면의 크기와 부품 발자국, 가장자리 맞춤이 되는 축', () => {
-  const v = faceViewOf(scene(), 'lid', { part: 'bin', face: 'top' })!
+  const v = faceViewOf(revisionOf(scene()), 'lid', { part: 'bin', face: 'top' })!
   assert.deepEqual(v.axes, ['x', 'z'])
   assert.deepEqual([v.face.x, v.face.z], [600, 400])
   assert.deepEqual([v.part.x, v.part.z], [300, 200])
@@ -57,7 +58,7 @@ test('놓은 자리: 가운데, 안쪽 끝(가장자리와 나란히), 바깥
 })
 
 test('면 밖으로 나온 곳과 닿지 않는 것을 말한다', () => {
-  const v = faceViewOf(scene(), 'lid', { part: 'bin', face: 'top' })!
+  const v = faceViewOf(revisionOf(scene()), 'lid', { part: 'bin', face: 'top' })!
   assert.deepEqual(overhangOf(v, { x: 0, y: 0, z: 0 }), { touching: true, sides: [] })
   assert.deepEqual(overhangOf(v, { x: 200, y: 0, z: 0 }), { touching: true, sides: [{ axis: 'x', side: 'high', mm: 50 }] })
   assert.equal(overhangOf(v, { x: 460, y: 0, z: 0 }).touching, false)

package/test/fields.test.ts

@@ -83,7 +83,7 @@ test('편집기는 저작한 부품 단위로 고르고 보인다 — 되풀이
   assert.ok(canvas.includes('.filter(([name]) => ownerOf(name) === this.selected)'), '사용자 2026-09-24: 「why repeatable parts are not selected?」')
   const editor = read('../client/modeller/editor.ts')
   assert.ok(editor.includes('this.selected = id ? ownerOf(id) : id'), '캔버스에서 복사본을 누르면 그 되풀이를 고른다')
-  assert.ok(editor.includes('.parts=${this.partRows(view.geometry, asset as FigureAsset | undefined)}'), '목록은 저작한 부품 한 줄씩')
+  assert.ok(editor.includes('.parts=${this.partRows(view.geometry, asset)}'), '목록은 저작한 부품 한 줄씩')
   assert.ok(editor.includes("this.session!.command({ kind: 'set-repeat', part: this.selected, pitch })"), 'pitch 는 명령으로 정한다')
   const parts = read('../client/modeller/figure-parts.ts')
   assert.ok(parts.includes('?disabled=${this.locked || full}'), '등급 한도에 이르면 팔레트가 잠긴다')

package/test/first-minute.test.ts

@@ -67,7 +67,7 @@ test('narrow, the parts list folds for the canvas, said once, and stays open onc
 
 test('a palette part\'s own sizes are its shape\'s fields, not a rule\'s: no "set by a rule" size row for them', () => {
   const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes("sizeRuled: (['x', 'y', 'z'] as const).every(axis => followOf(parsed, ownerOf(this.selected), axis).of !== 'own')"))
+  assert.ok(editor.includes("sizeRuled: (['x', 'y', 'z'] as const).every(axis => followOf(shown.asset, ownerOf(this.selected), axis).of !== 'own')"))
   assert.ok(editor.includes('if (!held?.sizeRuled ||'))
 })
 

package/test/gizmo.test.ts

@@ -168,7 +168,7 @@ test('크기 칸과 손잡이 — 배치가 지키는 면을 지킨다, 커널
   hung = applyFigureAuthoring(hung, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(hung), placement: 'ceiling' })
   assert.equal(centreY(grow(hung, 'lamp', gizmoReachOf(hung, 'lamp').sizes![1], 300), 'lamp') + 300 / 2, 0, '천장 도형: 윗면이 천장에')
   const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes('figureSizeEditChanges(this.parsedAsset(), part, [change])'), '숫자 칸이 부른다')
+  assert.ok(editor.includes('figureSizeEditChanges(this.shown()!.asset, part, [change])'), '숫자 칸이 부른다')
   assert.ok(editor.includes('figureSizeEditChanges(asset, ownerOf(id), written)'), '손잡이도 부른다')
   assert.ok(!read('../client/modeller/gizmo.ts').includes('keepBottomChanges'), '화면의 제 산수는 없다')
 })

package/test/joint-fan.test.ts

@@ -12,6 +12,8 @@ import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAss
 import type { FigureAsset } from '@hatiolab/figure-model'
 
 import { JOINT_FAN, jointFanOf } from '../client/modeller/joint-fan.ts'
+import { revisionOf } from './revision-of.ts'
+import { liveOverSession } from '../client/modeller/live.ts'
 import { moving } from './joints.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
@@ -43,7 +45,7 @@ const direction = (v: number[]) => {
 
 test('a part that turns gets a fan from the lowest value to the highest, where the part really goes', () => {
   const asset = arm()
-  const fan = jointFanOf(asset, 'arm') as unknown as { id: string; shape: { provider: string; profile: { x: number; y: number }[] }; pose: { t: number[]; r: number[][] } }
+  const fan = jointFanOf(revisionOf(asset), 'arm') as unknown as { id: string; shape: { provider: string; profile: { x: number; y: number }[] }; pose: { t: number[]; r: number[][] } }
   assert.ok(fan)
   assert.equal(fan.id, JOINT_FAN)
   assert.equal(fan.shape.provider, 'extrude', 'a section pushed thin, drawn as a part is')
@@ -65,32 +67,46 @@ test('a part that turns gets a fan from the lowest value to the highest, where t
 })
 
 test('a fan is as large as what turns, and never smaller than 60 mm', () => {
-  const big = jointFanOf(arm(), 'arm') as unknown as { shape: { profile: { x: number; y: number }[] } }
+  const big = jointFanOf(revisionOf(arm()), 'arm') as unknown as { shape: { profile: { x: number; y: number }[] } }
   const radius = Math.max(...profileOf(big).map(p => Math.hypot(p.x, p.y)))
   assert.ok(Math.abs(radius - 240) < 1e-3, `0.6 × 400 — ${radius}`)
 })
 
 test('no fan for a part that does not turn, nor for a slide -- a fan in a guessed plane would point the wrong way', () => {
   /* The base does not turn; it shows the joint that sits on it, the arm's -- one joint, one fan (the elbow rule). */
-  const onBase = jointFanOf(arm(), 'base') as unknown as { shape: { profile: unknown[] } }
-  const ofArm = jointFanOf(arm(), 'arm') as unknown as { shape: { profile: unknown[] } }
+  const onBase = jointFanOf(revisionOf(arm()), 'base') as unknown as { shape: { profile: unknown[] } }
+  const ofArm = jointFanOf(revisionOf(arm()), 'arm') as unknown as { shape: { profile: unknown[] } }
   assert.deepEqual(profileOf(onBase), profileOf(ofArm))
-  assert.equal(jointFanOf(arm(), ''), null)
+  assert.equal(jointFanOf(revisionOf(arm()), ''), null)
   let slider = createFigureAsset('Probe')
   slider = addFigureBox(slider, { id: 'block', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
   slider = moving(slider, 'block', { kind: 'slide', axis: 'x', id: 'shift', min: 0, max: 60 })
-  assert.equal(jointFanOf(slider, 'block'), null)
+  assert.equal(jointFanOf(revisionOf(slider), 'block'), null)
 })
 
-test('the editor draws it for the selected part, with the pose in hand; the canvas never lets it be picked', () => {
+test('the editor draws it for the selected part; the canvas never lets it be picked', () => {
   const editor = read('../client/modeller/editor.ts')
-  assert.ok(editor.includes('.fan=${this.fanOf(asset as FigureAsset | undefined)}'))
-  assert.ok(editor.includes('return jointFanOf(asset, this.selected, { ...this.currentInputs(), ...this.live.values })'), 'the fan reads the pose the session holds')
+  assert.ok(editor.includes('.fan=${this.fanOf(shown, live)}'))
   const canvas = read('../client/modeller/canvas.ts')
   /* The fan, and what a command would do, are shown and never picked (ADR-0097 §5.5). */
   assert.ok(canvas.includes('.map(c => ({ ...c, capturable: false, locked: true }))'))
 })
 
+/*
+ * The fan stands where the joint is drawn: the pose set with the controls (the version's inputs), and while a control is
+ * dragged, the pose in hand -- the same as a version where that pose was set (user 2026-09-24: the arm jumped on release).
+ */
+test('the fan follows the pose as drawn: set with the controls, or in hand while a control is dragged', () => {
+  const at = (fan: unknown) => (fan as { pose: { t: number[] } }).pose.t.map(v => Math.round(v * 1000) / 1000)
+  const rest = jointFanOf(revisionOf(column()), 'tip')
+  const set = jointFanOf(revisionOf(column(), { hinge: 40 }), 'tip')
+  assert.notDeepEqual(at(set), at(rest), 'the wrist moves with the hinge')
+  const shown = revisionOf(column())
+  const live = { values: { hinge: 40 } }
+  const inHand = jointFanOf(shown, 'tip', { ...live, geometry: liveOverSession(shown, live)! })
+  assert.deepEqual(at(inHand), at(set))
+})
+
 /* ── Joints on a chain (user 2026-09-24: 「로봇암 axis와 관절의 각도 표현을 다시 검증해보라」) ───────── */
 
 /**
@@ -122,7 +138,7 @@ for (const [part, joint] of [
 ] as const) {
   test(`${part} on ${joint}: the axis holds the part's plane, the fan's ends are where it goes, the fan opens as far as it turns`, () => {
     const asset = column()
-    const fan = jointFanOf(asset, part) as unknown as { pose: { t: number[]; r: number[][] }; shape: { profile: { x: number; y: number }[] } }
+    const fan = jointFanOf(revisionOf(asset), part) as unknown as { pose: { t: number[]; r: number[][] }; shape: { profile: { x: number; y: number }[] } }
     assert.ok(fan, 'a fan -- the first joint of a chain included')
     const input = asset.document.model.inputs.find(i => i.id === joint)!
     const pivot = fan.pose.t
@@ -152,7 +168,7 @@ for (const [part, joint] of [
 
 test('a housing shows the joint it houses, not the one that carries it; a part that holds no pivot shows none', () => {
   const asset = column()
-  const turns = (part: string) => (jointFanOf(asset, part) as unknown as { turns?: string } | null)?.turns ?? null
+  const turns = (part: string) => (jointFanOf(revisionOf(asset), part) as unknown as { turns?: string } | null)?.turns ?? null
   assert.equal(turns('housing'), 'wrist', 'user 2026-09-24: 「elbow-housing itself is a axis」 -- it rides the hinge, it houses the wrist')
   assert.equal(turns('link'), 'hinge', 'a link with pivots only at its ends shows the joint that turns it')
   assert.equal(turns('tip'), 'wrist')
@@ -160,7 +176,7 @@ test('a housing shows the joint it houses, not the one that carries it; a part t
   assert.equal(turns('base'), null)
 
   /* The housing's fan is the wrist's: its ends are where the tip goes. */
-  const fan = jointFanOf(asset, 'housing') as unknown as { pose: { t: number[]; r: number[][] }; shape: { profile: { x: number; y: number }[] } }
+  const fan = jointFanOf(revisionOf(asset), 'housing') as unknown as { pose: { t: number[]; r: number[][] }; shape: { profile: { x: number; y: number }[] } }
   const axis = [0, 1, 2].map(i => fan.pose.r[i]![1]!)
   const flat = (v: number[]) => sub(v, axis.map(a => a * dot(v, axis)))
   const onFan = (p: { x: number; y: number }) => [0, 1, 2].map(i => fan.pose.t[i]! + fan.pose.r[i]![0]! * p.x + fan.pose.r[i]![2]! * p.y)
@@ -173,7 +189,7 @@ test('a housing shows the joint it houses, not the one that carries it; a part t
 test('one joint, one fan: the housing and the part it turns show the same fan, sized from what turns', () => {
   const asset = column()
   const size = (part: string) => {
-    const fan = jointFanOf(asset, part) as unknown as { shape: { profile: { x: number; y: number }[] }; pose: { t: number[] } }
+    const fan = jointFanOf(revisionOf(asset), part) as unknown as { shape: { profile: { x: number; y: number }[] }; pose: { t: number[] } }
     return { radius: Math.max(...profileOf(fan).map(p => Math.hypot(p.x, p.y))), pivot: fan.pose.t }
   }
   const housing = size('housing'),
@@ -186,7 +202,7 @@ test('an axis running through a part does not make it that joint’s: a roll alo
   /* ROBOT_ARM's forearm showed the wrist roll, whose axis runs its length (2026-09-24 audit). */
   /* A link on a hinge and a roller on a twist whose axis runs along the link. */
   const asset = fixture('joint-roller')
-  const turns = (part: string) => (jointFanOf(asset, part) as unknown as { turns?: string } | null)?.turns ?? null
+  const turns = (part: string) => (jointFanOf(revisionOf(asset), part) as unknown as { turns?: string } | null)?.turns ?? null
   assert.equal(turns('link'), 'hinge', 'the twist axis runs through the link, and the link does not twist')
   assert.equal(turns('roller'), 'twist')
   assert.equal(turns('base'), null)